Search some code: Max results:

Found 40071 results in 1806 files (66MB index data, 18120819 ngram matches, 5711 docs considered, 2654 docs (90MB) loaded, 892 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 517.158217ms (queued: 3.73µs)

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

2293:         'class': 'className',
56:       var subclass = function() { };
57:       subclass.prototype = parent.prototype;
1816:   classNames: function(element) {
2165:       className: 'class',
4187: Element.ClassNames.prototype = {
1820:   hasClassName: function(element, className) {
1827:   addClassName: function(element, className) {
1834:   removeClassName: function(element, className) {
1841:   toggleClassName: function(element, className) {
41: var Class = {
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);
2625:   function findDOMClass(tagName) {
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, ] lang:javascript
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
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);
2644:   function findDOMClass(tagName) {
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 ?
eclipse.googlesource.com/jgit/jgit:org.eclipse.jgit/src/org/eclipse/jgit/util/RawSubStringPattern.java:[master, ] lang:java
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, ] lang:javascript
duplicate result
chromium.googlesource.com/playground/chromium/blink_format:third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ] lang:javascript
duplicate result
chromium.googlesource.com/chromium/blink:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ] lang:javascript
duplicate result
chromium.googlesource.com/dart/dartium/blink:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ] lang:javascript
duplicate result
android.googlesource.com/platform/superproject:external/clang/lib/Sema/AnalysisBasedWarnings.cpp:[master, ] lang:c++
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/chromium:chrome/test/data/dromaeo/lib/prototype.js:[trunk, ] lang:javascript
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
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);
2644:   function findDOMClass(tagName) {
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/chromium:sync/syncable/directory.h:[trunk, ] lang:c++
536:     EntryKernel needle;
23: class Cryptographer;
24: class UnrecoverableErrorHandler;
28: class BaseTransaction;
29: class DirectoryChangeDelegate;
30: class DirectoryBackingStore;
31: class NigoriHandler;
32: class ScopedKernelLock;
33: class TransactionObserver;
34: class WriteTransaction;
50: // index, the traits are grouped into a class called an Indexer which
53: template <typename FieldType, FieldType field_index> class LessField;
91:   class Comparator {
115: class EntryKernelLessByMetaHandle {
131: class Directory {
132:   friend class BaseTransaction;
133:   friend class Entry;
134:   friend class MutableEntry;
135:   friend class ReadTransaction;
136:   friend class ReadTransactionWithoutDB;
137:   friend class ScopedKernelLock;
138:   friend class ScopedKernelUnlock;
139:   friend class WriteTransaction;
140:   friend class SyncableDirectoryTest;
336:   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
535:     // look something up in an index.  Needle in haystack metaphor.
android.googlesource.com/platform/external/qt:Windows-4.7.4/src/scripttools/debugging/qscriptsyntaxhighlighter.cpp:[master, ] lang:c++
129:     const QString needle;
70:     "class",
128:     inline KeywordHelper(const QString &word) : needle(word) {}
134:     return helper.needle < QLatin1String(kw);
139:     return QLatin1String(kw) < helper.needle;
android.googlesource.com/platform/external/chromium:chrome/browser/sync/syncable/syncable.h:[master, ] lang:c++
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, ] lang:javascript
duplicate result
chromium.googlesource.com/chromium/third_party/ffmpeg:libavfilter/vf_find_rect.c:[master, ] lang:c
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,
github.com/fuchsia-mirror/third_party-ffmpeg:libavfilter/vf_find_rect.c:[master, ] lang:c
duplicate result
chromium.googlesource.com/dart/dartium/src:chrome/test/data/dromaeo/lib/prototype.js:[master, ] lang:javascript
duplicate result
chromium.googlesource.com/arc/arc:third_party/android/external/chromium/chrome/browser/sync/syncable/syncable.h:[master, ] lang:c++
duplicate result
github.com/fuchsia-mirror/third_party-cmake:Source/cmTarget.cxx:[master, ] lang:c++
571:   const cmSourceFileLocation& Needle;
587:   const cmSourceFileLocation& Needle;
161: class cmTargetInternals
573:   LocationMatcher(const cmSourceFileLocation& needle)
574:     : Needle(needle)
580:     return loc.Matches(this->Needle);
590:   TargetPropertyEntryFinder(const cmSourceFileLocation& needle)
591:     : Needle(needle)
601:                    CreateLocation(this->Needle.GetMakefile()));
604:                         LocationMatcher(this->Needle)) != locations.end();
github.com/pagespeed/page-speed:firefox_addon/branches/ff5/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ] lang:javascript
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/GoogleChrome/web-audio-samples:samples/audio/box2d-js/lib/prototype-1.6.0.2.js:[gh-pages, ] lang:javascript
duplicate result
github.com/yeoman/generator-angular:route/index.js:[master, ] lang:javascript
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, ] lang:javascript
duplicate result
github.com/google/rekall:rekall-core/rekall/scan.py:[master, ] lang:python
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, ] lang:javascript
duplicate result
chromium.googlesource.com/experimental/src-pruned-refs:chrome/test/data/dromaeo/lib/prototype.js:[master, ] lang:javascript
duplicate result
chromium.googlesource.com/chromium/src/codesearch:third_party/perl/perl/vendor/lib/Test/Object/Test.pm:[master, ] lang:perl
34: sub class {
66: sub _CLASS ($) {
20: 	my $class = shift;
21: 	my $self  = bless { @_ }, $class;
24: 	unless ( _CLASS($self->class) ) {
25: 		Carp::croak("Did not provide a valid test class");
35: 	$_[0]->{class};
64: # Stolen from Params::Util to avoid adding a dependency needlessly
android.googlesource.com/platform/external/clang_35a:lib/Sema/AnalysisBasedWarnings.cpp:[master, ] lang:c++
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/chromium/src/codesearch:third_party/ffmpeg/libavfilter/vf_find_rect.c:[master, ] lang:c
duplicate result
chromium.googlesource.com/native_client/pnacl-clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ] lang:c++
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, ] lang:javascript
duplicate result
github.com/llvm-mirror/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ] lang:c++
777:   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.
772: /// ContainsReference - A visitor class to search for references to
773: /// a particular declaration (the needle) within any evaluated component of an
775: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
782:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
783:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
794:     if (E == Needle)
1085:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1555: class UninitValsDiagReporter : public UninitVariablesHandler {
1667: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1937: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
264:   // templated classes.
913:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
920:     case Stmt::IfStmtClass: {
930:     case Stmt::ConditionalOperatorClass: {
940:     case Stmt::BinaryOperatorClass: {
960:     case Stmt::WhileStmtClass:
967:     case Stmt::ForStmtClass:
977:     case Stmt::CXXForRangeStmtClass:
990:     case Stmt::DoStmtClass:
999:     case Stmt::CaseStmtClass:
1004:     case Stmt::DefaultStmtClass:
1377:     switch (S->getStmtClass()) {
1378:     case Stmt::ForStmtClass:
1379:     case Stmt::WhileStmtClass:
1380:     case Stmt::CXXForRangeStmtClass:
1381:     case Stmt::ObjCForCollectionStmtClass:
1383:     case Stmt::DoStmtClass: {
1472:   // Classify the current code body for better warning text.
1475:   // FIXME: Should we use a common classification enum and the same set of
1510:     // Classify the weak object being accessed for better warning text.
2130:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
2131:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
2132:       .setAlwaysAdd(Stmt::BlockExprClass)
2133:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
2134:       .setAlwaysAdd(Stmt::DeclRefExprClass)
2135:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
2136:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
2137:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/fuchsia-mirror/third_party-clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ] lang:c++
duplicate result
android.googlesource.com/platform/external/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ] lang:c++
duplicate result
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.7.1.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ] lang:javascript
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/pagespeed/page-speed:firefox_addon/tags/page-speed-1.12.9.1/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ] lang:javascript
duplicate result
android.googlesource.com/platform/external/qt:Mac-4.7.4/src/scripttools/debugging/qscriptsyntaxhighlighter.cpp:[master, ] lang:c++
129:     const QString needle;
70:     "class",
128:     inline KeywordHelper(const QString &word) : needle(word) {}
134:     return helper.needle < QLatin1String(kw);
139:     return QLatin1String(kw) < helper.needle;
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.12.9.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ] lang:javascript
duplicate result
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.7.0.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ] lang:javascript
duplicate result
chromium.googlesource.com/chromium/deps/xulrunner-sdk:win/bin/modules/Microformats.js:[master, ] lang:javascript
1237:     "class" : {
1155:   className: "adr",
1221:   className: "vcard",
1433:   className: "vevent",
1641:   className: "geo",
31:     function isAncestor(haystack, needle) {
32:       var parent = needle;
36:         if (parent == needle.parentNode) {
186:         xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[mfname].className + " ')";
692:       /* is a class based microformat and the passed in node is not the */
708:       /* Query the correct set of nodes (rel or class) based on the setting */
734:             xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[Microformats.list[j]].className + " ')";
778:         /* If we didn't find any class nodes, check to see if this property */
791:      * the innerHTML and the class name.
1038:       xpathExpression = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1098:     var classValue = node.getAttribute("class");
1179:                                               "contains(concat(' ', @class, ' '), ' post-office-box ')" +
1180:                                               " or contains(concat(' ', @class, ' '), ' street-address ')" +
1181:                                               " or contains(concat(' ', @class, ' '), ' extended-address ')" +
1182:                                               " or contains(concat(' ', @class, ' '), ' locality ')" +
1183:                                               " or contains(concat(' ', @class, ' '), ' region ')" +
1184:                                               " or contains(concat(' ', @class, ' '), ' postal-code ')" +
1185:                                               " or contains(concat(' ', @class, ' '), ' country-name')" +
1442:     "class" : {
1614:     var xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vcard ')]";
1623:     xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vevent ')]";
65:     if (Microformats[name].className) {
67:                                         Microformats[name].className);
71:         var altClass = Microformats.getElementsByClassName(rootElement, Microformats[name].alternateClassName);
72:         if (altClass.length > 0) {
148:       if (Microformats[i].className) {
149:         if (Microformats.matchClass(node, Microformats[i].className)) {
185:       if (Microformats[mfname].className) {
220:         if (Microformats[i].className) {
221:           if (Microformats.matchClass(node, Microformats[i].className)) {
348:         if (!Microformats.matchClass(propnode, "value")) {
434:       if (Microformats.matchClass(propnode, "value")) {
464:         if (Microformats.matchClass(propnode, "value")) {
599:           if (!Microformats.matchClass(in_node, Microformats[microformat].className)) {
605:       if ((Microformats[microformat].className) && in_node.ownerDocument) {
696:       if (!in_mfnode.origNode && Microformats[mfname].className && in_mfnode.ownerDocument) {
728:           if (Microformats[Microformats.list[j]].className) {
826:               tempNode.className = headerNode.className;
1017:    * Retrieve elements matching all classes listed in a space-separated string.
1021:    * @param  className        A space separated list of classenames
1025:   getElementsByClassName: function getElementsByClassName(rootNode, className)
1031:       var col = rootNode.getElementsByClassName(className);
1047:       className = className.replace(/\-/g, "\\-");
1050:         if (elements[i].className.match("(^|\\s)" + className + "(\\s|$)")) {
1097:   matchClass: function matchClass(node, className) {
1099:     return (classValue && classValue.match("(^|\\s)" + className + "(\\s|$)"));
1720:           var ioService = Components.classes["@mozilla.org/network/io-service;1"].
66:       microformatNodes = Microformats.getElementsByClassName(rootElement,
68:       /* alternateClassName is for cases where a parent microformat is inferred by the children */
69:       /* If we find alternateClassName, the entire document becomes the microformat */
70:       if ((microformatNodes.length == 0) && Microformats[name].alternateClassName) {
323:         var values = Microformats.getElementsByClassName(propnode, "value");
640:             subpropnodes = Microformats.getElementsByClassName(propnode, subpropname);
714:         propnodes = Microformats.getElementsByClassName(mfnode, propname);
800:       var includes = Microformats.getElementsByClassName(in_mfnode, "include");
805:           includes = Microformats.getElementsByClassName(mfnode, "include");
1029:     if ((rootNode.ownerDocument || rootNode).getElementsByClassName) {
1030:     /* Firefox 3 - native getElementsByClassName */
1207:     var fns = Microformats.getElementsByClassName(this.node, "fn");
1416:     var summaries = Microformats.getElementsByClassName(this.node, "summary");
chromium.googlesource.com/native_client/pnacl-gcc:libjava/classpath/tools/gnu/classpath/tools/doclets/xmldoclet/Driver.java:[master, ] lang:java
2224:       public static final UsageType CLASS_DERIVED_FROM = new UsageType("class-derived-from");
245:    private ClassDoc currentClass;
38: package gnu.classpath.tools.doclets.xmldoclet;
410:    protected void outputClassDocSummary(ClassDoc classDoc) {
476:    protected void outputClassDoc(ClassDoc classDoc) throws IOException {
2250:    private Map usedClassToPackagesMap = new HashMap();
97: public class Driver {
104:    private static class NullErrorReporter implements DocErrorReporter {
242:     *  The current class that is being processed.
1011:                      useTagletPath = System.getProperty("java.class.path");
1015:                      Class tagletClass;
1023:                            = Class.forName(option[1]);
1026:                         = tagletClass.getDeclaredMethod("register", new Class[] { java.util.Map.class });
1029:                         printError("Taglet class '" + option[1] + "' found, but register method doesn't return void.");
1032:                         printError("Taglet class '" + option[1] + "' found, but register method contains throws clause.");
1035:                         printError("Taglet class '" + option[1] + "' found, but register method isn't public static, or is abstract..");
1048:                      printError("Taglet class '" + option[1] + "' found, but doesn't contain the register method.");
1051:                      printError("Taglet class '" + option[1] + "' cannot be loaded: " + e.getMessage());
1054:                      printError("Taglet class '" + option[1] + "' found, but register method throws exception: " + e.toString());
1057:                      printError("Taglet class '" + option[1] + "' found, but there was a problem when accessing the register method: " + e.toString());
1060:                      printError("Taglet class '" + option[1] + "' found, but there was a problem when accessing the register method: " + e.toString());
1063:                      printError("Taglet class '" + option[1] + "' cannot be found.");
1914:     *  Replaces all occurences of string <code>needle</code> within string
1918:     *  @param needle      The string which is searched for.
1919:     *  @param replacement The string by which every occurence of <code>needle</code> is replaced.
1921:    private static String replaceString(String haystack, String needle, String replacement) {
1922:       int ndx = haystack.indexOf(needle);
1927:             + replaceString(haystack.substring(ndx+needle.length()), needle, replacement);
1964:       InputStream in = Driver.class.getResourceAsStream(resourceName);
2222:    private static class UsageType
2286:             addUsedBy(superclass, UsageType.CLASS_DERIVED_FROM, clazz, clazz.containingPackage());
2387:                                   + " class=\"" + ((ClassDoc)user).name() + "\"");
2392:                                   + " class=\"" + fieldDoc.containingClass().name() + "\""
2398:                                   + " class=\"" + methodDoc.containingClass().name() + "\""
2406:                                   + " class=\"" + constructorDoc.containingClass().name() + "\""
1: /* gnu.classpath.tools.doclets.xmldoclet.Driver
4: This file is part of GNU Classpath.
6: GNU Classpath is free software; you can redistribute it and/or modify
11: GNU Classpath is distributed in the hope that it will be useful, but
17: along with GNU Classpath; see the file COPYING.  If not, write to the
69: import gnu.classpath.tools.gjdoc.TemporaryStore;
70: import gnu.classpath.tools.gjdoc.GjdocPackageDoc;
72: import gnu.classpath.tools.doclets.PackageGroup;
73: import gnu.classpath.tools.doclets.PackageMatcher;
74: import gnu.classpath.tools.doclets.InvalidPackageWildcardException;
76: import gnu.classpath.tools.doclets.xmldoclet.doctranslet.DocTranslet;
77: import gnu.classpath.tools.doclets.xmldoclet.doctranslet.DocTransletOptions;
79: import gnu.classpath.tools.taglets.AuthorTaglet;
80: import gnu.classpath.tools.taglets.VersionTaglet;
81: import gnu.classpath.tools.taglets.SinceTaglet;
82: import gnu.classpath.tools.taglets.DeprecatedTaglet;
83: import gnu.classpath.tools.taglets.GenericTaglet;
84: import gnu.classpath.tools.doclets.StandardTaglet;
86: import gnu.classpath.tools.java2xhtml.Java2xhtml;
88: import gnu.classpath.tools.IOToolkit;
89: import gnu.classpath.tools.FileSystemClassLoader;
237:     *  Classpath for loading Taglet classes.
317:       ClassDoc typeAsClassDoc = type.asClassDoc();
343:       ClassDoc[] exceptions = memberDoc.thrownExceptions();
345:          ClassDoc exception = exceptions[i];
398:    protected void outputSuperInterfacesRec(int level, ClassDoc classDoc) {
399:       if (null!=classDoc) {
400:          ClassDoc[] interfaces = classDoc.interfaces();
406:          outputSuperInterfacesRec(level, classDoc.superclass());
412:       printOpenTag(1, "classdoc name=\""+classDoc.name()+"\" qualifiedtypename=\""+classDoc.qualifiedName()+"\" isIncluded=\"true\"");
413:       if (null!=classDoc.superclass()) {
414:          outputType(2, "superclass", classDoc.superclass());
417:       ClassDoc[] interfaces = classDoc.interfaces();
421:       outputSuperInterfacesRec(2, classDoc.superclass());
423:       printAtomTag(2, "containingPackage name=\""+classDoc.containingPackage().name()+"\"");
424:       if (classDoc.isError()) {
427:       if (classDoc.isException()) {
430:       if (classDoc.isInterface()) {
433:       if (classDoc.isOrdinaryClass()) {
434:          printAtomTag(2, "isOrdinaryClass");
437:       printCloseTag(1, "classdoc");
464:       ClassDoc[] allClasses = (ClassDoc[]) packageDoc.allClasses().clone();
469:             printAtomTag(2, "containsClass qualifiedtypename=\""+allClasses[i].qualifiedTypeName()+"\"");
478:       currentClass = classDoc;
481:       printOpenTag(1, "classdoc xmlns=\"http://www.w3.org/TR/REC-html40\" xmlns:"+tagPrefix+"=\"http://www.gnu.org/software/cp-tools/gjdocxml\" name=\""+classDoc.name()+"\" qualifiedtypename=\""+classDoc.qualifiedName()+"\"");
483:       ClassDoc[] interfaces = classDoc.interfaces();
487:       outputSuperInterfacesRec(2, classDoc.superclass());
489:       outputProgramElementDocBody(2, classDoc);
490:       if (classDoc.isAbstract())
492:       if (classDoc.isSerializable())
494:       if (classDoc.isExternalizable())
496:       if (classDoc.definesSerializableFields()) {
500:       ConstructorDoc[] constructors = classDoc.constructors();
505:       MethodDoc[] methods = classDoc.methods();
510:       FieldDoc[] fields = classDoc.fields();
515:       if (classDoc.serializableFields().length > 0) {
518:          FieldDoc[] sfields = classDoc.serializableFields();
531:       if (null == classDoc.containingClass() && docTransletOptions.linksource) {
534:          File sourceFile = new File(((GjdocPackageDoc)classDoc.containingPackage()).packageDirectory(),
535:                                     classDoc.name() + ".java");
542:       ClassDoc superclassDoc = classDoc.superclass();
544:          outputType(2, "superclass", superclassDoc, false);
562:          printCloseTag(2, "superclass");
564:          superclassDoc = superclassDoc.superclass();
567:       outputUsage(classDoc, 2);
569:       printCloseTag(1, "classdoc");
571:       currentClass = null;
576:    protected int outputHeritageOpen(int level, ClassDoc classDoc) {
578:       ClassDoc superClassDoc = classDoc.superclass();
583:       outputType(level, "heritage", classDoc, false);
587:    protected void outputHeritageClose(int level, ClassDoc classDoc) {
589:       ClassDoc superClassDoc = classDoc.superclass();
600:       if (doc.isClass()) {
601:          printAtomTag(level, "isClass");
603:          ClassDoc classDoc = (ClassDoc)doc;
604:          ClassDoc[] classes = rootDoc.classes();
605:          for (int i=0, ilim=classes.length; i<ilim; ++i) {
606:             if (classes[i].superclass() == classDoc) {
607:                outputType(level, "extended-by", classes[i]);
611:          outputHeritageOpen(level, classDoc);
612:          outputHeritageClose(level, classDoc);
634:          ClassDoc classDoc = (ClassDoc)doc;
635:          ClassDoc[] classes = rootDoc.classes();
636:          for (int i=0, ilim=classes.length; i<ilim; ++i) {
637:             ClassDoc[] implementedInterfaces = classes[i].interfaces();
639:                if (implementedInterfaces[j] == classDoc) {
640:                   if (classDoc.isInterface()) {
641:                         outputType(level, "subinterface", classes[i]);
644:                      outputType(level, "implemented-by", classes[i]);
655:       if (doc.isOrdinaryClass()) {
656:          printAtomTag(level, "isOrdinaryClass");
692:       if (null!=programElementDoc.containingClass()) {
693:          outputType(level, "containingClass", programElementDoc.containingClass());
741:             sb.append(currentClass.qualifiedName());
964:                                          /** "gnu.classpath.tools.doclets.xmldoclet.DocBookPostprocessor") **/
1017:                         tagletClass
1018:                            = new FileSystemClassLoader(useTagletPath).loadClass(option[1]);
1020:                      catch (ClassNotFoundException e) {
1021:                         // If not found on specified tagletpath, try default classloader
1022:                         tagletClass
1062:                   catch (ClassNotFoundException e) {
1358:                ClassDoc[] classes = rootDoc.classes();
1359:                for (int i = 0, ilim = classes.length; i < ilim; ++ i) {
1360:                   ClassDoc c = classes[i];
1372:                      else /*if (c.isOrdinaryClass())*/ {
1398:                                             currentClass, currentMember,
1456:             // Output summary of all classes specified on command line
1459:             println(1, "<!-- Classes specified by user on command line -->");
1460:             ClassDoc[] specifiedClasses = rootDoc.specifiedClasses();
1462:                ClassDoc sc = specifiedClasses[i];
1463:                printAtomTag(1, "specifiedclass fqname=\""+sc.qualifiedName()+"\" name=\""+sc.name()+"\"");
1517:             // Output brief summary on all classes for which documentation
1524:             println(1, "<!-- Brief summary for all classes -->");
1525:             ClassDoc[] sumclasses = rootDoc.classes();
1527:                ClassDoc c = sumclasses[i];
1543:             // Output information on all classes for which documentation
1547:             println(1, "<!-- Documentation for all classes -->");
1548:             ClassDoc[] classes = rootDoc.classes();
1550:             for (int i = 0, ilim = classes.length; i < ilim; ++ i) {
1551:                ClassDoc c = classes[i];
1573:             classes = null;
1635:          gnu.classpath.tools.gjdoc.Main.releaseRootDoc();
1637:          this.currentClass = null;
2095:       // Add classes, fields and methods to index
2097:       ClassDoc[] sumclasses = rootDoc.classes();
2099:          ClassDoc c = sumclasses[i];
2100:          if (null == c.containingClass()) {
2104:             indexMap.put(c.name().substring(c.containingClass().name().length() + 1), c);
2162:          else if (entry instanceof ClassDoc) {
2163:             printAtomTag(3, "isClass");
2164:             ClassDoc centry = (ClassDoc)entry;
2165:             currentClass = centry;
2167:             if (null != centry.containingClass()) {
2168:                printAtomTag(3, "containingClass name=\"" + centry.containingClass().name() + "\"");
2179:             if (centry.isOrdinaryClass()) {
2180:                printAtomTag(3, "isOrdinaryClass");
2185:             currentClass = pentry.containingClass();
2187:             printAtomTag(3, "containingClass name=\"" + pentry.containingClass().name() + "\"");
2248:     *  ClassDoc -> (PackageDoc -> (UsageType -> (Set of Doc)))
2252:    private void addUsedBy(ClassDoc usedClass, UsageType usageType, Doc user, PackageDoc userPackage)
2254:       Map packageToUsageTypeMap = (Map)usedClassToPackagesMap.get(usedClass);
2257:          usedClassToPackagesMap.put(usedClass, packageToUsageTypeMap);
2279:       ClassDoc[] classes = rootDoc.classes();
2280:       for (int i = 0, ilim = classes.length; i < ilim; ++ i) {
2281:          ClassDoc clazz = classes[i];
2283:          // classes derived from
2284:          for (ClassDoc superclass = clazz.superclass(); superclass != null;
2285:               superclass = superclass.superclass()) {
2294:             ClassDoc fieldType = field.type().asClassDoc();
2307:             ClassDoc returnType = method.returnType().asClassDoc();
2318:                ClassDoc parameterType = parameter.type().asClassDoc();
2327:             ClassDoc[] thrownExceptions = method.thrownExceptions();
2329:                ClassDoc thrownException = thrownExceptions[k];
2346:                ClassDoc parameterType = parameter.type().asClassDoc();
2355:             ClassDoc[] thrownExceptions = constructor.thrownExceptions();
2357:                ClassDoc thrownException = thrownExceptions[k];
2365:    private void outputUsage(ClassDoc clazz, int level) {
2385:                   if (user instanceof ClassDoc) {
243:     *  Set in outputClassDoc().
319:       if (null != typeAsClassDoc) {
320:          isIncluded = typeAsClassDoc.isIncluded();
321:          packageName = typeAsClassDoc.containingPackage().name();
465:       Arrays.sort(allClasses);
468:          for (int i = 0, ilim = allClasses.length; i < ilim; ++ i) {
543:       while (superclassDoc != null) {
547:          printAtomTag(3, "containingPackage name=\"" + superclassDoc.containingPackage().name() + "\"");
549:          MethodDoc[] superMethods = superclassDoc.methods();
556:          FieldDoc[] superFields = superclassDoc.fields();
579:       if (null != superClassDoc) {
580:          level = outputHeritageOpen(level, superClassDoc);
590:       if (null != superClassDoc) {
591:          outputHeritageClose(level + 1, superClassDoc);
897:                = new TargetContext(DocTranslet.fromClasspath("/doctranslets/html/gjdoc.xsl"),
942:                               = new TargetContext(DocTranslet.fromClasspath("/doctranslets/info/gengj.xsl"),
952:                   targetContext = new TargetContext(DocTranslet.fromClasspath("/doctranslets/docbook/gengj.xsl"),
962:                      = new TargetContext(DocTranslet.fromClasspath("/doctranslets/docbook/gengj.xsl"),
1350:             boolean hasDeprecatedClasses = false;
1373:                         hasDeprecatedClasses = true;
1449:             if (hasDeprecatedClasses) printAtomTag(1, "hasDeprecatedClasses");
1461:             for (int i=0, ilim=specifiedClasses.length; i<ilim; ++i) {
1465:             specifiedClasses = null;
1526:             for (int i=0, ilim=sumclasses.length; i<ilim; ++i) {
1528:                outputClassDocSummary(c);
1530:             sumclasses = null;
1569:                outputClassDoc(c);
1652:             //DocTranslet docTranslet = DocTranslet.fromClasspath("/doctranslets/html/gjdoc.xsl");
2098:       for (int i=0, ilim=sumclasses.length; i<ilim; ++i) {
2367:       Map packageToUsageTypeMap = (Map)usedClassToPackagesMap.get(clazz);
github.com/hanwen/artisjokke:needle2d/needle-inserter.hh:[master, ] lang:c++
6: #define NEEDLE_INSERTER
13: class Needle_inserter : public Deformation_hook
29:   Link_array<Node> needle_;
36:   Array<Vector2> needle_params_;
2:   declare Needle_inserter
5: #ifndef NEEDLE_INSERTER
44:   Auto_needle_insert * auto_insert_;
49:   void dump_needle_forces (const char *);
54:   Needle_inserter (Maubach_tree*, Deformation_state*);
55:   void move_needle (Vector2 h, Vector2 t);
58:   void auto_needle_insert ();
61:   void refine_around_needle_tip (Vector2,Vector2);
64:   void print_needle ();  
github.com/hanwen/artisjokke:needle2d/artisjokke-drawer2.hh:[master, ] lang:c++
12:   Needle_inserter * needle_inserter_;
6: #include "needle-inserter.hh"
8: class Artisjokke_drawer2 : public Artisjokke_drawer
18:   virtual void set_needle ();
20:   virtual void draw_needle ();
github.com/google/mysql-protobuf:unittest/gunit/item_like-t.cc:[mysql-5.7.9, ] lang:c++
104:   const char *m_needle;
121:   const char *m_needle;
124: static const char *needles[] = {
218: static const char* falseNeedles[] = {
25: #include "sql_class.h"
39: class ItemLikeTest : public ::testing::Test
60:   const char needle[]= "%ACAGGTGCTGGAGAGGATGCGGAGAAATAGGAACA%" ;
62:   Item_string *it_needle=
63:     new Item_string(STRING_WITH_LEN(needle), &my_charset_latin1);
65:     new Item_func_like(it_haystack, it_needle, it_escape, false);
78:   const char needle[]= "%CAAAACCACTATGAGATATCATCTCACACCAGTTA%";
79:   Item_string *it_needle=
80:     new Item_string(STRING_WITH_LEN(needle), &my_charset_latin1);
83:     new Item_func_like(it_haystack, it_needle, it_escape, false);
91: class ItemLikeTestP : public ::testing::TestWithParam<const char*>
97:     m_needle= GetParam();
108: class ItemFalseLikeTestP : public ::testing::TestWithParam<const char*>
114:     m_needle= GetParam();
207:   Item_string *it_needle=
208:     new Item_string(m_needle, strlen(m_needle), &my_charset_latin1);
213:     new Item_func_like(it_haystack, it_needle, it_escape, false);
296:   Item_string *it_needle=
297:     new Item_string(m_needle, strlen(m_needle), &my_charset_latin1);
302:     new Item_func_like(it_haystack, it_needle, it_escape, false);
200:                         ::testing::ValuesIn(needles));
199: INSTANTIATE_TEST_CASE_P(MoreNeedles, ItemLikeTestP,
203: TEST_P(ItemLikeTestP, MoreNeedlesTest)
289: INSTANTIATE_TEST_CASE_P(FalseNeedlesTest, ItemFalseLikeTestP,
290:                         ::testing::ValuesIn(falseNeedles));
292: TEST_P(ItemFalseLikeTestP,FalseNeedlesTest)
chromium.googlesource.com/native_client/nacl-toolchain:gdb/sim/common/sim-fpu.h:[master, ] lang:c++
89: } sim_fpu_class;
83:   sim_fpu_class_zero,
84:   sim_fpu_class_snan,
85:   sim_fpu_class_qnan,
86:   sim_fpu_class_number,
87:   sim_fpu_class_denorm,
88:   sim_fpu_class_infinity,
92:   sim_fpu_class class;
346: /* General number class and comparison operators.
46:    Needless to say the results, while better than for a packed 64 bit
297: /* Specific number classes.
chromium.googlesource.com/arc/arc:third_party/chromium-ppapi/content/public/android/javatests/src/org/chromium/content/browser/ClipboardTest.java:[master, ] lang:java
33:     private static final String EXPECTED_HTML_NEEDLE = "http://www.example.com/";
25: public class ClipboardTest extends ContentShellTestBase {
78:         assertTrue(htmlText.contains(EXPECTED_HTML_NEEDLE));
android.googlesource.com/platform/external/qt:Windows-4.7.4/tools/qdoc3/cppcodeparser.cpp:[master, ] lang:c++
61: #define COMMAND_CLASS                   Doc::alias("class")
88: #define COMMAND_QMLCLASS                Doc::alias("qmlclass")
1608: bool CppCodeParser::matchClassDecl(InnerNode *parent,
194:         // remove needless (and needful) class prefixes
229:     nodeTypeMap.insert(COMMAND_CLASS, Node::Class);
230:     nodeTypeMap.insert(COMMAND_SERVICE, Node::Class);
257:   the same function in the base class.
348:   I think the most important thing it does is resolve class
532:     return QSet<QString>() << COMMAND_CLASS
689:             // class with the actual service name.
704:         if (command == COMMAND_CLASS) {
742:             Node* n = tre->findNode(names[1].split("::"),Node::Class);
971:                     tr("The function either doesn't exist in any base class "
978:               another function in a base class.
1005:                                                       Node::Class));
1606:   Parse a C++ class, union, or struct declarion.
1611:     bool isClass = (tok == Tok_class);
1624:       So far, so good. We have 'class Foo {' or 'class Foo :'.
1625:       This is enough to recognize a class definition.
1936:         case Tok_class:
416:   \a fuzzy is true, base classes are searched. The function
549:                            << COMMAND_QMLCLASS
692:                 ClassNode *cnode = static_cast<ClassNode *>(node);
707:                     ClassNode*cnode = static_cast<ClassNode*>(node);
738:     else if (command == COMMAND_QMLCLASS) {
739:         const ClassNode* classNode = 0;
744:                 classNode = static_cast<const ClassNode*>(n);
747:             return new QmlClassNode(tre->root(), QLatin1String("QML:")+names[0], classNode);
749:             return new QmlClassNode(tre->root(), names[0], classNode);
760:         QmlClassNode* qmlClass = 0;
765:             if (n && n->subType() == Node::QmlClass) {
766:                 qmlClass = static_cast<QmlClassNode*>(n);
768:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,false,COMMAND_QMLSIGNAL);
770:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,true,COMMAND_QMLATTACHEDSIGNAL);
772:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,false,COMMAND_QMLMETHOD);
774:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,true,COMMAND_QMLATTACHEDMETHOD);
872:             if (n && n->subType() == Node::QmlClass) {
873:                 QmlClassNode* qmlClass = static_cast<QmlClassNode*>(n);
874:                 if (qmlClass)
875:                     qmlPropGroup = new QmlPropGroupNode(qmlClass,
881:             const ClassNode *correspondingClass = static_cast<const QmlClassNode*>(qmlPropGroup->parent())->classNode();
885:             if (correspondingClass) {
1037:         if (node->subType() == Node::QmlClass) {
1557: bool CppCodeParser::matchBaseSpecifier(ClassNode *classe, bool isClass)
1575:         access = isClass ? Node::Private : Node::Public;
1581:     CodeChunk baseClass;
1582:     if (!matchDataType(&baseClass))
1585:     tre->addBaseClass(classe,
1587:                       baseClass.toPath(),
1588:                       baseClass.toString(),
1589:                       classe->parent());
1593: bool CppCodeParser::matchBaseList(ClassNode *classe, bool isClass)
1596:         if (!matchBaseSpecifier(classe, isClass))
1627:     ClassNode *classe = new ClassNode(parent, previousLexeme());
1628:     classe->setAccess(access);
1629:     classe->setLocation(location());
1631:         classe->setStatus(Node::Compat);
1633:         classe->setModuleName(moduleName);
1634:     classe->setTemplateStuff(templateStuff);
1636:     if (match(Tok_Colon) && !matchBaseList(classe, isClass))
1642:     access = isClass ? Node::Private : Node::Public;
1646:     bool matches = (matchDeclList(classe) && match(Tok_RightBrace) &&
356:     QMapIterator<QString, QString> i(sequentialIteratorClasses);
364:     i = mutableSequentialIteratorClasses;
372:     i = associativeIteratorClasses;
380:     i = mutableAssociativeIteratorClasses;
392:     sequentialIteratorClasses.clear();
393:     mutableSequentialIteratorClasses.clear();
394:     associativeIteratorClasses.clear();
395:     mutableAssociativeIteratorClasses.clear();
427:     int flags = fuzzy ? int(Tree::SearchBaseClasses) : 0;
1038:             QmlClassNode::addInheritedBy(arg,node);
1939:             matchClassDecl(parent, templateStuff);
1994:                 sequentialIteratorClasses.insert(previousLexeme(),
2001:                 mutableSequentialIteratorClasses.insert(previousLexeme(),
2008:                 associativeIteratorClasses.insert(previousLexeme(),
2015:                 mutableAssociativeIteratorClasses.insert(previousLexeme(),
github.com/google/coursebuilder-android-container-module:android/worker.py:[master, ] lang:python
110: _ACCEPT_LICENSE_NEEDLE = 'Do you accept the license'
133: _GRADLEW_INSTALL_SUCCESS_NEEDLE = 'BUILD SUCCESSFUL'
145: _TEST_FAILURE_NEEDLE = 'FAILURES!!!\r'
268: class Config(object):
289: class Error(Exception):
290:     """Base error class."""
293: class LockError(Error):
297: class Lock(object):
340: class Patch(object):
347: class TestRun(object):
635: class _Project(object):
638:             self, name, editor_file, package, path, test_class, test_package):
643:         self.test_class = test_class
724:             _Sdk.get_adb(), 'shell', 'am', 'instrument', '-w', '-e', 'class',
725:             self.test_class,
779:         return _GRADLEW_INSTALL_SUCCESS_NEEDLE not in result
782:         return _TEST_FAILURE_NEEDLE in result
785: class _Runtime(object):
1050: class _Sdk(object):
1111:             if _ACCEPT_LICENSE_NEEDLE in line and not process.poll():
1161: class _TestEnvironment(object):
1283:             src_project.package, test_project_path, src_project.test_class,
280:     @classmethod
306:     @classmethod
310:     @classmethod
322:     @classmethod
331:     @classmethod
646:     @classmethod
651:             value['testClass'], value['testPackage'])
797:     @classmethod
1056:     @classmethod
1067:     @classmethod
1071:     @classmethod
1075:     @classmethod
1079:     @classmethod
1091:     @classmethod
1095:     @classmethod
1101:     @classmethod
1105:     @classmethod
1125:     @classmethod
1131:     @classmethod
1135:     @classmethod
1144:     @classmethod
1153:     @classmethod
1188:     @classmethod
1210:     @classmethod
1214:     @classmethod
chromium.googlesource.com/chromium/src/codesearch:third_party/perl/perl/lib/Fatal.pm:[master, ] lang:perl
1216: sub exception_class { return "autodie::exception" };
187:     my $class        = shift(@_);
292:             my $sub_ref = $class->_make_fatal(
324:             $class->_install_subs($pkg, \%unload_later);
355:     my ($class, $pkg, $subs_to_reinstate) = @_;
395:     my $class = shift;
399:         croak(sprintf(ERROR_NO_LEX,$class));
440:             $class->_install_subs($pkg, { $symbol => $original_sub });
447:         $class->_install_subs($pkg,{ $symbol => undef });
464:         my ($class, $tag) = @_;
471:             croak "Invalid exception class $tag";
537:     my ($class, $core, $call, $name, $void, $lexical, $sub, $sref, @argvs) = @_;
544:         return $class->_one_invocation($core,$call,$name,$void,$sub,! $lexical, $sref, @argv);
566:         push @out, $class->_one_invocation($core,$call,$name,$void,$sub,! $lexical, $sref, @argv);
602:     my ($class, $core, $call, $name, $void, $sub, $back_compat, $sref, @argv) = @_;
605:     # If someone is calling us directly (a child class perhaps?) then
611:         Carp::confess("Internal error: :void mode not supported with $class");
738:         die $class->throw(
740:             pragma => q{$class}, errno => \$!,
798:     # the 'unopened' warning class here.  Especially since they
908:     my($class, $sub, $pkg, $void, $lexical, $filename, $insist) = @_;
928:     croak(sprintf(ERROR_BADNAME, $class, $name)) unless $name =~ /^\w+$/;
1068:     if (my $subref = $Cached_fatalised_sub{$class}{$sub}{$void}{$lexical}) {
1069:         $class->_install_subs($pkg, { $name => $subref });
1083:     $code .= $class->_write_invocation($core, $call, $name, $void, $lexical, $sub, $sref, @protos);
1194:         die "Internal error in $class: Leak-guard installation failure: $E" if $E;
1199:     $class->_install_subs($pkg, { $name => $installed_sub });
1201:     $Cached_fatalised_sub{$class}{$sub}{$void}{$lexical} = $installed_sub;
1213: # it to point to their own exception class.  Doing this is significantly
1219:     my %exception_class_for;
1220:     my %class_loaded;
1223:         my ($class, @args) = @_;
1225:         # Find our exception class if we need it.
1226:         my $exception_class =
1227:              $exception_class_for{$class} ||= $class->exception_class;
1229:         if (not $class_loaded{$exception_class}) {
1230:             if ($exception_class =~ /[^\w:']/) {
1231:                 confess "Bad exception class '$exception_class'.\nThe '$class->exception_class' method wants to use $exception_class\nfor exceptions, but it contains characters which are not word-characters or colons.";
1242:                 my $pm_file = $exception_class . ".pm";
1252:             confess "Failed to load '$exception_class'.\nThis may be a typo in the '$class->exception_class' method,\nor the '$exception_class' module may not exist.\n\n $E" if $E;
1254:             $class_loaded{$exception_class}++;
1258:         return $exception_class->new(@args);
1281:     my ($class, $handler) = @_;
1283:     return bless $handler, $class;
211:         # Don't allow :lexical with :void, it's needlessly confusing.
274:             # needlessly confusing on p5p.
721:                 # classes!
1212: # This subroutine exists primarily so that child classes can override
chromium.googlesource.com/chromium/codesearch:src/content/public/android/javatests/src/org/chromium/content/browser/ClipboardTest.java:[master, ] lang:java
duplicate result
android.googlesource.com/platform/superproject:external/c-ares/adig.c:[master, ] lang:c
800: static const char *class_name(int dnsclass)
118: static const struct nv classes[] = {
124: static const int nclasses = sizeof(classes) / sizeof(classes[0]);
191: static const char *class_name(int dnsclass);
302:           /* Set the query class. */
526:   /* Parse the question type and class. */
528:   dnsclass = DNS_QUESTION_CLASS(aptr);
536:     printf("\t%s", class_name(dnsclass));
572:   dnsclass = DNS_RR_CLASS(aptr);
582:   /* Display the RR name, class, and type. */
585:     printf("\t%s", class_name(dnsclass));
814:   fprintf(stderr, "usage: adig [-f flag] [-s server] [-c class] "
200:   int c, i, optmask = ARES_OPT_FLAGS, dnsclass = C_IN, type = T_A;
297:            * ares_init_options() will do needless work. */
305:               if (strcasecmp(classes[i].name, optarg) == 0)
309:             dnsclass = classes[i].value;
376:     ares_query(channel, *argv, dnsclass, type, callback, (char *) NULL);
380:         ares_query(channel, *argv, dnsclass, type, callback, *argv);
508:   int type, dnsclass, status;
535:   if (dnsclass != C_IN)
546:   int type, dnsclass, ttl, dlen, status;
584:   if (dnsclass != C_IN)
806:       if (classes[i].value == dnsclass)
807:         return classes[i].name;
303:           for (i = 0; i < nclasses; i++)
308:           if (i < nclasses)
804:   for (i = 0; i < nclasses; i++)