mirror of https://github.com/KLayout/klayout.git
812 lines
31 KiB
Python
Executable File
812 lines
31 KiB
Python
Executable File
#! /usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
#===============================================================================
|
|
# File: "macbuild/build4mac.py"
|
|
#
|
|
# The top Python script for building KLayout (http://www.klayout.de/index.php)
|
|
# version 0.25 or later on different Apple Mac OSX platforms.
|
|
#===============================================================================
|
|
from __future__ import print_function # to use print() of Python 3 in Python >= 2.7
|
|
import sys
|
|
import os
|
|
import shutil
|
|
import glob
|
|
import platform
|
|
import optparse
|
|
import subprocess
|
|
|
|
#-------------------------------------------------------------------------------
|
|
## To import global dictionaries of different modules
|
|
#-------------------------------------------------------------------------------
|
|
mydir = os.path.dirname(os.path.abspath(__file__))
|
|
sys.path.append( mydir + "/macbuild" )
|
|
from build4mac_env import *
|
|
from build4mac_util import *
|
|
|
|
#-------------------------------------------------------------------------------
|
|
## To set global variables including present directory and platform info.
|
|
#-------------------------------------------------------------------------------
|
|
def SetGlobals():
|
|
global ProjectDir # project directory where "build.sh" exists
|
|
global Usage # string on usage
|
|
global BuildBash # the main build Bash script
|
|
global Platform # platform
|
|
global ModuleQt # Qt module to be used
|
|
global ModuleRuby # Ruby module to be used
|
|
global ModulePython # Python module to be used
|
|
global NoQtBindings # True if not creating Qt bindings for Ruby scripts
|
|
global MakeOptions # options passed to `make`
|
|
global DebugMode # True if debug mode build
|
|
global CheckComOnly # True if only for checking the command line parameters to "build.sh"
|
|
global Deployment # True if deploying the binaries for a package
|
|
global Version # KLayout's version
|
|
# auxiliary variables on platform
|
|
global System # 6-tuple from platform.uname()
|
|
global Node # - do -
|
|
global Release # - do -
|
|
global Version # - do -
|
|
global Machine # - do -
|
|
global Processor # - do -
|
|
global Bit # machine bit-size
|
|
|
|
Usage = "\n"
|
|
Usage += "---------------------------------------------------------------------------------------------\n"
|
|
Usage += "<< Usage of 'build4mac.py' >>\n"
|
|
Usage += " for building KLayout 0.25 or later on different Apple Mac OSX platforms.\n"
|
|
Usage += "\n"
|
|
Usage += "$ [python] build4mac.py \n"
|
|
Usage += " option & argument : comment on option if any | default value\n"
|
|
Usage += " -----------------------------------------------------------------------+---------------\n"
|
|
Usage += " : * key type names below are case insensitive * | \n"
|
|
Usage += " : 'nil' = not to support the script language | \n"
|
|
Usage += " : 'Sys' = using the OS standard script language | \n"
|
|
Usage += " [-q|--qt <type>] : type=['Qt4MacPorts', 'Qt5MacPorts'] | qt5macports \n"
|
|
Usage += " [-r|--ruby <type>] : type=['nil', 'Sys', 'RubySource'] | sys \n"
|
|
Usage += " [-p|--python <type>] : type=['nil', 'Sys', 'Anaconda27', 'Anaconda36'] | sys \n"
|
|
Usage += " [-n|--noqtbinding] : don't create Qt bindings for ruby scripts | disabled \n"
|
|
Usage += " [-m|--make <option>] : option passed to 'make' | -j4 \n"
|
|
Usage += " [-d|--debug] : enable debug mode build | disabled \n"
|
|
Usage += " [-c|--checkcom] : check command line and exit without building | disabled \n"
|
|
Usage += " [-y|--deploy] : deploy built binaries with depending libraries | disabled \n"
|
|
Usage += " : ! After confirmation of successful build of | \n"
|
|
Usage += " : KLayout, rerun this script with BOTH: | \n"
|
|
Usage += " : 1) the same options used for building AND | \n"
|
|
Usage += " : 2) [-y|--deploy] | \n"
|
|
Usage += " [-?|--?] : print this usage and exit | disabled \n"
|
|
Usage += "---------------------------------------------------------------------------------------------\n"
|
|
|
|
ProjectDir = os.getcwd()
|
|
BuildBash = "./build.sh"
|
|
(System, Node, Release, Version, Machine, Processor) = platform.uname()
|
|
|
|
if not System == "Darwin":
|
|
print("")
|
|
print( "!!! Sorry. Your system <%s> looks like non-Mac" % System, file=sys.stderr )
|
|
print(Usage)
|
|
quit()
|
|
|
|
release = int( Release.split(".")[0] ) # take the first of ['14', '5', '0']
|
|
if release == 14:
|
|
Platform = "Yosemite"
|
|
elif release == 15:
|
|
Platform = "ElCapitan"
|
|
elif release == 16:
|
|
Platform = "Sierra"
|
|
elif release == 17:
|
|
Platform = "HighSierra"
|
|
else:
|
|
Platform = ""
|
|
print("")
|
|
print( "!!! Sorry. Unsupported major OS release <%d>" % release, file=sys.stderr )
|
|
print(Usage)
|
|
quit()
|
|
|
|
if not Machine == "x86_64":
|
|
print("")
|
|
print( "!!! Sorry. Only x86_64 architecture machine is supported but found <%s>" % Machine, file=sys.stderr )
|
|
print(Usage)
|
|
quit()
|
|
|
|
# default modules
|
|
ModuleQt = "Qt5MacPorts"
|
|
if Platform == "Yosemite":
|
|
ModuleRuby = "RubyYosemite"
|
|
ModulePython = "PythonYosemite"
|
|
elif Platform == "ElCapitan":
|
|
ModuleRuby = "RubyElCapitan"
|
|
ModulePytyon = "PythonElCapitan"
|
|
elif Platform == "Sierra":
|
|
ModuleRuby = "RubySierra"
|
|
ModulePython = "PythonSierra"
|
|
elif Platform == "HighSierra":
|
|
ModuleRuby = "RubyHighSierra"
|
|
ModulePython = "PythonHighSierra"
|
|
else:
|
|
ModuleRuby = "nil"
|
|
ModulePython = "nil"
|
|
|
|
NoQtBindings = False
|
|
MakeOptions = "-j4"
|
|
DebugMode = False
|
|
CheckComOnly = False
|
|
Deployment = False
|
|
Version = GetKLayoutVersionFrom( "./version.sh" )
|
|
|
|
#------------------------------------------------------------------------------
|
|
## To get command line parameters
|
|
#------------------------------------------------------------------------------
|
|
def ParseCommandLineArguments():
|
|
global Usage
|
|
global Platform
|
|
global ModuleQt
|
|
global ModuleRuby
|
|
global ModulePython
|
|
global NoQtBindings
|
|
global MakeOptions
|
|
global DebugMode
|
|
global CheckComOnly
|
|
global Deployment
|
|
|
|
p = optparse.OptionParser( usage=Usage )
|
|
p.add_option( '-q', '--qt',
|
|
dest='type_qt',
|
|
help="Qt type=['Qt4MacPorts', 'Qt5MacPorts']" )
|
|
|
|
p.add_option( '-r', '--ruby',
|
|
dest='type_ruby',
|
|
help="Ruby type=['nil', 'Sys', 'RubySource']" )
|
|
|
|
p.add_option( '-p', '--python',
|
|
dest='type_python',
|
|
help="Python type=['nil', 'Sys', 'Anaconda27', 'Anaconda36']" )
|
|
|
|
p.add_option( '-n', '--noqtbinding',
|
|
action='store_true',
|
|
dest='no_qt_binding',
|
|
default=False,
|
|
help="do not create Qt bindings for Ruby scripts" )
|
|
|
|
p.add_option( '-m', '--make',
|
|
dest='make_option',
|
|
help="options passed to `make`" )
|
|
|
|
p.add_option( '-d', '--debug',
|
|
action='store_true',
|
|
dest='debug_build',
|
|
default=False,
|
|
help="enable debug mode build" )
|
|
|
|
p.add_option( '-c', '--checkcom',
|
|
action='store_true',
|
|
dest='check_command',
|
|
default=False,
|
|
help="check command line and exit without building" )
|
|
|
|
p.add_option( '-y', '--deploy',
|
|
action='store_true',
|
|
dest='deploy_bins',
|
|
default=False,
|
|
help="deploy built binaries" )
|
|
|
|
p.add_option( '-?', '--??',
|
|
action='store_true',
|
|
dest='checkusage',
|
|
default=False,
|
|
help='check usage' )
|
|
|
|
p.set_defaults( type_qt = "qt5macports",
|
|
type_ruby = "sys",
|
|
type_python = "sys",
|
|
no_qt_binding = False,
|
|
make_option = "-j4",
|
|
debug_build = False,
|
|
check_command = False,
|
|
deploy_bins = False,
|
|
checkusage = False )
|
|
|
|
opt, args = p.parse_args()
|
|
if (opt.checkusage):
|
|
print(Usage)
|
|
quit()
|
|
|
|
# Determine Qt type
|
|
candidates = [ i.upper() for i in ['Qt4MacPorts', 'Qt5MacPorts'] ]
|
|
ModuleQt = ""
|
|
index = 0
|
|
for item in candidates:
|
|
if opt.type_qt.upper() == item:
|
|
if index == 0:
|
|
ModuleQt = 'Qt4MacPorts'
|
|
break
|
|
elif index == 1:
|
|
ModuleQt = 'Qt5MacPorts'
|
|
break
|
|
else:
|
|
index += 1
|
|
if ModuleQt == "":
|
|
print("")
|
|
print( "!!! Unknown Qt type", file=sys.stderr )
|
|
print(Usage)
|
|
quit()
|
|
|
|
# Determine Ruby type
|
|
candidates = [ i.upper() for i in ['nil', 'Sys', 'RubySource'] ]
|
|
ModuleRuby = ""
|
|
index = 0
|
|
for item in candidates:
|
|
if opt.type_ruby.upper() == item:
|
|
if index == 0:
|
|
ModuleRuby = 'nil'
|
|
break
|
|
elif index == 1:
|
|
if Platform == "Yosemite":
|
|
ModuleRuby = 'RubyYosemite'
|
|
elif Platform == "ElCapitan":
|
|
ModuleRuby = 'RubyElCapitan'
|
|
elif Platform == "Sierra":
|
|
ModuleRuby = 'RubySierra'
|
|
elif Platform == "HighSierra":
|
|
ModuleRuby = 'RubyHighSierra'
|
|
else:
|
|
ModuleRuby = ''
|
|
break
|
|
elif index == 2:
|
|
ModuleRuby = 'Ruby24SrcBuild'
|
|
else:
|
|
index += 1
|
|
if ModuleRuby == "":
|
|
print("")
|
|
print( "!!! Unknown Ruby type", file=sys.stderr )
|
|
print(Usage)
|
|
quit()
|
|
|
|
# Determine Python type
|
|
candidates = [ i.upper() for i in ['nil', 'Sys', 'Anaconda27', 'Anaconda36'] ]
|
|
ModulePython = ""
|
|
index = 0
|
|
for item in candidates:
|
|
if opt.type_python.upper() == item:
|
|
if index == 0:
|
|
ModulePython = 'nil'
|
|
break
|
|
elif index == 1:
|
|
if Platform == "Yosemite":
|
|
ModulePython = 'PythonYosemite'
|
|
elif Platform == "ElCapitan":
|
|
ModulePython = 'PythonElCapitan'
|
|
elif Platform == "Sierra":
|
|
ModulePython = 'PythonSierra'
|
|
elif Platform == "HighSierra":
|
|
ModulePython = 'PythonHighSierra'
|
|
else:
|
|
ModulePython = ''
|
|
break
|
|
elif index == 2:
|
|
ModulePython = 'Anaconda27'
|
|
elif index == 3:
|
|
ModulePython = 'Anaconda36'
|
|
else:
|
|
index += 1
|
|
if ModulePython == "":
|
|
print("")
|
|
print( "!!! Unknown Python type", file=sys.stderr )
|
|
print(Usage)
|
|
quit()
|
|
|
|
NoQtBindings = opt.no_qt_binding
|
|
MakeOptions = opt.make_option
|
|
DebugMode = opt.debug_build
|
|
CheckComOnly = opt.check_command
|
|
Deployment = opt.deploy_bins
|
|
|
|
if not Deployment:
|
|
target = "%s %s %s" % (Platform, Release, Machine)
|
|
modules = "Qt=%s, Ruby=%s, Python=%s" % (ModuleQt, ModuleRuby, ModulePython)
|
|
message = "### You are going to build KLayout\n for <%s>\n with <%s>...\n"
|
|
print("")
|
|
print( message % (target, modules) )
|
|
|
|
#------------------------------------------------------------------------------
|
|
## To run the main Bash script "build.sh" with appropriate options
|
|
#
|
|
# @return 0 on success; non-zero on failure
|
|
#------------------------------------------------------------------------------
|
|
def RunMainBuildBash():
|
|
global ProjectDir
|
|
global Platform
|
|
global BuildBash
|
|
global ModuleQt
|
|
global ModuleRuby
|
|
global ModulePython
|
|
global NoQtBindings
|
|
global MakeOptions
|
|
global DebugMode
|
|
global CheckComOnly
|
|
global Deployment
|
|
global MacPkgDir # relative path to package directory
|
|
global MacBinDir # relative path to binary directory
|
|
global MacBuildDir # relative path to build directory
|
|
global MacBuildLog # relative path to build log file
|
|
global AbsMacPkgDir # absolute path to package directory
|
|
global AbsMacBinDir # absolute path to binary directory
|
|
global AbsMacBuildDir # absolute path to build directory
|
|
global AbsMacBuildLog # absolute path to build log file
|
|
|
|
#-----------------------------------------------------
|
|
# [1] Set parameters passed to the main Bash script
|
|
#-----------------------------------------------------
|
|
parameters = ""
|
|
|
|
# (A) debug or release
|
|
if DebugMode:
|
|
mode = "debug"
|
|
parameters += " -debug"
|
|
else:
|
|
mode = "release"
|
|
parameters += " -release"
|
|
|
|
# (B) Qt4 or Qt5
|
|
if ModuleQt == 'Qt4MacPorts':
|
|
parameters += " \\\n -qt4"
|
|
parameters += " \\\n -qmake %s" % Qt4MacPorts['qmake']
|
|
MacPkgDir = "./qt4.pkg.macos-%s-%s" % (Platform, mode)
|
|
MacBinDir = "./qt4.bin.macos-%s-%s" % (Platform, mode)
|
|
MacBuildDir = "./qt4.build.macos-%s-%s" % (Platform, mode)
|
|
MacBuildLog = "./qt4.build.macos-%s-%s.log" % (Platform, mode)
|
|
AbsMacPkgDir = "%s/qt4.pkg.macos-%s-%s" % (ProjectDir, Platform, mode)
|
|
AbsMacBinDir = "%s/qt4.bin.macos-%s-%s" % (ProjectDir, Platform, mode)
|
|
AbsMacBuildDir = "%s/qt4.build.macos-%s-%s" % (ProjectDir, Platform, mode)
|
|
AbsMacBuildLog = "%s/qt4.build.macos-%s-%s.log" % (ProjectDir, Platform, mode)
|
|
parameters += " \\\n -bin %s" % MacBinDir
|
|
parameters += " \\\n -build %s" % MacBuildDir
|
|
elif ModuleQt == 'Qt5MacPorts':
|
|
parameters += " \\\n -qt5"
|
|
parameters += " \\\n -qmake %s" % Qt5MacPorts['qmake']
|
|
MacPkgDir = "./qt5.pkg.macos-%s-%s" % (Platform, mode)
|
|
MacBinDir = "./qt5.bin.macos-%s-%s" % (Platform, mode)
|
|
MacBuildDir = "./qt5.build.macos-%s-%s" % (Platform, mode)
|
|
MacBuildLog = "./qt5.build.macos-%s-%s.log" % (Platform, mode)
|
|
AbsMacPkgDir = "%s/qt5.pkg.macos-%s-%s" % (ProjectDir, Platform, mode)
|
|
AbsMacBinDir = "%s/qt5.bin.macos-%s-%s" % (ProjectDir, Platform, mode)
|
|
AbsMacBuildDir = "%s/qt5.build.macos-%s-%s" % (ProjectDir, Platform, mode)
|
|
AbsMacBuildLog = "%s/qt5.build.macos-%s-%s.log" % (ProjectDir, Platform, mode)
|
|
parameters += " \\\n -bin %s" % MacBinDir
|
|
parameters += " \\\n -build %s" % MacBuildDir
|
|
|
|
# (C) want Qt bindings with Ruby scripts?
|
|
if NoQtBindings:
|
|
parameters += " \\\n -without-qtbinding"
|
|
else:
|
|
parameters += " \\\n -with-qtbinding"
|
|
|
|
# (D) options to `make` tool
|
|
if not MakeOptions == "":
|
|
parameters += " \\\n -option %s" % MakeOptions
|
|
|
|
# (E) about Ruby
|
|
if ModuleRuby == "nil":
|
|
parameters += " \\\n -noruby"
|
|
else:
|
|
parameters += " \\\n -ruby %s" % RubyDictionary[ModuleRuby]['exe']
|
|
parameters += " \\\n -rbinc %s" % RubyDictionary[ModuleRuby]['inc']
|
|
parameters += " \\\n -rblib %s" % RubyDictionary[ModuleRuby]['lib']
|
|
|
|
# (F) about Python
|
|
if ModulePython == "nil":
|
|
parameters += " \\\n -nopython"
|
|
else:
|
|
parameters += " \\\n -python %s" % PythonDictionary[ModulePython]['exe']
|
|
parameters += " \\\n -pyinc %s" % PythonDictionary[ModulePython]['inc']
|
|
parameters += " \\\n -pylib %s" % PythonDictionary[ModulePython]['lib']
|
|
|
|
#-----------------------------------------------------
|
|
# [2] Make the consolidated command line
|
|
#-----------------------------------------------------
|
|
command = "time"
|
|
command += " \\\n %s" % BuildBash
|
|
command += parameters
|
|
command += " 2>&1 | tee %s" % MacBuildLog
|
|
if CheckComOnly:
|
|
print(command)
|
|
quit()
|
|
|
|
#-----------------------------------------------------
|
|
# [3] Invoke the main Bash script
|
|
#-----------------------------------------------------
|
|
if Deployment:
|
|
return 0
|
|
else:
|
|
myscript = "build4mac.py"
|
|
if subprocess.call( command, shell=True ) != 0:
|
|
print("")
|
|
print( "-------------------------------------------------------------" )
|
|
print( "!!! <%s>: failed to build KLayout" % myscript, file=sys.stderr )
|
|
print( "-------------------------------------------------------------" )
|
|
print("")
|
|
return 1
|
|
else:
|
|
print("")
|
|
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" )
|
|
print( "### <%s>: successfully built KLayout" % myscript, file=sys.stderr )
|
|
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" )
|
|
print("")
|
|
return 0
|
|
|
|
#------------------------------------------------------------------------------
|
|
## To deploy built binaries and libraries on which those binaries depend
|
|
# for making a bundle (klayout.app)
|
|
#
|
|
# Reference: "Deploying an Application on Mac OS X" of Qt Assistant.
|
|
#
|
|
# @return 0 on success; non-zero on failure
|
|
#------------------------------------------------------------------------------
|
|
def DeployBinariesForBundle():
|
|
global ProjectDir
|
|
global ModuleQt
|
|
global Deployment
|
|
global MacPkgDir
|
|
global MacBinDir
|
|
global MacBuildDir
|
|
global MacBuildLog
|
|
global AbsMacPkgDir
|
|
global AbsMacBinDir
|
|
global AbsMacBuildDir
|
|
global AbsMacBuildLog
|
|
global Version
|
|
|
|
print("")
|
|
print( "##### Started deploying libraries and executables for <klayout.app> #####" )
|
|
print( " [1] Checking the status of working directory ..." )
|
|
#-------------------------------------------------------------
|
|
# [1] Check the status of working directory
|
|
#-------------------------------------------------------------
|
|
os.chdir(ProjectDir)
|
|
if not Deployment:
|
|
return 1
|
|
if not os.path.isfile(MacBuildLog):
|
|
print( "!!! Build log file <%s> does not present !!!" % MacBuildLog, file=sys.stderr )
|
|
return 1
|
|
if not os.path.isdir(MacBuildDir):
|
|
print( "!!! Build directory <%s> does not present !!!" % MacBuildDir, file=sys.stderr )
|
|
return 1
|
|
if not os.path.isdir(MacBinDir):
|
|
print( "!!! Binary directory <%s> does not present !!!" % MacBinDir, file=sys.stderr )
|
|
return 1
|
|
|
|
|
|
print( " [2] Creating a new empty directory <%s> for deployment ..." % MacPkgDir )
|
|
#-------------------------------------------------------------
|
|
# [2] Create a new empty directory for deploying binaries
|
|
#-------------------------------------------------------------
|
|
os.chdir(ProjectDir)
|
|
if os.path.isfile(MacPkgDir):
|
|
os.remove(MacPkgDir)
|
|
if os.path.isdir(MacPkgDir):
|
|
shutil.rmtree(MacPkgDir)
|
|
os.mkdir(MacPkgDir)
|
|
|
|
|
|
print( " [3] Creating the standard directory structure for 'klayout.app' bundle ..." )
|
|
#-------------------------------------------------------------
|
|
# [3] Create the directory skeleton for "klayout.app" bundle
|
|
# and command line buddy tools such as "strm2cif".
|
|
# They are stored in the directory structure below.
|
|
#
|
|
# klayout.app/+
|
|
# +-- Contents/+
|
|
# +-- Info.plist
|
|
# +-- PkgInfo
|
|
# +-- Resources/
|
|
# +-- Frameworks/
|
|
# +-- MacOS/+
|
|
# | +-- 'klayout'
|
|
# +-- Buddy/+
|
|
# +-- 'strm2cif'
|
|
# +-- 'strm2dxf'
|
|
# :
|
|
# +-- 'strmxor'
|
|
#-------------------------------------------------------------
|
|
targetDir0 = "%s/klayout.app/Contents" % AbsMacPkgDir
|
|
targetDirR = targetDir0 + "/Resources"
|
|
targetDirF = targetDir0 + "/Frameworks"
|
|
targetDirM = targetDir0 + "/MacOS"
|
|
targetDirB = targetDir0 + "/Buddy"
|
|
os.makedirs(targetDirR)
|
|
os.makedirs(targetDirF)
|
|
os.makedirs(targetDirM)
|
|
os.makedirs(targetDirB)
|
|
|
|
|
|
print( " [4] Copying KLayout's dynamic link libraries to 'Frameworks' ..." )
|
|
#-------------------------------------------------------------------------------
|
|
# [4] Copy KLayout's dynamic link libraries to "Frameworks/" and create
|
|
# the library dependency dictionary.
|
|
# <<< Do this job in "Frameworks/" >>>
|
|
#
|
|
# Note:
|
|
# KLayout's dynamic link library is built as below:
|
|
# (1) libklayout_lay.0.25.0.dylib
|
|
# (2) libklayout_lay.0.25.dylib -> libklayout_lay.0.25.0.dylib
|
|
# (3) libklayout_lay.0.dylib -> libklayout_lay.0.25.0.dylib
|
|
# (4) libklayout_lay.dylib -> libklayout_lay.0.25.0.dylib
|
|
# where,
|
|
# (1) is an ordinary file with full version number 'major.minor.teeny'
|
|
# between "library_name."='libklayout_lay.' and '.dylib'
|
|
# (2) is a symbolic link with 'major.minor' version number
|
|
# (3) is a symbolic link with 'major' version number
|
|
# (4) is a symbolic link without version number number
|
|
#
|
|
# The dynamic linker tries to find a library name in style (3) as shown
|
|
# in the example below.
|
|
#
|
|
# Example:
|
|
# MacBookPro(1)$ otool -L klayout
|
|
# klayout:
|
|
# :
|
|
# :
|
|
# libklayout_tl.0.dylib (compatibility version 0.25.0, current version 0.25.0)
|
|
# libklayout_gsi.0.dylib (compatibility version 0.25.0, current version 0.25.0)
|
|
# libklayout_db.0.dylib (compatibility version 0.25.0, current version 0.25.0)
|
|
# :
|
|
#-------------------------------------------------------------------------------
|
|
os.chdir( targetDirF )
|
|
dynamicLinkLibs = glob.glob( AbsMacBinDir + "/*.dylib" )
|
|
depDicOrdinary = {} # inter-library dependency dictionary
|
|
for item in dynamicLinkLibs:
|
|
if os.path.isfile(item) and not os.path.islink(item):
|
|
#-------------------------------------------------------------------
|
|
# (A) Copy an ordinary *.dylib file here by changing the name
|
|
# to style (3) and set its mode to 0755 (sanity check).
|
|
#-------------------------------------------------------------------
|
|
fullName = os.path.basename(item).split('.')
|
|
# e.g. [ 'libklayout_lay', '0', '25', '0', 'dylib' ]
|
|
nameStyle3 = fullName[0] + "." + fullName[1] + ".dylib"
|
|
shutil.copy2( item, nameStyle3 )
|
|
os.chmod( nameStyle3, 0755 )
|
|
#-------------------------------------------------------------------
|
|
# (B) Then get inter-library dependencies
|
|
#-------------------------------------------------------------------
|
|
otoolCm = "otool -L %s | grep libklayout" % nameStyle3
|
|
otoolOut = os.popen( otoolCm ).read()
|
|
dependDic = DecomposeLibraryDependency(otoolOut)
|
|
depDicOrdinary.update(dependDic)
|
|
'''
|
|
PrintLibraryDependencyDictionary( depDicOrdinary, "Style (3)" )
|
|
quit()
|
|
'''
|
|
|
|
print( " [5] Setting and changing the identification names among KLayout's libraries ..." )
|
|
#-------------------------------------------------------------
|
|
# [5] Set the identification names for KLayout's libraries
|
|
# and make the library aware of the locations of libraries
|
|
# on which it depends; that is, inter-library dependency
|
|
#-------------------------------------------------------------
|
|
ret = SetChangeIdentificationNameOfDyLib( depDicOrdinary )
|
|
if not ret == 0:
|
|
msg = "!!! Failed to set and change to new identification names !!!"
|
|
print(msg)
|
|
return 1
|
|
|
|
|
|
print( " [6] Copying built executables and resource files ..." )
|
|
#-------------------------------------------------------------
|
|
# [6] Copy some known files in source directories to
|
|
# relevant target directories
|
|
#-------------------------------------------------------------
|
|
os.chdir(ProjectDir)
|
|
sourceDir0 = "%s/klayout.app/Contents" % MacBinDir
|
|
sourceDir1 = sourceDir0 + "/MacOS"
|
|
sourceDir2 = "%s/macbuild/Resources" % ProjectDir
|
|
sourceDir3 = "%s" % MacBinDir
|
|
|
|
tmpfileM = ProjectDir + "/macbuild/Resources/Info.plist.template"
|
|
keydicM = { 'exe': 'klayout', 'icon': 'klayout.icns', 'bname': 'klayout', 'ver': Version }
|
|
plistM = GenerateInfoPlist( keydicM, tmpfileM )
|
|
file = open( targetDir0 + "/Info.plist", "w" )
|
|
file.write(plistM)
|
|
file.close()
|
|
|
|
shutil.copy2( sourceDir0 + "/PkgInfo", targetDir0 ) # this file is not mandatory
|
|
shutil.copy2( sourceDir1 + "/klayout", targetDirM )
|
|
shutil.copy2( sourceDir2 + "/klayout.icns", targetDirR )
|
|
|
|
os.chmod( targetDir0 + "/PkgInfo", 0644 )
|
|
os.chmod( targetDir0 + "/Info.plist", 0644 )
|
|
os.chmod( targetDirM + "/klayout", 0755 )
|
|
os.chmod( targetDirR + "/klayout.icns", 0644 )
|
|
|
|
buddies = glob.glob( sourceDir3 + "/strm*" )
|
|
for item in buddies:
|
|
shutil.copy2( item, targetDirB )
|
|
buddy = os.path.basename(item)
|
|
os.chmod( targetDirB + "/" + buddy, 0755 )
|
|
|
|
|
|
print( " [7] Setting and changing the identification names of KLayout's libraries in each executable ..." )
|
|
#-------------------------------------------------------------
|
|
# [7] Set and change the library identification name(s) of
|
|
# different executables
|
|
#-------------------------------------------------------------
|
|
os.chdir(ProjectDir)
|
|
os.chdir(MacPkgDir)
|
|
klayoutexec = "klayout.app/Contents/MacOS/klayout"
|
|
ret = SetChangeLibIdentificationName( klayoutexec, "../Frameworks" )
|
|
if not ret == 0:
|
|
os.chdir(ProjectDir)
|
|
msg = "!!! Failed to set/change library identification name for <%s> !!!"
|
|
print( msg % klayoutexec, file=sys.stderr )
|
|
return 1
|
|
|
|
buddies = glob.glob( "klayout.app/Contents/Buddy/strm*" )
|
|
macdepQtOpt = ""
|
|
for buddy in buddies:
|
|
macdepQtOpt += "-executable=%s " % buddy
|
|
ret = SetChangeLibIdentificationName( buddy, "../Frameworks" )
|
|
if not ret == 0:
|
|
os.chdir(ProjectDir)
|
|
msg = "!!! Failed to set/change library identification name for <%s> !!!"
|
|
print( msg % buddy, file=sys.stderr )
|
|
return 1
|
|
|
|
|
|
print( " [8] Finally, deploying Qt's Frameworks ..." )
|
|
#-------------------------------------------------------------
|
|
# [8] Deploy Qt frameworks
|
|
#-------------------------------------------------------------
|
|
if ModuleQt == 'Qt4MacPorts':
|
|
deploytool = Qt4MacPorts['deploy']
|
|
app_bundle = "klayout.app"
|
|
options = macdepQtOpt
|
|
elif ModuleQt == 'Qt5MacPorts':
|
|
deploytool = Qt5MacPorts['deploy']
|
|
app_bundle = "klayout.app"
|
|
options = macdepQtOpt
|
|
|
|
os.chdir(ProjectDir)
|
|
os.chdir(MacPkgDir)
|
|
command = "%s %s %s" % ( deploytool, app_bundle, options )
|
|
if subprocess.call( command, shell=True ) != 0:
|
|
msg = "!!! Failed to deploy applications on OSX !!!"
|
|
print( msg, file=sys.stderr )
|
|
print("")
|
|
os.chdir(ProjectDir)
|
|
return 1
|
|
else:
|
|
print( "##### Finished deploying libraries and executables for <klayout.app> #####" )
|
|
print("")
|
|
os.chdir(ProjectDir)
|
|
return 0
|
|
|
|
#------------------------------------------------------------------------------
|
|
## To deploy script bundles that invoke the main bundle (klayout.app) in
|
|
# editor mode or viewer mode
|
|
#
|
|
# @return 0 on success; non-zero on failure
|
|
#------------------------------------------------------------------------------
|
|
def DeployScriptBundles():
|
|
global ProjectDir
|
|
global MacPkgDir
|
|
global AbsMacPkgDir
|
|
|
|
print("")
|
|
print( "##### Started deploying files for <KLayoutEditor.app> and <KLayoutViewer.app> #####" )
|
|
print( " [1] Checking the status of working directory ..." )
|
|
#-------------------------------------------------------------
|
|
# [1] Check the status of working directory
|
|
#-------------------------------------------------------------
|
|
os.chdir(ProjectDir)
|
|
if not os.path.isdir(MacPkgDir):
|
|
print( "!!! Package directory <%s> does not present !!!" % MacPkgDir, file=sys.stderr )
|
|
return 1
|
|
|
|
|
|
print( " [2] Creating a new empty directory <%s> for deployment ..." % (MacPkgDir + "/klayout.scripts") )
|
|
#-------------------------------------------------------------
|
|
# [2] Create a new empty directory for deploying binaries
|
|
#-------------------------------------------------------------
|
|
os.chdir(MacPkgDir)
|
|
scriptDir = "klayout.scripts"
|
|
if os.path.isfile(scriptDir):
|
|
os.remove(scriptDir)
|
|
if os.path.isdir(scriptDir):
|
|
shutil.rmtree(scriptDir)
|
|
os.mkdir(scriptDir)
|
|
|
|
|
|
print( " [3] Creating the standard directory structure for the script bundles ..." )
|
|
#-------------------------------------------------------------
|
|
# [3] Create the directory skeleton for the two script bundles.
|
|
#
|
|
# klayout.scripts/+
|
|
# +-- KLayoutEditor.app/+
|
|
# | +-- Contents/+
|
|
# | +-- Info.plist
|
|
# | +-- Resources/
|
|
# | +-- MacOS/+
|
|
# | +-- 'KLayoutEditor.sh'
|
|
# +-- KLayoutViewer.app/+
|
|
# +-- Contents/+
|
|
# +-- Info.plist
|
|
# +-- Resources/
|
|
# +-- MacOS/+
|
|
# +-- 'KLayoutViewer.sh'
|
|
#-------------------------------------------------------------
|
|
os.chdir(ProjectDir)
|
|
targetDir0E = "%s/%s/KLayoutEditor.app/Contents" % ( AbsMacPkgDir, scriptDir )
|
|
targetDir0V = "%s/%s/KLayoutViewer.app/Contents" % ( AbsMacPkgDir, scriptDir )
|
|
|
|
targetDirME = targetDir0E + "/MacOS"
|
|
targetDirMV = targetDir0V + "/MacOS"
|
|
targetDirRE = targetDir0E + "/Resources"
|
|
targetDirRV = targetDir0V + "/Resources"
|
|
|
|
os.makedirs(targetDirME)
|
|
os.makedirs(targetDirMV)
|
|
os.makedirs(targetDirRE)
|
|
os.makedirs(targetDirRV)
|
|
|
|
|
|
print( " [4] Copying script files and icon files ..." )
|
|
#-------------------------------------------------------------------------------
|
|
# [4] Copy different script files icon files
|
|
#-------------------------------------------------------------------------------
|
|
os.chdir(ProjectDir)
|
|
resourceDir = "macbuild/Resources"
|
|
|
|
shutil.copy2( resourceDir + "/KLayoutEditor.sh", targetDirME )
|
|
shutil.copy2( resourceDir + "/KLayoutViewer.sh", targetDirMV )
|
|
shutil.copy2( resourceDir + "/klayout-red.icns", targetDirRE )
|
|
shutil.copy2( resourceDir + "/klayout-blue.icns", targetDirRV )
|
|
|
|
os.chmod( targetDirME + "/KLayoutEditor.sh", 0755 )
|
|
os.chmod( targetDirMV + "/KLayoutViewer.sh", 0755 )
|
|
os.chmod( targetDirRE + "/klayout-red.icns", 0644 )
|
|
os.chmod( targetDirRV + "/klayout-blue.icns", 0644 )
|
|
|
|
tmpfileE = ProjectDir + "/macbuild/Resources/Info.plist.template"
|
|
keydicE = { 'exe': 'KLayoutEditor.sh', 'icon': 'klayout-red.icns', 'bname': 'klayout', 'ver': Version }
|
|
plistE = GenerateInfoPlist( keydicE, tmpfileE )
|
|
fileE = open( targetDir0E + "/Info.plist", "w" )
|
|
fileE.write(plistE)
|
|
fileE.close()
|
|
|
|
tmpfileV = ProjectDir + "/macbuild/Resources/Info.plist.template"
|
|
keydicV = { 'exe': 'KLayoutViewer.sh', 'icon': 'klayout-blue.icns', 'bname': 'klayout', 'ver': Version }
|
|
plistV = GenerateInfoPlist( keydicV, tmpfileV )
|
|
fileV = open( targetDir0V + "/Info.plist", "w" )
|
|
fileV.write(plistV)
|
|
fileV.close()
|
|
print( "##### Finished deploying files for <KLayoutEditor.app> and <KLayoutViewer.app> #####" )
|
|
print("")
|
|
os.chdir(ProjectDir)
|
|
return 0
|
|
|
|
#------------------------------------------------------------------------------
|
|
## The main function
|
|
#------------------------------------------------------------------------------
|
|
def main():
|
|
SetGlobals()
|
|
ParseCommandLineArguments()
|
|
ret = RunMainBuildBash()
|
|
if not Deployment:
|
|
if ret == 0:
|
|
sys.exit(0)
|
|
else:
|
|
sys.exit(1)
|
|
else:
|
|
ret1 = DeployBinariesForBundle()
|
|
ret2 = DeployScriptBundles()
|
|
if not (ret1 == 0 and ret2 == 0):
|
|
sys.exit(1)
|
|
else:
|
|
sys.exit(0)
|
|
|
|
#===================================================================================
|
|
if __name__ == "__main__":
|
|
main()
|
|
|
|
#---------------
|
|
# End of file
|
|
#---------------
|