Search some code: Max results:

Found 51045 results in 2168 files (78MB index data, 21345839 ngram matches, 6776 docs considered, 3238 docs (112MB) loaded, 998 docs skipped): for
(and substr:"class" substr:"needle") with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}
in 2.171339285s (queued: 2.078µs)

github.com/GoogleChrome/web-audio-samples:stress-test/boxes/third-party/prototype-1.6.0.2.js:[gh-pages, ]

41: var Class = {
2293:         'class': 'className',
56:       var subclass = function() { };
57:       subclass.prototype = parent.prototype;
1816:   classNames: function(element) {
2165:       className: 'class',
2625:   function findDOMClass(tagName) {
4187: Element.ClassNames.prototype = {
1820:   hasClassName: function(element, className) {
1827:   addClassName: function(element, className) {
1834:   removeClassName: function(element, className) {
1841:   toggleClassName: function(element, className) {
51:     Object.extend(klass, Class.Methods);
74: Class.Methods = {
286: var PeriodicalExecuter = Class.create({
552: var Template = Class.create({
988: var Hash = Class.create(Enumerable, (function() {
1083: var ObjectRange = Class.create(Enumerable, {
1157: Ajax.Base = Class.create({
1179: Ajax.Request = Class.create(Ajax.Base, {
1352: Ajax.Response = Class.create({
1426: Ajax.Updater = Class.create(Ajax.Request, {
1462: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1667:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2696: /* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
2700: var Selector = Class.create({
2846:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3146:       var needle = ' ' + className + ' ';
3150:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3634: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3651: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3657: Form.Observer = Class.create(Abstract.TimedObserver, {
3665: Abstract.EventObserver = Class.create({
3704: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3710: Form.EventObserver = Class.create(Abstract.EventObserver, {
4153:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4186: Element.ClassNames = Class.create();
52:     klass.superclass = parent;
58:       klass.prototype = new subclass;
76:     var ancestor   = this.superclass && this.superclass.prototype;
1817:     return new Element.ClassNames(element);
1822:     var elementClassName = element.className;
1823:     return (elementClassName.length > 0 && (elementClassName == className ||
1824:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1829:     if (!element.hasClassName(className))
1830:       element.className += (element.className ? ' ' : '') + className;
1836:     element.className = element.className.replace(
1837:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1843:     return element[element.hasClassName(className) ?
1844:       'removeClassName' : 'addClassName'](className);
2657:       var klass = findDOMClass(tag);
2940:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
2968:     className:    /^\.([\w\-\*]+)(\b|$)/,
2981:     className: function(element, matches) {
3139:     className: function(nodes, root, className, combinator) {
3141:       return Selector.handlers.byClassName(nodes, root, className);
3144:     byClassName: function(nodes, root, className) {
3148:         nodeClassName = node.className;
4157:   function(element, className) {
4158:     className = className.toString().strip();
4159:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4161:   } : function(element, className) {
4162:     className = className.toString().strip();
4163:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4164:     if (!classNames && !className) return elements;
4167:     className = ' ' + className + ' ';
4170:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4171:           (classNames && classNames.all(function(name) {
4179:   return function(className, parentElement) {
4180:     return $(parentElement || document.body).getElementsByClassName(className);
4193:     this.element.className.split(/\s+/).select(function(name) {
4198:   set: function(className) {
4199:     this.element.className = className;
4202:   add: function(classNameToAdd) {
4203:     if (this.include(classNameToAdd)) return;
4204:     this.set($A(this).concat(classNameToAdd).join(' '));
4207:   remove: function(classNameToRemove) {
4208:     if (!this.include(classNameToRemove)) return;
4209:     this.set($A(this).without(classNameToRemove).join(' '));
4217: Object.extend(Element.ClassNames.prototype, Enumerable);
53:     klass.subclasses = [];
59:       parent.subclasses.push(klass);
2982:       return Element.hasClassName(element, matches[1]);
3147:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3149:         if (nodeClassName.length == 0) continue;
4151: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4156:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/arc/arc:third_party/android/external/chromium_org__third_party_WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
44: var Class = {
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
2644:   function findDOMClass(tagName) {
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/external/Webkit:Websites/webkit.org/blog-files/prototype-for-gebcn-test.js:[master, ]
34: var Class = {
1495:   classNames: function(element) {
1875:   function findDOMClass(tagName) {
2017: Element.ClassNames.prototype = {
1266:   document.getXPathElementsByClassName = function(className, parentElement) {
1273: document.getJSElementsByClassName = function(className, parentElement) {
1470:   getElementsByClassName: function(element, className) {
1499:   hasClassName: function(element, className) {
1509:   addClassName: function(element, className) {
1515:   removeClassName: function(element, className) {
1521:   toggleClassName: function(element, className) {
167: var PeriodicalExecuter = Class.create();
422: var Template = Class.create();
898: ObjectRange = Class.create();
996: Ajax.Request = Class.create();
1162: Ajax.Updater = Class.create();
1203: Ajax.PeriodicalUpdater = Class.create();
1267:     var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1376:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
1959: Insertion.Before = Class.create();
1972: Insertion.Top = Class.create();
1986: Insertion.Bottom = Class.create();
2000: Insertion.After = Class.create();
2016: Element.ClassNames = Class.create();
2048: /* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
2052: var Selector = Class.create();
2149:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
2418:       var needle = ' ' + className + ' ';
2422:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
2868: Form.Element.Observer = Class.create();
2875: Form.Observer = Class.create();
2924: Form.Element.EventObserver = Class.create();
2931: Form.EventObserver = Class.create();
1278:     if (Element.hasClassName(child, className))
1471:     return document.getElementsByClassName(className, element);
1496:     return new Element.ClassNames(element);
1501:     var elementClassName = element.className;
1503:     if (elementClassName == className ||
1504:         elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
1511:     Element.classNames(element).add(className);
1517:     Element.classNames(element).remove(className);
1523:     Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
1907:       var klass = findDOMClass(tag);
2023:     this.element.className.split(/\s+/).select(function(name) {
2028:   set: function(className) {
2029:     this.element.className = className;
2032:   add: function(classNameToAdd) {
2033:     if (this.include(classNameToAdd)) return;
2034:     this.set($A(this).concat(classNameToAdd).join(' '));
2037:   remove: function(classNameToRemove) {
2038:     if (!this.include(classNameToRemove)) return;
2039:     this.set($A(this).without(classNameToRemove).join(' '));
2047: Object.extend(Element.ClassNames.prototype, Enumerable);
2239:     className:    'n = h.className(n, r, "#{1}", c); c = false;',
2267:     className:    /^\.([\w\-\*]+)(\b|$)/,
2411:     className: function(nodes, root, className, combinator) {
2413:       return Selector.handlers.byClassName(nodes, root, className);
2416:     byClassName: function(nodes, root, className) {
2420:         nodeClassName = node.className;
1502:     if (elementClassName.length == 0) return false;
2419:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
2421:         if (nodeClassName.length == 0) continue;
chromium.googlesource.com/external/WebKit_trimmed:Websites/webkit.org/blog-files/prototype-for-gebcn-test.js:[master, ]
duplicate result
eclipse.googlesource.com/jgit/jgit:org.eclipse.jgit/src/org/eclipse/jgit/util/RawSubStringPattern.java:[master, ]
59: 	private final byte[] needle;
57: 	private final String needleString;
56: public class RawSubStringPattern {
75: 		needle = new byte[b.length];
77: 			needle[i] = lc(b[i]);
91: 		final int needleLen = needle.length;
92: 		final byte first = needle[0];
109: 				if (neq(needle[j], text[si]))
72: 		needleString = patternText;
96: 		final int maxPos = rcs.endPtr - needleLen;
108: 			for (int j = 1; j < needleLen; j++, si++) {
131: 		return needleString;
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/external/WebKit_trimmed:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/external/Webkit:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/external/w3c/csswg-test:work-in-progress/gabriele/css-xml-dom/js/prototype.js:[master, ]
44: var Class = {
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
2644:   function findDOMClass(tagName) {
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/playground/chromium/blink_format:third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/chromium/blink:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/dart/dartium/blink:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/chromium/codesearch:src/third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/external/webrtc/codesearch:src:codesearch-gitlink-overlay/third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
android.googlesource.com/platform/superproject:external/clang/lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
591:   const DeclRefExpr *Needle;
62:   class UnreachableCodeHandler : public reachable_code::Callback {
121: class LogicalErrorHandler : public CFGCallback {
179:     // Skip function calls which are qualified with a templated class.
586: /// ContainsReference - A visitor class to search for references to
587: /// a particular declaration (the needle) within any evaluated component of an
589: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
596:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
597:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
608:     if (E == Needle)
899:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1360: class UninitValsDiagReporter : public UninitVariablesHandler {
1472: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1742: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
259:   // templated classes.
727:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
734:     case Stmt::IfStmtClass: {
744:     case Stmt::ConditionalOperatorClass: {
754:     case Stmt::BinaryOperatorClass: {
774:     case Stmt::WhileStmtClass:
781:     case Stmt::ForStmtClass:
791:     case Stmt::CXXForRangeStmtClass:
804:     case Stmt::DoStmtClass:
813:     case Stmt::CaseStmtClass:
818:     case Stmt::DefaultStmtClass:
1182:     switch (S->getStmtClass()) {
1183:     case Stmt::ForStmtClass:
1184:     case Stmt::WhileStmtClass:
1185:     case Stmt::CXXForRangeStmtClass:
1186:     case Stmt::ObjCForCollectionStmtClass:
1188:     case Stmt::DoStmtClass: {
1277:   // Classify the current code body for better warning text.
1280:   // FIXME: Should we use a common classification enum and the same set of
1315:     // Classify the weak object being accessed for better warning text.
1935:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1936:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1937:       .setAlwaysAdd(Stmt::BlockExprClass)
1938:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1939:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1940:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1941:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1942:       .setAlwaysAdd(Stmt::AttributedStmtClass);
chromium.googlesource.com/external/WebKit_submodule:Websites/webkit.org/blog-files/prototype-for-gebcn-test.js:[master, ]
duplicate result
chromium.googlesource.com/external/Webkit:Websites/webkit.org/perf/slickspeed/frameworks/prototype.js:[master, ]
duplicate result
chromium.googlesource.com/external/WebKit_trimmed:Websites/webkit.org/perf/slickspeed/frameworks/prototype.js:[master, ]
duplicate result
chromium.googlesource.com/external/w3c/web-platform-tests:css/work-in-progress/gabriele/css-xml-dom/js/prototype.js:[master, ]
duplicate result
chromium.googlesource.com/arc/arc:third_party/chromium-ppapi/third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/external/webrtc/codesearch/deps:third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
android.googlesource.com/platform/external/chromium:chrome/browser/sync/syncable/syncable.h:[master, ]
1002:     EntryKernel needle;
33: class DictionaryValue;
37: class ReadTransaction;
38: class WriteNode;
39: class ReadNode;
43: class DirectoryChangeListener;
44: class Entry;
48: class DirectoryBackingStore;
179: class BaseTransaction;
180: class WriteTransaction;
181: class ReadTransaction;
182: class Directory;
183: class ScopedDirLookup;
222: // The EntryKernel class contains the actual data for an entry.
347: class Entry {
348:   friend class Directory;
438:   friend class sync_api::ReadNode;
460: class MutableEntry : public Entry {
461:   friend class WriteTransaction;
462:   friend class Directory;
520:   friend class sync_api::WriteNode;
541: class LessParentIdAndHandle;
543: class LessField;
544: class LessEntryMetaHandles {
567: // index, the traits are grouped into a class called an Indexer which
606:   class Comparator {
659: class ScopedKernelLock;
660: class IdFilter;
661: class DirectoryManager;
663: class Directory {
664:   friend class BaseTransaction;
665:   friend class Entry;
666:   friend class MutableEntry;
667:   friend class ReadTransaction;
668:   friend class ReadTransactionWithoutDB;
669:   friend class ScopedKernelLock;
670:   friend class ScopedKernelUnlock;
671:   friend class WriteTransaction;
672:   friend class SyncableDirectoryTest;
682:   class EventListenerHookup;
828:   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
1001:     // look something up in an index.  Needle in haystack metaphor.
1071: class ScopedKernelLock {
1082: class BaseTransaction {
1083:   friend class Entry;
1118: class ReadTransaction : public BaseTransaction {
1128:   friend class sync_api::ReadTransaction;
1135: class WriteTransaction : public BaseTransaction {
1136:   friend class MutableEntry;
647: // friend classes.  The in-memory indices are protected against
android.googlesource.com/platform/external/webkit:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/chromium/third_party/ffmpeg:libavfilter/vf_find_rect.c:[master, ]
35:     AVClass *class;
42:     AVFrame *needle_frame[MAX_MIPMAPS];
59: AVFILTER_DEFINE_CLASS(find_rect);
171:             float score = compare(foc->haystack_frame[pass], foc->needle_frame[pass], x, y);
234:         av_frame_free(&foc->needle_frame[i]);
267:     foc->needle_frame[0] = av_frame_clone(foc->obj_frame);
269:         foc->needle_frame[i] = downscale(foc->needle_frame[i-1]);
270:         if (!foc->needle_frame[i])
304:     .priv_class      = &find_rect_class,
chromium.googlesource.com/chromium/src:third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/ios-chromium-mirror:third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
github.com/fuchsia-mirror/third_party-ffmpeg:libavfilter/vf_find_rect.c:[master, ]
duplicate result
chromium.googlesource.com/dart/dartium/src:chrome/test/data/dromaeo/lib/prototype.js:[master, ]
duplicate result
chromium.googlesource.com/arc/arc:third_party/android/external/chromium/chrome/browser/sync/syncable/syncable.h:[master, ]
duplicate result
github.com/fuchsia-mirror/third_party-cmake:Source/cmTarget.cxx:[master, ]
565:   const cmSourceFileLocation& Needle;
581:   const cmSourceFileLocation& Needle;
160: class cmTargetInternals
567:   LocationMatcher(const cmSourceFileLocation& needle)
568:     : Needle(needle)
574:     return loc.Matches(this->Needle);
584:   TargetPropertyEntryFinder(const cmSourceFileLocation& needle)
585:     : Needle(needle)
595:                    CreateLocation(this->Needle.GetMakefile()));
598:                         LocationMatcher(this->Needle)) != locations.end();
github.com/pagespeed/page-speed:firefox_addon/branches/ff5/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ]
141:   CLASS: 1,
34:  *     is one of {@code ID}, {@code CLASS}, {@code TAG}, or {@code UNIVERSAL}.
40:  *       <li>{@code CLASS} and {@code ID} selectors are given a cost of 1
42:  *         class or id.
58:  *       <li>Selectors that have an id plus a class or tag are multiplied by
61:  *       <li>Selectors that have a class and a tag are also multiplied
155:   case PAGESPEED.SelectorKey.CLASS:
156:     return 'Class';
174:  * a.foo, a b, #my-class { color:red; } -> 'a.foo, a b, #my-class'
200:  * 'a.foo, a b, #my-class' -> ['a.foo','a b','#my-class']
219:  * for the selector. See the class documentation for more information.
300:     // Selectors can only be overly qualified if they have an ID or CLASS
302:         selectorKey == PAGESPEED.SelectorKey.CLASS) {
311:       // Selectors with an ID shouldn't have CLASS refiners
316:             new PAGESPEED.Cost(2, 'ID overly qualified with class'));
320:       // Selectors with a CLASS shouldn't have ID refiners
321:       if (selectorKey == PAGESPEED.SelectorKey.CLASS) {
325:             new PAGESPEED.Cost(2, 'class overly qualified with ID'));
357:   // Look for CLASS and ID refiners
359:     selectorType = PAGESPEED.SelectorKey.CLASS;
439:   // a.class
59:  *         2 because they are needlessly requiring extra work -- the id by
71:  *     different tags, classes, and ids.
132:  * key is how Firefox classifies selectors in order to make matching more
github.com/yeoman/generator-angular:route/index.js:[master, ]
63:     needle: '.otherwise',
66:       "  controller: '" + this.classedName + "Ctrl'" + (coffee ? "" : ","),
github.com/pagespeed/page-speed:firefox_addon/branches/chromium_update4/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ]
duplicate result
github.com/google/rekall:rekall-core/rekall/scan.py:[master, ]
163:     needle = None
164:     needle_offset = None
539:     needles = []
41:     __metaclass__ = registry.MetaclassRegistry
356:     __metaclass__ = registry.MetaclassRegistry
31: class ScannerCheck(object):
32:     """A scanner check is a special class which is invoked on an AS to check
38:     This class is the base class for all checks.
55:         """Is the needle found at 'offset'?
59:             checked for the needle.
89: class MultiStringFinderCheck(ScannerCheck):
160: class StringCheck(ScannerCheck):
166:     def __init__(self, needle=None, needle_offset=0, **kwargs):
168:         self.needle = needle
169:         self.needle_offset = needle_offset
173:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
174:         if buffer_as.data.startswith(self.needle, buffer_offset):
175:             return self.needle
178:         # Search the rest of the buffer for the needle.
179:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
180:         dindex = buffer_as.data.find(self.needle, buffer_offset + 1)
188: class RegexCheck(ScannerCheck):
203: class _Padding(object):
209: class _BufferFragments(object):
251: class BufferASGenerator(object):
353: class BaseScanner(object):
354:     """Base class for all scanners."""
388:         for class_name, args in self.checks:
389:             check = ScannerCheck.classes[class_name](
490: class FastStructScanner(BaseScanner):
531:             yield ("StringCheck", dict(needle=expected_bytes,
532:                                        needle_offset=rel_offset + array_offset))
535: class MultiStringScanner(BaseScanner):
552:                 needle=self.needles[0])
568: class PointerScanner(BaseScanner):
602: class ScannerGroup(BaseScanner):
639: class DiscontigScannerGroup(ScannerGroup):
652: class DebugChecker(ScannerCheck):
92:     def __init__(self, needles=None, **kwargs):
96:           needles: A list of strings we search for.
99:           RuntimeError: No needles provided.
105:         if not needles:
106:             raise RuntimeError("No needles provided to search.")
110:         if max([len(x) for x in needles]) > 50:
113:         tree = acora.AcoraBuilder(*needles)
538:     # Override with the needles to check for.
541:     def __init__(self, needles=None, **kwargs):
543:         if needles is not None:
544:             self.needles = needles
549:         if len(needles) == 1:
556:                 needles=self.needles)
586:         self.needles = []
594:             self.needles.append(tmp.obj_vm.read(0, tmp.obj_size))
596:         # The common string between all the needles.
598:             ("MultiStringFinderCheck", dict(needles=self.needles)),
chromium.googlesource.com/chromium/chromium:chrome/test/data/dromaeo/lib/prototype.js:[trunk, ]
duplicate result
chromium.googlesource.com/experimental/src-pruned-refs:chrome/test/data/dromaeo/lib/prototype.js:[master, ]
duplicate result
github.com/GoogleChrome/web-audio-samples:samples/audio/box2d-js/lib/prototype-1.6.0.2.js:[gh-pages, ]
duplicate result
chromium.googlesource.com/chromium/src/codesearch:third_party/ffmpeg/libavfilter/vf_find_rect.c:[master, ]
duplicate result
android.googlesource.com/platform/external/clang_35a:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
577:   const DeclRefExpr *Needle;
63:   class UnreachableCodeHandler : public reachable_code::Callback {
121: class LogicalErrorHandler : public CFGCallback {
192:         // Skip function calls which are qualified with a templated class.
572: /// ContainsReference - A visitor class to search for references to
573: /// a particular declaration (the needle) within any evaluated component of an
575: class ContainsReference : public EvaluatedExprVisitor<ContainsReference> {
580:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
582:       FoundReference(false), Needle(Needle) {}
593:     if (E == Needle)
885:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1331: class UninitValsDiagReporter : public UninitVariablesHandler {
1454: class ThreadSafetyReporter : public clang::thread_safety::ThreadSafetyHandler {
1629: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
229:   // templated classes.
712:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
719:     case Stmt::IfStmtClass: {
729:     case Stmt::ConditionalOperatorClass: {
739:     case Stmt::BinaryOperatorClass: {
759:     case Stmt::WhileStmtClass:
766:     case Stmt::ForStmtClass:
776:     case Stmt::CXXForRangeStmtClass:
789:     case Stmt::DoStmtClass:
798:     case Stmt::CaseStmtClass:
803:     case Stmt::DefaultStmtClass:
1155:     switch (S->getStmtClass()) {
1156:     case Stmt::ForStmtClass:
1157:     case Stmt::WhileStmtClass:
1158:     case Stmt::CXXForRangeStmtClass:
1159:     case Stmt::ObjCForCollectionStmtClass:
1161:     case Stmt::DoStmtClass: {
1251:   // Classify the current code body for better warning text.
1254:   // FIXME: Should we use a common classification enum and the same set of
1291:     // Classify the weak object being accessed for better warning text.
1831:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1832:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1833:       .setAlwaysAdd(Stmt::BlockExprClass)
1834:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1835:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1836:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1837:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1838:       .setAlwaysAdd(Stmt::AttributedStmtClass);
chromium.googlesource.com/native_client/pnacl-clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
579:   const DeclRefExpr *Needle;
63:   class UnreachableCodeHandler : public reachable_code::Callback {
122: class LogicalErrorHandler : public CFGCallback {
203:         // Skip function calls which are qualified with a templated class.
574: /// ContainsReference - A visitor class to search for references to
575: /// a particular declaration (the needle) within any evaluated component of an
577: class ContainsReference : public EvaluatedExprVisitor<ContainsReference> {
582:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
584:       FoundReference(false), Needle(Needle) {}
595:     if (E == Needle)
888:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1325: class UninitValsDiagReporter : public UninitVariablesHandler {
1442: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1713: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
240:   // templated classes.
715:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
722:     case Stmt::IfStmtClass: {
732:     case Stmt::ConditionalOperatorClass: {
742:     case Stmt::BinaryOperatorClass: {
762:     case Stmt::WhileStmtClass:
769:     case Stmt::ForStmtClass:
779:     case Stmt::CXXForRangeStmtClass:
792:     case Stmt::DoStmtClass:
801:     case Stmt::CaseStmtClass:
806:     case Stmt::DefaultStmtClass:
1152:     switch (S->getStmtClass()) {
1153:     case Stmt::ForStmtClass:
1154:     case Stmt::WhileStmtClass:
1155:     case Stmt::CXXForRangeStmtClass:
1156:     case Stmt::ObjCForCollectionStmtClass:
1158:     case Stmt::DoStmtClass: {
1248:   // Classify the current code body for better warning text.
1251:   // FIXME: Should we use a common classification enum and the same set of
1286:     // Classify the weak object being accessed for better warning text.
1903:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1904:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1905:       .setAlwaysAdd(Stmt::BlockExprClass)
1906:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1907:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1908:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1909:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1910:       .setAlwaysAdd(Stmt::AttributedStmtClass);
android.googlesource.com/platform/external/chromium_org/third_party/WebKit:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
android.googlesource.com/platform/external/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
github.com/fuchsia-mirror/third_party-clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
618:   const DeclRefExpr *Needle;
57:   class UnreachableCodeHandler : public reachable_code::Callback {
126: class LogicalErrorHandler : public CFGCallback {
184:     // Skip function calls which are qualified with a templated class.
613: /// ContainsReference - A visitor class to search for references to
614: /// a particular declaration (the needle) within any evaluated component of an
616: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
623:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
624:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
635:     if (E == Needle)
926:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1396: class UninitValsDiagReporter : public UninitVariablesHandler {
1508: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1778: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
264:   // templated classes.
754:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
761:     case Stmt::IfStmtClass: {
771:     case Stmt::ConditionalOperatorClass: {
781:     case Stmt::BinaryOperatorClass: {
801:     case Stmt::WhileStmtClass:
808:     case Stmt::ForStmtClass:
818:     case Stmt::CXXForRangeStmtClass:
831:     case Stmt::DoStmtClass:
840:     case Stmt::CaseStmtClass:
845:     case Stmt::DefaultStmtClass:
1218:     switch (S->getStmtClass()) {
1219:     case Stmt::ForStmtClass:
1220:     case Stmt::WhileStmtClass:
1221:     case Stmt::CXXForRangeStmtClass:
1222:     case Stmt::ObjCForCollectionStmtClass:
1224:     case Stmt::DoStmtClass: {
1313:   // Classify the current code body for better warning text.
1316:   // FIXME: Should we use a common classification enum and the same set of
1351:     // Classify the weak object being accessed for better warning text.
1971:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1972:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1973:       .setAlwaysAdd(Stmt::BlockExprClass)
1974:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1975:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1976:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1977:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1978:       .setAlwaysAdd(Stmt::AttributedStmtClass);
chromium.googlesource.com/external/github.com/kripken/emscripten-fastcomp-clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
chromium.googlesource.com/chromiumos/third_party/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
768:   const DeclRefExpr *Needle;
57:   class UnreachableCodeHandler : public reachable_code::Callback {
126: class LogicalErrorHandler : public CFGCallback {
184:     // Skip function calls which are qualified with a templated class.
763: /// ContainsReference - A visitor class to search for references to
764: /// a particular declaration (the needle) within any evaluated component of an
766: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
773:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
774:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
785:     if (E == Needle)
1076:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1546: class UninitValsDiagReporter : public UninitVariablesHandler {
1658: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1928: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
264:   // templated classes.
904:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
911:     case Stmt::IfStmtClass: {
921:     case Stmt::ConditionalOperatorClass: {
931:     case Stmt::BinaryOperatorClass: {
951:     case Stmt::WhileStmtClass:
958:     case Stmt::ForStmtClass:
968:     case Stmt::CXXForRangeStmtClass:
981:     case Stmt::DoStmtClass:
990:     case Stmt::CaseStmtClass:
995:     case Stmt::DefaultStmtClass:
1368:     switch (S->getStmtClass()) {
1369:     case Stmt::ForStmtClass:
1370:     case Stmt::WhileStmtClass:
1371:     case Stmt::CXXForRangeStmtClass:
1372:     case Stmt::ObjCForCollectionStmtClass:
1374:     case Stmt::DoStmtClass: {
1463:   // Classify the current code body for better warning text.
1466:   // FIXME: Should we use a common classification enum and the same set of
1501:     // Classify the weak object being accessed for better warning text.
2121:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
2122:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
2123:       .setAlwaysAdd(Stmt::BlockExprClass)
2124:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
2125:       .setAlwaysAdd(Stmt::DeclRefExprClass)
2126:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
2127:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
2128:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/llvm-mirror/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
chromium.googlesource.com/external/llvm.org/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
chromium.googlesource.com/external/github.com/llvm-mirror/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
chromium.googlesource.com/chromium/codesearch:src:codesearch-gitlink-overlay/third_party/ffmpeg/libavfilter/vf_find_rect.c:[master, ]
duplicate result
chromium.googlesource.com/external/WebKit_submodule:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result