Compiler construction: only syntax analysis.

1. Syntax analysis of Scala
Compiler construction
Speaker: Nurgaliev Ildar

2. Basic Syntax
❖ Scala is case-sensitive
❖ Class names - For all class names, the first letter should be in Upper
Case.
❖ Method Names - All method names should start with a Lower Case letter.
❖ Program File Name - Name of the program file should exactly match the
object name.

3. Characters are distinguished
according to the following classes
1. Whitespace characters: u0020(space) u0009(tab) u000D(r) u000A(n)
2. Letters: (Unicode categories) lower case letters(Ll), upper case letters(Lu), title-
case letters(Lt), other letters(Lo), letter numerals(Nl) and the two characters
‘$’ and ‘_’
3. Digits: ‘0’ . . . ‘9’
4. Parentheses: ( ) [ ] { }
5. Delimiter characters: ‘ ’ " . ; ,
6. Operator characters: all printable ASCII characters u0020-u007F, mathematical
symbols(Sm) and other symbols(So) except parentheses ([]) and periods

4. Characters are distinguished
according to the following classes
Ex:
val #^ = 1 // legal - two opchars
val # = 1 // illegal - reserved word like class or => or @
val + = 1 // legal - opchar
val &+ = 1 // legal - two opchars
val &2 = 1 // illegal - opchar and letter do not mix arbitrarily
val £2 = 1 // working - £ is part of Sc (Symbol currency) - undefined by spec
val ¬ = 1 // legal - part of Sm

5. Scala identifiers
4 types of identifiers supported by Scala:
● ALPHANUMERIC IDENTIFIERS
● OPERATOR IDENTIFIERS
● MIXED IDENTIFIERS
● LITERAL IDENTIFIERS

6. ALPHANUMERIC IDENTIFIERS
● An ALPHANUMERIC IDENTIFIERS starts with a letter or underscore,
which can be followed by further letters, digits, or underscores.
● '$' character is a reserved keyword
Legal alphanumeric identifiers:
age, salary, _value, __1_value
Illegal identifiers:
$salary, 123abc, -salary

7. OPERATOR IDENTIFIERS
● An operator identifier consists of one or more operator characters.
● Operator characters are printable ASCII characters such as +, :, ?, ~ or #.
Legal operator identifiers:
+ ++ ::: <?> :>
ps: The Scala compiler will internally "mangle" operator identifiers to turn them into legal Java
identifiers with embedded $ characters. For instance, the identifier :-> would be represented internally
as $colon$minus$greater method. This is consistent with Java anonymous class names.

8. MIXED IDENTIFIERS
Consists of an alphanumeric identifier, which is followed
by an underscore and an operator identifier.
Legal mixed identifiers: unary_+, myvar_=
unary_+ as a method name defines a unary + operator
myvar_= as method name defines an assignment operator.

9. MIXED IDENTIFIERS
Scala will only allow mixed identifier names (containing alphanumerics and punctuation) if
you separate them by _.
Illegal identifiers:
scala> def iszero?(x : Int) = x == 0
<console>:1: error: '=' expected but identifier found.
def iszero?(x : Int) = x == 0
^
Legal identifiers:
scala> def iszero_?(x : Int) = x == 0
iszero_$qmark: (x: Int)Boolean

10. LITERAL IDENTIFIERS
A literal identifier is an arbitrary string enclosed in back-quotes (` . . . `).
Legal literal identifiers:
- `x` `<clinit>` `yield`
- using back-quotes, you can more or less give any name to a field identifier.
val ` ` = 0
Back-quotes are necessary when Java identifiers clash with Scala reserved words:
Thread.`yield`()

11. LITERAL IDENTIFIERS
- Case statements. The convention is that Lower case names refer to match variables; Upper case names refer to identifiers from the outer
scope.
val A = "a"
val b = "b"
"a" match {
case b => println("b")
case A => println("A")
} //case A were unreachable
"a" match {
case `b` => println("b")
case A => println("A")
} // prints "A".

12. Scala Keywords:
abstract case catch class
def do else extends
false final finally for
forSome if implicit import
lazy match new null
object override package private
protected return sealed super
this throw trait try
true type val var
while with yield
- : = =>
<- <: <% >:
# @

13. Comments in Scala
object HelloWorld {
/* This is my first Scala program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
* /* Nested comments are available */
*/
def main(args: Array[String]) {
// Prints Hello World
// This is also an example of single line comment.
println("Hello, world!")
}
}

14. Newline Characters
Scala is a line-oriented language: statements may be terminated by
semicolons (;) or newlines.
def swap(i: Int, j: Int) {
val t = xs(i)
xs(i) = xs(j)
xs(j) = t()
}
Semicolon is required if you write multiple statements on a single line:
val s = "hello"; println(s)

15. Scala mode and XML mode
● Start XML scanning when “<” is encountered
● Finish XML scanning after successful parse
● Scala expressions are embeddable in XML
● Need to keep stack of Scala/XML nesting
● No Scala tokens in XML mode

16. Scala mode and XML mode
var xmlBook =
<book>
<title>Scala</title>
<version>{book.ver}</version>
</book>

17. References:
- The Scala Language Specification Version 2.9
Martin Odersky, 11 June 2014
- Scala for the impatient
Cay S. Hostman