Как запустить скрипт qlua из командной строки?

Страницы: 1 2 След.
RSS
Как запустить скрипт qlua из командной строки?
 
У меня есть скрипт на питоне, который запускает lua файлы в командной строке. Но с скриптами для квика это не работает. Какие есть способы запуска скриптов для квика из командной строки?
 
Максим, Скрипт на Lua - это ИНТЕРПРЕТИРУЕМЫЙ код. Проще говоря, текст. Кто ж его интерпретировать (читать) будет? Из командной строки можно запустить разве что Квик.
 
Любой скрипт lua не проблема запустить из командной строки, используя интерпретатор lua.
Но с скриптами для Квика так не выйдет, т.к. окружение у qlua специфическое. В частности, интерпретатор, по сути, это и будет терминал.
Если только Вы не эмулировали набор методов и переменных их глобального контекста qlua.
 
Максим,
что вы хотите получить в результате запуска скриптов для квика из командной строки? какой результат выполнения этих скриптов вам требуется?
 
Я понимаю, что любой скрипт Lua можно выполнить используя родной интерпретатор Lua - lua.exe, нужную версию которого можно скачать с официального сайта. С этим всё просто и понятно. Это работает, когда мы пишем Lua программу, работающую самостоятельно(в данном случае отдельно от квика). Когда мы запускаем скрипт Lua в квике, то как я понимаю это происходит приблизительно так. Квик(info.exe наверное) загружает наш скрипт, построчно его читает, используя функции из библиотеки, например lua53.dll, выполняет прочитанные строки из нашего файла скрипта(используя pcall или что-то подобное), короче он сам интерпретирует наш скрипт построчно, используя нужную библиотеку Lua. Так же разработчики написали свою библитотеку qlua.dll, в которой реализовали все свои функции для торговли и получения информации от брокера, котировки с биржи и прочее. Так же, поскольку сам квик построчно выполняет скрипт, он чередует работу самого себя с работой по интерпретации скрипта, благодаря чему сделана возможность коллбэк функций для скрипта. Может что-то и не так понимаю. Если что-то не так - прошу разработчиков ответить так это или нет. А в связи с этим сам вопрос: есть ли возможность запустить мой скрипт qlua, используя в командной строке, что-то типа info.exe myscrypt.lua, при работающем квике и подключённом к серверу квик? Для чего это нужно? Поставил Visual Studio Code. Хочу настроить его для написания скриптов Lua. Там есть возможность установки плагина для запуска скрипта из редактора - что-то типа Code Runner. Он позволяет настроить запуск скрипта используя интерпретатор в виде программы, которая запускается в командной строке, принимая в качестве параметра запуска файл скрипта. Прошу кто знает или самих разработчиков ответить возможно ли организовать такое? Было бы очень удобно. Пишем в редакторе со всеми его возможностями. Запускаем скрипт прямо в редакторе на выполнение. Скрипт запускается через запуск интерпретатора квика, использует все возможности - функции из qlua библиотеки, скрипт делает вывод в терминал во время работы нужной информации по ходу работы скрипта. Или как-то подобное можно организовать по другому? Можно ли использовать стандартный интерпретатор lua.exe для запуска скрипта, но как тогда связать работу скрипта с билиотекой qlua.dll?. В любом случае нужен запуск скрипта из Visual Studio Code и чтобы скрипт нормально работал так как будто он работает в самом квике.
 
технически сделать так можно.
--------------------
Но поясню что не так в вашем понимании.
-------------------------
скрипт луа выполняет виртуальная машина луа ,если знаете есть виртуальная машина джава и еще куча виртуальных машин для других языков программирования.
виртуальная машина - это программная реализация некоторого вычислительного устройства.
У него своя система команд, свои регистры и свой процессор, не такой как тот, на котором исполняется эта программа.  
----------------
В программе КВИК запущена программа VMLua.
VMLua работает сама по себе, исполняя загружаемые в нее скрипты.
Т е разработчики КВИК не разрабатывали VMLua,
а взяли готовый код и запустили его внутри своей программы.
---
В нее можно грузить любой скрипт на луа и она будет его исполнять.
-------------
Чтобы передать VMLua данные из терминала QUIK, разработчики написали библиотеку QLUA на СИ и таким образом организовали обмен информацией между двумя процессами , один из которых на VMLua.
------------
Запуск скрипта для исполнения в VMLua осуществляем в соответствующем окне терминала QUIK.
==============
Ччтобы делать это автоматом надо  написать соответствующий скрипт для виртуальной машины либо для планировщика задач с использованием библиотеки функций манипуляции с экраном. В скриптах это делается хуками.  Я делал это на AutoIt.
===============
Но прикол в том, что разработчики встроили блокировку в новые версии QUIK,
которая  не позволяет работать с отладчиками.
 
Цитата
nikolz написал:
Но поясню что не так в вашем понимании.
Я конечно пока не настаиваю, но вынужден не согласиться с некоторыми Вашими объяснениями. Для начала:
1) Понятия конечно есть м/у компилируемыми и интерпретируемыми языками программирования. Грубо: компилируемые - исходный код -> asm код -> obj код -> сборка линкером -> выполняемый код(exe, dll)(процессором непосредственно в памяти с передачей на него управления). Интерпретируемые грубо: исходный код -> байт код -> выполнение в своей собственной среде байт кода.
2)
Цитата
nikolz написал:
В программе КВИК запущена программа VMLua. VMLua работает сама по себе, исполняя загружаемые в нее скрипты. Т е разработчики КВИК не разрабатывали VMLua, а взяли готовый код и запустили его внутри своей программы.
Как quik запустил VMLua? Как Вы себе это представляете?
3)
Цитата
nikolz написал:
В нее можно грузить любой скрипт на луа и она будет его исполнять.
Как Вы себе представляете как quik грузит код в "запущенную им VMLua?
4)
Цитата
nikolz написал:
Чтобы передать VMLua данные из терминала QUIK, разработчики написали библиотеку QLUA на СИ и таким образом организовали обмен информацией между двумя процессами , один из которых на VMLua.
Тут как бы да, а может и нет. Делают ли загрузку скрипта функции из qlua.ll или это делает сам info.exe или функции из других dll, имеющиеся в quik-е мне не известно, но в qlua.dll полагаю, что находятся функции для торговли и работы с брокером и для получения данных с биржи, т.е. это функции qlua, что описаны в документации quik-a. Quik не тупо передаёт скрипт на выполнение как единое целое в VM - типа загрузил, передал и всё,- скрипт работает сам по себе в среде VMLua, не так всё.
5)
Цитата
nikolz написал:
чтобы делать это автоматом надо  написать соответствующий скрипт для виртуальной машины либо для планировщика задач с использованием библиотеки функций манипуляции с экраном. В скриптах это делается хуками.  Я делал это на AutoIt.
Это не то, что хотелось бы,поскольку это всего лишь будет просто автоматизация обычного процесса пользователя по загрузке скрипта, т.е. тоже самое, что делаем руками для загрузки скрипта, но только автоматом через скрипт(AutoIt).

  А теперь попробую объяснить более подробно почему я так думаю как написал выше, а не так как Вы написали. Для этого рассмотрим как я представляю себе VMLua и как её использует quik. Но сначала посмотрим как интерпретирует Lua код обычный Lua. На оф. сайте Lua весь интерпретатор Lua - 4 файла(lua53.dll, lua53.exe, luac53.exe и wlua53.exe).
Как мы запускаем скрипт на выполнение в среде Lua? Мы запускаем lua53.exe и передаём ему в командной строке при запуске имя нашего .lua файла и видим результат его работы. Как работает Lua53.exe? Она открывает наш файл, чтобы его читать. Он его читает и разбивает на логические куски согласно синтаксису языка, проверяя при этом синтаксис - парсит, далее каждый кусок он компилирует в свой байт код(lua_load, luaL_loadstring), потом он выполняет последовательно каждый кусок(lua_pcall). Это тоже как бы грубое описание, но суть отражает, без нюансов. Т.е. lua53.exe это всего лишь загрузчик и обработчик, само выполнение реализуется функциями внутри lua53.dll. То есть что мы имеем? Мы не имеем конкретно работающую в прямом смысле слова VMLua. Мы имеем загруженную библиотеку lua53.dll, которая содержит в себе много чего из функций, некоторые из которых осуществляют компиляцию, некоторые - выполнение компилированного кода. Нет такого, что lua53.exe взял наш скрипт и просто тупо скормил его некоему работающему процессу VMLua. Хотя конечно можно было бы сказать и так, что допустим такой процесс есть как отдельный, но тогда lua53.exe грузит файл скрипта и передаёт его этому процессу, а этот процесс уже делает то, что я описал выше, но от этого суть не меняется.
  Так вот идём дальше. Как мне видится работа quik в плане обработки скриптов. У quik в рабочей папке есть библиотеки lua51-54.dll, там собственно и реализована VMLua и функции Lua. Quik грузит наш скрипт и ничего никому не скармливает в прямом смысле слова, а начинает сам выступать в качестве интерпретатора Lua скрипта по вышеописанной мной схеме, при этом он использует функционал заложенных в lua51-53.dll функций для компиляции и выполнения компилированного байт кода. Почему так? Потому как Quik помимо работы скрипта так же делает и "свою" работу и в тоже время он может "контролировать" выполнение скрипта, так как наш скрипт не выполняется отдельно сам по себе в какой-то VM, а quik выполняет его частями, тем самым quik может и "позволить" организацию коллбэк функций, отсюда кстати и многие проблемы непредвиденного характера, так как по сути скрипт не работает как непрерывно целое в некоей среде, при некоторых условиях возможно, что quik может прерывать его выполнение если "так надо", хотя main() скрипта обрабатывается в отдельном потоке quik-а, это не исключает этого. Ниже для подтверждения моих мыслей простой интерпретатор Lua, который делается элементарно, думаю как-то так работает и quik, т.е.по такому же принципу:

