import dis

import os

import pickle

import re

import sys

contents.append(b',()')

# The function contents depends on the closure captured cell values.

#xxx = [_object_contents(x.cell_contents) for x in closure]

try:

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#

from __future__ import print_function

__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"

# test for pull request #150

env = self.TestEnvironment()

env._dict.pop('BUILDERS')

env2 = env.Clone()

def test_Copy(self):

"""

#

# __COPYRIGHT__

#

# The source file does not exist. Make sure no old

# copy remains in the variant directory.

if print_duplicate:

if exists_base(node) or node.islink():

node.fs.unlink(node.get_internal_path())

# Return None explicitly because the Base.exists() call

contents.append('%s %s\n' % (n.get_csig(), n.name))

return ''.join(contents)

if not node.rexists():

return ''

fname = node.rfile().get_abspath()

try:

contents = open(fname, "rb").read()

if not e.filename:

e.filename = fname

raise

for name in getattr(obj,'__slots__',()):

if hasattr(self, name):

state[name] = getattr(self, name)

state['_version_id'] = self.current_version_id

try:

del state['__weakref__']

except KeyError:

pass

return state

def __setstate__(self, state):

"""

Restore the attributes from a pickled state. The version is discarded.

"""

# TODO check or discard version

del state['_version_id']

for key, value in state.items():

if key not in ('__weakref__',):

setattr(self, key, value)

"""

state = other.__getstate__()

self.__setstate__(state)

def __getstate__(self):

"""

Return all fields that shall be pickled. Walk the slots in the class

class Attrs(object):

__slots__ = ('shared', '__dict__')

def __init__(self):

if SCons.Debug.track_instances: logInstanceCreation(self, 'Node.Node')

self._func_rexists = 1

self._func_get_contents = 0

self._func_target_from_source = 0

self.clear_memoized_values()

# Let the interface in which the build engine is embedded

def release_target_info(self):

"""Called just after this node has been marked

up-to-date or was built completely.

This is where we try to release as many target node infos

as possible for clean builds and update runs, in order

to minimize the overall memory consumption.

By purging attributes that aren't needed any longer after

a Node (=File) got built, we don't have to care that much how

many KBytes a Node actually requires...as long as we free

the memory shortly afterwards.

@see: built() and File.release_target_info()

"""

pass

node = nodes.pop(0)

scanner = node._get_scanner(env, initial_scanner, root_node_scanner, kw)

if not scanner:

continue

else:

# handle explicit scanner case

scanner = initial_scanner.select(self)

if not scanner:

# no scanner could be found for the given node's scanner key;

# thus, make an attempt at using a default.

scanner = root_node_scanner

return scanner

def get_env_scanner(self, env, kw={}):

return env.get_scanner(self.scanner_key())

any difference, but we now rely on checking every dependency

to make sure that any necessary Node information (for example,

the content signature of an #included .h file) is updated.

The allowcache option was added for supporting the early

release of the executor/builder structures, right after

a File target was built. When set to true, the return

value of this changed method gets cached for File nodes.

Like this, the executor isn't needed any longer for subsequent

calls to changed().

@see: FS.File.changed(), FS.File.release_target_info()

"""

t = 0

it goes here.

"""

unsupported_python_version = (2, 6, 0)

deprecated_python_version = (2, 7, 0)

for t in self._get_files_to_clean():

try:

removed = t.remove()

# An OSError may indicate something like a permissions

# issue, an IOError would indicate something like

# the file not existing. In either case, print a

# message and keep going to try to remove as many

# targets as possible.

else:

if removed:

display("Removed " + str(t))

"""

#

# __COPYRIGHT__

#

"""Return the locals and globals for the function that called

into this module in the current call stack."""

try: 1//0

# Don't start iterating with the current stack-frame to

# prevent creating reference cycles (f_back is safe).

frame = sys.exc_info()[2].tb_frame.f_back

selection method.

