self.TimerAccessLock.acquire()

if self.LastRefreshTimer:

self.LastRefreshTimer.cancel()

self.TimerAccessLock.release()

if current_time - self.LastRefreshTime > REFRESH_PERIOD and self.RefreshLock.acquire(False):

self._should_write()

self.output.Freeze()

self.lock.acquire()

for s, style in self.stack:

if style != self.black_white:

self.output.StartStyling(self.output.GetLength(), 0xff)

self._RecursiveAddMenuItems(parent, GetAddMenuItems())

def _init_coll_HelpMenu_Items(self, parent):

wx.MessageBox(version.GetCommunityHelpMsg(), _(u'Community support'), wx.OK | wx.ICON_INFORMATION)

}

id = wx.NewId()

except:

defaultpath = os.path.expanduser("~")

wx.RESIZE_BORDER)

if dialog.ShowModal() == wx.ID_OK:

self.OpenProject(dialog.GetPath())

enabletwisted = True

havetwisted = False

for o, a in opts:

if o == "-h":

os.chdir(WorkingDir)

elif len(argv) == 0:

WorkingDir = os.getcwd()

import __builtin__

if __name__ == '__main__':

menu = wx.Menu()

menu.Append(self.TBMENU_START, _("Start PLC"))

menu.Append(self.TBMENU_STOP, _("Stop PLC"))

menu.AppendSeparator()

menu.Append(self.TBMENU_CHANGE_NAME, _("Change Name"))

menu.Append(self.TBMENU_CHANGE_INTERFACE, _("Change IP of interface to bind"))

def default_evaluator(tocall, *args, **kwargs):

try:

except Exception:

return res

def Start(self):

pyro.initServer()

self.plcobj = PLCObject(self.workdir, self.daemon, self.argv,

self.statuschange, self.evaluator,

self.pyruntimevars)

# avoid dead lock if called from the wx mainloop

return default_evaluator(tocall, *args, **kwargs)

else:

wx.CallAfter(wx_evaluator, o)

wx_eval_lock.acquire()

return o.res

if havetwisted or havewx:

pyro_thread.start()

if havetwisted:

# confnode asks for some LDFLAGS

if CTNLDFLAGS:

# LDFLAGS can be either string

# or list of strings

else:

# recurse through all children, and stack their results

for CTNChild in self.IECSortedChildren():

new_location = CTNChild.GetCurrentLocation()

# How deep are we in the tree ?

_LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