Листинг 25.1. Простой автономный интерпретатор Lua
#include <stdio.h>
#include <string.h>
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
int main (void) {
char buff[256];
int error;
lua_State *L = luaL_newstate(); /* открывает Lua
*/
luaL_openlibs(L); /* открывает стандартные библиотеки
*/
while (fgets(buff, sizeof(buff), stdin) != NULL) {
error = luaL_loadstring(L, buff) || lua_pcall(L, 0, 0, 0);
if (error) {
fprintf(stderr, "%s\n", lua_tostring(L, -1));
lua_pop(L, 1); /* выталкивает сообщение об ошибке из стека
*/
}
}
lua_close(L);

Поэтому хотелось бы услышать ответы разработчиков по заданным мной вопросам. Может быть я и не прав, а прав на самом деле nikolz, я не спорю, а просто хочу понять правильно ли я понимаю организацию работы скриптов в quik или нет.
 
Разработчики ПО Quik, прошу ответить.
 
Разработчики ПО Quik, прошу ответить, начиная отсюда: https://forum.quik.ru/messages/forum10/message70393/topic6175/#message70393
 
Ну вот какого  ответа вы ждёте?
Очевидно, что такой функциональности в QUIK нет.

Сделать можно , если наладить связь между процессами
а) QUIKа, с одной стороны
б) и собранным вами запускаемым exe-шикном, который будет уметь подхватывать Lua скрипты и выполнять их.

По пункту б) как пример для начала есть https://github.com/swerg/qlua-exe

Для связи между процессами есть библиотека lua_share https://quik2dde.ru/viewtopic.php?id=306
Опять же можно взять её исходники за основу.

И вот всё это скрестть и что-нибудь намутить. Если еще останется желание :)
 