"""

import re

import os

import SCons.Tool

#MAYBE: from . import gnulink

def _lib_generator(target, source, env, for_signature, **kw):

try: cmd = kw['cmd']

Verbose = False

if Verbose:

try: vp = kw['varprefix']

except KeyError: vp = 'SHLIB'

no_import_lib = env.get('no_import_lib', 0)

if Verbose:

if not dll or len(target) > 1:

raise SCons.Errors.UserError("A shared library should have exactly one target with the suffix: %s" % env.subst("$%sSUFFIX" % vp))

dll.name = pre + dll.name[len(pre)+3:]

if Verbose:

orig_target = target

target = [env.fs.File(dll)]

target[0].attributes.shared = 1

if Verbose:

# Append an import lib target

if not no_import_lib:

'%sPREFIX' % vp, '%sSUFFIX' % vp,

'IMPLIBPREFIX', 'IMPLIBSUFFIX')

if Verbose:

implib_target = env.fs.File(target_strings)

if Verbose:

implib_target.attributes.shared = 1

target.append(implib_target)

implib_libtype=libtype,

generator_libtype=libtype+'ImpLib')

if Verbose:

if symlinks:

SCons.Tool.EmitLibSymlinks(env, symlinks, implib_target, clean_targets = target[0])

implib_target.attributes.shliblinks = symlinks

If suffix='.dll', and version='0.1.2', then it returns '-0-1-2.dll'"""

Verbose = False

if Verbose:

cygversion = re.sub('\.', '-', version)

if not suffix.startswith('-' + cygversion):

suffix = '-' + cygversion + suffix

if Verbose:

return suffix

def _versioned_implib_name(env, libnode, version, prefix, suffix, **kw):

Verbose = False

if Verbose:

try: libtype = kw['libtype']

except KeyError: libtype = 'ShLib'

linkdir = os.path.dirname(libnode.get_path())

if Verbose:

name = SCons.Tool.ImpLibNameGenerator(env, libnode,

implib_libtype=libtype,

generator_libtype=libtype+'ImpLib')

if Verbose:

major = version.split('.')[0]

symlinks = [(link0, libnode)]

if Verbose:

return symlinks

"""

#

# __COPYRIGHT__

#

import SCons.Defaults

import SCons.Tool

import SCons.Util

from SCons.Tool.FortranCommon import add_all_to_env, add_f08_to_env

compilers = ['f08']

# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

from __future__ import print_function

__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"

import hashlib

import ntpath

import os

import pickle

import re

import sys

# Returns a tuple of nodes.

def processIncludes(includes, env, target, source):

return SCons.PathList.PathList(includes).subst_path(env, target, source)

external_makefile_guid = '{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}'

Base class for .dsp.user file generator

'''

# Default instance values.

# build for a workspace user file. :-)

usrhead = None

usrconf = None

def __init__(self, dspfile, source, env):

# DebugSettings should be a list of debug dictionary sorted in the same order

if 'variant' not in env:

raise SCons.Errors.InternalError("You must specify a 'variant' argument (i.e. 'Debug' or " +\

"'Release') to create an MSVSProject.")

variants = [env['variant']]

elif SCons.Util.is_List(env['variant']):

variants = env['variant']

if 'DebugSettings' not in env or env['DebugSettings'] == None:

dbg_settings = []

elif SCons.Util.is_Dict(env['DebugSettings']):

dbg_settings.append({})

else:

dbg_settings = []

if len(dbg_settings) == 1:

dbg_settings = dbg_settings * len(variants)

self.createfile = self.usrhead and self.usrdebg and self.usrconf and \

if self.createfile:

dbg_settings = dict(zip(variants, dbg_settings))

for key in [k for k in self.usrdebg.keys() if k in src]:

trg[key] = str(src[key])

self.configs[var].debug = trg

def UserHeader(self):

encoding = self.env.subst('$MSVSENCODING')

versionstr = self.versionstr

self.usrfile.write(self.usrhead % locals())

def UserProject(self):

pass

def Build(self):

if not self.createfile:

return

try:

filename = self.dspabs +'.user'

self.usrfile = open(filename, 'w')

raise SCons.Errors.InternalError('Unable to open "' + filename + '" for writing:' + str(detail))

else:

self.UserHeader()

self.usrconf = V9UserConfiguration

self.usrdebg = V9DebugSettings

_UserGenerator.__init__(self, dspfile, source, env)

def UserProject(self):

confkeys = sorted(self.configs.keys())

for kind in confkeys:

platform = self.configs[kind].platform

debug = self.configs[kind].debug

if debug:

if value is not None])

self.usrfile.write(self.usrconf % locals())

self.usrfile.write('\t</Configurations>\n</VisualStudioUserFile>')

class _GenerateV10User(_UserGenerator):

"""Generates a Project'user file for MSVS 2010"""

def __init__(self, dspfile, source, env):

self.versionstr = '4.0'

self.usrhead = V10UserHeader

platform = self.configs[kind].platform

debug = self.configs[kind].debug

if debug:

if value is not None])

self.usrfile.write(self.usrconf % locals())

self.usrfile.write('</Project>')

runfile.append(s)

self.sconscript = env['MSVSSCONSCRIPT']

