Search some code: Max results:

Found 3342 results in 220 files (16MB index data, 9951556 ngram matches, 837075 docs considered, 270 docs (8134KB) loaded, 7696 docs skipped): for
(and substr:"class" case_substr:"Needle") with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}
in 1.817895361s (queued: 2.856┬Ás)

github.com/google/DirectXShaderCompiler:tools/clang/lib/Sema/AnalysisBasedWarnings.cpp:[master, ]

578:   const DeclRefExpr *Needle;
63:   class UnreachableCodeHandler : public reachable_code::Callback {
122: class LogicalErrorHandler : public CFGCallback {
202:         // Skip function calls which are qualified with a templated class.
573: /// ContainsReference - A visitor class to search for references to
576: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
583:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
584:     : Inherited(Context), 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 {
239:   // 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.
1904:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1905:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1906:       .setAlwaysAdd(Stmt::BlockExprClass)
1907:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1908:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1909:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1910:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1911:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/google/rekall:rekall-gui/manuskript/static/bower_components/markdown/test/fixtures/Markdown-from-MDTest1.1.mdtest/Markdown_Documentation_-_Syntax.json:[master, ]
15:         "class": "selected",
264:     ["pre", ["code", "    <div class=\"footer\">\u000a        &copy; 2004 Foo Corporation\u000a    </div>\u000a"]],
266:     ["pre", ["code", "<pre><code>&lt;div class=\"footer\"&gt;\u000a    &amp;copy; 2004 Foo Corporation\u000a&lt;/div&gt;\u000a</code></pre>\u000a"]],
149:     ["p", "in your anchor tag ", ["code", "href"], " attribute. Needless to say, this is easy to\u000aforget, and is probably the single most common source of HTML validation\u000aerrors in otherwise well-marked-up web sites."],
github.com/fuchsia-mirror/third_party-cmake:Source/cmTarget.cxx:[master, ]
565:   const cmSourceFileLocation& Needle;
581:   const cmSourceFileLocation& Needle;
160: class cmTargetInternals
568:     : Needle(needle)
574:     return loc.Matches(this->Needle);
585:     : Needle(needle)
595:                    CreateLocation(this->Needle.GetMakefile()));
598:                         LocationMatcher(this->Needle)) != locations.end();
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
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);
android.googlesource.com/platform/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
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);
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
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);
github.com/llvm-mirror/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
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);
github.com/hanwen/artisjokke:needle3d/needle-inserter3.hh:[master, ]
10: class Needle_inserter3 : public Deformation_hook,  public Element_watcher
12:   enum Needle_state {
16:   Needle_state state_;
55:   Needle_inserter3 (Maubach_tree3*, Deformation_state*);
github.com/hanwen/artisjokke:needle2d/needle-inserter.hh:[master, ]
13: class Needle_inserter : public Deformation_hook
2:   declare Needle_inserter
54:   Needle_inserter (Maubach_tree*, Deformation_state*);
kernel.googlesource.com/pub/scm/linux/kernel/git/torvalds/linux:drivers/char/xillybus/xillybus_core.c:[master, ]
64: static struct class *xillybus_class;
1846: 		device = device_create(xillybus_class,
1868: 		device_destroy(xillybus_class, MKDEV(major, i));
1884: 		device_destroy(xillybus_class, MKDEV(endpoint->major, minor));
2085: 	xillybus_class = class_create(THIS_MODULE, xillyname);
2086: 	if (IS_ERR(xillybus_class))
2087: 		return PTR_ERR(xillybus_class);
2091: 		class_destroy(xillybus_class);
2103: 	class_destroy(xillybus_class);
84:  * They are held for short direct memory manipulations. Needless to say,
github.com/google/capsicum-linux:drivers/char/xillybus/xillybus_core.c:[capsicum, ]
64: static struct class *xillybus_class;
1846: 		device = device_create(xillybus_class,
1868: 		device_destroy(xillybus_class, MKDEV(major, i));
1884: 		device_destroy(xillybus_class, MKDEV(endpoint->major, minor));
2085: 	xillybus_class = class_create(THIS_MODULE, xillyname);
2086: 	if (IS_ERR(xillybus_class))
2087: 		return PTR_ERR(xillybus_class);
2091: 		class_destroy(xillybus_class);
2103: 	class_destroy(xillybus_class);
84:  * They are held for short direct memory manipulations. Needless to say,
github.com/gwtproject/gwt:samples/dynatable/src/com/google/gwt/sample/dynatable/server/SchoolCalendarServiceImpl.java:[master, ]
52:   private static final int CLASS_LENGTH_MINS = 50;
34: public class SchoolCalendarServiceImpl extends RemoteServiceServlet implements
146:       int absStopMins = absStartMins + CLASS_LENGTH_MINS;
43:       "Crutcher", "Needler", "Wilson", "Chase", "Edelstein"};
168:     generateRandomSchedule(student.getClassSchedule());
github.com/google/ktsan:drivers/char/xillybus/xillybus_core.c:[tsan, ]
64: static struct class *xillybus_class;
1844: 		device = device_create(xillybus_class,
1866: 		device_destroy(xillybus_class, MKDEV(major, i));
1882: 		device_destroy(xillybus_class, MKDEV(endpoint->major, minor));
2083: 	xillybus_class = class_create(THIS_MODULE, xillyname);
2084: 	if (IS_ERR(xillybus_class))
2085: 		return PTR_ERR(xillybus_class);
2089: 		class_destroy(xillybus_class);
2101: 	class_destroy(xillybus_class);
84:  * They are held for short direct memory manipulations. Needless to say,
github.com/fuchsia-mirror/third_party-binutils-gdb:sim/common/sim-fpu.h:[master, ]
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.
github.com/fuchsia-mirror/third_party-gdb:sim/common/sim-fpu.h:[master, ]
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.
github.com/gwtproject/gwt:user/test/com/google/gwt/uibinder/test/client/NeedlesslyAnnotatedLabel.java:[master, ]
25: public class NeedlesslyAnnotatedLabel extends Label {
26:   @UiConstructor public NeedlesslyAnnotatedLabel() {
github.com/google/error-prone:check_api/src/test/java/com/google/errorprone/names/NeedlemanWunschEditDistanceTest.java:[master, ]
27: public class NeedlemanWunschEditDistanceTest {
26: @RunWith(JUnit4.class)
25: /** Tests for NeedlemanWunschEditDistance */
34:         NeedlemanWunschEditDistance.getEditDistance(
47:         NeedlemanWunschEditDistance.getEditDistance(
62:         NeedlemanWunschEditDistance.getWorstCaseEditDistance(
github.com/google/error-prone:check_api/src/main/java/com/google/errorprone/names/NeedlemanWunschEditDistance.java:[master, ]
30: public final class NeedlemanWunschEditDistance {
32:   private NeedlemanWunschEditDistance() {
20:  * The Needleman-Wunsch algorithm for finding least-cost string edit distances between pairs of
26:  * <p>See http://en.wikipedia.org/wiki/Needleman-Wunsch_algorithm
github.com/google/pepper.js:examples/mouselock/mouselock.cc:[master, ]
268: void MouseLockInstance::DrawNeedle(pp::ImageData* image,
48:   RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE |
49:                      PP_INPUTEVENT_CLASS_KEYBOARD);
355: class MouseLockModule : public pp::Module {
217:   DrawNeedle(&image, kForegroundColor);
271:     Log("DrawNeedle with NULL image");
github.com/googleglass/gdk-compass-sample:app/src/main/java/com/google/android/glass/sample/compass/CompassView.java:[master, ]
341:     private void drawNeedle(Canvas canvas, boolean bottom) {
50: public class CompassView extends View {
217:         drawNeedle(canvas, false);
218:         drawNeedle(canvas, true);
github.com/bazelbuild/bazel:src/main/java/com/google/devtools/build/lib/rules/android/AndroidCommon.java:[master, ]
121:   private Artifact classJar;
124:   private Artifact genClassJar;
126:   private Artifact resourceClassJar;
826:   public Artifact getGenClassJar() {
838:   public Artifact getResourceClassJar() {
73:  * A helper class for android rules.
78: public class AndroidCommon {
87:       RuleContext ruleContext, Mode mode, final Class<T> classType) {
170:         AndroidNeverLinkLibrariesProvider.class)) {
177:           deps, JavaCompilationArgsProvider.class)) {
350:       // Needle index is exhausted, so the needle must match.
369:         ruleContext, Mode.TARGET, NativeLibsZipsProvider.class);
389:     // We don't actually use the ijar. That is almost the same as the resource class jar
406:         AndroidRuleClasses.ANDROID_RESOURCES_CLASS_JAR);
413:     // Only build the class jar if it's not already generated internally by resource processing.
433:       // Otherwise, it should have been the AndroidRuleClasses.ANDROID_RESOURCES_CLASS_JAR.
437:                   AndroidRuleClasses.ANDROID_RESOURCES_CLASS_JAR)));
509:     classJar = ruleContext.getImplicitOutputArtifact(AndroidRuleClasses.ANDROID_LIBRARY_CLASS_JAR);
517:               .getProvider(FileProvider.class)
542:       // Use a fast-path R class generator for android_binary with local resources, where there is
543:       // a bottleneck. For legacy resources, the srcjar and R class compiler don't match up
714:       builder.add(GeneratedExtensionRegistryProvider.class, generatedExtensionRegistryProvider);
748:         .add(JavaRuleOutputJarsProvider.class, ruleOutputJarsProvider)
749:         .add(JavaSourceJarsProvider.class, sourceJarsProvider)
751:             JavaRuntimeJarProvider.class,
753:         .add(RunfilesProvider.class, RunfilesProvider.simple(getRunfiles()))
754:         .add(AndroidResourcesProvider.class, resourceApk.toResourceProvider(ruleContext.getLabel()))
756:             AndroidIdeInfoProvider.class,
767:         .add(JavaCompilationArgsProvider.class, compilationArgsProvider)
805:     return prerequisite.getProvider(AndroidResourcesProvider.class);
818:         && ruleContext.getFragment(AndroidConfiguration.class).allowSrcsLessAndroidLibraryDeps();
891:     return context.getConfiguration().getFragment(AndroidConfiguration.class);
897:         getTransitivePrerequisites(ruleContext, Mode.TARGET, OutputGroupProvider.class)) {
46: import com.google.devtools.build.lib.rules.java.ClasspathConfiguredFragment;
50: import com.google.devtools.build.lib.rules.java.JavaCompilationArgs.ClasspathType;
92:         builder.add(ruleContext.getPrerequisites(attr, mode, classType));
191:       Artifact jarToDex, Artifact classesDex, List<String> dexOptions, boolean multidex,
211:     args.add("--output=" + classesDex.getExecPathString());
217:         .addOutput(classesDex)
386:     // Add the compiled resource jar to the classpath of the main compilation.
388:     // Add the compiled resource jar to the classpath of consuming targets.
457:       // combined resource constants copy needs to come before library classes that may contain
510:     idlHelper = new AndroidIdlHelper(ruleContext, classJar);
552:         // Combined resource constants needs to come even before our own classes that may contain
593:     this.jarsProducedForRuntime = jarsProducedForRuntime.add(classJar).build();
604:     helper.addLibrariesToAttributes(javaCommon.targetsTreatedAsDeps(ClasspathType.COMPILE_ONLY));
605:     attributes.setRuleKind(ruleContext.getRule().getRuleClass());
609:         javaCommon.targetsTreatedAsDeps(ClasspathType.BOTH));
632:       // We only want to add a jar to the classpath of a dependent rule if it has content.
633:       javaArtifactsBuilder.addRuntimeJar(classJar);
634:       jar = classJar;
637:     filesBuilder.add(classJar);
639:     manifestProtoOutput = helper.createManifestProtoOutput(classJar);
644:       genClassJar = helper.createGenJar(classJar);
645:       genSourceJar = helper.createGensrcJar(classJar);
646:       helper.createGenJarAction(classJar, manifestProtoOutput, genClassJar);
655:     outputDepsProto = helper.createOutputDepsProtoArtifact(classJar, javaArtifactsBuilder);
656:     helper.createCompileActionWithInstrumentation(classJar, manifestProtoOutput, genSourceJar,
683:         new ClasspathConfiguredFragment(
711:     idlHelper.addTransitiveInfoProviders(builder, classJar, manifestProtoOutput);
724:             .addOutputJar(classJar, iJar, ImmutableList.of(srcJar))
740:         builder, skylarkApiProvider, filesToBuild, classJar, ANDROID_COLLECTION_SPEC);
843:    * Returns Jars produced by this rule that may go into the runtime classpath.  By contrast
844:    * {@link #getRuntimeJars()} returns the complete runtime classpath needed by this rule, including
865:         javaCommon.targetsTreatedAsDeps(ClasspathType.BOTH), ImmutableList.<String>of());
933:       compileDeps = JavaCommon.defaultDeps(ruleContext, semantics, ClasspathType.COMPILE_ONLY);
935:       runtimeDeps = JavaCommon.defaultDeps(ruleContext, semantics, ClasspathType.RUNTIME_ONLY);
936:       bothDeps = JavaCommon.defaultDeps(ruleContext, semantics, ClasspathType.BOTH);
240:             .setIdlClassJar(idlHelper.getIdlClassJar())
293:     String packageName = JavaUtil.getJavaFullClassname(nameFragment);
383:       boolean useRClassGenerator)
385:     compileResourceJar(javaSemantics, resourceApk, resourcesJar, useRClassGenerator);
387:     attributes.addDirectJars(NestedSetBuilder.create(Order.STABLE_ORDER, resourceClassJar));
392:     artifactsBuilder.addCompileTimeJar(resourceClassJar);
396:     filesBuilder.add(resourceClassJar);
401:       boolean useRClassGenerator)
404:         AndroidRuleClasses.ANDROID_RESOURCES_SOURCE_JAR);
405:     resourceClassJar = ruleContext.getImplicitOutputArtifact(
414:     if (resourceApk.getResourceJavaClassJar() == null) {
415:       if (useRClassGenerator) {
416:         RClassGeneratorActionBuilder actionBuilder =
417:             new RClassGeneratorActionBuilder(ruleContext)
420:                 .setClassJarOut(resourceClassJar);
424:             javacHelper.createOutputDepsProtoArtifact(resourceClassJar, javaArtifactsBuilder);
426:             resourceClassJar,
435:           resourceApk.getResourceJavaClassJar().equals(
459:       attributes.addRuntimeClassPathEntry(resourcesJar);
513:     ImmutableList<Artifact> bootclasspath;
515:       bootclasspath = ImmutableList.<Artifact>builder()
516:           .addAll(ruleContext.getPrerequisite("$desugar_java8_extra_bootclasspath", Mode.HOST)
522:       bootclasspath =
530:             .setBootClassPath(bootclasspath);
545:       boolean useRClassGenerator = isBinary && !resourceApk.isLegacy();
547:           filesBuilder, useRClassGenerator);
554:         artifactsBuilder.addRuntimeJar(resourceClassJar);
555:         jarsProducedForRuntime.add(resourceClassJar);
563:             resourceApk.getPrimaryResource().getJavaPackage(), resourceClassJar);
591:       jarsProducedForRuntime.add(generatedExtensionRegistryProvider.getClassJar());
649:     srcJar = ruleContext.getImplicitOutputArtifact(AndroidRuleClasses.ANDROID_LIBRARY_SOURCE_JAR);
682:     javaCommon.setClassPathFragment(
687:             helper.getBootclasspathOrDefault()));
717:     if (resourceClassJar != null && resourceSourceJar != null) {
718:       resourceJar = new OutputJar(resourceClassJar, null, ImmutableList.of(resourceSourceJar));
741:     javaCommon.addGenJarsProvider(builder, skylarkApiProvider, genClassJar, genSourceJar);
827:     return genClassJar;
839:     return resourceClassJar;
android.googlesource.com/platform/external/swig:Doc/Manual/CPlusPlus11.html:[master, ]
807: <H3><a name="CPlusPlus11_allow_sizeof_to_work_on_members_of_classes_without_an_explicit_object"></a>7.2.24 Allow sizeof to work on members of classes without an explicit object</H3>
11: <div class="sectiontoc">
81: <div class="code"><pre>
82: class MyClass {
96: <div class="code"><pre>
103: <div class="code"><pre>
115: <div class="code"><pre>
116: extern template class std::vector&lt;MyClass&gt;; // explicit instantiation
120: class MyClass {
136: <div class="shell">
144: They often appear in constructors which are overloaded with alternative approaches to initializing a class,
149: <div class="code"><pre>
151: class Container {
160: <p>Alternatively you could modify the class and add another constructor for initialization by some other means,
163: <div class="code"><pre>
165: class Container {
177: <div class="targetlang"><pre>
182: If you are unable to modify the class being wrapped, consider ignoring the initializer-list constructor and using
186: <div class="code"><pre>
199: class Container {
209: The above makes the wrappers look is as if the class had been declared as follows:
212: <div class="code"><pre>
214: class Container {
233: <div class="code"><pre>
237: class Container {
265: <div class="code"><pre>
284: <div class="targetlang"><pre>
298: <div class="code"><pre>
304: <div class="code"><pre>
319: <div class="code"><pre>
333: <div class="code"><pre>
345: <div class="code"><pre>
353: <div class="code"><pre>
365: <div class="targetlang"><pre>
372: <div class="code"><pre>
383: <div class="code"><pre>
384: class A {
398: Constructor inheritance is parsed correctly, but the additional constructors are not currently added to the derived proxy class in the target language. Example is shown below:
405: <div class="code"><pre>
406: class BaseClass {
411: class DerivedClass: public BaseClass {
424: <div class="code"><pre>
448: <p>SWIG parses the new <tt>enum class</tt> syntax and forward declarator for the enums:</p>
449: <div class="code"><pre>
450: enum class MyEnum : unsigned int;
457: <div class="code"><pre>
458: class Color {
459:   enum class PrintingColors : unsigned int {
463:   enum class BasicColors {
467:   enum class AllColors {
476: <div class="code"><pre>
477: class PrintingColors {
483: class BasicColors {
489: class AllColors {
503: <div class="code"><pre>
513: <div class="code"><pre>
514: class U {
519: class V {
524: class TestClass {
549: <div class="code"><pre>
551: class SomeType {
565: <div class="shell">
575: <div class="code"><pre>
583: <div class="shell">
592: <div class="code"><pre>
603: <div class="code"><pre>
626: block, variadic class inheritance and variadic constructor and
629: <div class="code"><pre>
630: template &lt;typename... BaseClasses&gt; class ClassName : public BaseClasses... {
641: <div class="code"><pre>
649: <div class="code"><pre>
662: <div class="code"><pre>
691: <div class="code"><pre>
698: <div class="code"><pre>
706: <div class="code"><pre>
717: <div class="shell"><pre>
726: <div class="code"><pre>
734: <div class="code"><pre>
742: <div class="code"><pre>
754: <div class="code"><pre>
774: <div class="code"><pre>
800: <div class="code"><pre>
813: <div class="code"><pre>
822: <div class="targetlang"><pre>
837: <div class="code"><pre>
883: <div class="code"><pre>
887: template&lt; class F, class P &gt; void g( F f, P t )  { f(t); }
912: <div class="code"><pre>
929: <div class="targetlang"><pre>
939: <div class="code"><pre>
942:   template&lt; class T1, class T2 &gt; int do_it( T1&amp;, T2&amp; )  { /*...*/ }
946:   template&lt; class T1, class T2 &gt; int do_it( T1, T2 )  { /*...*/ }
949: template&lt; class T1, class T2 &gt; int elaborate( T1 A, T2 B ) {
962: <p>SWIG does not wrap the new result_of class introduced in the &lt;functional&gt; header and map the result_of::type to the concrete type yet. For example:</p>
963: <div class="code"><pre>
970: template&lt;class Fun, class Arg&gt;
982: <div class="targetlang"><pre>
39: <li><a href="#CPlusPlus11_allow_sizeof_to_work_on_members_of_classes_without_an_explicit_object">Allow sizeof to work on members of classes without an explicit object</a>
83:   MyClass(MyClass&amp;&amp; p) : ptr(p.ptr) {p.ptr = 0;}
84:   MyClass&amp; operator=(MyClass&amp;&amp; p) {
132: they are intended for compile time initialization of classes using the special <tt>std::initializer_list</tt> type.
248: Needless to say, this approach is very limited, but could be improved upon, but only slightly.
400: The extra constructors provided by the <tt>using</tt> syntax will add the appropriate constructors into the target language proxy derived classes.
401: In the example below a wrapper for the <tt>DerivedClass(int)</tt> is added to <tt>DerivedClass</tt>:
408:   BaseClass(int iValue);
413:   using BaseClass::BaseClass; // Adds DerivedClass(int) constructor
454: This is because SWIG doesn't support nested classes. This is usually not a problem, however, 
474: <p>A workaround is to write these as a series of separated classes containing anonymous enums:</p>
527:         TestClass( U const &amp;val ) { t=val.u; }
529:         explicit TestClass( V const &amp;val ) { t=val.v; }
539: SWIG target languages, because all use their own facilities (eg. classes Cloneable and Comparable in Java)
632:    ClassName (BaseClasses&amp;&amp;... baseClasses) : BaseClasses(baseClasses)... {}
642: %template(MyVariant1) ClassName&lt;&gt;         // zero argument not supported yet
643: %template(MyVariant2) ClassName&lt;int&gt;      // ok
644: %template(MyVariant3) ClassName&lt;int, int&gt; // too many arguments not supported yet
650: const int SIZE = sizeof...(ClassName&lt;int, int&gt;);
851: classes introduced (thread, mutex, locks, condition variables, task). The main reason is that
857: <p>SWIG does not wrap the new tuple types and the unordered_ container classes yet. Variadic template support is working so it is possible to
863: <p>SWIG does not wrap the new C++11 regular expressions classes, because the SWIG target languages use their own facilities for this.</p>
881: <p>The new ref and cref classes are used to instantiate a parameter as a reference of a template function. For example:</p>
901: <p>The ref and cref classes are not wrapped by SWIG because the SWIG target languages do not support referencing.</p>
907: SWIG supports functor classes in some languages in a very natural way.
github.com/google/mysql-protobuf:unittest/gunit/item_like-t.cc:[mysql-5.7.9, ]
218: static const char* falseNeedles[] = {
25: #include "sql_class.h"
39: class ItemLikeTest : public ::testing::Test
91: class ItemLikeTestP : public ::testing::TestWithParam<const char*>
108: class ItemFalseLikeTestP : public ::testing::TestWithParam<const char*>
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)
android.googlesource.com/platform/packages/wallpapers/MusicVisualization:src/com/android/musicvis/vis5/Visualization5RS.java:[master, ]
45:     private int mNeedlePos = 0;
46:     private int mNeedleSpeed = 0;
48:     private int mNeedleMass = 10;
35: class Visualization5RS extends RenderScriptScene {
51:     static class WorldState {
358:         // mNeedleSpeed * 3 is for the movement of the needle, which induces an opposite current
360:         // mNeedlePos + mSpringForceAtOrigin is for the force of the spring pushing the needle back
361:         int netforce = volt - mNeedleSpeed * 3 - (mNeedlePos + mSpringForceAtOrigin) ;
362:         int acceleration = netforce / mNeedleMass;
363:         mNeedleSpeed += acceleration;
364:         mNeedlePos += mNeedleSpeed;
365:         if (mNeedlePos < 0) {
366:             mNeedlePos = 0;
367:             mNeedleSpeed = 0;
368:         } else if (mNeedlePos > 32767) {
369:             if (mNeedlePos > 33333) {
372:             mNeedlePos = 32767;
373:             mNeedleSpeed = 0;
379:         mWorldState.mAngle = 131f - (mNeedlePos / 410f); // ~80 degree range
android.googlesource.com/platform/packages/wallpapers/MusicVisualization:src/com/android/musicvis/vis4/Visualization4RS.java:[master, ]
45:     private int mNeedlePos = 0;
46:     private int mNeedleSpeed = 0;
48:     private int mNeedleMass = 10;
35: class Visualization4RS extends RenderScriptScene {
51:     static class WorldState {
235:         // mNeedleSpeed * 3 is for the movement of the needle, which induces an opposite current
237:         // mNeedlePos + mSpringForceAtOrigin is for the force of the spring pushing the needle back
238:         int netforce = volt - mNeedleSpeed * 3 - (mNeedlePos + mSpringForceAtOrigin) ;
239:         int acceleration = netforce / mNeedleMass;
240:         mNeedleSpeed += acceleration;
241:         mNeedlePos += mNeedleSpeed;
242:         if (mNeedlePos < 0) {
243:             mNeedlePos = 0;
244:             mNeedleSpeed = 0;
245:         } else if (mNeedlePos > 32767) {
246:             if (mNeedlePos > 33333) {
249:             mNeedlePos = 32767;
250:             mNeedleSpeed = 0;
256:         mWorldState.mAngle = 131f - (mNeedlePos / 410f); // ~80 degree range
github.com/google/csp-evaluator:third_party/closure-library/closure/goog/ui/gaugetheme.js:[master, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/google/beautiful-audio-editor:third_party/closure_library/closure/goog/ui/gaugetheme.js:[master, ]
128: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
140: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/karma-runner/karma-closure:test-app/lib/goog/ui/gaugetheme.js:[master, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/google/crisis-info-hub:closure-library/closure/goog/ui/gaugetheme.js:[master, ]
128: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
140: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/google/closure-library:closure/goog/ui/gaugetheme.js:[master, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/GoogleCloudPlatform/PerfKitExplorer:lib/closure-library/closure/goog/ui/gaugetheme.js:[master, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/GoogleChrome/accessibility-developer-tools:lib/closure-library/closure/goog/ui/gaugetheme.js:[master, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/googlei18n/TachyFont:run_time/src/gae_server/third_party/closure-library/closure/goog/ui/gaugetheme.js:[master, ]
128: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
140: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/GoogleChrome/chromeos_smart_card_connector:third_party/closure-library/src/closure/goog/ui/gaugetheme.js:[master, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/google/gae-secure-scaffold-python:closure-library/closure/goog/ui/gaugetheme.js:[master, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/pagespeed/mod_pagespeed-debian-packaging:src/third_party/closure_library/closure/goog/ui/gaugetheme.js:[master, ]
128: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
140: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/googlemaps/js-v2-samples:fusiontables/script/closure/closure/goog/ui/gaugetheme.js:[gh-pages, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/google/closure-builder:third_party/closure-library/closure/goog/ui/gaugetheme.js:[master, ]
127: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
139: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
github.com/google/csp-evaluator:closure-library/closure/goog/ui/gaugetheme.js:[master, ]
128: goog.ui.GaugeTheme.prototype.getNeedleStroke = function() {
140: goog.ui.GaugeTheme.prototype.getNeedleFill = function(cx, cy, r) {
31:  * A class for the default color theme for a Gauge.
32:  * Users can extend this class to provide a custom color theme, and apply the
android.googlesource.com/platform/external/icu:icu4j/main/classes/core/src/com/ibm/icu/impl/UPropertyAliases.java:[master, ]
32:  * This class performs two functions.
38:  * Needless to say, this class is tightly coupled to the binary format
48: public final class UPropertyAliases {
70:     private static final class IsAcceptable implements ICUBinary.Authenticate {
github.com/google/mysql-protobuf:storage/ndb/mcc/frontend/dojo/dojox/gauges/GlossyCircularGaugeNeedle.js.uncompressed.js:[mysql-5.7.9, ]
17: 	//		Since the needle is created by the gauges class, you do not have to use this class directly.
2: define("dojox/gauges/GlossyCircularGaugeNeedle", ["dojo/_base/declare","dojo/_base/Color" ,"./AnalogIndicatorBase"],
9: return declare("dojox.gauges.GlossyCircularGaugeNeedle", [AnalogIndicatorBase], {
android.googlesource.com/platform/external/qt:Windows-4.7.4/src/corelib/tools/qbytearray.cpp:[master, ]
606:     \class QByteArray
607:     \brief The QByteArray class provides an array of bytes.
622:     In addition to QByteArray, Qt also provides the QString class to
623:     store string data. For most purposes, QString is the class you
1093:     The return value is of type QByteRef, a helper class for
1188:     Note: QByteArray is an \l{implicitly shared} class. Consequently,
1482:     Note: QByteArray is an \l{implicitly shared} class. Consequently,
1562:     Note: QByteArray is an \l{implicitly shared} class. Consequently,
3812:     because QByteArray is an \l{implicitly shared} class and the
2304:     uint hashNeedle = 0, hashHaystack = 0;
2307:         hashNeedle = ((hashNeedle<<1) + *(n-idx));
2313:         if (hashHaystack == hashNeedle && memcmp(needle, haystack, ol) == 0)
gerrit.googlesource.com/zoekt:web/templates.go:[master, ]
74:     <dt><a href="search?q=class+needle">class needle</a></dt><dd>search for files containing both "class" and "needle"
76:     <dt><a href="search?q=class+Needle">class Needle</a></dt><dd>search for files containing both "class" (case insensitive) and "Needle" (case sensitive)
78:     <dt><a href="search?q=class+Needle+case:yes">class Needle case:yes</a></dt><dd>search for files containing "class" and "Needle", both case sensitively
80:     <dt><a href="search?q=%22class Needle%22">"class Needle"</a></dt><dd>search for files with the phrase "class Needle"
github.com/google/zoekt:web/templates.go:[master, ]
74:     <dt><a href="search?q=class+needle">class needle</a></dt><dd>search for files containing both "class" and "needle"
76:     <dt><a href="search?q=class+Needle">class Needle</a></dt><dd>search for files containing both "class" (case insensitive) and "Needle" (case sensitive)
78:     <dt><a href="search?q=class+Needle+case:yes">class Needle case:yes</a></dt><dd>search for files containing "class" and "Needle", both case sensitively
80:     <dt><a href="search?q=%22class Needle%22">"class Needle"</a></dt><dd>search for files with the phrase "class Needle"
github.com/google/csp-evaluator:third_party/closure-library/closure/goog/ui/gauge.js:[master, ]
45:  * This is an internal-only class.
979:   goog.ui.Gauge.superClass_.enterDocument.call(this);
995:   goog.ui.Gauge.superClass_.exitDocument.call(this);
1008:   goog.ui.Gauge.superClass_.disposeInternal.call(this);
959:   var stroke = theme.getNeedleStroke();
960:   var fill = theme.getNeedleFill(cx, cy, rh);
github.com/google/rekall:tools/linux/vmcs_layout/vmcs_layout.c:[master, ]
228:         // Needle not found, so we'll probably need to force-flush.
230:         printk("[i] Needle not found. Force-flush technique required.\n");
279:         printk("[!] Needle found in memory. Force-flush is NOT required.\n");
30: // Needles used to discover the VMCS
434:     printk("  \"ProfileClass\": \"VMCSProfile\"\n");
github.com/googlei18n/language-resources:utils/edist.py:[master, ]
27: class EditDistance:
47:     # This is the standard Levenshtein-Viterbi-Vintsyuk-Needleman-Wunsch-
128:   """Cost function for what is now thought of as the classical
github.com/google/beautiful-audio-editor:third_party/closure_library/closure/goog/ui/gauge.js:[master, ]
44:  * This is an internal-only class.
983:   goog.ui.Gauge.superClass_.enterDocument.call(this);
999:   goog.ui.Gauge.superClass_.exitDocument.call(this);
1012:   goog.ui.Gauge.superClass_.disposeInternal.call(this);
963:   var stroke = theme.getNeedleStroke();
964:   var fill = theme.getNeedleFill(cx, cy, rh);
github.com/Polymer/core-home-page-dev:components/marked/test/tests/markdown_documentation_syntax.text:[master, ]
7:     <li><a class="selected" title="Markdown Syntax Documentation">Syntax</a></li>
505:         <div class="footer">
511:     <pre><code>&lt;div class="footer"&gt;
140: in your anchor tag `href` attribute. Needless to say, this is easy to
github.com/Polymer/core-home-page-dev:components/marked/test/tests/markdown_documentation_syntax.html:[master, ]
6:     <li><a class="selected" title="Markdown Syntax Documentation">Syntax</a></li>
525: <pre><code>    &lt;div class=&quot;footer&quot;&gt;
532: <pre><code>&lt;pre&gt;&lt;code&gt;&amp;lt;div class=&quot;footer&quot;&amp;gt;
138: <p>in your anchor tag <code>href</code> attribute. Needless to say, this is easy to