Perl Prettyprinting

Prettyprinting is a weak side of Perl: syntax is too complex. There are several approaches to this problem:

• Writing your own "KISS-style" (or "fuzzy" as I call them) prettyprinter. Which takes into account your style and does not delve into intricacies of the syntax. See Neatperl for the inspiration. It can change only indent which is 80% of the functionality of any prettyprinter.
• Use Perltidy, that does the job perfectly well. see  The Perltidy Home Page by Steven L. Hancock. As on September 2019 it is still maintained. Distribution is available from metacpan.org

  Perltidy is a Perl script which indents and reformats Perl scripts to make them easier to read. If you write Perl scripts, or spend much time reading them, you will probably find it useful.

• DzSoft Perl Editor that contains a built-in Perl beautifier (this is shareware  I think; can tell nothing about beautifier quality)

***** DzSoft Perl Editor   by Sergey Dzyubenko, Alexander Dzyubenko, DzSoft Ltd.

• Fully customizable Syntax Highlighting!
• Run the script with any parameters and see the result in the internal browser.
• All features are available offline.
• No need to run a web server on your computer to test the script!
• Syntax Check feature.
• Multi-line quick insert feature.
• NEW:STDIN support.
• Simple FTP client included to upload and chmod your script.
• HTML Export with syntax highlighting.
• Super comfortable editor with bookmarks.
• SDI interface that supports multiple instances.
• Print feature with Syntax Highlighting.
• Windows/Unix/Mac line endings support.
• Complete Perl Help included to browse offline.
• Windows 2000 100% compatible.
• Script parameters editor.
• Environment Variables Editor.
• New in v.5.1:

  • OfficeXP-styled menus and toolbars
  • Show the script execution time
  • Many other minor enhancements

  Features:

  • Customizable Syntax Highlighting
  • Run the script and see the result immediately in the internal browser without a web server
  • Syntax Check
  • Collapsible subroutines
  • Customizable code snippets
  • Full server simulation
  • Full control of the environment variables and input data
  • Code Explorer
  • Can upload the script to FTP
  • HTML export and print with syntax highlighting
  • Super comfortable editor with savable bookmarks
  • SDI interface that supports multiple instances
  • Windows/Unix/Mac line endings support

The idea of using  C beautifier for Perl
by preprocessing Perl into the form useable for C beautifier

This is an interesting idea which probably should be exploited further.  It was first published by Tim Maher in Jul, 1998] (Perl Beautifier Home Page - Google Groups)

See  the description from his now defunct  Web page A Beautifier for Perl

Note: the site is not defunct and domain was bought by  domain-grabber.

3.4   Is there a pretty-printer (similar to indent(1) ) for Perl?

. . . If what you mean is whether there is a program that will reformat the program such as indent(1) will do for C, then the answer is no. The complex feedback between the scanner and the parser (as in the things that confuse vgrind) make  [sic]  it challenging at best to write a standalone Perl parser.

But I figured it could not be as difficult as this makes it sound. For one thing, Perl knows how to parse Perl programs, and the Perl source code is freely available, so Perl could conceivably be reworked into a Perl beautifier.

Alternatively, the GNU source code for the popular C language beautifier "indent" is also available, so another approach would be to rework its 7k lines of C to handle the Perl language.

But I knew there was an easier approach, that would not require reworking anybody else's existing code, or the use of a language other than Perl. I knew this because my quest for beauty had already led me to write a rudimentary C++ beautifier in a three command (sed | indent| sed) shell script (UNIX/World, August 1991, p. 134.), and later a more robust C++ beautifier in 140 lines of C and shell code (Dr. Dobbs' Journal, Dec. 1992, pp. 23s-27s).

These beautifiers certainly don't qualify as "standalone parsers" for C++, because they don't classify the program elements into meaningful units. But that doesn't prevent them from doing for C++ everything that indent and cb do for C! The trick is realizing that programs written in Language B can be successfully processed by beautifiers for Language A, if Language B bears a syntactic similarity to Language A, and if the Language B program can be temporarily disguised as Language A.

