HDLRuby 2.6.25 → 2.7.11

data/lib/HDLRuby/hruby_high.rb

@@ -133,6 +133,8 @@ module HDLRuby::High
     module Hmissing
         High = HDLRuby::High
 
+        NAMES = { }
+
         # Missing methods may be immediate values, if not, they are looked up
         # in the upper level of the namespace if any.
         def method_missing(m, *args, &ruby_block)
@@ -140,6 +142,20 @@ module HDLRuby::High
             # Is the missing method an immediate value?
             value = m.to_value
             return value if value and args.empty?
+            # Or is it a uniq name generator?
+            if (m[-1] == '?') then
+                # Yes
+                m = m[0..-2]
+                return NAMES[m] = HDLRuby.uniq_name(m)
+            end
+            # Is in a previous uniq name?
+            if (m[-1] == '!') then
+                pm = m[0..-2]
+                if NAMES.key?(pm) then
+                    # Yes, returns the current corresponding uniq name.
+                    return self.send(NAMES[pm],*args,&ruby_block)
+                end
+            end
             # No, is there an upper namespace, i.e. is the current object
             # present in the space?
             if High.space_index(self) then
@@ -256,9 +272,9 @@ module HDLRuby::High
                                     SignalI.new(name,type,:inner))
                             elsif name.is_a?(Hash) then
                                 # Names associated with values.
-                                names.each do |name,value|
+                                name.each do |key,value|
                                     res = self.add_inner(
-                                        SignalI.new(name,type,:inner,value))
+                                        SignalI.new(key,type,:inner,value))
                                 end
                             else
                                 raise AnyError,
@@ -550,10 +566,14 @@ module HDLRuby::High
             expanded = self.class.new(name.to_s) {}
             # Include the mixin systems given when declaring the system.
             @to_includes.each { |system| expanded.scope.include(system) }
+            # Include the previously includeds. */
+            self.scope.each_included { |system| expanded.scope.include(system) }
 
             # Sets the generators of the expanded result.
             expanded.add_generator(self)
             @to_includes.each { |system| expanded.add_generator(system) }
+            # Also for the previously includeds. */
+            self.scope.each_included.each { |system| expanded.add_generator(system) }
 
             # Fills the scope of the expanded class.
             # puts "Build top with #{self.name} for #{name}"
@@ -828,8 +848,7 @@ module HDLRuby::High
             # Initialize the set of included systems.
             @includes = {}
 
-            # Builds the scope if a ruby block is provided
-            # (which means the scope is not the top of a system).
+            # Builds the scope if a ruby block is provided.
             self.build(&ruby_block) if block_given?
         end
 
@@ -940,18 +959,20 @@ module HDLRuby::High
             # Set the namespace for buidling the scope.
             High.space_push(@namespace)
             # Build the scope.
-            # @return_value = High.top_user.instance_eval(&ruby_block)
-            res = High.top_user.instance_eval(&ruby_block)
+            @return_value = High.top_user.instance_eval(&ruby_block)
+            # res = High.top_user.instance_eval(&ruby_block)
             High.space_pop
-            # Now gain access to the result within the sub scope.
-            if (res.is_a?(HRef)) then
-                @return_value = res.type.inner(HDLRuby.uniq_name)
-                High.space_push(@namespace)
-                @return_value <= res
-                High.space_pop
-            else
-                @return_value = res
-            end
+            # # Now gain access to the result within the sub scope.
+            # # if (res.is_a?(HRef)) then
+            # if (res.is_a?(HExpression)) then
+            #     High.space_push(@namespace)
+            #     @return_value = res.type.inner(HDLRuby.uniq_name)
+            #     @return_value <= res
+            #     High.space_pop
+            #     @return_value = RefObject.new(self,@return_value)
+            # else
+            #     @return_value = res
+            # end
             # This will be the return value.
             @return_value
         end
@@ -1083,10 +1104,12 @@ module HDLRuby::High
         # Declares a sub scope with possible +name+ and built from +ruby_block+.
         def sub(name = :"", &ruby_block)
             # Creates the new scope.
