Data update
This commit is contained in:
Ingy döt Net
parent
5150844a7d
commit
4bb20c9b71
7735 changed files with 38060 additions and 199180 deletions
|
|
@ -1 +0,0 @@
|
|||
S: String := Ada.Text_IO.Get_Line;
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
function F(X: Integer; Y: Integer := 0) return Integer; -- Y is optional
|
||||
...
|
||||
A : Integer := F(12);
|
||||
B : Integer := F(12, 0); -- the same as A
|
||||
C : Integer := F(12, 1); -- something different
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
type Integer_Array is array (Positive range <>) of Integer;
|
||||
function Sum(A: Integer_Array) return Integer is
|
||||
S: Integer := 0;
|
||||
begin
|
||||
for I in A'Range loop
|
||||
S := S + A(I);
|
||||
end loop;
|
||||
return S;
|
||||
end Sum;
|
||||
...
|
||||
A := Sum((1,2,3)); -- A = 6
|
||||
B := Sum((1,2,3,4)); -- B = 10
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
function H (Int: Integer;
|
||||
Fun: not null access function (X: Integer; Y: Integer)
|
||||
return Integer);
|
||||
return Integer;
|
||||
|
||||
...
|
||||
|
||||
X := H(A, F'Access) -- assuming X and A are Integers, and F is a function
|
||||
-- taking two Integers and returning an Integer.
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
Positional := H(A, F'Access);
|
||||
Named := H(Int => A, Fun => F'Access);
|
||||
Mixed := H(A, Fun=>F'Access);
|
||||
|
|
@ -7,8 +7,8 @@ sayHello: $[name][
|
|||
]
|
||||
|
||||
printAll: $[args][
|
||||
loop args [arg][
|
||||
print arg
|
||||
loop args [argv][
|
||||
print argv
|
||||
]
|
||||
]
|
||||
|
||||
|
|
|
|||
|
|
@ -1,65 +0,0 @@
|
|||
CALL "No-Arguments"
|
||||
|
||||
*> Fixed number of arguments.
|
||||
CALL "2-Arguments" USING Foo Bar
|
||||
|
||||
CALL "Optional-Arguments" USING Foo
|
||||
CALL "Optional-Arguments" USING Foo Bar
|
||||
*> If an optional argument is omitted and replaced with OMITTED, any following
|
||||
*> arguments can still be specified.
|
||||
CALL "Optional-Arguments" USING Foo OMITTED Bar
|
||||
*> Interestingly, even arguments not marked as optional can be omitted without
|
||||
*> a compiler warning. It is highly unlikely the function will still work,
|
||||
*> however.
|
||||
CALL "2-Arguments" USING Foo
|
||||
|
||||
*> COBOL does not support a variable number of arguments, or named arguments.
|
||||
|
||||
*> Values to return can be put in either one of the arguments or, in OpenCOBOL,
|
||||
*> the RETURN-CODE register.
|
||||
*> A standard function call cannot be done in another statement.
|
||||
CALL "Some-Func" USING Foo
|
||||
MOVE Return-Code TO Bar
|
||||
|
||||
*> Intrinsic functions can be used in any place a literal value may go (i.e. in
|
||||
*> statements) and are optionally preceded by FUNCTION.
|
||||
*> Intrinsic functions that do not take arguments may optionally have a pair of
|
||||
*> empty parentheses.
|
||||
*> Intrinsic functions cannot be defined by the user.
|
||||
MOVE FUNCTION PI TO Bar
|
||||
MOVE FUNCTION MEDIAN(4, 5, 6) TO Bar
|
||||
|
||||
*> Built-in functions/subroutines typically have prefixes indicating which
|
||||
*> compiler originally incorporated it:
|
||||
*> - C$ - ACUCOBOL-GT
|
||||
*> - CBL_ - Micro Focus
|
||||
*> - CBL_OC_ - OpenCOBOL
|
||||
*> Note: The user could name their functions similarly if they wanted to.
|
||||
CALL "C$MAKEDIR" USING Foo
|
||||
CALL "CBL_CREATE_DIR" USING Foo
|
||||
CALL "CBL_OC_NANOSLEEP" USING Bar
|
||||
*> Although some built-in functions identified by numbers.
|
||||
CALL X"F4" USING Foo Bar
|
||||
|
||||
*> Parameters can be passed in 3 different ways:
|
||||
*> - BY REFERENCE - this is the default way in OpenCOBOL and this clause may
|
||||
*> be omitted. The address of the argument is passed to the function.
|
||||
*> The function is allowed to modify the variable.
|
||||
*> - BY CONTENT - a copy is made and the function is passed the address
|
||||
*> of the copy, which it can then modify. This is recomended when
|
||||
*> passing a literal to a function.
|
||||
*> - BY VALUE - the function is passed the address of the argument (like a
|
||||
*> pointer). This is mostly used to provide compatibility with other
|
||||
*> languages, such as C.
|
||||
CALL "Modify-Arg" USING BY REFERENCE Foo *> Foo is modified.
|
||||
CALL "Modify-Arg" USING BY CONTENT Foo *> Foo is unchanged.
|
||||
CALL "C-Func" USING BY VALUE Bar
|
||||
|
||||
*> Partial application is impossible as COBOL does not support first-class
|
||||
*> functions.
|
||||
*> However, as functions are called using a string of their PROGRAM-ID,
|
||||
*> you could pass a 'function' as an argument to another function, or store
|
||||
*> it in a variable, or get it at runtime.
|
||||
ACCEPT Foo *> Get a PROGRAM-ID from the user.
|
||||
CALL "Use-Func" USING Foo
|
||||
CALL Foo USING Bar
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
/*REXX pgms demonstrates various methods/approaches of invoking/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() /*the function name is caseless if it isn't */
|
||||
/*enclosed in quotes (') or apostrophes (").*/
|
||||
say 'year=' yr
|
||||
exit /*stick a fork in it, we're all done. */
|
||||
|
||||
yearFunc: procedure /*function ARG returns the # of args.*/
|
||||
errmsg= '***error***' /*an error message eyecatcher string. */
|
||||
if arg() \== 0 then say errmsg "the YEARFUNC function won't accept arguments."
|
||||
return left( date('Sorted'), 3)
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
/*╔════════════════════════════════════════════════════════════════════╗
|
||||
║ 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). ║
|
||||
║ In some languages, these are known as "generic" functions. ║
|
||||
╚════════════════════════════════════════════════════════════════════╝*/
|
||||
|
||||
ggg= FourFunc(12, abc, 6+q, zz%2, 'da 5th disagreement')
|
||||
say 'ggg squared=' ggg**2
|
||||
exit /*stick a fork in it, we're all done. */
|
||||
|
||||
FourFunc: procedure; parse arg a1,a2,a3 /*obtain the first three arguments. */
|
||||
a4= arg(4) /*another way to obtain the 4th arg. */
|
||||
errmsg= '***error***' /*an error message eyecatcher string. */
|
||||
if arg() \== 4 then do
|
||||
say err "FourFunc function requires 4 arguments,"
|
||||
say err "but instead it found" arg() 'arguments.'
|
||||
exit 13 /*exit function with a RC of 13*/
|
||||
end
|
||||
|
||||
return a1 + a2 + a3 + a4
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
/*╔════════════════════════════════════════════════════════════════════╗
|
||||
║ 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 five args, the 4th arg is "null"*/
|
||||
exit /*stick a fork in it, we're all done. */
|
||||
|
||||
SumIt: procedure
|
||||
$= 0 /*initialize the sum to zero. */
|
||||
do j=1 for arg() /*obtain the sum of a number of args. */
|
||||
if arg(j,'E') then $= $ + arg(j) /*the Jth arg may have been omitted. */
|
||||
end /*j*/
|
||||
|
||||
return $
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
/*╔════════════════════════════════════════════════════════════════════╗
|
||||
║ 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 /*stick a fork in it, we're all done. */
|
||||
|
||||
parseFunc: procedure expose common.
|
||||
do j=1 for arg()
|
||||
parse var arg(j) name '=' val
|
||||
upper name /*uppercase it.*/
|
||||
call value 'COMMON.'name,val
|
||||
end
|
||||
return arg()
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
/*╔════════════════════════════════════════════════════════════════════╗
|
||||
║ 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 /*stick a fork in it, we're all done. */
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
/*╔════════════════════════════════════════════════════════════════════╗
|
||||
║ Obtaining the return value of a function. ║
|
||||
║ ║
|
||||
║ There are 2 ways to get the (return) value (RESULT) of a function. ║
|
||||
╚════════════════════════════════════════════════════════════════════╝*/
|
||||
|
||||
currYear= yearFunc()
|
||||
say 'the current year is' currYear
|
||||
|
||||
call yearFunc
|
||||
say 'the current year is' result /*result can be RESULT, it is caseless.*/
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
/*╔════════════════════════════════════════════════════════════════════╗
|
||||
║ 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). ║
|
||||
╚════════════════════════════════════════════════════════════════════╝*/
|
||||
|
||||
/*date: as in going out with someone. */
|
||||
qqq= date() /*number of real dates that Bob was on.*/
|
||||
/*hopefully, it accurately counts dates*/
|
||||
say "Bob's been out" qqq 'times.'
|
||||
www= 'DATE'("USA") /*returns date in format mm/dd/yyyy */
|
||||
/*any function in quotes is external. */
|
||||
exit /*stick a fork in it, we're all done. */
|
||||
|
||||
date: return 4 /*Bob only "went out" 4 times, no need */
|
||||
/* to actually count, he quit after 4. */
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
/*╔════════════════════════════════════════════════════════════════════╗
|
||||
║ Distinguishing subroutines and functions. ║
|
||||
║ ║
|
||||
║ There is no programmatic 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 per the "discussion" for "Partial Function Application" task: ║
|
||||
║ 1. The "syntactic sugar" that allows one to write some examples ║
|
||||
║ are: map (f 1 9) [1..9] ║
|
||||
║ or: map (f(1,_,9)) [1, ..., 9] ║
|
||||
╚════════════════════════════════════════════════════════════════════╝*/
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
/* 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
|
||||
|
|
@ -87,5 +87,3 @@ $ref.(@args); # 37 as object invocation, explicit postfix
|
|||
1.h(@args); # 43 as method via dispatcher
|
||||
1."$h-sym"(@args); # 44 as method via dispatcher, symbolic
|
||||
f(|@args); # 45 equivalent to f(1,2,3)
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue