414 lines
7.5 KiB
Ruby
414 lines
7.5 KiB
Ruby
#!/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;
|
|
}
|