view release on metacpan or  search on metacpan

lib/Sidef/Parser.pm  view on Meta::CPAN

            return
              bless(
                    {
                     arg  => $arg,
                     line => $self->{line},
                     file => $self->{file_name},
                    },
                    $action eq 'die'
                    ? "Sidef::Meta::Error"
                    : "Sidef::Meta::Warning"
                   );
        }

        # Eval keyword
        if (/\Geval\b\h*/gc) {

            my $obj = (
                       /\G(?=\()/
                       ? $self->parse_arg(code => $opt{code})
                       : $self->parse_obj(code => $opt{code})
                      );

#<<<
            return bless(
                {
                 expr   => $obj,
                 parser => Sidef::Object::Object::dclone(scalar {%$self}),

                 #vars          => {$self->{class} => [@{$self->{vars}{$self->{class}}}]},
                 #ref_vars_refs => {$self->{class} => [@{$self->{ref_vars_refs}{$self->{class}}}]},

                }, 'Sidef::Eval::Eval');
#>>>
        }

        if (/\GParser\b/gc) {
            return $self;
        }

        # Regular expression
        if (m{\G(?=/)} || /\G%r\b/gc) {
            my $string = $self->get_quoted_string(code => $opt{code});
            return Sidef::Types::Regex::Regex->new($string, /\G($self->{match_flags_re})/goc ? $1 : undef);
        }

        # Class variable in form of `Class!var_name`
        if (/\G($self->{var_name_re})!($self->{var_name_re})/goc) {
            my ($class_name, $var_name) = ($1, $2);
            my $class_obj = $self->parse_expr(code => \$class_name);
            return (bless {class => $class_obj, name => $var_name}, 'Sidef::Variable::ClassVar');
        }

        # Static object (like String or nil)
        if (/$self->{static_obj_re}/goc) {
            return $^R;
        }

        if (/\G__MAIN__\b/gc) {
            if (-e $self->{script_name}) {
                state $x = require Cwd;
                return Sidef::Types::String::String->new(Cwd::abs_path($self->{script_name}));
            }
            return Sidef::Types::String::String->new($self->{script_name});
        }

        if (/\G__FILE__\b/gc) {
            if (-e $self->{file_name}) {
                state $x = require Cwd;
                return Sidef::Types::String::String->new(Cwd::abs_path($self->{file_name}));
            }
            return Sidef::Types::String::String->new($self->{file_name});
        }

        if (/\G__DATE__\b/gc) {
            my (undef, undef, undef, $day, $mon, $year) = localtime;
            return Sidef::Types::String::String->new(join('-', $year + 1900, map { sprintf "%02d", $_ } $mon + 1, $day));
        }

        if (/\G__TIME__\b/gc) {
            my ($sec, $min, $hour) = localtime;
            return Sidef::Types::String::String->new(join(':', map { sprintf "%02d", $_ } $hour, $min, $sec));
        }

        if (/\G__LINE__\b/gc) {
            return Sidef::Types::Number::Number->new($self->{line});
        }

        if (/\G__COMPILED__\b/gc) {
            return Sidef::Types::Bool::Bool->new($self->{opt}{R} eq 'Perl' or $self->{opt}{c});
        }

        if (/\G__OPTIMIZED__\b/gc) {
            return Sidef::Types::Bool::Bool->new(($self->{opt}{O} || 0) > 0);
        }

        if (/\G__(?:END|DATA)__\b\h*+\R?/gc) {
            if (exists $self->{'__DATA__'}) {
                $self->{'__DATA__'} = substr($_, pos);
            }
            pos($_) = length($_);
            return;
        }

        if (/\GDATA\b/gc) {
            return (
                $self->{static_objects}{'__DATA__'} //= do {
                    bless({data => \$self->{'__DATA__'}}, 'Sidef::Meta::Glob::DATA');
                }
            );
        }

        # Beginning of a here-document (<<"EOT", <<'EOT', <<EOT)
        if (/\G<<(-)?+(?=\S)/gc) {
            my $indent = $1 ? 1 : 0;
            my ($name, $type) = (undef, 1);

            my $pos = pos($_);
            if (/\G(?=(['"„]))/) {
                $type = 0 if $1 eq q{'};
                my $str = $self->get_quoted_string(code => $opt{code});
                $name = $str;
            }
            elsif (/\G(\w+)/gc) {
                $name = $1;
            }
            else {
                $self->fatal_error(
                                   error  => "invalid 'here-doc' declaration",