Summary

This document license

Language References

The SSWF Setup File

How do I use the Javascript compiler with SSWF?

Comments

Literals (numbers, strings, etc.) and Special Keywords

Reserved Keywords

Attributes

Expressions and Operators

expr-- expr++ expr(...) exprtype(...) expr[...] expr.expr expr::expr (expr) +expr -expr ~expr !expr

--expr ++expr new expr delete expr typeof expr void expr { name: expr, ... } [ expr, ... ] function ... expr ** expr expr * expr expr / expr

expr % expr expr + expr expr - expr expr << expr expr >> expr expr >>> expr expr !< expr expr !> expr expr < expr expr > expr expr <= expr expr >= expr

expr is expr expr as expr expr ~= expr expr in expr expr in expr ... expr expr instanceof expr expr == expr expr === expr expr != expr expr !== expr expr & expr expr ^ expr

expr | expr expr && expr expr ^^ expr expr || expr expr ?< expr expr ?> expr expr ? expr : expr expr = expr expr , expr

Functions

Control Flow Statements

break continue do for (loop) for ... in (enumeration) for each ... in (value enumeration) goto if/else

label return switch throw try/catch/finally while with

Classes, Interfaces and Enums

Packages

Pragmas

Namespaces

Compiler Internals, Known Bugs and Frequently Asked Questions

History of this reference

This document license

Thought the language for Flash is mainly devised by Macromedia, the actual reference is from Netscape. In version 7.x, the ActionScript compiler in Flash is actually a free version of the compiler from Netscape most certainly based on ECMAScript version 3 and tweaked by Macromedia to support some of the features of the following version. The current version (at time of writing) is based on a proposal by Netscape to the ECMAScript people. This is version 4 which isn't official yet (we're in 2005 and the proposal was written in 1999.)

You can find the ECMAScript 4 Netscape Proposal on the Mozilla website at this time. (Search for "ECMAScript 4 Netscape Proposal" in some search engine if the link below does not work anymore at the time you click on it...)

On that page, you have a access to a PDF which describes ECMAScript 4 as (supposedly) currently in the work by the ECMA people.

Another reference is of course the complete reference from Macromedia. You can find ActionScript v8.0 fully described. Note that includes many objects implemented by Flash developers and not actually implemented in the Flash Player. These objects are part of the mx package. Everything else should be available in the player (Sorry! I won't take the time to test that for you to make sure... we'll have to go and find problems as they arise.)

There are other sources for JavaScript, but only the Netscape Proposal is sensical in being used to write a compiler which is what I've done.

In order to accomodate the ActionScript support, SSWF now reads a setup file which includes some information about where to find the default packages and where to save the package database. It also includes a version, so we can make sure that we are reading the proper information.

The setup file is named sswf.rc and it is searched in order in this list of directories:

• Current directory ("."),
• Include directory under the current directory ("include/sswf/scripts"),
• The hidden SSWF directory in your current directory (".sswf"),
• The hidden SSWF directory in your home directory ("~/.sswf"),
• The visible SSWF directory in your home directory ("~/sswf"),
• The normal Unix setup directory ("/etc"),
• The SSWF directory within the Unix setup directory ("/etc/sswf") — note that this is the default installation directory for the SSWF setup file,
• The SSWF scripts include directory ("/usr/include/sswf/scripts"),
• The SSWF scripts directory ("/usr/share/sswf/scripts"),