if 'cmdargs' not in env or env['cmdargs'] == None:

cmdargs = [''] * len(variants)

elif SCons.Util.is_String(env['cmdargs']):

raise SCons.Errors.InternalError("Sizes of 'cmdargs' and 'variant' lists must be the same.")

else:

cmdargs = env['cmdargs']

self.env = env

if 'name' in self.env:

CFG=%(name)s - Win32 %(confkey)s

!MESSAGE This is not a valid makefile. To build this project using NMAKE,

!MESSAGE use the Export Makefile command and run

!MESSAGE NMAKE /f "%(name)s.mak".

!MESSAGE You can specify a configuration when running NMAKE

!MESSAGE by defining the macro CFG on the command line. For example:

!MESSAGE NMAKE /f "%(name)s.mak" CFG="%(name)s - Win32 %(confkey)s"

!MESSAGE Possible choices for configuration are:

"""

class _GenerateV6DSP(_DSPGenerator):

self.dspheader = V7DSPHeader

self.dspconfiguration = V7DSPConfiguration

self.file = None

_GenerateV7User.__init__(self, dspfile, source, env)

def PrintHeader(self):

preprocdefs = xmlify(';'.join(processDefines(self.env.get('CPPDEFINES', []))))

includepath_Dirs = processIncludes(self.env.get('CPPPATH', []), self.env, None, None)

includepath = xmlify(';'.join([str(x) for x in includepath_Dirs]))

if not env_has_buildtarget:

del self.env['MSVSBUILDTARGET']

self.PrintHeader()

self.PrintProject()

self.file.close()

_GenerateV7User.Build(self)

V10DSPHeader = """\

self.dspheader = V10DSPHeader

self.dspconfiguration = V10DSPProjectConfiguration

self.dspglobals = V10DSPGlobals

_GenerateV10User.__init__(self, dspfile, source, env)

def PrintHeader(self):

'\t\t<SccLocalPath>%s</SccLocalPath>\n' % (scc_project_name, scc_local_path_legacy))

else:

self.dspglobals = self.dspglobals.replace('%(scc_attrs)s', '')

self.file.write(self.dspheader % locals())

self.file.write('\t<ItemGroup Label="ProjectConfigurations">\n')

confkeys = sorted(self.configs.keys())

for kind in confkeys:

variant = self.configs[kind].variant

platform = self.configs[kind].platform

self.file.write(self.dspconfiguration % locals())

self.file.write('\t</ItemGroup>\n')

self.file.write(self.dspglobals % locals())

def PrintProject(self):

name = self.name

confkeys = sorted(self.configs.keys())

self.file.write('\t<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\n')

toolset = ''

if 'MSVC_VERSION' in self.env:

version_num, suite = msvs_parse_version(self.env['MSVC_VERSION'])

self.file.write('\t<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\n')

self.file.write('\t<ImportGroup Label="ExtensionSettings">\n')

self.file.write('\t</ImportGroup>\n')

for kind in confkeys:

variant = self.configs[kind].variant

platform = self.configs[kind].platform

self.file.write(V10DSPImportGroupCondition % locals())

self.file.write('\t<PropertyGroup Label="UserMacros" />\n')

self.file.write('\t<PropertyGroup>\n')

self.file.write('\t<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\n')

for kind in confkeys:

variant = self.configs[kind].variant

platform = self.configs[kind].platform

buildtarget = self.configs[kind].buildtarget

runfile = self.configs[kind].runfile

cmdargs = self.configs[kind].cmdargs

env_has_buildtarget = 'MSVSBUILDTARGET' in self.env

if not env_has_buildtarget:

self.env['MSVSBUILDTARGET'] = buildtarget

del self.env['MSVSBUILDTARGET']

self.file.write(V10DSPCommandLine % locals())

self.file.write('\t</PropertyGroup>\n')

#filter settings in MSVS 2010 are stored in separate file

self.filtersabs = self.dspabs + '.filters'

try:

self.filters_file = open(self.filtersabs, 'w')

except IOError as detail:

raise SCons.Errors.InternalError('Unable to open "' + self.filtersabs + '" for writing:' + str(detail))

self.filters_file.write('<?xml version="1.0" encoding="utf-8"?>\n'

'<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\n')

self.PrintSourceFiles()

self.filters_file.write('</Project>')

self.filters_file.close()

self.file.write('\t<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\n'

'\t<ImportGroup Label="ExtensionTargets">\n'

'\t</ImportGroup>\n'

'</Project>\n')

if self.nokeep == 0:

# now we pickle some data and add it to the file -- MSDEV will ignore it.

