Changeset 244

Show
Ignore:
Timestamp:
09/20/07 18:43:48 (6 years ago)
Author:
tokuhirom
Message:

merge.

Location:
lang/perl/PlPy/trunk/PlPy
Files:
1 added
6 modified

Legend:

Unmodified
Added
Removed

  • lang/perl/PlPy/trunk/PlPy/lib/PlPy.pm

    r239 r244  
    1717use PlPy::Builtins::tuple; 
    1818use PlPy::Builtins::int; 
     19 
     20use PlPy::BuiltinClassMethod; 
    1921 
    2022use Inline Python => <<'...'; 
    … …  
    142144    my @stack; 
    143145 
     146    debug { "Code is:\n$src" }; 
    144147    run_vm($co, \@stack, 0, undef, {}); 
    145148} 
    … …  
    215218 
    216219        if ($ENV{DEBUG}) { 
    217             print GREEN, "# @{[ '--' x $call ]} $op_name $oparg", RESET, "\n"; 
     220            warn GREEN, "# @{[ '--' x $call ]} $op_name $oparg", RESET, "\n"; 
    218221        } 
    219222 
    … …  
    264267            case 'LOAD_LOCALS' { 
    265268                push @$stack, +{ map { $co->{co_names}->[$_] => $vars[$_] } 0..scalar(@vars)-1 }; 
     269            } 
     270 
     271            case 'UNPACK_SEQUENCE' { 
     272                debug { "unpack sequence" }; 
     273                my $tos = $stack->pop; 
     274                for my $x (@$tos) { 
     275                    $stack->push($x); 
     276                } 
    266277            } 
    267278 
    … …  
    357368                my $tos = $stack->pop; 
    358369                my $name = $co->{co_names}->[$oparg]; 
    359                 debug { "Replaces TOS($tos) with getattr(TOS($tos), co_names[namei]($name))" }; 
    360                 no strict 'refs'; 
    361                 push @$stack, $tos->__getattr($name); 
     370                debug { "Replaces TOS($tos) with getattr(TOS(@{[ ref $tos ]} $tos), co_names[namei]($name))" }; 
     371                if (ref($tos) =~ /^PlPy::Class/) { 
     372                    $stack->push($tos->__getattr($name)); # pushes PlPy::Method instance. 
     373                } elsif (ref($tos) =~ /^PlPy::Builtins::/) { 
     374                    # builtin class. 
     375                    $stack->push(PlPy::BuiltinClassMethod->new($tos, $name)); 
     376                } else { 
     377                    die "hmmm... invalid class? @{[ ref $tos ]}"; 
     378                } 
    362379            } 
    363380            case 'STORE_ATTR' { 
    … …  
    380397                my $w = $stack->pop; 
    381398 
    382                 if ( ref $w eq 'PlPy::Builtins::list' ) { 
    383                     push @$stack, $w->[$v]; 
    384                 } 
    385                 elsif ( ref $w eq 'PlPy::Builtins::map' ) { 
    386                     push @$stack, $w->{$v}; 
    387                 } 
    388                 else { 
    389                     die "INVALID TYPE"; 
    390                 } 
     399                debug { "get item from $w [ $v ] => @{[ $w->__getitem__($v) ]}" }; 
     400 
     401                $stack->push( $w->__getitem__($v) ); 
    391402            } 
    392403 
    … …  
    423434            } 
    424435 
     436            case 'ROT_TWO' { 
     437                # TOS <=> TOS1 
     438                my $tos = $stack->pop; 
     439                my $tos1 = $stack->pop; 
     440                $stack->push($tos); 
     441                $stack->push($tos1); 
     442            } 
    425443            case 'ROT_THREE' { 
    426444                # TOS      TOS1 
    … …  
    441459                my $tos2 = $stack->pop; 
    442460 
    443                 if (ref $tos1 eq 'PlPy::Builtins::map') { 
    444                     $tos1->{$tos} = $tos2; 
    445                 } elsif (ref $tos1 eq 'PlPy::Builtins::list') { 
    446                     debug { "$tos1 [ $tos ] = $tos2" }; 
    447                     $tos1->[$tos] = $tos2; 
    448                 } else { 
    449                     die "INVALID TYPE : $tos1"; 
    450                 } 
     461                $tos1->__setitem__($tos, $tos2); 
    451462            } 
    452463 
    … …  
    495506                my $kwargs_num = $oparg >> 8  ; # #kwargs 
    496507 
     508                debug { "calling function: the number of arguments: $args_num; kwargs: $kwargs_num" }; 
     509 
    497510                my $func_code = $stack->[scalar(@$stack)-$args_num-($kwargs_num*2)-1]; 
     511                debug { "FUNC CODE IS $func_code" }; 
    498512                my $op_vars; 
    499513 
    … …  
    502516                my $orig_func_code = $func_code; 
    503517                if (ref $func_code eq 'PlPy::Class') { 
     518                    debug { "constructing class" }; 
     519 
    504520                    no strict 'refs'; 
    505521                    my $f = $func_code->__getattr('__init__'); 
    … …  
    558574                } 
    559575 
     576                debug { "OPVARS: @{[ Dumper($op_vars) ]}" }; 
     577 
    560578                # store default arguments 
    561579                my @default_args = @{ $func_code->{default_args} || [] }; 
    … …  
    575593                }; 
    576594 
    577                 run_vm($func_code, $stack, $call+1, $op_vars, $next_global_vars); 
     595                if ($func_code->isa('PlPy::BuiltinClassMethod')) { 
     596                    debug { "BUILT IN CLASS METHOD" }; 
     597                    my $ret = $func_code->call($op_vars); 
     598                    debug { "ret value is $ret" }; 
     599                    $stack->push($ret); 
     600                } else { 
     601                    debug { "RUN THE NEXT VM" }; 
     602                    run_vm($func_code, $stack, $call+1, $op_vars, $next_global_vars); 
     603                } 
    578604 
    579605                if ($class_fg) { 

  • lang/perl/PlPy/trunk/PlPy/lib/PlPy/Builtins/int.pm

    r222 r244  
    33use warnings; 
    44use base qw/PlPy::Builtins::object/; 
     5use Digest::MD5; 
    56 
    67sub new { 
    … …  
    3031sub __cmp__    { my ($self, $other) = @_; ${$self} <=> ${$other} } 
    3132 
     33sub __hash__ { Digest::MD5::md5_hex(shift) } 
     34 
    32351; 
    3336 

  • lang/perl/PlPy/trunk/PlPy/lib/PlPy/Builtins/list.pm

    r222 r244  
    1919} 
    2020 
     21sub __getitem__ { 
     22    my ($self, $idx) = @_; 
     23    return $self->[$idx]; 
     24} 
     25 
     26sub __setitem__ { 
     27    my ($self, $idx, $val) = @_; 
     28    $self->[$idx] = $val; 
     29} 
     30 
    21311; 
    2232 

  • lang/perl/PlPy/trunk/PlPy/lib/PlPy/Builtins/map.pm

    r222 r244  
    44use base qw/PlPy::Builtins::object/; 
    55use Tie::RefHash; 
     6use autobox; 
     7use autobox::Core; 
     8 
     9my $name_for; 
    610 
    711sub new { 
    812    my ($class, ) = @_; 
    9     my %x; 
    10     tie %x, 'Tie::RefHash'; 
    11     bless \%x, $class; 
     13    bless {}, $class; 
    1214} 
    1315 
    1416sub __str__ { 
    1517    my $self = shift; 
     18 
    1619    return '{' . join( 
    1720        ", ", 
    1821        map { 
    19             $self->___stringify($_) . " : " 
     22            $self->___stringify($name_for->{$_}) . " : " 
    2023              . $self->___stringify( $self->{$_} ) 
    2124          } keys %$self 
    … …  
    2528sub __setitem__ { 
    2629    my ($self, $key, $val) = @_; 
    27     $self->{$key} = $val; 
     30    $name_for->{$key->__hash__} = $key; 
     31    $self->{$key->__hash__} = $val; 
     32} 
     33 
     34sub __getitem__ { 
     35    my ($self, $key) = @_; 
     36    return $self->{$key->__hash__}; 
     37} 
     38 
     39sub keys { 
     40    my ($self, ) = @_; 
     41    return PlPy::Builtins::list->new([map { $name_for->{$_} } keys %$self]); 
    2842} 
    2943 

  • lang/perl/PlPy/trunk/PlPy/lib/PlPy/Builtins/str.pm

    r222 r244  
    44use base qw/PlPy::Builtins::object/; 
    55use Scalar::Util qw/reftype/; 
     6use Digest::MD5; 
    67 
    78sub new { 
    … …  
    2122} 
    2223 
     24# This is dummy ;-( 
     25sub __hash__ { 
     26    my $self = shift; 
     27    Digest::MD5::md5_hex($self); 
     28} 
     29 
    23301; 
    2431 

  • lang/perl/PlPy/trunk/PlPy/t/vm_test.t

    r240 r244  
    2121#       raise. 
    2222#       builtin functions. 
    23 #       break statement. 
    24 #       continue statement. 
     23#       builtin class methods. 
    2524#       yield 
    26 #       dictionary should contain the object. 
     25#       error handling 
    2726#       use Class::MOP. 
    2827 
    2928__END__ 
    3029 
     30=== Array.__setitem__ 
     31--- SKIP 
     32--- input 
     33a=['fuga'] 
     34a.__setitem__(0, 'hoge') 
     35print a 
     36--- expected 
     37hoge 
     38 
     39=== builtin functions abs 
     40--- SKIP 
     41--- input 
     42print abs(3) 
     43print -4 
     44print abs(-4) 
     45--- expected 
     463 
     47-4 
     484 
     49 
    3150=== simple 
    3251--- input 
    … …  
    4867 
    4968=== String.__str__ 
    50 --- SKIP 
    5169--- input 
    5270print "FOO".__str__() 
    … …  
    443461--- expected 
    444462CONSTRUCTOR 
     463 
     464=== Dict.keys 
     465--- input 
     466print {'foo':'bar', 'moe':'nae'}.keys() 
     467--- expected 
     468['moe', 'foo'] 
    445469 
    446470=== call constructor with argument 
    … …  
    645669[4, 5] 
    646670 
     671=== Foo.lower() 
     672--- input 
     673print "FOO".lower() 
     674print "Foo".lower() 
     675print "foO".lower() 
     676print "foo".lower() 
     677--- expected 
     678foo 
     679foo 
     680foo 
     681foo 
     682