m204wiki - User contributions [en]

$SinH

2018-09-21T00:03:56Z

JALWiccan: Automatically generated page update

Hyperbolic sine
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $SinH function.
[[Category: Mathematical $functions]]



The <var>$SinH</var> function returns
the hyperbolic sine of an argument that is given in radians.
If the magnitude of the argument exceeds 175.366, an error message is
printed and a 0 is returned.

==Syntax==
%num = $SinH(x)

$Sin

2018-09-21T00:03:55Z

JALWiccan: Automatically generated page update

Sine
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $Sin function.
[[Category: Mathematical $functions]]



The <var>$Sin</var> function returns
the sine of an argument that is given in radians.
If the magnitude of the argument exceeds 1015 radians, an error
message is printed and a 0 is returned.

==Syntax==
%num = $Sin(x)

$Pi

2018-09-21T00:03:55Z

JALWiccan: Automatically generated page update

Value of pi
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $Pi function.

The <var>$Pi</var> function returns the value of pi (<code>π</code>) to 15 significant
digits (3.14159265358979).

==Syntax==
%num = $Pi 

[[Category: Mathematical $functions]]

$Exp2 or $Exp 2

2018-09-21T00:03:53Z

JALWiccan: Automatically generated page update

Two's exponent function
Note: Many $functions have been deprecated in favor of Object Oriented
methods.
The OO equivalent for the
<var>$Exp2</var>
function is the <var>[[Antilog2 (Float function)|Antilog2]]</var> function.
[[Category: Mathematical $functions]]



The <var>$Exp2</var> function (or its alias, <var>$Exp_2</var>) returns the
value <code>2x</code>.

==Syntax==
%num = $Exp2(x) 
%num = $Exp_2(x) 

==Usage notes==
<ul>
<li>If ''x'' exceeds 251.99, an error message is printed and the request is cancelled.</li>
</ul>

$Exp10 or $Exp 10

2018-09-21T00:03:52Z

JALWiccan: Automatically generated page update

Ten's exponent function
Note: Many $functions have been deprecated in favor of Object Oriented
methods.
The OO equivalent for the
<var>$Exp10</var>
function is the <var>[[Antilog10 (Float function)|Antilog10]]</var> function.
[[Category: Mathematical $functions]]



The <var>$Exp10</var> function (or its alias, <var>$Exp_10</var>) returns the
value <code>10x</code>.

==Syntax==
%num = $Exp10(x) 
%num = $Exp_10(x) 

==Usage notes==
<ul>
<li>If ''x'' exceeds 75.85, an error message is printed and the request is cancelled.</li>
</ul>

$Exp or $Exp e

2018-09-21T00:03:52Z

JALWiccan: Automatically generated page update

Exponential function
Note: Many $functions have been deprecated in favor of Object Oriented
methods.
The OO equivalent for the $Exp
function is the <var>[[AntilogE (Float function)|AntilogE]]</var> function.
[[Category: Mathematical $functions]]



The <var>$Exp</var> function (or its alias, <var>$Exp_e</var>) returns the
value <code>ex</code>.

==Syntax==
%num = $Exp(x) 
%num = $Exp_e(x) 

==Usage notes==
<ul>
<li>If ''x'' exceeds 174.63, an error message is printed and the request is cancelled.</li>
</ul>

$Erf

2018-09-21T00:03:51Z

JALWiccan: Automatically generated page update

Error function
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $Erf function.

The <var>$Erf</var> function returns the value:

2/√π 0∫x e-z2 dz



==Syntax==
%num = $Erf(x) 

[[Category: Mathematical $functions]]

$Cotan

2018-09-21T00:03:51Z

JALWiccan: Automatically generated page update

Cotangent
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $Cotan function.
[[Category: Mathematical $functions]]



The <var>$Cotan</var> function returns
the cotangent of an argument that is given in radians.
If the
magnitude of the argument exceeds 1015 radians, an error message is
printed and a 0 is returned.

==Syntax==
%num = $Cotan(x)

$CosH

2018-09-21T00:03:50Z

JALWiccan: Automatically generated page update

Hyperbolic cosine
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $CosH function.
[[Category: Mathematical $functions]]



The <var>$CosH</var> function returns
the hyperbolic cosine of an argument that is given in radians.
If the magnitude of the argument exceeds 175.366, an error message is printed
and a 0 is returned.

==Syntax==
%num = $CosH(x)

$Cos

2018-09-21T00:03:49Z

JALWiccan: Automatically generated page update

Cosine
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $Cos function.

The <var>$Cos</var> function returns
the cosine of an argument that is given in radians.
If the
magnitude of the argument exceeds 1015 radians, an error message is
printed and a 0 is returned.

==Syntax==
%num = $Cos(x) 

[[Category: Mathematical $functions]]

$ArcTan2

2018-09-21T00:03:49Z

JALWiccan: Automatically generated page update

Inverse tangent of ratio of arguments
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $ArcTan2 function.
[[Category: Mathematical $functions]]



The <var>$ArcTan2</var> function returns
the arctangent (in radians) of the ratio of two arguments
— ''x'' divided by ''y''.
If the second
argument is 0 (or omitted), an error message is printed and a 0 is returned.

==Syntax==
%num = $ArcTan2(x,y)

$ArcTan

2018-09-21T00:03:48Z

JALWiccan: Automatically generated page update

Inverse tangent
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $ArcTan function.
[[Category: Mathematical $functions]]



The <var>$ArcTan</var> function returns
the arctangent (in radians) of a given argument.

==Syntax==
%num = $ArcTan(x)

$ArcSin

2018-09-21T00:03:48Z

JALWiccan: Automatically generated page update

Inverse sine
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $ArcSin function.




The <var>$ArcSin</var> function returns
the arcsine (in radians) of a given argument.
If the magnitude of the argument exceeds 1, an error message is printed
and a 0 is returned.

==Syntax==
%num = $ArcSin(x) 

[[Category: Mathematical $functions]]

$ArcCos

2018-09-21T00:03:48Z

JALWiccan: Automatically generated page update

Inverse cosine
Note: Many $functions have been deprecated in favor of Object Oriented
methods. There is currently no direct OO equivalent for the $ArcCos function.

The <var>$ArcCos</var> function returns
the arccosine (in radians) of a given argument.
If the magnitude of the argument exceeds 1, an error message is printed
and a 0 is returned.

==Syntax==
%num = $ArcCos(x) 

[[Category: Mathematical $functions]]

$Abs

2018-09-21T00:03:47Z

JALWiccan: Automatically generated page update

Absolute value
Note: Many $functions have been deprecated in favor of Object Oriented
methods.
The OO equivalent for the $Abs function is the <var>[[Absolute (Float function)|Absolute]]</var> function.


The <var>$Abs</var> function returns the absolute value of its given argument.

==Syntax==
%num = $Abs(x) 

For example:
$ABS(-50) = 50

$ABS(6) = 6


[[Category: Mathematical $functions]]

$Sock URL Encode

2018-09-21T00:00:38Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_URL_Encode}}
Encode into URL "% hex hex" format
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_URL_Encode</var> is the <var>[[URLEncode (Socket function)|URLEncode]]</var> method.

<var>$Sock_URL_Encode</var> encodes special characters into the URL "% hex hex"
format, which has particular use constructing URLs, especially those
containing query strings for HTTP connections.
<var>$Sock_URL_Encode</var> is also useful for encoding form post data for HTTP connections.

==Syntax==
%longStr = $Sock_URL_Encode(string, sockNum) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%longStr</th>
<td>A <var>Longstring</var> to contain the encoding of the input string. </td></tr>
<tr><th>string</th>
<td>The input string to be translated. If this string is omitted, a null string is returned. </td></tr>
<tr><th>sockNum</th>
<td>The socket number, which has associated with it the translation table used for encoding special characters. </td></tr>
</table>

==Usage notes==
<ul>
<li>The translation table associated with the socket number is necessary because special characters are converted
to the hexadecimal representations of their '''ASCII''' values, even though the input and output strings are both in EBCDIC.
So any data that must be encoded as hexadecimal must be translated to ASCII
first, which means that the appropriate ASCII-to-EBCDIC translation table
must be indicated to <var>$Sock_URL_Encode</var> via the socket number.
</ul>

==Example==
<var>$Sock_URL_Encode</var> is useful when composing the query string portion of a URL
(<code>HTTP://host/path?query</code>), or when composing form data for a post request over HTTP:
* Use $Sock_URL_Encode to create % hex hex

%r = $Sock_Send(%x, 'GET /')
%r = $Sock_Send(%x, %URL)
%r = $Sock_Send(%x, '?info=')
%r = $Sock_Send(%x, $Sock_URL_Encode(%info))
%r = $Sock_SendLn(%x, ' HTTP/1.0')

For example, if <code>%info</code> contained:
10 + 3.14 * R*R*R * 2/3

The following value would be sent to the web server after the <code>info=</code>:
10+%2B+3.14+*+R*R*R+*+2%2F3

<code>+</code> is used to stand for a blank, <code>%</code> introduces a hex encoding,
<code>2B</code> is the ASCII code for a plus sign (+), and <code>2F</code> is the ASCII code for a slash (/).

The non-alphanumeric characters that <var>$Sock_URL_Encode</var> does not encode are:
. ( ) ! $ * - _


[[Category: Janus Sockets $functions]]

$Sock Tran Out

2018-09-21T00:00:38Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Tran_Out}}
Translate string to remote's character set
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Tran_Out</var> is the <var>[[TranOut (Socket function)|TranOut]]</var> method.

<var>$Sock_Tran_Out</var> translates a string,
from the local internal character set ("EBCDIC"),
to the character set of the remote.
It is a bit different from other $Sock functions:
<ul>
<li>The socket number is the second argument, not the first.
<li>Although it references a socket number, and it can cause a jump to
the <var>ONRESET</var> label or request cancellation and can set the last error information,
it does not return any error indication.
</ul>

==Syntax==
%string = $Sock_Tran_Out(string, sockNum) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%string</th>
<td>A string that is to contain the translation of the input string into the local character set. </td></tr>
<tr><th>string</th>
<td>The string to be translated. </td></tr>
<tr><th>sockNum</th>
<td>The socket number, which has associated with it the translation table used by <var>$Sock_Tran_Out</var>. </td></tr>
</table>

==Usage notes==
<ul>
<li><var>$Sock_Tran_Out</var> continues with the next statement if
<var>ONRESET CONTINUE</var>, <var>CANCELC</var>, or <var>LABELC</var> is in effect for the socket.
It always returns the translated string, it never returns an
error indicator.
<li>Typically, <var>$Sock_Tran_Out</var> is used to translate into ASCII strings from mainframe sources.
</ul>

==Examples==
<ol>
<li>In the following example, database fields are translated and sent to the remote:
%old = $Sock_Set(%socket, 'BINARY')
For Each record
%xlate = $Sock_Tran_Out(DATA_FIELD, %socket)
%rc = $Sock_SendLn(%socket, %xlate)
End For
%old = $Sock_Set(%socket, 'BINARY', %old)


<li><var>$Sock_Tran_Out</var> can be useful if you wish to use a "normal" character
in either the <var>LINEND</var> or
<var>PRSTOK</var> parameter, since you must specify it in the character set used to
communicate with the remote.
For example, the following sets <var>LINEND</var> to a pair of plus sign (<tt>+</tt>) characters:
Begin
%socket = $Sock_Conn('SOCKEM')
%s = $Sock_Tran_Out('++', %socket)
%t = %SOCK_SET(%socket, 'LINEND', %s)
...


The translate table used is the output table
defined by the XTAB parameter of the socket.
</ol>

[[Category: Janus Sockets $functions]]

$Sock Tran In

2018-09-21T00:00:37Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Tran_In}}
Translate string from remote's character set
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Tran_In</var> is the <var>[[TranIn (Socket function)|TranIn]]</var> method.
[[Category: Janus Sockets $functions]]

<var>$Sock_Tran_In</var> translates a string,
from the character set of the remote, to the local internal character set (EBCDIC).
It is a bit different from other $Sock functions:
<ul>
<li>The socket number is the second argument, not the first.
<li>Although it references a socket number, and it can cause a jump to
the <var>ONRESET</var> label or request cancellation and can set the last error information,
it does not return any error indication.
</ul>

==Syntax==
%string = $Sock_Tran_In(string, sockNum) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%string</th>
<td>A string that is to contain the translation of the input string into the local character set. </td></tr>
<tr><th>string</th>
<td>The string to be translated. </td></tr>
<tr><th>sockNum</th>
<td>The socket number, which has associated with it the translation table used by <var>$Sock_Tran_In</var>. </td></tr>
</table>

==Usage notes==
<ul>
<li><var>$Sock_Tran_In</var> continues with the next statement if
<var>ONRESET CONTINUE</var>, <var>CANCELC</var>, or <var>LABELC</var> is in effect for the socket.
It always returns the translated string; it never returns an error indicator.

<li>Typically the <var>$Sock_Tran_In</var> function is used to translate into EBCDIC
strings that are received from non-mainframe sources that use other
character mapping schemes, like ASCII or non-English character sets.
</ul>
==Example==
In the following example, parsed lines are received into the <code>%s</code> variable,
then translated, and printed in EBCDIC.
The translate table used is the input table
defined by the <var>[[XTAB (JANUS DEFINE parameter)|XTAB]]</var> parameter of the socket.
%old = $Sock_Set(%socket, 'BINARY')
Repeat
%len = $Sock_RecvPrs(%socket, %s)
If %len Le 0 Then
Loop End
End If
%xlate = $Sock_Tran_In(%s, %socket)
Print %xlate
End Repeat
%old = $Sock_Set(%socket, 'BINARY', %old)

$Sock SSL On

2018-09-21T00:00:37Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_SSL_On}}
Switch to SSL processing
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_SSL_On</var> is the <var>[[SSLOn (Socket function)|SSLOn]]</var> method.

<var>$Sock_SSL</var> turns on SSL processing, that is, starts an SSL handshake as a client on a connection.

==Syntax==
[%rc =] = $Sock_SSL_On(sockNum) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%rc</th>
<td>A numeric return code: 0 if successful, otherwise a negative value, as described [[#$Sock_SSL_On return codes|below]]. <tr><th>sockNum</th>
<td>The socket number, or it is -1, which indicates that the change affects all relevant sockets. </td></tr> </table>

===$Sock_SSL_On return codes===
<var>$Sock_SSL_On</var> return codes are:
<table>
<tr><th>  0</th>
<td>Successfully switched to SSL. </td></tr>
<tr><th>-110</th>
<td>Attempted on non-SSL port. <var>$Sock_SSL_On</var> can only be attempted on a port with <var>SSL</var> and <var>SSLOPT</var> on the <var>[[JANUS DEFINE]]</var> command. </td></tr>
<tr><th>-111</th>
<td>SSL handshake error. Likely result of trying to use <var>$Sock_SSL_On</var> against a non-SSL port. </td></tr>
<tr><th>-112</th>
<td>Have pending incoming data. <var>$Sock_SSL_On</var> is invalid until all incoming (presumably) non-SSL data has been received. </td></tr>
<tr><th>-149</th>
<td>Other error during connection. </td></tr>
</table>

==Usage notes==
This function makes it possible to make an initial connection from a <var class="product">Janus Sockets</var> client application to a proxy server, use the CONNECT method to connect to a server through the proxy, and then communicate via SSL with the back end server, simply having the proxy server act as a "tunnel" for the SSL data.
Basically, <var>$Sock_SSL_On</var> should be used after a positive response has been received for a CONNECT method request on a <var class="product">Janus Sockets</var> client socket.

==Example==
The following code illustrates the use of <var>$Sock_SSL_On</var>:
%x = $Sock_Conn('WEBDROPS', 'proxy')
%r = $Sock_Set(%x, 'LINEND', '0D0A')
%r = $Sock_Set(%x, 'PRSTOK', '0D0A')
%r = $Sock_Send(%x, 'CONNECT ')
%r = $Sock_Send(%x, 'sirius-software.com:443')
%r = $Sock_SendLn(%x, ' HTTP/1.0')
%r = $Sock_SendLn(%x, '')
%r = $Sock_RecvPrs(%x, %s)
If $WORD(%s, , 2) Ne '200' Then
Call CONNECT_ERROR
End If
Repeat Forever
%r = $Sock_RecvPrs(%x, %s)
If $lstr_len(%s) Eq 0 Then
Loop End
End If
End Repeat
%r = $Sock_SSL_On(%x)
If %r Then
Call SSL_ERROR
End If
%r = $Sock_Send(%x, 'GET ')
%r = $Sock_Send(%x, %URL)
%r = $Sock_SendLn(%x, ' HTTP/1.0')
%r = $Sock_SendLn(%x, '')
... 

For more information about HTTP tunneling and the CONNECT method, see <code>http://www.ietf.org/rfc/rfc2817.txt</code>. Many other references are also available on the web.

[[Category: Janus Sockets $functions]]

$Sock Set

2018-09-21T00:00:36Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Set}}
Change parameter or setting on one or all sockets
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Set</var> is the <var>[[Set (Socket function)|Set]]</var> method.