Цитата
Alexander написал:
Alexander
Вы же сами написали как исполняется скрипт.
Код
luaL_openlibs(L); /* открывает стандартные библиотеки
*/
while (fgets(buff, sizeof(buff), stdin) != NULL) {
error = luaL_loadstring(L, buff) || lua_pcall(L, 0, 0, 0);
if (error) {
fprintf(stderr, "%s\n", lua_tostring(L, -1));
lua_pop(L, 1); /* выталкивает сообщение об ошибке из стека
*/
}

Я точно также запускаю свои скрипты внутри КВИКА в потоках из пула.
Т е запускаю сколько мне надо новых VMLua внутри КВИКА и КВИК ничего в них не контролирует.
более того, можно вообще запустить вне квика VMLua и в нем скрипт чего-угодно, а необходимые данные передавать из квика с помощью библиотеки QLUA, которая собственно и сделана для передачи данных из терминала в скрипт луа.
-----------------------
VMLua - это программа и она запускается вызовом lua_pcall, в которой вызывается
собственно VMLua  - эта функция  Вот ее тест из sorce code Lua 5.4
Код
void luaV_execute (lua_State *L, CallInfo *ci) {
  LClosure *cl;
  TValue *k;
  StkId base;
  const Instruction *pc;
  int trap;
#if LUA_USE_JUMPTABLE
#include "ljumptab.h"
#endif
 startfunc:
  trap = L->hookmask;
 returning:  /* trap already set */
  cl = clLvalue(s2v(ci->func.p));
  k = cl->p->k;
  pc = ci->u.l.savedpc;
  if (l_unlikely(trap)) {
    if (pc == cl->p->code) {  /* first instruction (not resuming)? */
      if (cl->p->is_vararg)
        trap = 0;  /* hooks will start after VARARGPREP instruction */
      else  /* check 'call' hook */
        luaD_hookcall(L, ci);
    }
    ci->u.l.trap = 1;  /* assume trap is on, for now */
  }
  base = ci->func.p + 1;
  /* main loop of interpreter */
  for (;;) {
    Instruction i;  /* instruction being executed */
    vmfetch();
    #if 0
      /* low-level line tracing for debugging Lua */
      printf("line: %d\n", luaG_getfuncline(cl->p, pcRel(pc, cl->p)));
    #endif
    lua_assert(base == ci->func.p + 1);
    lua_assert(base <= L->top.p && L->top.p <= L->stack_last.p);
    /* invalidate top for instructions not expecting it */
    lua_assert(isIT(i) || (cast_void(L->top.p = base), 1));
    vmdispatch (GET_OPCODE(i)) {
      vmcase(OP_MOVE) {
        StkId ra = RA(i);
        setobjs2s(L, ra, RB(i));
        vmbreak;
      }
      vmcase(OP_LOADI) {
        StkId ra = RA(i);
        lua_Integer b = GETARG_sBx(i);
        setivalue(s2v(ra), b);
        vmbreak;
      }
      vmcase(OP_LOADF) {
        StkId ra = RA(i);
        int b = GETARG_sBx(i);
        setfltvalue(s2v(ra), cast_num(b));
        vmbreak;
      }
      vmcase(OP_LOADK) {
        StkId ra = RA(i);
        TValue *rb = k + GETARG_Bx(i);
        setobj2s(L, ra, rb);
        vmbreak;
      }
      vmcase(OP_LOADKX) {
        StkId ra = RA(i);
        TValue *rb;
        rb = k + GETARG_Ax(*pc); pc++;
        setobj2s(L, ra, rb);
        vmbreak;
      }
      vmcase(OP_LOADFALSE) {
        StkId ra = RA(i);
        setbfvalue(s2v(ra));
        vmbreak;
      }
      vmcase(OP_LFALSESKIP) {
        StkId ra = RA(i);
        setbfvalue(s2v(ra));
        pc++;  /* skip next instruction */
        vmbreak;
      }
      vmcase(OP_LOADTRUE) {
        StkId ra = RA(i);
        setbtvalue(s2v(ra));
        vmbreak;
      }
      vmcase(OP_LOADNIL) {
        StkId ra = RA(i);
        int b = GETARG_B(i);
        do {
          setnilvalue(s2v(ra++));
        } while (b--);
        vmbreak;
      }
      vmcase(OP_GETUPVAL) {
        StkId ra = RA(i);
        int b = GETARG_B(i);
        setobj2s(L, ra, cl->upvals[b]->v.p);
        vmbreak;
      }
      vmcase(OP_SETUPVAL) {
        StkId ra = RA(i);
        UpVal *uv = cl->upvals[GETARG_B(i)];
        setobj(L, uv->v.p, s2v(ra));
        luaC_barrier(L, uv, s2v(ra));
        vmbreak;
      }
      vmcase(OP_GETTABUP) {
        StkId ra = RA(i);
        const TValue *slot;
        TValue *upval = cl->upvals[GETARG_B(i)]->v.p;
        TValue *rc = KC(i);
        TString *key = tsvalue(rc);  /* key must be a string */
        if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) {
          setobj2s(L, ra, slot);
        }
        else
          Protect(luaV_finishget(L, upval, rc, ra, slot));
        vmbreak;
      }
      vmcase(OP_GETTABLE) {
        StkId ra = RA(i);
        const TValue *slot;
        TValue *rb = vRB(i);
        TValue *rc = vRC(i);
        lua_Unsigned n;
        if (ttisinteger(rc)  /* fast track for integers? */
            ? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot))
            : luaV_fastget(L, rb, rc, slot, luaH_get)) {
          setobj2s(L, ra, slot);
        }
        else
          Protect(luaV_finishget(L, rb, rc, ra, slot));
        vmbreak;
      }
      vmcase(OP_GETI) {
        StkId ra = RA(i);
        const TValue *slot;
        TValue *rb = vRB(i);
        int c = GETARG_C(i);
        if (luaV_fastgeti(L, rb, c, slot)) {
          setobj2s(L, ra, slot);
        }
        else {
          TValue key;
          setivalue(&key, c);
          Protect(luaV_finishget(L, rb, &key, ra, slot));
        }
        vmbreak;
      }
      vmcase(OP_GETFIELD) {
        StkId ra = RA(i);
        const TValue *slot;
        TValue *rb = vRB(i);
        TValue *rc = KC(i);
        TString *key = tsvalue(rc);  /* key must be a string */
        if (luaV_fastget(L, rb, key, slot, luaH_getshortstr)) {
          setobj2s(L, ra, slot);
        }
        else
          Protect(luaV_finishget(L, rb, rc, ra, slot));
        vmbreak;
      }
      vmcase(OP_SETTABUP) {
        const TValue *slot;
        TValue *upval = cl->upvals[GETARG_A(i)]->v.p;
        TValue *rb = KB(i);
        TValue *rc = RKC(i);
        TString *key = tsvalue(rb);  /* key must be a string */
        if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) {
          luaV_finishfastset(L, upval, slot, rc);
        }
        else
          Protect(luaV_finishset(L, upval, rb, rc, slot));
        vmbreak;
      }
      vmcase(OP_SETTABLE) {
        StkId ra = RA(i);
        const TValue *slot;
        TValue *rb = vRB(i);  /* key (table is in 'ra') */
        TValue *rc = RKC(i);  /* value */
        lua_Unsigned n;
        if (ttisinteger(rb)  /* fast track for integers? */
            ? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot))
            : luaV_fastget(L, s2v(ra), rb, slot, luaH_get)) {
          luaV_finishfastset(L, s2v(ra), slot, rc);
        }
        else
          Protect(luaV_finishset(L, s2v(ra), rb, rc, slot));
        vmbreak;
      }
      vmcase(OP_SETI) {
        StkId ra = RA(i);
        const TValue *slot;
        int c = GETARG_B(i);
        TValue *rc = RKC(i);
        if (luaV_fastgeti(L, s2v(ra), c, slot)) {
          luaV_finishfastset(L, s2v(ra), slot, rc);
        }
        else {
          TValue key;
          setivalue(&key, c);
          Protect(luaV_finishset(L, s2v(ra), &key, rc, slot));
        }
        vmbreak;
      }
      vmcase(OP_SETFIELD) {
        StkId ra = RA(i);
        const TValue *slot;
        TValue *rb = KB(i);
        TValue *rc = RKC(i);
        TString *key = tsvalue(rb);  /* key must be a string */
        if (luaV_fastget(L, s2v(ra), key, slot, luaH_getshortstr)) {
          luaV_finishfastset(L, s2v(ra), slot, rc);
        }
        else
          Protect(luaV_finishset(L, s2v(ra), rb, rc, slot));
        vmbreak;
      }
      vmcase(OP_NEWTABLE) {
        StkId ra = RA(i);
        int b = GETARG_B(i);  /* log2(hash size) + 1 */
        int c = GETARG_C(i);  /* array size */
        Table *t;
        if (b > 0)
          b = 1 << (b - 1);  /* size is 2^(b - 1) */
        lua_assert((!TESTARG_k(i)) == (GETARG_Ax(*pc) == 0));
        if (TESTARG_k(i))  /* non-zero extra argument? */
          c += GETARG_Ax(*pc) * (MAXARG_C + 1);  /* add it to size */
        pc++;  /* skip extra argument */
        L->top.p = ra + 1;  /* correct top in case of emergency GC */
        t = luaH_new(L);  /* memory allocation */
        sethvalue2s(L, ra, t);
        if (b != 0 || c != 0)
          luaH_resize(L, t, c, b);  /* idem */
        checkGC(L, ra + 1);
        vmbreak;
      }
      vmcase(OP_SELF) {
        StkId ra = RA(i);
        const TValue *slot;
        TValue *rb = vRB(i);
        TValue *rc = RKC(i);
        TString *key = tsvalue(rc);  /* key must be a string */
        setobj2s(L, ra + 1, rb);
        if (luaV_fastget(L, rb, key, slot, luaH_getstr)) {
          setobj2s(L, ra, slot);
        }
        else
          Protect(luaV_finishget(L, rb, rc, ra, slot));
        vmbreak;
      }
      vmcase(OP_ADDI) {
        op_arithI(L, l_addi, luai_numadd);
        vmbreak;
      }
      vmcase(OP_ADDK) {
        op_arithK(L, l_addi, luai_numadd);
        vmbreak;
      }
      vmcase(OP_SUBK) {
        op_arithK(L, l_subi, luai_numsub);
        vmbreak;
      }
      vmcase(OP_MULK) {
        op_arithK(L, l_muli, luai_nummul);
        vmbreak;
      }
      vmcase(OP_MODK) {
        savestate(L, ci);  /* in case of division by 0 */
        op_arithK(L, luaV_mod, luaV_modf);
        vmbreak;
      }
      vmcase(OP_POWK) {
        op_arithfK(L, luai_numpow);
        vmbreak;
      }
      vmcase(OP_DIVK) {
        op_arithfK(L, luai_numdiv);
        vmbreak;
      }
      vmcase(OP_IDIVK) {
        savestate(L, ci);  /* in case of division by 0 */
        op_arithK(L, luaV_idiv, luai_numidiv);
        vmbreak;
      }
      vmcase(OP_BANDK) {
        op_bitwiseK(L, l_band);
        vmbreak;
      }
      vmcase(OP_BORK) {
        op_bitwiseK(L, l_bor);
        vmbreak;
      }
      vmcase(OP_BXORK) {
        op_bitwiseK(L, l_bxor);
        vmbreak;
      }
      vmcase(OP_SHRI) {
        StkId ra = RA(i);
        TValue *rb = vRB(i);
        int ic = GETARG_sC(i);
        lua_Integer ib;
        if (tointegerns(rb, &ib)) {
          pc++; setivalue(s2v(ra), luaV_shiftl(ib, -ic));
        }
        vmbreak;
      }
      vmcase(OP_SHLI) {
        StkId ra = RA(i);
        TValue *rb = vRB(i);
        int ic = GETARG_sC(i);
        lua_Integer ib;
        if (tointegerns(rb, &ib)) {
          pc++; setivalue(s2v(ra), luaV_shiftl(ic, ib));
        }
        vmbreak;
      }
      vmcase(OP_ADD) {
        op_arith(L, l_addi, luai_numadd);
        vmbreak;
      }
      vmcase(OP_SUB) {
        op_arith(L, l_subi, luai_numsub);
        vmbreak;
      }
      vmcase(OP_MUL) {
        op_arith(L, l_muli, luai_nummul);
        vmbreak;
      }
      vmcase(OP_MOD) {
        savestate(L, ci);  /* in case of division by 0 */
        op_arith(L, luaV_mod, luaV_modf);
        vmbreak;
      }
      vmcase(OP_POW) {
        op_arithf(L, luai_numpow);
        vmbreak;
      }
      vmcase(OP_DIV) {  /* float division (always with floats) */
        op_arithf(L, luai_numdiv);
        vmbreak;
      }
      vmcase(OP_IDIV) {  /* floor division */
        savestate(L, ci);  /* in case of division by 0 */
        op_arith(L, luaV_idiv, luai_numidiv);
        vmbreak;
      }
      vmcase(OP_BAND) {
        op_bitwise(L, l_band);
        vmbreak;
      }
      vmcase(OP_BOR) {
        op_bitwise(L, l_bor);
        vmbreak;
      }
      vmcase(OP_BXOR) {
        op_bitwise(L, l_bxor);
        vmbreak;
      }
      vmcase(OP_SHR) {
        op_bitwise(L, luaV_shiftr);
        vmbreak;
      }
      vmcase(OP_SHL) {
        op_bitwise(L, luaV_shiftl);
        vmbreak;
      }
      vmcase(OP_MMBIN) {
        StkId ra = RA(i);
        Instruction pi = *(pc - 2);  /* original arith. expression */
        TValue *rb = vRB(i);
        TMS tm = (TMS)GETARG_C(i);
        StkId result = RA(pi);
        lua_assert(OP_ADD <= GET_OPCODE(pi) && GET_OPCODE(pi) <= OP_SHR);
        Protect(luaT_trybinTM(L, s2v(ra), rb, result, tm));
        vmbreak;
      }
      vmcase(OP_MMBINI) {
        StkId ra = RA(i);
        Instruction pi = *(pc - 2);  /* original arith. expression */
        int imm = GETARG_sB(i);
        TMS tm = (TMS)GETARG_C(i);
        int flip = GETARG_k(i);
        StkId result = RA(pi);
        Protect(luaT_trybiniTM(L, s2v(ra), imm, flip, result, tm));
        vmbreak;
      }
      vmcase(OP_MMBINK) {
        StkId ra = RA(i);
        Instruction pi = *(pc - 2);  /* original arith. expression */
        TValue *imm = KB(i);
        TMS tm = (TMS)GETARG_C(i);
        int flip = GETARG_k(i);
        StkId result = RA(pi);
        Protect(luaT_trybinassocTM(L, s2v(ra), imm, flip, result, tm));
        vmbreak;
      }
      vmcase(OP_UNM) {
        StkId ra = RA(i);
        TValue *rb = vRB(i);
        lua_Number nb;
        if (ttisinteger(rb)) {
          lua_Integer ib = ivalue(rb);
          setivalue(s2v(ra), intop(-, 0, ib));
        }
        else if (tonumberns(rb, nb)) {
          setfltvalue(s2v(ra), luai_numunm(L, nb));
        }
        else
          Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM));
        vmbreak;
      }
      vmcase(OP_BNOT) {
        StkId ra = RA(i);
        TValue *rb = vRB(i);
        lua_Integer ib;
        if (tointegerns(rb, &ib)) {
          setivalue(s2v(ra), intop(^, ~l_castS2U(0), ib));
        }
        else
          Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT));
        vmbreak;
      }
      vmcase(OP_NOT) {
        StkId ra = RA(i);
        TValue *rb = vRB(i);
        if (l_isfalse(rb))
          setbtvalue(s2v(ra));
        else
          setbfvalue(s2v(ra));
        vmbreak;
      }
      vmcase(OP_LEN) {
        StkId ra = RA(i);
        Protect(luaV_objlen(L, ra, vRB(i)));
        vmbreak;
      }
      vmcase(OP_CONCAT) {
        StkId ra = RA(i);
        int n = GETARG_B(i);  /* number of elements to concatenate */
        L->top.p = ra + n;  /* mark the end of concat operands */
        ProtectNT(luaV_concat(L, n));
        checkGC(L, L->top.p); /* 'luaV_concat' ensures correct top */
        vmbreak;
      }
      vmcase(OP_CLOSE) {
        StkId ra = RA(i);
        Protect(luaF_close(L, ra, LUA_OK, 1));
        vmbreak;
      }
      vmcase(OP_TBC) {
        StkId ra = RA(i);
        /* create new to-be-closed upvalue */
        halfProtect(luaF_newtbcupval(L, ra));
        vmbreak;
      }
      vmcase(OP_JMP) {
        dojump(ci, i, 0);
        vmbreak;
      }
      vmcase(OP_EQ) {
        StkId ra = RA(i);
        int cond;
        TValue *rb = vRB(i);
        Protect(cond = luaV_equalobj(L, s2v(ra), rb));
        docondjump();
        vmbreak;
      }
      vmcase(OP_LT) {
        op_order(L, l_lti, LTnum, lessthanothers);
        vmbreak;
      }
      vmcase(OP_LE) {
        op_order(L, l_lei, LEnum, lessequalothers);
        vmbreak;
      }
      vmcase(OP_EQK) {
        StkId ra = RA(i);
        TValue *rb = KB(i);
        /* basic types do not use '__eq'; we can use raw equality */
        int cond = luaV_rawequalobj(s2v(ra), rb);
        docondjump();
        vmbreak;
      }
      vmcase(OP_EQI) {
        StkId ra = RA(i);
        int cond;
        int im = GETARG_sB(i);
        if (ttisinteger(s2v(ra)))
          cond = (ivalue(s2v(ra)) == im);
        else if (ttisfloat(s2v(ra)))
          cond = luai_numeq(fltvalue(s2v(ra)), cast_num(im));
        else
          cond = 0;  /* other types cannot be equal to a number */
        docondjump();
        vmbreak;
      }
      vmcase(OP_LTI) {
        op_orderI(L, l_lti, luai_numlt, 0, TM_LT);
        vmbreak;
      }
      vmcase(OP_LEI) {
        op_orderI(L, l_lei, luai_numle, 0, TM_LE);
        vmbreak;
      }
      vmcase(OP_GTI) {
        op_orderI(L, l_gti, luai_numgt, 1, TM_LT);
        vmbreak;
      }
      vmcase(OP_GEI) {
        op_orderI(L, l_gei, luai_numge, 1, TM_LE);
        vmbreak;
      }
      vmcase(OP_TEST) {
        StkId ra = RA(i);
        int cond = !l_isfalse(s2v(ra));
        docondjump();
        vmbreak;
      }
      vmcase(OP_TESTSET) {
        StkId ra = RA(i);
        TValue *rb = vRB(i);
        if (l_isfalse(rb) == GETARG_k(i))
          pc++;
        else {
          setobj2s(L, ra, rb);
          donextjump(ci);
        }
        vmbreak;
      }
      vmcase(OP_CALL) {
        StkId ra = RA(i);
        CallInfo *newci;
        int b = GETARG_B(i);
        int nresults = GETARG_C(i) - 1;
        if (b != 0)  /* fixed number of arguments? */
          L->top.p = ra + b;  /* top signals number of arguments */
        /* else previous instruction set top */
        savepc(L);  /* in case of errors */
        if ((newci = luaD_precall(L, ra, nresults)) == NULL)
          updatetrap(ci);  /* C call; nothing else to be done */
        else {  /* Lua call: run function in this same C frame */
          ci = newci;
          goto startfunc;
        }
        vmbreak;
      }
      vmcase(OP_TAILCALL) {
        StkId ra = RA(i);
        int b = GETARG_B(i);  /* number of arguments + 1 (function) */
        int n;  /* number of results when calling a C function */
        int nparams1 = GETARG_C(i);
        /* delta is virtual 'func' - real 'func' (vararg functions) */
        int delta = (nparams1) ? ci->u.l.nextraargs + nparams1 : 0;
        if (b != 0)
          L->top.p = ra + b;
        else  /* previous instruction set top */
          b = cast_int(L->top.p - ra);
        savepc(ci);  /* several calls here can raise errors */
        if (TESTARG_k(i)) {
          luaF_closeupval(L, base);  /* close upvalues from current call */
          lua_assert(L->tbclist.p < base);  /* no pending tbc variables */
          lua_assert(base == ci->func.p + 1);
        }
        if ((n = luaD_pretailcall(L, ci, ra, b, delta)) < 0)  /* Lua function? */
          goto startfunc;  /* execute the callee */
        else {  /* C function? */
          ci->func.p -= delta;  /* restore 'func' (if vararg) */
          luaD_poscall(L, ci, n);  /* finish caller */
          updatetrap(ci);  /* 'luaD_poscall' can change hooks */
          goto ret;  /* caller returns after the tail call */
        }
      }
      vmcase(OP_RETURN) {
        StkId ra = RA(i);
        int n = GETARG_B(i) - 1;  /* number of results */
        int nparams1 = GETARG_C(i);
        if (n < 0)  /* not fixed? */
          n = cast_int(L->top.p - ra);  /* get what is available */
        savepc(ci);
        if (TESTARG_k(i)) {  /* may there be open upvalues? */
          ci->u2.nres = n;  /* save number of returns */
          if (L->top.p < ci->top.p)
            L->top.p = ci->top.p;
          luaF_close(L, base, CLOSEKTOP, 1);
          updatetrap(ci);
          updatestack(ci);
        }
        if (nparams1)  /* vararg function? */
          ci->func.p -= ci->u.l.nextraargs + nparams1;
        L->top.p = ra + n;  /* set call for 'luaD_poscall' */
        luaD_poscall(L, ci, n);
        updatetrap(ci);  /* 'luaD_poscall' can change hooks */
        goto ret;
      }
      vmcase(OP_RETURN0) {
        if (l_unlikely(L->hookmask)) {
          StkId ra = RA(i);
          L->top.p = ra;
          savepc(ci);
          luaD_poscall(L, ci, 0);  /* no hurry... */
          trap = 1;
        }
        else {  /* do the 'poscall' here */
          int nres;
          L->ci = ci->previous;  /* back to caller */
          L->top.p = base - 1;
          for (nres = ci->nresults; l_unlikely(nres > 0); nres--)
            setnilvalue(s2v(L->top.p++));  /* all results are nil */
        }
        goto ret;
      }
      vmcase(OP_RETURN1) {
        if (l_unlikely(L->hookmask)) {
          StkId ra = RA(i);
          L->top.p = ra + 1;
          savepc(ci);
          luaD_poscall(L, ci, 1);  /* no hurry... */
          trap = 1;
        }
        else {  /* do the 'poscall' here */
          int nres = ci->nresults;
          L->ci = ci->previous;  /* back to caller */
          if (nres == 0)
            L->top.p = base - 1;  /* asked for no results */
          else {
            StkId ra = RA(i);
            setobjs2s(L, base - 1, ra);  /* at least this result */
            L->top.p = base;
            for (; l_unlikely(nres > 1); nres--)
              setnilvalue(s2v(L->top.p++));  /* complete missing results */
          }
        }
       ret:  /* return from a Lua function */
        if (ci->callstatus & CIST_FRESH)
          return;  /* end this frame */
        else {
          ci = ci->previous;
          goto returning;  /* continue running caller in this frame */
        }
      }
      vmcase(OP_FORLOOP) {
        StkId ra = RA(i);
        if (ttisinteger(s2v(ra + 2))) {  /* integer loop? */
          lua_Unsigned count = l_castS2U(ivalue(s2v(ra + 1)));
          if (count > 0) {  /* still more iterations? */
            lua_Integer step = ivalue(s2v(ra + 2));
            lua_Integer idx = ivalue(s2v(ra));  /* internal index */
            chgivalue(s2v(ra + 1), count - 1);  /* update counter */
            idx = intop(+, idx, step);  /* add step to index */
            chgivalue(s2v(ra), idx);  /* update internal index */
            setivalue(s2v(ra + 3), idx);  /* and control variable */
            pc -= GETARG_Bx(i);  /* jump back */
          }
        }
        else if (floatforloop(ra))  /* float loop */
          pc -= GETARG_Bx(i);  /* jump back */
        updatetrap(ci);  /* allows a signal to break the loop */
        vmbreak;
      }
      vmcase(OP_FORPREP) {
        StkId ra = RA(i);
        savestate(L, ci);  /* in case of errors */
        if (forprep(L, ra))
          pc += GETARG_Bx(i) + 1;  /* skip the loop */
        vmbreak;
      }
      vmcase(OP_TFORPREP) {
       StkId ra = RA(i);
        /* create to-be-closed upvalue (if needed) */
        halfProtect(luaF_newtbcupval(L, ra + 3));
        pc += GETARG_Bx(i);
        i = *(pc++);  /* go to next instruction */
        lua_assert(GET_OPCODE(i) == OP_TFORCALL && ra == RA(i));
        goto l_tforcall;
      }
      vmcase(OP_TFORCALL) {
       l_tforcall: {
        StkId ra = RA(i);
        /* 'ra' has the iterator function, 'ra + 1' has the state,
           'ra + 2' has the control variable, and 'ra + 3' has the
           to-be-closed variable. The call will use the stack after
           these values (starting at 'ra + 4')
        */
        /* push function, state, and control variable */
        memcpy(ra + 4, ra, 3 * sizeof(*ra));
        L->top.p = ra + 4 + 3;
        ProtectNT(luaD_call(L, ra + 4, GETARG_C(i)));  /* do the call */
        updatestack(ci);  /* stack may have changed */
        i = *(pc++);  /* go to next instruction */
        lua_assert(GET_OPCODE(i) == OP_TFORLOOP && ra == RA(i));
        goto l_tforloop;
      }}
      vmcase(OP_TFORLOOP) {
       l_tforloop: {
        StkId ra = RA(i);
        if (!ttisnil(s2v(ra + 4))) {  /* continue loop? */
          setobjs2s(L, ra + 2, ra + 4);  /* save control variable */
          pc -= GETARG_Bx(i);  /* jump back */
        }
        vmbreak;
      }}
      vmcase(OP_SETLIST) {
        StkId ra = RA(i);
        int n = GETARG_B(i);
        unsigned int last = GETARG_C(i);
        Table *h = hvalue(s2v(ra));
        if (n == 0)
          n = cast_int(L->top.p - ra) - 1;  /* get up to the top */
        else
          L->top.p = ci->top.p;  /* correct top in case of emergency GC */
        last += n;
        if (TESTARG_k(i)) {
          last += GETARG_Ax(*pc) * (MAXARG_C + 1);
          pc++;
        }
        if (last > luaH_realasize(h))  /* needs more space? */
          luaH_resizearray(L, h, last);  /* preallocate it at once */
        for (; n > 0; n--) {
          TValue *val = s2v(ra + n);
          setobj2t(L, &h->array[last - 1], val);
          last--;
          luaC_barrierback(L, obj2gco(h), val);
        }
        vmbreak;
      }
      vmcase(OP_CLOSURE) {
        StkId ra = RA(i);
        Proto *p = cl->p->p[GETARG_Bx(i)];
        halfProtect(pushclosure(L, p, cl->upvals, base, ra));
        checkGC(L, ra + 1);
        vmbreak;
      }
      vmcase(OP_VARARG) {
        StkId ra = RA(i);
        int n = GETARG_C(i) - 1;  /* required results */
        Protect(luaT_getvarargs(L, ci, ra, n));
        vmbreak;
      }
      vmcase(OP_VARARGPREP) {
        ProtectNT(luaT_adjustvarargs(L, GETARG_A(i), ci, cl->p));
        if (l_unlikely(trap)) {  /* previous "Protect" updated trap */
          luaD_hookcall(L, ci);
          L->oldpc = 1;  /* next opcode will be seen as a "new" line */
        }
        updatebase(ci);  /* function has new base after adjustment */
        vmbreak;
      }
      vmcase(OP_EXTRAARG) {
        lua_assert(0);
        vmbreak;
      }
    }
  }
}

 
и еще...
скрипт исполняется в VMLua ,которую запускает КВИК, потом  в отдельном потоке запускает в дочерняя VMLua  и в ней Ваша функцию main
в которой крутится бесконечный цикл.
Вот этот цикл бесконечно и исполняет приведенная выше функция VMLua.
терминал никак не контролирует эту функции.
В потоке терминала сделана синхронизация обращения к глобальному стеку VMLua
Вы в своем main скрипте в вызываете функции из QLUA для обмена данными с основным потоком QUIK.
Так все и работает.  
 
