SigServer:SignatureMath: Difference between revisions

From AniDB
Jump to navigation Jump to search
(→‎fetchvar: Corrected return type and example)
(→‎fetchvar: Merged examples)
Line 208: Line 208:
Returns the variable given as an argument.
Returns the variable given as an argument.


Examples:
Example:
  @test1 = "Hi!";
  @test1 = "Hi!";
  fetchvar("@test" + 1); // Returns "Hi!"
  fetchvar("@test" + 1); // Returns "Hi!"
  @test2 = 1;
  @test2 = 1;
  fetchvar("$latestwatched_id" + @test2 + "_aname");
  fetchvar("$latestwatched_id" + @test2 + "_aname");

Revision as of 14:35, 4 May 2008

Back to: SigServer:Documentation

Language Reference

Basic Syntax

Before the XML is parsed the Signature engine looks for opening and closing tags ({{ and }}). Everything between those are interpreted as Signature Math (from now on abbreviated SigMath) and parsed before the XML parser takes action. Every opening tag must be followed by a closing tag.

Example

<text>
  <line>{{ 2 + 3 }}</line>
</text>

The example above will output 5 on the signature.

Types

SigMath supports types.

  • Number
  • String
  • Boolean

Number may be either float or integer.

Example: Numbers

1

The above example is classified as a number.

1.1

This example is also classified as a number.

"1"

This is too a number, because a check is performed on every string to see whether it is a number or not.

"-1"

This is the most efficient way to specify a negative number. Because of the way the parsing algoritm works only writing -1 doesn't work.

Example: Strings

"string"
'string'
" 1"

All three examples are strings. Both " and ' may be used with strings. You cannot escape anything inside a string. This means {{ "}}" }} or {{ "\"" }} gives you an error message.

Example: Boolean

true
false

Boolean values may only be lowercase.

Operators

SigMath supports some basic operators. Arithmetic operators have the highest priority. Comparison operators have the second highest priority. Logic operators have the least priority. Parenthesis may be used to group expressions, such as (1 + 2) * 3 = 9.

Arithmetic Operators

+
Adds two numbers. If one of the arguments are a string the second argument will be appnended to the first.
-
Subracts two numbers.
*
Takes the first argument times the second.
/
Divides the first argument with the second.

Comparison Operators

<
Checks if the first argument is smaller than the second. If so true is returned.
>
Checks if the first argument is bigger than the second. If so true is returned.
<=
Checks if the first argument is smaller than or equal to the second. If so true is returned.
>=
Checks if the first argument is bigger than or equal to the second. If so true is returned.
==
Checks if the first argument is equal to the second. If so true is returned.
!=
Checks if the first argument is not equal to the second. If so true is returned.

Logic Operators

||
Checks if the first argument or the second argument are true. If so true is returned.
&&
Checks if the first argument and the second argument are true. If so true is returned.

Variables

SigMath has support for variables. It supports both AniDB variables and user defined. AniDB variables are prefixed with $ and user defined variables with @.

Example

{{ $example }}
{{ @example }}

The first block outputs the AniDB variable named example. The second block outputs the user defined variable named example. A user defined variable may have the same name as an AniDB variable. The variables are only alphanumeric and may contain _ as well.

Setting a variable is quite straight-forward.

Example

{{ @example = "Where's the money Lebowski?" }}

This will set the variable @example to Where's the money Lebowski?. It's possible to redefine variables throughout the code.

Example

{{ @example = "Where's the money Lebowski?" }}
{{ @example = @example + " said Boris" }}

This will set the variable @example to Where's the money Lebowski? said Boris.

This method can override AniDB variables.

Functions

SigMath supports a range of functions. Arguments are separated by comma, and each argument is evaluated before it is passed on to the function. For a complete list of all functions see the function reference.

Function Reference

Mathematical

abs

number abs(number value);

Returns the absolute value of a number

Example:

abs(1);  // Returns 1
abs(-1); // Returns 1

ceil

number ceil(number value);

Returns the ceiling of a number.

Example:

ceil(1.4); // Returns 2
ceil(1.9); // Returns 2

div

number div(number dividend, number divisor);

Returns the integer quotient when dividing dividend with divider.

Example:

div(10, 3); // Returns 3

floor

number floor(number value);

Returns the floor of a number.

Example:

floor(1.1); // Returns 1
floor(1.9); // Returns 1

max

number max(number value1, number value2[, number ...]);

Returns the numerically highest value of the given arguments. At least two arguments are required.

Example:

max(3, 5);           // Returns 5
max(3, 1.2, 5, 5.1); // Returns 5.1

