Support --language and --backend pragmas; permit filename on the command line

- --language/--backend keep pragmas consistent with the command line
- Permit filenames or scripts on the command line for flexibility

Author: Chris White

lib/XML/Axk/App.pm

@@ -37,6 +37,8 @@ my %CMDLINE_OPTS = (
     # They are listed in alphabetical order by option name,
     # lowercase before upper, although the code does not require that order.
 
+    #BACKEND => ['b', '|backend=s'],        # TODO
+
     #DUMP_VARS => ['d', '|dump-variables', false],
     #DEBUG => ['D','|debug', false],
     EVAL => ['e','|source=s@', $dr_save_source],
@@ -144,10 +146,15 @@ sub Main {
         return 0;
     }
 
-    # Treat the first non-option arg as a script if appropriate
+    # Treat the first non-option arg as a script file if it exists
+    # and is readable, otherwise as axk source.
     unless(@{$opts{SOURCES}}) {
         die "No scripts to run" unless @$lrArgs;
-        push @{$opts{SOURCES}}, [false, shift @$lrArgs];
+        my $option = shift @$lrArgs;
+        push @{$opts{SOURCES}}, [
+            -r $option && (-f $option || -l $option),
+            $option
+        ];
     }
 
     my $core = XML::Axk::Core->new(\%opts);
@@ -192,18 +199,24 @@ XML::Axk::App - awk-like XML processor, command-line interface
 
 =head1 USAGE
 
-    axk [options] [--] [script] [input filename(s)]
+    axk [options] [--] [input filename or script]
 
 =head1 INPUTS
 
 A filename of C<-> represents standard input.  To actually process a file
 named C<->, you will need to use shell redirection (e.g., C<< axk < - >>).
 Standard input is the default if no input filenames are given.
 
-The first non-option argument is a program if no -e or -f are given.
+The first non-option argument is used for program text if no -e or -f
+are given.  If that argument names a readable regular file or symlink,
+an axk program will be loaded from that file.  Otherwise, that argument
+is used as an axk program directly.
+
 The script language version for a -e will default to the latest if the text
 on the command line doesn't specify a language version.
 
+# TODO make -L and -B apply to following -e's
+
 =head1 OPTIONS
 
 =over

lib/XML/Axk/Core.pm

@@ -114,6 +114,7 @@ sub load_script_text {
     # Text to wrap around the script
     my ($leader, $trailer) = ('', '');
 
+    #say "Text is $text";
     my ($lrPieces, $has_lang) = XML::Axk::Preparse::pieces(\$text,
         $add_Ln ? { L => {} } : undef);
 

lib/XML/Axk/Preparse.pm

@@ -65,16 +65,22 @@ first pragma in the source text.
 =cut
 
 sub pieces {
+    my @retval;
+
     my $srText = shift or croak('Need source text');
     croak 'Need a source reference' unless ref $srText eq 'SCALAR';
 
-    my @retval;
+    # Initial pragmas, if any
+    if(@_) {
+        push @retval, { text => '', start => 1, pragmas => (shift) };
+    }
+
     my $hasLang = false;
 
     # Regex to match a pragma line.  A pragma line can include up to two
     # -L/-B items, generally one -L and one -B.
     my $RE_Pragma_Item = q{
-        -(?<kind>[BL])\h*
+        -(?<kind>[BL]|-backend|-language)\h*
         (?:
                 0*(?<digits>\d+)     # digit form
             |   (?<name>[a-zA-Z][a-zA-Z0-9\.]*) # alpha form, e.g., -Lfoo.bar.
@@ -88,28 +94,27 @@ sub pieces {
         # Leader: on a #! line, or first thing on any line
         (?#!\H*\h.*?)?
         (($RE_Pragma_Item)(?{
-            $hrPragmas->{$+{kind}} = { digits => $+{digits}, name => $+{name} };
+            my $kind = $+{kind};
+            $kind = 'B' if $kind eq '-backend';
+            $kind = 'L' if $kind eq '-language';
+            $hrPragmas->{$kind} = { digits => $+{digits}, name => $+{name} };
         })){1,2}
     }mx;
 
-    # Initial pragmas, if any
-    if(@_) {
-        push @retval, { text => '', start => 1, pragmas => (shift) };
-    }
-
     # Main loop
     open my $fh, '<', $srText;
-    while(<$fh>) {
+    LINE: while(<$fh>) {
 
-        MAYBE_PRAGMA: if(/^(?:#!|-)/) {     # fast bail
+        MAYBE_PRAGMA: { if(/^(?:#!|-)/) {     # fast bail
             $hrPragmas = {};
             last MAYBE_PRAGMA unless /$RE_Pragma/;
 
+            #say "Saw pragma";
             $hrPragmas->{name} =~ s/\./::/g if $hrPragmas->{name};
             push @retval, { text => '' , start => $.+1, pragmas => $hrPragmas };
             $hasLang = true if $hrPragmas->{L};
-            next;
-        }
+            next LINE;
+        }}
 
         # Otherwise, normal line.
         # TODO permit the caller to say what to do with lines before the first pragma
@@ -118,6 +123,7 @@ sub pieces {
             die "Source text can't come before a pragma line" unless @retval;
         }
         $retval[-1]->{text} .= $_;
+        #say "Stashed $_";
     }
     close $fh;
 

t/01-preparse.t

@@ -28,12 +28,36 @@ EOT
 like($$srTest, qr/^use XML::Axk::L::L1/);
 like($$srTest, qr/^#line.*foo/m);
 
+$srTest = pp('foo', <<'EOT');
+#!x -L 1
+EOT
+like($$srTest, qr/^use XML::Axk::L::L1/);
+like($$srTest, qr/^#line.*foo/m);
+
+$srTest = pp('foo', <<'EOT');
+#!x --language 1
+EOT
+like($$srTest, qr/^use XML::Axk::L::L1/);
+like($$srTest, qr/^#line.*foo/m);
+
 $srTest = pp('foo', <<'EOT');
 -L1
 EOT
 like($$srTest, qr/^use XML::Axk::L::L1/);
 like($$srTest, qr/^#line.*foo/m);
 
+$srTest = pp('foo', <<'EOT');
+-L 1
+EOT
+like($$srTest, qr/^use XML::Axk::L::L1/);
+like($$srTest, qr/^#line.*foo/m);
+
+$srTest = pp('foo', <<'EOT');
+--language 1
+EOT
+like($$srTest, qr/^use XML::Axk::L::L1/);
+like($$srTest, qr/^#line.*foo/m);
+
 
 done_testing();