забыл заменить на TK_name

/* Emit method lookup expression. */ static void bcemit_method(FuncState *fs, ExpDesc *e, ExpDesc *key) { BCReg idx, func, fr2, obj = expr_toanyreg(fs, e); expr_free(fs, e); func = fs->freereg; fr2 = fs->ls->fr2; bcemit_AD(fs, BC_MOV, func+1+fr2, obj); /* Copy object to 1st argument. */ lj_assertFS(expr_isstrk(key), "bad usage"); idx = const_str(fs, key); if (idx <= BCMAX_C) { bcreg_reserve(fs, 2+fr2); bcemit_ABC(fs, BC_TGETS, func, obj, idx); } else { bcreg_reserve(fs, 3+fr2); bcemit_AD(fs, BC_KSTR, func+2+fr2, idx); bcemit_ABC(fs, BC_TGETV, func, obj, func+2+fr2); fs->freereg--; } e->u.s.info = func; e->k = VNONRELOC; }

Кто-то может объяснить,‌что за ветвление после idx <= BCMAX_C? Хотя бы любые бредовые идеи накиньте

Они так экономят регистры?‌ ведь больше 256 вряд ли получится выделить?‌ (BCMAX_C == 256)

Почему, если idx > 255, резервируются еще 3 или 4 регистра?

fr2 может быть 0 или 1 емнип, это та штука которая необходима для обхода ограничения 32 битной адресации и доступу к 4+‌ ГБ оперы

пора обмазаться принтф"ами и попробовать сделать цепочку на 255 вложенных полей

/* Emit method lookup expression. */ static void bcemit_method(FuncState *fs, ExpDesc *e, ExpDesc *key) { BCReg idx, func, fr2, obj = expr_toanyreg(fs, e); expr_free(fs, e); func = fs->freereg; fr2 = fs->ls->fr2; bcemit_AD(fs, BC_MOV, func+1+fr2, obj); /* Copy object to 1st argument. */ lj_assertFS(expr_isstrk(key), "bad usage"); idx = const_str(fs, key); if (idx <= BCMAX_C) { bcreg_reserve(fs, 2+fr2); bcemit_ABC(fs, BC_TGETS, func, obj, idx); } else { bcreg_reserve(fs, 3+fr2); bcemit_AD(fs, BC_KSTR, func+2+fr2, idx); bcemit_ABC(fs, BC_TGETV, func, obj, func+2+fr2); fs->freereg--; } e->u.s.info = func; e->k = VNONRELOC; }

это та функция которая вызывается каждый раз при разборе такой конструкции obj:key подразумевается obj:key(args...), но аргументы парсятся позже,‌ и сама инструкция CALL "излучается в байткод" позже

оказалось, 255 здесь значит максимальный индекс глобальной константы. ну и, само собой,‌ эта ветвь меня не интересует пока - инфиксы задаются переменными

выражение ... = math.cos увеличивает счетчик на 2

ШТО

[luar] local foo = 78; local bar = 56; fn infix(a, b) a + b; local stat = foo infix bar infix foo; print(stat); [lua]

оно заработало?

ну баги есть,‌ иногда регистр obj совпадает с регистром func и меня приветствует фиаско. где-то не хватает одного зарезервированного регистра

судя по тому,‌ что free раньше tonextreg, вот эта func клодёться прямо вместо только что освободившегося obj. щас попробуем наоборот

аааааааааааааааа вот эти два кода считаются одинаковыми (и генерируют одинаковый байткод!)‌ потому что аргументы так парсятся, а не как я думал [luar] fn tail(l, r) r(l); local fn proc1(x) x * x; local fn proc2(x) x * 2; local init = 8; local res = init tail proc1 tail proc2; print(res); function tail(l, r) return r(l) end; local function proc1(x) return x * x end; local function proc2(x) return x * 2 end; local init = 8; local res = tail(init, tail(proc1, proc2)); print(res);

приоритет моих инфиксов - справа налево

но я хотел полностью слева направо поэтому переделываю

ооо,‌включил ассерты и оказалось что я неправильно освобождаю регистр

фича таки удалась

фича таки удалась

Ловкач!

только мелкие косяки остались

видишь тут res один,‌а принт печатает два

и теперь ; крайне желательные

но думаю это того стоит

капец лиспо-расто-питоно-силуа

капец лиспо-расто-питоно-силуа

а питоном-то за что назвал?

на памяти вроде было за что

если не было то извиняюсь

а еще,‌ арность операторов может быть от 1 до хз скольки,‌ думаю не менее 200

