fwi 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 87be340eab8e5bf9eb089e92cff12a5334be00e7
+  data.tar.gz: 688dc30f47412cabbd679f6d8a2571e9a71980b8
+SHA512:
+  metadata.gz: 7df2c8cdffdee78b64599afbddf8d04efad76f37ed20f0b32de2051988de2ccaa6015d46aa65dcaf1ab75e95389e7d5fa074da9236145f75940ca69263ef6481
+  data.tar.gz: 3593cba598bc3cf4a2b552cca783a58f02ad8aa3dcb7c0a0deba5d9327b19160a5e2b9d2ffea3ed5ee00c51bc279dbdf0aa7ba989697f51fc8cc24315bf271ee

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in waitress-core.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jaci R Brunning
+
+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.

data/bin/fwi

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'fwi/compiler.rb'

data/fwi.gemspec

@@ -0,0 +1,17 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "fwi"
+  spec.version       = "1.0.0"
+  spec.authors       = ["Jaci Brunning"]
+  spec.email         = ["jaci.brunning@gmail.com"]
+
+  spec.summary       = %q{Fixed-Width Data Interchange Compiler}
+  spec.homepage      = "http://github.com/JacisNonsense/Fixed-Width-Interchange"
+
+  spec.bindir        = "bin"
+  spec.files = Dir.glob("lib/**/*") + ['fwi.gemspec', 'Gemfile', 'LICENSE']
+  spec.executables   = ["fwi"]
+  spec.require_paths = ["lib"]
+end

data/lib/fwi/compiler.rb

@@ -0,0 +1,64 @@
+require_relative 'cpp/compiler.rb'
+require_relative 'parser.rb'
+require 'optparse'
+
+COMPILERS = {
+    "cpp" => CPPCompiler.new
+};
+
+options = {
+    :source_root => "."
+}
+optp = OptionParser.new do |opts|
+    
+    opts.separator ""
+    opts.separator "Common options:"
+
+    opts.on("-h", "--help", "Show this message") do
+        puts opts
+        exit
+    end
+
+    opts.on("-l", "--language LANGUAGE", COMPILERS.map { |n, v| n }, 
+        "Select the language to compile down to. One of [#{COMPILERS.keys.join(", ")}]") do |lang|
+        options[:language] = lang
+    end
+
+    opts.on("-d", "--source-directory DIRECTORY", "Set the source directory to pull files from") do |directory|
+        options[:source_root] = directory
+    end
+
+    COMPILERS.each do |n,x|
+        opts.separator ""
+        opts.separator n 
+        x.populate_options opts 
+    end
+
+   
+end
+
+begin
+  optp.parse!
+  mandatory = [:language]                                
+  missing = mandatory.select{ |param| options[param].nil? }
+  unless missing.empty?
+    raise OptionParser::MissingArgument.new(missing.join(', '))
+  end
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+  puts $!.to_s 
+  puts optp
+  exit
+end   
+
+source_files = ARGV
+COMPILERS.each { |n,x| x.after_parse }
+selected_compiler = COMPILERS[options[:language]]
+
+p = FWI::Parser.new
+
+selected_compiler.on_selected
+source_files.each do |file|
+    lex = p.lex(file, options[:source_root])
+    bitmap = p.bitmap(lex)
+    selected_compiler.compile file, lex, bitmap, options
+end

data/lib/fwi/cpp/compiler.rb

