New lexer: lustre

lib/rouge/demos/lustre

@@ -0,0 +1,54 @@
+const nbtrains = 3;
+
+node switch(init, set, reset: bool) returns (state: bool);
+-- from an initial value (init), the state is set to true or reset to false
+-- and keeps its previous value otherwise
+let
+	state = init -> if set and not pre(state) then true
+                   else if reset and pre(state) then false
+                   else pre(state);
+tel;
+
+node count(init: int; reset, event: bool) returns (c: int);
+let
+	c = init -> if reset then init
+					else if event then pre(c)+1
+					else pre(c);
+tel;
+
+node train (s,b: bool) 
+returns (ontime, onbrake, late,  stopped: bool);
+-- a train receives signals "second" and "beacon" (assumed to be exclusive)
+-- and returns its state.
+var delta, nbrake: int;
+let
+	assert #(s,b);
+	assert (true -> (pre(stopped) => not b));
+	-- delta = nb_seconds - nb_beacons
+	delta = 0 -> pre(delta) +
+					if s then 1 else if b then -1 else 0;
+	ontime = true -> not (late or onbrake or stopped);
+	late = switch(false, delta>=10, delta<=0);
+	-- counting beacons when on-brake or stopped
+	nbrake = count(0, not(onbrake or stopped), b);
+	--early = onbrake or stopped;
+	onbrake = switch(false, delta<=-10 and pre(nbrake)<10, delta>=0 or pre(nbrake)>= 10);
+	stopped = switch(false, pre(onbrake) and pre(nbrake)>= 10, delta>=0);
+tel;
+
+node clock (late: bool^nbtrains; ss: bool) returns (s: bool);
+-- the clock broadcasts the "second" only when no train is late
+var 
+  onelatetrain: bool;
+let
+	onelatetrain = red<<or;nbtrains>>(false, late); 
+	s = if onelatetrain then false else ss;
+tel
+
+node metro (sec: bool; beacons: bool^nbtrains)
+returns (ontime, onbrake, late,  stopped: bool^nbtrains);
+var second : bool;
+let
+	second = clock(late, sec);
+	(ontime, onbrake, late,  stopped) = map<<train;nbtrains>> (sec^nbtrains, beacons);
+tel

lib/rouge/demos/lutin

