From WikiChip
Difference between revisions of "mirc/identifiers/$*"
< mirc‎ | identifiers

(Notes & quirks)
Line 1: Line 1:
The '''$*''' allows you to iterates over all the token contained in $1-, like a while loop, $* left the help file a while ago, after while loops were introduced, it's now an undocumented identifier.
+
The '''$*''' allows you to iterate over all of the tokens contained within $1-. The way this works is much like a while loop. $* has been omitted from the help file for a while now, after while loops were introduced, and is therefore no longer documented.
  
$* is extremely powerful because is it much faster than using a while loop on a list of token, consider the following:
+
$* is extremely powerful, because it is much faster than using a while loop on a list of tokens. Understanding how this works is pretty simple, so consider the following:
  
<syntaxhighlight lang="mIRC">
+
<syntaxhighlight lang="mIRC">var %list a b c d,%a 1
var %list a b c d,%a 1
 
 
while ($gettok(%list,%a,32)) {
 
while ($gettok(%list,%a,32)) {
 
echo -a $v1
 
echo -a $v1
 
inc %a
 
inc %a
}
+
}</syntaxhighlight>
</syntaxhighlight>
+
This can be written as:
this can be written as
+
<syntaxhighlight lang="mIRC">tokenize 32 a b c d | echo -a $*</syntaxhighlight>
<syntaxhighlight lang="mIRC">
+
The above is much smaller, and a lot faster. Pretty cool, isn't it?
tokenize 32 a b c d | echo -a $*
 
</syntaxhighlight>
 
And it's faster, cool isn't it?
 
  
 
== Notes & quirks ==
 
== Notes & quirks ==
 +
Why was the $* identifier removed from the help file in the first place? Well, $* was removed because it does not really work the same way that the other identifiers do, and because it is quirky.
  
Why was the $* identifiers removed from the help file? Well because it doesn't really work the same way the others identifiers does, and because it's quirky:
+
Quirky? Quirky, how?
 +
 
 +
Well, mIRC takes the command $*, which appears in and replace all of its occurrences in the line by a special marker: `~$*: You can see that by doing for example:
 +
 
 +
<syntaxhighlight lang="mIRC">//tokenize 32 abcd | echo -a $left($*,1) $+ $chr(3) $+ $mid($*,2)</syntaxhighlight>
  
mIRC takes the command $* appears in and replace all of its occurences in the line by a special marker: `~$*: you can see that by doing for example:
 
<syntaxhighlight lang="mIRC">
 
//tokenize 32 abcd | echo -a $left($*,1) $+ $chr(3) $+ $mid($*,2)
 
</syntaxhighlight>
 
 
Let's take a look at this:
 
Let's take a look at this:
<syntaxhighlight lang="mIRC">
+
<syntaxhighlight lang="mIRC">//tokenize 32 abcd | echo -a $mid($*,2)</syntaxhighlight>
//tokenize 32 abcd | echo -a $mid($*,2)
+
 
</syntaxhighlight>
+
Why isn't this returning bcd? Because of the usage of the special marker `~$*, mIRC has stored that the command is actually "echo -a $mid(`~$*,2)".
  
Why isn't this returning bcd? That's because of the usage of the special marker `~$*, mIRC store that the command is "echo -a $mid(`~$*,2)".
+
Therefore, for each token, (here only $1 == abcd), evaluate the line first, here $mid(`~$*,2) is ~$*, and then mIRC replaces the marker by the token and executes the echo command. However, after an operation, like $mid here, that marker cannot be found; so, basically it cannot be guaranteed to get the correct value of $* inside an identifier.
  
Then for each token, (here only $1 == abcd), evaluate the line first, here $mid(`~$*,2) is ~$*, and then mIRC replaces the marker by the token and execute the echo command, however after an operation like $mid here, that marker can't be found, you basically cannot get the correct value of $* inside an identifier.
+
There is a workaround for the above issue, and that workaround is by using scid and scon:
 +
<syntaxhighlight lang="mIRC">//tokenize 32 abcd | scon -r echo -a $!mid( $* ,2)</syntaxhighlight>
  
There is a workaround to that issue though, with scid and scon:
+
mIRC replaces $* by the marker, but scon has an extra evaluation system which fits perfectly. The $* mechanism is enabled on scon, and mIRC stores the command of the $* as "scon -r echo -a $!mid( `~$* ,2)"
<syntaxhighlight lang="mIRC">
 
//tokenize 32 abcd | scon -r echo -a $!mid( $* ,2)
 
