view release on metacpan or  search on metacpan

src/README.osx  view on Meta::CPAN

----------------

Building on Mac OS X Leopard : 

Install the xcode dev tools from the Leopard disk. 
When installing the dev tools make sure to have installed 10.3.9 SDK (it's not selected by default). 

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

use warnings;
use ExtUtils::MakeMaker;
use Alien::Build::MM;

if ( -e '.gitignore' ) {
    system('podselect lib/Alien/Gearman.pm > README.pod');
}

if ( $^O eq 'MSWin32' ) {
    print STDERR "Win32 is currently not supported";
    exit(0);

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

1.20   07.01.2009
  - Element.autoScroll : fix scroll amount when the scrolling block has
    an offsetTop > 0
  - removed PAGE_UP/DOWN handlers in TreeNavigator -- let the browser deal 
    with those
  - treeNavigator select() has an additional param "prevent_autoscroll"
  - treeNavigator autoscroll only active through kbd, not through click
  - treeNavigator observes "mouseup" (instead of mousedown or click)
  - autoCompleter bug fix on detach (stop observing "click")
  - protoExtensions : removed RegExp.escape() (now in prototype.js)
  - autoCompleter div, display above only if enough vertical space

 view release on metacpan or  search on metacpan

inc/My/Builder/Unix.pm  view on Meta::CPAN

    my $msg = "\nYou have the following build options available:\n" .
              join("\n", map ($n++ . ") $_", @build_opts)) .
	      "\nWhat do you wanna build?";
    my $i = $ENV{TRAVIS} ? 1 : $self->prompt($msg, 1);
    $build_target = $build_opts[$i-1];
    die "###ERROR### Wrong selection!" unless $build_target;
  }
  else {
    warn "###WARNING### No supported GUI subsystem detected!\n";
  }

 view release on metacpan or  search on metacpan

src/judy-1.0.5/aclocal.m4  view on Meta::CPAN

for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
  test ! -f $lt_ac_sed && continue
  cat /dev/null > conftest.in
  lt_ac_count=0
  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
  # Check for GNU sed and select it if it is found.
  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
    lt_cv_path_SED=$lt_ac_sed
    break
  fi
  while true; do

 view release on metacpan or  search on metacpan

lib/Alien/Keystone.pm  view on Meta::CPAN

Vikas N Kumar <vikas@cpan.org>

=head1 REPOSITORY

L<https://github.com/selectiveintellect/p5-alien-keystone.git>

=head1 COPYRIGHT

Copyright (C) 2016. Selective Intellect LLC <github@selectiveintellect.com>. All Rights Reserved.

=head1 LICENSE

This is free software under the MIT license.

 view release on metacpan or  search on metacpan

tidyall.ini  view on Meta::CPAN

[PerlTidy]
select = **/*.{pl,pm,t}
ignore = lib/CXC/SAOTrace/Optics/Config/TS/Grammar.pm
argv = --noprofile -se -w -conv -pt=0 -sot -sct -bbao -fbl -blbs=2 -nolq -nsbl -nvmll -tso

 view release on metacpan or  search on metacpan

libjit/ChangeLog  view on Meta::CPAN

	function that should finally optimize relative instructions
	correctly.

2007-06-10  Aleksey Demakov  <ademakov@gmail.com>

	* tools/gen-rules-parser.y (gensel_output_clauses): alter selection
	logic so that "reg" rules are chosen over "local" in case the value
	is used again in the same basic block.

	* jit/jit-rules-x86.ins: tweak COPY rules for bytes, shorts, and
	ints.

libjit/ChangeLog  view on Meta::CPAN

	function is not used with the x86 backend.

	* jit/jit-reg-alloc.c: improve handling of three-address op codes.
	Now the dest register may re-use one of the input registers while
	previously it was always assigned to a separate register. Also
	restructure the code that will be used for better selection of x87
	instructions (this code was not used before and still is not but
	this is about to change).

	* jit/jit-rules-x86.ins: rewrite all LOAD_RELATIVE and LOAD_ELEMENT
	ops for x86 as three-address. Adjust IREM ops so that they work

libjit/ChangeLog  view on Meta::CPAN

	* tools/gen-rules-scanner.l, tools/gen-rules-parser.y: add `any'
	keyword.

2006-04-18  Aleksey Demakov  <ademakov@gmail.com>

	* jit/jit-rules-x86.ins: add instruction selection rules for new
	register allocator.
	* jit/Makefile.am: build new instruction selection rules.
	* configure.in: add --enable-new-reg-alloc option.

2006-04-14  Aleksey Demakov  <ademakov@gmail.com>

	* jit/jit-reg-alloc.h, jit/jit-reg-alloc.c: new register allocator

libjit/ChangeLog  view on Meta::CPAN

	parameter passing; fix fastcall/stdcall conventions for x86.

	* jit/jit-rules-arm.h, jit/jit-rules-arm.sel, jit/jit-rules-x86.h,
	jit/jit-rules-x86.sel, tools/gen-sel-parser.y: enable register
	allocation for 64-bit values under x86 and ARM; expand some
	64-bit opcodes in the instruction selectors.

2004-06-12  Rhys Weatherley  <rweather@southern-storm.com.au>

	* jit/jit-insn.c, jit/jit-rules-x86.c, jit/jit-rules-x86.sel:
	implement or stub missing x86 instruction selection rules.

	* include/jit/jit-insn.h, include/jit/jit-opcode.h,
	include/jit/jit-plus.h, jit/jit-function.c, jit/jit-insn.c,
	jit/jit-interp.c, jit/jit-opcode.c, jit/jit-rules-interp.c,
	jitplus/jit-plus-function.cpp: add the "outgoing_frame_posn"

libjit/ChangeLog  view on Meta::CPAN

	* include/jit/jit-opcode.h, jit/jit-interp.c, jit/jit-opcode.c:
	remove obsolete opcodes which violate "_jit_load_opcode"'s rules.

	* jit/jit-reg-alloc.c, jit/jit-rules-x86.c, jit/jit-rules-x86.sel:
	more x86 instruction selection rules.

	* jit/jit-reg-alloc.c (_jit_regs_set_outgoing): implement
	missing function.

	* jit/jit-gen-arm.h (arm_call): use a more efficient form of

libjit/ChangeLog  view on Meta::CPAN

	* jit/jit-cache.c, jit/jit-elf-read.c, tools/gen-apply.c:
	fix some gcc 3.x compile warnings.

	* jit/jit-rules-arm.c, jit/jit-rules-arm.sel: more instruction
	selection rules for ARM.

	* configure.in, jit/jit-rules.h: enable the x86 back end by
	default on platforms where it makes sense, and add the option
	"--enable-interpreter" to "configure".

libjit/ChangeLog  view on Meta::CPAN

	* jit/jit-insn.c (jit_insn_convert): use intrinsic functions
	for conversions when the back end doesn't support the opcode.

	* jit/jit-rules-x86.sel, tools/gen-sel-parser.y,
	tools/gen-sel-scanner.l: improve instruction selection for
	floating-point "push" operations.

	* include/jit/jit-insn.h, jit/jit-insn.c, jit/jit-internal.h,
	jit/jit-rules-x86.c: add "jit_insn_defer_pop_stack" and
	"jit_insn_flush_defer_pop", to defer the popping of function

libjit/ChangeLog  view on Meta::CPAN

	jit/jit-insn.c: add "jit_block_current_is_dead" to simplify
	testing if the last block is reachable or not, taking empty
	trailing blocks into account.

	* jit/jit-rules-x86.c, jit/jit-rules-x86.sel, tools/gen-sel-parser.y,
	tools/gen-sel-scanner.l: more selection cases for the x86 back end.

	* jit/Makefile.am, jit/jit-gen-arm.h, jit/jit-rules-arm.c,
	jit/jit-rules-arm.sel: add the beginnings of the instruction
	selector for ARM.

2004-05-25  Rhys Weatherley  <rweather@southern-storm.com.au>

	* tools/.cvsignore, tools/Makefile.am, tools/gen-sel-parser.y,
	tools/gen-sel-scanner.l: add the "gen-sel" program to the tree,
	to assist with building native instruction selectors.

	* jit/.cvsignore, jit/Makefile.am, jit/jit-rules-x86.c,
	jit/jit-rules-x86.sel, tools/gen-sel-parser.y: check in the
	initial instruction selector for x86 (incomplete).

	* jit/jit-rules-x86.sel, tools/gen-sel-parser.y,
	tools/gen-sel-scanner.l: selectors for branch instructions.

	* jit/jit-rules-x86.sel: selectors for call instructions.

2004-05-24  Rhys Weatherley  <rweather@southern-storm.com.au>

	* include/jit/jit-insn.h, include/jit/jit-opcode.h, jit/jit-block.c,
	jit/jit-dump.c, jit/jit-except.c, jit/jit-function.c, jit/jit-insn.c,

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

use warnings;
use ExtUtils::MakeMaker;
use Alien::Build::MM;

if ( -e '.gitignore' ) {
    system('podselect lib/Alien/Libevent.pm > README.pod');
}

if ( $^O eq 'MSWin32' ) {
    print STDERR "Win32 is currently not supported";
    exit(0);

 view release on metacpan or  search on metacpan

libjio/UPGRADING  view on Meta::CPAN

  - jtrans_commit() returns -1 on recovered errors, -2 on unrecovered errors
    (which are an indication of a severe underlying condition).
  - jtrans_add() returns 0 on success and -1 on errors (it used to return 1 on
    success and 0 on errors).
  - jfsck() now has an additional "flags" parameter, which should be set to 0
    to select the default behaviour.
  - jfsck_cleanup() was removed, and now jfsck() cleans up by default.

-> 0.25
  - It is no longer necessary to pass O_SYNC to jopen() if lingering
    transactions are not in use.

 view release on metacpan or  search on metacpan

patch/Net-SSLeay.diff  view on Meta::CPAN

     res = POPi;
     if (res) {
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+	STRLEN newsecretlen;
+#endif
         /* See if there is a preferred cipher selected, if so it is an index into the stack */
         if (SvIOK(pref_cipher))
             *cipher = sk_SSL_CIPHER_value(peer_ciphers, SvIV(pref_cipher));
 
 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 	/* Use any new master secret set by the callback function in secret */

 view release on metacpan or  search on metacpan

corpus/config.guess  view on Meta::CPAN

case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
    *:NetBSD:*:*)
	# NetBSD (nbsd) targets should (where applicable) match one or
	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
	# switched to ELF, *-*-netbsd* would select the old
	# object file format.  This provides both forward
	# compatibility and a consistent mechanism for selecting the
	# object file format.
	#
	# Note: NetBSD doesn't particularly care about the vendor
	# portion of the name.  We always set it to "unknown".
	sysctl="sysctl -n hw.machine_arch"

 view release on metacpan or  search on metacpan