Цитата
nikolz написал:
void luaV_execute (lua_State *L, CallInfo *ci) {
...............
   Зачем вы постоянно гадите на форуме чужими длинными текстами?
   Вы испытываете терпение поддержки QUIK?
   Вы думаете, что чем длиннее ваши комментарии, тем умнее выглядите?
Помните, что говорил А.П. Чехов?:"Краткость, сестра таланта" :smile: . И куда вы относитесь по этой классификации?
 
Цитата
TGB написал:
Цитата
nikolz написал:
void luaV_execute (lua_State *L, CallInfo *ci) {
...............
    Зачем вы постоянно гадите на форуме чужими длинными текстами?
   Вы испытываете терпение поддержки QUIK?
   Вы думаете, что чем длиннее ваши комментарии, тем умнее выглядите?
Помните, что говорил А.П. Чехов?:"Краткость, сестра таланта" :: . И куда вы относитесь по этой классификации?
Если не понимаете, то не читайте. Классификатор Вы наш.
 
nikolz, Вас, лапуль, можно не читайте просто увидев Ваш ник. И понимать тут нечего: тупое распальцованное ничтожество пыжится изобразить из себя что-то состоятельное, засирая все ветки подряд своими тупыми комментами. Тегом "код" не пользуется, поскольку в этом случае львиную долю вываливаемого говна сам браузер спрячет.
 
Цитата
Владимир написал:
Если не понимаете, то не читайте. Классификатор Вы наш.
  Это трудно назвать ответом на заданные вопросы. И, похоже, вы не понимаете деструктивность своего поведения.
   Хотя, наверное, вам понять трудно, попытаюсь объяснить деструктивность вашего поведения.
1. Вы издеваетесь над читателями, так как прежде чем что-то прочесть, им приходится пролистывать ваш спам.
2. Вы, похоже, не способны упустить халявную возможность писать длинные комментарии и скоро переполните базу форума :smile: .
3. Работая прокладкой между комментариями, вы ухудшаете свой имидж.
 
В моем предыдущем комментарии ошибка. Должно быть:
nikolz написал:
 
Цитата
nikolz написал:
Я точно также запускаю свои скрипты внутри КВИКА в потоках из пула.Т е запускаю сколько мне надо новых VMLua внутри КВИКА и КВИК ничего в них не контролирует.более того, можно вообще запустить вне квика VMLua и в нем скрипт чего-угодно, а необходимые данные передавать из квика с помощью библиотеки QLUA, которая собственно и сделана для передачи данных из терминала в скрипт луа.
Что так Вы запускаете свои скрипты КВИКА внутри пула своих потоков вы только сейчас написали, до этого Вы писали, что виртуальная машина КВИКА работает сама по себе и ей просто достаточно "скормить" скрипт и он будет ей исполнен. Из Вашего объяснения вывод был получен такой, что эта виртуальная машина это самостоятельная единица самого некоего Lua процесса, который работает сам по себе независимо от КВИКА, теперь выясняется, что так и есть как я писал, что КВИК таки сам интерпретирует скрипты, и Вы пишете, что делаете тоже самое. Так зачем тогда писали в духе, что типа не КВИК интерпретатор?
Далее, да конечно можно запустить сколь угодно таких VMLua вне КВИКА. Передавать данные из КВИКА им с помощью библиотеки QLUA, что тут имеется ввиду?  Каким именно образом? Какие именно функции QLUA Вы имеете в виду? Так то, я могу и не Lua скрипты запускать, а процессы на C++, например написанные и принимать данные от КВИКА любым доступным способом Windows.
 
В сообщении выше надо читать в начале НЕ "Вы писали, что виртуальная машина КВИКА работает сама по себе и ей просто достаточно "скормить" скрипт и он будет ей исполнен", а "Вы писали, что виртуальная машина Lua работает сама по себе и ей просто достаточно "скормить" скрипт и он будет ей исполнен"
 
Цитата
swerg написал:
Сделать можно , если наладить связь между процессами а) QUIKа, с одной стороны б) и собранным вами запускаемым exe-шикном, который будет уметь подхватывать Lua скрипты и выполнять их.
Наладить связь между моим exe-шником и скриптом КВИКА конечно можно. Тут думаю проблем нет никаких. Способов достаточно. Тут вообще если такой подход использовать, то по сути этот Lua практически и не нужен. Достаточно всё, что надо писать на C++(dll, exe), а скрипт внутри Lua использовать чисто для связи с (dll, exe) как транспорт, ну транзакции естественно через QLua. Подхватывать скрипты, и выполнять их. Выполнять можно. Что значит подхватывать? Где? Или откуда? Что имелось ввиду?
 