@@ -0,0 +1,29 @@
+-- Some of the examples provided in [SIES'13] "Engineering Functional
+-- Requirements of Reactive Systems using Synchronous Languages"
+
+let inertia=0.6
+node gen_x_v2() returns (x:real) = loop { 0.0<x and x<42.0 fby loop [20] x = pre x }
+
+node gen_x_v4()  returns (target:real; x:real=0.0) =
+  run target := gen_x_v2() in
+  exist px,ppx : real = 0.0 in
+  loop { 
+      px = pre x and ppx = pre px and
+      x = (px+target) / 2.0+inertia*(px-ppx) 
+  }
+
+-- saw-tooth curves
+let  Between(x, min, max : real) : bool = ((min < x) and (x < max))
+
+node up(init, delta:real) returns( x : real) = 
+   x = init fby loop { Between(x, pre x, pre x + delta) }
+node down(init, delta:real) returns( x : real) = 
+   x = init fby loop { Between(x, pre x - delta, pre x) }
+
+node up_and_down(min, max, delta : real) returns (x : real) =   
+   Between(x, min, max)
+ fby
+   loop {
+        | run x := up(pre x, delta)   in loop { x < max }
+        | run x := down(pre x, delta) in loop { x > min }
+       }

lib/rouge/lexers/lustre.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*- #
+#
+# adapted from ocaml.rb, hence some ocaml-ism migth remains
+module Rouge
+  module Lexers
+    class Lustre < RegexLexer
+      title "Lustre"
+      desc 'The Lustre programming language (Verimag)'
+      tag 'lustre'
+      filenames '*.lus'
+      mimetypes 'text/x-lustre'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          extern unsafe assert const current enum function
+          false let node operator returns
+          step struct tel type true var  model package needs
+          provides uses is body end include merge
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(
+           div and xor mod or not nor if then else fby pre when with) 
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(int real bool)
+      end
+
+      operator = %r([;,_!$%&*+./:<=>?@^|~#-]+)
+      id = /[a-z_][\w']*/i
+
+      state :root do
+        rule /\s+/m, Text
+        rule /false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
+        rule %r(\-\-.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        rule id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.primitives.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule /[(){}\[\];]+/, Punctuation
+        rule operator, Operator
+
+        rule /-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule /0x\h[\h_]*/i, Num::Hex
+        rule /0o[0-7][0-7_]*/i, Num::Oct
+        rule /0b[01][01_]*/i, Num::Bin
+        rule /\d[\d_]*/, Num::Integer
+
+        rule /'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule /'[.]'/, Str::Char
+        rule /'/, Keyword
+        rule /"/, Str::Double, :string
+        rule /[~?]#{id}/, Name::Variable
+      end
+
+      state :string do
+        rule /[^\\"]+/, Str::Double
+        mixin :escape_sequence
+        rule /\\\n/, Str::Double
+        rule /"/, Str::Double, :pop!
+      end
+
+      state :escape_sequence do
+        rule /\\[\\"'ntbr]/, Str::Escape
+        rule /\\\d{3}/, Str::Escape
+        rule /\\x\h{2}/, Str::Escape
+      end
+
+      state :dotted do
+        rule /\s+/m, Text
+        rule /[.]/, Punctuation
+        rule id, Name, :pop!
+        rule /[({\[]/, Punctuation, :pop!
+      end
+    end
+  end
+end

lib/rouge/lexers/lutin.rb

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*- #
+#
+# adapted from lustre.rf (adapted from ocaml.rb), hence some ocaml-ism migth remains
+module Rouge
+  module Lexers
+    class Lutin < RegexLexer
+      title "Lutin"
+      desc 'The Lutin programming language (Verimag)'
+      tag 'lutin'
+      filenames '*.lut'
+      mimetypes 'text/x-lutin'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          let in node extern system returns weak strong assert raise try catch
+          trap do exist erun run type ref exception include false true 
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(
+           div and xor mod or not nor if then else pre) 
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(int real bool trace loop fby)
+      end
+
+      operator = %r([;,_!$%&*+./:<=>?@^|~#-]+)
+      id = /[a-z_][\w']*/i
+
+      state :root do
+        rule /\s+/m, Text
+        rule /false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
+        rule %r(\-\-.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        rule id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.primitives.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule /[(){}\[\];]+/, Punctuation
+        rule operator, Operator
+
+        rule /-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule /0x\h[\h_]*/i, Num::Hex
+        rule /0o[0-7][0-7_]*/i, Num::Oct
+        rule /0b[01][01_]*/i, Num::Bin
+        rule /\d[\d_]*/, Num::Integer
+
+        rule /'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule /'[.]'/, Str::Char
+        rule /'/, Keyword
+        rule /"/, Str::Double, :string
+        rule /[~?]#{id}/, Name::Variable
+      end
+
+      state :string do
+        rule /[^\\"]+/, Str::Double
+        mixin :escape_sequence
+        rule /\\\n/, Str::Double
+        rule /"/, Str::Double, :pop!
+      end
+
+      state :escape_sequence do
+        rule /\\[\\"'ntbr]/, Str::Escape
+        rule /\\\d{3}/, Str::Escape
+        rule /\\x\h{2}/, Str::Escape
+      end
+
+      state :dotted do
+        rule /\s+/m, Text
+        rule /[.]/, Punctuation
+        rule id, Name, :pop!
+        rule /[({\[]/, Punctuation, :pop!
+      end
+    end
+  end
+end

spec/lexers/lustre_spec.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*- #
+
+describe Rouge::Lexers::Lustre do
+  let(:subject) { Rouge::Lexers::Lustre.new }
+
+  describe 'guessing' do
+    include Support::Guessing
+
+    it 'guesses by filename' do
+      assert_guess :filename => 'foo.lus'
+    end
+
+    it 'guesses by mimetype' do
+      assert_guess :mimetype => 'text/x-lustre'
+    end
+  end
+end
+

spec/lexers/lutin_step.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*- #
+
+describe Rouge::Lexers::Lutin do
+  let(:subject) { Rouge::Lexers::Lutin.new }
+
+  describe 'guessing' do
+    include Support::Guessing
+
+    it 'guesses by filename' do
+      assert_guess :filename => 'foo.lut'
+    end
+
+    it 'guesses by mimetype' do
+      assert_guess :mimetype => 'text/x-lutin'
+    end
+  end
+end
+