@@ -0,0 +1,52 @@
+require_relative 'gen.rb'
+require 'fileutils'
+
+class CPPCompiler
+    GEN = FWI::Generator::CPP.new
+
+    def populate_options o
+        @options = {
+            :hpp => ".", :cpp => ".",
+            :hpp_ext => ".hpp", :cpp_ext => ".cpp",
+            :hpp_only => false
+        };
+        o.on("--headers [DIRECTORY]", "Directory to put Generated C++ Header Files.") { |x| @options[:hpp] = x }
+        o.on("--sources [DIRECTORY]", "Directory to put Generated C++ Source Files.") { |x| @options[:cpp] = x }
+        o.separator ""
+        o.on("--header_ext [EXTENSION]", "Extension for Generated C++ Header Files. Default .hpp") { |x| @options[:hpp_ext] = x }
+        o.on("--source_ext [EXTENSION]", "Extension for Generated C++ Source Files. Default .cpp") { |x| @options[:cpp_ext] = x }
+        o.separator ""
+        o.on("--header-only", "Compile as header-only") { |x| @options[:hpp_only] = true }
+    end
+
+    def after_parse
+    end
+
+    def on_selected; end
+
+    def compile file, lex, bitmap, options
+        base = File.basename(file, File.extname(file))
+
+        hpp_ext = @options[:hpp_ext]
+        cpp_ext = @options[:cpp_ext]
+
+        compile_cpp = !@options[:hpp_only]
+
+        hpp = GEN.gen_hpp bitmap, hpp_ext, @options[:hpp_only]
+        hpp.each do |fn, contents|
+            f = File.join(@options[:hpp], fn)
+            FileUtils.mkdir_p File.expand_path("..", f)
+            File.write(f, contents)
+        end
+
+        if compile_cpp
+            cpp = GEN.gen_cpp bitmap, cpp_ext, hpp_ext
+            cpp.each do |fn, contents|
+                f = File.join(@options[:cpp], fn)
+                FileUtils.mkdir_p File.expand_path("..", f)
+                File.write(f, contents)
+            end
+        end
+    end
+
+end

data/lib/fwi/cpp/gen.rb