Цитата
swerg написал:
По пункту б) как пример для начала есть  https://github.com/swerg/qlua-exe Для связи между процессами есть библиотека lua_share  https://quik2dde.ru/viewtopic.php?id=306 Опять же можно взять её исходники за основу.
Это пока не смотрел. Посмотрю как время будет, отпишу.
 
Пока ясно, что родной интерпретатор lua53.exe с сайта lua.org не катит. Он сам интерпретатор, использует lua53.dll, и квик интерпретатор, который тоже использует lua53dll. Но квик подгружает свою qlua.dll и наш скрипт использует её функции внутри себя, когда квик интерпретирует наш скрипт. А если я извне запущу через lua53.dll свой квиковский скрипт и подключу квиковскую qlua.dll? Чтобы использовать её функции. У меня будет окружении QLUA? Ну там _G с её элементами? Может так можно из вне запустить свой скрипт? Ну для начала скажем без коллбэков к примеру хотя бы. Так как они наверняка не будут в таком случае работать. Квик их обрабатывает сам при загрузке скрипта.
 
Цитата
nikolz написал:
Я точно также запускаю свои скрипты внутри КВИКА в потоках из пула.Т е запускаю сколько мне надо новых VMLua внутри КВИКА и КВИК ничего в них не контролирует.
Можете по пунктам расписать что Вы тут конкретно имели ввиду. Что за пул потоков? Кто его создаёт? Скрипт внутри квика, библиотека dll? Ваш код на C++ интерпретирует Ваши же скрипты?
 
