crun 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 673e146fb17b31e94d8c3eb0b07211588037ccac
-  data.tar.gz: 37512566a420652eaf9eb98dd7a18e2b493e05b7
+  metadata.gz: fdbb73ff120ce8d6c877f040acd9dae16b2ad0d3
+  data.tar.gz: 9b9273e32f0366ba3639c709741416e2d840e384
 SHA512:
-  metadata.gz: 7b9040aaed86d5d3c831c7b57d8a86d7ac839661ee025c974975debf6be6a9f828386489b8a583d1973b18acffdecc8ab5847d3c8ad01f3da53af801c5db9cc3
-  data.tar.gz: 0b2a5e8cc7c95c871a8b6d2fd8f0d0cab547dd4c4b09d4ea5c5d784dabe6a267fa22101d1af6ebe52dc0ddccfbb5f872d432efcfdded29728049c692beb5c8b8
+  metadata.gz: 6b985a96db0b25032904b6c0089d0a915477f278d38e665f785d60c40018a7d34ad649604ece9222bd5052351a71e398dfd42862b63f78f0b691ac9fcaba4814
+  data.tar.gz: 22ebcd85b9ebdfeb88eabd3101093781183753d294634f057241f9cb2992c5ff66d4295bd588210022087236f911a95b89189a28ef5df7a001ef2c9e75a28edd

data/CHANGELOG.rdoc

@@ -1,5 +1,8 @@
 = Version history
 
+[0.0.4] Autoheader mode.
+        Documentation improvements.
+
 [0.0.3] Option to save the binary.
 
 [0.0.2] Option prepend feature.

data/README.rdoc

@@ -11,8 +11,8 @@
 Crun is an utility for compiling and running C-programs straight from
 C source files. Crun supports compile-run and compile-debug flows.
 
-You can embed custom compile options into the main c-file, if you
-need, for example, an external library for the program. You can also
+User can embed custom compile options into the main c-file, if user
+need, for example, an external library for the program. User can also
 control the command line parameters passed to the program through
 Crun.
 
@@ -22,14 +22,29 @@ the list of files. Crun is targeted for small C-programs, so it is not
 typical to have multiple files.
 
 User of Crun is most probably trying out some basic C-features or maybe
-prototyping with some algorithm. 
+prototyping with some algorithm.
+
+User can avoid listing stardard POSIX headers, if the Autoheader mode
+is used. Autoheader mode will silently add "#include" directives to
+the start of source files for user.
+
+In Autoheader mode, the source files are examined for function
+calls. The function calls that are part of POSIX, will get the
+corresponding header files automatically included. Other libraries
+(and includes) are not handled, since the possibility for ambiguous
+function names are too high. Autoheader mode is activated with "-a"
+option. Before Autoheader mode is used, user should update the
+Autoheader DB:
+
+  shell> auto -u
+
 
 
 = Example runs
 
-In order to run "Hello World" example with Crun, you need to have the
+In order to run "Hello World" example with Crun, user need to have the
 C source file with "Hello World" program in it. This is available in
-the "examples" directory for you.
+the "examples" directory for user.
 
 "hello.c" content:
 
@@ -40,7 +55,7 @@ the "examples" directory for you.
     return 0;
   }
 
-You can execute compile-run flow by:
+User can execute compile-run flow by:
 
   shell> crun -f examples/hello.c
 
@@ -48,7 +63,7 @@ The output from program is:
 
   Hello World!
 
-You can execute compile-debug flow by:
+User can execute compile-debug flow by:
 
   shell> crun -f examples/hello.c -d
 
@@ -62,7 +77,7 @@ Check available command line interface, CLI, options for Crun:
 
 = Options
 
-You can specify options for Crun in multiple ways. Typically CLI is
+User can specify options for Crun in multiple ways. Typically CLI is
 used to control Crun, but if the program uses static compilation
 options, those live most naturally in the source file itself.
 
@@ -96,7 +111,7 @@ Here is the complete list of options that control Crun:
 [ compprog ]
 
   Array including the compiler name and base options. This options
-  array should only have one entry, but in theory you could have
+  array should only have one entry, but in theory user could have
   multiple entries. The entries are concatenated with SPACE. The
   compiler command has to have same command line parameters as
   "gcc". Default is: ["gcc", "-Wall", "-std=c11"].
