yaggo 1.5.10

data/lib/yaggo/general.rb

@@ -0,0 +1,127 @@
+# This file is part of Yaggo.
+
+# Yaggo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Yaggo 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 PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Yaggo.  If not, see <http://www.gnu.org/licenses/>.
+
+
+$typejust = 30
+$switchesjust = 40
+
+$type_to_C_type = { 
+  :uint32 => "uint32_t",
+  :uint64 => "uint64_t",
+  :int32 => "int32_t",
+  :int64 => "int64_t",
+  :int => "int",
+  :long => "long",
+  :double => "double",
+  :string => "string",
+  :c_string => "const char *",
+  :enum => "int",
+}
+$type_default = {
+  :uint32 => "0",
+  :uint64 => "0",
+  :int32 => "0",
+  :int64 => "0",
+  :int => "0",
+  :long => "0",
+  :double => "0.0",
+  :string => "",
+  :c_string => "",
+  :enum => "0",
+}
+
+def dflt_typestr(type, *argv)
+  case type
+  when :c_string
+    "string"
+  when :enum
+    argv[0].join("|")
+  else
+    type.to_s
+  end
+end
+
+def suffix_arg(suffix)
+  case suffix
+  when true
+    "true"
+  when false
+    "false"
+  when String
+    suffix
+  else
+    raise "Invalid suffix specifier"
+  end
+end
+
+def str_conv(arg, type, *argv)
+  case type
+  when :string
+    "string(#{arg})"
+  when :c_string
+    arg
+  when :uint32, :uint64
+    "conv_uint<#{$type_to_C_type[type]}>((const char*)#{arg}, err, #{suffix_arg(argv[0])})"
+  when :int32, :int64, :long, :int
+    "conv_int<#{$type_to_C_type[type]}>((const char*)#{arg}, err, #{suffix_arg(argv[0])})"
+  when :double
+    "conv_double((const char*)#{arg}, err, #{suffix_arg(argv[0])})"
+  when :enum
+    # Convert a string to its equivalent enum value
+    "conv_enum((const char*)#{arg}, err, #{argv[0]})"
+  end
+end
+
+def find_error_header bt
+  bt.each { |l| l =~ /^\(eval\):\d+:/ and return $& }
+  return ""
+end
+
+def run_block(name, b)
+  eval("#{$option_variables.join(" = ")} = nil", $main_binding)
+  b.call
+  $option_variables.each { |n| eval("#{n} #{n} unless #{n}.nil?", $main_binding) }
+rescue NoMethodError => e
+  header = find_error_header(e.backtrace)
+  raise "#{header} In #{name}: invalid keyword '#{e.name}' in statement '#{e.name} #{e.args.map { |s| "\"#{s}\"" }.join(" ")}'"
+rescue NameError => e
+  header = find_error_header(e.backtrace)
+  raise "#{header} In #{name}: invalid keyword '#{e.name}'"
+rescue RuntimeError, ArgumentError => e
+  header = find_error_header(e.backtrace)
+  raise "#{header} In #{name}: #{e.message}"
+end
+
+
+def check_conflict_exclude
+  $options.each { |o|
+    $opt_hash[o.long] = o unless o.long.nil?
+    $opt_hash[o.short] = o unless o.short.nil?
+  }
+  $options.each { |o|
+    o.conflict.each { |co|
+      $opt_hash[co] or 
+      raise "Unknown conflict option '#{co}' for switch #{o.long}|#{o.short}"
+    }
+  }
+  $options.each { |o|
+    o.imply.each { |ios|
+      io = $opt_hash[ios] or
+      raise "Unknown implied option '#{io}' for switch #{o.long}|#{o.short}"
+      io.type == :flag or
+      raise "Implied option '#{io}' for switch #{o.long}|#{o.short} is not a flag"
+    }
+  }
+end

data/lib/yaggo/library.rb