Цитата
nikolz написал:
VMLua - это программа и она запускается вызовом lua_pcall, в которой вызываетсясобственно VMLua  - эта функция  Вот ее тест из sorce code Lua 5.4
Ну тут всё правильно написали про VMLua, что она именно ЗАПУСКАЕТСЯ, а ранее писали, что VMLua РАБОТАЕТ как самостоятельная единица.
 
Цитата
nikolz написал:
Т е запускаю сколько мне надо новых VMLua внутри КВИКА и КВИК ничего в них не контролирует.
И тут даже вообще не понятно зачем запускать сколько надо новых VMLua внутри КВИКА если сам квик интерпретирует скрипт уже и он может их(скриптов) интерпретировать сколько угодно.
 
Цитата
nikolz написал:
VMLua - это программа и она запускается вызовом lua_pcall, в которой вызывается
Где в этой функции вызов lua_pcall?
 
Цитата
nikolz написал:
и еще...
скрипт исполняется в VMLua ,которую запускает КВИК, потом  в отдельном потоке запускает в дочерняя VMLua  и в ней Ваша функцию main
в которой крутится бесконечный цикл.
Вот этот цикл бесконечно и исполняет приведенная выше функция VMLua.
терминал никак не контролирует эту функции.
В потоке терминала сделана синхронизация обращения к глобальному стеку VMLua
Вы в своем main скрипте в вызываете функции из QLUA для обмена данными с основным потоком QUIK.
Так все и работает.  
Тут согласен. Вот и хотелось от разработчиков услышать нечто подобное. Может есть нюансы. Хотя в принципе как-то так это и должно быть. Но разрабы упорно молчат.
 
Тут вот, что хотелось попробовать. Запускаем скрипт QLUA из вне через lua53.exe. В скрипте подключаем qlua.dll. При работающем скрипте она может быть уже загружена и поток квика её использует. Да, пространства потоков разные у lua53.exe и у квика будут. Но функции qlua будут иметь доступ ко всем данным(таблицы например) потока квика если их умудриться вызвать. Чтобы их вызывать например из exe, dll, нам нужны заголовки с объявлениями. Можно ли их получить? А чтобы их вызывать из скрипта, нужно перменным скрипта задать адреса этих функций, как окружение, которое строит квик в виде _G. ... Как организовать то или другое? Или при загрузке qlua.dll уже будет окружение _G? И достаточно просто extern тип _G? Но опять же нужен заголовок с описание типа того же _G. Попробую потом посмотреть qlua.dll на предмет экспорта, и что там с символами. У квика вообще код закрытый? Они предоставляют lib файлы? Заголовки?
 
Цитата
Alexander написал:
Цитата
nikolz написал:
VMLua - это программа и она запускается вызовом lua_pcall, в которой вызываетсясобственно VMLua  - эта функция  Вот ее тест из sorce code Lua 5.4
Ну тут всё правильно написали про VMLua, что она именно ЗАПУСКАЕТСЯ, а ранее писали, что VMLua РАБОТАЕТ как самостоятельная единица.
Любая программа сначала запускается, а потом работает как самостоятельная единица. Поэтому я и написал - запускается и работает.  
 
Цитата
Alexander написал:
Тут вот, что хотелось попробовать. Запускаем скрипт QLUA из вне через lua53.exe. В скрипте подключаем qlua.dll. При работающем скрипте она может быть уже загружена и поток квика её использует. Да, пространства потоков разные у lua53.exe и у квика будут. Но функции qlua будут иметь доступ ко всем данным(таблицы например) потока квика если их умудриться вызвать. Чтобы их вызывать например из exe, dll, нам нужны заголовки с объявлениями. Можно ли их получить? А чтобы их вызывать из скрипта, нужно перменным скрипта задать адреса этих функций, как окружение, которое строит квик в виде _G. ... Как организовать то или другое? Или при загрузке qlua.dll уже будет окружение _G? И достаточно просто extern тип _G? Но опять же нужен заголовок с описание типа того же _G. Попробую потом посмотреть qlua.dll на предмет экспорта, и что там с символами. У квика вообще код закрытый? Они предоставляют lib файлы? Заголовки?
Вы ошибаетесь.
QLua - это не скрипт, а dll - написана на СИ или С++.  Т е скрипт на луа вызывает из нее функции.
Lua53.exe  - это приложение и внутри него запускается VMLua так же как и в терминале QUIK.

Более того, перед запуском VMLua в память грузится куча функций на СИ, которые позволяют в скрипте обращаться к строкам, таблицам, математическим функциям.   Все они написаны на СИ и находятся в Lua53.dll

Т е Вы хотите к этой куче догрузить свою dll. Ну и что Вы этим проверите? Лишь есть или нет у Вас в dll ошибки.
Но так делается при разработке любых приложений на любых языках . Ни луа ни квик ни причем.
--------------------
Я же Вам написал что так и делаю много много раз, как Вы хотите.
---------------------
Даже на форуме выкладывал пример , в котором запускал скрипт, загружал dll и обменивался данными с QUIK
================
Про функции qlua - к чему они имеют доступ описано в документации.
----
Заголовки к функциям из dll, если их нет, то делаются самостоятельно на основе dll и документации.
Для этого Вам надо изучить технологию разработки программ на СИ.
-----------------------
Разработчики уже объясняли, что они не дадут SDK (software development kit  на С)  для разработки пользовательских dll для QUIK.
Взамен этого они слепили QLua.dll и внедрили в терминал VMLua.
---------------
Поэтому спасение утопающих -дело рук самих утопающих.
 
Цитата
nikolz написал:
Вы ошибаетесь.QLua - это не скрипт, а dll - написана на СИ или С++.  Т е скрипт на луа вызывает из нее функции. Lua53.exe  - это приложение и внутри него запускается VMLua так же как и в терминале QUIK.
Я с этим согласен. Я вчера быстро и много писал по ходу мыслей. Сейчас с утра переосмыслил написанное. Я думаю, что квик работает так: он прогоняет наш скрипт сначала интерпретируя всё, что не main(), при этом он использует библиотеку lua53.dll для компиляции и выполнения скрипта, так же он видит есть ли колбэк функции, сохраняет их адреса, чтобы потом вызывать их из своего основного потока, дале как Вы и писали он запускает отдельный поток-интерпретатор для обеспечения работы main() скрипта. При этом на первом этапе он выполняет и что-то типа своего скрипта на Lua, где подключает свою qlua.dll и инициализирует _G таблицу, чтобы мы могли вызывать их функции из своего скрипта. Как то так.
 
Цитата
nikolz написал:
Более того, перед запуском VMLua в память грузится куча функций на СИ, которые позволяют в скрипте обращаться к строкам, таблицам, математическим функциям.   Все они написаны на СИ и находятся в Lua53.dll
Это тоже всё так. Но механизм скорее всего как раз тот, что описал выше. Мы же вызываем функции qlua.dll не просто так. Любая функция qlua это же по сути _G.имя функции. А значит квик интерпретирует либо свой скрипт, где инициализирует _G, либо просто своими вызовами функций из lua53.dll делает то же самое, как конкретно делается знают только разработчики, но по сути можно и так и так. "Свой" скрипт легко "держать" в памяти и выполнять и не светить в отдельном файле если надо.
 