min

number min(number value1, number value2[, number ...]);

Returns the numerically lowest value of the given arguments. At least two arguments are required.

Example:

min(3, 5);           // Returns 3
min(3, 1.2, 5, 5.1); // Returns 1.2

mod

number mod(number dividend, number divisor);

Returns the reminder when dividing dividend with divider.

Example:

mod(10, 3); // Returns 1

pow

number pow(number base, number exp);

Returns base to the power of exp.

Example:

pow(3, 2); // Returns 9
pow(2, 3); // Returns 8

random

number random(number start, number end);

Returns a random integer from the set of integers starting at start and ending at end.

Example:

random(1, 10);  // Returns a random integer from 1 to 10
random(0, 100); // Returns a random integer from 0 to 100

round

number round(number value[, number precision]);

Returns a rounded number with the given precision. If precision isn't specified it will return an integer.

Example:

round(2.4);     // Returns 2
round(2.5);     // Returns 3
round(2.55, 1); // Returns 2.6

sqrt

number sqrt(number value);

Returns the square root of value.

Example:

sqrt(9); // Returns 3

Miscellaneous

date

string date(string format[, string time]);

Returns date and time according to the first argument. The format syntax is the same as PHP's date(). The optional argument may be a timestamp or string with date.

Example:

date("Y-m-d");                        // Returns current date e.g. "2007-11-20"
date("H:i:s");                        // Returns current time, e.g. "19:50:37"
date("Y-m-d", "1995-10-03T20:30:37"); // Returns date "1995-10-03"

fetchvar

string fetchvar(string variable);

Returns the variable given as an argument.

Example:

@test1 = "Hi!";
fetchvar("@test" + 1); // Returns "Hi!"
@test2 = 1;
fetchvar("$latestwatched_id" + @test2 + "_aname");
//Returns the name of the latest anime you watched

if

Alias of notempty();

lc

Alias of lowercase();

length

number length(string value);

Returns the number of characters of the string.

Example:

length("Foobar");   // Returns 6
length("");         // Returns 0
length("Foo bar."); // Returns 8

lowercase

string lowercase(mixed value[, string options]);

If only first argument is specified it converts all the characters to lowercase. The second argument may be "first" or "words". If it is "first" only the string's first character will be converted. If it is set to "words", every word's first character will be converted.

Example:

lowercase("Foo Bar");          // Returns "foo bar"
lowercase("Foo Bar", "first"); // Returns "foo Bar"
lowercase("Foo BAR", "words"); // Returns "foo bAR"

notempty

mixed notempty(mixed value[, mixed true[, mixed false]]);

Check's if the first argument is not empty. Returns TRUE or FALSE if the optional arguments aren't specified. If they are specified it returns the second argument if TRUE and the third argument if FALSE.

Example:

notempty("");                       // Returns false
notempty("Foobar");                 // Returns true
notempty(6 > 2);                    // Returns true
notempty("", "Not empty", "Empty"); // Returns "Empty"

padding

string padding(mixed value, number padding[, string align]);

Takes value and adds padding on left side if third argument isn't specified. Third argument is optional and may be "left" or "right" and specifies the padding alignment. Second argument specifies the padding width.

Example:

padding("2.40", 6);         // Returns "  2.40"
padding("12.40", 6);        // Returns " 12.40"
padding("2.40", 6, "left"); // Returns "2.40  "
padding("1220.40", 6);      // Returns "1220.40"

precision

string precision(number value, number precision);

Returns string containing value with a fixed number of decimals.

Example:

precision(5, 2);    // Returns "5.00"
precision(5.25, 1); // Returns "5.2"
precision(5.26, 1); // Returns "5.3"
precision(5.24, 1); // Returns "5.2"

truncate

string truncate(string value, number length[, string appendage]);

Returns the string truncated to specified length. If third argument is specified it will be appended to the returned string if it's truncated.

Example:

truncate("Foobar", 3);       // Returns "Foo"
truncate("Foobar", 4, ".."); // Returns "Fo.."
truncate("Foob", 4, "..");   // Returns "Foob"

uc

Alias of uppercase();

uppercase

string uppercase(mixed value[, string options]);

If only first argument is specified it converts all the characters to uppercase. The second argument may be "first" or "words". If it is "first" only the string's first character will be converted. If it is set to "words", every word's first character will be converted.

Example:

uppercase("Foo Bar");          // Returns "FOO BAR"
uppercase("foo bar", "first"); // Returns "Foo bar"
uppercase("foo baR", "words"); // Returns "Foo BaR"