-            scope = Scope.new(name,&ruby_block)
-            # puts "new scope=#{scope}"
+            # scope = Scope.new(name,&ruby_block)
+            scope = Scope.new(name)
             # Add it
             self.add_scope(scope)
+            # Build it.
+            scope.build(&ruby_block)
             # puts "self=#{self}"
             # puts "self scopes=#{self.each_scope.to_a.join(",")}"
             # Use its return value
@@ -1237,6 +1260,7 @@ module HDLRuby::High
             end
             # Adds it the list of includeds
             @includes[include_name] = system
+            # puts "@includes=#{@includes}"
             
         end
 
@@ -1960,9 +1984,6 @@ module HDLRuby::High
                                                          &ruby_block)
                     # ruby_block.call(*args)
                 end
-                # sub do
-                #     ruby_block.call(*args,*other_block)
-                # end
             end
         else
             define_method(name.to_sym) do |*args,&other_block|
@@ -1970,10 +1991,8 @@ module HDLRuby::High
                 sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
+                    # ruby_block.call(*args,*other_block)
                 end
-                # sub do
-                #     ruby_block.call(*args,*other_block)
-                # end
             end
         end
     end
@@ -2033,10 +2052,25 @@ module HDLRuby::High
                 connects.each do |key,value|
                     # Gets the signal corresponding to connect.
                     signal = self.get_signal(key)
+                    unless signal then
+                        # Look into the included systems.
+                        self.systemT.scope.each_included do |included|
+                            signal = included.get_signal(key)
+                            break if signal
+                        end
+                    end
                     # Check if it is an output.
                     isout = self.get_output(key)
+                    unless isout then
+                        # Look into the inlucded systems.
+                        self.systemT.scope.each_included do |included|
+                            isout = included.get_output(key)
+                            break if isout
+                        end
+                    end
                     # Convert it to a reference.
                     ref = RefObject.new(self.to_ref,signal)
+                    # puts "key=#{key} value=#{value} signal=#{signal} ref=#{ref}"
                     # Make the connection.
                     if isout then
                         value <= ref
@@ -2651,6 +2685,20 @@ module HDLRuby::High
         #
         # NOTE: +rng+ can be a single expression in which case it is an index.
         def [](rng)
+            if rng.is_a?(::Range) then
+                first = rng.first
+                if (first.is_a?(::Integer)) then
+                    first = self.type.size+first if first < 0
+                end
+                last = rng.last
+                if (last.is_a?(::Integer)) then
+                    last = self.type.size+last if last < 0
+                end
+                rng = first..last
+            end
+            if rng.is_a?(::Integer) && rng < 0 then
+                rng = self.type.size+rng
+            end
             if rng.respond_to?(:to_expr) then
                 # Number range: convert it to an expression.
                 rng = rng.to_expr
@@ -2987,6 +3035,7 @@ module HDLRuby::High
 
         # Creates a new reference from a +base+ reference and named +object+.
         def initialize(base,object)
+            # puts "New RefObjet with base=#{base}, object=#{object.name}"
             if object.respond_to?(:type) then
                 # Typed object, so typed reference.
                 super(object.type)
@@ -3023,7 +3072,7 @@ module HDLRuby::High
 
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
-            # puts "to_low with base=#{@base} @object=#{@object}"
+            # puts "to_low with base=#{@base} @object=#{@object.name}"
             refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                              @base.to_ref.to_low,@object.name)
             # # For debugging: set the source high object 
@@ -3081,7 +3130,8 @@ module HDLRuby::High
         # Converts to a new reference.
         def to_ref
             return RefIndex.new(self.type,
-                                self.ref.to_ref,self.index.to_expr)
+                                # self.ref.to_ref,self.index.to_expr)
+                                self.ref.to_expr,self.index.to_expr)
         end
 
         # Converts the index reference to HDLRuby::Low.
@@ -3496,7 +3546,8 @@ module HDLRuby::High
         # Converts the system to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
             # return HDLRuby::Low::SignalI.new(name,self.type.to_low)
