# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.

import wiredtiger, wttest
from wtdataset import SimpleDataSet, ComplexDataSet, simple_key, simple_value
from wtscenario import make_scenarios

# test_cursor_random.py
#    Cursor next_random operations

            

Reported by Pylint.

                      self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.compare(cursor), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.insert(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.prev(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.remove(), msg)
        self.assertRaisesWithMessage(

            

Reported by Pylint.

                      self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.insert(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.prev(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.remove(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.search(), msg)
        self.assertRaisesWithMessage(

            

Reported by Pylint.

                      self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.prev(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.remove(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.search(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.search_near(), msg)
        self.assertRaisesWithMessage(

            

Reported by Pylint.

                      self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.remove(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.search(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.search_near(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.update(), msg)


            

Reported by Pylint.

                      self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.search(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.search_near(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.update(), msg)

        self.assertTrue(cursor.next(), wiredtiger.WT_NOTFOUND)
        self.assertEquals(cursor.reconfigure(), 0)

            

Reported by Pylint.

                      self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.search_near(), msg)
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError, lambda: cursor.update(), msg)

        self.assertTrue(cursor.next(), wiredtiger.WT_NOTFOUND)
        self.assertEquals(cursor.reconfigure(), 0)
        self.assertEquals(cursor.reset(), 0)
        cursor.close()

            

Reported by Pylint.

                          wiredtiger.WiredTigerError, lambda: cursor.update(), msg)

        self.assertTrue(cursor.next(), wiredtiger.WT_NOTFOUND)
        self.assertEquals(cursor.reconfigure(), 0)
        self.assertEquals(cursor.reset(), 0)
        cursor.close()

    # Check that next_random fails with an empty tree, repeatedly.
    def test_cursor_random_empty(self):

            

Reported by Pylint.

              
        self.assertTrue(cursor.next(), wiredtiger.WT_NOTFOUND)
        self.assertEquals(cursor.reconfigure(), 0)
        self.assertEquals(cursor.reset(), 0)
        cursor.close()

    # Check that next_random fails with an empty tree, repeatedly.
    def test_cursor_random_empty(self):
        uri = self.type

            

Reported by Pylint.

                      uri = self.type
        self.session.create(uri, 'key_format=S,value_format=S')
        cursor = self.session.open_cursor(uri, None, self.config)
        for i in range(1,5):
            self.assertTrue(cursor.next(), wiredtiger.WT_NOTFOUND)
        cursor.close

    # Check that next_random works with a single value, repeatedly.
    def test_cursor_random_single_record(self):

            

Reported by Pylint.

                  load_tests_apply_scenarios,
    multiply_scenarios,
    )
import testtools
from testtools.tests.helpers import LoggingResult


class TestGenerateScenarios(testtools.TestCase):


            

Reported by Pylint.

                  multiply_scenarios,
    )
import testtools
from testtools.tests.helpers import LoggingResult


class TestGenerateScenarios(testtools.TestCase):

    def hook_apply_scenarios(self):

            

Reported by Pylint.

                  multiply_scenarios,
    )
import testtools
from testtools.tests.helpers import LoggingResult


class TestGenerateScenarios(testtools.TestCase):

    def hook_apply_scenarios(self):

            

Reported by Pylint.

                                  does nothing but pass unconditionally.

                    """
                pass

        self.ReferenceTest = ReferenceTest

    def test_sets_specified_id(self):
        raw_test = self.ReferenceTest('test_pass')

            

Reported by Pylint.

              
    def test_sets_specified_id(self):
        raw_test = self.ReferenceTest('test_pass')
        raw_id = "testscenarios.tests.test_scenarios.ReferenceTest.test_pass"
        scenario_name = self.scenario_name
        expect_id = "%(raw_id)s(%(scenario_name)s)" % vars()
        modified_test = apply_scenario(self.scenario, raw_test)
        self.assertEqual(expect_id, modified_test.id())


            

Reported by Pylint.

                  def test_sets_specified_id(self):
        raw_test = self.ReferenceTest('test_pass')
        raw_id = "testscenarios.tests.test_scenarios.ReferenceTest.test_pass"
        scenario_name = self.scenario_name
        expect_id = "%(raw_id)s(%(scenario_name)s)" % vars()
        modified_test = apply_scenario(self.scenario, raw_test)
        self.assertEqual(expect_id, modified_test.id())

    def test_sets_specified_attributes(self):

            

Reported by Pylint.

                      raw_test = self.ReferenceTest('test_pass_with_docstring')
        modified_test = apply_scenario(self.scenario, raw_test)
        raw_doc = self.ReferenceTest.test_pass_with_docstring.__doc__
        raw_desc = raw_doc.split("\n")[0].strip()
        scenario_name = self.scenario_name
        expect_desc = "%(raw_desc)s (%(scenario_name)s)" % vars()
        self.assertEqual(expect_desc, modified_test.shortDescription())

class TestApplyScenarios(testtools.TestCase):

            

Reported by Pylint.

                      modified_test = apply_scenario(self.scenario, raw_test)
        raw_doc = self.ReferenceTest.test_pass_with_docstring.__doc__
        raw_desc = raw_doc.split("\n")[0].strip()
        scenario_name = self.scenario_name
        expect_desc = "%(raw_desc)s (%(scenario_name)s)" % vars()
        self.assertEqual(expect_desc, modified_test.shortDescription())

class TestApplyScenarios(testtools.TestCase):


            

Reported by Pylint.

                          log.append((scenario, test))
        testscenarios.scenarios.apply_scenario = capture
        scenarios = ["foo", "bar"]
        result = list(apply_scenarios(scenarios, "test"))
        self.assertEqual([('foo', 'test'), ('bar', 'test')], log)

    def test_preserves_scenarios_attribute(self):
        class ReferenceTest(unittest.TestCase):
            scenarios = [('demo', {})]

            

Reported by Pylint.

              #  testscenarios: extensions to python unittest to allow declarative
#  dependency injection ('scenarios') by tests.
#
# Copyright (c) 2009, Robert Collins <robertc@robertcollins.net>
# Copyright (c) 2010, 2011 Martin Pool <mbp@sourcefrog.net>
# 
# Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
# license at the users choice. A copy of both licenses are available in the
# project source as Apache-2.0 and BSD. You may not use this file except in

            

Reported by Pylint.

              import SCons.Util
import SCons.Warnings

from .BoolVariable import BoolVariable  # okay
from .EnumVariable import EnumVariable  # okay
from .ListVariable import ListVariable  # naja
from .PackageVariable import PackageVariable # naja
from .PathVariable import PathVariable # okay


            

Reported by Pylint.

              import SCons.Warnings

from .BoolVariable import BoolVariable  # okay
from .EnumVariable import EnumVariable  # okay
from .ListVariable import ListVariable  # naja
from .PackageVariable import PackageVariable # naja
from .PathVariable import PathVariable # okay



            

Reported by Pylint.

              
from .BoolVariable import BoolVariable  # okay
from .EnumVariable import EnumVariable  # okay
from .ListVariable import ListVariable  # naja
from .PackageVariable import PackageVariable # naja
from .PathVariable import PathVariable # okay


class Variables(object):

            

Reported by Pylint.

              from .BoolVariable import BoolVariable  # okay
from .EnumVariable import EnumVariable  # okay
from .ListVariable import ListVariable  # naja
from .PackageVariable import PackageVariable # naja
from .PathVariable import PathVariable # okay


class Variables(object):
    instance=None

            

Reported by Pylint.

              from .EnumVariable import EnumVariable  # okay
from .ListVariable import ListVariable  # naja
from .PackageVariable import PackageVariable # naja
from .PathVariable import PathVariable # okay


class Variables(object):
    instance=None


            

Reported by Pylint.

              
        # create the singleton instance
        if is_global:
            self=Variables.instance

            if not Variables.instance:
                Variables.instance=self

    def _do_add(self, key, help="", default=None, validator=None, converter=None):

            

Reported by Pylint.

                          if not Variables.instance:
                Variables.instance=self

    def _do_add(self, key, help="", default=None, validator=None, converter=None):
        class Variable(object):
            pass

        option = Variable()


            

Reported by Pylint.

                      # if we get a list or a tuple, we take the first element as the
        # option key and store the remaining in aliases.
        if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
            option.key     = key[0]
            option.aliases = key[1:]
        else:
            option.key     = key
            option.aliases = [ key ]
        option.help = help

            

Reported by Pylint.

                      # option key and store the remaining in aliases.
        if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
            option.key     = key[0]
            option.aliases = key[1:]
        else:
            option.key     = key
            option.aliases = [ key ]
        option.help = help
        option.default = default

            

Reported by Pylint.

                          option.key     = key[0]
            option.aliases = key[1:]
        else:
            option.key     = key
            option.aliases = [ key ]
        option.help = help
        option.default = default
        option.validator = validator
        option.converter = converter

            

Reported by Pylint.

              import fnmatch, os, shutil, time
from wtscenario import make_scenarios
from suite_subprocess import suite_subprocess
import wiredtiger, wttest

# This test uses an artificially small log file limit, and creates
# large records so two fit into a log file. This allows us to test
# both the case when corruption happens at the beginning of a log file
# (an even number of records have been created), and when corruption

            

Reported by Pylint.

              
    # This function prunes out unnecessary or problematic test cases
    # from the list of scenarios.
    def includeFunc(name, dictarg):
        kind = dictarg['kind']
        corruptpos = dictarg['corruptpos']
        chkpt = dictarg['chkpt']

        # corruptpos == 0 indicates there is no corruption.

            

Reported by Pylint.

                      # Then does a restart with recovery, then starts again with salvage,
        # and finally starts again with recovery (adding new records).

        create_params = 'key_format=i,value_format=S'.format(self.key_format)
        self.session.create(self.uri, create_params)
        self.inserts([x for x in range(0, self.nrecords)])
        newdir = "RESTART"
        copy_for_crash_restart(self.home, newdir)
        self.close_conn()

            

Reported by Pylint.

              #   Transactions: test recovery with corrupted log files
#

import fnmatch, os, shutil, time
from wtscenario import make_scenarios
from suite_subprocess import suite_subprocess
import wiredtiger, wttest

# This test uses an artificially small log file limit, and creates

            

Reported by Pylint.

              #   Transactions: test recovery with corrupted log files
#

import fnmatch, os, shutil, time
from wtscenario import make_scenarios
from suite_subprocess import suite_subprocess
import wiredtiger, wttest

# This test uses an artificially small log file limit, and creates

            

Reported by Pylint.

                                'debug_mode=(corruption_abort=false),'
    conn_config = base_config
    corruption_type = [
        ('removal', dict(kind='removal', f=lambda fname:
            os.remove(fname))),
        ('truncate', dict(kind='truncate', f=lambda fname:
            corrupt(fname, True, 0, None))),
        ('truncate-middle', dict(kind='truncate-middle', f=lambda fname:
            corrupt(fname, True, 1024 * 25, None))),

            

Reported by Pylint.

                  def includeFunc(name, dictarg):
        kind = dictarg['kind']
        corruptpos = dictarg['corruptpos']
        chkpt = dictarg['chkpt']

        # corruptpos == 0 indicates there is no corruption.
        # (i.e. corrupt log file 0, which doesn't exist)
        # We do want to test the case of no corruption, but we don't
        # need to try it against every type of corruption, only one.

            

Reported by Pylint.

              
    # The type of corruption to be applied
    corruption_scenarios = [
        ('removal', dict(kind='removal', f=lambda fname:
            os.remove(fname))),
        ('truncate', dict(kind='truncate', f=lambda fname:
            corrupt(fname, True, 0, None))),
        ('truncate-middle', dict(kind='truncate-middle', f=lambda fname:
            corrupt(fname, True, 1024 * 25, None))),

            

Reported by Pylint.

                      key = self.kind + ':' + self.filename
        return key not in self.not_salvageable

    def run_wt_and_check(self, dir, expect_fail):
        if expect_fail:
            errmsg = '/WT_TRY_SALVAGE: database corruption detected/'
            if self.filename == 'WiredTigerHS.wt':
                if self.kind == 'removal':
                    errmsg = '/hs_exists/'

            

Reported by Pylint.

                              # messages produced during the error is variable by which case
                # it is, and even variable from system to system.
                self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                    lambda: self.reopen_conn(salvagedir, salvage_config),
                    '/.*/')

if __name__ == '__main__':
    wttest.run()

            

Reported by Pylint.

              # test_reserve.py
#       Reserve update tests.

import wiredtiger, wttest
from wtdataset import SimpleDataSet, SimpleIndexDataSet
from wtdataset import SimpleLSMDataSet, ComplexDataSet, ComplexLSMDataSet
from wtscenario import make_scenarios

# Test WT_CURSOR.reserve.

            

Reported by Pylint.

                      c = s.open_cursor(uri, None)

        # Repeatedly update a record.
        for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')
            c.set_key(ds.key(100))
            c.set_value(ds.value(100))
            self.assertEquals(c.update(), 0)
            s.commit_transaction()

            

Reported by Pylint.

                          s.begin_transaction('isolation=snapshot')
            c.set_key(ds.key(100))
            c.set_value(ds.value(100))
            self.assertEquals(c.update(), 0)
            s.commit_transaction()

        # Confirm reserve fails if the record doesn't exist.
        s.begin_transaction('isolation=snapshot')
        c.set_key(ds.key(600))

            

Reported by Pylint.

                      # Confirm reserve fails if the record doesn't exist.
        s.begin_transaction('isolation=snapshot')
        c.set_key(ds.key(600))
        self.assertRaises(wiredtiger.WiredTigerError, lambda:c.reserve())
        s.rollback_transaction()

        # Repeatedly reserve a record and commit.
        for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')

            

Reported by Pylint.

                      for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')
            c.set_key(ds.key(100))
            self.assertEquals(c.reserve(), 0)
            s.commit_transaction()

        # Repeatedly reserve a record and rollback.
        for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')

            

Reported by Pylint.

                      for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')
            c.set_key(ds.key(100))
            self.assertEquals(c.reserve(), 0)
            s.rollback_transaction()

        # Repeatedly reserve, then update, a record, and commit.
        for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')

            

Reported by Pylint.

                      for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')
            c.set_key(ds.key(100))
            self.assertEquals(c.reserve(), 0)
            c.set_value(ds.value(100))
            self.assertEquals(c.update(), 0)
            s.commit_transaction()

        # Repeatedly reserve, then update, a record, and rollback.

            

Reported by Pylint.

                          c.set_key(ds.key(100))
            self.assertEquals(c.reserve(), 0)
            c.set_value(ds.value(100))
            self.assertEquals(c.update(), 0)
            s.commit_transaction()

        # Repeatedly reserve, then update, a record, and rollback.
        for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')

            

Reported by Pylint.

                      for i in range(1, 5):
            s.begin_transaction('isolation=snapshot')
            c.set_key(ds.key(100))
            self.assertEquals(c.reserve(), 0)
            c.set_value(ds.value(100))
            self.assertEquals(c.update(), 0)
            s.commit_transaction()

        # Reserve a slot, repeatedly try and update a record from another

            

Reported by Pylint.

                          c.set_key(ds.key(100))
            self.assertEquals(c.reserve(), 0)
            c.set_value(ds.value(100))
            self.assertEquals(c.update(), 0)
            s.commit_transaction()

        # Reserve a slot, repeatedly try and update a record from another
        # transaction (which should fail), repeatedly update a record and
        # commit.

            

Reported by Pylint.

                              user_cconfig =
                  drealloc(user_cconfig, strlen(user_cconfig) + strlen(__wt_optarg) + 2);
                strcat(user_cconfig, ",");
                strcat(user_cconfig, __wt_optarg);
            }
            break;
        case 'h':
            free(wtperf->home);
            wtperf->home = dstrdup(__wt_optarg);

            

Reported by FlawFinder.

                              user_tconfig =
                  drealloc(user_tconfig, strlen(user_tconfig) + strlen(__wt_optarg) + 2);
                strcat(user_tconfig, ",");
                strcat(user_tconfig, __wt_optarg);
            }
            break;
        case '?':
            usage();
            goto einval;

            

Reported by FlawFinder.

                  uint64_t next_val, prev_val;
    int64_t rand_range, range;
    char *range_key_buf;
    char buf[512];
    int ret;

    wtperf = thread->wtperf;
    ret = 0;


            

Reported by FlawFinder.

                  uint8_t *op, *op_end;
    int measure_latency, nmodify, ret, truncated;
    char *key_buf, *value, *value_buf;
    char buf[512];

    thread = (WTPERF_THREAD *)arg;
    workload = thread->workload;
    wtperf = thread->wtperf;
    opts = wtperf->opts;

            

Reported by FlawFinder.

                  size_t buf_size;
    int msg_err;
    const char *str;
    char buf[64], *path;
    bool first;

    wtperf = (WTPERF *)arg;
    opts = wtperf->opts;
    assert(opts->sample_interval != 0);

            

Reported by FlawFinder.

                  len = strlen(wtperf->monitor_dir) + 100;
    path = dmalloc(len);
    testutil_check(__wt_snprintf(path, len, "%s/monitor", wtperf->monitor_dir));
    if ((fp = fopen(path, "w")) == NULL) {
        lprintf(wtperf, errno, 0, "%s", path);
        goto err;
    }
    testutil_check(__wt_snprintf(path, len, "%s/monitor.json", wtperf->monitor_dir));
    if ((jfp = fopen(path, "w")) == NULL) {

            

Reported by FlawFinder.

                      goto err;
    }
    testutil_check(__wt_snprintf(path, len, "%s/monitor.json", wtperf->monitor_dir));
    if ((jfp = fopen(path, "w")) == NULL) {
        lprintf(wtperf, errno, 0, "%s", path);
        goto err;
    }
    /* Set line buffering for monitor file. */
    __wt_stream_set_line_buffer(fp);

            

Reported by FlawFinder.

                          lprintf(wtperf, ret, 0, "find_table_count: cursor get_key failed");
            goto err;
        }
        table_icount = (uint32_t)atoi(key);
        if (table_icount > max_icount)
            max_icount = table_icount;

        if ((ret = cursor->close(cursor)) != 0) {
            lprintf(wtperf, ret, 0, "find_table_count: cursor close failed");

            

Reported by FlawFinder.

                  size_t i;
    int ret;
    uint32_t total_table_count;
    char buf[512];

    opts = wtperf->opts;

    if ((ret = wtperf->conn->open_session(wtperf->conn, NULL, opts->sess_config, &session)) != 0) {
        lprintf(wtperf, ret, 0, "Error opening a session on %s", wtperf->home);

            

Reported by FlawFinder.

                  if (src->workload_cnt != 0) {
        dest->workload_cnt = src->workload_cnt;
        dest->workload = dcalloc(src->workload_cnt, sizeof(WORKLOAD));
        memcpy(dest->workload, src->workload, src->workload_cnt * sizeof(WORKLOAD));
    }

    TAILQ_INIT(&dest->stone_head);

    dest->opts = src->opts;

            

Reported by FlawFinder.

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

import SCons
import os
import os.path as ospath
import subprocess
import shutil
import tarfile

            

Reported by Pylint.

                      [setattr(self, key, val) for (key, val) in list(kwargs.items())]

    def __str__(self):
        return self.name


class DistSrcArchive:
    def __init__(self, archive_type, archive_file, filename, mode):
        self.archive_type = archive_type

            

Reported by Pylint.

              #

import SCons
import os
import os.path as ospath
import subprocess
import shutil
import tarfile
import time

            

Reported by Pylint.

              
import SCons
import os
import os.path as ospath
import subprocess
import shutil
import tarfile
import time
import zipfile

            

Reported by Pylint.

              import SCons
import os
import os.path as ospath
import subprocess
import shutil
import tarfile
import time
import zipfile
import io

            

Reported by Pylint.

              import os
import os.path as ospath
import subprocess
import shutil
import tarfile
import time
import zipfile
import io


            

Reported by Pylint.

              
class DistSrcFile:
    def __init__(self, **kwargs):
        [setattr(self, key, val) for (key, val) in list(kwargs.items())]

    def __str__(self):
        return self.name



            

Reported by Pylint.

                      self,
        filename,
        file_contents,
        mtime=time.time(),
        mode=0o644,
        uname="root",
        gname="root",
    ):
        self.archive_file.writestr(filename, file_contents)

            

Reported by Pylint.

                      filename,
        file_contents,
        mtime=time.time(),
        mode=0o644,
        uname="root",
        gname="root",
    ):
        self.archive_file.writestr(filename, file_contents)


            

Reported by Pylint.

                      file_contents,
        mtime=time.time(),
        mode=0o644,
        uname="root",
        gname="root",
    ):
        self.archive_file.writestr(filename, file_contents)

    def append_file(self, filename, localfile):

            

Reported by Pylint.

                                          int32_t shift = instr->bits(11, 7);
                            if (shift == 0)
                                shift = 32;
                            rm_val >>= shift;
                            set_register(rd, (rn_val & 0xFFFF0000U) | (rm_val & 0xFFFF));
                        }
                    } else {
                        MOZ_CRASH();
                    }

            

Reported by Cppcheck.

                      return nullptr;
    }

    char* stopAtStr = getenv("ARM_SIM_STOP_AT");
    int64_t stopAt;
    if (stopAtStr && sscanf(stopAtStr, "%lld", &stopAt) == 1) {
        fprintf(stderr, "\nStopping simulation at icount %lld\n", stopAt);
        Simulator::StopSimAt = stopAt;
    }

            

Reported by FlawFinder.

              bool
SimulatorProcess::init()
{
    if (getenv("ARM_SIM_ICACHE_CHECKS"))
        ICacheCheckingDisableCount = 0;

    return icache_.init();
}


            

Reported by FlawFinder.

                            }
              case 7: { // BKPT
                fprintf(stderr, "Simulator hit BKPT.\n");
                if (getenv("ARM_SIM_DEBUGGER")) {
                    ArmDebugger dbg(this);
                    dbg.debug();
                } else {
                    fprintf(stderr, "Use ARM_SIM_DEBUGGER=1 to enter the builtin debugger.\n");
                    MOZ_CRASH("ARM simulator breakpoint");

            

Reported by FlawFinder.

                  }

  private:
    char data_[kPageSize];   // The cached data.
    static const int kValidityMapSize = kPageSize >> kLineShift;
    char validity_map_[kValidityMapSize];  // One byte per line.
};

// Protects the icache() and redirection() properties of the

            

Reported by FlawFinder.

                private:
    char data_[kPageSize];   // The cached data.
    static const int kValidityMapSize = kPageSize >> kLineShift;
    char validity_map_[kValidityMapSize];  // One byte per line.
};

// Protects the icache() and redirection() properties of the
// Simulator.
class AutoLockSimulatorCache : public LockGuard<Mutex>

            

Reported by FlawFinder.

              ReadLine(const char* prompt)
{
    char* result = nullptr;
    char line_buf[256];
    int offset = 0;
    bool keep_going = true;
    fprintf(stdout, "%s", prompt);
    fflush(stdout);
    while (keep_going) {

            

Reported by FlawFinder.

                              return nullptr;
            // Copy the existing input into the new array and set the new
            // array as the result.
            memcpy(new_result, result, offset * sizeof(char));
            js_free(result);
            result = new_result;
        }
        // Copy the newly read line into the result.
        memcpy(result + offset, line_buf, len * sizeof(char));

            

Reported by FlawFinder.

                          result = new_result;
        }
        // Copy the newly read line into the result.
        memcpy(result + offset, line_buf, len * sizeof(char));
        offset += len;
    }

    MOZ_ASSERT(result);
    result[offset] = '\0';

            

Reported by FlawFinder.

              #define STR(a) #a
#define XSTR(a) STR(a)

    char cmd[COMMAND_SIZE + 1];
    char arg1[ARG_SIZE + 1];
    char arg2[ARG_SIZE + 1];
    char* argv[3] = { cmd, arg1, arg2 };

    // Make sure to have a proper terminating character if reaching the limit.

            

Reported by FlawFinder.

              """SCons.Tool.FortranCommon

Stuff for processing Fortran, common to all fortran dialects.

"""

#
# Copyright (c) 2001 - 2019 The SCons Foundation
#

            

Reported by Pylint.

              #
from __future__ import print_function

__revision__ = "src/engine/SCons/Tool/FortranCommon.py bee7caf9defd6e108fc2998a2520ddb36a967691 2019-12-17 02:07:09 bdeegan"

import re
import os.path

import SCons.Action

            

Reported by Pylint.

                  if not source:
        # Source might be None for unusual cases like SConf.
        return 0
    for s in source:
        if s.sources:
            ext = os.path.splitext(str(s.sources[0]))[1]
            if ext in fsuffixes:
                return 1
    return 0

            

Reported by Pylint.

                              return 1
    return 0

def _fortranEmitter(target, source, env):
    node = source[0].rfile()
    if not node.exists() and not node.is_derived():
       print("Could not locate " + str(node.name))
       return ([], [])
    # This has to match the def_regex in the Fortran scanner

            

Reported by Pylint.

              def _fortranEmitter(target, source, env):
    node = source[0].rfile()
    if not node.exists() and not node.is_derived():
       print("Could not locate " + str(node.name))
       return ([], [])
    # This has to match the def_regex in the Fortran scanner
    mod_regex = r"""(?i)^\s*MODULE\s+(?!PROCEDURE|SUBROUTINE|FUNCTION|PURE|ELEMENTAL)(\w+)"""
    cre = re.compile(mod_regex,re.M)
    # Retrieve all USE'd module names

            

Reported by Pylint.

                  node = source[0].rfile()
    if not node.exists() and not node.is_derived():
       print("Could not locate " + str(node.name))
       return ([], [])
    # This has to match the def_regex in the Fortran scanner
    mod_regex = r"""(?i)^\s*MODULE\s+(?!PROCEDURE|SUBROUTINE|FUNCTION|PURE|ELEMENTAL)(\w+)"""
    cre = re.compile(mod_regex,re.M)
    # Retrieve all USE'd module names
    modules = cre.findall(node.get_text_contents())

            

Reported by Pylint.

                  suffix = env.subst('$FORTRANMODSUFFIX', target=target, source=source)
    moddir = env.subst('$FORTRANMODDIR', target=target, source=source)
    modules = [x.lower() + suffix for x in modules]
    for m in modules:
       target.append(env.fs.File(m, moddir))
    return (target, source)

def FortranEmitter(target, source, env):
    target, source = _fortranEmitter(target, source, env)

            

Reported by Pylint.

                  moddir = env.subst('$FORTRANMODDIR', target=target, source=source)
    modules = [x.lower() + suffix for x in modules]
    for m in modules:
       target.append(env.fs.File(m, moddir))
    return (target, source)

def FortranEmitter(target, source, env):
    target, source = _fortranEmitter(target, source, env)
    return SCons.Defaults.StaticObjectEmitter(target, source, env)

            

Reported by Pylint.

                     target.append(env.fs.File(m, moddir))
    return (target, source)

def FortranEmitter(target, source, env):
    target, source = _fortranEmitter(target, source, env)
    return SCons.Defaults.StaticObjectEmitter(target, source, env)

def ShFortranEmitter(target, source, env):
    target, source = _fortranEmitter(target, source, env)

            

Reported by Pylint.

                     target.append(env.fs.File(m, moddir))
    return (target, source)

def FortranEmitter(target, source, env):
    target, source = _fortranEmitter(target, source, env)
    return SCons.Defaults.StaticObjectEmitter(target, source, env)

def ShFortranEmitter(target, source, env):
    target, source = _fortranEmitter(target, source, env)

            

Reported by Pylint.

              # are part of the package. To create the distribution, in this directory, run
# "python setup_pip.py sdist", this creates a tar.gz file under ./dist .
from __future__ import print_function
import os, os.path, re, shutil, site, sys
from setuptools import setup, Distribution, Extension
import distutils.sysconfig
import distutils.ccompiler
import subprocess
from subprocess import call

            

Reported by Pylint.

              
# build_commands --
#   Run a sequence of commands, and die if any fail.
def build_commands(commands, build_dir, build_env):
    for command in commands:
        callargs = [ 'sh', '-c', command ]
        verbose_command = '"' + '" "'.join(callargs) + '"'
        print('running: ' + verbose_command)
        if call(callargs, cwd=build_dir, env=build_env) != 0:

            

Reported by Pylint.

              #   Make a quick check of any needed library dependencies, and
# add to the library path and include path as needed.  If a library
# is not found, it is not definitive.
def check_needed_dependencies(builtins, inc_paths, lib_paths):
    library_dirs = get_library_dirs()
    compiler = distutils.ccompiler.new_compiler()
    distutils.sysconfig.customize_compiler(compiler)
    compiler.set_library_dirs(library_dirs)
    missing = []

            

Reported by Pylint.

              #   Make a quick check of any needed library dependencies, and
# add to the library path and include path as needed.  If a library
# is not found, it is not definitive.
def check_needed_dependencies(builtins, inc_paths, lib_paths):
    library_dirs = get_library_dirs()
    compiler = distutils.ccompiler.new_compiler()
    distutils.sysconfig.customize_compiler(compiler)
    compiler.set_library_dirs(library_dirs)
    missing = []

            

Reported by Pylint.

              #   Make a quick check of any needed library dependencies, and
# add to the library path and include path as needed.  If a library
# is not found, it is not definitive.
def check_needed_dependencies(builtins, inc_paths, lib_paths):
    library_dirs = get_library_dirs()
    compiler = distutils.ccompiler.new_compiler()
    distutils.sysconfig.customize_compiler(compiler)
    compiler.set_library_dirs(library_dirs)
    missing = []

            

Reported by Pylint.

                          inc_paths.append(os.path.join(package_top, 'include'))
            lib_paths.append(os.path.join(package_top, 'lib'))

    # XXX: we are not accounting for other directories that might be
    # discoverable via /sbin/ldconfig. It might be better to write a tiny
    # compile using  -lsnappy, -lz...
    #
    #if len(missing) > 0:
    #    die("install packages for: " + str(missing))

            

Reported by Pylint.

              # get_compile_flags --
#   Get system specific compile flags.  Return a triple: C preprocessor
# flags, C compilation flags and linker flags.
def get_compile_flags(inc_paths, lib_paths):
    # Suppress warnings building SWIG generated code
    if sys.platform == 'win32':
        # Windows untested and incomplete, don't claim that it works.
        die('Windows is not supported by this setup script')
    else:

            

Reported by Pylint.

              # get_compile_flags --
#   Get system specific compile flags.  Return a triple: C preprocessor
# flags, C compilation flags and linker flags.
def get_compile_flags(inc_paths, lib_paths):
    # Suppress warnings building SWIG generated code
    if sys.platform == 'win32':
        # Windows untested and incomplete, don't claim that it works.
        die('Windows is not supported by this setup script')
    else:

            

Reported by Pylint.

                      # Windows untested and incomplete, don't claim that it works.
        die('Windows is not supported by this setup script')
    else:
        cflags = [ '-w', '-Wno-sign-conversion', '-std=c11' ]
        cppflags = ['-I' + path for path in inc_paths]
        cppflags.append('-DHAVE_CONFIG_H')
        ldflags = ['-L' + path for path in lib_paths]
        if sys.platform == 'darwin':
            cflags.extend([ '-arch', 'x86_64' ])

            

Reported by Pylint.

                      die('Windows is not supported by this setup script')
    else:
        cflags = [ '-w', '-Wno-sign-conversion', '-std=c11' ]
        cppflags = ['-I' + path for path in inc_paths]
        cppflags.append('-DHAVE_CONFIG_H')
        ldflags = ['-L' + path for path in lib_paths]
        if sys.platform == 'darwin':
            cflags.extend([ '-arch', 'x86_64' ])
    return (cppflags, cflags, ldflags)

            

Reported by Pylint.