Main > Free Download Search >

Free reference software for linux

reference

Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 1073
cb2Bib 1.3.1

cb2Bib 1.3.1


The cb2Bib is a tool for rapidly extracting unformatted biblographic references from email alerts. more>>
cb2Bib 1.3.1 is a useful tool used for rapidly extracting unformatted biblographic references from email alerts.

The cb2Bib reads the clipboard text contents and process it against a set of predefined patterns. If this automatic detection is successful, cb2Bib formats the clipboard data according to the structured BibTeX reference standard.

Otherwise, if no predefined format pattern is found or if detection proves to be difficult, manual data extraction is greatly simplified by cb2Bib. In most cases, such manual data extraction will provide with a new, personalized pattern to be included within the predefined pattern set for future automatic extractions.

Once the bibliographic reference is correctly extracted, it is added to a specified BibTeX database file. Optionally, article PDF files, if available, are renamed to its citeID and moved to a desired directory as a personal article library

Major Features:

  1. Select the reference to import from the email or web browser: On Unix machines, cb2Bib automatically detects mouse selections and clipboard changes. On Windows machines, copy or Ctrl-C is necessary to activate cb2Bib automatic processing.
  2. cb2Bib automatic processing: Once text is selected cb2Bib initiates the automatic reference extraction. It uses the predefined patterns from file regexp.txt to attempt automatic extraction. See Configuring Files section for setting the user predefined pattern matching expression file. After a successful detection bibliographic fields appear on the cb2Bib item line edits. Manual editing is possible at this stage.
  3. cb2Bib manual processing: If no predefined format pattern is found or if detection proves to be difficult, a manual data extraction must be performed. Select individual reference items from the cb2Bib clipboard area. A popup menu will appear after selection is made. Choose the corresponding bibliographic field. See BiBTeX Entry Types available as cb2Bib fields. Selection is post-processed and added to the cb2Bib item line edit. cb2Bib field tags will show on the cb2Bib clipboard area. Once the manual processing is done, cb2Bib clipboard area will contain the matching pattern. The pattern can be further edited and stored to the regexp.txt file using Insert Regular Expression, Alt+I. See the Extracting Data from the Clipboard and The Regular Expression Editor sections.
  4. Download reference to cb2Bib: The cb2Bib has the built-in functionality to interact with publishers "Download reference to Citation Manager" service. Choose BibTeX format, or any other format that you can translate using External Clipboard Preparsing Command. See Additional, Keyboard Functionality, Alt C. Click "Download" from your browser. When asked "Open with..." select cb2Bib. The cb2Bib will be launched if no running instance is found. If already running, it will place the downloaded reference to the clipboard, and it will start processing. Make sure your running instance is aware of clipboard changes. See Buttons Functionality. For convenience, the shell script c2bimport, and the desktop config file c2bimport.desktop are also provided.
  5. Adding documents: PDF and other documents can be added to the BibTeX reference by dragging the file icon and dropping it into the cb2Bib's panel. Optionally, document files, are renamed to its citeID and moved to a desired directory as a personal article library (See Configuring Documents section). Linked to a reference documents correspond to the BibTeX tag file. Usual reference manager software will permit to retrieve and visualize these files. Download, copy and/or moving is scheduled and performed once the reference is accepted, e.g., once it is saved by pressing Save Reference button.
  6. Multiple retrieving from PDF files: Multiple PDF or convertible to text files can be sequentially processed by dragging a set of files into cb2Bib's PDFImport dialog. By starting the processing button, files are sequentially converted to text and send to cb2Bib clipboard panel for reference extraction. See PDF Reference Import for details.
  7. Journal-Volume-Page Queries: Takes input Journal, Volume, and first page from the corresponding edit lines and attempts to complete the reference. Additionally, queries consider Title, DOI, and an excerpt, which is a simplified clipboard panel contents. See Configuring Network section, the distribution file netqinf.txt, and Release Note cb2Bib 0.3.5 for customization and details.
  8. BibTeX Editor: cb2Bib includes a practical text editor suitable for corrections and additions. cb2Bib capabilities are readily available within the editor. E.g., the reference is first sent to cb2Bib by selecting it, and later retrieved from cb2Bib to the editor using 'right click' + 'Paste Current BibTeX'. Interconversions Unicode LaTeX, long abbreviated journal name, and adding/renaming PDF files are easily available. BibTeX Editor is also accessible through a shell command line.
  9. Advanced features, and processing and extraction details are described in the following sections:
    • Extracting Data from the Clipboard
    • Processing of author's names
    • Processing of journal names
    • Field Recognition Rules
    • The Regular Expression Editor
  10. Configuration information is described in the following sections:
    • Configuration
    • Predefined cite ID placeholders
  11. Utilities and modules are described in the following sections:
    • Search BibTeX files for references
    • Embedded File Editor
    • PDF Reference Import
    • The cb2Bib Command Line
    • Reading and writing bibliographic metadata
    • The cb2Bib Annote
    • The cb2Bib Citer

