OpenCores
URL https://opencores.org/ocsvn/an-fpga-implementation-of-low-latency-noc-based-mpsoc/an-fpga-implementation-of-low-latency-noc-based-mpsoc/trunk

Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

[/] [an-fpga-implementation-of-low-latency-noc-based-mpsoc/] [trunk/] [mpsoc/] [perl_gui/] [lib/] [perl/] [ip_gen.pm] - Blame information for rev 17

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 16 alirezamon 
#!/usr/bin/perl -w -I ..
2 
###############################################################################
3 
#
4 
# File:         interface.pm
5 
#
6 
#
7 
###############################################################################
8 
use warnings;
9 
use strict;
10 
 
11 
 
12 
package ip_gen;
13 
#use Clone 'clone';
14 
 
15 
 
16 
 
17 
sub ip_gen_new {
18 
    # be backwards compatible with non-OO call
19 
    my $class = ("ARRAY" eq ref $_[0]) ? "ip_gen" : shift;
20 
    my $self;
21 
 
22 
 
23 
    $self = {};
24 
    $self->{file_name}        = ();
25 
    $self->{parameters_order}=[];
26 
    $self->{ports_order}=[];
27 
    $self->{hdl_files}=[];
28 
 
29 
 
30 
 
31 
    bless($self,$class);
32 
 
33 
 
34 
    return $self;
35 
}
36 
 
37 
sub ipgen_set_file{
38 
        my ($self,$file)=@_;
39 
          $self->{file_name}=$file;
40 
}
41 
 
42 
 
43 
 
44 
sub ipgen_get_file{
45 
        my $self=shift;
46 
        return   $self->{file_name};
47 
}
48 
 
49 
sub ipgen_set_module_name{
50 
        my ($self,$module)=@_;
51 
        $self->{module_name}=$module;
52 
}
53 
 
54 
sub ipgen_get_module_name{
55 
        my ($self)=@_;
56 
        return $self->{module_name};
57 
}
58 
 
59 
sub ipgen_set_ip_name{
60 
        my ($self,$name)=@_;
61 
        $self->{ip_name}=$name;
62 
}
63 
 
64 
sub ipgen_get_ip_name{
65 
        my ($self)=@_;
66 
        return  $self->{ip_name};
67 
}
68 
 
69 
 
70 
sub ipgen_set_module_list{
71 
        my ($self,@list)=@_;
72 
        $self->{modules}={};
73 
        foreach my $p(@list) {
74 
                $self->{modules}{$p}={};
75 
        }
76 
 
77 
}
78 
 
79 
 
80 
 
81 
sub ipgen_get_module_list{
82 
                my ($self)=@_;
83 
                my @modules;
84 
                if(exists($self->{modules})){
85 
                        @modules=keys %{$self->{modules}};
86 
                }
87 
                return @modules;
88 
}
89 
 
90 
 
91 
 
92 
sub ipgen_add_parameter{
93 
        my ($self,$parameter,$deafult,$type,$content,$info,$global_param,$redefine)=@_;
94 
        $self->{parameters}{$parameter}{deafult}=$deafult;
95 
        $self->{parameters}{$parameter}{type}=$type;
96 
        $self->{parameters}{$parameter}{content}=$content;
97 
        $self->{parameters}{$parameter}{info}=$info;
98 
        $self->{parameters}{$parameter}{global_param}=$global_param;
99 
        $self->{parameters}{$parameter}{redefine_param}=$redefine;
100 
}
101 
 
102 
 
103 
 
104 
sub ipgen_add_parameters_order{
105 
        my ($self,@parameters_order)=@_;
106 
        $self->{parameters_order}=\@parameters_order;
107 
 
108 
 
109 
}
110 
 
111 
 
112 
sub ipgen_get_parameters_order{
113 
        my $self=shift;
114 
        my @r;
115 
        @r =    @{$self->{parameters_order}} if (defined $self->{parameters_order});
116 
        return @r;
117 
}
118 
 
119 
sub ipgen_push_parameters_order{
120 
        my ($self,$param)=@_;
121 
        if(defined $param){
122 
                push(@{$self->{parameters_order}},$param);
123 
        }
124 
 
125 
}
126 
 
