HDLRuby 2.11.3 → 2.11.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71e8ee2662101e18157249150f4766654b0c049e08c87190fa6e06e2805d087b
-  data.tar.gz: cfc13c02e2fae3ad7d2a3831be9728cc35dffa3096016c2790d9649d19348f18
+  metadata.gz: 450d4465eb4fb71c70d61bdadf5bd0d944b5b8c7f7f9f3d02f847d670eb74f76
+  data.tar.gz: b3cf3b934d8a50f6d85ffc74f3a34b0cfd2f074d472d2f6a8b93b4324cc2e5bd
 SHA512:
-  metadata.gz: cae45da4c41f556fc550a53272861e3def26bc15107a7bcb2cce1b3f8e99491d4b9cb8d2d4f4f621f422ef99c64ed704ac2e05a5f7c2b6d906133f420994aaf1
-  data.tar.gz: d29fb9b5ba800bcc4dff27c78e8a5762b9e7be1550ec1cb916a3cda543fabce878cc317c11e208e7a299896a7fc308cb307db0667dc6b3f416920b3d1c5fa2b0
+  metadata.gz: 667da8c2f678834407374f739ea4d0094803e82145b1485aa2b53bcef54f04b368668ad62996aaa67ae48b0e80fb9c9c9f731131e3eeb6c69c5c23363b2242e7
+  data.tar.gz: 39ae4cea2c84140063b601b5c3f171462db40a41b01739894daa95b90cec6dd8c87780cc86f65ff269a0d7fb4478412d06c114d4c3a921ade691c6c3d9868110

data/README.md

@@ -1949,15 +1949,19 @@ There are two kinds of such statements:
       !10.ns
    ```
 
- - The `repeat` statements: such a statement takes as argument a time value and a block. The execution of the block is repeated until the delay that is given by the time value argument expires.  For example, the following code executes repeatedly the inversion of the `clk` signal every 10 nanoseconds for 10 seconds (i.e., it simulates a clock signal for 10 seconds):
+ - The `repeat` statements: such a statement takes as argument a number of iteration and a block. The execution of the block is repeated the given number times.  For example, the following code executes 10 times the inversion of the `clk` signal every 10 nanoseconds:
 
    ```ruby
