$NON-NLS-1$ 
@callback
160228
function run(server, query) {
			if(server.options && typeof server.options.defs === 'object') {
				return server.options.defs;
			}
			return null;
		}
444247
function(bson, ns, cursorId, opts) {
  opts = opts || {};
  this.numberToReturn = opts.numberToReturn || 0;
  this.requestId = _requestId++;
  this.bson = bson;
  this.ns = ns;
  this.cursorId = cursorId;
}
7663
function callback (prefix, name, message) {
      if (!message) {
        return false;
      }
      count++;
      var msg  = errMsg(prefix, name, message);
      switch(action) {
      case 'show':
        console.log(msg);
        break;
      case 'hide':
        break;
      case 'throw':
      case 'copy':
        throw new Error(msg);
      }
      return true;
    }
784610
public static function noConstraints(Closure $callback)
    {
        $previous = static::$constraints;

        static::$constraints = false;

        // When resetting the relation where clause, we want to shift the first element
        // off of the bindings, leaving only the constraints that the developers put
        // as "extra" on the relationships, and not original relation constraints.
        try {
            return call_user_func($callback);
        } finally {
            static::$constraints = $previous;
        }
    }
599048
function key$2(n, callback) {
    var self = this;
    var promise = self.ready().then(function () {
        var dbInfo = self._dbInfo;
        var result;
        try {
            result = localStorage.key(n);
        } catch (error) {
            result = null;
        }

        // Remove the prefix from the key, if a key is found.
        if (result) {
            result = result.substring(dbInfo.keyPrefix.length);
        }

        return result;
    });

    executeCallback(promise, callback);
    return promise;
}
1171280
function(r, callback) {
      result = r || {};

      RunUtil.displayScriptData(grunt, result);
      RunUtil.displayScriptOutput(grunt, outputs, result);

      try {
        RunUtil.checkRunScriptResult(result, method);
      } catch(e) {
        CommonUtil.header(grunt, 'VALIDATION:', 'red');
        grunt.fail.fatal(e);
      }
      callback();
    }
936173
function normalize(args) {
  let result = {
    queries:  null,
    callback: null
  };

  if (args.length === 1 && Array.isArray(args[0])) {
    result.queries = args[0];
  } else if (args.length === 2 && Array.isArray(args[0])) {
    result.queries = args[0];

    if (typeof args[1] === 'function') {
      result.callback = args[1];
    }
  } else {
    result.queries = args;

    if (typeof result.queries[result.queries.length - 1] === 'function') {
      result.callback = result.queries.pop();
    }
  }

  return result;
}
394523
function (callback) {
        self.client.query(sql, function (err, result) {
          if (err) {
            if (err.indexOf('Couldn\'t find series: ') > -1)
              result = []; //allow this error to fly
            else
              return callback(err);
          }

          results.push(result);
          return callback(null);
        });
      }
610594
function parseResult(text, callback) {
  var errors = [], i = 0, l, errBlock, match, match2, lines;

  text = text.replace(/\r/g, '');
  lines = text.split('\n');

  match = skippingRegex.exec(lines[i]);
  if (match) {
    i++;
  }

  match = successRegex.exec(lines[i]);
  if (match) {
    callback(null, createParseSuccessObj(match));
    return;
  }

  for (l = lines.length; i < l; i++) {
    match = fileRegex.exec(lines[i]);
    if (match) {
      match2 = errorRegex.exec(lines[++i]);
      errBlock = createFailObj(match);
      for (var j = i; match2 && j < lines.length;) {
        errBlock.errors.push(createErrorObj(match2));
        match2 = errorRegex.exec(lines[++j]);
      }
      i = --j;
      errors.push(errBlock);
    } else {
      match = abstractRegex.exec(lines[i]);
      if (match) {
        callback(createErrorGJSLintFailed(match, errors));
        return;
      }
    }
  }
  callback(createParseErrorUnknown(lines));

}
928730
protected function normalizeCallback($callback)
	{
		// Normalize ['foo', 'bar'] to 'foo::bar'
		if (is_array($callback) && is_string($callback[0]))
		{
			$callback = $callback[0] . '::' . $callback[1];
		}

		// Normalize '\\foo' to 'foo' and '\\foo::bar' to 'foo::bar'
		if (is_string($callback))
		{
			$callback = ltrim($callback, '\\');
		}

		return $callback;
	}
1270724
function ttEach($els, fn) {
    $els.each(function() {
      var $input = $(this), typeahead;

      (typeahead = $input.data(keys.typeahead)) && fn(typeahead, $input);
    });
  }
1274777
function(callback) {
            // We have to check "failOnFirst" flag to make sure we did not
            // throw the error before.
            if (phpcsError && !options.failOnFirst) {
                this.emit('error', new gutil.PluginError(
                    'gulp-phpcs',
                    'PHP Code Sniffer failed on \n    ' + badFiles.join('\n    ')
                ));
            }

            callback();
        }
1162870
public static function assertNotCalled(
      FBMock_Mock $mock,
      $method_name,
      $msg='') {
    FBMock_Utils::assertString($method_name);
    self::assertNumCalls($mock, $method_name, 0, $msg);
  }
112992
function (callback) {
            async.map([ "tid.dat.gz", "tid_pos.dat.gz", "tid_map.dat.gz" ], function (filename, _callback) {
                loadArrayBuffer(path.join(dic_path, filename), function (err, buffer) {
                    if(err) {
                        return _callback(err);
                    }
                    _callback(null, buffer);
                });
            }, function (err, buffers) {
                if(err) {
                    return callback(err);
                }
                var token_info_buffer = new Uint8Array(buffers[0]);
                var pos_buffer = new Uint8Array(buffers[1]);
                var target_map_buffer = new Uint8Array(buffers[2]);

                dic.loadTokenInfoDictionaries(token_info_buffer, pos_buffer, target_map_buffer);
                callback(null);
            });
        }
636802
public static function noRender()
    {
        if (count(self::$execContexts)) {
            self::$execContexts[count(self::$execContexts) - 1]['render'] = false;
        }
    }
472791
function invalidArgs(src, dest, options, cb) {
  // get the callback so we can give the correct errors
  // when src or dest is missing
  if (typeof dest === 'function') cb = dest;
  if (typeof src === 'function') cb = src;
  if (typeof cb !== 'function') {
    throw new TypeError('expected callback to be a function');
  }
  if (typeof src !== 'string') {
    return cb(new TypeError('expected "src" to be a string'));
  }
  if (typeof dest !== 'string') {
    return cb(new TypeError('expected "dest" to be a string'));
  }
}
1258521
function(callback) {
            if(typeof opts !== "object") return callback();

            defOpts = Object.merge(defOpts, opts);
            for(var key in defOpts) {
                if(!defOpts.hasOwnProperty(key)) continue;
                switch(key) {
                case "mkdir": header.mkdir = defOpts.mkdir; break;
                case "md5": {
                    if(!md5) break;
                    if(typeof defOpts.md5 === "string" && 32 === defOpts.md5.length) {
                        header["content-md5"] = defOpts.md5;
                        break;
                    }
                    header["content-md5"] = md5(rawData);
                    break;
                }
                case "secret": header["content-secret"] = defOpts.secret; break;
                case "mime": header["content-type"] = defOpts.mime; break;
                default: break;
                }
            }

            callback();
        }