3 – Описание языка

Примечание: В информатике лексический анализ — процесс аналитического разбора входной последовательности символов (например, такой как исходный код на одном из языков программирования) с целью получения на выходе последовательности символов, называемых «токенами» (подобно группировке букв в слова). Группа символов входной последовательности, идентифицируемая на выходе процесса как токен, называется лексемой. В процессе лексического анализа производится распознавание и выделение лексем из входной последовательности символов.

3.1 – Лексические соглашения

     and       break     do        else      elseif    end
     false     for       function  goto      if        in
     local     nil       not       or        repeat    return
     then      true      until     while

     +     -     *     /     %     ^     #
     &     ~     |     <<    >>    //
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]     ::
     ;     :     ,     .     ..    ...

a = 'alo\n123"'
a = "alo\n123\""
a = '\97lo\10\04923"'
a = [[alo
123"]]
a = [==[
alo
123"]==]

3   345   0xff   0xBEBADA

3.0     3.1416     314.16e-2     0.31416E1     34e1
0x0.1E  0xA23p-4   0X1.921FB54442D18P+1

3.2 – Переменные

var ::= Name

var ::= prefixexp ‘[’ exp ‘]’

var ::= prefixexp ‘.’ Name

3.3 – Операторы

3.3.1 – Блоки

block ::= {stat}

stat ::= ‘;’

a = b + c
(print or io.write)('done')

a = b + c(print or io.write)('done')
a = b + c; (print or io.write)('done')

;(print or io.write)('done')

stat ::= do block end

3.3.2 – Порции

chunk ::= block

3.3.3 – Присваивание

stat ::= varlist ‘=’ explist
varlist ::= var {‘,’ var}
explist ::= exp {‘,’ exp}

i = 3
i, a[i] = i+1, 20

x, y = y, x

x, y, z = y, z, x

3.3.4 – Управляющие структуры

stat ::= while exp do block end
stat ::= repeat block until exp
stat ::= if exp then block {elseif exp then block} [else block] end

stat ::= goto Name
stat ::= label
label ::= ‘::’ Name ‘::’

stat ::= break

stat ::= return [explist] [‘;’]

3.3.5 – Оператор for

stat ::= for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end

for v = e1, e2, e3 do block end

do
  local var, limit, step = tonumber(e1), tonumber(e2), tonumber(e3)
  if not (var and limit and step) then error() end
  var = var - step
  while true do
    var = var + step
    if (step >= 0 and var > limit) or (step < 0 and var < limit) then
      break
    end
    local v = var
    block
  end
end

• Все три управляющих выражения вычисляются только один раз, перед началом цикла. Все они должны быть приведены в числах.
• var (переменная), limit (предел), и step (шаг) - невидимые (неявные) переменные. Имена, показанные здесь, приведены только для пояснения.
• Если третье выражение (step) отсутствует, то используется шаг равный 1.
• Для выхода из цикла for можно использовать break и goto.
• Переменная цикла v является локальной для тела цикла. Если потребуется её значение после цикла, назначьте его в другую переменную перед выходом из цикла.

stat ::= for namelist in explist do block end
namelist ::= Name {‘,’ Name}

for var_1, ..., var_n in explist do block end

do
  local f, s, var = explist
  while true do
    local var_1, ..., var_n = f(s, var)
    if var_1 == nil then break end
    var = var_1
    block
  end
end

• explist вычисляется только один раз. Его результатами являются функция iterator, state и начальное значение для первой переменной итератора.
• f, s, и var являются неявными переменными. Имена, используемые здесь, только для пояснения.
• Для выхода из цикла for можно использовать break.
• Переменные цикла var_i являются локальными для цикла, их значения нельзя использовать после завершения цикла for. Если все же эти значения потребовались, то присвойте их другим переменным перед тем как прервать цикл или выйти из него.

3.3.6 – Вызовы функций как операторы

stat ::= functioncall

3.3.7 – Локальные объявления

stat ::= local namelist [‘=’ explist]

3.4 – Выражения

exp ::= prefixexp
exp ::= nil | false | true
exp ::= Numeral
exp ::= LiteralString
exp ::= functiondef
exp ::= tableconstructor
exp ::= ‘...’
exp ::= exp binop exp
exp ::= unop exp
prefixexp ::= var | functioncall | ‘(’ exp ‘)’

f()             -- возврат корректируется до 0 значений
                -- (т.е. все результаты сбрасываются)
g(f(), x)       -- возврат f() сводится к 1 значению
g(x, f())       -- g получает x плюс все результаты из f()
a,b,c = f(), x  -- возврат f() сводится к 1 значению
                -- (c получает nil)
a,b = ...       -- a получает первый параметр из vararg,
                -- b - второй (и a и b могут получить nil,
                -- если соответствующих vararg параметров
                -- не существует)
a,b,c = x, f()  -- возврат f() сводится к 2 значениям
a,b,c = f()     -- возврат f() сводится к 3 значениям
return f()      -- возвращает все результаты из f()
return ...      -- возвращает все полученные vararg параметры
return x,y,f()  -- возвращает x, y, и все результаты из f()
{f()}           -- создает список со всеми результатами из f()
{...}           -- создает список со всеми vararg параметрами
{f(), nil}      -- возврат f() сводится к 1 значению

3.4.1 – Арифметические операторы

• +: сложение (addition)
• -: вычитание (subtraction)
• *: умножение (multiplication)
• /: деление чисел с плавающей запятой (float division)
• //: деление с округлением вниз (floor division)
• %: модуль (modulo) - остаток от деления
• ^: возведение в степень (exponentiation)
• -: унарный минус (unary minus)

Число                 | -2.9 | -0.5 | 0.3 | 1.5 | 2.9 |
Результат округления  |   -3 |   -1 |   0 |   1 |   2 |

00 - 0000
...
15 - 1111

0 - 0000
1 - 0001
7 - 0111

прямой код 7 = 0111
обратный код 7 = 1000
дополнительный код 7 = 1001

7-3=4
0111 прямой код 7
1101 дополнительный код 3
0100 результат сложения 4

-1+7=6
1111 дополнительный код 1
0111 прямой код 7
0110 результат сложения 6

7+1=8
00111 прямой код 7
00001 прямой код 1
01110 переносы
01000 результат 8 - переполнение

-7+7=0
00111 прямой код 7
01001 дополнительный код 7
11110 переносы
10000 результат 16 - но пятый разряд можно игнорировать, реальный результат 0

3.4.2 – Побитовые операторы

• &: побитовое И (bitwise and)
• |: побитовое ИЛИ (bitwise or)
• ~: побитовое исключающее ИЛИ (bitwise exclusive or)
• >>: сдвиг вправо (right shift)
• <<: сдвиг влево (left shift)
• ~: унарный побитовый НЕ (unary bitwise not)

3.4.3 – Приведения и преобразования

3.4.4 – Операторы сравнения

• ==: равенство (equality)
• ~=: неравенство (inequality)
• <: меньше чем (less than)
• >: больше чем (greater than)
• <=: меньше или равно (less or equal)
• >=: больше или равно (greater or equal)

3.4.5 – Логические операторы

10 or 20            --> 10
10 or error()       --> 10
nil or "a"          --> "a"
nil and 10          --> nil
false and error()   --> false
false and nil       --> false
false or nil        --> nil
10 and 20           --> 20

3.4.6 – Конкатенация

3.4.7 – Оператор длины

{10, 20, nil, 40}

3.4.8 – Приоритет

or
and
<     >     <=    >=    ~=    ==
|
~
&
<<    >>
..
+     -
*     /     //    %
unary operators (not   #     -     ~)
^

3.4.9 – Конструкторы таблиц

tableconstructor ::= ‘{’ [fieldlist] ‘}’
fieldlist ::= field {fieldsep field} [fieldsep]
field ::= ‘[’ exp ‘]’ ‘=’ exp | Name ‘=’ exp | exp
fieldsep ::= ‘,’ | ‘;’

a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }

do
  local t = {}
  t[f(1)] = g
  t[1] = "x"         -- 1st exp
  t[2] = "y"         -- 2nd exp
  t.x = 1            -- t["x"] = 1
  t[3] = f(x)        -- 3rd exp
  t[30] = 23
  t[4] = 45          -- 4th exp
  a = t
end

3.4.10 – Вызовы функций

functioncall ::= prefixexp args

вызовфункции ::= префиксныевыражения аргументы

functioncall ::= prefixexp ‘:’ Name args

args ::= ‘(’ [explist] ‘)’
args ::= tableconstructor
args ::= LiteralString

return (f(x))        -- результаты сводятся к 1 значению
return 2 * f(x)
return x, f(x)       -- дополнительные результаты
f(x); return         -- результаты отбрасываются
return x or f(x)     -- результаты сводятся к 1 значению

3.4.11 – Определения функций

functiondef ::= function funcbody
funcbody ::= ‘(’ [parlist] ‘)’ block end

stat ::= function funcname funcbody
stat ::= local function Name funcbody
funcname ::= Name {‘.’ Name} [‘:’ Name]

function f () body end

f = function () body end

function t.a.b.c.f () body end

t.a.b.c.f = function () body end

local function f () body end

local f; f = function () body end

local f = function () body end

parlist ::= namelist [‘,’ ‘...’] | ‘...’

function f(a, b) end
function g(a, b, ...) end
function r() return 1,2,3 end

CALL            PARAMETERS
ВЫЗОВ           ПАРАМЕТРЫ
f(3)             a=3, b=nil
f(3, 4)          a=3, b=4
f(3, 4, 5)       a=3, b=4
f(r(), 10)       a=1, b=10
f(r())           a=1, b=2
g(3)             a=3, b=nil, ... -->  (nothing)
g(3, 4)          a=3, b=4,   ... -->  (nothing)
g(3, 4, 5, 8)    a=3, b=4,   ... -->  5  8
g(5, r())        a=5, b=1,   ... -->  2  3

function t.a.b.c:f (params) body end

t.a.b.c.f = function (self, params) body end

3.5 – Правила видимости

x = 10            -- глобальная переменная
do                -- начало нового блока
  local x = x     -- новый 'x', со значением 10
  print(x)        --> 10
  x = x+1
  do              -- начало другого блока
    local x = x+1 -- другой 'x'
    print(x)      --> 12
  end
  print(x)        --> 11
end
print(x)          --> 10 глобальная переменная

a = {}
local x = 20
for i=1,10 do
  local y = 0
  a[i] = function () y=y+1; return x+y end
end