pdata = pickle.dumps(self.configs,1)

def printFilters(self, hierarchy, name):

sorteditems = sorted(hierarchy.items(), key = lambda a: a[0].lower())

for key, value in sorteditems:

if SCons.Util.is_Dict(value):

filter_name = name + '\\' + key

'\t\t\t<UniqueIdentifier>%s</UniqueIdentifier>\n'

'\t\t</Filter>\n' % (filter_name, _generateGUID(self.dspabs, filter_name)))

self.printFilters(value, filter_name)

def printSources(self, hierarchy, kind, commonprefix, filter_name):

keywords = {'Source Files': 'ClCompile',

'Header Files': 'ClInclude',

'Local Headers': 'ClInclude',

'Resource Files': 'None',

'Other Files': 'None'}

sorteditems = sorted(hierarchy.items(), key = lambda a: a[0].lower())

# First folders, then files

if commonprefix:

file = os.path.join(commonprefix, value)

file = os.path.normpath(file)

self.file.write('\t\t<%s Include="%s" />\n' % (keywords[kind], file))

self.filters_file.write('\t\t<%s Include="%s">\n'

'\t\t\t<Filter>%s</Filter>\n'

'Local Headers': 'h;hpp;hxx;hm;inl',

'Resource Files': 'r;rc;ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe',

'Other Files': ''}

cats = sorted([k for k in categories.keys() if self.sources[k]],

key = lambda a: a.lower())

# print vcxproj.filters file first

self.filters_file.write('\t<ItemGroup>\n')

for kind in cats:

'\t\t\t<UniqueIdentifier>{7b42d31d-d53c-4868-8b92-ca2bc9fc052f}</UniqueIdentifier>\n'

'\t\t\t<Extensions>%s</Extensions>\n'

'\t\t</Filter>\n' % (kind, categories[kind]))

# First remove any common prefix

sources = self.sources[kind]

commonprefix = None

# +1 because the filename starts after the separator

sources = [s[len(cp)+1:] for s in sources]

commonprefix = cp

hierarchy = makeHierarchy(sources)

self.printFilters(hierarchy, kind)

self.filters_file.write('\t</ItemGroup>\n')

# then print files and filters

for kind in cats:

self.file.write('\t<ItemGroup>\n')

self.filters_file.write('\t<ItemGroup>\n')

# First remove any common prefix

sources = self.sources[kind]

commonprefix = None

# +1 because the filename starts after the separator

sources = [s[len(cp)+1:] for s in sources]

commonprefix = cp

hierarchy = makeHierarchy(sources)

self.printSources(hierarchy, kind, commonprefix, kind)

self.file.write('\t</ItemGroup>\n')

self.filters_file.write('\t</ItemGroup>\n')

# add the SConscript file outside of the groups

self.file.write('\t<ItemGroup>\n'

'\t\t<None Include="%s" />\n'

self.PrintHeader()

self.PrintProject()

self.file.close()

_GenerateV10User.Build(self)

class _DSWGenerator(object):

'SLN_RELATIVE_FOLDER_PATH': dsp_relative_folder_path,

'SLN_RELATIVE_FILE_PATH': dsp_relative_file_path}

self.dspfiles_info.append(dspfile_info)

self.dspfiles_info = []

GenerateProjectFilesInfo(self)

self.file.write('# Visual Studio 2008\n')

elif self.version_num >= 8.0:

self.file.write('# Visual Studio 2005\n')

for dspinfo in self.dspfiles_info:

name = dspinfo['NAME']

base, suffix = SCons.Util.splitext(name)

else:

env['MSVS']['PROJECTSUFFIX'] = '.vcxproj'

env['MSVS']['SOLUTIONSUFFIX'] = '.sln'

if (version_num >= 10.0):

env['MSVSENCODING'] = 'utf-8'

else:

selection method.

"""

#

# __COPYRIGHT__

out = pipe.stdout.read()

match = re.search(r'SWIG Version\s+(\S+).*', out, re.MULTILINE)

if match:

return match.group(1)

else:

def generate(env):

"""Add Builders and construction variables for swig to an Environment."""

else:

string_types = basestring,

integer_types = (int, long)

text_type = unicode

binary_type = str

Iterator = object

else:

def get_unbound_function(unbound):

def create_bound_method(func, obj):

return types.MethodType(func, obj, obj.__class__)

#

# __COPYRIGHT__

#

def test_import(self):

"""Test that six imports correctly."""

import sys

from SCons.compat.six import PY2, PY3

self.assertTrue(PY2 or PY3)

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#

__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"

import atexit

import TestUnit