options.rb

#!/bin/env ruby -w 

require 'erb'
require 'optparse'

class Option

  attr_reader :name
  attr_reader :description
  attr_reader :argument # nil, :, =, ?


  # name of the field, in the struct
  # will be null if virtual.
  attr_reader :field

  # array of custom code.
  attr_accessor :code

  attr_reader :modifiers


  def _fieldName(name, modifiers)
    return nil if modifiers[:virtual]
    return modifiers[:field] if modifiers[:field]
    return "_#{name}"
  end

  def initialize(name, argument, modifiers)
    @code = []

    modifiers ||= {}
    @name = name
    @field = _fieldName(name, modifiers)
    @argument = argument
    @modifiers = modifiers
  end

  def to_s()
    return "Option: #{description}#{argument} #{field}"
  end

  # def addCode(x)
  #   @code.push(x)
  # end

  # def finishCode
  #   # remove all blank lines at the end
  #   while @code.length && @code.last =~ /^\s*$/
  #     @code.pop
  #   end
  # end
  
end

class ShortOption < Option
  def initialize(name, argument, modifiers)
    super(name, argument, modifiers)

    @description = "-#{name}"
  end


  def generateCase()

    rv = []
    indent = " " * 8
    rv.push indent, "case '#{@name}':\n"
    indent += "  "

    if (@argument)
      #print indent, "GETOPTARG(#{@description})\n"
      rv.push indent, "++j;\n"
      rv.push indent, "if (cp[j]) {\n"
      rv.push indent, "  optarg = cp + j;\n"
      rv.push indent, "} else {\n"
      rv.push indent, "  ++i;\n"
      rv.push indent, "  if (i < argc) optarg = argv[i];\n"
      rv.push indent, "}\n"
      rv.push indent, "if (!optarg) {\n"
      rv.push indent, "  fputs(\"#{@description} requires an argument\\n\", stderr);\n"
      rv.push indent, "  exit(1);\n"
      rv.push indent, "}\n"
    end

    if @field
      if @argument
        rv.push indent, "options->#{@field} = optarg;\n"
      else
        if @modifiers[:increment]
          rv.push indent, "options->#{@field} += 1;\n"
        else
          rv.push indent, "options->#{@field} = 1;\n"
        end
      end
    end

    @code.each {|x| rv.push indent, x }
    rv.push indent,"break;\n"

  end

  def generateField()
    # generate the field for the struct.

    return "" unless @field
    return "  char *#{@field};\n" if @argument
    return "  unsigned #{@field};\n" if @modifiers[:increment]
    return "  unsigned #{@field}:1;\n"
  end
end


def arrayTrim(x)
  while x.length && x.last =~ /^\s*$/
    x.pop
  end
  x
end

def parseModifiers(string)

  # splits a key=value (, key=value)* string
  # key is equivalent to key={true}
  rv = {}
  return rv unless string
  args = string.split(',')
  args.each{|x|
    x.strip!
    next unless x.length

    key, value = x.split('=')

    value ||= true # key == key={true}
    key = key.intern

    rv[key] = value
  }

  return rv;
end


@shortRE = /
  ^
  -([\w])           # 1. letter
  ([:])?            # 2. argument type?
  \s*
  (?:\[
    ([\w\s,=]*)     # 3. modifiers?
  \])?
  \s*
  (->)?             # 4. code?
  $
  /x

@longRE = /
  ^
  --([\w-]*)        # 1. name
  ([=?])?           # 2. argument type?
  \s*
  (?:\[
    ([\w\s,=]*)     # 3. modifiers?
  \])?
  \s*
  (->)?             # 4. code?
  $
  /x

@headerTemplate = <<EOD
#ifndef __<%= config[:prefix] %>Options__
#define __<%= config[:prefix] %>Options__

typedef struct <%= config[:prefix] %>Options
{
<%= (config[:extra_fields] || []).join() %>
<%= (options.map {|x| x.generateField }).join() %>
} <%= config[:prefix] %>Options;

int Get<%= config[:prefix] %>Options(int argc, char **argv,
  <%= config[:prefix] %>Options *options);
#endif
EOD
#


def stripExtension(path)
  return $1 if path =~ /^(.*?)\.([^.\/]*)$/
  return path
end

