#
# This file is free software, which comes along with NIT. This software is
# distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE. You can modify it is you want, provided this header
# is kept unaltered, and a notification of the changes is added.
# You are allowed to redistribute it and sell it, alone or is a part of
# Super class of all option's class
abstract class Option
# Names for the option (including long and short ones)
- readable var _names: Array[String]
+ var names: Array[String]
# Type of the value of the option
type VALUE: nullable Object
# Human readable description of the option
- readable var _helptext: String
+ var helptext: String
+
+ # Gathering errors during parsing
+ var errors: Array[String] = new Array[String]
# Is this option mandatory?
- readable writable var _mandatory: Bool
+ var mandatory: Bool writable = false
# Has this option been read?
- readable var _read:Bool
-
- # Current value of this option
- writable var _value: nullable VALUE
+ var read: Bool writable = false
# Current value of this option
- fun value: VALUE do return _value.as(VALUE)
+ var value: VALUE writable
# Default value of this option
- readable writable var _default_value: nullable VALUE
+ var default_value: VALUE writable
# Create a new option
- init init_opt(help: String, default: nullable VALUE, names: nullable Array[String])
+ init(help: String, default: VALUE, names: nullable Array[String])
+ do
+ init_opt(help, default, names)
+ end
+
+ fun init_opt(help: String, default: VALUE, names: nullable Array[String])
do
if names == null then
- _names = new Array[String]
+ self.names = new Array[String]
else
- _names = names.to_a
+ self.names = names.to_a
end
- _helptext = help
- _mandatory = false
- _read = false
- _default_value = default
- _value = default
+ helptext = help
+ default_value = default
+ value = default
end
# Add new aliases for this option
- fun add_aliases(names: String...) do _names.add_all(names)
+ fun add_aliases(names: String...) do names.add_all(names)
# An help text for this option with default settings
redef fun to_s do return pretty(2)
# A pretty print for this help
fun pretty(off: Int): String
do
- var text = new Buffer.from(" ")
- text.append(_names.join(", "))
+ var text = new FlatBuffer.from(" ")
+ text.append(names.join(", "))
text.append(" ")
var rest = off - text.length
if rest > 0 then text.append(" " * rest)
fun pretty_default: String
do
var dv = default_value
- if dv != null then return " ({dv})"
+ if dv != null then return " ({dv.to_s})"
return ""
end
# Consume parameters for this option
protected fun read_param(it: Iterator[String])
do
- _read = true
+ read = true
end
end
class OptionText
super Option
- init(text: String) do init_opt(text, null, null)
+ init(text: String) do super(text, null, null)
redef fun pretty(off) do return to_s
super Option
redef type VALUE: Bool
- init(help: String, names: String...) do init_opt(help, false, names)
+ init(help: String, names: String...) do super(help, false, names)
redef fun read_param(it)
do
super Option
redef type VALUE: Int
- init(help: String, names: String...) do init_opt(help, 0, names)
+ init(help: String, names: String...) do super(help, 0, names)
redef fun read_param(it)
do
protected fun convert(str: String): VALUE is abstract
# Is the parameter mandatory?
- readable writable var _parameter_mandatory: Bool
+ var parameter_mandatory: Bool writable = true
redef fun read_param(it)
do
super
- if it.is_ok and it.item.first != '-' then
+ if it.is_ok and it.item.chars.first != '-' then
value = convert(it.item)
it.next
else
- if _parameter_mandatory then
- # FIXME exit(1) is not a good way of handling the error
- stderr.write("Error: parameter expected for option {names.first}\n")
- exit(1)
+ if parameter_mandatory then
+ errors.add("Parameter expected for option {names.first}.")
end
end
end
-
- init init_opt(h, d, n)
- do
- super
- _parameter_mandatory = true
- end
end
class OptionString
super OptionParameter
redef type VALUE: nullable String
- init(help: String, names: String...) do init_opt(help, null, names)
+ init(help: String, names: String...) do super(help, null, names)
redef fun convert(str) do return str
end
class OptionEnum
super OptionParameter
redef type VALUE: Int
- var _values: Array[String]
+ var values: Array[String]
init(values: Array[String], help: String, default: Int, names: String...)
do
assert values.length > 0
- _values = values.to_a
- init_opt("{help} <{values.join(", ")}>", default, names)
+ self.values = values.to_a
+ super("{help} <{values.join(", ")}>", default, names)
end
redef fun convert(str)
do
- var id = _values.index_of(str)
+ var id = values.index_of(str)
+ if id == -1 then
+ var e = "Unrecognized value for option {names.join(", ")}.\n"
+ e += "Expected values are: {values.join(", ")}."
+ errors.add(e)
+ end
return id
end
- fun value_name: String = _values[value]
+ fun value_name: String do return values[value]
redef fun pretty_default
do
if default_value != null then
- return " ({_values[default_value.as(not null)]})"
+ return " ({values[default_value]})"
else
return ""
end
super OptionParameter
redef type VALUE: Int
- init(help: String, default: Int, names: String...) do init_opt(help, default, names)
+ init(help: String, default: Int, names: String...) do super(help, default, names)
redef fun convert(str) do return str.to_i
end
+class OptionFloat
+ super OptionParameter
+ redef type VALUE: Float
+
+ init(help: String, default: Float, names: String...) do super(help, default, names)
+
+ redef fun convert(str) do return str.to_f
+end
+
class OptionArray
super OptionParameter
redef type VALUE: Array[String]
init(help: String, names: String...)
do
- _values = new Array[String]
- init_opt(help, _values, names)
+ values = new Array[String]
+ super(help, values, names)
end
- var _values: Array[String]
+ private var values: Array[String]
redef fun convert(str)
do
- _values.add(str)
- return _values
+ values.add(str)
+ return values
end
end
class OptionContext
- readable var _options: Array[Option]
- readable var _rest: Array[String]
+ var options: Array[Option]
+ var rest: Array[String]
+ var errors: Array[String]
- var _optmap: Map[String, Option]
+ private var optmap: Map[String, Option]
fun usage
do
var lmax = 1
- for i in _options do
+ for i in options do
var l = 3
for n in i.names do
l += n.length + 2
if lmax < l then lmax = l
end
- for i in _options do
+ for i in options do
print(i.pretty(lmax))
end
end
do
var parseargs = true
build
- var rest = _rest
-
+ var rest = rest
+
while parseargs and it.is_ok do
var str = it.item
if str == "--" then
rest.add_all(it.to_a)
parseargs = false
else
- if _optmap.has_key(str) then
- var opt = _optmap[str]
- it.next
- opt.read_param(it)
+ # We're looking for packed short options
+ if str.chars.last_index_of('-') == 0 and str.length > 2 then
+ var next_called = false
+ for i in [1..str.length] do
+ var short_opt = "-" + str.chars[i].to_s
+ if optmap.has_key(short_opt) then
+ var option = optmap[short_opt]
+ if option isa OptionParameter then
+ it.next
+ next_called = true
+ end
+ option.read_param(it)
+ end
+ end
+ if not next_called then it.next
else
- rest.add(it.item)
- it.next
+ if optmap.has_key(str) then
+ var opt = optmap[str]
+ it.next
+ opt.read_param(it)
+ else
+ rest.add(it.item)
+ it.next
+ end
end
end
end
- for opt in _options do
+ for opt in options do
if opt.mandatory and not opt.read then
- stderr.write("Error: mandatory option {opt.names.join(", ")} not found\n")
- exit(1)
+ errors.add("Mandatory option {opt.names.join(", ")} not found.")
end
end
end
fun add_option(opts: Option...)
do
for opt in opts do
- _options.add(opt)
+ options.add(opt)
end
end
init
do
- _options = new Array[Option]
- _optmap = new HashMap[String, Option]
- _rest = new Array[String]
+ options = new Array[Option]
+ optmap = new HashMap[String, Option]
+ rest = new Array[String]
+ errors = new Array[String]
end
private fun build
do
- for o in _options do
+ for o in options do
for n in o.names do
- _optmap[n] = o
+ optmap[n] = o
end
end
end
+
+ fun get_errors: Array[String]
+ do
+ var errors: Array[String] = new Array[String]
+
+ errors.add_all(errors)
+
+ for o in options do
+ for e in o.errors do
+ errors.add(e)
+ end
+ end
+
+ return errors
+ end
end
nitlanguage / nit.git / blobdiff