cauterize 0.0.1.pre13 → 0.0.1.pre14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8dc3160a85139642df941d4afd5e3e7bbac2b32b
-  data.tar.gz: 827cf33e36a85a7acf94e0c92418e4a5ece5b419
+  metadata.gz: d11716e541353c226d505c7a4722a81e682d9e2a
+  data.tar.gz: ac8804479d6ebc0ed4ab1b606a480f74ac3ba101
 SHA512:
-  metadata.gz: 6f4311c1ca2b228a9cad06b595756f57e40327fdba18664b8419770c91e7f2b1fd95aa1cb0a7b94e66b7f8007d1cbd2aeea19a41209197ece8bf7da8c082b9dd
-  data.tar.gz: c32033d4dfd4575cc11ff4dda714211df2cbf46b552903a69659278b90f8ee049bf3f2ef4191da363f4664f2e115a8aa4dd143a401c2017b34233c19cd8edfd7
+  metadata.gz: eb52dda5e785d62fa1aea8410f1bd9c0005e2118d2645f5b056900de8818cbee5b931d323cc277ce099c3cf7b8862bde849d18d6e9af0766b87a143eda664cf9
+  data.tar.gz: e9d6fde04f9f564f1fe0dee795f1d1866388d2efa9c7922a0f1944189547e201f94f648f55c492c120d617c23e3f20d0130184966410184840e5fbe91e1e4a16

data/.gitignore

