luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update of the build system for macOS for 0.26.9 (#686) 

* * Updated the build system for Mac
* Catalina env. uses Python 3.8 in MacPorts, Homebrew, and Anaconda3.

* Use Ruby 2.7 in MacPorts.

* Test build for macOS "Big Sur" (11.0) on Intel Mac "Catalina" (10.15.7).

* Updated the build system for macOS, including the future support for Big Sur (11.0)
This commit is contained in:
Kazunari Sekigawa 2020-11-27 07:00:12 +09:00 committed by Matthias Koefferlein
parent 517903dafa
commit 22df10f425
10 changed files with 1594 additions and 1326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
macbuild/ReadMe.md
View File

@ -1,27 +1,28 @@
Relevant KLayout version: 0.26.7 Relevant KLayout version: 0.26.9
# 1. Introduction # 1. Introduction
This directory **`macbuild`** contains different files required for building KLayout (http://www.klayout.de/) version 0.26.1 or later for different 64-bit Mac OSXs including: This directory **`macbuild`** contains different files required for building KLayout (http://www.klayout.de/) version 0.26.1 or later for different 64-bit Mac OSXs, including:
* El Capitan (10.11) * El Capitan (10.11)
* Sierra (10.12) * Sierra (10.12)
* High Sierra (10.13) * High Sierra (10.13)
* Mojave (10.14) * Mojave (10.14)
* Catalina (10.15) * Catalina (10.15) : the primary development environment
* Big Sur (11.0) : under development for the future support
# 2. Qt5 Frameworks # 2. Qt5 Frameworks
By default, Qt frameworks are "Qt5" from MacPorts (https://www.macports.org/) which is usually located under: By default, the Qt framework is "Qt5" from MacPorts (https://www.macports.org/), which is usually located under:
``` ```
/opt/local/libexec/qt5/ /opt/local/libexec/qt5/
``` ```
Alternatively, you can use "Qt5" from Homebrew (https://brew.sh/) which is usually located under: Alternatively, you can use "Qt5" from Homebrew (https://brew.sh/), which is usually located under:
``` ```
/usr/local/opt/qt/ /usr/local/opt/qt/
``` ```
OR OR
"Qt5" from Anaconda3 (https://www.anaconda.com/) which is usually located under: "Qt5" from Anaconda3 (https://www.anaconda.com/), which is usually located under:
``` ```
$HOME/opt/anaconda3/pkgs/qt-{version} $HOME/opt/anaconda3/pkgs/qt-{version}
``` ```
@ -41,9 +42,9 @@ $ /usr/bin/ruby -v
$ /usr/bin/python --version $ /usr/bin/python --version
Python 2.7.16 Python 2.7.16
``` ```
Even in the latest OS as of today (December 2019), Python 3.x is not bundled with the OS, and this is the main reason why users want non-OS-standard script language support. Even in the latest OS (11.0 Big Sur) as of today (November 2020), Python 3.x is not bundled with the OS, which is why users want non-OS-standard script language support.
To meet such a requirement, the build script **`build4mac.py`** provides several possible combinations of Qt5, Ruy and Python module.<br> To meet such a requirement, the build script **`build4mac.py`** provides several possible combinations of Qt5, Ruy, and Python module.<br>
Some typical use cases are described in Section 6. Some typical use cases are described in Section 6.
# 4. Prerequisites # 4. Prerequisites
@ -66,22 +67,24 @@ $ [python] ./build4mac.py
: Qt5MacPorts: use Qt5 from MacPorts | : Qt5MacPorts: use Qt5 from MacPorts |
: Qt5Brew: use Qt5 from Homebrew | : Qt5Brew: use Qt5 from Homebrew |
: Qt5Ana3: use Qt5 from Anaconda3 | : Qt5Ana3: use Qt5 from Anaconda3 |
[-r|--ruby <type>] : case-insensitive type=['nil', 'Sys', 'MP26', 'HB27', 'Ana3'] | sys [-r|--ruby <type>] : case-insensitive type=['nil', 'Sys', 'MP27', 'HB27', 'Ana3'] | sys
: nil: don't bind Ruby | : nil: don't bind Ruby |
: Sys: use OS-bundled Ruby [2.0 - 2.6] depending on OS | : Sys: use OS-bundled Ruby [2.0 - 2.6] depending on OS |
: MP26: use Ruby 2.6 from MacPorts | : MP27: use Ruby 2.7 from MacPorts |
: HB27: use Ruby 2.7 from Homebrew | : HB27: use Ruby 2.7 from Homebrew |
: Ana3: use Ruby 2.5 from Anaconda3 | : Ana3: use Ruby 2.5 from Anaconda3 |
[-p|--python <type>] : case-insensitive type=['nil', 'Sys', 'MP38', 'HB38', 'Ana3'] | sys [-p|--python <type>] : case-insensitive type=['nil', 'Sys', 'MP38', 'HB38', 'Ana3', | sys
: 'HBAuto'] |
: nil: don't bind Python | : nil: don't bind Python |
: Sys: use OS-bundled Python 2.7 [ElCapitan -- Catalina] | : Sys: use OS-bundled Python 2.7 [ElCapitan -- BigSur] |
: MP38: use Python 3.8 from MacPorts | : MP38: use Python 3.8 from MacPorts |
: HB38: use Python 3.8 from Homebrew | : HB38: use Python 3.8 from Homebrew |
: Ana3: use Python 3.8 from Anaconda3 | : Ana3: use Python 3.7 from Anaconda3 |
: HBAuto: use the latest Python 3.x auto-detected from Homebrew |
[-n|--noqtbinding] : don't create Qt bindings for ruby scripts | disabled [-n|--noqtbinding] : don't create Qt bindings for ruby scripts | disabled
[-m|--make <option>] : option passed to 'make' | '-j4' [-m|--make <option>] : option passed to 'make' | '-j4'
[-d|--debug] : enable debug mode build | disabled [-d|--debug] : enable debug mode build | disabled
[-c|--checkcom] : check command line and exit without building | disabled [-c|--checkcom] : check command-line and exit without building | disabled
[-y|--deploy] : deploy executables and dylibs including Qt's Frameworks | disabled [-y|--deploy] : deploy executables and dylibs including Qt's Frameworks | disabled
[-Y|--DEPLOY] : deploy executables and dylibs for those who built KLayout | disabled [-Y|--DEPLOY] : deploy executables and dylibs for those who built KLayout | disabled
: from the source code and use the tools in the same machine | : from the source code and use the tools in the same machine |
@ -98,7 +101,7 @@ $ [python] ./build4mac.py
``` ```
# 6. Use-cases # 6. Use-cases
In this section, the actual file- and directory names are those obtained on macOS Catalina.<br> In this section, the actual file names and directory names are those obtained on macOS Catalina.<br>
On different OS, those names differ accordingly. On different OS, those names differ accordingly.
### 6A. Standard build using the OS-bundled Ruby and Python ### 6A. Standard build using the OS-bundled Ruby and Python
@ -108,40 +111,40 @@ $ cd /where/'build.sh'/exists
$ ./build4mac.py $ ./build4mac.py
``` ```
2. Confirm successful build (it will take about one hour depending on your machine spec). 2. Confirm successful build (it will take about one hour depending on your machine spec).
3. Run **`build4mac.py`** again with the same options used in 1. PLUS "-y" to deploy executables and libraries (including Qt's frameworks) under **`klayout.app`** bundle.<br> 3. Run **`build4mac.py`** again with the same options used in 1. PLUS "-y" to deploy executables and libraries (including Qt's framework) under **`klayout.app`** bundle.<br>
The buddy command-line tools (strm*) will also be deployed in this step. The buddy command-line tools (strm*) will also be deployed in this step.
``` ```
$ ./build4mac.py -y $ ./build4mac.py -y
``` ```
The application bundle **`klayout.app`** is located under:<br> The application bundle **`klayout.app`** is located under:<br>
**`ST-qt5MP.pkg.macos-Catalina-release-RsysPsys`** directory, where the three parts below are important. **`ST-qt5MP.pkg.macos-Catalina-release-RsysPsys`** directory, where the three name parts below are important.
* "ST-" means that this is a standard package (LW-, HW-, and EX- are other possibilities explained below). * "ST-" means that this is a standard package (LW-, HW-, and EX- are other possibilities explained below).
* "qt5MP" means that Qt5 from MacPorts is used. * "qt5MP" means that Qt5 from MacPorts is used.
* "RsysPsys" means that Ruby is OS-bundled; Python is OS-bundled. * "RsysPsys" means that Ruby is OS-bundled; Python is OS-bundled.
4. Copy/move the generated application bundle **`klayout.app`** to your **`/Applications`** directory for installation. 4. Copy/move the generated application bundle **`klayout.app`** to your **`/Applications`** directory for installation.
If you use "-Y" option instead of "-y" in Step-3, Qt5 frameworks is NOT deployed in the application bundle.<br> If you use the "-Y" option instead of the "-y" in Step-3, the Qt5 framework is NOT deployed in the application bundle.<br>
Then the directory name will be **`LW-qt5MP.pkg.macos-Catalina-release-RsysPsys`**, where Then the directory name will be **`LW-qt5MP.pkg.macos-Catalina-release-RsysPsys`**, where
* "LW-" means that this is a lightweight package. * "LW-" means that this is a lightweight package.
#### If you build KLayout from the source code AND use it on the same machine, "-Y" option is highly recommended. #### #### If you build KLayout from the source code AND run it on the same machine, the "-Y" option is highly recommended. ####
### 6B. Fully MacPorts-flavored build with MacPorts Ruby 2.6 and MacPorts Python 3.8 ### 6B. Fully MacPorts-flavored build with MacPorts Ruby 2.7 and MacPorts Python 3.8
``` ```
$ cd /where/'build.sh'/exists $ cd /where/'build.sh'/exists
$ ./build4mac.py -q qt5macports -r mp26 -p mp38 $ ./build4mac.py -q qt5macports -r mp27 -p mp38
``` ```
2. Confirm successful build (it will take about one hour depending on your machine spec). 2. Confirm successful build (it will take about one hour depending on your machine spec).
3. Run **`build4mac.py`** again with the same options used in 1. PLUS "-Y" to deploy executables and libraries under **`klayout.app`** bundle.<br> 3. Run **`build4mac.py`** again with the same options used in 1. PLUS "-Y" to deploy executables and libraries under **`klayout.app`** bundle.<br>
The buddy command-line tools (strm*) will also be deployed in this step. The buddy command-line tools (strm*) will also be deployed in this step.
``` ```
$ ./build4mac.py -q qt5macports -r mp26 -p mp38 -Y $ ./build4mac.py -q qt5macports -r mp27 -p mp38 -Y
``` ```
The application bundle **`klayout.app`** is located under:<br> The application bundle **`klayout.app`** is located under:<br>
**`LW-qt5MP.pkg.macos-Catalina-release-Rmp26Pmp38`** directory, where **`LW-qt5MP.pkg.macos-Catalina-release-Rmp27Pmp38`** directory, where
* "LW-" means that this is a lightweight package. * "LW-" means that this is a lightweight package.
* "qt5MP" means that Qt5 from MacPorts is used. * "qt5MP" means that Qt5 from MacPorts is used.
* "Rmp26Pmp38" means that Ruby is 2.6 from MacPorts; Python is 3.8 from MacPorts. * "Rmp27Pmp38" means that Ruby is 2.7 from MacPorts; Python is 3.8 from MacPorts.
4. Copy/move the generated application bundle **`klayout.app`** to your **`/Applications`** directory for installation. 4. Copy/move the generated application bundle **`klayout.app`** to your **`/Applications`** directory for installation.
### 6C. Fully Homebrew-flavored build with Homebrew Ruby 2.7 and Homebrew Python 3.8 ### 6C. Fully Homebrew-flavored build with Homebrew Ruby 2.7 and Homebrew Python 3.8
@ -168,7 +171,7 @@ $ cd /where/'build.sh'/exists
$ ./build4mac.py -q qt5brew -r sys -p hb38 $ ./build4mac.py -q qt5brew -r sys -p hb38
``` ```
2. Confirm successful build (it will take about one hour depending on your machine spec). 2. Confirm successful build (it will take about one hour depending on your machine spec).
3. Run **`build4mac.py`** again with the same options used in 1. PLUS "-y" to deploy executables and libraries (including Qt's frameworks and Python frameworks) under **`klayout.app`** bundle.<br> 3. Run **`build4mac.py`** again with the same options used in 1. PLUS "-y" to deploy executables and libraries (including Qt's framework and Python framework) under **`klayout.app`** bundle.<br>
The buddy command-line tools (strm*) will also be deployed in this step. The buddy command-line tools (strm*) will also be deployed in this step.
``` ```
$ ./build4mac.py -q qt5brew -r sys -p hb38 -y $ ./build4mac.py -q qt5brew -r sys -p hb38 -y
@ -180,8 +183,8 @@ $ ./build4mac.py -q qt5brew -r sys -p hb38 -y
* "RsysPhb38" means that Ruby is OS-bundled; Python is 3.8 from Homebrew. * "RsysPhb38" means that Ruby is OS-bundled; Python is 3.8 from Homebrew.
4. Copy/move the generated application bundle **`klayout.app`** to your **`/Applications`** directory for installation. 4. Copy/move the generated application bundle **`klayout.app`** to your **`/Applications`** directory for installation.
### Important ### ### Important ###
So far, deployment of Homebrew Ruby is not supported. <br> So far, the deployment of Homebrew Ruby is not supported. <br>
Therefore, if you intend to use "-y" option, you need to use "-r sys" for building. Therefore, if you intend to use the "-y" option for deployment, you need to use the "-r sys" option for building.
### 6E. Fully Anaconda3-flavored build with Anaconda3 Ruby 2.5 and Anaconda3 Python 3.8 ### 6E. Fully Anaconda3-flavored build with Anaconda3 Ruby 2.5 and Anaconda3 Python 3.8
``` ```
@ -225,8 +228,8 @@ $ cd /where/'build.sh'/exists
$ ./makeDMG4mac.py -p ST-qt5MP.pkg.macos-Catalina-release-RsysPsys -m $ ./makeDMG4mac.py -p ST-qt5MP.pkg.macos-Catalina-release-RsysPsys -m
``` ```
This command will generate the two files below:<br> This command will generate the two files below:<br>
* **`ST-klayout-0.26.5-macOS-Catalina-1-qt5MP-RsysPsys.dmg`** ---(1) the main DMG file * **`ST-klayout-0.26.9-macOS-Catalina-1-qt5MP-RsysPsys.dmg`** ---(1) the main DMG file
* **`ST-klayout-0.26.5-macOS-Catalina-1-qt5MP-RsysPsys.dmg.md5`** ---(2) MD5-value text file * **`ST-klayout-0.26.9-macOS-Catalina-1-qt5MP-RsysPsys.dmg.md5`** ---(2) MD5-value text file
# Known issues # Known issues
Because we assume some specific versions of non-OS-standard Ruby and Python, updating MacPorts, Homebrew, or Anaconda3 may cause build- and link errors.<br> Because we assume some specific versions of non-OS-standard Ruby and Python, updating MacPorts, Homebrew, or Anaconda3 may cause build- and link errors.<br>
@ -234,7 +237,7 @@ In such cases, you need to update the dictionary contents of **`build4mac_env.py
# Final comments # Final comments
No need to say, KLayout is a great tool! <br> No need to say, KLayout is a great tool! <br>
With the object-oriented script language (both Ruby and Python) support, our error-prone jobs can be simplified and speed-up.<br> With the object-oriented script language (both Ruby and Python) support, our error-prone jobs can be greatly simplified and speed-up.<br>
Building KLayout from its source code is not difficult. Try it with your favorite environment! Building KLayout from its source code is not difficult. Try it with your favorite environment!
[End of File] [End of File]

BIN
macbuild/Resources/KLayoutDMG-Back.logoist
View File

Binary file not shown.

BIN
macbuild/Resources/KLayoutDMG-Back.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 204 KiB

After

Width:  |  Height:  |  Size: 205 KiB

BIN
macbuild/Resources/script-bundle-P.zip
View File

Binary file not shown.

519
macbuild/build4mac.py
View File

@ -15,6 +15,7 @@ import glob
import platform import platform
import optparse import optparse
import subprocess import subprocess
import pprint
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
## To import global dictionaries of different modules and utility functions ## To import global dictionaries of different modules and utility functions
@ -25,38 +26,11 @@ from build4mac_env import *
from build4mac_util import * from build4mac_util import *
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
## To set global variables including present directory and platform info. ## To get the default configurations
#
# @return a dictionary containing the default configuration for the macOS build
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def get_default_config(): def Get_Default_Config():
"""
Returns a dictionary containing the default configuration for the macOS build.
"""
# 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 NonOSStdLang # True if non-OS-standard language is chosen
# 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 DeploymentF # True if fully (including Qt's Frameworks) deploy the binaries for bundles
# global DeploymentP # True if partially deploy the binaries excluding Qt's Frameworks
# global PackagePrefix # the package prefix: 'ST-', 'LW-', 'HW-', or 'EX-'
# global DeployVerbose # -verbose=<0-3> level passed to 'macdeployqt' tool
# global Version # KLayout's version
# global ModuleSet # (Qt, Ruby, Python)-tuple
# # 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 -
Usage = "\n" Usage = "\n"
Usage += "---------------------------------------------------------------------------------------------------------\n" Usage += "---------------------------------------------------------------------------------------------------------\n"
Usage += "<< Usage of 'build4mac.py' >>\n" Usage += "<< Usage of 'build4mac.py' >>\n"
@ -69,22 +43,24 @@ def get_default_config():
Usage += " : Qt5MacPorts: use Qt5 from MacPorts | \n" Usage += " : Qt5MacPorts: use Qt5 from MacPorts | \n"
Usage += " : Qt5Brew: use Qt5 from Homebrew | \n" Usage += " : Qt5Brew: use Qt5 from Homebrew | \n"
Usage += " : Qt5Ana3: use Qt5 from Anaconda3 | \n" Usage += " : Qt5Ana3: use Qt5 from Anaconda3 | \n"
Usage += " [-r|--ruby <type>] : case-insensitive type=['nil', 'Sys', 'MP26', 'HB27', 'Ana3'] | sys \n" Usage += " [-r|--ruby <type>] : case-insensitive type=['nil', 'Sys', 'MP27', 'HB27', 'Ana3'] | sys \n"
Usage += " : nil: don't bind Ruby | \n" Usage += " : nil: don't bind Ruby | \n"
Usage += " : Sys: use OS-bundled Ruby [2.0 - 2.6] depending on OS | \n" Usage += " : Sys: use OS-bundled Ruby [2.0 - 2.7] depending on OS | \n"
Usage += " : MP26: use Ruby 2.6 from MacPorts | \n" Usage += " : MP27: use Ruby 2.7 from MacPorts | \n"
Usage += " : HB27: use Ruby 2.7 from Homebrew | \n" Usage += " : HB27: use Ruby 2.7 from Homebrew | \n"
Usage += " : Ana3: use Ruby 2.5 from Anaconda3 | \n" Usage += " : Ana3: use Ruby 2.5 from Anaconda3 | \n"
Usage += " [-p|--python <type>] : case-insensitive type=['nil', 'Sys', 'MP38', 'HB38', 'Ana3'] | sys \n" Usage += " [-p|--python <type>] : case-insensitive type=['nil', 'Sys', 'MP38', 'HB38', 'Ana3', | sys \n"
Usage += " : 'HBAuto'] | \n"
Usage += " : nil: don't bind Python | \n" Usage += " : nil: don't bind Python | \n"
Usage += " : Sys: use OS-bundled Python 2.7 [ElCapitan -- Catalina] | \n" Usage += " : Sys: use OS-bundled Python 2.7 [ElCapitan -- BigSur] | \n"
Usage += " : MP38: use Python 3.8 from MacPorts | \n" Usage += " : MP38: use Python 3.8 from MacPorts | \n"
Usage += " : HB38: use Python 3.8 from Homebrew | \n" Usage += " : HB38: use Python 3.8 from Homebrew | \n"
Usage += " : Ana3: use Python 3.7 from Anaconda3 | \n" Usage += " : Ana3: use Python 3.7 from Anaconda3 | \n"
Usage += " : HBAuto: use the latest Python 3.x auto-detected from Homebrew | \n"
Usage += " [-n|--noqtbinding] : don't create Qt bindings for ruby scripts | disabled \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 += " [-m|--make <option>] : option passed to 'make' | '-j4' \n"
Usage += " [-d|--debug] : enable debug mode build | disabled \n" Usage += " [-d|--debug] : enable debug mode build | disabled \n"
Usage += " [-c|--checkcom] : check command line and exit without building | disabled \n" Usage += " [-c|--checkcom] : check command-line and exit without building | disabled \n"
Usage += " [-y|--deploy] : deploy executables and dylibs including Qt's Frameworks | disabled \n" Usage += " [-y|--deploy] : deploy executables and dylibs including Qt's Frameworks | disabled \n"
Usage += " [-Y|--DEPLOY] : deploy executables and dylibs for those who built KLayout | disabled \n" Usage += " [-Y|--DEPLOY] : deploy executables and dylibs for those who built KLayout | disabled \n"
Usage += " : from the source code and use the tools in the same machine | \n" Usage += " : from the source code and use the tools in the same machine | \n"
@ -137,7 +113,10 @@ def get_default_config():
# Set the default modules # Set the default modules
ModuleQt = "Qt5MacPorts" ModuleQt = "Qt5MacPorts"
if Platform == "Catalina": if Platform == "BigSur":
ModuleRuby = "RubyBigSur"
ModulePython = "PythonBigSur"
elif Platform == "Catalina":
ModuleRuby = "RubyCatalina" ModuleRuby = "RubyCatalina"
ModulePython = "PythonCatalina" ModulePython = "PythonCatalina"
elif Platform == "Mojave": elif Platform == "Mojave":
@ -169,131 +148,140 @@ def get_default_config():
ModuleSet = ( 'qt5MP', 'Sys', 'Sys' ) ModuleSet = ( 'qt5MP', 'Sys', 'Sys' )
config = dict() config = dict()
config['ProjectDir'] = ProjectDir # project directory where "build.sh" exists
config['ProjectDir'] = ProjectDir # project directory where "build.sh" exists config['Usage'] = Usage # string on usage
config['Usage'] = Usage # string on usage config['BuildBash'] = BuildBash # the main build Bash script
config['BuildBash'] = BuildBash # the main build Bash script config['Platform'] = Platform # platform
config['Platform'] = Platform # platform config['ModuleQt'] = ModuleQt # Qt module to be used
config['ModuleQt'] = ModuleQt # Qt module to be used config['ModuleRuby'] = ModuleRuby # Ruby module to be used
config['ModuleRuby'] = ModuleRuby # Ruby module to be used config['ModulePython'] = ModulePython # Python module to be used
config['ModulePython'] = ModulePython # Python module to be used config['NonOSStdLang'] = NonOSStdLang # True if non-OS-standard language is chosen
config['NonOSStdLang'] = NonOSStdLang # True if non-OS-standard language is chosen config['NoQtBindings'] = NoQtBindings # True if not creating Qt bindings for Ruby scripts
config['NoQtBindings'] = NoQtBindings # True if not creating Qt bindings for Ruby scripts config['MakeOptions'] = MakeOptions # options passed to `make`
config['MakeOptions'] = MakeOptions # options passed to `make` config['DebugMode'] = DebugMode # True if debug mode build
config['DebugMode'] = DebugMode # True if debug mode build config['CheckComOnly'] = CheckComOnly # True if only for checking the command line parameters to "build.sh"
config['CheckComOnly'] = CheckComOnly # True if only for checking the command line parameters to "build.sh" config['DeploymentF'] = DeploymentF # True if fully (including Qt's Frameworks) deploy the binaries for bundles
config['DeploymentF'] = DeploymentF # True if fully (including Qt's Frameworks) deploy the binaries for bundles config['DeploymentP'] = DeploymentP # True if partially deploy the binaries excluding Qt's Frameworks
config['DeploymentP'] = DeploymentP # True if partially deploy the binaries excluding Qt's Frameworks config['PackagePrefix'] = PackagePrefix # the package prefix: 'ST-', 'LW-', 'HW-', or 'EX-'
config['PackagePrefix'] = PackagePrefix # the package prefix: 'ST-', 'LW-', 'HW-', or 'EX-' config['DeployVerbose'] = DeployVerbose # -verbose=<0-3> level passed to 'macdeployqt' tool
config['DeployVerbose'] = DeployVerbose # -verbose=<0-3> level passed to 'macdeployqt' tool config['Version'] = Version # KLayout's version
config['Version'] = Version # KLayout's version config['ModuleSet'] = ModuleSet # (Qt, Ruby, Python)-tuple
config['ModuleSet'] = ModuleSet # (Qt, Ruby, Python)-tuple
# auxiliary variables on platform # auxiliary variables on platform
config['System'] = System # 6-tuple from platform.uname() config['System'] = System # 6-tuple from platform.uname()
config['Node'] = Node # - do - config['Node'] = Node # - do -
config['Release'] = Release # - do - config['Release'] = Release # - do -
config['MacVersion'] = MacVersion # - do - config['MacVersion'] = MacVersion # - do -
config['Machine'] = Machine # - do - config['Machine'] = Machine # - do -
config['Processor'] = Processor # - do - config['Processor'] = Processor # - do -
return config return config
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
## To get command line parameters ## To parse the command line parameters
#
# @param[in] config dictionary containing the default configuration
#
# @return the configuration dictionary updated with the CLI parameters
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
def parse_cli_args(config): def Parse_CLI_Args(config):
Usage = config['Usage'] # #-----------------------------------------------------
Platform = config['Platform'] # # [1] Retrieve the configuration
Release = config['Release'] # #-----------------------------------------------------
Machine = config['Machine'] # Usage = config['Usage']
ModuleQt = config['ModuleQt'] # Platform = config['Platform']
ModuleRuby = config['ModuleRuby'] # Release = config['Release']
ModulePython = config['ModulePython'] # Machine = config['Machine']
NonOSStdLang = config['NonOSStdLang'] # ModuleQt = config['ModuleQt']
NoQtBindings = config['NoQtBindings'] # ModuleRuby = config['ModuleRuby']
MakeOptions = config['MakeOptions'] # ModulePython = config['ModulePython']
DebugMode = config['DebugMode'] # NonOSStdLang = config['NonOSStdLang']
CheckComOnly = config['CheckComOnly'] # NoQtBindings = config['NoQtBindings']
DeploymentF = config['DeploymentF'] # MakeOptions = config['MakeOptions']
DeploymentP = config['DeploymentP'] # DebugMode = config['DebugMode']
PackagePrefix = config['PackagePrefix'] # CheckComOnly = config['CheckComOnly']
DeployVerbose = config['DeployVerbose'] # DeploymentF = config['DeploymentF']
ModuleSet = config['ModuleSet'] # DeploymentP = config['DeploymentP']
PackagePrefix = config['PackagePrefix']
DeployVerbose = config['DeployVerbose']
ModuleSet = config['ModuleSet']
p = optparse.OptionParser( usage=Usage ) #-----------------------------------------------------
# [2] Parse the CLI arguments
#-----------------------------------------------------
p = optparse.OptionParser(usage=Usage)
p.add_option( '-q', '--qt', p.add_option( '-q', '--qt',
dest='type_qt', dest='type_qt',
help="Qt type=['Qt5MacPorts', 'Qt5Brew', 'Qt5Ana3']" ) help="Qt type=['Qt5MacPorts', 'Qt5Brew', 'Qt5Ana3']" )
p.add_option( '-r', '--ruby', p.add_option( '-r', '--ruby',
dest='type_ruby', dest='type_ruby',
help="Ruby type=['nil', 'Sys', 'MP26', 'HB27', 'Ana3']" ) help="Ruby type=['nil', 'Sys', 'MP27', 'HB27', 'Ana3']" )
p.add_option( '-p', '--python', p.add_option( '-p', '--python',
dest='type_python', dest='type_python',
help="Python type=['nil', 'Sys', 'MP38', 'HB38', 'Ana3']" ) help="Python type=['nil', 'Sys', 'MP38', 'HB38', 'Ana3', 'HBAuto']" )
p.add_option( '-n', '--noqtbinding', p.add_option( '-n', '--noqtbinding',
action='store_true', action='store_true',
dest='no_qt_binding', dest='no_qt_binding',
default=False, default=False,
help="do not create Qt bindings for Ruby scripts" ) help="do not create Qt bindings for Ruby scripts" )
p.add_option( '-m', '--make', p.add_option( '-m', '--make',
dest='make_option', dest='make_option',
help="options passed to `make`" ) help="options passed to `make`" )
p.add_option( '-d', '--debug', p.add_option( '-d', '--debug',
action='store_true', action='store_true',
dest='debug_build', dest='debug_build',
default=False, default=False,
help="enable debug mode build" ) help="enable debug mode build" )
p.add_option( '-c', '--checkcom', p.add_option( '-c', '--checkcom',
action='store_true', action='store_true',
dest='check_command', dest='check_command',
default=False, default=False,
help="check command line and exit without building" ) help="check command line and exit without building" )
p.add_option( '-y', '--deploy', p.add_option( '-y', '--deploy',
action='store_true', action='store_true',
dest='deploy_full', dest='deploy_full',
default=False, default=False,
help="fully deploy built binaries" ) help="fully deploy built binaries" )
p.add_option( '-Y', '--DEPLOY', p.add_option( '-Y', '--DEPLOY',
action='store_true', action='store_true',
dest='deploy_partial', dest='deploy_partial',
default=False, default=False,
help="deploy built binaries when non-OS-standard script language is chosen" ) help="deploy built binaries when non-OS-standard script language is chosen" )
p.add_option( '-v', '--verbose', p.add_option( '-v', '--verbose',
dest='deploy_verbose', dest='deploy_verbose',
help="verbose level of `macdeployqt` tool" ) help="verbose level of `macdeployqt` tool" )
p.add_option( '-?', '--??', p.add_option( '-?', '--??',
action='store_true', action='store_true',
dest='checkusage', dest='checkusage',
default=False, default=False,
help='check usage' ) help='check usage' )
p.set_defaults( type_qt = "qt5macports", p.set_defaults( type_qt = "qt5macports",
type_ruby = "sys", type_ruby = "sys",
type_python = "sys", type_python = "sys",
no_qt_binding = False, no_qt_binding = False,
make_option = "-j4", make_option = "-j4",
debug_build = False, debug_build = False,
check_command = False, check_command = False,
deploy_full = False, deploy_full = False,
deploy_partial = False, deploy_partial = False,
deploy_verbose = "1", deploy_verbose = "1",
checkusage = False ) checkusage = False )
opt, args = p.parse_args() opt, args = p.parse_args()
if (opt.checkusage): if (opt.checkusage):
print(Usage) print(Usage)
sys.exit(0) sys.exit(0)
# Determine the Qt type # (A) Determine the Qt type
candidates = dict() candidates = dict()
candidates['QT5MACPORTS'] = 'Qt5MacPorts' candidates['QT5MACPORTS'] = 'Qt5MacPorts'
candidates['QT5BREW'] = 'Qt5Brew' candidates['QT5BREW'] = 'Qt5Brew'
@ -319,11 +307,11 @@ def parse_cli_args(config):
# By default, OS-standard (-bundled) script languages (Ruby and Python) are used # By default, OS-standard (-bundled) script languages (Ruby and Python) are used
NonOSStdLang = False NonOSStdLang = False
# Determine the Ruby type # (B) Determine the Ruby type
candidates = dict() candidates = dict()
candidates['NIL'] = 'nil' candidates['NIL'] = 'nil'
candidates['SYS'] = 'Sys' candidates['SYS'] = 'Sys'
candidates['MP26'] = 'MP26' candidates['MP27'] = 'MP27'
candidates['HB27'] = 'HB27' candidates['HB27'] = 'HB27'
candidates['ANA3'] = 'Ana3' candidates['ANA3'] = 'Ana3'
try: try:
@ -337,7 +325,9 @@ def parse_cli_args(config):
ModuleRuby = 'nil' ModuleRuby = 'nil'
elif choiceRuby == "Sys": elif choiceRuby == "Sys":
choiceRuby = "Sys" choiceRuby = "Sys"
if Platform == "Catalina": if Platform == "BigSur":
ModuleRuby = 'RubyBigSur'
elif Platform == "Catalina":
ModuleRuby = 'RubyCatalina' ModuleRuby = 'RubyCatalina'
elif Platform == "Mojave": elif Platform == "Mojave":
ModuleRuby = 'RubyMojave' ModuleRuby = 'RubyMojave'
@ -347,8 +337,8 @@ def parse_cli_args(config):
ModuleRuby = 'RubySierra' ModuleRuby = 'RubySierra'
elif Platform == "ElCapitan": elif Platform == "ElCapitan":
ModuleRuby = 'RubyElCapitan' ModuleRuby = 'RubyElCapitan'
elif choiceRuby == "MP26": elif choiceRuby == "MP27":
ModuleRuby = 'Ruby26MacPorts' ModuleRuby = 'Ruby27MacPorts'
NonOSStdLang = True NonOSStdLang = True
elif choiceRuby == "HB27": elif choiceRuby == "HB27":
ModuleRuby = 'Ruby27Brew' ModuleRuby = 'Ruby27Brew'
@ -363,13 +353,14 @@ def parse_cli_args(config):
print(Usage) print(Usage)
sys.exit(1) sys.exit(1)
# Determine the Python type # (C) Determine the Python type
candidates = dict() candidates = dict()
candidates['NIL'] = 'nil' candidates['NIL'] = 'nil'
candidates['SYS'] = 'Sys' candidates['SYS'] = 'Sys'
candidates['MP38'] = 'MP38' candidates['MP38'] = 'MP38'
candidates['HB38'] = 'HB38' candidates['HB38'] = 'HB38'
candidates['ANA3'] = 'Ana3' candidates['ANA3'] = 'Ana3'
candidates['HBAUTO'] = 'HBAuto'
try: try:
choicePython = candidates[ opt.type_python.upper() ] choicePython = candidates[ opt.type_python.upper() ]
except KeyError: except KeyError:
@ -380,7 +371,9 @@ def parse_cli_args(config):
if choicePython == "nil": if choicePython == "nil":
ModulePython = 'nil' ModulePython = 'nil'
elif choicePython == "Sys": elif choicePython == "Sys":
if Platform == "Catalina": if Platform == "BigSur":
ModulePython = 'PythonBigSur'
elif Platform == "Catalina":
ModulePython = 'PythonCatalina' ModulePython = 'PythonCatalina'
elif Platform == "Mojave": elif Platform == "Mojave":
ModulePython = 'PythonMojave' ModulePython = 'PythonMojave'
@ -399,6 +392,9 @@ def parse_cli_args(config):
elif choicePython == "Ana3": elif choicePython == "Ana3":
ModulePython = 'PythonAnaconda3' ModulePython = 'PythonAnaconda3'
NonOSStdLang = True NonOSStdLang = True
elif choicePython == "HBAuto":
ModulePython = 'PythonAutoBrew'
NonOSStdLang = True
if ModulePython == '': if ModulePython == '':
print("") print("")
print( "!!! Unknown Python type <%s>. Case-insensitive candidates: %s" % \ print( "!!! Unknown Python type <%s>. Case-insensitive candidates: %s" % \
@ -406,7 +402,7 @@ def parse_cli_args(config):
print(Usage) print(Usage)
sys.exit(1) sys.exit(1)
# Set of modules chosen # (D) Set of modules chosen
ModuleSet = ( choiceQt5, choiceRuby, choicePython ) ModuleSet = ( choiceQt5, choiceRuby, choicePython )
NoQtBindings = opt.no_qt_binding NoQtBindings = opt.no_qt_binding
@ -444,9 +440,9 @@ def parse_cli_args(config):
if (ModuleRuby in RubySys) and (ModulePython in PythonSys): if (ModuleRuby in RubySys) and (ModulePython in PythonSys):
PackagePrefix = "ST-" PackagePrefix = "ST-"
message += "a standard (ST-) package including Qt5 and using OS-bundled Ruby and Python..." message += "a standard (ST-) package including Qt5 and using OS-bundled Ruby and Python..."
elif ModulePython == 'Python38Brew': elif ModulePython == 'Python38Brew' or ModulePython == 'PythonAutoBrew':
PackagePrefix = "HW-" PackagePrefix = "HW-"
message += "a heavyweight (HW-) package including Qt5 and Python3.8 from Homebrew..." message += "a heavyweight (HW-) package including Qt5 and Python3.8~ from Homebrew..."
else: else:
PackagePrefix = "EX-" PackagePrefix = "EX-"
message += "a package with exceptional (EX-) combinations of different modules..." message += "a package with exceptional (EX-) combinations of different modules..."
@ -456,93 +452,90 @@ def parse_cli_args(config):
if CheckComOnly: if CheckComOnly:
sys.exit(0) sys.exit(0)
config['Usage'] = Usage # #-----------------------------------------------------
config['Platform'] = Platform # # [3] Update the configuration to return
config['ModuleQt'] = ModuleQt # #-----------------------------------------------------
config['ModuleRuby'] = ModuleRuby # config['Usage'] = Usage
config['ModulePython'] = ModulePython # config['Platform'] = Platform
config['NonOSStdLang'] = NonOSStdLang # config['ModuleQt'] = ModuleQt
config['NoQtBindings'] = NoQtBindings # config['ModuleRuby'] = ModuleRuby
config['MakeOptions'] = MakeOptions # config['ModulePython'] = ModulePython
config['DebugMode'] = DebugMode # config['NonOSStdLang'] = NonOSStdLang
config['CheckComOnly'] = CheckComOnly # config['NoQtBindings'] = NoQtBindings
config['DeploymentF'] = DeploymentF # config['MakeOptions'] = MakeOptions
config['DeploymentP'] = DeploymentP # config['DebugMode'] = DebugMode
config['PackagePrefix'] = PackagePrefix # config['CheckComOnly'] = CheckComOnly
config['DeployVerbose'] = DeployVerbose # config['DeploymentF'] = DeploymentF
config['ModuleSet'] = ModuleSet # config['DeploymentP'] = DeploymentP
config['PackagePrefix'] = PackagePrefix
config['DeployVerbose'] = DeployVerbose
config['ModuleSet'] = ModuleSet #
return config return config
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
## To run the main Bash script "build.sh" with appropriate options ## To run the main Bash script "build.sh" with appropriate options
# #
# @return 0 on success; non-zero on failure # @param[in] config dictionary containing the build configuration
# @return a dictionary containing the build parameters
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
def get_build_parameters(config): def Get_Build_Parameters(config):
ProjectDir = config['ProjectDir'] # #-----------------------------------------------------
Platform = config['Platform'] # # [1] Retrieve the configuration
BuildBash = config['BuildBash'] # #-----------------------------------------------------
ModuleQt = config['ModuleQt'] # ProjectDir = config['ProjectDir']
ModuleRuby = config['ModuleRuby'] # Platform = config['Platform']
ModulePython = config['ModulePython'] # BuildBash = config['BuildBash']
ModuleSet = config['ModuleSet'] # ModuleQt = config['ModuleQt']
NoQtBindings = config['NoQtBindings'] # ModuleRuby = config['ModuleRuby']
MakeOptions = config['MakeOptions'] # ModulePython = config['ModulePython']
DebugMode = config['DebugMode'] # ModuleSet = config['ModuleSet']
CheckComOnly = config['CheckComOnly'] # NoQtBindings = config['NoQtBindings']
DeploymentF = config['DeploymentF'] # MakeOptions = config['MakeOptions']
DeploymentP = config['DeploymentP'] # DebugMode = config['DebugMode']
PackagePrefix = config['PackagePrefix'] # CheckComOnly = config['CheckComOnly']
DeploymentF = config['DeploymentF']
DeploymentP = config['DeploymentP']
PackagePrefix = config['PackagePrefix']
#----------------------------------------------------- #-----------------------------------------------------
# [1] Set parameters passed to the main Bash script # [2] Set parameters passed to the main Bash script
#----------------------------------------------------- #-----------------------------------------------------
parameters = dict() parameters = dict()
parameters['build_cmd'] = BuildBash
parameters['build_cmd'] = BuildBash
parameters['check_cmd_only'] = CheckComOnly parameters['check_cmd_only'] = CheckComOnly
# (A) debug or release # (A) debug or release
parameters['debug_mode'] = DebugMode # True if debug, False if release parameters['debug_mode'] = DebugMode # True if debug, False if release
if parameters["debug_mode"]: if parameters["debug_mode"]:
mode = "debug" mode = "debug"
else: else:
mode = "release" mode = "release"
# (B) Modules # (B) Modules
(qt, ruby, python) = ModuleSet # ( 'qt5MP', 'Sys', 'Sys' ) (qt, ruby, python) = ModuleSet # ( 'qt5MP', 'Sys', 'Sys' )
ruby_python = "R%sP%s" % ( ruby.lower(), python.lower() ) ruby_python = "R%sP%s" % ( ruby.lower(), python.lower() )
# (C) Target directories and files # (C) Target directories and files
MacPkgDir = "%s%s.pkg.macos-%s-%s-%s" % (PackagePrefix, qt, Platform, mode, ruby_python) MacPkgDir = "%s%s.pkg.macos-%s-%s-%s" % (PackagePrefix, qt, Platform, mode, ruby_python)
MacBinDir = "%s.bin.macos-%s-%s-%s" % ( qt, Platform, mode, ruby_python) MacBinDir = "%s.bin.macos-%s-%s-%s" % ( qt, Platform, mode, ruby_python)
MacBuildDir = "%s.build.macos-%s-%s-%s" % ( qt, Platform, mode, ruby_python) MacBuildDir = "%s.build.macos-%s-%s-%s" % ( qt, Platform, mode, ruby_python)
MacBuildLog = "%s.build.macos-%s-%s-%s.log" % ( qt, Platform, mode, ruby_python) MacBuildLog = "%s.build.macos-%s-%s-%s.log" % ( qt, Platform, mode, ruby_python)
# AbsMacPkgDir = "%s/%s%s.pkg.macos-%s-%s-%s" % (ProjectDir, PackagePrefix, qt, Platform, mode, ruby_python) MacBuildDirQAT = MacBuildDir + ".macQAT"
# AbsMacBinDir = "%s/%s.bin.macos-%s-%s-%s" % (ProjectDir, qt, Platform, mode, ruby_python)
# AbsMacBuildDir = "%s/%s.build.macos-%s-%s-%s" % (ProjectDir, qt, Platform, mode, ruby_python)
# AbsMacBuildLog = "%s/%s.build.macos-%s-%s-%s.log" % (ProjectDir, qt, Platform, mode, ruby_python)
# AbsMacPkgDir = "%s/%s" % (ProjectDir, MacPkgDir)
# AbsMacBinDir = "%s/%s" % (ProjectDir, MacBinDir)
# AbsMacBuildDir = "%s/%s" % (ProjectDir, MacBuildDir)
# AbsMacBuildLog = "%s/%s" % (ProjectDir, MacBuildLog)
MacBuildDirQAT = MacBuildDir + ".macQAT"
parameters['logfile'] = MacBuildLog parameters['logfile'] = MacBuildLog
# (D) Qt5 # (D) Qt5
if ModuleQt == 'Qt5MacPorts': if ModuleQt == 'Qt5MacPorts':
parameters['qmake'] = Qt5MacPorts['qmake'] parameters['qmake'] = Qt5MacPorts['qmake']
parameters['deploy_tool'] = Qt5MacPorts['deploy'] parameters['deploy_tool'] = Qt5MacPorts['deploy']
elif ModuleQt == 'Qt5Brew': elif ModuleQt == 'Qt5Brew':
parameters['qmake'] = Qt5Brew['qmake'] parameters['qmake'] = Qt5Brew['qmake']
parameters['deploy_tool'] = Qt5Brew['deploy'] parameters['deploy_tool'] = Qt5Brew['deploy']
elif ModuleQt == 'Qt5Ana3': elif ModuleQt == 'Qt5Ana3':
parameters['qmake'] = Qt5Ana3['qmake'] parameters['qmake'] = Qt5Ana3['qmake']
parameters['deploy_tool'] = Qt5Ana3['deploy'] parameters['deploy_tool'] = Qt5Ana3['deploy']
parameters['bin'] = MacBinDir parameters['bin'] = MacBinDir
parameters['build'] = MacBuildDir parameters['build'] = MacBuildDir
parameters['rpath'] = "@executable_path/../Frameworks" parameters['rpath'] = "@executable_path/../Frameworks"
@ -555,7 +548,7 @@ def get_build_parameters(config):
# (G) about Ruby # (G) about Ruby
if ModuleRuby != "nil": if ModuleRuby != "nil":
parameters['ruby'] = RubyDictionary[ModuleRuby]['exe'] parameters['ruby'] = RubyDictionary[ModuleRuby]['exe']
parameters['rbinc'] = RubyDictionary[ModuleRuby]['inc'] parameters['rbinc'] = RubyDictionary[ModuleRuby]['inc']
parameters['rblib'] = RubyDictionary[ModuleRuby]['lib'] parameters['rblib'] = RubyDictionary[ModuleRuby]['lib']
if 'inc2' in RubyDictionary[ModuleRuby]: if 'inc2' in RubyDictionary[ModuleRuby]:
@ -564,50 +557,49 @@ def get_build_parameters(config):
# (H) about Python # (H) about Python
if ModulePython != "nil": if ModulePython != "nil":
parameters['python'] = PythonDictionary[ModulePython]['exe'] parameters['python'] = PythonDictionary[ModulePython]['exe']
parameters['pyinc'] = PythonDictionary[ModulePython]['inc'] parameters['pyinc'] = PythonDictionary[ModulePython]['inc']
parameters['pylib'] = PythonDictionary[ModulePython]['lib'] parameters['pylib'] = PythonDictionary[ModulePython]['lib']
config['MacPkgDir'] = MacPkgDir # relative path to package directory config['MacPkgDir'] = MacPkgDir # relative path to package directory
config['MacBinDir'] = MacBinDir # relative path to binary directory config['MacBinDir'] = MacBinDir # relative path to binary directory
config['MacBuildDir'] = MacBuildDir # relative path to build directory config['MacBuildDir'] = MacBuildDir # relative path to build directory
config['MacBuildDirQAT'] = MacBuildDirQAT # relative path to build directory for QATest config['MacBuildDirQAT'] = MacBuildDirQAT # relative path to build directory for QATest
config['MacBuildLog'] = MacBuildLog # relative path to build log file config['MacBuildLog'] = MacBuildLog # relative path to build log file
# config['AbsMacPkgDir'] = AbsMacPkgDir # absolute path to package directory
# config['AbsMacBinDir'] = AbsMacBinDir # absolute path to binary directory
# config['AbsMacBuildDir'] = AbsMacBuildDir # absolute path to build directory
# config['AbsMacBuildDirQAT'] = AbsMacBuildDirQAT # absolute path to build directory for QATest
# config['AbsMacBuildLog'] = AbsMacBuildLog # absolute path to build log file
# Extra parameteres needed for deployment # (I) Extra parameteres needed for deployment
parameters['project_dir'] = ProjectDir parameters['project_dir'] = ProjectDir
return parameters return parameters
def run_build_command(parameters): #------------------------------------------------------------------------------
## To run the main Bash script "build.sh" with appropriate options
#
# @param[in] parameters dictionary containing the build parameters
#
# @return 0 on success; non-zero (1), otherwise
#------------------------------------------------------------------------------
def Run_Build_Command(parameters):
#----------------------------------------------------- #-----------------------------------------------------
# [1] Set parameters passed to the main Bash script # [1] Set parameters passed to the main Bash script
#----------------------------------------------------- #-----------------------------------------------------
cmd_args = "" cmd_args = ""
# (A) debug or release # (A) debug or release
if parameters["debug_mode"]: if parameters["debug_mode"]:
mode = "debug" mode = "debug"
cmd_args += " -debug" cmd_args += " -debug"
else: else:
mode = "release" mode = "release"
cmd_args += " -release" cmd_args += " -release"
# (C) Target directories and files # (C) Target directories and files
MacBuildDirQAT = parameters['build'] + ".macQAT" MacBuildDirQAT = parameters['build'] + ".macQAT"
# (D) Qt5 # (D) Qt5
cmd_args += " \\\n -qt5" cmd_args += " \\\n -qt5"
cmd_args += " \\\n -qmake %s" % parameters['qmake'] cmd_args += " \\\n -qmake %s" % parameters['qmake']
cmd_args += " \\\n -bin %s" % parameters['bin'] cmd_args += " \\\n -bin %s" % parameters['bin']
cmd_args += " \\\n -build %s" % parameters['build'] cmd_args += " \\\n -build %s" % parameters['build']
cmd_args += " \\\n -rpath %s" % parameters['rpath'] cmd_args += " \\\n -rpath %s" % parameters['rpath']
# (E) want Qt bindings with Ruby scripts? # (E) want Qt bindings with Ruby scripts?
if parameters['no_qt_bindings']: if parameters['no_qt_bindings']:
@ -653,7 +645,6 @@ def run_build_command(parameters):
#----------------------------------------------------- #-----------------------------------------------------
# [3] Invoke the main Bash script; takes time:-) # [3] Invoke the main Bash script; takes time:-)
#----------------------------------------------------- #-----------------------------------------------------
myscript = os.path.basename(__file__) myscript = os.path.basename(__file__)
ret = subprocess.call( command, shell=True ) ret = subprocess.call( command, shell=True )
if ret != 0: if ret != 0:
@ -717,9 +708,15 @@ def run_build_command(parameters):
# #
# Reference: "Deploying an Application on Mac OS X" of Qt Assistant. # Reference: "Deploying an Application on Mac OS X" of Qt Assistant.
# #
# @param[in] config the build configuration
# @param[in] parameters the build parameters
#
# @return 0 on success; non-zero on failure # @return 0 on success; non-zero on failure
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
def DeployBinariesForBundle(config, parameters): def Deploy_Binaries_For_Bundle(config, parameters):
#-----------------------------------------------------
# [0] Retrieve the configuration and build parameters
#-----------------------------------------------------
NonOSStdLang = config['NonOSStdLang'] NonOSStdLang = config['NonOSStdLang']
DeploymentF = config['DeploymentF'] DeploymentF = config['DeploymentF']
DeploymentP = config['DeploymentP'] DeploymentP = config['DeploymentP']
@ -729,15 +726,16 @@ def DeployBinariesForBundle(config, parameters):
ModuleRuby = config['ModuleRuby'] ModuleRuby = config['ModuleRuby']
ModulePython = config['ModulePython'] ModulePython = config['ModulePython']
ProjectDir = parameters['project_dir'] ProjectDir = parameters['project_dir']
MacBinDir = parameters['bin'] MacBinDir = parameters['bin']
MacBuildDir = parameters['build'] MacBuildDir = parameters['build']
MacBuildLog = parameters['logfile'] MacBuildLog = parameters['logfile']
AbsMacPkgDir = "%s/%s" % (ProjectDir, MacPkgDir)
AbsMacBinDir = "%s/%s" % (ProjectDir, MacBinDir)
AbsMacBuildDir = "%s/%s" % (ProjectDir, MacBuildDir)
AbsMacBuildLog = "%s/%s" % (ProjectDir, MacBuildLog)
AbsMacPkgDir = "%s/%s" % (ProjectDir, MacPkgDir)
AbsMacBinDir = "%s/%s" % (ProjectDir, MacBinDir)
AbsMacBuildDir = "%s/%s" % (ProjectDir, MacBuildDir)
AbsMacBuildLog = "%s/%s" % (ProjectDir, MacBuildLog)
print("") print("")
print( "##### Started deploying libraries and executables for <klayout.app> #####" ) print( "##### Started deploying libraries and executables for <klayout.app> #####" )
@ -1033,17 +1031,24 @@ def DeployBinariesForBundle(config, parameters):
return 1 return 1
#----------------------------------------------------------------------------------------------- #-----------------------------------------------------------------------------------------------
# [9] Special deployment of Python3.8 from Homebrew # [9] Special deployment of Python3.8 or newer from Homebrew
# To use Python3.8 from Homebrew on Catalina... # To use Python3.8 from Homebrew on Catalina...
# in "/usr/local/opt/python/lib/" # in "/usr/local/opt/python@3.8/lib/"
# Python.framework -> ../Frameworks/Python.framework/ <=== this symbolic was needed # Python.framework -> ../Frameworks/Python.framework/ <=== this symbolic was needed
# pkgconfig/ # pkgconfig/
#----------------------------------------------------------------------------------------------- #-----------------------------------------------------------------------------------------------
deploymentPython38HB = (ModulePython == 'Python38Brew') deploymentPython38HB = (ModulePython == 'Python38Brew')
if deploymentPython38HB and NonOSStdLang: deploymentPythonAutoHB = (ModulePython == 'PythonAutoBrew')
if (deploymentPython38HB or deploymentPythonAutoHB) and NonOSStdLang:
from build4mac_util import WalkFrameworkPaths, PerformChanges from build4mac_util import WalkFrameworkPaths, PerformChanges
pythonHBVer = "3.8" # 'pinned' to this version as of KLayout version 0.26.7 (2020-09-13) if deploymentPython38HB:
HBPythonFrameworkPath = HBPython38FrameworkPath
pythonHBVer = "3.8" # 'pinned' to this version as of KLayout version 0.26.7 (2020-09-13)
elif deploymentPythonAutoHB:
HBPythonFrameworkPath = HBPythonAutoFrameworkPath
pythonHBVer = HBPythonAutoVersion
bundlePath = AbsMacPkgDir + '/klayout.app' bundlePath = AbsMacPkgDir + '/klayout.app'
bundleExecPathAbs = '%s/Contents/MacOS/' % bundlePath bundleExecPathAbs = '%s/Contents/MacOS/' % bundlePath
pythonFrameworkPath = '%s/Contents/Frameworks/Python.framework' % bundlePath pythonFrameworkPath = '%s/Contents/Frameworks/Python.framework' % bundlePath
@ -1052,14 +1057,14 @@ def DeployBinariesForBundle(config, parameters):
resourceTarget2 = '%s/Resources' % pythonFrameworkPath resourceTarget2 = '%s/Resources' % pythonFrameworkPath
binTarget = '%s/Versions/%s/bin' % (pythonFrameworkPath, pythonHBVer) binTarget = '%s/Versions/%s/bin' % (pythonFrameworkPath, pythonHBVer)
sitepackagesTarget = '%s/Versions/%s/lib/python%s/site-packages' % (pythonFrameworkPath, pythonHBVer, pythonHBVer) sitepackagesTarget = '%s/Versions/%s/lib/python%s/site-packages' % (pythonFrameworkPath, pythonHBVer, pythonHBVer)
sitepackagesSource = '%s/Versions/%s/lib/python%s/site-packages' % (HBPython38FrameworkPath, pythonHBVer, pythonHBVer) sitepackagesSource = '%s/Versions/%s/lib/python%s/site-packages' % (HBPythonFrameworkPath, pythonHBVer, pythonHBVer)
print( "" ) print( "" )
print( " [9] Optional deployment of Python from %s ..." % HBPython38FrameworkPath ) print( " [9] Optional deployment of Python from %s ..." % HBPythonFrameworkPath )
print( " [9.1] Copying Python Framework" ) print( " [9.1] Copying Python Framework" )
cmd01 = "rm -rf %s" % pythonFrameworkPath cmd01 = "rm -rf %s" % pythonFrameworkPath
cmd02 = "rsync -a --safe-links %s/ %s" % (HBPython38FrameworkPath, pythonFrameworkPath) cmd02 = "rsync -a --safe-links %s/ %s" % (HBPythonFrameworkPath, pythonFrameworkPath)
cmd03 = "rm -rf %s" % testTarget cmd03 = "rm -rf %s" % testTarget
cmd04 = "rm -rf %s" % resourceTarget1 cmd04 = "rm -rf %s" % resourceTarget1
@ -1094,7 +1099,7 @@ def DeployBinariesForBundle(config, parameters):
print(" [9.2.1] Patching Python Framework" ) print(" [9.2.1] Patching Python Framework" )
depdict = WalkFrameworkPaths( pythonFrameworkPath ) depdict = WalkFrameworkPaths( pythonFrameworkPath )
appPythonFrameworkPath = '@executable_path/../Frameworks/Python.framework/' appPythonFrameworkPath = '@executable_path/../Frameworks/Python.framework/'
PerformChanges(depdict, [(HBPython38FrameworkPath, appPythonFrameworkPath, False)], bundleExecPathAbs) PerformChanges(depdict, [(HBPythonFrameworkPath, appPythonFrameworkPath, False)], bundleExecPathAbs)
print(" [9.2.2] Patching /usr/local/opt/ libs") print(" [9.2.2] Patching /usr/local/opt/ libs")
usrLocalPath = '/usr/local/opt/' usrLocalPath = '/usr/local/opt/'
@ -1120,11 +1125,11 @@ def DeployBinariesForBundle(config, parameters):
print(" [9.3] Relinking dylib dependencies for klayout") print(" [9.3] Relinking dylib dependencies for klayout")
klayoutPath = bundleExecPathAbs klayoutPath = bundleExecPathAbs
depdict = WalkFrameworkPaths(klayoutPath, filter_regex=r'klayout$') depdict = WalkFrameworkPaths(klayoutPath, filter_regex=r'klayout$')
PerformChanges(depdict, [(HBPython38FrameworkPath, appPythonFrameworkPath, False)], bundleExecPathAbs) PerformChanges(depdict, [(HBPythonFrameworkPath, appPythonFrameworkPath, False)], bundleExecPathAbs)
libKlayoutPath = bundleExecPathAbs + '../Frameworks' libKlayoutPath = bundleExecPathAbs + '../Frameworks'
depdict = WalkFrameworkPaths(libKlayoutPath, filter_regex=r'libklayout') depdict = WalkFrameworkPaths(libKlayoutPath, filter_regex=r'libklayout')
PerformChanges(depdict, [(HBPython38FrameworkPath, appPythonFrameworkPath, False)], bundleExecPathAbs) PerformChanges(depdict, [(HBPythonFrameworkPath, appPythonFrameworkPath, False)], bundleExecPathAbs)
print(" [9.4] Patching site.py, pip/, and distutils/") print(" [9.4] Patching site.py, pip/, and distutils/")
site_module = "%s/Versions/%s/lib/python%s/site.py" % (pythonFrameworkPath, pythonHBVer, pythonHBVer) site_module = "%s/Versions/%s/lib/python%s/site.py" % (pythonFrameworkPath, pythonHBVer, pythonHBVer)
@ -1184,8 +1189,8 @@ def DeployBinariesForBundle(config, parameters):
#------------------------------------------------------------- #-------------------------------------------------------------
# [10] Special deployment of Ruby2.7 from Homebrew? # [10] Special deployment of Ruby2.7 from Homebrew?
#------------------------------------------------------------- #-------------------------------------------------------------
deploymentRuby26HB = (ModuleRuby == 'Ruby27Brew') deploymentRuby27HB = (ModuleRuby == 'Ruby27Brew')
if deploymentRuby26HB and NonOSStdLang: if deploymentRuby27HB and NonOSStdLang:
print( "" ) print( "" )
print( " [10] You have reached optional deployment of Ruby from %s ..." % HBRuby27Path ) print( " [10] You have reached optional deployment of Ruby from %s ..." % HBRuby27Path )
@ -1209,19 +1214,19 @@ def DeployBinariesForBundle(config, parameters):
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
## The main function ## The main function
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
def main(): def Main():
import pprint pp = pprint.PrettyPrinter( indent=4, width=140 )
pp = pprint.PrettyPrinter(indent=4) config = Get_Default_Config()
config = get_default_config() Parse_CLI_Args(config)
parse_cli_args(config)
#---------------------------------------------------------- #----------------------------------------------------------
# [The main build stage] # [The main build stage]
#---------------------------------------------------------- #----------------------------------------------------------
parameters = get_build_parameters(config) parameters = Get_Build_Parameters(config)
pp.pprint(parameters) pp.pprint(parameters)
if not config['DeploymentF'] and not config['DeploymentP']: if not config['DeploymentF'] and not config['DeploymentP']:
ret = run_build_command(parameters) ret = Run_Build_Command(parameters)
pp.pprint(config) pp.pprint(config)
if not ret == 0: if not ret == 0:
sys.exit(1) sys.exit(1)
@ -1231,13 +1236,13 @@ def main():
# Deployment of dynamic link libraries, executables and # Deployment of dynamic link libraries, executables and
# resources to make the main "klayout.app" bundle # resources to make the main "klayout.app" bundle
#---------------------------------------------------------- #----------------------------------------------------------
ret = DeployBinariesForBundle(config, parameters) ret = Deploy_Binaries_For_Bundle(config, parameters)
if not ret == 0: if not ret == 0:
sys.exit(1) sys.exit(1)
#=================================================================================== #===================================================================================
if __name__ == "__main__": if __name__ == "__main__":
main() Main()
#--------------- #---------------
# End of file # End of file

127
macbuild/build4mac_env.py
View File

@ -11,7 +11,7 @@
# This file is imported by 'build4mac.py' script. # This file is imported by 'build4mac.py' script.
#=============================================================================== #===============================================================================
import os import os
MyHome = os.environ['HOME'] import glob
#----------------------------------------------------- #-----------------------------------------------------
# [0] Xcode's tools # [0] Xcode's tools
@ -54,8 +54,8 @@ Qt5Ana3 = { 'qmake' : '/Applications/anaconda3/bin/qmake',
# [2] Ruby # [2] Ruby
#----------------------------------------------------- #-----------------------------------------------------
RubyNil = [ 'nil' ] RubyNil = [ 'nil' ]
RubySys = [ 'RubyElCapitan', 'RubySierra', 'RubyHighSierra', 'RubyMojave', 'RubyCatalina' ] RubySys = [ 'RubyElCapitan', 'RubySierra', 'RubyHighSierra', 'RubyMojave', 'RubyCatalina', 'RubyBigSur' ]
RubyExt = [ 'Ruby26MacPorts', 'Ruby27Brew', 'RubyAnaconda3' ] RubyExt = [ 'Ruby27MacPorts', 'Ruby27Brew', 'RubyAnaconda3' ]
Rubies = RubyNil + RubySys + RubyExt Rubies = RubyNil + RubySys + RubyExt
#----------------------------------------------------- #-----------------------------------------------------
@ -103,20 +103,43 @@ RubyMojave = { 'exe': '/System/Library/Frameworks/Ruby.framework/Versions/2
# Bundled with Catalina (10.15) # Bundled with Catalina (10.15)
# !!! Catalina does not allow to hack the "/System" directory; it's READ ONLY even for the super user! # !!! Catalina does not allow to hack the "/System" directory; it's READ ONLY even for the super user!
# Hence, we need to refer to the Ruby header file in "Xcode.app" directly. # Hence, we need to refer to the Ruby header file in "Xcode.app" directly.
#
# With the major release of "macOS Big Sur (11.0)" in November 2020, Xcode has been updated, too.
# (base) MacBookPro2{kazzz-s}(1)$ pwd
# /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/include/ruby-2.6.0
#
# (base) MacBookPro2{kazzz-s}(2)$ ll
# total 4
# drwxr-xr-x 6 root wheel 192 11 15 20:57 .
# drwxr-xr-x 3 root wheel 96 10 20 05:33 ..
# drwxr-xr-x 23 root wheel 736 10 24 11:57 ruby
# -rw-r--r-- 1 root wheel 868 10 19 19:32 ruby.h
# lrwxr-xr-x 1 root wheel 19 11 15 20:57 universal-darwin19 -> universal-darwin20/ <=== manually created this symbolic link
# drwxr-xr-x 6 root wheel 192 10 20 05:33 universal-darwin20
# [Key Type Name] = 'Sys' # [Key Type Name] = 'Sys'
CatalinaSDK = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.0.sdk" CatalinaSDK = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk"
RubyCatalina = { 'exe': '/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/bin/ruby', RubyCatalina = { 'exe': '/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/bin/ruby',
'inc': '%s/System/Library/Frameworks/Ruby.framework/Headers' % CatalinaSDK, 'inc': '%s/System/Library/Frameworks/Ruby.framework/Headers' % CatalinaSDK,
'inc2': '%s/System/Library/Frameworks/Ruby.framework/Headers/ruby' % CatalinaSDK, 'inc2': '%s/System/Library/Frameworks/Ruby.framework/Headers/ruby' % CatalinaSDK,
'lib': '/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/lib/libruby.dylib' 'lib': '/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/lib/libruby.dylib'
} }
# Ruby 2.6 from MacPorts (https://www.macports.org/) *+*+*+ EXPERIMENTAL *+*+*+ # Bundled with Big Sur (11.0)
# install with 'sudo port install ruby26' # Refer to the "Catalina" section above
# [Key Type Name] = 'MP26' # [Key Type Name] = 'Sys'
Ruby26MacPorts = { 'exe': '/opt/local/bin/ruby2.6', BigSurSDK = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk"
'inc': '/opt/local/include/ruby-2.6.0', RubyBigSur = { 'exe': '/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/bin/ruby',
'lib': '/opt/local/lib/libruby.2.6.dylib' 'inc': '%s/System/Library/Frameworks/Ruby.framework/Headers' % BigSurSDK,
'inc2': '%s/System/Library/Frameworks/Ruby.framework/Headers/ruby' % BigSurSDK,
'lib': '/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/lib/libruby.dylib'
}
# Ruby 2.7 from MacPorts (https://www.macports.org/) *+*+*+ EXPERIMENTAL *+*+*+
# install with 'sudo port install ruby27'
# [Key Type Name] = 'MP27'
Ruby27MacPorts = { 'exe': '/opt/local/bin/ruby2.7',
'inc': '/opt/local/include/ruby-2.7.0',
'lib': '/opt/local/lib/libruby.2.7.dylib'
} }
# Ruby 2.7 from Homebrew *+*+*+ EXPERIMENTAL *+*+*+ # Ruby 2.7 from Homebrew *+*+*+ EXPERIMENTAL *+*+*+
@ -145,7 +168,8 @@ RubyDictionary = { 'nil' : None,
'RubyHighSierra': RubyHighSierra, 'RubyHighSierra': RubyHighSierra,
'RubyMojave' : RubyMojave, 'RubyMojave' : RubyMojave,
'RubyCatalina' : RubyCatalina, 'RubyCatalina' : RubyCatalina,
'Ruby26MacPorts': Ruby26MacPorts, 'RubyBigSur' : RubyBigSur,
'Ruby27MacPorts': Ruby27MacPorts,
'Ruby27Brew' : Ruby27Brew, 'Ruby27Brew' : Ruby27Brew,
'RubyAnaconda3' : RubyAnaconda3 'RubyAnaconda3' : RubyAnaconda3
} }
@ -154,8 +178,8 @@ RubyDictionary = { 'nil' : None,
# [3] Python # [3] Python
#----------------------------------------------------- #-----------------------------------------------------
PythonNil = [ 'nil' ] PythonNil = [ 'nil' ]
PythonSys = [ 'PythonElCapitan', 'PythonSierra', 'PythonHighSierra', 'PythonMojave', 'PythonCatalina' ] PythonSys = [ 'PythonElCapitan', 'PythonSierra', 'PythonHighSierra', 'PythonMojave', 'PythonCatalina', 'PythonBigSur' ]
PythonExt = [ 'Python38MacPorts', 'Python38Brew', 'PythonAnaconda3' ] PythonExt = [ 'Python38MacPorts', 'Python38Brew', 'PythonAnaconda3', 'PythonAutoBrew' ]
Pythons = PythonNil + PythonSys + PythonExt Pythons = PythonNil + PythonSys + PythonExt
#----------------------------------------------------- #-----------------------------------------------------
@ -198,13 +222,20 @@ PythonMojave = { 'exe': '/System/Library/Frameworks/Python.framework/Versions
'lib': '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/libpython2.7.dylib' 'lib': '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/libpython2.7.dylib'
} }
# Bundled with Mojave (10.15) # Bundled with Catalina (10.15)
# [Key Type Name] = 'Sys' # [Key Type Name] = 'Sys'
PythonCatalina = { 'exe': '/System/Library/Frameworks/Python.framework/Versions/2.7/bin/python', PythonCatalina = { 'exe': '/System/Library/Frameworks/Python.framework/Versions/2.7/bin/python',
'inc': '/System/Library/Frameworks/Python.framework/Versions/2.7/include/python2.7', 'inc': '/System/Library/Frameworks/Python.framework/Versions/2.7/include/python2.7',
'lib': '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/libpython2.7.dylib' 'lib': '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/libpython2.7.dylib'
} }
# Bundled with Big Sur (11.0)
# [Key Type Name] = 'Sys'
PythonBigSur = { 'exe': '/System/Library/Frameworks/Python.framework/Versions/2.7/bin/python',
'inc': '/System/Library/Frameworks/Python.framework/Versions/2.7/include/python2.7',
'lib': '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/libpython2.7.dylib'
}
# Python 3.8 from MacPorts (https://www.macports.org/) *+*+*+ EXPERIMENTAL *+*+*+ # Python 3.8 from MacPorts (https://www.macports.org/) *+*+*+ EXPERIMENTAL *+*+*+
# install with 'sudo port install python38' # install with 'sudo port install python38'
# [Key Type Name] = 'MP38' # [Key Type Name] = 'MP38'
@ -216,27 +247,12 @@ Python38MacPorts= { 'exe': '/opt/local/Library/Frameworks/Python.framework/Versi
# Python 3.8 from Homebrew *+*+*+ EXPERIMENTAL *+*+*+ # Python 3.8 from Homebrew *+*+*+ EXPERIMENTAL *+*+*+
# install with 'brew install python' # install with 'brew install python'
# [Key Type Name] = 'HB38' # [Key Type Name] = 'HB38'
HBPython38FrameworkPath = '/usr/local/opt/python3/Frameworks/Python.framework' HBPython38FrameworkPath = '/usr/local/opt/python@3.8/Frameworks/Python.framework'
Python38Brew = { 'exe': '%s/Versions/3.8/bin/python3.8' % HBPython38FrameworkPath, Python38Brew = { 'exe': '%s/Versions/3.8/bin/python3.8' % HBPython38FrameworkPath,
'inc': '%s/Versions/3.8/include/python3.8' % HBPython38FrameworkPath, 'inc': '%s/Versions/3.8/include/python3.8' % HBPython38FrameworkPath,
'lib': '%s/Versions/3.8/lib/libpython3.8.dylib' % HBPython38FrameworkPath 'lib': '%s/Versions/3.8/lib/libpython3.8.dylib' % HBPython38FrameworkPath
} }
# # Latest Python from Homebrew *+*+*+ EXPERIMENTAL *+*+*+
# # install with 'brew install python'
# # [Key Type Name] = 'HBAuto'
# import glob
# # In my system, there are four candidates: (python, python3, python@3, python@3.8)
# # Hard to tell which is going to be available to the user. Picking the last one
# HBAutoFrameworkPath = glob.glob("/usr/local/opt/python*/Frameworks/Python.framework/")[-1]
# # expand 3* into _py_version, there should be only one, but I am taking no chances.
# HBAutoFrameworkVersionPath, _py_version = os.path.split(glob.glob("%s/Versions/3*" % HBAutoFrameworkPath)[0])
# PythonAutoBrew = { 'exe': '%s/bin/python%s' % (HBAutoFrameworkVersionPath, _py_version),
# 'inc': '%s/include/python%s' % (HBAutoFrameworkVersionPath, _py_version),
# 'lib': glob.glob("%s/lib/*.dylib" % HBAutoFrameworkVersionPath)[0]
# }
# Python 3.8 bundled with anaconda3 installed under /Applications/anaconda3/ *+*+*+ EXPERIMENTAL *+*+*+ # Python 3.8 bundled with anaconda3 installed under /Applications/anaconda3/ *+*+*+ EXPERIMENTAL *+*+*+
# The standard installation deploys the tool under $HOME/opt/anaconda3/. # The standard installation deploys the tool under $HOME/opt/anaconda3/.
# If so, you need to make a symbolic link: /Applications/anaconda3 ---> $HOME/opt/anaconda3/ # If so, you need to make a symbolic link: /Applications/anaconda3 ---> $HOME/opt/anaconda3/
@ -246,17 +262,42 @@ PythonAnaconda3 = { 'exe': '/Applications/anaconda3/bin/python3.8',
'lib': '/Applications/anaconda3/lib/libpython3.8.dylib' 'lib': '/Applications/anaconda3/lib/libpython3.8.dylib'
} }
# Latest Python from Homebrew *+*+*+ EXPERIMENTAL *+*+*+
# install with 'brew install python'
# There can be multiple candidates such as: (python, python3, python@3, python@3.8, python@3.9)
# Hard to tell which is going to be available to the user. Picking the last one.
# [Key Type Name] = 'HBAuto'
HBPythonAutoFrameworkPath = ""
HBPythonAutoVersion = ""
try:
HBPythonAutoFrameworkPath = glob.glob( "/usr/local/opt/python*/Frameworks/Python.framework" )[-1]
# expand 3* into HBPythonAutoVersion, there should be only one, but I am taking no chances.
HBAutoFrameworkVersionPath, HBPythonAutoVersion = os.path.split( glob.glob( "%s/Versions/3*" % HBPythonAutoFrameworkPath )[0] )
PythonAutoBrew = { 'exe': '%s/%s/bin/python%s' % ( HBAutoFrameworkVersionPath, HBPythonAutoVersion, HBPythonAutoVersion ),
'inc': '%s/%s/include/python%s' % ( HBAutoFrameworkVersionPath, HBPythonAutoVersion, HBPythonAutoVersion ),
'lib': glob.glob( "%s/%s/lib/*.dylib" % ( HBAutoFrameworkVersionPath, HBPythonAutoVersion ) )[0]
}
except Exception as e:
_have_Homebrew_Python = False
print( " WARNING!!! Since you don't have the Homebrew Python Frameworks, you cannot use the '-p HBAuto' option. " )
pass
else:
_have_Homebrew_Python = True
# Consolidated dictionary kit for Python # Consolidated dictionary kit for Python
PythonDictionary= { 'nil' : None, PythonDictionary = { 'nil' : None,
'PythonElCapitan' : PythonElCapitan, 'PythonElCapitan' : PythonElCapitan,
'PythonSierra' : PythonSierra, 'PythonSierra' : PythonSierra,
'PythonHighSierra': PythonHighSierra, 'PythonHighSierra': PythonHighSierra,
'PythonMojave' : PythonMojave, 'PythonMojave' : PythonMojave,
'PythonCatalina' : PythonCatalina, 'PythonCatalina' : PythonCatalina,
'Python38MacPorts': Python38MacPorts, 'PythonBigSur' : PythonBigSur,
'Python38Brew' : Python38Brew, 'Python38MacPorts': Python38MacPorts,
'PythonAnaconda3' : PythonAnaconda3 'Python38Brew' : Python38Brew,
} 'PythonAnaconda3' : PythonAnaconda3
}
if _have_Homebrew_Python:
PythonDictionary['PythonAutoBrew'] = PythonAutoBrew
#----------------------------------------------------- #-----------------------------------------------------
# [4] KLayout executables including buddy tools # [4] KLayout executables including buddy tools

358
macbuild/macQAT.py
View File

@ -16,8 +16,6 @@ import os
import datetime import datetime
from time import sleep from time import sleep
import six import six
import shutil
import glob
import platform import platform
import optparse import optparse
import subprocess import subprocess
@ -27,55 +25,55 @@ import subprocess
# #
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def SetGlobals(): def SetGlobals():
global ProjectDir # project directory where "ut_runner" exists global ProjectDir # project directory where "ut_runner" exists
global RunnerUsage # True to print the usage of 'ut_runner' global RunnerUsage # True to print the usage of 'ut_runner'
global Run # True to run this script global Run # True to run this script
global ContinueOnError # True to continue after an error global ContinueOnError # True to continue after an error
global TestsExcluded # list of tests to exclude global TestsExcluded # list of tests to exclude
global Arguments # other arguments global Arguments # other arguments
global GitSHA1 # Git's short SHA1 value of the HEAD global GitSHA1 # Git's short SHA1 value of the HEAD
global TimeStamp # time stamp global TimeStamp # time stamp
global WorkDir # work directory name global WorkDir # work directory name
global LogFile # log file name global LogFile # log file name
global Usage # string on usage global Usage # string on usage
# auxiliary variables on platform # auxiliary variables on platform
global System # 6-tuple from platform.uname() global System # 6-tuple from platform.uname()
global Node # - do - global Node # - do -
global Release # - do - global Release # - do -
global Version # - do - global Version # - do -
global Machine # - do - global Machine # - do -
global Processor # - do - global Processor # - do -
global Bit # machine bit-size global Bit # machine bit-size
Usage = "\n" Usage = "\n"
Usage += "----------------------------------------------------------------------------------------\n" Usage += "----------------------------------------------------------------------------------------\n"
Usage += "<< Usage of 'macQAT.py' >>\n" Usage += "<< Usage of 'macQAT.py' >>\n"
Usage += " for running 'ut_runner' after building KLayout.\n" Usage += " for running 'ut_runner' after building KLayout.\n"
Usage += "\n" Usage += "\n"
Usage += "$ [python] ./macQAT.py \n" Usage += "$ [python] ./macQAT.py \n"
Usage += " option & argument : descriptions | default value\n" Usage += " option & argument : descriptions | default value\n"
Usage += " -----------------------------------------------------------------+---------------\n" Usage += " -----------------------------------------------------------------+---------------\n"
Usage += " [-u|--usage] : print usage of 'ut_runner'and exit | disabled \n" Usage += " [-u|--usage] : print usage of 'ut_runner'and exit | disabled \n"
Usage += " | \n" Usage += " | \n"
Usage += " <-r|--run> : run this script | disabled \n" Usage += " <-r|--run> : run this script | disabled \n"
Usage += " [-s|--stop] : stop on error | disabled \n" Usage += " [-s|--stop] : stop on error | disabled \n"
Usage += " [-x|--exclude <tests>] : exclude test(s) such as 'pymod,pya' | '' \n" Usage += " [-x|--exclude <tests>] : exclude test(s) such as 'pymod,pya' | '' \n"
Usage += " [-a|--args <string>] : arguments other than '-x' and '-c' | '' \n" Usage += " [-a|--args <string>] : arguments other than '-x' and '-c' | '' \n"
Usage += " [-?|--?] : print this usage and exit | disabled \n" Usage += " [-?|--?] : print this usage and exit | disabled \n"
Usage += "--------------------------------------------------------------------+-------------------\n" Usage += "--------------------------------------------------------------------+-------------------\n"
ProjectDir = os.getcwd() ProjectDir = os.getcwd()
RunnerUsage = False RunnerUsage = False
Run = False Run = False
ContinueOnError = True ContinueOnError = True
TestsExcluded = list() TestsExcluded = list()
Arguments = "" Arguments = ""
GitSHA1 = GetGitShortSHA1() GitSHA1 = GetGitShortSHA1()
TimeStamp = GetTimeStamp() TimeStamp = GetTimeStamp()
WorkDir = "QATest_%s_%s__%s" % (GitSHA1, TimeStamp, os.path.basename(ProjectDir) ) WorkDir = "QATest_%s_%s__%s" % (GitSHA1, TimeStamp, os.path.basename(ProjectDir) )
LogFile = WorkDir + ".log" LogFile = WorkDir + ".log"
(System, Node, Release, Version, Machine, Processor) = platform.uname() (System, Node, Release, Version, Machine, Processor) = platform.uname()
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
## Get git's short SHA1 value of the HEAD ## Get git's short SHA1 value of the HEAD
@ -83,9 +81,9 @@ def SetGlobals():
# @return SHA1 value string # @return SHA1 value string
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def GetGitShortSHA1(): def GetGitShortSHA1():
command = "git rev-parse --short HEAD 2>/dev/null" command = "git rev-parse --short HEAD 2>/dev/null"
sha1val = os.popen( command ).read().strip() sha1val = os.popen( command ).read().strip()
return sha1val return sha1val
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
## Get the time stamp ## Get the time stamp
@ -93,108 +91,108 @@ def GetGitShortSHA1():
# @return time stamp string # @return time stamp string
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def GetTimeStamp(): def GetTimeStamp():
ts = datetime.datetime.today() ts = datetime.datetime.today()
return "%04d_%02d%02d_%02d%02d" % (ts.year, ts.month, ts.day, ts.hour, ts.minute) return "%04d_%02d%02d_%02d%02d" % (ts.year, ts.month, ts.day, ts.hour, ts.minute)
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
## To parse the command line arguments ## To parse the command line arguments
# #
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def ParseCommandLineArguments(): def ParseCommandLineArguments():
global Usage global Usage
global RunnerUsage global RunnerUsage
global Run global Run
global ContinueOnError global ContinueOnError
global TestsExcluded global TestsExcluded
global Arguments global Arguments
p = optparse.OptionParser( usage=Usage ) p = optparse.OptionParser( usage=Usage )
p.add_option( '-u', '--usage', p.add_option( '-u', '--usage',
action='store_true', action='store_true',
dest='runner_usage', dest='runner_usage',
default=False, default=False,
help="print usage of 'ut_runner' and exit (false)" ) help="print usage of 'ut_runner' and exit (false)" )
p.add_option( '-r', '--run', p.add_option( '-r', '--run',
action='store_true', action='store_true',
dest='runme', dest='runme',
default=False, default=False,
help='run this script (false)' ) help='run this script (false)' )
p.add_option( '-s', '--stop', p.add_option( '-s', '--stop',
action='store_true', action='store_true',
dest='stop_on_error', dest='stop_on_error',
default=False, default=False,
help='stop on error (false)' ) help='stop on error (false)' )
p.add_option( '-x', '--exclude', p.add_option( '-x', '--exclude',
dest='exclude_tests', dest='exclude_tests',
help="exclude test(s) such as 'pymod,pya' ('')" ) help="exclude test(s) such as 'pymod,pya' ('')" )
p.add_option( '-a', '--args', p.add_option( '-a', '--args',
dest='arguments', dest='arguments',
help="arguments other than '-x' and '-c' ('')" ) help="arguments other than '-x' and '-c' ('')" )
p.add_option( '-?', '--??', p.add_option( '-?', '--??',
action='store_true', action='store_true',
dest='checkusage', dest='checkusage',
default=False, default=False,
help='check usage (false)' ) help='check usage (false)' )
p.set_defaults( runner_usage = False, p.set_defaults( runner_usage = False,
runme = False, runme = False,
stop_on_error = False, stop_on_error = False,
exclude_tests = "", exclude_tests = "",
arguments = "", arguments = "",
checkusage = False ) checkusage = False )
opt, args = p.parse_args() opt, args = p.parse_args()
if opt.checkusage: if opt.checkusage:
print(Usage) print(Usage)
quit() quit()
RunnerUsage = opt.runner_usage RunnerUsage = opt.runner_usage
Run = opt.runme Run = opt.runme
ContinueOnError = not opt.stop_on_error ContinueOnError = not opt.stop_on_error
if not opt.exclude_tests == "": if not opt.exclude_tests == "":
TestsExcluded = [ item.strip() for item in opt.exclude_tests.split(',') ] TestsExcluded = [ item.strip() for item in opt.exclude_tests.split(',') ]
else: else:
TestsExcluded = [] TestsExcluded = []
Arguments = opt.arguments Arguments = opt.arguments
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
## Hide/Show the private directory ## Hide/Show the private directory
# #
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def HidePrivateDir(): def HidePrivateDir():
if os.path.isdir( "../private" ): if os.path.isdir( "../private" ):
os.rename( "../private", "../private.stash" ) os.rename( "../private", "../private.stash" )
def ShowPrivateDir(): def ShowPrivateDir():
if os.path.isdir( "../private.stash" ): if os.path.isdir( "../private.stash" ):
os.rename( "../private.stash", "../private" ) os.rename( "../private.stash", "../private" )
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
## Export environment variables for "ut_runner" ## Export environment variables for "ut_runner"
# #
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def ExportEnvVariables(): def ExportEnvVariables():
global ProjectDir global ProjectDir
global WorkDir global WorkDir
global MyEnviron # my environment variables; can be independently used later global MyEnviron # my environment variables; can be independently used later
# In older versions of subprocess module, 'env=None' argument is not provided # In older versions of subprocess module, 'env=None' argument is not provided
MyEnviron = os.environ.copy() MyEnviron = os.environ.copy()
MyEnviron[ 'TESTSRC' ] = ".." MyEnviron[ 'TESTSRC' ] = ".."
MyEnviron[ 'TESTTMP' ] = WorkDir MyEnviron[ 'TESTTMP' ] = WorkDir
if System == "Darwin": if System == "Darwin":
MyEnviron[ 'DYLD_LIBRARY_PATH' ] = "%s:%s/db_plugins" % (ProjectDir, ProjectDir) MyEnviron[ 'DYLD_LIBRARY_PATH' ] = "%s:%s/db_plugins" % (ProjectDir, ProjectDir)
for env in [ 'TESTSRC', 'TESTTMP', 'DYLD_LIBRARY_PATH' ]: for env in [ 'TESTSRC', 'TESTTMP', 'DYLD_LIBRARY_PATH' ]:
os.environ[env] = MyEnviron[env] os.environ[env] = MyEnviron[env]
else: else:
MyEnviron[ 'LD_LIBRARY_PATH' ] = "%s:%s/db_plugins" % (ProjectDir, ProjectDir) MyEnviron[ 'LD_LIBRARY_PATH' ] = "%s:%s/db_plugins" % (ProjectDir, ProjectDir)
for env in [ 'TESTSRC', 'TESTTMP', 'LD_LIBRARY_PATH' ]: for env in [ 'TESTSRC', 'TESTTMP', 'LD_LIBRARY_PATH' ]:
os.environ[env] = MyEnviron[env] os.environ[env] = MyEnviron[env]
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
## Run the tester ## Run the tester
@ -203,75 +201,77 @@ def ExportEnvVariables():
# @param[in] logfile log file name # @param[in] logfile log file name
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def RunTester( command, logfile="" ): def RunTester( command, logfile="" ):
if six.PY3: if six.PY3:
proc = subprocess.Popen( command.split(), stdout=subprocess.PIPE, \ proc = subprocess.Popen( command.split(),
stderr=subprocess.STDOUT, \ stdout=subprocess.PIPE, \
universal_newlines=True ) stderr=subprocess.STDOUT, \
else: universal_newlines=True )
proc = subprocess.Popen( command.split(), stdout=subprocess.PIPE, \ else:
stderr=subprocess.STDOUT ) proc = subprocess.Popen( command.split(),
stdout=subprocess.PIPE, \
stderr=subprocess.STDOUT )
if not logfile == "": if not logfile == "":
with proc.stdout, open( logfile, 'w' ) as file: with proc.stdout, open( logfile, 'w' ) as file:
for line in proc.stdout: for line in proc.stdout:
sys.stdout.write(line) sys.stdout.write(line)
file.write(line) file.write(line)
proc.wait() proc.wait()
else: else:
with proc.stdout: with proc.stdout:
for line in proc.stdout: for line in proc.stdout:
sys.stdout.write(line) sys.stdout.write(line)
proc.wait() proc.wait()
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
# Main function # Main function
#------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
def Main(): def Main():
#------------------------------------------------------- #-------------------------------------------------------
# [1] Initialize # [1] Initialize
#------------------------------------------------------- #-------------------------------------------------------
SetGlobals() SetGlobals()
ParseCommandLineArguments() ParseCommandLineArguments()
ExportEnvVariables() ExportEnvVariables()
#------------------------------------------------------- #-------------------------------------------------------
# [2] Print the runner's usage # [2] Print the runner's usage
#------------------------------------------------------- #-------------------------------------------------------
if RunnerUsage: if RunnerUsage:
command = './ut_runner --help-all' command = './ut_runner --help-all'
RunTester( command ) RunTester( command )
quit() quit()
#------------------------------------------------------- #-------------------------------------------------------
# [3] Run the unit tester # [3] Run the unit tester
#------------------------------------------------------- #-------------------------------------------------------
if not Run: if not Run:
print( "! pass <-r|--run> option to run" ) print( "! pass <-r|--run> option to run" )
print(Usage) print(Usage)
quit() quit()
command = './ut_runner' command = './ut_runner'
if ContinueOnError: if ContinueOnError:
command += " -c" command += " -c"
for item in TestsExcluded: for item in TestsExcluded:
command += ' -x %s' % item command += ' -x %s' % item
if not Arguments == "": if not Arguments == "":
command += " %s" % Arguments command += " %s" % Arguments
print( "" ) print( "" )
print( "### Dumping the log to <%s>" % LogFile ) print( "### Dumping the log to <%s>" % LogFile )
print( "------------------------------------------------------------" ) print( "------------------------------------------------------------" )
print( " Git SHA1 = %s" % GitSHA1 ) print( " Git SHA1 = %s" % GitSHA1 )
print( " Time stamp = %s" % TimeStamp ) print( " Time stamp = %s" % TimeStamp )
print( "------------------------------------------------------------" ) print( "------------------------------------------------------------" )
sleep( 1.0 ) sleep( 1.0 )
HidePrivateDir() HidePrivateDir()
RunTester( command, logfile=LogFile ) RunTester( command, logfile=LogFile )
ShowPrivateDir() ShowPrivateDir()
#=================================================================================== #===================================================================================
if __name__ == "__main__": if __name__ == "__main__":
Main() Main()
#--------------- #---------------
# End of file # End of file

66
macbuild/macQAT.sh
View File

@ -14,23 +14,23 @@
# Functions # Functions
#---------------------------------------------------------------- #----------------------------------------------------------------
function GetPresentDir() { function GetPresentDir() {
path=$1 path=$1
array=( `echo $path | tr -s '/' ' '`) array=( `echo $path | tr -s '/' ' '`)
last_index=`expr ${#array[@]} - 1` last_index=`expr ${#array[@]} - 1`
echo ${array[${last_index}]} echo ${array[${last_index}]}
return 0 return 0
} }
function HidePrivateDir() { function HidePrivateDir() {
if [ -d "../private" ]; then if [ -d "../private" ]; then
ret=$(/bin/mv ../private ../private.stash) ret=$(/bin/mv ../private ../private.stash)
fi fi
} }
function ShowPrivateDir() { function ShowPrivateDir() {
if [ -d "../private.stash" ]; then if [ -d "../private.stash" ]; then
ret=$(/bin/mv ../private.stash ../private) ret=$(/bin/mv ../private.stash ../private)
fi fi
} }
#---------------------------------------------------------------- #----------------------------------------------------------------
@ -52,17 +52,28 @@ export DYLD_LIBRARY_PATH=$(pwd):$(pwd)/db_plugins
# Environment variables for "ut_runner" # Environment variables for "ut_runner"
#---------------------------------------------------------------- #----------------------------------------------------------------
if [ $# -eq 1 ]; then if [ $# -eq 1 ]; then
if [ "$1" == "-h" ]; then if [ "$1" == "-h" ]; then
./ut_runner -h ./ut_runner -h
exit 0 exit 0
fi fi
if [ "$1" == "-r" ]; then if [ "$1" == "-r" ]; then
echo "### Dumping the log to" $logfile "..." echo "### Dumping the log to" $logfile "..."
HidePrivateDir HidePrivateDir
./ut_runner -x pymod -c 2>&1 | tee $logfile ./ut_runner -x pymod -c 2>&1 | tee $logfile
ShowPrivateDir ShowPrivateDir
exit 0 exit 0
else else
echo ""
echo " Git SHA1 = ${gitSHA1}"
echo " Time stamp = ${timestamp}"
echo " Log file = ${logfile}"
echo " Usage:"
echo " ./QATest.sh -h: to get the help of 'ut_runner'"
echo " ./QATest.sh -r: to run the tests with '-c' option: continues after an error"
echo ""
exit 0
fi
else
echo "" echo ""
echo " Git SHA1 = ${gitSHA1}" echo " Git SHA1 = ${gitSHA1}"
echo " Time stamp = ${timestamp}" echo " Time stamp = ${timestamp}"
@ -72,17 +83,6 @@ if [ $# -eq 1 ]; then
echo " ./QATest.sh -r: to run the tests with '-c' option: continues after an error" echo " ./QATest.sh -r: to run the tests with '-c' option: continues after an error"
echo "" echo ""
exit 0 exit 0
fi
else
echo ""
echo " Git SHA1 = ${gitSHA1}"
echo " Time stamp = ${timestamp}"
echo " Log file = ${logfile}"
echo " Usage:"
echo " ./QATest.sh -h: to get the help of 'ut_runner'"
echo " ./QATest.sh -r: to run the tests with '-c' option: continues after an error"
echo ""
exit 0
fi fi
#-------------- #--------------

1185
macbuild/makeDMG4mac.py
View File

File diff suppressed because it is too large Load Diff

602
macbuild/nightyCatalina.py
View File

@ -6,245 +6,461 @@ import sys
import os import os
import shutil import shutil
import glob import glob
import platform
import optparse import optparse
import subprocess import subprocess
Variation = [ 'std', 'ports', 'brew', 'ana3' ] #------------------------------------------------------------------------------
## To populate the build target dictionary
#
# @return a dictionary; key=integer, value=mnemonic
#------------------------------------------------------------------------------
def Get_Build_Target_Dict():
buildTargetDic = dict()
buildTargetDic[0] = 'std'
buildTargetDic[1] = 'ports'
buildTargetDic[2] = 'brew'
buildTargetDic[3] = 'brewHW'
buildTargetDic[4] = 'ana3'
Usage = "\n" buildTargetDic[5] = 'brewA'
Usage += "------------------------------------------------------------------------------------------\n" buildTargetDic[6] = 'brewAHW'
Usage += " nightyCatalina.py [EXPERIMENTAL] \n" return buildTargetDic
Usage += " << To execute the jobs for making KLatyout's DMGs for macOS Catalina >> \n"
Usage += "\n"
Usage += "$ [python] nightyCatalina.py \n"
Usage += " option & argument : comment on option if any | default value\n"
Usage += " -------------------------------------------------------------------+--------------\n"
Usage += " [--build] : build and deploy | disabled\n"
Usage += " [--makedmg <srlno>] : make DMG | disabled\n"
Usage += " [--cleandmg <srlno>] : clean DMG | disabled\n"
Usage += " [--upload <dropbox>] : upload to $HOME/Dropbox/klayout/<dropbox> | disabled\n"
Usage += " [-?|--?] : print this usage and exit | disabled\n"
Usage += "----------------------------------------------------------------------+-------------------\n"
def ParseCommandLineArguments(): #------------------------------------------------------------------------------
global Usage ## To get the build option dictionary
global Build # operation flag #
global MakeDMG # operation flag # @param[in] targetDic build target dictionary
global CleanDMG # operation flag #
global Upload # operation flag # @return a dictionary; key=mnemonic, value=build option list
global SrlDMG # DMG serial number #------------------------------------------------------------------------------
global Dropbox # Dropbox directory def Get_Build_Options( targetDic ):
buildOp = dict()
for key in targetDic.keys():
target = targetDic[key]
if target == "std": # use 'Qt5Brew' that provides Qt 5.15.1 to run on "Big Sur", too
buildOp["std"] = [ '-q', 'Qt5Brew', '-r', 'sys', '-p', 'sys' ]
elif target == "ports":
buildOp["ports"] = [ '-q', 'Qt5MacPorts', '-r', 'MP27', '-p', 'MP38' ]
elif target == "brew":
buildOp["brew"] = [ '-q', 'Qt5Brew', '-r', 'HB27', '-p', 'HB38' ]
elif target == "brewHW":
buildOp["brewHW"] = [ '-q', 'Qt5Brew', '-r', 'sys', '-p', 'HB38' ]
elif target == "ana3":
buildOp["ana3"] = [ '-q', 'Qt5Ana3', '-r', 'Ana3', '-p', 'Ana3' ]
elif target == "brewA":
buildOp["brewA"] = [ '-q', 'Qt5Brew', '-r', 'HB27', '-p', 'HBAuto' ]
elif target == "brewAHW":
buildOp["brewAHW"] = [ '-q', 'Qt5Brew', '-r', 'sys', '-p', 'HBAuto' ]
return buildOp
p = optparse.OptionParser( usage=Usage ) #------------------------------------------------------------------------------
p.add_option( '--build', ## To get the ".macQAT" dictionary for QA Test
action='store_true', #
dest='build', # @param[in] targetDic build target dictionary
default=False, #
help='build and deploy' ) # @return a dictionary; key=mnemonic, value=".macQAT" directory
#------------------------------------------------------------------------------
def Get_QAT_Directory( targetDic ):
dirQAT = dict()
for key in targetDic.keys():
target = targetDic[key]
if target == "std":
dirQAT["std"] = 'qt5Brew.build.macos-Catalina-release-RsysPsys.macQAT'
elif target == "ports":
dirQAT["ports"] = 'qt5MP.build.macos-Catalina-release-Rmp27Pmp38.macQAT'
elif target == "brew":
dirQAT["brew"] = 'qt5Brew.build.macos-Catalina-release-Rhb27Phb38.macQAT'
elif target == "brewHW":
dirQAT["brewHW"] = 'qt5Brew.build.macos-Catalina-release-RsysPhb38.macQAT'
elif target == "ana3":
dirQAT["ana3"] = 'qt5Ana3.build.macos-Catalina-release-Rana3Pana3.macQAT'
elif target == "brewA":
dirQAT["brewA"] = 'qt5Brew.build.macos-Catalina-release-Rhb27Phbauto.macQAT'
elif target == "brewAHW":
dirQAT["brewAHW"] = 'qt5Brew.build.macos-Catalina-release-RsysPhbauto.macQAT'
return dirQAT
p.add_option( '--makedmg', #------------------------------------------------------------------------------
dest='makedmg', ## To get the build option dictionary for making/cleaning DMG
help='make DMG' ) #
# @param[in] targetDic build target dictionary
# @param[in] srlDMG serial number of DMG
# @param[in] makeflag True to make; False to clean
#
# @return a dictionary; key=mnemonic, value=build option list
#------------------------------------------------------------------------------
def Get_Package_Options( targetDic, srlDMG, makeflag ):
if makeflag:
flag = '-m'
else:
flag = '-c'
p.add_option( '--cleandmg', packOp = dict()
dest='cleandmg', for key in targetDic.keys():
help='clean DMG' ) target = targetDic[key]
if target == "std":
packOp["std"] = [ '-p', 'ST-qt5Brew.pkg.macos-Catalina-release-RsysPsys', '-s', '%d' % srlDMG, '%s' % flag ]
elif target == "ports":
packOp["ports"] = [ '-p', 'LW-qt5MP.pkg.macos-Catalina-release-Rmp27Pmp38', '-s', '%d' % srlDMG, '%s' % flag ]
elif target == "brew":
packOp["brew"] = [ '-p', 'LW-qt5Brew.pkg.macos-Catalina-release-Rhb27Phb38', '-s', '%d' % srlDMG, '%s' % flag ]
elif target == "brewHW":
packOp["brewHW"] = [ '-p', 'HW-qt5Brew.pkg.macos-Catalina-release-RsysPhb38', '-s', '%d' % srlDMG, '%s' % flag ]
elif target == "ana3":
packOp["ana3"] = [ '-p', 'LW-qt5Ana3.pkg.macos-Catalina-release-Rana3Pana3', '-s', '%d' % srlDMG, '%s' % flag ]
elif target == "brewA":
packOp["brewA"] = [ '-p', 'LW-qt5Brew.pkg.macos-Catalina-release-Rhb27Phbauto', '-s', '%d' % srlDMG, '%s' % flag ]
elif target == "brewAHW":
packOp["brewAHW"] = [ '-p', 'HW-qt5Brew.pkg.macos-Catalina-release-RsysPhbauto', '-s', '%d' % srlDMG, '%s' % flag ]
return packOp
p.add_option( '--upload', #------------------------------------------------------------------------------
dest='upload', ## To parse the command line arguments
help='upload to Dropbox' ) #------------------------------------------------------------------------------
def Parse_CommandLine_Arguments():
global Usage # usage
global Target # target list
global Build # operation flag
global QATest # operation flag
global QACheck # operation flag
global MakeDMG # operation flag
global CleanDMG # operation flag
global Upload # operation flag
global SrlDMG # DMG serial number
global Dropbox # Dropbox directory
p.add_option( '-?', '--??', Usage = "\n"
action='store_true', Usage += "--------------------------------------------------------------------------------------------\n"
dest='checkusage', Usage += " nightyCatalina.py [EXPERIMENTAL] \n"
default=False, Usage += " << To execute the jobs for making KLatyout's DMGs for macOS Catalina >> \n"
help='check usage (false)' ) Usage += "\n"
Usage += "$ [python] nightyCatalina.py \n"
Usage += " option & argument : comment on option if any | default value\n"
Usage += " ------------------------------------------------------------------------+--------------\n"
Usage += " [--target <list>] : 0='std', 1='ports', 2='brew', 3='brewHW', 4='ana3', | '0,1,2,3,4'\n"
Usage += " 5='brewA', 6='brewAHW' | \n"
Usage += " [--build] : build and deploy | disabled\n"
Usage += " [--test] : run the QA Test | disabled\n"
Usage += " [--check] : check the QA Test results | disabled\n"
Usage += " [--makedmg|--cleandmg <srlno>] : make or clean DMGs | disabled\n"
Usage += " [--upload <dropbox>] : upload DMGs to $HOME/Dropbox/klayout/<dropbox> | disabled\n"
Usage += " [-?|--?] : print this usage and exit | disabled\n"
Usage += " | \n"
Usage += " Standard sequence for using this script: | \n"
Usage += " (1) $ ./nightyCatalina.py --build | \n"
Usage += " (2) (confirm the build results) | \n"
Usage += " (3) $ ./nightyCatalina.py --test | \n"
Usage += " (4) $ ./nightyCatalina.py --check (confirm the QA Test results) | \n"
Usage += " (5) $ ./nightyCatalina.py --makedmg 1 | \n"
Usage += " (6) $ ./nightyCatalina.py --upload '0.26.9' | \n"
Usage += " (7) $ ./nightyCatalina.py --cleandmg 1 | \n"
Usage += "---------------------------------------------------------------------------+----------------\n"
p.set_defaults( build = False, p = optparse.OptionParser( usage=Usage )
makedmg = "", p.add_option( '--target',
cleandmg = "", dest='targets',
upload = "", help='build target list' )
checkusage = False )
opt, args = p.parse_args() p.add_option( '--build',
if opt.checkusage: action='store_true',
print(Usage) dest='build',
quit() default=False,
help='build and deploy' )
Build = False p.add_option( '--test',
MakeDMG = False action='store_true',
CleanDMG = False dest='qa_test',
Upload = False default=False,
help='run the QA Test' )
Build = opt.build p.add_option( '--check',
action='store_true',
dest='qa_check',
default=False,
help='check the QA Test results' )
if not opt.makedmg == "": p.add_option( '--makedmg',
MakeDMG = True dest='makedmg',
CleanDMG = False help='make DMG' )
SrlDMG = int(opt.makedmg)
if not opt.cleandmg == "": p.add_option( '--cleandmg',
dest='cleandmg',
help='clean DMG' )
p.add_option( '--upload',
dest='upload',
help='upload to Dropbox' )
p.add_option( '-?', '--??',
action='store_true',
dest='checkusage',
default=False,
help='check usage' )
p.set_defaults( targets = "0,1,2,3,4",
build = False,
qa_test = False,
qa_check = False,
makedmg = "",
cleandmg = "",
upload = "",
checkusage = False )
opt, args = p.parse_args()
if opt.checkusage:
print(Usage)
quit()
targetDic = Get_Build_Target_Dict()
Target = list()
for idx in sorted( list( set( [ int(item) for item in opt.targets.split(",") ] ) ) ):
if idx in range(0, 7):
Target.append( targetDic[idx] )
Build = opt.build
QATest = opt.qa_test
QACheck = opt.qa_check
MakeDMG = False MakeDMG = False
CleanDMG = True CleanDMG = False
SrlDMG = int(opt.cleandmg) Upload = False
if not opt.upload == "": if not opt.makedmg == "":
Upload = True MakeDMG = True
Dropbox = opt.upload SrlDMG = int(opt.makedmg)
if not (Build or MakeDMG or CleanDMG or Upload): if not opt.cleandmg == "":
print( "! No option selected" ) CleanDMG = True
print(Usage) SrlDMG = int(opt.cleandmg)
quit()
if MakeDMG and CleanDMG:
print( "! --makedmg and --cleandmg cannot be used simultaneously" )
print(Usage)
quit()
def BuildDeploy(): if not opt.upload == "":
PyBuild = "./build4mac.py" Upload = True
Dropbox = opt.upload
Build = dict() if not (Build or QATest or QACheck or MakeDMG or CleanDMG or Upload):
Build["std"] = [ '-q', 'Qt5MacPorts', '-r', 'sys', '-p', 'sys' ] print( "! No option selected" )
Build["ports"] = [ '-q', 'Qt5MacPorts', '-r', 'MP26', '-p', 'MP37' ] print(Usage)
Build["brew"] = [ '-q', 'Qt5Brew', '-r', 'HB27', '-p', 'HB37' ] quit()
Build["ana3"] = [ '-q', 'Qt5Ana3', '-r', 'Ana3', '-p', 'Ana3' ]
for key in Variation: #------------------------------------------------------------------------------
command1 = [ PyBuild ] + Build[key] ## To build and deploy
if key == "std": #------------------------------------------------------------------------------
command2 = [ PyBuild ] + Build[key] + ['-y'] def Build_Deploy():
else: pyBuilder = "./build4mac.py"
command2 = [ PyBuild ] + Build[key] + ['-Y'] buildOp = Get_Build_Options( Get_Build_Target_Dict() )
print(command1)
print(command2)
#continue
if subprocess.call( command1, shell=False ) != 0: for key in Target:
print( "", file=sys.stderr ) command1 = [ pyBuilder ] + buildOp[key]
print( "-----------------------------------------------------------------", file=sys.stderr ) if key in [ "std", "brewHW", "brewAHW" ] :
print( "!!! <%s>: failed to build KLayout" % PyBuild, file=sys.stderr ) command2 = [ pyBuilder ] + buildOp[key] + ['-y']
print( "-----------------------------------------------------------------", file=sys.stderr ) else:
print( "", file=sys.stderr ) command2 = [ pyBuilder ] + buildOp[key] + ['-Y']
sys.exit(1) print(command1)
else: print(command2)
print( "", file=sys.stderr ) #continue
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "### <%s>: successfully built KLayout" % PyBuild, file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr )
if subprocess.call( command2, shell=False ) != 0: if subprocess.call( command1, shell=False ) != 0:
print( "", file=sys.stderr ) print( "", file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr ) print( "-----------------------------------------------------------------", file=sys.stderr )
print( "!!! <%s>: failed to deploy KLayout" % PyBuild, file=sys.stderr ) print( "!!! <%s>: failed to build KLayout" % pyBuilder, file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr ) print( "-----------------------------------------------------------------", file=sys.stderr )
print( "", file=sys.stderr ) print( "", file=sys.stderr )
sys.exit(1) sys.exit(1)
else: else:
print( "", file=sys.stderr ) print( "", file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr ) print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "### <%s>: successfully deployed KLayout" % PyBuild, file=sys.stderr ) print( "### <%s>: successfully built KLayout" % pyBuilder, file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr ) print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr ) print( "", file=sys.stderr )
if subprocess.call( command2, shell=False ) != 0:
print( "", file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr )
print( "!!! <%s>: failed to deploy KLayout" % pyBuilder, file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr )
print( "", file=sys.stderr )
sys.exit(1)
else:
print( "", file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "### <%s>: successfully deployed KLayout" % pyBuilder, file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr )
#------------------------------------------------------------------------------
## To run the QA tests
#
# @param[in] exclude test to exclude such as 'pymod,pya'
#------------------------------------------------------------------------------
def Run_QATest( exclude ):
pyRunnerQAT = "./macQAT.py"
dirQAT = Get_QAT_Directory( Get_Build_Target_Dict() )
for key in Target:
command1 = [ pyRunnerQAT ] + [ '--run', '--exclude', '%s' % exclude ]
print( dirQAT[key], command1 )
#continue
os.chdir( dirQAT[key] )
if subprocess.call( command1, shell=False ) != 0:
print( "", file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr )
print( "!!! <%s>: failed to run the QA Test" % pyRunnerQAT, file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr )
print( "", file=sys.stderr )
sys.exit(1)
else:
print( "", file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "### <%s>: successfully ran the QA Test" % pyRunnerQAT, file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr )
os.chdir( "../" )
#------------------------------------------------------------------------------
## To check the QA test results
#
# @param[in] lines number of lines to dump from the tail
#------------------------------------------------------------------------------
def Check_QATest_Results( lines ):
tailCommand = "/usr/bin/tail"
dirQAT = Get_QAT_Directory( Get_Build_Target_Dict() )
for key in Target:
os.chdir( dirQAT[key] )
logfile = glob.glob( "*.log" )
command1 = [ tailCommand ] + [ '-n', '%d' % lines ] + logfile
print( dirQAT[key], command1 )
#continue
if subprocess.call( command1, shell=False ) != 0:
print( "", file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr )
print( "!!! <%s>: failed to check the QA Test results" % tailCommand, file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr )
print( "", file=sys.stderr )
sys.exit(1)
else:
print( "", file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "### <%s>: successfully checked the QA Test results" % tailCommand, file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr )
os.chdir( "../" )
#------------------------------------------------------------------------------
## To make DMGs
#
# @param[in] srlDMG DMG's serial number
#------------------------------------------------------------------------------
def DMG_Make( srlDMG ): def DMG_Make( srlDMG ):
PyDMG = "./makeDMG4mac.py" pyDMGmaker = "./makeDMG4mac.py"
Stash = "./DMGStash" stashDMG = "./DMGStash"
packOp = Get_Package_Options( Get_Build_Target_Dict(), srlDMG, makeflag=True )
Pack = dict() if os.path.isdir( stashDMG ):
Pack["std"] = [ '-p', 'ST-qt5MP.pkg.macos-Catalina-release-RsysPsys', '-s', '%d' % srlDMG, '-m' ] shutil.rmtree( stashDMG )
Pack["ports"] = [ '-p', 'LW-qt5MP.pkg.macos-Catalina-release-Rmp26Pmp37', '-s', '%d' % srlDMG, '-m' ] os.mkdir( stashDMG )
Pack["brew"] = [ '-p', 'LW-qt5Brew.pkg.macos-Catalina-release-Rhb27Phb37', '-s', '%d' % srlDMG, '-m' ]
Pack["ana3"] = [ '-p', 'LW-qt5Ana3.pkg.macos-Catalina-release-Rana3Pana3', '-s', '%d' % srlDMG, '-m' ]
if os.path.isdir( Stash ): for key in Target:
shutil.rmtree( Stash ) command1 = [ pyDMGmaker ] + packOp[key]
os.mkdir( Stash ) print(command1)
#continue
for key in Variation: if subprocess.call( command1, shell=False ) != 0:
command3 = [ PyDMG ] + Pack[key] print( "", file=sys.stderr )
print(command3) print( "-----------------------------------------------------------------", file=sys.stderr )
#continue print( "!!! <%s>: failed to make KLayout DMG" % pyDMGmaker, file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr )
if subprocess.call( command3, shell=False ) != 0: print( "", file=sys.stderr )
print( "", file=sys.stderr ) sys.exit(1)
print( "-----------------------------------------------------------------", file=sys.stderr ) else:
print( "!!! <%s>: failed to make KLayout DMG" % PyDMG, file=sys.stderr ) print( "", file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr ) print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr ) print( "### <%s>: successfully made KLayout DMG" % pyDMGmaker, file=sys.stderr )
sys.exit(1) print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
else: print( "", file=sys.stderr )
print( "", file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "### <%s>: successfully made KLayout DMG" % PyDMG, file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr )
dmgs = glob.glob( "*.dmg*" )
for item in dmgs:
shutil.move( item, Stash )
dmgs = glob.glob( "*.dmg*" )
for item in dmgs:
shutil.move( item, stashDMG )
#------------------------------------------------------------------------------
## To clean up DMGs
#
# @param[in] srlDMG DMG's serial number
#------------------------------------------------------------------------------
def DMG_Clean( srlDMG ): def DMG_Clean( srlDMG ):
PyDMG = "./makeDMG4mac.py" pyDMGmaker = "./makeDMG4mac.py"
Stash = "./DMGStash" stashDMG = "./DMGStash"
packOp = Get_Package_Options( Get_Build_Target_Dict(), srlDMG, makeflag=False )
Pack = dict() if os.path.isdir( stashDMG ):
Pack["std"] = [ '-p', 'ST-qt5MP.pkg.macos-Catalina-release-RsysPsys', '-s', '%d' % srlDMG, '-c' ] shutil.rmtree( stashDMG )
Pack["ports"] = [ '-p', 'LW-qt5MP.pkg.macos-Catalina-release-Rmp26Pmp37', '-s', '%d' % srlDMG, '-c' ]
Pack["brew"] = [ '-p', 'LW-qt5Brew.pkg.macos-Catalina-release-Rhb27Phb37', '-s', '%d' % srlDMG, '-c' ]
Pack["ana3"] = [ '-p', 'LW-qt5Ana3.pkg.macos-Catalina-release-Rana3Pana3', '-s', '%d' % srlDMG, '-c' ]
if os.path.isdir( Stash ): for key in Target:
shutil.rmtree( Stash ) command1 = [ pyDMGmaker ] + packOp[key]
print(command1)
#continue
for key in Variation: if subprocess.call( command1, shell=False ) != 0:
command3 = [ PyDMG ] + Pack[key] print( "", file=sys.stderr )
print(command3) print( "-----------------------------------------------------------------", file=sys.stderr )
#continue print( "!!! <%s>: failed to clean KLayout DMG" % pyDMGmaker, file=sys.stderr )
print( "-----------------------------------------------------------------", file=sys.stderr )
print( "", file=sys.stderr )
sys.exit(1)
else:
print( "", file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "### <%s>: successfully cleaned KLayout DMG" % pyDMGmaker, file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr )
if subprocess.call( command3, shell=False ) != 0: #------------------------------------------------------------------------------
print( "", file=sys.stderr ) ## To upload DMGs to Dropbox
print( "-----------------------------------------------------------------", file=sys.stderr ) #
print( "!!! <%s>: failed to clean KLayout DMG" % PyDMG, file=sys.stderr ) # @param[in] targetdir existing target directory such as "0.26.9"
print( "-----------------------------------------------------------------", file=sys.stderr ) #------------------------------------------------------------------------------
print( "", file=sys.stderr ) def Upload_To_Dropbox( targetdir ):
sys.exit(1) stashDMG = "./DMGStash"
else:
print( "", file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "### <%s>: successfully cleaned KLayout DMG" % PyDMG, file=sys.stderr )
print( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", file=sys.stderr )
print( "", file=sys.stderr )
distDir = os.environ["HOME"] + "/Dropbox/klayout/" + targetdir
if not os.path.isdir(distDir):
os.makedirs(distDir)
def UploadToDropbox( targetdir ): dmgs = glob.glob( "%s/*.dmg*" % stashDMG )
Stash = "./DMGStash" for item in dmgs:
shutil.copy2( item, distDir )
distDir = os.environ["HOME"] + "/Dropbox/klayout/" + targetdir
if not os.path.isdir(distDir):
os.makedirs(distDir)
dmgs = glob.glob( "%s/*.dmg*" % Stash )
for item in dmgs:
shutil.copy2( item, distDir )
#------------------------------------------------------------------------------
## The main function
#------------------------------------------------------------------------------
def Main(): def Main():
ParseCommandLineArguments() Parse_CommandLine_Arguments()
if Build: if Build:
BuildDeploy() Build_Deploy()
elif MakeDMG: if QATest:
DMG_Make( SrlDMG ) Run_QATest( 'pymod,pya' )
elif CleanDMG: if QACheck:
DMG_Clean( SrlDMG ) Check_QATest_Results( 20 )
elif Upload: elif MakeDMG:
UploadToDropbox( Dropbox ) DMG_Make( SrlDMG )
elif Upload:
Upload_To_Dropbox( Dropbox )
elif CleanDMG:
DMG_Clean( SrlDMG )
#=================================================================================== #===================================================================================
if __name__ == "__main__": if __name__ == "__main__":
Main() Main()
#--------------- #---------------
# End of file # End of file