Enhancements:

  • Added Check Repeated functionality for current reference
  • Fixed parser not processing last field in inverted comma style BibTeX
  • Set netqinf.txt to use internal XML parser for PubMed
  • Fixed packaging, double copying scripts and initial external tool setting
  • Fixed c2bciter script not passing all arguments (Thanks to F. Rusconi)

Requirements:

To compile cb2Bib, the following libraries must be present and accessible:

  • Qt 4.4.0 or higher from Trolltech. On a Linux platform with Qt preinstalled, make sure that the devel packages and Qt tools are also present.
  • WebKit library (optional) to compile cb2Bib Annote viewer. It is already included in Qt > 4.4.0 library. No special action/flag is needed during compilation.
  • X11 header files if compiling on Unix platforms. Concretely, headers X11/Xlib.h and X11/Xatom.h are needed.
  • The header files fcntl.h and unistd.h from glibc-devel package are also required. Otherwise compilation will fail with reference list.cpp:227: `close' undeclared.
<<less
Added: 2009-06-30 License: GPL Price: FREE
14 downloads
Advanced Bash Scripting Guide 5.4

Advanced Bash Scripting Guide 5.4


Complete ebook tutorial and reference on shell scripting with Bash in Linux/UNIX/BSD. This is the equivalent of a 918-page printed book. more>>

Complete ebook tutorial and reference on shell scripting with Bash in Linux/UNIX/BSD. This is the equivalent of a 918-page printed book. Includes shell scripts that emulate games, such as Perquackey and Nim. It is an official Linux Documentation Project (http://www.tldp.org) Guide. Some reviewers have named it the best book available on the subject.

Requirements: Web Browser or PDF viewer

Whats new in this version: New material, updates, bugfixes, stylistic revisions

<<less
Download (2.85MB)
Added: 2009-04-03 License: Freeware Price: $0
250 downloads
 
Other version of Advanced Bash Scripting Guide
Advanced Bash Scripting Guide 5.0M. Leo Cooper - The Advanced Bash Scripting Guide is both a reference and a tutorial on shell scripting. Advanced Bash Scripting Guide. This tutorial assumes no
License:(FDL) GNU Free Documentation License
Download (0.74MB)
892 downloads
Added: 2007-06-21
Math::Amoeba 0.04

Math::Amoeba 0.04


Math::Amoeba is a Multidimensional Function Minimization. more>>
Math::Amoeba is a Multidimensional Function Minimization.

SYNOPSIS

use Math::Amoeba qw(ConstructVertices EvaluateVertices Amoeba MinimiseND);
my ($vertice,$y)=MinimiseND(@guess,@scales,&func,$tol,$itmax,$verbose);
my @vertices=ConstructVertices(@vector,@offsets);
my @y=EvaluateVertices(@vertices,&func);
my ($vertice,$y)=Amoeba(@vertices,@y,&func,$tol,$itmax,$verbose);

This is an implementation of the Downhill Simpex Method in Multidimensions (Nelder and Mead) for finding the (local) minimum of a function. Doing this in Perl makes it easy for that function to actually be the output of another program such as a simulator.

Arrays and the function are passed by reference to the routines.

The simplest use is the MinimiseND function. This takes a reference to an array of guess values for the parameters at the function minimum, a reference to an array of scales for these parameters (sensible ranges around the guess in which to look), a reference to the function, a convergence tolerance for the minimum, the maximum number of iterations to be taken and the verbose flag (default ON). It returns an array consisting of a reference to the function parameters at the minimum and the value there.

The Amoeba function is the actual implementation of the Downhill Simpex Method in Multidimensions. It takes a reference to an array of references to arrays which are the initial n+1 vertices (where n is the number of function parameters), a reference to the function valuation at these vertices, a reference to the function, a convergence tolerance for the minimum, the maximum number of iterations to be taken and the verbose flag (default ON). It returns an array consisting of a reference to the function parameters at the minimum and the value there.

The ConstructVertices is used by MinimiseND to construct the initial vertices for Amoeba as the initial guess plus the parameter scale parameters as vectors along the parameter axis.

The EvaluateVertices takes these set of vertices, calling the function for each one and returning the vector of results.

EXAMPLE

use Math::Amoeba qw(MinimiseND);
sub afunc {
my ($a,$b)=@_;
print "$at$bn";
return ($a-7)**2+($b+3)**2;
}
my @guess=(1,1);
my @scale=(1,1);
($p,$y)=MinimiseND(@guess,@scale,&afunc,1e-7,100);
print "(",join(,,@{$p}),")=$yn";

produces the output

(6.99978191653352,-2.99981241563247)=1.00000008274829

<<less
Download (0.004MB)
Added: 2007-08-14 License: Perl Artistic License Price:
801 downloads
KBib 0.6.2

KBib 0.6.2


KBib is a BibTex management program for KDE (Similar to KBibTex). more>>
KBib is a BibTex management program for KDE (Similar to KBibTex).
Features include import from RIS/ISI/Endnote files, export to Endnote/RIS files, automatically generate citation keys, check and correct duplicated citation keys, check and remove duplicated references, cite references into Lyx/Kile.
Main features:
- Add/edit/remove references
- Support copy/paste/drag-drop of references (BibTex entries can be copied/pasted or dragged/dropped from another Kbib window or a text editor into KBib and vice versus)
- Create new reference from plain text
- Find/remove duplicated references
- Generate citation key automatically
- Check/correct duplicated citation keys
- Lock/unlock citation keys (to prevent unwanted change of citation keys)
- Sort references
- Search references(fairly simple)
- Cite selected references into Lyx/Kile (using Lyx pipe)
- Support string macros
- Import references from Bibtex/RIS/ISI/Endnote/COPAC/MODS XML/PubMed XML/Endnote exported Bibtex (without citation key) files
- Export to RIS/Endnote/MODS XML/HTML files
- Search references from Z39.50 servers, SRU servers and Pubmed server.
- Download references from remote reference database (opened with Konqueror, Firefox), such as IEEEXplore, ScienceDirect (RIS format), Web of Science (ISI format) into KBib (seescreenshot)
- Save selected references into a new file
- Maintain a list of existing authors/journals/keywords in the current document
- Support user defined reference types
- Add/Delete/Edit reference types
- Allow different view modes (view all/by reference type/selected references/unselected references)
- Group references by various properties. References can be grouped by Reference type/Author/Editor/Journal/Keywords. Group view can be disabled.
- Allow flexible displayed fields
- Generate bibliography from selected references
Enhancements:
- Configuration dialog: add options to change the order of datasource
- Remote search dialog: double click to import an entry, press enter to start searching
- Reference editing dialog: ask to save data if close dialog with modified data
- New reference from text dialog: add option to add selected text to multiple value fields (e.g. authors, keywords)
<<less
Download (0.98MB)
Added: 2007-08-13 License: GPL (GNU General Public License) Price:
804 downloads
Bio::LiveSeq::Translation 1.4

Bio::LiveSeq::Translation 1.4


Bio::LiveSeq::Translation is a translation class for LiveSeq. more>>
Bio::LiveSeq::Translation is a translation class for LiveSeq.

This stores informations about aminoacids translations of transcripts. The implementation is that a Translation object is the translation of a Transcript object, with different possibilities of manipulation, different coordinate system and eventually its own ranges (protein domains).

APPENDIX

The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _

new

Title : new
Usage : $protein = Bio::LiveSeq::Translation->new(-transcript => $transcr);

Function: generates a new Bio::LiveSeq::Translation
Returns : reference to a new object of class Translation
Errorcode -1
Args : reference to an object of class Transcript

get_Transcript

Title : valid
Usage : $transcript = $obj->get_Transcript()
Function: retrieves the reference to the object of class Transcript (if any)
attached to a LiveSeq object
Returns : object reference
Args : none

aa_ranges

Title : aa_ranges
Usage : @proteinfeatures = $translation->aa_ranges()
Function: to retrieve all the LiveSeq AARange objects attached to a
Translation, usually created out of a SwissProt database entry
crossreferenced from an EMBL CDS feature.
Returns : an array
Args : none

<<less
Download (4.7MB)
Added: 2007-08-10 License: Perl Artistic License Price:
806 downloads
libSpiff 0.7.2

libSpiff 0.7.2


libSpiff brings XSPF playlist reading and writing support to your C++ application. more>>
libSpiff library brings XSPF playlist reading and writing support to your C++ application. Both version 0 and 1 are supported.

libSpiff uses Expat for XML parsing and CppTest for unit testing. libSpiff is the official reference implementation for XSPF of the Xiph.Org Foundation.

<<less
Download (0.58MB)
Added: 2007-08-09 License: BSD License Price:
806 downloads
Devel::Pointer 1.00

Devel::Pointer 1.00


Devel::Pointer is a Perl module that can fiddle around with pointers. more>>
Devel::Pointer is a Perl module that can fiddle around with pointers.

SYNOPSIS

use Devel::Pointer;
$a = address_of($b); # a = &b;
$b = deref($a); # b = *a;

$a = unsmash_sv(0+$scalar_ref);
@a = unsmash_av(0+$array_ref);
%a = unsmash_hv(0+$hash_ref);
&a = unsmash_cv(0+$code_ref);
# OK, you cant do that, but you get the idea

$c = deref(-1); # *(-1), and the resulting segfault.

The primary purpose of this is to turn a smashed reference address back into a value. Once a reference is treated as a numeric value, you cant dereference it normally; although with this module, you can.

Be careful, though, to avoid dereferencing things that dont want to be dereferenced.

<<less
Download (0.003MB)
Added: 2007-07-26 License: Perl Artistic License Price:
821 downloads
Objective Modula-2 1.00 (Reference Implementation)

Objective Modula-2 1.00 (Reference Implementation)


Objective Modula-2 programming language is a hybrid between Smalltalk and Modula-2. more>>
Objective Modula-2 programming language is a hybrid between Smalltalk and Modula-2 based on the object model and runtime of Objective-C.
The design is an example how native Cocoa/GNUstep support can be added to static imperative programming languages without implementing a bridge.
Objective Modula-2s scope encompasses the design of the Objective Modula-2 programming language and the implementation of a compiler to implement it. The initial compiler will generate Objective-C source code.
Enhancements:
- This code is used to verify ideas and concepts which come up in the course of defining the language.
- It is in an early stage, incomplete and subject to frequent changes.
<<less
Download (0.019MB)
Added: 2007-07-21 License: (FDL) GNU Free Documentation License Price:
825 downloads
Sunrise Data Dictionary 1.00

Sunrise Data Dictionary 1.00


Sunrise Data Dictionary is a library for hashtable storage of arbitrary data objects. more>>
Sunrise Data Dictionary is a library for hashtable storage of arbitrary data objects with built-in reference counting and guaranteed order iteration for the C programming language.
Sunrise Data Dictionary library can participate in external reference counting systems or use its own built-in reference counting. It comes with a variety of hash functions and allows the use of runtime supplied hash functions via callback mechanism. The source code is well documented.
The Sunrise Data Dictionary was specifically designed for use within the Afelio and Callweaver telephony servers, the implementation focuses on performance and scalability.
Enhancements:
- This is the initial release of the full API (all header files) and a developer snapshot of the implementation.
<<less
Download (0.17MB)
Added: 2007-07-16 License: MIT/X Consortium License Price:
832 downloads
libmng 1.0.10

libmng 1.0.10


libmng is the reference library for the MNG image format. more>>
libmng is the reference library for MNG, the animation extension to the popular PNG format.
The project provides powerful animation features combined with PNGs robustness and patent freedom.
Enhancements:
- This release adds provisional support for mpNG and ANG animations.
- There are minor bugfixes.
<<less
Download (0.50MB)
Added: 2007-07-14 License: zlib/libpng License Price:
844 downloads
OpenSCADA Project 0.8.0 (Atlantis)

OpenSCADA Project 0.8.0 (Atlantis)


The OpenSCADA project aims to create a full-featured and state-of-the-art SCADA system. more>>
The OpenSCADA project aims to create a full-featured and state-of-the-art SCADA (Supervisory Control and Data Acquisition) system to be used in industrial and civil engineering applications to control distributed systems from a master location.
The OpenSCADA project was started in order to create a common standard for SCADA applications. This includes specifications, interfaces and reference implementations.
Enhancements:
- This release has many new features and enhancements to existing functionality.
- The interfaces and the reference implementation were cleaned up a little bit.
- The new upstream version of Utgard was added.
<<less
Download (MB)
Added: 2007-07-10 License: LGPL (GNU Lesser General Public License) Price:
861 downloads
ISC DHCP 3.0.6

ISC DHCP 3.0.6


ISC DHCP provides a freely redistributable reference implementation of all aspects of DHCP. more>>
ISC DHCP provides a freely redistributable reference implementation of all aspects of DHCP, through a suite of DHCP tools:
- A DHCP server
- A DHCP client
- A DHCP relay agent
These tools all use a modular API which is designed to be sufficiently general that it can easily be made to work on POSIX-compliant operating systems and also non-POSIX systems like Windows NT and MacOS.
The DHCP server, client and relay agent are provided both as reference implementations of the protocol and as working, fully-featured sample implementations.
Both the client and the server provide functionality that, while not strictly required by the protocol, is very useful in practice. DHCP server also makes allowances for non-compliant clients which one might still like to support.
<<less
Download (0.85MB)
Added: 2007-07-06 License: BSD License Price:
532 downloads
Devel::Monitor 0.9.0.7

Devel::Monitor 0.9.0.7


Devel::Monitor is a Perl module that can monitor your variables/objects for memory leaks. more>>
Devel::Monitor is a Perl module that can monitor your variables/objects for memory leaks.

You have memory leaks, and you want to remove it... You can use this tool to help you find which variables/objects that are not destroyed when they should be, and thereafter, you can visualise exactly where is the circular reference for some specific variables/objects.

WHAT IT CANT DO

Even if your modules are memory leak free, it doesnt mean that external modules that you are using dont have it. So, before running your application on mod_perl, you should be sure that EVERY modules are ok. (In particular those perl extensions calling C++ code)

SYNOPSIS

use Devel::Monitor qw(:all);

#-----------------------------------------------------------------------------
# Monitor scalars, arrays, hashes, references, constants
#-----------------------------------------------------------------------------
my ($a,$b) = (Foo::Bar->new(), Foo::Bar->new());
my ($c, @d, %e);
use constant F => [1,2];
monitor(name for a => $a,
name for b => $b,
name for c => $c,
name for d => @d,
name for e => %e,
name for F => &F); #NOTE : Dont add parentheses to the end of the constant (&F())

#-----------------------------------------------------------------------------
# Print circular references
#-----------------------------------------------------------------------------
# NOTE : You cannot use print_circular_ref on a monitored/tied variable
# (See "We cannot use tied objects references because it reuse memory space" doc)
print_circular_ref($a);
print_circular_ref($b);
print_circular_ref($c);
print_circular_ref(@d);
print_circular_ref(%e);
print_circular_ref(&F); #NOTE : Dont add parentheses to the end of the constant (&F())

USAGE : monitor

Example with a circular reference
+----------------------+
| Code |
+----------------------+
{
my @a;
monitor(a => @a);
$a[0] = @a; #Add a circular reference
print STDERR "Leaving scopen";
}
print STDERR "Scope leftn";

+----------------------+
| Output |
+----------------------+
MONITOR ARRAY a
Leaving scope
Scope left
DESTROY ARRAY a

+----------------------+
| Meaning |
+----------------------+
The line "DESTROY ARRAY a" should be between scope prints.
@a were deleted on program exit.

Example without a circular reference

+----------------------+
| Code |
+----------------------+
{
my @a;
monitor(a => @a);
print STDERR "Leaving scopen";
}
print STDERR "Scope leftn";

+----------------------+
| Output |
+----------------------+
MONITOR ARRAY a
Leaving scope
DESTROY ARRAY a
Scope left

+----------------------+
| Meaning |
+----------------------+
Everything is ok

Now that you know there is a circular reference, you can track it down using the print_circular_ref method

<<less
Download (0.016MB)
Added: 2007-06-28 License: Perl Artistic License Price:
848 downloads
Perl6::Parameters 0.03

Perl6::Parameters 0.03


Perl6::Parameters is a module with Perl 6-style prototypes with named parameters. more>>
Perl6::Parameters is a module with Perl 6-style prototypes with named parameters.

SYNOPSIS

use Perl6::Parameters;

sub mysub($foo, ARRAY $bar, *%rest) {
...
}

DETAILS

Perl6::Parameters is a Perl module which simulates Perl 6s named parameters. (When I talk about "named parameters" I mean something like the parameters youre used to from C, Java and many other languages--not pass-a-hash-with-the-parameters-in-it things.)

Like most other programming languages, Perl 6 will support subroutines with pre-declared variables the parameters are put into. (Using this will be optional, however.) This goes far beyond the "line-noise prototypes" available in Perl 5, which only allow you to control context and automatically take references to some parameters--lines like my($first, $second)=(@_) will no longer be necessary.

Although Perl 6 will have this, Perl 5 doesnt; this module makes it so that Perl 5 does. It uses some other Perl 6-isms too, notably the names for builtin types and the unary-asterisk notation for flattening a list.

Crafting Parameter Lists

Crafting parameter lists is simple; just declare your subroutine and put the parameters separated by commas or semicolons, in parenthesis. (Using a semicolon signifies that all remaining parameters are optional; this may not be available this way in Perl 6, but Im assuming it is until I hear otherwise.)

Most parameters are just variable names like $foo; however, more sophisticated behavior is possible. There are three ways to achieve this.

The first way is by specifying a type for the variable. Certain types make the actual parameters turn into references to themselves:

ARRAY $foo

This turns an array into a reference to itself and stores the reference into $foo.

HASH $foo

This turns a hash into a reference to itself and stores the reference into $foo.

CODE $foo

This turns a subroutine into a reference to itself and stores the reference into $foo.

SCALAR $foo

This turns a scalar into a reference to itself and stores the reference into $foo.

GLOB $foo

This turns a typeglob into a reference to itself and stores the reference into $foo. Typeglobs will be going away in Perl 6; this type exists in this module so that its useful for general use in Perl 5.

REF $foo

This turns any parameter into a reference to itself and stores it into $foo.

This only works in Perl 5.8. Otherwise, its treated the same as any other unrecognized type name.

AnythingElse $foo

This has no effect in this module; its treated as though youd typed $foo without the AnythingElse.

For example, if a subroutine had the parameters ($foo, HASH $bar, CODE $baz) and was called with ($scalar, %hash, &mysub) the subroutine would get the contents of $scalar, a reference to %hash and a reference to &mysub.
The second way is by supplying an actual array or hash as a parameter name. This requires an array or hash to be passed in for that parameter; it preserves the length of the array or hash.

The final way is only available for the last parameter: if an array or hash is prefixed with an asterisk, that array or hash will be filled with any additional parameters.

<<less
Download (0.004MB)
Added: 2007-06-22 License: Perl Artistic License Price:
854 downloads
Scalar::Util 1.19

Scalar::Util 1.19


Scalar::Util is a selection of general-utility scalar subroutines. more>>
Scalar::Util is a selection of general-utility scalar subroutines.

SYNOPSIS

use Scalar::Util qw(blessed dualvar isweak readonly refaddr reftype tainted
weaken isvstring looks_like_number set_prototype);

Scalar::Util contains a selection of subroutines that people have expressed would be nice to have in the perl core, but the usage would not really be high enough to warrant the use of a keyword, and the size so small such that being individual extensions would be wasteful.

By default Scalar::Util does not export any subroutines. The subroutines defined are

blessed EXPR

If EXPR evaluates to a blessed reference the name of the package that it is blessed into is returned. Otherwise undef is returned.

$scalar = "foo";
$class = blessed $scalar; # undef

$ref = [];
$class = blessed $ref; # undef

$obj = bless [], "Foo";
$class = blessed $obj; # "Foo"

dualvar NUM, STRING

Returns a scalar that has the value NUM in a numeric context and the value STRING in a string context.

$foo = dualvar 10, "Hello";
$num = $foo + 2; # 12
$str = $foo . " world"; # Hello world

isvstring EXPR

If EXPR is a scalar which was coded as a vstring the result is true.

$vs = v49.46.48;
$fmt = isvstring($vs) ? "%vd" : "%s"; #true
printf($fmt,$vs);

isweak EXPR

If EXPR is a scalar which is a weak reference the result is true.

$ref = $foo;
$weak = isweak($ref); # false
weaken($ref);
$weak = isweak($ref); # true

NOTE: Copying a weak reference creates a normal, strong, reference.

$copy = $ref;
$weak = isweak($ref); # false

looks_like_number EXPR

Returns true if perl thinks EXPR is a number. See "looks_like_number" in perlapi.

openhandle FH

Returns FH if FH may be used as a filehandle and is open, or FH is a tied handle. Otherwise undef is returned.

$fh = openhandle(*STDIN); # *STDIN
$fh = openhandle(*STDIN); # *STDIN
$fh = openhandle(*NOTOPEN); # undef
$fh = openhandle("scalar"); # undef

readonly SCALAR

Returns true if SCALAR is readonly.

sub foo { readonly($_[0]) }

$readonly = foo($bar); # false
$readonly = foo(0); # true

refaddr EXPR

If EXPR evaluates to a reference the internal memory address of the referenced value is returned. Otherwise undef is returned.

$addr = refaddr "string"; # undef
$addr = refaddr $var; # eg 12345678
$addr = refaddr []; # eg 23456784

$obj = bless {}, "Foo";
$addr = refaddr $obj; # eg 88123488

reftype EXPR

If EXPR evaluates to a reference the type of the variable referenced is returned. Otherwise undef is returned.

$type = reftype "string"; # undef
$type = reftype $var; # SCALAR
$type = reftype []; # ARRAY

$obj = bless {}, "Foo";
$type = reftype $obj; # HASH

set_prototype CODEREF, PROTOTYPE

Sets the prototype of the given function, or deletes it if PROTOTYPE is undef. Returns the CODEREF.

set_prototype &foo, $$;

tainted EXPR

Return true if the result of EXPR is tainted

$taint = tainted("constant"); # false
$taint = tainted($ENV{PWD}); # true if running under -T

weaken REF

REF will be turned into a weak reference. This means that it will not hold a reference count on the object it references. Also when the reference count on that object reaches zero, REF will be set to undef.

This is useful for keeping copies of references , but you dont want to prevent the object being DESTROY-ed at its usual time.

{
my $var;
$ref = $var;
weaken($ref); # Make $ref a weak reference
}
# $ref is now undef

Note that if you take a copy of a scalar with a weakened reference, the copy will be a strong reference.

my $var;
my $foo = $var;
weaken($foo); # Make $foo a weak reference
my $bar = $foo; # $bar is now a strong reference

This may be less obvious in other situations, such as grep(), for instance when grepping through a list of weakened references to objects that may have been destroyed already:

@object = grep { defined } @object;

This will indeed remove all references to destroyed objects, but the remaining references to objects will be strong, causing the remaining objects to never be destroyed because there is now always a strong reference to them in the @object array.

<<less
Download (0.042MB)
Added: 2007-05-21 License: Perl Artistic License Price:
888 downloads
Secleted [ 0 ] software to compare
  • Page: 1 of 5
  • 1
  • 2
  • 3
  • 4
  • 5