-      repeat(10.s) do 
+      repeat(10) do 
          !10.ns
          clk <= ~clk
       end
    ```
 
+__Note:__
+
+   This statement is not synthesizable and therefore can only be used in timed behaviors.
+
 ### Parallel and sequential execution
 
 Time behaviors are by default sequential, but they can include both parallel and

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -299,11 +299,14 @@ VALUE rcsim_make_event(VALUE mod, VALUE typeV, VALUE sigV) {
 }
 
 
+static size_t last_signal_id = 0;
+
 /* Creating a signal C object. */
 VALUE rcsim_make_signal(VALUE mod, VALUE name, VALUE type) {
     // printf("rcsim_make_signal\n");
     /* Allocates the signal. */
     SignalI signal = (SignalI)malloc(sizeof(SignalIS));
+    signal->id = last_signal_id++;
     // printf("signal=%p\n",signal);
     /* Set it up. */
     signal->kind = SIGNALI;
@@ -430,6 +433,27 @@ VALUE rcsim_make_timeWait(VALUE mod, VALUE unitV, VALUE delayV) {
     return res;
 }
 
+/* Creating a time repeat C object. */
+VALUE rcsim_make_timeRepeat(VALUE mod, VALUE numberV, VALUE statementV) {
+    // printf("rcsim_make_timeRepeat\n"); fflush(stdout);
+    /* Allocates the time repeat. */
+    TimeRepeat timeRepeat = (TimeRepeat)malloc(sizeof(TimeRepeatS));
+    // printf("timeRepeat=%p\n",timeRepeat); fflush(stdout);
+    /* Set it up. */
+    timeRepeat->kind = TIME_REPEAT;
+    /* Get and set the number of repeatition. */
+    long long number;
+    number = NUM2LL(numberV);
+    // printf("number=%lld\n",number); fflush(stdout);
+    timeRepeat->number = number;
+    /* Get and set the statement. */
+    value_to_rcsim(StatementS,statementV,timeRepeat->statement);
+    /* Returns the C time wait embedded into a ruby VALUE. */
+    VALUE res;
+    rcsim_to_value(TimeRepeatS,timeRepeat,res);
+    return res;
+}
+
 
 /* Creating a time terminate C object. */
 VALUE rcsim_make_timeTerminate(VALUE mod) {
@@ -447,19 +471,19 @@ VALUE rcsim_make_timeTerminate(VALUE mod) {
 
 
 /* Creating a hardware if C object. */
-VALUE rcsim_make_hif(VALUE mod, VALUE condition, VALUE yes, VALUE no) {
+VALUE rcsim_make_hif(VALUE mod, VALUE conditionV, VALUE yesV, VALUE noV) {
     // printf("rcsim_make_hif\n");
     /* Allocates the hardware if. */
     HIf hif = (HIf)malloc(sizeof(HIfS));
     // printf("hif=%p\n",hif);
     /* Set it up. */
     hif->kind = HIF;
-    value_to_rcsim(ExpressionS,condition,hif->condition);
-    value_to_rcsim(StatementS,yes,hif->yes);
-    if (TYPE(no) == T_NIL)
+    value_to_rcsim(ExpressionS,conditionV,hif->condition);
+    value_to_rcsim(StatementS,yesV,hif->yes);
+    if (TYPE(noV) == T_NIL)
         hif->no = NULL;
     else
-        value_to_rcsim(StatementS,no,hif->no);
+        value_to_rcsim(StatementS,noV,hif->no);
     hif->num_noifs = 0;
     hif->noconds = NULL;
     hif->nostmnts = NULL;
@@ -471,21 +495,21 @@ VALUE rcsim_make_hif(VALUE mod, VALUE condition, VALUE yes, VALUE no) {
 
 
 /* Creating a hardware case C object. */
-VALUE rcsim_make_hcase(VALUE mod, VALUE value, VALUE defolt) {
+VALUE rcsim_make_hcase(VALUE mod, VALUE valueV, VALUE defoltV) {
     // printf("rcsim_make_hcase\n");
     /* Allocates the hardware case. */
     HCase hcase = (HCase)malloc(sizeof(HCaseS));
     // printf("hcase=%p\n",hcase);
     /* Set it up. */
     hcase->kind = HCASE;
-    value_to_rcsim(ExpressionS,value,hcase->value);
+    value_to_rcsim(ExpressionS,valueV,hcase->value);
     hcase->num_whens = 0;
     hcase->matches = NULL;
     hcase->stmnts = NULL;
-    if (TYPE(defolt) == T_NIL)
+    if (TYPE(defoltV) == T_NIL)
         hcase->defolt = NULL;
     else
-        value_to_rcsim(StatementS,defolt,hcase->defolt);
+        value_to_rcsim(StatementS,defoltV,hcase->defolt);
     /* Returns the C hardware case embedded into a ruby VALUE. */
     VALUE res;
     rcsim_to_value(HCaseS,hcase,res);
@@ -494,7 +518,7 @@ VALUE rcsim_make_hcase(VALUE mod, VALUE value, VALUE defolt) {
 
 
 /* Creating a block C object. */
-VALUE rcsim_make_block(VALUE mod, VALUE mode) {
+VALUE rcsim_make_block(VALUE mod, VALUE modeV) {
     // printf("rcsim_make_block\n");
     /* Allocates the block. */
     Block block = (Block)malloc(sizeof(BlockS));
@@ -507,7 +531,7 @@ VALUE rcsim_make_block(VALUE mod, VALUE mode) {
     block->inners = NULL;
     block->num_stmnts = 0;
     block->stmnts = NULL;
-    block->mode = SYM2ID(mode) == id_PAR ? PAR : SEQ;
+    block->mode = SYM2ID(modeV) == id_PAR ? PAR : SEQ;
     /* Returns the C block embedded into a ruby VALUE. */
     VALUE res;
     rcsim_to_value(BlockS,block,res);
@@ -1373,6 +1397,7 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_make_transmit",rcsim_make_transmit,2);
     rb_define_singleton_method(mod,"rcsim_make_print",rcsim_make_print,0);
     rb_define_singleton_method(mod,"rcsim_make_timeWait",rcsim_make_timeWait,2);
+    rb_define_singleton_method(mod,"rcsim_make_timeRepeat",rcsim_make_timeRepeat,2);
     rb_define_singleton_method(mod,"rcsim_make_timeTerminate",rcsim_make_timeTerminate,0);
     rb_define_singleton_method(mod,"rcsim_make_hif",rcsim_make_hif,3);
     rb_define_singleton_method(mod,"rcsim_make_hcase",rcsim_make_hcase,2);

data/ext/hruby_sim/hruby_sim.h

@@ -28,6 +28,7 @@ typedef struct PrintS_ PrintS;
 typedef struct HIfS_ HIfS;
 typedef struct HCaseS_ HCaseS;
 typedef struct TimeWaitS_ TimeWaitS;
+typedef struct TimeRepeatS_ TimeRepeatS;
 typedef struct TimeTerminateS_ TimeTerminateS;
 typedef struct ExpressionS_ ExpressionS;
 typedef struct UnaryS_ UnaryS;
@@ -63,6 +64,7 @@ typedef struct PrintS_* Print;
 typedef struct HIfS_* HIf;
 typedef struct HCaseS_* HCase;
 typedef struct TimeWaitS_* TimeWait;
+typedef struct TimeRepeatS_* TimeRepeat;
 typedef struct TimeTerminateS_* TimeTerminate;
 typedef struct ExpressionS_* Expression;
 typedef struct UnaryS_* Unary;
@@ -89,7 +91,8 @@ typedef enum {
 #endif
     OBJECT, SYSTEMT, SIGNALI, SCOPE, BEHAVIOR, SYSTEMI, CODE, BLOCK, EVENT,
 #ifdef RCSIM
-    /* Statements */  TRANSMIT, PRINT, HIF, HCASE, TIME_WAIT, TIME_TERMINATE,
+    /* Statements */  TRANSMIT, PRINT, HIF, HCASE, 
+                      TIME_WAIT, TIME_REPEAT, TIME_TERMINATE,
     /* Expressions */ UNARY, BINARY, SELECT, CONCAT, CAST,
     /* References */  REF_OBJECT, REF_INDEX, REF_RANGE, REF_CONCAT,
     /* Non-hardware*/ STRINGE,
@@ -521,6 +524,8 @@ typedef struct SignalIS_ {
     Object* pos;        /* The objects actvated on pos edge. */
     int num_neg;        /* The number of behavior activated on neg edge. */
     Object* neg;        /* The objects actvated on neg edge. */
+
+    size_t id;          /* The identity of the signal. */
 } SignalIS;
 
 
@@ -670,6 +675,13 @@ typedef struct TimeWaitS_ {
     unsigned long long delay; /* The delay to wait in pico seconds. */
 } TimeWaitS;
 
+/** The C model of a time repeat statement. */
+typedef struct TimeRepeatS_ {
+    Kind kind;          /* The kind of object. */
+    long long number;   /* The number of interations, negative means infinity. */
+    Statement statement;/* The statement to execute in loop. */
+} TimeRepeatS;
+
 /** The C model of a time terminate statement. */
 typedef struct TimeTerminateS_ {
     Kind kind;          /* The kind of object. */

data/ext/hruby_sim/hruby_sim_core.c

@@ -62,7 +62,8 @@ static pthread_cond_t hruby_beh_cond = PTHREAD_COND_INITIALIZER;
 static pthread_cond_t hruby_sim_cond = PTHREAD_COND_INITIALIZER;
 
 /** Flags for the simulation. */
-static int sim_end_flag = 0;
+static int sim_single_flag = 0; /* Run in single timed behavior mode. */
+static int sim_end_flag = 0;    /* Ending the simulation. */
 
 /** Adds a timed behavior for processing. 
  *  @param behavior the timed behavior to register */
@@ -422,6 +423,21 @@ void* behavior_run(void* arg) {
     pthread_exit(NULL);
 }
 
+/** Starts a signle timed behavior to run without the multi-threaded engine. */
+void hruby_sim_start_single_timed_behavior() {
+    int i;
+    // printf("hruby_sim_start_single_timed_behaviors\n");fflush(stdout);
+    /* Set in mono-thread mode. */
+    sim_single_flag = 1;
+    Behavior behavior = timed_behaviors[0];
+    /* Simply run the timed behavior. */
+#ifdef RCSIM
+        execute_statement((Statement)(behavior->block),0,behavior);
+#else
+        behavior->block->function();
+#endif
+}
+
 
 /** Starts the timed behaviors.
  *  @note create a thread per timed behavior. */
@@ -473,37 +489,46 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
     /* Initialize the time to 0. */
     hruby_sim_time = 0;
 
-    /* Start all the timed behaviors. */
-    hruby_sim_start_timed_behaviors();
-    // /* Activate the timed behavior that are on time. */
-    // hruby_sim_activate_behaviors_on_time();
-
-    /* Run while there are active behaviors and the time limit is not 
-     * reached */
-    while(hruby_sim_time<limit) {
-        int i;
-        // printf("num_active_behaviors = %d\n",num_active_behaviors);
-        /* Wait for the active timed behaviors to perform their computations. */
-        hruby_sim_wait_behaviors();
-        /* Update the signal values (recursively executing blocks locked
-         * on the signals). */
+    if (num_timed_behaviors == 1) {
+        /* Initialize and touch all the signals. */
         hruby_sim_update_signals(); 
-        if (hruby_sim_time == 0) {
-            /* Initially touch all the signals. */
-            each_all_signal(&touch_signal);
-        }
-        // printf("num_run_behavior=%d\n",num_run_behaviors);
-        if (num_run_behaviors <= 0) break;
-        /* Advance time to next timestep. */
-        hruby_sim_advance_time();
+        each_all_signal(&touch_signal);
+        /* Only one timed behavior, no need of the multi-threaded engine. */
+        hruby_sim_start_single_timed_behavior();
+    } else {
+        /* Use the multi-threaded engine. */
+        /* Start all the timed behaviors. */
+        hruby_sim_start_timed_behaviors();
+        // /* Activate the timed behavior that are on time. */
+        // hruby_sim_activate_behaviors_on_time();
+
+        /* Run while there are active behaviors and the time limit is not 
+         * reached */
+        while(hruby_sim_time<limit) {
+            int i;
+            // printf("num_active_behaviors = %d\n",num_active_behaviors);
+            /* Wait for the active timed behaviors to perform their computations. */
+            hruby_sim_wait_behaviors();
+            /* Update the signal values (recursively executing blocks locked
+             * on the signals). */
+            hruby_sim_update_signals(); 
+            if (hruby_sim_time == 0) {
+                /* Initially touch all the signals. */
+                each_all_signal(&touch_signal);
+            }
+            // printf("num_run_behavior=%d\n",num_run_behaviors);
+            if (num_run_behaviors <= 0) break;
+            /* Advance time to next timestep. */
+            hruby_sim_advance_time();
+
+            /* Mark the signals as fading. */
+            for(i=0; i<num_all_signals; ++i) {
+                all_signals[i]->fading = 1;
+            }
 
-        /* Mark the signals as fading. */
-        for(i=0; i<num_all_signals; ++i) {
-            all_signals[i]->fading = 1;
+            /* Activate the timed behavior that are on time. */
+            hruby_sim_activate_behaviors_on_time();
         }
-
-        /* Activate the timed behavior that are on time. */
-        hruby_sim_activate_behaviors_on_time();
     }
 }
 
@@ -521,29 +546,38 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
  *  @param delay the delay to wait in ps.
  *  @param behavior the current behavior. */
 void hw_wait(unsigned long long delay, Behavior behavior) {
-    /* Maybe the thread is to end immediatly. */
-    if (sim_end_flag)
-        pthread_exit(NULL);
-    /* No go on with the wait procedure. */
-    pthread_mutex_lock(&hruby_sim_mutex);
-    /* Indicate the behavior finished current execution. */
-    num_active_behaviors -= 1;
-    // printf("!!num_active_behaviors=%d\n",num_active_behaviors);
-    // pthread_cond_signal(&hruby_sim_cond);
-    /* Update the behavior's time. */
-    behavior->active_time += delay;
-    pthread_mutex_unlock(&hruby_sim_mutex);
-    pthread_cond_signal(&hruby_sim_cond);
-    /* Wait for being reactivated. */
-    while(behavior->active_time > hruby_sim_time) {
+    /* Is it in single timed behavior mode? */
+    if (sim_single_flag) {
+        /* Yes, simply update signals and advance time. */
+        behavior->active_time += delay;
+        hruby_sim_update_signals(); 
+        hruby_sim_advance_time();
+    } else {
+        /* No, handle the multi-threading. */
+        /* Maybe the thread is to end immediatly. */
+        if (sim_end_flag)
+            pthread_exit(NULL);
+        /* No go on with the wait procedure. */
         pthread_mutex_lock(&hruby_sim_mutex);
-        while(!behaviors_can_run) {
-            // printf("!1\n");
-            // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
-            pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
-            // printf("!2\n");
-        }
+        /* Indicate the behavior finished current execution. */
+        num_active_behaviors -= 1;
+        // printf("!!num_active_behaviors=%d\n",num_active_behaviors);
+        // pthread_cond_signal(&hruby_sim_cond);
+        /* Update the behavior's time. */
+        behavior->active_time += delay;
         pthread_mutex_unlock(&hruby_sim_mutex);
+        pthread_cond_signal(&hruby_sim_cond);
+        /* Wait for being reactivated. */
+        while(behavior->active_time > hruby_sim_time) {
+            pthread_mutex_lock(&hruby_sim_mutex);
+            while(!behaviors_can_run) {
+                // printf("!1\n");
+                // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
+                pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
+                // printf("!2\n");
+            }
+            pthread_mutex_unlock(&hruby_sim_mutex);
+        }
     }
 }
 

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -358,6 +358,20 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                 hw_wait(delay,behavior);
                 break;
             }
+        case TIME_REPEAT:
+            {
+                TimeRepeat rep = (TimeRepeat)stmnt;
+                if (rep->number>=0) {
+                    for(long long i=0; i<rep->number; ++i) {
+                        execute_statement(rep->statement,mode,behavior);
+                    }
+                } else {
+                    for(;;) {
+                        execute_statement(rep->statement,mode,behavior);
+                    }
+                }
+                break;
+            }
         case BLOCK:
             {
                 Block block = (Block)stmnt;

data/ext/hruby_sim/hruby_sim_vcd.c

@@ -98,7 +98,6 @@ static void vcd_print_name(Object object) {
  *  @param object the object to print the name. */
 static void vcd_print_full_name(Object object) {
     /* Recurse on the owner if any. */
-    // printf("owner=%p\n",object->owner);
     if (object->owner != NULL) {
         vcd_print_full_name(object->owner);
         vcd_print("$");
@@ -107,12 +106,23 @@ static void vcd_print_full_name(Object object) {
     vcd_print_name(object);
 }
 
+/** Prints the id of a signal in vcd indentifier format.
+ *  @param signal the signal to print the id. */
+static void vcd_print_signal_id(SignalI signal) {
+    size_t id = signal->id;
+    do {
+        vcd_print("%c",(id % (127-33)) + 33);
+        id = id / (127-33);
+    } while (id > 0);
+}
+
 /** Prints a value.
  *  @param value the value to print */
 static void vcd_print_value(Value value) {
-    vcd_print("b");
+    unsigned long long width = type_width(value->type);
+    if (width > 1) vcd_print("b");
     if (value->numeric) {
-        unsigned long long width = type_width(value->type);
+        // unsigned long long width = type_width(value->type);
         unsigned long long mask = 1ULL << (width-1);
         for(; mask > 0; mask >>= 1) {
             vcd_print("%d",(value->data_int & mask) != 0);
@@ -120,7 +130,7 @@ static void vcd_print_value(Value value) {
     } else {
         /* Display a bitstring value. */
         unsigned long long i;
-        unsigned long long width = type_width(value->type);
+        // unsigned long long width = type_width(value->type);
         char* data = value->data_str;
         if (value->capacity == 0) {
             /* The value is empty, therefore undefined. */
@@ -135,13 +145,15 @@ static void vcd_print_value(Value value) {
             } 
         }
     }
+    if (width > 1) vcd_print(" ");
 }
 
 /** Prints a signal declaration.
  *  @param signal the signal to declare */
 static void vcd_print_var(SignalI signal) {
     vcd_print("$var wire %d ",type_width(signal->type));
-    vcd_print_full_name((Object)signal);
+    // vcd_print_full_name((Object)signal);
+    vcd_print_signal_id(signal);
     vcd_print(" ");
     vcd_print_name((Object)signal);
     vcd_print(" $end\n");
@@ -153,8 +165,9 @@ static void vcd_print_var(SignalI signal) {
 static void vcd_print_signal_fvalue(SignalI signal) {
     if (signal->f_value) {
         vcd_print_value(signal->f_value);
-        vcd_print(" ");
-        vcd_print_full_name((Object)signal);
+        // vcd_print(" ");
+        // vcd_print_full_name((Object)signal);
+        vcd_print_signal_id(signal);
         vcd_print("\n");
     }
 }
@@ -165,8 +178,9 @@ static void vcd_print_signal_fvalue(SignalI signal) {
 static void vcd_print_signal_cvalue(SignalI signal) {
     if (signal->c_value) {
         vcd_print_value(signal->c_value);
-        vcd_print(" ");
-        vcd_print_full_name((Object)signal);
+        // vcd_print(" ");
+        // vcd_print_full_name((Object)signal);
+        vcd_print_signal_id(signal);
         vcd_print("\n");
     }
 }

data/lib/HDLRuby/hdr_samples/repeat_bench.rb

@@ -0,0 +1,48 @@
+# A simple D-FF
+system :dff do
+    input  :d, :clk, :rst
+    output :q
+
+    (q <= d & ~rst).at(clk.posedge)
+end
+
+# A benchmark for the dff using repeat.
+system :dff_bench do
+    inner :d, :clk, :rst
+    inner :q
+
+    dff(:my_dff).(d,clk,rst,q)
+
+    timed do
+        clk <= 0
+        rst <= 0
+        d   <= _z
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= _z
+        !10.ns
+        clk <= 0
+        rst <= 1
+        d   <= _z
+        !10.ns
+        clk <= 1
+        rst <= 1
+        d   <= _z
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 1
+        rst <= 0
+        !10.ns
+        repeat(100) do
+            clk <= 0
+            d <= ~d
+            !10.ns
+            clk <= 1
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hruby_high.rb

@@ -2682,10 +2682,10 @@ module HDLRuby::High
 
         # Converts the repeat statement to HDLRuby::Low.
         def to_low
-            # return HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
+            # timeRepeatL = HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
             #                                     self.delay.to_low)
-            timeRepeatL = HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
-                                                self.delay.to_low)
+            timeRepeatL = HDLRuby::Low::TimeRepeat.new(self.number,
+                                                       self.statement.to_low)
             # # For debugging: set the source high object 
             # timeRepeatL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = timeRepeatL
@@ -4233,15 +4233,20 @@ module HDLRuby::High
             self.add_statement(TimeWait.new(delay))
         end
 
-        # Adds a loop until +delay+ statement in the block in +mode+ whose
+        # # Adds a loop until +delay+ statement in the block in +mode+ whose
+        # # loop content is built using +ruby_block+.
+        # def repeat(delay, mode = nil, &ruby_block)
+        # Adds a +number+ times loop statement in the block in +mode+ whose
         # loop content is built using +ruby_block+.
-        def repeat(delay, mode = nil, &ruby_block)
+        # NOTE: if +number+ is negative, the number of iteration is infinite.
+        def repeat(number = -1, mode = nil, &ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # Build the content block.
             content = High.make_block(mode,&ruby_block)
             # Create and add the statement.
-            self.add_statement(TimeRepeat.new(content,delay))
+            # self.add_statement(TimeRepeat.new(content,delay))
+            self.add_statement(TimeRepeat.new(number,content))
         end
 
         # Converts the time block to HDLRuby::Low.

data/lib/HDLRuby/hruby_low.rb

@@ -4042,15 +4042,20 @@ module HDLRuby::Low
     ## 
     # Describes a timed loop statement: not synthesizable!
     class TimeRepeat < Statement
-        # The delay until the loop is repeated
-        attr_reader :delay
+        # # The delay until the loop is repeated
+        # attr_reader :delay
+        # The number of interrations.
+        attr_reader :number
 
         # The statement to execute.
         attr_reader :statement
 
-        # Creates a new timed loop statement execute in a loop +statement+ until
-        # +delay+ has passed.
-        def initialize(statement,delay)
+        # # Creates a new timed loop statement execute in a loop +statement+ until
+        # # +delay+ has passed.
+        # def initialize(statement,delay)
+        # Creates a new timed loop statement execute in a loop +statement+ 
+        # +number+ times (negative means inifinity).
+        def initialize(number,statement)
             # Check and set the statement.
             unless statement.is_a?(Statement)
                 raise AnyError,
@@ -4061,13 +4066,15 @@ module HDLRuby::Low
             # And set its parent.
             statement.parent = self
 
-            # Check and set the delay.
-            unless delay.is_a?(Delay)
-                raise AnyError, "Invalid class for a delay: #{delay.class}."
-            end
-            @delay = delay
-            # And set its parent.
-            delay.parent = self
+            # # Check and set the delay.
+            # unless delay.is_a?(Delay)
+            #     raise AnyError, "Invalid class for a delay: #{delay.class}."
+            # end
+            # @delay = delay
+            # Check and set the number.
+            @number = number.to_i
+            # # And set its parent.
+            # delay.parent = self
         end
 
         # Iterates over each object deeply.
@@ -4080,26 +4087,29 @@ module HDLRuby::Low
             ruby_block.call(self)
             # Then apply on the statement.
             self.statement.each_deep(&ruby_block)
-            # Then apply on the delay.
-            self.delay.each_deep(&ruby_block)
+            # # Then apply on the delay.
+            # self.delay.each_deep(&ruby_block)
         end
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(TimeRepeat)
-            return false unless @delay.eql?(obj.delay)
+            # return false unless @delay.eql?(obj.delay)
+            return false unless @number.eql?(obj.number)
             return false unless @statement.eql?(obj.statement)
             return true
         end
 
         # Hash function.
         def hash
-            return [@delay,@statement].hash
+            # return [@delay,@statement].hash
+            return [@number,@statement].hash
         end
 
         # Clones the TimeRepeat (deeply)
         def clone
-            return TimeRepeat.new(@statement.clone,@delay.clone)
+            # return TimeRepeat.new(@statement.clone,@delay.clone)
+            return TimeRepeat.new(@statement.clone,@number)
         end
 
         # Iterates over the expression children if any.