Arena Language Manual

1 Introduction

1.1 What's Arena?

1.2 Why another scripting language

1.3 Target audience

1.4 Versioning

1.5 Structure of this manual

1.6 License

2 Language

2.1 Basic tokens

2.1.1 Comments

	# this line is ignored
	a = 5; // everything back here is ignored

	/* this is lengthy explanation of what is happening,
	   but you can probably figure that out yourself */

2.1.2 Keywords

	array   break    bool     case    catch   continue
	default do       else     extends false   float
	fn      for      forced   if      include int
	mixed   new      resource return  string  struct
	switch  template throw    true    try     void
	while

2.1.3 Operators

	::      ==      !=      <=      >=      <
	>       ++      --      &&      ||      **
	+       -       *       /       %       &
	|       ^       <<      >>      !       ~
	=       +=      -=      *=      /=      &=
	|=      ^=      <<=     >>=

2.1.4 Identifiers

	foo
	x2
	my_funny_name
	__something

2.1.5 Integer literals

	0
	123
	0755
	0xFF
	0xbeef

2.1.6 Float literals

	1.0
	.25
	0.376568E-10
	1E+30

2.1.7 String literals

	\\      a literal backslash
	\b      backspace character
	\e      escape character
	\f      form feed character
	\n      newline character
	\r      carriage return character
	\t      tab character
	\ccc    character with octal character code ccc
	\occc   character with octal character code ccc
	\dccc   character with decimal character code ccc
	\xcc    character with hexadecimal char code cc

	"Hello"
	'Greetings to you!\n'
	"All your base are belong to us"
	'Embedded \0 zero \0 characters'

2.1.8 Grouping symbols

	(       )       {      }        [       ]
	.       ;       ,

2.2 Runtime type system

2.2.1 void

2.2.2 bool

2.2.3 int

2.2.4 float

2.2.5 string

2.2.6 array

2.2.7 struct

2.2.8 fn

2.2.9 resource

2.3 Scopes and namespaces

2.3.1 Top-level vs. function-level scope

2.3.2 Global vs. local namespace

2.4 Statements

2.4.1 Basic rules for statements

	expr;

	{
	  stmt1;
	  stmt2;
	  stmt3;
	}

2.4.2 Include statement

	include "library.inc";

2.4.3 Control flow statements

2.4.3.1 if statement

	if (x % 2 == 0)
	  print("x is even!");

	if (x % 2 == 0)
	  print("x is even!");
	else
	  print("Sorry, x is uneven!");

2.4.3.2 while loop statement

	while (x % 2 == 0) {
	  print("x was even");
	  x = rand(0,999);
	}

2.4.3.3 do loop statement

	do {
	  now = time();
	} while (now - saved < 10);

2.4.3.4 for loop statement

	for (i = 0; i < 10; i++) {
	  print("hello");
	}

2.4.3.5 continue statement

	odd = 0;
	for (i = 0; i < 100; i++) {
	  if (i % 2 == 0) continue;
	  ++odd;
	}
	print(odd, " odd numbers found");

2.4.3.6 break statement

	for (;;) {
	  number = rand(0, 99);
	  print("my number: ", number, "\n");
	  if (number == 0) break;
	}

2.4.3.7 switch statement

	three = six = none = 0;
	for (i = 0; i < 100; i++) {
	  switch (i % 6) {
	    case 0:
	      ++six;
	    case 3:
	      ++three;
	      break;
	    default:
	      ++none;
	  }
	}
	print(three, "numbers were divisible by 3\n");
	print(six, "numbers were divisible by 6\n");
	print(none, "number were not divisible by either\n");

2.4.3.8 try statement

	try {
	  a = somefunc();
	  b = someotherfunc();
	} catch (e) {
	  print("exception ", e, " occurred\n");
	}

2.4.3.9 throw statement

	throw "oops";

2.4.4 User-defined functions

2.4.4.1 Function definition

	int sum(int x, int y)
	{
	  return x + y;
	}

	int sum(forced int x, forced int y)
	{
	  return x + y;
	}

2.4.4.2 return statement

	return true;

2.4.5 Structure templates

2.4.5.1 Defining structure fields

	template example
	{
	  i;
	  foo = 42;
	}

	template foo
	{
	  i = 1;
	}
	template bar extends foo
	{
	  i = 2;
	}