CTNChild._Generate_C(

# keep the same path

# Do nothing if no change

#if CurrentName == DesiredName: return CurrentName

# Build a list of used Name out of parent's Children

for CTNInstance in self.CTNParent.IterChildren():

if CTNInstance != self:

AllNames.append(CTNInstance.BaseParams.getName())

return res

def GetAllChannels(self):

for CTNInstance in self.CTNParent.IterChildren():

if CTNInstance != self:

AllChannels.append(CTNInstance.BaseParams.getIEC_Channel())

self.Panes = {}

self.LeftNoteBook = wx.aui.AuiNotebook(self, ID_PLCOPENEDITORLEFTNOTEBOOK,

self.LeftNoteBook.Bind(wx.aui.EVT_AUINOTEBOOK_ALLOW_DND,

self.OnAllowNotebookDnD)

self.AUIManager.AddPane(self.LeftNoteBook,

BestSize(wx.Size(300, 500)).CloseButton(False))

self.BottomNoteBook = wx.aui.AuiNotebook(self, ID_PLCOPENEDITORBOTTOMNOTEBOOK,

self.BottomNoteBook.Bind(wx.aui.EVT_AUINOTEBOOK_ALLOW_DND,

self.OnAllowNotebookDnD)

self.AUIManager.AddPane(self.BottomNoteBook,

BestSize(wx.Size(800, 300)).CloseButton(False))

self.RightNoteBook = wx.aui.AuiNotebook(self, ID_PLCOPENEDITORRIGHTNOTEBOOK,

self.RightNoteBook.Bind(wx.aui.EVT_AUINOTEBOOK_ALLOW_DND,

self.OnAllowNotebookDnD)

self.AUIManager.AddPane(self.RightNoteBook,

BestSize(wx.Size(250, 400)).CloseButton(False))

self.TabsOpened = wx.aui.AuiNotebook(self, ID_PLCOPENEDITORTABSOPENED,

self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGING,

self.OnPouSelectedChanging)

self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED,

format(a1 = task.getname(), a2 = config_name, a3 = resource.getname())

raise PLCGenException, msg

SNGLKW = "MULTI"

else:

SNGLKW = "SINGLE"

def _init_coll_FileMenu_Items(self, parent):

AppendMenu(parent, help='', id=wx.ID_NEW,

AppendMenu(parent, help='', id=wx.ID_OPEN,

kind=wx.ITEM_NORMAL, text=_(u'Open') + '\tCTRL+O')

AppendMenu(parent, help='', id=wx.ID_CLOSE,

#AppendMenu(parent, help='', id=wx.ID_HELP_CONTEXT,

# kind=wx.ITEM_NORMAL, text=u'IEC 61131-3\tF3')

wx.MessageBox(version.GetCommunityHelpMsg(), _(u'Community support'), wx.OK | wx.ICON_INFORMATION)

}

id = wx.NewId()

self.ieclib_c_path = self.findLibCPath()

def findObject(self, paths, test):

for p in paths:

if test(p):

path = p

return path

def findCmd(self):

os.path.join(base_folder, "matiec")

]

path = self.findObject(paths, lambda p: os.path.isfile(os.path.join(p, cmd)))

# otherwise use iec2c from PATH

if path is not None:

return cmd

def findLibPath(self):

os.path.join(base_folder, "matiec", "lib"),

"/usr/lib/matiec"

]

return path

def findLibCPath(self):

os.path.join(self.ieclib_path, "C"),

self.ieclib_path]

path = self.findObject(paths, lambda p: os.path.isfile(os.path.join(p, "iec_types.h")))

def findSupportedOptions(self):

buildcmd = "\"%s\" -h" % (self.getCmd())

buildopt = ""

try:

</xsd:element>"""+(("""

<xsd:element name="Libraries" minOccurs="0">

<xsd:complexType>

'type="xsd:boolean" use="optional" default="true"/>'

for libname, lib in features.libraries])+"""

</xsd:complexType>

</xsd:sequence>

<xsd:attribute name="URI_location" type="xsd:string" use="optional" default=""/>

<xsd:attribute name="Disable_Extensions" type="xsd:boolean" use="optional" default="false"/>

self.IECdebug_datas = {}

self.IECdebug_lock = Lock()

self.ResetIECProgramsAndVariables()

# In both new or load scenario, no need to save

def LoadLibraries(self):

self.Libraries = []

for libname, clsname in features.libraries:

if self.BeremizRoot.Libraries is None or getattr(self.BeremizRoot.Libraries, "Enable_"+libname+"_Library"):

Lib = GetClassImporter(clsname)()(self, libname, TypeStack)

return "\n".join([ lib.GetSTCode() for lib in self.Libraries ])

def GetLibrariesCCode(self, buildpath):

return [], [], ()

self.GetIECProgramsAndVariables()

LibIECCflags = '"-I%s" -Wno-unused-function' % os.path.abspath(self.GetIECLibPath())

for lib in self.Libraries:

LocatedCCodeAndFlags.append(res[:2])

Extras.extend(res[2:])

return map(list, zip(*LocatedCCodeAndFlags))+[tuple(Extras)]

return False

# Now extract C files of stdout

# remove those that are not to be compiled because included by others

C_files.remove("POUS.c")

if not C_files:

C_files = map(lambda filename: os.path.join(buildpath, filename), C_files)

# prepend beremiz include to configuration header

H_files.remove("LOCATED_VARIABLES.h")

H_files = map(lambda filename: os.path.join(buildpath, filename), H_files)

for H_file in H_files:

return self._builder

def ResetBuildMD5(self):

if builder is not None:

builder.ResetBinaryCodeMD5()

self.EnableMethod("_Transfer", False)

def GetLastBuildMD5(self):

if builder is not None:

return builder.GetBinaryCodeMD5()

else:

# Push this dictionnary into result.

self._DbgVariablesList.append(attrs)

# Fill in IEC<->C translation dicts

# Ignores numbers given in CSV file

# Idx=int(attrs["num"])

# Count variables only, ignore FBs

self._VariablesList.append(attrs)

# third section contains ticktime

for v in self._DbgVariablesList:

sz = DebugTypesSize.get(v["type"], 0)

variable_decl_array += [

{

"EXT": "%(type)s_P_ENUM",

"IN": "%(type)s_P_ENUM",

"VAR": "extern __IEC_%(type)s_t %(C_path)s;",

"FB": "extern %(type)s %(C_path)s;"

}[v["vartype"]] % v

"variable_decl_array": ",\n".join(variable_decl_array)

}

if not self.BeremizRoot.getDisable_Extensions():

plc_main_code = targets.GetCode("plc_main_head.c") % {

"calls_prototypes": "\n".join([(

"void __publish_%(s)s(void);") % {'s': locstr} for locstr in locstrs]),

"retrieve_calls": "\n ".join([

"__retrieve_%s();" % locstr for locstr in locstrs]),

"publish_calls": "\n ".join([ # Call publish in reverse order

"__publish_%s();" % locstrs[i-1] for i in xrange(len(locstrs), 0, -1)]),

"init_calls": "\n ".join([

"if((res = __init_%s(argc,argv))){" % locstr +

#"printf(\"%s\"); "%locstr + #for debug

"return res;}" for i, locstr in enumerate(locstrs)]),

"cleanup_calls": "\n ".join([

"__cleanup_%s();" % locstrs[i-1] for i in xrange(len(locstrs), 0, -1)])

}

else:

return ticks, buffers

def RegisterDebugVarToConnector(self):

Idxs = []

self.TracedIECPath = []

self.TracedIECTypes = []

if self.IsPLCStarted():

# Timer to prevent rapid-fire when registering many variables

# use wx.CallAfter use keep using same thread. TODO : use wx.Timer instead

# Rearm anti-rapid-fire timer

self.DebugTimer.start()

else:

IECdebug_data[4] |= buffer_list

self.IECdebug_lock.release()

def EnableMethod(self, method, value):

for d in self.StatusMethods:

return True

return False

def ShowMethod(self, method, value):

for d in self.StatusMethods:

return True

return False

def CallMethod(self, method):

for d in self.StatusMethods:

getattr(self, method)()

"static void %s_post_SlaveBootup(CO_Data* d, UNS8 nodeId){}\n" % (nodename))

else:

format_dict["slavebootups"] += (

"}\n")

# register previously declared func as post_SlaveBootup callback for that node

format_dict["slavebootup_register"] += (

"%s_Data.post_SlaveBootup = %s_post_SlaveBootup;\n" % (nodename, nodename))

format_dict["pre_op"] += (

"}\n")

format_dict["pre_op_register"] += (

"%s_Data.preOperational = %s_preOperational;\n" % (nodename, nodename))

else:

# Slave node

align = child_data.getSync_Align()

if align > 0:

format_dict["post_sync"] += (

"}\n")

format_dict["post_sync_register"] += (

"%s_Data.post_sync = %s_post_sync;\n" % (nodename, nodename))

@return: a tuple of value and number of parameters to add to DCF

"""

