def _flock(fp):
		# The string representation of a PID should never be
		# bigger than 32 characters, not even on 64bit systems.
		# However, it should work even if it is, because all
		# FileLocks want to lock the same proportion of the
		# file, even though it might not be the whole file.
		locking(fp.fileno(), LK_LOCK, 32)

 def _remove_lock(self):
     if sys.platform == 'win32':
         import msvcrt
         msvcrt.locking(self._lock_file_descriptor, msvcrt.LK_UNLCK, 32)
     else:
         import fcntl
         fcntl.flock(self._lock_file_descriptor, fcntl.LOCK_UN)

 def _create_lock(self):
     if sys.platform == 'win32':
         import msvcrt
         msvcrt.locking(self._lock_file_descriptor, msvcrt.LK_NBLCK, 32)
     else:
         import fcntl
         fcntl.flock(self._lock_file_descriptor, fcntl.LOCK_EX | fcntl.LOCK_NB)

 def _remove_lock(self):
     if sys.platform in ('darwin', 'linux2', 'cygwin'):
         import fcntl
         fcntl.flock(self._lock_file_descriptor, fcntl.LOCK_UN)
     elif sys.platform == 'win32':
         import msvcrt
         msvcrt.locking(self._lock_file_descriptor, msvcrt.LK_UNLCK, 32)

    def __enter__(self):

        try:
            self.fd = os.open(self.name, os.O_WRONLY | os.O_CREAT | os.O_APPEND)
        except OSError as e:
            if e.errno == errno.ENOENT:
                raise LockFileCreationException(e)
            else:
                raise
        self.file = os.fdopen(self.fd, "w")
        if is_windows:
            lock_flags = msvcrt.LK_LOCK
        else:
            lock_flags = fcntl.LOCK_EX
        if self.fail_on_lock:
            if is_windows:
                lock_flags = msvcrt.LK_NBLCK
            else:
                lock_flags |= fcntl.LOCK_NB
        try:
            if is_windows:
                msvcrt.locking(self.file.fileno(), lock_flags, 1)
            else:
                fcntl.flock(self.file, lock_flags)
        except IOError as e:
            error_code = errno.EACCES if is_windows else errno.EAGAIN
            if e.errno == error_code:
                raise LockFileObtainException()
            raise

        return self.file

 def _lock_file_non_blocking(file_):
     try:
         msvcrt.locking(file_.fileno(), msvcrt.LK_NBLCK, 1)
         return True
     # TODO: check errno
     except IOError:
         return False

def unlock_file(fd):
	try:
		import msvcrt
		msvcrt.locking(fd, 0, 1024)
	except ImportError:
		pass
	os.close(fd)

 def _lock_windows(self):
     try:
         msvcrt.locking(self.fh, msvcrt.LK_LOCK, 1)
     except OSError:
         return False
     else:
         return True

 def _lock_file(self, name, f):
     import msvcrt
     for p in range(0,
                    min(self.sizes[name], MAXLOCKRANGE), MAXLOCKSIZE):
         f.seek(p)
         msvcrt.locking(f.fileno(), msvcrt.LK_LOCK,
                        min(MAXLOCKSIZE, self.sizes[name] - p))

        def do_acquire(self, waitflag=False):            
            if waitflag:
                sleep = 1
                locked = self.do_acquire(False)

                while not locked:
                    time.sleep(sleep)
                    sleep = min(sleep + 1, 15)
                    locked = self.do_acquire(False)
                return locked

            locked = False

            self.f = open(self.fn, 'a')
            try:
                msvcrt.locking(self.f.fileno(), msvcrt.LK_NBLCK, 1)
                try:
                    self.f.write(`os.getpid()` + '\n')  # informational only
                    self.f.seek(0)  # lock is at offset 0, so go back there
                    locked = True
                except:
                    self.do_release()
                    raise

            except IOError, x:
                if x.errno == errno.EACCES:
                    self.f.close()
                    del self.f
                else:
                    raise

	def _tryflock(fp):
		try:
			locking(fp.fileno(), LK_LOCK | LK_NBLCK, 32)
		except IOError:
			return False
		else:
			return True

