--- /dev/null
+#!/usr/bin/env ruby
+# ======================================================================
+# faust2sc - Generate language modules from Faust XML.
+# Copyright (C) 2005-2008 Stefan Kersten
+# ======================================================================
+# This program 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 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+# USA
+# ======================================================================
+
+# TODO:
+# rexml is dog slow, maybe use libxml?
+
+require 'getoptlong'
+require 'rexml/document'
+
+PROGRAM = File.basename($0)
+PROGRAM_VERSION = "1.1.0"
+
+class Array
+ def flatten1
+ res = []
+ self.each { |l|
+ res += l
+ }
+ res
+ end
+end
+
+module REXML
+ class Element
+ def to_i
+ self.text.to_i
+ end
+ def to_f
+ self.text.to_f
+ end
+ end
+end
+
+class String
+ def encapitalize
+ self[0..0].upcase + self[1..-1]
+ end
+ def decapitalize(greedy=false)
+ unless greedy
+ self[0..0].downcase + self[1..-1]
+ else
+ res = self.clone
+ (0..res.size-1).each { |i|
+ c = res[i]
+ if 65 <= c && c <= 90
+ res[i] = c + 32
+ else
+ break
+ end
+ }
+ res
+ end
+ end
+end
+
+def print_error(str)
+ $stderr.print("#{PROGRAM}[ERROR] #{str}")
+end
+
+def print_info(str)
+ $stderr.print("#{PROGRAM}[INFO] #{str}")
+end
+
+module Faust
+ class Widget
+ attr_reader :type, :id, :label, :init, :min, :max, :step
+ def initialize(node)
+ @type = node.attributes["type"]
+ @id = node.attributes["id"]
+ if (node.elements["label"].text)
+ @label = node.elements["label"].text
+ else
+ print_info("No label for widget ID #{id} - calling it widget#{id}\n")
+ @label = "widget#{id}"
+ end
+ if (@label =~ /^[0-9]/)
+ plabel = @label
+ @label = @type + "_" + @label
+ print_info("Widget label `#{plabel}' prefixed to become `#{@label}'\n")
+ end
+ dict = node.elements
+ @init = dict["init"].to_f
+ @min = dict["min"].to_f
+ @max = dict["max"].to_f
+ @step = dict["step"].to_f
+ if (@type == "button")
+ @max = 1 # no metadata other than name for buttons
+ @step = 1
+ end
+ end
+ end
+
+ class UI
+ attr_reader :active_widgets, :passive_widgets
+ def initialize(node)
+ @active_widgets = node.get_elements("//activewidgets/widget").collect { |x| Widget.new(x) }
+ @passive_widgets = node.get_elements("//passivewidgets/widget").collect { |x| Widget.new(x) }
+ end
+ end
+
+ class Plugin
+ attr_reader :path, :name, :author, :copyright, :license, :inputs, :outputs, :ui
+ def initialize(path, node)
+ @path = path
+ %w(name author copyright license).each { |name|
+ instance_variable_set("@#{name}", node.elements["/faust/#{name}"].text)
+ }
+ %w(inputs outputs).each { |name|
+ instance_variable_set("@#{name}", node.elements["/faust/#{name}"].text.to_i)
+ }
+ @ui = UI.new(node.elements["/faust/ui"])
+ end
+ def total_inputs
+ inputs + ui.active_widgets.size
+ end
+ def Plugin::from_file(path)
+ self.new(path, REXML::Document.new(File.open(path) { |io| io.read }))
+ end
+ end
+
+ class Generator
+ attr_reader :plugins, :options
+ def initialize(plugins, options)
+ @plugins = plugins
+ @options = options
+ end
+ def lang
+ "unknown"
+ end
+ def generate(io)
+ generate_header(io)
+ generate_body(io)
+ generate_footer(io)
+ end
+ def generate_header(io)
+ end
+ def generate_footer(io)
+ end
+ def generate_body(io)
+ plugins.each_with_index { |plugin,i|
+ if plugin
+ begin
+ print_info("Generating #{lang} code for #{plugin.name} ...\n")
+ generate_plugin(io, plugin)
+ if i < (plugins.size - 1)
+ io.print("\n")
+ end
+ rescue
+ print_error("#{$!}\n")
+ $!.backtrace.each { |l| print_error(l + "\n") }
+ print_error("Omitting #{plugin.path}\n")
+ end
+ end
+ }
+ io.print("\n")
+ end
+ def generate_plugin(io, plugin)
+ raise "#{self.class}::generate_plugin() missing!"
+ end
+ end
+
+ module Language
+ IDENTIFIER_REGEXP = /^[a-z][a-zA-Z0-9_]*[a-zA-Z0-9]?$/
+ def make_identifier(name)
+ # gentle identifier massage
+ # remove quotes
+ name = name.sub(/^"([^"]*)"/, "\\1")
+ # replace invalid chars with underscores
+ name = name.downcase.gsub(/[^a-zA-Z0-9_]/, "_")
+ # reduce multiple underscores to one
+ name = name.gsub(/__+/, "_")
+ # remove leading/terminating underscores
+ name = name.sub(/(^_|_$)/, "")
+ # move leading digits to the end
+ name = name.sub(/^([0-9]+)_/, "") + ("_#{$1}" if $1).to_s
+ # if digit(s) only, prepend alpha prefix
+ if (name[0..0] =~ /^[0-9]/)
+ pname = name
+ name = "w" + name
+ print_info("Widget label `#{pname}' prefixed to become `#{name}'\n")
+ end
+ unless name =~ IDENTIFIER_REGEXP
+ raise "invalid identifier: \"#{name}\""
+ end
+ name
+ end
+ def make_unique(list)
+ # bad, bad, bad
+ list = list.clone
+ res = []
+ ids = {}
+ while hd = list.shift
+ if ids.has_key?(hd)
+ ids[hd] = id = ids[hd] + 1
+ else
+ if list.include?(hd)
+ ids[hd] = id = 0
+ end
+ end
+ res << (id ? "#{hd}_#{id}" : hd)
+ end
+ res
+ end
+ module_function :make_identifier, :make_unique
+ end
+
+ module Haskell
+ INDENT = " " * 4
+
+ def mk_function_names(plugin)
+ fname = plugin.name.decapitalize(true)
+ lname = fname + "'"
+ [lname, fname]
+ end
+ module_function :mk_function_names
+
+ class PluginGenerator
+ attr_reader :plugin
+ def initialize(plugin)
+ @plugin = plugin
+ end
+ def generate(io)
+ lname, fname = Haskell.mk_function_names(plugin)
+ gen_curry_func(io, lname, fname)
+ io << "\n"
+ gen_list_func(io, lname)
+ end
+ def gen_ugen(io, name, rate, inputs, num_outputs)
+ io << "UGen.mkUGen #{rate} \"#{name}\" #{inputs} (replicate #{num_outputs} #{rate}) (UGen.Special 0) Nothing"
+ io << "\n"
+ end
+ def gen_curry_func(io, lname, fname)
+ args = mk_args(plugin.total_inputs)
+ decs = args.collect { "UGen" } + ["UGen"] # add result type
+ io << "#{fname} :: #{decs.join(" -> ")}\n"
+ io << "#{fname} #{args.join(" ")} = #{lname} [#{args.join(',')}]\n"
+ end
+ def gen_list_func(io, fname)
+ io << "#{fname} :: [UGen] -> UGen\n"
+ io << "#{fname} args = "
+ gen_ugen(io, plugin.name, "UGen.AR", "args", plugin.outputs)
+ end
+
+ protected
+ def mk_args(n, x="x")
+ (1..n).collect { |i| "#{x}#{i}" }
+ end
+ end # PluginGenerator
+
+ class Generator < Faust::Generator
+ def initialize(plugins, options)
+ super(plugins, options)
+ @module = options["prefix"]
+ end
+ def lang
+ "haskell"
+ end
+ def generate_header(io)
+ gen_module(io, plugins.collect { |p| Haskell.mk_function_names(p) }.flatten1)
+ io << "\n"
+ gen_imports(io)
+ io << "\n"
+ end
+ def generate_plugin(io, plugin)
+ PluginGenerator.new(plugin).generate(io)
+ end
+ def gen_module(io, exports)
+ #m = @module.empty? ? "" : @module + "."
+ #io << "module #{m}#{plugin.name.encapitalize} (\n"
+ io << "module #{@module.empty? ? "Main" : @module} (\n"
+ io << exports.collect { |x| (INDENT * 1) + x }.join(",\n") << "\n"
+ io << ") where\n"
+ end
+ def gen_imports(io)
+ io << "import Sound.SC3.UGen (UGen)\n"
+ io << "import qualified Sound.SC3.UGen as UGen\n"
+ end
+ end
+ end
+
+ module SC3
+ include Language
+
+ CLASS_REGEXP = /^[A-Z][a-zA-Z0-9_]*[a-zA-Z0-9]?$/
+
+ def path_to_unitname(path)
+ name = File.basename(path)
+ if ext_index = name.index(".")
+ name = name[0..ext_index-1]
+ end
+ name
+ end
+ def make_class_name(unit_name, prefix)
+ # The SuperCollider UGen class name generated here must match
+ # that generated in the Faust architecture file supercollider.cpp
+ if prefix == ""
+ prefix = "Faust"
+ end
+ class_name = unit_name
+ class_name = class_name.sub(/^#{prefix}/i, '')
+ class_name = prefix + '_' + class_name
+ cna = class_name.split(/[^0-9a-z]/i)
+ cna.each_index { |i| cna[i] = cna[i].encapitalize } # SC name convention
+ class_name = cna.join
+ print_info(unit_name + " -> " + class_name + "\n")
+ if class_name.length > 31 # maximum SC Node ID length is 31 (hashed)
+ print_info("Class name `#{class_name}' truncated to 1st 31 chars\n")
+ class_name = class_name[0,30]
+ end
+ unless class_name =~ CLASS_REGEXP
+ raise "invalid class name: \"#{class_name}\""
+ end
+ class_name
+ end
+ module_function :path_to_unitname, :make_class_name
+
+ class Faust::Widget
+ def sc3_identifier
+ l = self.label
+ l = l.gsub(/\([^\)]*\)/, '')
+ l = Language.make_identifier(l)
+ if l.length > 30 # maximum SC ParamSpec length is 31 (hashed)
+ lt = l[0,29] # leave a final char for make_unique
+ print_info("Label `#{l}' for #{self.type} #{self.id} truncated to " +
+ "`#{lt}' (30 chars)\n")
+ l = lt
+ end
+ l
+ end
+ def sc3_arg_string
+ "#{self.sc3_identifier}(#{self.init})"
+ end
+ def sc3_default
+ "(#{self.init})"
+ end
+ def sc3_default2
+ "=(#{self.init})" # Parens make unary minus work in SC
+ end
+ end
+
+ class PluginGenerator
+ attr_reader :unit_name, :class_name
+ def initialize(plugin, options)
+ @plugin = plugin
+ @options = options
+ @unit_name = plugin.name || SC3::path_to_unitname(plugin.path)
+ @class_name = SC3::make_class_name(@unit_name, options["prefix"])
+ end
+ def inputs
+ @plugin.inputs
+ end
+ def outputs
+ @plugin.outputs
+ end
+ def superclass_name
+ @plugin.outputs > 1 ? "MultiOutUGen" : "UGen"
+ end
+ def input_names
+ (1..self.inputs).collect { |i| "in#{i}" }
+ end
+ def control_names
+ Language::make_unique(@plugin.ui.active_widgets.collect { |x| x.sc3_identifier })
+ end
+ def decl_args # "name(default)"
+ cnames = self.control_names
+ cdefaults = @plugin.ui.active_widgets.collect { |x| x.sc3_default }
+ args = self.input_names + cnames.zip(cdefaults).collect { |ary| ary[0] + ary[1] }
+ args.empty? ? "" : " | " + args.join(", ") + " |"
+ end
+ def decl_args2 # "name=default"
+ cnames = self.control_names
+ cdefaults = @plugin.ui.active_widgets.collect { |x| x.sc3_default2 }
+ args = self.input_names + cnames.zip(cdefaults).collect { |ary| ary[0] + ary[1] }
+ args.empty? ? "" : args.join(", ") + ";"
+ end
+ def decl_args3 # args for SynthDef
+ cnames = self.control_names
+ cdefaults = @plugin.ui.active_widgets.collect { |x| x.sc3_default }
+ args = self.input_names.collect { |x| "\\#{x}.ar(0)" } \
+ + cnames.zip(cdefaults).collect { |x| "\\#{x[0]}.kr#{x[1]}" }
+ args.empty? ? "" : args.join(", ")
+ end
+ def decl_buses # declare input buses for Synth
+ args = self.input_names.collect { |x| \
+ " #{x}Bus = Bus.audio(s,1);\n"};
+ end
+ def decl_args4 # args for Synth
+ cnames = self.control_names
+ cdefaults = @plugin.ui.active_widgets.collect { |x| x.sc3_default }
+ args = self.input_names.collect { |x| "#{x}:#{x}Bus.asMap"} \
+ + cnames.collect { |x| "#{x}:#{x}Var" }
+ args.empty? ? "" : "\n\t[\t" + args.join(",\n\t\t") + "\n\t]"
+ end
+ def decl_metadata
+ cnames = self.control_names
+ cnames.collect! {|x| " \\"+x+":"}
+ warp = 0
+ cmeta = @plugin.ui.active_widgets.collect \
+ { |x| "[#{x.min}, #{x.max}, #{warp}, #{x.step}, #{x.init}].asSpec" }
+ # \\name1: [minval, maxval, warp, step, default, units].asSpec,
+ # Note: could append x.units as well
+ args = cnames.zip(cmeta).collect { |ary| ary[0] + ary[1] }
+ args.empty? ? "" : args.join(",\n ")
+ end
+ def new_args(rate)
+ ["'%s'" % rate] + self.input_names + self.control_names
+ end
+ def validate
+ args = self.input_names + self.control_names
+ unless args.uniq == args
+ raise "argument list not unique"
+ end
+ self
+ end
+ def generate(io)
+ self.validate
+ generate_decl(io)
+ generate_body(io)
+ end
+ def generate_decl(io)
+ io.print("#{@class_name} : #{self.superclass_name}\n")
+ print_info("UGen: #{@class_name}\n")
+ end
+ def generate_body(io)
+ io.print("{\n")
+ body = <<EOF
+ *ar {#{self.decl_args}
+ ^this.multiNew(#{self.new_args(:audio).join(", ")})
+ }
+
+ *kr {#{self.decl_args}
+ ^this.multiNew(#{self.new_args(:control).join(", ")})
+ }
+EOF
+ if self.inputs > 0
+ body = body + <<EOF
+
+ checkInputs {
+ if (rate == 'audio', {
+ #{self.inputs}.do({|i|
+ if (inputs.at(i).rate != 'audio', {
+ ^(" input at index " + i + "(" + inputs.at(i) +
+ ") is not audio rate");
+ });
+ });
+ });
+ ^this.checkValidInputs
+ }
+EOF
+ end
+ io.print(body)
+ generate_outputs(io)
+ if @options["synthdef"]
+ generate_synthdef(io)
+ end
+ io.print("\n name { ^\"#{@class_name}\" }\n")
+ io.print("}\n")
+ end
+ def generate_outputs(io)
+ if self.outputs > 1 # add initOutputs to overridden init:
+ io.print <<EOF
+
+ init { | ... theInputs |
+ inputs = theInputs
+ ^this.initOutputs(#{self.outputs}, rate)
+ }
+EOF
+ end
+ end
+ def generate_synthdef(io)
+ s = @class_name
+ sdname = s[0,1].downcase + s[1 .. s.length]
+ print_info("SynthDef: \\#{sdname}\n")
+# if \arg.ar(0) form not used, add after out=0: ,#{self.decl_args2}
+ io.print <<EOF
+
+/*
+ SynthDef - Typical usage in SuperCollider:
+
+EOF
+ print_info("SynthDef: have #{self.input_names.size} inputs\n")
+ if self.input_names.size>0
+ io.print "#{decl_buses}\n";
+ end
+ io.print <<EOF
+ ~synth = Synth(\\#{sdname}, #{self.decl_args4});
+ */
+
+ *initClass {
+ StartUp.add {
+ SynthDesc.mdPlugin = TextArchiveMDPlugin;
+// When SynthDef.writeOnce writes metadata:
+// SynthDef.writeOnce(\\#{sdname},
+ SynthDef(\\#{sdname},
+ { |out=0|
+ Out.ar(out,
+ #{@class_name}.ar(
+ #{self.decl_args3}
+ )
+ )
+ }, metadata: (specs:(
+ //\\controlName:[min, max, warp, step, default, units].asSpec,
+ #{self.decl_metadata}
+ ) ) ).store } }
+// When SynthDef.writeOnce writes metadata:
+//) ) ) } }
+EOF
+ end
+ end
+
+ class Generator < Faust::Generator
+ def lang
+ "sclang"
+ end
+ def generate_plugin(io, plugin)
+ PluginGenerator.new(plugin, options).generate(io)
+ end
+ end
+ end # module SC3
+end # module Faust
+
+def usage
+ $stdout.print <<EOF
+Usage: #{File.basename($0)} [OPTION]... INPUT_FILE...
+
+Generate a language module file from FAUST generated XML.
+Currently supported languages are Haskell and SuperCollider.
+
+Options:
+ -h, --help Display this help
+ -l, --lang Set output language (haskell, sclang)
+ -o, --output Set output file name
+ -p, --prefix Set class or module prefix
+ -s, --synthdef Emit SynthDef including metadata (sclang)
+ -V, --version Display version information
+EOF
+end
+
+opts = GetoptLong.new(
+ [ "--help", "-h", GetoptLong::NO_ARGUMENT ],
+ [ "--lang", "-l", GetoptLong::REQUIRED_ARGUMENT ],
+ [ "--output", "-o", GetoptLong::REQUIRED_ARGUMENT ],
+ [ "--prefix", "-p", GetoptLong::REQUIRED_ARGUMENT ],
+ [ "--synthdef", "-s", GetoptLong::NO_ARGUMENT ],
+ [ "--version", "-V", GetoptLong::NO_ARGUMENT ]
+)
+
+LANG_MAP = {
+ "sclang" => Faust::SC3::Generator,
+ "haskell" => Faust::Haskell::Generator
+}
+
+lang = "sclang"
+generator = nil
+output_file = nil
+
+options = {
+ "prefix" => "",
+ "synthdef" => false
+}
+
+opts.each { | opt, arg |
+ case opt
+ when "--help"
+ usage
+ exit(0)
+ when "--lang"
+ lang = arg
+ when "--output"
+ output_file = arg
+ when "--prefix"
+ options["prefix"] = arg
+ options["module"] = arg
+ when "--synthdef"
+ options["synthdef"] = true
+ when "--version"
+ puts "#{PROGRAM} #{PROGRAM_VERSION}"
+ exit(0)
+ end
+}
+
+if LANG_MAP.key?(lang)
+ generator = LANG_MAP[lang]
+else
+ print_error("unknown output language #{lang}\n")
+ exit(1)
+end
+
+if output_file
+ output = File.open(output_file, "w")
+else
+ output = $stdout
+end
+
+plugins = ARGV.collect { |file|
+ begin
+ print_info("Parsing #{file} ...\n")
+ Faust::Plugin.from_file(file)
+ rescue
+ print_error("#{$!}\n")
+ print_error("Omitting #{file}\n")
+ end
+}
+
+begin
+ generator.new(plugins, options).generate(output)
+ensure
+ output.close unless output === $stdout
+end
+
+# EOF
projects / Faustine.git / blobdiff