Sync
This commit is contained in:
Ingy döt Net
parent
6f050a029e
commit
776bba907c
3887 changed files with 59894 additions and 7280 deletions
137
Task/Call-a-function/REXX/call-a-function-1.rexx
Normal file
137
Task/Call-a-function/REXX/call-a-function-1.rexx
Normal file
|
|
@ -0,0 +1,137 @@
|
|||
/*REXX program to demonstrate various methods of calling a REXX function*/
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Calling a function that REQUIRES no arguments. │
|
||||
│ │
|
||||
│ In the REXX language, there is no way to require the caller to not │
|
||||
│ pass arguments, but the programmer can check if any arguments were │
|
||||
│ (or weren't) passed. │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
yr=yearFunc()
|
||||
say 'year=' yr
|
||||
exit
|
||||
|
||||
yearFunc: procedure
|
||||
if arg()\==0 then call sayErr "SomeFunc function won't accept arguments."
|
||||
return left(date('Sorted'),3)
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Calling a function with a fixed number of arguments. │
|
||||
│ │
|
||||
│ I take this to mean that the function requires a fixed number of │
|
||||
│ arguments. As above, REXX doesn't enforce calling (or invoking) │
|
||||
│ a (any) function with a certain number of arguments, but the │
|
||||
│ programmer can check if the correct number of arguments have been │
|
||||
│ specified (or not). │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
ggg=FourFunc(12,abc,6+q,zz%2,'da 5th disagreement')
|
||||
say 'ggg squared=' ggg**2
|
||||
exit
|
||||
|
||||
FourFunc: procedure; parse arg a1,a2,a3; a4=arg(4) /*another way get a4*/
|
||||
|
||||
if arg()\==4 then do
|
||||
call sayErr "FourFunc function requires 4 arguments,"
|
||||
call sayErr "but instead it found" arg() 'arguments.'
|
||||
exit 13
|
||||
end
|
||||
return a1+a2+a3+a4
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Calling a function with optional arguments. │
|
||||
│ │
|
||||
│ Note that not passing an argument isn't the same as passing a null │
|
||||
│ argument (a REXX variable whose value is length zero). │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
x=12; w=x/2; y=x**2; z=x//7 /* z is x modulo seven.*/
|
||||
say 'sum of w, x, y, & z=' SumIt(w,x,y,,z) /*pass 5 args, 4th is null*/
|
||||
exit
|
||||
|
||||
SumIt: procedure; sum=0
|
||||
|
||||
do j=1 for arg()
|
||||
if arg(j,'E') then sum=sum+arg(j) /*the Jth arg may have been omitted*/
|
||||
end
|
||||
|
||||
return sum
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Calling a function with a variable number of arguments. │
|
||||
│ │
|
||||
│ This situation isn't any different then the previous example. │
|
||||
│ It's up to the programmer to code how to utilize the arguments. │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Calling a function with named arguments. │
|
||||
│ │
|
||||
│ REXX allows almost anything to be passed, so the following is one │
|
||||
│ way this can be accomplished. │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
what=parserFunc('name=Luna',"gravity=.1654",'moon=yes')
|
||||
say 'name=' common.name
|
||||
gr=common.gr
|
||||
say 'gravity=' gr
|
||||
exit
|
||||
|
||||
parseFunc: procedure expose common.
|
||||
do j=1 for arg()
|
||||
parse var arg(j) name '=' val
|
||||
upper name
|
||||
call value 'COMMON.'name,val
|
||||
end
|
||||
return arg()
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Calling a function in statement context. │
|
||||
│ │
|
||||
│ REXX allows functions to be called (invoked) two ways, the first │
|
||||
│ example (above) is calling a function in statement context. │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Calling a function in within an expression. │
|
||||
│ │
|
||||
│ This is a variant of the first example. │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
yr=yearFunc()+20
|
||||
say 'two decades from now, the year will be:' yr
|
||||
exit
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Obtaining the return value of a function. │
|
||||
│ │
|
||||
│ There are two ways to get the (return) value of a function. │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
currYear=yearFunc()
|
||||
say 'the current year is' currYear
|
||||
|
||||
call yearFunc
|
||||
say 'the current year is' result
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Distinguishing built-in functions and user-defined functions. │
|
||||
│ │
|
||||
│ One objective of the REXX language is to allow the user to use any │
|
||||
│ function (or subroutine) name whether or not there is a built-in │
|
||||
│ function with the same name (there isn't a penality for this). │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
qqq=date() /*number of real dates that Bob was on. */
|
||||
say "Bob's been out" qqq 'times.'
|
||||
www='DATE'('USA') /*returns date in format mm/dd/yyy */
|
||||
exit /*any function in quotes is external. */
|
||||
|
||||
date: return 4
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ Distinguishing subroutines and functions. │
|
||||
│ │
|
||||
│ There is no programatic difference between subroutines and │
|
||||
│ functions if the subroutine returns a value (which effectively │
|
||||
│ makes it a function). REXX allows you to call a function as if │
|
||||
│ it were a subroutine. │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ In REXX, all arguments are passed by value, never by name, but it │
|
||||
│ is possible to accomplish this if the variable's name is passed │
|
||||
│ and the subroutine/function could use the built-in-function VALUE │
|
||||
│ to retrieve the variable's value. │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
/*┌────────────────────────────────────────────────────────────────────┐
|
||||
│ In the REXX language, partial application is possible, depending │
|
||||
│ how partial application is defined; I prefer the 1st definition (as│
|
||||
│ (as per the "discussion" for "Partial Function Application" task: │
|
||||
│ 1. The "syntactic sugar" that allows one to write (some examples│
|
||||
│ are: map (f 7 9) [1..9] │
|
||||
│ or: map(f(7,_,9),{1,...,9}) │
|
||||
└────────────────────────────────────────────────────────────────────┘*/
|
||||
77
Task/Call-a-function/REXX/call-a-function-2.rexx
Normal file
77
Task/Call-a-function/REXX/call-a-function-2.rexx
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
/* REXX ***************************************************************
|
||||
* 29.07.2013 Walter Pachl trying to address the task concisely
|
||||
***********************************************************************
|
||||
* f1 Calling a function that requires no arguments
|
||||
* f2 Calling a function with a fixed number of arguments
|
||||
* f3 Calling a function with optional arguments
|
||||
* f4 Calling a function with a variable number of arguments
|
||||
* f5 Calling a function with named arguments
|
||||
* f6 Using a function in statement context
|
||||
* f7 Using a function within an expression
|
||||
* f8 Obtaining the return value of a function
|
||||
* f8(...) is replaced by the returned value
|
||||
* call f8 ... returned value is in special vatiable RESULT
|
||||
* f9 Distinguishing built-in functions and user-defined functions
|
||||
* bif is enforced by using its name quoted in uppercase
|
||||
* fa,fb Distinguishing subroutines and functions
|
||||
* Stating whether arguments are passed by value or by reference
|
||||
* Arguments are passed by value
|
||||
* ooRexx supports passing by reference (Use Arg instruction)
|
||||
* Is partial application possible and how
|
||||
* no ideas
|
||||
**********************************************************************/
|
||||
say f1()
|
||||
Say f2(1,2,3)
|
||||
say f2(1,2,3,4)
|
||||
say f3(1,,,4)
|
||||
Say f4(1,2)
|
||||
Say f4(1,2,3)
|
||||
a=4700; b=11;
|
||||
Say f5('A','B')
|
||||
f6() /* returned value is used as command */
|
||||
x=f7()**2
|
||||
call f8 1,2; Say result '=' f8(1,2)
|
||||
f9: Say 'DATE'('S') date()
|
||||
call fa 11,22; Say result '=' fa(1,,
|
||||
2) /* the second comma above is for line continuation */
|
||||
Signal On Syntax
|
||||
Call fb 1,2
|
||||
x=fb(1,2)
|
||||
Exit
|
||||
f1: Return 'f1 doesn''t need an argument'
|
||||
f2: If arg()=3 Then
|
||||
Return 'f2: Sum of 3 arguments:' arg(1)+arg(2)+arg(3)
|
||||
Else
|
||||
Return 'f2: Invalid invocation:' arg() 'arguments. Needed: 3'
|
||||
f3: sum=0
|
||||
do i=1 To arg()
|
||||
If arg(i,'E')=0 Then Say 'f3: Argument' i 'omitted'
|
||||
Else sum=sum+arg(i)
|
||||
End
|
||||
Return 'f3 sum=' sum
|
||||
f4: sum=0; Do i=1 To arg(); sum=sum+arg(i); End
|
||||
Return 'f4: Sum of' arg() 'arguments is' sum
|
||||
f5: Parse Arg p1,p2
|
||||
Say 'f5: Argument 1 ('p1') contains' value(p1)
|
||||
Say 'f5: Argument 2 ('p2') contains' value(p2)
|
||||
Return 'f5: sum='value(p1)+value(p2)
|
||||
f6: Say 'f6: dir ft.rex'
|
||||
Return 'dir ft.rex'
|
||||
f7: Say 'f7 returns 7'
|
||||
Return 7
|
||||
f8: Say 'f8 returns arg(1)+arg(2)'
|
||||
Return arg(1)+arg(2)
|
||||
date: Say 'date is my date function'
|
||||
Return translate('ef/gh/abcd','DATE'('S'),'abcdefgh')
|
||||
fa: Say 'fa returns arg(1)+arg(2)'
|
||||
Return arg(1)+arg(2)
|
||||
fb: Say 'fb:' arg(1)','arg(2)
|
||||
Return
|
||||
|
||||
Syntax:
|
||||
Say 'Syntax raised in line' sigl
|
||||
Say sourceline(sigl)
|
||||
Say 'rc='rc '('errortext(rc)')'
|
||||
If sigl=39 Then
|
||||
Say 'fb cannot be invoked as function (it does not return a value'
|
||||
Exit
|
||||
Loading…
Add table
Add a link
Reference in a new issue