So with this C++ beautification experience under my belt, and a stubborn determination to prove that "Perl Beautification" could be accomplished if sufficient Hubris, Impatience, and Laziness could be mustered, I began writing in Perl the first fully functional "Perl Beautifier", pbeaut,   in April of 1998 [1].

Beautification Strategy

As with its C++ predecessors, I approached the problem of writing pbeaut by capitalizing on the existence of mature beautification utilities for the C language, which has some fortunate syntactic similarities to Perl, and milking the UNIX filter model for all it's worth.

The basic approach, borrowed from my C++ beautifiers, is to use a pre-processor to disguise Perl code as C code, effect the beautification using standard C tools, and then convert the disguised Perl back to its original form using a post-processor.

The basic model is therefore:

PERL CODE ->

Perl-to-C Encoder ->

Standard C beautifier ->

C-to-Perl Decoder ->

BEAUTIFIED PERL CODE

Here is a listing of the first pbeaut program:

$ cat pbeaut
#! /bin/sh
# Tim Maher, Consultix. [email protected]
# pbeaut, v .1
# these indent options work pretty well
pencode $* | indent -npro -bl -bli0 -nce -npcs | pdecode
$

The encoder, pencode, examines every character of the Perl program, from first to last, and rewrites certain character sequences as necessary to disguise the Perl code as C.

The C beautifier, in this case GNU indent, inserts tabs to properly represent nesting levels, aligns parentheses and braces, inserts newline characters to split long lines into shorter ones, and generally fools around with the layout of the code to make it look more orderly and to emphasize the program's structure.

The decoder, pdecode, undoes the disguises crafted by pencode to reveal the hidden Perl program elements in their newly beautified context.

The current "production" version of pbeaut (version .62; 412 lines of code) communicates various types of information to and from the encoder and decoder and does extensive error checking, but its basic function is the same as the simple version shown above.

De-Obfuscation Testing

