| Current Path : /home/cgabriel/20_dev/12_procpy/xy/ |
Linux ift1.ift-informatik.de 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64 |
| Current File : //home/cgabriel/20_dev/12_procpy/xy/xyparser.py |
# pyarmor pack -e "\-F" xyparser.py
import os,re,sys,glob,time,datetime,random,json,hashlib,base64
from ecdsa import SigningKey,VerifyingKey # ,NIST384p
#import mysql.connector # pip3 install mysql-connector-python (MySQL)
#import pypyodbc # pip3 install pypyodbc (MS SQL)
import sqlite3 # (SQLite3)
# not working:
#import cx_Oracle # pip3 install cx_oracle (Linux works!) (Oracle)
#import psycopg2 # pip3 install psycopg2 (PostgreSQL)
#import mariadb # pip3 install mariadb (MariaDB)
# apt-get install mariadb-server mariadb-client libmariadbclient-dev
# from lark import Lark
def json1(x):
return(json.dumps(x))
def hash1(x):
return(hashlib.shake_256(bytearray(x,"utf8")).hexdigest(12))
class Rule ():
pass
#**********************************************************************************
class XYparser ():
def mark (self,remark=""):
t = time.perf_counter()
if self.t0 > 0:
print ( ("%9.2f" % ((t-self.t0)*1000)) + " ms for: " + remark )
self.t0 = t
#**********************************************************************************
def __init__ (self,*pars):
self.t0 = -1.0
self.dir = pars[1]
self.vkey = "913e4785a4472e3c70017c97a0b2602c4380f1cc018e9b5a71daba3731360981a4055c331eff51ac3f7e72cdfc28f46c"
self.id = hashlib.shake_256(bytearray(str(time.time()),"utf8")).hexdigest(4)
self.dbh = None
# 1. Check all the license files, and first of all, the hardcoded license
text = None
vkey = None
for lic_file in ( [""] + glob.glob(self.dir[0]+"/*.license") ):
if lic_file == "":
try:
text = self.lic_file_hardcoded()
break
except:
continue
print("Check license file " + lic_file + " ...")
m = re.search(r"^([0123456789abcdef])+(\S+)\.license",lic_file)
if m:
self.vkey = m.group(1)
self.id = m.group(2)
zeilen = open(lic_file).read().strip().split("\n")
signature = ""
while len(signature) < 90:
m = re.search(r"^[0123456789abcdef]+$",zeilen[-1])
if not m:
break
signature = zeilen[-1] + signature
zeilen.pop()
text = ("\n".join(zeilen)).strip()
try: # erstmal versuchen, ob die Signatur passt
vkey = VerifyingKey.from_string( bytearray.fromhex(self.vkey))
vkey.verify( bytearray.fromhex(signature) ,bytearray(text,"utf-8"))
break
except Exception as e: # wenn keine gueltige Signatur vorgefunden wird, dann neues Schluesselpaar generieren
print(str(e))
vkey = None
if vkey == None: # keine gueltige Signatur
if text == None:
print("No license found.")
return(None)
self.show_new_keys(text)
return(None)
print("License ok.")
# 2. Analyse the license file
m = re.search(r"expiry\: +(\S+)",text.lower())
if not m:
print("No expiry date.")
return(None)
self.endtry = ( datetime.datetime.strptime(m.group(1),"%Y/%m/%d") -
datetime.datetime.strptime("1970/01/01","%Y/%m/%d") ).total_seconds()
m = re.search(r"start\: +(\S+)",text.lower())
if not m:
print("No start date.")
return(None)
self.starttry = ( datetime.datetime.strptime(m.group(1),"%Y/%m/%d") -
datetime.datetime.strptime("1970/01/01","%Y/%m/%d") ).total_seconds()
m = re.search(r"maxcycles\: +(\d+)",text.lower())
if not m:
print("No maxcycles.")
return(None)
return()
self.max_cycles = int( m.group(1) )
self.idouble = 0 # 86400*7
m = re.search(r"dbtype\: +(\S+)",text.lower())
if not m:
print("No dbtype.")
return(None)
self.dbtype = m.group(1)
m = re.search(r"dbfile\: +(\S+)",text.lower())
if m:
self.dbfile = m.group(1)
m = re.search(r"dburl\: +(\S+)",text.lower())
if m:
self.dburl = m.group(1)
m = re.search(r"dbuser\: +(\S+)",text.lower())
if m:
self.dbuser = m.group(1)
m = re.search(r"passwd\: +(\S+)",text.lower())
if m:
self.passwd = m.group(1)
m = re.search(r"database\: +(\S+)",text.lower())
if m:
self.database = m.group(1)
self.mark("start")
self.sections = {}
# 3. Call a certain function
if pars[0] == "__main__" and len(pars) > 2:
self.__class__.__dict__[pars[2]](self,*pars[3:])
return(None)
else:
self.__class__.__dict__["standard"](self,*pars[2:])
return(None)
#**********************************************************************************
def show_new_keys (self,text):
print("")
print("Actual verifying key: ",self.vkey)
print("------------------------------------------------------------"+
"-----------------------------------------------------------")
skey1 = ""
for keyfile in glob.glob(self.dir+"/*.keys"): # vielleicht findet man den signing key in der Liste
for zeile in open(keyfile).read().split("\n"):
if zeile.startswith(self.vkey):
m = re.search(r"^(.*?)([0123456789abcdef]+)",zeile[len(self.vkey):])
if m:
skey1 = m.group(2)
break
if not skey1 == "":
break
if not skey1 == "":
try:
skey = SigningKey.from_string( bytearray.fromhex(skey1))
except:
skey1 == ""
new_keys_entry = 0
if skey1 == "":
skey = SigningKey.generate()
skey1 = skey.to_string().hex()
new_keys_entry = 1
print("New signing key: ",skey1)
vkey = skey.verifying_key
vkey1 = vkey.to_string().hex()
print("New verifying key: ",vkey1)
try:
os.mkdir(self.dir+"/generate")
except:
pass
bed = 0
for zeile in open(self.dir+"/generate/new.keys").read().split("\n"):
if zeile.startswith(vkey1):
bed = 1
break
if bed == 0:
open(self.dir+"/generate/new.keys","a").write(vkey1 + " " + skey1 + "\n")
print("")
print("Signed license file:")
newsignature = skey.sign(bytearray(text,"utf-8")).hex()
text = text + "\n\n" + newsignature[0:32] + "\n" + newsignature[32:64] + "\n" + newsignature[64:96] + "\n"
print("")
print(text)
print("")
open(self.dir + "/generate/" + vkey1 + "_" + self.id + ".license","w").write(text)
pyfiles = glob.glob(self.dir+"/*xyparser*py")
if len(pyfiles) > 0:
text = open(pyfiles[0]).read()
text = re.sub("\"([0123456789abcdef]{48})\"","\""+skey1+"\"",text)
text = re.sub("\"([0123456789abcdef]{96})\"","\""+vkey1+"\"",text)
open(self.dir + "/generate/xyparser_" + vkey1 + ".py","w").write(text)
#**********************************************************************************
def sign_license (self,text):
"64b95e70a62cfba0a08b5d152b75c5c23c4dc4036f1ec964"
#**********************************************************************************
def dbh__database (self):
print(self.dbtype)
if not self.dbh:
if self.dbtype[0:6] == "sqlite":
self.dbh = sqlite3.connect(self.dbfile)
return(self.dbh)
#**********************************************************************************
def parse_db_rule (self):
v = Rule() # Check which variables are needed
(e,f,g,h,i,j,k,l,m,n) = ( Rule(),Rule(),Rule(),Rule(),Rule(),
Rule(),Rule(),Rule(),Rule(),Rule() )
self.entries = []
zaehler = 0
add_variable = ""
var_types = [" "*100,[]*100,1,0.9,None,{}]
zaehler0 = 0
while (0 == 0):
zaehler0 = zaehler0 + 1
if zaehler0 > 10000:
return("115. Not parseable.")
zaehler = (zaehler + 1) % len(var_types)
try: # Are enough variables set?
self.execute_rule(v,e,f,g,h,i,j,k,l,m,n)
break
except Exception as ee: # No. We add one variable
m = re.search(r"^(.*)attribute +\'(.*)\' *$",str(ee))
if m: # ... and set it to None
add_variable = m.group(2)
vars(v)[add_variable] = var_types[zaehler]
self.entries.append(m.group(2)) # list the variable for the record
else: # another fault at runtime, does not matter -> exit
if add_variable in vars(v):
del vars(v)[add_variable]
else:
# print(zaehler,add_variable)
vars(v)[add_variable] = var_types[zaehler]
self.entries.append(add_variable) # list the variable for the record
(e,f,g,h,i,j,k,l,m,n) = (Rule(),Rule(),Rule(),Rule(),Rule(),Rule(),Rule(),Rule(),Rule(),Rule())
return(v,e,f,g,h,i,j,k,l,m,n)
#****************************************************************************************
def evaluate_db_rule (self,tree0):
v = Rule()
# self.mark("701")
tree = tree0.split("\n")
for entry in self.entries:
# if "xxsequenceeditor".startswith(entry):
# m = re.search(r"^(.*?)sequence +editor(.*)$",tree0,re.DOTALL|re.IGNORECASE)
# if m:
# vars(v)[entry] = m.group(2).strip() + "\n"
# continue
while (0 == 0):
if entry in self.sections: # check whether entry has position info
if "_" in entry:
[entry0,entry1] = entry.split("_")
[row0,row,col,anz] = self.sections[entry]
else:
entry1 = entry
[row,col,anz] = self.sections[entry]
entry0 = None
if not entry0 or entry0 in tree[row0].replace(" ","").replace(".","").replace("-","").replace("(","").replace(")","").lower():
try:
spalten = tree[row].split(";")
spalte = spalten[col].replace(" ","").replace(".","").replace("-","").replace("(","").replace(")","")
except:
spalte = " x x x"
if spalte.lower().startswith(entry1): # check whether the
if anz == 1: # position info is correct
vars(v)[entry] = spalten[col+1]
elif anz == 2:
vars(v)[entry] = spalten[col+1] + spalten[col+2]
elif anz == 9:
vals = []
offset = 1
while (0 == 0):
if not tree[row+offset].strip() == "":
break
offset = offset + 1
zusatz = tree[row+offset].split(";")
if zusatz[0].strip() == "":
offset = offset + 1
else:
zusatz = None
while (0 == 0):
spalten3 = tree[row+offset].split(";")
if len(spalten3) < 4 or len(spalten3) < col+1:
break
if zusatz and not spalten3[col].strip() == "":
vals.append(spalten3[col]+zusatz[col])
else:
vals.append(spalten3[col])
offset = offset + 1
vars(v)[entry] = vals
else:
text = ""
for zeile3 in tree[row:]:
if zeile3.strip() == "":
vars(v)[entry] = text
break
text = text + zeile3 + "\n"
break # and go out, if it is the case
#-----------------------------------------------------------------------------------------
if "_" in entry: # here we try to find the right position info
[entry0,entry1] = entry.split("_")
bed = 0
else:
entry0 = None
entry1 = entry
bed = 1
anz = 0
row = -1
row0 = -1
zeile0 = ""
for zeile in tree:
row = row + 1
if zeile.lower().startswith("index") or zeile.lower().startswith("line"):
zeile0 = zeile
continue
if entry0:
if zeile0.strip() == "":
zeile5 = zeile.replace(" ","").replace(".","").replace("-","")
zeile7 = zeile5.replace("(","").replace(")","").split(";")
if entry0 in zeile7[0].lower():
bed = 1
row0 = row
if zeile.strip() == "":
bed = 0
col = 0
spalten = zeile.split(";")
for spalte in spalten:
spalte1 = spalte.replace(" ","").replace(".","").replace("-","").replace("(","").replace(")","")
if bed == 1 and spalte1.replace(" ","").lower().startswith(entry1):
# print(entry,col,zeile0,zeile[0:30])
if entry0 and row0 == row:
anz = 9
elif col == 0 and zeile0.strip() == "":
anz = -1
elif len(spalten[col:]) < 3:
anz = 1
elif len(spalten[col:]) == 3:
anz = 2
elif re.search(r"^[A-Za-z][A-Za-z]$",spalten[col+2]):
anz = 2
else:
anz = 1
if entry0:
self.sections[entry] = [row0,row,col,anz]
else:
self.sections[entry] = [row,col,anz]
# print(entry,self.sections[entry])
break
col = col + 1
if not anz == 0:
break
zeile0 = zeile
if anz == 0:
print("105. " + entry + " not found.")
return("105. Not found.")
(e,f,g,h,i,j,k,l,m,n) = ( Rule(),Rule(),Rule(),Rule(),Rule(),
Rule(),Rule(),Rule(),Rule(),Rule() )
# self.mark("tree evaluated")
self.execute_rule(v,e,f,g,h,i,j,k,l,m,n)
# self.mark("dbcols set")
# for x in vars(e):
# print(vars(e)[x])
# for x in vars(f):
# print(vars(e)[x])
# for x in vars(g):
# print(vars(e)[x])
# self.mark("printed")
return(v,e,f,g,h,i,j,k,l,m,n)
#**********************************************************************************************
def parsing_loop (self,wait_if_idle=100,processing_dirs=["."]):
self.dbh__database()
self.interval = 1.0 / float(self.max_cycles)
time1 = time.time() - 0.001
while (0 == 0):
time0 = time1
time1 = time.time()
print(time0,time1)
if time1 > self.endtry:
print("Trial period is expired.")
return()
tdiff = time1 - time0
trialtime = time1 - self.starttry
halbwertsperioden = 0
if self.idouble > 10: # Zeit, nach der sich das Auswerteintervall verdoppelt
halbwertsperioden = int(trialtime/self.idouble)
# print ("TT",trialtime,self.idouble)
interval = self.interval * 2**halbwertsperioden
sleeptime = interval - tdiff
# print("HH",halbwertsperioden,tdiff,"SLEEP",sleeptime,"GESAMT",tdiff+sleeptime)
if sleeptime > 0:
time.sleep(sleeptime)
time1 = time1 + sleeptime
# print(time1)
file_found = ""
basedir = ""
processing_dirs1 = []
for dir in processing_dirs:
if dir[-2:] == "**":
dir = dir[:-2]
processing_dirs1 = processing_dirs1 + [x(0) for x in os.walk(dir)]
else:
processing_dirs1 = processing_dirs1 + glob.glob(dir)
for dir in processing_dirs1:
if not os.path.isfile(dir+"/"+self.id + ".id"):
open(dir+"/"+self.id+".id","w").write("1\n")
dateilist = glob.glob(dir + "/*.csv")
for datei in dateilist:
dateiroot = datei[0:-4]
if not os.path.isfile(dateiroot+".processed"):
if not os.path.isfile(dir+"/"+dateiroot+".process"):
open(dir+"/"+dateiroot+".process","w").write("1\n")
file_found = dateiroot
basedir = dir
break
if not file_found == "":
break
if file_found == "":
print("")
print( " No file found.","("+str(int(time.time()))+")")
time.sleep(0.001*wait_if_idle)
# return()
continue
if not os.path.isfile(basedir+"/"+self.id + ".id"):
return("101")
if ("%21.20f" % time.perf_counter())[-1] == "7":
if len(glob.glob(basedir+"/*.id")) > 1:
return("102")
print("Parse " + file_found+".csv","("+str(int(time.time()))+")")
try:
csv_file_text = open(file_found+".csv").read()
except:
csv_file_text = open(file_found+".csv",encoding="latin-1").read()
(v,e,f,g,h,i,j,k,l,m,n) = self.evaluate_db_rule(csv_file_text)
self.write_db(v,e,f,g,h,i,j,k,l,m,n)
if "_delete_csv" in vars(v) and v._delete_csv == 1:
os.unlink(file_found+".csv")
else:
open(dateiroot+".processed","w").write("1\n")
os.unlink(dateiroot+".process")
#****************************************************************************************
def write_db (self,v,e,f,g,h,i,j,k,l,m,n):
self.mark("start_write_db")
text = []
try:
v._keylen
except:
v._keylen = 4
try:
v._speed
except:
v._speed = 1
v._keylen = v._keylen * (1 + v._speed)
cyclekey = ""
cursor = self.dbh.cursor()
while (0 == 0):
while (0 == 0):
cyclekey = cyclekey + str(random.randint(100000000000,999999999999)) # eindeutiger key des Zyklus
if len(cyclekey) > 400:
break
cyclekey = hashlib.shake_256(bytearray(cyclekey,"utf8")) # .hexdigest(6)
cyclekey = cyclekey.hexdigest(v._keylen)
# cyclekey = str( base64.b64encode(cyclekey.digest(6)), "utf-8" )
if "+" in cyclekey or "/" in cyclekey:
continue
if v._speed == 1: # wenn dieser Test uebersprungen wird, dann sind auch die keys doppelt so lang
break
bed = 0
for tabelle in ([e,f,g,h,i,j,k,l,m,n]): # gehe durch jede Tabelle und pruefe, ob schon
try: # dieser cyclekey existiert
cursor.execute("select CYCLEKEY from " + tabelle.TABLE + " where CYCLEKEY='"+cyclekey+"'")
except:
continue
if cursor.fetchone():
bed = 1
break
if bed == 0:
break
for tabelle in ([e,f,g,h,i,j,k,l,m,n]): # gehe durch jede Tabelle
spalten = []
werte = []
tablename = ""
cyclekey1 = cyclekey
for x in vars(tabelle): # sammle alle Werte
if x == "TABLE":
tablename = vars(tabelle)[x]
elif x == "CYCLEKEY":
cyclekey1 = vars(tabelle)[x]
else:
spalten.append(x)
val = vars(tabelle)[x]
if not type(val) == type([]):
val = [val]
werte.append(val)
if tablename == "":
continue
tpl = "INSERT INTO " + tablename + " (CYCLEKEY,CYCLECOUNT," + ",".join(spalten) + ") VALUES (\""+cyclekey1+"\",\""
cursor = self.dbh.cursor()
cyclecount = 0
while (0 == 0): # schreibe alle zeilen als insert statements (zu jedem zyklus koennen mehrere werte
# in der tabelle stehen)
bed = 0
values = [str(cyclecount+1)]
vdata = []
for x in werte:
if len(x) > cyclecount:
values.append('?')
vdata.append(x[cyclecount])
bed = 1
else:
values.append('?')
vdata.append(x[-1])
# values.append('')
if bed == 0:
break
join_values = '","'.join(values) + "\")"
join_values = re.sub(r"\"\?\"","?",join_values,9999)
text.append(tpl + join_values)
text.append(",".join(vdata))
while (0 == 0): # add tables and columns as long as there are some missing
try:
if cursor.execute(tpl + join_values,vdata):
break
except Exception as e:
if re.search(r"^UNIQUE",str(e),re.IGNORECASE):
break
m = re.search(r"(Unknown +column .*?|no +column +named +)([A-Z0-9\_]+)",str(e))
if m:
o = m.group(2) # column extension
cursor.execute("alter table " + tablename + " add column " + o + " TEXT")
cursor.execute("create index " + o + "_" + tablename + "_idx on " + tablename + "(" + o + ")")
else:
m = re.search(r"(table|TABLE)",str(e))
if m:
cursor.execute("create table " + tablename +
"(CYCLEKEY TEXT,CYCLECOUNT TEXT, UNIQUE(CYCLEKEY,CYCLECOUNT))")
cursor.execute("create index CYCLEKEY_"+tablename+"_idx on " + tablename + "(CYCLEKEY)")
else:
print("117.",str(e))
return("117. " + str(e)) # if there is another error
cyclecount = cyclecount + 1
self.dbh.commit()
# text = "\n".join(text) + "\n"
# print(text)
self.mark("end_write_db")
return(text)
#****************************************************************************************
exec('def execute_rule (self,V,E,F,G,H,I,J,K,L,M,N):\n\n'
+ re.sub("\n","\n ","\nself=''\n"+
re.sub(r"json *\(","json1(",
re.sub(r"hash *\(","hash1(",open(glob.glob("*.rule")[0]).read()))))
# self = '' for avoid hacking
#****************************************************************************************
def standard (self,*pars):
self.parse_db_rule()
self.parsing_loop()
#****************************************************************************************
#****************************************************************************************
def test1 (self,*pars):
self.mark("A")
self.xy16_parser()
self.parse_db_rule('')
erg = self.parser.parse(open("xyexample.csv").read())
self.mark("B")
for el in erg.find_data("servo"):
for el1 in el.find_data("settingline"):
print(el1.children[0].value)
for ch in next(erg.find_data("values")).children:
for vv in ch.children[0:3]:
print(vv.value)
print("")
self.mark("C")
# p.processing_dirs = (".")
# p.parsing_loop()
#****************************************************************************************
def test2 (self,*pars):
self.parse_db_rule()
self.mark("db rules parsed")
# erg = self.parser.parse(open("xyexample.csv").read())
erg = open("xyexample.csv").read()
self.mark("file opened")
(v,e,f,g,h,i,j,k,l,m,n) = self.evaluate_db_rule(erg)
self.mark("dbcols set")
for x in vars(e):
print(x,vars(e)[x])
for x in vars(f):
print(x,vars(f)[x])
for x in vars(g):
print(x,vars(g)[x])
self.mark("printed")
#****************************************************************************************
def test3 (self,*pars):
os.system("rm *rocess*")
os.system("del *rocess*")
self.parse_db_rule()
self.mark("db rules parsed")
# erg = self.parser.parse(open("xyexample.csv").read())
self.parsing_loop()
# erg = open("xyexample.csv").read()
# self.mark("file opened")
# self.evaluate_db_rule(erg)
#****************************************************************************************
def test4 (self,*pars):
skey = SigningKey.generate()
skey = self.hex_to_byte(skey)
skey = SigningKey.from_string(skey)
vkey = skey.verifying_key
signature = skey.sign(bytearray(open("xyexample.csv").read(),"utf-8"))
print(skey.to_string().hex())
print(signature.hex())
print(vkey.verify(signature,bytearray(open("xyexample1.csv").read(),"utf-8")))
#****************************************************************************************
#****************************************************************************************
#****************************************************************************************
#****************************************************************************************
# DEL_BEGIN
def xxxy16_parser (self):
grammar = '''
start: " "* "\\n"* header
"\\n"+ index
"\\n"+ resultinfo
"\\n"+ procvalcurve
"\\n"+ procvaleo
"\\n"+ eosettings
"\\n"+ switchsignals
"\\n"+ deviceinfo
"\\n"+ servo
"\\n"+ channelx
"\\n"+ channely
"\\n"+ cyclecontrol
"\\n"+ evalsettings
"\\n"+ triggery
"\\n"+ blocksettings
"\\n"* measuringcurve
"\\n"* values
"\\n"* sequence
"\\n"*
header: "Part protocol"
"\\nFile name" filename
"\\nProtocol version" protocolversion
filename: /;[A-Za-z0-9\-\_\-\.]*/
protocolversion: /;[0-9\.]*/
index: "Index;Result information;Process values - curve related;Process values - EO related;Evaluation objects settings;Switch signal settings;Device information;Servo;Channel-X settings;Channel-Y settings;Cycle control settings;Evaluation settings;Trigger Y settings;Block settings;Measuring curve;Measuring points;Sequence;"
"\\nLine" linenumbers
linenumbers: /;[0-9\;]*/
resultinfo: "Result information"
"\\nDate" date
"\\nTime" time
"\\nCycle number" cyclenumber
"\\nTotal result" totalresult
"\\nTriggered switch signals" triggeredswitchsignals
"\\nPart serial number" partserialnumber
"\\nMeasuring program name" measuringprogramname
"\\nMeasuring program number" measuringprogramnumber
"\\nZero X offset" zeroxoffset
"\\nTara Y offset" tarayoffset
date: /;\d\d\d\d\/\d\d\/\d\d/
time: /;\d\d\:\d\d\:\d\d/
cyclenumber: integer
totalresult: /;(OK|NOK)/
triggeredswitchsignals: string
partserialnumber: string
measuringprogramname: string
measuringprogramnumber: integer
zeroxoffset: number unitx
tarayoffset: number unity
integer: /;\d*/
number: /;\-?\d*[,\.]?\d*/
string: /;[A-Za-z\d\.\,\-\+\_\/\;\%\|\(\) ]*/
unitx: /;[A-Za-z]+/
unity: /;[A-Za-z]+/
unitz: /;[A-Za-z\-]*/
procvalcurve: "Process values - curve related"
"\\nBlock X" curveblockx ";XMIN-X" curvexminx
"\\nBlock Y" curveblocky ";XMIN-Y" curvexminy
"\\nRef X" curverefx ";XMAX-X" curvexmaxx
"\\nPeak-peak X" curvepeakpeakx ";XMAX-Y" curvexmaxy
"\\nPeak-peak Y" curvepeakpeaky ";YMIN-X" curveyminx
"\\n" ";"+ ";YMIN-Y" curveyminy
"\\n" ";"+ ";YMAX-X" curveymaxx
"\\n" ";"+ ";YMAX-Y" curveymaxy
curveblockx: number unitx
curveblocky: number unity
curverefx: number unitx
curvepeakpeakx: number unitx
curvepeakpeaky: number unity
curvexminx: number unitx
curvexminy: number unity
curvexmaxx: number unitx
curvexmaxy: number unity
curveyminx: number unitx
curveyminy: number unity
curveymaxx: number unitx
curveymaxy: number unity
procvaleo: "Process values - EO related" procvaleocols
"\\n" dimprocessvalues
"\\nEO-01" eoaprocessvalues
"\\nEO-02" eobprocessvalues
"\\nEO-03" eocprocessvalues
"\\nEO-04" eodprocessvalues
"\\nEO-05" eoeprocessvalues
"\\nEO-06" eofprocessvalues
"\\nEO-07" eogprocessvalues
"\\nEO-08" eohprocessvalues
"\\nEO-09" eoiprocessvalues
"\\nEO-10" eojprocessvalues
procvaleocols: string
dimprocessvalues: string
eoaprocessvalues: string
eobprocessvalues: string
eocprocessvalues: string
eodprocessvalues: string
eoeprocessvalues: string
eofprocessvalues: string
eogprocessvalues: string
eohprocessvalues: string
eoiprocessvalues: string
eojprocessvalues: string
eosettings: "Evaluation objects settings" eosettingscols
"\\nEO-01" eoasettingsvalues
"\\nEO-02" eobsettingsvalues
"\\nEO-03" eocsettingsvalues
"\\nEO-04" eodsettingsvalues
"\\nEO-05" eoesettingsvalues
"\\nEO-06" eofsettingsvalues
"\\nEO-07" eogsettingsvalues
"\\nEO-08" eohsettingsvalues
"\\nEO-09" eoisettingsvalues
"\\nEO-10" eojsettingsvalues
eosettingscols: string
eoasettingsvalues: string
eobsettingsvalues: string
eocsettingsvalues: string
eodsettingsvalues: string
eoesettingsvalues: string
eofsettingsvalues: string
eogsettingsvalues: string
eohsettingsvalues: string
eoisettingsvalues: string
eojsettingsvalues: string
switchsignals: "Switch signal settings" switchsignalcols
"\\nType S1" switchsignala
"\\nType S2" switchsignalb
switchsignalcols: string
switchsignala: string
switchsignalb: string
deviceinfo: "Device information" ";"* ( "\\n" settingline )+ "\\n"
servo: "Servo" ";"* ( "\\n" settingline )+ "\\n"
channelx: "Channel-X settings" ";"* ( "\\n" settingline )+ "\\n"
channely: "Channel-Y settings" ";"* ( "\\n" settingline )+ "\\n"
cyclecontrol: "Cycle control settings" ";"* ( "\\n" settingline )+ "\\n"
evalsettings: "Evaluation settings" ";"* ( "\\n" settingline )+ "\\n"
triggery: "Trigger Y settings" ";"* ( "\\n" settingline )+ "\\n"
blocksettings: "Block settings" ";"* ( "\\n" settingline )+ "\\n"
measuringcurve: "Measuring curve" ";"* ( "\\n" settingline )+ "\\n"+
"Time" settingline
values: "\\n" settingline "\\n" dataline+
sequence: "Sequence Editor" ";"* ( "\\n" settingline )+ "\\n"
settingline: /[A-Za-z\d\.\,\-\+\_\/\%\|\(\)\; ]+/
dataline: /[\d\,\-\;]+/ "\\n"
'''
grammar = re.sub(r"\n +([a-z]+\:)","\n\\1",grammar,99999999,re.DOTALL)
grammar = re.sub(r"\n +([A-Z]+\:)","\n\\1",grammar,99999999,re.DOTALL)
grammar = re.sub("\n +([^\n])"," \\1", grammar,99999999,re.DOTALL)
self.parser = Lark(grammar,parser="lalr")
#****************************************************************************************
def xxparse_db_rule (self,db_rule):
self.db_rule = []
self.entries = []
zeilen = [] # Multilines zusammenfuegen, Kommentare entfernen
for zeile in db_rule.split("\n"):
zeile1 = re.sub(r"\#.*$","",zeile)
if zeile1.strip() == "":
continue
if zeile1[0] == " ":
zeilen[-1] = zeilen[-1] + " " + zeile1
else:
zeilen.append(zeile1)
zeilen1 = []
for zeile in zeilen: # Pre-Prozessor fuer 10 EOs
if "[i]" in zeile:
zaehler = "01"
while (0 == 0):
zeilen1.append(re.sub(r"\[i\]",zaehler,zeile))
if zaehler == "10":
break
zaehler = "%02u" % (int(zaehler) + 1)
else:
zeilen1.append(zeile)
for zeile in zeilen1: # Alle benoetigten Variablen auflisten
while (0 == 0):
m = re.search("^(.*?R\.)([A-Za-z][A-Za-z\_\d]*)(.*$)",text,re.DOTALL)
if not m:
b = b + text
break
val_field = m.group(2)
if not val_field in self.entries:
self.entries.append(val_field)
b = b + m.group(1) + "self.RULE['" + m.group(2) + "']"
text = m.group(3)
self.db_rule.append([a,b])
#****************************************************************************************
def xxevaluate_db_rule (self,tree):
v = Rule()
e = Rule()
for val_field in self.entries:
print(val_field)
vars(v)[val_field] = ""
for ch in next(tree.find_data(val_field)).children:
if type(ch).__name__ == "Tree":
vars(v)[val_field] += ch.children[0].value.replace(";","")
else:
vars(v)[val_field] = ch.value.replace(";","")
self.mark("100")
self.execute_rule(v,e)
self.mark("101")
print(vars(e))
self.mark("102")
# DEL_END
#****************************************************************************************
if __name__ == "__main__":
XYparser(*tuple(["__main__"]+sys.argv[1:]))