785c6aa1cf
This is a pretty big diff because SourceMod had lots of multi-arch workarounds that can now go away. I've also changed 'x64' to 'x86_64' in many places since this is how AMBuild normalizes it, and it's far too late to pick the shorter string, so we might as well suck it up. The --target-archs parameter has been replaced with --targets. It works the same way. The default behavior for SDK inclusion is now "present" instead of "all" since this lowers the burden of storing many SDKs. Official builds will still be made with --sdks=all.
753 lines
26 KiB
Python
753 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'
|
|
|
|
not_found = []
|
|
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))
|
|
not_found.append(sdk_name)
|
|
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 SDKs were found that build on {0}-{1}, nothing to do.'.format(
|
|
builder.target.platform, builder.target.arch))
|
|
|
|
for sdk in not_found:
|
|
print('Warning: hl2sdk-{} was not found, and will not be included in build.'.format(sdk))
|
|
|
|
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(builder.target.arch))
|
|
|
|
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':
|
|
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, 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 += [
|
|
compiler.Dep(os.path.join(lib_folder, 'tier1.a')),
|
|
compiler.Dep(os.path.join(lib_folder, 'mathlib.a'))
|
|
]
|
|
else:
|
|
compiler.postlink += [
|
|
compiler.Dep(os.path.join(lib_folder, 'tier1_i486.a')),
|
|
compiler.Dep(os.path.join(lib_folder, 'mathlib_i486.a'))
|
|
]
|
|
|
|
if sdk.name in ['blade', 'insurgency', 'doi', 'csgo']:
|
|
if compiler.target.arch == 'x86_64':
|
|
compiler.postlink += [compiler.Dep(os.path.join(lib_folder, 'interfaces.a'))]
|
|
else:
|
|
compiler.postlink += [compiler.Dep(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(compiler.Dep(lib_path))
|
|
|
|
for library in dynamic_libs:
|
|
source_path = os.path.join(lib_folder, library)
|
|
output_path = os.path.join(binary.localFolder, library)
|
|
|
|
def make_linker(source_path, output_path):
|
|
def link(context, binary):
|
|
cmd_node, (output,) = context.AddSymlink(source_path, output_path)
|
|
return output
|
|
return link
|
|
|
|
linker = make_linker(source_path, output_path)
|
|
compiler.linkflags[0:0] = [compiler.Dep(library, linker)]
|
|
|
|
return binary
|
|
|
|
def HL2Library(self, context, compiler, name, sdk):
|
|
binary = self.Library(context, compiler, name)
|
|
self.ConfigureForExtension(context, binary.compiler)
|
|
return self.ConfigureForHL2(binary, sdk)
|
|
|
|
def HL2Config(self, project, 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(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(binary, sdk)
|
|
self.ConfigureForExtension(context, binary.compiler)
|
|
return binary
|
|
|
|
SM = SMConfig()
|
|
SM.detectProductVersion()
|
|
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
|
|
|
|
# Build SourcePawn externally.
|
|
SP = builder.Build('sourcepawn/AMBuildScript', {
|
|
'external_root': SPRoot(),
|
|
'external_amtl': os.path.join(builder.sourcePath, 'public', 'amtl'),
|
|
'external_build': ['core'],
|
|
})
|
|
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())
|
|
for cxx in SM.all_targets:
|
|
SM.spvm += [
|
|
SP.libsourcepawn[cxx.target.arch]
|
|
]
|
|
|
|
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/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/PackageScript',
|
|
]
|
|
|
|
builder.Build(BuildScripts, { 'SM': SM })
|
|
|
|
if builder.options.breakpad_dump:
|
|
builder.Build('tools/buildbot/BreakpadSymbols', { 'SM': SM })
|