tidyall.ini  view on Meta::CPAN

[PerlTidy]
select = **/*.{pl,pm,t}
select = alienfile
argv = --profile=perltidy.rc -nst

 view release on metacpan or  search on metacpan

tidyall.ini  view on Meta::CPAN

[PerlTidy]
select = **/*.{pl,pm,t}
select = alienfile
argv = --profile=perltidy.rc -nst

 view release on metacpan or  search on metacpan

tidyall.ini  view on Meta::CPAN

[PerlTidy]
select = **/*.{pl,pm,t}
argv = --noprofile -se -w -conv -pt=0 -sot -sct -bbao -fbl -blbs=2 -nolq -nsbl -nvmll -tso

 view release on metacpan or  search on metacpan

prototype.js  view on Meta::CPAN

};

Object.extend(Enumerable, {
  map:     Enumerable.collect,
  find:    Enumerable.detect,
  select:  Enumerable.findAll,
  filter:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray,
  every:   Enumerable.all,
  some:    Enumerable.any

prototype.js  view on Meta::CPAN

  last: function() {
    return this[this.length - 1];
  },

  compact: function() {
    return this.select(function(value) {
      return value != null;
    });
  },

  flatten: function() {

prototype.js  view on Meta::CPAN

    });
  },

  without: function() {
    var values = $A(arguments);
    return this.select(function(value) {
      return !values.include(value);
    });
  },

  reverse: function(inline) {

prototype.js  view on Meta::CPAN

    element = $(element);
    if (content && content.toElement) content = content.toElement();
    else if (!Object.isElement(content)) {
      content = Object.toHTML(content);
      var range = element.ownerDocument.createRange();
      range.selectNode(element);
      content.evalScripts.bind(content).defer();
      content = range.createContextualFragment(content.stripScripts());
    }
    element.parentNode.replaceChild(content, element);
    return element;

prototype.js  view on Meta::CPAN

  siblings: function(element) {
    element = $(element);
    return element.previousSiblings().reverse().concat(element.nextSiblings());
  },

  match: function(element, selector) {
    if (Object.isString(selector))
      selector = new Selector(selector);
    return selector.match($(element));
  },

  up: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(element.parentNode);

prototype.js  view on Meta::CPAN

    var nextSiblings = element.nextSiblings();
    return expression ? Selector.findElement(nextSiblings, expression, index) :
      nextSiblings[index || 0];
  },

  select: function() {
    var args = $A(arguments), element = $(args.shift());
    return Selector.findChildElements(element, args);
  },

  adjacent: function() {

prototype.js  view on Meta::CPAN

};

Element.Methods.identify.counter = 1;

Object.extend(Element.Methods, {
  getElementsBySelector: Element.Methods.select,
  childElements: Element.Methods.immediateDescendants
});

Element._attributeTranslations = {
  write: {

prototype.js  view on Meta::CPAN

      onkeypress:  v._getEv,
      onkeydown:   v._getEv,
      onkeyup:     v._getEv,
      onsubmit:    v._getEv,
      onreset:     v._getEv,
      onselect:    v._getEv,
      onchange:    v._getEv
    });
  })(Element._attributeTranslations.read.values);
}

prototype.js  view on Meta::CPAN

    adjacency: 'afterBegin',
    insert: function(element, node) {
      element.insertBefore(node, element.firstChild);
    },
    initializeRange: function(element, range) {
      range.selectNodeContents(element);
      range.collapse(true);
    }
  },
  bottom: {
    adjacency: 'beforeEnd',

prototype.js  view on Meta::CPAN

  tags: {
    TABLE:  ['<table>',                '</table>',                   1],
    TBODY:  ['<table><tbody>',         '</tbody></table>',           2],
    TR:     ['<table><tbody><tr>',     '</tr></tbody></table>',      3],
    TD:     ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
    SELECT: ['<select>',               '</select>',                  1]
  }
};

(function() {
  this.bottom.initializeRange = this.top.initializeRange;

prototype.js  view on Meta::CPAN

    while (e && le !== e && (/\S/).test(e)) {
      le = e;
      for (var i in ps) {
        p = ps[i];
        if (m = e.match(p)) {
          // use the Selector.assertions methods unless the selector
          // is too complex.
          if (as[i]) {
            this.tokens.push([i, Object.clone(m)]);
            e = e.replace(m[0], '');
          } else {

prototype.js  view on Meta::CPAN

    laterSibling: /^\s*~\s*/,
    child:        /^\s*>\s*/,
    adjacent:     /^\s*\+\s*/,
    descendant:   /^\s/,

    // selectors follow
    tagName:      /^\s*(\*|[\w\-]+)(\b|$)?/,
    id:           /^#([\w\-\*]+)(\b|$)/,
    className:    /^\.([\w\-\*]+)(\b|$)/,
    pseudo:       /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s)|(?=:))/,
    attrPresence: /^\[([\w]+)\]/,