127 
sub ipgen_remove_parameters_order{
128 
        my ($self,$param)=@_;
129 
        my @r=@{$self->{parameters_order}};
130 
        my @n;
131 
        foreach my $p(@r){
132 
                if( $p ne $param) {push(@n,$p)};
133 
 
134 
        }
135 
        $self->{parameters_order}=\@n;
136 
 
137 
}
138 
 
139 
 
140 
sub ipgen_add_ports_order{
141 
        my ($self,@ports_order) =@_;
142 
        $self->{ports_order}=\@ports_order;
143 
}
144 
 
145 
 
146 
 
147 
sub ipgen_get_ports_order{
148 
        my $self =shift;
149 
        my @order=(defined $self->{ports_order})?  @{$self->{ports_order}} : undef;
150 
    return  @order;
151 
}
152 
 
153 
 
154 
 
155 
 
156 
sub ipgen_remove_parameter{
157 
        my ($self,$parameter)=@_;
158 
        if(exists ( $self->{parameters}{$parameter})){
159 
                delete $self->{parameters}{$parameter};
160 
        }
161 
}
162 
 
163 
sub ipgen_get_parameter_detail{
164 
        my ($self,$parameter)=@_;
165 
        my ($deafult,$type,$content,$info,$global_param,$redefine);
166 
        if(exists ($self->{parameters}{$parameter})){
167 
                $deafult                =$self->{parameters}{$parameter}{deafult};
168 
                $type                   =$self->{parameters}{$parameter}{type};
169 
                $content                =$self->{parameters}{$parameter}{content};
170 
                $info                   =$self->{parameters}{$parameter}{info};
171 
                $global_param           =$self->{parameters}{$parameter}{global_param};
172 
                $redefine               =$self->{parameters}{$parameter}{redefine_param};
173 
 
174 
        }
175 
        return ($deafult,$type,$content,$info,$global_param,$redefine);
176 
}
177 
 
178 
sub ipgen_get_all_parameters_list{
179 
        my ($self)=@_;
180 
        my @parameters;
181 
        if(exists ($self->{parameters})){
182 
                foreach my $p ( keys %{$self->{parameters}}){
183 
                        push(@parameters,$p);
184 
                }
185 
        }
186 
        return @parameters;
187 
}
188 
 
189 
sub ipgen_remove_all_parameters{
190 
        my ($self)=@_;
191 
        if (exists ($self->{parameters})){
192 
                delete $self->{parameters};
193 
        }
194 
}
195 
 
196 
 
197 
 
198 
sub ipgen_add_port{
199 
        my($self,$port,$range,$type,$intfc_name,$intfc_port)=@_;
200 
        $self->{ports}{$port}{range}=$range;
201 
        $self->{ports}{$port}{type}=$type;
202 
        $self->{ports}{$port}{intfc_name}=$intfc_name;
203 
        $self->{ports}{$port}{intfc_port}=$intfc_port;
204 
}
205 
 
206 
sub ipgen_get_port{
207 
        my($self,$port)=@_;
208 
        my($range,$type,$intfc_name,$intfc_port);
209 
        if(exists ($self->{ports}{$port})){
210 
                $range=$self->{ports}{$port}{range};
211 
                $type=$self->{ports}{$port}{type};
212 
                $intfc_name=$self->{ports}{$port}{intfc_name};
213 
                $intfc_port=$self->{ports}{$port}{intfc_port};
214 
        }
215 
        return ($range,$type,$intfc_name,$intfc_port);
216 
}
217 
 
218 
 
219 
sub ipgen_list_ports{
220 
        my($self)=@_;
221 
        my @ports;
222 
        foreach my $p (keys %{$self->{ports}}){
223 
                push (@ports,$p);
224 
        }
225 
        return @ports;
226 
}
227 
 
228 
 
229 
 
230 
sub ipgen_remove_all_ports{
231 
        my $self=shift;
232 
        if (exists ($self->{ports})){
233 
                delete $self->{ports};
234 
        }
235 
 
236 
}
237 
 