@@ -0,0 +1,209 @@
+# This file is part of Yaggo.
+
+# Yaggo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Yaggo 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 PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Yaggo.  If not, see <http://www.gnu.org/licenses/>.
+
+
+def output_conversion_code file
+  file.puts(<<EOS)
+  static bool adjust_double_si_suffix(double &res, const char *suffix) {
+    if(*suffix == '\\0')
+      return true;
+    if(*(suffix + 1) != '\\0')
+      return false;
+
+    switch(*suffix) {
+    case 'a': res *= 1e-18; break;
+    case 'f': res *= 1e-15; break;
+    case 'p': res *= 1e-12; break;
+    case 'n': res *= 1e-9;  break;
+    case 'u': res *= 1e-6;  break;
+    case 'm': res *= 1e-3;  break;
+    case 'k': res *= 1e3;   break;
+    case 'M': res *= 1e6;   break;
+    case 'G': res *= 1e9;   break;
+    case 'T': res *= 1e12;  break;
+    case 'P': res *= 1e15;  break;
+    case 'E': res *= 1e18;  break;
+    default: return false;
+    }
+    return true;
+  }
+
+  static double conv_double(const char *str, ::std::string &err, bool si_suffix) {
+    char *endptr = 0;
+    errno = 0;
+    double res = strtod(str, &endptr);
+    if(endptr == str) {
+      err.assign("Invalid floating point string");
+      return (double)0.0;
+    }
+    if(errno) {
+      err.assign(strerror(errno));
+      return (double)0.0;
+    }
+    bool invalid =
+      si_suffix ? !adjust_double_si_suffix(res, endptr) : *endptr != '\\0';
+    if(invalid) {
+      err.assign("Invalid character");
+      return (double)0.0;
+    }
+    return res;
+  }
+
+  static int conv_enum(const char* str, ::std::string& err, const char* const strs[]) {
+    int res = 0;
+    for(const char* const* cstr = strs; *cstr; ++cstr, ++res)
+      if(!strcmp(*cstr, str))
+        return res;
+    err += "Invalid constant '";
+    err += str;
+    err += "'. Expected one of { ";
+    for(const char* const* cstr = strs; *cstr; ++cstr) {
+      if(cstr != strs)
+        err += ", ";
+      err += *cstr;
+    }
+    err += " }";
+    return -1;
+  }
+
+  template<typename T>
+  static bool adjust_int_si_suffix(T &res, const char *suffix) {
+    if(*suffix == '\\0')
+      return true;
+    if(*(suffix + 1) != '\\0')
+      return false;
+
+    switch(*suffix) {
+    case 'k': res *= (T)1000; break;
+    case 'M': res *= (T)1000000; break;
+    case 'G': res *= (T)1000000000; break;
+    case 'T': res *= (T)1000000000000; break;
+    case 'P': res *= (T)1000000000000000; break;
+    case 'E': res *= (T)1000000000000000000; break;
+    default: return false;
+    }
+    return true;
+  }
+
+  template<typename T>
+  static T conv_int(const char *str, ::std::string &err, bool si_suffix) {
+    char *endptr = 0;
+    errno = 0;
+    long long int res = strtoll(str, &endptr, 0);
+    if(endptr == str) {
+      err.assign("Invalid signed int string");
+      return (T)0;
+    }
+    if(errno) {
+      err.assign(strerror(errno));
+      return (T)0;
+    }
+    bool invalid =
+      si_suffix ? !adjust_int_si_suffix(res, endptr) : *endptr != '\\0';
+    if(invalid) {
+      err.assign("Invalid character");
+      return (T)0;
+    }
+    if(res > ::std::numeric_limits<T>::max() ||
+       res < ::std::numeric_limits<T>::min()) {
+      err.assign("Value out of range");
+      return (T)0;
+    }
+    return (T)res;
+  }
+
+  template<typename T>
+  static T conv_uint(const char *str, ::std::string &err, bool si_suffix) {
+    char *endptr = 0;
+    errno = 0;
+    while(isspace(*str)) { ++str; }
+    if(*str == '-') {
+      err.assign("Negative value");
+      return (T)0;
+    }
+    unsigned long long int res = strtoull(str, &endptr, 0);
+    if(endptr == str) {
+      err.assign("Invalid unsigned int string");
+      return (T)0;
+    }
+    if(errno) {
+      err.assign(strerror(errno));
+      return (T)0;
+    }
+    bool invalid =
+      si_suffix ? !adjust_int_si_suffix(res, endptr) : *endptr != '\\0';
+    if(invalid) {
+      err.assign("Invalid character");
+      return (T)0;
+    }
+    if(res > ::std::numeric_limits<T>::max()) {
+      err.assign("Value out of range");
+      return (T)0;
+    }
+    return (T)res;
+  }
+
+  template<typename T>
+  static ::std::string vec_str(const std::vector<T> &vec) {
+    ::std::ostringstream os;
+    for(typename ::std::vector<T>::const_iterator it = vec.begin();
+        it != vec.end(); ++it) {
+      if(it != vec.begin())
+        os << ",";
+      os << *it;
+    }
+    return os.str();
+  }
+
+  class string : public ::std::string {
+  public:
+    string() : ::std::string() {}
+    explicit string(const ::std::string &s) : std::string(s) {}
+    explicit string(const char *s) : ::std::string(s) {}
+    int as_enum(const char* const strs[]) {
+      ::std::string err;
+      int res = #{str_conv("this->c_str()", :enum, "strs")};
+      if(!err.empty())
+        throw ::std::runtime_error(err);
+      return res;
+    }
+
+
+EOS
+  [:uint32, :uint64, :int32, :int64, :int, :long, :double].each do |type|
+  file.puts(<<EOS)
+    #{$type_to_C_type[type]} as_#{type}_suffix() const { return as_#{type}(true); }
+    #{$type_to_C_type[type]} as_#{type}(bool si_suffix = false) const {
+      ::std::string err;
+      #{$type_to_C_type[type]} res = #{str_conv("this->c_str()", type, "si_suffix")};
+      if(!err.empty()) {
+        ::std::string msg("Invalid conversion of '");
+        msg += *this;
+        msg += "' to #{type}_t: ";
+        msg += err;
+        throw ::std::runtime_error(msg);
+      }
+      return res;
+    }
+EOS
+  end
+
+  file.puts(<<EOS)
+  };
+
+EOS
+# }
+    end
+