The file is composed of shell like variables (<name>=<value>). The table below lists the values currently understood by SSWF. The file can also include empty lines and lines commented out. Comments are like in a shell script, they start with a hash (#) and end with the end of the line.

	version=1.7.3

	asc_path=/usr/share/sswf/scripts

	asc_db=tmp/sswf-db.txt

The actionscript compiler is actually in a library. The SSWF compiler links against that library and thus includes the functionality directly inside its language. Whenever you need to write an actionscript in an SSWF file, you now can use the actionscript object.

	do action {
		actionscript test {
			// do something useless
			var b: Integer, c: Integer, d: Integer, e: Integer;
			var a: Integer = (b + c * d) ** e;
		};
	};

The scripts themselves are mostly Javascript compliant. Some features are either not yet implemented or may work in a slightly different way than expected, but in general, it will work the same. (Most of you will be just fine. As long as you do not try all the most advance features of the language... you know!)

So, in order to learn the basics, I suggest that you read Javascript manuals. That will give you most of what you need to understand the basic flow control statements, expressions, the exception hanlding and the global classes: arrays, strings, numbers, dates, functions, math, boolean and errors. All of this is described in this documentation but only briefly. This documentation isn't a tutorial.

On the other hand, in this documentation you will find what is and what is not working in this implementation. Also, there are extensions available in the SSWF version which you may want to use in your scripts. For instance, you can use the ?< and ?> operators to retrieve the maximum or minimum of two or more expressions. Similarly, the SSWF version supports overloading of operators. Here too, we went beyond the specification and we authorize nearly all the operators to be overloaded.

Finally, this documentation describes all the objects available in the SSWF implementation: the Global objects (such as Integer and String), the System object specific to Flash and the Native objects which are used to manipulate all the objects available in Flash such as sprites (called movie clip?!), buttons, cameras, colors, etc. That you can also find on the Macromedia website.

Please, refer to the actionscript object in the Reference to the Scripting language for SWF for more information on how to include an actionscript in your SSWF scripts.

ActionScripts which include class or interface definitions can't be defined within a sprite. This is because a sprite can't be defined as a child of another sprite (it can only be referenced and viewed as a child, not defined). And internally, classes and interfaces are sprites. However, SSWF takes care of extracting these classes accordingly and thus as an end user you can declare anything anywhere it is legal in Javascript.

This implementation of ActionScript supports two types of comments.

The regular multiline C comment introduced by /* and ending with */. Note that you cannot include a comment in another comment (as per the ECMAScript documentation.) Thus, the first */ found closes a comment.

	/* my comment
	   can span
		 on multiple
		 lines */

The regular one line C++ comment introduced by // and ending with the end of the current line. Note that all the characters are ignored in that comment and thus another comment introducer (// or /*) will be ignored.

	// a one line comment

If you need to comment out a block of instructions between { and } then you can simply mark them false. This is the best way to comment out a whole block whether it includes C comments or not.

	false {
		if(quit) {
			exit();
		}
	}

This implementation of ActionScript supports the literals as described in the table below.

	class A { function test() {} }
	class B extends A { function test() { super.test(); } }

The language has a set of reserved and special meaning keywords. Reserved keywords are recognized by the low level lexer and they cannot be used as identifiers anywhere. The special meaning keywords can however be used as regular identifiers in places other than where they have that special meaning.

The ECMAScript language reference says that an identifier with an escape sequence cannot be a keyword. I do not see the point. Escape sequences are being parsed at the time the text is read and if the resulting identifier is a reserved keyword, it is reserved in SSWF. (Also, what is the point of having escape sequences in identifiers? I would think that you can use UTF-8 or Unicode if you want to write identifiers in your own language and not have to use escape sequences anywhere. A variable name such as: être will never be a keyword.)

Definitions in your code can receive a list of attributes. Definitions are functions, blocks of declarations¹, packages, classes, variables, etc.

¹a declaration is a definition or a statement.

All the definitions will always accept true and false. A definition marked true (the default when not marked either true or false,) means that the definition is to be used. A definition marked false, is a definition which needs to be ignored. This allows for dynamic compiling similar to a pre-processor. Whenever you include a package, using the true and false attributes, you can turn on and off different features. For instance, you can have a debug and a release version of some code. In the example below, the do_something() function writes some extraneous messages in a console when attr_debug is set to true.

	// NOTE: this example is not yet functional (as of v1.7.3)
	// in some package
	package that_package {
		function do_something(a, b, c)
		{
			...
			attr_debug {
				echo("We came through here");
			}
			...
		}
	}
	// in some program file
	const var attr_debug := true;
	const var attr_release := !attr_debug;
	...
	import that_package;
	...

In this example, we define the value for attr_debug to true. Then the echo() function is compiled. [Note: an external package will not look outside itself for variables; that's a problem for this pre-processor! I will look into a fix in a later version of SSWF to support this mechanism.]

The attributes, by definition, are a list of names put in front of a definition and understood by the system. They can be used directly or put in a constant variable. When defined in a variable name, that name can be used instead of the attribute. In effect, it makes it a dynamic attribute. Note that a variable can reference another variable. All the variables need to be constants. The name of the variables cannot be the name of any of the currently supported attributes. The special true and false attributes can be negated with the logical not operator.

The attributes understood by such and such definition are listed along that definition documentation. The following is just a list of all the attributes currently understood and which definitions understand it. The ones underlined are also reserved keywords.

¹ switch statements get their attributes defined right before their block of statements; for instance one can write the following:

	switch(expr) with(<) foreach {
	case 0:
		// executed when 'expr < 0' is true
		...
	case 1:
		// executed when 'expr < 1' is true
		...
	case 2:
		// executed when 'expr < 2' is true
		...
	default:
		// always executed
		...
	}

In this example, if expr is 1, then the statements of case 1, case 2 and default are all executed. To avoid executing default after case 2, use a break statement. (similarly, you can break any one case to avoid the foreach effect.)

This implementation of ActionScript supports the operators as descibed in the table below. Note that some of these operators are extensions to the standard. You can make sure not to use them using a pragma to turn them off. You will recognize these extensions by the asterisk following the SSWF version availability such as in: 1.7.3 (*).

The following table gives the operators in priority order. Operators with a higher priority appears first in the table. A higher priority is used first in an expression without the need to use parenthesis for proper grouping.

For instance, in a + b * c, the compiler generates b * c and then adds a to the result.

When you use one or more operators with the same priority, it usually will apply the first operation first (the one most on the left). A few operators have a right priority such as the power operator. This means the last operation is executed first.

For instance, the expression a ** b ** c is equivalent to a ** (b ** c).

The SSWF Availability column also include a flag to mark operators which can be overloaded. To overload an operator, create a function with a name written in a string that is the operator that you want to overload. For instance, the additive operator for the integers is defined like this:

	intrinsic function "+" (l: Integer, r: Integer): Integer;

Note that if you define your own class and want to override an operator you cannot specify intrinsic. It will usually reference objects of the same class, though this is not a requirement since operator functions are automatically considered static.

Operator Name	Priority	Comments	SSWF Availability
<expr> -- post decrement	18	Decrement the expression by one. If the expression is a variable name, the content of the variable is decremented. The expression result is the expression value before it is decremented. Note that if the expression is not a variable or an object, then this operator has no effect.	1.7.3
<expr> ++ post increment	18	Increment the expression by one. If the expression is a variable name, the content of the variable is incremented. The expression result is the value before it is incremented. Note that if the expression is not a variable or an object, then this operator has no effect.	1.7.3
<expr> ( <params> ) function call	18	An expression followed by parenthesis becomes a function call. The expression needs to be resolved as an identifier naming a function. The function can be defined locally, globally or as a class member. If the name is resolved as a variable name being a reference to an object of a class that has the "()" operator overloaded, then that operator function is called with this set to that variable. For example: class Foo { ... function "()" (q: Number) { ... } ... }; ... var t: Foo = new Foo; ... t(53.2); // calls the "()" function // this = t and q = 53.2 ... The <params> defined between the parenthesis in this definition represents a list of expressions separated by commas and used as parameters to the function being called. This list can be empty. All functions should be defined with a prototype. This means the type and number of parameters that you can pass to a function are predetermined and need to match the prototype exactly. If one or more functions with the same name are found but none of them match the prototype, then the compiler fails. If the call expression is defined in a function, that function is named the caller function. Similarly, the function being called is named the callee function. When the caller function has a rest (...) parameter, it can be passed down to the callee function using the rest keyword as in: function func(a, b, ...) { sub_func(a + 3, ...); } This has the effect of passing all of the parameters specified after the first two (a and b in this example) to the function func() down to the function sub_func() (not available in 1.7.3, at least not yet . SSWF supports the naming of parameters. This means you can write the name of each parameter followed by a colon and then an expression representing the value given to that parameter. This enables you to specify the parameters in whatever order you like. Contrary to the ECMAScript documentation, in SSWF, you do not need to specify 'named' for any of the function parameters, you do not need to specify all the parameters by name even after you started to use a named parameter, and you do not need to have default values for any parameter in the function prototype. The compiler can very easily figure all of that out by itself.	1.7.3 overload
<expr> ( <expr> ) implicit cast	18	An expression followed by parenthesis becomes a cast whenever the expression represents a type. This has the effect of the as operator. For example: var a:Integer := Integer(x); is equivalent to var a:Integer := x as Integer;	1.7.3 overload
<expr> [ ... ] array or property access	18	The first expression is expected to be either an array or an object. In the first case, you can define a list of expressions between the square brackets ([]). When an object is being accessed, only one expression is expected which will be a string representing the name of a property of that object.	1.7.3
<expr> . <expr> member	18	The period is used to access a member of an object or a package. This is considered an operator thought at times it does not really look like it. The second expression is usally an identifier, but it is not a requirement (Javascript is very dynamic!). When it is not an identifier the result will only be known at run time.	1.7.3
<expr> :: <expr> scope	18	The scope is a way to group functions, variables and classes which can then dynamically be selected. It is somewhat similar to using a preprocessor in C/C++. The first expression is the name of the scope. The expression on the right is the name of the function, variable or class to access. Internally, there are many different scopes defined such as public, private, internal, protected, intrinsic, true, false, etc. Please, see the chapter Namespace & Scope for more information. Only some internal scopes are currently implemented. If it looks like there is a need for a real scoping support, I will look into add that in the language. It could be of interest in a world such as a browser so you can scope using the name of the browser (i.e. the same name function could be scoped for Netscape, Internet Explorer or Opera. Put that name in a variable, and the language automatically picks the correct function at run time!)	n.a.
( <expr> ) grouping	17	Group expressions to force the order in which they need to be evaluated. In most cases, you can define a list of expressions between parenthesis. Note that an identifier used between parenthesis automatically becomes a reference to a variable whereas, used directly, it can be a direct name (i.e. a.b(); b is a direct member name, wheras in a.(b)(); b is viewed as a variable name or a getter function and what it returns becomes the member name.)	1.7.3
+ <expr> positive	17	The positive operator is mainly for completeness. It may be used to convert any expression to a Number. However, you should really use the ToNumber() function for that purpose.	1.7.3 overload
- <expr> negative	17	Negates the expression. This is equivalent to 0 - <expr>.	1.7.3 overload
~ <expr> bitwise not	17	Transforms all the bits of the number from 1 to 0 and vice versa. This is similar to <expr> ^ -1	1.7.3 overload
! <expr> logical not	17	If the expression is true, return false otherwise return true.	1.7.3 overload
-- <expr> pre decrement	17	Decrements the expression by one. If the expression is a variable name, the content of the variable is decremented. The expression result is the decremented value.	1.7.3
++ <expr> pre increment	17	Increments the expression by one. If the expression is a variable name, the content of the variable is incremented. The expression result is the incremented value.	1.7.3
new <expr> ( ... ) create an object	17	Creates a new object. The expression defines the name of a class of which an object is to be created. The result is a reference to the newly created object. You can later use that reference to call function members and read/write variable members of that object. The expression can be a function call. In that case a corresponding constructor will be called before the new expression returns. Note that the parenthesis are not required if there is not a constructor requiring parameters. You can create a copy of an object using the source object as a parameter to the constructor as in: o:Object; o := new Object; ... copy:Object; copy := new Object(o); NOTE: Some objects, in a Flash movie, cannot be created using the new operator. Instead, you need to call a specialized function which will automatically attach the object where it needs to be (i.e. a text field).	1.7.3
delete <expr> destroy an object	17	Destroys an object previously created with the new operator. The expression is a reference to the object.	1.7.3
typeof <expr> type of	17	Returns the type of the expression as a string. You can use this string to create another object of the same type, compare the type of two different objects, ensure that an object is of a specific type, etc.	1.7.3
void <expr> void	17	Transforms the result of expression to void (that is undefined). This is similar to a cast. I am not too sure why we need this cast since you could put undefined in your expression as is if need be. Note: SSWF tries to optimize many things and this one is one of them. When SSWF finds a void, it first checks to see whether the expression has a side effect, if not, then the whole expression is simply replaced by undefined. This can be wrong if one of the parameters in the expression is a getter or some operators used have some hidden side effects. To fix this problem: do not use void	1.7.3
{ <name1>: <expr1>,   <name2>: <expr2>,     ...   <namen>: <exprn> } object declaration	17	Declares the list of members for a new object with the members separated by commas (,). Each member is defined as a name and a value separated by a colon (:). The name can be any dynamic expression resulting either in a string or a number. Putting a direct name as an identifier is view as a static name unless you put that identifier between parenthesis. var array = { a: 1, b: 2 }; Create an object with two members: a and b set to 1 and 2 respectively. var array = { (a): 1, (b): 2 }; In this case, a and b are viewed as variables and they need to be defined. Say a is set to first and b to second, then the new object will have two members: first and second set to 1 and 2 respectively as in: array.first = 1; array.second = 2;	1.7.3
[<expr1>, <expr2>, ... <exprn>] array declaration	17	Creates an array from the list of items specified between square brackets and separated by commas.	1.7.3
function ... function	17	Declares a function as a literal. The main purpose of this syntax is to create dynamic functions that you can attach to an object as a function member. Functions can also be saved in variables and later called with a syntax such as (func)(...). Note: The dynamism of Flash is limited and all the possibilities that this syntax opens will actually not be available to you. Especially, the function must be constant at compile time to be used in Flash.	1.7.3
<expr> ** <expr> power	16 right	Returns the first expression to the power of the second expression. Note that this operator has a right priority.	1.7.3 overload
<expr> * <expr> multiply	15	Returns the multiplication of both expressions.	1.7.3 overload
<expr> / <expr> divide	15	Returns the division of the first expression by the second. When both expressions are integers, then integer arthimetic is used. Otherwise it will compute a floating point value. If the second expression is zero, the expression will throw an exception.	1.7.3 overload
<expr> % <expr> modulo	15	Returns the modulo of the first expression by the second. When both expressions are integers, then integer arthimetic is used. Otherwise it will compute a floating point value. If the second expression is zero, the expression will throw an exception.	1.7.3 overload
<expr> + <expr> add	14	Returns the addition of both expressions. When both expressions are strings, the result is the concatenation of both strings. Otherwise the operator, like the other arithmetic operators, will try to convert both expressions to a number.	1.7.3 overload
<expr> - <expr> subtract	14	Returns the first expression minus the second.	1.7.3 overload
<expr> << <expr> shift left	13	Shifts the first expression on the left a number of bits as specified in the second expression.	1.7.3 overload
<expr> >> <expr> shift right	13	Shifts the first expression on the right arithmetically a number of bits as specified in the second expression. This means the sign is being copied and thus negative values remain negative.	1.7.3 overload
<expr> >>> <expr> unsigned shift right	13	Shifts the first expression on the right logically a number of bits as specified in the second expression. This means the sign is ignored and zeroes are pushed in as the shift is applied.	1.7.3 overload
<expr> !> <expr> rotate right	13	Rotates the first expression on the right a number of bits as specified in the second expression.	1.7.3 (*) overload
<expr> !< <expr> rotate left	13	Rotates the first expression on the left a number of bits as specified in the second expression.	1.7.3 (*) overload
<expr> < <expr> less	12	Evaluates both expressions and compare them together. If the first expression is less than the second, the operator returns true, otherwise it returns false.	1.7.3 overload
<expr> > <expr> greater	12	Evaluates both expressions and compare them together. If the first expression is greater than the second, the operator returns true, otherwise it returns false.	1.7.3 overload
<expr> <= <expr> less or equal	12	Evaluates both expressions and compare them together. If the first expression is less or equal to the second, the operator returns true, otherwise it returns false.	1.7.3 overload
<expr> >= <expr> greater or equal	12	Evaluates both expressions and compare them together. If the first expression is greater or equal to the second, the operator returns true, otherwise it returns false.	1.7.3 overload
<expr> is <expr> is	12	Evaluates both expressions and determines whether the object on the left is of the type defined on the right. Note 1: this is very similar to instanceof and it is implemented that way in SSWF for now. If you find a specific case where it should & could be distinguished, let me know! Note 2: It looks like v8.x of Flash solves that problem with a new instruction (TBD) [maybe the isPrototypeOf()].	1.7.3
<expr> as <expr> as	12	Casts the left hand side expression to the right hand side type. This expressions checks whether the expression defined on the left is of the right hand side type or one of its supers. If it is, then the left hand side object is returned. Otherwise, this expression returns null. You can also write <expr>(<expr>) to cast the second expression (parameter) to some type (what looks like a function name.)	1.7.3
<expr> ~= <expr> match	12	Test whether the first expression matches the regular expression defined in the second expression. [an internal implemention is available since Flash 9 with ABC ActionScript, which I do not support yet. Note that won't prevent an overloaded operator from working, but of course, you have to write the matching function...]	n.a. (*) overload
<expr> in <expr> in property	12	The first expression is evaluated and expected to be the name of a property (also called member) to search in the object defined in the second expression. If it is found, this operator returns true, otherwise it returns false. WARNING: this syntax used in a for() has the effect of iterating through all the elements of the second expression, setting the variable defined as the first expression (which needs to be an identifier)	1.7.3
<expr> in <expr> ... <expr> in range	12	Evaluates the first expression. Compare it against the second expression. If it is smaller, return false. Otherwise, evaluate the third expression. If it is larger, return false. Otherwise return true. In other words, test that the first expression is included between the bounds defined by the second and third expressions. Note that if the second expression is larger than the third, then this expression always returns false. Note that at this time both the range (.. ) and rest (... ) operators are accepted as the range operator.	1.7.3 (*)
<expr> instanceof <expr> object relationship	12	Defines the object type of the first expression and compare to the name of the class defined on the right. If both are equal, then return true. Note that equal means that the first expression is exactly of the type specified or is a derived class of the type specified in the second expression. For instance: class A { ... } class B extends A { ... }; var b:B; b instanceof A === true	1.7.3
<expr> == <expr> equal	11	Compares the two expressions and determine whether they are equal. If so, return true, otherwise return false. All objects can be compared between each others to know whether they are equal or not. You can also compare void values such as null and undefined. The equal and not equal operators are loose in the sense that many objects will be equal to null and undefined. The strictly equal and strictly not equal operators, however, will compare objects exactly. Thus, two objects need to be of exactly the same class to have a chance to be equal.	1.7.3 overload
<expr> === <expr> strictly equal	11	Compares the two expressions and determines whether they are strictly equal. If so, return true, otherwise return false. Please, see the equal (==) operator for more information.	1.7.3 overload
<expr> != <expr> <expr> <> <expr> not equal	11	Compares the two expressions and determines whether they are different. If so, return true, otherwise return false. The <> operator is an extension and is available by default in SSWF. Macromedia supported that operator before and thus some people may still be used to it and since it does not break the syntax in anyway, it is still usable. Please, see the equal (==) operator for more information.	1.7.3 (*) overload
<expr> !== <expr> strictly not equal	11	Compares the two expressions and determines whether they are strictly different. If so, return true otherwise return false. Please, see the equal (==) operator for more information.	1.7.3 overload
<expr> & <expr> bitwise and	10	Evaluates both expressions, and applies a bitwise and (keep all the bits which are set in both expressions).	1.7.3 overload
<expr> ^ <expr> bitwise exclusive or	9	Evaluates both expressions, and applies a bitwise exclusive or (in the result, set all the bits which are not common to both expressions).	1.7.3 overload
<expr> | <expr> bitwise or	8	Evaluates both expressions, and applies a bitwise or (keep all the bits which are set to 1 in both expressions).	1.7.3 overload
<expr> && <expr> logical and	7	Evaluates both expressions, if both are true, returns true, otherwise returns false.	1.7.3 overload
<expr> ^^ <expr> logical exclusive or	6	Evaluates both expressions, if both are equal, returns false, otherwise returns true. This is partially an SSWF extension in the sense that it is not available in all Javascript implementations. However, because it is in the documentation of ECMAScript version 4, this implementation does not view this operator as an extension.	1.7.3 overload
<expr> || <expr> logical or	5	Evaluates both expressions, if both are false, returns false, otherwise returns true.	1.7.3 overload
<expr> ?< <expr> minimum	4	Evaluates both expressions and returns only the smallest one, the other is lost. Note that this operator is different from the Math.min() function since it works on numbers, strings, boolean and any other object which can be sorted (i.e. which has one of the minimum (?<) or less (<) operators overridden. But the use of the less operator is not yet implemented in 1.7.3)	1.7.3 (*) overload
<expr> ?> <expr> maximum	4	Evaluates both expressions and returns only the largest one, the other is lost. Note that this operator is different from the Math.max() function since it works on numbers, strings, booleans and any other object which can be sorted (i.e. which has one of the maximum (?>) or less (<) operators overridden. But the use of the less operator is not yet implemented in 1.7.3)	1.7.3 (*) overload
<expr> ? <expr> : <expr> conditional	3	Evaluates the first expression: (1) if true, evaluates the second expression and returns it, (2) if false, evaluates the third expression and returns it. Note that only one of the second or third expressions will be evaluated. This means if you have a function call in one of them, that function will be called only when that expression is required. The second and third expressions can usually be assignment expressions. However, in some cases they are limited to conditional expressions.	1.7.3
<expr> <assignment> <expr> assignment	2 right	Assigns the expression on the right to the variable defined on the left. The available assignment operators are as described in the table below. Note that all assignments have the same priority. The right most assignment is applied first. Note that implies that the expression on the right be evaluated first which is exactly what SSWF does. The expression on the left does not need to be an identifier, it can be a dynamically defined variable name (i.e. a string) in which case you want to mark the corresponding variables with the dynamic attribute. Operator Comments Availability = or := Sets the variable to the expression; the := is an SSWF extension (the set variable from Pascal) 1.7.3 (*) += Adds the expression to the variable 1.7.3 -= Subtracts the expression from the variable 1.7.3 &= In the variable, clears the bits that are zero (0) in the expression 1.7.3 |= In the variable, sets the bits that are set (1) in the expression 1.7.3 ^= In the variable, swaps the bits that are set (1) in the expression 1.7.3 /= Divides the content of the variable by the expression 1.7.3 &&= Sets the variable to false, unless the variable and the expression are both true 1.7.3 ||= Set the variable to true, unless the variable and the expression are both false 1.7.3 ^^= Sets the variable to true, if the variable and the expression have different boolean values NOTE: this is partially an SSWF extension in the sense that it is not available in all Javascript implementations. However, because it is in the documentation of ECMAScript version 4, this implementation does not view it as an extension. 1.7.3 ?>= Sets the expression in the variable to the expression value if the expression is larger than the current value in the variable 1.7.3 (*) ?<= Sets the expression in the variable to the expression value if the expression is smaller than the current value in the variable 1.7.3 (*) %= Computes the modulo of the variable content and the expression and saves the result in the variable 1.7.3 *= Multiplies the content of the variable by the expression and saves the result in the variable 1.7.3 **= Computes the content of the variable power the expression and saves the result in the variable 1.7.3 (*) !>= Rotates the content of the variable by expression bits on the left 1.7.3 (*) !<= Rotates the content of the variable by expression bits on the right 1.7.3 (*) <<= Shifts the content of the variable by expression bits on the left 1.7.3 >>= Shifts the content of the variable by expression bits on the right keeping the sign (this is also called the arithmetic shift) 1.7.3 >>>= Shift the content of the variable by expression bits on the right not keeping the sign (zeroes are inserted in the top bits; this is also called a logical shift) 1.7.3	1.7.3 overload
<expr>, <expr> list	1	Groups expressions one after another. The result is the last element of the list. When used as a list of parameters, then each parameter is evaluated and each result is used for the corresponding function parameter. In that case, you can use a label to name the parameter that you are defining. Also, in a function that has a rest paramater (...) you can use ... to add all the arguments passed to your current function on to the next function.	1.7.3

SSWF supports an advanced function declaration and for evaluation it will always follow the ECMAScript specification in that it will evaluate the parameters from left to right. (Flash uses a stack and if you want to just follow the stack order, the parameters would be declared from right to left!)

A function is defined with a name, a list of parameters, a type and a body. The list of parameters is mandatory, though it can be empty or marked as unprototyped. However, you only need either a name or a body. Of course, you can also have everything defined. A function defined in an expression is expected to not have a name. A function defined anywhere else is required to have a name. The function type is optional and defaults to Object when not defined.

A function defined without a name is usually right away put in an object as a new function member. Then the name of the function is the name of the member. It can also be saved in a variable. Later you can use that variable to call the function.

A function defined without a body is either intrinsic (defined internally, also called implicit) or abstract. You cannot define an intrinsic function. These are defined in the Global, System and Native packages and cannot be extended without creating an external library for the Flash Player (and I think that only works under MS-Windows). Abstract functions can be defined in interfaces and classes. The last class to extend a class or interface with an abstract function needs to define that function if it is to be used. Note that Flash doesn't support abstract functions. Once compiled, these will simply have an empty body.

The declaration of a function goes like this:

	function [get|set] name ( param1, ... ) [: type] { ... }

Note that you can declare a function within another function. This works perfectly in SSWF and Flash. However, watch out because the size limit of a function is 64Kb in Flash. You may reach that size very quickly if you have many sub-functions.

It is possible to create a function named get or set (since Flash as such functions, we've got to support them!). When a function has the get or set keyword followed by another name, then the function is considered a getter or a setter. Note that Flash does not support that syntax. The compiler will generate the necessary code to simulate that functionality. Getters and setters can never be created dynamically.

The name of a function is any valid identifier or a string. In case of a string, it is expected to be an operator overload. (i.e. "+", "**", "<=", etc.) Note that like for getters and setters, Flash does not support operator overloading. The compiler will generate the necessary code for you. But this means you cannot use dynamic operator overloading; whenever you need dynamism, use functions.

The list of parameters defines what the function accepts as input. Flash works with a stack and thus the parameters would by default be defined from right to left. To avoid this problem, the SSWF compiler either computes the parameters and saves them in registers before to stack them, or it creates an array with the parameter values and passes that array instead. The array also allows for modifiable parameters (i.e. parameters marked 'out'). Each parameter can have attributes, a name, a type and a default value. The rest parameter (...) can only be named. It cannot receive a default value, nor any attributes. Note that the expression of the default value of parameter n can use the value of parameters 1 to n - 1 (ECMAScript version 5+ if I understand...).

The following shows the list of attributes that parameters accept in SSWF: