Differences
This shows you the differences between two versions of the page.
Both sides previous revisionPrevious revisionNext revision | Previous revision | ||
v3:subroutines [2022/01/21 22:16] – [Forward Declaration] shawn | v3:subroutines [2024/07/30 22:43] (current) – [Overloading] neils | ||
---|---|---|---|
Line 3: | Line 3: | ||
While you can use the [[GOSUB]] command in pair with [[RETURN]] to call parts of code as subroutines, | While you can use the [[GOSUB]] command in pair with [[RETURN]] to call parts of code as subroutines, | ||
- | ===== Defining | + | ===== Defining |
Subroutines are named routines that accept zero or more arguments. The simplest syntax to define a subroutine is the following: | Subroutines are named routines that accept zero or more arguments. The simplest syntax to define a subroutine is the following: | ||
- | SUB < | + | SUB < |
< | < | ||
END SUB | END SUB | ||
- | It is worth noting that a subroutine does not require arguments. In this case you still must add the empty parentheses after the routine name, though, like so: | + | It is worth noting that the argument list is optional. If you omit the arguments, |
SUB < | SUB < | ||
Line 17: | Line 17: | ||
END SUB | END SUB | ||
- | ===== Calling | + | ===== Calling |
You can use the [[CALL]] keyword to call a subroutine. It behaves similarly to [[GOSUB]] with an important difference: '' | You can use the [[CALL]] keyword to call a subroutine. It behaves similarly to [[GOSUB]] with an important difference: '' | ||
Line 25: | Line 25: | ||
END SUB | END SUB | ||
| | ||
- | CALL greet(" | + | CALL greet(" |
- | CALL greet(" | + | CALL greet(" |
The '' | The '' | ||
- | ===== Exiting | + | ===== Exiting |
The subroutine will be exited at the '' | The subroutine will be exited at the '' | ||
Line 39: | Line 39: | ||
END SUB | END SUB | ||
CALL test(-1) | CALL test(-1) | ||
- | ===== Local and global variables | + | ===== Local and Global Variables |
Variables defined inside a subroutine are local variables, i. e. they are only accessible within that subroutine. Global variables (the ones defined outside subroutines) are visible from within all subroutines. | Variables defined inside a subroutine are local variables, i. e. they are only accessible within that subroutine. Global variables (the ones defined outside subroutines) are visible from within all subroutines. | ||
Line 53: | Line 53: | ||
==== Shadowing ==== | ==== Shadowing ==== | ||
- | A local variable may have the same name as a global variable. In such cases the local variable will be used inside the subroutine. Consider the following example: | + | A local variable may have the same name as a global variable. In such cases the local variable will be used inside the subroutine. |
a = 42 | a = 42 | ||
Line 83: | Line 83: | ||
</ | </ | ||
- | ==== Static | + | ==== Static |
You can mix static and dynamic behaviour using the '' | You can mix static and dynamic behaviour using the '' | ||
Line 109: | Line 109: | ||
===== Overloading ===== | ===== Overloading ===== | ||
- | When passing arguments to a subroutine, the compiler will match the number of arguments | + | Subroutine overloading, commonly known as method overloading |
- | If the number | + | Overloaded subroutines have the same name but differ in the type, number, |
- | But what if the programmer desires a subroutine that behaves differently depending on the number or type of arguments that are passed? This is possible using overloading. A subroutine may have as many variations as desired. If there is more than one variation, the compiler will locate the best match among the candidates for the call. Consider the following example: | + | ==== Compile-Time Polymorphism ==== |
- | | + | The appropriate subroutine to call is determined at compile-time based on the arguments provided in the call. |
- | PRINT "a is an integer: "; a | + | |
+ | Consider the following example: | ||
+ | |||
+ | | ||
+ | PRINT msg | ||
END SUB | END SUB | ||
| | ||
- | SUB test (a AS STRING * 16) OVERLOAD | + | SUB PrintMessage(msg AS STRING * 16, num AS INT) OVERLOAD |
- | PRINT "a is a string: | + | PRINT msg; " "; |
END SUB | END SUB | ||
| | ||
- | CALL test(5) | + | CALL PrintMessage(" |
- | CALL test("hello") | + | CALL PrintMessage("The number is", 42) |
<adm warning> | <adm warning> | ||
Line 151: | Line 155: | ||
The implementation of the subroutine later in the code must use the same number and type of arguments as the declaration. Overloading is still possible, though: you may declare overloaded variations of the subroutine and implement each variation later on in the program. | The implementation of the subroutine later in the code must use the same number and type of arguments as the declaration. Overloading is still possible, though: you may declare overloaded variations of the subroutine and implement each variation later on in the program. | ||
</ | </ | ||
- | ===== Subroutine | + | ===== Subroutine |
- | Subroutines, | + | Subroutines, |
- | * //Global// visibility: the subroutine is callable from within the entire code module | + | * //Global// visibility: the subroutine is callable from within the entire code module it was defined |
* //Shared// visibility: the subroutine is callable from within all code modules. | * //Shared// visibility: the subroutine is callable from within all code modules. | ||
Line 168: | Line 172: | ||
END SUB | END SUB | ||
- | This way you make sure it is callable from within other code modules. Read more about [[code_modules|Code Modules here]]. | + | This will ensure the subroutine |
<- flowcontrol|Previous page ^ subroutines|Subroutines ^ functions|Next page -> | <- flowcontrol|Previous page ^ subroutines|Subroutines ^ functions|Next page -> | ||