frausto 0.2.0

data/lib/faust2ruby/lexer.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Faust2Ruby
+  # Lexer for Faust DSP source code.
+  # Uses StringScanner for efficient tokenization.
+  class Lexer
+    # Token struct for lexer output
+    Token = Struct.new(:type, :value, :line, :column, keyword_init: true)
+
+    # Keywords in Faust
+    KEYWORDS = %w[
+      import declare process with letrec where
+      par seq sum prod
+      case of
+      environment library component
+      inputs outputs
+    ].freeze
+
+    # Multi-character operators (must check before single-char)
+    MULTI_CHAR_OPS = {
+      "<:" => :SPLIT,
+      ":>" => :MERGE,
+      "==" => :EQ,
+      "!=" => :NEQ,
+      "<=" => :LE,
+      ">=" => :GE,
+      "<<" => :LSHIFT,
+      ">>" => :RSHIFT,
+      "=>" => :ARROW,
+    }.freeze
+
+    # Single-character operators and punctuation
+    SINGLE_CHAR_OPS = {
+      ":" => :SEQ,
+      "," => :PAR,
+      "~" => :REC,
+      "+" => :ADD,
+      "-" => :SUB,
+      "*" => :MUL,
+      "/" => :DIV,
+      "%" => :MOD,
+      "^" => :POW,
+      "@" => :DELAY,
+      "'" => :PRIME,
+      "=" => :DEF,
+      ";" => :ENDDEF,
+      "(" => :LPAREN,
+      ")" => :RPAREN,
+      "{" => :LBRACE,
+      "}" => :RBRACE,
+      "[" => :LBRACKET,
+      "]" => :RBRACKET,
+      "<" => :LT,
+      ">" => :GT,
+      "&" => :AND,
+      "|" => :OR,
+      "!" => :CUT,
+      "_" => :WIRE,
+      "." => :DOT,
+      "\\" => :LAMBDA,
+    }.freeze
+
+    attr_reader :tokens, :errors
+
+    def initialize(source)
+      @source = source
+      @scanner = StringScanner.new(source)
+      @tokens = []
+      @errors = []
+      @line = 1
+      @line_start = 0
+    end
+
+    def tokenize
+      until @scanner.eos?
+        token = next_token
+        @tokens << token if token
+      end
+      @tokens << Token.new(type: :EOF, value: nil, line: @line, column: current_column)
+      @tokens
+    end
+
+    private
+
+    def current_column
+      @scanner.pos - @line_start + 1
+    end
+
+    def next_token
+      skip_whitespace_and_comments
+
+      return nil if @scanner.eos?
+
+      start_line = @line
+      start_col = current_column
+
+      # Try to match each token type
+      token = try_string ||
+              try_number ||
+              try_multi_char_op ||
+              try_single_char_op ||
+              try_identifier
+
+      unless token
+        # Unknown character - report error and skip
+        char = @scanner.getch
+        @errors << "Unknown character '#{char}' at line #{start_line}, column #{start_col}"
+        return nil
+      end
+
+      token
+    end
+
+    def skip_whitespace_and_comments
+      loop do
+        # Skip whitespace, tracking newlines
+        while @scanner.scan(/[ \t]+/) || @scanner.scan(/\r?\n/)
+          if @scanner.matched.include?("\n")
+            @line += 1
+            @line_start = @scanner.pos
+          end
+        end
+
+        # Skip line comments
+        if @scanner.scan(%r{//[^\n]*})
+          next
+        end
+
+        # Skip block comments
+        if @scanner.scan(%r{/\*})
+          depth = 1
+          until depth.zero? || @scanner.eos?
+            if @scanner.scan(%r{/\*})
+              depth += 1
+            elsif @scanner.scan(%r{\*/})
+              depth -= 1
+            elsif @scanner.scan(/\n/)
+              @line += 1
+              @line_start = @scanner.pos
+            else
+              @scanner.getch
+            end
+          end
+          next
+        end
+
+        break
+      end
+    end
+
+    def try_string
+      start_line = @line
+      start_col = current_column
+
+      # Double-quoted string
+      if @scanner.scan(/"/)
+        value = String.new
+        until @scanner.eos?
+          if @scanner.scan(/\\(.)/)
+            # Escape sequence
+            case @scanner[1]
+            when "n" then value << "\n"
+            when "t" then value << "\t"
+            when "r" then value << "\r"
+            when "\\" then value << "\\"
+            when '"' then value << '"'
+            else value << @scanner[1]
+            end
+          elsif @scanner.scan(/"/)
+            return Token.new(type: :STRING, value: value, line: start_line, column: start_col)
+          elsif @scanner.scan(/[^"\\]+/)
+            value << @scanner.matched
+          else
+            break
+          end
+        end
+        @errors << "Unterminated string at line #{start_line}, column #{start_col}"
+        return Token.new(type: :STRING, value: value, line: start_line, column: start_col)
+      end
+
+      nil
+    end
+
+    def try_number
+      start_line = @line
+      start_col = current_column
+
+      # Float with optional exponent
+      if @scanner.scan(/\d+\.\d+([eE][+-]?\d+)?/)
+        return Token.new(type: :FLOAT, value: @scanner.matched.to_f, line: start_line, column: start_col)
+      end
+
+      # Float with exponent (no decimal point)
+      if @scanner.scan(/\d+[eE][+-]?\d+/)
+        return Token.new(type: :FLOAT, value: @scanner.matched.to_f, line: start_line, column: start_col)
+      end
+
+      # Integer
+      if @scanner.scan(/\d+/)
+        return Token.new(type: :INT, value: @scanner.matched.to_i, line: start_line, column: start_col)
+      end
+
+      nil
+    end
+
+    def try_multi_char_op
+      start_line = @line
+      start_col = current_column
+
+      MULTI_CHAR_OPS.each do |op, type|
+        if @scanner.scan(Regexp.new(Regexp.escape(op)))
+          return Token.new(type: type, value: op, line: start_line, column: start_col)
+        end
+      end
+
+      nil
+    end
+
+    def try_single_char_op
+      start_line = @line
+      start_col = current_column
+
+      char = @scanner.peek(1)
+      if SINGLE_CHAR_OPS.key?(char)
+        @scanner.getch
+        return Token.new(type: SINGLE_CHAR_OPS[char], value: char, line: start_line, column: start_col)
+      end
+
+      nil
+    end
+
+    def try_identifier
+      start_line = @line
+      start_col = current_column
+
+      # Identifiers: start with letter or underscore (but not just _)
+      # Allow dots for qualified names like os.osc
+      if @scanner.scan(/[a-zA-Z_][a-zA-Z0-9_]*/)
+        value = @scanner.matched
+
+        # Check if it's a keyword
+        if KEYWORDS.include?(value)
+          type = value.upcase.to_sym
+          return Token.new(type: type, value: value, line: start_line, column: start_col)
+        end
+
+        return Token.new(type: :IDENT, value: value, line: start_line, column: start_col)
+      end
+
+      nil
+    end
+  end
+end

data/lib/faust2ruby/library_mapper.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Faust2Ruby
+  # Maps Faust library function calls to Ruby2Faust NodeTypes and DSL methods.
+  module LibraryMapper
+    # Mapping from Faust function names to Ruby DSL info
+    # Each entry: faust_name => { type: NodeType, dsl: method_name, args: arg_count }
+    MAPPINGS = {
+      # Oscillators (os.)
+      "os.osc" => { dsl: :osc, args: 1 },
+      "os.sawtooth" => { dsl: :saw, args: 1 },
+      "os.square" => { dsl: :square, args: 1 },
+      "os.triangle" => { dsl: :triangle, args: 1 },
+      "os.phasor" => { dsl: :phasor, args: 2 },
+      "os.lf_sawpos" => { dsl: :lf_saw, args: 1 },
+      "os.lf_trianglepos" => { dsl: :lf_triangle, args: 1 },
+      "os.lf_squarewavepos" => { dsl: :lf_square, args: 1 },
+      "os.lf_imptrain" => { dsl: :imptrain, args: 1 },
+      "os.lf_pulsetrain" => { dsl: :pulsetrain, args: 2 },
+
+      # Noise (no.)
+      "no.noise" => { dsl: :noise, args: 0 },
+      "no.pink_noise" => { dsl: :pink_noise, args: 0 },
+
+      # Filters (fi.)
+      "fi.lowpass" => { dsl: :lp, args: 2, opts: { order: 0 } },
+      "fi.highpass" => { dsl: :hp, args: 2, opts: { order: 0 } },
+      "fi.bandpass" => { dsl: :bp, args: 3 },
+      "fi.resonlp" => { dsl: :resonlp, args: 3 },
+      "fi.resonhp" => { dsl: :resonhp, args: 3 },
+      "fi.resonbp" => { dsl: :resonbp, args: 3 },
+      "fi.allpass_comb" => { dsl: :allpass, args: 3 },
+      "fi.dcblocker" => { dsl: :dcblock, args: 0 },
+      "fi.peak_eq" => { dsl: :peak_eq, args: 3 },
+
+      # SVF (State Variable Filter) (fi.svf.)
+      "fi.svf.lp" => { dsl: :svf_lp, args: 2 },
+      "fi.svf.hp" => { dsl: :svf_hp, args: 2 },
+      "fi.svf.bp" => { dsl: :svf_bp, args: 2 },
+      "fi.svf.notch" => { dsl: :svf_notch, args: 2 },
+      "fi.svf.ap" => { dsl: :svf_ap, args: 2 },
+      "fi.svf.bell" => { dsl: :svf_bell, args: 3 },
+      "fi.svf.ls" => { dsl: :svf_ls, args: 3 },
+      "fi.svf.hs" => { dsl: :svf_hs, args: 3 },
+
+      # Other filters (fi.)
+      "fi.lowpass3e" => { dsl: :lowpass3e, args: 1 },
+      "fi.highpass3e" => { dsl: :highpass3e, args: 1 },
+      "fi.lowpass6e" => { dsl: :lowpass6e, args: 1 },
+      "fi.highpass6e" => { dsl: :highpass6e, args: 1 },
+      "fi.bandstop" => { dsl: :bandstop, args: 3 },
+      "fi.notchw" => { dsl: :notchw, args: 2 },
+      "fi.low_shelf" => { dsl: :low_shelf, args: 3 },
+      "fi.high_shelf" => { dsl: :high_shelf, args: 3 },
+      "fi.peak_eq_cq" => { dsl: :peak_eq_cq, args: 3 },
+      "fi.pole" => { dsl: :fi_pole, args: 1 },
+      "fi.zero" => { dsl: :fi_zero, args: 1 },
+      "fi.tf1" => { dsl: :tf1, args: 3 },
+      "fi.tf2" => { dsl: :tf2, args: 5 },
+      "fi.tf1s" => { dsl: :tf1s, args: 3 },
+      "fi.tf2s" => { dsl: :tf2s, args: 5 },
+      "fi.iir" => { dsl: :iir, args: 2 },
+      "fi.fir" => { dsl: :fir, args: 1 },
+      "fi.conv" => { dsl: :conv, args: 2 },
+      "fi.fbcombfilter" => { dsl: :fbcombfilter, args: 3 },
+      "fi.ffcombfilter" => { dsl: :ffcombfilter, args: 2 },
+
+      # Delays (de.)
+      "de.delay" => { dsl: :delay, args: 2 },
+      "de.fdelay" => { dsl: :fdelay, args: 2 },
+      "de.sdelay" => { dsl: :sdelay, args: 3 },
+
+      # Envelopes (en.)
+      "en.ar" => { dsl: :ar, args: 3 },
+      "en.asr" => { dsl: :asr, args: 4 },
+      "en.adsr" => { dsl: :adsr, args: 5 },
+      "en.adsre" => { dsl: :adsre, args: 5 },
+
+      # Conversion (ba.)
+      "ba.db2linear" => { dsl: :db2linear, args: 1 },
+      "ba.linear2db" => { dsl: :linear2db, args: 1 },
+      "ba.samp2sec" => { dsl: :samp2sec, args: 1 },
+      "ba.sec2samp" => { dsl: :sec2samp, args: 1 },
+      "ba.midikey2hz" => { dsl: :midi2hz, args: 1 },
+      "ba.hz2midikey" => { dsl: :hz2midi, args: 1 },
+      "ba.selectn" => { dsl: :selectn, args: :variadic },
+      "ba.tau2pole" => { dsl: :tau2pole, args: 1 },
+      "ba.pole2tau" => { dsl: :pole2tau, args: 1 },
+      "ba.if" => { dsl: :ba_if, args: 3 },
+      "ba.selector" => { dsl: :selector, args: 3 },
+      "ba.selectmulti" => { dsl: :selectmulti, args: :variadic },
+      "ba.count" => { dsl: :ba_count, args: :variadic },
+      "ba.take" => { dsl: :ba_take, args: 2 },
+
+      # Smoothing (si.)
+      "si.smooth" => { dsl: :smooth, args: 1 },
+      "si.smoo" => { dsl: :smoo, args: 0 },
+      "si.bus" => { dsl: :bus, args: 1 },
+      "si.block" => { dsl: :block, args: 1 },
+
+      # Reverbs (re.)
+      "re.mono_freeverb" => { dsl: :freeverb, args: 4 },
+      "re.zita_rev1_stereo" => { dsl: :zita_rev, args: 6 },
+      "re.jpverb" => { dsl: :jpverb, args: 11 },
+
+      # Compressors (co.)
+      "co.compressor_mono" => { dsl: :compressor, args: 4 },
+      "co.limiter_1176_R4_mono" => { dsl: :limiter, args: 0 },
+
+      # Spatial (sp.)
+      "sp.panner" => { dsl: :panner, args: 1 },
+
+      # Math (ma.)
+      "ma.SR" => { dsl: :sr, args: 0 },
+      "ma.PI" => { dsl: :pi, args: 0 },
+      "ma.tempo" => { dsl: :tempo, args: 0 },
+      "ma.tanh" => { dsl: :tanh_, args: 0 },
+
+      # Antialiasing (aa.)
+      "aa.tanh1" => { dsl: :aa_tanh1, args: 0 },
+      "aa.tanh2" => { dsl: :aa_tanh2, args: 0 },
+      "aa.arctan" => { dsl: :aa_arctan, args: 0 },
+      "aa.softclip" => { dsl: :aa_softclip, args: 0 },
+      "aa.hardclip" => { dsl: :aa_hardclip, args: 0 },
+      "aa.parabolic" => { dsl: :aa_parabolic, args: 0 },
+      "aa.sin" => { dsl: :aa_sin, args: 0 },
+      "aa.cubic1" => { dsl: :aa_cubic1, args: 0 },
+      "aa.cubic2" => { dsl: :aa_cubic2, args: 0 },
+
+      # Analyzers (an.)
+      "an.amp_follower" => { dsl: :amp_follower, args: 1 },
+      "an.amp_follower_ar" => { dsl: :amp_follower_ar, args: 2 },
+      "an.amp_follower_ud" => { dsl: :amp_follower_ud, args: 2 },
+      "an.rms_envelope_rect" => { dsl: :rms_envelope_rect, args: 1 },
+      "an.rms_envelope_tau" => { dsl: :rms_envelope_tau, args: 1 },
+      "an.abs_envelope_rect" => { dsl: :abs_envelope_rect, args: 1 },
+      "an.abs_envelope_tau" => { dsl: :abs_envelope_tau, args: 1 },
+      "an.ms_envelope_rect" => { dsl: :ms_envelope_rect, args: 1 },
+      "an.ms_envelope_tau" => { dsl: :ms_envelope_tau, args: 1 },
+      "an.peak_envelope" => { dsl: :peak_envelope, args: 1 },
+
+      # Effects (ef.)
+      "ef.cubicnl" => { dsl: :cubicnl, args: 2 },
+      "ef.gate_mono" => { dsl: :gate_mono, args: 4 },
+      "ef.gate_stereo" => { dsl: :gate_stereo, args: 4 },
+      "ef.compressor_mono" => { dsl: :ef_compressor_mono, args: 4 },
+      "ef.compressor_stereo" => { dsl: :ef_compressor_stereo, args: 4 },
+      "ef.limiter_1176_R4_mono" => { dsl: :ef_limiter_1176_mono, args: 0 },
+      "ef.limiter_1176_R4_stereo" => { dsl: :ef_limiter_1176_stereo, args: 0 },
+      "ef.echo" => { dsl: :echo, args: 3 },
+      "ef.transpose" => { dsl: :transpose, args: 3 },
+      "ef.flanger_mono" => { dsl: :flanger_mono, args: 5 },
+      "ef.flanger_stereo" => { dsl: :flanger_stereo, args: 7 },
+      "ef.phaser2_mono" => { dsl: :phaser2_mono, args: 6 },
+      "ef.phaser2_stereo" => { dsl: :phaser2_stereo, args: 6 },
+      "ef.wah4" => { dsl: :wah4, args: 1 },
+      "ef.auto_wah" => { dsl: :auto_wah, args: 1 },
+      "ef.crybaby" => { dsl: :crybaby, args: 1 },
+      "ef.vocoder" => { dsl: :vocoder, args: 2 },
+      "ef.speakerbp" => { dsl: :speakerbp, args: 2 },
+      "ef.dryWetMixer" => { dsl: :dry_wet_mixer, args: 1 },
+      "ef.dryWetMixerConstantPower" => { dsl: :dry_wet_mixer_cp, args: 1 },
+    }.freeze
+
+    # Primitive functions that map directly to DSL
+    PRIMITIVES = {
+      # Math operators (used as functions)
+      "abs" => { dsl: :abs_, args: 0 },
+      "min" => { dsl: :min_, args: 2 },
+      "max" => { dsl: :max_, args: 2 },
+      "pow" => { dsl: :pow, args: 2 },
+      "sqrt" => { dsl: :sqrt_, args: 0 },
+      "exp" => { dsl: :exp_, args: 0 },
+      "log" => { dsl: :log_, args: 0 },
+      "log10" => { dsl: :log10_, args: 0 },
+      "sin" => { dsl: :sin_, args: 0 },
+      "cos" => { dsl: :cos_, args: 0 },
+      "tan" => { dsl: :tan_, args: 0 },
+      "tanh" => { dsl: :tanh_, args: 0 },
+      "asin" => { dsl: :asin_, args: 0 },
+      "acos" => { dsl: :acos_, args: 0 },
+      "atan" => { dsl: :atan_, args: 0 },
+      "atan2" => { dsl: :atan2, args: 2 },
+      "sinh" => { dsl: :sinh_, args: 0 },
+      "cosh" => { dsl: :cosh_, args: 0 },
+      "asinh" => { dsl: :asinh_, args: 0 },
+      "acosh" => { dsl: :acosh_, args: 0 },
+      "atanh" => { dsl: :atanh_, args: 0 },
+      "floor" => { dsl: :floor_, args: 0 },
+      "ceil" => { dsl: :ceil_, args: 0 },
+      "rint" => { dsl: :rint_, args: 0 },
+      "fmod" => { dsl: :fmod, args: 2 },
+      "int" => { dsl: :int_, args: 0 },
+      "float" => { dsl: :float_, args: 0 },
+
+      # Tables
+      "rdtable" => { dsl: :rdtable, args: 3 },
+      "rwtable" => { dsl: :rwtable, args: 5 },
+
+      # Selectors
+      "select2" => { dsl: :select2, args: 3 },
+      "select3" => { dsl: :select3, args: 4 },
+
+      # Primitives
+      "mem" => { dsl: :mem, args: 0 },
+    }.freeze
+
+    # UI element types
+    UI_ELEMENTS = {
+      "hslider" => :slider,
+      "vslider" => :vslider,
+      "nentry" => :nentry,
+      "button" => :button,
+      "checkbox" => :checkbox,
+    }.freeze
+
+    UI_GROUPS = {
+      "hgroup" => :hgroup,
+      "vgroup" => :vgroup,
+      "tgroup" => :tgroup,
+    }.freeze
+
+    module_function
+
+    def lookup(name)
+      MAPPINGS[name] || PRIMITIVES[name]
+    end
+
+    def ui_element?(name)
+      UI_ELEMENTS.key?(name)
+    end
+
+    def ui_group?(name)
+      UI_GROUPS.key?(name)
+    end
+
+    def ui_element_method(name)
+      UI_ELEMENTS[name]
+    end
+
+    def ui_group_method(name)
+      UI_GROUPS[name]
+    end
+
+    def known_function?(name)
+      MAPPINGS.key?(name) || PRIMITIVES.key?(name)
+    end
+  end
+end