IB Statements/UserDefinedProcs - Revision history

Badge at 21:12, 23 January 2011

2011-01-23T21:12:58Z

← Older revision		Revision as of 21:12, 23 January 2011
Line 19:		Line 19:

	Numeric Factor(n)		Numeric Factor(n)
-	length 32.0 & local i z	+	length 32.0 & local i z
-		+
	print (et)		print (et)
-		+	.
	fact:		fact:
	print 'factorial of what?'		print 'factorial of what?'
Line 28:		Line 27:
	if i > 29 print 'Warning -- factorial of a number > 29 will overflow' & wait		if i > 29 print 'Warning -- factorial of a number > 29 will overflow' & wait
	if i = 0 stop		if i = 0 stop
-		+	!!
-	Z = Factor(I) ! Call our function here	+	Z = Factor(I) ! Call our function here
-		+	!!
-	Print i;' Factorial Is ' ! Iterate through the function to get the factorial	+	Print i;' Factorial Is ' ! Iterate through the function to get the factorial
	Print z		Print z
	Wait		Wait

Badge at 21:10, 23 January 2011

2011-01-23T21:10:08Z

← Older revision		Revision as of 21:10, 23 January 2011
Line 23:		Line 23:
	print (et)		print (et)

-	fact:	+	fact:
	print 'factorial of what?'		print 'factorial of what?'
	input i		input i
Line 38:		Line 38:
	wait		wait
	goto fact		goto fact
-	end	+	end
		+	! Called Function

-	Numeric Factor(n)	+	Numeric Factor(n)
	Length 32.0 & Local x		Length 32.0 & Local x
	print 'fact';n		print 'fact';n
Line 47:		Line 48:
	x = n - 1		x = n - 1
	Procreturn Factor(x) * n ! Calling myself		Procreturn Factor(x) * n ! Calling myself
-	End	+	End

SteveA at 20:48, 20 January 2011

2011-01-20T20:48:18Z

← Older revision		Revision as of 20:48, 20 January 2011
Line 1:		Line 1:
-	User Defined Procedures in Comet32 (Procs)	+	'''User Defined Procedures in Comet32 (Procs)'''
-	~~User Defined Procedures in Comet32 (Procs)~~	+

-	May be subroutines or functions A Proc may or may not return a value.	+	May be subroutines or functions. A Proc may or may not return a value.
	Procs that return a value are called Functions and those that do not are called subroutines.		Procs that return a value are called Functions and those that do not are called subroutines.

	Functions may be numeric or string depending on the kind of result they return. Functions may be called anywhere a system function is called.		Functions may be numeric or string depending on the kind of result they return. Functions may be called anywhere a system function is called.
-	Subroutines are ~~called~~ with the CALL verb (Not GOSUB).	+	Subroutines are invoked with the CALL verb (Not GOSUB).

	Procs must be declared in the main program. Just like variables, Procs must be declared before use. In fact, they must be declared in the Main part of the program.		Procs must be declared in the main program. Just like variables, Procs must be declared before use. In fact, they must be declared in the Main part of the program.

Badge: New page: User Defined Procedures in Comet32 (Procs) User Defined Procedures in Comet32 (Procs) May be subroutines or functions A Proc may or may not return a value. Procs that return a value are ...

2009-05-20T01:12:16Z

New page: User Defined Procedures in Comet32 (Procs) User Defined Procedures in Comet32 (Procs) May be subroutines or functions A Proc may or may not return a value. Procs that return a value are ...

New page

User Defined Procedures in Comet32 (Procs)
User Defined Procedures in Comet32 (Procs)

May be subroutines or functions A Proc may or may not return a value.
Procs that return a value are called Functions and those that do not are called subroutines.

Functions may be numeric or string depending on the kind of result they return. Functions may be called anywhere a system function is called.
Subroutines are called with the CALL verb (Not GOSUB).

Procs must be declared in the main program. Just like variables, Procs must be declared before use. In fact, they must be declared in the Main part of the program.
Procs may take arguments and have locally defined local variables. The body of a proc looks like a mini program. It has a declaration section and an executable section.
All locals declared in the proc except for arguments are cleared. A clear local statement is not required.
Procs inherit all system variables and all variables declared in the main program. If a variable name is not found in the local declarations for a proc, and the variable is declared in the main program, that variable is used by the proc. In this case, the variable is used BY REFERENCE; that is, if the proc changes the variable, it is changed for the main program as well.

Arguments may be passed by value or by reference. If an argument to a proc also appears in the declarations of local for the proc, the argument is copied into that local variable. If an argument does not also appear as a local variable, it as passed by reference. When a variable is passed by reference, no copy action is done (better performance), and the contents of the variable may be changed for the calling routine as well as for the proc.
Procs can call procs and may be recursive. Each time a proc is called; new storage for the proc is created. The arguments are then passed, initializing some of that storage. When a ProcReturn is executed, all local storage for that instance of the proc is destroyed. This provides a mechanism for recursion.
An example:

! Declare Subroutines And Functions

Numeric Factor(n)
length 32.0 & local i z

print (et)

fact:
print 'factorial of what?'
input i
if i > 29 print 'Warning -- factorial of a number > 29 will overflow' & wait
if i = 0 stop

Z = Factor(I) ! Call our function here

Print i;' Factorial Is ' ! Iterate through the function to get the factorial
Print z
Wait
z = Factorial(I) ! use the math library to get the factorial for validation purposes
Print z
wait
goto fact
end

Numeric Factor(n)
Length 32.0 & Local x
print 'fact';n
if n <= 1 Procreturn 1
print 'returning ';n &wait
x = n - 1
Procreturn Factor(x) * n ! Calling myself
End