module_generator/gener.py

   1 # Copyright (C) 2009-2015  EDF R&D
   2 #
   3 # This library is free software; you can redistribute it and/or
   4 # modify it under the terms of the GNU Lesser General Public
   5 # License as published by the Free Software Foundation; either
   6 # version 2.1 of the License, or (at your option) any later version.
   7 #
   8 # This library is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 # Lesser General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU Lesser General Public
  14 # License along with this library; if not, write to the Free Software
  15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 #
  17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 #
  19
  20 import os, shutil, glob, socket
  21 import traceback
  22 import warnings
  23
  24 try:
  25   from string import Template
  26 except:
  27   from compat import Template, set
  28
  29 class Invalid(Exception):
  30   pass
  31
  32 debug=0
  33
  34 from mod_tmpl import *
  35 from cata_tmpl import catalog, interface, idl
  36 from cata_tmpl import xml, xml_interface, xml_service
  37 from cata_tmpl import idlMakefilePaCO_BUILT_SOURCES, idlMakefilePaCO_nodist_salomeinclude_HEADERS
  38 from cata_tmpl import idlMakefilePACO_salomepython_DATA, idlMakefilePACO_salomeidl_DATA
  39 from cata_tmpl import idlMakefilePACO_INCLUDES
  40 from cata_tmpl import cataOutStream, cataInStream, cataOutparam, cataInparam
  41 from cata_tmpl import cataOutParallelStream, cataInParallelStream
  42 from cata_tmpl import cataService, cataCompo
  43 #from aster_tmpl import check_aster
  44 from salomemodules import salome_modules
  45 from yacstypes import corbaTypes, corbaOutTypes, moduleTypes, idlTypes, corba_in_type, corba_out_type
  46 from yacstypes import ValidTypes, PyValidTypes, calciumTypes, DatastreamParallelTypes
  47 from yacstypes import ValidImpl, ValidImplTypes, ValidStreamTypes, ValidParallelStreamTypes, ValidDependencies
  48 from gui_tmpl import cmake_py_gui, pysalomeapp, cmake_cpp_gui, cppsalomeapp
  49 from doc_tmpl import docmakefile, docconf, docsalomeapp
  50 import yacsgen_version
  51
  52 def makedirs(namedir):
  53   """Create a new directory named namedir. If a directory already exists copy it to namedir.bak"""
  54   if os.path.exists(namedir):
  55     dirbak = namedir+".bak"
  56     if os.path.exists(dirbak):
  57       shutil.rmtree(dirbak)
  58     os.rename(namedir, dirbak)
  59     os.listdir(dirbak) #needed to update filesystem on special machines (cluster with NFS, for example)
  60   os.makedirs(namedir)
  61
  62 class Module(object):
  63   """
  64    A :class:`Module` instance represents a SALOME module that contains components given as a list of
  65    component instances (:class:`CPPComponent` or :class:`PYComponent` or :class:`F77Component` or :class:`ASTERComponent`)
  66    with the parameter *components*.
  67
  68    :param name: gives the name of the module. The SALOME source module
  69       will be located in the <name_SRC> directory.
  70    :type name: str
  71    :param components: gives the list of components of the module.
  72    :param prefix: is the path of the installation directory.
  73    :param doc: can be used to add an online documentation to the module. It must be a list of file names (sources, images, ...) that will be
  74       used to build a sphinx documentation (see http://sphinx.pocoo.org, for more information). If not given, the Makefile.am
  75       and the conf.py (sphinx configuration) files are generated. In this case, the file name extension of source files must be .rst.
  76       See small examples in Examples/pygui1 and Examples/cppgui1.
  77    :param gui: can be used to add a GUI to the module. It must be a list of file names (sources, images, qt designer files, ...).
  78       If not given, the CMakeLists.txt and SalomeApp.xml are generated. All image files are put in the resources directory of the module.
  79       The GUI can be implemented in C++ (file name extension '.cxx') or in Python (file name extension '.py').
  80       See small examples in Examples/pygui1 and Examples/cppgui1.
  81
  82    For example, the following call defines a module named "mymodule" with 2 components c1 and c2  (they must have been
  83    defined before) that will be installed in the "install" directory::
  84
  85       >>> m = module_generator.Module('mymodule', components=[c1,c2],
  86                                                   prefix="./install")
  87
  88   """
  89   def __init__(self, name, components=None, prefix="", doc=None, gui=None):
  90     self.name = name
  91     self.components = components or []
  92     self.prefix = prefix or "%s_INSTALL" % name
  93     self.doc = doc
  94     self.gui = gui
  95     try:
  96       self.validate()
  97     except Invalid,e:
  98       if debug:
  99         traceback.print_exc()
 100       print "Error in module %s: %s" % (name,e)
 101       raise SystemExit
 102
 103   def validate(self):
 104     # Test Module name, canot have a "-" in the name
 105     if self.name.find("-") != -1:
 106       raise Invalid("Module name %s is not valid, remove character - in the module name" % self.name)
 107     lcompo = set()
 108     for compo in self.components:
 109       if compo.name in lcompo:
 110         raise Invalid("%s is already defined as a component of the module" % compo.name)
 111       lcompo.add(compo.name)
 112       compo.validate()
 113
 114 class Library(object):
 115   """
 116      A :class:'Library' instance contains the informations of a user library.
 117
 118      :param name: name of the library (exemple: "cppunit", "calcul")
 119      :param path: path where to find the library (exemple: "/home/user/libs")
 120   """
 121
 122   def __init__(self, name, path):
 123     self.name=name
 124     self.path=path
 125
 126   def findLibrary(self):
 127     """
 128     return : text for the FIND_LIBRARY command for cmake.
 129     Feel free to overload this function for your own needs.
 130     """
 131     return "FIND_LIBRARY( "+self.cmakeVarName()+" "+self.name+" PATH "+self.path + ")\n"
 132
 133   def cmakeVarName(self):
 134     """
 135     return : name of the cmake variable used by FIND_LIBRARY
 136     """
 137     return "_userlib_" + self.name.split()[0]
 138
 139 class Component(object):
 140   def __init__(self, name, services=None, impl="PY", libs=[], rlibs="",
 141                      includes="", kind="lib", sources=None,
 142                      inheritedclass="",compodefs="",
 143                      idls=None,interfacedefs="",inheritedinterface="",addedmethods=""):
 144     self.name = name
 145     self.impl = impl
 146     self.kind = kind
 147     self.services = services or []
 148     self.libs = libs
 149     self.rlibs = rlibs
 150     self.includes = includes
 151     self.sources = sources or []
 152     self.inheritedclass=inheritedclass
 153     self.compodefs=compodefs
 154     self.idls=idls
 155     self.interfacedefs=interfacedefs
 156     self.inheritedinterface=inheritedinterface
 157     self.addedmethods=addedmethods
 158
 159   def additionalLibraries(self):
 160     """ generate the cmake code for finding the additional libraries
 161     return
 162       string containing a list of "find_library"
 163       string containing a list of cmake variables defined
 164     """
 165     cmake_text=""
 166     cmake_vars=""
 167
 168     for lib in self.libs:
 169       cmake_text = cmake_text + lib.findLibrary()
 170       cmake_vars = cmake_vars + "${" + lib.cmakeVarName() + "}\n  "
 171
 172     var_template = Template("$${${name}_SalomeIDL${name}}")
 173     for mod in self.getDependentModules():
 174       if salome_modules[mod]["linklibs"]:
 175         cmake_vars = cmake_vars + salome_modules[mod]["linklibs"]
 176       else:
 177         default_lib = var_template.substitute(name=mod)
 178         print "Unknown libraries for module " + mod
 179         print "Using default library name " + default_lib
 180         cmake_vars = cmake_vars + default_lib + "\n  "
 181
 182     return cmake_text, cmake_vars
 183
 184   def validate(self):
 185     if self.impl not in ValidImpl:
 186       raise Invalid("%s is not a valid implementation. It should be one of %s" % (self.impl, ValidImpl))
 187
 188     lnames = set()
 189     for serv in self.services:
 190       serv.impl = self.impl
 191       if serv.name in lnames:
 192         raise Invalid("%s is already defined as a service of the module" % serv.name)
 193       lnames.add(serv.name)
 194       serv.validate()
 195
 196     for src in self.sources:
 197       if not os.path.exists(src):
 198         raise Invalid("Source file %s does not exist" % src)
 199
 200   def getImpl(self):
 201     return "SO", ""
 202
 203   def getMakefileItems(self,gen):
 204     return {}
 205
 206   def setPrerequisites(self, prerequisites_file):
 207     self.prerequisites = prerequisites_file
 208
 209   def getIdlInterfaces(self):
 210     services = self.getIdlServices()
 211     inheritedinterface=""
 212     if self.inheritedinterface:
 213       inheritedinterface=self.inheritedinterface+","
 214     return interface.substitute(component=self.name,
 215                                 services="\n".join(services),
 216                                 inheritedinterface=inheritedinterface)
 217
 218   def getIdlServices(self):
 219     services = []
 220     for serv in self.services:
 221       params = []
 222       for name, typ in serv.inport:
 223         if typ == "file":continue #files are not passed through IDL interface
 224         if self.impl in ("PY", "ASTER") and typ == "pyobj":
 225           typ = "Engines::fileBlock"
 226         else:
 227           typ=idlTypes[typ]
 228         params.append("in %s %s" % (typ, name))
 229       for name, typ in serv.outport:
 230         if typ == "file":continue #files are not passed through IDL interface
 231         if self.impl in ("PY", "ASTER") and typ == "pyobj":
 232           typ = "Engines::fileBlock"
 233         else:
 234           typ=idlTypes[typ]
 235         params.append("out %s %s" % (typ, name))
 236       service = "    %s %s(" % (idlTypes[serv.ret],serv.name)
 237       service = service+",".join(params)+") raises (SALOME::SALOME_Exception);"
 238       services.append(service)
 239     return services
 240
 241   def getIdlDefs(self):
 242     idldefs = """
 243 #include "DSC_Engines.idl"
 244 #include "SALOME_Parametric.idl"
 245 """
 246     if self.interfacedefs:
 247       idldefs = idldefs + self.interfacedefs
 248     return idldefs
 249
 250   def getDependentModules(self):
 251     """get the list of SALOME modules used by the component
 252     """
 253     def get_dependent_modules(mod,modules):
 254       modules.add(mod)
 255       if salome_modules[mod].has_key("depends"):
 256         for m in salome_modules[mod]["depends"]:
 257           if m not in modules:
 258             get_dependent_modules(m,modules)
 259
 260     depend_modules = set()
 261     for serv in self.services:
 262       for name, typ in serv.inport + serv.outport + [ ("return",serv.ret) ] :
 263         mod = moduleTypes[typ]
 264         if mod:
 265           get_dependent_modules(mod,depend_modules)
 266     return depend_modules
 267
 268 class Service(object):
 269   """
 270    A :class:`Service` instance represents a component service with dataflow and datastream ports.
 271
 272    :param name: gives the name of the service.
 273    :type name: str
 274    :param inport: gives the list of input dataflow ports.
 275    :param outport: gives the list of output dataflow ports. An input or output dataflow port is defined
 276       by a 2-tuple (port name, data type name). The list of supported basic data types is: "double", "long", "string",
 277       "dblevec", "stringvec", "intvec", "file" and "pyobj" only for Python services. Depending on the implementation
 278       language, it is also possible to use some types from SALOME modules (see :ref:`yacstypes`).
 279    :param ret: gives the type of the return parameter
 280    :param instream: gives the list of input datastream ports.
 281    :param outstream: gives the list of output datastream ports. An input or output datastream port is defined
 282       by a 3-tuple (port name, data type name, mode name). The list of possible data types is: "CALCIUM_double", "CALCIUM_integer",
 283       "CALCIUM_real", "CALCIUM_string", "CALCIUM_complex", "CALCIUM_logical", "CALCIUM_long". The mode can be "I" (iterative mode)
 284       or "T" (temporal mode).
 285    :param defs: gives the source code to insert in the definition section of the component. It can be C++ includes
 286       or Python imports
 287    :type defs: str
 288    :param body: gives the source code to insert in the service call. It can be any C++
 289       or Python code that fits well in the body of the service method.
 290    :type body: str
 291
 292    For example, the following call defines a minimal Python service with one input dataflow port (name "a", type double)
 293    and one input datastream port::
 294
 295       >>> s1 = module_generator.Service('myservice', inport=[("a","double"),],
 296                                         instream=[("aa","CALCIUM_double","I")],
 297                                         body="print a")
 298
 299
 300   """
 301   def __init__(self, name, inport=None, outport=None, ret="void", instream=None, outstream=None,
 302                      parallel_instream=None, parallel_outstream=None, defs="", body="", impl_type="sequential"):
 303     self.name = name
 304     self.inport = inport or []
 305     self.outport = outport or []
 306     self.ret = ret
 307     self.instream = instream or []
 308     self.outstream = outstream or []
 309     self.parallel_instream = parallel_instream or []
 310     self.parallel_outstream = parallel_outstream or []
 311     self.defs = defs
 312     self.body = body
 313     self.impl = ""
 314     self.impl_type = impl_type
 315
 316   def validate(self):
 317     lports = set()
 318     for port in self.inport:
 319       name, typ = self.validatePort(port)
 320       if name in lports:
 321         raise Invalid("%s is already defined as a service parameter" % name)
 322       lports.add(name)
 323
 324     for port in self.outport:
 325       name, typ = self.validatePort(port)
 326       if name in lports:
 327         raise Invalid("%s is already defined as a service parameter" % name)
 328       lports.add(name)
 329
 330     lports = set()
 331     for port in self.instream:
 332       name, typ, dep = self.validateStream(port)
 333       if name in lports:
 334         raise Invalid("%s is already defined as a stream port" % name)
 335       lports.add(name)
 336
 337     for port in self.outstream:
 338       name, typ, dep = self.validateStream(port)
 339       if name in lports:
 340         raise Invalid("%s is already defined as a stream port" % name)
 341       lports.add(name)
 342
 343     for port in self.parallel_instream:
 344       name, typ = self.validateParallelStream(port)
 345       if name in lports:
 346         raise Invalid("%s is already defined as a stream port" % name)
 347       lports.add(name)
 348
 349     for port in self.parallel_outstream:
 350       name, typ = self.validateParallelStream(port)
 351       if name in lports:
 352         raise Invalid("%s is already defined as a stream port" % name)
 353       lports.add(name)
 354
 355     self.validateImplType()
 356
 357   def validatePort(self, port):
 358     try:
 359       name, typ = port
 360     except:
 361       raise Invalid("%s is not a valid definition of an data port (name,type)" % (port,))
 362
 363     if self.impl in ("PY", "ASTER"):
 364       validtypes = PyValidTypes
 365     else:
 366       validtypes = ValidTypes
 367
 368     if typ not in validtypes:
 369       raise Invalid("%s is not a valid type. It should be one of %s" % (typ, validtypes))
 370     return name, typ
 371
 372   def validateImplType(self):
 373     if self.impl_type not in ValidImplTypes:
 374       raise Invalid("%s is not a valid impl type. It should be one of %s" % (self.impl_type, ValidImplTypes))
 375
 376   def validateStream(self, port):
 377     try:
 378       name, typ, dep = port
 379     except:
 380       raise Invalid("%s is not a valid definition of a stream port (name,type,dependency)" % (port,))
 381     if typ not in ValidStreamTypes:
 382       raise Invalid("%s is not a valid type. It should be one of %s" % (typ, ValidStreamTypes))
 383     if dep not in ValidDependencies:
 384       raise Invalid("%s is not a valid dependency. It should be one of %s" % (dep, ValidDependencies))
 385     return name, typ, dep
 386
 387   def validateParallelStream(self, port):
 388     try:
 389       name, typ = port
 390     except:
 391       raise Invalid("%s is not a valid definition of a parallel stream port (name,type)" % (port,))
 392     if typ not in ValidParallelStreamTypes:
 393       raise Invalid("%s is not a valid type. It should be one of %s" % (typ, ValidParallelStreamTypes))
 394     return name, typ
 395
 396 class Generator(object):
 397   """
 398    A :class:`Generator` instance take a :class:`Module` instance as its first parameter and can be used to generate the
 399    SALOME source module, builds it, installs it and includes it in a SALOME application.
 400
 401    :param module: gives the :class:`Module` instance that will be used for the generation.
 402    :param context: If given , its content is used to specify the prerequisites
 403       environment file (key *"prerequisites"*) and the SALOME KERNEL installation directory (key *"kernel"*).
 404    :type context: dict
 405
 406    For example, the following call creates a generator for the module m::
 407
 408       >>> g = module_generator.Generator(m,context)
 409   """
 410   def __init__(self, module, context=None):
 411     self.module = module
 412     self.context = context or {}
 413     self.kernel = self.context["kernel"]
 414     self.gui = self.context.get("gui")
 415     self.makeflags = self.context.get("makeflags")
 416     self.aster = ""
 417     if self.module.gui and not self.gui:
 418       raise Invalid("To generate a module with GUI, you need to set the 'gui' parameter in the context dictionnary")
 419     for component in self.module.components:
 420       component.setPrerequisites(self.context.get("prerequisites"))
 421
 422   def sourceDir(self):
 423     """ get the name of the source directory"""
 424     return self.module.name+"_SRC"
 425
 426   def generate(self):
 427     """Generate a SALOME source module"""
 428     module = self.module
 429     namedir = self.sourceDir()
 430     force = self.context.get("force")
 431     update = self.context.get("update")
 432     paco = self.context.get("paco")
 433     if os.path.exists(namedir):
 434       if force:
 435         shutil.rmtree(namedir)
 436       elif not update:
 437         raise Invalid("The directory %s already exists" % namedir)
 438     if update:
 439       makedirs(namedir)
 440     else:
 441       os.makedirs(namedir)
 442
 443     srcs = {}
 444
 445     #get the list of SALOME modules used and put it in used_modules attribute
 446     modules = set()
 447     for compo in module.components:
 448       modules |= compo.getDependentModules()
 449
 450     self.used_modules = modules
 451
 452     for compo in module.components:
 453       #for components files
 454       fdict=compo.makeCompo(self)
 455       srcs[compo.name] = fdict
 456
 457     cmakecontent = ""
 458     components_string = "".join(map(lambda x: x.name+" ", module.components))
 459
 460     if self.module.gui:
 461       GUIname=module.name+"GUI"
 462       fdict=self.makeGui(namedir)
 463       srcs[GUIname] = fdict
 464       components_string = components_string + "\n  " + GUIname
 465
 466     cmakecontent = cmake_src.substitute(components=components_string)
 467     srcs["CMakeLists.txt"] = cmakecontent
 468
 469     docsubdir=""
 470     if module.doc:
 471       docsubdir="doc"
 472       cmake_doc="ON"
 473     else:
 474       cmake_doc="OFF"
 475
 476     #for catalog files
 477     catalogfile = "%sCatalog.xml" % module.name
 478
 479     if module.gui:
 480       cmake_gui="ON"
 481     else:
 482       cmake_gui="OFF"
 483
 484     prefix = os.path.abspath(self.module.prefix)
 485     component_libs = "".join(map(lambda x: x.libraryName()+" ",
 486                                            module.components))
 487     add_modules = "".join(map(lambda x:cmake_find_module.substitute(module=x),
 488                                        self.used_modules))
 489     self.makeFiles({"CMakeLists.txt":cmake_root_cpp.substitute(
 490                                                  module=self.module.name,
 491                                                  module_min=self.module.name.lower(),
 492                                                  compolibs=component_libs,
 493                                                  with_doc=cmake_doc,
 494                                                  with_gui=cmake_gui,
 495                                                  add_modules=add_modules,
 496                                                  major_version=yacsgen_version.major_version,
 497                                                  minor_version=yacsgen_version.minor_version,
 498                                                  patch_version=yacsgen_version.patch_version),
 499                     "README":"", "NEWS":"", "AUTHORS":"", "ChangeLog":"",
 500                     "src":srcs,
 501                     "resources":{"CMakeLists.txt":cmake_ressources.substitute(
 502                                                         module=self.module.name),
 503                                  catalogfile:self.makeCatalog()},
 504                     }, namedir)
 505
 506     files={}
 507     #for idl files
 508     idlfile = "%s.idl" % module.name
 509
 510     #if components have other idls
 511     other_idls=""
 512 #    other_sks=""
 513     for compo in module.components:
 514       if compo.idls:
 515         for idl in compo.idls:
 516           for fidl in glob.glob(idl):
 517             other_idls=other_idls+os.path.basename(fidl) +" "
 518 #            other_sks=other_sks+os.path.splitext(os.path.basename(fidl))[0]+"SK.cc "
 519
 520     include_template=Template("$${${module}_ROOT_DIR}/idl/salome")
 521     opt_inc="".join(map(lambda x:include_template.substitute(module=x)+"\n  ",
 522                                        self.used_modules))
 523     link_template=Template("$${${module}_SalomeIDL${module}}")
 524     opt_link="".join(map(lambda x:link_template.substitute(module=x)+"\n  ",
 525                                        self.used_modules))
 526
 527     idlfiles={"CMakeLists.txt":cmake_idl.substitute(module=module.name,
 528                                                     extra_idl=other_idls,
 529                                                     extra_include=opt_inc,
 530                                                     extra_link=opt_link),
 531               idlfile         :self.makeidl(),
 532              }
 533
 534     files["idl"]=idlfiles
 535
 536     self.makeFiles(files,namedir)
 537
 538     #copy source files if any in created tree
 539     for compo in module.components:
 540       for src in compo.sources:
 541         shutil.copyfile(src, os.path.join(namedir, "src", compo.name, os.path.basename(src)))
 542
 543       if compo.idls:
 544         #copy provided idl files in idl directory
 545         for idl in compo.idls:
 546           for fidl in glob.glob(idl):
 547             shutil.copyfile(fidl, os.path.join(namedir, "idl", os.path.basename(fidl)))
 548
 549     self.makeDoc(namedir)
 550     return
 551
 552   def makeDoc(self,namedir):
 553     if not self.module.doc:
 554       return
 555     rep=os.path.join(namedir,"doc")
 556     os.makedirs(rep)
 557     doc_files=""
 558     for docs in self.module.doc:
 559       for doc in glob.glob(docs):
 560         name = os.path.basename(doc)
 561         doc_files = doc_files + name + "\n  "
 562         shutil.copyfile(doc, os.path.join(rep, name))
 563
 564     d={}
 565
 566     if not self.module.gui:
 567        #without gui but with doc: create a small SalomeApp.xml in doc directory
 568        if not os.path.exists(os.path.join(namedir, "doc", "SalomeApp.xml")):
 569          #create a minimal SalomeApp.xml
 570          salomeapp=docsalomeapp.substitute(module=self.module.name,
 571                                            lmodule=self.module.name.lower(),
 572                                            version=yacsgen_version.complete_version)
 573          d["SalomeApp.xml"]=salomeapp
 574
 575     if not os.path.exists(os.path.join(namedir, "doc", "CMakeLists.txt")):
 576       #create a minimal CMakeLists.txt
 577       makefile_txt=docmakefile.substitute(module=self.module.name,
 578                                           files=doc_files)
 579       if not self.module.gui:
 580         txt = 'INSTALL(FILES SalomeApp.xml DESTINATION \
 581 "${SALOME_%s_INSTALL_RES_DATA}")\n' % self.module.name
 582         makefile_txt = makefile_txt + txt
 583         pass
 584
 585       d["CMakeLists.txt"]=makefile_txt
 586       pass
 587
 588     if not os.path.exists(os.path.join(namedir, "doc", "conf.py")):
 589       #create a minimal conf.py
 590       d["conf.py"]=docconf.substitute(module=self.module.name)
 591
 592     self.makeFiles(d,os.path.join(namedir,"doc"))
 593
 594   def makeGui(self,namedir):
 595     if not self.module.gui:
 596       return
 597     ispython=False
 598     iscpp=False
 599     #Force creation of intermediate directories
 600     os.makedirs(os.path.join(namedir, "src", self.module.name+"GUI"))
 601
 602     for srcs in self.module.gui:
 603       for src in glob.glob(srcs):
 604         shutil.copyfile(src, os.path.join(namedir, "src", self.module.name+"GUI", os.path.basename(src)))
 605         if src[-3:]==".py":ispython=True
 606         if src[-4:]==".cxx":iscpp=True
 607     if ispython and iscpp:
 608       raise Invalid("Module GUI must be pure python or pure C++ but not mixed")
 609     if ispython:
 610       return self.makePyGUI(namedir)
 611     if iscpp:
 612       return self.makeCPPGUI(namedir)
 613     raise Invalid("Module GUI must be in python or C++ but it is none of them")
 614
 615   def makePyGUI(self,namedir):
 616     d={}
 617     if not os.path.exists(os.path.join(namedir, "src", self.module.name+"GUI", "CMakeLists.txt")):
 618       #create a minimal CMakeLists.txt
 619       sources=""
 620       other=""
 621       ui_files=""
 622       ts_files=""
 623       for srcs in self.module.gui:
 624         for src in glob.glob(srcs):
 625           if src[-3:]==".py":
 626             sources=sources+os.path.basename(src)+"\n  "
 627           elif src[-3:]==".ts":
 628             ts_files=ts_files+os.path.basename(src)+"\n  "
 629           else:
 630             other=other+os.path.basename(src)+"\n  "
 631       makefile=cmake_py_gui.substitute(module=self.module.name,
 632                                        scripts=sources,
 633                                        ts_resources=ts_files,
 634                                        resources=other)
 635       d["CMakeLists.txt"]=makefile
 636
 637     if not os.path.exists(os.path.join(namedir, "src", self.module.name+"GUI", "SalomeApp.xml")):
 638       #create a minimal SalomeApp.xml
 639       salomeapp=pysalomeapp.substitute(module=self.module.name,
 640                                        lmodule=self.module.name.lower(),
 641                                        version=yacsgen_version.complete_version)
 642       d["SalomeApp.xml"]=salomeapp
 643
 644     return d
 645
 646   def makeCPPGUI(self,namedir):
 647     d={}
 648     if not os.path.exists(os.path.join(namedir, "src", self.module.name+"GUI", "CMakeLists.txt")):
 649       #create a minimal CMakeLists.txt
 650       sources=""
 651       headers=""
 652       other=""
 653       ui_files=""
 654       ts_files=""
 655       for srcs in self.module.gui:
 656         for src in glob.glob(srcs):
 657           if src[-4:]==".cxx" or src[-4:]==".cpp":
 658             sources=sources+os.path.basename(src)+"\n  "
 659           elif src[-2:]==".h" or src[-4:]==".hxx":
 660             headers=headers+os.path.basename(src)+"\n  "
 661           elif src[-3:]==".ui":
 662             ui_files=ui_files+os.path.basename(src)+"\n  "
 663           elif src[-3:]==".ts":
 664             ts_files=ts_files+os.path.basename(src)+"\n  "
 665           else:
 666             other=other+os.path.basename(src)+"\n  "
 667
 668       compo_dirs = "".join(map(lambda x:
 669                                  "${PROJECT_SOURCE_DIR}/src/"+x.name+"\n  ",
 670                                  self.module.components))
 671       compo_dirs = compo_dirs + "${PROJECT_BINARY_DIR}/src/" + self.module.name + "GUI\n"
 672       component_libs = "".join(map(lambda x:
 673                               x.libraryName()+" ", self.module.components))
 674       makefile=cmake_cpp_gui.substitute(module=self.module.name,
 675                                     include_dirs=compo_dirs,
 676                                     libs=component_libs,
 677                                     uic_files=ui_files,
 678                                     moc_headers=headers,
 679                                     sources=sources,
 680                                     resources=other,
 681                                     ts_resources=ts_files)
 682       d["CMakeLists.txt"]=makefile
 683
 684     if not os.path.exists(os.path.join(namedir, "src", self.module.name+"GUI", "SalomeApp.xml")):
 685       #create a minimal SalomeApp.xml
 686       salomeapp=cppsalomeapp.substitute(module=self.module.name,
 687                                         lmodule=self.module.name.lower(),
 688                                         version=yacsgen_version.complete_version)
 689       d["SalomeApp.xml"]=salomeapp
 690
 691     return d
 692
 693   def makeMakefile(self,makefileItems):
 694     makefile=""
 695     if makefileItems.has_key("header"):
 696       makefile=makefile + makefileItems["header"]+'\n'
 697     if makefileItems.has_key("lib_LTLIBRARIES"):
 698       makefile=makefile+"lib_LTLIBRARIES= "+" ".join(makefileItems["lib_LTLIBRARIES"])+'\n'
 699     if makefileItems.has_key("salomepython_PYTHON"):
 700       makefile=makefile+"salomepython_PYTHON= "+" ".join(makefileItems["salomepython_PYTHON"])+'\n'
 701     if makefileItems.has_key("dist_salomescript_SCRIPTS"):
 702       makefile=makefile+"dist_salomescript_SCRIPTS= "+" ".join(makefileItems["dist_salomescript_SCRIPTS"])+'\n'
 703     if makefileItems.has_key("salomeres_DATA"):
 704       makefile=makefile+"salomeres_DATA= "+" ".join(makefileItems["salomeres_DATA"])+'\n'
 705     if makefileItems.has_key("salomeinclude_HEADERS"):
 706       makefile=makefile+"salomeinclude_HEADERS= "+" ".join(makefileItems["salomeinclude_HEADERS"])+'\n'
 707     if makefileItems.has_key("body"):
 708       makefile=makefile+makefileItems["body"]+'\n'
 709     return makefile
 710
 711   def makeArgs(self, service):
 712     """generate source service for arguments"""
 713     params = []
 714     for name, typ in service.inport:
 715       if typ=="file":continue #files are not passed through service interface
 716       params.append("%s %s" % (corba_in_type(typ, self.module.name), name))
 717     for name, typ in service.outport:
 718       if typ=="file":continue #files are not passed through service interface
 719       params.append("%s %s" % (corba_out_type(typ, self.module.name), name))
 720     return ",".join(params)
 721
 722   def makeCatalog(self):
 723     """generate SALOME components catalog source"""
 724     components = []
 725     for compo in self.module.components:
 726       services = []
 727       for serv in compo.services:
 728         params = []
 729         for name, typ in serv.inport:
 730           params.append(cataInparam.substitute(name=name, type=typ))
 731         inparams = "\n".join(params)
 732         params = []
 733         for name, typ in serv.outport:
 734           params.append(cataOutparam.substitute(name=name, type=typ))
 735         if serv.ret != "void" :
 736           params.append(cataOutparam.substitute(name="return", type=serv.ret))
 737         outparams = "\n".join(params)
 738         streams = []
 739         for name, typ, dep in serv.instream:
 740           streams.append(cataInStream.substitute(name=name, type=calciumTypes[typ], dep=dep))
 741         for name, typ, dep in serv.outstream:
 742           streams.append(cataOutStream.substitute(name=name, type=calciumTypes[typ], dep=dep))
 743         for name, typ in serv.parallel_instream:
 744           streams.append(cataInParallelStream.substitute(name=name, type=DatastreamParallelTypes[typ]))
 745         for name, typ in serv.parallel_outstream:
 746           streams.append(cataOutParallelStream.substitute(name=name, type=DatastreamParallelTypes[typ]))
 747         datastreams = "\n".join(streams)
 748         services.append(cataService.substitute(service=serv.name, author="EDF-RD",
 749                                                inparams=inparams, outparams=outparams, datastreams=datastreams))
 750       impltype, implname = compo.getImpl()
 751       components.append(cataCompo.substitute(component=compo.name, author="EDF-RD", impltype=impltype, implname=implname,
 752                                              services='\n'.join(services)))
 753     return catalog.substitute(components='\n'.join(components))
 754
 755   def makeidl(self):
 756     """generate module IDL file source (CORBA interface)"""
 757     interfaces = []
 758     idldefs=""
 759     for compo in self.module.components:
 760       interfaces.append(compo.getIdlInterfaces())
 761
 762     #build idl includes for SALOME modules
 763     for mod in self.used_modules:
 764       idldefs = idldefs + salome_modules[mod]["idldefs"]
 765
 766     for compo in self.module.components:
 767       idldefs = idldefs + compo.getIdlDefs()
 768
 769     filteredDefs = []
 770     for defLine in idldefs.split('\n'):
 771       if defLine not in filteredDefs:
 772         filteredDefs.append(defLine)
 773
 774     return idl.substitute(module=self.module.name,
 775                           interfaces='\n'.join(interfaces),
 776                           idldefs='\n'.join(filteredDefs) )
 777
 778   # For PaCO++
 779   def makexml(self):
 780     from pacocompo import PACOComponent
 781     interfaces = []
 782     for compo in self.module.components:
 783       if isinstance(compo, PACOComponent):
 784         services = []
 785         for serv in compo.services:
 786           if serv.impl_type == "parallel":
 787             service = xml_service.substitute(service_name=serv.name)
 788             services.append(service)
 789         interfaces.append(xml_interface.substitute(component=compo.name, xml_services="\n".join(services)))
 790     return xml.substitute(module=self.module.name, interfaces='\n'.join(interfaces))
 791
 792   def makeFiles(self, dic, basedir):
 793     """create files and directories defined in dictionary dic in basedir directory
 794        dic key = file name to create
 795        dic value = file content or dictionary defining the content of a sub directory
 796     """
 797     for name, content in dic.items():
 798       filename = os.path.join(basedir, name)
 799       if isinstance(content, str):
 800         fil =  open(filename, 'w')
 801         fil.write(content)
 802         fil.close()
 803       else:
 804         if not os.path.exists(filename):
 805           os.makedirs(filename)
 806         self.makeFiles(content, filename)
 807
 808   def configure(self):
 809     """Execute the second build step (configure) with installation prefix as given by the prefix attribute of module"""
 810     prefix = os.path.abspath(self.module.prefix)
 811
 812     self.build_dir = "%s_build" % self.module.name
 813     makedirs(self.build_dir)
 814
 815     build_sh = "cd %s; cmake ../%s -DCMAKE_INSTALL_PREFIX:PATH=%s"%(self.build_dir, self.sourceDir(), prefix)
 816     ier = os.system(build_sh)
 817     if ier != 0:
 818       raise Invalid("configure has ended in error")
 819
 820   def make(self):
 821     """Execute the third build step (compile and link) : make"""
 822     make_command = "cd %s; make " % self.build_dir
 823     if self.makeflags:
 824       make_command += self.makeflags
 825     ier = os.system(make_command)
 826     if ier != 0:
 827       raise Invalid("make has ended in error")
 828
 829   def install(self):
 830     """Execute the installation step : make install """
 831     make_command = "cd %s; make install" % self.build_dir
 832     ier = os.system(make_command)
 833     if ier != 0:
 834       raise Invalid("install has ended in error")
 835
 836   def make_appli(self, appliname, restrict=None, altmodules=None, resources=""):
 837     """
 838    Create a SALOME application containing the module and preexisting SALOME modules.
 839
 840    :param appliname: is a string that gives the name of the application (directory path where the application
 841       will be installed).
 842    :type appliname: str
 843    :param restrict: If given (a list of module names), only those SALOME modules will be included in the
 844       application. The default is to include all modules that are located in the same directory as the KERNEL module and have
 845       the same suffix (for example, if KERNEL directory is KERNEL_V5 and GEOM directory is GEOM_V5, GEOM module is automatically
 846       included, except if restrict is used).
 847    :param altmodules: can be used to add SALOME modules that cannot be managed with the precedent rule. This parameter
 848       is a dict with a module name as the key and the installation path as the value.
 849    :param resources: can be used to define an alternative resources catalog (path of the file).
 850
 851    For example, the following calls create a SALOME application with external modules and resources catalog in "appli" directory::
 852
 853      >>> g=Generator(m,context)
 854      >>> g.generate()
 855      >>> g.configure()
 856      >>> g.make()
 857      >>> g.install()
 858      >>> g.make_appli("appli", restrict=["KERNEL"], altmodules={"GUI":GUI_ROOT_DIR, "YACS":YACS_ROOT_DIR},
 859                       resources="myresources.xml")
 860
 861     """
 862     makedirs(appliname)
 863
 864     rootdir, kerdir = os.path.split(self.kernel)
 865
 866     #collect modules besides KERNEL module with the same suffix if any
 867     modules_dict = {}
 868     if kerdir[:6] == "KERNEL":
 869       suffix = kerdir[6:]
 870       for mod in os.listdir(rootdir):
 871         if mod[-len(suffix):] == suffix:
 872           module = mod[:-len(suffix)]
 873           path = os.path.join(rootdir, mod)
 874           #try to find catalog files
 875           lcata = glob.glob(os.path.join(path, "share", "salome", "resources", "*", "*Catalog.xml"))
 876           if not lcata:
 877             #catalogs have not been found : try the upper level
 878             lcata = glob.glob(os.path.join(path, "share", "salome", "resources", "*Catalog.xml"))
 879           if lcata:
 880             #catalogs have been found : add the corresponding entries in the application
 881             for cata in lcata:
 882               catadir, catafile = os.path.split(cata)
 883               name = catafile[:-11]
 884               modules_dict[name] = '  <module name="%s" path="%s"/>' % (name, path)
 885           else:
 886             modules_dict[module] = '  <module name="%s" path="%s"/>' % (module, path)
 887
 888     modules_dict["KERNEL"] = '  <module name="KERNEL" path="%s"/>' % self.kernel
 889
 890     #keep only the modules which names are in restrict if given
 891     modules = []
 892     if restrict:
 893       for mod in restrict:
 894         if modules_dict.has_key(mod):
 895           modules.append(modules_dict[mod])
 896     else:
 897       modules = modules_dict.values()
 898
 899     #add the alternate modules if given
 900     if altmodules:
 901       for module, path in altmodules.items():
 902         modules.append('  <module name="%s" path="%s"/>' % (module, path))
 903
 904     #add the generated module
 905     modules.append('  <module name="%s" path="%s"/>' % (self.module.name, os.path.abspath(self.module.prefix)))
 906
 907
 908     #try to find a prerequisites file
 909     prerequisites = self.context.get("prerequisites")
 910     if not prerequisites:
 911       #try to find one in rootdir
 912       prerequisites = os.path.join(rootdir, "profile%s.sh" % suffix)
 913     if not os.path.exists(prerequisites):
 914       raise Invalid("Can not create an application : prerequisites file not defined or does not exist")
 915
 916     #add resources catalog if it exists
 917     resources_spec=""
 918     if os.path.isfile(resources):
 919       resources_spec='<resources path="%s" />' % os.path.abspath(resources)
 920
 921     #create config_appli.xml file
 922     appli = application.substitute(prerequisites=prerequisites,
 923                                    modules="\n".join(modules),
 924                                    resources=resources_spec)
 925     fil = open(os.path.join(appliname, "config_appli.xml"), 'w')
 926     fil.write(appli)
 927     fil.close()
 928
 929     #execute appli_gen.py script
 930     appligen = os.path.join(self.kernel, "bin", "salome", "appli_gen.py")
 931     ier = os.system("cd %s;%s" % (appliname, appligen))
 932     if ier != 0:
 933       raise Invalid("make_appli has ended in error")
 934
 935     #add CatalogResources.xml if not created by appli_gen.py
 936     if not os.path.exists(os.path.join(appliname, "CatalogResources.xml")):
 937       #CatalogResources.xml does not exist create a minimal one
 938       fil  = open(os.path.join(appliname, 'CatalogResources.xml'), 'w')
 939       command = """<!DOCTYPE ResourcesCatalog>
 940 <resources>
 941     <machine hostname="%s" protocol="ssh" mode="interactive" />
 942 </resources>
 943 """
 944       host = socket.gethostname().split('.')[0]
 945       fil.write(command % host)
 946       fil.close()
 947