data/lib/yaggo/main.rb

@@ -0,0 +1,152 @@
+# This file is part of Yaggo.
+
+# Yaggo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Yaggo 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 PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Yaggo.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'optparse'
+
+require 'yaggo/version'
+require 'yaggo/man_page'
+require 'yaggo/stub'
+require 'yaggo/general'
+require 'yaggo/library'
+require 'yaggo/dsl'
+require 'yaggo/parser'
+require 'yaggo/zsh_completion'
+
+def main
+  $yaggo_options = {
+    :output => nil,
+    :license => nil,
+    :stub => false,
+    :zc => nil,
+    :extended => false,
+    :debug => false,
+  }
+
+  parser = OptionParser.new do |o|
+    o.version = $yaggo_version
+    o.banner = "Usage: #{$0} [options] [file.yaggo]"
+    o.separator ""
+    o.separator "Specific options:"
+
+    o.on("-o", "--output FILE", "Output file") { |v|
+      $yaggo_options[:output] = v
+    }
+    o.on("-l", "--license PATH", "License file to copy in header") { |v|
+      $yaggo_options[:license] = v
+    }
+    o.on("-m", "--man [FILE]", "Display or write manpage") { |v|
+      display_man_page v
+      exit 0;
+    }
+    o.on("-s", "--stub", "Output a stub yaggo file") {
+      $yaggo_options[:stub] = true
+    }
+    o.on("--zc PATH", "Write zsh completion file") { |v|
+      $yaggo_options[:zc] = v
+    }
+    o.on("-e", "--extended-syntax", "Use extended syntax") {
+      $yaggo_options[:extended] = true
+    }
+    o.on("--debug", "Debug yaggo") {
+      $yaggo_options[:debug] = true
+    }
+
+    o.on_tail("-h", "--help", "Show this message") {
+      puts o
+      exit 0
+    }
+  end
+  parser.parse! ARGV
+
+  if $yaggo_options[:stub]
+    begin
+      display_stub_yaggo_file $yaggo_options[:output]
+    rescue => e
+      STDERR.puts("Failed to write stub: #{e.message}")
+      exit 1
+    end
+
+    exit
+  end
+
+  if !$yaggo_options[:stub] && !$yaggo_options[:manual] && ARGV.empty?
+    STDERR.puts "Error: some yaggo files and/or --lib switch is required", parser
+    exit 1
+  end
+  if !$yaggo_options[:output].nil?
+    if $yaggo_options[:stub]
+      if ARGV.size > 0
+        STDERR.puts "Error: no input file needed with the --stub switch", parser
+        exit 1
+      end
+    elsif ARGV.size != 1
+      STDERR.puts "Error: output switch meaningfull only with 1 input file", parser
+      exit 1
+    end
+  end
+
+  ARGV.each do |input_file|
+    pid = fork do
+      begin
+        yaggo_script = File.read(input_file)
+        if $yaggo_options[:extended]
+          yaggo_script.gsub!(/\)\s*\n\s*\{/, ") {")
+        end
+        eval(File.read(input_file))
+        parsed = true
+        check_conflict_exclude
+      rescue RuntimeError, SyntaxError, Errno::ENOENT, Errno::EACCES => e
+        raise e if $yaggo_options[:debug]
+        STDERR.puts(e.message.gsub(/^\(eval\)/, input_file))
+        exit 1
+      rescue NoMethodError => e
+        raise e if $yaggo_options[:debug]
+        STDERR.puts("Invalid keyword '#{e.name}'")
+        exit 1
+      end
+
+      fsplit    = File.basename(input_file).split(/\./)
+      $klass  ||= fsplit.size > 1 ? fsplit[0..-2].join(".") : fsplit[0]
+      $output   = $yaggo_options[:output] if $yaggo_options[:output]
+      $output ||= input_file.gsub(/\.yaggo$/, "") + ".hpp"
+      
+      begin
+        out_fd = open($output, "w")
+        output_cpp_parser(out_fd, $klass)
+      rescue RuntimeError => e
+        raise e if $yaggo_options[:debug]
+        STDERR.puts("#{input_file}: #{e.message}")
+        exit 1
+      ensure
+        out_fd.close if out_fd
+      end
+
+      if $yaggo_options[:zc]
+        begin
+          out_fd = open($yaggo_options[:zc], "w")
+          output_zsh_completion(out_fd, $yaggo_options[:zc])
+        rescue RuntimeError => e
+          raise e if $yaggo_options[:debug]
+          STDERR.puts("#{input_file}: #{e.message}")
+          exit 1
+        ensure
+          out_fd.close if out_fd
+        end
+      end
+    end
+    Process.waitpid pid
+    exit 1 if !$?.exited? || ($?.exited? && $?.exitstatus != 0)
+  end
+end