... I ran some evals and it seems to be working fine ... what I want to do is take arguments from a command line (.txt) and then parse the file.

When you "ran some evals", how did you do that, exactly? Normally, PRD works on a string that you supply to some particular "rule" defined in your grammar. Apparently, in your "evals", you've just been passing numbers -- these get "stringified" by automatically by perl so that string operations can be performed on them.

In order to pass a string that comes from a file, just read the file contents into a scalar variable, and pass that variable to the parser rule -- e.g.:

my $input_text;
{
    local $/;  # turn on slurp mode within this block
    open( my $input, "<", $ARGV[0] );
    $input_text = <$input>;
}
$parser->my_first_rule( $input_text );
[download]

  first_rule : identifier | binops | lbinops | integer | number
[download]

I posted a question earlier about how to parse a file containing 4Test code with Parse::RecDescent

Parse::RecDescent is quite difficult to understand fully, but I hope someone can comprehend what I'm trying to do

I don't want to post the entire code because it is unnecessary. In fact I don't have any problems with the parser I have written. The grammar works fine and my evals all return what I have asked them to. All I want to know/do is read in a file and parse it. I'm having trouble understanding if this is in fact how Parse::RecDescent could potentially be used.

Here is part of the code:

 
use strict;
use warnings;
use Parse::RecDescent;


$::RD_ERRORS = 1;
$::RD_WARN   = 1;
$::RD_HINT   = 1;

my $grammar = q{
     identifier : /[a-z]\w+/
     binops : '+' | '-' | '/' | '*' | '%' | '**'
     lbinops: '!' | '<' | '>' | '>='| '<='| '&&'| '||' | '=='
     integer: /-\d+/ {print "hello $item[-1]" if $::debugging;}
     number : /(\d+|\d*\.\d+)/ {print "hello $item[-1]" if $::debuggin
+g;}
};

#evals: these will evaluate to "1" and print
#print "valid number\n" if $parser->number(2);
#print "valid integer\n" if $parser->integer(-2);
[download]

All I want to know/do is read in a file and parse it.

The following code will read an input file, parse using Parse::RecDescent, then write the output to a file. I adapted the example code from Parse-RecDescent-FAQ (Super Search is your friend).

The input file consists of just a single line: aa

The output file also consists of just a single line: a

use strict; 
use warnings; 
use Parse::RecDescent;
use File::Slurp;

my $grammar = 'startrule: ( "a" | "aa" ) "a"';
my $parser  = Parse::RecDescent->new($grammar);

my $text = read_file('input.txt');
write_file('output.txt', $parser->startrule($text), "\n");
[download]

Hopefully, you can apply this trivial example to your code. (Keep in mind that this is the 1st time I've ever used Parse::RecDescent.)

So the problem is that you don't know how to read a file?

my $file;
{
   open(my $fh, '<', ...) or die ...;
   local $/;
   $file = <$fh>;
}
[download]

But it also seems that your grammar isn't complete. You've defined some basic blocks, but not how they fit together. If you just want a tokenizer, you can use something like

use strict;
use warnings;

use Parse::RecDescent;

$::RD_ERRORS = 1;
$::RD_WARN   = 1;
$::RD_HINT   = 1;

my $grammar = <<'__EOI__';

    {
        use strict;
        use warnings;
    }

    tokenize : token(s?) /\Z/ { $item[1] }

    token    : ident
             | binops
             | lbinops
             | number
             | integer
             | /./ { [ skip => $items[1] ] }

    ident    : /[a-zA-Z][a-zA-Z0-9_]*/   { [ @items ] }
    binops   : /\*\*|[+\-\/*%]/          { [ @items ] }
    lbinops  : />=?|<=?|!|&&|\|\||==/    { [ @items ] }
    number   : /-?[0-9]*\.[0-9]+/        { [ @items ] }
    integer  : /-?[0-9]/                 { [ @items ] }

__EOI__

...

my @tokens = $parser->tokenize($file);
[download]