-            signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low)
+            valueL = self.value ? self.value.to_low : nil
+            signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low,valueL)
             # # For debugging: set the source high object 
             # signalIL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = signalIL
@@ -3586,6 +3637,15 @@ module HDLRuby::High
             High.space_push(@namespace)
             @return_value = High.top_user.instance_eval(&ruby_block)
             High.space_pop
+            # if @return_value.is_a?(HExpression) then
+            #     res = @return_value
+            #     High.space_push(@namespace)
+            #     @return_value = res.type.inner(HDLRuby.uniq_name)
+            #     puts "@return_value name=#{@return_value.name}"
+            #     @return_value <= res
+            #     High.space_pop
+            #     @return_value = RefObject.new(self,@return_value)
+            # end
             @return_value
         end
 
@@ -3775,7 +3835,7 @@ module HDLRuby::High
         # Converts the block to HDLRuby::Low.
         def to_low
             # Create the resulting block
-            blockL = HDLRuby::Low::Block.new(self.mode)
+            blockL = HDLRuby::Low::Block.new(self.mode,self.name)
             # # For debugging: set the source high object 
             # blockL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = blockL

data/lib/HDLRuby/hruby_low.rb

@@ -4058,6 +4058,7 @@ module HDLRuby::Low
 
         # Adds inner signal +signal+.
         def add_inner(signal)
+            # puts "add inner=#{signal.name} in block=#{self}"
             # Check and add the signal.
             unless signal.is_a?(SignalI)
                 raise AnyError,
@@ -4087,6 +4088,7 @@ module HDLRuby::Low
 
         ## Gets an inner signal by +name+.
         def get_inner(name)
+            # puts "name=#{name}, inners=#{@inners.each_key.to_a}"
             return @inners[name.to_sym]
         end
         alias_method :get_signal, :get_inner
@@ -5342,7 +5344,8 @@ module HDLRuby::Low
         def initialize(type,ref,index)
             super(type)
             # Check and set the accessed reference.
-            unless ref.is_a?(Ref) then
+            # unless ref.is_a?(Ref) then
+            unless ref.is_a?(Expression) then
                 raise AnyError, "Invalid class for a reference: #{ref.class}."
             end
             @ref = ref

data/lib/HDLRuby/hruby_low2c.rb

@@ -356,8 +356,13 @@ module HDLRuby::Low
             end
             self.scope.each_block_deep do |block|
                 block.each_inner do |signal|
-                    # res << signal.value.to_ch if signal.value
-                    signal.value.to_ch(res) if signal.value
+                    # signal.value.to_ch(res) if signal.value
+                    if signal.value then
+                        signal.value.each_node_deep do |node|
+                            # res << node.to_ch if node.is_a?(Value)
+                            node.to_ch(res) if node.is_a?(Value)
+                        end
+                    end
                 end
                 block.each_node_deep do |node|
                     # res << node.to_ch if node.is_a?(Value)
@@ -702,6 +707,10 @@ module HDLRuby::Low
                 end.to_a
                 # Keep only one ref per signal.
                 refs.uniq! { |node| node.full_name }
+                # Remove the inner signals from the list.
+                self.block.each_inner do |inner|
+                    refs.delete_if {|r| r.name == inner.name }
+                end
                 # Generate the event.
                 events = refs.map {|ref| Event.new(:anyedge,ref.clone) }
                 # Add them to the behavior for further processing.
@@ -891,11 +900,12 @@ module HDLRuby::Low
             if self.value then
                 # There is an initial value.
                 res << " " * (level+1)*3
-                # res << "copy_value(#{self.value.to_c(level+2)}," +
-                #        "signalI->c_value);\n"
+                # res << "copy_value("
+                # self.value.to_c_expr(res,level+2)
+                # res << ",signalI->c_value);\n"
                 res << "copy_value("
                 self.value.to_c_expr(res,level+2)
-                res << ",signalI->c_value);\n"
+                res << ",signalI->f_value);\n"
             end
 
             # Initially the signal can be overwritten by anything.
@@ -1360,7 +1370,7 @@ module HDLRuby::Low
         # def to_c(level = 0)
         def to_c(res,level = 0)
             # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