2.4.5.2 Defining structure methods

	template foo
	{
	  int double(int x)
	  {
	    return 2 * x;
	  }
	}

	template foo
	{
	  int fiddle(int x)
	  {
	    return 3 * x;
	  }
	}
	template bar extends foo
	{
	  int fiddle(int x)
	  {
	    return 4 * x;
	  }
	}

2.4.5.3 Constructor method

	template foo
	{
	  void foo()
	  {
	    print("constructor method foo called!\n");
	  }
	}

2.5 Expressions

2.5.1 Basic rules for expression nesting

2.5.2 Constant expressions

	true
	12.0
	"I'm a string"
	()
	42

2.5.3 Reference expressions

	a
	foo
	some_long_identifier

2.5.3.1 Static reference expressions

	foo::bar
	some_template::some_field

2.5.3.2 Indexing of elements

	a[2]

	a.name

	a[2].foo[3][7].value
	str.data[100]
	a[0][1][2]
	foo.bar.foobar
	a[1].bar.foo[2]

2.5.4 Cast expressions

	(float) 1

2.5.4.1 Conversion to void

2.5.4.2 Conversion to bool

2.5.4.3 Conversion to int

2.5.4.4 Conversion to float

2.5.4.5 Conversion to string

2.5.4.6 Conversion to array

2.5.4.7 Conversion to struct

2.5.4.8 Conversion to fn

2.5.4.9 Conversion to resource

2.5.5 Assignment expressions

	val = 12.5

	a = b = 0

2.5.5.1 Indexing in assignments

	map[4] = true

	a.foo.data[3] = 12

	s.stack[s.sp++] = 42

2.5.5.2 Combining assignments and operators

	+=      -=      *=       /=     &=      |=
	^=      <<=     >>=

	a += 2

	a = a + 2

2.5.6 Function calls

	int mult(int x, int y)

	printf("Hello World!\n");
	array_merge(a, b ,c);
	versions()
	my_func(12, "foo", 42);

	foo(a, b)

2.5.6.1 Passing arguments "by reference"

	void swap(mixed a, mixed b)
	{
	  c = a;
	  a = b;
	  b = c;
	}

	swap(&x, &y);

	swap(&i, &a[i])

2.5.7 Basic rules for structure templates

2.5.8 Constructor calls

	template foo
	{
	  void foo()
	  {
	    print("this is foo\n");
	  }
	}
	template bar extends foo
	{
	  i = 12;
	}

	template foo
	{
	  void foo(int x)
	  {
	    this.i = x;
	  }
	}

	new foo(12)

2.5.9 Method calls

2.5.9.1 Static method calls

	foo::bar(1, 2, 3)
	input::check("foo", false)
	login::logout()

2.5.9.2 Dynamic method calls

	foo.bar()
	registry[512].files.destroy(2)
	new foo().something("foo", 42)

2.5.10 Operators

2.5.10.1 Math operators

	+     addition
	-     subtraction
	*     multiplication
	/     division
	%     remainder
	**    exponentiation

	-12
	1 + 2
	1.2 * 5
	2 ** 10

2.5.10.2 Boolean operators

	!failed
	x && y
	(x || y) && !z

2.5.10.3 Equality operators

	1 != 2
	x == "foo"
	divisor != 0.0

2.5.10.4 Order operators

	<    left value smaller than right value
	>    left value larger than right value
	<=   left value smaller or equal to right value
	>=   left value larger or equal to right value

	a < b
	x >= 10
	epsilon < 0.01

2.5.10.5 Bitwise operators

	i++
	flags & 0x40
	x ^ y
	--refcount

2.5.10.6 Operator precedence

	Associativity   Operators
	right           = += -= *= /= |= &= ^= <<= >>=
	none            ?
	right           ||
	right           &&
	right           !
	none            == != < <= > >=
	left            & | ^
	left            + - (infix)
	left            * / %
	right           **
	left            << >>
	left            ~ - (postfix)
	left            ++ --

2.5.11 Conditional expression

	x % 2 == 0 ? "even" : "odd"
	x ? false : true

2.5.12 Source file and line expressions

2.5.13 Anonymous functions