GNTCFL - Revision history

Vassia Atanassova: /* The for special form */

2009-04-27T20:30:15Z

The for special form

← Older revision		Revision as of 23:30, 27 April 2009
Line 50:		Line 50:
	<for-expression> ::= (for <local-variable> <start-value> <end-value> <step> <expression>)		<for-expression> ::= (for <local-variable> <start-value> <end-value> <step> <expression>)

	The <tt><local-variable></tt> is assigned values starting from <tt><start-value></tt>, increased or decreased by <tt><step></tt> to reach <end-value>. On every assignment, <expression> is evaluated. The result is the last evaluation of <tt><expression></tt>. The <tt><local-variable></tt> must be declared in the <tt>defun</tt> construction (see [[#GNTCFL syntax\|GNTCFL syntax]]).		The <tt><local-variable></tt> is assigned values starting from <tt><start-value></tt>, increased or decreased by <tt><step></tt> to reach <tt><end-value></tt>. On every assignment, <tt><expression></tt> is evaluated. The result is the last evaluation of <tt><expression></tt>. The <tt><local-variable></tt> must be declared in the <tt>defun</tt> construction (see [[#GNTCFL syntax\|GNTCFL syntax]]).

	=== The ''while'' special form ===		=== The ''while'' special form ===

Vassia Atanassova: /* Declaring an user-defined function */

2009-04-27T20:28:35Z

Declaring an user-defined function

← Older revision		Revision as of 23:28, 27 April 2009
Line 105:		Line 105:
	</source>		</source>

	In this example sq is a local variable and the special form let is used to assign some value to it so that it can be used afterward in all following expressions. The value of the last expression of the function body forms the functions value.		In this example <tt>sq</tt> is a local variable and the special form let is used to assign some value to it so that it can be used afterward in all following expressions. The value of the last expression of the function body forms the functions value.

	== Characteristic functions and predicates ==		== Characteristic functions and predicates ==

Vassia Atanassova: /* Characteristic functions and predicates */ fix link

2009-04-27T20:27:34Z

Characteristic functions and predicates: fix link

← Older revision		Revision as of 23:27, 27 April 2009
Line 118:		Line 118:
	to a reference to the token the function is applied to.		to a reference to the token the function is applied to.

	Finally, here is an example of GNTCFL definitions for [[~~GNTicker~~#Example:_test.xml\|test.xml]].		Finally, here is an example of GNTCFL definitions for [[GN XML format#Example:_test.xml\|test.xml]].

	<source lang="lisp">		<source lang="lisp">

Vassia Atanassova: /* Characteristic functions and predicates */

2009-04-27T17:13:42Z

Characteristic functions and predicates

← Older revision		Revision as of 20:13, 27 April 2009
Line 108:		Line 108:

	== Characteristic functions and predicates ==		== Characteristic functions and predicates ==
	The characteristic function is applied to each token entering the place. Characteristic functions are user-defined functions, which use primitive like <tt>set</tt>, <tt>set-nth</tt>, <tt>setnamed</tt>, split to set the new value of the characteristic of the token to which the function is applied. The functions are referred by their names in the char and mergeRule attributes		The characteristic function is applied to each token entering the place. Characteristic functions are user-defined functions, which use primitive like <tt>set</tt>, <tt>set-nth</tt>, <tt>setnamed</tt>, split to set the new value of the characteristic of the token to which the function is applied. The functions are referred by their names in the char and <tt>mergeRule</tt> attributes
	of the <place> tag.		of the <tt><place></tt> tag.

	Predicates are user-defined functions, which return a numeric value. Zero is considered false and any other value - true. Names of predicates are listed in the <tt><predicates></tt> tag, when describing the predicate matrix of a transition. A predicate is evaluated whenever a token tries to pass through the transition from an input place to an output place.		Predicates are user-defined functions, which return a numeric value. Zero is considered false and any other value - true. Names of predicates are listed in the <tt><predicates></tt> tag, when describing the predicate matrix of a [[transition]]. A predicate is evaluated whenever a token tries to pass through the transition from an input place to an output place.

	Some reserved words are defined only for the characteristic functions and predicates. The reserved word time is evaluated as an integer, showing the current step of the GN. The reserved word token can be used only in characteristic functions, and is evaluated as the value of the last value of the "Default" named characteristic of the token having entered the place.		Some reserved words are defined only for the characteristic functions and predicates. The reserved word time is evaluated as an integer, showing the current step of the GN. The reserved word token can be used only in characteristic functions, and is evaluated as the value of the last value of the "Default" named characteristic of the token having entered the place.

Vassia Atanassova:

2009-04-27T17:01:17Z

← Older revision		Revision as of 20:01, 27 April 2009
Line 93:		Line 93:
	Let us now define a function that gets the square of the default characteristic of some token named "MyToken" and afterward adds 5 to it if there is at least one token in place "MyPlace".		Let us now define a function that gets the square of the default characteristic of some token named "MyToken" and afterward adds 5 to it if there is at least one token in place "MyPlace".

	<source lang="~~xml~~">		<source lang="lisp">
	(defun square "" (x) () (* x x))		(defun square "" (x) () (* x x))
	(defun myfunction "2;tokens.MyToken.char;places.MyPlace.obj" () (sq)		(defun myfunction "2;tokens.MyToken.char;places.MyPlace.obj" () (sq)
Line 120:		Line 120:
	Finally, here is an example of GNTCFL definitions for [[GNTicker#Example:_test.xml\|test.xml]].		Finally, here is an example of GNTCFL definitions for [[GNTicker#Example:_test.xml\|test.xml]].

	<source lang="~~xml~~">		<source lang="lisp">
	(defun inc "" () ()		(defun inc "" () ()
	(set (+ token 1)))		(set (+ token 1)))

Vassia Atanassova at 16:59, 27 April 2009

2009-04-27T16:59:17Z

← Older revision		Revision as of 19:59, 27 April 2009
Line 11:		Line 11:
	<program> ::= <function definition>...		<program> ::= <function definition>...
	<function definition> ::= (defun <unique name> <frame definition> ([<formal arguments>]) ([<local variables>]) <expression>...)		<function definition> ::= (defun <unique name> <frame definition> ([<formal arguments>]) ([<local variables>]) <expression>...)
	<frame definition> ::= “<number of references>;<reference>;...”		<frame definition> ::= "<number of references>;<reference>;..."
	<formal arguments> ::= <unique name>...		<formal arguments> ::= <unique name>...
	<local variables> ::= <unique name>...		<local variables> ::= <unique name>...
Line 43:		Line 43:
	<else> ::= <expression>		<else> ::= <expression>

	After the conditional expression has been evaluated, the process continues with evaluating '''''only''''' one of <tt><then></tt> and <tt><else></tt> expressions, according to the condition value. Thus the following expression is evaluated to '''''42''''' instead of raising a ~~“division~~ by ~~zero”~~ error:		After the conditional expression has been evaluated, the process continues with evaluating '''''only''''' one of <tt><then></tt> and <tt><else></tt> expressions, according to the condition value. Thus the following expression is evaluated to '''''42''''' instead of raising a "division by zero" error:
	(if (* 1 1) (* 7 6) (/ 8 0))		(if (* 1 1) (* 7 6) (/ 8 0))

Line 113:		Line 113:
	Predicates are user-defined functions, which return a numeric value. Zero is considered false and any other value - true. Names of predicates are listed in the <tt><predicates></tt> tag, when describing the predicate matrix of a transition. A predicate is evaluated whenever a token tries to pass through the transition from an input place to an output place.		Predicates are user-defined functions, which return a numeric value. Zero is considered false and any other value - true. Names of predicates are listed in the <tt><predicates></tt> tag, when describing the predicate matrix of a transition. A predicate is evaluated whenever a token tries to pass through the transition from an input place to an output place.

	Some reserved words are defined only for the characteristic functions and predicates. The reserved word time is evaluated as an integer, showing the current step of the GN. The reserved word token can be used only in characteristic functions, and is evaluated as the value of the last value of the ~~“Default”~~ named characteristic of the token having entered the place.		Some reserved words are defined only for the characteristic functions and predicates. The reserved word time is evaluated as an integer, showing the current step of the GN. The reserved word token can be used only in characteristic functions, and is evaluated as the value of the last value of the "Default" named characteristic of the token having entered the place.

	The reserved word <tt>tokenobj</tt> is also defined only for characteristic functions and is valuated		The reserved word <tt>tokenobj</tt> is also defined only for characteristic functions and is valuated
Line 123:		Line 123:
	(defun inc "" () ()		(defun inc "" () ()
	(set (+ token 1)))		(set (+ token 1)))
	(defun less_than_10 “1;tokens.T1.~~char”~~ () ()		(defun less_than_10 "1;tokens.T1.char" () ()
	(< #0 10))		(< #0 10))
	</source>		</source>

Vassia Atanassova: /* List of GNTCFL primitives */

2009-04-27T16:12:24Z

List of GNTCFL primitives

← Older revision		Revision as of 19:12, 27 April 2009
Line 280:		Line 280:
	\|- valign="top"		\|- valign="top"
	\| <tt>senddata</tt>		\| <tt>senddata</tt>
	\| <numeric id> <vector>		\| <tt><numeric id> <vector></tt>
	\| Draws lines from the previously "sent" point to the points of this vector, i.e. visualizes the new points.		\| Draws lines from the previously "sent" point to the points of this vector, i.e. visualizes the new points.
	\|}		\|}

Vassia Atanassova: /* A list of GNTCFL primitives */

2009-04-27T16:11:59Z

A list of GNTCFL primitives

Show changes

Vassia Atanassova: format

2009-04-27T15:45:43Z

format

← Older revision		Revision as of 18:45, 27 April 2009
Line 1:		Line 1:
	<div style="float:right; margin-left: .5em">__TOC__</div>		<div style="float:right; margin-left: .5em">__TOC__</div>
	'''GNTCFL''' is a language with Lisp-like syntax developed especially for [[GNTicker]]. Despite its resemblance to LISP, it is not a fully declarative programming language since it contains certain procedural elements~~. The main purpose of the language is to provide the capability of defining GN characteristic functions and predicates as well as user-defined functions used in them~~.		'''GNTCFL''' is a language with [[wikipedia:Lisp (programming language)\|LISP]]-like syntax developed especially for [[GNTicker]]. Despite its resemblance to LISP, it is not a fully [[wikipedia:Declarative programming\|declarative programming language]] since it contains certain procedural elements.

	A GNTCFL program is a set of function definitions that can be used as characteristic functions and predicates as well as user defined utility functions.		A GNTCFL program is a set of function definitions that can be used as characteristic functions and predicates as well as user defined utility functions.

	== GNTCFL syntax ==		== GNTCFL syntax ==
	LISP-styled, the syntax of GNTCFL programs is very simple. It follows the BNF:		LISP-styled, the syntax of GNTCFL programs is very simple. It follows the [[wikipedia:Backus–Naur Form\|BNF]]:

			{{break}}
	<pre>		<pre>
	<program> ::= <function definition>...		<program> ::= <function definition>...
Line 36:		Line 37:

	=== The ''if'' special form ===		=== The ''if'' special form ===
	The if special form is an exception from the evaluation rule.		The ''if'' special form is an exception from the evaluation rule.
	<if-expression> ::= (if <condition> <then> [<else>])		<if-expression> ::= (if <condition> <then> [<else>])
	<condition> ::= <expression>		<condition> ::= <expression>
Line 42:		Line 43:
	<else> ::= <expression>		<else> ::= <expression>

	After the conditional expression has been evaluated, the process continues with evaluating '''''only''''' one of <then> and <else> expressions, according to the condition value. Thus the following expression is evaluated to '''''42''''' instead of raising a “division by zero” error:		After the conditional expression has been evaluated, the process continues with evaluating '''''only''''' one of <tt><then></tt> and <tt><else></tt> expressions, according to the condition value. Thus the following expression is evaluated to '''''42''''' instead of raising a “division by zero” error:
	(if (* 1 1) (* 7 6) (/ 8 0))		(if (* 1 1) (* 7 6) (/ 8 0))

Line 49:		Line 50:
	<for-expression> ::= (for <local-variable> <start-value> <end-value> <step> <expression>)		<for-expression> ::= (for <local-variable> <start-value> <end-value> <step> <expression>)

	The <local-variable> is assigned values starting from <start-value>, increased or decreased by <step> to reach <end-value>. On every assignment, <expression> is evaluated. The result is the last evaluation of <expression>. The <local-variable> must be declared in the defun construction (see 3.1)		The <tt><local-variable></tt> is assigned values starting from <tt><start-value></tt>, increased or decreased by <tt><step></tt> to reach <end-value>. On every assignment, <expression> is evaluated. The result is the last evaluation of <tt><expression></tt>. The <tt><local-variable></tt> must be declared in the <tt>defun</tt> construction (see [[#GNTCFL syntax\|GNTCFL syntax]]).

	=== The ''while'' special form ===		=== The ''while'' special form ===
Line 55:		Line 56:
	<while-expression> ::= (while <condition> <expression>)		<while-expression> ::= (while <condition> <expression>)

	Evaluation of the while special form involves consequent evaluation of <condition> and <expression>. If <condition> evaluates to a zero value, the process of evaluation is completed and the result is the last value of <expression>.		Evaluation of the ''while'' special form involves consequent evaluation of <tt><condition></tt> and <tt><expression></tt>. If <tt><condition></tt> evaluates to a zero value, the process of evaluation is completed and the result is the last value of <expression>.

	=== The ''let'' special form ===		=== The ''let'' special form ===
Line 61:		Line 62:
	<let-expression> ::= (let <local-variable> <expression>)		<let-expression> ::= (let <local-variable> <expression>)

	The let special form is an assignment construction. First <expression> is evaluated and then its value is assigned to the <local-variable>. In all expressions in the same function, following the let construction, <local-variable> is evaluated to its assigned value. Consequent assignment of different values to the same local variable is possible. In that case the latest assignment is valid.		The let special form is an assignment construction. First <tt><expression></tt> is evaluated and then its value is assigned to the <tt><local-variable></tt>. In all expressions in the same function, following the let construction, <tt><local-variable></tt> is evaluated to its assigned value. Consequent assignment of different values to the same local variable is possible. In that case the latest assignment is valid.

	~~== Primitives ==~~
	~~The primitives are built-in functions providing standard operations (arithmetical, input/output, etc). For a complete list of implemented primitives see appendix A~~.

	== User-defined functions ==		== User-defined functions ==
Line 72:		Line 70:
	Whenever a function needs to access some property of a GN component such as (and mainly) the characteristic of a named token, it needs to declare a reference in the so called function frame. The frame is a list of all needed GN properties. Frames describe an environment of network components for the functions. The BNF of the frame definitions is:		Whenever a function needs to access some property of a GN component such as (and mainly) the characteristic of a named token, it needs to declare a reference in the so called function frame. The frame is a list of all needed GN properties. Frames describe an environment of network components for the functions. The BNF of the frame definitions is:

	<frame definition> ::= “<number of references>;<reference>;...”		<frame definition> ::= "<number of references>;<reference>;..."
	<reference> ::= tokens.<unique name>. obj \| tokens.<unique name>. char \| places.<unique name>. obj \| file.<file name>.<file extension>		<reference> ::= tokens.<unique name>. obj \| tokens.<unique name>. char \| places.<unique name>. obj \| file.<file name>.<file extension>

	where only reference definitions for the recently implemented reference types are given.		where only reference definitions for the recently implemented reference types are given.

	For example let us suppose that some function needs the characteristic of a token named ~~“MyToken”~~ and a reference to a place named ~~“MyPlace”~~. The frame definition will look like		For example let us suppose that some function needs the characteristic of a token named "MyToken" and a reference to a place named "MyPlace". The frame definition will look like
	“2;tokens.MyToken.char;places.MyPlace.~~obj”~~.		"2;tokens.MyToken.char;places.MyPlace.obj".

	With this frame the network components properties will be referable in the function body as #0 and #1, respectively.		With this frame the network components properties will be referable in the function body as '''#0''' and '''#1''', respectively.

	=== Declaring an user-defined function ===		=== Declaring an user-defined function ===
Line 91:		Line 89:
	(defun factorial "" (x) () (if (= x 0) 1 (* x (factorial (- x 1))))		(defun factorial "" (x) () (if (= x 0) 1 (* x (factorial (- x 1))))

	Here x is a local variable and the semantics of the expression has already been discussed.		Here <tt>x</tt> is a local variable and the semantics of the expression has already been discussed.

	Let us now define a function that gets the square of the default characteristic of some token named ~~“MyToken”~~ and afterward adds 5 to it if there is at least one token in place ~~“MyPlace”~~.		Let us now define a function that gets the square of the default characteristic of some token named "MyToken" and afterward adds 5 to it if there is at least one token in place "MyPlace".

	<source lang="xml">		<source lang="xml">
Line 113:		Line 111:
	of the <place> tag.		of the <place> tag.

	Predicates are user-defined functions, which return a numeric value. Zero is considered false and any other value - true. Names of predicates are listed in the <predicates> tag, when describing the predicate matrix of a transition. A predicate is evaluated whenever a token tries to pass through the transition from an input place to an output place.		Predicates are user-defined functions, which return a numeric value. Zero is considered false and any other value - true. Names of predicates are listed in the <tt><predicates></tt> tag, when describing the predicate matrix of a transition. A predicate is evaluated whenever a token tries to pass through the transition from an input place to an output place.

	Some reserved words are defined only for the characteristic functions and predicates. The reserved word time is evaluated as an integer, showing the current step of the GN. The reserved word token can be used only in characteristic functions, and is evaluated as the value of the last value of the “Default” named characteristic of the token having entered the place.		Some reserved words are defined only for the characteristic functions and predicates. The reserved word time is evaluated as an integer, showing the current step of the GN. The reserved word token can be used only in characteristic functions, and is evaluated as the value of the last value of the “Default” named characteristic of the token having entered the place.
Line 120:		Line 118:
	to a reference to the token the function is applied to.		to a reference to the token the function is applied to.

	Finally, here is an example of GNTCFL definitions for test.xml.		Finally, here is an example of GNTCFL definitions for [[GNTicker#Example:_test.xml\|test.xml]].

	<source lang-"xml">		<source lang="xml">
	(defun inc "" () ()		(defun inc "" () ()
	(set (+ token 1)))		(set (+ token 1)))
Line 129:		Line 127:
	</source>		</source>

	== A list of GNTCFL primitives ==		== Primitives ==
			The primitives are built-in functions providing standard operations (arithmetical, input/output, etc). For a complete list of implemented primitives see the list below.

			=== A list of GNTCFL primitives ===


	== References ==		== References ==

Vassia Atanassova: New page:
TOC
'''GNTCFL''' is a language with Lisp-like syntax developed especially for GNTicker. Despite its resemblance to LISP, it is no...

2009-04-27T15:23:59Z

New page: <div style="float:right; margin-left: .5em">__TOC__</div> '''GNTCFL''' is a language with Lisp-like syntax developed especially for GNTicker. Despite its resemblance to LISP, it is no...

New page

<div style="float:right; margin-left: .5em">__TOC__</div>
'''GNTCFL''' is a language with Lisp-like syntax developed especially for [[GNTicker]]. Despite its resemblance to LISP, it is not a fully declarative programming language since it contains certain procedural elements. The main purpose of the language is to provide the capability of defining GN characteristic functions and predicates as well as user-defined functions used in them.

A GNTCFL program is a set of function definitions that can be used as characteristic functions and predicates as well as user defined utility functions.

== GNTCFL syntax ==
LISP-styled, the syntax of GNTCFL programs is very simple. It follows the BNF:

<pre>
<program> ::= <function definition>...
<function definition> ::= (defun <unique name> <frame definition> ([<formal arguments>]) ([<local variables>]) <expression>...)
<frame definition> ::= “<number of references>;<reference>;...”
<formal arguments> ::= <unique name>...
<local variables> ::= <unique name>...
<expression> ::= (<supercombinator> [<argument>...])
<supercombinator> ::= <primitive> | <special form> | <user-defined function>
<special form> ::= if | for | and | or | let
<argument> ::= <formal argument> | <local variable> | <constant> | <frame index> | <expression>
<frame index> ::= #<number>
</pre>

Frame definitions, special forms, primitives and user-defined functions are described in details in the following sections.

== GNTCFL semantics ==
As mentioned above, a GNTCFL program consists entirely of function definitions. As in functional languages there is a general rule for expression evaluating, which applies to all combinations except special forms. The semantics of special forms are specific for each of them and are described separately.

Let
(<supercombinator> [<argument>...])
be an expression, where the supercombinator '''''is not''''' a special form. Evaluating the expression involves subsequent evaluation of the arguments, prior to the application of the supercombinator over their values. In terms of the functional programming the expression evaluations follow the so called ''applicative model''. The following example includes only primitives and constants and demonstrates the process

(* 2 3 (- 11 (+ 1 1) (/10 5)))
-> (* 2 3 (- 11 2 (/10 5)))
-> (* 2 3 (- 11 2 2))
-> (* 2 3 7)
-> 42

=== The ''if'' special form ===
The if special form is an exception from the evaluation rule.
<if-expression> ::= (if <condition> <then> [<else>])
<condition> ::= <expression>
<then> ::= <expression>
<else> ::= <expression>

After the conditional expression has been evaluated, the process continues with evaluating '''''only''''' one of <then> and <else> expressions, according to the condition value. Thus the following expression is evaluated to '''''42''''' instead of raising a “division by zero” error:
(if (* 1 1) (* 7 6) (/ 8 0))

=== The ''for'' special form ===

<for-expression> ::= (for <local-variable> <start-value> <end-value> <step> <expression>)

The <local-variable> is assigned values starting from <start-value>, increased or decreased by <step> to reach <end-value>. On every assignment, <expression> is evaluated. The result is the last evaluation of <expression>. The <local-variable> must be declared in the defun construction (see 3.1)

=== The ''while'' special form ===

<while-expression> ::= (while <condition> <expression>)

Evaluation of the while special form involves consequent evaluation of <condition> and <expression>. If <condition> evaluates to a zero value, the process of evaluation is completed and the result is the last value of <expression>.

=== The ''let'' special form ===

<let-expression> ::= (let <local-variable> <expression>)

The let special form is an assignment construction. First <expression> is evaluated and then its value is assigned to the <local-variable>. In all expressions in the same function, following the let construction, <local-variable> is evaluated to its assigned value. Consequent assignment of different values to the same local variable is possible. In that case the latest assignment is valid.

== Primitives ==
The primitives are built-in functions providing standard operations (arithmetical, input/output, etc). For a complete list of implemented primitives see appendix A.

== User-defined functions ==
As shown in the previous sections, a function definition includes its frame definition, formal arguments and local variables.

=== Frames ===
Whenever a function needs to access some property of a GN component such as (and mainly) the characteristic of a named token, it needs to declare a reference in the so called function frame. The frame is a list of all needed GN properties. Frames describe an environment of network components for the functions. The BNF of the frame definitions is:

<frame definition> ::= “<number of references>;<reference>;...”
<reference> ::= tokens.<unique name>. obj | tokens.<unique name>. char | places.<unique name>. obj | file.<file name>.<file extension>

where only reference definitions for the recently implemented reference types are given.

For example let us suppose that some function needs the characteristic of a token named “MyToken” and a reference to a place named “MyPlace”. The frame definition will look like
“2;tokens.MyToken.char;places.MyPlace.obj”.

With this frame the network components properties will be referable in the function body as #0 and #1, respectively.

=== Declaring an user-defined function ===
As shown above, a user-defined function definition follows the BNF:

<function definition> ::= (defun <unique name> <frame definition> ([<formal arguments>]) ([<local variables>]) <expression>...)

Having described of all the major components, let us go straight to the example:

(defun factorial "" (x) () (if (= x 0) 1 (* x (factorial (- x 1))))

Here x is a local variable and the semantics of the expression has already been discussed.

Let us now define a function that gets the square of the default characteristic of some token named “MyToken” and afterward adds 5 to it if there is at least one token in place “MyPlace”.

<source lang="xml">
(defun square "" (x) () (* x x))
(defun myfunction "2;tokens.MyToken.char;places.MyPlace.obj" () (sq)

;assign the square of the
;characteristic to the local variable
;sq
(let sq (square #0))
;return sq or sq + 5
(if (exists #1) (+ sq 5) sq))
</source>

In this example sq is a local variable and the special form let is used to assign some value to it so that it can be used afterward in all following expressions. The value of the last expression of the function body forms the functions value.

== Characteristic functions and predicates ==
The characteristic function is applied to each token entering the place. Characteristic functions are user-defined functions, which use primitive like <tt>set</tt>, <tt>set-nth</tt>, <tt>setnamed</tt>, split to set the new value of the characteristic of the token to which the function is applied. The functions are referred by their names in the char and mergeRule attributes
of the <place> tag.

Predicates are user-defined functions, which return a numeric value. Zero is considered false and any other value - true. Names of predicates are listed in the <predicates> tag, when describing the predicate matrix of a transition. A predicate is evaluated whenever a token tries to pass through the transition from an input place to an output place.

Some reserved words are defined only for the characteristic functions and predicates. The reserved word time is evaluated as an integer, showing the current step of the GN. The reserved word token can be used only in characteristic functions, and is evaluated as the value of the last value of the “Default” named characteristic of the token having entered the place.

The reserved word <tt>tokenobj</tt> is also defined only for characteristic functions and is valuated
to a reference to the token the function is applied to.

Finally, here is an example of GNTCFL definitions for test.xml.

<source lang-"xml">
(defun inc "" () ()
(set (+ token 1)))
(defun less_than_10 “1;tokens.T1.char” () ()
(< #0 10))
</source>

== A list of GNTCFL primitives ==

== References ==
* [http://debian.fmi.uni-sofia.bg/~spooler/gnticker/GNticker.pdf GNTicker - Brief description]

[[Category:Generalized nets]]
[[Category:Software]]