238 
sub ipgen_add_soket{
239 
        my ($self,$socket,$type,$value,$connection_num)=@_;
240 
        $self->{sockets}{$socket}{type}=$type;
241 
        if(defined $value) {
242 
                $self->{sockets}{$socket}{value}=$value;
243 
 
244 
        }
245 
        if(defined $connection_num) {$self->{sockets}{$socket}{connection_num}=$connection_num;}
246 
        if($type eq 'num'){
247 
                if($value == 1) {ipgen_set_socket_name($self,$socket,0,$socket);}
248 
                else{
249 
                                for (my $i=0; $i<$value; $i++){
250 
                                        my $name="$socket\_$i";
251 
                                        ipgen_set_socket_name($self,$socket,$i,$name);
252 
                                }
253 
 
254 
                }
255 
 
256 
        }
257 
        else{ipgen_set_socket_name($self,$socket,0,$socket);}
258 
 
259 
        #print "\$self->{sockets}{$socket}{type}=$type;\n"
260 
}
261 
 
262 
sub ipgen_add_plug{
263 
        my ($self,$plug,$type,$value)=@_;
264 
        $self->{plugs}{$plug}{type}=$type;
265 
        if(defined $value){$self->{plugs}{$plug}{value}=$value};
266 
        if($type eq 'num'){
267 
                if($value == 1) {ipgen_set_plug_name($self,$plug,0,$plug);}
268 
                else{
269 
                                for (my $i=0; $i<$value; $i++){
270 
                                        my $name="$plug\_$i";
271 
                                        ipgen_set_plug_name($self,$plug,$i,$name);
272 
                                }
273 
 
274 
                }
275 
 
276 
        }
277 
        else{ipgen_set_plug_name($self,$plug,0,$plug);}
278 
 
279 
}
280 
 
281 
sub ipgen_list_sokets{
282 
        my ($self)=@_;
283 
        my @sokets;
284 
 
285 
        if(exists ($self->{sockets})){
286 
                foreach my $p(keys %{$self->{sockets}}){
287 
                        push (@sokets,$p);
288 
                }
289 
        }
290 
        return @sokets;
291 
}
292 
 
293 
 
294 
sub ipgen_list_plugs{
295 
        my ($self)=@_;
296 
        my @plugs;
297 
        if(exists ($self->{plugs})){
298 
                foreach my $p(keys %{$self->{plugs}}){
299 
                        push (@plugs,$p);
300 
                }
301 
        }
302 
        return @plugs;
303 
}
304 
 
305 
 
306 
 
307 
sub ipgen_get_socket{
308 
        my ($self,$socket)=@_;
309 
        my ($type,$value,$connection_num);
310 
        if(exists ($self->{sockets}{$socket})){
311 
                $type   =$self->{sockets}{$socket}{type};
312 
                $value  =$self->{sockets}{$socket}{value};
313 
                $connection_num= $self->{sockets}{$socket}{connection_num};
314 
                #print "$type,$value\n"
315 
        }
316 
        return ($type,$value,$connection_num);
317 
}
318 
 
319 
sub ipgen_get_plug{
320 
        my ($self,$plug)=@_;
321 
        my ($type,$value,$connection_num);
322 
        if(exists ($self->{plugs}{$plug})){
323 
                $type   =$self->{plugs}{$plug}{type};
324 
                $value  =$self->{plugs}{$plug}{value};
325 
                $connection_num=$self->{plugs}{$plug}{connection_num};
326 
        }
327 
        return ($type,$value,$connection_num);
328 
}
329 
 
330 
sub ipgen_remove_socket{
331 
                my ($self,$socket)=@_;
332 
                if(exists ($self->{sockets}{$socket})) {
333 
                                delete $self->{sockets}{$socket};
334 
                }
335 
}
336 
 
337 
sub ipgen_remove_plug{
338 
                my ($self,$plug)=@_;
339 
                if(exists ($self->{plugs}{$plug})) {
340 
                                delete $self->{plugs}{$plug};
341 
                }
342 
}
343 
 
344 
 
345 
 
346 
sub ipgen_set_port_intfc_name{
347 
        my ($self,$port,$intfc_name)=@_;
348 
        if(exists ($self->{ports}{$port})){
349 
                $self->{ports}{$port}{intfc_name}=$intfc_name;
350 
        }
351 
 
352 
}
353 
 
354 
sub ipgen_get_port_intfc_name{
355 
        my ($self,$port)=@_;
356 
        my $intfc_name;
357 
        if(exists ($self->{ports}{$port}{intfc_name})){
358 
                $intfc_name=$self->{ports}{$port}{intfc_name};
359 
        }
360 
        return ($intfc_name);
361 
}
362 
 