Цитата
nikolz написал:
Т е Вы хотите к этой куче догрузить свою dll. Ну и что Вы этим проверите? Лишь есть или нет у Вас в dll ошибки.Но так делается при разработке любых приложений на любых языках . Ни луа ни квик ни причем.
Я вообще изначально хотел просто выполнить свой скрипт не прямо в квике, а извне. Я хотел писать в VSC и запускать его прямо из среды на выполнение. Но для этого нужно, чтобы разработчики квика предоставили функционал типа например такого: info.exe -e myscrypt.lua. Вот и всё. Сделать они это могут элементарно при работающем квике, подключенном к серверу квика. У них же есть функция запуска нашего скрипта? Есть. Но они грузят наш скрипт и потом его передают в качестве аргумента своей функции запуска. Так кто мешает сделать то же самое, только не из графического интерфейса квика, а из командной строки? Почему бы и нет? Зато я могу писать удобно в удобной среде и сразу запускать написанное и смотреть результат. И результаты работы выводить в окно терминала, а не через PrintDbgStr() в сторонний отладчик. Можно и отдельный файл .exe для запуска наших скриптов из вне написать, а не напрягать этим info.exe.
 
Цитата
nikolz написал:
Я же Вам написал что так и делаю много много раз, как Вы хотите.---------------------Даже на форуме выкладывал пример , в котором запускал скрипт, загружал dll и обменивался данными с QUIK
Я про это Вас и спросил. Можете по пунктам расписать алгоритм, что конкретно вы делаете? Подробно, чтобы было понятно. Или ссылку на всё это и пример. А то на словах много чего, а толком не понятна реализация что к чему.
 
Цитата
nikolz написал:
Заголовки к функциям из dll, если их нет, то делаются самостоятельно на основе dll и документации. Для этого Вам надо изучить технологию разработки программ на СИ.
Какую конкретно технологию? Можно ссылку? Или имелось в виду структура dll, формат ?
 
Цитата
nikolz написал:
Разработчики уже объясняли, что они не дадут SDK (software development kit  на С)  для разработки пользовательских dll для QUIK. Взамен этого они слепили QLua.dll и внедрили в терминал VMLua.
Ну я вот только от Вас сейчас это услышал. Сами то разработчики вообще самоустранились и не отвечают здесь от слова совсем.
 
Цитата
Alexander написал:
Цитата
nikolz написал:
VMLua - это программа и она запускается вызовом lua_pcall, в которой вызывается
Где в этой функции вызов lua_pcall?
Это ерунду написал я. Тут имелось в виду обратное.
 
Цитата
nikolz написал:
Цитата
Alexander написал:
 
Цитата
nikolz  написал:
VMLua - это программа и она запускается вызовом lua_pcall, в которой вызываетсясобственно VMLua  - эта функция  Вот ее тест из sorce code Lua 5.4
 Ну тут всё правильно написали про VMLua, что она именно ЗАПУСКАЕТСЯ, а ранее писали, что VMLua РАБОТАЕТ как самостоятельная единица.
Любая программа сначала запускается, а потом работает как самостоятельная единица. Поэтому я и написал - запускается и работает.  
Отсюда все и недопонимания возникли. Программа конечно, чтобы начать работать должна быть сначала быть загружена в память, а потом ей должно быть передано управление(call, jmp, return с адресом в стеке, int, может и ещё что есть). Так вот в моём понимании VMLua сначала просто загружена в качестве библиотеки lua53dll и НЕ работает, а работать начинает только тогда, когда нужные функции из неё для компиляции, интерпретации начинают ВЫЗЫВАТЬСЯ, ну или начинает вызываться специальная функция, которая начинает интерпретировать весь скрипт тем же самым образом, но в любом случае библиотека есть и она НЕ работает пока её функции не начнут вызывать. Поэтому Вы всё объединили в кучу - загрузка и передача управления в функцию одной фразой - VMLua уже работает.
 
Alexander, Вот скажите: зачем Вам всё это надо? Зачем связываться с библиотеками, что-то компилить, что-то собирать, разбираться с тем, как работает Квик, перелопачивать это всё с выходом очередной версии? КАКАЯ РАЗНИЦА, как работает Квик? Обилие глюков и обилие версий позволяет уверенно предположить, что работает всё это ПЛОХО. С другой стороны, это всё же РАБОТАЕТ, более-менее надёжно - система достаточно популярная, и искать что-либо иное просто не имеет смысла: как бы ни был убог Lua, он всё же обеспечивает возможность организации торговли на бирже, а больше от него ничего и не требуется. Юзеру от скрипта тоже почти ничего не нужно - запустил и забыл. И программисту тоже - написал и забыл. Я уже несколько месяцев вообще не прикасаюсь к коду, да и до этого полгода-год рихтовал лишь СВОИ алгоритмы торговли, "техника" уж тыщу лет работает безукоризненно: нужно было лишь сообразить, что не надо заниматься разной фигнёй с потоками, и всё, что можно, делать в потоке main - и всё, глюки закончились. И теперь мне плевать, что там за версия Квика, что за версия языка, что там за библиотеки водятся и на всё остальное. Зачем искать на свою задницу приключений?
 
Цитата
Владимир написал:
Alexander, Вот скажите: зачем Вам всё это надо? Зачем связываться с библиотеками, что-то компилить, что-то собирать, разбираться с тем, как работает Квик, перелопачивать это всё с выходом очередной версии? КАКАЯ РАЗНИЦА, как работает Квик? Обилие глюков и обилие версий позволяет уверенно предположить, что работает всё это ПЛОХО. С другой стороны, это всё же РАБОТАЕТ, более-менее надёжно - система достаточно популярная, и искать что-либо иное просто не имеет смысла: как бы ни был убог Lua, он всё же обеспечивает возможность организации торговли на бирже, а больше от него ничего и не требуется. Юзеру от скрипта тоже почти ничего не нужно - запустил и забыл. И программисту тоже - написал и забыл. Я уже несколько месяцев вообще не прикасаюсь к коду, да и до этого полгода-год рихтовал лишь СВОИ алгоритмы торговли, "техника" уж тыщу лет работает безукоризненно: нужно было лишь сообразить, что не надо заниматься разной фигнёй с потоками, и всё, что можно, делать в потоке main - и всё, глюки закончились. И теперь мне плевать, что там за версия Квика, что за версия языка, что там за библиотеки водятся и на всё остальное. Зачем искать на свою задницу приключений?
Всё верно Вы пишите. Но у меня тоже всё просто. Всё, что я хотел, я описал уже выше. Повторю. Я хочу писать код Lua в нормальном редакторе(подсветка, форматирование). А именно в Visual Studio Code. Хочу из среды сразу запускать на выполнение скрипт и смотреть как он работает - вывод во встроенный терминал среды VSC. Всё. Более мне ничего и не надо. Чтобы такое сделать, VSC поддерживает плагины для запуска редактируемого кода, но это делается естественно через запуск внешней программы, которой в качестве параметра передаётся наш код. Поэтому мне нужен функционал от квика, чтобы он мог выполнить мой скрипт из командной строки. Не знаю может такое квик или нет, но сделать это возможным не представляется сложным для разработчиков квика. А так как сейчас, так мне надо мой код сохранить, потом загрузить его в самом квике и запустить, и результаты работы я вынужден смотреть в стороннем отладчике, который должен каждый раз запускать, да ещё и каждый раз настроить фильтр в нём, чтобы он не принимал чужие отладочные выводы. Я хочу более простого подхода. Зачем мне все эти лишние телодвижения? Я и так уже написал программу на C++, которая сам запускает квик, ждёт появление окна логина, вводит логин и пароль, запускает программу DebugView, получает ID процесса квика, настраивает фильтр в DebugView по этому ID, сама отвечает на вопрос диалогового окна не обновлять инструменты и нажимает в окне на OK. Всё это упрощает мои действия, которые мне приходилось бы делать руками. Вот и тут я не хочу руками постоянно сохранять скрипт, в квике удалять старый скрипт, загружать новый, опять его запускать, иногда можно запариться и не удалить старый и запустить, или внести изменения в скрипт и забыть по запарке сохранить и в квике загрузить тот же самый предыдущий скрипт. Конечно это уже делается на автомате и практически без таких ошибок, но иногда по запарке можно и накосячить на голом месте. А зачем всё это надо? Есть же нормальные простые решения для этого. Нужно только разработчикам обратить на это внимание и упростить жизнь программистам. А раз этого нет из коробки, вот и начинаем думать, а можно ли как то это в принципе обойти.
И ещё. Я сейчас пишу даже не какой-то то там алгоритм для торговли. Я всего лишь получаю информацию с таблиц и передаю её в dll, а dll мне открывает потоки и окна, в которых онлайн рисуются позиции по выбранным опционам и базовым активам. И для этого мне по сути вообще и не нужен был бы никакой там их QLua если бы они мне расшарили свой API из qlua.dll и я бы вообще не запаривался бы с изучение этого Lua, а просто вызывал бы те же самы функции, что сейчас вызываю из скрипта на Lua, сразу из C++ программы.
 