</syntaxhighlight>
 
  
Here mIRC replace $* by the marker, but scon has an extra evaluation system which fits perfectly here, $* mechanism is enabled on scon, mIRC store the command of the $* as "scon -r echo -a $!mid( `~$* ,2)"
+
Beyond that, mIRC evaluates the line for each token, which then becomes: "scon -r echo -a $mid( abcd ,2)", and finally the scon command is executed, resulting in the expected value being echoed.
  
Then for each token, mIRC evaluates the line, which becomes: "scon -r echo -a $mid( abcd ,2)" and then finally the scon command is executed, resulting in the expected value echoed.
+
Another issue is that you cannot call $* more than once in the same scope; the command will simply be skipped. However, this can also be circumvented/worked-around :)
  
Another issue is that you cannot call $* more than once in the same scope the command will simply be skipped, however... this can be worked around :)
+
Simply retokenize after using $*, which forces the update of $1-, $* can be used again, but only if the number of tokens passed is higher than the previous number of tokens passed. $* will only start from the previous number of tokens + 1:
  
If you retokenize after using $*, forcing the update of $1-, you can use $* again but only if the number of tokens you pass is higher than the previous number of token you passed, and $* will only start from that previous number of token + 1:
+
<syntaxhighlight lang="mIRC">//tokenize 32 1 2 3 | echo -a $* | tokenize 32 4 5 6 7 8 | echo -a $* | echo -a here</syntaxhighlight>
<syntaxhighlight lang="mIRC">
 
//tokenize 32 1 2 3 | echo -a $* | tokenize 32 4 5 6 7 8 | echo -a $* | echo -a here
 
</syntaxhighlight>
 
  
As you can see with this line, the second tokenize's first 3 token "4 5 6" are dumb tokens passed to fill in the gap, you can use $1- in front of your next tokenize command to start from those new tokens, like a normal situation.
+
The first three tokens of the second tokenize, "4 5 6", are dummy tokens which are passed to fill in the gap. $1- can be used in front of the next tokenize command in order to start from those new tokens, much like a normal situation.

Revision as of 19:34, 3 September 2015

The $* allows you to iterate over all of the tokens contained within $1-. The way this works is much like a while loop. $* has been omitted from the help file for a while now, after while loops were introduced, and is therefore no longer documented.

$* is extremely powerful, because it is much faster than using a while loop on a list of tokens. Understanding how this works is pretty simple, so consider the following:

var %list a b c d,%a 1
while ($gettok(%list,%a,32)) {
echo -a $v1
inc %a
}

This can be written as:

tokenize 32 a b c d | echo -a $*

The above is much smaller, and a lot faster. Pretty cool, isn't it?

Notes & quirks

Why was the $* identifier removed from the help file in the first place? Well, $* was removed because it does not really work the same way that the other identifiers do, and because it is quirky.

Quirky? Quirky, how?

Well, mIRC takes the command $*, which appears in and replace all of its occurrences in the line by a special marker: `~$*: You can see that by doing for example:

//tokenize 32 abcd | echo -a $left($*,1) $+ $chr(3) $+ $mid($*,2)

Let's take a look at this:

//tokenize 32 abcd | echo -a $mid($*,2)

Why isn't this returning bcd? Because of the usage of the special marker `~$*, mIRC has stored that the command is actually "echo -a $mid(`~$*,2)".

Therefore, for each token, (here only $1 == abcd), evaluate the line first, here $mid(`~$*,2) is ~$*, and then mIRC replaces the marker by the token and executes the echo command. However, after an operation, like $mid here, that marker cannot be found; so, basically it cannot be guaranteed to get the correct value of $* inside an identifier.

There is a workaround for the above issue, and that workaround is by using scid and scon:

//tokenize 32 abcd | scon -r echo -a $!mid( $* ,2)

mIRC replaces $* by the marker, but scon has an extra evaluation system which fits perfectly. The $* mechanism is enabled on scon, and mIRC stores the command of the $* as "scon -r echo -a $!mid( `~$* ,2)"

Beyond that, mIRC evaluates the line for each token, which then becomes: "scon -r echo -a $mid( abcd ,2)", and finally the scon command is executed, resulting in the expected value being echoed.

Another issue is that you cannot call $* more than once in the same scope; the command will simply be skipped. However, this can also be circumvented/worked-around :)

Simply retokenize after using $*, which forces the update of $1-, $* can be used again, but only if the number of tokens passed is higher than the previous number of tokens passed. $* will only start from the previous number of tokens + 1:

//tokenize 32 1 2 3 | echo -a $* | tokenize 32 4 5 6 7 8 | echo -a $* | echo -a here

The first three tokens of the second tokenize, "4 5 6", are dummy tokens which are passed to fill in the gap. $1- can be used in front of the next tokenize command in order to start from those new tokens, much like a normal situation.