363 
sub ipgen_set_port_intfc_port{
364 
        my ($self,$port,$intfc_port)=@_;
365 
        if(exists ($self->{ports}{$port})){
366 
                $self->{ports}{$port}{intfc_port}=$intfc_port;
367 
        }
368 
 
369 
}
370 
 
371 
sub ipgen_get_port_intfc_port{
372 
        my ($self,$port)=@_;
373 
        my $intfc_port;
374 
        if(exists ($self->{ports}{$port}{intfc_port})){
375 
                $intfc_port=$self->{ports}{$port}{intfc_port};
376 
        }
377 
        return ($intfc_port);
378 
}
379 
 
380 
 
381 
sub ipgen_set_category{
382 
        my ($self,$category)=@_;
383 
        if(defined $category){
384 
                $self->{category}=$category;
385 
 
386 
        }
387 
 
388 
}
389 
 
390 
 
391 
 
392 
sub ipgen_get_category{
393 
        my ($self)=@_;
394 
        my $category;
395 
        if(exists ($self->{category})){
396 
                $category=$self->{category};
397 
        }
398 
        return  $category;
399 
}
400 
 
401 
 
402 
sub ipgen_get_description{
403 
        my ($self)=@_;
404 
        my $description;
405 
        if(exists ($self->{description})){
406 
                $description=$self->{description};
407 
        }
408 
        return $description;
409 
}
410 
 
411 
sub ipgen_set_description{
412 
        my ($self,$description)=@_;
413 
                $self->{description}=$description;
414 
 
415 
 
416 
}
417 
 
418 
 
419 
sub ipgen_save_wb_addr{
420 
        my ($self,$plug,$num,$addr,$width)=@_;
421 
        $self->{plugs}{$plug}{$num}{addr}=$addr;
422 
        $self->{plugs}{$plug}{$num}{width}=$width;
423 
 
424 
}
425 
 
426 
sub ipgen_get_wb_addr{
427 
        my ($self,$plug,$num)=@_;
428 
        my($addr,$width);
429 
        if(exists ($self->{plugs}{$plug}{$num})){
430 
                $addr= $self->{plugs}{$plug}{$num}{addr};
431 
                $width=$self->{plugs}{$plug}{$num}{width};
432 
        }
433 
        return  ($addr,$width);
434 
}
435 
 
436 
sub ipgen_set_plug_name{
437 
        my ($self,$plug,$num,$name)=@_;
438 
        if(exists ($self->{plugs}{$plug})){
439 
                $self->{plugs}{$plug}{$num}{name}=$name;
440 
 
441 
        }
442 
 
443 
}
444 
 
445 
 
446 
sub ipgen_get_plug_name{
447 
        my ($self,$plug,$num)=@_;
448 
        my $name;
449 
        if(exists ($self->{plugs}{$plug}{$num}{name})){
450 
                 $name=$self->{plugs}{$plug}{$num}{name};
451 
 
452 
        }
453 
        return  $name;
454 
}
455 
 
456 
sub ipgen_set_socket_name {
457 
        my ($self,$socket,$num,$name)= @_;
458 
        if(exists ($self->{sockets}{$socket})){
459 
                $self->{sockets}{$socket}{$num}{name}=$name;
460 
 
461 
        }
462 
 
463 
}
464 
 
465 
sub ipgen_get_socket_name{
466 
        my ($self,$socket,$num)=@_;
467 
        my $name;
468 
        if(exists ($self->{sockets}{$socket}{$num}{name})){
469 
                $name=$self->{sockets}{$socket}{$num}{name};
470 
 
471 
        }
472 
        return $name;
473 
 
474 
}
475 
 
476 
sub ipgen_set_hdr{
477 
        my ($self,$hdr)=@_;
478 
        $self->{header}=$hdr;
479 
}
480 
 
481 
 
482 
sub ipgen_get_hdr{
483 
        my ($self)=@_;
484 
        my $hdr;
485 
        if(exists ($self->{header})){
486 
                $hdr=$self->{header};
487 
 
488 
        }
489 
        return $hdr;
490 
 
491 
}
492 
 
493 17 alirezamon 
 
494 
 
495 
 
