It's pretty easy to deal with up to 9 arguments in batch through built-in variables %1 through %9.  For example:

    echoargs.cmd
    @echo off
    echo %1
    echo %2
    echo %3
    echo %4
    echo %5
    echo %6
    echo %7
    echo %8
    echo %9

If you feed this A B C D E F G H I, you'll get back those letters, one per line.

But, if you try this with a tenth argument, it won't work like you might have thought:

    echo10args.cmd
    @echo off
    echo %1
    echo %2
    echo %3
    echo %4
    echo %5
    echo %6
    echo %7
    echo %8
    echo %9
    echo %10

You'll see that the last line echoes the first argument again, followed by a 0 (A0).  That is, it gets parsed as "echo %1, then 0".  So, how do you deal with this if you need more than 9 arguments?  My first suggestion would be to see if there's a way you can deal with fewer arguments, though that's often not possible.  If you must, you'll need to loop over each argument and deal with them one by one.  Here's an example listing:

At :Top, we check to see if there are any arguments to deal with.  If not, we go to :NoMoreArgs and bail out.  Then (assuming we didn't bail out), we call :EchoArg with the parameter that's first in the list (in this case, A).  :EchoArg takes the parameter it was passed (A) and echos Arg: A.  Once it's done, we use goto :EOF to indicate that we're done with this subroutine.  Control then passes back up to the line just after our call.

This next step is where all the magic happens.  The shift command takes everything you've passed in and shifts them all to the left by one.  That is, what used to be %3 becomes %2, %2 becomes %1, and %1 falls off.  So now, since there was a tenth parameter, that one becomes %9, which means there's now a way of referring to it.

Once we've shifted everything, we go back to the :Top again.  Now since our original second argument (B) has been shifted to %1, we do the same thing all over again.  That gets echoed, we shift again, and C is the new %1 (and K is the new %9).  We keep doing this until we run out of arguments, and then we bail out.

There are a few important points in here:

• For anything you call, whether it's a "subroutine" like :EchoArg or another script (like call foo.cmd), the arguments passed to it are "local".  That is, if you were to call :EchoArg %8 (that is, H in our case), as far as :EchoArg is concerned, that's %1.  It's its own first argument.
• The built-in variable %* (meaning all arguments passed in) is not at all affected by shift.  In our example, no matter how much you shift, %* will still be A B C D E F G H I J K.  This is sort of unfortunate, in my opinion, since there are times that I've found that I wanted to deal with the first (say) three arguments, then refer to "the rest" in one fell swoop, but the only way to do that is shift your way through them one by one.

While we're on the topic of shift, you can see from shift /? that it can also take a switch that indicates where you want to start shifting.  This takes a bit of wrapping your brain around, but it goes like this:

Given a list of arguments A B C D E F G H I J K, a regular shift would change that to B C D E F G H I J K.

But, we could also use shift /3 (for example) to start the shifting at the third argument.  So our A B C D E F G H I J K becomes A B D E F G H I J K; the third argument (C) gets swallowed.  Note that even though you can address 9 elements at a time %1 through %9, you can't do shift /9 and have the tenth argument become the ninth.  You're limited to shift /8. 

Oh well, you can't have everything...