Alexander, Да и Вы всё верно пишете. Только... код Lua можно писать хоть в блокноте. Я лично пишу в редакторе FAR Manager, а там всё в порядке и с подсветкой, и с форматированием, и с показом нетекстовых символов. Скрипт я запускаю из Квика, утром в рабочие дни, но, в принципе, его можно и месяцами не выключать. А смотреть как он работает нужно только в процессе отладки, да и то удобнее всего по логам. То есть не только "среды VSC" - вообще ничего не надо. Вы, судя по всему, вполне профессиональны как программист - следовательно, Lua можете освоить за пару часов. Кстати, вовсе не обязательно "руками постоянно сохранять скрипт, в квике удалять старый скрипт, загружать новый, опять его запускать" - записываете новую версию на место старой и кликаете на "остановить" и тут же на "запустить" - это максимум пара секунд. А "в запарке" пишется лишь самая первая, ещё толком не рабочая версия скрипта - дальше новые версии будут появляться через часы, дни, недели, месяцы, годы. Это и есть самое "нормальное простое решение для этого". И от разработчиков ничего не требуется.

Ах, так Вы не торгуете скриптом, используете его только как справочник для принятия рещений. Я сначала тоже выводил информацию на экран, раскрашивал таблицы, как попугая (цвет очень нагляден и информативен для принятия решений), но быстро понял, что скрипт с этой информацией разбирается  быстрее меня, точнее меня, принимаемые им решения почти всегда лучше моих, и мне незачем вообще путаться у него под ногами. И сейчас я заглядываю в Квик два-три раза в день, чисто "из спортивного интереса".
 
Цитата
Alexander написал:
Я хочу более простого подхода. Зачем мне все эти лишние телодвижения? Я и так уже написал программу на C++, которая сам запускает квик, ждёт появление окна логина, вводит логин и пароль, запускает программу DebugView, получает ID процесса квика, настраивает фильтр в DebugView по этому ID, сама отвечает на вопрос диалогового окна не обновлять инструменты и нажимает в окне на OK. Всё это упрощает мои действия, которые мне приходилось бы делать руками. Вот и тут я не хочу руками постоянно сохранять скрипт, в квике удалять старый скрипт, загружать новый, опять его запускать, иногда можно запариться и не удалить старый и запустить, или внести изменения в скрипт и забыть по запарке сохранить и в квике загрузить тот же самый предыдущий скрипт. Конечно это уже делается на автомате и практически без таких ошибок, но иногда по запарке можно и накосячить на голом месте. А зачем всё это надо? Есть же нормальные простые решения для этого.
Зачем вы удаляете в Квике старый скрипт и загружаете новый? Вы каждый раз сохраняете его под новым названием? Вы в этой теме потратили на написание текста времени больше, чем сэкономите за ближайшие 2 года, реализовав вот это вот всё, а может и не сэкономите. У вас какая-то автоматизация ради автоматизации. Вот вы в блокноте отредактировали скрипт, допустим у вас там сообщения контрольные вставлены или запись в лог файл, сохранили вы его и кнопку запуска скрипта в Квике нажали. Всё. Что вы тут сэкономите? Да, бывает не нажал Ctrl S, но это редкость, в том же Notepad подсветка меняется и * в панели задач на несохраненном видна. Ради этого редкого события?
 
Цитата
Владимир написал:
Кстати, вовсе не обязательно "руками постоянно сохранять скрипт, в квике удалять старый скрипт, загружать новый, опять его запускать"
и
Цитата
Игорь М написал:
Зачем вы удаляете в Квике старый скрипт и загружаете новый?
Да, действительно не надо его постоянно удалять и заново загружать. А я вот так тупил всё это время. Я просто начинал с QPILE и там постоянно надо было скрипт загружать локально. Вот я привык к этому. Думал, что и Lua скрипты квик по аналогии требует заново загрузить после сохранения изменений. Думал, по аналогии, квик раз загрузил его первый раз когда я его выбрал из папки, то он его хранит открытым и для замены надо его удалить и заново загрузить новый, квик откроет файл и будет держать открытым. И вот даже не удосужился проверить на практике, а надо ли действительно загружать новую версию. После ваших удивлений проверил - действительно не надо, достаточно просто сохранить изменения и всё, ну и имя я естественно не меняю и файл у меня место хранения не меняет. Так что в этом плане спасибо, а то так и тупил бы с этим дальше.
 
Цитата
Alexander написал:
Да, действительно не надо его постоянно удалять и заново загружать. А я вот так тупил всё это время. Я просто начинал с QPILE и там постоянно надо было скрипт загружать локально.
Я некоторое время на Qpile еще и каждый раз заново таблицу создавал без надобности.
 
Владимир, поскольку выяснилось, что перезагружать скрипт не надо в квике,это многое меняет дело. Пишу себе в VSC, сохраняю когда нужно, переключаюсь на квик и просто запускаю. Не так это сложно, хотя запуск скрипта из самой студии конечно было бы ещё проще и быстрее, ну да ладно. По поводу редактора FAR Manager ничего не скажу, FAR - ом как-то давно-давно пользовался совсем ещё с времён перехода с DOS на Windows, сейчас у меня Total Commander, а вот VSC, там нашёл приличный форматтер именно под Lua, от Tencent китайской, он форматирует хорошо и на лету и файл целиком, а мне это и надо было, чтобы можно было форматировать файлы целиком, ранее писанные в блокноте. Может и другие есть редакторы, которые хорошо формитируют именно Lua, но меня этот вполне себе устроил, и плагин этот настраивать можно при желании - настроек куча.
 
Цитата
swerg написал:
По пункту б) как пример для начала есть  https://github.com/swerg/qlua-exe
Я вот бегло посмотрел это. Там пишете, что: "Мне всегда хотелось иметь под рукой консольный аналог lua.exe прямо в папке с QUIK, да еще такой, чтобы можно было выполнять непосредственно скрипты, предназначенные для QUIK,
т.е. с возможностью вызова функций QLua."
Но я что-то не понял, а откуда там такая функциональность? Я там увидел вроде как Lua интерпретатор Lua скрипта из файла. Вижу, что файл открывается, далее в цикле читаются аргументы переданные вместе с именем файла и пишутся в созданную в стеке таблицу и далее создаётся глобальная переменная и ей присваивается эта таблица(qlua_exe.cpp). В qlua_functions.cpp вы создаёте набор своих функций, наподобие квиковских(message, print, sleep, getWorkingFolder) и регистрируете их в RegisterQLuaFunctions(L).Так же там написали функцию const char *luaL_tolstring(lua_State *L, int idx, size_t *len), зачем? Она же уже есть в Lua.
Вобщем я не понял, как Вы собираетесь вызывать функции QLua для работы с таблицами, например. Всё, что я понял, вы ввели свои функции (message, print, sleep, getWorkingFolder) и предлагаете их использовать в запускаемом скрипте, так? Но как таковой возможности вызвать сами функции Qlua нет.
 
Цитата
swerg написал:
Для связи между процессами есть библиотека lua_share  https://quik2dde.ru/viewtopic.php?id=306
Это не плохо, может оно кому такое и нужно. Очереди, списки хорошо если нужно такое в реализации алгоритма, а так обмен данными между скриптами, и даже работающими в разных квиках от разных брокеров просто без очередей и списков организовать можно разными способами и это не сложно. Но на заметку взял, может пригодится.
 
Alexander, FAR и как оболочка куда удобнее Total Commander, хотя идеология обоих передрана у дяди Нортона, но редактор FAR - это просто НЕЧТО! Макросы через Ctrl+"." настолько дико расширяют возможности, что ничего другого я и видеть не хочу, не то что искать. А что такое "приличный форматтер именно под Lua"? Я отлаженные блоки и функции просто схлопываю в одну строчку, чтобы не мельтещили перед глазами, с оставшимся работаю. Очень удобно, а полностью отлаженный скрипт состоит из одной строки.
 
Цитата
Владимир написал:
А что такое "приличный форматтер именно под Lua"
Ну нормально форматирует Lua текст, ну там ровно else под if отображает. Некоторые после формата всего файла некорректно это делают, "промахаваются".
 
Цитата
Владимир написал:
Alexander, FAR и как оболочка куда удобнее Total Commander, хотя идеология обоих передрана у дяди Нортона, но редактор FAR - это просто НЕЧТО! Макросы через Ctrl+"." настолько дико расширяют возможности, что ничего другого я и видеть не хочу, не то что искать. А что такое "приличный форматтер именно под Lua"? Я отлаженные блоки и функции просто схлопываю в одну строчку, чтобы не мельтещили перед глазами, с оставшимся работаю. Очень удобно, а полностью отлаженный скрипт состоит из одной строки.
О, да, как только вышел Нортон - это было нечто! Сразу жизнь веселей пошла. А, так то и в Totale много всего, использую только то, что надо. И идея конечно же Нортоновская у них.
Страницы: 1 2 След.
Читают тему
Наверх