496 
sub ipgen_get_files_list{
497 
        my ($self,$list_name)=@_;
498 16 alirezamon 
        my @l;
499 17 alirezamon 
        if ( defined $self->{$list_name} ){
500 
                @l=@{$self->{$list_name}};
501 16 alirezamon 
        }
502 
 
503 
        return @l;
504 
}
505 
 
506 
 
507 17 alirezamon 
sub ipgen_set_files_list{
508 
        my ($self,$list_name,$ref)=@_;
509 
        $self->{$list_name}=    $ref;
510 16 alirezamon 
}
511 
 
512 
 
513 17 alirezamon 
sub ipgen_add_unused_intfc_port{
514 
        my ($self,$intfc_name,$port)=@_;
515 
        push(@{$self->{unused}{$intfc_name}},$port);
516 
}
517 
 
518 
sub ipgen_get_unused_intfc_ports{
519 
        my $self=shift;
520 
        return $self->{unused};
521 
 
522 
}
523 
 
524 
sub ipgen_remove_unused_intfc_port{
525 
        my $self=shift;
526 
        $self->{unused}=undef;
527 
}
528 
 
529 16 alirezamon 
######################################
530 
 
531 
 
532 
 
533 
 
534 
sub top_gen_new {
535 
    # be backwards compatible with non-OO call
536 
    my $class =  shift;
537 
    my $self;
538 
 
539 
 
540 
    $self = {};
541 
    $self->{instance_ids}={};
542 
    bless($self,$class);
543 
 
544 
 
545 
    return $self;
546 
}
547 
 
548 
sub top_add_def_to_instance {
549 
        my ($self,$inst,$def,$value )=@_;
550 
                $self->{instance_ids}{$inst}{$def}=$value;
551 
}
552 
 
553 
sub top_get_def_of_instance {
554 
        my ($self,$inst,$def)=@_;
555 
        my $val;
556 
        $val=$self->{instance_ids}{$inst}{$def} if(exists $self->{instance_ids}{$inst}{$def})   ;
557 
        return $val;
558 
}
559 
 
560 
 
561 
sub top_add_port{
562 
        my($self,$inst,$port,$range,$type,$intfc_name,$intfc_port)=@_;
563 
 
564 
        #all ports
565 
        $self->{ports}{$port}{range}=$range;
566 
        $self->{ports}{$port}{type}=$type;
567 
        $self->{ports}{$port}{intfc_name}=$intfc_name;
568 
        $self->{ports}{$port}{intfc_port}=$intfc_port;
569 
        $self->{ports}{$port}{instance_name}=$inst;
570 
 
571 
 
572 
        #based on instance name
573 
        $self->{instance_ids}{$inst}{ports}{$port}{range}=$range;
574 
        $self->{instance_ids}{$inst}{ports}{$port}{type}=$type;
575 
        $self->{instance_ids}{$inst}{ports}{$port}{intfc_name}=$intfc_name;
576 
        $self->{instance_ids}{$inst}{ports}{$port}{intfc_port}=$intfc_port;
577 
 
578 
        #based on interface name
579 
        $self->{interface}{$intfc_name}{ports}{$port}{range}=$range;
580 
        $self->{interface}{$intfc_name}{ports}{$port}{type}=$type;
581 
        $self->{interface}{$intfc_name}{ports}{$port}{instance_name}=$inst;
582 
        $self->{interface}{$intfc_name}{ports}{$port}{intfc_port}=$intfc_port;
583 
}
584 
 
585 
 
586 
 
587 
 
588 
sub top_get_port{
589 
        my($self,$port)=@_;
590 
        my($inst,$range,$type,$intfc_name,$intfc_port);
591 
        $inst           =$self->{ports}{$port}{instance_name};
592 
        $range          =$self->{ports}{$port}{range};
593 
        $type           =$self->{ports}{$port}{type};
594 
        $intfc_name     =$self->{ports}{$port}{intfc_name};
595 
        $intfc_port     =$self->{ports}{$port}{intfc_port};
596 
        return ($inst,$range,$type,$intfc_name,$intfc_port);
597 
}
598 
 
599 
sub top_get_port_list{
600 
        my$self=shift;
601 
        my @l;
602 
        if(exists $self->{ports}){
603 
                @l= sort keys %{$self->{ports}};
604 
        }
605 
        return @l;
606 
}
607 
 
608 
 
609 
 
