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 42

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

powered by: WebSVN 2.1.0

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