@@ -0,0 +1,329 @@
+module FWI
+module Generator
+    class CPP
+        TYPE_MAP = {
+            :float64 => "double",
+            :float32 => "float",
+            :u64 => "uint64_t",
+            :u32 => "uint32_t",
+            :u16 => "uint16_t",
+            :u8 => "uint8_t",
+            :i64 => "int64_t",
+            :i32 => "int32_t",
+            :i16 => "int16_t",
+            :i8 => "int8_t",
+            :string => "char *",
+            :bool => "bool"
+        };
+
+        def append buffer, indent, string
+            string.split(/\n/).each { |y| buffer << ("\t" * indent) + y + "\n" }
+        end
+
+        def _write_fwd_child name, child, indent, buffer
+            if child[:type] == :namespace
+                _write_fwd name, child, indent, buffer
+            elsif child[:type] == :block
+                append(buffer, indent, "struct #{name};")
+            elsif child[:type] == :enum
+                type = child[:reltype]
+                append(buffer, indent, "enum class #{name} {")
+                indent += 1
+                append(buffer, indent, child[:members].map { |n| "#{n[:name]} = #{n[:val]}" }.join(",\n"))
+                indent -= 1
+                append(buffer, indent, "};")
+            end
+        end
+
+        def _write_fwd name, namespace, indent, buffer
+            append(buffer, indent, "namespace #{name} {")
+            indent += 1
+            namespace[:members].each do |name, child|
+                _write_fwd_child name, child, indent, buffer
+            end
+            indent -= 1
+            append(buffer, indent, "}")
+        end
+
+        def write_fwd_declarations str, root, indent
+            root[:members].each do |name, child|
+                _write_fwd_child name, child, indent, str
+            end
+        end
+
+        def _func_util mode, name, member, truncate=true, relative_types=true, fulltype=""
+            type = member[:type]
+            type_sym = relative_types ? :reltype : :element_name
+
+            ctype = TYPE_MAP[type]
+            ctype = member[type_sym] + (member[:element_type] == :block ? " *" : "") if (member[:type] == :reference)
+            ctype = member[:attribute_map]["ctype"] unless member[:attribute_map]["ctype"].nil?
+
+            param = member[:array].nil? ? "" : "int index#{mode == :setter ? ', ' : ''}"
+            custom_getter = member[:attribute_map]["getter"]
+            custom_setter = member[:attribute_map]["setter"]
+            custom_length = member[:attribute_map]["length_func"]
+            prefix = relative_types ? "" : (fulltype + "::")
+            func_name = prefix
+            func_sig = ""
+            if mode == :setter
+                func_name += custom_setter.nil? ? "set_#{name}" : custom_setter
+                func_sig = "void #{func_name}(#{param}#{ctype} value)"
+            elsif mode == :getter
+                func_name += custom_getter.nil? ? "get_#{name}" : custom_getter
+                func_sig = "#{ctype} #{func_name}(#{param})"
+            elsif mode == :length
+                func_name += custom_length.nil? ? "#{name}_length" : custom_length
+                func_sig = "int #{func_name}(#{param})"
+            end
+            func_sig += truncate ? ";" : ' {'
+            index = member[:index]
+            index = "#{index} + (#{member[:typesize]} * index)" unless member[:array].nil?
+            { :ctype => ctype, :prefix => prefix, :func_name => func_name, :func_sig => func_sig, :index => index }
+        end
+
+        def write_getter str, name, member, indent, truncate=true, relative_types=true, fulltype=""
+            return "" if member[:attributes].include? "no-getter"
+            util = _func_util :getter, name, member, truncate, relative_types, fulltype
+
+            append(str, indent, util[:func_sig])
+            unless truncate
+                type = member[:type]
+                ctype = util[:ctype]
+
+                indent += 1
+                if type == :reference
+                    if member[:element_type] == :enum
+                        append(str, indent, "return (#{ctype})(_store[#{util[:index]}]);")
+                    else
+                        if member[:array].nil?
+                            append(str, indent, "return &_#{member[:name]};")
+                        else
+                            append(str, indent, "return &_#{member[:name]}[index];")
+                        end
+                    end
+                elsif type == :string
+                    append(str, indent, "return (_store + #{util[:index]});")
+                elsif type == :bool
+                    if member[:array].nil?
+                        append(str, indent, "return FWI_IS_BIT_SET(_store[#{util[:index]}], #{member[:bit_index]});")
+                    else
+                        append(str, indent, "return FWI_IS_BIT_SET(_store[#{member[:index]} + index / 8], index % 8);")
+                    end
+                else
+                    append(str, indent, "return FWI_MEM_VAL(#{util[:ctype]}, _store, #{util[:index]});")
+                end
+                indent -= 1
+                append(str, indent, "}")
+            end
+            str
+        end
+
+        def write_setter str, name, member, indent, truncate=true, relative_types=true, fulltype=""
+            return "" if member[:attributes].include? "no-setter"
+            util = _func_util :setter, name, member, truncate, relative_types, fulltype
+
+            append(str, indent, util[:func_sig])
+            unless truncate
+                type = member[:type]
+                ctype = util[:ctype]
+
+                indent += 1
+                if type == :reference
+                    append(str, indent, "_store[#{util[:index]}] = (char)value;")
+                elsif type == :bool
+                    if member[:array].nil?
+                        append(str, indent, "FWI_SET_BIT_TO(_store[#{util[:index]}], #{member[:bit_index]}, value ? 1 : 0);")
+                    else
+                        append(str, indent, "FWI_SET_BIT_TO(_store[#{member[:index]} + index / 8], index % 8, value ? 1 : 0);")
+                    end
+                else
+                    append(str, indent, "FWI_MEM_VAL(#{ctype}, _store, #{util[:index]}) = value;")
+                end
+                indent -= 1
+                append(str, indent, "}")
+            end
+            str
+        end
+
+        def write_length str, name, member, indent, truncate=true, relative_types=true, fulltype=""
+            return "" if member[:attributes].include? "no-len"
+            util = _func_util :length, name, member, truncate, relative_types, fulltype
+
+            append(str, indent, util[:func_sig])
+            unless truncate
+                indent += 1
+                append(str, indent, "return #{member[:size]};")
+                indent -= 1
+                append(str, indent, "}")
+            end
+            str
+        end
+
+        def write_ptr_update buffer, b_refs, indent, truncate=true, prefix=""
+            unless b_refs.empty?
+                virt = prefix.empty? ? "virtual " : ""
+                if truncate
+                    append(buffer, indent, "#{virt}void #{prefix}_update_ptr();")
+                else
+                    append(buffer, indent, "#{virt}void #{prefix}_update_ptr() {")
+                    indent += 1
+                    i_def = false
+                    b_refs.each do |ref|
+                        if ref[:array].nil?
+                            append(buffer, indent, "_#{ref[:name]}.map_to(_store + #{ref[:index]});")
+                        else
+                            unless i_def
+                                i_def = true
+                                append(buffer, indent, "int i;")
+                            end
+                            append(buffer, indent, "for (i = 0; i < #{ref[:array]}; i++) {")
+                            indent += 1
+                            append(buffer, indent, "_#{ref[:name]}[i].map_to(_store + #{ref[:index]} + (#{ref[:typesize]} * i));")
+                            indent -= 1
+                            append(buffer, indent, "}")
+                        end
+                    end
+                    indent -= 1
+                    append(buffer, indent, "}")
+                end
+            end
+        end
+
+        def _get_for_file bitmap, file
+            map = { :members => {}, :type => :namespace }
+            bitmap[:members].each do |name, member|
+                if member[:type] == :namespace
+                    ret = _get_for_file member, file
+                    map[:members][name] = ret unless ret[:members].empty?
+                else
+                    map[:members][name] = member if member[:file] == file
+                end
+            end
+            map
+        end
+
+        def gen_hpp_for buffer, indent, filtered, hpp_only
+            namespace, object = filtered[:members].partition { |n,x| x[:type] == :namespace }
+
+            object.select { |n,x| x[:type] == :block }.each do |name, block|
+                append(buffer, indent, "struct #{name} : public FWI::Block {")
+                indent += 1
+                append(buffer, indent, "static const int SIZE = #{block[:size]};")
+                b_refs, mems = block[:members].partition { |x| x[:type] == :reference && x[:element_type] == :block }
+                buffer << "\n"
+
+                trunc = !hpp_only
+
+                b_refs.each do |block_ref|
+                    write_getter buffer, block_ref[:name], block_ref, indent, trunc, true
+                    buffer << "\n"
+                end
+
+                mems.each do |member_ref|
+                    write_getter buffer, member_ref[:name], member_ref, indent, trunc, true
+                    if member_ref[:type] == :string
+                        write_length buffer, member_ref[:name], member_ref, indent, trunc, true
+                    else
+                        write_setter buffer, member_ref[:name], member_ref, indent, trunc, true
+                    end
+                    buffer << "\n"
+                end
+
+                b_refs.each do |block_ref|
+                    if block_ref[:array].nil?
+                        append(buffer, indent, "#{block_ref[:reltype]} _#{block_ref[:name]};")
+                    else
+                        append(buffer, indent, "#{block_ref[:reltype]} _#{block_ref[:name]}[#{block_ref[:array]}];")
+                    end
+                end
+
+                buffer << "\n"
+
+                write_ptr_update buffer, b_refs, indent, trunc
+
+                indent -= 1
+                append(buffer, indent, "}; // struct: #{name}")
+            end
+
+            namespace.each do |name, ns|
+                append(buffer, indent, "namespace #{name} {")
+                gen_hpp_for buffer, indent + 1, ns, hpp_only
+                append(buffer, indent, "} // namespace: #{name}")
+            end
+        end
+
+        def gen_cpp_for buffer, indent, blocks
+            blocks.each do |obj|
+                name = obj[:name]
+                block = obj[:block]
+
+                b_refs, mems = block[:members].partition { |x| x[:type] == :reference && x[:element_type] == :block }
+
+                b_refs.each do |block_ref|
+                    write_getter buffer, block_ref[:name], block_ref, indent, false, false, block[:fulltype]
+                    buffer << "\n"
+                end
+
+                mems.each do |member_ref|
+                    write_getter buffer, member_ref[:name], member_ref, indent, false, false, block[:fulltype]
+                    if member_ref[:type] == :string
+                        write_length buffer, member_ref[:name], member_ref, indent, false, false, block[:fulltype]
+                    else
+                        write_setter buffer, member_ref[:name], member_ref, indent, false, false, block[:fulltype]
+                    end
+                    buffer << "\n"
+                end
+
+                buffer << "\n"
+
+                write_ptr_update(buffer, b_refs, indent, false, (block[:fulltype] + "::"))
+            end
+        end
+
+        def gen_hpp bitmap, hpp_ext, hpp_only
+            map = {}
+            bitmap[:files].each do |name, file|
+                filename = name.sub ".fwi", hpp_ext
+                contents = "#pragma once\n\n#include \"fwi.hpp\"\n"
+                file[:imports].each do |import|
+                    append(contents, 0, "#include \"#{import.sub '.fwi', hpp_ext}\"")
+                end
+                contents << "\n" unless file[:imports].empty?
+
+                filtered_bitmap = _get_for_file(bitmap, name)
+
+                write_fwd_declarations contents, filtered_bitmap, 0
+                contents << "\n"
+                gen_hpp_for contents, 0, filtered_bitmap, hpp_only
+
+                map[filename] = contents
+            end
+            map
+        end
+
+        def gen_cpp bitmap, cpp_ext, hpp_ext
+            map = {}
+            bitmap[:files].each do |name, file|
+                filename = name.sub ".fwi", cpp_ext
+                contents = "#include \"#{name.sub '.fwi', hpp_ext}\"\n\n"
+
+                blocks = file[:blocks].map do |b|
+                    ref = bitmap
+                    name = ""
+                    b.split("::").each do |c|
+                        ref = ref[:members][c]
+                        name = c
+                    end
+                    { :name => name, :block => ref }
+                end
+
+                gen_cpp_for contents, 0, blocks
+
+                map[filename] = contents
+            end
+            map
+        end
+    end
+end
+end