+            res << (" " * (level*3)) << "PV;\n"
             # Generate the print for each argument.
             self.each_arg do |arg|
                 if (arg.is_a?(StringE)) then
@@ -1610,26 +1620,18 @@ module HDLRuby::Low
             res << "{\n"
             self.value.to_c(res,level+1)
             res << " " * ((level+1)*3)
-            res << "Value v=d;\n"
+            res << "dup();\n"
             # Ensure the selection value is testable.
             res << " " * ((level+1)*3)
-            res << "if (is_defined_value(v)) {\n"
+            res << "if (is_defined()) {\n"
             # The condition is testable.
             # Generate the case as a succession of if statements.
-            first = true
             self.each_when do |w|
                 res << " " * ((level+2)*3)
-                if first then
-                    first = false
-                else
-                    res << "else "
-                end
-                res << "if (value2integer(v) == "
-                res << "value2integer(({\n"
+                res << "dup();\n"
                 res << " " * ((level+2)*3)
                 w.match.to_c(res,level+2)
-                res << "d;})"
-                res << ")) {\n"
+                res << "if (to_integer() == to_integer()) {\n"
                 w.statement.to_c(res,level+3)
                 res << " " * (level+2)*3
                 res << "}\n"
@@ -1643,6 +1645,8 @@ module HDLRuby::Low
             end
             # Close the case.
             res << " " * (level+1)*3
+            res << "pop();\n" # Remove the testing value.
+            res << " " * (level+1)*3
             res << "}\n"
             res << " " * (level)*3
             res << "}\n"
@@ -1899,6 +1903,16 @@ module HDLRuby::Low
             # Should never be here.
             raise AnyError, "Internal error: to_c should be implemented in class :#{self.class}"
         end
+
+        ## Generates the C text for an expression access to the expression,
+        #  default case.
+        #  +level+ is the hierachical level of the object.
+        def to_c_expr(res,level = 0)
+            res << "({"
+            self.to_c(res,level+1)
+            res << (" " * ((level+1)*3))
+            res << "pop();})"
+        end
     end
 
 
@@ -1981,7 +1995,7 @@ module HDLRuby::Low
                 res << " " * (level+1)*3
                 # res << "static unsigned long long data[] = { "
                 res << "static unsigned int data[] = { "
