Here’s my entry. I started doing this in the Bourne shell, but halfway through I felt just too dirty writing it. So, I whipped this up in Perl, instead. Enjoy (and if you think this is too verbose, be happy that I didn’t “use strict;”…. at least I didn’t write it in lisp).

!/usr/bin/perl -w

$real_cal = “/usr/bin/cal”; if (@ARGV != 1 || $ARGV[0] ne “now”) { exec($real_cal, @ARGV) || die “could not exec $real_cal: $!\n”; }

Set $months to be our current year * 12 + the current month of the year.

Remember, $t[5] contains the number of years since 1900. Also, $t[4] is

the month of the year starting at zero (Jan == 0, Dec == 11).

@t = localtime(time()); $months = (($t[5] + 1900) * 12) + $t[4];

@cal will store the merged output of three months’ output from cal(1).

@cal = ();

Iterate over the three months for which we want data.

for $month ($months – 1, $months, $months + 1) {

append_cal wants the first argument to be an array reference,

the second argument to be the month, numbering from one, not zero,

and the last to be the year.

append_cal(\@cal, ($month % 12) + 1, int($month / 12)); }

Print out our data, appending newlines.

foreach $line (@cal) { $line =~ s/\s+$//; print $line, “\n”; } #

append_cal – Append the calendar for the specified month and year to

an array of lines.

Parameters:

$cal: an array reference into which to store the output from cal(1).

$month: month of the year, suitable for passing directly to cal(1).

Note that this starts at one (Jan == 1, Dec == 12).

$year: year, numbering from zero (2004 == 2004).

# sub append_cal { my ($cal) = shift(@); my ($month) = shift(@); my ($year) = shift(@_); my ($fh); my ($index); my ($line); open($fh, “$real_cal $month $year|”) || die “opening pipe from cal: $!\n”; $index = 0; while (defined($line = <$fh>)) { chomp($line); if (!defined($$cal[$index])) { $$cal[$index] = “”; } $$cal[$index] .= sprintf(“%-20s “, $line); $index++; } close($fh); }

Heh. I’ve been meaning to write this for years, but never got around to it.

Here’s a version in zsh, modeled after gkeramidas’ solution, but gets the years wrapped properly, and uses two different constructs to get things side by side. I use zsh specifically for the =() construct, which sticks the contents of the output of the command inside in a temporary file, though once I’m using zsh, I take advantage of a few other features.

For the “now” clause, I’ve two ways to print the calendars side by side. The first, using sdiff, forks fewer processes, but I believe is likely to be more fragile, given the column cutting. The second, using join, is probably more robust, but forks eleven processes to do the job. Choose your poison.

!/bin/zsh -f

PATH=/usr/bin if [[ $# -eq 1 ]]; then case $1 in (<0-12>) cal $1 $(date +%Y) ;; (“now”) this=( $(date +%m) $(date +%Y) ) next=( $(( this[1] % 12 + 1)) $this[2] ) prev=( $(( (this[1] – 2) % 12 + 1)) $this[2] ) (( next[1] == 1 )) && (( ++next[2] )) (( prev[1] == 0 )) && (( –prev[2], prev[1] = 12 )) sdiff =(cal $=prev) =(sdiff -w 60 =(cal $=this) =(cal $=next)) | \ cut -c 1-22,67-88,98- echo join -t$’\t’ -o 1.2,2.2 =(join -t$’\t’ -o 1.2,2.2 \ =(cal $=prev | cat -n) =(cal $=this | cat -n) | expand -t 23 | cat -n) \ =(cal $=next | cat -n) | expand -t 46 ;; (*) exec cal $0 ;; esac else exec cal $@ fi

And voila, here’s a version that hopefully has no bugs, is written in ksh(1) to make use of the $(( expr )) syntax for brevity, and is faster:

#!/bin/sh
if [ $# -eq 1 ]; then
case $1 in
[0-9]|[0-9][0-9])
cal $1 date '+%Y' ;;
now)
year=$(date '+%Y')
mon=$(date '+%m')
pmon=$(( ( $mon - 2 ) % 12 + 1 ))
[ $pmon -eq 0 ] && pmon=12
pyear=$year
[ $pmon -gt $mon ] && pyear=$(( $pyear - 1 ))
nmon=$(( $mon % 12 + 1 ))
nyear=$year
[ $nmon -lt $mon ] && nyear=$(( $nyear + 1 ))
{ cal "$pmon" "$pyear" | sed -e 's/^/a:/' ; \
cal "$mon" "$year"   | sed -e 's/^/b:/' ; \
cal "$nmon" "$nyear" | sed -e 's/^/c:/' ; } | \
awk 'BEGIN { ja = jb = jc = 0;}
/^a:/ {av[ja] = substr($0,3); ja++;}
/^b:/ {bv[jb] = substr($0,3); jb++;}
/^c:/ {cv[jc] = substr($0,3); jc++;}
END {
jmax = ja;
if (jb > jmax) {jmax = jb;}
if (jc > jmax) {jmax = jc;}
for (ja = 0; ja < jmax; ja++) {
printf "%-22s%-22s%-22s\n", av[ja],bv[ja],cv[ja];
}
}'
;;
*)
cal "$1" ;;
esac
else
cal "$@"
fi

Again, with pre tags, sigh.

!/bin/perl

#

You are not supposed to understand this, just be in awe of my perl-foo.

# use strict; use warnings; my ($m, $y, @my) = (localtime())[4, 5]; $m += 1; $y += 1900; if (@ARGV == 1 && $ARGV[0] eq ‘now’) { $my[1] = [ $m, $y ]; } elsif (@ARGV == 1 && $ARGV[0] =~ /^\d+$/ && $ARGV[0] >= 1 && $ARGV[0] <= 12) { $my[1] = [ $ARGV[0], $y ]; } else { exec(‘/usr/bin/cal’, @ARGV) || die(“Can’t exec cal: $!\n”); } $_ = $my[1][0] – 1; @{$my[0]} = $_ == 0 ? ( 12, $my[1][1] – 1 ) : ( $, $my[1][1] ); $ = $my[1][0] + 1; @{$my[2]} = $_ == 13 ? ( 1, $my[1][1] + 1 ) : ( $, $my[1][1] ); my @cal = map([ map({ chomp($); $_ } qx{/usr/bin/cal $->[0] $->[1]}) ], @my); for ($_ = 0; $_ < 7; $++) { printf(“%-20s %-20s %-20s\n”, map(shift(@{$}) || ”, @cal)); } exit(0);

And if I win this competition I’d just like to remind you that you still haven’t given me my prize for winning your sort(1) competition – yes I was that anonymous poster.

Actually someone over on my blog has kindly fixed a bug in the version I posted here, and between us we’ve reduced it down to 393 bytes, or 380 bytes if you exclude the #! line and the trailing newline.

This is my version, done on 10 minutes:

!/usr/bin/env perl

my $arg = shift @ARGV;
my @years = ( );
my @months = ( );
my %output = ( );
my @lt = localtime; # see manual for localtime in perl but:

index 5 is year minus 1900,

index 4 is month minus 1

if (not defined $arg or $arg eq ”) {
system (‘/usr/bin/env cal’);
exit (0);
} elsif ($arg =~ m/^now$/i) {
foreach (($lt [4] – 1)..($lt [4] + 1)) {
if ($_ < 0) {
push @years, $lt [5] + 1900 – 1;
push @months, $_ + 11;
} elsif ($_ > 11) {
push @years, $lt [5] + 1900 + 1;
push @months, $_ – 11;
} else {
push @years, $lt [5] + 1900;
push @months, $_ + 1;
}
}
} elsif ($arg =~ m/^[0-9]{0,2}$/ and $arg+0 >= 1 and $arg+0 <= 12) {
push @years, $lt [5] + 1900;
push @months, $arg+0;
} else {
die ‘usage: ‘ . $0 . ‘ [<month> | now]‘;
}

foreach my $i (0..$#years) {
$output{$i} = [split ("\n", /usr/bin/env cal $months[$i] $years[$i])];
}

-- join output

foreach my $row (0..7) { # max of each cal output are 8 rows
print join (' 'x3, map { $_ . ' 'x(20-length ($)) } map { $output{$}->[$row] } (0..$#years) ) . "\n";
}

my email: Antonio.Santos at pt.jazztel.com

This ksh script weighs in at just 375 characters (including the #! line). Your turn, Alan.

!/bin/ksh -p

z=/usr/bin/cal c(){ $z $|sed ‘s/$/ /’|expand -t 23 } date “+%Y %m”|read y m d=0${1%%now} [[ $d -lt 13 && $d -gt 0 ]]&&exec $z $d ${2:-$y} [[ $1 != "now" ]]&&exec $z $ set -A a $y $y $y set -A b — $((m-1)) $m $((m+1)) f[1]=’a[0]=$((y-1));b[0]=12′ f[12]=’a[2]=$((y+1));b[2]=1′ eval ${f[$m]} eval paste for i in 0 1 2; do echo '<(c '${b[$i]} ${a[$i]}')' done (note: the whitespace in the sed substitution is a single tab)

Even more shuffling produces a 365 character solution:

!/bin/ksh -p

z=/usr/bin/cal c(){ sed ‘s/$/ /’|expand -t23 } date +%Y\ %m|read y m d=0${1%%now} [[ $d -lt 13 && $d -gt 0 ]]&&exec $z $d ${2:-$y} [[ $1 = now ]]||exec $z $* set -A a $y $y $y set -A b — $((m-1)) $m $((m+1)) f[1]=’a[0]=$((y-1));b[0]=12′ f[12]=’a[2]=$((y+1));b[2]=1′ eval ${f[$m]} eval paste for i in 0 1 2; do echo "<($z ${b[$i]} ${a[$i]}|c)" done

Jesus. And they call me crazy, … Why not change z=/usr/bin/cal\ to z=/bin/cal If Solaris already has a symlink, you might use it after all, you can save 4 more characters )

!/bin/ksh -p

c() { cal $(($1%12+1)) $(($1/12)) | sed -e ‘s/$/ /’ | expand -21 } [[ $# -ne 1 ]] && exec cal “$@” integer y=$(date +%Y) [[ $1 != now ]] && { [[ $1 -lt 13 ]] && exec cal $1 $y || exec cal $1 } integer m=$(date +%m) integer d=$((y*12+(m-1))) exec paste <(c $((d-1))) <(c $((d))) <(c $((d+1)))