*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->Linux man pages -> a2p (1)              
Title
Content
Arch
Section
 

A2P(1)

Contents


NAME    [Toc]    [Back]

       a2p - Awk to Perl translator

SYNOPSIS    [Toc]    [Back]

       a2p [options] filename

DESCRIPTION    [Toc]    [Back]

       A2p takes an awk script specified on the command line (or from standard
       input) and produces a comparable perl script on the standard output.

       Options    [Toc]    [Back]

       Options include:

       -D<number>
	    sets debugging flags.

       -F<character>
	    tells a2p that this awk script is always invoked with this -F
	    switch.

       -n<fieldlist>
	    specifies the names of the input fields if input does not have to
	    be split into an array.  If you were translating an awk script
	    that processes the password file, you might say:

		    a2p -7 -nlogin.password.uid.gid.gcos.shell.home

	    Any delimiter can be used to separate the field names.

       -<number>
	    causes a2p to assume that input will always have that many fields.

       -o   tells a2p to use old awk behavior.	The only current differences
	    are:

	    o	 Old awk always has a line loop, even if there are no line
		 actions, whereas new awk does not.

	    o	 In old awk, sprintf is extremely greedy about its arguments.
		 For example, given the statement

			 print sprintf(some_args), extra_args;

		 old awk considers extra_args to be arguments to "sprintf";
		 new awk considers them arguments to "print".

	    "Considerations"

	    A2p cannot do as good a job translating as a human would, but it
	    usually does pretty well.  There are some areas where you may want
	    to examine the perl script produced and tweak it some.  Here are
	    some of them, in no particular order.

	    There is an awk idiom of putting int() around a string expression
	    to force numeric interpretation, even though the argument is
	    always integer anyway.  This is generally unneeded in perl, but
	    a2p can't tell if the argument is always going to be integer, so
	    it leaves it in.  You may wish to remove it.

	    Perl differentiates numeric comparison from string comparison.
	    Awk has one operator for both that decides at run time which comparison
 to do.  A2p does not try to do a complete job of awk emulation
 at this point.  Instead it guesses which one you want.
	    It's almost always right, but it can be spoofed.  All such guesses
	    are marked with the comment ""#???"".  You should go through and
	    check them.  You might want to run at least once with the -w
	    switch to perl, which will warn you if you use == where you should
	    have used eq.

	    Perl does not attempt to emulate the behavior of awk in which
	    nonexistent array elements spring into existence simply by being
	    referenced.  If somehow you are relying on this mechanism to create
 null entries for a subsequent for...in, they won't be there in
	    perl.

	    If a2p makes a split line that assigns to a list of variables that
	    looks like (Fld1, Fld2, Fld3...) you may want to rerun a2p using
	    the -n option mentioned above.  This will let you name the fields
	    throughout the script.  If it splits to an array instead, the
	    script is probably referring to the number of fields somewhere.

	    The exit statement in awk doesn't necessarily exit; it goes to the
	    END block if there is one.	Awk scripts that do contortions within
	    the END block to bypass the block under such circumstances can be
	    simplified by removing the conditional in the END block and just
	    exiting directly from the perl script.

	    Perl has two kinds of array, numerically-indexed and associative.
	    Perl associative arrays are called "hashes".  Awk arrays are usually
 translated to hashes, but if you happen to know that the
	    index is always going to be numeric you could change the {...} to
	    [...].  Iteration over a hash is done using the keys() function,
	    but iteration over an array is NOT.  You might need to modify any
	    loop that iterates over such an array.

	    Awk starts by assuming OFMT has the value %.6g.  Perl starts by
	    assuming its equivalent, $#, to have the value %.20g.  You'll want
	    to set $# explicitly if you use the default value of OFMT.

	    Near the top of the line loop will be the split operation that is
	    implicit in the awk script.  There are times when you can move
	    this down past some conditionals that test the entire record so
	    that the split is not done as often.

	    For aesthetic reasons you may wish to change the array base $[
	    from 1 back to perl's default of 0, but remember to change all
	    array subscripts AND all substr() and index() operations to match.

	    Cute comments that say "# Here is a workaround because awk is
	    dumb" are passed through unmodified.

	    Awk scripts are often embedded in a shell script that pipes stuff
	    into and out of awk.  Often the shell script wrapper can be incorporated
 into the perl script, since perl can start up pipes into
	    and out of itself, and can do other things that awk can't do by
	    itself.

	    Scripts that refer to the special variables RSTART and RLENGTH can
	    often be simplified by referring to the variables $`, $& and $',
	    as long as they are within the scope of the pattern match that
	    sets them.

	    The produced perl script may have subroutines defined to deal with
	    awk's semantics regarding getline and print.  Since a2p usually
	    picks correctness over efficiency.	it is almost always possible
	    to rewrite such code to be more efficient by discarding the semantic
 sugar.

	    For efficiency, you may wish to remove the keyword from any return
	    statement that is the last statement executed in a subroutine.
	    A2p catches the most common case, but doesn't analyze embedded
	    blocks for subtler cases.

	    ARGV[0] translates to $ARGV0, but ARGV[n] translates to $ARGV[$n].
	    A loop that tries to iterate over ARGV[0] won't find it.

ENVIRONMENT    [Toc]    [Back]

       A2p uses no environment variables.

AUTHOR    [Toc]    [Back]

       Larry Wall <larry@wall.org>

FILES    [Toc]    [Back]

SEE ALSO
	perl   The perl compiler/interpreter

	s2p    sed to perl translator

DIAGNOSTICS    [Toc]    [Back]

BUGS
       It would be possible to emulate awk's behavior in selecting string versus
 numeric operations at run time by inspection of the operands, but
       it would be gross and inefficient.  Besides, a2p almost always guesses
       right.

       Storage for the awk syntax tree is currently static, and can run out.



3rd Berkeley Distribution	  2004-12-24				A2P(1)
[ Back ]
 Similar pages
Name OS Title
s2p Linux Sed to Perl translator
s2p IRIX Sed to Perl translator
perlcompile OpenBSD Introduction to the Perl Compiler-Translator
perljp OpenBSD AEuEU,i Perl Y~YxYE `A^a`I`A Perl xIAx3|xOxex|x3x1/2! Perl 5.8.0 xexeicUni- _ codeYuYYi1/4YEx~AcEyxE...
pppoe OpenBSD PPP Over Ethernet translator
textps IRIX Text to PostScript translator
pdf2ps Linux Ghostscript PDF to PostScript translator
faithd OpenBSD FAITH IPv6/v4 translator daemon
XmTranslateKey HP-UX The default keycode-to-keysym translator
XmTranslateKey IRIX The default keycode-to-keysym translator
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service