# Create entry for RPDO or TPDO parameters and Disable PDO

# ---- INDEX ----- --- SUBINDEX ---- ----- SIZE ------ ------ DATA ------

dcfdata += [LE_to_BE(idx, 2) + LE_to_BE(0x01, 1) + LE_to_BE(0x04, 4) + LE_to_BE(0x80000000 + cobid, 4)]

main_sizer = wx.BoxSizer(wx.VERTICAL)

self.Tree = wx.TreeCtrl(self,

wx.TR_EDIT_LABELS)

if wx.Platform == '__WXMSW__':

self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnTreeItemExpanded, self.Tree)

# window

self.Tree = wx.TreeCtrl(splitter_window,

size=wx.Size(0, 0),

wx.TR_LINES_AT_ROOT)

self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnTreeItemSelected, self.Tree)

self.Tree.Bind(wx.EVT_CHAR, self.OnKeyDown)

same_inputs = reduce(

lambda x, y: x and y,

map(

zip(type_inputs,

(inputs[:type_extension]

if type_extension is not None

self.MessageScrollBar.RefreshThumbPosition()

def IsPLCLogEmpty(self):

for level, prev in zip(xrange(LogLevelsCount), self.previous_log_count):

if prev is not None:

break

return empty

self.VariablesList = CustomTreeCtrlWithRightImage(self,

style=wx.SUNKEN_BORDER,

getattr(CT, "TR_ALIGN_WINDOWS_RIGHT", CT.TR_ALIGN_WINDOWS))

self.VariablesList.SetIndent(0)

self.VariablesList.SetSpacing(5)

l = wx.ALIGN_LEFT

c = wx.ALIGN_CENTER

else:

# this is an element that cannot have located variables

l = wx.ALIGN_LEFT

c = wx.ALIGN_CENTER

self.PanelWidthMin = sum(self.ColSizes)

top_sizer.AddWindow(self.BaseType, 1, flag=wx.GROW)

self.Dimensions = CustomEditableListBox(self, label=_("Dimensions:"),

wx.gizmos.EL_ALLOW_DELETE)

for func in ["_OnLabelEndEdit",

"_OnAddButton",

("VAR_INPUT", LOCATION_VAR_INPUT),

("VAR_OUTPUT", LOCATION_VAR_OUTPUT),

("VAR_LOCAL", LOCATION_VAR_MEMORY)]:

# Assign icon list to TreeCtrls

self.LocationsTree.SetImageList(self.TreeImageList)

self.ZeroConfInstance = Zeroconf()

self.RefreshList()

def __del__(self):

if self.Browser is not None: self.Browser.cancel()

self.Bind(wx.EVT_BUTTON, self.OnOK,

self.GetSizer().GetItem(2).GetSizer().GetItem(1).GetSizer().GetAffirmativeButton())

if self.IEC_Type == "BOOL":

self.ToggleButton = wx.ToggleButton(self, label=_("Toggle value"))

if value is not None:

self.ToggleButton.SetValue(value)

self.GetSizer().Insert(before=2, item=self.ToggleButton,

border=border,

flag=wx.LEFT|wx.RIGHT|wx.EXPAND)

self.Fit()

def ToggleBoolValue(self, event):

self.ValueTextCtrl.SetValue(unicode(value))

def OnOK(self, event):

pos_x = (width-bw)/2+dw # adjust for bitmap and text to centre

pos_y = (height-bh-th)/2+dy

dc.DrawBitmap(bmp, pos_x, pos_y, hasMask) # draw bitmap if available

pos_x = (width-tw)/2+dw # adjust for bitmap and text to centre

pos_y += bh + 2

self.Thaw()

def GenerateMethodButtonSizer(self):

msizer = wx.BoxSizer(wx.HORIZONTAL)

enumerated_panel_sizer = wx.BoxSizer(wx.HORIZONTAL)

self.EnumeratedValues = CustomEditableListBox(self.EnumeratedPanel,

wx.gizmos.EL_ALLOW_DELETE)

setattr(self.EnumeratedValues, "_OnLabelEndEdit", self.OnEnumeratedValueEndEdit)

for func in ["_OnAddButton", "_OnDelButton", "_OnUpButton", "_OnDownButton"]:

flag=wx.ALL)

self.ArrayDimensions = CustomEditableListBox(self.ArrayPanel,

wx.gizmos.EL_ALLOW_DELETE)

for func in ["_OnLabelEndEdit", "_OnAddButton", "_OnDelButton",

"_OnUpButton", "_OnDownButton"]:

self.TimerAccessLock.acquire()

if self.LastRefreshTimer is not None:

self.LastRefreshTimer.cancel()

self.TimerAccessLock.release()

# Only try to refresh DebugViewer if it is visible on screen and not

message = _("\"%s\" is not a valid identifier!") % value

elif value.upper() in IEC_KEYWORDS:

message = _("\"%s\" is a keyword. It can't be used!") % value

message = _("A task with the same name already exists!")

if message is not None:

event.Veto()

message = _("\"%s\" is not a valid identifier!") % value

elif value.upper() in IEC_KEYWORDS:

message = _("\"%s\" is a keyword. It can't be used!") % value

message = _("An instance with the same name already exists!")

if message is not None:

event.Veto()

# This method check the IEC 61131-3 compatibility between two SFC blocks

def BlockCompatibility(self, startblock = None, endblock = None, direction = None):

or isinstance(endblock, SFC_Objects)):

# Full "SFC_StandardRules" table would be symmetrical and

# to avoid duplicate records and minimize the table only upper part is defined.

self.Editor.SetTabWidth(2)

self.Editor.SetUseTabs(0)

wx.stc.STC_PERFORMED_USER)

self.Bind(wx.stc.EVT_STC_STYLENEEDED, self.OnStyleNeeded, id=ID_TEXTVIEWERTEXTCTRL)

def ConnectionAvailable(self, direction=None, exclude=True):

wire_nums = len(self.Wires)

connector_max_used = ((wire_nums > 0) and self.OneConnected)

if (self.Parent.CurrentLanguage in ["SFC", "LD"]) and (self.Type == "BOOL"):

connector_max_used = False;

# ----------------

#

# -----------------------------------------------------------------------------

languageDict = getlanguageDict()

for langCode in languageDict.keys():

pass

else:

langPOfileName = "%s_%s.po" % (applicationName, langCode)

# translate the path separators

directory = unixpath(directory)

# build a list of all directory elements

theLen = len(aList)

# if the first element is a Windows-style disk drive

# concatenate it with the first directory

test_result = []

result = criteria["pattern"].search(text)

while result is not None:

start = TextLenInRowColumn(text[:result.start()])

end = TextLenInRowColumn(text[:result.end() - 1])

test_result.append((start, end, "\n".join(lines[start[0]:end[0] + 1])))

result = criteria["pattern"].search(text, result.end())

break

return test_result

fields = [True, True]

while(fields[1]):

fields = table.pop(0)

standard_funtions_input_variables[variable_from_csv['name']] = variable_from_csv['type']

return standard_funtions_input_variables

varinfos = map(lambda variable: {

"name": variable.getname(),

"desc": repr(variable.getdesc()),

"('"+variable.getname()+"')\"" \

if variable.getonchange() else '""',

"onchange": repr(variable.getonchange()) \

__SET_VAR(__%(name)s_notifier->,CODE,,__STRING_LITERAL(%(onchangelen)d,%(onchangecode)s));

"""

vardec = "\n".join([(vardecfmt + vardeconchangefmt

for varinfo in varinfos])

varret = "\n".join([varretfmt % varinfo for varinfo in varinfos])

varpub = "\n".join([(varpubonchangefmt if varinfo["onchange"] else

tb = tb.tb_next

return tb

"linux2": ".so",

"win32": ".dll",

}.get(sys.platform, "")

def AutoLoad(self):

# Get the last transfered PLC if connector must be restart

try:

self._GetMD5FileName(),

"r").read().strip() + lib_ext

if self.LoadPLC():

self.PLCStatus = "Stopped"

except Exception, e:

self.PLCStatus = "Empty"

def StatusChange(self):

if self.statuschange is not None:

def GetLogCount(self, level):

if self._GetLogCount is not None:

return int(self._GetLogCount(level))

return 1

def GetLogMessage(self, level, msgid):

if sz and sz <= maxsz:

self._log_read_buffer[sz] = '\x00'

return self._log_read_buffer.value, tick.value, tv_sec.value, tv_nsec.value

return self._loading_error, 0, 0, 0

return None

def PythonThreadProc(self):

self.StartSem.release()

res, cmd, blkid = "None", "None", ctypes.c_void_p()

while True:

# print "_PythonIterator(", res, ")",

cmd = self._PythonIterator(res, blkid)

if cmd is None:

break

try:

AST = compile(cmd, '<plc>', 'eval')

result, exp = self.evaluator(eval, AST, self.python_runtime_vars)

if exp is not None:

res = "#EXCEPTION : "+str(exp[1])

self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID, cmd,

'\n'.join(traceback.format_exception(*exp))))

else:

except Exception, e:

res = "#EXCEPTION : "+str(e)

self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID, cmd, str(e)))

self.PLCStatus = "Started"

self.StatusChange()

self.PythonRuntimeCall("start")

self.PythonThread = Thread(target=self.PythonThreadProc)

self.PythonThread.start()

self.StartSem.acquire()

# keep a copy of requested idx

self._ResetDebugVariables()

for idx, iectype, force in idxs:

c_type, unpack_func, pack_func = \

TypeTranslator.get(iectype,

(None, None, None))

self.ip_32b,

self.port,

properties = self.serviceproperties))

def UnRegisterService(self):

if self.retrytimer is not None:

# .cache.html files produces look like this

# ok these are the three "default" library directories, containing

# the builtins (str, List, Dict, ord, round, len, range etc.)

while deps:

l_deps = len(deps)

#print l_deps

for m, dl in deps.items():

for d in dl:

if m in deps.get(d, []):

class JSONRPCServiceBase:

def __init__(self):

def response(self, id, result):

return simplejson.dumps({'version': '1.1', 'id': id,

id, method, params = data["id"], data["method"], data["params"]

if method in self.methods:

try:

return self.response(id, result)

except BaseException:

etype, eval, etb = sys.exc_info()

except:

etype, eval, etb = sys.exc_info()

else:

return self.error(id, 100, 'method "%s" does not exist' % method)

return self.process(request.body.read())

def __call__(self, func):

return func

UU = ""

def pyjs_builtin_remap(name):

# XXX: this is a hack: these should be dealt with another way

# however, console is currently the only global name which is causing

# problems.

# This is taken from the django project.

# Escape every ASCII character with a value less than 32.

default_name = arg_names[default_pos]

print >>self.output, " if (typeof %s == 'undefined')" % (default_name)

default_pos += 1

#self._default_args_handler(node, arg_names, current_klass)

if isinstance(v.expr, ast.Getattr):

call_name = self._getattr2(v.expr, current_klass, v.attrname + "." + attr_name)

elif isinstance(v.expr, ast.Name) and v.expr.name in self.module_imports():

else:

obj = self.expr(v.expr, current_klass)

call_name = obj + "." + v.attrname + "." + attr_name

def main():

import sys

print >> sys.stderr, usage % sys.argv[0]

sys.exit(1)

file_name = os.path.abspath(sys.argv[1])

res = ([], "", False)

if os.path.exists(svgfile):

res += (("gui.svg", file(svgfile, "rb")),)

svguilibpath = os.path.join(self._getBuildPath(), "svguilib.js")

svguilibfile = open(svguilibpath, 'w')

svguilibfile.write(translate(os.path.join(fpath, "pyjs", "lib", "sys.py"), "sys"))

svguilibfile.write(open(os.path.join(fpath, "pyjs", "lib", "_pyjs.js"), 'r').read())

svguilibfile.write(translate(os.path.join(fpath, "pyjs", "lib", "pyjslib.py"), "pyjslib"))

extension = ".so"

def getXenoConfig(self, flagsname):

""" Get xeno-config from target parameters """

if xeno_config:

from util.ProcessLogger import ProcessLogger

status, result, err_result = ProcessLogger(self.CTRInstance.logger,

status, result, err_result = ProcessLogger(

self.CTRInstance.logger,

(self.compiler, CFile, objectfilename, Builder_CFLAGS, CFLAGS)

).spin()

status, result, err_result = ProcessLogger(

self.CTRInstance.logger,

(self.linker,

listobjstring,

self.exe_path,

return reduce(operator.concat, map(self.concat_deps, deps), src)

def build(self):

cflags = []

wholesrcdata = ""

for Location, CFilesAndCFLAGS, DoCalls in self.CTRInstance.LocationCFilesAndCFLAGS:

lambda t, x: t(x.days * 24 * 3600 + x.seconds, x.microseconds*1000))

SameEndianessTypeTranslator = {

"STEP": _t(c_uint8),

"TRANSITION": _t(c_uint8),

"ACTION": _t(c_uint8),

# TODO

}

# Construct debugger natively supported types

DebugTypesSize = dict([(key, sizeof(t)) for key, (t, p, u) in SameEndianessTypeTranslator.iteritems() if t is not None])

self.finishsem = Semaphore(0)

self.endlock = Lock()

"cwd": os.getcwd() if cwd is None else cwd,

"stdin": subprocess.PIPE,

"stdout": subprocess.PIPE,

self.outlen += 1

if not self.no_stdout:

self.logger.write(v)

self.endlog()

def errors(self, v):

ctypes.windll.kernel32.CloseHandle(handle)

else:

if gently:

else:

try:

os.kill(self.Proc.pid, sig)

except:

def GetClassImporter(classpath):

def fac():

return reduce(getattr, classpath.split('.')[1:], mod)

return fac

else:

def GetAppRevision():

rev = None

try:

pipe = subprocess.Popen(

["hg", "id", "-i"],

'')

# read license file

license_path = os.path.join(path, "COPYING")

if os.path.exists(license_path):

with open(license_path) as f:

info.License += f.read()

except ImportError:

pass

if os.path.isdir(defLibDir):

path = defLibDir

hmi_frames = []

if os.path.exists(wxgfile_path):

wxgfile = open(wxgfile_path, 'r')

wxgtree = minidom.parse(wxgfile)

hnode.firstChild.data for hnode in

node.getElementsByTagName("handler")]})

if wx.Platform == '__WXMSW__':

wxgfile_path = "\"%s\"" % wxgfile_path

wxghmipyfile_path = "\"%s\"" % hmipyfile_path

define_hmi = ""

declare_hmi = "\n".join(["%(name)s = None\n" % x +

dict(x, h=h) for h in x['handlers']])

for x in hmi_frames])

global_hmi = ("global %s\n" % ",".join(