view release on metacpan or  search on metacpan

lib/Ewindows1252.pm  view on Meta::CPAN

                }
                die __FILE__, ": Can't find string terminator anywhere before EOF\n";
            }
        }

# split m//
        elsif (/\G \b (m) \b /oxgc) {
            if (/\G (\#) ((?:$qq_char)*?) (\#) ([cgimosxpadlunbB]*) /oxgc)                        { return e_split  ($e.'qr',$1,$3,$2,$4);   } # m# #  --> qr # #
            else {
                while (not /\G \z/oxgc) {
                    if    (/\G ((?>\s+)|\#.*)                                              /oxgc) { $e .= $1; }

 view release on metacpan or  search on metacpan

lib/Ewindows1254.pm  view on Meta::CPAN

                }
                die __FILE__, ": Can't find string terminator anywhere before EOF\n";
            }
        }

# split m//
        elsif (/\G \b (m) \b /oxgc) {
            if (/\G (\#) ((?:$qq_char)*?) (\#) ([cgimosxpadlunbB]*) /oxgc)                        { return e_split  ($e.'qr',$1,$3,$2,$4);   } # m# #  --> qr # #
            else {
                while (not /\G \z/oxgc) {
                    if    (/\G ((?>\s+)|\#.*)                                              /oxgc) { $e .= $1; }

 view release on metacpan or  search on metacpan

lib/Ewindows1257.pm  view on Meta::CPAN

                }
                die __FILE__, ": Can't find string terminator anywhere before EOF\n";
            }
        }

# split m//
        elsif (/\G \b (m) \b /oxgc) {
            if (/\G (\#) ((?:$qq_char)*?) (\#) ([cgimosxpadlunbB]*) /oxgc)                        { return e_split  ($e.'qr',$1,$3,$2,$4);   } # m# #  --> qr # #
            else {
                while (not /\G \z/oxgc) {
                    if    (/\G ((?>\s+)|\#.*)                                              /oxgc) { $e .= $1; }

 view release on metacpan or  search on metacpan

lib/Ewindows1258.pm  view on Meta::CPAN

                }
                die __FILE__, ": Can't find string terminator anywhere before EOF\n";
            }
        }

# split m//
        elsif (/\G \b (m) \b /oxgc) {
            if (/\G (\#) ((?:$qq_char)*?) (\#) ([cgimosxpadlunbB]*) /oxgc)                        { return e_split  ($e.'qr',$1,$3,$2,$4);   } # m# #  --> qr # #
            else {
                while (not /\G \z/oxgc) {
                    if    (/\G ((?>\s+)|\#.*)                                              /oxgc) { $e .= $1; }

 view release on metacpan or  search on metacpan

bin/XLSperl  view on Meta::CPAN

Current cell (A1 .. ZZx)

=item @F

Array of cell values (in autosplit mode)

=item %F

Hash of cell values (in autosplit mode). Entries in %F are aliases
for the corresponding elements of @F, so modifying $F{A} will also
update the value of $F[0] and vice-versa.

=back

 view release on metacpan or  search on metacpan

lib/XML/Compile/Schema.pm  view on Meta::CPAN

      : exists $args{show} ? $args{show} # pre-0.79 option name 
      : 'ALL';

    $show    = 'struct,type,occur,facets' if $show eq 'ALL';
    $show    = '' if $show eq 'NONE';
    my %show = map {("show_$_" => 1)} split m/\,/, $show;
    my $nss  = $self->namespaces;

    my $indent                  = $args{indent} || "  ";
    $args{check_occurs}         = 1;
    $args{mixed_elements}     ||= 'ATTRIBUTES';

 view release on metacpan or  search on metacpan

t/lib/SyndTempWrap.pm  view on Meta::CPAN

our @EXPORT_OK = qw($temp_dir cur_fn fn yaml_fn atom_fn rss_fn common_fns dir);

sub dir
{
    my $fn = shift;
    return File::Spec->catdir( File::Spec->curdir(), ( split m!/!, $fn ), );
}

sub cur_fn
{
    my $fn = shift;
    return File::Spec->catfile( File::Spec->curdir(), ( split m!/!, $fn ), );
}

sub fn
{
    return File::Spec->catfile( $temp_dir, shift );

 view release on metacpan or  search on metacpan

lib/XML/MinWriter.pm  view on Meta::CPAN

sub write_pyx {
    my $self = shift;

    my @inlist;
    for (@_) {
        push @inlist, split m{\n}xms;
    }

    LOOP1: for my $instr (@inlist) {
        if ($instr eq '') {
            next LOOP1;

 view release on metacpan or  search on metacpan

lib/XML/Parsepp/Testgen.pm  view on Meta::CPAN

    my $i = 0;
    for my $hl (@HList) { $i++;
        my $func_body = '';

        my @vlist = split m{,}xms, $hl->[2] =~ s{[\s\(\)]}''xmsgr;
        for my $vl (@vlist) {
            $vl = '$'.$vl unless $vl =~ m{\A \@}xms;
        }

        $func_body .= "{ # ".sprintf('%2d', $i).". ".sprintf('%-15s', $hl->[0])." ".$hl->[2]."\n";

lib/XML/Parsepp/Testgen.pm  view on Meta::CPAN

    $XmlParser->setHandlers(@HParam);

    my @current;
    my @RList;

    for (split m{\n}xms, $xml) {
        if (m{\A \s* \#! (.*) \z}xms) {
            my $remark = $1;

            if ($remark =~ m{\A \s* =+ \s* \z}xms) {
                push @RList, { xml => [@current] } if @current;

lib/XML/Parsepp/Testgen.pm  view on Meta::CPAN

    my $result = '';

    open my $ofh, '>', \$result or die "Error-0090: Can't open > '\\\$result' because $!";

    for (split m{\n}xms, $template) {
        if (m{\A \s* %}xms) {
            m{\A %include \s+ (\w+) \z}xms
              or die "Error-0100: Can't parse %include from '$_'";

            my $subject = $1;

lib/XML/Parsepp/Testgen.pm  view on Meta::CPAN

    for my $i (0..$#gr_list) {
        my $text = $gr_list[$i];

        say {$ofh} '#! ===' unless $i == 0;

        my @lines = split m{\n}xms, $text;

        my $first = shift @lines;

        unless (defined $first) {
            die "Error-0230: Too few elements in lines";

 view release on metacpan or  search on metacpan

t/XML-Parser-Nodes.t  view on Meta::CPAN

$xml = new XML::Parser::Nodes $msmxml ;
$dump = $header .$xml->dump ;
is( $dump, $msmxml, "new() #1" ) ;

my @path = split m|/|, $0 ;
pop @path ;
my $fn = join '/', @path, 'XML-Parser-Nodes.xml' ;
local( *H ) ;
my $fh = *H ;

 view release on metacpan or  search on metacpan

lib/XML/Reader.pm  view on Meta::CPAN

                $self->{path}   = '/';
                $self->{level}  = 0;
                $self->{tag}    = ''; # unfortunately we have to nullify the tag here...
                last;
            }
            if ($check.'/' eq substr($self->{path}, 0, length($check) + 1)) { my @temp = split m{/}xms, $check;
                $self->{prefix} = $check;
                $self->{path}   = substr($self->{path}, length($check));
                $self->{level} -= @temp - 1;
                last;
            }

 view release on metacpan or  search on metacpan

lib/XML/TreePP/XMLPath.pm  view on Meta::CPAN

    ["\@key='val'"]

In this example of bad data being parsed, the C<boundry_stop> character C<]> was
never matched for the C<key2=val2> element.

And there is no error message. The charlexsplit method throws away the second
element silently due to the token start and stop mismatch.

=head2 Method: parseXMLPath

    use XML::TreePP::XMLPath qw(parseXMLPath);

 view release on metacpan or  search on metacpan

lib/XML/Twig.pm  view on Meta::CPAN

      my @result;                                 # the returned list of elements
      my $text= $elt->text;
      my $gi= $elt->gi;

      # 2 uses: if split matches then the first substring reuses $elt
      #         once a split has occurred then the last match needs to be put in
      #         a new element
      my $previous_match= 0;

      while( my( $pre_match, @matches)= $text=~ /^(.*?)$regexp(.*)$/gcs)

lib/XML/Twig.pm  view on Meta::CPAN

      return $string;
    }

  sub _install_replace_sub
    { my $replace_exp= shift;
      my @item= split m{(&e[ln]t\s*\([^)]*\))}, $replace_exp;
      my $sub= q{ my( $match, @var)= @_; my $new; my $last_inserted=$match;};
      my( $gi, $exp);
      foreach my $item (@item)
        { next if ! length $item;
          if(    $item=~ m{^&elt\s*\(([^)]*)\)})

 view release on metacpan or  search on metacpan

lib/XML/XPathScript/Stylesheet/DocBook2LaTeX.pm  view on Meta::CPAN

	if (findvalue('name(..)',$self) eq "table") {
		$title=apply_templates_under("../title",$self);
	};
	# So "defined($title)" is a valid test for "this is a formal table".

	my @styles=split m/,/,utf8tolatin1(findvalue('@tgroupstyle',$self));

	my @TeXspecs=map {&$typeset_tablecolumnpattern($_->{colspec},
												   "colspec",$self);
				  } _table_getcolspecs_onelevel($self);

 view release on metacpan or  search on metacpan

t/70infix.t  view on Meta::CPAN

   # Deparsed output is '{ ... }'-wrapped
   $got = ( $got =~ m/^{\n(.*)\n}$/s )[0];

   # Deparsed output will have a lot of pragmata and so on; just grab the
   # final line
   $got = ( split m/\n/, $got )[-1];
   $got =~ s/^\s+//;

   is( $got, $exp, $name );
}

 view release on metacpan or  search on metacpan

include/boost/serialization/split_member.hpp  view on Meta::CPAN

}

} // namespace serialization
} // namespace boost

// split member function serialize function into save/load
#define BOOST_SERIALIZATION_SPLIT_MEMBER()                       \
template<class Archive>                                          \
void serialize(                                                  \
    Archive &ar,                                                 \
    const unsigned int file_version                              \

 view release on metacpan or  search on metacpan

libdwarf-code-0.11.1/src/lib/libdwarf/dwarf_init_finish.c  view on Meta::CPAN

    }
    return DW_DLV_OK;
}

/*  Split dwarf CUs can be in an object with non-split
    or split may be in a separate object.
    If all in one object the default is to deal with group_number
    and ignore DW_GROUPNUMBER_DWO.
    If only .dwo the default is DW_GROUPNUMBER_DWO(2).
    Otherwise use DW_GROUP_NUMBER_BASE(1).

 view release on metacpan or  search on metacpan

lib/XTaTIK/Controller/Root.pm  view on Meta::CPAN

            grep exists $_->{number}, $_->{contents}->@*;
    }

    my $title = $self->stash('category') =~ s{^\s*/\s*}{}r;
    $title = $self->xtext('products_nav_name') unless length $title;
    $title = join '/', (split m{\s*/\s*}, $title )[-2,-1]
        if $title =~ tr{/}{} > 1;

    $title =~ s{/}{ / }g;

    my $meta_desc = join ', ', reverse $self->xtext('market'),
        split m{\s*/\s*}, $title;

    $self->stash(
        products    => $products,
        return_path => $return_path,
        return_name => $return_name,

 view release on metacpan or  search on metacpan

etc/generate-schema-html.pl  view on Meta::CPAN

for my $input (sort keys %$data) {
    my $schemas = $data->{ $input };
    my @keys = keys %$schemas;
    for my $key (@keys) {
        my $def = $schemas->{ $key };
        my @schemas = split m/ *, */, $key;
        for my $schema (@schemas) {
            $examples{ $input }->{ $schema } = $def;
        }
    }
}

 view release on metacpan or  search on metacpan

lib/YAML/Tidy.pm  view on Meta::CPAN

sub highlight($self, $yaml, $type = 'ansi') {
    my ($error, $tokens) = YAML::PP::Parser->yaml_to_tokens(string => $yaml);
    if ($error) {
        $tokens = [];
        my @lines = split m/(?<=\n)/, $yaml;
        for my $line (@lines) {
            if ($line =~ s/( +\n)//) {
                push @$tokens, { value => $line, name => 'PLAIN' };
                push @$tokens, { value => $1, name => 'TRAILING_SPACE' };
                next;

 view release on metacpan or  search on metacpan

Lite/LanguageServer/SpecParser.pm  view on Meta::CPAN

sub tokenize_declbody :method {
  (my MY $self, my $declString) = @_;
  [map {s/\s*\z//; $_}
   grep {/\S/}
   split m{(; | [{}(),\|&:]
           | \[ (?=[^]]) | (?<!\[) \]
           | /\*\*\n(?:.*?)\*/ | //[^\n]*\n) \s*}xs, $declString];
}

sub tokenize_comment_block :method {

 view release on metacpan or  search on metacpan

lib/YUI/Loader/Manifest.pm  view on Meta::CPAN

    return @{ $self->{schedule} };
}

sub parse {
    my $self = shift;
    my @_collection = map { split m/\n/ } @_;

    my @collection;
    for (@_collection) {
        next if m/^\s*#/;
        next if m/^\s*<!--/;

 view release on metacpan or  search on metacpan

lib/Yakuake/Sessions/TraitFor/DBus.pm  view on Meta::CPAN

sub _get_current_directory {
   my ($self, $pid) = @_; my $cmd = [ 'pwdx', $pid ];

   my $out = $self->run_cmd( $cmd, { debug => $self->debug } )->stdout;

   return trim( (split m{ : }msx, $out)[ 1 ] );
}

sub _get_executing_command {
   my ($self, $pid, $fgpid) = @_; $pid == $fgpid and return NUL;

lib/Yakuake/Sessions/TraitFor/DBus.pm  view on Meta::CPAN

sub _get_ksession_ids {
   return ( sort   { $a <=> $b }
            map    { m{ name = [\"] (\d+) [\"] }mx }
            grep   { m{ <node \s+ name }mx }
            split m{ \n }msx,
            $_[ 0 ]->service->get_object( '/Sessions' )->Introspect );
}

sub _get_session_at_tab {
   return int $_[ 0 ]->tabs->sessionAtTab( $_[ 1 ] );

lib/Yakuake/Sessions/TraitFor/DBus.pm  view on Meta::CPAN

}

sub _get_session_ids {
   return ( sort   { $a <=> $b }
            map    { int $_ }
            split m{ , }msx, $_[ 0 ]->sessions->sessionIdList );
}

sub _get_session_map {
   return { zip $_[ 0 ]->_get_session_ids, $_[ 0 ]->_get_ksession_ids };
}

lib/Yakuake/Sessions/TraitFor/DBus.pm  view on Meta::CPAN

   my ($self, $ksess_id) = @_; defined $ksess_id or return '?';

   my $pid = $self->_get_session_process_id( $ksess_id );
   my $cmd = [ qw( ps --no-headers -o tty -p ), $pid ];

   return (split m{ [/] }mx, $self->run_cmd( $cmd )->out)[ -1 ];
}

sub _maybe_add_session {
   my ($self, $tab_no) = @_; my $sess_id = $self->_get_active_session_id;

 view release on metacpan or  search on metacpan

eg/todo-app/myapp.pl  view on Meta::CPAN

# Login sessions expire after one week
app->sessions->default_expiration( 60 * 60 * 24 * 7 );

if ( my $path = $ENV{MOJO_REVERSE_PROXY} ) {
    app->sessions->cookie_path( $ENV{MOJO_REVERSE_PROXY} );
    my @parts = grep { $_ } split m{/}, $path;
    app->hook( before_dispatch => sub {
        my ( $c ) = @_;
        my $url = $c->req->url;
        my $base = $url->base;
        # Append to the base path

 view release on metacpan or  search on metacpan

bin/ybapi  view on Meta::CPAN

    api_server => $opt_api_server
);

my %args;
for my $arg (@ARGV) {
    my ($key,$value) = split m/=/, $arg, 2;
    die "invalid key=value pair: $arg" unless defined $value;
    $args{$key} = $value;
}

if ($opt_debug) {

 view release on metacpan or  search on metacpan

lib/Yukki/Model/File.pm  view on Meta::CPAN

        LINE: for my $line ($self->fetch) {
            if ($line =~ /^#\s*(.*)$/) {
                return $1;
            }
            elsif ($line =~ /:/) {
                my ($name, $value) = split m{\s*:\s*}, $line, 2;
                return $value if lc($name) eq 'title';
            }
            else {
                last LINE;
            }

lib/Yukki/Model/File.pm  view on Meta::CPAN

sub store {
    my ($self, $params) = @_;
    my $path = $self->full_path;

    my (@parts) = split m{/}, $path;
    my $blob_name = $parts[-1];

    my $object_id;
    if ($params->{content}) {
        $object_id = $self->make_blob($blob_name, $params->{content});

lib/Yukki/Model/File.pm  view on Meta::CPAN

sub rename {
    my ($self, $params) = @_;
    my $old_path = $self->full_path;

    my (@new_parts) = split m{/}, $params->{full_path};
    my (@old_parts) = split m{/}, $old_path;
    my $blob_name = $old_parts[-1];

    my $object_id = $self->object_id;

    my $old_tree_id = $self->find_root;

lib/Yukki/Model/File.pm  view on Meta::CPAN

sub remove {
    my ($self, $params) = @_;
    my $old_path = $self->full_path;

    my (@old_parts) = split m{/}, $old_path;

    my $old_tree_id = $self->find_root;
    http_throw("unable to locate original tree ID for ".$self->branch)
        unless $old_tree_id;

lib/Yukki/Model/File.pm  view on Meta::CPAN

sub parent {
    my $self = shift;

    my @parts = split m{/}, $self->path;
    return if @parts == 1;

    pop @parts;
    return Yukki::Model::File->new(
        app        => $self->app,

 view release on metacpan or  search on metacpan

lib/Zapp/Task/Request.pm  view on Meta::CPAN

    # ; say Dumper $tx->res;
    my $method = !$tx->res->error ? 'finish' : 'fail';

    my @res_body;
    if ( $tx->res->headers->content_type eq 'application/octet-stream' ) {
        my ( $filename ) = grep !!$_, reverse split m{/}, $input->{url};
        if ( $tx->res->headers->content_disposition =~ m{filename\*?=['"]?([^'"]+)['"]?} ) {
            $filename = $1;
        }
        my $path = $self->app->static->paths->[0];
        my $file = Mojo::File->new( $path, 'task', 'request', $self->id, $filename );

 view release on metacpan or  search on metacpan

t/TestUtil.pm  view on Meta::CPAN

    my ( $scenario, $ns_expressions ) = @_;

    return if ! defined $ns_expressions;

    foreach my $nsexp ( @{ $ns_expressions } ) {
        my ( $ns, $ip ) = split m(/), $nsexp;
        croak "Scenario $scenario: Name server name '$ns' in '$nsexp' is not valid" if $ns !~ /^[0-9A-Za-z-.]+$/;

        if ( $ip ) {
            croak "Scenario $scenario: IP address '$ip' in '$nsexp' is not valid"
                unless validate_ipv4( $ip ) or validate_ipv6( $ip );                

t/TestUtil.pm  view on Meta::CPAN

        subtest $scenario => sub {
            if ( @$undelegated_ns ) {
                my %undel_ns;
                foreach my $nsexp ( @$undelegated_ns ) {
                    my ( $ns, $ip ) = split m(/), $nsexp;
                    $undel_ns{$ns} //= [];
                    push @{ $undel_ns{$ns} }, $ip if $ip;
                }

                # Use default value of "fill_in_empty_oob_glue".

t/TestUtil.pm  view on Meta::CPAN

        subtest $scenario => sub {

            if ( @$undelegated_ns ) {
                my %undel_ns;
                foreach my $nsexp ( @$undelegated_ns ) {
                    my ($ns, $ip) = split m(/), $nsexp;
                    $undel_ns{$ns} //= [];
                    push @{ $undel_ns{$ns} }, $ip if $ip;
                }

                # Use default value of "fill_in_empty_oob_glue".

 view release on metacpan or  search on metacpan

local/lib/perl5/Module/Build/Base.pm  view on Meta::CPAN

           @{ $self->rscan_dir($dir, $self->file_qr("\\.$type\$")) } };
}

sub localize_file_path {
  my ($self, $path) = @_;
  return File::Spec->catfile( split m{/}, $path );
}

sub localize_dir_path {
  my ($self, $path) = @_;
  return File::Spec->catdir( split m{/}, $path );
}

sub fix_shebang_line { # Adapted from fixin() in ExtUtils::MM_Unix 1.35
  my ($self, @files) = @_;
  my $c = ref($self) ? $self->{config} : 'Module::Build::Config';

 view release on metacpan or  search on metacpan

t/integration/cli-zuzuzoo.t  view on Meta::CPAN

	my $root_name = "$name-$version";
	my $dist_root = File::Spec->catdir( $tmp, $root_name );
	my $module_path = File::Spec->catfile(
		$dist_root,
		'modules',
		split m{/}, "$module.zzm",
	);
	my $meta_path = File::Spec->catfile(
		$dist_root,
		'zuzu-distribution.json',
	);

t/integration/cli-zuzuzoo.t  view on Meta::CPAN

	my ( $home, $module ) = @_;
	return File::Spec->catfile(
		$home,
		'.zuzu',
		'modules',
		split m{/}, "$module.zzm",
	);
}

sub decode_json_output {
	my ( $text ) = @_;