prototype.js  view on Meta::CPAN

        results.push(node);
      }
      return results;
    },

    'not': function(nodes, selector, root) {
      var h = Selector.handlers, selectorType, m;
      var exclusions = new Selector(selector).findElements(root);
      h.mark(exclusions);
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!node._counted) results.push(node);
      h.unmark(exclusions);
      return results;

prototype.js  view on Meta::CPAN

    var exprs = expressions.join(','), expressions = [];
    exprs.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
      expressions.push(m[1].strip());
    });
    var results = [], h = Selector.handlers;
    for (var i = 0, l = expressions.length, selector; i < l; i++) {
      selector = new Selector(expressions[i].strip());
      h.concat(results, selector.findElements(element));
    }
    return (l > 1) ? h.unique(results) : results;
  }
});

prototype.js  view on Meta::CPAN

    var firstByIndex = elements.findAll(function(element) {
      return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
    }).sortBy(function(element) { return element.tabIndex }).first();

    return firstByIndex ? firstByIndex : elements.find(function(element) {
      return ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
    });
  },

  focusFirstElement: function(form) {
    form = $(form);

prototype.js  view on Meta::CPAN

  focus: function(element) {
    $(element).focus();
    return element;
  },

  select: function(element) {
    $(element).select();
    return element;
  }
};

