Chapter Contents

Previous

Next

ENTRY

Category:

Modular Programming and Object Oriented

argument-list

lists one or more sets of arguments, with each set specified as follows:

var-list <: INPUT |UPDATE |OUTPUT> :data-type

var-list

lists one or more variables to which the parameter in the corresponding position in the DISPLAY routine or function is passed. For details, see DISPLAY.

INPUT | I

specifies that, at run time, the variable contains the value that is copied from the corresponding parameter of the calling program. However, when the program finishes, the value is not copied back to the calling program. This is equivalent to using CALL NOCHANGE() in the calling program.

UPDATE | U

specifies that, at run time, the variable contains the value that is copied from the corresponding parameter of the calling program. When the program finishes, the value is copied back to that parameter (unless CALL NOCHANGE is specified).

OUTPUT | O

specifies that, when the program finishes, the value is copied back to the corresponding parameter in the calling program. An error condition results if the corresponding parameter in the calling program is a constant, because a constant cannot receive a value.

data-type

specifies the data type of the variable. Any valid SCL data type may be specifid. A named data type (for example, CHAR or LIST) must be preceded by the : delimiter. The delimiter is optional for unnamed data types (for example, $).

arg-list-id

contains the identifier for the SCL list that will contain all the arguments passed to the ENTRY statement. This includes all optional arguments.

Type: List

rest-list-id

contains the identifier for the SCL list that will contain all arguments that are passed to the ENTRY statement but are not explicitly specified in argument-list for either ENTRY or OPTIONAL=.

Type: List

Details

The ENTRY statement receives parameters from the DISPLAY routine or function. It can also return a value if the ENTRY statement contains both the RETURN= option to declare the data type of the returned value and a RETURN statement that specifies either the variable containing the value or the literal value to be returned.

To be compatible with the applications built in earlier releases of SAS software, the : delimiter is optional for variables that are assigned unnamed data types (for example, $), but it is required for variables that are assigned named data types. The following example shows a variety of data type declarations:

ENTRY:  char1  :$20
        char2  $20
        char3  :input :char(20)
        char4 char5:char
        num1   :8
        num2   8
        num3   : num
        mylist :list
        myobj  :object
        mybutton :mylib.mycat.button.class return=char;

RETURN=data-type enables you to return a value to the calling program. An error condition is produced if data-type is not the same as the type of data to be returned to the calling program. Use a RETURN statement in the program to specify the value to return.

When there are no options in the ENTRY statement, there is a strict correspondence between DISPLAY parameters and ENTRY statement arguments. The arguments and parameters must agree in number, data type, and relative position. If you pass an incorrect number of parameters or a parameter of the incorrect type, SCL stops executing the program. The correspondence of arguments to parameters is less restrictive when you use the options REST=, ARGLIST=, and OPTIONAL= in the ENTRY statement.

OPTIONAL= enables you to specify a list of optional arguments that are used only if the calling program supplies the corresponding parameters in the DISPLAY parameter list. If the corresponding parameters in the DISPLAY routine are not supplied, then the optional arguments are initialized to missing values.

ARGLIST= and REST= enable you to pass a variable number of parameters to the ENTRY statement. You determine the types and order of the variable arguments. The lists identified by arg-list-id and rest-list-id are created automatically when the entry is called, and they are deleted automatically when the entry ends. When arrays are passed as parameters, the array is expanded into individual items, and these items are inserted into the arg-list-id and rest-list-id lists. ARGLIST= and REST= are mutually exclusive, so you can use only one or the other.

The called program can modify all call-by-reference arguments that it receives. However, it cannot modify any call-by-value arguments. For a description of call-by-reference and call-by-value, see DISPLAY .

By default, values for call-by-reference arguments are returned to the calling program. If you want a called program to receive values but not to return values to its calling program, use the NOCHANGE routine. Or, you can use the INPUT, OUTPUT, or UPDATE option for each variable to specify how its value is passed and returned.

An SCL program with ENTRY statement arguments cannot be executed by itself due to the uninitialized arguments. To test a program that receives parameters via the ENTRY statement, run it with the SCL debugger. The debugger enables you to initialize all the ENTRY arguments before program execution starts.

Examples

Example 1: Returning a Value from the ENTRY Statement

B.SCL contains the following ENTRY statement, which uses several numeric arguments:

entry x  y z u v :i :num return=num;
INIT:
   total=x+y+z+u+v;
return(total); 

total=display('b.scl',1,2,3,4,5);
put total=;

total=15

Example 2: Using ENTRY with OPTIONAL=

B.SCL contains the following ENTRY statement, which defines multiple character variables:

entry x   :char(10)
      y z :num
      optional=u v w :num ;
INIT:
   put x= y= z= u= v= w=;
return;

call display('b.program','one',2,3,4,5);

X='one' Y=2 Z=3 U=4 V=5 W=.

Example 3: Using ENTRY with ARGLIST=

B.SCL contains the following ENTRY statement, declaring both numeric, character, and list variables:

entry x   :char(10)
      y z :num
      optional=u v   :num
      arglist=mylist;

INIT:
   put x= y = z= u= v=;
   call putlist(mylist);
return;

call display('b.scl','one',2,3,4,5);

x='one'
y=2
z=3
u=4
v=5('one' 2 3 4 5) [list-id]

Example 4: Using ENTRY with ARGLIST=

Suppose B.SCL contains

entry arglist=mylist;
 INIT:
    call putlist(mylist);
 return; 

call display('b.scl','one',2,3,4,5);

 ('one' 2 3 4 5) [list-id]

Example 5: Using ENTRY with REST=

B.SCL contains the following ENTRY statement, which declares numeric variables:

entry x y :num
      rest=mylist;
INIT:
   put x= y=;
   call putlist(mylist);
 return;

call display('b.scl',1,2,3,4,5);

x=1
y=2
(3 4 5) [list-id]

Example 6: Using ENTRY with OPTIONAL= and REST=

B.SCL contains the following ENTRY statement, which declares both numeric and character variables along with parameter Z, which is optional:

 entry x y :num optional=z :num rest=mylist;
 INIT:
    put x= y= z=;
    call putlist(mylist);
 return;

call display('b.scl',1,2,3,4,5);

x=1
y=2
z=3
(4 5) [list-id]

DISPLAY

NOCHANGE

METHOD

RETURN

Chapter Contents

Previous

Next

Top of Page

Copyright 1999 by SAS Institute Inc., Cary, NC, USA. All rights reserved.