def process(infile, keepName)

  opt = nil       # current option being processed
  tmp = []        # code block array
  callback = nil  # callback when code is finished.


  options = [] # list of options
  config = {} 

  infile.each_line { |line|

    line.chomp!

    line.rstrip!

    if callback
      if line == "" || line =~ /^\s+/
        tmp.push(line + "\n")
        next
      end
      # store...

      callback.call(arrayTrim(tmp));
      callback = nil
      tmp = []
      code = false
    end

    next if line =~ /^\s*#/

    if line =~ /^%/

      if m = line.match(/^%(\w+)=(\w+)$/)
        key = m[1].intern
        config[key] = m[2]
        next
      end

      if m = line.match(/^%(\w+)$/)
        key = m[1].intern
        config[key] = true
        next
      end

      if m = line.match(/^%(\w+)\s*->$/)
        key = m[1].intern
        callback = Proc.new {|code| config[key] = code }

        next
      end

      $stderr.puts "Not supported: #{line}" 
      next
    end

    if m = line.match(@shortRE)
      tmp = []
      flag = m[1]
      arg = m[2]
      modifiers = m[3]
      modifiers = parseModifiers(modifiers)
      opt = ShortOption.new(flag, arg, modifiers)
      options.push(opt)

      # any code?
      if m[4]
        callback = Proc.new {|code| opt.code = code }
      end

    end


    #
  }

  # if it ended within a code block...
  if callback
    callback.call(arrayTrim(tmp))
    callback = nil
    tmp = []
  end

  options.sort! {|a, b| a.name <=> b.name }


  keepName = nil if keepName == ""
  keepBase = stripExtension(keepName)

  headerName = (config[:prefix] || '') + 'Options.h'
  headerName = keepBase + '.h' if keepBase

  io = $stdout
  io = File.open(keepName, "w") if keepName

  b = binding
  erb = ERB.new(DATA.read(), 0, "%<>")

  io.write(erb.result(b))
  io.close unless io == $stdout


  # header file.
  io = $stdout
  io = File.open(headerName, "w") if headerName && keepName
  erb = ERB.new(@headerTemplate, 0, "%<>")
  io.write(erb.result(b))
  io.close unless io == $stdout

end

keepFile = nil

op = OptionParser.new {|opts|
  opts.banner = "Usage: options.rb [options] [infile]"

  opts.on("-o", "--keep OUTFILE", "Specify output file name") do |filename|
    keepFile = filename
  end
}

op.parse!


keepFile = nil if keepFile == ""

case ARGV.length
when 0
  process($stdin, keepFile)
when 1
  file = ARGV[0]
  io = $stdin
  if file != '-'
    keepFile = stripExtension(file) + '.c' if keepFile == nil
    io = File.open(file, "r")
  end
  process(io, keepFile)
  io.close unless io == $stdin
else
  op.help
  exit(1)
end



exit(0)

__END__
#ifdef __ORCAC__
#pragma optimize 79
#pragma noroot
#endif

#include <stdio.h>
#include <stdlib.h>

#include "<%= File.basename(headerName) %>"

<%= (config[:extra_includes] || []).join() %>

int Get<%= config[:prefix] %>Options(int argc, char **argv, 
  struct <%= config[:prefix] %>Options *options)
{
  int i, j;
  int eof = 0;
  int mindex = 1; /* mutation index */

  for (i = 1; i < argc; ++i)
  {
    char *cp = argv[i];
    char c = cp[0];

    <% if config[:posixly_correct] %>
    // stop processing at first non-opt.
    if (c != '-')
    {
      eof = 1;
      if (i == mindex) return argc;
      argv[mindex] = argv[i];
      ++mindex;
      continue;
    }
    <% end %>

    if (eof || c != '-')
    {
      if (mindex != i) argv[mindex] = argv[i];
      ++mindex;
      continue;
    }

    // long opt check would go here...
    if (cp[1] == '-' && cp[2] == 0)
    {
      eof = 1;
      continue;
    }

    // special case for '-'
    j = 0;
    if (cp[1] != 0) j = 1;

    for (; ; ++j)
    {
      char *optarg = 0;

      c = cp[j];
      if (!c) break;
      switch(c)
      {
<%= options.map{|o| o.generateCase() }.join() %>
        default:
          fprintf(stderr, "-%c : invalid option\n", c);
          exit(1);
          break;
      }
      // could optimize out if no options have flags.
      if (optarg) break;
    }
  }
  return mindex;
}