def keyPressEvent(self, event):
if event.key() == Qt.Key_Delete:
if self.m_chooseShape != None:
self.m_chooseShape.setColor(False)
print 'key delete'
History.Push(self.m_lShape)
if self.m_chooseShape.isRect() or self.m_chooseShape.isDiamond(
):
self.RemoveRect(self.m_chooseShape.m_nId)
elif self.m_chooseShape.isLine():
self.RemoveLine(self.m_chooseShape.m_nId)
self.m_chooseShape = None
self.update()
elif event.modifiers() == (
Qt.ControlModifier) and event.key() == Qt.Key_Z:
self.m_lShape = History.Pop(self.m_lShape)
self.update()
if self.m_chooseShape == True:
self.m_chooseShape.setColor(False)
self.m_chooseShape = None
self.m_shape = None
self.m_perm = True
if self.m_curAction != None:
self.m_curAction.setChecked(False)
self.m_curAction = None
self.m_curShapeCode = -1
def on_finish_loading(self, widget, frame):
url = self.webview.get_main_frame().get_uri()
# set the security icon
if "https://" in url:
self.secure_icon.set_from_stock(gtk.STOCK_YES, gtk.ICON_SIZE_MENU)
else:
self.secure_icon.set_from_stock(gtk.STOCK_STOP, gtk.ICON_SIZE_MENU)
# set the url bar
self.url_textbox.set_text(url)
# add history
title = self.webview.get_title()
time = datetime.datetime.now().strftime("%H:%M:%S")
date = datetime.datetime.now().date()
h = History()
h.insert_history(title, url, time, date)
# check bookmark
if title in bookmarks_list:
image = gtk.Image()
image.set_from_file("bookmarked.ico")
self.bookmark_image.set_active(True)
self.bookmark_image.set_image(image)
else:
image = gtk.Image()
image.set_from_file("not_bookmarked.ico")
self.bookmark_image.set_active(False)
self.bookmark_image.set_image(image)
def VLAUVFITS(inUV, filename, outDisk, err, compress=False, \
exclude=["AIPS HI", "AIPS AN", "AIPS FQ", "AIPS SL", "AIPS PL"], \
include=[], headHi=False):
""" Write UV data as FITS file
Write a UV data set as a FITAB format file
History written to header
inUV = UV data to copy
filename = name of FITS file
inDisk = FITS directory number
err = Python Obit Error/message stack
exclude = List of table types NOT to copy
NB: "AIPS HI" isn't really a table and gets copied anyway
include = List of table types to copy (FQ, AN always done )
Exclude has presidence over include
headHi = if True move history to header, else leave in History table
returns FITS UV data object
"""
################################################################
# Checks
if not UV.PIsA(inUV):
raise TypeError, "inUV MUST be a Python Obit UV"
if not OErr.OErrIsA(err):
raise TypeError, "err MUST be an OErr"
#
# Set output
outUV = UV.newPFUV("FITS UV DATA", filename, outDisk, False, err)
if err.isErr:
OErr.printErrMsg(err, "Error creating FITS data")
#Compressed?
if compress:
inInfo = UV.PGetList(outUV) #
dim = [1, 1, 1, 1, 1]
InfoList.PAlwaysPutBoolean(inInfo, "Compress", dim, [True])
# Copy
UV.PCopy(inUV, outUV, err)
if err.isErr:
OErr.printErrMsg(err, "Error copying UV data to FITS")
# History
inHistory = History.History("inhistory", outUV.List, err)
outHistory = History.History("outhistory", outUV.List, err)
# Add history
outHistory.Open(History.READWRITE, err)
outHistory.TimeStamp(" Start Obit uvtab", err)
outHistory.WriteRec(
-1, "uvtab / FITS file " + filename + " disk " + str(outDisk), err)
outHistory.Close(err)
# History in header?
if headHi:
History.PCopy2Header(inHistory, outHistory, err)
OErr.printErrMsg(err, "Error with history")
# zap table
outHistory.Zap(err)
# Copy Tables
UV.PCopyTables(inUV, outUV, exclude, include, err)
return outUV # return new object
def CalculateSeasonWeight(recipe):
'''
Calculate weight factor based on season
'''
today = datetime.date.today()
seasons = recipe.Seasons()
if seasons.find('s') < 0 and History.IsSpring(today):
return 0
if seasons.find('u') < 0 and History.IsSummer(today):
return 0
if seasons.find('f') < 0 and History.IsFall(today):
return 0
if seasons.find('w') < 0 and History.IsWinter(today):
return 0
return 1
def set_url(self, url, baseurl=None, target=None, histify=1):
"""Set loaded URL, base URL and target for the current page.
The loaded URL is what this page was loaded from; the base URL
is used to calculate relative links, and defaults to the
loaded URL. The target is the default viewer name
where followed links will appear, and defaults to this viewer.
HISTIFY flag, if true, adds the URL to the history stack.
"""
if url and histify:
# don't lose title if we have one:
title, when = self.app.global_history.lookup_url(url)
self.app.global_history.remember_url(url, title or '')
if not self.page:
self.page = History.PageInfo(url)
self.history.append_page(self.page)
else:
self.page.set_url(url)
self.page.set_title("") # Will be reset from fresh HTML
self.history.refresh()
else:
if self.future >= 0:
self.page = self.history.page(self.future)
self.future = -1
else:
self.page = None
URIContext.set_url(self, url, baseurl=baseurl)
self._target = target
if self.on_top():
self.browser.set_url(self.get_url())
self.applet_group = None
def manage_historyCompare(self, rev1, rev2, REQUEST,
historyComparisonResults=''):
return DTMLMethod.inheritedAttribute('manage_historyCompare')(
self, rev1, rev2, REQUEST,
historyComparisonResults=History.html_diff(
rev1.read(), rev2.read()
))
def initUI(self):
self.preDefined = PreDefined.myPreDefined(self)
self.userDefined = UserDefined.myUserDefined(self)
self.history = History.myHistory()
self.addTab(self.preDefined, '预设风格')
self.addTab(self.userDefined, '自定义风格')
self.addTab(self.history, '历史记录')
def history(instrument,
start_date,
num_days=100000,
host="localhost",
port=9100):
'''
Generates history lines for a given instrument
'''
if type(start_date) == types.StringType:
start_date = datetime.date(int(start_date[0:4]), int(start_date[5:7]),
int(start_date[8:10]))
_q = Queue.Queue()
_qp = _QueueProducer(_q)
client = History.HistoryClient((host, port))
client.set_listener('', _qp)
client.getHistory(instrument, start_date, num_days)
while 1:
try:
# Wait until a new message is available
message = _q.get()
if message is None:
break
yield message
except KeyboardInterrupt:
break
client.del_listener('')
def SaveNClean(defject, vertices, i, content):
#save all there is to run from current iteration and clean up proper
rs.Command("_SelNone")
rs.Command("_SelPolysrf")
index = i
if index < 10:
j = "0" + str(index)
if index >= 10:
j = index
#Quite probably there is a purely scripted way of writing the export now
#It would be through the Rhino and scriptcontext
rs.Command("_-Export C:\R3\OffCenter\Walk\Temp\proto2o" + j + ".igs ENTER")
rs.DeleteObject(defject)
for vrtx in vertices:
rs.AddPolyline(vrtx)
#Again
rs.Command("-saveas C:\\R3\OffCenter\Walk\Temp\sth" + j + ".3dm")
objects = rs.AllObjects()
rs.DeleteObjects(objects)
#need a place to write our polies to!!!
History.WritePolies(tempfolder + "\polies" + j + ".txt", content)
def mouseMoveEvent(self, event):
if self.m_chooseShape != None and self.m_chooseShape.hasCorner() != -1:
self.MoveReShape(event)
return
#处理被选中的物体的拖动，这里线是不能被拖动的
DeltaMoveObj = QPoint()
if self.m_chooseShape != None and (
self.m_chooseShape.isRect() == True
or self.m_chooseShape.isDiamond() == True
or self.m_chooseShape.isComment() == True):
if self.m_bMoving == True:
self.m_bMoving = False
self.m_chooseShape.setColor(False)
History.Push(self.m_lShape)
self.m_chooseShape.setColor(True)
self.m_curPoint = event.pos()
DeltaMoveObj = self.m_curPoint - self.m_prePoint
self.m_chooseShape.move(DeltaMoveObj)
#所有线段检查是否和这个矩形有关系，如果有，移动
for shape in self.m_lShape:
if shape.isLine() == True:
shape.move(DeltaMoveObj, self.m_chooseShape.m_nId)
self.m_prePoint = self.m_curPoint
self.update()
return
if self.m_shape and self.m_perm == False:
self.m_shape.setEnd(event.pos())
self.update()
return
def show_bookmarks(self):
if self.history_box.get_property("visible"):
self.hide_history(self.history_box)
if self.bookmarks_box.get_property("visible"):
self.bookmarks_box.hide()
self.bottom_hpan.remove(self.bookmarks_box)
self.bookmarks_list_store.clear()
column_list = self.bookmarks_tree_view.get_columns()
for iter_column in column_list:
self.bookmarks_tree_view.remove_column(iter_column)
else:
self.bottom_hpan.add1(self.bookmarks_box)
h = History()
h.cursor.execute("select title from bookmarks")
row = h.cursor.fetchone()
while row:
self.bookmarks_list_store.append(row)
row = h.cursor.fetchone()
for i, col_title in enumerate(["Title"]):
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(col_title, renderer, text=i)
self.bookmarks_tree_view.append_column(column)
self.bookmarks_box.show_all()
async def server(self, websocket, path):
req = await websocket.recv()
req = json.loads(req)
if req['msg'] == 'method':
if req['method'] == 'getHistory':
h = History.History('/home/pi/OS/HistoryDB.json')
res = {'msg': 'result', 'result': h.get()}
await websocket.send(json.dumps(res))
if req['method'] == 'getEnergy':
e = Energy.Energy('/home/pi/OS/EnergyDB.json')
if not req['params']:
res = {'msg': 'result', 'result': e.get()}
else:
resultArray = []
params = req['params']
if len(params) > 0:
for p in params:
resultArray.append(e.get(p))
res = {'msg': 'result', 'result': resultArray}
await websocket.send(json.dumps(res))
else:
res = {
'msg': 'error',
'error': 'unrecognized request',
'code': 501
}
await websocket.send(json.dumps(res))
print("sent response")
def MFPBCor(inIm, err, antSize=24.5, minGain=0.05):
"""
Apply primary beam corrections to an ImageMF
WARNING: This routine modifies the input image;
ONLY RUN IT ONCE.
* inIm = Image to be modified
* err = Python Obit Error/message stack
* antSize = Antenna diameter in m.
* minGain = Minimum antenna gain
"""
# Check
if not inIm.ImageIsA():
raise TypeError("input MUST be a Python Obit Image")
# Image info
nterm = inIm.Desc.List.Dict['NTERM'][2][0]
nspec = inIm.Desc.List.Dict['NSPEC'][2][0]
freqs = []
for i in range(1, nspec + 1):
key = 'FREQ%4.4d' % i
freqs.append(inIm.Desc.List.Dict[key][2][0])
# end loop
# Make scratch image for beam
beam = Image.Image("PBeam")
Image.PCloneMem(inIm, beam, err)
OErr.printErrMsg(err, "Error with scratch beam image")
# Loop over planes
for i in range(1, nspec + 1):
# Read plane
plane = [i + nterm, 1, 1, 1, 1]
Image.PGetPlane(inIm, None, plane, err)
OErr.printErrMsg(err, "Error reading image")
# Set frequency for PBCor
d = inIm.Desc.Dict
d['crval'][2] = freqs[i - 1]
inIm.Desc.Dict = d
# Make PB Image
ImageUtil.PPBImage(beam,
beam,
err,
minGain=minGain,
antSize=antSize,
outPlane=plane)
OErr.printErrMsg(err, "Error making PB image")
# Divide
FArray.PDivClip(inIm.FArray, beam.FArray, minGain, inIm.FArray)
# Rewrite plane
Image.PPutPlane(inIm, None, plane, err)
OErr.printErrMsg(err, "Error writing image")
# end loop
# Add history
outHistory = History.History("history", inIm.List, err)
outHistory.Open(History.READWRITE, err)
outHistory.TimeStamp(" Start Obit MFPBCor", err)
outHistory.WriteRec(-1, "MFPBCor" + " antSize = " + str(antSize), err)
outHistory.WriteRec(-1, "MFPBCor" + " minGain = " + str(minGain), err)
outHistory.Close(err)
def MainS():
#SETTING UP THE FILE ACCESS TO READ ALL THERE IS TO BE READ
#THE SCRIPT FROM NOW ON LOOKS for FILE AND if IT CANNOT FIND ONE IT WILL HAVE TO MAKE ONE
#SOOO WE START BY LOOKING for AND READING THE FILE if WE FIND IT
##
########################################################################
#READ INFO IN THE FILE
########################################################################
#ReadFile returns an array of [isAlive,startPoint,jointNos]
content = History.ReadPolies(folder,file)
rhUnitInches = 8
rs.UnitSystem(rhUnitInches, False, True)
zero = [0,0,0]
zaxis = [0,0,1]
vrt = []
#Decimal display and decimal places
#rs.UnitDistanceDisplayMode(0)
#rs.UnitDistanceDisplayPrecision(7)
#sth to control that we have an [0,0,0] to check
endcheck = 1
size = 1
helper =[]
#if we read nothing we should save 1 starting point - namely [0,0,0]
if content is None:
endpts = [[0,0,0]]
npolies = 0
#polylines is an array of polylines
#polyline is an array of points
#point is an array of numbers
#life#starting_point#joints_used
sequence = [1,[0,0,0],[0]]
#content = [[sequence],0]
content = [sequence]
else:
#checking if new rib has actualy been started
#[0,0,0] will always be the lasrt one
for i = 0 To content(1]
if rs.Distance(content(0](i](1],[0,0,0]]<tiny Then
endcheck = endcheck*0
End if
def historyDetailJson():
row = History.Get(request.query.time)
return "{" + \
"\"path\":\"" + row[0] + "\"," + \
"\"user\":\"" + row[1] + "\"," + \
"\"comment\":\"" + row[2] + "\"," + \
"\"time\":\"" + row[3] + "\"" + \
"}"
def __init__(self, data=None):
"""
Initialize the QuadsData object.
"""
self.hosts = Hosts.Hosts(data)
self.clouds = Clouds.Clouds(data)
self.history = History.History(data)
self.cloud_history = CloudHistory.CloudHistory(data)
def mousePressEvent(self, event):
"""
@ 鼠标单击事件
"""
self.m_prePoint = event.pos()
#判断是否选中了直线的一端，如果选中了，需要触发编辑功能
if self.m_sChooseShapeName != None and self.m_sChooseShapeName != "":
shapeObj = self.m_dShape[self.m_sChooseShapeName]
if shapeObj.isLine() == True:
if shapeObj.getCorner(event.pos()) != -1:
History.push(self.m_dLayers)
#启动编辑对m_dLayer的输入输出产生影响
self.removeLine(self.m_sChooseShapeName)
return
self.PressChooseShape(event)
return
def readLog(path):
# Reader de log de NOMAD et creer un objet history consequent
# Regarde par le nom les specs de la run
file=path.split('\\')[-1]
name = file.split('_')
ext = name[-1].split('.')[2]
name[-1]=name[-1].split('.')[0]
name.append(ext)
#Erreur si on a pas un file history
if name[2]!='history':
print('file provided is not of the right format')
return
#On cree un objet history
history=History.History()
#Nom, Classe, solveur et parametre de resolution du probleme
history.setProblem(str(name[0])+str(name[1]))
history.setProblemNumber(str(name[0]))
history.setProblemClass(str(name[1]))
history.setSeed(str(name[3]))
history.setAlgo(str(name[4][0]))
history.setStrat(str(name[4][1:]))
history.setSolver('NOMAD')
# Ouvrir le history.txt
with open(path, 'r') as file:
iniFile = file.readlines()
file.close()
# Mettre la history dans l'objet
nbIteration = len(iniFile) #nombre de lignes dans le fichier
table = [] # initialisation de ma liste
for x in range(0, nbIteration):
# Pour chaque ligne de mon history je dois
# creer une liste
# appender la liste a l indice x du array
ligne = list(map(float, (iniFile[x]).split())) # creer la ligne de float
table.append(ligne) # ajoute a la table
history.setTable(table)
# Determiner la dimension du probleme
paramPath = path[:-(len(path.split('\\')[-1]))]
paramName = history.getSeed()+'_param.txt'
paramFile = paramPath+paramName
with open(paramFile, 'r') as f:
# Ouvrir le parameters.txt
params = f.readlines()
f.close()
for el in params:
if el.split() and el.split()[0]=='DIMENSION':
dim = el.split()[1]
history.setNbVar(dim)
return history
def test_trend_forecasting_model(test_years,
min_trend_h,
model_years=None,
model_hist=None,
strict_mode=False,
mode="avg"):
if not model_years and not model_hist:
raise Exception(
"You must provide a model history or year for a model history!"
)
if model_years:
if type(model_years) is not list:
model_years = list(model_years)
if len(model_years) > 2:
model_years = [model_years[0], model_years[-1]]
if type(test_years) is not list:
test_years = list(test_years)
if len(test_years) > 2:
test_years = [test_years[0], test_years[-1]]
if model_hist:
anal = Analyzer(model_hist,
min_trend_h=min_trend_h,
realistic=False)
else:
h = History("GER30", *model_years)
anal = Analyzer(h, min_trend_h=min_trend_h, realistic=False)
anal.get_intern_trend_prediction_error(p=True,
use_strict_mode=strict_mode,
mode=mode)
test_anal = Analyzer(History("GER30", *test_years),
min_trend_h=min_trend_h,
realistic=False)
anal.get_extern_trend_prediction_error(test_anal.trend_list,
p=True,
use_strict_mode=strict_mode,
mode=mode)
def createNewHistory(self, wherex, wherey, screenCoordinates=1):
self.fromClass = None
self.toClass = None
# try the global constraints...
res = self.ASGroot.preCondition(ASG.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
new_semantic_obj = History(self)
res = new_semantic_obj.preCondition(ASGNode.CREATE)
if res: return self.constraintViolation(res)
new_semantic_obj.preAction(ASGNode.CREATE)
ne = len(self.ASGroot.listNodes["History"])
if new_semantic_obj.keyword_:
new_semantic_obj.keyword_.setValue(
new_semantic_obj.keyword_.toString() + str(ne))
if screenCoordinates:
new_obj = graph_History(self.UMLmodel.canvasx(wherex),
self.UMLmodel.canvasy(wherey),
new_semantic_obj)
else: # already in canvas coordinates
new_obj = graph_History(wherex, wherey, new_semantic_obj)
new_obj.DrawObject(self.UMLmodel, self.editGGLabel)
self.UMLmodel.addtag_withtag("History", new_obj.tag)
new_semantic_obj.graphObject_ = new_obj
self.ASGroot.addNode(new_semantic_obj)
res = self.ASGroot.postCondition(ASG.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
res = new_semantic_obj.postCondition(ASGNode.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
new_semantic_obj.postAction(ASGNode.CREATE)
self.mode = self.IDLEMODE
if self.editGGLabel:
self.statusbar.event(StatusBar.TRANSFORMATION, StatusBar.CREATE)
else:
self.statusbar.event(StatusBar.MODEL, StatusBar.CREATE)
return new_semantic_obj
def keyPressEvent(self, event):
"""
@ 键盘回调函数
"""
#删除矩形或者线条
if event.key() == Qt.Key_Delete or event.key() == 16777219:
if self.m_sChooseShapeName != None and self.m_sChooseShapeName != "":
print 'key delete'
History.push(self.m_dLayers)
shapeObj = self.m_dShape[self.m_sChooseShapeName]
shapeObj.setColor(False)
if shapeObj.isRect():
self.removeRect(self.m_sChooseShapeName)
del self.m_dLayers[self.m_sChooseShapeName]
elif shapeObj.isLine():
self.removeLine(self.m_sChooseShapeName)
self.transLayersToShape()
self.m_sChooseShapeName = None
self.update()
#ctrl + z 回退错误修改
elif event.modifiers() == (
Qt.ControlModifier) and event.key() == Qt.Key_Z:
self.m_sChooseShapeName = None
self.m_dLayers = History.back(self.m_dLayers)
self.transLayersToShape()
self.update()
#ctrl + r 前进
elif event.modifiers() == (
Qt.ControlModifier) and event.key() == Qt.Key_R:
self.m_sChooseShapeName = None
self.m_dLayers = History.forward(self.m_dLayers)
self.transLayersToShape()
self.update()
#F 刷新
elif event.key() == Qt.Key_F:
for (sName, layerObj) in self.m_dLayers.items():
if sName != layerObj.GetName():
self.changeLayerName(sName, layerObj.GetName())
del self.m_dLayers[sName]
self.m_dLayers[layerObj.GetName()] = layerObj
self.transLayersToShape()
def test_trend_predictor():
h = 35
anal = Analyzer(dax_hist, min_trend_h=h)
vali_anal = Analyzer(History("GER30", 2017), min_trend_h=h)
#arti_anal = Analyzer(ArtificialHistory(dax_hist, out_len=1000000, min_trend_h=h), min_trend_h=h)
anal.build_trend_predictor(
7,
validation_data=vali_anal.trend_list,
)
def manage_historyCompare(self,
rev1,
rev2,
REQUEST,
historyComparisonResults=''):
return DTMLMethod.inheritedAttribute('manage_historyCompare')(
self,
rev1,
rev2,
REQUEST,
historyComparisonResults=History.html_diff(rev1.read(),
rev2.read()))
def createNewHistory(self, wherex, wherey, screenCoordinates = 1):
self.fromClass = None
self.toClass = None
# try the global constraints...
res = self.ASGroot.preCondition(ASG.CREATE)
if res:
self.constraintViolation(res)
self.mode=self.IDLEMODE
return
new_semantic_obj = History(self)
ne = len(self.ASGroot.listNodes["History"])
if new_semantic_obj.keyword_:
new_semantic_obj.keyword_.setValue(new_semantic_obj.keyword_.toString()+str(ne))
if screenCoordinates:
new_obj = graph_History(self.UMLmodel.canvasx(wherex), self.UMLmodel.canvasy(wherey), new_semantic_obj)
else: # already in canvas coordinates
new_obj = graph_History(wherex, wherey, new_semantic_obj)
new_obj.DrawObject(self.UMLmodel, self.editGGLabel)
self.UMLmodel.addtag_withtag("History", new_obj.tag)
new_semantic_obj.graphObject_ = new_obj
self.ASGroot.addNode(new_semantic_obj)
res = self.ASGroot.postCondition(ASG.CREATE)
if res:
self.constraintViolation(res)
self.mode=self.IDLEMODE
return
res = new_semantic_obj.postCondition(ASGNode.CREATE)
if res:
self.constraintViolation(res)
self.mode=self.IDLEMODE
return
self.mode=self.IDLEMODE
if self.editGGLabel :
self.statusbar.event(StatusBar.TRANSFORMATION, StatusBar.CREATE)
else:
self.statusbar.event(StatusBar.MODEL, StatusBar.CREATE)
return new_semantic_obj
def Detail(
no, # String(In): FileID
user # String(In): User Name
): # String(html)
global lock
global conn
global c
global videoInfo
# [[[ 1. Lock ]]]
lock.acquire()
# [[[ 2. Prepare SQLite ]]]
if conn is None:
conn = sqlite3.connect(fileName, check_same_thread=False)
c = conn.cursor()
# [[[ 3. Make <li></li> List ]]]
list = '' # return html string
# [[ 3.1. Prepare SQL statement ]]
sql = 'SELECT FileID, DirName, FileName, Size, Time FROM File WHERE FileID = ?'
# [[ 3.2. Query ]]
size = 0
time = ''
filePath = ''
for row in c.execute(sql, [no]):
size = row[3]
time = row[4]
filePath = os.path.join(row[1], row[2])
# [[[ 4. Unlock ]]]
lock.release()
# [[[ 5. Make Tag ]]]
list = filePath + "<br>" + "{:,}".format(size) + "[Byte]<br>"
list = list + time + "<br>"
if None is videoInfo:
videoInfo = VideoInfo.VideoInfo()
if (None is videoInfo.GetDuration(filePath)):
list = u"動画が見つかりません。" + "<br>" + u"曲情報を更新してください。"
else:
hour = str(int(videoInfo.GetDuration(filePath) / 3600)).zfill(2)
minutes = str(int(videoInfo.GetDuration(filePath) % 3600 /
60)).zfill(2)
seconds = str(int(videoInfo.GetDuration(filePath) % 60)).zfill(2)
list = list + hour + ":" + minutes + ":" + seconds + "<br>"
list = list + videoInfo.GetVideoEncode(filePath) + "("
list = list + videoInfo.GetResolution(filePath) + ")"
# [[ 5.1. History Count ]]
list = list + "<br>" + str(History.Count(filePath)) + u"回"
return list
def Stalin(self, startr, endr, err):
"""
Edit history
return 0 on success, else failure
* self = input Python History
* startr = first (1-rel) history record to delete
* endr = highest (1-rel) history record to delete, 0->to end
* err = Python Obit Error/message stack
"""
hi = self.History(READWRITE, err)
return History.PEdit(hi, startr, endr, err)
def __init__(self, logger, configFile, root):
""" Construt a session with the current thread logger and the configFile name. """
self.cwd = None # Working directory (discovered after crab -create)
self.root = os.path.abspath(root)
self.jobsHistory = History()
self.configFile = os.path.abspath(configFile)
self.outNames = parseOutNames(open(self.configFile).read()) # Output file names found in the UI/res after getouput
self.totJobs = None # Jobs managed (discovered after crab -crete)
self.submitted = 0 # jobs submitted
self.logger = logger
self.returncode = None
self.outdata = None
self.errdata = None
self.cmd = None
def History(self, access, err):
"""
Return the associated History
* self = Python OData object
* access = access code 1=READONLY, 2=WRITEONLY, 3=READWRITE
* err = Python Obit Error/message stack
"""
out = History.History("History", self.List, err)
#out.me = newODataHistory (self, access, err)
# Error?
if err.isErr:
OErr.printErrMsg(err, "Error getting History")
return out
def historyJson():
list = '['
firstLine = True
for row in History.List():
if True == firstLine:
firstLine = False
else:
list = list + ","
list = list + \
"{\"file\":\"" + os.path.basename(row[0]) + "\"," + \
"\"user\":\"" + row[1] + "\"," + \
"\"comment\":\"" + row[2] + "\"," + \
"\"time\":\"" + row[3] + "\"}"
return list + "]"
def createLayerCallback(self, sLayerTypeName):
"""
@ 创建新的层, 窗口关闭回调
@ sLayerTypeName 层的类型名
"""
History.push(self.m_dLayers)
try:
self.createLayerCallback.__func__.nCounter += 1
except AttributeError:
self.createLayerCallback.__func__.nCounter = 1
sLayerName = sLayerTypeName + "_" + str(
self.createLayerCallback.__func__.nCounter)
while self.m_dLayers.has_key(sLayerName) == True:
self.createLayerCallback.__func__.nCounter += 1
sLayerName = sLayerTypeName + "_" + str(
self.createLayerCallback.__func__.nCounter)
layerObj = CfgInstance.getLayerCfg(sLayerTypeName)
layerObj.m_dKeys["name"] = sLayerName
self.m_dLayers[sLayerName] = layerObj
self.transLayersToShape()
return
def CopyBeamHistory (inIm, outIm, err):
"""
Copy beam and history from one image to another (beam)
History may not appear in AIPS header (but is there)
FITS History is written to "History" table
* inIm Input Obit image
* outIm Output Obit image (beam)
* err Obit Error/message object
"""
# Copy Beam
din = inIm.Desc.Dict
dout = outIm.Desc.Dict
dout['beamMaj'] = din['beamMaj']
dout['beamMin'] = din['beamMin']
dout['beamPA'] = din['beamPA']
outIm.Desc.Dict = dout
outIm.UpdateDesc(err)
# Copy History
inHis = History.History("in",inIm.List,err)
outHis = History.History("out",outIm.List,err)
History.PCopy(inHis, outHis,err)
outIm.UpdateDesc(err)
OErr.printErr(err)
def mouseDoubleClickEvent(self, event):
"""
@鼠标双击事件回调
@坐标落在空白处，触发生成一个新的层的逻辑
@坐标落在矩形内部，触发生成一个新的连接的逻辑
"""
#走单击的逻辑
self.PressChooseShape(event)
#触发新建连接的逻辑
if self.m_sChooseShapeName != None and self.m_sChooseShapeName != "":
History.push(self.m_dLayers)
shapeObj = self.m_dShape[self.m_sChooseShapeName]
lineObj = BaseShape.Line()
lineObj.setStart(event.pos())
lineObj.setEnd(event.pos())
lineObj.m_left = self.m_sChooseShapeName
lineObj.m_curConner = 1
sName = lineObj.m_left + lineObj.m_left
self.m_dShape[sName] = lineObj
self.m_sChooseShapeName = sName
#触发新建层的逻辑
else:
editor = Editor.CreateLayerEditor(self.createLayerCallback)
editor.exec_()
def console():
global path
global user
global comment
global pause
global duration
global audioNum
# [[[ 1. Update Playing Video ]]]
if 0 != len(Book.List()) and False is pause:
# < Can Play >
if False is video.CheckPlaying():
# < Not Playing >
# [[ 1.1. Lock ]]
lock.acquire()
try:
# [[ 1.2. Get and Update First Reservation ]]
bookList = Book.List()[0]
path = bookList[2]
user = bookList[3]
comment = bookList[4]
dummy = bookList[8]
audioIndex = int(bookList[7])
duration = videoInfo.GetDuration(path)
audioNum = videoInfo.GetAudioNum(path)
# [[ 1.2. Check Dummy ]]
if 0 == dummy:
# < Not Dummy >
# [ 1.2.1. Play Video ]
video.Open(path, vol, audioNum, audioIndex)
# [ 1.2.2. Add History ]
History.Add(path, user, comment)
# [ 1.2.3. Update pause status for playing ]
pause = False
else:
# < Dummy >
# [ 1.2.4. Switch HDMI Signal ]
hdmi.Switch()
# [ 1.2.5. Update pause status for pausing ]
pause = True
except:
import traceback
traceback.print_exc()
finally:
# [[ 1.3. Delete Playing Book ]]
Book.Delete(bookList[0])
# [[ 1.4. Unlock ]]
lock.release()
class Session:
""" Manager of a Crab session. """
def __init__(self, logger, configFile, root):
""" Construt a session with the current thread logger and the configFile name. """
self.cwd = None # Working directory (discovered after crab -create)
self.root = os.path.abspath(root)
self.jobsHistory = History()
self.configFile = os.path.abspath(configFile)
self.outNames = parseOutNames(open(self.configFile).read()) # Output file names found in the UI/res after getouput
self.totJobs = None # Jobs managed (discovered after crab -crete)
self.submitted = 0 # jobs submitted
self.logger = logger
self.returncode = None
self.outdata = None
self.errdata = None
self.cmd = None
def jobIds2str(self, jobIds):
""" Translates a list of jobs into a string. "all" means a complete list of jobs built using self.totJobs.
>>> jobIds2str([3,1,2])
'3,1,2'
"""
if jobIds == "all":
return str(self.totJobs)
elif jobIds:
jobIds = list(jobIds)
jobs = str(jobIds[0])
for jobId in jobIds[1:]:
jobs += ","+str(jobId)
return jobs
else:
return ""
def crabRunner(self, cmd):
""" Executes crab with the list of parameters cmd.
Executes crab with the list of parameters cmd. It returns a tuple containing the returncode and the stdout and the stderr
in two string.
"""
cmd = ["crab"] + cmd
self.logger.debug("Testing: "+" ".join(cmd))
self.cmd = " ".join(cmd)
self.returncode, self.outdata, self.errdata = runner(cmd)
if self.returncode:
raise CrabException, (cmd, self.returncode, self.outdata, self.errdata)
return self.returncode, self.outdata, self.errdata
def crabCreate(self):
""" Run and test crab -create, returning the set of jobsIds created. """
cmd = ['-create', '-cfg', self.configFile, '-USER.ui_working_dir', self.root]
returncode, outdata, errdata = self.crabRunner(cmd)
self.totJobs = parseCreate(outdata)
if int(self.totJobs < 1):
raise TestException, "No jobs created!"
self.logger.info("#### creating -> "+self.jobIds2str(range(1,self.totJobs+1)))
self.jobsHistory.setJobsNumber(self.totJobs)
self.cwd = findCrabWD(outdata)
if not str(self.cwd):
raise TestException, "Can't get the WD!"
for i in range(1, self.totJobs+1):
self.jobsHistory.setLocalJobStatus(i, 'create')
self.crabStatus()
for i in range(1, self.totJobs+1):
local, remote = self.jobsHistory.getJobStatus(i)
if not remote in CREATED:
raise TestException, "Job "+str(i)+" not correctly created!"
return set(range(1, self.totJobs+1))
def crabStatus(self):
""" Run and test crab -status, updating the jobsHistory. """
assert(self.cwd)
cmd = ['-status', '-c', self.cwd]
returncode, outdata, errdata = self.crabRunner(cmd)
jobList = parseEntireStatus(outdata)
self.logger.debug("parseEntireStatus->"+str(jobList))
for jobId, status, host, exitcode, statuscode in jobList:
self.jobsHistory.setRemoteJobStatus(jobId, status)
self.jobsHistory.setJobAttrs(jobId, host, exitcode, statuscode)
self.logger.debug(str(self.jobsHistory))
def crabSubmit(self, nSubmit=-1):
""" Run and test crab -submit, returning the set of jobsIds submitted. If nSubmit < 0 submit all the jobs it can submit. """
assert(self.cwd)
nSubmit = int(nSubmit)
if int(nSubmit) < 0:
cmd = ['-submit', '-c', self.cwd]
else:
cmd = ['-submit', str(nSubmit), '-c', self.cwd]
if nSubmit < 0:
nSubmit = self.totJobs
returncode, outdata, errdata = self.crabRunner(cmd)
submitted = parseSubmit(outdata)
if not submitted:
raise TestException, "Wasn't able to submit any jobs correctly!"
elif submitted < nSubmit:
self.logger.error("Requested "+str(nSubmit)+" jobs but submitted only "+str(submitted)+"!")
for i in range(self.submitted+1, self.submitted+submitted+1):
self.jobsHistory.setLocalJobStatus(i, 'submit')
self.logger.info("#### submitting -> "+self.jobIds2str(range(self.submitted+1, self.submitted+submitted+1)))
self.crabStatus()
if self.submitted+submitted > self.totJobs:
raise TestException, "More jobs submitted than created!!!"
for i in range(self.submitted+1, self.submitted+submitted+1):
local, remote = self.jobsHistory.getJobStatus(i)
if not (remote in SUBMITTED or remote in WAITING or remote in RUNNING or remote in DONE):
raise TestException, "Job "+str(i)+" not submitted correctly!"
self.submitted += submitted
return set(range(self.submitted-submitted+1,self.submitted+1))
def crabGetOutput(self, jobIds = "all", expectedIds = None):
""" Run and test crab -getouput, returning the set of jobsIds retrieved.
Run and test crab -getouput, returning the set of jobsIds retrieved. if expectedIds is a set of jobIds, the jobs
retrieved is compared to the expectedIds set, in order to check if some jobs aren't correctly retrieved.
"""
assert(self.cwd)
if jobIds == "all":
cmd = ['-getoutput', '-c', self.cwd]
self.logger.info("crab -getouput")
else:
cmd = ['-getoutput', self.jobIds2str(jobIds), '-c', self.cwd]
if jobIds == "all":
jobIds = set(range(1, self.totJobs+1))
self.logger.info("#### retrieving -> "+self.jobIds2str(jobIds))
returncode, outdata, errdata = self.crabRunner(cmd)
if not expectedIds:
expectedIds = jobIds
try:
getoutput = parseGetOutput(outdata)
except TestException, txt:
if expectedIds:
raise TestException, txt
for i in getoutput:
self.jobsHistory.setLocalJobStatus(i, 'getouput')
if expectedIds > getoutput: # If something was retrievable but wasn't retrieved
raise TestException, "Crab didn't succeed in getting every output requested!"
self.crabStatus()
for i in getoutput:
local, remote = self.jobsHistory.getJobStatus(i)
host, exitcode, exitstatus = self.jobsHistory.getJobAttrs(i)
if not remote in CLEARED:
raise TestException, "Status of job "+str(i)+" after getoutput isn't correctly cleared!"
# Checking the existance of output files in the UI
try:
for name in self.outNames:
self.logger.debug("Verifing "+name+" was retrieved...")
name = name.rsplit(".",1)
assert(len(name) == 2)
name = os.path.join(self.cwd, "res", name[0]+"_"+str(i)+"."+name[1])
try:
open(name, "rb").close()
except IOError:
raise TestException, "Output "+name+ " for job "+str(i)+" doesn't exist!"
except TestException, txt:
if not exitcode or not exitstatus: # The job hasn't correctly ended
self.logger.error(txt) # no need to say crab failed
else:
raise TestException, txt # well, maybe here crab failed!
if not exitcode or not exitstatus:
raise TestException, "Job "+str(i)+" not ended cleanly: EXITCODE="+str(exitcode)+" EXITSTATUS="+str(exitstatus)
def __init__(self):
Sim.__init__(self)
self.history = History()
class Simulator(Sim):
def __init__(self):
Sim.__init__(self)
self.history = History()
def handleErr(self, desc): # TODO:
return
def simLog(self, s):
if self.isGuimode:
return
if self.logfile != None:
self.logfile.write("%s\n" % (s))
if self.isOnScreen or self.logfile == None:
print s
return
def showStatTitle(self):
if self.isGuimode:
return
self.simLog('Cycle_%d' % self.cycle)
self.simLog('--------------------')
def showStat(self):
if self.isGuimode:
return
self.simLog('FETCH:')
self.simLog('\tF_predPC \t= 0x%s\n' % int_to_hexStr(self.F_predPC, 8))
self.simLog('DECODE:')
self.simLog('\tD_icode \t= 0x%s' % int_to_hexStr(self.D_icode))
self.simLog('\tD_ifun \t= 0x%s' % int_to_hexStr(self.D_ifun))
self.simLog('\tD_rA \t= 0x%s' % int_to_hexStr(self.D_rA))
self.simLog('\tD_rB \t= 0x%s' % int_to_hexStr(self.D_rB))
self.simLog('\tD_valC \t= 0x%s' % int_to_hexStr(self.D_valC, 8))
self.simLog('\tD_valP \t= 0x%s\n' % int_to_hexStr(self.D_valP, 8))
self.simLog('EXECUTE:')
self.simLog('\tE_icode \t= 0x%s' % int_to_hexStr(self.E_icode))
self.simLog('\tE_ifun \t= 0x%s' % int_to_hexStr(self.E_ifun))
self.simLog('\tE_valC \t= 0x%s' % int_to_hexStr(self.E_valC, 8))
self.simLog('\tE_valA \t= 0x%s' % int_to_hexStr(self.E_valA, 8))
self.simLog('\tE_valB \t= 0x%s' % int_to_hexStr(self.E_valB, 8))
self.simLog('\tE_dstE \t= 0x%s' % int_to_hexStr(self.E_dstE))
self.simLog('\tE_dstM \t= 0x%s' % int_to_hexStr(self.E_dstM))
self.simLog('\tE_srcA \t= 0x%s' % int_to_hexStr(self.E_srcA))
self.simLog('\tE_srcB \t= 0x%s\n' % int_to_hexStr(self.E_srcB))
self.simLog('MEMORY:')
self.simLog('\tM_icode \t= 0x%s' % int_to_hexStr(self.M_icode))
self.simLog('\tM_Bch \t= %s' % self.M_Cnd)
self.simLog('\tM_valE \t= 0x%s' % int_to_hexStr(self.M_valE, 8))
self.simLog('\tM_valA \t= 0x%s' % int_to_hexStr(self.M_valA, 8))
self.simLog('\tM_dstE \t= 0x%s' % int_to_hexStr(self.M_dstE))
self.simLog('\tM_dstM \t= 0x%s\n' % int_to_hexStr(self.M_dstM))
self.simLog('WRITE BACK:')
self.simLog('\tW_icode \t= 0x%s' % int_to_hexStr(self.W_icode))
self.simLog('\tW_valE \t= 0x%s' % int_to_hexStr(self.W_valE, 8))
self.simLog('\tW_valM \t= 0x%s' % int_to_hexStr(self.W_valM, 8))
self.simLog('\tW_dstE \t= 0x%s' % int_to_hexStr(self.W_dstE))
self.simLog('\tW_dstM \t= 0x%s\n' % int_to_hexStr(self.W_dstM))
def pipeCtr(self):
# F_stall
if IRET in (self.D_icode, self.E_icode, self.M_icode) or \
(self.E_icode in (IMRMOVL, IPOPL) and \
self.E_dstM in (self.d_srcA, self.d_srcB)):
self.F_stall = True
# D_stall and D_bub
if self.E_icode in (IMRMOVL, IPOPL) and self.E_dstM in (self.d_srcA, self.d_srcB):
self.D_stall = True # stall
elif (self.E_icode==IJXX and not self.e_Cnd) or \
not (self.E_icode in (IMRMOVL, IPOPL) and self.E_dstM in (self.d_srcA, self.d_srcB)) \
and IRET in (self.D_icode, self.E_icode, self.M_icode):
self.D_bub = True
# E_bub
if (self.E_icode == IJXX and not self.e_Cnd) or \
self.E_icode in (IMRMOVL, IPOPL) and \
self.E_dstM in (self.d_srcA, self.d_srcB):
self.E_bub = True
def writeF(self):
if self.F_stall:
self.F_stall = False
return # stall
self.F_currentPC = self.F_predPC
self.F_predPC = self.f_predPC
self.F_stat = 'AOK'
def stageF(self):
f_pc = self.F_predPC
if self.M_icode == IJXX and not self.M_Cnd:
f_pc = self.M_valA
elif self.W_icode == IRET:
f_pc = self.W_valM
old_pc = f_pc
pcstart = f_pc * 2
imem_error = False
instr = self.memory.getByte(f_pc)
imem_icode = hi4(instr)
imem_ifun = lo4(instr)
if self.isSecond:
if imem_icode == 0x1:
imem_icode = INOP
elif imem_icode == 0x0:
imem_icode = IHALT
pcstart += 2
f_pc += 1
self.f_icode = INOP if imem_error else imem_icode
self.f_ifun = FNONE if imem_error else imem_ifun
instr_valid = self.f_icode in (INOP, IHALT, IRRMOVL, IIRMOVL, IRMMOVL, IMRMOVL, \
IOPL, IJXX, ICALL, IRET, IPUSHL, IPOPL, IIADDL, ILEAVE)
if instr_valid:
try:
if self.f_icode in (IRRMOVL, IOPL, IPUSHL, IPOPL, \
IIRMOVL, IRMMOVL, IMRMOVL, IIADDL):
regids = self.memory.getByte(f_pc)
self.f_rA = hi4(regids)
self.f_rB = lo4(regids)
if self.isSecond:
if self.f_rA == 0xf:
self.f_rA = RNONE
if self.f_rB == 0xf:
self.f_rB = RNONE
pcstart += 2
f_pc += 1
else:
self.f_rA = RNONE
self.f_rB = RNONE
if (self.f_rA not in regname.keys() and self.f_rA != RNONE) or \
(self.f_rB not in regname.keys() and self.f_rB != RNONE):
imem_error = True
except:
imem_error = True
self.f_valC = 0x0
try:
if self.f_icode in (IIRMOVL, IRMMOVL, IMRMOVL, IJXX, ICALL, IIADDL):
self.f_valC = self.memory.getWord(f_pc)
pcstart += 8
f_pc += 4
except:
imem_error = True
if not instr_valid:
self.handleErr({'what':'instr-not-valid', 'imem_icode':imem_icode, \
'imem_ifun':imem_ifun})
self.f_valP = f_pc
self.f_predPC = self.f_valC if self.f_icode in (IJXX, ICALL) else self.f_valP
self.f_stat = 'AOK'
if imem_error:
self.f_stat = 'ADR'
if not instr_valid:
self.f_stat = 'INS'
if self.f_icode == IHALT:
self.f_stat = 'HLT'
def writeD(self):
if self.D_stall:
self.D_stall = False
return
if self.D_bub:
self.D_bub = False
self.D_icode = INOP
self.D_ifun = FNONE
self.D_rA = RNONE
self.D_rB = RNONE
self.D_valC = 0x0
self.D_valP = 0x0
self.D_stat = 'BUB'
return
self.D_stat = self.f_stat
self.D_icode = self.f_icode
self.D_ifun = self.f_ifun
self.D_rA = self.f_rA
self.D_rB = self.f_rB
self.D_valC = self.f_valC
self.D_valP = self.f_valP
self.D_currentPC = self.F_currentPC
def stageD(self):
self.d_srcA = RNONE
if self.D_icode in (IRRMOVL, IRMMOVL, IOPL, IPUSHL):
self.d_srcA = self.D_rA
elif self.D_icode in (IPOPL, IRET):
self.d_srcA = RESP
elif self.D_icode == ILEAVE:
self.d_srcA = REBP
self.d_srcB = RNONE
if self.D_icode in (IOPL, IRMMOVL, IMRMOVL, IIADDL):
self.d_srcB = self.D_rB
elif self.D_icode in (IPUSHL, IPOPL, ICALL, IRET):
self.d_srcB = RESP
self.d_dstE = RNONE
if self.D_icode in (IRRMOVL, IIRMOVL, IOPL, IIADDL):
self.d_dstE = self.D_rB
elif self.D_icode in (IPUSHL, IPOPL, ICALL, IRET, ILEAVE):
self.d_dstE = RESP
self.d_dstM = RNONE
if self.D_icode in (IMRMOVL, IPOPL):
self.d_dstM = self.D_rA
elif self.D_icode == ILEAVE:
self.d_dstM = REBP
self.d_valA = self.register[self.d_srcA]
if self.D_icode in (ICALL, IJXX):
self.d_valA = self.D_valP
elif self.d_srcA == self.e_dstE:
self.d_valA = self.e_valE
elif self.d_srcA == self.M_dstM:
self.d_valA = self.m_valM
elif self.d_srcA == self.M_dstE:
self.d_valA = self.M_valE
elif self.d_srcA == self.W_dstM:
self.d_valA = self.W_valM
elif self.d_srcA == self.W_dstE:
self.d_valA = self.W_valE
self.d_valB = self.register[self.d_srcB]
if self.d_srcB == self.e_dstE:
self.d_valB = self.e_valE
elif self.d_srcB == self.M_dstM:
self.d_valB = self.m_valM
elif self.d_srcB == self.M_dstE:
self.d_valB = self.M_valE
elif self.d_srcB == self.W_dstM:
self.d_valB = self.W_valM
elif self.d_srcB == self.W_dstE:
self.d_valB = self.W_valE
def writeE(self):
if self.E_bub:
self.E_bub = False
self.E_icode = INOP
self.E_ifun = FNONE
self.E_valC = 0x0
self.E_valA = 0x0
self.E_valB = 0x0
self.E_dstE = RNONE
self.E_dstM = RNONE
self.E_srcA = RNONE
self.E_srcB = RNONE
self.E_stat = 'BUB'
return
self.E_stat = self.D_stat
self.E_icode = self.D_icode
self.E_ifun = self.D_ifun
self.E_valC = self.D_valC
self.E_valA = self.d_valA
self.E_valB = self.d_valB
self.E_dstE = self.d_dstE
self.E_dstM = self.d_dstM
self.E_srcA = self.d_srcA
self.E_srcB = self.d_srcB
self.E_currentPC = self.D_currentPC
def stageE(self):
aluA = 0
if self.E_icode in (IRRMOVL, IOPL, ILEAVE):
aluA = self.E_valA
elif self.E_icode in (IIRMOVL, IRMMOVL, IMRMOVL, IIADDL):
aluA = self.E_valC
elif self.E_icode in (ICALL, IPUSHL):
aluA = -4
elif self.E_icode in (IRET, IPOPL):
aluA = 4
aluB = 0
if self.E_icode in (IRMMOVL, IMRMOVL, IOPL, ICALL, \
IPUSHL, IRET, IPOPL, IIADDL):
aluB = self.E_valB
elif self.E_icode == ILEAVE:
aluB = 4
alufun = self.E_ifun if self.E_icode == IOPL else ALUADD
alures = 0
aluchar = '+'
if alufun == ALUADD:
alures = aluB + aluA
aluchar = '+'
elif alufun == ALUSUB:
alures = aluB - aluA
aluchar = '-'
elif alufun == ALUAND:
alures = aluB & aluA
aluchar = '&'
elif alufun == ALUXOR:
alures = aluB ^ aluA
aluchar = '^'
self.e_setcc = self.E_icode in (IOPL, IIADDL) and \
self.m_stat not in ('ADR', 'INS', 'HLT') and \
self.W_stat not in ('ADR', 'INS', 'HLT')
if self.e_setcc:
self.condcode['ZF'] = 1 if alures == 0 else 0
self.condcode['SF'] = 1 if alures < 0 else 0
self.condcode['OF'] = 0
if (self.E_ifun == ALUADD) and \
((aluB > 0 and aluA > 0 and alures < 0) or \
aluB < 0 and aluB < 0 and alures > 0):
self.condcode['OF'] = 1
if (self.E_ifun == ALUSUB) and \
((aluB > 0 and aluA < 0 and alures < 0) or \
aluB < 0 and aluB > 0 and alures > 0):
self.condcode['OF'] = 1
self.e_Cnd = False
if self.E_icode == IJXX or self.E_icode == IRRMOVL:
zf = self.condcode['ZF']
sf = self.condcode['SF']
of = self.condcode['OF']
if self.E_ifun == FJMP:
self.e_Cnd = True
elif self.E_ifun == FJLE and (sf ^ of) | zf == 1:
self.e_Cnd = True
elif self.E_ifun == FJL and sf ^ of == 1:
self.e_Cnd = True
elif self.E_ifun == FJE and zf == 1:
self.e_Cnd = True
elif self.E_ifun == FJNE and zf == 0:
self.e_Cnd = True
elif self.E_ifun == FJGE and sf ^ of == 0:
self.e_Cnd = True
elif self.E_ifun == FJG and (sf ^ of) | zf == 0:
self.e_Cnd = True
self.e_valE = alures
self.e_dstE = self.E_dstE
if self.E_icode == IRRMOVL and not self.e_Cnd:
self.e_dstE = RNONE
def writeM(self):
if self.m_stat in ('ADR', 'INS', 'HLT') or \
self.W_stat in ('ADR', 'INS', 'HLT'):
self.M_stat = 'BUB'
self.M_icode = INOP
self.M_ifun = FNONE
self.M_Cnd = False
self.M_valE = 0x0
self.M_valA = 0x0
self.M_dstE = RNONE
self.M_dstM = RNONE
return
self.M_stat = self.E_stat
self.M_icode = self.E_icode
self.M_ifun = self.E_ifun
self.M_Cnd = self.e_Cnd
self.M_valE = self.e_valE
self.M_valA = self.E_valA
self.M_dstE = self.e_dstE
self.M_dstM = self.E_dstM
self.M_currentPC = self.E_currentPC
def stageM(self):
self.m_valM = 0
self.mem_addr = 0
self.dmem_error = False
if self.M_icode in (IRMMOVL, IPUSHL, ICALL, IMRMOVL): # write
self.mem_addr = self.M_valE
elif self.M_icode in (IPOPL, IRET, ILEAVE): # read, get addr
self.mem_addr = self.M_valA
if self.M_icode in (IMRMOVL, IPOPL, IRET, ILEAVE): # read
try:
self.m_valM = self.memory.getWord(self.mem_addr)
self.m_read = True
except:
self.dmem_error = True
if self.M_icode in (IRMMOVL, IPUSHL, ICALL): # write
try:
self.memory.setWord(self.mem_addr, self.M_valA)
except:
self.dmem_error = True
self.m_stat = 'ADR' if self.dmem_error else self.M_stat
def writeW(self):
if self.W_stat in ('ADR', 'INS', 'HLT'):
return
self.W_stat = self.m_stat
self.W_icode = self.M_icode
self.W_ifun = self.M_ifun
self.W_valE = self.M_valE
self.W_valM = self.m_valM
self.W_dstE = self.M_dstE
self.W_dstM = self.M_dstM
self.W_currentPC = self.M_currentPC
def stageW(self):
if self.W_dstE != RNONE:
self.register[self.W_dstE] = self.W_valE
if self.W_dstM != RNONE:
self.register[self.W_dstM] = self.W_valM
self.cpustat = 'AOK' if self.W_stat == 'BUB' else self.W_stat
def step(self):
if self.maxCycle != 0 and self.cycle > self.maxCycle:
self.simLog('Reach Max Cycle')
self.cpustat = 'HLT'
return
self.showStatTitle()
self.pipeCtr()
self.writeW() # take care of orders if u wanna save some intermediate vals
self.writeM()
self.writeE()
self.writeD()
self.writeF()
self.stageW()
self.stageM()
self.stageE()
self.stageD()
self.stageF()
self.showStat()
self.history.record(self)
self.cycle += 1
if self.cpustat != 'AOK' and self.cpustat != 'BUB':
self.isTerminated = True
return False
else:
return True
def back(self):
tmp = self.history.back(self.cycle-1)
if tmp==False or tmp==None:
self.simLog('out of history\'s reach')
return
else:
self.isTerminated = False
self.copy(tmp)
self.showStatTitle()
self.showStat()
self.cycle += 1
def load(self, fin, fout=None):
# prepare
self.cycle = 0
self.yasbin = ''
inputName = fin.name
prefixName = os.path.splitext(inputName)[0]
if fout==None and not self.isNoLogFile:
outputName = prefixName + '.txt'
try:
self.logfile = open(outputName, 'w')
except IOError:
self.handleErr({'what':'cannot open a logfile to write'})
raise
else:
self.logfile = fout
outputName = fout.name
if not self.isNoLogFile and not self.isGuimode:
print('Log file: %s' % (outputName))
# load
# TODO: how to load both bin and non-bin
for str_line in fin.readlines():
str_valid = str_line
str_valid = re.sub(r'\|.*','',str_valid)
str_valid = str_valid.strip(' \n\r\t')
if str_valid == '':
continue
tokens = str_valid.split(':')
if tokens[1] == '':
continue
addr = int(tokens[0].strip(' '), 16)
content_str = tokens[1].strip(' ')
self.yasbin += content_str
content_bytes = str_to_bytes(content_str)
self.memory.setBytesThrough( addr, content_bytes)
self.binlen = len(self.yasbin)
def run(self):
try:
while True:
if self.isGoing:
if not self.step():
break
time.sleep(self.interval)
self.logfile.close()
except:
self.simLog('Error: bad input binary file')
self.logfile.close()
raise
def getMemory(self, addr):
return self.memory.mem[addr]
def getMemoryChange(self):
return self.memory.memChange
def getCache(self, setIndex, lineIndex):
entrySize = self.memory.cache.E
line = self.memory.cache.set[setIndex*entrySize+lineIndex]
return line.isValid, line.isDirty, line.tag, line.block
def setCacheParams(self, S, E, B, m):
self.memory.setCache(S, E, B, m)
'''''''''''''''''
' trivial '
'''''''''''''''''
