This command is called 'execp', which stands for 'execute with parameters'. What this does is it allows you to pass parameters to your exec files. Previously, an exec file (also known as a script or batch file) could only function as it was written. Now, by using the execp command to invoke your exec files, you can pass from one to six parameters to them, which can make the same exec file perform actions in different ways.
The exec command itself is a resident command in geoSHELL. It does not have to be loaded from a disk when used. Normally, when you use the exec command, it will load in your exec file and execute the commands contained within it. If you use the execp command, execp will take care of loading in the file, but it will also plug in any parameters that you have supplied on the command line. Once this is done, it will invoke the exec command to finish the job.
You can use the command exactly like you would the exec command and it will perform exactly the same. However, you can also supply up to six optional parameters. These parameters will be copied into the exec file in place of specific variables that you define when creating the exec file. Here's a simple example that uses one parameter:
execp copyram^ b
In this example, 'copyram' is the name of the exec file and 'b' is the parameter that is supplied to it. The exec file might look something like this:
fcopy parm1 getshell^
fcopy parm1 geoSHELL^
fcopy parm1 GEOPAINT^
fcopy parm1 MyFile^
What would happen here is that since one parameter was supplied, execp will load in the exec file called copyram and replace all occurences of the string 'parm1' with the letter 'b'. When the exec command executes the file, it will call fcopy to copy four different files to the ramdisk which is drive B in this example.
Let's look at another example that requires two parameters:
execp paint^ a^ 8
By now, you may have noticed that the filename for the exec file must be terminated by the usual up-arrow. Then each parameter is also terminated by an up-arrow. The last parameter on the line need not have an up-arrow since there are no more commands following it. One thing to keep in mind though is that you cannot have any multiple commands on the line with the execp command, since they would look like parameters to it. You must also place exactly one space between each up-arrow and the next parameter. If more than one space is used, the additional spaces will be considered part of the parameter, so this is perfectly legal.
Anyway, let's take a look at an exec file that could use this example:
parm1:
@cpparm2^
run GEOPAINT^
The first parameter, which is an 'a' would be put in place of 'parm1'. Since parm1 is followed by a colon, this would select drive A as the active drive. Then an '8' would get put in place of 'parm2' and the command to select partition 8 on a CMD device would be formed.
@SOME LIMITS
You can use as many as six different parameters named parm1 through parm6, and you can repeat any one of them as often as you wish within an exec file. Of course, depending on the size of your parameters, you may not be able to fit six parameters on one command line, especially in 40 column mode. If you find you need more room, you can define a function key from within an exec file and then use the function key. You can define the maximum allowed 80 characters for a function key if it is done from an exec file. The maximum size that each individual parameter may be is 16 characters. If you find that you need more than this for one parameter, then you would have to combine two parameters together.
If the user supplies more parameters on the command line than exist in the exec file, the extra parameters will simply be ignored. Likewise, if not enough parameters are supplied, then no substitutions will be made for the missing ones. The drawback to this is that when the exec command comes to a location containing the text 'parm2', or 'parm3', or whatever, it will naturally not be a valid command and execution of the file will cease.
@USING DEFAULTS
There might be some exec files that you will create and use that can be used exactly the s
@USING DEFAULTS
There might be some exec files that you will create and use that can be used exactly the same way most of the time. In that case, the execp command is not needed. You would just do things the way you have always done them. However, there might be those times when you need to make a change here or there, in which case it is handy to be able to send a parameter. The command execp allows you to define some default parameters right within the exec file. You simply put the execp command in the exec file and follow it with the default parameters enclosed within curly braces. A previous example might be written as follows:
execp {a^ 8^ GEOPAINT^ }
parm1:
@cpparm2^
run parm3^
If this file is named 'paint', you would just enter:
execp paint
Since you did not supply any parameters on the command line, the file will be loaded and executed as-is. Within the file, however, the execp command will be invoked and will recognize that you wish to use the default parameters. It will proceed to copy the defaults into the desired locations within the file and then exec will continue to execute the remainder of the file. If you had supplied any or all of the required parameters on the command line, then execp would only have used the defaults that you did not supply parameters for.
To use execp from within the exec file like this, you must be sure to place the left curly brace after execp with exactly one space in between. Then put the first default beginning just after the curly brace without any space, unless the space is needed as part of the parameter. Put an up-arrow at the end of each parameter with a space separating each one. You must end the default definitions with a right curly brace. And this must be placed after the last defined default with exactly one space separating it from the last up-arrow. In other words, it would be where the next parameter would be placed if there was one. Up to six default parameters may be used here also.
With execp contained in the file, the exec command itself could be used to execute the file since the execp command would set up the file correctly with the defaults anyway. The above example would then load and run GEOPAINT from partition #8 of drive A.
You can place execp with the default definitions anywhere within the exec file as long as they appear before the parameters that are to be changed. Normally, you would put it first in the file, since it is likely that the command is already loaded in memory if it was used to invoke the file.
@CALLING ANY PAGE
Execp has another handy feature in that it allows you to execute any page within an exec file. The resident exec command wil
@CALLING ANY PAGE
Execp has another handy feature in that it allows you to execute any page within an exec file. The resident exec command will only read page one. Just put the desired page number between the command name and the filename as in this example:
execp 15 menufile^ key1^ key2
This would load in page 15 of an exec file called 'menufile' and supply two parameters called 'key1' and key2'. Just like with the exec command, you can use the execp command to call up an exec file from within an exec file. You could conceivably have a 61 page exec file running some sort of presentation demo continuously. You can even put an exec file in a header or footer of your file. In this case, use page 62 or 63.
If no page number is supplied, then execp defaults to page one.
Here's one more example of a way to switch between 1581 partitions and native partitions on a CMD hard drive. To invoke the file, a command line would look like one of the following two forms:
execp hd^ a^ NT
- or -
execp hd^ c^ 81
The first example would make the hard drive as drive A begin working with native partitions, while the second example would make it use 1581 partitions if it is located as drive C. Here's what the exec file would look like:
remove parm1
installHDparm2.128 parm1
If you imagine the parameters copied in place of parm1 and parm2, you can figure out quite easily how the commands will work. Remember that the command such as installHD81.128 is created by the 'learn' command.
The execp command should open up many possibilities for anything from a simple exec file to a very elaborate one. Just use your imagination and put this command to work for you.
(.txt)