How to run a program with parameters (Pick BASIC)

Question

In Pick BASIC source code I see lines such as

CALL SOMEPROGRAM (PARAM1, PARAM2)

How can I invoke that same line from the TCL command prompt? I've tried variations of the following but nothing seems to work.

SOMEPROGRAM ('1','2')

The only way I've found is to write and compile a program with the single line command and then run that program.

Answer 1

Tcl can invoke your overall program file as a subprocess using exec, but it is up to your program to turn that into a call to the program and processing of correct arguments.

The Tcl code to run the program will probably look something like this:

exec {*}[auto_execok CALLERPROGRAM]

If you were passing the arguments 1 and 2 over, you'd do this:

exec {*}[auto_execok CALLERPROGRAM] 1 2

Again, that does not say how those values get from the command line into the Pick Basic subprogram. You'll need to consult the Pick documentation for how to do that. But I know (and have tested) that Tcl will definitely have correctly provided them…

Answer 2

If this was your routine:

SUBROUTINE REALPROG(A,B)
PRINT "A is ":A
PRINT "B is ":B
END

To call it from command line, you'd build this routine:

PROGRAM WRAPPERPROG
COMMAND.RECEIVED = SENTENCE()
VAR1 = FIELD(COMMAND.RECEIVED,' ',2)
VAR2 = FIELD(COMMAND.RECEIVED,' ',3)
CALL REALPROG(VAR1, VAR2)
END

Assuming you typed this from the TCL/ECL command line:

WRAPPERPROG DOG CAT

VAR1 would be DOG and VAR2 would be CAT

...and would call REALPROG with those parameters and you should see

A is DOG
B is CAT

Answer 3

In Pick BASIC CALL statements are used to call subroutines and they can't be directly executed from TCL. Subroutines are denoted by setting the first word on the first line of the program to SUBROUTINE.

You can execute "programs" from TCL. These don't include the SUBROUTINE at the top of the source code. In some Pick BASIC variants you may need to include PROGRAM but I think most don't require that (I know D3 doesn't). These programs can be run from TCL but they don't get the command line parameters passed in automatically like subroutines do. I think you can use SENTENCE() in pretty much any Pick BASIC variant to get the command line parameters.

Here's an example program that will print the command line arguments:

PRINT SENTENCE()
END

You could use this to create a program that will take the command line arguments and pass them into a subroutine to do something for you.

Answer 4

I wrote a utility 30+ years ago to address this. Other Basics (QB, VB, Dartmouth) have a single command line. You are either writing lines into a program or processing single line requests. Pick did not.

I created an MD item called PRINT. It then runs a program called BP PRINT that takes the whole TCLREAD line, writes it out to another program space called BP PPRINT, compiles it and then runs it.

Incredibly useful. Thus at TCL these commands would work:

PRINT ; X=1 ; Y=2 ; CALL SOMESUB(X,Y)

PRINT ; FOR I=1 TO 12 ; PRINT (I*28)"DMA" ; NEXT I

PRINT ; OPEN "CUST" THEN READV NAME FROM "1234", 1 THEN PRINT NAME

PRINT OCONV("12345678","MD2Z,$")

PRINT DATE()

Basically anything that can be programmed within a single line of code can be typed at TCL this way. Any IF or ELSE statements must be completed in the same one line. Great for testing.

Should be part of every Pick implementation out of the box.

Mark Johnson

Answer 5

I was literally typing out some elaborate answer, but your question has been answered. You cant directly call a subroutine, you need to call a program that calls the subroutine. Also subroutines are a good way to separate code from the main program to reduce clutter, but they arent always necessary. Other methods you can use are functions, or GOSUBS/GOTOS. This is an example of a GOTO below..

VAR = 'HELLO'
GOTO 10:

10:
CRT VAR

from the TCL you will call the name of your program and all of this code will be executed without calling another program. The output will be the string hello.