-                res << str.scan(/.{1,#{Low2C.int_width}}/m).map do |sub|
+                res << str.scan(/.{1,#{Low2C.int_width}}/m).reverse.map do |sub|
                     sub.to_i(2).to_s # + "ULL"
                 end.join(",")
                 res << " };\n"
@@ -2056,7 +2070,7 @@ module HDLRuby::Low
         # def to_c(level = 0)
         def to_c(res,level = 0)
             # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
+            res << (" " * (level*3)) << "PV;\n"
             # Generate the child.
             self.child.to_c(res,level)
             res << (" " * (level*3))
@@ -2144,7 +2158,7 @@ module HDLRuby::Low
             end
             # Some computation required.
             # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
+            res << (" " * (level*3)) << "PV;\n"
             # Generate the child.
             self.child.to_c(res,level)
             res << (" " * (level*3))
@@ -2256,7 +2270,7 @@ module HDLRuby::Low
         # def to_c(level = 0)
         def to_c(res, level = 0)
             # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
+            res << (" " * (level*3)) << "PV;\n"
             # Generate the left computation.
             self.left.to_c(res,level)
             # Generate the right computation.
@@ -2375,7 +2389,7 @@ module HDLRuby::Low
         # +level+ is the hierachical level of the object.
         def to_c(res,level = 0)
             # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
+            res << (" " * (level*3)) << "PV;\n"
             # Gather the possible selection choices.
             expressions = self.each_choice.to_a
             # Create the resulting string.
@@ -2444,7 +2458,7 @@ module HDLRuby::Low
         # +level+ is the hierachical level of the object.
         def to_c(res,level = 0)
             # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
+            res << (" " * (level*3)) << "PV;\n"
             # Gather the content to concat.
             expressions = self.each_expression.to_a
             # Compute each sub expression.
@@ -2461,46 +2475,64 @@ module HDLRuby::Low
             return res
         end
 
-        # Generates the C text of expression for the equivalent HDLRuby code.
-        # +level+ is the hierachical level of the object.
-        def to_c_expr(res,level = 0)
-            # Gather the content to concat.
-            expressions = self.each_expression.to_a
-            # Create the resulting string.
-            res << "({\n"
-            # Overrides the upper src0, src1, ..., and dst...
-            # And allocates a new value for dst.
-            res << (" " * ((level+1)*3))
-            res << "Value "
-            res << expressions.size.times.map do |i| 
-                "src#{i}"
-            end.join(",")
-            res << ";\n"
-            res << (" " * ((level+1)*3))
-            res << "Value dst = get_value();\n"
-            # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
-            # Compute each sub expression.
-            expressions.each_with_index do |expr,i|
-                res << (" " * ((level+1)*3))
-                res << "src#{i} = "
-                expr.to_c_expr(res,level+2)
-                res << ";\n"
-            end
-            # Compute the direction.
-            # Compute the resulting concatenation.
-            res << (" " * ((level+1)*3))
-            res << "concat_value(#{expressions.size},"
-            res << "#{self.type.direction == :little ? 1 : 0},dst,"
-            res << expressions.size.times.map { |i| "src#{i}" }.join(",")
-            res << ");\n"
-            # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
-            # Close the computation.
-            res << (" " * (level*3))
-            res << "dst; })"
-            return res
-        end
+        # # # Generates the C text of expression for the equivalent HDLRuby code.
+        # # # +level+ is the hierachical level of the object.
+        # # def to_c_expr(res,level = 0)
+        # #     # Gather the content to concat.
+        # #     expressions = self.each_expression.to_a
+        # #     # Create the resulting string.
+        # #     res << "({\n"
+        # #     # Overrides the upper src0, src1, ..., and dst...
+        # #     # And allocates a new value for dst.
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "Value "
+        # #     res << expressions.size.times.map do |i| 
+        # #         "src#{i}"
+        # #     end.join(",")
+        # #     res << ";\n"
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "Value dst = get_value();\n"
+        # #     # Save the value pool state.
+        # #     res << (" " * (level*3)) << "SV;\n"
+        # #     # Compute each sub expression.
+        # #     expressions.each_with_index do |expr,i|
+        # #         res << (" " * ((level+1)*3))
+        # #         res << "src#{i} = "
+        # #         expr.to_c_expr(res,level+2)
+        # #         res << ";\n"
+        # #     end
+        # #     # Compute the direction.
+        # #     # Compute the resulting concatenation.
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "concat_value(#{expressions.size},"
+        # #     res << "#{self.type.direction == :little ? 1 : 0},dst,"
+        # #     res << expressions.size.times.map { |i| "src#{i}" }.join(",")
+        # #     res << ");\n"
+        # #     # Save the value pool state.
+        # #     res << (" " * (level*3)) << "SV;\n"
+        # #     # Close the computation.
+        # #     res << (" " * (level*3))
+        # #     res << "dst; })"
+        # #     return res
+        # # end
+        # def to_c_expr(res,level = 0)
+        #     # Save the value pool state.
+        #     res << "({ PV;"
+        #     # Gather the content to concat.
+        #     expressions = self.each_expression.to_a
+        #     # Compute each sub expression.
+        #     expressions.each_with_index do |expr,i|
+        #         expr.to_c(res,level+2)
+        #     end
+        #     # Compute the resulting concatenation.
+        #     res << (" " * ((level+1)*3))
+        #     res << "sconcat(#{expressions.size},"
+        #     res << (self.type.direction == :little ? "1" : "0")
+        #     res << ");\n"
+        #     # Restore the value pool state.
+        #     res << "RV; pop();})"
+        #     return res
+        # end
     end
 
 
@@ -2604,7 +2636,7 @@ module HDLRuby::Low
         # +left+ tells if it is a left value or not.
         def to_c(res,level = 0, left = false)
             # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
+            res << (" " * (level*3)) << "PV;\n"
             # Compute the reference.
             self.ref.to_c(res,level)
             # Compute the index.
@@ -2718,7 +2750,7 @@ module HDLRuby::Low
         # end
         def to_c(res,level = 0, left = false)
             # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
+            res << (" " * (level*3)) << "PV;\n"
             # Compute the reference.
             self.ref.to_c(res,level)
             # res << (" " * (level*3))
@@ -2784,17 +2816,11 @@ module HDLRuby::Low
         # +left+ tells if it is a left value or not.
         # def to_c(level = 0, left = false)
         def to_c(res,level = 0, left = false)
-            # # puts "RefName to_c for #{self.name}"
-            # self.resolve.to_c_signal(res,level+1)
-            # res << "->" << (left ? "f_value" : "c_value")
-            # return res
             # puts "RefName to_c for #{self.name}"
             res << (" " * (level*3))
-            # res << "d="
             res << "push("
             self.resolve.to_c_signal(res,level+1)
             res << "->" << (left ? "f_value" : "c_value")
-            # res << ";\n"
             res << ");\n"
             return res
         end

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -50,9 +50,25 @@ module HDLRuby::Low
             return found if found
             # Maybe it is a sub scope.
             return self.each_scope.find { |scope| scope.name == name }
+            # Maybe it in the behavior.
+            return self.behavior.get_by_name
         end
     end
 
+    ##
+    #  Extends Behavior with the capability of finding one of its inner object
+    #  by name.
+    class Behavior
+        
+        ## Find an inner object by +name+.
+        #  NOTE: return nil if not found.
+        def get_by_name(name)
+            if (self.block.name == name.to_sym) then
+                return self.block
+            end
+            return self.block.get_by_name(name)
+        end
+    end
 
     ##
     #  Extends SystemI with the capability of finding one of its inner object
@@ -79,7 +95,16 @@ module HDLRuby::Low
             # Ensure the name is a symbol.
             name = name.to_sym
             # Look in the signals.
-            return self.get_inner(name)
+            found = self.get_inner(name)
+            return found if found
+            # Check the sub blocks names.
+            self.each_block do |block|
+                # puts "block=#{block.name}"
+                if (block.name == name) then
+                    return block
+                end
+            end
+            return nil
         end
     end
 
@@ -199,6 +224,7 @@ module HDLRuby::Low
             if self.ref.is_a?(RefName) then
                 # puts "ref name=#{self.ref.name}"
                 obj = self.ref.resolve
+                # puts "obj=#{obj}"
                 # Look into the object for the name.
                 return obj.get_by_name(self.name)
             else
@@ -208,12 +234,15 @@ module HDLRuby::Low
                 while parent
                     # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
+                        # puts "get_by_name"
                         found = parent.get_by_name(self.name)
+                        # puts "found" if found
                         return found if found
                     end
                     parent = parent.parent
                 end
                 # Not found.
+                # puts "Not found!"
                 return nil
             end
         end

data/lib/HDLRuby/hruby_tools.rb

@@ -1,5 +1,6 @@
 require 'set'
 
+
 module HDLRuby
 
 ##

data/lib/HDLRuby/sim/hruby_sim.h

@@ -410,7 +410,8 @@ extern void save_value_pos();
 extern void restore_value_pos();
 
 /** Macros for short control of the pool of values. */
-#define SV get_value();save_value_pos();
+#define SV save_value_pos();
+#define PV push(get_value());save_value_pos();
 #define RV restore_value_pos();
 
 
@@ -753,10 +754,17 @@ extern Value write_range_no_z(Value src, long long first, long long last,
  *  @param val the value to push. */
 extern void push(Value val);
 
+/** Duplicates a value in the stack. */
+extern void dup();
+
 /** Pops a value.
  *  @return the value. */
 extern Value pop();
 
+/** Access the top value of the stack without removing it.
+ *  @return the value. */
+extern Value peek();
+
 /** Unary calculation.
  *  @param oper the operator function
  *  @return the destination