def __release_lock(lock):
  if sys.platform == "win32":
    import msvcrt
    msvcrt.locking(lock.fileno(), msvcrt.LK_UNLCK, 1)
  else:
    import fcntl
    fcntl.flock(lock, fcntl.LOCK_UN)

 def _create_lock(self):
     if sys.platform.startswith('linux') or sys.platform in ('darwin', 'cygwin'):
         import fcntl
         fcntl.flock(self._lock_file_descriptor, fcntl.LOCK_EX | fcntl.LOCK_NB)
     elif sys.platform == 'win32':
         import msvcrt
         msvcrt.locking(self._lock_file_descriptor, msvcrt.LK_NBLCK, 32)

    def create_extension(self, code, force=False, name=None,
                         include_dirs=None,
                         library_dirs=None,
                         runtime_library_dirs=None,
                         extra_compile_args=None,
                         extra_link_args=None,
                         libraries=None,
                         compiler=None,
                         ):

        if Cython is None:
            raise ImportError('Cython is not available')

        code = deindent(code)

        lib_dir = os.path.expanduser('~/.brian/cython_extensions')
        try:
            os.makedirs(lib_dir)
        except OSError:
            if not os.path.exists(lib_dir):
                raise

        key = code, sys.version_info, sys.executable, Cython.__version__
            
        if force:
            # Force a new module name by adding the current time to the
            # key which is hashed to determine the module name.
            key += time.time(),            

        if key in self._code_cache:
            return self._code_cache[key]

        if name is not None:
            module_name = name#py3compat.unicode_to_str(args.name)
        else:
            module_name = "_cython_magic_" + hashlib.md5(str(key).encode('utf-8')).hexdigest()



        module_path = os.path.join(lib_dir, module_name + self.so_ext)

        if prefs['codegen.runtime.cython.multiprocess_safe']:
            lock_file = os.path.join(lib_dir, module_name + '.lock')
            with open(lock_file, 'w') as f:
                if msvcrt:
                    msvcrt.locking(f.fileno(), msvcrt.LK_RLCK,
                                   os.stat(lock_file).st_size)
                else:
                    fcntl.flock(f, fcntl.LOCK_EX)
                return self._load_module(module_path, include_dirs,
                                         library_dirs,
                                         extra_compile_args, extra_link_args,
                                         libraries, code, lib_dir, module_name,
                                         runtime_library_dirs, compiler, key)
        else:
            return self._load_module(module_path, include_dirs, library_dirs,
                                     extra_compile_args, extra_link_args,
                                     libraries, code, lib_dir, module_name,
                                     runtime_library_dirs, compiler, key)

 def lockf(fileno,mode):
     if mode & LOCK_UN:
         msvcrt.locking(fileno, msvcrt.LK_UNLCK, 0)
     if mode & _locks:
         msmode = _modes[mode & _locks]
         if msmode is None:
             raise AssertionError("Invalid lock flags", mode)
         msvcrt.locking(fileno, msmode, 0)

def unlock2(fd):
    if sys.platform == "win32":
        os.lseek(fd, 0, 0)  # make sure we're at the beginning
        msvcrt.locking(fd, msvcrt.LK_UNLCK, 10) # assuming first 10 bytes!
    else:
        fcntl.flock(fd, fcntl.LOCK_UN)

    return

def write():
    try:
        fd = open( ini_filename, "w" )
        msvcrt.locking( fd.fileno(), msvcrt.LK_LOCK, 1 )
        ini.write(fd)
        fd.close()
    except:
        pass

def __acquire_lock(lock):
  if sys.platform == "win32":
    import msvcrt
    # lock 1 byte: file is supposed to be zero-byte long
    msvcrt.locking(lock.fileno(), msvcrt.LK_LOCK, 1)
  else:
    import fcntl
    fcntl.flock(lock, fcntl.LOCK_EX)

    def release(self):
        import msvcrt  # @UnresolvedImport

        if self.fd is None:
            raise Exception("Lock was not acquired")
        msvcrt.locking(self.fd, msvcrt.LK_UNLCK, 1)
        os.close(self.fd)
        self.fd = None

 def unlock(file):
     """
     Unlock first 10 bytes of a file.
     """
     pos = file.tell() # remember current position
     file.seek(0)
     msvcrt.locking(file.fileno(),msvcrt.LK_UNLCK,10)
     file.seek(pos) # reset position