<var>$Sock_Set</var> changes the value of a parameter or setting on one or all relevant sockets.

It is also a [[Notation conventions for methods#Callable functions|callable]] function.

==Syntax==
[%old =] = $Sock_Set(sockNum, keyword, [value]) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%old</th>
<td>A string containing either a previous value of parameter or setting, or, if <var class="term">sockNum</var> argument is -1, count of sockets changed. </td></tr>
<tr><th>sockNum</th>
<td>The socket number; or it is -1, which indicates that the change affects all relevant sockets. </td></tr> <tr><th>keyword</th>
<td>Any of the keywords from the parameter and settings list provided [[#Eligible keyword and value settings for $Sock_Set|below]]. Some of these keywords require that the socket be <var>[[Janus Sockets User Language coding considerations#Socket states: OPEN, RESET, FIN indicator|OPEN]]</var> for the setting to take effect; for these, if the socket is not <var>OPEN</var>, the operation is ignored. </td></tr>
<tr><th>value</th>
<td>The value to which the parameter or setting should be changed. If the keyword is self-defining, this argument may be omitted or left null. Valid values are explained in the keyword list provided [[#Eligible keyword and value settings for $Sock_Set|below]]. </td></tr>
</table>

===Eligible keyword and value settings for $Sock_Set===
<table class="syntaxTable">
<tr><th>Keyword</th>
<th>Meaning</th></tr>
<tr><th>BINARY</th>
<td>Do not translate bytes sent and received.

The default is taken from the socket's port definition. For more information about this setting, see [[BINARY (JANUS DEFINE parameter)]]. 

This requires that the socket be <var>[[Janus Sockets User Language coding considerations#Socket states: OPEN, RESET, FIN indicator|OPEN]]</var>. </td></tr>
<tr><th>CHAR</th>
<td>Translate strings sent and received with $Sock_ functions between the internal representation within <var class="product">Model 204</var> (EBCDIC) and the character representation used by the remote end of the connection.

The default is taken from the socket's port definition. For more information about this setting, see [[CHAR (JANUS DEFINE parameter)]].

This requires that the socket be <var>OPEN</var>. </td></tr>
<tr><th>CLOSE</th>
<td>Close socket at end of request; this is the default for <var>[[JANUS DEFINE#type|CLSOCK]]</var> sockets.

This applies to any in-use socket. </td></tr>
<tr><th>NOCLOSE</th>
<td>Close socket at <var>LOGOUT</var>, not at end of request. This is the default for <var>[[JANUS DEFINE#type|SRVSOCK]]</var> sockets.

This applies to any in-use socket. </td></tr>
<tr><th>LINEND</th>
<td>This parameter must have a value specified as <code>NONE</code> or <code><hexchars></code> as the <var class="term">value</var> argument.
<var>NONE</var> indicates that a linend string is not set, and one must be provided before or with the next <var>[[$Sock_SendLn]]</var> call.
Follow each <var>$Sock_SendLn</var> call with the indicated string of bytes; no translation is done on these hex bytes, whether <var>BINARY</var> or <var>CHAR</var> is set. The special value <code>NONE</code> disables any previously defined
<var>LINEND</var> string.

The default is taken from the socket's port definition. For more information about this setting, see [[LINEND (JANUS DEFINE parameter)]].

This requires that the socket be <var>OPEN</var>. </td></tr>
<tr><th>ONRESET</th>
<td>This setting must have one of the following values specified as the <var class="term">value</var> argument:

<ul>
<li><var>CANCEL</var>, to indicate that socket reset conditions are handled by cancelling the <var class="product">User Language</var> request.
<li><var>CANCELC</var>, to indicate that socket reset conditions are handled depending
on whether the given operation can complete.
Those which cannot complete are handled by cancelling the <var
class="product">User Language</var> request.
For those that can complete, the request continues as usual to the next statement,
and an error indicator is returned by the $function encountering the condition.
The last error indication can also be retrieved using the <var>[[$Sock_ErrInfo]]</var> function.
<li><var>CONTINUE</var>, to indicate that when a socket reset condition is found, the request continues as usual to the next statement, and an error indicator is returned by the $function encountering the condition. The last error indication can also be retrieved using the <var>$Sock_ErrInfo</var> function.
<li><var>LABEL</var>, to indicate that all socket reset conditions are handled by the label established by the most recent <var>[[$Sock_OnReset]]</var> call, or that the request is cancelled if there is no <var>ONRESET</var> label.
<li><var>LABELC</var>, to indicate that socket reset conditions are handled depending on whether the given operation can complete.
Those which cannot complete are handled by the label established by the most recent <var>$Sock_OnReset</var> call, or that the
request is cancelled if there is no <var>ONRESET</var> label. For those that can complete, the request continues as usual to the next statement, and an error indicator is returned by the $function encountering the condition.
The last error indication can also be retrieved using the <var>[[$Sock_ErrInfo]]</var> function.
</ul>

The default is <var>LABEL</var>. See [[Janus Sockets User Language coding considerations#Handling connection errors and RESET sockets|"Handling connection errors and RESET sockets"]].

This applies to any in-use socket. </td></tr>
<tr><th>PRSTOK</th>
<td>This parameter must have a value specified as either <code>NONE</code> or <code>[AMBIG|]<hexchars>[|<hexchars>]...</code> as the <var class="term">value</var> argument. <var>NONE</var> indicates that a separator string is not set, and one must be provided before or with the next <var>[[$Sock_RecvPrs]]</var> call.
The specified set of hexadecimal strings are used as "break" strings for returning subsequent strings with the <var>$Sock_RecvPrs</var> function. If and only if one string is a prefix of another, <code>AMBIG|</code> must be used at the start.

The default is taken from the socket's port definition. For more information about this setting, see [[PRSTOK (JANUS DEFINE parameter)]].

This requires that the socket be <var>OPEN</var>. </td></tr>
<tr><th>RECVLIM</th>
<td>A number ranging from 0 to 2,147,483,647, specifying the limit on total bytes of data plus "parse tokens" scanned by subsequent receive operations. The default is 0, indicating no limit.

<var>RECVLIM</var> is discussed in [[$Sock_Recv#Lengths: maximum, minimum, truncation, RECVLIM|"Lengths: maximum,
minimum, truncation, RECVLIM"]] and [[$Sock_RecvPrs#Lengths: maximum, minimum, truncation, RECVLIM|"Lengths: maximum, truncation, RECVLIM"]].
This requires that the socket be <var>OPEN</var>. </td></tr>
<tr><th>TIMEOUT</th>
<td>Number indicating the port <var>[[TIMEOUT (JANUS DEFINE parameter)|TIMEOUT]]</var> time, in seconds.

The default is taken from the socket's port definition.

This requires that the socket be <var>OPEN</var>. </td></tr>
<tr><th>XTAB</th>
<td>The EBCDIC-to-ASCII, ASCII-to-EBCDIC, and character-entity translation tables to be used for the socket.

The default is taken from the socket's port definition For more information about this setting, see [[XTAB (JANUS DEFINE parameter)]].

This requires that the socket be <var>OPEN</var>. </td></tr>
</table>

==Usage notes==
<ul>
<li>If the <var class="term">sockNum</var> argument is -1, indicating that all relevant sockets are affected by the <var>$Sock_Set</var> call, the return string will be the number of sockets affected by the change.
If <var class="term">sockNum</var> is the number of an in-use socket, the returned string contains the previous value of the parameter or setting or the string <code>RESET</code> if the socket must be <var>OPEN</var> and it is not.
If <var>$Sock_Set</var> is invoked with a single socket (that is, not -1) as the <var class="term">sockNum</var> argument, and that socket is <code>RESET</code>, the results depend on several factors:

<ul>
<li>If the <var class="term">keyword</var> argument is <code>ONRESET</code>, the operation is performed normally, and there is no indication of the fact that the socket is <code>RESET</code>.
<li>Otherwise, if the <var class="term">keyword</var> argument is a keyword that does not require an <var>OPEN</var> socket, and <var>ONRESET CONTINUE</var>, <var>CANCELC</var>, or <var>LABELC</var> is in effect for the socket, the string <code>RESET</code> is returned and the last error information is set.
<li>Otherwise, if <var>ONRESET CONTINUE</var> is in effect for the socket, the string <code>RESET</code> is returned and the last error information is set. <li>Otherwise the request is canceled or the <var>ONRESET</var> label is jumped to, as explained in [[Janus Sockets User Language coding considerations#Handling connection errors and RESET sockets|"Handling connection errors and RESET sockets"]].
</ul>

<li>The <var class="term">value</var> argument can be omitted for keywords that are self-defining:
%t = $Sock_Set(%sockno, 'BINARY') 
This sets the socket to binary mode, in which bytes sent over the connection are not translated in any way. "Self-defining" keywords can also be given a <var class="term">value</var> argument, which allows you to restore a previous value:
Foo: Subroutine
%t = $Sock_Set(%sockno, 'BINARY')
...
%t = $Sock_Set(%sockno, 'BINARY', %t)
Return 
The <var class="term">value</var> argument is required for keywords that need a value:
%t = $Sock_Set(%sockno, 'LINEND', 'NONE') 
This disables the sending of the line-end string.

<li>You can use <var>[[$Sock_Info]]</var> to obtain the current value of the setting of any of the keywords that can be specified as the <var class="term">keyword</var> argument of <var>$Sock_Set</var>.
</ul>

[[Category: Janus Sockets $functions]]

$Sock SendLn

2018-09-21T00:00:36Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_SendLn}}
Send string followed by LINEND
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_SendLn</var> is the <var>[[SendWithLineEnd (Socket function)|SendWithLineEnd]]</var> method.

<var>$Sock_SendLn</var> sends an argument string and the untranslated <var>LINEND</var> string
over a <var class="product">Janus Sockets</var> connection.

It is also a [[Notation conventions for methods#Callable functions|callable]] function.

==Syntax==
[%rc =] = $Sock_SendLn(sockNum, string, [opts]) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%rc</th>
<td>A numeric error code (described further [[#$Sock_Send return codes|below]]), or if the operation could not be performed as requested, a 0 value. For more details, see [[#$Sock_RecvPrs return values|"$Sock_RecvPrs return values"]]. </td></tr><tr><th>sockNum</th>
<td>The socket number. </td></tr>
<tr><th>string</th>
<td>The string to send. <var class="product">Model 204</var> limits this to a length of 255 bytes. </td></tr>
<tr><th>opts</th>
<td>This optional argument is an option string, which can contain any of the following:
<table class="syntaxTable">

<tr><th><var>BINARY</var> </th>
<td>Indicates that regardless of the socket's <var>[[BINARY (JANUS DEFINE parameter)|BINARY]]</var> or <var>[[CHAR (JANUS DEFINE parameter)|CHAR]]</var> parameter, data '''is not translated''' when sent. The argument can be the result of a previous translation using <var>[[$Sock_Tran_Out]]</var>.</td></tr>

<tr><th><var>CHAR</var> </th>
<td>Indicates that regardless of the socket's <var>BINARY</var> or <var>CHAR</var> parameter, data '''is translated''' when sent. The translation is specified by the output table defined by the socket's <var>[[XTAB (JANUS DEFINE parameter)|XTAB]]</var> parameter. </td></tr>

<tr><th><var>FIN</var> </th>
<td>Indicates that after the <var class="term">string</var> argument and the <var>LINEND</var> string are sent, no more data will be sent on the socket. This transmits the <code>FIN</code> indication to the remote partner. See [[Janus Sockets User Language coding considerations#Socket states: OPEN, RESET, FIN indicator|"Socket states: OPEN, RESET, FIN indicator"]] for a discussion of the <var>FIN</var> indicator.
 Note that when <code>FIN</code> is sent, print capturing is automatically turned <var>OFF</var> for the socket. </td></tr>

<tr><th><var>PUSH</var> </th>
<td>Ensures that the data being sent on the socket is immediately sent to the receiver. Normally, data to be sent is buffered and may not be sent immediately.
 Using <var>PUSH</var> is '''not''' necessary if: 
<ul>
<li>You are specifying <var>FIN</var>, since a push operation is implied by <var>FIN</var>.
<li>You are alternating sends and receives on a socket, since receive-processing functions (<var>$Sock_Recv</var> and <var>$Sock_RecvPrs</var>) always do a push before receiving.
</ul></td></tr>
<tr><th nowrap><var>LINEND</var> hexstr</th>
<td>The string whose hexadecimal representation is <var class="term">hexstr</var> is used rather than the current <var>[[LINEND (JANUS DEFINE parameter)|LINEND]]</var> parameter of the socket. </td></tr>
</table>
</td></tr></table>

==Usage notes==
<ul>
<li>Whether it is set on the port definition, via <var>[[$Sock_Set]]</var>, or as an argument on the <var>$Sock_SendLn</var> function, <var>LINEND</var> must not be <var>NONE</var> when using <var>$Sock_SendLn</var>.
<li>These are the <var>$Sock_SendLn</var> return codes:
<ul>
<li>0, if the function completes successfully.
<li>-1, if the socket is not open and <var>ONRESET CONTINUE</var> is in effect for the socket.
</ul> </ul>

==Example==
The following example uses a combination of <var>$Sock_Send</var> and <var>$Sock_SendLn</var>.
%domain = 'www.sirius-software.com'
%page = 'main.html'
%socket = $Sock_Conn('TEST', %domain)
%s = $Sock_Set(%socket, 'LINEND', '0D0A')
%rc = $Sock_Send(%socket, 'GET /')
%rc = $Sock_Send(%socket, %page)
%rc = $Sock_SendLn(%socket, ' HTTP/1.0')
%rc = $Sock_SendLn(%socket, '')

In this example, <var>$Sock_Set</var> is used to specify a line-end string of hexadecimal '0D0A'. Then, a few lines are sent for which the protocol does not require line-end delimiters: the <code>GET /</code> and the name of the HTML page defined in <code>%page</code>. Then the HTTP specification is sent with a line-delimiter via the <var>$Sock_SendLn</var> function.

This example highlights the fact that the programmer needs to know the requirements of the communication protocol they are using before they know the appropriate function to use in sending strings to the socket.

[[Category: Janus Sockets $functions]]

$Sock Send

2018-09-21T00:00:35Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Send}}
Send string
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Send</var> is the <var>[[Send (Socket function)|Send]]</var> method.

<var>$Sock_Send</var> sends a string over a <var class="product">Janus Sockets</var> connection.

It is also a [[Notation conventions for methods#Callable functions|callable]] function.

==Syntax==
[%rc =] $Sock_Send(sockNum, string, [opts]) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%rc</th>
<td>A numeric value that is a numeric error code (described further [[#$Sock_Send return codes|below]]), or if the operation could not be performed as requested, a 0 value. For more details, see [[#$Sock_RecvPrs return values|"$Sock_RecvPrs return values"]]. </td></tr>
<tr><th>sockNum</th>
<td>The socket number. </td></tr>
<tr><th>string</th>
<td>The string to send. </td></tr>
<tr><th>opts</th>
<td>This optional argument is an option string, which can contain any of the following:

<table class="syntaxTable">
<tr><th><var>BINARY</var> </th>
<td>Indicates that regardless of the socket's <var>[[BINARY (JANUS DEFINE parameter)|BINARY]]</var> or <var>[[CHAR (JANUS DEFINE parameter)|CHAR]]</var> parameter, data '''is not translated''' when sent. The argument can be the result of a previous translation using <var>[[$Sock_Tran_Out]]</var>. </td></tr>

<tr><th><var>CHAR</var> </th>
<td>Indicates that regardless of the socket's <var>BINARY</var> or <var>CHAR</var> parameter, data '''is translated''' when sent. The translation is specified by the output table defined in the socket's <var>[[XTAB (JANUS DEFINE parameter)|XTAB]]</var> parameter. </td></tr>

<tr><th><var>FIN</var> </th>
<td>Indicates that after the <var class="term">string</var> argument is sent, no more data will be sent on the socket. This transmits the <code>FIN</code> indication to the remote partner.
Note that when <code>FIN</code> is sent, print capturing is automatically turned <var>OFF</var> for the socket. </td></tr>

<tr><th><var>PUSH</var> </th>
<td>Ensures that the data being sent on the socket is immediately sent to the receiver. Normally, data to be sent is buffered and may not be sent immediately.
 Using <var>PUSH</var> is '''not''' necessary if: 
<ul>
<li>You are specifying <var>FIN</var>, since a push operation is implied by <var>FIN</var>.
<li>You are alternating sends and receives on a socket, since receive-processing functions (<var>$Sock_Recv</var> and <var>$Sock_RecvPrs</var>) always do a push before receiving.
</ul></td></tr>
</table>
</td></tr></table>

===$Sock_Send return codes===
<ul>
<li>0, if the function completes successfully.
<li>-1, if the socket is not open and ONRESET CONTINUE is in effect for the socket.
</ul>

If you need to send line-end delimited information, use <var>[[$Sock_SendLn]]</var>.

[[Category: Janus Sockets $functions]]

$Sock RecvPrs

2018-09-21T00:00:35Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_RecvPrs}}
Receive parsed string
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_RecvPrs</var> is the <var>[[ReceiveAndParse (Socket function)|ReceiveAndParse]]</var> method.

<var>$Sock_RecvPrs</var> receives, over a <var class="product">Janus Sockets</var> connection, a string whose length
is not known beforehand but which is terminated by a known string or by
one of a known set of strings.

<var>$Sock_RecvPrs</var> is also [[Notation conventions for methods#Callable functions|callable]].

==Syntax==
[%num =] = $Sock_RecvPrs(sockNum, %recv_targ, [maxrecvp], [prsindx], [opts])

===Syntax terms===
<table class="syntaxTable">
<tr><th>%num</th>
<td>A numeric value that is the number of bytes received, or, if the operation could not be performed as requested, a 0 value. For more details, see [[#$Sock_RecvPrs return values|$Sock_RecvPrs return values]]. </td></tr>

<tr><th>sockNum</th>
<td>The socket number. </td></tr>

<tr><th>%recv_targ</th>
<td>A %variable or an <var>IMAGE</var> item (and '''never''' a <var class="product">SOUL</var> class variable). This argument is the target of the receive operation, and is referred to as the "receive target." You may request that some bytes from the socket stream can be discarded, so the length of the string stored in this target may be less than the value returned by <var>$Sock_RecvPrs</var>. </td></tr>

<tr><th>maxrecvp</th>
<td>This optional argument, the maximum number of bytes of data to receive, '''less''' the '''length of the separator''' string, must be from 0 to 2,147,483,647, or must be the special value -1, which indicates there is no limit to the number of bytes received.

The default is 0, which means limit the received data (less separator) to to the declared length of the receive target.
If this argument is 0 and the receive argument is a <var>Longstring</var>, the received data is limited to 2,147,483,647 bytes. </td></tr>

<tr><th>prsindx</th>
<td>This optional argument is is a %variable or <var>IMAGE</var> item in which the index number (> 0) of the parse token found is stored. This variable is set to 0 if no token is found '''within''' <var>RECVLIM</var> bytes or if it is not found '''after''' more than the number of data bytes specified by the effective value of the <var class="term">maxrecvp</var> argument. </td></tr>

<tr><th>opts</th>
<td>This optional argument is an option string which can contain any of the following:

<table class="thJustBold">

<tr><th>BINARY </th>
<td>This indicates that regardless of the socket's <var>[[BINARY (JANUS DEFINE parameter)|BINARY]]</var> or <var>[[CHAR (JANUS DEFINE parameter)|CHAR]]</var> parameter, data '''is not translated''' when saved in the receive target. The received string can be translated later in the program using the <var>[[$Sock_Tran_In]]</var> function. </td></tr>

<tr><th>CHAR </th>
<td>This indicates that regardless of the socket's <var>[[BINARY (JANUS DEFINE parameter)|BINARY]]</var> or <var>[[CHAR (JANUS DEFINE parameter)|CHAR]]</var> parameter, data '''is translated''' when saved in the receive target. The translation is specified by the input table defined by the socket's <var>[[XTAB (JANUS DEFINE parameter)|XTAB]]</var> parameter. </td></tr>

<tr><th nowrap>PRSTOK [AMBIG<tt>|</tt>]hexstr[<tt>|</tt>hexstr]... </th>
<td>This is a set of parse tokens which override the parse tokens set on the socket.
Whether it is set on the port definition, via <var>[[$Sock_Set]]</var>, or as an argument on the <var>$Sock_RecvPrs</var> function, <var>PRSTOK</var> must not be <code>NONE</code> when using <var>$Sock_RecvPrs</var>. </td></tr></table>

</td></tr> </table>

===$Sock_RecvPrs return values===
<ul>
<li><var>$Sock_RecvPrs</var> returns the value -1 if the socket is not open and <code>ONRESET CONTINUE</code> is in effect for the socket.
<li><var>$Sock_RecvPrs</var> returns a number greater than 0 which is the number of bytes received from of the socket stream. [[#Lengths: maximum, truncation, RECVLIM|Lengths: maximum, truncation, RECVLIM]] explains how the term '''number of bytes received''' is used, and discusses the <var class="term">maxrecvp</var> argument and other values affecting the received string.
<li><var>$Sock_RecvPrs</var> returns zero to indicate there is no data remaining to be received on the connection, that is, if <code>FIN</code> has been received or the <var>RECVLIM</var> has been reached.
</ul>

==Usage notes==
<ul>
<li>You use <var>$Sock_RecvPrs</var> for a data item whose length is unknown beforehand, but rather is terminated by a known string (or one of a known set of strings). In general, you use the alternate receive operation, <var>[[$Sock_Recv]]</var>, when the protocol in use establishes the length of a data item before it appears in the socket stream.
<li>The <var class="term">prsindx</var> argument is used in case there is more than one alternative in the <var>PRSTOK</var> setting, and you need to distinguish which one of them terminated the received value. For example, with the input stream of <code>X'36370D38390D'</code>, the following expression will store the value 2 in the variable <code>%prs</code>.
$Sock_RecvPrs(%sk, %str, , %prs, 'PRSTOK AMBIG|0D0A|0D|0A') 

Note that this example uses ambiguous <var>PRSTOK</var> strings (<code>0D</code> is a prefix of <code>0D0A</code>). Considerations for this are discussed in [[Sample Janus Sockets programs#Ambiguous PRSTOK strings|Ambiguous PRSTOK strings]].

The <var>PRSTOK</var> separators are chosen to match the protocol and data streams that are used with your application. One of the considerations, of course, is that a separator should not occur in the "normal" data received by your application. If that is unavoidable, you will need to use an "escaping" mechanism; for example, you could use the ASCII <code>ESC</code> character (hexadecimal <code>1B</code>) to indicate that it precedes a character that is to be taken literally. 

For example, if the data contains non-separator instances of <code>CR</code> and <code>ESC</code>: 
%junk String Len 1
%r = $Sock_Set(%sok, 'PRSTOK', '0D|1B')
Repeat
%r = $Sock_RecvPrs(%sok, %targ, %sep)
If %sep Eq 2 Then
%r = $Sock_Recv(%sok, %junk)
%targ = %targ With %junk
End If
... 
</ul>

==Examples==
The following example shows part of a program that communicates with a remote web server and which parses and prints the
returned HTML stream. Note that the third argument to <var>$Sock_RecvPrs</var> is -1, which means that there is no limit to the length of each line parsed, hence no limit to the number of bytes discarded at the end of the line; only the first 78 bytes (the size of <code>%s</code>) of each line of HTML is examined by the <var class="product">SOUL</var> program.

A complete version of this program is shown in [[Sample Janus Sockets programs#Simple echo of HTTP/HTML|Simple echo of
HTTP/HTML]]. See [[Sample Janus Sockets programs#Simple echo of HTTP/HTML|Simple echo of HTTP/HTML]] for another complete
program, which does not discard any received data.

%s = $Sock_Set(%socket, 'PRSTOK', '0D0A|0A|0D')
Repeat
%rc = $Sock_RecvPrs(%socket, %s, -1)
Print %s
If %rc LE 0 Then
Loop End
End If
End Repeat
%rc = $Sock_Close(%socket) 

==Lengths: maximum, truncation, RECVLIM==
The <var>$Sock_RecvPrs</var> function allows you to locate a separator string, and to store all or part of the string before
the separator into the receive target. It is important to understand that when we say "the string that is received in a call to <var>$Sock_RecvPrs</var>", it may be more than the string that <var>$Sock_RecvPrs</var> stores in the receive target. This is for the following two reasons:
<ol>
<li>The separator string is part of the string received, but it is not stored in the receive target.
<li>The string before the separator may exceed the size of the target, and thus can be partially discarded (or "truncated").
</ol>
References to the string received by $Sock_RecvPrs are to the string stored in the target plus any subsequent bytes that are
discarded, plus the separator string.
Several of the values that control the length of the string received are discussed in this section, using the following terms:
<table>
<tr><th><var>RECVLIM</var> </th>
<td>This specifies the number of bytes remaining in the "receive window." A value of zero means there is no limit to the window. The purpose of this window is to allow you to limit a series of receive operations (using, if you want, a mixture of <var>$Sock_Recv</var> and <var>$Sock_RecvPrs</var>) to a predetermined total number of bytes. <var>RECVLIM</var> can be set in a <var>$Sock_Set</var> call, and subsequent receive operations decrement from <var>RECVLIM</var> the number of bytes received, until it reaches zero (at which point a<var>$Sock_Recv</var> call will return a 0, just as if a <code>FIN</code> had been received.
When <var>RECVLIM</var> is greater than zero, no receive operation will use any bytes beyond the window.
A good example of the use of <var>RECVLIM</var> is obtaining a web page, whose length is (usually) specified in the "Content-length" field of the HTTP response header. </td></tr>

<tr><th>len_to_end</th>
<td>When a receive operation is performed, the received string is of course limited to the total remaining bytes in the stream that the remote end sent before issuing a close operation. Although this value is not known ahead of time, when describing the operation of receive, this term is used to indicate various cases. </td></tr>

<tr><th>max_recvp</th>
<td>This corresponds to the <var class="term">maxrecvp</var> argument of the <var>$Sock_RecvPrs</var> function call. It needs to be specified only if you want to allow truncation, or if you want to limit the received string to a length less than the declared size of the target.

You can specify that an unlimited number of bytes can be discarded by specifying -1 as the <var class="term">maxrecvp</var> argument of <var>$Sock_RecvPrs</var>, making the effective value "infinite." The number of bytes received by <var>$Sock_RecvPrs</var> will not exceed the effective value of this argument plus the length of the separator string. The effective value of <var class="term">max_recvp</var> if the <var class="term">maxrecvp</var> argument of <var>$Sock_RecvPrs</var> is 0 (its default), is discussed below. 

<tr><th>targ_size </th>
<td>The size of the target is used in calculating various defaults of the other values here, and it also obviously limits the
number of bytes stored in the target and so affects the number of bytes discarded. </td></tr>

<tr><th>discard_len </th>
<td>This is the number of bytes received minus the length of the separator string, minus <var class="term">targ_size</var>. It will always be zero, unless <var class="term">max_recvp</var> is greater than <var class="term">targ_size</var>. </td></tr>
</table>

Argument <var class="term">max_recvp</var> defaults to 0; if they are omitted, or if it is coded as 0, its effective value is shown here:
<table>
<tr class="head"><th>Item</th>
<th>Value when argument is 0</th></tr>

<tr><td><var class="term">maxrecvp</var> argument of <var>$Sock_RecvPrs</var></td>
<td><var class="term">targ_size</var> </td></tr>
</table>

'''Truncation''' can only occur if <var class="term">max_recvp</var> > <var class="term">targ_size</var>, which cannot happen if the target is a <var>Longstring</var>.

If a separator string is not found due to a limit imposed by <var>RECVLIM</var>,
<var class="term">len_to_end</var>, or <var class="term">max_recvp</var>, then zero is stored in the parse index target (the <var class="term">%prsindx</var> argument).

[[Category: Janus Sockets $functions]]

$Sock Recv

2018-09-21T00:00:34Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Recv}}
Receive string based on count
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Recv</var> is the <var>[[Receive (Socket function)|Receive]]</var> method.

<var>$Sock_Recv</var> receives a string of bytes on a <var class="product">Janus Sockets</var> connection, typically
to obtain a fixed-length string, and also to allow receipt of additional "already-buffered" bytes.

<var>$Sock_Recv</var> is also a [[Notation conventions for methods#Callable functions|callable]] function.

==Syntax==
[%num =] $Sock_Recv(sockNum, %recv_targ, [opts]) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%num</th>
<td>A numeric value that is the number of bytes received, or, if the operation could not be performed as requested, a 0 value. For more details, see [[#$Sock_Recv return values]]. </td></tr>
<tr><th>sockNum</th>
<td>The socket number. </td></tr>

<tr><th>%recv_targ</th>
<td>A %variable or an <var>IMAGE</var> item (and '''never''' a <var class="product">SOUL</var> class variable). This argument is the target of the receive operation, and is referred to as the "receive target." You may request that some bytes from the socket stream can be discarded, so the length of the string stored in this target may be less than the value returned by <var>$Sock_Recv</var>. </td></tr>

<tr><th>maxbytes</th>
<td>This optional argument, the maximum number of bytes of data to receive, must be from 0 to 2,147,483,647. The default is 0, which means limit the received data to the larger of the value of the <var class="term">minbytes</var> argument and the declared length of the receive target.

If this argument is 0 and the receive argument is a <var>Longstring</var>, the received data is limited to 2,147,483,647 bytes. </td></tr>

<tr><th>minbytes</th>
<td>This optional argument is the minimum number of bytes of data to receive before the operation completes, unless the input stream ends (a close operation by the remote) or <code>RECVLIM</code> is encountered. The argument only needs to be specified for a variable length receive, which is fairly unusual.

The default is 0, which means use the effective value of the <var class="term">maxbytes</var> argument. Valid values must be from 0 to 2,147,483,647, and must not exceed the effective value of <var class="term">maxbytes</var>. </td></tr>

<tr><th>opts</th>
<td>This optional argument is an option string which can contain any of the following:
<table>

<tr><th><var>BINARY</var> </th>
<td>This indicates that regardless of the socket's <var>[[BINARY (JANUS DEFINE parameter)|BINARY]]</var> or <var>[[CHAR (JANUS DEFINE parameter)|CHAR]]</var> parameter, data '''is not translated''' when saved in the receive target. The received string can be translated later in the program using the <var>[[$Sock_Tran_In]]</var> function. </td></tr>

<tr><th><var>CHAR</var> </th>
<td>This indicates that regardless of the socket's <var>[[BINARY (JANUS DEFINE parameter)|BINARY]]</var> or <var>[[CHAR (JANUS DEFINE parameter)|CHAR]]</var> parameter, data '''is translated''' when saved in the receive target. The translation is specified by the input table defined by the socket's <var>[[XTAB (JANUS DEFINE parameter)|XTAB]]</var> parameter. </td></tr></table>
</td></tr>
</table>

===$Sock_Recv return values===
<ul>
<li><var>$Sock_Recv</var> returns the value -1 if the socket is not <var>OPEN</var>
and <var>ONRESET CONTINUE</var> is in effect for the socket.
<li><var>$Sock_Recv</var> returns a number greater than 0
(which is the number of bytes received from the socket stream)
if at least <var class="term">minbytes</var> are stored in the target.
[[#Lengths: maximum, minimum, truncation, RECVLIM|Lengths: maximum, minimum, truncation, RECVLIM]] explains how the term
'''number of bytes received''' is used, and it discusses the <var class="term">maxbytes</var>
and <var class="term">minbytes</var> arguments and other values affecting the received string.

The return value from <var>$Sock_Recv</var>
can be less than the value of <var class="term">minbytes</var>.
<li>Formerly, <var>$Sock_Recv</var> would return 0 to indicate that the length of the received
string is less than <var class="term">minbytes</var>. [[#Less than minbytes available|Less than minbytes available]] explains the 0 return code.
One case of this is if there is no data remaining to be received on
the connection, that is, if <code>FIN</code> has been received.

<var>$Sock_Recv</var> now returns 0 to indicate
that there is no more data to be received.
Calling <var>$Sock_Recv</var> (or <var>[[$Sock_RecvPrs]]</var>) again in this situation, without
at the very least setting <var>RECVLIM</var> to a new value, will result in request cancellation.
</ul>

==Usage notes==
In general, you use <var>$Sock_Recv</var> when the protocol in use establishes the
length of a data item before it appears in the socket stream.
The simplest case is receiving the next n bytes, where n
is the size of the target, as shown in the following example to receive 5 strings of 100 bytes each.
You use the alternate receive operation,
<var>$Sock_RecvPrs</var>, for a data item whose length is unknown beforehand,
but rather is terminated by a known string (or one of a known set of strings).

%GRABIT IS STRING LEN 100 ARRAY(5)
For %x From 1 To 5
%len = $Sock_Recv(%socket, %grabit(%x))
If %len Ne 100 Then
Print 'Invalid number of bytes received.'
Print 'Last string received=' %grabit(%x)
Print 'Partial length=' With $Len(%grabit(%x))
End If
End For


==Lengths: maximum, minimum, truncation, RECVLIM==
The <var>$Sock_Recv</var> function allows you to receive either a fixed length
string of bytes, or to receive some minimum length
and also any additional bytes that may already be available in the
socket's TCP/IP input buffer; this latter capability is called a "variable length receive."

It is important to understand that a string referred to as
"the string that is received in a call to <var>$Sock_Recv</var>"
may be more than the string that <var>$Sock_Recv</var> stores in the receive target.
Therefore, data in the input stream that exceeds the size
of the target can be discarded (or "truncated").
The "string received by <var>$Sock_Recv</var>," is a reference to the
string stored in the target plus any subsequent bytes that are discarded.
If the target is a <var>Longstring</var>, no bytes
would ever be discarded, since the maximum size of a <var>Longstring</var> is the
same as the greatest number of bytes <var>$Sock_Recv</var> will ever receive.

The several values that control the length of the string received
are discussed in this section, using the following terms:
<table>
<tr><th><var>RECVLIM</var> </th>
<td>This specifies the number of bytes remaining in the "receive window." A value of zero means there is no limit to the window. The purpose of this window is to allow you to limit a series of receive operations (using, if you want, a mixture of <var>$Sock_Recv</var> and <var>$Sock_RecvPrs</var>) to a predetermined total number of bytes.
<var>RECVLIM</var> can be set in a <var>$Sock_Set</var> call, and subsequent receive operations decrement from <var>RECVLIM</var> the number of bytes received, until it reaches zero (at which point a<var>$Sock_Recv</var> call will return a 0, just as i
When <var>RECVLIM</var> has been set, no receive operation will use any bytes beyond the window.
A good example of the use of <var>RECVLIM</var> is obtaining a web page, whose length is (usually) specified in the "Content-length" field of the HTTP response header.
</td></tr>

<tr><th>len_to_end </th>
<td>When a receive operation is performed, the received string is of course limited to the total remaining bytes in the stream that the remote end sent before issuing a close operation. Although this value is not known ahead of time, when describing the operation of receive, the <var class="term">len_to_end</var> term is used to indicate various cases.
</td></tr>

<tr><th>max_recv </th>
<td>This corresponds to the <var class="term">maxbytes</var> argument of the <var>$Sock_Recv</var> function call. It needs to be specified only if you want to allow truncation, or if you want to limit the received string to a length shorter than the size of the receive target. The number of bytes received by <var>$Sock_Recv</var> will not exceed the effective value of this argument. The effective value of <var class="term">max_recv</var> if argument 3 is 0 (its default), is discussed [[#maxmin|below]].</td></tr>

<tr><th>min_recv </th>
<td>This corresponds to the <var class="term">minbytes</var> argument of the <var>$Sock_Recv</var> function call. You only need to provide this argument for a variable length receive. The receive initiated by <var>$Sock_Recv</var> will only complete if <var class="term">min_recv</var> bytes are received, or if the limit to the stream (<var>RECVLIM</var> or <var class="term">len_to_end</var>) is reached. The effective value of <var class="term">min_recv</var>, if <var class="term">minbytes</var> is 0 (its default), is discussed [[#maxmin|below]]. </td></tr>

<tr><th>targ_size </th>
<td>The size of the target is used in calculating various defaults of the other values here, and it also obviously limits the number of bytes stored in the target and so affects the number of bytes discarded. </td></tr>

<tr><th>discard_len </th>
<td>This is the number of bytes received minus <var class="term">targ_size</var>. It will always be zero, unless <var class="term">max_recv</var> is greater than <var class="term">targ_size</var>. </td></tr>
</table>

<div id="maxmin"></div>
Arguments <var class="term">max_recv</var> and <var class="term">min_recv</var> both default to 0; if they are omitted, or if
they are coded as 0, their effective values are shown here:

<table>
<tr class="head"><th>Item</th>
<th>Value when argument is 0</th></tr>

<tr><th>max_recv</th>
<td>larger of <var class="term">min_recv</var> and <var class="term">targ_size</var></td></tr>

<tr><th>min_recv</th>
<td>the effective value of <var class="term">max_recv</var></td></tr>
</table>

'''Truncation''' can only occur if <var class="term">max_recv</var> > <var class="term">targ_size</var>, which
cannot happen if the target is a <var>Longstring</var>.

A '''variable length''' receive, which is a fairly unusual operation,
is only possible if <var class="term">min_recv</var> differs from <var class="term">max_recv</var>; therefore, you will
generally not code the <var class="term">minbytes</var> argument of <var>$Sock_Recv</var>.

===Less than minbytes available===
Formerly, if <var>$Sock_Recv</var> was called and the number of bytes
remaining on the connection within the remaining <var>RECVLIM</var> was
less than the effective value of the <var class="term">minbytes</var> argument,
<var>$Sock_Recv</var> returned 0 to indicate this, but the receive target
was set to any partial string remaining, or to the null string if there
were none remaining (that is, <code>FIN</code> has been received).

The 0 return code indicated unsuccessful completion because the
function wasn't able to do all it was asked to do (that is, return a
fixed number of bytes or a specified minimum number of bytes).
Depending on your application, this may be an error or the partial
string may be valid data.
If no bytes were discarded, you could determine the number of
bytes received by the length of the string stored in the receive target.

It is now the case that if <var>$Sock_Recv</var> is called and the number of
bytes remaining on the connection within the remaining <var>RECVLIM</var> is
less than the effective value of the <var class="term">minbytes</var> argument,
<var>$Sock_Recv</var> returns the number of bytes read.

In such a case, if the application determines that the number of bytes
returned is less than <var class="term">minbytes</var>,
it knows that either <var>RECVLIM</var>
must have been hit or a <code>FIN</code> must have been received.
Alternatively, the application can forego checking for this case and
simply wait until <var>$Sock_Recv</var> returns a zero.

This allows a simple receive loop structure like:
Do While $Sock_Recv(%sock, %str)
...
End Do

However, with the use of <var>Longstring</var>s, an application can simply receive
everything up to <var>RECVLIM</var> or the end of a stream with a simple call like:
%rc = $Sock_Recv(%sock, %longstr)


[[Category: Janus Sockets $functions]]

$Sock OnReset

2018-09-21T00:00:34Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_OnReset}}
Set label to handle RESET conditions
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_OnReset</var> is the <var>[[OnReset (Socket function)|OnReset]]</var> method.

<var>$Sock_OnReset</var> specifies a label in the <var class="product">User Language</var> sockets program to
jump to when a <var>RESET</var> socket is encountered in the current or lower scope.

<var>$Sock_OnReset</var> is also [[Notation conventions for methods#Callable functions|callable]].

==Syntax==
[%rc =] = $Sock_OnReset(label) 
[[Category: Janus Sockets $functions]]

===Syntax terms===
<table class="syntaxTable">
<tr><th>%rc</th>
<td>A numeric value that indicates whether the program jump is successful. 0 means success.</td></tr>
<tr><th>label</th>
<td>A string that identifies the label that is to handle <var>RESET</var> conditions. </td></tr>
</table>

==Usage notes==
<ul>
<li><var>$Sock_OnReset</var> does not have a socket number argument, thus it is not affected by any <var>ONRESET</var> setting.
<li>If <var class="term">label</var> is the null string or all blanks, any existing <var>ONRESET</var> label in the current scope is cleared, and <var>$Sock_OnReset</var> returns:
<ul>
<li>-3, if $SOCK_ONRESET is issued from an ON unit
<li>-1, otherwise
</ul>
Otherwise, if the argument is a valid label and the function call is successful, it replaces any existing <var>ONRESET</var> label definition in the current scope and returns a 0.

<li>If the function call fails to clear or set the <var>ONRESET</var> label, the request is cancelled. The function can fail for the following reasons:
<ul>
<li>The label is not found in the current scope.
<li>The label is a subroutine.
<li><var>$Sock_OnReset</var> is invoked from an <var>ON</var> unit, and the argument is neither the null string nor all blank. <li>Label is in a loop, <var>ON</var> unit, or simple subroutine.
</ul>

<li>A request may have multiple <var>ONRESET</var> labels set, up to one for each scope (the outer level of a request is a scope, as is each complex subroutine). A jump to an <var>ONRESET</var> label is attempted when a <var>RESET</var> socket is encountered during a <var class="product">Janus Sockets</var> operation and the socket's <var>ONRESET</var> setting is <code>LABEL</code>. If the operation requires an <var>OPEN</var> socket, a socket can have the <var>LABELC</var> setting. See [[Janus Sockets User Language coding considerations#Handling connection errors and RESET sockets|"Handling connection errors and RESET sockets"]] for an explanation of the <var>ONRESET</var> setting.

When the jump is attempted, it is successful if there is an <var>ONRESET</var> label within the current or an invoking scope of the <var class="product">User Language</var> request that encountered the <var>RESET</var> socket. If there is no such label, the <var class="product">User Language</var> request is cancelled. 

<li>Using this function to set an <var>ONRESET</var> handler reduces the amount of return code checking the application has to do on each $Sock_xxx function call.
</ul>

==Example==
As a result of the <var>$Sock_OnReset</var> code in the following example, encountering a <var>RESET</var> socket will print a set of error messages that provide the failing operation, return code, and socket identifier before terminating evaluation:
%x = $Sock_OnReset('KABOOM')
...

KABOOM:
%c = $Sock_ErrInfo('CODE')
%s = $Sock_ErrInfo('SOCKNUM')
%f = $Sock_ErrInfo('FUN')
Print 'The connection was unexpectedly lost.'
Print 'The last sockets error operation was:'
Print 'Function: ' With %f
Print 'Return code: ' With %c
Print 'Socket: ' With %s
STOP


[[Category: Janus Sockets $functions]]

$Sock Num

2018-09-21T00:00:33Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Num}}
Get selected socket numbers
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Num</var> is the <var>[[Num (Socket function)|Num]]</var> method.

<var>$Sock_Num</var> retrieves selected socket numbers.

==Syntax==
%nums = $Sock_Num[([selection])] 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%nums</th>
<td>A string that contains blank-separated selected socket numbers in ascending order. </td></tr>
<tr><th>selection</th>
<td>A string that identifies which socket numbers to return. It is any combination of the following strings separated by '''OR''', and each optionally prefixed by '''NOT''':
<table class="syntaxTable">
<tr><th><var>ANY</var> </th>
<td>Return all sockets. This is the default. </td></tr>
<tr><th><var>CONN</var> </th>
<td>Return sockets enabled for sending in both directions. </td></tr>
<tr><th><var>FINR</var> </th>
<td>Return sockets on which local partner is enabled for sending but remote has stopped sending ("FIN received"). </td></tr> <tr><th><var>FINS</var> </th>
<td>Return sockets on which remote partner is enabled for sending but local stopped sending ("FIN sent"). </td></tr>
<tr><th><var>FINBOTH</var> </th>
<td>Return <code>OPEN</code> sockets on which remote and local partners both stopped sending ("FIN sent and received"). </td></tr>
<tr><th><var>RESET</var> </th>
<td>Return in-use but no longer connected sockets. </td></tr>
<tr><th><var>OPEN</var> </th>
<td>Return <code>OPEN</code> sockets. This is equivalent to either of the following:
<ul>
<li>NOT RESET
<li>CONN OR FINR OR FINS OR FINBOTH
</ul> </td></tr>
<tr><th><var>CAPTURE</var> </th>
<td>Return sockets (<code>OPEN</code> or not) for which print capturing is on. </td></tr>
<tr><th><var>CAPOPEN</var> </th>
<td>Return <code>OPEN</code> sockets for which print capturing is on. </td></tr>
</table>
If <var>NOT</var> prefixes one of the above specifications, then all in-use sockets (excluding the specified set) are included in the selected set. With multiple terms separated by <var>OR</var>, the specified sets are combined by the set union operation.
</table>

==Usage notes==
<var>$Sock_Num</var> does not have a socket number argument, and thus it is not affected by any <var>ONRESET</var> setting.

==Examples==
<ol>
<li>In the following example, <code>%sock</code> contains the blank-delimited values of <code>%c1</code> and <code>%c2</code>. Assuming no other client socket numbers were in use, this would result in <code>%sock = '2 3'</code>.
JANUS DEFINE PIPE * CLSOCK 5 REMOTE * * SOCKPMAX 2
Begin
%c1 is Float
%c2 is Float
%sock is String Len 255
%c1 = $Sock_conn('PIPE', 'www.ampas.org', 80)
%c2 = $Sock_conn('PIPE', 'www.wga.org', 80)
%sock = $Sock_Num ... 
<li>The following example shows another way to retrieve the list of all <code>OPEN</code> socket numbers:
%sock = $Sock_Num('NOT RESET') 
<li>The following example shows how to retrieve the list of all <code>OPEN</code> socket numbers that have not received the <var>FIN</var> indicator:
%sock = $Sock_Num('CONN OR FINS') 
</ol>

[[Category: Janus Sockets $functions]]

$Sock Info

2018-09-21T00:00:33Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Info}}
Get info about a socket
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Info</var> is the <var>[[Info (Socket function)|Info]]</var> method.

<var>$Sock_info</var> retrieves socket information.

==Syntax==
%info = $Sock_Info(socket, infoType) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%info</th>
<td>A string that contains the requested information. </td></tr>
<tr><th>socket</th>
<td>A string that is the socket identifier.
<tr><th>infoType</th>
<td>One of the following string indicators of the information to be retrieved about the socket:

<table class="syntaxTable">
<tr><th>Value</th>
<th>Description</th></tr>
<tr><th><var>CAPTURE</var></th>
<td>Retrieve current print capture setting of socket (see <var>[[$Sock_Capture]]</var>). The socket need not be <code>OPEN</code>. </td></tr>
<tr><th><var>REMOTE</var></th>
<td>Retrieve dotted IP address of remote host, followed by blank and remote port number. The socket must be <code>OPEN</code>; if it is not, the string "RESET" is returned. </td></tr>
<tr><th><var>STAT</var></th>
<td>Retrieve socket state. The socket need not be <code>OPEN</code>. The returned value will be one of the following:
<dl>
<dt>CONN <dd>Socket <code>OPEN</code> and enabled for sending in both directions
<dt>FINR <dd>Socket <code>OPEN</code>, remote stopped sending, local enabled for sending ("FIN received but not sent")
<dt>FINS <dd>Socket <code>OPEN</code>, local stopped sending, remote enabled for sending ("FIN sent but not received") <dt>FINBOTH <dd>Socket <code>OPEN</code>, local and remote stopped sending ("FIN sent and received")
<dt>RESET <dd>Socket is <code>RESET</code> (no longer connected)
</dl>
 
Note: Since the status of <code>OPEN</code> sockets may include several more status types in future releases, test for <code>OPEN</code> sockets by testing for the string "RESET":
If $sock_info(%sk, 'STATUS') Ne 'RESET' ... </td></tr>
<tr><th>opt</th>
<td>Any of the strings that may be passed as the second argument to <var>$Sock_Set</var> (for example, <var>CHAR</var> or <var>PRSTOK</var>). For some of these, the socket must be <code>OPEN</code>; if not, the string "RESET" is returned. To view the arguments that require an <code>OPEN</code> socket, see <var>[[$Sock_Set]]</var>. </td></tr>
</table>
The <var>$Sock_Info</var> function returns either the requested value or, as noted above, the string "RESET".
If <var>$Sock_Info</var> is invoked with a socket that is <code>RESET</code>, the results depend on several factors:
<ul>
<li>If argument two is <var>ONRESET</var>, the operation is performed normally, and there is no indication of the fact that the socket is RESET.
<li>Otherwise, if argument two is a keyword which does not require an <code>OPEN</code> socket, and <var>ONRESET CONTINUE</var>, <var>CANCELC</var>, or <var>LABELC</var> is in effect for the socket, the string <code>RESET</code> is returned and the last error information is set.
<li>Otherwise, if <var>ONRESET CONTINUE</var> is in effect for the socket, the string <code>RESET</code> is returned and the last error information is set.
<li>Otherwise the request is canceled or the <code>ONRESET</code> label is jumped to, as explained in [[Janus Sockets User Language coding considerations#Handling connection errors and RESET sockets|"Handling connection errors and RESET sockets"]]. </ul>

[[Category: Janus Sockets $functions]]

$Sock ErrInfo

2018-09-21T00:00:32Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_ErrInfo}}
Get info about last Janus Sockets error
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_ErrInfo</var> is the <var>[[ErrInfo (Socket function)|ErrInfo]]</var> method.

<var>$Sock_ErrInfo</var> retrieves information about the last <var class="product">Janus Sockets</var> error.

==Syntax==
%info = $Sock_ErrInfo(infoType) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%info</th>
<td>A string that contains the requested information. </td></tr>
<tr><th>infoType</th>
<td>One of the following strings:
<table class="syntaxTable">
<tr><th>Value</th>
<th>Description</th></tr>
<tr><th><var>CODE</var></th>
<td>Retrieve the code from the last <var class="product">Janus Sockets</var> error. </td></tr>
<tr><th><var>SOCKNUM</var></th>
<td>Retrieve the socket number used by the last <var class="product">Janus Sockets</var> operation with an error condition. </td></tr>
<tr><th><var>FUN</var></th>
<td>Retrieve the name of the $function producing the last <var class="product">Janus Sockets</var> error. This may also be the string "Captured print," if a captured "print" operation was the last operation that encountered a <var class="product">Janus Sockets</var> error. </td></tr></table>
</td></tr>
</table>

==Usage notes==
<ul>
<li>If the return string is null, there was no <var class="product">Janus Sockets</var>
error since the thread logged in (note, as described in [[Janus Sockets User Language coding considerations#Handling connection errors and RESET sockets|"Handling connection errors and RESET sockets"]],
that $Sock_Conn does not set the last error information, and a few other $Sock_xxx functions do not set it, either).
<li><var>$Sock_ErrInfo</var> does not have a socket number argument, and thus it is not affected by any <code>ONRESET</code> setting.
</ul>

[[Category: Janus Sockets $functions]]

$Sock Conn

2018-09-21T00:00:32Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Conn}}
Connect to remote using CLSOCK port
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Conn</var> is the <var>Socket</var> class <var>[[New (Socket constructor)|New]]</var> method.
[[Category: Janus Sockets $functions]]

<var>$Sock_Conn</var> creates a connection to a remote host using a Janus
client socket port.

==Syntax==
%num = $Sock_Conn(socketPortName, remoteHost, remotePort, [options]) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%num</th>
<td>An integer socket identifier or an error code. </td></tr>
<tr><th>socketPortName</th>
<td>The client socket port name. The <var class="term">socketPortName</var> default is the <var>[[MASTER (JANUS DEFINE parameter)|MASTER]]</var> port, if any is defined. However, if you omit <var class="term">socketPortName</var> and no <var>MASTER</var> port is defined, the request is canceled. </td></tr>
<tr><th>remoteHost</th>
<td>The remote host name or IP address. This argument is optional or may be the null string if the remote host or remote IP address is fully specified on the port definition <var>[[REMOTE (JANUS DEFINE parameter)|REMOTE]]</var> clause.
If <var class="term">remoteHost</var> is specified and is not the null string, it must match the remote host specified explicitly or indicated by a pattern on the port definition. If an asterisk (*) was specified for the remote host on the port definition, <var class="term">remoteHost</var> must be specified. The remote host may also be restricted by <var>[[JANUS_CLSOCK#JANUS_CLSOCK_ALLOW|JANUS CLSOCK ALLOW]]</var> rules. </td></tr>
<tr><th>remotePort</th>
<td>The port number on the remote host to which the socket will connect. If a port number was specified on the <var>REMOTE</var> clause of the port definition, this argument can be either the matching number or -1, or it can be omitted. If an asterisk (*) was specified for the remote port on the port definition, <var class="term">remotePort</var> must be specified. The port number may also be restricted by <var>[[JANUS_CLSOCK#JANUS_CLSOCK_ALLOW|JANUS CLSOCK ALLOW]]</var> rules. </td></tr>
<tr><th>options</th>
<td>An option string that can be used to invoke socket-specific processing that is not already explicitly specified on the <var>[[JANUS DEFINE]]</var> command for the port. The argument string may contain one or two options, selected from the two pairs of alternatives below. If the argument string is omitted, the option defaults depend on the <var>[[JANUS DEFINE#type|CLSOCK]]</var> port definition. If the argument string contains an option that conflicts with the port definition, the request is canceled.
<table class="syntaxTable">
<tr><th><var>SSL</var> </th>
<td>Use SSL (Secure Sockets Layer) encryption over the connection (see <var>[[SSL (JANUS DEFINE parameter)|SSL]]</var>, and see the [http://www.sirius-software.com/maint/download/jansslr.pdf Janus Network Security Reference Manual]). Setting <code>SSL</code> here is meaningful only if the port definition includes the <var>SSL</var> and <var>[[SSLOPT (JANUS DEFINE parameter)|SSLOPT]]</var> parameters (in which case, by default, SSL is '''not''' used unless the socket connection explicitly requests it).

Setting <code>SSL</code> here is redundant if the port definition includes <var>SSL</var> but not <var>SSLOPT</var>, and setting it is invalid if the port definition excludes <var>SSL</var>. </td></tr>
<tr><th><var>NOSSL</var></th>
<td>Do not use SSL over the connection. This setting is valid only if the port definition includes the <var>SSLOPT</var> parameter. </td></tr>
<tr><th><var>FINCLOSE</var></th>
<td>If the remote host closes the connection, even if it does so "cleanly" (that is, with <code>FIN</code> rather than <code>RESET</code>), <var class="product">Janus Sockets</var> closes the connection immediately. This setting avoids wasted processing or even a hung connection in a situation(like a keep-alive facility) where a remote application uses a <code>FIN</code> to close a connection with a request. </td></tr>
<tr><th><var>NOFINCLOSE</var>
</th><td>Do not use <var>FINCLOSE</var> processing for this connection. </td></tr>
</table>
</table>

===$Sock_Conn return values===
The number returned from <var>$Sock_Conn</var> is a positive value which is used as the
identifier of the successfully connected socket, or otherwise it is an error code as shown below:

<table>
<tr class="head"><th>Code</th>
<th>Meaning</th></tr>

<tr><td>0</td>
<td>Communications was successful.</td></tr>

<tr><td>100</td>
<td>The format of the response from the server was invalid.</td></tr>

<tr><td>101</td>
<td>A <var>Get</var> operation exceeded its [[Timeout (HttpRequest property)|timeout]] value.</td></tr>

<tr><td>102</td>
<td>The connection was closed before the complete response was received.</td></tr>

<tr><td>-100</td>
<td>No free socket numbers for user.</td></tr>

<tr><td>-101</td>
<td>Remote host name or IP address missing or mismatch with <var>CLSOCK</var> port definition.</td></tr>

<tr><td>-102</td>
<td>Remote port number missing or mismatch with <var>CLSOCK</var> port definition.</td></tr>

<tr><td>-103</td>
<td><var>CLSOCK</var> port not defined or not started.</td></tr>

<tr><td>-104</td>
<td>All ports on specified <var>CLSOCK</var> port are busy.</td></tr>

<tr><td>-105</td>
<td>Insufficient virtual storage.</td></tr>

<tr><td>-106</td>
<td>Maximum connections exceeded.</td></tr>

<tr><td>-107</td>
<td>Couldn't resolve remote host.</td></tr>

<tr><td>-108</td>
<td>Remote port not responding.</td></tr>

<tr><td>-109</td>
<td>Already have <var>[[SOCKPMAX]]</var> sockets open on this <var>CLSOCK</var> port.</td></tr>

<tr><td>-110</td>
<td>SSL/NOSSL setting mismatch.</td></tr>

<tr><td>-111</td>
<td>SSL handshake error.</td></tr>

<tr><td>-112</td>
<td>Access to <var>CLSOCK</var> port not enabled by <var>[[JANUS WEB ALLOW|ALLOW]]</var> rule.</td></tr>

<tr><td>-149</td>
<td>Other error during connection attempt which prevents establishment of the connection.</td></tr>
</table>

==Usage notes==
<ul>
<li>$Sock_xxx functions that encounter an "unusable" socket can ordinarily be handled by a jump to an <var>ONRESET</var> label, by request cancellation, or by continuation of the request at the next statement with an error return code. <var>$Sock_Conn</var>, however, always continues execution with the next statement. It does not have a socket number argument, and it cannot encounter a reset socket. You must check the error return code: if it is negative and you try to use it in a subsequent $Sock_xxx call, the request will be cancelled at that time.
</li>

<li>When <var>$Sock_Conn</var> detects an error, it also issues an error message to the user. If you want to suppress this, and the <var>APSY</var> facility for suppressing error messages is not appropriate for your application, you can use the <var>[[$Resetn]]</var> function to set the <var>MSGCTL</var> user parameter to 4. </li>

<li><var>$Sock_Conn</var> initiates a connection to a remote port over a client socket port. If the remote host and port were specified on the client socket port definition, they don't have to be specified in the function call.

In the following example, because the port definition specifies that all client requests on port <code>SOCKEM</code> will go to port 80 at host IP address <code>198.242.244.47</code>, specifying the destination on the function call is superfluous. <code>%num</code> contains either a positive number identifying the socket number or a negative number identifying the type of error received during the attempt to establish a new socket connection. A negative number indicates an error condition, and processing is routed to an error-handling subroutine. 
JANUS DEFINE SOCKEM * CLSOCK 5 REMOTE 198.242.244.47 80
Begin
...
%num = $Sock_Conn('SOCKEM')
If %num Lt 0 Then
Call PROCESS_SOCKET_ERROR
End If ... 

In the example below, the port is defined to accept client requests to any remote port. The <var>$Sock_Conn</var> function specifies a connection to the default web port (80) at a well-known satirical news provider. 
* Define the client sockets port.
JANUS DEFINE SOCKEM * CLSOCK 5 REMOTE * *
Begin
...
%num = $Sock_Conn('SOCKEM', 'www.theonion.com', 80)
If %num Lt 0 Then
Call PROCESS_SOCKET_ERROR
End If ... </li>

<li>The <code>FINCLOSE</code> option is useful in situations where <code>FIN</code> is as good as <code>RESET</code> for rendering a connection unusable, and where it's important to know that <code>FIN</code> has been sent to avoid wasted processing or even a hung connection.

For example, an appropriate occasion for <code>FINCLOSE</code> is a <var class="product">Janus Sockets</var> application communicating with a web server that is using a keep-alive facility (multiple requests over the same TCP/IP connection). Such a web server could close the connection between any pair of requests, and probably would use <code>FIN</code>. Without <code>FINCLOSE</code>, the Janus thread that connected to the web server would remain in-use until the <var class="product">Janus Sockets</var> application tried to receive data on the connection and so noticed the closed connection. </li>
</ul>

$Sock Close

2018-09-21T00:00:31Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Close}}
Close Janus Sockets connection(s)
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Close</var> is the <var>[[Close (Socket function)|Close]]</var> method.

<var>$Sock_Close</var> terminates the sending and receiving of data on, and removes from use,
one or all <var class="product">Janus Sockets</var> connection(s).

==Syntax==
[%num =]$Sock_Close[([sockNum])] 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%num</th>
<td>The number of of connections closed.</td></tr>
<tr><th>sockNum</th>
<td>The number of a socket that is to be closed, or the value -1, which indicates that all the user's sockets should be closed. The default value of this optional argument is -1. </td></tr>
</table>

==Usage notes==
<ul>
<li>If <var class="term">socket</var> is -1, indicating that all sockets are affected by the <var>$Sock_Close</var> call, then the returned number <var class="term">%num</var> will be the number of sockets in use. Otherwise <code>1</code> is returned.
<li><var>$Sock_Close</var> is not affected by any <var>ONRESET</var> setting.
</ul>

==Examples==
<ol>
<li>In the following example, the <var>$Sock_Close</var> call signals that the program has completed all processing on the socket identified by the value in <code>%sock</code>:
%count = $Sock_Close(%sock) 
<li>The following call closes all socket connections the user has:
%count = $Sock_Close(-1) 
</ol>

[[Category: Janus Sockets $functions]]

$Sock Capture

2018-09-21T00:00:30Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sock_Capture}}
Change print capture setting
Note: Many $functions have been deprecated in favor of Object Oriented
methods. The OO equivalent for <var>$Sock_Capture</var> is the <var>[[Capture (Socket function)|Capture]]</var> method.

<var>$Sock_Capture</var> specifies whether print output should be sent as lines on a <var class="product">Janus Sockets</var> connection.

==Syntax==
[%num =] $Sock_Capture(sockNum, value) 

===Syntax terms===
<table class="syntaxTable">
<tr><th>%num</th>
<td>The content of this return string depends on the <var class="term">sockNum</var> argument, as described below in [[#$Sock_Capture return values|$Sock_Capture return values]]. </td></tr>

<tr><th>sockNum</th>
<td>The socket number, or it is '-1' to indicate that the setting affects all sockets.</td></tr>

<tr><th>value</th>
<td>A string that is the print capture setting for the socket. Valid values are:
<dl>
<dt>OFF<dd>Don't capture print to this socket.
<dt>ON<dd>Capture print to this socket as well as any other capturing sockets.
</dl></td></tr>
</table>

===$Sock_Capture return values===
<ul>
<li>If the <var class="term">sockNum</var> argument is -1, indicating that all sockets are affected by the <var>$Sock_Capture</var> call, the return string is the number of sockets (not counting the open sockets that have sent the <code>FIN</code> operation). </li>

<li>If <var class="term">sockNum</var> is not -1, the returned string contains the value of the socket's previous <var>$Sock_Capture</var> setting. </li>

<li>If a single socket is specified as the <var class="term">sockNum</var> value, the socket is not open,
and <var>ONRESET CONTINUE</var> is in effect for the socket, then <var>$Sock_Capture</var> returns the string <code>RESET</code>.
</ul>

==Usage notes==
<ul>
<li>Each captured print line is followed by a <var>LINEND</var> string,
if the socket has one set in its definition or by <var>[[$Sock_Set]]</var>.

<li>The set of socket numbers that currently capture print lines can be obtained as <code>$Sock_Num('CAPTURE')</code>.
The set of open socket numbers that currently capture print lines can be obtained as <code>$Sock_Num('CAPOPEN')</code>.

<li>When a <code>FIN</code> is sent (using either <var>[[$Sock_Send]]</var> or <var>[[$Sock_SendLn]]</var>), print capturing is automatically turned <var>OFF</var> for the socket.
</ul>

==Example==
In the following example, the <var>$Sock_Capture</var> call specifies that print operations should be sent to the [[JANUS SRVSOCK|SRVSOCK]] socket.
Subsequent print operations, such as the <var class="product">User Language</var> <var>Print</var> statement, will send lines to the socket rather than to the normal terminal output:
%t = $Sock_Capture(1, 'ON')


There is a more complete example in [[Sample Janus Sockets programs#Print capturing example|Print capturing example]]; also
see [[#Print capturing hierarchy and other considerations|Print capturing hierarchy and other considerations]].

==Print capturing hierarchy and other considerations==
The <var class="product">User Language</var> <var>Print</var> and <var>[[Text and Html statements|Html]]</var> statements, the <var>DISPLAY PROCEDURE</var> command, and the <var>DISPLAY LIST</var> command are a few of many "print"
operations that can produce output lines for an application.
These operations "normally" send their output to the "terminal output" for the thread running the application.
'''Terminal output''' refers to the print destination defined by the <var>IODEV</var> for the thread.

For example, the terminal output of an IODEV=7 (VTAM) terminal user is the user's 3270-style terminal; the
terminal output of an IODEV=29 (IFDIAL, or BATCH2) user is the MVS batch program that retrieves the output lines.

The terminal output of an <var>[[Sdaemons|Sdaemon]]</var> thread (usually IODEV=15) depends on how the <var>Sdaemon</var> was started:
<table class="thJustBold">
<tr><th>COMMxx</th>
<td>If the thread was started by a Sirius $COMMxx function, the output can be saved in a [[$lists|$list]] that can be processed by the $COMMxx caller. </td></tr>

<tr><th nowrap>Janus SDS, OPENSERV, or SRVSOCK</th>
<td>For an [[JANUS DEFINE#type|SDS, OPENSERV, or SRVSOCK]] thread, the audit trail is used as the terminal output. For these port types, messages during compilation are always sent to the audit trail. For other types of print output, the <var class="product">Model 204</var> <var>AUDTERM</var> or <var>NOAUDTERM</var> parameter controls whether the terminal output is sent to the audit trail (<var>AUDTERM</var>) or simply discarded (<var>NOAUDTERM</var>). </td></tr>

<tr><th>Janus Web</th>
<td>For a <var>[[JANUS DEFINE#type|WEB]]</var> thread, the terminal output can either be the browser (if <var>[[$Web_On]]</var> is in effect) or the audit trail (if <var>[[$Web_Off]]</var> is in effect), although <var>NOAUDTERM</var> prevents non-compiler print lines from appearing on the audit trail, as with other Janus server threads. </td></tr>
</table>

As stated, $COMMxx can be used to process print output, since the <var>Sdaemon</var> doing its work can place print output in a Sirius $list.
There are also facilities for processing print output on any kind of
thread, including other <var>Sdaemon</var> threads, and 3270 and <var>IFDIAL</var>/<var>BATCH204</var> threads:
<ol>
<li>The <var>[[$List_Capture]]</var> function directs print output to a $list.
<li>The <var>$Sock_Capture</var> function directs print output to a <var class="product">Janus Sockets</var> connection.
<li>The <var class="product">Model 204</var> <var>USE</var> command directs print output to a <var>USE</var> stream.
</ol>

For the above three facilities, "interactive" output is not sent to the $list, the socket,
nor the <var>USE</var> stream, but instead is sent to the normal terminal output.
The types of interactive output lines are:
<table class="thJustBold">
<tr class="head"><th>Type</th><th>Description</th></tr>

<tr><th>Messages</th>
<td>Informational or error messages (for example, M204.nnnn or MSIR.nnnn) except when <code>$List_Capture(id, 'MSGS')</code> in effect. </td></tr>

<tr><th>Prompts</th>
<td>Password prompts, <var>$Read</var> input, etc. </td></tr>

<tr><th>READ SCREEN</th>
<td><var class="product">SOUL</var> full-screen display for input (note that <var>Print Screen</var> statements '''are subject''' to redirection) </td></tr>

<tr><th nowrap>WRITE IMAGE ON TERMINAL</th>
<td><var class="product">SOUL</var> statement for sending lines directly to the normal terminal output </td></tr>
</table>

When an output line is redirected from the normal terminal output, it is directed based on the following hierarchy:
<table class="thJustBold">
<tr class="head"><th>Type</th><th>Conditions</th></tr>

<tr><th>$List_Capture</th>
<td>Non-interactive print lines captured on $list, if one is active as specified to <var>$List_Capture</var> </td></tr>

<tr><th>$Sock_Capture</th>
<td>Non-interactive print lines captured on one or more sockets, if any are specified as <code>ON</code> to <var>$Sock_Capture</var>, and if no $list is active as specified to <var>$List_Capture</var> (<code>$List_Capture(-1)</code> removes any active $list capture) </td></tr>

<tr><th>USE stream</th>
<td>Non-interactive print lines directed to a <var>USE</var> stream, if it is active and there is no socket specified as <code>ON</code> to <var>$Sock_Capture</var> (<code>$Sock_Capture(-1, 'OFF')</code> removes all socket capturing)
and if no $list is active as specified to <var>$List_Capture</var> </td></tr>

<tr><th nowrap>Normal terminal output</th>
<td>Print lines are sent to the normal terminal output if none of the above print redirections are active </td></tr>
</table>

Below are some additional suggestions and considerations for the use of applications using print redirection in general and socket capturing in particular:
<ul>
<li>For output lines (non <var>SCREEN</var> output/input)
that should go to the terminal, use <var>WRITE IMAGE ON TERMINAL</var> (on server applications, where the "terminal" output is the audit trail, you can use <var>AUDIT</var> instead). </li>

<li>The <var>OUTCCC</var>, <var>OUTMRL</var>, and <var>LOBUFF</var> limits are ignored for <var>$Sock_Capture</var>.
A very long print line is captured as a single "logical" line (with a single trailing <var>LINEND</var> string, as specified on the <var>[[JANUS DEFINE]]</var> command or <var>[[$Sock_Set]]</var> for the socket). </li>

<li>Output lines sent by the "ellipsis" form of the <var>Print</var> statement
(<code>PRINT <items> ...</code>) are captured without a trailing <var>LINEND</var> string.
The <var>LINEND</var> string is sent at the end of the logical line (that is, <var>OUTMRL</var>, <var>OUTCCC</var>, and <var>LOBUFF</var> do not cause added <var>LINEND</var> strings to be sent). The <var>LINEND</var> string is not translated. </li>

<li>If the socket's <var>LINEND</var> parameter is <code>NONE</code> when a print line is captured, the line is simply sent without any string following it. </li>

<li>If the socket is set to <var>CHAR</var>, the print line is translated using the output translation table specified
by the socket's <var>XTAB</var> parameter.
If the socket is set to <var>BINARY</var>, the print line is not translated. </li>

<li>If you want a request to continue normal evaluation if a <code>RESET</code> condition is encountered on a socket,
use <code>$Sock_Set(socknum, 'ONRESET', 'CONTINUE')</code>.
When print capturing is attempted to an <var>ONRESET CONTINUE</var> socket, and the socket is
<code>RESET</code>, <var class="product">Janus Sockets</var> simply acts as if the print was captured and continues. </li>

<li>If <var>CONTINUE</var> is not in effect for a <var>CAPTURE ON SOCKET</var> that is <code>RESET</code>,
a <var class="product">User Language</var> print operation will jump
to the <code>ONRESET</code> label if one is active, or else the
request is cancelled (and any <var>APSY</var> <var>ERROR</var> procedure is evaluated).
In this case, <var>[[$Sock_ErrInfo]]</var> returns -1 for <code>CODE</code>, and it returns the string
<code>Captured print</code> for <code>FUN</code>. </li>
</ul>

[[Category: Janus Sockets $functions]]

$SubRep

2018-09-20T23:29:43Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$SubRep}}
Replace occurrences of string

Note: Many $functions have been deprecated in favor of Object Oriented methods. The recommended OO replacement function for $SubRep is <var>[[Replace (String function)|Replace]]</var>. (See the [[#Usage notes|Usage notes]] below.) 

This function replaces occurrences of a substring in one string with another.

The <var>$SubRep</var> function accepts five arguments and returns a string result that is part of the first argument string.

==Syntax==
%string = $SubRep(string, substring, repstring, [start_pos], [count])


===Syntax terms===
<table>
<tr><th>%string</th>
<td>The part of the first argument string that remains after the replacements of substring by repstring.</td></tr>

<tr><th>string</th>
<td>An arbitrary string. </td></tr>

<tr><th>substring</th>
<td>An arbitrary string located in the <var class="term">string</var> argument value. </td></tr>

<tr><th>repstring</th>
<td>A replacement string. </td></tr>

<tr><th>start_pos</th>
<td>A starting position in the <var class="term">string</var> argument string. This optional argument defaults to 1. </td></tr>

<tr><th>count</th>
<td>A repeat count indicating the number of occurrences to be replaced. This optional argument defaults to 1. </td></tr>
</table>

==Usage notes==
<ul>
<li>As stated above, the recommended OO replacement function for <var>$SubRep</var> is <var>[[Replace (String function)|Replace]]</var>. However, unlike <var>$SubRep</var>, <var>Replace</var> is Longstring capable (like all OO methods), so:
<ul>
<li>Both <var>$SubRep</var> and <var>Replace</var> have an optional argument for the count of substrings to replace, but their defaults differ: for <var>$SubRep</var> it is 1; <var>Replace</var> replaces all instances of the substring. </li>

<li>It is possible that an application using <var>$SubRep</var> is unintentionally using "silent truncation," which will become noticable if you replace it with <var>Replace</var>; see the discussion in [[Longstrings]]. </li>

<li>'''Do not''' replace <var>Replace</var> with <var>$SubRep</var>. </li>
</ul> </li>

<li>If the substitution would cause the result value to exceed 255 characters, it is not performed. </li>
</ul>

==Examples==
<ol>
<li>This statement sets %JUNK to <code>XYCDABAB</code>:

%JUNK = $SubRep('ABCDABAB', 'AB', 'XY')


<li>This statement sets %JUNK to <code>XYCDXYXY</code>:
%JUNK = $SubRep('ABCDABAB', 'AB', 'XY', ,5)


<li>This statement sets %JUNK to <code>ABCDXYXY</code>.
%JUNK = $SubRep('ABCDABAB', 'AB', 'XY', 3 ,5)

</ol>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$SubRep]]

$SubIns

2018-09-20T23:29:43Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$SubIns}}
Insert string inside another string

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $SubIns function is <var>[[Insert (String function)|Insert]]</var>.

This function inserts a string inside another.

The <var>$SubIns</var> function accepts three arguments and returns a string result.

==Syntax==
%string = $SubIns(string, ins_string, insert_pos)


===Syntax terms===
<table>
<tr><th>%string</th>
<td>The string result that is a combination of <var class="term">string</var> and <var class="term">ins_string</var>.</td></tr>

<tr><th>string</th>
<td>An arbitrary string. </td></tr>

<tr><th>ins_string</th>
<td>A string to be inserted in the <var class="term">string</var> value. </td></tr>

<tr><th>insert_pos</th>
<td>The insertion position in the <var class="term">string</var> argument string.</td></tr>
</table>

==Usage notes==
<ul>
<li>If no insertion position is provided, the insertion string is appended to the end of the first input string. If the insertion point is past the first input string, the first input string is left unmodified.
</ul>

==Examples==
<ol>
<li>This statement sets %JUNK to <code>PAT STAMPER, TRADER HORSE</code>:

%JUNK = $SubIns('PAT STAMPER, TRADER', ' HORSE')
</li>

<li>This statement sets %JUNK to <code>PAT STAMPER, HORSE TRADER</code>:

%JUNK = $SubIns('PAT STAMPER, TRADER', ' HORSE', 12)
</li>

<li>This statement sets %JUNK to <code>PAT STAMPER, TRADER</code>:

%JUNK = $SubIns('PAT STAMPER, TRADER', ' HORSE', 92)
</li>
</ol>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$SubIns]]

$SubErs

2018-09-20T23:29:42Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$SubErs}}
Remove occurrence of one string from another

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $SubErs function is the <var>[[Remove (String function)|Remove]]</var> function.

This function removes an occurrence of one string from another.

The <var>$SubErs</var> function accepts four arguments and returns a string result that is part of the first argument string.

==Syntax==
%string = $SubErs(string, substring, start_pos, [count])


===Syntax terms===
<table>
<tr><th>%string</th>
<td>The part of the <var class="term">string</var> argument that remains after <var class="term">substring</var> is removed from it.</td></tr>

<tr><th>string</th>
<td>An arbitrary string.</td></tr>

<tr><th>substring</th>
<td>Another arbitrary string. </td></tr>

<tr><th>start_pos</th>
<td>A starting position within <var class="term">string</var>. </td></tr>

<tr><th>count</th>
<td>A repeat count indicating the number of occurrences of <var class="term">substring</var> to be removed. This is an optional argument, and it defaults to 1.</td></tr>
</table>

==Examples==
<ol>
<li>This statement sets %JUNK to <tt>CDABAB</tt>:

%JUNK = $SubErs('ABCDABAB', 'AB')


<li>This statement sets %JUNK to <tt>WE WAITED LONG ENOUGH</tt>:

%JUNK = $SubErs('WE HAVE WAITED LONG ENOUGH', 'HAVE ')


<li>This statement sets %JUNK to <tt>WE HAVE AITED LONG ENOUGH</tt>:

%JUNK = $SubErs('WE HAVE WAITED LONG ENOUGH', 'W', 5)


<li>This statement sets %JUNK to <tt>E HAVE AITED LONG ENOUGH</tt>:

%JUNK = $SubErs('WE HAVE WAITED LONG ENOUGH', 'W', 1, 5)

</ol>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$SubErs]]

$SubCnt

2018-09-20T23:29:41Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$SubCnt}}
Count occurrences of one string in another

Note: Many $functions have been deprecated in favor of Object Oriented methods. There is currently no OO equivalent for the $SubCnt function.

This function counts the occurrences of one string in another.

==Syntax==
%count = $SubCnt(string, substring)


===Syntax terms===
<table class="syntaxTable">
<tr><th>%count</th>
<td>The count of occurrences of <var class="term">substring</var> in <var class="term">string</var>.</td></tr>

<tr><th>string</th>
<td>An arbitrary string. </td></tr>

<tr><th>substring</th>
<td>Another arbitrary string.</td></tr>
</table>

==Examples==
The following statement would set %JUNK to 3:
%JUNK = $SubCnt('ABCDABAB', 'AB')


This statement would set %JUNK to 0:
%JUNK = $SubCnt('WE HAVE WAITED LONG ENOUGH', 'WEHAVE')


And this statement would set %JUNK to 4:
%JUNK = $SubCnt('WE HAVE WAITED LONG ENOUGH', 'E')


==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$SubCnt]]

$StrXor

2018-09-20T23:28:51Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$StrXor}}
Bit-wise exclusive OR two strings

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $StrXor function is <var>[[BitXorString (String function)|BitXorString]]</var>.

This function performs a bit-wise exclusive OR of two strings.

The <var>$StrXor</var> function accepts three arguments and returns a string result that is the bit-wise exclusive OR of the first two arguments, the shorter being padded with as many copies of the third argument as are required to make the string lengths equal.

==Syntax==
%STR = $StrXor(string1, string2, [pad])


===Syntax terms===
<table>
<tr><th>%str</th>
<td>The bit-wise AND of <var class="term">string1</var> and <var class="term">string2</var>.</td></tr>

<tr><th>string1</th>
<td>An arbitrary string.</td></tr>

<tr><th>string2</th>
<td>Another arbitrary string.</td></tr>

<tr><th>pad</th>
<td>An arbitrary string that is appended to the shorter of the first two strings and replicated as many times as required to make the strings of equal length. If this value is not specified or is null, it defaults to a single null byte (X'00').
</td></tr>
</table>

==Examples==
<ol>
<li>This code fragment would set <code>%junk</code> to <code>X'746112445566'</code>:
%X = $X2C('112233445566')
%Y = $X2C('654321')
%junk = $StrXor(%X, %Y)


<li>These statements would set <code>%junk</code> to <code>X'DDEEFF8899AA'</code>:
%X = $X2C('112233445566')
%junk = $StrXor(%X, , $X2C('CC'))


<li>This code fragment would set <code>%junk</code> to <code>X'0000CC44AA66'</code>:
%X = $X2C('112233445566')
%Y = $X2C('1122')
%Z = $X2C('FF00')
%junk = $StrXor(%X, %Y, %Z)

</ol>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$StrXor]]

$StrOr

2018-09-20T23:28:50Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$StrOr}}
Bit-wise OR two strings

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $StrOr function is the [[BitOrString (String function)]].

This function performs a bit-wise OR of two strings.

The <var>$StrOr</var> function accepts three arguments and returns a string result that is the bit-wise OR of the first two arguments, the shorter being padded with as many copies of the third argument as are required to make the string lengths equal.

==Syntax==
%STR = $StrOr(string1, string2, [pad])


===Syntax terms===
<table>
<tr><th>%str</th>
<td>The bit-wise AND of <var class="term">string1</var> and <var class="term">string2</var>.</td></tr>

<tr><th>string1</th>
<td>An arbitrary string.</td></tr>

<tr><th>string2</th>
<td>Another arbitrary string.</td></tr>

<tr><th>pad</th>
<td>An arbitrary string that is appended to the shorter of the first two strings and replicated as many times as required to make the strings of equal length. If this value is not specified or is null, it defaults to a single null byte (X'00').
</td></tr>
</table>

==Examples==
<ol>
<li>This code fragment would set <code>%junk</code> to <code>X'756333445566'</code>:
%X = $X2C('112233445566')
%Y = $X2C('654321')
%junk = $StrOr(%X, %Y)


<li>These statements would set <code>%junk</code> to <code>X'DDEEFFCCDDEE'</code>:
%X = $X2C('112233445566')
%junk = $StrOr(%X, , $X2C('CC'))


<li>This code fragment would set <code>%junk</code> to <code>X'1122FF44FF66'</code>:
%X = $X2C('112233445566')
%Y = $X2C('1122')
%Z = $X2C('FF00')
%junk = $StrOr(%X, %Y, %Z)

</ol>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$StrOr]]

$StrAnd

2018-09-20T23:28:49Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$StrAnd}}
Bit-wise AND two strings

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $StrAnd function is <var>[[BitAndString (String function)|BitAndString]]</var>.

This function performs a bit-wise AND of two strings.

The <var>$StrAnd</var> function accepts three arguments and returns a string result that is the bit-wise AND of the first two arguments, the shorter being padded with as many copies of the third argument as are required to make the string lengths equal.

==Syntax==
%str = $StrAnd(string1, string2, [pad])


===Syntax terms===
<table>
<tr><th>%str</th>
<td>The bit-wise AND of ''string1'' and ''string2''.</td></tr>

<tr><th>string1</th>
<td>An arbitrary string.</td></tr>

<tr><th>string2</th>
<td>Another arbitrary string.</td></tr>

<tr><th>pad</th>
<td>An arbitrary string that is appended to the shorter of the first two strings and replicated as many times as required to make the strings of equal length. If this value is not specified or is null, it defaults to a single null byte (X'00').
</td></tr>
</table>

==Examples==
<ol>
<li>This code fragment would set <code>%junk</code> to <code>X'010221000000'</code>:
%X = $X2C('112233445566')
%Y = $X2C('654321')
%junk = $StrAnd(%X, %Y)


<li>These statements would set <code>%junk</code> to <code>X'000000444444'</code>:
%X = $X2C('112233445566')
%junk = $StrAnd(%X, , $X2C('CC'))


<li>This code fragment would set <code>%junk</code> to <code>X'112233005500'</code>:
%X = $X2C('112233445566')
%Y = $X2C('1122')
%Z = $X2C('FF00')
%junk = $StrAnd(%X, %Y, %Z)

</ol>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$StrAnd]]

$Str

2018-09-20T23:28:48Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Str}}
Treat a longstring as string

Note: Many $functions have been deprecated in favor of Object Oriented methods. There is no OO equivalent for the $Str function.

This function takes a longstring input and produces a string output, silently truncating the result at 255 bytes or shorter if the target is shorter.

The <var>$Str</var> function accepts one argument and returns a string result that is the first argument truncated at the $function target's length.

The first argument is an arbitrary string.

==Syntax==
%str = $Str(longstring)



<var class="term">%str</var> is up to the first 255 bytes of <var class="term">longstring</var>.

==Usage notes==
<ul>
<li>The main utility of the <var>$Str</var> function is to prevent the request cancellation that would result from a direct assignment from a <var>Longstring</var> value to a <var>String</var> %variable that is too small to hold the entire value. While the input to <var>$Str</var> could be a regular <var>String</var>, this doesn't really make much sense since a regular <var>String</var> can be assigned to a regular <var>String</var> without request cancellation for truncation, anyway.

A <var>$Str</var> would upgrade an argument With expression to a <var>Longstring</var> With expression, but this is again rather silly as the result would then simply be truncated at 255 bytes if it exceeds 255 bytes.

<li><var>$Str</var> also makes sense as a quick shorthand for the first 255 bytes of a <var>Longstring</var>, even if the target is a <var>Longstring</var>.
</ul>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$Str]]

$StatLD

2018-09-20T23:28:48Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$StatLD}}
Calculate differences and rates for statistics $lists

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $StatLD function is the [[UserStatistics class]].

This function allows calculation of differences and rates for statistics $lists. These statistics $lists must be in a format identical to $lists produced by <var>$CfStatL</var>, <var>$FiStatL</var>, <var>$TkStatL</var>, <var>$SsStatL</var>, <var>$UsStatL</var>, and <var>$JpStatL</var>.

The <var>$StatLD</var> function accepts six arguments and returns a numeric error code.

==Syntax==
%result = $StatLD(list1_id, list2_id, list3_id, action_list, divisor, prelen)


===Syntax terms===
<table>
<tr><th>%result</th>
<td>Either 0 or a negative error code.</td></tr>

<tr><th>list1_id</th>
<td>The identifier of a $list where each item contains an EBCDIC identifier in bytes 1-10, a binary number in bytes 11-12, and data in bytes 13 to the end of the $list item. </td></tr>

<tr><th>list2_id</th>
<td>The identifier of a $list where each item contains an EBCDIC identifier in bytes 1-10, a binary number in bytes 11-12, and data in bytes 13 to the end of the $list item. </td></tr>

<tr><th>list3_id</th>
<td>The identifier of an output $list. The contents of this $list are deleted and replaced by the differences between the <var class="term">list1_id</var> $list and the <var class="term">list2_id</var> $list. </td></tr>

<tr><th>action_list</th>
<td>A control string containing blank-delimited tokens describing the action to be performed for each 4-byte chunk of the input $list items. The available actions are:
<ul>
<li>'N' - Number. Simply copy 4 bytes from the <var class="term">list2_id</var> argument. </li>

<li>'D' - Difference. Calculate binary difference between 4 bytes in <var class="term">list2_id</var> and <var class="term">list1_id</var>. </li>

<li>'R' - Rate. Calculate binary difference between 4 bytes in argument 2 and argument 1, multiply by 1,000,000, then divide by the <var class="term">divisor</var> argument. </li>
</ul></td></tr>

<tr><th>divisor</th>
<td>A number to be used as a divisor in calculating rates. This optional argument is required if there is an <code>R</code> in the <var class="term">action_list</var> argument. This would ordinarily be the elapsed time between calculation of the <var class="term">list1_id</var> argument and the <var class="term">list2_id</var> argument.</td></tr>

<tr><th>pre_len</th>
<td>A number of characters at the beginning of the output list (parameter 3) reserved for the name of the monitored entity. Should be set to 30 when monitoring Janus ports, and to 10 (the default) for all other entities.
</table>

==Usage notes==
<ul>
<li>The data returned into the output $list by <var>$StatLD</var> is binary, with the first 12 bytes matching the first 12 bytes of an item in the second $list that matches one in the first list. Any item in the second $list that has the high order bit of byte 11 on (set to flag exclusion by a selection criterion on <var>$FistatL</var>, <var>$TkstatL</var>, <var>$SsStatL</var>, or <var>$UsStatL</var>) is excluded from the new $list. The actual difference data starts at offset 12 (byte number 13) in the result $list items.
</ul>

===Return codes===
 -3 - CCATEMP is full (if LISTFC <var>$SirParm</var> parameter not set)
-5 - Required parameter not specified
-6 - Invalid $list identifier
-12 - Invalid control string
-13 - Invalid rate divisor
-14 - Invalid length $list item


==Examples==
<ol>
<li>The following program displays every user's CPU usage as a rate over one second interval and as a total over the whole run.

Begin
%i is float
%list1 is float
%list2 is float
%list3 is float
%time1 is float
%time2 is float
%rc is float
%data is string len 255

%list1 = $ListNew
%list2 = $ListNew
%list3 = $ListNew

%time1 = $UsStatL(%list1, 'IODEV CPU')
Pause 1
%time2 = $UsStatL(%list2, 'IODEV CPU')
%rc = $StatLD(%list1, %list2, %list3, 'N N', %time2 - %time1)

For %i from 1 to $ListCnt(%list3)
%data = $ListInf(%list3, %i)
Text
userid = { $substr(%data,1,10) } -
usernum = { $unbin($substr(%data,11,2)) } -
iodev = { $unbin($substr(%data,13,4)) } -
cpu total = { $unbin($substr(%data,17,4)) }
End Text
End For
End
</li>

<li>The statistics collection functions (<var>$FiStatL</var>, <var>$SSStatL</var>, etc.) have a parameter that lets you subset the list of entities to be viewed. But those functions always return the full list of entities. To view the subsetted list, the collected statistics need to be run through <var>$StatLD</var>. This example demonstrates the technique:

begin
%al1 is float
%al2 is float
%al3 is float
%error is float
%rc is float
%z is float

%an is string len 20 array (20)
%file is string len 20
%restrict is string len 20
%file = 'SIRLOCAL'

%al1 = $listNew
%al2 = $listNew
%al3 = $listNew
%restrict = 'FILE=' with %file
%rc = $ssstatl(%al1,'STATUS',%RESTRICT)
%rc = $ssstatl(%al2,'STATUS',%RESTRICT)
%rc = $STATLD(%al1,%al2,%al3,'N N')
for %z from 1 to $listCnt(%al3)
%an(%z) = $deBlank($listInf(%al3,%Z,1,10))
printText {%an(%z)}
end for
%al1 = $listDel
%al2 = $listDel
%al3 = $listDel
end


The example shows a set of subsystem statistics collected by <var>$SsStatL</var>, limited to only those subsystems with file <code>SIRLOCAL</code> open. The statistics are collected twice, into lists <code>%al1</code> and <code>%al2</code>, and then run through <var>$StatLD</var> to produce list <code>%al3</code>. $List <code>%al3</code> shows the selected subset. </li>
</ol>

==Products authorizing {{PAGENAMEE}}==
<ul>
<li>[[SirMon]]
</ul>

[[Category:$Functions|$StatLD]]

$StatD

2018-09-20T23:28:47Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$StatD}}
Calculate differences and rates for statistics strings

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $StatD function is the [[UserStatistics class]].

This function allows calculation of differences and rates for statistics strings. These statistics strings must be in a format identical to strings produced by <var>$FISTAT</var>, <var>$SYSTAT</var>, <var>$TKSTAT</var>, <var>$SsStat</var>, and <var>$UsStat</var>.

The <var>$StatD</var> function accepts four arguments and returns a string made up of an error code and returned statistics.

==Syntax==
%string = $StatD(stat_string1, stat_string2, ctl_string, [divisor])


===Syntax terms===
<table>
<tr><th>%string</th>
<td>The returned string consists of binary data, the first 4 bytes of which is an error code. If the error code is negative, <var class="term">%string</var> will only be 4 bytes long.</td></tr>

<tr><th>stat_string1</th>
<td>This string contains an EBCDIC identifier in bytes 1-10, a binary number in bytes 11-12, and data in bytes 13 to the end of the string. </td></tr>

<tr><th>stat_string2</th>
<td>This string contains an EBCDIC identifier in bytes 1-10, a binary number in bytes 11-12, and data in bytes 13 to the end of the string. For differences to be calculated, bytes 1-12 must match bytes 1-12 of the <var class="term">stat_string1</var> argument. </td></tr>

<tr><th>ctl_string</th>
<td>This control string contains blank-delimited tokens describing the action to be performed for each 4 byte chunk of the input strings. The available actions are:
<ul>
<li>'N' - stands for number. Simply copy 4 bytes from argument 2.
<li>'D' - stands for difference. Calculate binary difference between 4 bytes in argument 2 and argument 1.
<li>'R' - stands for rate. Calculate binary difference between 4 bytes in argument 2 and argument 1, multiply by 1,000,000 and then divide by argument 4. Argument 4 is required if an R is included in the control string.
</ul> </td></tr>

<tr><th>divisor</th>
<td>This a number to be used as a divisor in calculating rates. This optional argument is required if there is an 'R' in the <var class="term">ctl_string</var> argument. This would ordinarily be the elapsed time between calculation of the <var class="term">stat_string1</var> and the <var class="term">stat_string2</var> argument.</td></tr>
</table>

===Return codes===
 -5 - Required parameter not specified
-12 - Invalid control string
-13 - Invalid rate divisor
-14 - Invalid length input string
-15 - First 12 bytes don't match in input


==Usage notes==
<ul>
<li>The data returned by <var>$StatD</var> is binary with the first 4 bytes containing an error code. If the error code is negative, only 4 bytes are returned. If the differences were successfully calculated, the first 4 bytes are set to binary 0. When a zero error code is returned, the next 12 bytes contain a copy of the first 12 bytes of argument 1 and 2. This means that the actual data starts at offset 16 (byte number 17) in the result string.
</ul>

==Example==
The following program displays system CPU as a rate and difference over a one second interval and as a total over the whole run:

Begin
%data is string len 255
%data1 is string len 255
%data2 is string len 255
%data1 = $SyStat('CPU SVIO DNSCACHE DNSRTIMO'):subString(5)
pause 1
%data2 = $SyStat('CPU SVIO DNSCACHE DNSRTIMO'):subString(5)
%data = $statD( %data1, %data2, 'R R N N', 1000)
Text
%data
Return Code = {$UnBin($subStr(%data,1,4))}
CPU = {$UnBin($SUBSTR(%data,17,4))}
SVIO = {$UnBin($SUBSTR(%data,21,4))}
DNSCACHE = {$UnBin($SUBSTR(%data,25,4))}
DNSRTIMO = {$UnBin($SUBSTR(%data,29,4))}
end Text
End


==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[SirMon]]
</ul>

[[Category:$Functions|$StatD]]

$Sir Wild

2018-09-20T23:27:43Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sir_Wild}}
Test string against a wildcard string

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $Sir_Wild function is the <var>[[RegexMatch (String function)|RegexMatch]]</var> function.

<var>$Sir_Wild</var> indicates whether the one string matches a Sirius-style pattern where asterisk (<tt>*</tt>) matches any set of characters, question mark (<tt>?</tt>) matches any single character, and double-quotation mark (<tt>"</tt>) indicates that the following character is to be treated as a literal even if it is one of the three special wildcard characters: <code>* ? "</code>. <var>$Sir_Wild</var> takes two string arguments and returns either a 0 or 1.

The first argument is the string to be tested for a match. This is an optional argument and defaults to null.

The second argument is the string, possibly containing wildcards, against which the first argument is to be tested. This is an optional argument and defaults to null.

==Syntax==
%rc = $Sir_Wild([string], [wildcard])


<var class="term">%rc</var> is set to 0 or 1.

==Examples==
<var>$Sir_Wild</var> returns either a 1 indicating that the first string matches the second or 0 otherwise. For example, this returns 1:

 $Sir_Wild('Ahab', 'A*')


This returns 0:

 $Sir_Wild('Starbuck', 'A*')


This returns 1:

 $Sir_Wild('*LOOK', '"*LOO?')


==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$Sir_Wild]]

$Sir N2Date

2018-09-20T23:27:43Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sir_N2Date}}
Convert datetime number of seconds/300 to string

Note: Many $functions have been deprecated in favor of Object Oriented methods. There is currently no OO equivalent for the $Sir_N2Date function.

The <var>$Sir_N2Date</var> function expects a numeric datetime argument containing a number of seconds/300 since January 1, 1900, and a datetime format string. It returns the date represented by the first argument, in the format corresponding to the second argument. <var>$Sir_N2Date</var> accepts an optional error control string and returns the null string if an error is detected.

==Syntax==
%dat = $Sir_N2Date(datn, fmt, errctl)


===Syntax terms===
<table class="syntaxTable">
<tr><th>%dat</th>
<td>Set to the datetime value string, using format specified by <var class="term">fmt</var>, corresponding to <var class="term">datn</var>, unless an error is detected.
</td></tr>
<tr><th>datn</th>
<td>Datetime number containing a signed number of seconds/300 since January 1, 1900.</td></tr>
<tr><th>fmt</th>
<td>Datetime format string. Refer to [[Datetime string formats|"Datetime string formats"]] for an explanation of valid datetime formats and valid datetime values.</td></tr>
<tr><th>errctl</th>
<td>Optional error control string; refer to [[Datetime string formats#Datetime error handling|"Datetime error handling"]].</td></tr>
</table>

==Usage notes==
<ul>
<li>The inverse of this $function is <var>[[$Sir_Date2N]]</var>.
<li><var>$Sir_N2Date</var> returns a null string in the following cases (see the discussion in [[Datetime string formats#Datetime error handling|"Datetime error handling"]]):
<ul>
<li><var class="term">fmt</var> is not a valid datetime format.
<li><var class="term">datn</var> out of range.
</ul>
</ul>

==Example==
The following fragment prints the string <code>07/31/84</code>:

%x = $Sir_Date2N('8407301230', 'YYMMDDHHMI')
* Add 15 hours:
%x = %x + 300 * 60 * 60 * 15
Print $Sir_N2Date(%X, 'MM/DD/YY')


==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
<li>[http://m204wiki.rocketsoftware.com/images/d/d6/Ul2krNew.pdf Sir2000 User Language Tools]</li>
</ul>

[[Category:$Functions|$Sir_N2Date]]

$Sir NS2Date

2018-09-20T23:27:42Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sir_NS2Date}}
Convert datetime number of seconds to string

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $Sir_NS2Date function is <var>[[SecondsToString (Float function)|SecondsToString]]</var>.

The <var>$Sir_NS2Date</var> function expects a numeric datetime argument containing a number of seconds since January 1, 1900, and a datetime format string. It returns the date represented by the first argument, in the format corresponding to the second argument. <var>$Sir_NS2Date</var> accepts an optional error control string and returns the null string if an error is detected.

==Syntax==
%dat = $Sir_NS2Date(datn, fmt, errctl)


===Syntax terms===
<table class="syntaxTable">
<tr><th>%dat</th>
<td>Set to the datetime value string, using format specified by <var class="term">fmt</var>, corresponding to <var class="term">datn</var>, unless an error is detected.
</td></tr>
<tr><th>datn</th>
<td>Datetime number containing a signed number of seconds since January 1, 1900.</td></tr>
<tr><th>fmt</th>
<td>Datetime format string. Refer to [[Datetime string formats|"Datetime string formats"]] for an explanation of valid datetime formats and valid datetime values.</td></tr>
<tr><th>errctl</th>
<td>Optional error control string; refer to [[Datetime string formats#Datetime error handling|"Datetime error handling"]].</td></tr>
</table>

==Example==
The following fragment prints the string <tt>07/31/84</tt>:
%X = $Sir_Date2NS('8407301230', 'YYMMDDHHMI')
* Add 15 hours:
%X = %X + 60 * 60 * 15
PRINT $Sir_NS2Date(%X, 'MM/DD/YY')


==Usage notes==
<ul>
<li>The inverse of this $function is <var>[[$Sir_Date2NS]]</var>.
<li><var>$Sir_NS2Date</var> returns a null string in the following cases:
<ul>
<li><var class="term">fmt</var> is not a valid datetime format.
<li><var class="term">datn</var> out of range.
</ul>
</ul>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
<li>[http://m204wiki.rocketsoftware.com/images/d/d6/Ul2krNew.pdf Sir2000 User Language Tools]</li>
</ul>

[[Category:$Functions|$Sir_NS2Date]]

$Sir ND2Date

2018-09-20T23:27:41Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Sir_ND2Date}}
Convert datetime number of days to string

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for this $function is <var>[[DaysToString (Float function)|DaysToString]]</var>.

The <var>$Sir_ND2Date</var> function expects a numeric datetime argument containing a number of days since January 1, 1900, and a datetime format string. It returns the date represented by the first argument, in the format corresponding to the second argument. <var>$Sir_ND2Date</var> accepts an optional error control string and returns the null string if an error is detected.

==Syntax==
%dat = $Sir_ND2Date(datn, fmt, errctl)


===Syntax terms===
<table class="syntaxTable">
<tr><th>%dat</th>
<td>Set to the datetime value string, using format specified by <var class="term">fmt</var>, corresponding to <var class="term">datn</var>, unless an error is detected.
</td></tr>
<tr><th>datn</th>
<td>Datetime number containing a signed number of days since January 1, 1900.</td></tr>
<tr><th>fmt</th>
<td>Datetime format string. Refer to [[Datetime string formats|"Datetime string formats"]] for an explanation of valid datetime formats and valid datetime values.</td></tr>
<tr><th>errctl</th>
<td>Optional error control string; refer to [[Datetime string formats#Datetime error handling|"Datetime error handling"]].</td></tr>
</table>

==Usage notes==
<ul>
<li>The inverse of this $function is <var>[[$Sir_Date2ND]]</var>.
<li><var>$Sir_ND2Date</var> returns a null string in the following cases:
<ul>
<li><var class="term">fmt</var> is not a valid datetime format.
<li><var class="term">datn</var> out of range.
</ul>
</ul>

==Example==
The following fragment prints the string <code>07/31/84</code>:
%x = $Sir_Date2ND('8407301230', 'YYMMDDHHMI')
+ Add a day:
%x = %x + 1
Print $Sir_ND2Date(%X, 'MM/DD/YY')


==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
<li>[http://m204wiki.rocketsoftware.com/images/d/d6/Ul2krNew.pdf Sir2000 User Language Tools]</li>
</ul>

[[Category:$Functions|$Sir_ND2Date]]

$SetStat

2018-09-20T22:52:19Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$SetStat}}
Set local system statistic

Note: Many $functions have been deprecated in favor of Object Oriented methods. There is currently no OO equivalent for the $SetStat function.

This function allows a user to set the current value of a local system statistic. There are ten local system statistics that can be set via <var>$SetStat</var>. These stats can be examined via <var>$SyStat</var> under the names <code>LOCAL0</code> through <code>LOCAL9</code>.

==Syntax==
%value = $SetStat(stat_num, [value])


===Syntax terms===
<table class="syntaxTable">
<tr><th>%value</th>
<td>A variable that is set to <var class="term">value</var>, the new value of the appropriate local statistic, or it is set to 0 if there is an error.</td></tr>

<tr><th>stat_num</th>
<td>The local stat number to be set. If this number is not in the range 0 through 9, <var>$SetStat</var> performs no action and returns a 0. </td></tr>

<tr><th>value</th>
<td>A number that indicates the value to which the local stat is to be set. This is an optional argument that defaults to 0.</td></tr>
</table>

==Usage notes==
<ul>
<li>This function can be used to initialize a local statistic. For example, this code fragment initializes local stat number 1 to 0:
%value = $SetStat(1)
</ul>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]
<li>[[SirMon]]
</ul>

[[Category:$Functions|$SetStat]]

$Setg Sys List

2018-09-20T22:52:19Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Setg_Sys_List}}
Get list of system-wide globals

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $Setg_Sys_List function is <var>[[ListOfGlobals (System function)|ListOfGlobals]]</var>.

This function returns names and values from the current set of system global variables. It may be useful in debugging situations.

The <var>$Setg_Sys_List</var> function accepts three arguments and returns zero, indicating success, or a number indicating the cause of error, if there is one.

The first argument identifies the $list to which items for the subsystem globals will be added. This is a required argument.

The second argument is the string which is used to separate the global name from its value in each item of the output $list. This is an optional argument; if omitted, or if the null string is supplied, it defaults to a single byte with value X'00'. This separator value (X'00') can be particularly useful for sorting the output $list; see [[$Setg_Subsys_List]] for an example with sorting.

The third argument is a pattern string; all system global variables matching this pattern are placed on the output $list. This is an optional argument; if omitted, all system global variables are placed on the output $list.

==Syntax==
%rc = $Setg_Sys_List(list_id, [sep], [glob_pat])



<var class="term">%rc</var> is set to 0 or to an error indicator.

===Return codes===
 0 - No errors
-3 - No room to create $list items
(if LISTFC <var>$SirParm</var> parameter not set)
-6 - $List identifier invalid


==Usage notes==
<ul>
<li>This function can be used for debugging, to retrieve values of selected system global variables. The names global variables can be specified using the following wildcard characters:

<table class="syntaxTable">
<tr><th>*</th>
<td>Matches any number of characters including none</td></tr>

<tr><th>?</th>
<td>Matches any single character</td></tr>

<tr><th>"</th>
<td>Indicates that the next character must be treated literally even if it is a wildcard character.
</td></tr></table>

<li>The format of the items created by $Setg_Sys_List is as follows:

<table>
<tr class="head"><th>Length</th> <th>Description</th></tr>
<tr><th><var>10</var></th> <td>Blanks</td></tr>
<tr><th>gg</th> <td>Global name</td></tr>
<tr><th>ss</th> <td>Separator string</td></tr>
<tr><th>vv</th> <td>Global value</td></tr>
</table>
</ul>

==Example==
The following request displays information about the system global variables whose names start with the string 'DATE' or with the string 'EXPIRE'. A single slash character ("/") is used to separate the global name from the global value. (This example assumes that the combined length of the global name and value is less than 245.)

BEGIN
%L FLOAT
%X FLOAT
%L = $ListNew
%X = $Setg_Sys_List(%L, '/', 'DATE*')
* Append more globals to $list:
%X = $Setg_Sys_List(%L, '/', 'EXPIRE*')
FOR %X FROM 1 TO $ListCnt(%L)
PRINT $ListInf(%L, %X)
END FOR
END


==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]
<li>[[Janus Web Server]]
</ul>

[[Category:$Functions|$Setg_Sys_List]]

$Setg Sys

2018-09-20T22:52:18Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Setg_Sys}}
Set system-wide global

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $Setg_Sys function is the <var>[[SetGlobal (System subroutine)|SetGlobal]]</var> <var>System</var> subroutine.

This function allows a user to set the value of a <var class="product">Model 204</var> "global variable" which has a system-wide scope. These are used for the value of the $GetG function or dummy string ("?&") substitution. The order in which the different scopes of global variables are searched can be controlled using <var>$SirParm</var> arguments: for $GETG, with 'GETGSYS', and for dummy strings, with 'DUMMYSYS'.

The $Setg_Sys function accepts two arguments and returns zero, indicating success, or a number indicating the cause of error, if there is one.

The first argument is the name of the global variable to be set. This is an optional argument; it defaults to the null string.

The second argument is the value to which the global variable is to be set. This is an optional argument; it defaults to the null string.

System administrator privileges are required to invoke this $function.
==Syntax==
%rc = $Setg_Sys([glob_name], [value])



<var class="term">%rc</var> is set to 0 or to an error indicator.

===Return codes===
0 - No errors
1 - Not system administrator
2 - Insufficient storage


==Usage notes==
This function can be used to set a global variable which is used for all <var class="product">Model 204</var> users. The value can be set during <var class="product">Model 204</var> initialization (that is, in the CCAIN stream), so values can be calculated once, rather than coding it in the login proc of all subsystems, in which case it is calculated every time a user enters the subsystem, or rather than using some kind of "setup" subsystem that every user is forced into at user login time. For example, the following request can be run from CCAIN:

BEGIN
%X FLOAT
%X = $Setg_Sys('BOSS', 'Mr. Homer J. Simpson')
END

Then the global variable BOSS can be used to obtain the name of the latest boss.

Also, since there is one shared system global table for the entire system, a smaller GTBL value for each user can be achieved than if the global values are set with user global variables.

The order in which the different scopes of global variables are searched can be controlled using <var>$SirParm</var> parameters: for $GETG, with 'GETGSYS', and for dummy strings, with 'DUMMYSYS'.
Here is an example to show the effects of DUMMYSYS and GETGSYS; assume the following procedure is executed in the CCAIN input stream, and that there are no $Setg_Subsys invocations for the global variable named 'JUNK':

 BEGIN
%X FLOAT
%X = $Setg_Sys('JUNK', 'HELLO')
END


and the procedure TESTIT contains the following requests:

 BEGIN
%Y = $SETG('JUNK', 'GOODBYE')
END
BEGIN
PRINT '?&JUNK'
PRINT $GETG('JUNK')
END


Then here are various command streams, and their results:

1. DUMMYSYS=0, GETGSYS=0:

 BEGIN
%X FLOAT
%X = $SirParm('DUMMYSYS', 0)
%X = $SirParm('GETGSYS', 0)
END
I TESTIT

'''produces the following print lines:'''

GOODBYE
GOODBYE


1. DUMMYSYS=0, GETGSYS=1:
 BEGIN
%X FLOAT
%X = $SirParm('DUMMYSYS', 0)
%X = $SirParm('GETGSYS', 1)
END
I TESTIT

'''produces the following print lines:'''

GOODBYE
HELLO


1. DUMMYSYS=1, GETGSYS=0:

 BEGIN
%X FLOAT
%X = $SirParm('DUMMYSYS', 1)
%X = $SirParm('GETGSYS', 0)
END
I TESTIT

'''produces the following print lines:'''

HELLO
GOODBYE


1. DUMMYSYS=1, GETGSYS=1:

 BEGIN
%X FLOAT
%X = $SirParm('DUMMYSYS', 1)
%X = $SirParm('GETGSYS', 1)
END
I TESTIT

'''produces the following print lines:'''

HELLO
HELLO


Retrieval of system global variables is highly efficient; updates, however, are not, so use this $function appropriately.

The current values of system globals can be retrieved using <var>$Setg_Sys_List</var>.

See [[$SirParm]] for more information.

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]] </li>
<li>[[Janus Web Server]] </li>
</ul>



[[Category:$Functions|$Setg_Sys]]

$Setg Subsys List

2018-09-20T22:52:18Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Setg_Subsys_List}}
Get list of subsystem-wide globals

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $Setg_Subsys_List function is the <var>[[ListOfGlobals (Subsystem function)|ListOfGlobals]]</var> <var>Subsystem</var> function.

This function returns names and values from the current set of subsystem global variables. It may be useful in debugging situations.

The $Setg_Subsys_List function accepts four arguments and returns zero, indicating success, or a number indicating the cause of error, if there is one.

The first argument identifies the $list to which items for the subsystem globals will be added. This is a required argument.

The second argument is the string which is used to separate the global name from its value in each item of the output $list. This is an optional argument; if omitted, or if the null string is supplied, it defaults to a single byte with value X'00'. This separator value (X'00') can be particularly useful for sorting the output $list, as shown in the example below.

The third argument specifys the subsystem(s) whose global variables are to be examined for placement on the output $list. This argument may contain pattern matching characters. This is a required argument, and it may not be the null string.

The fourth argument is a pattern string; all global variables in the selected subsystem(s) matching this pattern are placed on the output $list. This is an optional argument; if omitted, all variables in the subsystems specified by the third argument are placed on the output $list.

==Syntax==
%rc = $Setg_Subsys_List(list_id, [sep], subsys_pat, [glob_pat])



<var class="term">%rc</var> is set to 0 or to an error indicator.

===Return codes===
 0 - No errors
-3 - No room to create $list items
(if LISTFC <var>$SirParm</var> parameter not set)
-6 - $List identifier invalid
3 - Subsystem name missing


==Usage notes==
<ul>
<li>This function can be used for debugging, to retrieve values of selected global variables for selected subsystems. The names of subsystems and global variables can be specified using the following wildcard characters:

<table>
<tr><th>*</th>
<td>Matches any number of characters including none</td></tr>
<tr><th>?</th>
<td>Matches any single character</td></tr>

<tr><th>"</th>
<td>Indicates that the next character must be treated literally even if it is a wildcard character.
</td></tr></table>

<li>The format of the items created by <var>$Setg_Subsys_List</var> is as follows:

<table>
<tr class="head"><th>Length</th> <th>Description</th></tr>
<tr><th><var>10</var></th> <td>Subsystem name, padded on right by blanks</td></tr>
<tr><th>gg</th> <td>Global name</td></tr>
<tr><th>ss</th> <td>Separator string</td></tr>
<tr><th>vv</th> <td>Global value</td></tr>
</table>
</ul>

==Example==
The following request displays information about the global variables whose names start with the string 'DATE' in the subsystems whose names contain either the string 'AB' or with the string 'CD'. The display is sorted by subsystem name and global variable name; X'00' as the separator ensures this sort order.
BEGIN
%I FLOAT
%I2 FLOAT
%L FLOAT
%L2 FLOAT
%X FLOAT
%SEP STRING LEN 1
%S1 STRING LEN 255
%L = $ListNew
%SEP = $X2C('00')
%X = $Setg_Subsys_List(%L, %SEP, '*AB*')
* Append more globals to $list:
%X = $Setg_Subsys_List(%L, %SEP, '*CD*')
%L2 = $ListSort(%L, '1,10,A 11,255,A')
PRINT 'Subsystem Global' AND '/ Value' AT 33
%S1 = '----------'
PRINT %S1 AND %S1 WITH %S1 AND ' ' -
AND %S1 WITH %S1
FOR %X FROM 1 TO $ListCnt(%L2)
%S1 = $ListInf(%L2, %X, 11)
%I = $INDEX(%S1, %SEP)
IF %I EQ 0 THEN
%I = 256
END IF
%I2 = %I
IF %I LT 21 THEN
%S1 = $PADR($SUBSTR(%S1, 1, %I - 1), ' ', 20)
%I2 = 21
END IF
PRINT $ListInf(%L2, %X, 1, 10) AND -
$SUBSTR(%S1, 1, %I2 - 1) AND '/' -
AND $ListInf(%L2, %X, 11 + %I)
END FOR
END


==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Janus Web Server]]</li>
</ul>

[[Category:$Functions|$Setg_Subsys_List]]

$Setg Subsys

2018-09-20T22:52:17Z

JALWiccan: Automatically generated page update

{{DISPLAYTITLE:$Setg_Subsys}}
Set subsystem-wide global

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $Setg_Subsys function is the <var>[[SetGlobal (System subroutine)|SetGlobal]]</var> subroutine.

This function allows a user to set the value of a <var class="product">Model 204</var> "global variable" which has a subsystem-wide scope. These are used for the value of the $GetG function or dummy string ("?&") substitution. The order in which the different scopes of global variables are searched can be controlled using <var>$SirParm</var> parameters: for $GetG, with 'GETGSYS', and for dummy strings, with 'DUMMYSYS'.

The $Setg_Subsys function accepts three arguments and returns zero, indicating success, or a number indicating the cause of error, if there is one.

The first argument is the name of the global variable to be set. This is an optional argument; it defaults to the null string.

The second argument is the value to which the global variable is to be set. This is an optional argument; it defaults to the null string.

The third argument is the name of the subsystem that the variable is associated with. This is an optional argument if the $function is invoked from within a subsystem; it defaults to the null string. A non-null subsystem name is required if the $function is invoked from outside a subsystem. If invoked from a subsystem and the third argument is null, the name of the subsystem is used.

System administrator privileges are required to invoke this $function, unless the third argument is omitted or is the null string, and the $function is invoked from a precompiled procedure; in that case, no privileges are required, and the subsystem name used is the active subsystem.

==Syntax==
%rc = $Setg_Subsys([glob_name], [value], subsys_name)



<var class="term">%rc</var> is set to 0 or to an error indicator.

===Return codes===
0 - No errors
1 - Not system administrator
2 - Insufficient storage
3 - Subsystem name missing


==Usage notes==
<ul>
<li>This function can be used to set a global variable which is used for all users of a subsystem. The value can be set during <var class="product">Model 204</var> initialization (that is, in the CCAIN stream), so values can be calculated once, rather than every time a user enters the subsystem. For example, the following request can be run from CCAIN:

OPEN CALENDAR
BEGIN
%DAYS STRING LEN 100
%X FLOAT
%DAYS = ''
D: FOR EACH VALUE OF DAY
%DAYS = %DAYS WITH ' ' WITH VALUE IN D
END FOR
%X = $Setg_Subsys('DAYS', %DAYS, 'TIMESHEET')
END


Then, during execution of the <code>TIMESHEET</code> subsystem, the global variable <code>DAYS</code> can be used to obtain the days of the week.

Also, since there is one shared subsystem global table for the entire system, a smaller GTBL value for each user can be achieved than if the global values are set with user global variables. </li>

<li>The order in which the different scopes of global variables are searched can be controlled using <var>[[$SirParm]]</var> parameters: for <var>$Getg</var>, with 'GETGSYS', and for dummy strings, with 'DUMMYSYS'.
Here is an example to show the effects of DUMMYSYS and GETGSYS; assume the following procedure is executed in the CCAIN input stream:

BEGIN
%X = $Setg_Subsys('JUNK', 'HELLO', 'MY_SUBSYS')
END


And assume the login procedure of <code>MY_SUBSYS</code> contains the following requests:

BEGIN
%Y = $SETG('JUNK', 'GOODBYE')
END
BEGIN
PRINT '?&amp.JUNK'
PRINT $GETG('JUNK')
END


Then here are various command streams, and their results:
<ol>
<li>DUMMYSYS=0, GETGSYS=0:

BEGIN
%X FLOAT
%X = $SirParm('DUMMYSYS', 0)
%X = $SirParm('GETGSYS', 0)
END
MY_SUBSYS 

Produces the following print lines:

GOODBYE
GOODBYE
</li>

<li>DUMMYSYS=0, GETGSYS=1:
BEGIN
%X FLOAT
%X = $SirParm('DUMMYSYS', 0)
%X = $SirParm('GETGSYS', 1)
END
MY_SUBSYS 

Produces the following print lines:
GOODBYE
HELLO
</li>

<li>DUMMYSYS=1, GETGSYS=0:
BEGIN
%X FLOAT
%X = $SirParm('DUMMYSYS', 1)
%X = $SirParm('GETGSYS', 0)
END
MY_SUBSYS 

Produces the following print lines:

HELLO
GOODBYE
</li>

<li>DUMMYSYS=1, GETGSYS=1:
BEGIN
%X FLOAT
%X = $SirParm('DUMMYSYS', 1)
%X = $SirParm('GETGSYS', 1)
END
MY_SUBSYS 

Produces the following print lines:
HELLO
HELLO
</li>
</ol></li>

<li>The current values of subsystem globals can be retrieved using <var>[[$Setg_Subsys_List]]</var>. </li>

<li>Retrieval of subsystem global variables is highly efficient; updates, however, are not, so use this $function appropriately. </li>
</ul>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList"></li>
<li>[[List of $functions|Sirius functions]]</li>
<li>[[Janus Web Server]]</li>
</ul>

[[Category:$Functions|$Setg_Subsys]]