Form.Element.Methods = {

prototype.js  view on Meta::CPAN

  activate: function(element) {
    element = $(element);
    try {
      element.focus();
      if (element.select && (element.tagName.toLowerCase() != 'input' ||
          !['button', 'reset', 'submit'].include(element.type)))
        element.select();
    } catch (e) { }
    return element;
  },

  disable: function(element) {

prototype.js  view on Meta::CPAN

  textarea: function(element, value) {
    if (value === undefined) return element.value;
    else element.value = value;
  },

  select: function(element, index) {
    if (index === undefined)
      return this[element.type == 'select-one' ?
        'selectOne' : 'selectMany'](element);
    else {
      var opt, value, single = !Object.isArray(index);
      for (var i = 0, length = element.length; i < length; i++) {
        opt = element.options[i];
        value = this.optionValue(opt);
        if (single) {
          if (value == index) {
            opt.selected = true;
            return;
          }
        }
        else opt.selected = index.include(value);
      }
    }
  },

  selectOne: function(element) {
    var index = element.selectedIndex;
    return index >= 0 ? this.optionValue(element.options[index]) : null;
  },

  selectMany: function(element) {
    var values, length = element.length;
    if (!length) return null;

    for (var i = 0, values = []; i < length; i++) {
      var opt = element.options[i];
      if (opt.selected) values.push(this.optionValue(opt));
    }
    return values;
  },

  optionValue: function(opt) {

prototype.js  view on Meta::CPAN

  initialize: function(element) {
    this.element = $(element);
  },

  _each: function(iterator) {
    this.element.className.split(/\s+/).select(function(name) {
      return name.length > 0;
    })._each(iterator);
  },

  set: function(className) {

 view release on metacpan or  search on metacpan

tidyall.ini  view on Meta::CPAN

[PerlTidy]
select = **/*.{pl,pm,t}
select = alienfile
argv = --profile=perltidy.rc -nst

 view release on metacpan or  search on metacpan

inc/inc_File-Fetch/File/Fetch.pm  view on Meta::CPAN

        my $path = File::Spec::Unix->catfile( $self->path, $self->file );
        my $req = "GET $path HTTP/1.0\x0d\x0aHost: " . $self->host . "\x0d\x0a\x0d\x0a";
        $sock->send( $req );

        my $select = IO::Select->new( $sock );

        my $resp = '';
        my $normal = 0;
        while ( $select->can_read( $TIMEOUT || 60 ) ) {
          my $ret = $sock->sysread( $resp, 4096, length($resp) );
          if ( !defined $ret or $ret == 0 ) {
            $select->remove( $sock );
            $normal++;
          }
        }
        close $sock;

 view release on metacpan or  search on metacpan

corpus/autoheck-libpalindrome/config.guess  view on Meta::CPAN

case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
    *:NetBSD:*:*)
	# NetBSD (nbsd) targets should (where applicable) match one or
	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
	# switched to ELF, *-*-netbsd* would select the old
	# object file format.  This provides both forward
	# compatibility and a consistent mechanism for selecting the
	# object file format.
	#
	# Note: NetBSD doesn't particularly care about the vendor
	# portion of the name.  We always set it to "unknown".
	sysctl="sysctl -n hw.machine_arch"

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

    }

    $prompt_string .= "[" . $i++ . "] " . $c->{title} . "\n";
  }

  # select option '1' for travis
  if ( defined $travis and $travis == 1 ) {
    $ans = 1;
  }

# or prompt user for build option

 view release on metacpan or  search on metacpan

inc/My/Builder.pm  view on Meta::CPAN

    }
    elsif ( $bp->{buildtype} eq 'build_from_sources' ) {

        my $m = '';
        if ( $self->notes('travis') && $self->notes('travis') == 1 ) {
            # always select option '1'
            $m = 1;
        }
        else {
            $m = $self->prompt(
"\nDo you want to see all messages during configure/make (y/n)?",

 view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/swig/perl/native/Client.pm  view on Meta::CPAN

If both revision arguments are either svn_opt_revision_unspecified or NULL,
then information will be pulled solely from the working copy; no network
connections will be made.

Otherwise, information will be pulled from a repository.  The actual node
revision selected is determined by the $path_or_url as it exists in
$peg_revision.  If $peg_revision is undef, then it defaults to HEAD for URLs
or WORKING for WC targets.

If $path_or_url is not a local path, then if $revision is PREV (or some other
kind that requires a local path), an error will be returned, because the

 view release on metacpan or  search on metacpan

inc/IPC/Cmd.pm  view on Meta::CPAN

    };


    return (undef, $@) if $@;

    my $sel = IO::Select->new; # create a select object
    $sel->add($outfh, $errfh); # and add the fhs

    STDOUT->autoflush(1); STDERR->autoflush(1);
    $outfh->autoflush(1) if UNIVERSAL::can($outfh, 'autoflush');
    $errfh->autoflush(1) if UNIVERSAL::can($errfh, 'autoflush');

 view release on metacpan or  search on metacpan

lib/Alien/SeqAlignment/hmmer3.pm  view on Meta::CPAN

  system Alien::SeqAlignment::hmmer3->esl_construct  (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_histplot   (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_mask       (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_mixdchlet  (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_reformat   (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_selectn    (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_seqrange   (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_seqstat    (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_sfetch     (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_shuffle    (parameters & options);
  system Alien::SeqAlignment::hmmer3->esl_ssdraw     (parameters & options);

lib/Alien/SeqAlignment/hmmer3.pm  view on Meta::CPAN

=head2 esl_reformat

  Alien::SeqAlignment::hmmer3->esl_reformat (parameters & options);
esl_reformat - convert sequence file formats

=head2 esl_selectn

  Alien::SeqAlignment::hmmer3->esl_selectn (parameters & options);
esl_selectn - select random subset of lines from file

=head2 esl_seqrange

  Alien::SeqAlignment::hmmer3->esl_seqrange (parameters & options);
esl_seqrange - determine a range of sequences for one of many parallel

 view release on metacpan or  search on metacpan

share/swagger-ui-bundle.js  view on Meta::CPAN

!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(function(){try{return require("esprima")}catch(e){}}()):"function"==typeof define&&define.amd?define(["esprima"],t):"object"==typeof exports?exports.SwaggerUIBundle=t(f...
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/var r=Object.getOwnPropertySymbols,o=Object.prototype.hasOwnProperty,i=Object.prototype.propertyIsEnumerable;function a(e){if(null==e)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(e)}e.exports=function()...
/*!
  Copyright (c) 2017 Jed Watson.
  Licensed under the MIT License (MIT), see
  http://jedwatson.github.io/classnames
*/
/*!
  Copyright (c) 2017 Jed Watson.
  Licensed under the MIT License (MIT), see
  http://jedwatson.github.io/classnames
*/
!function(){"use strict";var n={}.hasOwnProperty;function o(){for(var e=[],t=0;t<arguments.length;t++){var r=arguments[t];if(r){var i=typeof r;if("string"===i||"number"===i)e.push(r);else if(Array.isArray(r)&&r.length){var a=o.apply(null,r);a&&e.push...
/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
 * @license  MIT
 */
var r=n(569),o=n(570),i=n(355);function a(){return u.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function s(e,t){if(a()<t)throw new RangeError("Invalid typed array length");return u.TYPED_ARRAY_SUPPORT?(e=new Uint8Array(t)).__proto__=u.prototype:(null=...
/*!
 * @description Recursive object extending
 * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
 * @license MIT
 *

share/swagger-ui-bundle.js  view on Meta::CPAN

 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
function n(e){return e instanceof t||e instanceof Date||e instanceof RegExp}function r(e){if(e instanceof t){var n=t.alloc?t.alloc(e.length):new t(e.length);return e.copy(n),n}if(e instanceof Date)return new Date(e.getTime());if(e instanceof RegExp)r...
/**
 * Checks if an event is supported in the current execution environment.
 *
 * NOTE: This will not work correctly for non-generic events such as `change`,
 * `reset`, `load`, `error`, and `select`.
 *
 * Borrows from Modernizr.
 *
 * @param {string} eventNameSuffix Event name, e.g. "click".
 * @param {?boolean} capture Check if the capture phase is supported.

share/swagger-ui-bundle.js  view on Meta::CPAN

/*!
 * https://github.com/Starcounter-Jack/JSON-Patch
 * (c) 2017 Joachim Wester
 * MIT license
 */
var n=this&&this.__extends||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n]);function r(){this.constructor=e}e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},r=Object.prototype.hasOwnProperty;function o(e,t){return ...
/** @license React v16.8.6
 * react-is.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */Object.defineProperty(t,"__esModule",{value:!0});var r="function"==typeof Symbol&&Symbol.for,o=r?Symbol.for("react.element"):60103,i=r?Symbol.for("react.portal"):60106,a=r?Symbol.for("react.fragment"):60107,s=r?Symbol.for("react.strict_mode"):6010...
/*!
 * https://github.com/Starcounter-Jack/JSON-Patch
 * (c) 2017 Joachim Wester
 * MIT license
 */

share/swagger-ui-bundle.js  view on Meta::CPAN

 *
 * Copyright(c) 2016 Gregory Jacobs <greg@greg-jacobs.com>
 * MIT License
 *
 * https://github.com/gregjacobs/Autolinker.js
 */o=[],void 0===(i="function"==typeof(r=function(){var e,t,n,r,o,i,a,s=function(e){e=e||{},this.version=s.version,this.urls=this.normalizeUrlsCfg(e.urls),this.email="boolean"!=typeof e.email||e.email,this.twitter="boolean"!=typeof e.twitter||e.twitt...
//# sourceMappingURL=swagger-ui-bundle.js.map

 view release on metacpan or  search on metacpan

lib/Alien/Taco/Server.pm  view on Meta::CPAN

=item new()

Set up a L<Alien::Taco::Transport> object communicating via
C<STDIN> and C<STDOUT>.

C<STDERR> is selected as the current stream to try to avoid
any subroutine or method calls printing to C<STDOUT> which would
corrupt communications with the client.

=cut

lib/Alien/Taco/Server.pm  view on Meta::CPAN

    }, $class;

    # Select STDERR as current file handle so that if a function is
    # called which in turn prints something, it doesn't go into the
    # transport stream.
    select(STDERR);

    $self->{'xp'} = $self->_construct_transport(*STDIN, *STDOUT);

    return $self;
}

 view release on metacpan or  search on metacpan

patches/config.guess  view on Meta::CPAN

case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
    *:NetBSD:*:*)
	# NetBSD (nbsd) targets should (where applicable) match one or
	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
	# switched to ELF, *-*-netbsd* would select the old
	# object file format.  This provides both forward
	# compatibility and a consistent mechanism for selecting the
	# object file format.
	#
	# Note: NetBSD doesn't particularly care about the vendor
	# portion of the name.  We always set it to "unknown".
	sysctl="sysctl -n hw.machine_arch"

 view release on metacpan or  search on metacpan

src/elf.h  view on Meta::CPAN

#define DT_AUXILIARY    0x7ffffffd      /* Shared object to load before self */
#define DT_FILTER       0x7fffffff      /* Shared object to get values from */
#define DT_EXTRATAGIDX(tag)     ((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
#define DT_EXTRANUM     3

/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1
   entry in the dynamic section.  */
#define DF_1_NOW        0x00000001      /* Set RTLD_NOW for this object.  */
#define DF_1_GLOBAL     0x00000002      /* Set RTLD_GLOBAL for this object.  */
#define DF_1_GROUP      0x00000004      /* Set RTLD_GROUP for this object.  */
#define DF_1_NODELETE   0x00000008      /* Set RTLD_NODELETE for this object.*/