845c20ad93
* Start using Github Actions Build on windows and linux. Cannot build for macos, since the builders only support xcode 10+ which dropped x86 support. * Build sourcepawn tooling as separate package Upload build artifacts containing only spcomp and the includes. This adds a new `--scripting-only` flag to configure.py which skips everything and goes straight to building spcomp and packaging the include folder with it. * Only run the workflows for the master branch * Split common operations into PackageHelpers file Don't duplicate the code for packaging releases for the tooling-only packages. Instead use a common `PackageHelpers` class which provides the functionality common to both packages. This replaces the explicit list of files to package with a directory scan, so we don't have to list them all. The pgsql sql-init-scripts were missing from the release package before, so they were added here as well. Three scripts from the testsuite were missing from the explicit list (mapdisplayname, floats, findmap), so they're now included. * Fix Python 2 compatibility os.scandir is Python 3 only.
766 lines
26 KiB
Python
766 lines
26 KiB
Python
# vim: set sts=2 ts=8 sw=2 tw=99 et ft=python:
|
|
import os, sys
|
|
import traceback
|
|
|
|
class SDK(object):
|
|
def __init__(self, sdk, ext, aDef, name, platform, dir):
|
|
self.folder = 'hl2sdk-' + dir
|
|
self.envvar = sdk
|
|
self.ext = ext
|
|
self.code = aDef
|
|
self.define = name
|
|
self.platform = platform
|
|
self.name = dir
|
|
self.path = None # Actual path
|
|
self.platformSpec = platform
|
|
|
|
# By default, nothing supports x64.
|
|
if type(platform) is list:
|
|
self.platformSpec = {p: ['x86'] for p in platform}
|
|
else:
|
|
self.platformSpec = platform
|
|
|
|
def shouldBuild(self, targets):
|
|
for cxx in targets:
|
|
if cxx.target.platform in self.platformSpec:
|
|
if cxx.target.arch in self.platformSpec[cxx.target.platform]:
|
|
return True
|
|
return False
|
|
|
|
WinOnly = ['windows']
|
|
WinLinux = ['windows', 'linux']
|
|
WinLinuxMac = ['windows', 'linux', 'mac']
|
|
CSGO = {
|
|
'windows': ['x86'],
|
|
'linux': ['x86', 'x86_64'],
|
|
'mac': ['x86_64']
|
|
}
|
|
|
|
PossibleSDKs = {
|
|
'episode1': SDK('HL2SDK', '2.ep1', '1', 'EPISODEONE', WinLinux, 'episode1'),
|
|
'ep2': SDK('HL2SDKOB', '2.ep2', '3', 'ORANGEBOX', WinLinux, 'orangebox'),
|
|
'css': SDK('HL2SDKCSS', '2.css', '6', 'CSS', WinLinuxMac, 'css'),
|
|
'hl2dm': SDK('HL2SDKHL2DM', '2.hl2dm', '7', 'HL2DM', WinLinuxMac, 'hl2dm'),
|
|
'dods': SDK('HL2SDKDODS', '2.dods', '8', 'DODS', WinLinuxMac, 'dods'),
|
|
'sdk2013': SDK('HL2SDK2013', '2.sdk2013', '9', 'SDK2013', WinLinuxMac, 'sdk2013'),
|
|
'tf2': SDK('HL2SDKTF2', '2.tf2', '11', 'TF2', WinLinuxMac, 'tf2'),
|
|
'l4d': SDK('HL2SDKL4D', '2.l4d', '12', 'LEFT4DEAD', WinLinuxMac, 'l4d'),
|
|
'nucleardawn': SDK('HL2SDKND', '2.nd', '13', 'NUCLEARDAWN', WinLinuxMac, 'nucleardawn'),
|
|
'l4d2': SDK('HL2SDKL4D2', '2.l4d2', '15', 'LEFT4DEAD2', WinLinuxMac, 'l4d2'),
|
|
'darkm': SDK('HL2SDK-DARKM', '2.darkm', '2', 'DARKMESSIAH', WinOnly, 'darkm'),
|
|
'swarm': SDK('HL2SDK-SWARM', '2.swarm', '16', 'ALIENSWARM', WinOnly, 'swarm'),
|
|
'bgt': SDK('HL2SDK-BGT', '2.bgt', '4', 'BLOODYGOODTIME', WinOnly, 'bgt'),
|
|
'eye': SDK('HL2SDK-EYE', '2.eye', '5', 'EYE', WinOnly, 'eye'),
|
|
'csgo': SDK('HL2SDKCSGO', '2.csgo', '21', 'CSGO', CSGO, 'csgo'),
|
|
'portal2': SDK('HL2SDKPORTAL2', '2.portal2', '17', 'PORTAL2', [], 'portal2'),
|
|
'blade': SDK('HL2SDKBLADE', '2.blade', '18', 'BLADE', WinOnly, 'blade'),
|
|
'insurgency': SDK('HL2SDKINSURGENCY', '2.insurgency', '19', 'INSURGENCY', WinLinuxMac, 'insurgency'),
|
|
'contagion': SDK('HL2SDKCONTAGION', '2.contagion', '14', 'CONTAGION', WinOnly, 'contagion'),
|
|
'bms': SDK('HL2SDKBMS', '2.bms', '10', 'BMS', WinLinux, 'bms'),
|
|
'doi': SDK('HL2SDKDOI', '2.doi', '20', 'DOI', WinLinuxMac, 'doi'),
|
|
}
|
|
|
|
def ResolveEnvPath(env, folder):
|
|
if env in os.environ:
|
|
path = os.environ[env]
|
|
if os.path.isdir(path):
|
|
return path
|
|
return None
|
|
|
|
head = os.getcwd()
|
|
oldhead = None
|
|
while head != None and head != oldhead:
|
|
path = os.path.join(head, folder)
|
|
if os.path.isdir(path):
|
|
return path
|
|
oldhead = head
|
|
head, tail = os.path.split(head)
|
|
|
|
return None
|
|
|
|
def Normalize(path):
|
|
return os.path.abspath(os.path.normpath(path))
|
|
|
|
def SetArchFlags(compiler):
|
|
if compiler.behavior == 'gcc':
|
|
if compiler.target.arch == 'x86_64':
|
|
compiler.cflags += ['-fPIC']
|
|
elif compiler.like('msvc'):
|
|
if compiler.target.arch == 'x86_64':
|
|
compiler.defines += ['WIN64']
|
|
|
|
class SMConfig(object):
|
|
def __init__(self):
|
|
self.sdks = {}
|
|
self.binaries = []
|
|
self.spvm = []
|
|
self.extensions = []
|
|
self.generated_headers = None
|
|
self.mms_root = None
|
|
self.mysql_root = {}
|
|
self.spcomp = None
|
|
self.spcomp_bins = None
|
|
self.smx_files = {}
|
|
self.versionlib = None
|
|
self.all_targets = []
|
|
self.target_archs = set()
|
|
|
|
|
|
if builder.options.targets:
|
|
target_archs = builder.options.targets.split(',')
|
|
else:
|
|
target_archs = ['x86']
|
|
if builder.backend != 'amb2':
|
|
target_archs.append('x86_64')
|
|
|
|
for arch in target_archs:
|
|
try:
|
|
cxx = builder.DetectCxx(target_arch = arch)
|
|
self.target_archs.add(cxx.target.arch)
|
|
except Exception as e:
|
|
# Error if archs were manually overridden.
|
|
if builder.options.targets:
|
|
raise
|
|
print('Skipping target {}: {}'.format(arch, e))
|
|
continue
|
|
self.all_targets.append(cxx)
|
|
|
|
if not self.all_targets:
|
|
raise Exception('No suitable C/C++ compiler was found.')
|
|
|
|
def use_auto_versioning(self):
|
|
if builder.backend != 'amb2':
|
|
return False
|
|
return not getattr(builder.options, 'disable_auto_versioning', False)
|
|
|
|
@property
|
|
def tag(self):
|
|
if builder.options.debug == '1':
|
|
return 'Debug'
|
|
return 'Release'
|
|
|
|
def detectProductVersion(self):
|
|
builder.AddConfigureFile('product.version')
|
|
|
|
# For OS X dylib versioning
|
|
import re
|
|
with open(os.path.join(builder.sourcePath, 'product.version'), 'r') as fp:
|
|
productContents = fp.read()
|
|
m = re.match('(\d+)\.(\d+)\.(\d+).*', productContents)
|
|
if m == None:
|
|
self.productVersion = '1.0.0'
|
|
else:
|
|
major, minor, release = m.groups()
|
|
self.productVersion = '{0}.{1}.{2}'.format(major, minor, release)
|
|
|
|
def detectSDKs(self):
|
|
sdk_list = builder.options.sdks.split(',')
|
|
use_none = sdk_list[0] == 'none'
|
|
use_all = sdk_list[0] == 'all'
|
|
use_present = sdk_list[0] == 'present'
|
|
|
|
for sdk_name in PossibleSDKs:
|
|
sdk = PossibleSDKs[sdk_name]
|
|
if sdk.shouldBuild(self.all_targets):
|
|
if builder.options.hl2sdk_root:
|
|
sdk_path = os.path.join(builder.options.hl2sdk_root, sdk.folder)
|
|
else:
|
|
sdk_path = ResolveEnvPath(sdk.envvar, sdk.folder)
|
|
if sdk_path is None or not os.path.isdir(sdk_path):
|
|
if use_all or sdk_name in sdk_list:
|
|
raise Exception('Could not find a valid path for {0}'.format(sdk.envvar))
|
|
continue
|
|
if use_all or use_present or sdk_name in sdk_list:
|
|
sdk.path = Normalize(sdk_path)
|
|
self.sdks[sdk_name] = sdk
|
|
|
|
if len(self.sdks) < 1 and len(sdk_list) and not use_none:
|
|
raise Exception('No applicable SDKs were found, nothing to do')
|
|
|
|
if builder.options.mms_path:
|
|
self.mms_root = builder.options.mms_path
|
|
else:
|
|
self.mms_root = ResolveEnvPath('MMSOURCE110', 'mmsource-1.10')
|
|
if not self.mms_root:
|
|
self.mms_root = ResolveEnvPath('MMSOURCE_DEV', 'metamod-source')
|
|
if not self.mms_root:
|
|
self.mms_root = ResolveEnvPath('MMSOURCE_DEV', 'mmsource-central')
|
|
|
|
if not self.mms_root or not os.path.isdir(self.mms_root):
|
|
raise Exception('Could not find a source copy of Metamod:Source')
|
|
self.mms_root = Normalize(self.mms_root)
|
|
|
|
if builder.options.hasMySql:
|
|
if 'x86' in self.target_archs:
|
|
if builder.options.mysql_path:
|
|
self.mysql_root['x86'] = builder.options.mysql_path
|
|
else:
|
|
for i in range(10):
|
|
self.mysql_root['x86'] = ResolveEnvPath('MYSQL55', 'mysql-5.' + str(i))
|
|
if self.mysql_root['x86']:
|
|
break
|
|
if not self.mysql_root['x86'] or not os.path.isdir(self.mysql_root['x86']):
|
|
raise Exception('Could not find a path to MySQL. Configure with --no-mysql to disable it.')
|
|
self.mysql_root['x86'] = Normalize(self.mysql_root['x86'])
|
|
|
|
if 'x86_64' in self.target_archs:
|
|
if builder.options.mysql64_path:
|
|
self.mysql_root['x86_64'] = builder.options.mysql64_path
|
|
else:
|
|
for i in range(10):
|
|
self.mysql_root['x86_64'] = ResolveEnvPath('MYSQL55_64', 'mysql-5.' + str(i) + '-x86_64')
|
|
if self.mysql_root['x86_64']:
|
|
break
|
|
if not self.mysql_root['x86_64'] or not os.path.isdir(self.mysql_root['x86_64']):
|
|
raise Exception('Could not find a path to 64-bit MySQL!')
|
|
self.mysql_root['x86_64'] = Normalize(self.mysql_root['x86_64'])
|
|
|
|
def configure(self):
|
|
builder.AddConfigureFile('pushbuild.txt')
|
|
|
|
if not set(self.target_archs).issubset(['x86', 'x86_64']):
|
|
raise Exception('Unknown target architecture: {0}'.format(self.target_archs))
|
|
|
|
for cxx in self.all_targets:
|
|
self.configure_cxx(cxx)
|
|
|
|
def configure_cxx(self, cxx):
|
|
if cxx.family == 'msvc':
|
|
if cxx.version < 1900:
|
|
raise Exception('Only MSVC 2015 and later are supported, c++14 support is required.')
|
|
if cxx.family == 'gcc':
|
|
if cxx.version < 'gcc-4.9':
|
|
raise Exception('Only GCC versions 4.9 or greater are supported, c++14 support is required.')
|
|
if cxx.family == 'clang':
|
|
if cxx.version < 'clang-3.4':
|
|
raise Exception('Only clang versions 3.4 or greater are supported, c++14 support is required.')
|
|
|
|
if cxx.like('gcc'):
|
|
self.configure_gcc(cxx)
|
|
elif cxx.family == 'msvc':
|
|
self.configure_msvc(cxx)
|
|
|
|
# Optimizaiton
|
|
if builder.options.opt == '1':
|
|
cxx.defines += ['NDEBUG']
|
|
|
|
# Debugging
|
|
if builder.options.debug == '1':
|
|
cxx.defines += ['DEBUG', '_DEBUG']
|
|
|
|
# Platform-specifics
|
|
if cxx.target.platform == 'linux':
|
|
self.configure_linux(cxx)
|
|
elif cxx.target.platform == 'mac':
|
|
self.configure_mac(cxx)
|
|
elif cxx.target.platform == 'windows':
|
|
self.configure_windows(cxx)
|
|
|
|
# Finish up.
|
|
cxx.defines += [
|
|
'SOURCEMOD_BUILD',
|
|
'SM_USE_VERSIONLIB',
|
|
]
|
|
cxx.includes += [
|
|
os.path.join(builder.sourcePath, 'public'),
|
|
]
|
|
if self.use_auto_versioning():
|
|
cxx.defines += ['SM_GENERATED_BUILD']
|
|
cxx.includes += [
|
|
os.path.join(builder.buildPath, 'includes'),
|
|
os.path.join(builder.sourcePath, 'versionlib'),
|
|
]
|
|
|
|
def configure_gcc(self, cxx):
|
|
cxx.defines += [
|
|
'stricmp=strcasecmp',
|
|
'_stricmp=strcasecmp',
|
|
'_snprintf=snprintf',
|
|
'_vsnprintf=vsnprintf',
|
|
'HAVE_STDINT_H',
|
|
'GNUC',
|
|
]
|
|
cxx.cflags += [
|
|
'-pipe',
|
|
'-fno-strict-aliasing',
|
|
'-Wall',
|
|
'-Werror',
|
|
'-Wno-unused',
|
|
'-Wno-switch',
|
|
'-Wno-array-bounds',
|
|
'-msse',
|
|
'-fvisibility=hidden',
|
|
]
|
|
|
|
if cxx.version == 'apple-clang-6.0' or cxx.version == 'clang-3.4':
|
|
cxx.cxxflags += ['-std=c++1y']
|
|
else:
|
|
cxx.cxxflags += ['-std=c++14']
|
|
|
|
cxx.cxxflags += [
|
|
'-fno-threadsafe-statics',
|
|
'-Wno-non-virtual-dtor',
|
|
'-Wno-overloaded-virtual',
|
|
'-fvisibility-inlines-hidden',
|
|
]
|
|
|
|
have_gcc = cxx.family == 'gcc'
|
|
have_clang = cxx.family == 'clang'
|
|
if cxx.version >= 'clang-3.9' or cxx.version == 'clang-3.4' or cxx.version > 'apple-clang-6.0':
|
|
cxx.cxxflags += ['-Wno-expansion-to-defined']
|
|
if cxx.version == 'clang-3.9' or cxx.version == 'apple-clang-8.0':
|
|
cxx.cflags += ['-Wno-varargs']
|
|
if cxx.version >= 'clang-3.4' or cxx.version >= 'apple-clang-7.0':
|
|
cxx.cxxflags += ['-Wno-inconsistent-missing-override']
|
|
if cxx.version >= 'clang-2.9' or cxx.version >= 'apple-clang-3.0':
|
|
cxx.cxxflags += ['-Wno-null-dereference']
|
|
if have_clang or (cxx.version >= 'gcc-4.6'):
|
|
cxx.cflags += ['-Wno-narrowing']
|
|
if have_clang or (cxx.version >= 'gcc-4.7'):
|
|
cxx.cxxflags += ['-Wno-delete-non-virtual-dtor']
|
|
if cxx.version >= 'gcc-4.8':
|
|
cxx.cflags += ['-Wno-unused-result']
|
|
if cxx.version >= 'gcc-9.0':
|
|
cxx.cxxflags += ['-Wno-class-memaccess', '-Wno-packed-not-aligned']
|
|
if have_clang:
|
|
cxx.cxxflags += ['-Wno-implicit-exception-spec-mismatch']
|
|
if cxx.version >= 'apple-clang-5.1' or cxx.version >= 'clang-3.4':
|
|
cxx.cxxflags += ['-Wno-deprecated-register']
|
|
else:
|
|
cxx.cxxflags += ['-Wno-deprecated']
|
|
cxx.cflags += ['-Wno-sometimes-uninitialized']
|
|
|
|
# Work around SDK warnings.
|
|
if cxx.version >= 'clang-10.0' or cxx.version >= 'apple-clang-12.0':
|
|
cxx.cflags += [
|
|
'-Wno-implicit-int-float-conversion',
|
|
'-Wno-tautological-overlap-compare',
|
|
]
|
|
|
|
if have_gcc:
|
|
cxx.cflags += ['-mfpmath=sse']
|
|
cxx.cflags += ['-Wno-maybe-uninitialized']
|
|
|
|
if builder.options.opt == '1':
|
|
cxx.cflags += ['-O3']
|
|
|
|
# Don't omit the frame pointer.
|
|
cxx.cflags += ['-fno-omit-frame-pointer']
|
|
|
|
def configure_msvc(self, cxx):
|
|
if builder.options.debug == '1':
|
|
cxx.cflags += ['/MTd']
|
|
cxx.linkflags += ['/NODEFAULTLIB:libcmt']
|
|
else:
|
|
cxx.cflags += ['/MT']
|
|
cxx.defines += [
|
|
'_CRT_SECURE_NO_DEPRECATE',
|
|
'_CRT_SECURE_NO_WARNINGS',
|
|
'_CRT_NONSTDC_NO_DEPRECATE',
|
|
'_ITERATOR_DEBUG_LEVEL=0',
|
|
]
|
|
cxx.cflags += [
|
|
'/W3',
|
|
]
|
|
cxx.cxxflags += [
|
|
'/EHsc',
|
|
'/GR-',
|
|
'/TP',
|
|
]
|
|
cxx.linkflags += [
|
|
'kernel32.lib',
|
|
'user32.lib',
|
|
'gdi32.lib',
|
|
'winspool.lib',
|
|
'comdlg32.lib',
|
|
'advapi32.lib',
|
|
'shell32.lib',
|
|
'ole32.lib',
|
|
'oleaut32.lib',
|
|
'uuid.lib',
|
|
'odbc32.lib',
|
|
'odbccp32.lib',
|
|
]
|
|
|
|
if builder.options.opt == '1':
|
|
cxx.cflags += ['/Ox', '/Zo']
|
|
cxx.linkflags += ['/OPT:ICF', '/OPT:REF']
|
|
|
|
if builder.options.debug == '1':
|
|
cxx.cflags += ['/Od', '/RTC1']
|
|
|
|
# This needs to be after our optimization flags which could otherwise disable it.
|
|
# Don't omit the frame pointer.
|
|
cxx.cflags += ['/Oy-']
|
|
|
|
def configure_linux(self, cxx):
|
|
cxx.defines += ['_LINUX', 'POSIX', '_FILE_OFFSET_BITS=64']
|
|
cxx.linkflags += ['-lm']
|
|
if cxx.family == 'gcc':
|
|
cxx.linkflags += ['-static-libgcc']
|
|
elif cxx.family == 'clang':
|
|
cxx.linkflags += ['-lgcc_eh']
|
|
cxx.linkflags += ['-static-libstdc++']
|
|
|
|
def configure_mac(self, cxx):
|
|
cxx.defines += ['OSX', '_OSX', 'POSIX', 'KE_ABSOLUTELY_NO_STL']
|
|
cxx.cflags += ['-mmacosx-version-min=10.7']
|
|
cxx.linkflags += [
|
|
'-mmacosx-version-min=10.7',
|
|
'-stdlib=libc++',
|
|
'-lc++',
|
|
]
|
|
cxx.cxxflags += ['-stdlib=libc++']
|
|
|
|
def configure_windows(self, cxx):
|
|
cxx.defines += ['WIN32', '_WINDOWS']
|
|
|
|
def add_libamtl(self):
|
|
# Add libamtl.
|
|
self.libamtl = {}
|
|
for cxx in self.all_targets:
|
|
def get_configure_fn(cxx):
|
|
return lambda builder, name: self.StaticLibrary(builder, cxx, name)
|
|
extra_vars = {'Configure': get_configure_fn(cxx)}
|
|
libamtl = builder.Build('public/amtl/amtl/AMBuilder', extra_vars)
|
|
self.libamtl[cxx.target.arch] = libamtl.binary
|
|
|
|
def AddVersioning(self, binary):
|
|
if binary.compiler.target.platform == 'windows':
|
|
binary.sources += ['version.rc']
|
|
binary.compiler.rcdefines += [
|
|
'BINARY_NAME="{0}"'.format(binary.outputFile),
|
|
'RC_COMPILE',
|
|
]
|
|
if self.use_auto_versioning():
|
|
binary.compiler.rcdefines += ['SM_GENERATED_BUILD']
|
|
elif binary.compiler.target.platform == 'mac':
|
|
if binary.type == 'library':
|
|
binary.compiler.postlink += [
|
|
'-compatibility_version', '1.0.0',
|
|
'-current_version', self.productVersion
|
|
]
|
|
if self.use_auto_versioning():
|
|
binary.compiler.linkflags += [self.versionlib[binary.compiler.target.arch]]
|
|
binary.compiler.sourcedeps += SM.generated_headers
|
|
return binary
|
|
|
|
def LibraryBuilder(self, compiler, name):
|
|
binary = compiler.Library(name)
|
|
self.AddVersioning(binary)
|
|
if binary.compiler.like('msvc'):
|
|
binary.compiler.linkflags += ['/SUBSYSTEM:WINDOWS']
|
|
return binary
|
|
|
|
def ProgramBuilder(self, compiler, name):
|
|
binary = compiler.Program(name)
|
|
self.AddVersioning(binary)
|
|
if '-static-libgcc' in binary.compiler.linkflags:
|
|
binary.compiler.linkflags.remove('-static-libgcc')
|
|
if '-lgcc_eh' in binary.compiler.linkflags:
|
|
binary.compiler.linkflags.remove('-lgcc_eh')
|
|
if binary.compiler.like('gcc'):
|
|
binary.compiler.linkflags += ['-lstdc++', '-lpthread']
|
|
if binary.compiler.like('msvc'):
|
|
binary.compiler.linkflags += ['/SUBSYSTEM:CONSOLE']
|
|
return binary
|
|
|
|
def StaticLibraryBuilder(self, compiler, name):
|
|
return compiler.StaticLibrary(name)
|
|
|
|
def Library(self, context, compiler, name):
|
|
compiler = compiler.clone()
|
|
SetArchFlags(compiler)
|
|
return self.LibraryBuilder(compiler, name)
|
|
|
|
def Program(self, context, compiler, name):
|
|
compiler = compiler.clone()
|
|
SetArchFlags(compiler)
|
|
return self.ProgramBuilder(compiler, name)
|
|
|
|
def StaticLibrary(self, context, compiler, name):
|
|
compiler = compiler.clone()
|
|
SetArchFlags(compiler)
|
|
return self.StaticLibraryBuilder(compiler, name)
|
|
|
|
def ConfigureForExtension(self, context, compiler):
|
|
compiler.cxxincludes += [
|
|
os.path.join(context.currentSourcePath),
|
|
os.path.join(context.currentSourcePath, 'sdk'),
|
|
os.path.join(builder.sourcePath, 'public', 'extensions'),
|
|
os.path.join(builder.sourcePath, 'sourcepawn', 'include'),
|
|
os.path.join(builder.sourcePath, 'public', 'amtl', 'amtl'),
|
|
os.path.join(builder.sourcePath, 'public', 'amtl'),
|
|
]
|
|
return compiler
|
|
|
|
def ExtLibrary(self, context, compiler, name):
|
|
binary = self.Library(context, compiler, name)
|
|
SetArchFlags(compiler)
|
|
self.ConfigureForExtension(context, binary.compiler)
|
|
return binary
|
|
|
|
def ConfigureForHL2(self, context, binary, sdk):
|
|
compiler = binary.compiler
|
|
SetArchFlags(compiler)
|
|
|
|
compiler.cxxincludes += [
|
|
os.path.join(self.mms_root, 'core'),
|
|
os.path.join(self.mms_root, 'core', 'sourcehook'),
|
|
]
|
|
|
|
defines = ['SE_' + PossibleSDKs[i].define + '=' + PossibleSDKs[i].code for i in PossibleSDKs]
|
|
compiler.defines += defines
|
|
|
|
paths = [
|
|
['public'],
|
|
['public', 'engine'],
|
|
['public', 'mathlib'],
|
|
['public', 'vstdlib'],
|
|
['public', 'tier0'],
|
|
['public', 'tier1']
|
|
]
|
|
if sdk.name == 'episode1' or sdk.name == 'darkm':
|
|
paths.append(['public', 'dlls'])
|
|
paths.append(['game_shared'])
|
|
else:
|
|
paths.append(['public', 'game', 'server'])
|
|
paths.append(['public', 'toolframework'])
|
|
paths.append(['game', 'shared'])
|
|
paths.append(['common'])
|
|
|
|
compiler.defines += ['SOURCE_ENGINE=' + sdk.code]
|
|
|
|
if sdk.name in ['sdk2013', 'bms'] and compiler.like('gcc'):
|
|
# The 2013 SDK already has these in public/tier0/basetypes.h
|
|
compiler.defines.remove('stricmp=strcasecmp')
|
|
compiler.defines.remove('_stricmp=strcasecmp')
|
|
compiler.defines.remove('_snprintf=snprintf')
|
|
compiler.defines.remove('_vsnprintf=vsnprintf')
|
|
|
|
if compiler.like('msvc'):
|
|
compiler.defines += ['COMPILER_MSVC']
|
|
if compiler.target.arch == 'x86':
|
|
compiler.defines += ['COMPILER_MSVC32']
|
|
elif compiler.target.arch == 'x86_64':
|
|
compiler.defines += ['COMPILER_MSVC64']
|
|
compiler.linkflags += ['legacy_stdio_definitions.lib']
|
|
else:
|
|
compiler.defines += ['COMPILER_GCC']
|
|
|
|
if compiler.target.arch == 'x86_64':
|
|
compiler.defines += ['X64BITS', 'PLATFORM_64BITS']
|
|
|
|
# For everything after Swarm, this needs to be defined for entity networking
|
|
# to work properly with sendprop value changes.
|
|
if sdk.name in ['blade', 'insurgency', 'doi', 'csgo']:
|
|
compiler.defines += ['NETWORK_VARS_ENABLED']
|
|
|
|
if sdk.name in ['css', 'hl2dm', 'dods', 'sdk2013', 'bms', 'tf2', 'l4d', 'nucleardawn', 'l4d2']:
|
|
if compiler.target.platform in ['linux', 'mac']:
|
|
compiler.defines += ['NO_HOOK_MALLOC', 'NO_MALLOC_OVERRIDE']
|
|
|
|
if compiler.target.platform == 'linux':
|
|
if sdk.name in ['csgo', 'blade']:
|
|
compiler.linkflags.remove('-static-libstdc++')
|
|
compiler.defines += ['_GLIBCXX_USE_CXX11_ABI=0']
|
|
|
|
for path in paths:
|
|
compiler.cxxincludes += [os.path.join(sdk.path, *path)]
|
|
|
|
if compiler.target.platform == 'linux':
|
|
if sdk.name == 'episode1':
|
|
lib_folder = os.path.join(sdk.path, 'linux_sdk')
|
|
elif sdk.name in ['sdk2013', 'bms']:
|
|
lib_folder = os.path.join(sdk.path, 'lib', 'public', 'linux32')
|
|
elif compiler.target.arch == 'x86_64':
|
|
lib_folder = os.path.join(sdk.path, 'lib', 'linux64')
|
|
else:
|
|
lib_folder = os.path.join(sdk.path, 'lib', 'linux')
|
|
elif compiler.target.platform == 'mac':
|
|
if sdk.name in ['sdk2013', 'bms']:
|
|
lib_folder = os.path.join(sdk.path, 'lib', 'public', 'osx32')
|
|
elif compiler.target.arch == 'x86_64':
|
|
lib_folder = os.path.join(sdk.path, 'lib', 'osx64')
|
|
else:
|
|
lib_folder = os.path.join(sdk.path, 'lib', 'mac')
|
|
|
|
if compiler.target.platform in ['linux', 'mac']:
|
|
if sdk.name in ['sdk2013', 'bms'] or compiler.target.arch == 'x86_64':
|
|
compiler.postlink += [
|
|
os.path.join(lib_folder, 'tier1.a'),
|
|
os.path.join(lib_folder, 'mathlib.a')
|
|
]
|
|
else:
|
|
compiler.postlink += [
|
|
os.path.join(lib_folder, 'tier1_i486.a'),
|
|
os.path.join(lib_folder, 'mathlib_i486.a')
|
|
]
|
|
|
|
if sdk.name in ['blade', 'insurgency', 'doi', 'csgo']:
|
|
if compiler.target.arch == 'x86_64':
|
|
compiler.postlink += [os.path.join(lib_folder, 'interfaces.a')]
|
|
else:
|
|
compiler.postlink += [os.path.join(lib_folder, 'interfaces_i486.a')]
|
|
|
|
dynamic_libs = []
|
|
if compiler.target.platform == 'linux':
|
|
if sdk.name in ['css', 'hl2dm', 'dods', 'tf2', 'sdk2013', 'bms', 'nucleardawn', 'l4d2', 'insurgency', 'doi']:
|
|
dynamic_libs = ['libtier0_srv.so', 'libvstdlib_srv.so']
|
|
elif compiler.target.arch == 'x86_64' and sdk.name in ['csgo', 'blade']:
|
|
dynamic_libs = ['libtier0_client.so', 'libvstdlib_client.so']
|
|
elif sdk.name in ['l4d', 'blade', 'insurgency', 'doi', 'csgo']:
|
|
dynamic_libs = ['libtier0.so', 'libvstdlib.so']
|
|
else:
|
|
dynamic_libs = ['tier0_i486.so', 'vstdlib_i486.so']
|
|
elif compiler.target.platform == 'mac':
|
|
compiler.linkflags.append('-liconv')
|
|
dynamic_libs = ['libtier0.dylib', 'libvstdlib.dylib']
|
|
elif compiler.target.platform == 'windows':
|
|
libs = ['tier0', 'tier1', 'vstdlib', 'mathlib']
|
|
if sdk.name in ['swarm', 'blade', 'insurgency', 'doi', 'csgo']:
|
|
libs.append('interfaces')
|
|
for lib in libs:
|
|
if compiler.target.arch == 'x86':
|
|
lib_path = os.path.join(sdk.path, 'lib', 'public', lib) + '.lib'
|
|
elif compiler.target.arch == 'x86_64':
|
|
lib_path = os.path.join(sdk.path, 'lib', 'public', 'win64', lib) + '.lib'
|
|
compiler.linkflags.append(lib_path)
|
|
|
|
for library in dynamic_libs:
|
|
source_path = os.path.join(lib_folder, library)
|
|
output_path = os.path.join(binary.localFolder, library)
|
|
|
|
# Ensure the output path exists.
|
|
context.AddFolder(binary.localFolder)
|
|
output = context.AddSymlink(source_path, output_path)
|
|
|
|
compiler.weaklinkdeps += [output]
|
|
compiler.linkflags[0:0] = [library]
|
|
|
|
return binary
|
|
|
|
def HL2Library(self, context, compiler, name, sdk):
|
|
binary = self.Library(context, compiler, name)
|
|
self.ConfigureForExtension(context, binary.compiler)
|
|
return self.ConfigureForHL2(context, binary, sdk)
|
|
|
|
def HL2Config(self, project, context, compiler, name, sdk):
|
|
binary = project.Configure(compiler, name,
|
|
'{0} - {1} {2}'.format(self.tag, sdk.name, compiler.target.arch))
|
|
self.AddVersioning(binary)
|
|
return self.ConfigureForHL2(context, binary, sdk)
|
|
|
|
def HL2ExtConfig(self, project, context, compiler, name, sdk):
|
|
binary = project.Configure(compiler, name,
|
|
'{0} - {1} {2}'.format(self.tag, sdk.name, compiler.target.arch))
|
|
self.AddVersioning(binary)
|
|
self.ConfigureForHL2(context, binary, sdk)
|
|
self.ConfigureForExtension(context, binary.compiler)
|
|
return binary
|
|
|
|
if getattr(builder, 'target', None) is not None:
|
|
sys.stderr.write("Your output folder was configured for AMBuild 2.1, and SourceMod is now\n")
|
|
sys.stderr.write("configured to use AMBuild 2.2. Please remove your output folder and\n")
|
|
sys.stderr.write("reconfigure to continue.\n")
|
|
os._exit(1)
|
|
|
|
SM = SMConfig()
|
|
SM.detectProductVersion()
|
|
if not getattr(builder.options, 'scripting_only', False):
|
|
SM.detectSDKs()
|
|
SM.configure()
|
|
SM.add_libamtl()
|
|
|
|
# This will clone the list and each cxx object as we recurse, preventing child
|
|
# scripts from messing up global state.
|
|
builder.targets = builder.CloneableList(SM.all_targets)
|
|
|
|
if SM.use_auto_versioning():
|
|
SM.generated_headers = builder.Build(
|
|
'tools/buildbot/Versioning',
|
|
{ 'SM': SM }
|
|
)
|
|
SM.versionlib = builder.Build(
|
|
'versionlib/AMBuilder',
|
|
{ 'SM': SM }
|
|
)
|
|
|
|
class SPRoot(object):
|
|
# SourcePawn's build scripts are always one-offs, and attach the current target
|
|
# to the builder, so we have to provide a shim to our StaticLibrary() method.
|
|
def StaticLibrary(self, builder, name):
|
|
return SM.StaticLibrary(builder, builder.cxx, name)
|
|
def Program(self, builder, name):
|
|
return SM.Program(builder, builder.cxx, name)
|
|
def Library(self, builder, name):
|
|
return SM.Library(builder, builder.cxx, name)
|
|
|
|
@property
|
|
def targets(self):
|
|
return SM.all_targets
|
|
|
|
@property
|
|
def libamtl(self):
|
|
return SM.libamtl
|
|
|
|
SP_build_parts = ['core']
|
|
if getattr(builder.options, 'scripting_only', False):
|
|
SP_build_parts = ['spcomp']
|
|
|
|
# Build SourcePawn externally.
|
|
SP = builder.Build('sourcepawn/AMBuildScript', {
|
|
'external_root': SPRoot(),
|
|
'external_amtl': os.path.join(builder.sourcePath, 'public', 'amtl'),
|
|
'external_build': SP_build_parts,
|
|
})
|
|
if len(SP.spcomp) > 1:
|
|
SM.spcomp = SP.spcomp['x86']
|
|
else:
|
|
SM.spcomp = SP.spcomp[list(SP.spcomp.keys())[0]]
|
|
SM.spcomp_bins = list(SP.spcomp.values())
|
|
|
|
if not getattr(builder.options, 'scripting_only', False):
|
|
for cxx in SM.all_targets:
|
|
SM.spvm += [
|
|
SP.libsourcepawn[cxx.target.arch]
|
|
]
|
|
|
|
if getattr(builder.options, 'scripting_only', False):
|
|
BuildScripts = [
|
|
'tools/buildbot/PackageHelpers',
|
|
'tools/buildbot/ToolsPackageScript',
|
|
]
|
|
else:
|
|
BuildScripts = [
|
|
'loader/AMBuilder',
|
|
'core/AMBuilder',
|
|
'core/logic/AMBuilder',
|
|
'extensions/bintools/AMBuilder',
|
|
'extensions/clientprefs/AMBuilder',
|
|
'extensions/curl/AMBuilder',
|
|
'extensions/cstrike/AMBuilder',
|
|
'extensions/geoip/AMBuilder',
|
|
'extensions/mysql/AMBuilder',
|
|
'extensions/pgsql/AMBuilder',
|
|
'extensions/regex/AMBuilder',
|
|
'extensions/sdkhooks/AMBuilder',
|
|
'extensions/sdktools/AMBuilder',
|
|
'extensions/sqlite/AMBuilder',
|
|
'extensions/tf2/AMBuilder',
|
|
'extensions/topmenus/AMBuilder',
|
|
'extensions/updater/AMBuilder',
|
|
]
|
|
|
|
if builder.backend == 'amb2':
|
|
BuildScripts += [
|
|
'plugins/AMBuilder',
|
|
'tools/buildbot/PackageHelpers',
|
|
'tools/buildbot/PackageScript',
|
|
]
|
|
|
|
builder.Build(BuildScripts, { 'SM': SM })
|
|
|
|
if builder.options.breakpad_dump:
|
|
builder.Build('tools/buildbot/BreakpadSymbols', { 'SM': SM })
|