@@ -1,33 +1,33 @@
-# Object files
-*.o
-
-# Libraries
-*.lib
-*.a
-
-# Shared objects (inc. Windows DLLs)
-*.dll
-*.so
-*.so.*
-*.dylib
-
-# Executables
-*.exe
-*.out
-*.app
-
-# Bundler
-Gemfile.lock
-pkg
-
-# Examples
-example/*_cauterize_output
-
-# Nunit test results
-TestResult.xml
-
-# rbenv
-.ruby-version
-
-# Tags
-tags
+# Object files
+*.o
+
+# Libraries
+*.lib
+*.a
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# Bundler
+Gemfile.lock
+pkg
+
+# Examples
+example/*_cauterize_output
+
+# Nunit test results
+TestResult.xml
+
+# rbenv
+.ruby-version
+
+# Tags
+tags

data/.rspec

@@ -1 +1 @@
--r spec_helper
+-r spec_helper

data/.travisci.yml

@@ -1,4 +1,4 @@
-language: ruby
-rvm:
-  - "1.9.3"
-script: bundle exec rake
+language: ruby
+rvm:
+  - "1.9.3"
+script: bundle exec rake

data/Gemfile

@@ -1,4 +1,4 @@
-source 'http://rubygems.org'
-
-# Specify your gem's dependencies in cauterize.gemspec
-gemspec
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in cauterize.gemspec
+gemspec

data/LICENSE.txt

@@ -1,22 +1,22 @@
-Copyright (c) 2012 John Van Enk
-
-MIT License
-
-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
+Copyright (c) 2012 John Van Enk
+
+MIT License
+
+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/README.md

@@ -1,177 +1,177 @@
-# cauterize
-
-A Ruby DSL for generating marshalable structured data easily compatable with
-statically allocated C systems. Currently, it prefers simplicity and
-predictability over speed.
-
-# Why?
-
-Basically, `malloc` is a huge pain when you only have 16K of RAM.
-
-# Examples
-
-There's currently a (single) example in this project. To run it, do this:
-
-```
-git clone git://github.com/sw17ch/cauterize.git
-cd cauterize
-bundle install
-cd example
-sh build.sh
-```
-
-If this completes without error, then you should find a bunch of generated code
-in cauterize_output. Look at the structures and enumerations defined in the
-`example_project.h` file. Also look at how the `Pack_*` and `Unpack_*`
-functions are organized and named.
-
-Once you've looked at this, take a look at `example_project.c`. This will show
-you the exact mechanism used to package and unpackage different structures.
-
-`cauterize.h` and `cauterize.c` are used as iterators over C buffers. They are
-used to abstract the process of packaging and unpackaging different elements.
-
-# Different Types
-
-There are 7 fundamental classes of types in Cauterize. These types have several characteristics:
-
-* They can be copied with `memcpy`.
-* They do not attempt to cover the concept of indirection or pointers.
-* They are simple.
-* They cannot be defined recursively.
-
-## Primitives
-
-* 1 Byte Primitives
-  * `:bool` - a boolean value
-  * `:int8` - a signed, 8 bit value
-  * `:uint8` - an unsigned, 8 bit value
-* 2 Byte Primitives
-  * `:int16` - a signed, 16 bit value
-  * `:uint16` - an unsigned, 16 bit value
-* 4 Byte Primitives
-  * `:int32` - a signed, 32 bit value
-  * `:uint32` - an unsigned, 32 bit value
-  * `:float32` - a 32 bit floating point value
-* 8 Byte Primitives
-  * `:int64` - a signed, 64 bit value
-  * `:uint64` - an unsigned, 64 bit value
-  * `:float64` - a 64 bit floating point value
-
-## Scalars
-
-Scalars are any type that corresponds to a C scalar value. That is, something
-that can be defined with the native types (`int`, `long`, `short`, etc). It is
-highly recommended that these ONLY ever use values from `stdint.h`. This
-ensures that the sizes of these scalars will be consistent across platforms.
-
-Scalars can be defined simply by giving them a name that corresponds to a type
-from `stdint.h`.
-
-```ruby
-scalar(:uint8_t)
-scalar(:uint32_t)
-```
-
-## Enumerations
-
-Enumerations correspond almost exactly to C enumerations. They are a list of
-names. When appropriate, a specific scalar value may also be specified. If no
-scalar is specified, enumerations will be represented in order from 0.
-
-```ruby
-enumeration(:color) do |e|
-  e.value :red
-  e.value :blue
-  e.value :green
-end
-
-enumeration(:days_of_week) do |e|
-  e.value :sunday, 100
-  e.value :monday, 101
-  e.value :tuesday, 102
-  e.value :wednesday, 103
-  e.value :thursday, 104
-  e.value :friday, 105
-  e.value :saturday, 106
-end
-```
-
-## Fixed Arrays
-
-Fixed arrays are arrays that only ever make sense when they are full. An
-example of an array with this property is a MAC Address. MAC addresses are
-always 6 bytes. Never more. Never less.
-
-```ruby
-fixed_array(:mac_address) do |a|
- a.array_type :uint8_t # the type held by the array
- a.array_size 6 # the number of elements in the array
-end
-```
-
-## Variable Arrays
-
-Variable Arrays are arrays that have a maximum length, but may not be entirely
-utilized.
-
-```ruby
-# a way to represent some number of dates/times as 32-bit values
-variable_array(:datetimes) do |a|
-  a.size_type  :uint8_t # WILL BE DEPRECATED
-  a.array_type :int32_t
-  a.array_size 128
-end
-
-# a string, represented as `int_8`'s, with a maximum length of 32 bytes
-variable_array(:string_32) do |a|
-  a.size_type  :uint8_t # WILL BE DEPRECATED
-  a.array_type :int8_t
-  a.array_size 32
-end
-```
-
-## Composites
-
-Composites are very similar to C structures. They are collections of other
-types. Each field has a name and may correspond to any other defined type.
-
-```ruby
-composite(:person) do |c|
-  c.field :name, :string_32
-  c.field :age, :uint8_t
-  c.field :date_of_birth, :uint32_t
-end
-```
-
-## Groups
-
-Groups are similar to C unions with one major difference. Each group is
-comprised of a type tag and a union of the types the union is capable of
-representing. This is known as a tagged union.
-
-The tag is used to inform the user application what type the union is currently
-representing. The tag is a special enumeration that is automatically defined.
-
-```ruby
-group(:requests) do |g|
-  c.field :add_user, :add_user_request
-  c.field :get_user, :get_user_request
-  c.field :delete_user, :delete_user_request
-end
-
-group(:responses) do |g|
-  c.field :add_user, :add_user_response
-  c.field :get_user, :get_user_response
-  c.field :delete_user, :delete_user_response
-end
-```
-
-Groups don't have to specify a data type in all of their fields.
-
-```ruby
-group(:complex) do |g|
-  g.field :a_number, :int32
-  g.dataless :a_state # no associated data with this alternative
-end
-```
+# cauterize
+
+A Ruby DSL for generating marshalable structured data easily compatable with
+statically allocated C systems. Currently, it prefers simplicity and
+predictability over speed.
+
+# Why?
+
+Basically, `malloc` is a huge pain when you only have 16K of RAM.
+
+# Examples
+
+There's currently a (single) example in this project. To run it, do this:
+
+```
+git clone git://github.com/sw17ch/cauterize.git
+cd cauterize
+bundle install
+cd example
+sh build.sh
+```
+
+If this completes without error, then you should find a bunch of generated code
+in cauterize_output. Look at the structures and enumerations defined in the
+`example_project.h` file. Also look at how the `Pack_*` and `Unpack_*`
+functions are organized and named.
+
+Once you've looked at this, take a look at `example_project.c`. This will show
+you the exact mechanism used to package and unpackage different structures.
+
+`cauterize.h` and `cauterize.c` are used as iterators over C buffers. They are
+used to abstract the process of packaging and unpackaging different elements.
+
+# Different Types
+
+There are 7 fundamental classes of types in Cauterize. These types have several characteristics:
+
+* They can be copied with `memcpy`.
+* They do not attempt to cover the concept of indirection or pointers.
+* They are simple.
+* They cannot be defined recursively.
+
+## Primitives
+
+* 1 Byte Primitives
+  * `:bool` - a boolean value
+  * `:int8` - a signed, 8 bit value
+  * `:uint8` - an unsigned, 8 bit value
+* 2 Byte Primitives
+  * `:int16` - a signed, 16 bit value
+  * `:uint16` - an unsigned, 16 bit value
+* 4 Byte Primitives
+  * `:int32` - a signed, 32 bit value
+  * `:uint32` - an unsigned, 32 bit value
+  * `:float32` - a 32 bit floating point value
+* 8 Byte Primitives
+  * `:int64` - a signed, 64 bit value
+  * `:uint64` - an unsigned, 64 bit value
+  * `:float64` - a 64 bit floating point value
+
+## Scalars
+
+Scalars are any type that corresponds to a C scalar value. That is, something
+that can be defined with the native types (`int`, `long`, `short`, etc). It is
+highly recommended that these ONLY ever use values from `stdint.h`. This
+ensures that the sizes of these scalars will be consistent across platforms.
+
+Scalars can be defined simply by giving them a name that corresponds to a type
+from `stdint.h`.
+
+```ruby
+scalar(:uint8_t)
+scalar(:uint32_t)
+```
+
+## Enumerations
+
+Enumerations correspond almost exactly to C enumerations. They are a list of
+names. When appropriate, a specific scalar value may also be specified. If no
+scalar is specified, enumerations will be represented in order from 0.
+
+```ruby
+enumeration(:color) do |e|
+  e.value :red
+  e.value :blue
+  e.value :green
+end
+
+enumeration(:days_of_week) do |e|
+  e.value :sunday, 100
+  e.value :monday, 101
+  e.value :tuesday, 102
+  e.value :wednesday, 103
+  e.value :thursday, 104
+  e.value :friday, 105
+  e.value :saturday, 106
+end
+```
+
+## Fixed Arrays
+
+Fixed arrays are arrays that only ever make sense when they are full. An
+example of an array with this property is a MAC Address. MAC addresses are
+always 6 bytes. Never more. Never less.
+
+```ruby
+fixed_array(:mac_address) do |a|
+ a.array_type :uint8_t # the type held by the array
+ a.array_size 6 # the number of elements in the array
+end
+```
+
+## Variable Arrays
+
+Variable Arrays are arrays that have a maximum length, but may not be entirely
+utilized.
+
+```ruby
+# a way to represent some number of dates/times as 32-bit values
+variable_array(:datetimes) do |a|
+  a.size_type  :uint8_t # WILL BE DEPRECATED
+  a.array_type :int32_t
+  a.array_size 128
+end
+
+# a string, represented as `int_8`'s, with a maximum length of 32 bytes
+variable_array(:string_32) do |a|
+  a.size_type  :uint8_t # WILL BE DEPRECATED
+  a.array_type :int8_t
+  a.array_size 32
+end
+```
+
+## Composites
+
+Composites are very similar to C structures. They are collections of other
+types. Each field has a name and may correspond to any other defined type.
+
+```ruby
+composite(:person) do |c|
+  c.field :name, :string_32
+  c.field :age, :uint8_t
+  c.field :date_of_birth, :uint32_t
+end
+```
+
+## Groups
+
+Groups are similar to C unions with one major difference. Each group is
+comprised of a type tag and a union of the types the union is capable of
+representing. This is known as a tagged union.
+
+The tag is used to inform the user application what type the union is currently
+representing. The tag is a special enumeration that is automatically defined.
+
+```ruby
+group(:requests) do |g|
+  c.field :add_user, :add_user_request
+  c.field :get_user, :get_user_request
+  c.field :delete_user, :delete_user_request
+end
+
+group(:responses) do |g|
+  c.field :add_user, :add_user_response
+  c.field :get_user, :get_user_response
+  c.field :delete_user, :delete_user_response
+end
+```
+
+Groups don't have to specify a data type in all of their fields.
+
+```ruby
+group(:complex) do |g|
+  g.field :a_number, :int32
+  g.dataless :a_state # no associated data with this alternative
+end
+```