You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
786 lines
29 KiB
786 lines
29 KiB
import aquery_config
|
|
|
|
help_message = '''\
|
|
======================================================
|
|
AQUERY COMMANDLINE HELP
|
|
======================================================
|
|
|
|
Run prompt.py without supplying with any arguments to run in interactive mode.
|
|
|
|
--help, -h
|
|
print out this help message
|
|
|
|
--version, -v
|
|
returns current version of AQuery
|
|
|
|
--mode, -m Optional[threaded|IPC]
|
|
execution engine run mode:
|
|
threaded or 1 (default): run the execution engine and compiler/prompt in separate threads
|
|
IPC, standalong or 2: run the execution engine in a new process which uses shared memory to communicate with the compiler process
|
|
|
|
--script, -s [SCRIPT_FILE]
|
|
script mode: run the aquery script file
|
|
|
|
--parse-only, -p
|
|
parse only: parse the file and print out the AST
|
|
'''
|
|
|
|
prompt_help = '''\
|
|
|
|
******** AQuery Prompt Help *********
|
|
|
|
help:
|
|
print this help message
|
|
help commandline:
|
|
print help message for AQuery Commandline
|
|
<sql statement>:
|
|
parse sql statement
|
|
f <query file>:
|
|
parse all AQuery statements in file
|
|
script <AQuery Script file>:
|
|
run AQuery Script in file
|
|
dbg:
|
|
start debugging session with current context
|
|
print:
|
|
printout parsed sql statements
|
|
exec:
|
|
execute last parsed statement(s) with AQuery Execution Engine (disabled)
|
|
xexec:
|
|
execute last parsed statement(s) with Hybrid Execution Engine
|
|
r:
|
|
run the last generated code snippet
|
|
save <OPTIONAL: filename>:
|
|
save current code snippet. will use timestamp as filename if not specified.
|
|
exit or Ctrl+C:
|
|
exit prompt mode
|
|
'''
|
|
|
|
if __name__ == '__main__':
|
|
import mimetypes
|
|
mimetypes._winreg = None
|
|
state = None
|
|
nextcmd = ''
|
|
def check_param(param, args = False) -> bool:
|
|
global nextcmd
|
|
import sys
|
|
for p in param:
|
|
if p in sys.argv:
|
|
if args:
|
|
return True
|
|
pos = sys.argv.index(p)
|
|
if len(sys.argv) > pos + 1:
|
|
nextcmd = sys.argv[pos + 1]
|
|
return True
|
|
return False
|
|
|
|
if check_param(['-v', '--version'], True):
|
|
print(aquery_config.version_string)
|
|
exit()
|
|
|
|
if check_param(['-h', '--help'], True):
|
|
print(help_message)
|
|
exit()
|
|
|
|
|
|
import atexit
|
|
import ctypes
|
|
import enum
|
|
import mmap
|
|
import os
|
|
# import dbconn
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
import time
|
|
from dataclasses import dataclass
|
|
from typing import Callable, List, Optional, Union
|
|
|
|
import numpy as np
|
|
from mo_parsing import ParseException
|
|
|
|
import aquery_parser as parser
|
|
import common
|
|
import common.ddl
|
|
import common.projection
|
|
import engine as xengine
|
|
from build import build_manager
|
|
from common.utils import add_dll_dir, base62uuid, nullstream, ws, Backend_Type, backend_strings
|
|
from enum import auto
|
|
|
|
## CLASSES BEGIN
|
|
class RunType(enum.Enum):
|
|
Threaded = 0
|
|
IPC = 1
|
|
|
|
class StoredProcedure(ctypes.Structure):
|
|
_fields_ = [
|
|
('cnt', ctypes.c_uint32),
|
|
('postproc_modules', ctypes.c_uint32),
|
|
('queries', ctypes.POINTER(ctypes.c_char_p)),
|
|
('name', ctypes.c_char_p),
|
|
('__rt_loaded_modules', ctypes.POINTER(ctypes.c_void_p)),
|
|
]
|
|
|
|
@dataclass
|
|
class QueryStats:
|
|
last_time : int = time.time()
|
|
parse_time : int = 0
|
|
codegen_time : int = 0
|
|
compile_time : int = 0
|
|
exec_time : int = 0
|
|
need_print : bool = False
|
|
def clear(self):
|
|
self.parse_time = 0
|
|
self.codegen_time = 0
|
|
self.compile_time = 0
|
|
self.exec_time = 0
|
|
self.last_time = time.time()
|
|
|
|
def stop(self):
|
|
ret = time.time() - self.last_time
|
|
self.last_time = time.time()
|
|
return ret
|
|
|
|
def cumulate(self, other : Optional['QueryStats']):
|
|
if other:
|
|
other.parse_time += self.parse_time
|
|
other.codegen_time += self.codegen_time
|
|
other.compile_time += self.compile_time
|
|
other.exec_time += self.exec_time
|
|
|
|
def print(self, cumulative = None, clear = True, need_print = True):
|
|
if self.need_print:
|
|
if cumulative:
|
|
self.exec_time = self.stop()
|
|
self.cumulate(cumulative)
|
|
if need_print:
|
|
print(f'Parse Time: {self.parse_time}, Codegen Time: {self.codegen_time}, Compile Time: {self.compile_time}, Execution Time: {self.exec_time}.')
|
|
print(f'Total Time: {self.parse_time + self.codegen_time + self.compile_time + self.exec_time}')
|
|
self.need_print = False
|
|
if clear:
|
|
self.clear()
|
|
class Config:
|
|
__all_attrs__ = ['running', 'new_query', 'server_mode',
|
|
'backend_type', 'has_dll',
|
|
'n_buffers',
|
|
]
|
|
__i64_attrs__ = [
|
|
'monetdb_time', 'postproc_time'
|
|
]
|
|
__init_attributes__ = False
|
|
|
|
@staticmethod
|
|
def __init_self__():
|
|
if not Config.__init_attributes__:
|
|
from functools import partial
|
|
for _i, attr in enumerate(Config.__all_attrs__):
|
|
if not hasattr(Config, attr):
|
|
setattr(Config, attr, property(
|
|
partial(Config.getter, i = _i), partial(Config.setter, i = _i)
|
|
))
|
|
for _i, attr in enumerate(Config.__i64_attrs__):
|
|
if not hasattr(Config, attr):
|
|
setattr(Config, attr, property(
|
|
partial(Config.i64_getter, i = _i), partial(Config.i64_setter, i = _i)
|
|
))
|
|
Config.__init_attributes__ = True
|
|
|
|
def __init__(self, mode, nq = 0, n_bufs = 0, bf_szs = []) -> None:
|
|
Config.__init_self__()
|
|
self.n_attrib = len(Config.__all_attrs__)
|
|
self.buf = bytearray((self.n_attrib + n_bufs) * 4 +
|
|
len(self.__i64_attrs__) * 8
|
|
)
|
|
self.np_buf = np.ndarray(shape = (self.n_attrib), buffer = self.buf, dtype = np.int32)
|
|
self.np_i64buf = np.ndarray(shape = len(self.__i64_attrs__), buffer = self.buf,
|
|
dtype = np.int64, offset = 4 * len(self.__all_attrs__))
|
|
self.new_query = nq
|
|
self.server_mode = mode.value
|
|
self.running = 1
|
|
self.backend_type = Backend_Type.BACKEND_MonetDB.value
|
|
self.has_dll = 0
|
|
self.n_buffers = n_bufs
|
|
self.monetdb_time = 0
|
|
self.postproc_time = 0
|
|
|
|
def getter (self, *, i):
|
|
return self.np_buf[i]
|
|
def setter(self, v, *, i):
|
|
self.np_buf[i] = v
|
|
def i64_getter (self, *, i):
|
|
return self.np_i64buf[i]
|
|
def i64_setter(self, v, *, i):
|
|
self.np_i64buf[i] = v
|
|
|
|
def set_bufszs(self, buf_szs):
|
|
for i in range(min(len(buf_szs), self.n_buffers)):
|
|
self.np_buf[i+self.n_attrib] = buf_szs[i]
|
|
|
|
@property
|
|
def c(self):
|
|
return ctypes.cast(\
|
|
(ctypes.c_char * len(self.buf)).from_buffer(self.buf), ctypes.c_char_p)
|
|
|
|
@dataclass
|
|
class PromptState():
|
|
cleanup = True
|
|
th = None
|
|
send = None
|
|
test_parser = True
|
|
server_mode: RunType = RunType.Threaded
|
|
server_bin = 'server.bin' if server_mode == RunType.IPC else 'server.so'
|
|
wait_engine = lambda: None
|
|
wake_engine = lambda: None
|
|
get_storedproc = lambda *_: StoredProcedure()
|
|
set_ready = lambda: None
|
|
get_ready = lambda: None
|
|
server_status = lambda: False
|
|
cfg : Optional[Config] = None
|
|
shm : str = ''
|
|
server : subprocess.Popen = None
|
|
basecmd : List[str] = None
|
|
mm : mmap = None
|
|
th : threading.Thread
|
|
send : Callable = lambda *_:None
|
|
init : Callable[['PromptState'], None] = lambda _:None
|
|
stmts = ['']
|
|
payloads = {}
|
|
need_print : bool = False
|
|
stats : Optional[QueryStats] = None
|
|
currstats : Optional[QueryStats] = None
|
|
buildmgr : Optional[build_manager]= None
|
|
current_procedure : Optional[str] = None
|
|
_force_compiled : bool = False
|
|
_cxt : Optional[Union[xengine.Context, common.Context]] = None
|
|
@property
|
|
def force_compiled(self):
|
|
return self._force_compiled
|
|
|
|
@force_compiled.setter
|
|
def force_compiled(self, new_val):
|
|
self.cxt.force_compiled = new_val
|
|
self._force_compiled = new_val
|
|
|
|
@property
|
|
def cxt(self):
|
|
return self._cxt
|
|
|
|
@cxt.setter
|
|
def cxt(self, cxt):
|
|
cxt.force_compiled = self.force_compiled
|
|
self._cxt = cxt
|
|
self._cxt.system_state = self
|
|
## CLASSES END
|
|
|
|
## FUNCTIONS BEGIN
|
|
def rm(state:PromptState):
|
|
if state.cleanup:
|
|
state.mm.seek(0,os.SEEK_SET)
|
|
state.mm.write(b'\x00\x00')
|
|
state.mm.flush()
|
|
|
|
try:
|
|
time.sleep(.001)
|
|
state.server.kill()
|
|
time.sleep(.001)
|
|
state.server.terminate()
|
|
except OSError:
|
|
pass
|
|
|
|
files = os.listdir('.')
|
|
for f in files:
|
|
if f.endswith('.shm'):
|
|
os.remove(f)
|
|
state.mm.close()
|
|
state.cleanup = False
|
|
nullstream.close()
|
|
|
|
def init_ipc(state: PromptState):
|
|
state.shm = base62uuid()
|
|
if sys.platform != 'win32':
|
|
state.shm += '.shm'
|
|
state.basecmd = ['bash', '-c', 'rlwrap k']
|
|
state.mm = None
|
|
if not os.path.isfile(shm):
|
|
# create initial file
|
|
with open(shm, "w+b") as handle:
|
|
handle.write(b'\x01\x00') # [running, new job]
|
|
handle.flush()
|
|
state.mm = mmap.mmap(handle.fileno(), 2, access=mmap.ACCESS_WRITE, offset=0)
|
|
if state.mm is None:
|
|
exit(1)
|
|
else:
|
|
state.basecmd = ['bash.exe', '-c', 'rlwrap ./k']
|
|
state.mm = mmap.mmap(0, 2, state.shm)
|
|
state.mm.write(b'\x01\x00')
|
|
state.mm.flush()
|
|
state.server = subprocess.Popen(["./server.bin", state.shm])
|
|
|
|
def init_threaded(state : PromptState):
|
|
state.cleanup = False
|
|
if os.name == 'nt' and aquery_config.add_path_to_ldpath:
|
|
t = os.environ['PATH'].lower().split(';')
|
|
vars = re.compile('%.*%')
|
|
add_dll_dir(os.path.abspath('.'))
|
|
add_dll_dir(os.path.abspath('./lib'))
|
|
for e in t:
|
|
if(len(e) != 0):
|
|
if '%' in e:
|
|
try:
|
|
m_e = vars.findall(e)
|
|
for m in m_e:
|
|
e = e.replace(m, os.environ[m[1:-1]])
|
|
except Exception:
|
|
continue
|
|
try:
|
|
add_dll_dir(e)
|
|
except Exception:
|
|
continue
|
|
|
|
else:
|
|
os.environ['PATH'] = os.environ['PATH'] + os.pathsep + os.path.abspath('.')
|
|
os.environ['PATH'] = os.environ['PATH'] + os.pathsep + os.path.abspath('./lib')
|
|
if aquery_config.run_backend:
|
|
server_so = ctypes.CDLL('./'+state.server_bin)
|
|
state.send = server_so['receive_args']
|
|
state.wait_engine = server_so['wait_engine']
|
|
state.wake_engine = server_so['wake_engine']
|
|
state.get_storedproc = server_so['get_procedure_ex']
|
|
state.get_storedproc.restype = StoredProcedure
|
|
aquery_config.have_hge = server_so['have_hge']()
|
|
if aquery_config.have_hge != 0:
|
|
from common.types import get_int128_support
|
|
get_int128_support()
|
|
state.th = threading.Thread(target=server_so['dllmain'], args=(-1, ctypes.POINTER(ctypes.c_char_p)(state.cfg.c)), daemon=True)
|
|
state.th.start()
|
|
|
|
def init_prompt() -> PromptState:
|
|
aquery_config.init_config()
|
|
|
|
state = PromptState()
|
|
common.utils.session_context = state
|
|
# if aquery_config.rebuild_backend:
|
|
# try:
|
|
# os.remove(state.server_bin)
|
|
# except Exception as e:
|
|
# print(type(e), e)
|
|
# subprocess.call(['make', "info"])
|
|
# subprocess.call(['make', state.server_bin], stdout=nullstream)
|
|
state.buildmgr = build_manager()
|
|
state.buildmgr.build_caches()
|
|
state.cfg = Config(state.server_mode)
|
|
state.stats = QueryStats()
|
|
state.currstats = QueryStats()
|
|
|
|
if state.server_mode == RunType.IPC:
|
|
atexit.register(lambda: rm(state))
|
|
state.init = init_ipc
|
|
state.set_ready = lambda : state.mm.seek(0,os.SEEK_SET) or state.mm.write(b'\x01\x01')
|
|
def __get_ready():
|
|
state.mm.seek(0,os.SEEK_SET)
|
|
return state.mm.read(2)[1]
|
|
state.get_ready = __get_ready
|
|
state.server_status = lambda : state.server.poll() is not None
|
|
else:
|
|
state.init = init_threaded
|
|
rm = lambda: None
|
|
def __set_ready():
|
|
state.cfg.new_query = 1
|
|
state.wake_engine()
|
|
|
|
state.set_ready = __set_ready
|
|
state.get_ready = lambda: aquery_config.run_backend and state.cfg.new_query
|
|
if aquery_config.run_backend:
|
|
state.server_status = lambda : not state.th.is_alive()
|
|
else:
|
|
state.server_status = lambda : True
|
|
state.init(state)
|
|
return state
|
|
|
|
def save(q:str, cxt: xengine.Context):
|
|
savecmd = re.split(r'[ \t]', q)
|
|
if len(savecmd) > 1:
|
|
fname = savecmd[1]
|
|
else:
|
|
tm = time.gmtime()
|
|
fname = f'{tm.tm_year}{tm.tm_mon}_{tm.tm_mday}_{tm.tm_hour}:{tm.tm_min}:{tm.tm_sec}'
|
|
if cxt:
|
|
from typing import Optional
|
|
def savefile(attr:str, desc:str, ext:Optional[str] = None):
|
|
if hasattr(cxt, attr):
|
|
attr : str = getattr(cxt, attr)
|
|
if attr:
|
|
ext = ext if ext else '.' + desc
|
|
name = fname if fname.endswith(ext) else fname + ext
|
|
with open('saves/' + name, 'wb') as cfile:
|
|
cfile.write(attr.encode('utf-8'))
|
|
print(f'saved {desc} code as {name}')
|
|
savefile('ccode', 'cpp')
|
|
savefile('udf', 'udf', '.hpp')
|
|
savefile('sql', 'sql')
|
|
|
|
def prompt(running = lambda:True, next = lambda:input('> '), state : Optional[PromptState] = None):
|
|
if state is None:
|
|
state = init_prompt()
|
|
q = ''
|
|
payload = None
|
|
keep = True
|
|
|
|
state.cxt = cxt = xengine.initialize()
|
|
parser.parse('SELECT "**** WELCOME TO AQUERY++! ****";')
|
|
|
|
# state.currstats = QueryStats()
|
|
# state.need_print = False
|
|
while running():
|
|
try:
|
|
if state.server_status():
|
|
state.init(state)
|
|
# *** busy waiting ***
|
|
# while state.get_ready():
|
|
# time.sleep(.00001)
|
|
while state.get_ready():
|
|
state.wait_engine()
|
|
if state.need_print:
|
|
print(f'MonetDB Time: {state.cfg.monetdb_time/10**9}, '
|
|
f'PostProc Time: {state.cfg.postproc_time/10**9}')
|
|
state.cfg.monetdb_time = state.cfg.postproc_time = 0
|
|
state.currstats.print(state.stats, need_print=state.need_print)
|
|
try:
|
|
og_q : str = next()
|
|
state.currstats.stop()
|
|
except EOFError:
|
|
print('stdin inreadable, Exiting...')
|
|
exit(0)
|
|
q = og_q.lower().strip()
|
|
if (not re.sub(r'[ \r\n\t;]', '', q)):
|
|
continue
|
|
if False and q == 'exec': # generate build and run (AQuery Engine)
|
|
state.cfg.backend_type = Backend_Type.BACKEND_AQuery.value
|
|
state.cxt = cxt = common.exec(state.stmts, cxt, keep)
|
|
if state.buildmgr.build_dll() == 0:
|
|
state.set_ready()
|
|
continue
|
|
elif q.startswith('echo '):
|
|
print(og_q[5:].lstrip())
|
|
continue
|
|
elif q.startswith('list '):
|
|
qs = re.split(r'[ \t]', q)
|
|
if len(qs) > 1 and qs[1].startswith('table'):
|
|
for t in cxt.tables:
|
|
lst_cols = []
|
|
for c in t.columns:
|
|
lst_cols.append(f'{c.name} : {c.type.name}')
|
|
print(f'{t.table_name} ({", ".join(lst_cols)})')
|
|
continue
|
|
elif q.startswith('help'):
|
|
qs = re.split(r'[ \t]', q)
|
|
if len(qs) > 1 and qs[1].startswith('c'):
|
|
print(help_message)
|
|
else:
|
|
print(prompt_help)
|
|
continue
|
|
elif q.startswith('xexec') or q.startswith('exec'): # generate build and run (MonetDB Engine)
|
|
#state.cfg.backend_type = Backend_Type.BACKEND_MonetDB.value
|
|
state.cxt = cxt = xengine.exec(state.stmts, cxt, keep, parser.parse)
|
|
|
|
this_udf = cxt.finalize_udf()
|
|
if this_udf:
|
|
with open('udf.hpp', 'wb') as outfile:
|
|
outfile.write(this_udf.encode('utf-8'))
|
|
|
|
if state.server_mode == RunType.Threaded:
|
|
# assignment to avoid auto gc
|
|
# sqls = [s.strip() for s in cxt.sql.split(';')]
|
|
qs = [ctypes.c_char_p(bytes(q, 'utf-8')) for q in cxt.queries if len(q)]
|
|
sz = len(qs)
|
|
payload = (ctypes.c_char_p*sz)(*qs)
|
|
state.payload = payload
|
|
try:
|
|
state.send(sz, payload)
|
|
except TypeError as e:
|
|
print(e)
|
|
state.currstats.codegen_time = state.currstats.stop()
|
|
state.currstats.compile_time = 0
|
|
state.currstats.exec_time = 0
|
|
qs = re.split(r'[ \t]', q)
|
|
build_this = not(len(qs) > 1 and qs[1].startswith('n'))
|
|
if cxt.has_dll:
|
|
with open('out.cpp', 'wb') as outfile:
|
|
outfile.write((cxt.finalize()).encode('utf-8'))
|
|
state.currstats.codegen_time += state.currstats.stop()
|
|
|
|
if build_this:
|
|
state.buildmgr.build_dll()
|
|
state.cfg.has_dll = 1
|
|
else:
|
|
state.cfg.has_dll = 0
|
|
state.currstats.compile_time = state.currstats.stop()
|
|
cxt.post_exec_triggers()
|
|
if build_this:
|
|
state.set_ready()
|
|
# while state.get_ready():
|
|
# state.wait_engine()
|
|
state.currstats.need_print = True
|
|
continue
|
|
|
|
elif q == 'dbg':
|
|
import code
|
|
from copy import deepcopy
|
|
var = {**globals(), **locals()}
|
|
sh = code.InteractiveConsole(var)
|
|
__stdin = os.dup(0)
|
|
try:
|
|
sh.interact(banner = 'debugging session began.', exitmsg = 'debugging session ended.')
|
|
except BaseException as e:
|
|
# dont care about whatever happened in dbg session
|
|
print(e)
|
|
finally:
|
|
import io
|
|
sys.stdin = io.TextIOWrapper(io.BufferedReader(io.FileIO(__stdin, mode='rb', closefd=False)), encoding='utf8')
|
|
continue
|
|
elif q.startswith('log'):
|
|
qs = re.split(r'[ \t]', q)
|
|
if len(qs) > 1:
|
|
cxt.log_level = qs[1]
|
|
else:
|
|
cxt.print(cxt.log_level)
|
|
continue
|
|
elif q == 'k':
|
|
subprocess.call(state.basecmd)
|
|
continue
|
|
elif q == 'print':
|
|
cxt.print(state.stmts)
|
|
continue
|
|
elif q.startswith('save'):
|
|
save(q, cxt)
|
|
continue
|
|
elif q == 'keep':
|
|
keep = not keep
|
|
continue
|
|
elif q == 'format' or q == 'fmt':
|
|
subprocess.call(['clang-format', 'out.cpp'])
|
|
elif q == 'exit' or q == 'exit()' or q == 'quit' or q == 'quit()' or q == '\\q':
|
|
rm(state)
|
|
exit()
|
|
elif q.startswith('sh'):
|
|
from shutil import which
|
|
qs = re.split(r'[ \t]', q)
|
|
shells = ('zsh', 'bash', 'sh', 'fish', 'cmd', 'pwsh', 'powershell', 'csh', 'tcsh', 'ksh')
|
|
shell_path = ''
|
|
if len(qs) > 1 and qs[1] in shells:
|
|
shell_path = which(qs[1])
|
|
if shell_path:
|
|
os.system(shell_path)
|
|
else:
|
|
for sh in shells:
|
|
shell_path = which(sh)
|
|
if shell_path:
|
|
os.system(shell_path)
|
|
break
|
|
|
|
continue
|
|
elif q == 'r': # build and run
|
|
if state.server_mode == RunType.Threaded:
|
|
enc = lambda q: 'latin-1' if q.startswith('O') else 'utf-8'
|
|
qs = [ctypes.c_char_p(bytes(q, enc(q))) for q in cxt.queries if len(q)]
|
|
sz = len(qs)
|
|
payload = (ctypes.c_char_p*sz)(*qs)
|
|
state.payload = payload
|
|
try:
|
|
state.send(sz, payload)
|
|
except TypeError as e:
|
|
print(e)
|
|
if subprocess.call(['make', 'snippet']) == 0:
|
|
state.set_ready()
|
|
continue
|
|
elif q == 'rr': # run
|
|
state.set_ready()
|
|
continue
|
|
elif q.startswith('script'):
|
|
qs = re.split(r'[ \t]', q)
|
|
if len(qs) > 1:
|
|
qs = qs[1]
|
|
with open(qs) as file:
|
|
qs = file.readline()
|
|
from common.utils import _Counter
|
|
lst_tell = -1
|
|
while(qs):
|
|
while(not ws.sub('', qs) or qs.strip().startswith('#')):
|
|
qs = file.readline()
|
|
if lst_tell == file.tell():
|
|
break
|
|
else:
|
|
lst_tell = file.tell()
|
|
cnt = _Counter(1)
|
|
prompt(lambda : cnt.inc(-1) > 0, lambda:qs.strip(), state)
|
|
qs = file.readline()
|
|
continue
|
|
elif q.startswith('save2'):
|
|
filename = re.split(r'[ \t]', q)
|
|
if (len(filename) > 1):
|
|
filename = filename[1]
|
|
else:
|
|
filename = f'out_{base62uuid(4)}.cpp'
|
|
with open(filename, 'wb') as outfile:
|
|
outfile.write((cxt.finalize()).encode('utf-8'))
|
|
continue
|
|
elif q.startswith('stats'):
|
|
qs = re.split(r'[ \t]', q)
|
|
if len(qs) > 1:
|
|
if qs[1].startswith('on'):
|
|
state.need_print = True
|
|
elif qs[1].startswith('off'):
|
|
state.need_print = False
|
|
elif qs[1].startswith('last'):
|
|
state.currstats.need_print = True
|
|
state.currstats.print()
|
|
elif qs[1].startswith('reset'):
|
|
state.currstats.clear()
|
|
continue
|
|
state.stats.need_print = True
|
|
state.stats.print(clear = False)
|
|
continue
|
|
elif q.startswith('procedure'):
|
|
qs = re.split(r'[ \t\r\n]', q)
|
|
procedure_help = '''Usage: procedure <procedure_name> [record|stop|run|remove|save|load]'''
|
|
from common.utils import send_to_server
|
|
if len(qs) > 2:
|
|
if qs[2].lower() =='record':
|
|
if state.current_procedure is not None and state.current_procedure != qs[1]:
|
|
print(f'Cannot record 2 procedures at the same time. Stop recording {state.current_procedure} first.')
|
|
elif state.current_procedure is None:
|
|
state.current_procedure = qs[1]
|
|
send_to_server(f'R\0{qs[1]}')
|
|
elif qs[2].lower() == 'stop':
|
|
send_to_server(f'RT\0{qs[1]}')
|
|
state.current_procedure = None
|
|
else:
|
|
if state.current_procedure:
|
|
print(f'Procedure manipulation commands are disallowed during procedure recording.')
|
|
continue
|
|
if qs[2].lower() == 'run':
|
|
send_to_server(f'RE\0{qs[1]}')
|
|
elif qs[2].lower() == 'remove':
|
|
send_to_server(f'RD\0{qs[1]}')
|
|
elif qs[2].lower() == 'save':
|
|
send_to_server(f'RS\0{qs[1]}')
|
|
elif qs[2].lower() == 'load':
|
|
send_to_server(f'RL\0{qs[1]}')
|
|
|
|
elif len(qs) > 1:
|
|
if qs[1].lower() == 'display':
|
|
send_to_server(f'Rd\0')
|
|
else:
|
|
print(procedure_help)
|
|
continue
|
|
elif q.startswith('force'):
|
|
splits = q.split()
|
|
if len(splits > 1) and splits[1] == 'compiled':
|
|
state.force_compiled = True
|
|
cxt.force_compiled = True
|
|
continue
|
|
elif q.startswith('engine'):
|
|
splits = q.split()
|
|
if len(splits) > 1 and splits[1] in backend_strings:
|
|
state.cfg.backend_type = backend_strings[splits[1]].value
|
|
else:
|
|
cxt.Error('Not a valid engine type.')
|
|
print('External Engine is set to', Backend_Type(state.cfg.backend_type).name)
|
|
continue
|
|
trimed = ws.sub(' ', og_q).split(' ')
|
|
if len(trimed) > 1 and trimed[0].lower().startswith('fi') or trimed[0].lower() == 'f':
|
|
fn = 'stock.a' if len(trimed) <= 1 or len(trimed[1]) == 0 \
|
|
else trimed[1]
|
|
try:
|
|
with open(fn, 'r') as file:
|
|
contents = file.read()#.lower()
|
|
except FileNotFoundError:
|
|
with open('tests/' + fn, 'r') as file:
|
|
contents = file.read()
|
|
state.stmts = parser.parse(contents)
|
|
state.currstats.parse_time = state.currstats.stop()
|
|
continue
|
|
state.stmts = parser.parse(og_q.strip())
|
|
cxt.Info(state.stmts)
|
|
state.currstats.parse_time = state.currstats.stop()
|
|
except (ParseException) as e:
|
|
print(e)
|
|
continue
|
|
except (ValueError, FileNotFoundError) as e:
|
|
try:
|
|
os.remove('./cached')
|
|
except:
|
|
pass
|
|
print(e)
|
|
except (KeyboardInterrupt):
|
|
break
|
|
except SystemExit:
|
|
print("\nBye.")
|
|
raise
|
|
except ValueError as e:
|
|
import code
|
|
import traceback
|
|
__stdin = os.dup(0)
|
|
raise_exception = True
|
|
sh = code.InteractiveConsole({**globals(), **locals()})
|
|
try:
|
|
sh.interact(banner = traceback.format_exc(), exitmsg = 'debugging session ended.')
|
|
except:
|
|
pass
|
|
finally:
|
|
sys.stdin = io.TextIOWrapper(io.BufferedReader(io.FileIO(__stdin, mode='rb', closefd=False)), encoding='utf8')
|
|
save('', cxt)
|
|
rm(state)
|
|
# control whether to raise exception in interactive console
|
|
if raise_exception:
|
|
raise e
|
|
|
|
rm(state)
|
|
## FUNCTIONS END
|
|
|
|
## MAIN
|
|
if __name__ == '__main__':
|
|
|
|
if len(sys.argv) == 2:
|
|
nextcmd = sys.argv[1]
|
|
if nextcmd.startswith('-'):
|
|
nextcmd = ''
|
|
|
|
#nextcmd = 'test.aquery'
|
|
if nextcmd or check_param(['-s', '--script']):
|
|
with open(nextcmd) as file:
|
|
nextcmd = file.readline()
|
|
from common.utils import _Counter
|
|
if file.name.endswith('aquery') or nextcmd.strip() == '#!aquery':
|
|
state = init_prompt()
|
|
while(nextcmd):
|
|
while(not ws.sub('', nextcmd) or nextcmd.strip().startswith('#')):
|
|
nextcmd = file.readline()
|
|
cnt = _Counter(1)
|
|
prompt(lambda : cnt.inc(-1) > 0, lambda:nextcmd.strip(), state)
|
|
nextcmd = file.readline()
|
|
|
|
if check_param(['-p', '--parse']):
|
|
with open(nextcmd, 'r') as file:
|
|
contents = file.read()
|
|
print(parser.parse(contents))
|
|
|
|
if check_param(['-m', '--mode', '--run-type']):
|
|
nextcmd = nextcmd.lower()
|
|
ipc_string = ['ipc', 'proc', '2', 'standalong']
|
|
thread_string = ['thread', '1']
|
|
if any([s in nextcmd for s in ipc_string]):
|
|
server_mode = RunType.IPC
|
|
elif any([s in nextcmd for s in thread_string]):
|
|
server_mode = RunType.Threaded
|
|
|
|
if check_param(['-r', '--rebuild']):
|
|
try:
|
|
os.remove('./.cached')
|
|
except FileNotFoundError:
|
|
pass
|
|
|
|
prompt(state=state)
|
|
|