Programmer Guide/Command Reference/GOSUBX - Revision history

Jw at 07:49, 16 August 2019

2019-08-16T07:49:10Z

← Older revision		Revision as of 09:49, 16 August 2019
Line 1:		Line 1:
	GOSUBX <var>subrlabel</var> [<var>arguments</var>]		GOSUBX <var>subrlabel</var> [<var>arguments</var>]
	Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> label, and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new local varible space, instead the subroutine use ''in the local variable space of the caller'', meaning that any changes to local variables done in the subroutine will also be visible to the caller.		Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> [[Programmer_Guide/Source_code#labels\|label]], and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new local varible space, instead the subroutine use ''in the local variable space of the caller'', meaning that any changes to local variables done in the subroutine will also be visible to the caller.

	For this reason, the <code>GOSUBX</code> statement can be a useful tool if numerous arguments and data need to be passed or also for other reasons, but it should be used with care, because changing the variables of the callers may be done as easily unintentionally.		For this reason, the <code>GOSUBX</code> statement can be a useful tool if numerous arguments and data need to be passed or also for other reasons, but it should be used with care, because changing the variables of the callers may be done as easily unintentionally.

Toni at 07:56, 25 January 2016

2016-01-25T07:56:48Z

← Older revision		Revision as of 09:56, 25 January 2016
Line 2:		Line 2:
	Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> label, and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new local varible space, instead the subroutine use ''in the local variable space of the caller'', meaning that any changes to local variables done in the subroutine will also be visible to the caller.		Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> label, and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new local varible space, instead the subroutine use ''in the local variable space of the caller'', meaning that any changes to local variables done in the subroutine will also be visible to the caller.

	For this reason, the <code>GOSUBX</code> statement ~~can~~ can be a useful tool if numerous arguments and data need to be passed or for other reasons, but it should be used with care, because changing the variables of the callers may be done as easily unintentionally.		For this reason, the <code>GOSUBX</code> statement can be a useful tool if numerous arguments and data need to be passed or also for other reasons, but it should be used with care, because changing the variables of the callers may be done as easily unintentionally.

	See also:		See also:
	[[../GOTO\|GOTO]], [[../DISPATCH\|DISPATCH]], [[../MACRO\|MACRO]]		[[../GOTO\|GOTO]], [[../DISPATCH\|DISPATCH]], [[../MACRO\|MACRO]]

Toni at 07:55, 25 January 2016

2016-01-25T07:55:54Z

← Older revision		Revision as of 09:55, 25 January 2016
Line 3:		Line 3:

	For this reason, the <code>GOSUBX</code> statement can can be a useful tool if numerous arguments and data need to be passed or for other reasons, but it should be used with care, because changing the variables of the callers may be done as easily unintentionally.		For this reason, the <code>GOSUBX</code> statement can can be a useful tool if numerous arguments and data need to be passed or for other reasons, but it should be used with care, because changing the variables of the callers may be done as easily unintentionally.

			See also:
			[[../GOTO\|GOTO]], [[../DISPATCH\|DISPATCH]], [[../MACRO\|MACRO]]

Toni at 07:50, 25 January 2016

2016-01-25T07:50:59Z

← Older revision		Revision as of 09:50, 25 January 2016
Line 1:		Line 1:
	GOSUBX <var>subrlabel</var> [<var>arguments</var>]		GOSUBX <var>subrlabel</var> [<var>arguments</var>]
	Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> label, and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new ~~execution environment~~, instead ~~executing~~ the subroutine ''in the ~~execution environment~~ of the caller'', meaning that any changes to local variables done in the subroutine will be ~~''permanent'' and, hence,~~ visible to the caller.		Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> label, and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new local varible space, instead the subroutine use ''in the local variable space of the caller'', meaning that any changes to local variables done in the subroutine will also be visible to the caller.

	For this reason, the <code>GOSUBX</code> statement can can be a useful tool if numerous arguments and data need to be passed ~~hither and thither~~, but it should be used with ~~extreme~~ care, because changing the variables of the callers may be done as easily unintentionally.		For this reason, the <code>GOSUBX</code> statement can can be a useful tool if numerous arguments and data need to be passed or for other reasons, but it should be used with care, because changing the variables of the callers may be done as easily unintentionally.

Toni at 17:49, 13 April 2011

2011-04-13T17:49:39Z

← Older revision		Revision as of 19:49, 13 April 2011
Line 1:		Line 1:
	GOSUBX <var>~~subroutine~~</var> [<var>arguments</var>]		GOSUBX <var>subrlabel</var> [<var>arguments</var>]
	Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> label, and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new execution environment, instead executing the subroutine ''in the execution environment of the caller'', meaning that any changes to local variables done in the subroutine will be ''permanent'' and, hence, visible to the caller.		Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> label, and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new execution environment, instead executing the subroutine ''in the execution environment of the caller'', meaning that any changes to local variables done in the subroutine will be ''permanent'' and, hence, visible to the caller.

	For this reason, the <code>GOSUBX</code> statement can can be a useful tool if numerous arguments and data need to be passed hither and thither, but it should be used with extreme care, because changing the variables of the callers may be done as easily unintentionally.		For this reason, the <code>GOSUBX</code> statement can can be a useful tool if numerous arguments and data need to be passed hither and thither, but it should be used with extreme care, because changing the variables of the callers may be done as easily unintentionally.

Christian at 15:46, 23 March 2011

2011-03-23T15:46:26Z

← Older revision		Revision as of 17:46, 23 March 2011
Line 1:		Line 1:
	~~<code>~~GOSUBX <var>~~label~~</var> [<var>arguments</var>]</code>		GOSUBX <var>subroutine</var> [<var>arguments</var>]
	~~:Like~~ <code>GOSUB</code> ~~but no~~ new ~~variable namespace is created (i.e.~~ the subroutine ~~uses~~ the ~~same~~ environment as the caller). ~~This feature~~ can be useful if numerous arguments and data need to be passed ~~or shared~~, but it should be used with care, because the ~~subroutine can change~~ the ~~caller's variables. The [[Programmer_Guide/Command_Reference/MACRO_and_SHELL\|MACROX]] command implements a comparable feature~~.		Like the <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB ]]</code> statement, <code>GOSUBX</code> will call the local subroutine starting at the <var>subrlabel</var> label, and mandatorily ending with an appropriate [[Programmer_Guide/Command_Reference/EXIT\|EXIT]] statement. Note that, unlike the plain <code>[[Programmer Guide/Command Reference/GOSUB\|GOSUB]]</code>, <code>GOSUBX</code> will ''not'' create a new execution environment, instead executing the subroutine ''in the execution environment of the caller'', meaning that any changes to local variables done in the subroutine will be ''permanent'' and, hence, visible to the caller.

			For this reason, the <code>GOSUBX</code> statement can can be a useful tool if numerous arguments and data need to be passed hither and thither, but it should be used with extreme care, because changing the variables of the callers may be done as easily unintentionally.

Christian: Created page with '`GOSUBX label [arguments]` :Like `GOSUB` but no new variable namespace is created (i.e. the subroutine uses the same environment as th…'

2011-03-23T15:31:19Z

Created page with '<code>GOSUBX <var>label</var> [<var>arguments</var>]</code> :Like <code>GOSUB</code> but no new variable namespace is created (i.e. the subroutine uses the same environment as th…'

New page

<code>GOSUBX <var>label</var> [<var>arguments</var>]</code>
:Like <code>GOSUB</code> but no new variable namespace is created (i.e. the subroutine uses the same environment as the caller). This feature can be useful if numerous arguments and data need to be passed or shared, but it should be used with care, because the subroutine can change the caller's variables. The [[Programmer_Guide/Command_Reference/MACRO_and_SHELL|MACROX]] command implements a comparable feature.