a = a ?? 2, 3;

или лучше не делать такое?

видишь тут res один,‌а принт печатает два

починил это. дело было в том что при разборе fn(x) x + 1; последний semicolon съедался в качестве просто части return ...; Ноо... парсинг тела функции не заканчивался

и стейтмент был эквивалентен вот этому (строка 12)

другими словами res = print(res tail fn(x) x + 1, res);

или по-другому. я уже запутался

если так то должен быть порядок уже справа налево но его нет

кароч,‌ вот ваши операторы

[luar] local obj = { num = 0 }; local fn +=(self, n) { self.num = self.num + n; print(self.num); }; local fn -=(self, n) { self.num = self.num - n; print(self.num); }; print("Hello World!"); obj += 7; obj -= 2; obj += 96; obj += 12083; obj -= -12.5;

Hello World! 7 5 101 12184 12196.5

that's it

Народ, команда Pop front извлекает первый элемент массива. Как этот поп на русский перевести?

Народ, команда Pop front извлекает первый элемент массива. Как этот поп на русский перевести?

эм.. вытолкнуть?

[luar] local obj = { num = 0 }; local fn +=(self, n) { self.num = self.num + n; print(self.num); }; local fn -=(self, n) { self.num = self.num - n; print(self.num); }; print("Hello World!"); obj += 7; obj -= 2; obj += 96; obj += 12083; obj -= -12.5;

да,‌ к сожалению, напрямую на переменные влиять не получится, для этого нужно уже патчить VM

чтобы для простых чисел += работал

усё,‌ я починил приоритет и теперь он равняется 1

щас будет красивый код

[luar] fn tail(l, r) r(l); local result = 2 tail fn(x) x * x tail fn(x) x * 8 tail fn(x) x + 1 tail print; [lua]

Вывод 33

Это то,‌ о чем я мечтал

я сделал этот синтаксис, и заодно операторы

Еще одна проблемка - код не генерируется,‌если просто писать вот так [luar] fn tail(l, r) r(l); (2) tail fn(x) x * x tail fn(x) x * 8 tail fn(x) x + 1 tail print; [lua]

думоем

вот унарные. но результат должен быть использован

и эти починил

[luar] local obj = {num = 0}; fn ++(self) { self.num = self.num + 1; print(self.num); }; fn --(self) { self.num = self.num - 1; print(self.num); }; obj++; obj++; obj--; [lua]

output: 1 2 2

да,‌ теперь коменты // и [//[...]//]

[luar] local prev_require = require; fn require(pkg) { local prevmode = __syntax_mode(); if (prevmode == 1) __syntax_mode(0); local stuff = prev_require(pkg); __syntax_mode(prevmode); return stuff; }; local class = require "class"; fn is(self, mt) getmetatable(self).template == mt; fn tail(l, r) r(l); fn new(T, a) !a and T() or ( {type = T, count = a} tail fn(a) { local t = {}; for i = 1, a.count do t[i] = a.type(); return t; } ); [//[ fn new(T, a) { return !a and T() or ({type = T, count = a} tail fn(a) { for k, v in pairs(a) do print(k, v); local t = {}; for i = 1, a.count do t[i] = a.type(); return t; }); } ]//] local counter = 0; local Foo = class { __init = fn(self) { self.n = counter; counter = counter + 1; } }; local foo = Foo new; local foos = Foo new 20; print(foo.n); print(foo is Foo); for k, v in pairs(foos) do print(k, v, v is Foo); [lua]

красота

всё работает

делать индексацию с нуля и массивы такого типа [foo, bar, {tab, field}, 12] ? обычные луашные таблицы так и останутся {}, и эти [] тоже будут луашными таблицами,‌ но по умолчанию начинаться с 0. И‌ можно добавить npairs() чтобы перебирать элементы в таких массивах

делать индексацию с нуля и массивы такого типа [foo, bar, {tab, field}, 12] ? обычные луашные таблицы так и останутся {}, и эти [] тоже будут луашными таблицами,‌ но по умолчанию начинаться с 0. И‌ можно добавить npairs() чтобы перебирать элементы в таких массивах

Кароч, есть прекол. Если делать массивы через [], то им можно смело добавлять методы.

Кароч, есть прекол. Если делать массивы через [], то им можно смело добавлять методы.

это намек на пихтон?

Это намек на npairs

а

ну так смотри

for k, v in foos pairs do print(k, v);

вместо for k, v in pairs(foos) do print(k, v) end