oryx 0.0.1 → 0.1.0

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+script: bundle exec rake

data/README.md

@@ -1,6 +1,14 @@
 # Oryx
+C-Flat to x86 compiler.
 
-TODO: Write a gem description
+## Progress
+
+- 20 Feb 13
+    + Oryx 0.1.0
+    + Lexer complete
+
+## C-Flat
+C-Flat is a working subset of C designed for use in compilers courses. C-flat includes expressions, basic control flow, recursive functions, and strict type checking. It is object-compatible with ordinary C and thus can take advantage of the standard C library, at least when using limited types.
 
 ## Installation
 
@@ -18,12 +26,24 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+    $ oryx ~/test.cflat
+
+For more details try
+
+    $ oryx -h
+
+or
+
+    $ man oryx
 
 ## Contributing
+As this is a course project pull requests will be ignored.
+
+## Build Status
+[![Build Status](https://travis-ci.org/rampantmonkey/oryx.png?branch=master)](https://travis-ci.org/rampantmonkey/oryx)
+
+Provided by [Travis-CI](http://travis-ci.org)
+
+## License
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+MIT

data/Rakefile

@@ -1,5 +1,7 @@
 require "bundler/gem_tasks"
 require 'rake/testtask'
+require 'binman/rakefile'
+
 Rake::TestTask.new do |t|
   t.libs << 'lib/oryx'
   t.test_files = FileList['test/lib/oryx/*_test.rb']

data/bin/oryx

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'oryx/runner'
+
+runner = Oryx::Runner.new(ARGV)
+runner.run

data/bin/oryx.markdown

@@ -0,0 +1,29 @@
+=begin===
+# ORYX 2013-2-20 0.1.0
+
+## NAME
+
+oryx - cflat tokenizer
+
+## SYNOPSIS
+
+`oryx` [-o output-file] input-file
+
+## DESCRIPTION
+
+[oryx] produces a table of tokens representing the source code contained in `input-file`. If invalid characters/strings are found they are returned as error tokens and lexing continues. Oryx can even handle (in other words not throw an exception) when given random input, as shown by the test suite.
+
+## OPTIONS
+
+`-h`, `--help`
+    Show list of options and usage
+
+`-o`, `--output` [*FILE*]
+    Specify the filename in which to write the token table
+
+
+## SEE ALSO
+
+clang(1), gcc(1)
+
+=end===

data/lib/oryx.rb

@@ -1,4 +1,8 @@
 require "oryx/version"
+require "oryx/preprocessor"
+require "oryx/options"
+require "oryx/runner"
+require "oryx/lexer"
 
 module Oryx
   # Your code goes here...

data/lib/oryx/lexer.rb

@@ -0,0 +1,92 @@
+require 'rltk'
+
+module Oryx
+  class Lexer < RLTK::Lexer
+    # Skip whitespace
+    rule(/\s/)
+
+    # Keywords
+    rule(/boolean/) { :BOOLEAN }
+    rule(/char/)    { :CHAR    }
+    rule(/else/)    { :ELSE    }
+    rule(/false/)   { :FALSE   }
+    rule(/if/)      { :IF      }
+    rule(/int/)     { :INT     }
+    rule(/print/)   { :PRINT   }
+    rule(/return/)  { :RETURN  }
+    rule(/string/)  { :STRING  }
+    rule(/true/)    { :TRUE    }
+    rule(/void/)    { :VOID    }
+    rule(/while/)   { :WHILE   }
+
+    # Operators and delimiters
+    rule(/\(/)      { :LPAREN }
+    rule(/\)/)      { :RPAREN }
+    rule(/\{/)      { :LCURLY }
+    rule(/\}/)      { :RCURLY }
+    rule(/\*/)      { :TIMES  }
+    rule(/\//)      { :DIV    }
+    rule(/\+/)      { :PLUS   }
+    rule(/-/)       { :MINUS  }
+    rule(/</)       { :LE     }
+    rule(/<=/)      { :LEQ    }
+    rule(/>=/)      { :GEQ    }
+    rule(/>/)       { :GE     }
+    rule(/==/)      { :EQ     }
+    rule(/\!=/)     { :NEQ    }
+    rule(/&&/)      { :AND    }
+    rule(/\|\|/)    { :OR     }
+    rule(/=/)       { :ASSIGN }
+    rule(/;/)       { :SEMI   }
+    rule(/,/)       { :COMMA  }
+
+    # Continue Line
+    rule(/\\[\ \t]*\n/) { :CONTNL }
+
+    # Identifier
+    rule(/^[^\d\W]\w*/)      { |t| [:IDENT, t] }
+
+    # Numerics
+    rule(/\d+/)              { |t| [:NUM, t] }
+
+    # Comments
+    rule(/\/\//)             { push_state :cpp_comment }
+    rule(/\n/, :cpp_comment) { pop_state }
+    rule(/./, :cpp_comment)
+    rule(/\/\*/)             { push_state :c_comment; set_flag :c_comment}
+    rule(/\*\//, :c_comment) { pop_state; unset_flag :c_comment }
+    rule(/\*\//)             { :UCOMTER }
+    rule(/\n/, :c_comment)
+    rule(/./, :c_comment)
+
+    # Characters
+    rule(/\'((\\(n|0))|[^\']{1})\'/) { |t| [:CHARCON, t[1...-1]] }
+    rule(/\'\\[^n0]{1}'/)            { |t| [:CHARCON, t[2]] }
+    rule(/\'[^\']*'/)                { |t| [:INVCON, t[1...-1]] }
+
+    # Strings
+    rule(/\"/)                            { push_state :string }
+    rule(/\n/, :string)                   { pop_state; :MSTRTER }
+    rule(/(\\\"|[^\"\n]){,255}/, :string) do |t|
+      push_state :str_overflow if t.length == 255
+      [:STRCON, t[0...255]]
+    end
+    rule(/[^\"]*/, :str_overflow)    { :STRLNG   }
+    rule(/\"/, :str_overflow)        { pop_state }
+    rule(/\"/, :string)              { pop_state }
+
+    # Invalid token starters
+    rule(/[^(\w|\s|\(|\)|\{|\}|\*|\/|\+|-|<|>|=|\!|&|\||;|,)\"|\'|\\]/) { |t| [:INVCHR, t] }
+
+    # Pokémon Rule
+    rule(/./) { |t| [:INVCHR, t]}
+
+    def lex string, file_name = nil
+      tokens = super
+      if env.flags.include? :c_comment
+        tokens.insert -2, RLTK::Token.new(:MCOMTER)
+      end
+      tokens
+    end
+  end
+end

data/lib/oryx/options.rb

@@ -0,0 +1,51 @@
+require 'optparse'
+require 'pathname'
+
+module Oryx
+  class Options
+    DEFAULT_INPUT = ""
+    DEFAULT_OUTPUT = Pathname.new("/tmp/oryx-output")
+
+    def initialize(argv)
+      @config = {output: DEFAULT_OUTPUT,
+                 input:  DEFAULT_INPUT}
+      parse(argv)
+      begin
+        input = Pathname.new(argv.pop).expand_path
+        @config[:input] = input
+      rescue TypeError => e
+        STDERR.puts "No input_file specified.\nUse --help for more information."
+        exit(-1)
+      end
+    end
+
+    def method_missing m, *args, &block
+      if @config.has_key? m
+        @config[m]
+      else
+        super
+      end
+    end
+
+    def parse(argv)
+      OptionParser.new do |opts|
+        opts.banner = "Usage:   oryx [ options ] input_file"
+        opts.on("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+        opts.on("-o", "--output FILE", String, "Output filename") do |path|
+          @config[:output] = Pathname.new(path).expand_path
+        end
+
+        begin
+          argv = ["-h"] if argv.empty?
+          opts.parse!(argv)
+        rescue OptionParser::ParseError => e
+          STDERR.puts e.message, "\n", opts
+          exit(-1)
+        end
+      end
+    end
+  end
+end

data/lib/oryx/preprocessor.rb

@@ -0,0 +1,21 @@
+module Oryx
+  class Preprocessor
+    def initialize
+    end
+
+    def parse content
+      content = remove_comment content
+      remove_outer_whitespace content
+    end
+
+    def remove_comment content
+      content.gsub /\/\*.*?\*\//, ''
+    end
+
+    def remove_outer_whitespace content
+      content.lstrip.rstrip
+    end
+
+
+  end
+end

data/lib/oryx/runner.rb

@@ -0,0 +1,56 @@
+require_relative '../oryx.rb'
+require 'colorize'
+
+module Oryx
+  class Runner
+    attr_reader :input_filename, :output_filename
+
+    def initialize argv
+      @options = Options.new argv
+      @input_filename  = @options.input
+      @output_filename = @options.output
+    end
+
+    def run
+      puts "input:  #{input_filename}"
+      puts "output: #{output_filename}"
+      print "lexing".blue+"."*17
+      l = Lexer.new
+      output_filename.open('w:UTF-8') { |f| f.write(tabularize_output l.lex_file(input_filename.to_s)) }
+      puts "complete".green
+    end
+
+    private
+      def tabularize_output tokens
+        s = table_header
+        tokens.each do |t|
+          line = ""
+          line += format " %-9s", t.type
+          line += " "
+          line += center t.value.to_s, 10
+          line += " "
+          line += center("#{t.position.line_number},#{t.position.line_offset}", 13) if t.position
+          s += line + "\n"
+        end
+        s
+      end
+
+      def table_header
+        s = center "TYPE", 10
+        s += "|"
+        s += center "VALUE", 10
+        s += "|"
+        s += center "POSITION", 12
+        s += "\n"
+        s += "-"*35
+        s += "\n"
+      end
+
+
+      def center text, width
+        left = (width - text.length)/2
+        right = width - text.length - left
+        " "*left + text + " "*right
+      end
+  end
+end

data/lib/oryx/version.rb

@@ -1,3 +1,3 @@
 module Oryx
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/man/man1/oryx.1

@@ -0,0 +1,21 @@
+.TH ORYX 2013\-2\-20 0.1.0
+.SH NAME
+.PP
+oryx \- cflat tokenizer
+.SH SYNOPSIS
+.PP
+\fB\fCoryx\fR [\-o output\-file] input\-file
+.SH DESCRIPTION
+.PP
+[oryx] produces a table of tokens representing the source code contained in \fB\fCinput-file\fR. If invalid characters/strings are found they are returned as error tokens and lexing continues. Oryx can even handle (in other words not throw an exception) when given random input, as shown by the test suite.
+.SH OPTIONS
+.PP
+\fB\fC-h\fR, \fB\fC--help\fR
+    Show list of options and usage
+.PP
+\fB\fC-o\fR, \fB\fC--output\fR [\fIFILE\fP]
+    Specify the filename in which to write the token table
+.SH SEE ALSO
+.PP
+.BR clang (1), 
+.BR gcc (1)

data/oryx.gemspec

@@ -6,16 +6,24 @@ require 'oryx/version'
 Gem::Specification.new do |gem|
   gem.name          = "oryx"
   gem.version       = Oryx::VERSION
+  gem.date          = Date.today.to_s
   gem.authors       = ["Casey Robinson"]
   gem.email         = ["kc@rampantmonkey.com"]
-  gem.description   = %q{Write a gem description}
-  gem.summary       = %q{Write a gem summary}
-  gem.homepage      = ""
+  gem.description   = %q{C-Flat to x86 compiler}
+  gem.summary       = %q{Take a program written in C-Flat and convert it to x86 assembly}
+  gem.homepage      = "http://github.com/rampantmonkey/oryx"
 
   gem.files         = `git ls-files`.split($/)
+  gem.files        += Dir['man/man?/*.?']
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rake', '~>0.9.2.2'
+  gem.add_development_dependency 'shoulda', '~>3.3.2'
+  gem.add_development_dependency 'md2man', '~>1.4'
+  gem.add_development_dependency 'binman', '~>3.2.0'
+
+  gem.add_dependency 'rltk', '~>2.2.1'
+  gem.add_dependency 'colorize', '~>0.5.8'
 end

data/test/lib/oryx/lexer_test.rb

@@ -0,0 +1,303 @@
+require_relative '../../test_helper'
+require 'rltk'
+
+module Oryx
+  class TestLexer < Test::Unit::TestCase
+    def compare(input, expected)
+      l = Lexer.new
+      l.lex(input).each_with_index do |t, i|
+        assert_equal expected[i], t.to_s unless t.to_s == "EOS"
+      end
+    end
+
+    def valid_id? query_id
+      assert is_id? query_id
+    end
+
+    def invalid_id? query_id
+      assert !is_id?(query_id), "#{query_id} is a valid id"
+    end
+
+    def is_id? query_id
+      l = Lexer.new
+      tokens = l.lex(query_id).map{|t| ["IDENT", "EOS"].include? t.type.to_s }
+      !tokens.include? false
+    end
+
+    context "keywords" do
+      should "match boolean" do
+        compare("boolean", ["BOOLEAN"])
+      end
+      should "match char" do
+        compare("char", ["CHAR"])
+      end
+      should "match else" do
+        compare("else", ["ELSE"])
+      end
+      should "match false" do
+        compare("false", ["FALSE"])
+      end
+      should "match if" do
+        compare("if", ["IF"])
+      end
+      should "match int" do
+        compare("int", ["INT"])
+      end
+      should "match print" do
+        compare("print", ["PRINT"])
+      end
+      should "match return" do
+        compare("return", ["RETURN"])
+      end
+      should "match string" do
+        compare("string", ["STRING"])
+      end
+      should "match true" do
+        compare("true", ["TRUE"])
+      end
+      should "match void" do
+        compare("void", ["VOID"])
+      end
+      should "match while" do
+        compare("while", ["WHILE"])
+      end
+    end
+
+    context "operators and delimiters" do
+      should "match )" do
+        compare('(', ["LPAREN"])
+      end
+      should "match (" do
+        compare(')', ["RPAREN"])
+      end
+      should "match {" do
+        compare('{', ["LCURLY"])
+      end
+      should "match }" do
+        compare('}', ["RCURLY"])
+      end
+      should "match *" do
+        compare('*', ["TIMES"])
+      end
+      should "match " do
+        compare('/', ["DIV"])
+      end
+      should "match +" do
+        compare('+', ["PLUS"])
+      end
+      should "match -" do
+        compare('-', ["MINUS"])
+      end
+      should "match <" do
+        compare('<', ["LE"])
+      end
+      should "match <=" do
+        compare('<=', ["LEQ"])
+      end
+      should "match >=" do
+        compare('>=', ["GEQ"])
+      end
+      should "match >" do
+        compare('>', ["GE"])
+      end
+      should "match ==" do
+        compare('==', ["EQ"])
+      end
+      should "match !=" do
+        compare('!=', ["NEQ"])
+      end
+      should "match &&" do
+        compare('&&', ["AND"])
+      end
+      should "match ||" do
+        compare('||', ["OR"])
+      end
+      should "match =" do
+        compare('=', ["ASSIGN"])
+      end
+      should "match ;" do
+        compare(';', ["SEMI"])
+      end
+      should "match ," do
+        compare(',', ["COMMA"])
+      end
+      should "match newline" do
+        queries = [ "\\\n",
+                    "\\\t\n",
+                    "\\   \n"]
+        queries.each { |q| compare q, ["CONTNL"] }
+      end
+    end
+
+    context "identifiers" do
+      should "be valid ids" do
+        queries = [ "a",
+                    "a1",
+                    "qwerty_uiop",
+                    "abc123",
+                    "ab_12",
+                    "etc",
+                    "j",
+                    "LastNumber",
+                    "not_sureHow_many_more_areNecessary"]
+        queries.each { |q| valid_id? q }
+      end
+
+      should "be invalid ids" do
+        queries = [ "if",
+                    '?',
+                    "1a",
+                    "1.ab",
+                    "1b a",
+                    "ab 12",
+                    "abc.126",
+                    "!abc123"]
+        queries.each { |q| invalid_id? q }
+      end
+    end
+
+    context "comments" do
+      should "remove the c-style commment" do
+        compare "/* this is a comment */", ["EOS"]
+      end
+
+      should "remove two line c-style comment" do
+        compare "/* line 1 \n line 2 */", ["EOS"]
+      end
+
+      should "remove multi-line comment (c-style)" do
+        input = "/*" + "dnfdikas kenib UHJa ia !( *(*#ASD}{asdfi%*&) \n"*50 + "*/"
+        compare input, ["EOS"]
+      end
+
+      should "remove c++-style comment" do
+        compare "//\n", ["EOS"]
+      end
+
+      should "return warning with eos in comment" do
+        compare  "/*", ["MCOMTER"]
+      end
+
+    end
+
+    context "test.cflat" do
+      should "replicate results from example" do
+        input = "char true boolean\nboolean ( +\nstring s"
+        result = ["CHAR", "TRUE", "BOOLEAN", "BOOLEAN", "LPAREN", "PLUS", "STRING", "IDENT(s)"]
+        compare input, result
+      end
+    end
+
+    context "comments" do
+      should "produce error token" do
+        compare '*/', ["UCOMTER"]
+      end
+    end
+
+    context "characters" do
+      should "produce a character constant token" do
+        compare "'a'", ["CHARCON(a)"]
+      end
+
+      should "not be a character constant" do
+        compare "'abc'", ["INVCON(abc)"]
+      end
+
+      should "disallow empty character constants" do
+        compare "''", ["INVCON()"]
+      end
+
+      should "match escape sequences" do
+        valid_escapes = %w{n 0}
+        valid_escapes.each do |v|
+          sequence = "'\\#{v.lstrip}'"
+          result = ["CHARCON(\\#{v.lstrip})"]
+          compare sequence, result
+        end
+      end
+
+      should "return character for non-special escape sequence" do
+        test_escapes = %w{c d e g h ! ^ &}
+        test_escapes.each do |t|
+          sequence = "'\\#{t.lstrip}'"
+          result = ["CHARCON(#{t.lstrip})"]
+          compare sequence, result
+        end
+      end
+    end
+
+    context "strings" do
+      should "produce a string constant token" do
+        compare '"a"', ["STRCON(a)"]
+      end
+
+      should "produce a longer string constant" do
+        input = '"Why, you stuck up, half-witted, scruffy-looking Nerf herder."'
+        compare input, ["STRCON(#{input[1...-1]})"]
+      end
+
+      should "handle escaped double quote in string" do
+        input = '"\""'
+        compare input, ["STRCON(#{input[1...-1]})"]
+      end
+
+      should "report missing closing double quote" do
+        input = '"asdfasdf
+        '
+        compare input, ["STRCON(asdfasdf)", "MSTRTER"]
+      end
+
+      should "report that string is too long" do
+        input = '"' + "a"*259 + '"'
+        compare input, ["STRCON(#{'a'*255})", "STRLNG"]
+      end
+    end
+
+    context "fibonacci sequence example" do
+      should "match the expected result" do
+        input = <<-'EOF'
+          int x=35;
+          void fib( int x )
+          {
+            if(x<2) {
+              return 1;
+            } else {
+              return fib(x-1)+fib(x-2);
+            } }
+            int main() {
+              int i=x;
+                while(i>0) {
+                  print "fib(", i, ") = ", fib(i), "\n";
+                  i=i-1; }
+              return 0;
+           }
+        EOF
+        expected = %w{INT IDENT(x) ASSIGN NUM(35) SEMI VOID IDENT(fib) LPAREN INT
+                      IDENT(x) RPAREN LCURLY IF LPAREN IDENT(x) LE NUM(2) RPAREN
+                      LCURLY RETURN NUM(1) SEMI RCURLY ELSE LCURLY RETURN IDENT(fib)
+                      LPAREN IDENT(x) MINUS NUM(1) RPAREN PLUS IDENT(fib) LPAREN
+                      IDENT(x) MINUS NUM(2) RPAREN SEMI RCURLY RCURLY INT IDENT(main)
+                      LPAREN RPAREN LCURLY INT IDENT(i) ASSIGN IDENT(x) SEMI WHILE
+                      LPAREN IDENT(i) GE NUM(0) RPAREN LCURLY PRINT STRCON(fib()
+                      COMMA IDENT(i) COMMA STRCON()\ =\ ) COMMA IDENT(fib) LPAREN
+                      IDENT(i) RPAREN COMMA STRCON(\\n) SEMI IDENT(i) ASSIGN IDENT(i)
+                      MINUS NUM(1) SEMI RCURLY RETURN NUM(0) SEMI RCURLY EOS}
+        compare input, expected
+      end
+    end
+
+    context "randomness" do
+      should "not raise an error" do
+        assert_nothing_raised do
+          random = `cat /dev/urandom | strings | head -100`
+          random.encode!("ISO-8859-1", invalid: :replace)
+          input = random.encode("UTF-8", invalid: :replace)
+          l = Lexer.new
+          l.lex(input)
+        end
+      end
+    end
+
+  end
+end
+

data/test/lib/oryx/preprocessor_test.rb

@@ -0,0 +1,65 @@
+require_relative '../../test_helper'
+
+module Oryx
+  class TestPreprocessor < Test::Unit::TestCase
+    context "one line inputs" do
+      setup do
+        @preprocessor = Preprocessor.new
+      end
+
+      should "not modify empty input" do
+        test_input = ""
+        assert_equal test_input, @preprocessor.parse(test_input)
+      end
+
+      should "not modify simple assignment" do
+        test_input = "int length=7;"
+        assert_equal test_input, @preprocessor.parse(test_input)
+      end
+
+      should "remove block comment" do
+        test_input = "/* this is a block comment in c */"
+        assert_equal "", @preprocessor.parse(test_input)
+      end
+
+      should "remove trailing comment" do
+        test_input = "int a = 5; /* a */"
+        assert_equal "int a = 5;", @preprocessor.parse(test_input)
+      end
+
+      should "remove starting comment" do
+        test_input = "/* a */ int a = 5;"
+        assert_equal "int a = 5;", @preprocessor.parse(test_input)
+      end
+
+      should "remove both comments" do
+        test_input = "/* a */ int a = 5; /* b */"
+        assert_equal "int a = 5;", @preprocessor.parse(test_input)
+      end
+
+      should "remove tons of comments" do
+        test_input = "/* a */"*700 + " int a = 5; " + "/* b */"*107
+        assert_equal "int a = 5;", @preprocessor.parse(test_input)
+      end
+    end
+
+    context "multi line test" do
+      setup do
+        @preprocessor = Preprocessor.new
+      end
+
+      should "remove extra newline" do
+        test_input = "\n"
+        assert_equal "", @preprocessor.parse(test_input)
+      end
+
+      should "do nothing" do
+        test_input = "int a=5;\na++"
+        assert_equal test_input, @preprocessor.parse(test_input)
+      end
+    end
+
+
+  end
+end
+

data/test/lib/oryx/version_test.rb

@@ -0,0 +1,12 @@
+require_relative '../../test_helper'
+
+module Oryx
+  class TestVersion < Test::Unit::TestCase
+    context "version" do
+      should "be defined" do
+        assert_not_nil Oryx::VERSION
+      end
+    end
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+require 'shoulda'
+require File.expand_path('../../lib/oryx.rb', __FILE__)
+
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oryx
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,40 +9,134 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-15 00:00:00.000000000 Z
+date: 2013-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.2.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-description: Write a gem description
+        version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.2
+- !ruby/object:Gem::Dependency
+  name: md2man
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: binman
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rltk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+description: C-Flat to x86 compiler
 email:
 - kc@rampantmonkey.com
-executables: []
+executables:
+- oryx
+- oryx.markdown
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/oryx
+- bin/oryx.markdown
 - lib/oryx.rb
+- lib/oryx/lexer.rb
+- lib/oryx/options.rb
+- lib/oryx/preprocessor.rb
+- lib/oryx/runner.rb
 - lib/oryx/version.rb
 - oryx.gemspec
-homepage: ''
+- test/lib/oryx/lexer_test.rb
+- test/lib/oryx/preprocessor_test.rb
+- test/lib/oryx/version_test.rb
+- test/test_helper.rb
+- man/man1/oryx.1
+homepage: http://github.com/rampantmonkey/oryx
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -54,16 +148,26 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 620521509045120590
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 620521509045120590
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Write a gem summary
-test_files: []
+summary: Take a program written in C-Flat and convert it to x86 assembly
+test_files:
+- test/lib/oryx/lexer_test.rb
+- test/lib/oryx/preprocessor_test.rb
+- test/lib/oryx/version_test.rb
+- test/test_helper.rb