data/lib/fwi/parser.rb

@@ -0,0 +1,323 @@
+class ::Hash
+    def deep_merge(second)
+        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
+        self.merge(second.to_h, &merger)
+    end
+end
+
+module FWI
+    class Parser
+        TYPE_MAP = {
+            "float64"   => :float64,
+            "float32"   => :float32,
+            "u64"       => :u64,
+            "u32"       => :u32,
+            "u16"       => :u16,
+            "u8"        => :u8,
+            "i64"       => :i64,
+            "i32"       => :i32,
+            "i16"       => :i16,
+            "i8"        => :i8,
+            "string"    => :string,
+            "bool"      => :bool,
+
+            "blank"     => :blank,
+
+            "float"     => :float32,
+            "double"    => :float64,
+            "ulong"     => :u64,
+            "long"      => :i64,
+            "uint"      => :u32,
+            "int"       => :i32,
+            "ushort"    => :u16,
+            "short"     => :i16,
+            "char"      => :i8,
+            "uchar"     => :u8,
+            "byte"      => :i8,
+            "ubyte"     => :u8,
+            "boolean"   => :bool,
+            "bit"       => :bool
+        };
+
+        TYPE_SIZES = {
+            :float64 => 8,
+            :u64 => 8,
+            :i64 => 8,
+
+            :float32 => 4,
+            :u32 => 4,
+            :i32 => 4,
+
+            :u16 => 2,
+            :i16 => 2,
+
+            :u8 => 1,
+            :i8 => 1
+        };
+        
+        # Do the initial parsing on the file
+        def lex src_file, src_dir
+            src = File.read(File.join(src_dir, src_file))
+            hash = { 
+                :members => {}, 
+                :files => { 
+                    src_file => { 
+                        :imports => [],
+                        :enums => [],
+                        :blocks => []
+                    } 
+                }, 
+                :block_order => [] 
+            }
+            file = hash[:files][src_file]
+
+            _blevel = []
+            hashobj = lambda do
+                hr = hash
+                _blevel.select { |n| n[:type] == :namespace }.each do |ns|
+                    hr = hr[:members][ns[:name]]
+                end
+                hr
+            end
+
+            namespacedive = lambda do |fqn|
+                hr = hash
+                comp = fqn.split("::")
+                _blevel.select { |x| x[:type] == :namespace }.each do |b|
+                    return nil if hr.nil?
+                    hr = hr[:members][b[:name]]
+                end
+                comp.each do |c|
+                    return nil if hr.nil?
+                    hr = hr[:members][c]
+                end
+                hr
+            end
+
+            rootdive = lambda do |fqn|
+                hr = hash
+                comp = fqn.split("::")
+                comp.each do |a|
+                    return nil if hr.nil?
+                    hr = hr[:members][a]
+                end
+                hr
+            end
+
+            current_fqn = lambda do
+                _blevel.select { |n| n[:type] == :namespace }.map { |n| n[:name] }.join("::")
+            end
+
+            findtype = lambda do |tn|
+                return tn unless rootdive[tn].nil?
+                unless namespacedive[tn].nil?
+                    return [current_fqn[], tn].join("::")
+                end
+                usings = _blevel.each_index.map { |x| Hash[x, _blevel[x]] if _blevel[x][:type] == :using }.reject(&:nil?)
+                usings.size.times do |time|
+                    afqn = [usings.first(time + 1).map { |x| x.values[0][:name] }, tn].join("::")
+                    return afqn unless rootdive[afqn].nil?
+                    return [current_fqn[], afqn].join("::") unless namespacedive[afqn].nil?
+                end
+                nil
+            end
+
+            _enumidx = 0
+
+            src.each_line.map(&:strip).reject { |l| l.start_with?("//") || l.start_with?("#") }.each do |line|
+                tok = line.split(/\s+/).reject(&:empty?)
+                unless _blevel.empty? || tok[0] == "}"
+                    cur = _blevel.last
+                    b_name = cur[:name]
+                    b_type = cur[:type]
+                    h = hashobj[][:members][b_name]
+
+                    if b_type == :block
+                        type, vals = line.split(/\s+/, 2)
+
+                        next if vals.nil?
+                        vals.split(/\s*,\s*/).each do |splitcomma|
+                            name, *attrib = splitcomma.split(/\s+/).reject(&:empty?)
+                            array_match = /(.+)\[([0-9]+)\]/.match(name)
+                            arrlen = 1
+
+                            unless array_match.nil?
+                                name = array_match[1]
+                                arrlen = array_match[2].to_i
+                            end
+
+                            type_s = TYPE_MAP[type]
+                            m = { :type => type_s, :name => name, :original_type => type }
+                            m[:attributes] = attrib
+                            m[:attribute_map] = Hash[attrib.select { |x| x.is_a?(String) && x.include?("=") }.map { |x| x.split(/\s*=\s*/, 2) }]
+
+                            if m[:type].nil?
+                                fqn = findtype[type]
+                                throw "Can't find type: #{type}" if fqn.nil?
+                                m[:type] = :reference
+                                m[:element_name] = fqn
+                                m[:element_type] = rootdive[fqn][:type]
+
+                                spl = fqn.split("::")
+                                spl_cu = current_fqn[].split("::")
+
+                                min = spl - spl_cu
+                                if min.empty?
+                                    m[:reltype] = fqn
+                                else
+                                    m[:reltype] = min.join("::")
+                                end
+                            end
+
+                            unless arrlen == 1
+                                m[:array] = arrlen
+                            end
+                            h[:members] << m
+                        end
+                    elsif b_type == :enum
+                        line.split(",").each do |ln|
+                            a, b, c = ln.split(/\s+/).reject(&:empty?)
+
+                            if !b.nil? && b == "="
+                                _enumidx = c.to_i
+                            end
+                            h[:members] << { :name => a, :val => _enumidx}
+                            _enumidx = _enumidx + 1
+                        end
+                    end
+                end
+                
+                if tok[0] == "}"
+                    _blevel.pop
+                elsif tok[0] == "namespace"
+                    if tok[2] == "{"
+                        hashobj[][:members][tok[1]] = { :type => :namespace, :members => {} }
+                        _blevel << { :type => :namespace, :name => tok[1] }
+                    else
+                        tok[1].split("::").each do |ns|
+                            hashobj[][:members][ns] = { :type => :namespace, :members => {} }
+                            _blevel << { :type => :namespace, :name => ns }
+                        end
+                    end
+                elsif tok[0] == "block"
+                    cur = current_fqn[]
+                    fulltype = tok[1]
+                    fulltype = cur + "::" + tok[1] unless cur.empty?
+
+                    hashobj[][:members][tok[1]] = { 
+                        :type => :block, 
+                        :members => [], 
+                        :file => src_file,
+                        :fulltype => fulltype
+                    }
+
+                    # Block Order is used by the bitmap generator to decide what order to process block sizes
+                    # and references in. This means that declaration order matters
+                    hash[:block_order] << fulltype
+                    file[:blocks] << fulltype
+
+                    _blevel << { :type => :block, :name => tok[1] }
+                elsif tok[0] == "enum"
+                    cur = current_fqn[]
+                    fulltype = tok[1]
+                    fulltype = cur + "::" + tok[1] unless cur.empty?
+
+                    hashobj[][:members][tok[1]] = { 
+                        :type => :enum, 
+                        :members => [], 
+                        :file => src_file,
+                        :fulltype => fulltype
+                    }
+                    _enumidx = 0
+                    _blevel << { :type => :enum, :name => tok[1] }
+
+                    file[:enums] << fulltype
+                elsif tok[0] == "using" && tok[1] == "namespace"
+                    if tok[3] == "{"
+                        _blevel << { :type => :using, :name => tok[2] }
+                    else
+                        tok[2].split("::").each do |ns|
+                            _blevel << { :type => :using, :name => ns }
+                        end
+                    end
+                elsif tok[0] == "import"
+                    file[:imports] << tok[1]
+                    hash = hash.deep_merge(lex(tok[1], src_dir))
+                end
+            end
+            hash
+        end
+
+        def bitmap lex
+            lex[:block_order].each do |block_name|
+                block = lex
+                block_name.split("::").each { |x| block = block[:members][x] }
+                
+                bools, nonbools = block[:members].partition { |el| el[:type] == :bool && el[:array].nil? }
+                idx = 0
+
+                bools.each_slice(8) do |byte|
+                    byte.each_with_index do |bitvalue, i|
+                        bitvalue[:bit_index] = i
+                        bitvalue[:index] = idx
+                    end
+                    idx += 1
+                end
+
+                nonbools.each do |member|
+                    t = member[:type]
+                    n = member[:name]
+
+                    arraysize = 1
+                    arraysize = member[:array] unless member[:array].nil?
+
+                    if t == :bool
+                        # It must be a boolean array.
+                        total_size = (arraysize / 8.to_f).ceil
+                        member[:index] = idx
+                        member[:size] = total_size
+                        idx += total_size
+                    elsif t == :blank
+                        idx += arraysize
+                    elsif t == :string
+                        typesize = member[:attributes][0].to_i
+                        len = typesize * arraysize
+                        member[:index] = idx
+                        member[:size] = len
+                        member[:typesize] = typesize
+                        idx += len
+                    elsif t == :reference
+                        if member[:element_type] == :block
+                            referenced = lex
+                            member[:element_name].split("::").each { |a| referenced = referenced[:members][a] }
+                            
+                            size = referenced[:size] * arraysize
+                            member[:size] = size
+                            member[:index] = idx
+                            member[:typesize] = referenced[:size]
+                            idx += size
+                        elsif member[:element_type] == :enum
+                            member[:size] = arraysize
+                            member[:typesize] = 1
+                            member[:index] = idx
+                            idx += arraysize
+                        end
+                    else
+                        size = TYPE_SIZES[t] * arraysize
+                        member[:size] = size
+                        member[:index] = idx
+                        member[:typesize] = TYPE_SIZES[t]
+                        idx += TYPE_SIZES[t] 
+                    end
+                end
+                
+                # Remove :blank types
+                block[:members].each_index.select { |i| block[:members][i][:type] == :blank }.each { |x| block[:members].delete_at(x) }
+                
+                # Final Size
+                block[:size] = idx
+            end
+            lex
+        end
+    end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: fwi
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jaci Brunning
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-01 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- jaci.brunning@gmail.com
+executables:
+- fwi
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- bin/fwi
+- fwi.gemspec
+- lib/fwi/compiler.rb
+- lib/fwi/cpp/compiler.rb
+- lib/fwi/cpp/gen.rb
+- lib/fwi/parser.rb
+homepage: http://github.com/JacisNonsense/Fixed-Width-Interchange
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Fixed-Width Data Interchange Compiler
+test_files: []