@@ -104,7 +119,7 @@ Here is the complete list of options that control Crun:
 [ dbugprog ]
 
   Array including the debugger name and base options. This options
-  array should only have one entry, but in theory you could have
+  array should only have one entry, but in theory user could have
   multiple entries. The entries are concatenated with SPACE. The
   debugger command has to have same command line parameters as
   "gdb". Default is: ["gdb", "--nx"].
@@ -138,7 +153,7 @@ User can specify static overrides in "$HOME/.crun" file and/or in
 "-c" Crun CLI option to read in option overrides.
 
 For example if the program is always run with "-c 10" command line
-options, you use this in ".crun":
+options, user can set in ".crun":
 
   @crun['progopts'] = [ "-c 10" ]
 
@@ -148,19 +163,22 @@ use the -o option:
   shell> crun -o "progopts:=-c 10" ...
 
 This sets the list of program options to "-c 10". ":=" syntax means
-setting the Array of options. If you need to add to existing list of
-options, you should do:
+setting the Array of options. If user needs to add to existing list of
+options, perform:
 
   shell> crun -o "progopts:+-c 10" ...
 
 Thus ":+" is the syntax for appending more options to existing list.
 
+If user wants to put an option to start of list, the ":." syntax is
+used.
+
 The simplest way to pass 'progopts' to target program is using the
 "-p" CLI option. However user must be aware of the shell option
 parsing, since it is very easy to miss the target program and actually
 pass the option to Crun.
 
-If you want to pass '-' based option to target program:
+If user wants to pass '-' based option to target program:
 
   shell> crun -p "\-c 10" ...
 
@@ -177,8 +195,10 @@ Summary of option setting from first to last:
 * "-o" options from Crun CLI.
 * "-p" options for program (only).
 
+The options are applied in this order, and later options may override
+the earlier settings, i.e. CLI options have the highest priority.
 
 = Issues
 
-If you take C source input from STDIN, you can't use the debug
-option. Only compile-run flow is possible.
+If user takes C source input from STDIN, debug option can't be
+used. Only compile-run flow is possible.

data/bin/crun

@@ -11,6 +11,10 @@ require 'como'
 include Como
 require 'tempfile'
 require_relative '../lib/version'