Where should one look to find the ugliest Perl code on the planet? Why the archives of past Obfuscated Perl Contests, of course, where contestants are rewarded for making their programs as inscrutable as possible (http://www.tpj.com/tpj/contest).

In this section, we'll examine the effects on Perl programs of C-style beautification using indent, as well as Perl-style beautification using pbeaut.

Here's a prize-winning entry from the 1996 contest:

$ cat caton
#F. First place: Russell Caton
# (Reduced in size to fit on one line.)

$-=100;while((($@)=(getpwent())[2])){push(@@,$@);}foreach(sort{$a<=>$b}@@){(($_<=$-)||($_==($-+++1)))?next:die"$-\n";}

After beautification with indent, it looks like this:

$ indent -npro -br -nce -npcs  < caton  # -br: brace on line with keyword

#F. First place: Russell Caton
$ -= 100;
while ((($ @) = (getpwent())[2])) {
        push(@@, $ @);
}
foreach(sort
        {
        $a <=> $b
        }
        @@) {
        (($_  <= $ -) || ($_  == ($ - +++1))) ? next : die "$-\n";
}

Perhaps surprisingly, the program layout looks pretty good, owing to the fact that Perl inherited many of its basic features from C (brace-delimited blocks, &&/|| conjunctions, semicolon line-termination, operator syntax, etc.).

On the other hand, the representations of two variables ( $- , $@ ) were altered by the insertion of a space between the symbols. Does this bother Perl?

$ perl -c caton
caton syntax OK
$ indent -npro -br -nce -npcs  < caton > caton.ind; perl -c caton.ind
caton.ind syntax OK
$ perl -w caton.ind
101
$

It doesn't bother Perl a bit! The program still produces the next available number from the /etc/passwd file (or NIS database). However, having the depictions of those variables messed up is definitely likely to annoy most (non-obfuscatory) Perl programmers!

After beautification with pbeaut, the program looks like this:

$- = 100;
while ((($@) = (getpwent())[2])) {
    push(@@, $@);
}
foreach(sort{$a<=>$b} @@) {
    (($_ <= $-)  || ($_ == ($-++ + 1))) ? next : die "$-\n";
}

As you can see, the preservation of variable names has been achieved, along with a much more Perlish representation of the foreach loop.

Here's another unattractive winning entry from the 1996 contest:

#D. First place: Robert Klep
# (Line breaks in original exactly as shown)
$Y=-1.2;for(0..24){$X=-2;for(0..79){($r,$i)=(0,0);for(0..15){$n=$_;$r=($x=$
r)*$x-($y=$i)*$y+$X;$i=2*$x*$y+$Y;$x*$x+$y*$y>4&&last}print unpack("\@$n a"
,".,:;=+itIYVXRBM ");$X+=3/80}$Y+=2.4/25}

Let's try beautifying this one with indent:

$ indent -npro -br -nce -npcs < klep > klep.ind
Standard input:1: Warning: old style assignment ambiguity in "=-". Assuming "= -"
Standard input:1: Warning: old style assignment ambiguity in "=-". Assuming "= -"

$ indent -npro -br -nce -npcs < klep 2>/dev/null | tee klep.ind
     1  $Y = -1.2;
     2  for (0. .24) {
     3          $X = -2;
     4          for (0. .79) {
     5                  ($r, $i) = (0, 0);
     6                  for (0. .15) {
     7                          $n = $_;
     8                          $r = ($x = $
     9                                r) * $x - ($y = $i) * $y + $X;
    10                          $i = 2 * $x * $y + $Y;
    11                          $x *$x + $y * $y > 4 && last
    12                  }
    13                  print unpack("\@$n a"
    14                               ,".,:;=+itIYVXRBM ");
    15                  $X += 3 / 80
    16          }
    17          $Y += 2.4 / 25
    18  }

$ perl -c klep.ind
klep.ind syntax OK
$

The "$Y=-1.2" assignment was correctly interpreted as "$Y = -1.2", rather than the archaic C "$Y =- 1.2", so no problem there. And once again, the program structure looks good, and it passed Perl's syntax check.

However, instead of drawing the default Mandelbrot fractal on the screen in ASCII characters, here's what the program does:

$ klep.ind


$

It seems that the degenerate range specifications (e.g, 0.  .79) in the for loops, although syntactically acceptable, resulted in only one iteration of each loop, which wasn't enough to show much output.

The lesson to be learned here is that a faulty beautification process can produce code that is attractive but dysfunctional!

pbeaut, on the other hand, produces the following reworked version of this program, which functions correctly:

$ pbeaut -b 2 klep | cat -n     # -b 2: opening brace on line with keyword
    
1  $Y = -1.2;
2  for (0 .. 24) {
3          $X = -2;
4          for (0 .. 79) {
5                  ($r, $i) = (0, 0);
6                  for (0 .. 15) {
7                          $n = $_;
8                          $r = ($x = $  # NOTE: extraneous newline here
9                                            r) * $x - ($y = $i) * $y + $X;
10                          $i = 2 * $x * $y + $Y;
11                          $x * $x + $y * $y > 4 && last
12                  }
13                  print unpack("\@$n a" # NOTE: extraneous newline here
14                               ,".,:;=+itIYVXRBM ");
15                  $X += 3 / 80
16          }
17          $Y += 2.4 / 25
18  }

$

This program looks pretty good, apart from the undesirable preservation of badly located newline characters from the original, which caused the splitting of the $r variable (lines 8-9) across a line break!

Although pbeaut tries to preserve programmer newlines by default, on the assumption they were sensibly placed, this behavior can be disabled through use of the -n (ignore newlines) invocation option:

$ pbeaut -n -b 2 klep | cat -n  # -n: ignore newlines in original
     1  $Y = -1.2;
     2  for (0 .. 24) {
     3          $X = -2;
     4          for (0 .. 79) {
     5                  ($r, $i) = (0, 0);
     6                  for (0 .. 15) {
     7                          $n = $_;
     8                          $r = ($x = $r) * $x - ($y = $i) * $y + $X;
     9                          $i = 2 * $x * $y + $Y;
    10                          $x * $x + $y * $y > 4 && last
    11                  }
    12                  print unpack("\@$n a", ".,:;=+itIYVXRBM ");
    13                  $X += 3 / 80
    14          }
    15          $Y += 2.4 / 25
    16  }

That's better!

Testing with Perl Modules

It can certainly be fun decoding the purposely inscrutable scribblings of the obfuscatory programmers, but the real testing of pbeaut has focused on a different collection of programs - the modules of the standard Perl distribution. These 66 programs, totaling 20,247 lines of expert-grade Perl code, use most of the features of the language, in lots of different combinations.

Most of these programs can be successfully beautified. The others ( diagnostics.pm, getcwd.pl, perl5db.pl, CPAN.pm, English.pm ) cannot, due to their use of currently unsupported syntax features. (For example, semicolon delimiters with the substitution operator; see Current Limitations, below.)

How pbeaut Works

The job of pencode (currently about 1.7k lines of Perl5) is to make Perl code acceptable C code, using one of four techniques:

• encapsulating within C comments
• enclosing in quotes
• encoding symbols alphabetically; e.g., { -> LB
• leaving code unaltered (for material that can be properly handled by C-oriented rules)

We'll use a small program called fix to illustrate the encoding, beautification, and decoding processes.

$ cat fix
#! /usr/bin/perl -wn
# modify shebang pathname in input script
# Written strangely to involve certain syntax features

${prog}='perl';

if ($. =~ /^1$/) {$_=s|^#! /usr/bin/$prog|#! /usr/local/bin/$prog|o;print;}
else {print;} # other lines unaltered

$ pencode fix | cat -n  # show line numbers     
1  /* _a_C #! _a_RMa\/usr_a_RMa\/bin_a_RMa\/perl -wn C_a_ */     
2  /* _a_C # modify shebang pathname in input script C_a_ */     
3  /* _a_C # written strangely to involve certain syntax features C_a_ */
4       
5  "_a_F_${prog}_F_a_"='perl';
6       
7  if ("_a_F_$._F_a_" _a_EQ_a_TD "_a_M_/^1$/_M_a_")  # line wrapped for display
     {"_a_F_$__F_a_"="_a_S_s|^#! /usr/bin/$prog|#! /usr/local/bin/$prog|o_S_a_";print;}
8  else {print;} /* _a_C # other lines unaltered C_a_ */

As you can see, the Perl comments were encapsulated within C comments (e.g., line 1), with a code sequence being inserted before each inner / . This is to guard against accidental termination of the C comment by material within the Perl comment. (Actually, the backslashes are only necessary for embedded slashes preceded by asterisks, but for simplicity all slashes are backslashed).

The basic encoding sequence, _a_ , and an ancillary preceding or following syntax-specific code, mark the sequences added by pencode to facilitate their later removal by pdecode. (NOTE: if _a_ appears in the input program, pbeaut will select a different sequence for use.)

To prevent indent from making bad decisions about formatting Perl symbol sequences, such as inserting spaces or newlines between them, certain ones are encoded with an alphabetic representation, such as EQ...TD for =~  (line 7).

For related reasons, in line 5, ${prog} gets quoted to prevent the C beautifier from splitting apart its components.

The job of pdecode (currently about 50 lines of Perl5) is to reverse the effects of pencode, by removing the C-comment "wrappers" encapsulating Perl comments, decoding the various encoded strings to their original forms, and so forth.

Let's look at the result of subjecting fix to the full beautification process:

$ nl -ba fix  # original, pre-beautification
    1  #! /usr/bin/perl -wn
    2  # modify shebang pathname in input script
    3  # written strangely to involve certain syntax features
    4  
    5  ${prog}='perl';
    6  
    7  if ($. =~ /^1$/) {$_=s|^#! /usr/bin/$prog|#! /usr/local/bin/$prog|o;print;}
    8  else {print;} # other lines unaltered

$ pbeaut < fix | cat -n
    1 #! /usr/bin/perl -wn
    2 # modify shebang pathname in input script
    3 # written strangely to involve certain syntax features
    4
    5 ${prog} = 'perl';
    6
    7 if ($. =~ /^1$/) {
    8       $_ = s|^#! /usr/bin/$prog|#! /usr/local/bin/$prog|o;
    9       print;
    10 }
    11 else {
    12      print;
    13 } # other lines unaltered

Compared to the original program, spaces have been inserted around the assignment operators (=) on lines 5 and 8, and the one-line code blocks on lines 7 and 8 of the original have been spread out over several lines (7-10, and 11-13).

Current Limitations

pbeaut is aware of many of its limitations, and it will report them to the user if one is encountered during processing, or if it is invoked with the -l option:

$ pbeaut -l
     LIMITATIONS OF pbeaut VERSION 0.62:

     Delimiters for match and substitution operators known to work: <{[(#/|!?
             (others might work, but they haven't been tested)
     Whitespace before some delimiters not supported (e.g., m  /a/;
     s/// and tr/// are not allowed to change delimiters for the second part
     // sometimes formatted better if explicitly tagged as match, via m//
     q{}, qq(), etc., cannot have embedded }/) unless backslashed
     split must have white-space before first / (split //, not split//)
     Keyword "sub" and following subroutine name assumed to be on same line
     Here-Docs cannot omit Framing-Word (can't use blank line as terminator)

     TIPS: To disable beautification for a line, put "#LIT" at its end
           If you don't like the formatting of subs without parentheses,
             try adding them: sub foo() rather than sub foo

     (c) Tim Maher, CONSULTIX.  [email protected]  (206) 781-UNIX
        Contact author for restrictions on distribution and usage

NOTE: Although there are numerous options to indent that can be used to enable or disable different types of program alterations, only a few of the various combinations have thus far been tested with pencode/pdecode.

For this reason, the current pbeaut only offers two choices of indent options: "-b 1" (braces on lines following keywords) and "-b 2" (braces on same lines as keywords).

Perl Beautifier Demo Page

To allow interested parties to experiment with it, I provided a pbeaut Demo Page on the World-Wide-Web for many months, which allowed me to obtain useful information about the strengths and weaknesses of the early versions.

Status Report

pbeaut is progressing rapidly, but is not yet fully reliable. In some cases, it generates Perl code that is syntactically incorrect, usually due to the introduction or removal of spaces and/or newline characters.

Fortunately, pbeaut incorporates safeguards to prevent the accidental corruption of the original program, including:

• presenting the beautified result to the standard output, rather than altering the original program
• running perl -c (syntax check) on the beautified code and reporting any syntax errors to the user
• reporting statistics on the input program and its beautified output, to facilitate detection of code loss

Even when errors are introduced, they are typically of a very minor nature, and are easily detected and fixed by an experienced Perl programmer.

Development and Testing Platforms

pbeaut was developed on Slackware Linux 3.0 using GNU indent 1.9.1, and has also been lightly tested under ULTRIX 4.3 using /usr/ucb/indent and /usr/bin/cb. I expect it to work just as well on other platforms having different versions of indent and cb, but that assumption is currently untested.

Availability

No version of pbeaut has yet been released, due to the author's reluctance to do so until it has been rewritten into a form more accessible to other programmers. Those in need of immediate beautification services are encouraged to try PerlTidy, which just came out in April, 2001, and from my preliminary testing looks pretty good.

Summary

pbeaut is a utility that can rewrite most Perl programs into compliance with an adjustable standard of presentation. Since the writing of this article, Steve Hancock's PerlTidy has become the de facto standard beautification utility, and we recommend it highly.

Footnotes

[1]

I am aware of the 5/20/96 pb program by P. Lutus Ashland, [email protected]. But unlike pbeaut, it does nothing but adjust indentation to properly reflect nesting levels, rather than offering the full power of C's indent and cb utilities.

NEWS CONTENTS

• 20110119 : pb ( pb, Jan 19, 2011 )
• 20110119 : Beautifier freshmeat.net ( Beautifier freshmeat.net, )
• 20071207 : Project details for perltidy ( freshmeat.net )
• 20071207 : GNU Source-highlight - GNU Project - Free Software Foundation (FSF) v1.6 by Lorenzo Bettini ( GNU Source-highlight - GNU Project - Free Software Foundation (FSF) v1.6 , )
• 19980712 : Perl Beautifier Home Page - Google Groups by Tim Maher ( Perl Beautifier Home Page - Google Groups, Jul 12, 1998 )

Old News ;-)

[Jan 19, 2011] pb

#!/usr/bin/perl

# 'pb' Perl Beautifier

# Written by P. Lutus Ashland, Oregon [email protected] 5/20/96

# This script processes Perl scripts, cleans up and indents, like cb does for C

# Be careful with this script - it accepts wildcards and processes every text file
# that meets the wildcard criteria. This could be a catastrophe in the hands of the unwary.

$tabstring = "  "; # You may place any tab-stop characters you want here

if($ARGV[0] eq "") {
  print "usage: file1 file2 etc. or wildcards (replaces originals in place)\n";
}
else {
  foreach $filename (@ARGV) {
    if(-T $filename) {
      &process($filename);
    }
  }
}

sub process {
  $fn = $_[0];
  undef $/; # so we can grab the entire file at once
  undef @infa; # prevent left-overs
  print STDERR "$fn";
  open (INFILE,$fn);
  @infa = split(/\n/,<INFILE>);
  close INFILE;
  
  $/ = "\n"; # restore default
  
  open (OUTFILE,">$fn");
  $tabtotal = 0;
  for (@infa) {
    
    s/^\s*(.*?)\s*$/$1/; # strip leading and trailing spaces
    
    $a = $_; # copy original string
    $q = $a; # i plan to modify this copy for testing
    $q =~ s/\\\#//g; # remove escaped comment tokens
    $q =~ s/\#.*?$//g; # remove Perl-style comments
    $q =~ s{/\*.*?\*/} []gsx; # remove C-style comments
    $q =~ s/\\\{//g; # remove escaped left  braces
    $q =~ s/\\\}//g; # remove escaped right braces
    $q =~ s/\\\(//g; # remove escaped left  parentheses
    $q =~ s/\\\)//g; # remove escaped right parentheses
    
    $q =~ s/\'.*?\'//g; # remove single-quoted lines
    
# now the remaining braces/parentheses should be structural
    
    $delta = -($q =~ s/\}/\}/g); # subtract closing braces
    $delta += ($q =~ s/\{/\{/g); # add opening braces
    
    $delta -= ($q =~ s/\)/\)/g); # subtract closing parens
    $delta += ($q =~ s/\(/\(/g); # add opening parens
    
    $tabtotal += ($delta < 0)?$delta:0; # subtract closing braces/parentheses
    
    $i = ($tabtotal > 0)?$tabtotal:0; # create tab index
    
    $tabtotal += ($delta>0)?$delta:0; # add opening braces/parentheses for next print
    
    if(substr($a,0,1) ne "#") { # don't tab comments
      print OUTFILE $tabstring x $i; # "tab" out to position
    }
    
    print OUTFILE "$a\n"; # print original line
  } # -- for (@infa)
  
  close OUTFILE;
  
  if($tabtotal != 0) {
    print STDERR " Indentation error: $tabtotal\n";
  }
  else {
    print STDERR "\n";
  }
} # sub process

Beautifier freshmeat.net

Beautifier (previously known as PSH, the PHP Syntax Highlighter) highlights and indents source code using highlight configuration files which are similar to Ultraedit highlighting files.

It supports C, C#, Java, Perl, PHP, Pascal, Lisp, Mumps, Eiffel, Euphoria, and x86 Assembler, amongst others.

It handles line/block comments, keyword highlighting, correct indentation, string highlighting, language contexts (allowing embedded languages), and selection highlighting. It is available in PHP and Perl versions.

[Dec 7, 2007] Project details for perltidy

freshmeat.net

Perltidy is a Perl script indenter and beautifier. By default it approximately follows the suggestions in perlstyle(1), but the style can be adjusted with command line parameters. Perltidy can also write syntax-colored HTML output.

Release focus: Minor feature enhancements

GNU Source-highlight - GNU Project - Free Software Foundation (FSF) v1.6 by Lorenzo Bettini

This program, given a source file, produces a document with syntax highlighting.

At the moment this package can handle

• Java
• C/C++
• Prolog
• Perl
• Php3
• Python
• Flex new
• ChangeLog new

as source languages, and

• HTML
• XHTML

as output format.

NOTICE: now the name of the program is source-highlight: there are no two separate programs, namely java2html and cpp2html, anymore. However there are two shell scripts with the same name in order to facilitate the migration (however their use is not advised).

GNU Source-highlight is free software. Please see the file COPYING for details. For documentation, please read this file.

GNU Source-highlight is a GNU program and its main home page is at GNU site:
http://www.gnu.org/software/src-highlite/source-highlight.html

You can download it from GNU's ftp site:
ftp://ftp.gnu.org/gnu/source-highlight/ or from one of its mirrors (see http://www.gnu.org/prep/ftp.html).

I do not distribute Windows binaries anymore; since, they can be easily built by using Cygnus C/C++ compiler, available at http://www.cygwin.com/. However, if you don't feel like downloading such compiler, you can request such binaries directly to me, by e-mail ([email protected]) and I can send them to you.
An MS-Windows port of Source-highlight is available from http://gnuwin32.sourceforge.net/.

You may also want to check the md5sum of the archives, which are also digitally signed by me (Lorenzo Bettini) with GNU gpg (http://www.gnupg.org). My GPG public key can be found at my home page (see at the end of this doc).

You can also get the patches, if they are available for a particular release (see below for patching from a previous version).

[Jul 12, 1998] Perl Beautifier Home Page - Google Groups by Tim Maher

7/12/98

I've got my Perl Beautifier running, with a reasonable set of default options, on http://www.consultix.wa.com/yumpy/cgi-pvt/pbeaut.cgi.

It's been tested primarily with the 66 modules of the standard Perl distribution, so I'm interested to see what happens when it's confronted with other programming styles.

Please help me test it by whipping some of your code at it! I'll be Emailed any syntax errors that my beautifier introduces, which could help me improve it, prior to making
it more generally available.

TIA,

Tim

JAPT (Just Another Perl Trainer)
+-------------------------------------------------------------------+
| Tim Maher, Ph.D. Head PERL Trainer & CEO, CONSULTIX |
| Email: [email protected] http://www.consultix.wa.com/yumpy/ |
| Board, Seattle UNIX Group: http://www.seaslug.org/seaslug.html |
| Leader, Seattle Perl Group: http://www.halcyon.com/spug/ |
+-------------------------------------------------------------------+

Recommended Links

Softpanorama Recommended

Top articles

Sites

Etc

Society

Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers :   Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy

Quotes

War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotes :  Somerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose Bierce :  Bernard Shaw : Mark Twain Quotes

Bulletin:

Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 :  Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method  : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law

History:

Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOS :  Programming Languages History : PL/1 : Simula 67 : C : History of GCC development :  Scripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-Month :  How to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

The Last but not Least Technology is dominated by two types of people: those who understand what they do not manage and those who manage what they do not understand ~Archibald Putt. Ph.D

The statements, views and opinions presented on this web page are those of the author (or referenced source) and are not endorsed by, nor do they necessarily reflect, the opinions of the Softpanorama society. We do not warrant the correctness of the information provided or its fitness for any purpose. The site uses AdSense so you need to be aware of Google privacy policy. You you do not want to be tracked by Google please disable Javascript for this site. This site is perfectly usable without Javascript.

Last modified: September 02, 2019