610 
sub top_add_parameter{
611 
        my ($self,$inst,$parameter,$deafult,$type,$content,$info,$global_param,$redefine)=@_;
612 
        $self->{instance_ids}{$inst}{parameters}{$parameter}{deafult}=$deafult;
613 
        $self->{instance_ids}{$inst}{parameters}{$parameter}{type}=$type;
614 
        $self->{instance_ids}{$inst}{parameters}{$parameter}{content}=$content;
615 
        $self->{instance_ids}{$inst}{parameters}{$parameter}{info}=$info;
616 
        $self->{instance_ids}{$inst}{parameters}{$parameter}{global_param}=$global_param;
617 
        $self->{instance_ids}{$inst}{parameters}{$parameter}{redefine_param}=$redefine;
618 
}
619 
 
620 
sub top_get_parameter{
621 
        my ($self,$inst,$parameter)=@_;
622 
        my ($deafult,$type,$content,$info,$global_param,$redefine);
623 
        $deafult=$self->{instance_ids}{$inst}{parameters}{$parameter}{deafult};
624 
        $type=$self->{instance_ids}{$inst}{parameters}{$parameter}{type};
625 
        $content=$self->{instance_ids}{$inst}{parameters}{$parameter}{content};
626 
        $info=$self->{instance_ids}{$inst}{parameters}{$parameter}{info};
627 
        $global_param=$self->{instance_ids}{$inst}{parameters}{$parameter}{global_param};
628 
        $redefine=$self->{instance_ids}{$inst}{parameters}{$parameter}{redefine_param};
629 
        return  ($deafult,$type,$content,$info,$global_param,$redefine);
630 
}
631 
 
632 
sub top_get_parameter_list{
633 
        my($self,$inst)=@_;
634 
        my @l;
635 
        if(exists $self->{instance_ids}{$inst}{parameters}){
636 
                @l= sort keys %{$self->{instance_ids}{$inst}{parameters}};
637 
        }
638 
        return @l;
639 
}
640 
 
641 
sub top_add_default_soc_param{
642 
        my ($self,$param_ref)=@_;
643 
        my %l=%{$param_ref};
644 
        foreach my $p (sort keys %l){
645 
                $self->{parameters}{$p}=$l{$p};
646 
                #print"$self->{parameters}{$p}=$l{$p};\n";
647 
        }
648 
}
649 
 
650 
sub top_get_default_soc_param{
651 
        my $self=shift;
652 
        my %l;
653 
        if(exists $self->{parameters}){
654 
                 %l=%{$self->{parameters}};
655 
        }
656 
        return  %l;
657 
}
658 
 
659 
 
660 
sub top_get_all_instances{
661 
        my ($self)=shift;
662 
        my @r= keys %{$self->{instance_ids}};
663 
        return @r;
664 
 
665 
}
666 
 
667 
 
668 
sub top_get_intfc_list{
669 
        my ($self)=shift;
670 
        my @intfcs;
671 
        if(exists $self->{interface}){
672 
                @intfcs= sort keys %{$self->{interface}};
673 
        }
674 
 
675 
        return  @intfcs;
676 
}
677 
 
678 
 
679 
sub top_get_intfc_ports_list{
680 
        my($self,$intfc_name)=@_;
681 
        my @ports;
682 
        if( exists $self->{interface}{$intfc_name}{ports}){
683 
                @ports= sort keys %{$self->{interface}{$intfc_name}{ports}};
684 
        }
685 
        return @ports;
686 
}
687 
 
688 
 
689 
sub top_add_custom_soc_param{
690 
        my ($self,$param_ref,$tile)=@_;
691 
        my %l=%{$param_ref};
692 
        foreach my $p (sort keys %l){
693 
                $self->{tiles}{$tile}{parameters}{$p}=$l{$p};
694 
                #print"$self->{parameters}{$p}=$l{$p};\n";
695 
        }
696 
}
697 
 
698 
sub top_get_custom_soc_param{
699 
        my ($self,$tile)=@_;
700 
        my %l;
701 
        if(exists $self->{tiles}{$tile}{parameters}){#get custom param
702 
                 %l=%{$self->{tiles}{$tile}{parameters}};
703 
        }elsif (exists $self->{parameters}){#get default param
704 
                 %l=%{$self->{parameters}};
705 
        }
706 
        return  %l;
707 
 
708 
}
709 
 
710 
 
711 
 
712 
        1

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.