+require 'yaml'
+
+# require 'byebug'
+
 
 Spec.command( 'crun', 'Tero Isannainen', '2016',
   [
@@ -18,14 +22,18 @@ Spec.command( 'crun', 'Tero Isannainen', '2016',
       [ :opt_single, 'prog',    '-p',  "Add program options (i.e. progopts)." ],
       [ :switch,     'debug',   '-d',  "Debug program." ],
       [ :opt_multi,  'opts',    '-o',  "Set/add crun option." ],
+      [ :switch,     'auto',    '-a',  "Use Autoheader mode." ],
       [ :opt_multi,  'conf',    '-c',  "Crun option file(s)." ],
       [ :switch,     'input',   '-i',  "Read stdin for C-code." ],
       [ :opt_single, 'save',    '-s',  "Save compiled file." ],
-      [ :exclusive,  'template','-t',  "Output a template file for program." ],
       [ :switch,     'verbose', '-v',  "Verbose (to stderr)." ],
+      [ :switch,     'template','-t',  "Output a template file for program." ],
+      [ :switch,     'database','-u',  "Update DB for Autoheader mode." ],
   ] )
 
 
+CRUN_HEADERS = "#{ENV['HOME']}/.crun_headers"
+
 # Execute shell command with optional verbosity.
 def crun_exe( cmd )
     if Opt['verbose'].given
@@ -34,17 +42,28 @@ def crun_exe( cmd )
     system( cmd )
 end
 
+
 # Parse and apply option setting.
 def apply_opt( opt )
+
     if opt.split(':=').length == 2
+
+        # Create option array.
         parts = opt.split(':=')
         @crun[parts[0]] = [ parts[1] ]
+
     elsif opt.split(':+').length == 2
+
+        # Add to existing option array.
         parts = opt.split(':+')
         @crun[parts[0]].push parts[1]
+
     elsif opt.split(':.').length == 2
+
+        # Put option to start of list.
         parts = opt.split(':.')
         @crun[parts[0]].unshift parts[1]
+
     end
 end
 
@@ -67,19 +86,135 @@ int main( int argc, char** argv )
 end
 
 
+if Opt['database'].given
+    require_relative '../lib/parsec'
+
+    posix_headers = %w{
+<aio.h>        <libgen.h>       <spawn.h>         <sys/time.h>
+<arpa/inet.h>  <limits.h>       <stdarg.h>        <sys/times.h>
+<assert.h>     <locale.h>       <stdbool.h>       <sys/types.h>
+<complex.h>    <math.h>         <stddef.h>        <sys/uio.h>
+<cpio.h>       <monetary.h>     <stdint.h>        <sys/un.h>
+<ctype.h>      <mqueue.h>       <stdio.h>         <sys/utsname.h>
+<dirent.h>     <ndbm.h>         <stdlib.h>        <sys/wait.h>
+<dlfcn.h>      <net/if.h>       <string.h>        <syslog.h>
+<errno.h>      <netdb.h>        <strings.h>       <tar.h>
+<fcntl.h>      <netinet/in.h>   <stropts.h>       <termios.h>
+<fenv.h>       <netinet/tcp.h>  <sys/ipc.h>       <tgmath.h>
+<float.h>      <nl_types.h>     <sys/mman.h>      <time.h>
+<fmtmsg.h>     <poll.h>         <sys/msg.h>       <trace.h>
+<fnmatch.h>    <pthread.h>      <sys/resource.h>  <ulimit.h>
+<ftw.h>        <pwd.h>          <sys/select.h>    <unistd.h>
+<glob.h>       <regex.h>        <sys/sem.h>       <utime.h>
+<grp.h>        <sched.h>        <sys/shm.h>       <utmpx.h>
+<iconv.h>      <search.h>       <sys/socket.h>    <wchar.h>
+<inttypes.h>   <semaphore.h>    <sys/stat.h>      <wctype.h>
+<iso646.h>     <setjmp.h>       <sys/statvfs.h>   <wordexp.h>
+<langinfo.h>   <signal.h>
+}
+
+    func_header_map = {}
+
+    posix_headers.each do |header|
+        base = header[1..-2]
+        
+        headername = "/usr/include/" + base
+
+        if File.exist?( headername )
+            file = ParseC::SourceFile.new( headername, "/usr/include" )
+            file.conf( :defsonly, true )
+            # file.conf( :mainonly, true )
+            file.conf( :mainonly, false )
+            file.parse
+
+            file.funcdefs.each do |k,v|
+                if k[0..1] != "__"
+                    func_header_map[ k ] = header
+                end
+            end
+        end
+    end
+    
+    File.write( CRUN_HEADERS, YAML.dump( func_header_map ) )
+
+    exit( false )
+end
+
+
+# C-source file object.
+class SourceFile
+    
+    def initialize( name )
+        # Original name.
+        @name = name
+
+        # Current path to compile filed.
+        @path = name
+
+        # Temp file to remove (if any).
+        @remove = nil
+    end
+
+    def headerize
+        require_relative '../lib/parsec'
+
+        func_header_map = nil
+        if File.exist? CRUN_HEADERS
+            func_header_map = YAML.load( File.read( CRUN_HEADERS ) )
+        else
+            return
+        end
+        
+        base = File.basename( @name, ".c" )
+        @path = "/dev/shm/auto-#{base}.c"
+        parse = ParseC::SourceFile.new( @name, File.dirname( @name ) )
+        parse.conf( :mainonly, true )
+        parse.parse
+
+        autoheaders = {}
+
+        parse.funcalls.each do |k,v|
+            if func_header_map[ k ]
+                autoheaders[ func_header_map[ k ] ] = true
+            end
+        end
+         
+        fh = File.open( @path, "w" )
+        autoheaders.each do |k,v|
+            fh.write( "#include #{k}\n" )
+        end
+        fh.write( File.read( @name ) )
+        fh.close
+
+        # Set file to be removed.
+        @remove = @path
+    end
+
+    def path
+        @path
+    end
+
+    def delete
+        FileUtils.rm_f( @remove ) if @remove
+    end
+end
+
+
+
 if Opt['file'].given
-    cfiles = Opt['file'].value
+    cfiles = Opt['file'].value.map{ |i| SourceFile.new( i ) }
 elsif Opt['input'].given
     # Create a temp c-file for input.
     input = STDIN.read
     cfile = "#{Tempfile.new( "crun-source", '/dev/shm' ).path}.c"
     File.write( cfile, input )
-    cfiles = [ cfile ]
+    cfiles = [ SourceFile.new( cfile ) ]
 else
     Spec.usage
 end
 
 
+
 # ------------------------------------------------------------
 # Configurations:
 
@@ -126,7 +261,7 @@ end
 compopts = @crun['compopts']
 crun_re = /[\s]+crun-([a-z]+)/
 
-File.readlines( cfiles[0] ).each do |line|
+File.readlines( cfiles[0].path ).each do |line|
     m = line.match( crun_re )
     if m
         option = m[1]
@@ -163,7 +298,7 @@ end
 
 # ------------------------------------------------------------
 # Create tempfile for executable.
-exefile = File.basename( cfiles[0], '.c' )
+exefile = File.basename( cfiles[0].path, '.c' )
 exepath = Tempfile.new( "crun-#{exefile}", '/dev/shm' ).path
 
 
@@ -178,7 +313,16 @@ class Array
     end
 end
 
-cmds.push "#{@crun['compprog'].crun} #{@crun['crunopts'].crun} #{@crun['compopts'].crun} #{cfiles.crun} -o #{exepath}"
+# Autoheader source files if needed.
+if Opt['auto'].given
+    cfiles.each do |cfile|
+        cfile.headerize
+    end
+end
+
+cfile_paths = cfiles.map{ |i| i.path }
+
+cmds.push "#{@crun['compprog'].crun} #{@crun['crunopts'].crun} #{@crun['compopts'].crun} #{cfile_paths.crun} -o #{exepath}"
 
 # In order to avoid the "text file busy" issue, copy back and forth the exefile.
 cmds.push "cp #{exepath} #{exepath}-tmp"
@@ -230,7 +374,11 @@ end
 # ------------------------------------------------------------
 # Always cleanup, but not necessary if using "/dev/shm".
 if Opt['input'].given
-    system( "rm -f #{cfiles[0]}" )
+    system( "rm -f #{cfiles[0].name}" )
+end
+
+cfiles.each do |cfile|
+    cfile.delete
 end
 
 FileUtils.rm_f exepath

data/examples/greeting_noheader.c

@@ -0,0 +1,44 @@
+/*
+ * Options for crun:
+ * -crun-compopts:=-O2
+ * crun-compopts:+-lm
+ * crun-compopts:.-std=c99
+ * crun-compopts:.-std=c11
+ * crun-progopts:=-c 12
+ */
+
+int main( int argc, char** argv )
+{
+  char* greeting   = "Greetings!\n";
+  char* greeting_n = "Greeting #%d!\n";
+
+  int strlenlog;
+  strlenlog = log2( strlen( greeting ) );
+
+  if ( strlenlog > 10 )
+    exit( 1 );
+
+  int times = 1;
+  if ( argc > 1 )
+    {
+      if ( !strcmp( argv[1], "-c" ) )
+        sscanf( argv[2], "%d", &times );
+      else
+        {
+          fprintf( stderr, "Usage: greeting [-c count]\n" );
+          exit( 1 );
+        }
+    }
+
+  if ( times > 1 )
+    {
+      for ( int i = 0; i < times; i++ )
+        printf( greeting_n, i+1 );
+    }
+  else
+    {
+      printf( greeting );
+    }
+
+  return 0;
+}

data/lib/parsec.rb

@@ -0,0 +1,311 @@
+# Detect suitable CLANG library
+unless ENV['LIBCLANG']
+    begin
+        libdir = %x{llvm-config --libdir}.chomp
+        libs = Dir.glob( "#{libdir}/*libclang*so*" )
+        ENV['LIBCLANG'] = libs[0]
+    rescue
+        raise RuntimeError, "Could not find LLVM, try setting LIBCLANG to library!"
+    end
+end
+
+
+
+# require 'ffi/clang' display stupid messages to stdout, silence them.
+begin
+    require "stringio"
+    old_stdout, $stdout = $stdout, StringIO.new
+    require 'ffi/clang'
+    $stdout = old_stdout
+end
+
+# C-parsing module based on libclang and ffi/clang, i.e. ffi bindings.
+#
+# @example
+#   require 'parsec'
+#   ast = ParseC::SourceFile.new( './code_out.c', '.' )
+#
+module ParseC
+
+    # Source file contains C-function definitions and header file
+    # inclusions.
+    class SourceFile
+
+        # File name.
+        attr_reader :name
+
+        def SourceFile.parseLocalDefs( name, headerPath )
+            file = SourceFile.new( name, headerPath )
+            file.conf( :defsonly, true )
+            file.conf( :mainonly, true )
+            file.parse
+            file
+        end
+
+
+        # Set file to parse and path for header search. Finally,
+        # perform parsing for the file.
+        def initialize( name, headerPath )
+            @name = name
+            @headerPath = headerPath
+
+            @localHeader = {}
+            @funcdefs = {}
+            @funcalls = {}
+
+            @conf = {}
+            @conf[ :defsonly ] = false
+            @conf[ :mainonly ] = false
+        end
+
+
+        def conf( opt, value = nil )
+            if value
+                @conf[ opt ] = value
+            else
+                @conf[ opt ]
+            end
+        end
+
+
+        # Return list of included (local) header files. Can be used e.g. for
+        # c-to-h file dependence.
+        #
+        # @return [Array<HeaderFile>] Headers.
+        def headers
+            @localHeader
+        end
+
+
+        # Return list of defined functions. Can be used e.g. to
+        # generate function declarations to a header file
+        # (automatically).
+        #
+        # @return [Array<HeaderFile>] Functions.
+        def funcdefs
+            @funcdefs
+        end
+
+
+        def funcalls
+            @funcalls
+        end
+
+
+        # Return true if file name is for a local header.
+        def isLocalHeader?( file )
+            if file[0] != '/' && /\.h$/.match( file )
+                true
+            else
+                false
+            end
+        end
+
+
+        # Parse c-file.
+        #
+        # @param headerPath [String] Path for system header lookup.
+        def parse( headerPath = @headerPath )
+
+            index = FFI::Clang::Index.new
+            translation_unit = index.parse_translation_unit( @name, headerPath )
+            cursor = translation_unit.cursor
+
+            # Get list of included local headers.
+            translation_unit.inclusions do |header|
+                if isLocalHeader? header
+                    @localHeader[ header ] = HeaderFile.new( header )
+                end
+            end
+
+            # Recursively travel the c-file hierarchy to detect
+            # function definitions.
+            cursor.visit_children do |cursor, parent|
+
+                if cursor.kind == :cursor_function
+
+                    # Check that function is in the file that is being
+                    # analysed. Might also be from an included header.
+                    if ( @conf[:mainonly] == false ) || cursor.location.from_main_file?
+
+                        f = Function.new( cursor.spelling, cursor.variadic? )
+                        f.setReturnType( cursor.result_type.spelling )
+
+                        # Get argument list.
+                        cursor.visit_children do |cursor, parent|
+
+                            case cursor.kind
+
+                            when :cursor_parm_decl
+                                f.addArgument( cursor.spelling, cursor.type.spelling )
+
+                            else
+                                # puts cursor.kind
+                                true
+
+                            end
+
+                            next :continue
+                        end
+
+
+                        # Mark function complete and add to list.
+                        @funcdefs[ f.name ] = f.done
+
+                        if @conf[:defsonly]
+                            # Don't recurse anymore.
+                            next :continue
+                        else
+                            next :recurse
+                        end
+
+                    else
+
+                        next :continue
+
+                    end
+
+                elsif cursor.kind == :cursor_call_expr
+
+
+                    # if cursor.location.from_main_file?
+                    f = FunCall.new( cursor.spelling )
+                    @funcalls[ f.name ] = f
+                    # end
+
+                    next :recurse
+
+                else
+
+                    # Non-functions are not interesting.
+                    next :recurse
+
+                end
+
+            end
+        end
+
+
+        # Display c-file content.
+        def display
+            puts "File: #{@name}"
+            puts "  Includes:"
+            @localHeader.each_value do |i|
+                puts "    #{i.name} | #{i.path}"
+            end
+            puts "  Functions:"
+            @funcdefs.each_value do |f|
+                puts "    #{f.declaration}"
+            end
+        end
+
+
+        # Show raw content of c-file.
+        def dump( headerPath = @headerPath )
+            index = FFI::Clang::Index.new
+            translation_unit = index.parse_translation_unit( @name, headerPath )
+            cursor = translation_unit.cursor
+            cursor.visit_children do |cursor, parent|
+                puts "#{cursor.kind} #{cursor.spelling}"
+                next :recurse
+            end
+        end
+
+
+    end
+
+
+    # Included local header.
+    class HeaderFile
+
+        # File name.
+        attr_reader :name
+
+        # File path.
+        attr_reader :path
+
+        # Initialize.
+        def initialize( path )
+            @name = File.basename( path )
+            @path = path
+        end
+
+    end
+
+
+    # Defined function.
+    class Function
+
+        # Func name.
+        attr_reader :name
+
+        # Variadic (end with ellipsis).
+        attr_reader :variadic
+
+
+        # Initialize function object. Default return type to void.
+        #
+        # @param name [String] Func name.
+        def initialize( name, variadic = false )
+            @name = name
+            @variadic = variadic
+            @args = {}
+            @returnType = 'void'
+        end
+
+
+        # Set function return type.
+        def setReturnType( type )
+            @returnType = type
+        end
+
+
+        # Add argument to functions argument list.
+        def addArgument( name, type )
+            @args[ name ] = type
+        end
+
+
+        # Close function defition. If argument list is empty, then arg
+        # list contains only void.
+        def done
+            if @variadic
+                @args[ nil ] = '...'
+            end
+
+            if @args.empty?
+                @args = { nil => 'void' }
+            end
+            self
+        end
+
+
+        # Get argument declarations String presentation.
+        def argDecl( name )
+            if name
+                # Has type.
+                "#{@args[ name ]} #{name}"
+            else
+                # Void/variadic.
+                @args[ name ]
+            end
+        end
+
+
+        # Return functions declation as String.
+        def declaration
+            "#{@returnType} #{@name}( #{(@args.keys.map { |k| argDecl(k) }).join(', ')} );"
+        end
+
+    end
+
+    class FunCall
+        # Func name.
+        attr_reader :name
+
+        def initialize( name )
+            @name = name
+        end
+    end
+
+end

data/lib/version.rb

@@ -1,5 +1,5 @@
 module Crun
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
     def Crun.version
         Crun::VERSION
     end

data/test/golden/autoheader.txt

@@ -0,0 +1,12 @@
+Greeting #1!
+Greeting #2!
+Greeting #3!
+Greeting #4!
+Greeting #5!
+Greeting #6!
+Greeting #7!
+Greeting #8!
+Greeting #9!
+Greeting #10!
+Greeting #11!
+Greeting #12!

data/test/result/autoheader.txt

@@ -0,0 +1,12 @@
+Greeting #1!
+Greeting #2!
+Greeting #3!
+Greeting #4!
+Greeting #5!
+Greeting #6!
+Greeting #7!
+Greeting #8!
+Greeting #9!
+Greeting #10!
+Greeting #11!
+Greeting #12!

data/test/test_crun.rb

@@ -39,5 +39,6 @@ class CrunTest < Test::Unit::TestCase
     def test_override2()  runTest( "override2", "-f ../examples/greeting.c -o \"progopts:.-c 13\"" ); end
     def test_override3()  runTest( "override3", "-f ../examples/greeting.c -o \"progopts:+-c 13\"" ); end
     def test_template()   runTest( "template", "-f ../examples/greeting.c -o \"progopts:+-c 13\" -t" ); end
+    def test_autoheader() runTest( "autoheader", "-a -f ../examples/greeting_noheader.c" ); end
 
 end

metadata

@@ -1,19 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: crun
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Tero Isannainen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-22 00:00:00.000000000 Z
+date: 2017-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: como
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.0
@@ -21,9 +24,32 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: ffi-clang
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 description: |-
   Crun is an utility for compiling and running C-programs straight from
   C source files. Crun supports compile-run and compile-debug flows.
@@ -46,15 +72,19 @@ files:
 - bin/crun
 - examples/crun_conf.rb
 - examples/greeting.c
+- examples/greeting_noheader.c
 - examples/hello.c
 - examples/sizeof.c
+- lib/parsec.rb
 - lib/version.rb
+- test/golden/autoheader.txt
 - test/golden/basic.txt
 - test/golden/conf.txt
 - test/golden/override.txt
 - test/golden/override2.txt
 - test/golden/override3.txt
 - test/golden/template.txt
+- test/result/autoheader.txt
 - test/result/basic.txt
 - test/result/conf.txt
 - test/result/override.txt