For reference, this is somewhat of a follow up question to a question I asked previously: https://perlmonks.org/?node_id=11120004

What is the impact on the value of $? if the output of an application is redirected to /dev/null? This is running under RHEL7.

For example, suppose I have a perl script that calls a compiled executable that seg faults:

`my_executable_that_seg_faults`;

my $exit_value = $? >> 8;
my $signal_num = $? & 127;
my $dumped_core = $? & 128;

printf("return value is %d\n", $?);

printf("exit_value = $exit_value\n");
printf("signal_num = $signal_num\n");
printf("dumped_core = $dumped_core\n");
[download]

Running the above code produces the following output:

return value is 11
exit_value = 0
signal_num = 11
dumped_core = 0
[download]

This output is consistent with what I would expect based on information found here related to the $? variable: https://perldoc.perl.org/perlvar.html

However if I change the executable call above to the following:

`my_executable_that_seg_faults > /dev/null`;
[download]

The following output is produced:

return value is 35584
exit_value = 139
signal_num = 0
dumped_core = 0
[download]

The above output is significantly different even though the application still seg faulted. Here are my questions:

1. Why did the value of $? completely change when I added the output redirect to /dev/null but kept everything else the same?

2. Does the value of $? in the second case still contain the same information but encoded differently?

I created a different application with an intentional segmentation fault and called it using the above perl script. It produced the exact same output, suggesting that this behavior is not dependent on the behavior of the called application.

  on_connect => sub {
        my ($serv, $conn) = @_;
        $conn->on(
            },
            utf8 => sub {
            },
            binary => sub {
            },
[download]

Thanks in advance.

Hello wise Monks who are always wiser than I am. I have several thousand html files that I'm parsing using Mojo::DOM. I've encountered a few older files that are surprisingly missing one the fields I'm trying to extract. Not many by enough to cause my script to error out. Here's the code I have:

              my $dom1 = Mojo::DOM->new( $$temp_content );
              
              my $abstr = $dom1->at('div.abstract-content > p')->text;
              
              print "Abstract is: $abstr \n\n";
[download]

Here's the what I tried to do to catch the exception (when abstract is null)

  my $abstr = $dom1->at('div.abstract-content > p' || 'not provided')-
+>text;
[download]

Here's the error that I'm getting: Can't call method "text" on an undefined value at /Volumes/HD-PATU3/test.pl line 5.

I've looked at the Mojo::DOM documentation and can't seem to find an answer. I've sure it's easy and being a nub I"m missing something simple. Thanks in advance for your wisdom and assistance

In the case of a named subroutine one is able to get the code-ref of the caller by inspecting the STASH.

But this doesn't work with anonymous subs.

Caller claims they are part of the stash (here main::__ANON__ ) but accessing the associated code-ref fails. It most likely a newly autovivificated code-ref.

Any better way to get the callers code-ref?

First the output

CURRENT SUB: CODE(0x24c9198)
main::upper CODE(0x24c9198)
CURRENT SUB: CODE(0x24e8568)
main::__ANON__ CODE(0x24c0580)  # <--- OOPS
[download]

Here the demo:

use strict;
use warnings;
use Data::Dump qw/pp dd/;
use feature "current_sub","say";

sub lower {
    my %caller;
    package DB {
        @caller{ qw/
                       package   filename line       subroutine hasarg
+s
                       wantarray evaltext is_require hints      bitmas
+k
                       hinthash
                   /
               } = caller(1);
    };

    my $caller_name = $caller{subroutine};
    my $caller_ref =\&{$caller_name};;

    say $caller_name," ",$caller_ref;
}



# --- normal
sub upper {
    say "CURRENT SUB: ",__SUB__;
    lower( "UPPER" );
}

upper();

# --- ano sub
my $ano = sub {
    say "CURRENT SUB: ",__SUB__;
    lower("ANNO");
};

$ano->();
[download]

for my $c (@car_links) {
    my $pid = fork();
    if ($pid == 0) {
        # Reserve for 30 min. total.
        for (1..6) {
            reserve_car($c, $username, $password);
            sleep 300;
        }
        exit;
    }
    
    push @known_cars, $c;
    write_url_to_known_cars($c, $fh);
}
[download]

for my $c (@car_links) {
    threads->create(sub {
        threads->detach;

        # Reserve for 30 min. total.
        for (1..6) {
            reserve_car($c, $username, $password);
            sleep 300;
        }
    });
    
    push @known_cars, $c;
    write_url_to_known_cars($c, $fh);
}
[download]

Both of these exit after fork() and threads->create() on Windows 10 using Strawberry Perl 5.30.2.1 and ActiveState 5.26.3 and 5.28.1. What could be the reason and is it possible to fix this? Both versions work fine on Linux.

I tried AnyEvent too, but I couldn't get it to work either and other event systems seem to need their on loops. The above code is already run in another loop, so I would like to stick with it.

I parse string using /gc and \G regexes. Current solution for skipping white characters and comments starting from # to the end of line is:

Look ahead ?= assertion is necessary, because zero-length matches cause problems. That solution unfortunatelly gives error:

I have changes to such one:

but this is not elegant. I have changed "+" to "*" after "\s" and this also solves the problem, but I don't know why...

Questions: (1) what is the better solution to strip white chars and commments (2) why * instead of + solves the problem?

With the example print ++($foo = "Az"); # prints "Ba" The logic in my head is that it printed uppercase "B" because it's the letter that comes after the uppercase "A", and it printed lowercase "a" because it's what comes after lowercase "z" going back to the first letter of the alphabet that's "a" since "z" is the lastest.

So why print ++($foo = "zz"); prints "aaa"? It makes no sense to me. Shouldn't it print just "aa" since there's two z characters?

As does "cpan install"; fails with:

   "  MANWAR/XML-XPath-1.44.tar.gz
    E:\PLang\ActivePerl\bin\perl.exe Makefile.PL INSTALLDIRS=site -- O
+K
    Running make for M/MA/MANWAR/XML-XPath-1.44.tar.gz
    x[91m[DMAKE] error: the following arguments are required: command.
+.[0m
    ...
    e:\Plang\Python\python36\scripts\dmake.exe -- NOT OK
[download]

So I played around with sub X::foo and noticed that sub resolution happens in the surrounding package.

That looks consistent to me, it's analogue to BEGIN{ *X::foo = sub { } } where the anonymous sub carries its package context around.

Hence calling foo() will work while bar() fails, because Data::Dump wasn't imported into X::

use strict;
use warnings;
use Data::Dump qw/pp dd/;

sub X::foo { pp(\@_) }; 

BEGIN { *X::baz = sub { pp(\@_) } };


package X;

sub bar { pp(\@_) } ;

foo(1..3);                              # [1, 2, 3]
baz(1..3);                              # [1, 2, 3]

bar(4..6);                              # Undefined subroutine &X::pp 
+called
[download]

Question: What are the use cases of that pattern?

The only thing which comes to mind is monkey patching a sub in another package without adding inner helper functions into that package.

RTLSDR_API int rtlsdr_open(rtlsdr_dev_t **dev, uint32_t index);

# where rtlsdr_dev_t is initialized as:

typedef struct rtlsdr_dev rtlsdr_dev_t;
[download]

int 
rtlsdr_open(dev, index)
  RTLSDRDevice_T **dev
  uint32_t index

# where RTLSDRDEVICE_T is

typedef  rtlsdr_dev_t  RTLSDRDevice_T;
[download]

RTLSDRDevice_T *    T_PTRREF
RTLSDRDevice_T **   T_PTRREF
[download]

use SDR::RTLSDR qw(:all); # my library

my $serial_number = "00000001"; # from dmesg output

my $index = rtlsdr_get_index_by_serial( $serial_number ); # it returns
+ 0, this is not an error value so I think is good

my $device = rtlsdr_get_device_name( $index );
print rtlsdr_open( $device , $index)
[download]

SDR::RTLSDR::rtlsdr_close: dev is not of type RTLSDRDevice_TPtr at sdr
+.pl line 7.
[download]

print rtlsdr_open( \$device , $index)
[download]