\nAPL mode\n\n⍝ Conway's game of life\n\n⍝ This example was inspired by the impressive demo at\n⍝ http://www.youtube.com/watch?v=a9xAKttWgP4\n\n⍝ Create a matrix:\n⍝ 0 1 1\n⍝ 1 1 0\n⍝ 0 1 0\ncreature ← (3 3 ⍴ ⍳ 9) ∈ 1 2 3 4 7 ⍝ Original creature from demo\ncreature ← (3 3 ⍴ ⍳ 9) ∈ 1 3 6 7 8 ⍝ Glider\n\n⍝ Place the creature on a larger board, near the centre\nboard ← ¯1 ⊖ ¯2 ⌽ 5 7 ↑ creature\n\n⍝ A function to move from one generation to the next\nlife ← {∨/ 1 ⍵ ∧ 3 4 = ⊂+/ +⌿ 1 0 ¯1 ∘.⊖ 1 0 ¯1 ⌽¨ ⊂⍵}\n\n⍝ Compute n-th generation and format it as a\n⍝ character matrix\ngen ← {' #'[(life ⍣ ⍵) board]}\n\n⍝ Show first three generations\n(gen 1) (gen 2) (gen 3)\n\n\n \n\n Simple mode that tries to handle APL as well as it can.\n It attempts to label functions/operators based upon\n monadic/dyadic usage (but this is far from fully fleshed out).\n This means there are meaningful classnames so hover states can\n have popups etc.\n\n MIME types defined: text/apl (APL code)\n
\nAsterisk dialplan mode\n\n; extensions.conf - the Asterisk dial plan\n;\n\n[general]\n;\n; If static is set to no, or omitted, then the pbx_config will rewrite\n; this file when extensions are modified. Remember that all comments\n; made in the file will be lost when that happens.\nstatic=yes\n\n#include \"/etc/asterisk/additional_general.conf\n\n[iaxprovider]\nswitch => IAX2/user:[key]@myserver/mycontext\n\n[dynamic]\n#exec /usr/bin/dynamic-peers.pl\n\n[trunkint]\n;\n; International long distance through trunk\n;\nexten => _9011.,1,Macro(dundi-e164,${EXTEN:4})\nexten => _9011.,n,Dial(${GLOBAL(TRUNK)}/${FILTER(0-9,${EXTEN:${GLOBAL(TRUNKMSD)}})})\n\n[local]\n;\n; Master context for local, toll-free, and iaxtel calls only\n;\nignorepat => 9\ninclude => default\n\n[demo]\ninclude => stdexten\n;\n; We start with what to do when a call first comes in.\n;\nexten => s,1,Wait(1)\t\t\t; Wait a second, just for fun\nsame => n,Answer\t\t\t; Answer the line\nsame => n,Set(TIMEOUT(digit)=5)\t; Set Digit Timeout to 5 seconds\nsame => n,Set(TIMEOUT(response)=10)\t; Set Response Timeout to 10 seconds\nsame => n(restart),BackGround(demo-congrats)\t; Play a congratulatory message\nsame => n(instruct),BackGround(demo-instruct)\t; Play some instructions\nsame => n,WaitExten\t\t\t; Wait for an extension to be dialed.\n\nexten => 2,1,BackGround(demo-moreinfo)\t; Give some more information.\nexten => 2,n,Goto(s,instruct)\n\nexten => 3,1,Set(LANGUAGE()=fr)\t\t; Set language to french\nexten => 3,n,Goto(s,restart)\t\t; Start with the congratulations\n\nexten => 1000,1,Goto(default,s,1)\n;\n; We also create an example user, 1234, who is on the console and has\n; voicemail, etc.\n;\nexten => 1234,1,Playback(transfer,skip)\t\t; \"Please hold while...\"\n\t\t\t\t\t; (but skip if channel is not up)\nexten => 1234,n,Gosub(${EXTEN},stdexten(${GLOBAL(CONSOLE)}))\nexten => 1234,n,Goto(default,s,1)\t\t; exited Voicemail\n\nexten => 1235,1,Voicemail(1234,u)\t\t; Right to voicemail\n\nexten => 1236,1,Dial(Console/dsp)\t\t; Ring forever\nexten => 1236,n,Voicemail(1234,b)\t\t; Unless busy\n\n;\n; # for when they're done with the demo\n;\nexten => #,1,Playback(demo-thanks)\t; \"Thanks for trying the demo\"\nexten => #,n,Hangup\t\t\t; Hang them up.\n\n;\n; A timeout and \"invalid extension rule\"\n;\nexten => t,1,Goto(#,1)\t\t\t; If they take too long, give up\nexten => i,1,Playback(invalid)\t\t; \"That's not valid, try again\"\n\n;\n; Create an extension, 500, for dialing the\n; Asterisk demo.\n;\nexten => 500,1,Playback(demo-abouttotry); Let them know what's going on\nexten => 500,n,Dial(IAX2/guest@pbx.digium.com/s@default)\t; Call the Asterisk demo\nexten => 500,n,Playback(demo-nogo)\t; Couldn't connect to the demo site\nexten => 500,n,Goto(s,6)\t\t; Return to the start over message.\n\n;\n; Create an extension, 600, for evaluating echo latency.\n;\nexten => 600,1,Playback(demo-echotest)\t; Let them know what's going on\nexten => 600,n,Echo\t\t\t; Do the echo test\nexten => 600,n,Playback(demo-echodone)\t; Let them know it's over\nexten => 600,n,Goto(s,6)\t\t; Start over\n\n;\n;\tYou can use the Macro Page to intercom a individual user\nexten => 76245,1,Macro(page,SIP/Grandstream1)\n; or if your peernames are the same as extensions\nexten => _7XXX,1,Macro(page,SIP/${EXTEN})\n;\n;\n; System Wide Page at extension 7999\n;\nexten => 7999,1,Set(TIMEOUT(absolute)=60)\nexten => 7999,2,Page(Local/Grandstream1@page&Local/Xlite1@page&Local/1234@page/n,d)\n\n; Give voicemail at extension 8500\n;\nexten => 8500,1,VoicemailMain\nexten => 8500,n,Goto(s,6)\n\n \n \n\n MIME types defined: text/x-asterisk.\n\n
\nC-like mode\n\n\n/* C demo code */\n\n#include <zmq.h>\n#include <pthread.h>\n#include <semaphore.h>\n#include <time.h>\n#include <stdio.h>\n#include <fcntl.h>\n#include <malloc.h>\n\ntypedef struct {\n void* arg_socket;\n zmq_msg_t* arg_msg;\n char* arg_string;\n unsigned long arg_len;\n int arg_int, arg_command;\n\n int signal_fd;\n int pad;\n void* context;\n sem_t sem;\n} acl_zmq_context;\n\n#define p(X) (context->arg_##X)\n\nvoid* zmq_thread(void* context_pointer) {\n acl_zmq_context* context = (acl_zmq_context*)context_pointer;\n char ok = 'K', err = 'X';\n int res;\n\n while (1) {\n while ((res = sem_wait(&context->sem)) == EINTR);\n if (res) {write(context->signal_fd, &err, 1); goto cleanup;}\n switch(p(command)) {\n case 0: goto cleanup;\n case 1: p(socket) = zmq_socket(context->context, p(int)); break;\n case 2: p(int) = zmq_close(p(socket)); break;\n case 3: p(int) = zmq_bind(p(socket), p(string)); break;\n case 4: p(int) = zmq_connect(p(socket), p(string)); break;\n case 5: p(int) = zmq_getsockopt(p(socket), p(int), (void*)p(string), &p(len)); break;\n case 6: p(int) = zmq_setsockopt(p(socket), p(int), (void*)p(string), p(len)); break;\n case 7: p(int) = zmq_send(p(socket), p(msg), p(int)); break;\n case 8: p(int) = zmq_recv(p(socket), p(msg), p(int)); break;\n case 9: p(int) = zmq_poll(p(socket), p(int), p(len)); break;\n }\n p(command) = errno;\n write(context->signal_fd, &ok, 1);\n }\n cleanup:\n close(context->signal_fd);\n free(context_pointer);\n return 0;\n}\n\nvoid* zmq_thread_init(void* zmq_context, int signal_fd) {\n acl_zmq_context* context = malloc(sizeof(acl_zmq_context));\n pthread_t thread;\n\n context->context = zmq_context;\n context->signal_fd = signal_fd;\n sem_init(&context->sem, 1, 0);\n pthread_create(&thread, 0, &zmq_thread, context);\n pthread_detach(thread);\n return context;\n}\n\n\nC++ example\n\n\n#include <iostream>\n#include \"mystuff/util.h\"\n\nnamespace {\nenum Enum {\n VAL1, VAL2, VAL3\n};\n\nchar32_t unicode_string = U\"\\U0010FFFF\";\nstring raw_string = R\"delim(anything\nyou\nwant)delim\";\n\nint Helper(const MyType& param) {\n return 0;\n}\n} // namespace\n\nclass ForwardDec;\n\ntemplate <class T, class V>\nclass Class : public BaseClass {\n const MyType<T, V> member_;\n\n public:\n const MyType<T, V>& Method() const {\n return member_;\n }\n\n void Method2(MyType<T, V>* value);\n}\n\ntemplate <class T, class V>\nvoid Class::Method2(MyType<T, V>* value) {\n std::out << 1 >> method();\n value->Method3(member_);\n member_ = value;\n}\n\n\nJava example\n\n\nimport com.demo.util.MyType;\nimport com.demo.util.MyInterface;\n\npublic enum Enum {\n VAL1, VAL2, VAL3\n}\n\npublic class Class<T, V> implements MyInterface {\n public static final MyType<T, V> member;\n \n private class InnerClass {\n public int zero() {\n return 0;\n }\n }\n\n @Override\n public MyType method() {\n return member;\n }\n\n public void method2(MyType<T, V> value) {\n method();\n value.method3();\n member = value;\n }\n}\n\n\nScala example\n\n\nobject FilterTest extends App {\n def filter(xs: List[Int], threshold: Int) = {\n def process(ys: List[Int]): List[Int] =\n if (ys.isEmpty) ys\n else if (ys.head < threshold) ys.head :: process(ys.tail)\n else process(ys.tail)\n process(xs)\n }\n println(filter(List(1, 9, 2, 8, 3, 7, 4), 5))\n}\n\n\n \n\n Simple mode that tries to handle C-like languages as well as it\n can. Takes two configuration parameters: keywords, an\n object whose property names are the keywords in the language,\n and useCPP, which determines whether C preprocessor\n directives are recognized.\n\n MIME types defined: text/x-csrc\n (C), text/x-c++src (C++), text/x-java\n (Java), text/x-csharp (C#),\n text/x-scala (Scala), text/x-vertex\n and x-shader/x-fragment (shader programs).\n
\nScala mode\n\n\n\n /* __ *\\\n ** ________ ___ / / ___ Scala API **\n ** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL **\n ** __\\ \\/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **\n ** /____/\\___/_/ |_/____/_/ | | **\n ** |/ **\n \\* */\n\n package scala.collection\n\n import generic._\n import mutable.{ Builder, ListBuffer }\n import annotation.{tailrec, migration, bridge}\n import annotation.unchecked.{ uncheckedVariance => uV }\n import parallel.ParIterable\n\n /** A template trait for traversable collections of type `Traversable[A]`.\n * \n * $traversableInfo\n * @define mutability\n * @define traversableInfo\n * This is a base trait of all kinds of $mutability Scala collections. It\n * implements the behavior common to all collections, in terms of a method\n * `foreach` with signature:\n * {{{\n * def foreach[U](f: Elem => U): Unit\n * }}}\n * Collection classes mixing in this trait provide a concrete \n * `foreach` method which traverses all the\n * elements contained in the collection, applying a given function to each.\n * They also need to provide a method `newBuilder`\n * which creates a builder for collections of the same kind.\n * \n * A traversable class might or might not have two properties: strictness\n * and orderedness. Neither is represented as a type.\n * \n * The instances of a strict collection class have all their elements\n * computed before they can be used as values. By contrast, instances of\n * a non-strict collection class may defer computation of some of their\n * elements until after the instance is available as a value.\n * A typical example of a non-strict collection class is a\n * <a href=\"../immutable/Stream.html\" target=\"ContentFrame\">\n * `scala.collection.immutable.Stream`</a>.\n * A more general class of examples are `TraversableViews`.\n * \n * If a collection is an instance of an ordered collection class, traversing\n * its elements with `foreach` will always visit elements in the\n * same order, even for different runs of the program. If the class is not\n * ordered, `foreach` can visit elements in different orders for\n * different runs (but it will keep the same order in the same run).'\n * \n * A typical example of a collection class which is not ordered is a\n * `HashMap` of objects. The traversal order for hash maps will\n * depend on the hash codes of its elements, and these hash codes might\n * differ from one run to the next. By contrast, a `LinkedHashMap`\n * is ordered because it's `foreach` method visits elements in the\n * order they were inserted into the `HashMap`.\n *\n * @author Martin Odersky\n * @version 2.8\n * @since 2.8\n * @tparam A the element type of the collection\n * @tparam Repr the type of the actual collection containing the elements.\n *\n * @define Coll Traversable\n * @define coll traversable collection\n */\n trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr] \n with FilterMonadic[A, Repr]\n with TraversableOnce[A]\n with GenTraversableLike[A, Repr]\n with Parallelizable[A, ParIterable[A]]\n {\n self =>\n\n import Traversable.breaks._\n\n /** The type implementing this traversable */\n protected type Self = Repr\n\n /** The collection of type $coll underlying this `TraversableLike` object.\n * By default this is implemented as the `TraversableLike` object itself,\n * but this can be overridden.\n */\n def repr: Repr = this.asInstanceOf[Repr]\n\n /** The underlying collection seen as an instance of `$Coll`.\n * By default this is implemented as the current collection object itself,\n * but this can be overridden.\n */\n protected[this] def thisCollection: Traversable[A] = this.asInstanceOf[Traversable[A]]\n\n /** A conversion from collections of type `Repr` to `$Coll` objects.\n * By default this is implemented as just a cast, but this can be overridden.\n */\n protected[this] def toCollection(repr: Repr): Traversable[A] = repr.asInstanceOf[Traversable[A]]\n\n /** Creates a new builder for this collection type.\n */\n protected[this] def newBuilder: Builder[A, Repr]\n\n protected[this] def parCombiner = ParIterable.newCombiner[A]\n\n /** Applies a function `f` to all elements of this $coll.\n * \n * Note: this method underlies the implementation of most other bulk operations.\n * It's important to implement this method in an efficient way.\n * \n *\n * @param f the function that is applied for its side-effect to every element.\n * The result of function `f` is discarded.\n * \n * @tparam U the type parameter describing the result of function `f`. \n * This result will always be ignored. Typically `U` is `Unit`,\n * but this is not necessary.\n *\n * @usecase def foreach(f: A => Unit): Unit\n */\n def foreach[U](f: A => U): Unit\n\n /** Tests whether this $coll is empty.\n *\n * @return `true` if the $coll contain no elements, `false` otherwise.\n */\n def isEmpty: Boolean = {\n var result = true\n breakable {\n for (x <- this) {\n result = false\n break\n }\n }\n result\n }\n\n /** Tests whether this $coll is known to have a finite size.\n * All strict collections are known to have finite size. For a non-strict collection\n * such as `Stream`, the predicate returns `true` if all elements have been computed.\n * It returns `false` if the stream is not yet evaluated to the end.\n *\n * Note: many collection methods will not work on collections of infinite sizes. \n *\n * @return `true` if this collection is known to have finite size, `false` otherwise.\n */\n def hasDefiniteSize = true\n\n def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size)\n b ++= thisCollection\n b ++= that.seq\n b.result\n }\n\n @bridge\n def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =\n ++(that: GenTraversableOnce[B])(bf)\n\n /** Concatenates this $coll with the elements of a traversable collection.\n * It differs from ++ in that the right operand determines the type of the\n * resulting collection rather than the left one.\n * \n * @param that the traversable to append.\n * @tparam B the element type of the returned collection. \n * @tparam That $thatinfo\n * @param bf $bfinfo\n * @return a new collection of type `That` which contains all elements\n * of this $coll followed by all elements of `that`.\n * \n * @usecase def ++:[B](that: TraversableOnce[B]): $Coll[B]\n * \n * @return a new $coll which contains all elements of this $coll\n * followed by all elements of `that`.\n */\n def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size)\n b ++= that\n b ++= thisCollection\n b.result\n }\n\n /** This overload exists because: for the implementation of ++: we should reuse\n * that of ++ because many collections override it with more efficient versions.\n * Since TraversableOnce has no '++' method, we have to implement that directly,\n * but Traversable and down can use the overload.\n */\n def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =\n (that ++ seq)(breakOut)\n\n def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n b.sizeHint(this) \n for (x <- this) b += f(x)\n b.result\n }\n\n def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n for (x <- this) b ++= f(x).seq\n b.result\n }\n\n /** Selects all elements of this $coll which satisfy a predicate.\n *\n * @param p the predicate used to test elements.\n * @return a new $coll consisting of all elements of this $coll that satisfy the given\n * predicate `p`. The order of the elements is preserved.\n */\n def filter(p: A => Boolean): Repr = {\n val b = newBuilder\n for (x <- this) \n if (p(x)) b += x\n b.result\n }\n\n /** Selects all elements of this $coll which do not satisfy a predicate.\n *\n * @param p the predicate used to test elements.\n * @return a new $coll consisting of all elements of this $coll that do not satisfy the given\n * predicate `p`. The order of the elements is preserved.\n */\n def filterNot(p: A => Boolean): Repr = filter(!p(_))\n\n def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n for (x <- this) if (pf.isDefinedAt(x)) b += pf(x)\n b.result\n }\n\n /** Builds a new collection by applying an option-valued function to all\n * elements of this $coll on which the function is defined.\n *\n * @param f the option-valued function which filters and maps the $coll.\n * @tparam B the element type of the returned collection.\n * @tparam That $thatinfo\n * @param bf $bfinfo\n * @return a new collection of type `That` resulting from applying the option-valued function\n * `f` to each element and collecting all defined results.\n * The order of the elements is preserved.\n *\n * @usecase def filterMap[B](f: A => Option[B]): $Coll[B]\n * \n * @param pf the partial function which filters and maps the $coll.\n * @return a new $coll resulting from applying the given option-valued function\n * `f` to each element and collecting all defined results.\n * The order of the elements is preserved.\n def filterMap[B, That](f: A => Option[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n for (x <- this) \n f(x) match {\n case Some(y) => b += y\n case _ =>\n }\n b.result\n }\n */\n\n /** Partitions this $coll in two ${coll}s according to a predicate.\n *\n * @param p the predicate on which to partition.\n * @return a pair of ${coll}s: the first $coll consists of all elements that \n * satisfy the predicate `p` and the second $coll consists of all elements\n * that don't. The relative order of the elements in the resulting ${coll}s\n * is the same as in the original $coll.\n */\n def partition(p: A => Boolean): (Repr, Repr) = {\n val l, r = newBuilder\n for (x <- this) (if (p(x)) l else r) += x\n (l.result, r.result)\n }\n\n def groupBy[K](f: A => K): immutable.Map[K, Repr] = {\n val m = mutable.Map.empty[K, Builder[A, Repr]]\n for (elem <- this) {\n val key = f(elem)\n val bldr = m.getOrElseUpdate(key, newBuilder)\n bldr += elem\n }\n val b = immutable.Map.newBuilder[K, Repr]\n for ((k, v) <- m)\n b += ((k, v.result))\n\n b.result\n }\n\n /** Tests whether a predicate holds for all elements of this $coll.\n *\n * $mayNotTerminateInf\n *\n * @param p the predicate used to test elements.\n * @return `true` if the given predicate `p` holds for all elements\n * of this $coll, otherwise `false`.\n */\n def forall(p: A => Boolean): Boolean = {\n var result = true\n breakable {\n for (x <- this)\n if (!p(x)) { result = false; break }\n }\n result\n }\n\n /** Tests whether a predicate holds for some of the elements of this $coll.\n *\n * $mayNotTerminateInf\n *\n * @param p the predicate used to test elements.\n * @return `true` if the given predicate `p` holds for some of the\n * elements of this $coll, otherwise `false`.\n */\n def exists(p: A => Boolean): Boolean = {\n var result = false\n breakable {\n for (x <- this)\n if (p(x)) { result = true; break }\n }\n result\n }\n\n /** Finds the first element of the $coll satisfying a predicate, if any.\n * \n * $mayNotTerminateInf\n * $orderDependent\n *\n * @param p the predicate used to test elements.\n * @return an option value containing the first element in the $coll\n * that satisfies `p`, or `None` if none exists.\n */\n def find(p: A => Boolean): Option[A] = {\n var result: Option[A] = None\n breakable {\n for (x <- this)\n if (p(x)) { result = Some(x); break }\n }\n result\n }\n\n def scan[B >: A, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That = scanLeft(z)(op)\n\n def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n b.sizeHint(this, 1)\n var acc = z\n b += acc\n for (x <- this) { acc = op(acc, x); b += acc }\n b.result\n }\n\n @migration(2, 9,\n \"This scanRight definition has changed in 2.9.\\n\" +\n \"The previous behavior can be reproduced with scanRight.reverse.\"\n )\n def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n var scanned = List(z)\n var acc = z\n for (x <- reversed) {\n acc = op(x, acc)\n scanned ::= acc\n }\n val b = bf(repr)\n for (elem <- scanned) b += elem\n b.result\n }\n\n /** Selects the first element of this $coll.\n * $orderDependent\n * @return the first element of this $coll.\n * @throws `NoSuchElementException` if the $coll is empty.\n */\n def head: A = {\n var result: () => A = () => throw new NoSuchElementException\n breakable {\n for (x <- this) {\n result = () => x\n break\n }\n }\n result()\n }\n\n /** Optionally selects the first element.\n * $orderDependent\n * @return the first element of this $coll if it is nonempty, `None` if it is empty.\n */\n def headOption: Option[A] = if (isEmpty) None else Some(head)\n\n /** Selects all elements except the first.\n * $orderDependent\n * @return a $coll consisting of all elements of this $coll\n * except the first one.\n * @throws `UnsupportedOperationException` if the $coll is empty.\n */ \n override def tail: Repr = {\n if (isEmpty) throw new UnsupportedOperationException(\"empty.tail\")\n drop(1)\n }\n\n /** Selects the last element.\n * $orderDependent\n * @return The last element of this $coll.\n * @throws NoSuchElementException If the $coll is empty.\n */\n def last: A = {\n var lst = head\n for (x <- this)\n lst = x\n lst\n }\n\n /** Optionally selects the last element.\n * $orderDependent\n * @return the last element of this $coll$ if it is nonempty, `None` if it is empty.\n */\n def lastOption: Option[A] = if (isEmpty) None else Some(last)\n\n /** Selects all elements except the last.\n * $orderDependent\n * @return a $coll consisting of all elements of this $coll\n * except the last one.\n * @throws `UnsupportedOperationException` if the $coll is empty.\n */\n def init: Repr = {\n if (isEmpty) throw new UnsupportedOperationException(\"empty.init\")\n var lst = head\n var follow = false\n val b = newBuilder\n b.sizeHint(this, -1)\n for (x <- this.seq) {\n if (follow) b += lst\n else follow = true\n lst = x\n }\n b.result\n }\n\n def take(n: Int): Repr = slice(0, n)\n\n def drop(n: Int): Repr = \n if (n <= 0) {\n val b = newBuilder\n b.sizeHint(this)\n b ++= thisCollection result\n }\n else sliceWithKnownDelta(n, Int.MaxValue, -n)\n\n def slice(from: Int, until: Int): Repr = sliceWithKnownBound(math.max(from, 0), until)\n\n // Precondition: from >= 0, until > 0, builder already configured for building.\n private[this] def sliceInternal(from: Int, until: Int, b: Builder[A, Repr]): Repr = {\n var i = 0\n breakable {\n for (x <- this.seq) {\n if (i >= from) b += x\n i += 1\n if (i >= until) break\n }\n }\n b.result\n }\n // Precondition: from >= 0\n private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr = {\n val b = newBuilder\n if (until <= from) b.result\n else {\n b.sizeHint(this, delta)\n sliceInternal(from, until, b)\n }\n }\n // Precondition: from >= 0\n private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr = {\n val b = newBuilder\n if (until <= from) b.result\n else {\n b.sizeHintBounded(until - from, this) \n sliceInternal(from, until, b)\n }\n }\n\n def takeWhile(p: A => Boolean): Repr = {\n val b = newBuilder\n breakable {\n for (x <- this) {\n if (!p(x)) break\n b += x\n }\n }\n b.result\n }\n\n def dropWhile(p: A => Boolean): Repr = {\n val b = newBuilder\n var go = false\n for (x <- this) {\n if (!p(x)) go = true\n if (go) b += x\n }\n b.result\n }\n\n def span(p: A => Boolean): (Repr, Repr) = {\n val l, r = newBuilder\n var toLeft = true\n for (x <- this) {\n toLeft = toLeft && p(x)\n (if (toLeft) l else r) += x\n }\n (l.result, r.result)\n }\n\n def splitAt(n: Int): (Repr, Repr) = {\n val l, r = newBuilder\n l.sizeHintBounded(n, this)\n if (n >= 0) r.sizeHint(this, -n)\n var i = 0\n for (x <- this) {\n (if (i < n) l else r) += x\n i += 1\n }\n (l.result, r.result)\n }\n\n /** Iterates over the tails of this $coll. The first value will be this\n * $coll and the final one will be an empty $coll, with the intervening\n * values the results of successive applications of `tail`.\n *\n * @return an iterator over all the tails of this $coll\n * @example `List(1,2,3).tails = Iterator(List(1,2,3), List(2,3), List(3), Nil)`\n */ \n def tails: Iterator[Repr] = iterateUntilEmpty(_.tail)\n\n /** Iterates over the inits of this $coll. The first value will be this\n * $coll and the final one will be an empty $coll, with the intervening\n * values the results of successive applications of `init`.\n *\n * @return an iterator over all the inits of this $coll\n * @example `List(1,2,3).inits = Iterator(List(1,2,3), List(1,2), List(1), Nil)`\n */\n def inits: Iterator[Repr] = iterateUntilEmpty(_.init)\n\n /** Copies elements of this $coll to an array.\n * Fills the given array `xs` with at most `len` elements of\n * this $coll, starting at position `start`.\n * Copying will stop once either the end of the current $coll is reached,\n * or the end of the array is reached, or `len` elements have been copied.\n *\n * $willNotTerminateInf\n * \n * @param xs the array to fill.\n * @param start the starting index.\n * @param len the maximal number of elements to copy.\n * @tparam B the type of the elements of the array. \n * \n *\n * @usecase def copyToArray(xs: Array[A], start: Int, len: Int): Unit\n */\n def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) {\n var i = start\n val end = (start + len) min xs.length\n breakable {\n for (x <- this) {\n if (i >= end) break\n xs(i) = x\n i += 1\n }\n }\n }\n\n def toTraversable: Traversable[A] = thisCollection\n def toIterator: Iterator[A] = toStream.iterator\n def toStream: Stream[A] = toBuffer.toStream\n\n /** Converts this $coll to a string.\n *\n * @return a string representation of this collection. By default this\n * string consists of the `stringPrefix` of this $coll,\n * followed by all elements separated by commas and enclosed in parentheses.\n */\n override def toString = mkString(stringPrefix + \"(\", \", \", \")\")\n\n /** Defines the prefix of this object's `toString` representation.\n *\n * @return a string representation which starts the result of `toString`\n * applied to this $coll. By default the string prefix is the\n * simple name of the collection class $coll.\n */\n def stringPrefix : String = {\n var string = repr.asInstanceOf[AnyRef].getClass.getName\n val idx1 = string.lastIndexOf('.' : Int)\n if (idx1 != -1) string = string.substring(idx1 + 1)\n val idx2 = string.indexOf('$')\n if (idx2 != -1) string = string.substring(0, idx2)\n string\n }\n\n /** Creates a non-strict view of this $coll.\n * \n * @return a non-strict view of this $coll.\n */\n def view = new TraversableView[A, Repr] {\n protected lazy val underlying = self.repr\n override def foreach[U](f: A => U) = self foreach f\n }\n\n /** Creates a non-strict view of a slice of this $coll.\n *\n * Note: the difference between `view` and `slice` is that `view` produces\n * a view of the current $coll, whereas `slice` produces a new $coll.\n * \n * Note: `view(from, to)` is equivalent to `view.slice(from, to)`\n * $orderDependent\n * \n * @param from the index of the first element of the view\n * @param until the index of the element following the view\n * @return a non-strict view of a slice of this $coll, starting at index `from`\n * and extending up to (but not including) index `until`.\n */\n def view(from: Int, until: Int): TraversableView[A, Repr] = view.slice(from, until)\n\n /** Creates a non-strict filter of this $coll.\n *\n * Note: the difference between `c filter p` and `c withFilter p` is that\n * the former creates a new collection, whereas the latter only\n * restricts the domain of subsequent `map`, `flatMap`, `foreach`,\n * and `withFilter` operations.\n * $orderDependent\n * \n * @param p the predicate used to test elements.\n * @return an object of class `WithFilter`, which supports\n * `map`, `flatMap`, `foreach`, and `withFilter` operations.\n * All these operations apply to those elements of this $coll which\n * satisfy the predicate `p`.\n */\n def withFilter(p: A => Boolean): FilterMonadic[A, Repr] = new WithFilter(p)\n\n /** A class supporting filtered operations. Instances of this class are\n * returned by method `withFilter`.\n */\n class WithFilter(p: A => Boolean) extends FilterMonadic[A, Repr] {\n\n /** Builds a new collection by applying a function to all elements of the\n * outer $coll containing this `WithFilter` instance that satisfy predicate `p`.\n *\n * @param f the function to apply to each element.\n * @tparam B the element type of the returned collection.\n * @tparam That $thatinfo\n * @param bf $bfinfo\n * @return a new collection of type `That` resulting from applying\n * the given function `f` to each element of the outer $coll\n * that satisfies predicate `p` and collecting the results.\n *\n * @usecase def map[B](f: A => B): $Coll[B] \n * \n * @return a new $coll resulting from applying the given function\n * `f` to each element of the outer $coll that satisfies\n * predicate `p` and collecting the results.\n */\n def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n for (x <- self) \n if (p(x)) b += f(x)\n b.result\n }\n\n /** Builds a new collection by applying a function to all elements of the\n * outer $coll containing this `WithFilter` instance that satisfy\n * predicate `p` and concatenating the results. \n *\n * @param f the function to apply to each element.\n * @tparam B the element type of the returned collection.\n * @tparam That $thatinfo\n * @param bf $bfinfo\n * @return a new collection of type `That` resulting from applying\n * the given collection-valued function `f` to each element\n * of the outer $coll that satisfies predicate `p` and\n * concatenating the results.\n *\n * @usecase def flatMap[B](f: A => TraversableOnce[B]): $Coll[B]\n * \n * @return a new $coll resulting from applying the given collection-valued function\n * `f` to each element of the outer $coll that satisfies predicate `p` and concatenating the results.\n */\n def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {\n val b = bf(repr)\n for (x <- self) \n if (p(x)) b ++= f(x).seq\n b.result\n }\n\n /** Applies a function `f` to all elements of the outer $coll containing\n * this `WithFilter` instance that satisfy predicate `p`.\n *\n * @param f the function that is applied for its side-effect to every element.\n * The result of function `f` is discarded.\n * \n * @tparam U the type parameter describing the result of function `f`. \n * This result will always be ignored. Typically `U` is `Unit`,\n * but this is not necessary.\n *\n * @usecase def foreach(f: A => Unit): Unit\n */ \n def foreach[U](f: A => U): Unit = \n for (x <- self) \n if (p(x)) f(x)\n\n /** Further refines the filter for this $coll.\n *\n * @param q the predicate used to test elements.\n * @return an object of class `WithFilter`, which supports\n * `map`, `flatMap`, `foreach`, and `withFilter` operations.\n * All these operations apply to those elements of this $coll which\n * satisfy the predicate `q` in addition to the predicate `p`.\n */\n def withFilter(q: A => Boolean): WithFilter = \n new WithFilter(x => p(x) && q(x))\n }\n\n // A helper for tails and inits.\n private def iterateUntilEmpty(f: Traversable[A @uV] => Traversable[A @uV]): Iterator[Repr] = {\n val it = Iterator.iterate(thisCollection)(f) takeWhile (x => !x.isEmpty)\n it ++ Iterator(Nil) map (newBuilder ++= _ result)\n }\n }\n\n\n\n\n\n \n
\nClojure mode\n\n; Conway's Game of Life, based on the work of:\n;; Laurent Petit https://gist.github.com/1200343\n;; Christophe Grand http://clj-me.cgrand.net/2011/08/19/conways-game-of-life\n\n(ns ^{:doc \"Conway's Game of Life.\"}\n game-of-life)\n\n;; Core game of life's algorithm functions\n\n(defn neighbours\n \"Given a cell's coordinates, returns the coordinates of its neighbours.\"\n [[x y]]\n (for [dx [-1 0 1] dy (if (zero? dx) [-1 1] [-1 0 1])]\n [(+ dx x) (+ dy y)]))\n\n(defn step\n \"Given a set of living cells, computes the new set of living cells.\"\n [cells]\n (set (for [[cell n] (frequencies (mapcat neighbours cells))\n :when (or (= n 3) (and (= n 2) (cells cell)))]\n cell)))\n\n;; Utility methods for displaying game on a text terminal\n\n(defn print-board\n \"Prints a board on *out*, representing a step in the game.\"\n [board w h]\n (doseq [x (range (inc w)) y (range (inc h))]\n (if (= y 0) (print \"\\n\"))\n (print (if (board [x y]) \"[X]\" \" . \"))))\n\n(defn display-grids\n \"Prints a squence of boards on *out*, representing several steps.\"\n [grids w h]\n (doseq [board grids]\n (print-board board w h)\n (print \"\\n\")))\n\n;; Launches an example board\n\n(def\n ^{:doc \"board represents the initial set of living cells\"}\n board #{[2 1] [2 2] [2 3]})\n\n(display-grids (take 3 (iterate step board)) 5 5)\n\n;; Let's play with characters\n(println \\1 \\a \\# \\\\\n \\\" \\( \\newline\n \\} \\\" \\space\n \\tab \\return \\backspace\n \\u1000 \\uAaAa \\u9F9F)\n\n\n \n\n MIME types defined: text/x-clojure.\n\n
\nCOBOL mode\n\n Select Theme \n default\n ambiance\n blackboard\n cobalt\n eclipse\n elegant\n erlang-dark\n lesser-dark\n midnight\n monokai\n neat\n night\n rubyblue\n solarized dark\n solarized light\n twilight\n vibrant-ink\n xq-dark\n xq-light\n Select Font Size \n 13px\n 14px\n 16px\n 18px\n 20px\n 24px\n 26px\n 28px\n 30px\n 32px\n 34px\n 36px\n \nRead-only\n\nInsert Spaces on Tab\n\n\n\n---------1---------2---------3---------4---------5---------6---------7---------8\n12345678911234567892123456789312345678941234567895123456789612345678971234567898\n000010 IDENTIFICATION DIVISION. MODTGHERE\n000020 PROGRAM-ID. SAMPLE.\n000030 AUTHOR. TEST SAM. \n000040 DATE-WRITTEN. 5 February 2013\n000041\n000042* A sample program just to show the form.\n000043* The program copies its input to the output,\n000044* and counts the number of records.\n000045* At the end this number is printed.\n000046\n000050 ENVIRONMENT DIVISION.\n000060 INPUT-OUTPUT SECTION.\n000070 FILE-CONTROL.\n000080 SELECT STUDENT-FILE ASSIGN TO SYSIN\n000090 ORGANIZATION IS LINE SEQUENTIAL.\n000100 SELECT PRINT-FILE ASSIGN TO SYSOUT\n000110 ORGANIZATION IS LINE SEQUENTIAL.\n000120\n000130 DATA DIVISION.\n000140 FILE SECTION.\n000150 FD STUDENT-FILE\n000160 RECORD CONTAINS 43 CHARACTERS\n000170 DATA RECORD IS STUDENT-IN.\n000180 01 STUDENT-IN PIC X(43).\n000190\n000200 FD PRINT-FILE\n000210 RECORD CONTAINS 80 CHARACTERS\n000220 DATA RECORD IS PRINT-LINE.\n000230 01 PRINT-LINE PIC X(80).\n000240\n000250 WORKING-STORAGE SECTION.\n000260 01 DATA-REMAINS-SWITCH PIC X(2) VALUE SPACES.\n000261 01 RECORDS-WRITTEN PIC 99.\n000270\n000280 01 DETAIL-LINE.\n000290 05 FILLER PIC X(7) VALUE SPACES.\n000300 05 RECORD-IMAGE PIC X(43).\n000310 05 FILLER PIC X(30) VALUE SPACES.\n000311 \n000312 01 SUMMARY-LINE.\n000313 05 FILLER PIC X(7) VALUE SPACES.\n000314 05 TOTAL-READ PIC 99.\n000315 05 FILLER PIC X VALUE SPACE.\n000316 05 FILLER PIC X(17) \n000317 VALUE 'Records were read'.\n000318 05 FILLER PIC X(53) VALUE SPACES.\n000319\n000320 PROCEDURE DIVISION.\n000321\n000330 PREPARE-SENIOR-REPORT.\n000340 OPEN INPUT STUDENT-FILE\n000350 OUTPUT PRINT-FILE.\n000351 MOVE ZERO TO RECORDS-WRITTEN.\n000360 READ STUDENT-FILE\n000370 AT END MOVE 'NO' TO DATA-REMAINS-SWITCH\n000380 END-READ.\n000390 PERFORM PROCESS-RECORDS\n000410 UNTIL DATA-REMAINS-SWITCH = 'NO'.\n000411 PERFORM PRINT-SUMMARY.\n000420 CLOSE STUDENT-FILE\n000430 PRINT-FILE.\n000440 STOP RUN.\n000450\n000460 PROCESS-RECORDS.\n000470 MOVE STUDENT-IN TO RECORD-IMAGE.\n000480 MOVE DETAIL-LINE TO PRINT-LINE.\n000490 WRITE PRINT-LINE.\n000500 ADD 1 TO RECORDS-WRITTEN.\n000510 READ STUDENT-FILE\n000520 AT END MOVE 'NO' TO DATA-REMAINS-SWITCH\n000530 END-READ. \n000540\n000550 PRINT-SUMMARY.\n000560 MOVE RECORDS-WRITTEN TO TOTAL-READ.\n000570 MOVE SUMMARY-LINE TO PRINT-LINE.\n000571 WRITE PRINT-LINE. \n000572\n000580\n\n \n
\nCoffeeScript mode\n\n# CoffeeScript mode for CodeMirror\n# Copyright (c) 2011 Jeff Pickhardt, released under\n# the MIT License.\n#\n# Modified from the Python CodeMirror mode, which also is \n# under the MIT License Copyright (c) 2010 Timothy Farrell.\n#\n# The following script, Underscore.coffee, is used to \n# demonstrate CoffeeScript mode for CodeMirror.\n#\n# To download CoffeeScript mode for CodeMirror, go to:\n# https://github.com/pickhardt/coffeescript-codemirror-mode\n\n# **Underscore.coffee\n# (c) 2011 Jeremy Ashkenas, DocumentCloud Inc.**\n# Underscore is freely distributable under the terms of the\n# [MIT license](http://en.wikipedia.org/wiki/MIT_License).\n# Portions of Underscore are inspired by or borrowed from\n# [Prototype.js](http://prototypejs.org/api), Oliver Steele's\n# [Functional](http://osteele.com), and John Resig's\n# [Micro-Templating](http://ejohn.org).\n# For all details and documentation:\n# http://documentcloud.github.com/underscore/\n\n\n# Baseline setup\n# --------------\n\n# Establish the root object, `window` in the browser, or `global` on the server.\nroot = this\n\n\n# Save the previous value of the `_` variable.\npreviousUnderscore = root._\n\n### Multiline\n comment\n###\n\n# Establish the object that gets thrown to break out of a loop iteration.\n# `StopIteration` is SOP on Mozilla.\nbreaker = if typeof(StopIteration) is 'undefined' then '__break__' else StopIteration\n\n\n#### Docco style single line comment (title)\n\n\n# Helper function to escape **RegExp** contents, because JS doesn't have one.\nescapeRegExp = (string) -> string.replace(/([.*+?^${}()|[\\]\\/\\\\])/g, '\\\\$1')\n\n\n# Save bytes in the minified (but not gzipped) version:\nArrayProto = Array.prototype\nObjProto = Object.prototype\n\n\n# Create quick reference variables for speed access to core prototypes.\nslice = ArrayProto.slice\nunshift = ArrayProto.unshift\ntoString = ObjProto.toString\nhasOwnProperty = ObjProto.hasOwnProperty\npropertyIsEnumerable = ObjProto.propertyIsEnumerable\n\n\n# All **ECMA5** native implementations we hope to use are declared here.\nnativeForEach = ArrayProto.forEach\nnativeMap = ArrayProto.map\nnativeReduce = ArrayProto.reduce\nnativeReduceRight = ArrayProto.reduceRight\nnativeFilter = ArrayProto.filter\nnativeEvery = ArrayProto.every\nnativeSome = ArrayProto.some\nnativeIndexOf = ArrayProto.indexOf\nnativeLastIndexOf = ArrayProto.lastIndexOf\nnativeIsArray = Array.isArray\nnativeKeys = Object.keys\n\n\n# Create a safe reference to the Underscore object for use below.\n_ = (obj) -> new wrapper(obj)\n\n\n# Export the Underscore object for **CommonJS**.\nif typeof(exports) != 'undefined' then exports._ = _\n\n\n# Export Underscore to global scope.\nroot._ = _\n\n\n# Current version.\n_.VERSION = '1.1.0'\n\n\n# Collection Functions\n# --------------------\n\n# The cornerstone, an **each** implementation.\n# Handles objects implementing **forEach**, arrays, and raw objects.\n_.each = (obj, iterator, context) ->\n try\n if nativeForEach and obj.forEach is nativeForEach\n obj.forEach iterator, context\n else if _.isNumber obj.length\n iterator.call context, obj[i], i, obj for i in [0...obj.length]\n else\n iterator.call context, val, key, obj for own key, val of obj\n catch e\n throw e if e isnt breaker\n obj\n\n\n# Return the results of applying the iterator to each element. Use JavaScript\n# 1.6's version of **map**, if possible.\n_.map = (obj, iterator, context) ->\n return obj.map(iterator, context) if nativeMap and obj.map is nativeMap\n results = []\n _.each obj, (value, index, list) ->\n results.push iterator.call context, value, index, list\n results\n\n\n# **Reduce** builds up a single result from a list of values. Also known as\n# **inject**, or **foldl**. Uses JavaScript 1.8's version of **reduce**, if possible.\n_.reduce = (obj, iterator, memo, context) ->\n if nativeReduce and obj.reduce is nativeReduce\n iterator = _.bind iterator, context if context\n return obj.reduce iterator, memo\n _.each obj, (value, index, list) ->\n memo = iterator.call context, memo, value, index, list\n memo\n\n\n# The right-associative version of **reduce**, also known as **foldr**. Uses\n# JavaScript 1.8's version of **reduceRight**, if available.\n_.reduceRight = (obj, iterator, memo, context) ->\n if nativeReduceRight and obj.reduceRight is nativeReduceRight\n iterator = _.bind iterator, context if context\n return obj.reduceRight iterator, memo\n reversed = _.clone(_.toArray(obj)).reverse()\n _.reduce reversed, iterator, memo, context\n\n\n# Return the first value which passes a truth test.\n_.detect = (obj, iterator, context) ->\n result = null\n _.each obj, (value, index, list) ->\n if iterator.call context, value, index, list\n result = value\n _.breakLoop()\n result\n\n\n# Return all the elements that pass a truth test. Use JavaScript 1.6's\n# **filter**, if it exists.\n_.filter = (obj, iterator, context) ->\n return obj.filter iterator, context if nativeFilter and obj.filter is nativeFilter\n results = []\n _.each obj, (value, index, list) ->\n results.push value if iterator.call context, value, index, list\n results\n\n\n# Return all the elements for which a truth test fails.\n_.reject = (obj, iterator, context) ->\n results = []\n _.each obj, (value, index, list) ->\n results.push value if not iterator.call context, value, index, list\n results\n\n\n# Determine whether all of the elements match a truth test. Delegate to\n# JavaScript 1.6's **every**, if it is present.\n_.every = (obj, iterator, context) ->\n iterator ||= _.identity\n return obj.every iterator, context if nativeEvery and obj.every is nativeEvery\n result = true\n _.each obj, (value, index, list) ->\n _.breakLoop() unless (result = result and iterator.call(context, value, index, list))\n result\n\n\n# Determine if at least one element in the object matches a truth test. Use\n# JavaScript 1.6's **some**, if it exists.\n_.some = (obj, iterator, context) ->\n iterator ||= _.identity\n return obj.some iterator, context if nativeSome and obj.some is nativeSome\n result = false\n _.each obj, (value, index, list) ->\n _.breakLoop() if (result = iterator.call(context, value, index, list))\n result\n\n\n# Determine if a given value is included in the array or object,\n# based on `===`.\n_.include = (obj, target) ->\n return _.indexOf(obj, target) isnt -1 if nativeIndexOf and obj.indexOf is nativeIndexOf\n return true for own key, val of obj when val is target\n false\n\n\n# Invoke a method with arguments on every item in a collection.\n_.invoke = (obj, method) ->\n args = _.rest arguments, 2\n (if method then val[method] else val).apply(val, args) for val in obj\n\n\n# Convenience version of a common use case of **map**: fetching a property.\n_.pluck = (obj, key) ->\n _.map(obj, (val) -> val[key])\n\n\n# Return the maximum item or (item-based computation).\n_.max = (obj, iterator, context) ->\n return Math.max.apply(Math, obj) if not iterator and _.isArray(obj)\n result = computed: -Infinity\n _.each obj, (value, index, list) ->\n computed = if iterator then iterator.call(context, value, index, list) else value\n computed >= result.computed and (result = {value: value, computed: computed})\n result.value\n\n\n# Return the minimum element (or element-based computation).\n_.min = (obj, iterator, context) ->\n return Math.min.apply(Math, obj) if not iterator and _.isArray(obj)\n result = computed: Infinity\n _.each obj, (value, index, list) ->\n computed = if iterator then iterator.call(context, value, index, list) else value\n computed < result.computed and (result = {value: value, computed: computed})\n result.value\n\n\n# Sort the object's values by a criterion produced by an iterator.\n_.sortBy = (obj, iterator, context) ->\n _.pluck(((_.map obj, (value, index, list) ->\n {value: value, criteria: iterator.call(context, value, index, list)}\n ).sort((left, right) ->\n a = left.criteria; b = right.criteria\n if a < b then -1 else if a > b then 1 else 0\n )), 'value')\n\n\n# Use a comparator function to figure out at what index an object should\n# be inserted so as to maintain order. Uses binary search.\n_.sortedIndex = (array, obj, iterator) ->\n iterator ||= _.identity\n low = 0\n high = array.length\n while low < high\n mid = (low + high) >> 1\n if iterator(array[mid]) < iterator(obj) then low = mid + 1 else high = mid\n low\n\n\n# Convert anything iterable into a real, live array.\n_.toArray = (iterable) ->\n return [] if (!iterable)\n return iterable.toArray() if (iterable.toArray)\n return iterable if (_.isArray(iterable))\n return slice.call(iterable) if (_.isArguments(iterable))\n _.values(iterable)\n\n\n# Return the number of elements in an object.\n_.size = (obj) -> _.toArray(obj).length\n\n\n# Array Functions\n# ---------------\n\n# Get the first element of an array. Passing `n` will return the first N\n# values in the array. Aliased as **head**. The `guard` check allows it to work\n# with **map**.\n_.first = (array, n, guard) ->\n if n and not guard then slice.call(array, 0, n) else array[0]\n\n\n# Returns everything but the first entry of the array. Aliased as **tail**.\n# Especially useful on the arguments object. Passing an `index` will return\n# the rest of the values in the array from that index onward. The `guard`\n# check allows it to work with **map**.\n_.rest = (array, index, guard) ->\n slice.call(array, if _.isUndefined(index) or guard then 1 else index)\n\n\n# Get the last element of an array.\n_.last = (array) -> array[array.length - 1]\n\n\n# Trim out all falsy values from an array.\n_.compact = (array) -> item for item in array when item\n\n\n# Return a completely flattened version of an array.\n_.flatten = (array) ->\n _.reduce array, (memo, value) ->\n return memo.concat(_.flatten(value)) if _.isArray value\n memo.push value\n memo\n , []\n\n\n# Return a version of the array that does not contain the specified value(s).\n_.without = (array) ->\n values = _.rest arguments\n val for val in _.toArray(array) when not _.include values, val\n\n\n# Produce a duplicate-free version of the array. If the array has already\n# been sorted, you have the option of using a faster algorithm.\n_.uniq = (array, isSorted) ->\n memo = []\n for el, i in _.toArray array\n memo.push el if i is 0 || (if isSorted is true then _.last(memo) isnt el else not _.include(memo, el))\n memo\n\n\n# Produce an array that contains every item shared between all the\n# passed-in arrays.\n_.intersect = (array) ->\n rest = _.rest arguments\n _.select _.uniq(array), (item) ->\n _.all rest, (other) ->\n _.indexOf(other, item) >= 0\n\n\n# Zip together multiple lists into a single array -- elements that share\n# an index go together.\n_.zip = ->\n length = _.max _.pluck arguments, 'length'\n results = new Array length\n for i in [0...length]\n results[i] = _.pluck arguments, String i\n results\n\n\n# If the browser doesn't supply us with **indexOf** (I'm looking at you, MSIE),\n# we need this function. Return the position of the first occurrence of an\n# item in an array, or -1 if the item is not included in the array.\n_.indexOf = (array, item) ->\n return array.indexOf item if nativeIndexOf and array.indexOf is nativeIndexOf\n i = 0; l = array.length\n while l - i\n if array[i] is item then return i else i++\n -1\n\n\n# Provide JavaScript 1.6's **lastIndexOf**, delegating to the native function,\n# if possible.\n_.lastIndexOf = (array, item) ->\n return array.lastIndexOf(item) if nativeLastIndexOf and array.lastIndexOf is nativeLastIndexOf\n i = array.length\n while i\n if array[i] is item then return i else i--\n -1\n\n\n# Generate an integer Array containing an arithmetic progression. A port of\n# [the native Python **range** function](http://docs.python.org/library/functions.html#range).\n_.range = (start, stop, step) ->\n a = arguments\n solo = a.length <= 1\n i = start = if solo then 0 else a[0]\n stop = if solo then a[0] else a[1]\n step = a[2] or 1\n len = Math.ceil((stop - start) / step)\n return [] if len <= 0\n range = new Array len\n idx = 0\n loop\n return range if (if step > 0 then i - stop else stop - i) >= 0\n range[idx] = i\n idx++\n i+= step\n\n\n# Function Functions\n# ------------------\n\n# Create a function bound to a given object (assigning `this`, and arguments,\n# optionally). Binding with arguments is also known as **curry**.\n_.bind = (func, obj) ->\n args = _.rest arguments, 2\n -> func.apply obj or root, args.concat arguments\n\n\n# Bind all of an object's methods to that object. Useful for ensuring that\n# all callbacks defined on an object belong to it.\n_.bindAll = (obj) ->\n funcs = if arguments.length > 1 then _.rest(arguments) else _.functions(obj)\n _.each funcs, (f) -> obj[f] = _.bind obj[f], obj\n obj\n\n\n# Delays a function for the given number of milliseconds, and then calls\n# it with the arguments supplied.\n_.delay = (func, wait) ->\n args = _.rest arguments, 2\n setTimeout((-> func.apply(func, args)), wait)\n\n\n# Memoize an expensive function by storing its results.\n_.memoize = (func, hasher) ->\n memo = {}\n hasher or= _.identity\n ->\n key = hasher.apply this, arguments\n return memo[key] if key of memo\n memo[key] = func.apply this, arguments\n\n\n# Defers a function, scheduling it to run after the current call stack has\n# cleared.\n_.defer = (func) ->\n _.delay.apply _, [func, 1].concat _.rest arguments\n\n\n# Returns the first function passed as an argument to the second,\n# allowing you to adjust arguments, run code before and after, and\n# conditionally execute the original function.\n_.wrap = (func, wrapper) ->\n -> wrapper.apply wrapper, [func].concat arguments\n\n\n# Returns a function that is the composition of a list of functions, each\n# consuming the return value of the function that follows.\n_.compose = ->\n funcs = arguments\n ->\n args = arguments\n for i in [funcs.length - 1..0] by -1\n args = [funcs[i].apply(this, args)]\n args[0]\n\n\n# Object Functions\n# ----------------\n\n# Retrieve the names of an object's properties.\n_.keys = nativeKeys or (obj) ->\n return _.range 0, obj.length if _.isArray(obj)\n key for key, val of obj\n\n\n# Retrieve the values of an object's properties.\n_.values = (obj) ->\n _.map obj, _.identity\n\n\n# Return a sorted list of the function names available in Underscore.\n_.functions = (obj) ->\n _.filter(_.keys(obj), (key) -> _.isFunction(obj[key])).sort()\n\n\n# Extend a given object with all of the properties in a source object.\n_.extend = (obj) ->\n for source in _.rest(arguments)\n obj[key] = val for key, val of source\n obj\n\n\n# Create a (shallow-cloned) duplicate of an object.\n_.clone = (obj) ->\n return obj.slice 0 if _.isArray obj\n _.extend {}, obj\n\n\n# Invokes interceptor with the obj, and then returns obj.\n# The primary purpose of this method is to \"tap into\" a method chain,\n# in order to perform operations on intermediate results within\n the chain.\n_.tap = (obj, interceptor) ->\n interceptor obj\n obj\n\n\n# Perform a deep comparison to check if two objects are equal.\n_.isEqual = (a, b) ->\n # Check object identity.\n return true if a is b\n # Different types?\n atype = typeof(a); btype = typeof(b)\n return false if atype isnt btype\n # Basic equality test (watch out for coercions).\n return true if `a == b`\n # One is falsy and the other truthy.\n return false if (!a and b) or (a and !b)\n # One of them implements an `isEqual()`?\n return a.isEqual(b) if a.isEqual\n # Check dates' integer values.\n return a.getTime() is b.getTime() if _.isDate(a) and _.isDate(b)\n # Both are NaN?\n return false if _.isNaN(a) and _.isNaN(b)\n # Compare regular expressions.\n if _.isRegExp(a) and _.isRegExp(b)\n return a.source is b.source and\n a.global is b.global and\n a.ignoreCase is b.ignoreCase and\n a.multiline is b.multiline\n # If a is not an object by this point, we can't handle it.\n return false if atype isnt 'object'\n # Check for different array lengths before comparing contents.\n return false if a.length and (a.length isnt b.length)\n # Nothing else worked, deep compare the contents.\n aKeys = _.keys(a); bKeys = _.keys(b)\n # Different object sizes?\n return false if aKeys.length isnt bKeys.length\n # Recursive comparison of contents.\n return false for key, val of a when !(key of b) or !_.isEqual(val, b[key])\n true\n\n\n# Is a given array or object empty?\n_.isEmpty = (obj) ->\n return obj.length is 0 if _.isArray(obj) or _.isString(obj)\n return false for own key of obj\n true\n\n\n# Is a given value a DOM element?\n_.isElement = (obj) -> obj and obj.nodeType is 1\n\n\n# Is a given value an array?\n_.isArray = nativeIsArray or (obj) -> !!(obj and obj.concat and obj.unshift and not obj.callee)\n\n\n# Is a given variable an arguments object?\n_.isArguments = (obj) -> obj and obj.callee\n\n\n# Is the given value a function?\n_.isFunction = (obj) -> !!(obj and obj.constructor and obj.call and obj.apply)\n\n\n# Is the given value a string?\n_.isString = (obj) -> !!(obj is '' or (obj and obj.charCodeAt and obj.substr))\n\n\n# Is a given value a number?\n_.isNumber = (obj) -> (obj is +obj) or toString.call(obj) is '[object Number]'\n\n\n# Is a given value a boolean?\n_.isBoolean = (obj) -> obj is true or obj is false\n\n\n# Is a given value a Date?\n_.isDate = (obj) -> !!(obj and obj.getTimezoneOffset and obj.setUTCFullYear)\n\n\n# Is the given value a regular expression?\n_.isRegExp = (obj) -> !!(obj and obj.exec and (obj.ignoreCase or obj.ignoreCase is false))\n\n\n# Is the given value NaN -- this one is interesting. `NaN != NaN`, and\n# `isNaN(undefined) == true`, so we make sure it's a number first.\n_.isNaN = (obj) -> _.isNumber(obj) and window.isNaN(obj)\n\n\n# Is a given value equal to null?\n_.isNull = (obj) -> obj is null\n\n\n# Is a given variable undefined?\n_.isUndefined = (obj) -> typeof obj is 'undefined'\n\n\n# Utility Functions\n# -----------------\n\n# Run Underscore.js in noConflict mode, returning the `_` variable to its\n# previous owner. Returns a reference to the Underscore object.\n_.noConflict = ->\n root._ = previousUnderscore\n this\n\n\n# Keep the identity function around for default iterators.\n_.identity = (value) -> value\n\n\n# Run a function `n` times.\n_.times = (n, iterator, context) ->\n iterator.call context, i for i in [0...n]\n\n\n# Break out of the middle of an iteration.\n_.breakLoop = -> throw breaker\n\n\n# Add your own custom functions to the Underscore object, ensuring that\n# they're correctly added to the OOP wrapper as well.\n_.mixin = (obj) ->\n for name in _.functions(obj)\n addToWrapper name, _[name] = obj[name]\n\n\n# Generate a unique integer id (unique within the entire client session).\n# Useful for temporary DOM ids.\nidCounter = 0\n_.uniqueId = (prefix) ->\n (prefix or '') + idCounter++\n\n\n# By default, Underscore uses **ERB**-style template delimiters, change the\n# following template settings to use alternative delimiters.\n_.templateSettings = {\n start: '<%'\n end: '%>'\n interpolate: /<%=(.+?)%>/g\n}\n\n\n# JavaScript templating a-la **ERB**, pilfered from John Resig's\n# *Secrets of the JavaScript Ninja*, page 83.\n# Single-quote fix from Rick Strahl.\n# With alterations for arbitrary delimiters, and to preserve whitespace.\n_.template = (str, data) ->\n c = _.templateSettings\n endMatch = new RegExp(\"'(?=[^\"+c.end.substr(0, 1)+\"]*\"+escapeRegExp(c.end)+\")\",\"g\")\n fn = new Function 'obj',\n 'var p=[],print=function(){p.push.apply(p,arguments);};' +\n 'with(obj||{}){p.push(\\'' +\n str.replace(/\\r/g, '\\\\r')\n .replace(/\\n/g, '\\\\n')\n .replace(/\\t/g, '\\\\t')\n .replace(endMatch,\"���\")\n .split(\"'\").join(\"\\\\'\")\n .split(\"���\").join(\"'\")\n .replace(c.interpolate, \"',$1,'\")\n .split(c.start).join(\"');\")\n .split(c.end).join(\"p.push('\") +\n \"');}return p.join('');\"\n if data then fn(data) else fn\n\n\n# Aliases\n# -------\n\n_.forEach = _.each\n_.foldl = _.inject = _.reduce\n_.foldr = _.reduceRight\n_.select = _.filter\n_.all = _.every\n_.any = _.some\n_.contains = _.include\n_.head = _.first\n_.tail = _.rest\n_.methods = _.functions\n\n\n# Setup the OOP Wrapper\n# ---------------------\n\n# If Underscore is called as a function, it returns a wrapped object that\n# can be used OO-style. This wrapper holds altered versions of all the\n# underscore functions. Wrapped objects may be chained.\nwrapper = (obj) ->\n this._wrapped = obj\n this\n\n\n# Helper function to continue chaining intermediate results.\nresult = (obj, chain) ->\n if chain then _(obj).chain() else obj\n\n\n# A method to easily add functions to the OOP wrapper.\naddToWrapper = (name, func) ->\n wrapper.prototype[name] = ->\n args = _.toArray arguments\n unshift.call args, this._wrapped\n result func.apply(_, args), this._chain\n\n\n# Add all ofthe Underscore functions to the wrapper object.\n_.mixin _\n\n\n# Add all mutator Array functions to the wrapper.\n_.each ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], (name) ->\n method = Array.prototype[name]\n wrapper.prototype[name] = ->\n method.apply(this._wrapped, arguments)\n result(this._wrapped, this._chain)\n\n\n# Add all accessor Array functions to the wrapper.\n_.each ['concat', 'join', 'slice'], (name) ->\n method = Array.prototype[name]\n wrapper.prototype[name] = ->\n result(method.apply(this._wrapped, arguments), this._chain)\n\n\n# Start chaining a wrapped Underscore object.\nwrapper::chain = ->\n this._chain = true\n this\n\n\n# Extracts the result from a wrapped and chained object.\nwrapper::value = -> this._wrapped\n\n \n\n MIME types defined: text/x-coffeescript.\n\n The CoffeeScript mode was written by Jeff Pickhardt.\n\n
\nCommon Lisp mode\n(in-package :cl-postgres)\n\n;; These are used to synthesize reader and writer names for integer\n;; reading/writing functions when the amount of bytes and the\n;; signedness is known. Both the macro that creates the functions and\n;; some macros that use them create names this way.\n(eval-when (:compile-toplevel :load-toplevel :execute)\n (defun integer-reader-name (bytes signed)\n (intern (with-standard-io-syntax\n (format nil \"~a~a~a~a\" '#:read- (if signed \"\" '#:u) '#:int bytes))))\n (defun integer-writer-name (bytes signed)\n (intern (with-standard-io-syntax\n (format nil \"~a~a~a~a\" '#:write- (if signed \"\" '#:u) '#:int bytes)))))\n\n(defmacro integer-reader (bytes)\n \"Create a function to read integers from a binary stream.\"\n (let ((bits (* bytes 8)))\n (labels ((return-form (signed)\n (if signed\n `(if (logbitp ,(1- bits) result)\n (dpb result (byte ,(1- bits) 0) -1)\n result)\n `result))\n (generate-reader (signed)\n `(defun ,(integer-reader-name bytes signed) (socket)\n (declare (type stream socket)\n #.*optimize*)\n ,(if (= bytes 1)\n `(let ((result (the (unsigned-byte 8) (read-byte socket))))\n (declare (type (unsigned-byte 8) result))\n ,(return-form signed))\n `(let ((result 0))\n (declare (type (unsigned-byte ,bits) result))\n ,@(loop :for byte :from (1- bytes) :downto 0\n :collect `(setf (ldb (byte 8 ,(* 8 byte)) result)\n (the (unsigned-byte 8) (read-byte socket))))\n ,(return-form signed))))))\n `(progn\n;; This causes weird errors on SBCL in some circumstances. Disabled for now.\n;; (declaim (inline ,(integer-reader-name bytes t)\n;; ,(integer-reader-name bytes nil)))\n (declaim (ftype (function (t) (signed-byte ,bits))\n ,(integer-reader-name bytes t)))\n ,(generate-reader t)\n (declaim (ftype (function (t) (unsigned-byte ,bits))\n ,(integer-reader-name bytes nil)))\n ,(generate-reader nil)))))\n\n(defmacro integer-writer (bytes)\n \"Create a function to write integers to a binary stream.\"\n (let ((bits (* 8 bytes)))\n `(progn\n (declaim (inline ,(integer-writer-name bytes t)\n ,(integer-writer-name bytes nil)))\n (defun ,(integer-writer-name bytes nil) (socket value)\n (declare (type stream socket)\n (type (unsigned-byte ,bits) value)\n #.*optimize*)\n ,@(if (= bytes 1)\n `((write-byte value socket))\n (loop :for byte :from (1- bytes) :downto 0\n :collect `(write-byte (ldb (byte 8 ,(* byte 8)) value)\n socket)))\n (values))\n (defun ,(integer-writer-name bytes t) (socket value)\n (declare (type stream socket)\n (type (signed-byte ,bits) value)\n #.*optimize*)\n ,@(if (= bytes 1)\n `((write-byte (ldb (byte 8 0) value) socket))\n (loop :for byte :from (1- bytes) :downto 0\n :collect `(write-byte (ldb (byte 8 ,(* byte 8)) value)\n socket)))\n (values)))))\n\n;; All the instances of the above that we need.\n\n(integer-reader 1)\n(integer-reader 2)\n(integer-reader 4)\n(integer-reader 8)\n\n(integer-writer 1)\n(integer-writer 2)\n(integer-writer 4)\n\n(defun write-bytes (socket bytes)\n \"Write a byte-array to a stream.\"\n (declare (type stream socket)\n (type (simple-array (unsigned-byte 8)) bytes)\n #.*optimize*)\n (write-sequence bytes socket))\n\n(defun write-str (socket string)\n \"Write a null-terminated string to a stream \\(encoding it when UTF-8\nsupport is enabled.).\"\n (declare (type stream socket)\n (type string string)\n #.*optimize*)\n (enc-write-string string socket)\n (write-uint1 socket 0))\n\n(declaim (ftype (function (t unsigned-byte)\n (simple-array (unsigned-byte 8) (*)))\n read-bytes))\n(defun read-bytes (socket length)\n \"Read a byte array of the given length from a stream.\"\n (declare (type stream socket)\n (type fixnum length)\n #.*optimize*)\n (let ((result (make-array length :element-type '(unsigned-byte 8))))\n (read-sequence result socket)\n result))\n\n(declaim (ftype (function (t) string) read-str))\n(defun read-str (socket)\n \"Read a null-terminated string from a stream. Takes care of encoding\nwhen UTF-8 support is enabled.\"\n (declare (type stream socket)\n #.*optimize*)\n (enc-read-string socket :null-terminated t))\n\n(defun skip-bytes (socket length)\n \"Skip a given number of bytes in a binary stream.\"\n (declare (type stream socket)\n (type (unsigned-byte 32) length)\n #.*optimize*)\n (dotimes (i length)\n (read-byte socket)))\n\n(defun skip-str (socket)\n \"Skip a null-terminated string.\"\n (declare (type stream socket)\n #.*optimize*)\n (loop :for char :of-type fixnum = (read-byte socket)\n :until (zerop char)))\n\n(defun ensure-socket-is-closed (socket &key abort)\n (when (open-stream-p socket)\n (handler-case\n (close socket :abort abort)\n (error (error)\n (warn \"Ignoring the error which happened while trying to close PostgreSQL socket: ~A\" error)))))\n\n \n\n MIME types defined: text/x-common-lisp.\n\n
\nCSS mode\n\n/* Some example CSS */\n\n@import url(\"something.css\");\n\nbody {\n margin: 0;\n padding: 3em 6em;\n font-family: tahoma, arial, sans-serif;\n color: #000;\n}\n\n#navigation a {\n font-weight: bold;\n text-decoration: none !important;\n}\n\nh1 {\n font-size: 2.5em;\n}\n\nh2 {\n font-size: 1.7em;\n}\n\nh1:before, h2:before {\n content: \"::\";\n}\n\ncode {\n font-family: courier, monospace;\n font-size: 80%;\n color: #418A8A;\n}\n\n \n\n MIME types defined: text/css, text/x-scss (demo), text/x-less (demo).\n\n Parsing/Highlighting Tests: normal, verbose.\n\n
\nLESS mode\n@media screen and (device-aspect-ratio: 16/9) { … }\n@media screen and (device-aspect-ratio: 1280/720) { … }\n@media screen and (device-aspect-ratio: 2560/1440) { … }\n\nhtml:lang(fr-be)\n\ntr:nth-child(2n+1) /* represents every odd row of an HTML table */\n\nimg:nth-of-type(2n+1) { float: right; }\nimg:nth-of-type(2n) { float: left; }\n\nbody > h2:not(:first-of-type):not(:last-of-type)\n\nhtml|*:not(:link):not(:visited)\n*|*:not(:hover)\np::first-line { text-transform: uppercase }\n\n@namespace foo url(http://www.example.com);\nfoo|h1 { color: blue } /* first rule */\n\nspan[hello=\"Ocean\"][goodbye=\"Land\"]\n\nE[foo]{\n padding:65px;\n}\n\ninput[type=\"search\"]::-webkit-search-decoration,\ninput[type=\"search\"]::-webkit-search-cancel-button {\n -webkit-appearance: none; // Inner-padding issues in Chrome OSX, Safari 5\n}\nbutton::-moz-focus-inner,\ninput::-moz-focus-inner { // Inner padding and border oddities in FF3/4\n padding: 0;\n border: 0;\n}\n.btn {\n // reset here as of 2.0.3 due to Recess property order\n border-color: #ccc;\n border-color: rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25);\n}\nfieldset span button, fieldset span input[type=\"file\"] {\n font-size:12px;\n\tfont-family:Arial, Helvetica, sans-serif;\n}\n\n.rounded-corners (@radius: 5px) {\n border-radius: @radius;\n -webkit-border-radius: @radius;\n -moz-border-radius: @radius;\n}\n\n@import url(\"something.css\");\n\n@light-blue: hsl(190, 50%, 65%);\n\n#menu {\n position: absolute;\n width: 100%;\n z-index: 3;\n clear: both;\n display: block;\n background-color: @blue;\n height: 42px;\n border-top: 2px solid lighten(@alpha-blue, 20%);\n border-bottom: 2px solid darken(@alpha-blue, 25%);\n .box-shadow(0, 1px, 8px, 0.6);\n -moz-box-shadow: 0 0 0 #000; // Because firefox sucks.\n\n &.docked {\n background-color: hsla(210, 60%, 40%, 0.4);\n }\n &:hover {\n background-color: @blue;\n }\n\n #dropdown {\n margin: 0 0 0 117px;\n padding: 0;\n padding-top: 5px;\n display: none;\n width: 190px;\n border-top: 2px solid @medium;\n color: @highlight;\n border: 2px solid darken(@medium, 25%);\n border-left-color: darken(@medium, 15%);\n border-right-color: darken(@medium, 15%);\n border-top-width: 0;\n background-color: darken(@medium, 10%);\n ul {\n padding: 0px; \n }\n li {\n font-size: 14px;\n display: block;\n text-align: left;\n padding: 0;\n border: 0;\n a {\n display: block;\n padding: 0px 15px; \n text-decoration: none;\n color: white; \n &:hover {\n background-color: darken(@medium, 15%);\n text-decoration: none;\n }\n }\n }\n .border-radius(5px, bottom);\n .box-shadow(0, 6px, 8px, 0.5);\n }\n}\n\n \n\n The LESS mode is a sub-mode of the CSS mode (defined in css.js.\n\n Parsing/Highlighting Tests: normal, verbose.\n
\nSCSS mode\n\n/* Some example SCSS */\n\n@import \"compass/css3\";\n$variable: #333;\n\n$blue: #3bbfce;\n$margin: 16px;\n\n.content-navigation {\n #nested {\n background-color: black;\n }\n border-color: $blue;\n color:\n darken($blue, 9%);\n}\n\n.border {\n padding: $margin / 2;\n margin: $margin / 2;\n border-color: $blue;\n}\n\n@mixin table-base {\n th {\n text-align: center;\n font-weight: bold;\n }\n td, th {padding: 2px}\n}\n\ntable.hl {\n margin: 2em 0;\n td.ln {\n text-align: right;\n }\n}\n\nli {\n font: {\n family: serif;\n weight: bold;\n size: 1.2em;\n }\n}\n\n@mixin left($dist) {\n float: left;\n margin-left: $dist;\n}\n\n#data {\n @include left(10px);\n @include table-base;\n}\n\n.source {\n @include flow-into(target);\n border: 10px solid green;\n margin: 20px;\n width: 200px; }\n\n.new-container {\n @include flow-from(target);\n border: 10px solid red;\n margin: 20px;\n width: 200px; }\n\nbody {\n margin: 0;\n padding: 3em 6em;\n font-family: tahoma, arial, sans-serif;\n color: #000;\n}\n\n@mixin yellow() {\n background: yellow;\n}\n\n.big {\n font-size: 14px;\n}\n\n.nested {\n @include border-radius(3px);\n @extend .big;\n p {\n background: whitesmoke;\n a {\n color: red;\n }\n }\n}\n\n#navigation a {\n font-weight: bold;\n text-decoration: none !important;\n}\n\nh1 {\n font-size: 2.5em;\n}\n\nh2 {\n font-size: 1.7em;\n}\n\nh1:before, h2:before {\n content: \"::\";\n}\n\ncode {\n font-family: courier, monospace;\n font-size: 80%;\n color: #418A8A;\n}\n\n \n\n The SCSS mode is a sub-mode of the CSS mode (defined in css.js.\n\n Parsing/Highlighting Tests: normal, verbose.\n\n
\nCypher Mode for CodeMirror\n\n // Cypher Mode for CodeMirror, using the neo theme\nMATCH (joe { name: 'Joe' })-[:knows*2..2]-(friend_of_friend)\nWHERE NOT (joe)-[:knows]-(friend_of_friend)\nRETURN friend_of_friend.name, COUNT(*)\nORDER BY COUNT(*) DESC , friend_of_friend.name\n\n \n MIME types defined: \n application/x-cypher-query\n \n\n\n
\nD mode\n\n/* D demo code // copied from phobos/sd/metastrings.d */\n// Written in the D programming language.\n\n/**\nTemplates with which to do compile-time manipulation of strings.\n\nMacros:\n WIKI = Phobos/StdMetastrings\n\nCopyright: Copyright Digital Mars 2007 - 2009.\nLicense: <a href=\"http://www.boost.org/LICENSE_1_0.txt\">Boost License 1.0</a>.\nAuthors: $(WEB digitalmars.com, Walter Bright),\n Don Clugston\nSource: $(PHOBOSSRC std/_metastrings.d)\n*/\n/*\n Copyright Digital Mars 2007 - 2009.\nDistributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE_1_0.txt or copy at\n http://www.boost.org/LICENSE_1_0.txt)\n */\nmodule std.metastrings;\n\n/**\nFormats constants into a string at compile time. Analogous to $(XREF\nstring,format).\n\nParameters:\n\nA = tuple of constants, which can be strings, characters, or integral\n values.\n\nFormats:\n * The formats supported are %s for strings, and %%\n * for the % character.\nExample:\n---\nimport std.metastrings;\nimport std.stdio;\n\nvoid main()\n{\n string s = Format!(\"Arg %s = %s\", \"foo\", 27);\n writefln(s); // \"Arg foo = 27\"\n}\n * ---\n */\n\ntemplate Format(A...)\n{\n static if (A.length == 0)\n enum Format = \"\";\n else static if (is(typeof(A[0]) : const(char)[]))\n enum Format = FormatString!(A[0], A[1..$]);\n else\n enum Format = toStringNow!(A[0]) ~ Format!(A[1..$]);\n}\n\ntemplate FormatString(const(char)[] F, A...)\n{\n static if (F.length == 0)\n enum FormatString = Format!(A);\n else static if (F.length == 1)\n enum FormatString = F[0] ~ Format!(A);\n else static if (F[0..2] == \"%s\")\n enum FormatString\n = toStringNow!(A[0]) ~ FormatString!(F[2..$],A[1..$]);\n else static if (F[0..2] == \"%%\")\n enum FormatString = \"%\" ~ FormatString!(F[2..$],A);\n else\n {\n static assert(F[0] != '%', \"unrecognized format %\" ~ F[1]);\n enum FormatString = F[0] ~ FormatString!(F[1..$],A);\n }\n}\n\nunittest\n{\n auto s = Format!(\"hel%slo\", \"world\", -138, 'c', true);\n assert(s == \"helworldlo-138ctrue\", \"[\" ~ s ~ \"]\");\n}\n\n/**\n * Convert constant argument to a string.\n */\n\ntemplate toStringNow(ulong v)\n{\n static if (v < 10)\n enum toStringNow = \"\" ~ cast(char)(v + '0');\n else\n enum toStringNow = toStringNow!(v / 10) ~ toStringNow!(v % 10);\n}\n\nunittest\n{\n static assert(toStringNow!(1uL << 62) == \"4611686018427387904\");\n}\n\n/// ditto\ntemplate toStringNow(long v)\n{\n static if (v < 0)\n enum toStringNow = \"-\" ~ toStringNow!(cast(ulong) -v);\n else\n enum toStringNow = toStringNow!(cast(ulong) v);\n}\n\nunittest\n{\n static assert(toStringNow!(0x100000000) == \"4294967296\");\n static assert(toStringNow!(-138L) == \"-138\");\n}\n\n/// ditto\ntemplate toStringNow(uint U)\n{\n enum toStringNow = toStringNow!(cast(ulong)U);\n}\n\n/// ditto\ntemplate toStringNow(int I)\n{\n enum toStringNow = toStringNow!(cast(long)I);\n}\n\n/// ditto\ntemplate toStringNow(bool B)\n{\n enum toStringNow = B ? \"true\" : \"false\";\n}\n\n/// ditto\ntemplate toStringNow(string S)\n{\n enum toStringNow = S;\n}\n\n/// ditto\ntemplate toStringNow(char C)\n{\n enum toStringNow = \"\" ~ C;\n}\n\n\n/********\n * Parse unsigned integer literal from the start of string s.\n * returns:\n * .value = the integer literal as a string,\n * .rest = the string following the integer literal\n * Otherwise:\n * .value = null,\n * .rest = s\n */\n\ntemplate parseUinteger(const(char)[] s)\n{\n static if (s.length == 0)\n {\n enum value = \"\";\n enum rest = \"\";\n }\n else static if (s[0] >= '0' && s[0] <= '9')\n {\n enum value = s[0] ~ parseUinteger!(s[1..$]).value;\n enum rest = parseUinteger!(s[1..$]).rest;\n }\n else\n {\n enum value = \"\";\n enum rest = s;\n }\n}\n\n/********\nParse integer literal optionally preceded by $(D '-') from the start\nof string $(D s).\n\nReturns:\n .value = the integer literal as a string,\n .rest = the string following the integer literal\n\nOtherwise:\n .value = null,\n .rest = s\n*/\n\ntemplate parseInteger(const(char)[] s)\n{\n static if (s.length == 0)\n {\n enum value = \"\";\n enum rest = \"\";\n }\n else static if (s[0] >= '0' && s[0] <= '9')\n {\n enum value = s[0] ~ parseUinteger!(s[1..$]).value;\n enum rest = parseUinteger!(s[1..$]).rest;\n }\n else static if (s.length >= 2 &&\n s[0] == '-' && s[1] >= '0' && s[1] <= '9')\n {\n enum value = s[0..2] ~ parseUinteger!(s[2..$]).value;\n enum rest = parseUinteger!(s[2..$]).rest;\n }\n else\n {\n enum value = \"\";\n enum rest = s;\n }\n}\n\nunittest\n{\n assert(parseUinteger!(\"1234abc\").value == \"1234\");\n assert(parseUinteger!(\"1234abc\").rest == \"abc\");\n assert(parseInteger!(\"-1234abc\").value == \"-1234\");\n assert(parseInteger!(\"-1234abc\").rest == \"abc\");\n}\n\n/**\nDeprecated aliases held for backward compatibility.\n*/\ndeprecated alias toStringNow ToString;\n/// Ditto\ndeprecated alias parseUinteger ParseUinteger;\n/// Ditto\ndeprecated alias parseUinteger ParseInteger;\n\n\n\n \n\n Simple mode that handle D-Syntax (DLang Homepage).\n\n MIME types defined: text/x-d\n .\n
\nDiff mode\n\ndiff --git a/index.html b/index.html\nindex c1d9156..7764744 100644\n--- a/index.html\n+++ b/index.html\n@@ -95,7 +95,8 @@ StringStream.prototype = {\n <script>\n var editor = CodeMirror.fromTextArea(document.getElementById(\"code\"), {\n lineNumbers: true,\n- autoMatchBrackets: true\n+ autoMatchBrackets: true,\n+ onGutterClick: function(x){console.log(x);}\n });\n </script>\n </body>\ndiff --git a/lib/codemirror.js b/lib/codemirror.js\nindex 04646a9..9a39cc7 100644\n--- a/lib/codemirror.js\n+++ b/lib/codemirror.js\n@@ -399,10 +399,16 @@ var CodeMirror = (function() {\n }\n \n function onMouseDown(e) {\n- var start = posFromMouse(e), last = start; \n+ var start = posFromMouse(e), last = start, target = e.target();\n if (!start) return;\n setCursor(start.line, start.ch, false);\n if (e.button() != 1) return;\n+ if (target.parentNode == gutter) { \n+ if (options.onGutterClick)\n+ options.onGutterClick(indexOf(gutter.childNodes, target) + showingFrom);\n+ return;\n+ }\n+\n if (!focused) onFocus();\n \n e.stop();\n@@ -808,7 +814,7 @@ var CodeMirror = (function() {\n for (var i = showingFrom; i < showingTo; ++i) {\n var marker = lines[i].gutterMarker;\n if (marker) html.push('<div class=\"' + marker.style + '\">' + htmlEscape(marker.text) + '</div>');\n- else html.push(\"<div>\" + (options.lineNumbers ? i + 1 : \"\\u00a0\") + \"</div>\");\n+ else html.push(\"<div>\" + (options.lineNumbers ? i + options.firstLineNumber : \"\\u00a0\") + \"</div>\");\n }\n gutter.style.display = \"none\"; // TODO test whether this actually helps\n gutter.innerHTML = html.join(\"\");\n@@ -1371,10 +1377,8 @@ var CodeMirror = (function() {\n if (option == \"parser\") setParser(value);\n else if (option === \"lineNumbers\") setLineNumbers(value);\n else if (option === \"gutter\") setGutter(value);\n- else if (option === \"readOnly\") options.readOnly = value;\n- else if (option === \"indentUnit\") {options.indentUnit = indentUnit = value; setParser(options.parser);}\n- else if (/^(?:enterMode|tabMode|indentWithTabs|readOnly|autoMatchBrackets|undoDepth)$/.test(option)) options[option] = value;\n- else throw new Error(\"Can't set option \" + option);\n+ else if (option === \"indentUnit\") {options.indentUnit = value; setParser(options.parser);}\n+ else options[option] = value;\n },\n cursorCoords: cursorCoords,\n undo: operation(undo),\n@@ -1402,7 +1406,8 @@ var CodeMirror = (function() {\n replaceRange: operation(replaceRange),\n \n operation: function(f){return operation(f)();},\n- refresh: function(){updateDisplay([{from: 0, to: lines.length}]);}\n+ refresh: function(){updateDisplay([{from: 0, to: lines.length}]);},\n+ getInputField: function(){return input;}\n };\n return instance;\n }\n@@ -1420,6 +1425,7 @@ var CodeMirror = (function() {\n readOnly: false,\n onChange: null,\n onCursorActivity: null,\n+ onGutterClick: null,\n autoMatchBrackets: false,\n workTime: 200,\n workDelay: 300,\n\n \n\n MIME types defined: text/x-diff.\n\n
\nDjango template mode\n\n<!doctype html>\n<html>\n <head>\n <title>My Django web application</title>\n </head>\n <body>\n <h1>\n {{ page.title }}\n </h1>\n <ul class=\"my-list\">\n {% for item in items %}\n <li>{% item.name %}</li>\n {% empty %}\n <li>You have no items in your list.</li>\n {% endfor %}\n </ul>\n </body>\n</html>\n\n\n \n\n Mode for HTML with embedded Django template markup.\n\n MIME types defined: text/x-django\n
\nDTD mode\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n<!ATTLIST title\n xmlns\tCDATA\t#FIXED\t\"http://docbook.org/ns/docbook\"\n role\tCDATA\t#IMPLIED\n %db.common.attributes;\n %db.common.linking.attributes;\n>\n\n<!--\n Try: http://docbook.org/xml/5.0/dtd/docbook.dtd\n-->\n\n<!DOCTYPE xsl:stylesheet\n [\n <!ENTITY nbsp \" \">\n <!ENTITY copy \"©\">\n <!ENTITY reg \"®\">\n <!ENTITY trade \"™\">\n <!ENTITY mdash \"—\">\n <!ENTITY ldquo \"“\">\n <!ENTITY rdquo \"”\">\n <!ENTITY pound \"£\">\n <!ENTITY yen \"¥\">\n <!ENTITY euro \"€\">\n <!ENTITY mathml \"http://www.w3.org/1998/Math/MathML\">\n ]\n>\n\n<!ELEMENT title (#PCDATA|inlinemediaobject|remark|superscript|subscript|xref|link|olink|anchor|biblioref|alt|annotation|indexterm|abbrev|acronym|date|emphasis|footnote|footnoteref|foreignphrase|phrase|quote|wordasword|firstterm|glossterm|coref|trademark|productnumber|productname|database|application|hardware|citation|citerefentry|citetitle|citebiblioid|author|person|personname|org|orgname|editor|jobtitle|replaceable|package|parameter|termdef|nonterminal|systemitem|option|optional|property|inlineequation|tag|markup|token|symbol|literal|code|constant|email|uri|guiicon|guibutton|guimenuitem|guimenu|guisubmenu|guilabel|menuchoice|mousebutton|keycombo|keycap|keycode|keysym|shortcut|accel|prompt|envar|filename|command|computeroutput|userinput|function|varname|returnvalue|type|classname|exceptionname|interfacename|methodname|modifier|initializer|ooclass|ooexception|oointerface|errorcode|errortext|errorname|errortype)*>\n\n<!ENTITY % db.common.attributes \"\n xml:id\tID\t#IMPLIED\n version\tCDATA\t#IMPLIED\n xml:lang\tCDATA\t#IMPLIED\n xml:base\tCDATA\t#IMPLIED\n remap\tCDATA\t#IMPLIED\n xreflabel\tCDATA\t#IMPLIED\n revisionflag\t(changed|added|deleted|off)\t#IMPLIED\n dir\t(ltr|rtl|lro|rlo)\t#IMPLIED\n arch\tCDATA\t#IMPLIED\n audience\tCDATA\t#IMPLIED\n condition\tCDATA\t#IMPLIED\n conformance\tCDATA\t#IMPLIED\n os\tCDATA\t#IMPLIED\n revision\tCDATA\t#IMPLIED\n security\tCDATA\t#IMPLIED\n userlevel\tCDATA\t#IMPLIED\n vendor\tCDATA\t#IMPLIED\n wordsize\tCDATA\t#IMPLIED\n annotations\tCDATA\t#IMPLIED\n\n\">\n \n\n MIME types defined: application/xml-dtd.\n
\nDylan mode\n\n\n\nModule: locators-internals\nSynopsis: Abstract modeling of locations\nAuthor: Andy Armstrong\nCopyright: Original Code is Copyright (c) 1995-2004 Functional Objects, Inc.\n All rights reserved.\nLicense: See License.txt in this distribution for details.\nWarranty: Distributed WITHOUT WARRANTY OF ANY KIND\n\ndefine open generic locator-server\n (locator :: <locator>) => (server :: false-or(<server-locator>));\ndefine open generic locator-host\n (locator :: <locator>) => (host :: false-or(<string>));\ndefine open generic locator-volume\n (locator :: <locator>) => (volume :: false-or(<string>));\ndefine open generic locator-directory\n (locator :: <locator>) => (directory :: false-or(<directory-locator>));\ndefine open generic locator-relative?\n (locator :: <locator>) => (relative? :: <boolean>);\ndefine open generic locator-path\n (locator :: <locator>) => (path :: <sequence>);\ndefine open generic locator-base\n (locator :: <locator>) => (base :: false-or(<string>));\ndefine open generic locator-extension\n (locator :: <locator>) => (extension :: false-or(<string>));\n\n/// Locator classes\n\ndefine open abstract class <directory-locator> (<physical-locator>)\nend class <directory-locator>;\n\ndefine open abstract class <file-locator> (<physical-locator>)\nend class <file-locator>;\n\ndefine method as\n (class == <directory-locator>, string :: <string>)\n => (locator :: <directory-locator>)\n as(<native-directory-locator>, string)\nend method as;\n\ndefine method make\n (class == <directory-locator>,\n #key server :: false-or(<server-locator>) = #f,\n path :: <sequence> = #[],\n relative? :: <boolean> = #f,\n name :: false-or(<string>) = #f)\n => (locator :: <directory-locator>)\n make(<native-directory-locator>,\n server: server,\n path: path,\n relative?: relative?,\n name: name)\nend method make;\n\ndefine method as\n (class == <file-locator>, string :: <string>)\n => (locator :: <file-locator>)\n as(<native-file-locator>, string)\nend method as;\n\ndefine method make\n (class == <file-locator>,\n #key directory :: false-or(<directory-locator>) = #f,\n base :: false-or(<string>) = #f,\n extension :: false-or(<string>) = #f,\n name :: false-or(<string>) = #f)\n => (locator :: <file-locator>)\n make(<native-file-locator>,\n directory: directory,\n base: base,\n extension: extension,\n name: name)\nend method make;\n\n/// Locator coercion\n\n//---*** andrewa: This caching scheme doesn't work yet, so disable it.\ndefine constant $cache-locators? = #f;\ndefine constant $cache-locator-strings? = #f;\n\ndefine constant $locator-to-string-cache = make(<object-table>, weak: #\"key\");\ndefine constant $string-to-locator-cache = make(<string-table>, weak: #\"value\");\n\ndefine open generic locator-as-string\n (class :: subclass(<string>), locator :: <locator>)\n => (string :: <string>);\n\ndefine open generic string-as-locator\n (class :: subclass(<locator>), string :: <string>)\n => (locator :: <locator>);\n\ndefine sealed sideways method as\n (class :: subclass(<string>), locator :: <locator>)\n => (string :: <string>)\n let string = element($locator-to-string-cache, locator, default: #f);\n if (string)\n as(class, string)\n else\n let string = locator-as-string(class, locator);\n if ($cache-locator-strings?)\n element($locator-to-string-cache, locator) := string;\n else\n string\n end\n end\nend method as;\n\ndefine sealed sideways method as\n (class :: subclass(<locator>), string :: <string>)\n => (locator :: <locator>)\n let locator = element($string-to-locator-cache, string, default: #f);\n if (instance?(locator, class))\n locator\n else\n let locator = string-as-locator(class, string);\n if ($cache-locators?)\n element($string-to-locator-cache, string) := locator;\n else\n locator\n end\n end\nend method as;\n\n/// Locator conditions\n\ndefine class <locator-error> (<format-string-condition>, <error>)\nend class <locator-error>;\n\ndefine function locator-error\n (format-string :: <string>, #rest format-arguments)\n error(make(<locator-error>, \n format-string: format-string,\n format-arguments: format-arguments))\nend function locator-error;\n\n/// Useful locator protocols\n\ndefine open generic locator-test\n (locator :: <directory-locator>) => (test :: <function>);\n\ndefine method locator-test\n (locator :: <directory-locator>) => (test :: <function>)\n \\=\nend method locator-test;\n\ndefine open generic locator-might-have-links?\n (locator :: <directory-locator>) => (links? :: <boolean>);\n\ndefine method locator-might-have-links?\n (locator :: <directory-locator>) => (links? :: singleton(#f))\n #f\nend method locator-might-have-links?;\n\ndefine method locator-relative?\n (locator :: <file-locator>) => (relative? :: <boolean>)\n let directory = locator.locator-directory;\n ~directory | directory.locator-relative?\nend method locator-relative?;\n\ndefine method current-directory-locator?\n (locator :: <directory-locator>) => (current-directory? :: <boolean>)\n locator.locator-relative?\n & locator.locator-path = #[#\"self\"]\nend method current-directory-locator?;\n\ndefine method locator-directory\n (locator :: <directory-locator>) => (parent :: false-or(<directory-locator>))\n let path = locator.locator-path;\n unless (empty?(path))\n make(object-class(locator),\n server: locator.locator-server,\n path: copy-sequence(path, end: path.size - 1),\n relative?: locator.locator-relative?)\n end\nend method locator-directory;\n\n/// Simplify locator\n\ndefine open generic simplify-locator\n (locator :: <physical-locator>)\n => (simplified-locator :: <physical-locator>);\n\ndefine method simplify-locator\n (locator :: <directory-locator>)\n => (simplified-locator :: <directory-locator>)\n let path = locator.locator-path;\n let relative? = locator.locator-relative?;\n let resolve-parent? = ~locator.locator-might-have-links?;\n let simplified-path\n = simplify-path(path, \n resolve-parent?: resolve-parent?,\n relative?: relative?);\n if (path ~= simplified-path)\n make(object-class(locator),\n server: locator.locator-server,\n path: simplified-path,\n relative?: locator.locator-relative?)\n else\n locator\n end\nend method simplify-locator;\n\ndefine method simplify-locator\n (locator :: <file-locator>) => (simplified-locator :: <file-locator>)\n let directory = locator.locator-directory;\n let simplified-directory = directory & simplify-locator(directory);\n if (directory ~= simplified-directory)\n make(object-class(locator),\n directory: simplified-directory,\n base: locator.locator-base,\n extension: locator.locator-extension)\n else\n locator\n end\nend method simplify-locator;\n\n/// Subdirectory locator\n\ndefine open generic subdirectory-locator\n (locator :: <directory-locator>, #rest sub-path)\n => (subdirectory :: <directory-locator>);\n\ndefine method subdirectory-locator\n (locator :: <directory-locator>, #rest sub-path)\n => (subdirectory :: <directory-locator>)\n let old-path = locator.locator-path;\n let new-path = concatenate-as(<simple-object-vector>, old-path, sub-path);\n make(object-class(locator),\n server: locator.locator-server,\n path: new-path,\n relative?: locator.locator-relative?)\nend method subdirectory-locator;\n\n/// Relative locator\n\ndefine open generic relative-locator\n (locator :: <physical-locator>, from-locator :: <physical-locator>)\n => (relative-locator :: <physical-locator>);\n\ndefine method relative-locator\n (locator :: <directory-locator>, from-locator :: <directory-locator>)\n => (relative-locator :: <directory-locator>)\n let path = locator.locator-path;\n let from-path = from-locator.locator-path;\n case\n ~locator.locator-relative? & from-locator.locator-relative? =>\n locator-error\n (\"Cannot find relative path of absolute locator %= from relative locator %=\",\n locator, from-locator);\n locator.locator-server ~= from-locator.locator-server =>\n locator;\n path = from-path =>\n make(object-class(locator),\n path: vector(#\"self\"),\n relative?: #t);\n otherwise =>\n make(object-class(locator),\n path: relative-path(path, from-path, test: locator.locator-test),\n relative?: #t);\n end\nend method relative-locator;\n\ndefine method relative-locator\n (locator :: <file-locator>, from-directory :: <directory-locator>)\n => (relative-locator :: <file-locator>)\n let directory = locator.locator-directory;\n let relative-directory = directory & relative-locator(directory, from-directory);\n if (relative-directory ~= directory)\n simplify-locator\n (make(object-class(locator),\n directory: relative-directory,\n base: locator.locator-base,\n extension: locator.locator-extension))\n else\n locator\n end\nend method relative-locator;\n\ndefine method relative-locator\n (locator :: <physical-locator>, from-locator :: <file-locator>)\n => (relative-locator :: <physical-locator>)\n let from-directory = from-locator.locator-directory;\n case\n from-directory =>\n relative-locator(locator, from-directory);\n ~locator.locator-relative? =>\n locator-error\n (\"Cannot find relative path of absolute locator %= from relative locator %=\",\n locator, from-locator);\n otherwise =>\n locator;\n end\nend method relative-locator;\n\n/// Merge locators\n\ndefine open generic merge-locators\n (locator :: <physical-locator>, from-locator :: <physical-locator>)\n => (merged-locator :: <physical-locator>);\n\n/// Merge locators\n\ndefine method merge-locators\n (locator :: <directory-locator>, from-locator :: <directory-locator>)\n => (merged-locator :: <directory-locator>)\n if (locator.locator-relative?)\n let path = concatenate(from-locator.locator-path, locator.locator-path);\n simplify-locator\n (make(object-class(locator),\n server: from-locator.locator-server,\n path: path,\n relative?: from-locator.locator-relative?))\n else\n locator\n end\nend method merge-locators;\n\ndefine method merge-locators\n (locator :: <file-locator>, from-locator :: <directory-locator>)\n => (merged-locator :: <file-locator>)\n let directory = locator.locator-directory;\n let merged-directory \n = if (directory)\n merge-locators(directory, from-locator)\n else\n simplify-locator(from-locator)\n end;\n if (merged-directory ~= directory)\n make(object-class(locator),\n directory: merged-directory,\n base: locator.locator-base,\n extension: locator.locator-extension)\n else\n locator\n end\nend method merge-locators;\n\ndefine method merge-locators\n (locator :: <physical-locator>, from-locator :: <file-locator>)\n => (merged-locator :: <physical-locator>)\n let from-directory = from-locator.locator-directory;\n if (from-directory)\n merge-locators(locator, from-directory)\n else\n locator\n end\nend method merge-locators;\n\n/// Locator protocols\n\ndefine sideways method supports-open-locator?\n (locator :: <file-locator>) => (openable? :: <boolean>)\n ~locator.locator-relative?\nend method supports-open-locator?;\n\ndefine sideways method open-locator\n (locator :: <file-locator>, #rest keywords, #key, #all-keys)\n => (stream :: <stream>)\n apply(open-file-stream, locator, keywords)\nend method open-locator;\n\n\n \n\n MIME types defined: text/x-dylan.\n
\nECL mode\n\n/*\nsample useless code to demonstrate ecl syntax highlighting\nthis is a multiline comment!\n*/\n\n// this is a singleline comment!\n\nimport ut;\nr := \n record\n string22 s1 := '123';\n integer4 i1 := 123;\n end;\n#option('tmp', true);\nd := dataset('tmp::qb', r, thor);\noutput(d);\n\n \n\n Based on CodeMirror's clike mode. For more information see HPCC Systems web site.\n MIME types defined: text/x-ecl.\n\n
\nEiffel mode\n\nnote\n description: \"[\n Project-wide universal properties.\n This class is an ancestor to all developer-written classes.\n ANY may be customized for individual projects or teams.\n ]\"\n\n library: \"Free implementation of ELKS library\"\n status: \"See notice at end of class.\"\n legal: \"See notice at end of class.\"\n date: \"$Date: 2013-01-25 11:49:00 -0800 (Fri, 25 Jan 2013) $\"\n revision: \"$Revision: 712 $\"\n\nclass\n ANY\n\nfeature -- Customization\n\nfeature -- Access\n\n generator: STRING\n -- Name of current object's generating class\n -- (base class of the type of which it is a direct instance)\n external\n \"built_in\"\n ensure\n generator_not_void: Result /= Void\n generator_not_empty: not Result.is_empty\n end\n\n generating_type: TYPE [detachable like Current]\n -- Type of current object\n -- (type of which it is a direct instance)\n do\n Result := {detachable like Current}\n ensure\n generating_type_not_void: Result /= Void\n end\n\nfeature -- Status report\n\n conforms_to (other: ANY): BOOLEAN\n -- Does type of current object conform to type\n -- of `other' (as per Eiffel: The Language, chapter 13)?\n require\n other_not_void: other /= Void\n external\n \"built_in\"\n end\n\n same_type (other: ANY): BOOLEAN\n -- Is type of current object identical to type of `other'?\n require\n other_not_void: other /= Void\n external\n \"built_in\"\n ensure\n definition: Result = (conforms_to (other) and\n other.conforms_to (Current))\n end\n\nfeature -- Comparison\n\n is_equal (other: like Current): BOOLEAN\n -- Is `other' attached to an object considered\n -- equal to current object?\n require\n other_not_void: other /= Void\n external\n \"built_in\"\n ensure\n symmetric: Result implies other ~ Current\n consistent: standard_is_equal (other) implies Result\n end\n\n frozen standard_is_equal (other: like Current): BOOLEAN\n -- Is `other' attached to an object of the same type\n -- as current object, and field-by-field identical to it?\n require\n other_not_void: other /= Void\n external\n \"built_in\"\n ensure\n same_type: Result implies same_type (other)\n symmetric: Result implies other.standard_is_equal (Current)\n end\n\n frozen equal (a: detachable ANY; b: like a): BOOLEAN\n -- Are `a' and `b' either both void or attached\n -- to objects considered equal?\n do\n if a = Void then\n Result := b = Void\n else\n Result := b /= Void and then\n a.is_equal (b)\n end\n ensure\n definition: Result = (a = Void and b = Void) or else\n ((a /= Void and b /= Void) and then\n a.is_equal (b))\n end\n\n frozen standard_equal (a: detachable ANY; b: like a): BOOLEAN\n -- Are `a' and `b' either both void or attached to\n -- field-by-field identical objects of the same type?\n -- Always uses default object comparison criterion.\n do\n if a = Void then\n Result := b = Void\n else\n Result := b /= Void and then\n a.standard_is_equal (b)\n end\n ensure\n definition: Result = (a = Void and b = Void) or else\n ((a /= Void and b /= Void) and then\n a.standard_is_equal (b))\n end\n\n frozen is_deep_equal (other: like Current): BOOLEAN\n -- Are `Current' and `other' attached to isomorphic object structures?\n require\n other_not_void: other /= Void\n external\n \"built_in\"\n ensure\n shallow_implies_deep: standard_is_equal (other) implies Result\n same_type: Result implies same_type (other)\n symmetric: Result implies other.is_deep_equal (Current)\n end\n\n frozen deep_equal (a: detachable ANY; b: like a): BOOLEAN\n -- Are `a' and `b' either both void\n -- or attached to isomorphic object structures?\n do\n if a = Void then\n Result := b = Void\n else\n Result := b /= Void and then a.is_deep_equal (b)\n end\n ensure\n shallow_implies_deep: standard_equal (a, b) implies Result\n both_or_none_void: (a = Void) implies (Result = (b = Void))\n same_type: (Result and (a /= Void)) implies (b /= Void and then a.same_type (b))\n symmetric: Result implies deep_equal (b, a)\n end\n\nfeature -- Duplication\n\n frozen twin: like Current\n -- New object equal to `Current'\n -- `twin' calls `copy'; to change copying/twinning semantics, redefine `copy'.\n external\n \"built_in\"\n ensure\n twin_not_void: Result /= Void\n is_equal: Result ~ Current\n end\n\n copy (other: like Current)\n -- Update current object using fields of object attached\n -- to `other', so as to yield equal objects.\n require\n other_not_void: other /= Void\n type_identity: same_type (other)\n external\n \"built_in\"\n ensure\n is_equal: Current ~ other\n end\n\n frozen standard_copy (other: like Current)\n -- Copy every field of `other' onto corresponding field\n -- of current object.\n require\n other_not_void: other /= Void\n type_identity: same_type (other)\n external\n \"built_in\"\n ensure\n is_standard_equal: standard_is_equal (other)\n end\n\n frozen clone (other: detachable ANY): like other\n -- Void if `other' is void; otherwise new object\n -- equal to `other'\n --\n -- For non-void `other', `clone' calls `copy';\n -- to change copying/cloning semantics, redefine `copy'.\n obsolete\n \"Use `twin' instead.\"\n do\n if other /= Void then\n Result := other.twin\n end\n ensure\n equal: Result ~ other\n end\n\n frozen standard_clone (other: detachable ANY): like other\n -- Void if `other' is void; otherwise new object\n -- field-by-field identical to `other'.\n -- Always uses default copying semantics.\n obsolete\n \"Use `standard_twin' instead.\"\n do\n if other /= Void then\n Result := other.standard_twin\n end\n ensure\n equal: standard_equal (Result, other)\n end\n\n frozen standard_twin: like Current\n -- New object field-by-field identical to `other'.\n -- Always uses default copying semantics.\n external\n \"built_in\"\n ensure\n standard_twin_not_void: Result /= Void\n equal: standard_equal (Result, Current)\n end\n\n frozen deep_twin: like Current\n -- New object structure recursively duplicated from Current.\n external\n \"built_in\"\n ensure\n deep_twin_not_void: Result /= Void\n deep_equal: deep_equal (Current, Result)\n end\n\n frozen deep_clone (other: detachable ANY): like other\n -- Void if `other' is void: otherwise, new object structure\n -- recursively duplicated from the one attached to `other'\n obsolete\n \"Use `deep_twin' instead.\"\n do\n if other /= Void then\n Result := other.deep_twin\n end\n ensure\n deep_equal: deep_equal (other, Result)\n end\n\n frozen deep_copy (other: like Current)\n -- Effect equivalent to that of:\n -- `copy' (`other' . `deep_twin')\n require\n other_not_void: other /= Void\n do\n copy (other.deep_twin)\n ensure\n deep_equal: deep_equal (Current, other)\n end\n\nfeature {NONE} -- Retrieval\n\n frozen internal_correct_mismatch\n -- Called from runtime to perform a proper dynamic dispatch on `correct_mismatch'\n -- from MISMATCH_CORRECTOR.\n local\n l_msg: STRING\n l_exc: EXCEPTIONS\n do\n if attached {MISMATCH_CORRECTOR} Current as l_corrector then\n l_corrector.correct_mismatch\n else\n create l_msg.make_from_string (\"Mismatch: \")\n create l_exc\n l_msg.append (generating_type.name)\n l_exc.raise_retrieval_exception (l_msg)\n end\n end\n\nfeature -- Output\n\n io: STD_FILES\n -- Handle to standard file setup\n once\n create Result\n Result.set_output_default\n ensure\n io_not_void: Result /= Void\n end\n\n out: STRING\n -- New string containing terse printable representation\n -- of current object\n do\n Result := tagged_out\n ensure\n out_not_void: Result /= Void\n end\n\n frozen tagged_out: STRING\n -- New string containing terse printable representation\n -- of current object\n external\n \"built_in\"\n ensure\n tagged_out_not_void: Result /= Void\n end\n\n print (o: detachable ANY)\n -- Write terse external representation of `o'\n -- on standard output.\n do\n if o /= Void then\n io.put_string (o.out)\n end\n end\n\nfeature -- Platform\n\n Operating_environment: OPERATING_ENVIRONMENT\n -- Objects available from the operating system\n once\n create Result\n ensure\n operating_environment_not_void: Result /= Void\n end\n\nfeature {NONE} -- Initialization\n\n default_create\n -- Process instances of classes with no creation clause.\n -- (Default: do nothing.)\n do\n end\n\nfeature -- Basic operations\n\n default_rescue\n -- Process exception for routines with no Rescue clause.\n -- (Default: do nothing.)\n do\n end\n\n frozen do_nothing\n -- Execute a null action.\n do\n end\n\n frozen default: detachable like Current\n -- Default value of object's type\n do\n end\n\n frozen default_pointer: POINTER\n -- Default value of type `POINTER'\n -- (Avoid the need to write `p'.`default' for\n -- some `p' of type `POINTER'.)\n do\n ensure\n -- Result = Result.default\n end\n\n frozen as_attached: attached like Current\n -- Attached version of Current\n -- (Can be used during transitional period to convert\n -- non-void-safe classes to void-safe ones.)\n do\n Result := Current\n end\n\ninvariant\n reflexive_equality: standard_is_equal (Current)\n reflexive_conformance: conforms_to (Current)\n\nnote\n copyright: \"Copyright (c) 1984-2012, Eiffel Software and others\"\n license: \"Eiffel Forum License v2 (see http://www.eiffel.com/licensing/forum.txt)\"\n source: \"[\n Eiffel Software\n 5949 Hollister Ave., Goleta, CA 93117 USA\n Telephone 805-685-1006, Fax 805-685-6869\n Website http://www.eiffel.com\n Customer support http://support.eiffel.com\n ]\"\n\nend\n\n\n \n\n MIME types defined: text/x-eiffel.\n \n Created by YNH.\n
\nErlang mode\n\n%% -*- mode: erlang; erlang-indent-level: 2 -*-\n%%% Created : 7 May 2012 by mats cronqvist <masse@klarna.com>\n\n%% @doc\n%% Demonstrates how to print a record.\n%% @end\n\n-module('ex').\n-author('mats cronqvist').\n-export([demo/0,\n rec_info/1]).\n\n-record(demo,{a=\"One\",b=\"Two\",c=\"Three\",d=\"Four\"}).\n\nrec_info(demo) -> record_info(fields,demo).\n\ndemo() -> expand_recs(?MODULE,#demo{a=\"A\",b=\"BB\"}).\n\nexpand_recs(M,List) when is_list(List) ->\n [expand_recs(M,L)||L<-List];\nexpand_recs(M,Tup) when is_tuple(Tup) ->\n case tuple_size(Tup) of\n L when L < 1 -> Tup;\n L ->\n try\n Fields = M:rec_info(element(1,Tup)),\n L = length(Fields)+1,\n lists:zip(Fields,expand_recs(M,tl(tuple_to_list(Tup))))\n catch\n _:_ -> list_to_tuple(expand_recs(M,tuple_to_list(Tup)))\n end\n end;\nexpand_recs(_,Term) ->\n Term.\n\n\n \n\n MIME types defined: text/x-erlang.\n
\nFortran mode\n\n\n\n! Example Fortran code\n program average\n\n ! Read in some numbers and take the average\n ! As written, if there are no data points, an average of zero is returned\n ! While this may not be desired behavior, it keeps this example simple\n\n implicit none\n\n real, dimension(:), allocatable :: points\n integer :: number_of_points\n real :: average_points=0., positive_average=0., negative_average=0.\n\n write (*,*) \"Input number of points to average:\"\n read (*,*) number_of_points\n\n allocate (points(number_of_points))\n\n write (*,*) \"Enter the points to average:\"\n read (*,*) points\n\n ! Take the average by summing points and dividing by number_of_points\n if (number_of_points > 0) average_points = sum(points) / number_of_points\n\n ! Now form average over positive and negative points only\n if (count(points > 0.) > 0) then\n positive_average = sum(points, points > 0.) / count(points > 0.)\n end if\n\n if (count(points < 0.) > 0) then\n negative_average = sum(points, points < 0.) / count(points < 0.)\n end if\n\n deallocate (points)\n\n ! Print result to terminal\n write (*,'(a,g12.4)') 'Average = ', average_points\n write (*,'(a,g12.4)') 'Average of positive points = ', positive_average\n write (*,'(a,g12.4)') 'Average of negative points = ', negative_average\n\n end program average\n\n\n \n\n MIME types defined: text/x-Fortran.\n
\nGas mode\n\n\n.syntax unified\n.global main\n\n/* \n * A\n * multi-line\n * comment.\n */\n\n@ A single line comment.\n\nmain:\n push {sp, lr}\n ldr r0, =message\n bl puts\n mov r0, #0\n pop {sp, pc}\n\nmessage:\n .asciz \"Hello world!<br />\"\n\n \n\n \n\n Handles AT&T assembler syntax (more specifically this handles\n the GNU Assembler (gas) syntax.)\n It takes a single optional configuration parameter:\n architecture, which can be one of \"ARM\",\n \"ARMv6\" or \"x86\".\n Including the parameter adds syntax for the registers and special\n directives for the supplied architecture.\n\n MIME types defined: text/x-gas\n
\nGFM mode\n\nGitHub Flavored Markdown\n========================\n\nEverything from markdown plus GFM features:\n\n## URL autolinking\n\nUnderscores_are_allowed_between_words.\n\n## Fenced code blocks (and syntax highlighting)\n\n```javascript\nfor (var i = 0; i < items.length; i++) {\n console.log(items[i], i); // log them\n}\n```\n\n## Task Lists\n\n- [ ] Incomplete task list item\n- [x] **Completed** task list item\n\n## A bit of GitHub spice\n\n* SHA: be6a8cc1c1ecfe9489fb51e4869af15a13fc2cd2\n* User@SHA ref: mojombo@be6a8cc1c1ecfe9489fb51e4869af15a13fc2cd2\n* User/Project@SHA: mojombo/god@be6a8cc1c1ecfe9489fb51e4869af15a13fc2cd2\n* \\#Num: #1\n* User/#Num: mojombo#1\n* User/Project#Num: mojombo/god#1\n\nSee http://github.github.com/github-flavored-markdown/.\n\n\n\n \n\n Optionally depends on other modes for properly highlighted code blocks.\n\n Parsing/Highlighting Tests: normal, verbose.\n\n
\nGherkin mode\n\nFeature: Using Google\n Background: \n Something something\n Something else\n Scenario: Has a homepage\n When I navigate to the google home page\n Then the home page should contain the menu and the search form\n Scenario: Searching for a term \n When I navigate to the google home page\n When I search for Tofu\n Then the search results page is displayed\n Then the search results page contains 10 individual search results\n Then the search results contain a link to the wikipedia tofu page\n\n \n\n MIME types defined: text/x-feature.\n\n
\nGo mode\n\n// Prime Sieve in Go.\n// Taken from the Go specification.\n// Copyright © The Go Authors.\n\npackage main\n\nimport \"fmt\"\n\n// Send the sequence 2, 3, 4, ... to channel 'ch'.\nfunc generate(ch chan<- int) {\n\tfor i := 2; ; i++ {\n\t\tch <- i // Send 'i' to channel 'ch'\n\t}\n}\n\n// Copy the values from channel 'src' to channel 'dst',\n// removing those divisible by 'prime'.\nfunc filter(src <-chan int, dst chan<- int, prime int) {\n\tfor i := range src { // Loop over values received from 'src'.\n\t\tif i%prime != 0 {\n\t\t\tdst <- i // Send 'i' to channel 'dst'.\n\t\t}\n\t}\n}\n\n// The prime sieve: Daisy-chain filter processes together.\nfunc sieve() {\n\tch := make(chan int) // Create a new channel.\n\tgo generate(ch) // Start generate() as a subprocess.\n\tfor {\n\t\tprime := <-ch\n\t\tfmt.Print(prime, \"\\n\")\n\t\tch1 := make(chan int)\n\t\tgo filter(ch, ch1, prime)\n\t\tch = ch1\n\t}\n}\n\nfunc main() {\n\tsieve()\n}\n\n\n \n\n MIME type: text/x-go\n
\nGroovy mode\n\n//Pattern for groovy script\ndef p = ~/.*\\.groovy/\nnew File( 'd:\\\\scripts' ).eachFileMatch(p) {f ->\n // imports list\n def imports = []\n f.eachLine {\n // condition to detect an import instruction\n ln -> if ( ln =~ '^import .*' ) {\n imports << \"${ln - 'import '}\"\n }\n }\n // print thmen\n if ( ! imports.empty ) {\n println f\n imports.each{ println \" $it\" }\n }\n}\n\n/* Coin changer demo code from http://groovy.codehaus.org */\n\nenum UsCoin {\n quarter(25), dime(10), nickel(5), penny(1)\n UsCoin(v) { value = v }\n final value\n}\n\nenum OzzieCoin {\n fifty(50), twenty(20), ten(10), five(5)\n OzzieCoin(v) { value = v }\n final value\n}\n\ndef plural(word, count) {\n if (count == 1) return word\n word[-1] == 'y' ? word[0..-2] + \"ies\" : word + \"s\"\n}\n\ndef change(currency, amount) {\n currency.values().inject([]){ list, coin ->\n int count = amount / coin.value\n amount = amount % coin.value\n list += \"$count ${plural(coin.toString(), count)}\"\n }\n}\n\n\n \n\n MIME types defined: text/x-groovy\n
\nHAML mode\n\n!!!\n#content\n.left.column(title=\"title\"){:href => \"/hello\", :test => \"#{hello}_#{world}\"}\n <!-- This is a comment -->\n %h2 Welcome to our site!\n %p= puts \"HAML MODE\"\n .right.column\n = render :partial => \"sidebar\"\n\n.container\n .row\n .span8\n %h1.title= @page_title\n%p.title= @page_title\n%p\n /\n The same as HTML comment\n Hello multiline comment\n\n -# haml comment\n This wont be displayed\n nor will this\n Date/Time:\n - now = DateTime.now\n %strong= now\n - if now > DateTime.parse(\"December 31, 2006\")\n = \"Happy new \" + \"year!\"\n\n%title\n = @title\n \\= @title\n <h1>Title</h1>\n <h1 title=\"HELLO\">\n Title\n </h1>\n \n \n\n MIME types defined: text/x-haml.\n\n Parsing/Highlighting Tests: normal, verbose.\n\n
\nHaskell mode\n\nmodule UniquePerms (\n uniquePerms\n )\nwhere\n\n-- | Find all unique permutations of a list where there might be duplicates.\nuniquePerms :: (Eq a) => [a] -> [[a]]\nuniquePerms = permBag . makeBag\n\n-- | An unordered collection where duplicate values are allowed,\n-- but represented with a single value and a count.\ntype Bag a = [(a, Int)]\n\nmakeBag :: (Eq a) => [a] -> Bag a\nmakeBag [] = []\nmakeBag (a:as) = mix a $ makeBag as\n where\n mix a [] = [(a,1)]\n mix a (bn@(b,n):bs) | a == b = (b,n+1):bs\n | otherwise = bn : mix a bs\n\npermBag :: Bag a -> [[a]]\npermBag [] = [[]]\npermBag bs = concatMap (\\(f,cs) -> map (f:) $ permBag cs) . oneOfEach $ bs\n where\n oneOfEach [] = []\n oneOfEach (an@(a,n):bs) =\n let bs' = if n == 1 then bs else (a,n-1):bs\n in (a,bs') : mapSnd (an:) (oneOfEach bs)\n \n apSnd f (a,b) = (a, f b)\n mapSnd = map . apSnd\n\n\n \n\n MIME types defined: text/x-haskell.\n
\nHaxe mode\n\n\n\nimport one.two.Three;\n\n@attr(\"test\")\nclass Foo<T> extends Three\n{\n\tpublic function new()\n\t{\n\t\tnoFoo = 12;\n\t}\n\t\n\tpublic static inline function doFoo(obj:{k:Int, l:Float}):Int\n\t{\n\t\tfor(i in 0...10)\n\t\t{\n\t\t\tobj.k++;\n\t\t\ttrace(i);\n\t\t\tvar var1 = new Array();\n\t\t\tif(var1.length > 1)\n\t\t\t\tthrow \"Error\";\n\t\t}\n\t\t// The following line should not be colored, the variable is scoped out\n\t\tvar1;\n\t\t/* Multi line\n\t\t * Comment test\n\t\t */\n\t\treturn obj.k;\n\t}\n\tprivate function bar():Void\n\t{\n\t\t#if flash\n\t\tvar t1:String = \"1.21\";\n\t\t#end\n\t\ttry {\n\t\t\tdoFoo({k:3, l:1.2});\n\t\t}\n\t\tcatch (e : String) {\n\t\t\ttrace(e);\n\t\t}\n\t\tvar t2:Float = cast(3.2);\n\t\tvar t3:haxe.Timer = new haxe.Timer();\n\t\tvar t4 = {k:Std.int(t2), l:Std.parseFloat(t1)};\n\t\tvar t5 = ~/123+.*$/i;\n\t\tdoFoo(t4);\n\t\tuntyped t1 = 4;\n\t\tbob = new Foo<Int>\n\t}\n\tpublic var okFoo(default, never):Float;\n\tvar noFoo(getFoo, null):Int;\n\tfunction getFoo():Int {\n\t\treturn noFoo;\n\t}\n\t\n\tpublic var three:Int;\n}\nenum Color\n{\n\tred;\n\tgreen;\n\tblue;\n\tgrey( v : Int );\n\trgb (r:Int,g:Int,b:Int);\n}\n\n\nHxml mode:\n\n\n-cp test\n-js path/to/file.js\n#-remap nme:flash\n--next\n-D source-map-content\n-cmd 'test'\n-lib lime\n\n\n\n \n\n MIME types defined: text/x-haxe, text/x-hxml.\n
\nHtml Embedded Scripts mode\n\n<%\nfunction hello(who) {\n\treturn \"Hello \" + who;\n}\n%>\nThis is an example of EJS (embedded javascript)\n<p>The program says <%= hello(\"world\") %>.</p>\n<script>\n\talert(\"And here is some normal JS code\"); // also colored\n</script>\n\n\n \n\n Mode for html embedded scripts like JSP and ASP.NET. Depends on HtmlMixed which in turn depends on\n JavaScript, CSS and XML.Other dependancies include those of the scriping language chosen.\n\n MIME types defined: application/x-aspx (ASP.NET), \n application/x-ejs (Embedded Javascript), application/x-jsp (JavaServer Pages)\n
\nHTML mixed mode\n\n<html style=\"color: green\">\n <!-- this is a comment -->\n <head>\n <title>Mixed HTML Example</title>\n <style type=\"text/css\">\n h1 {font-family: comic sans; color: #f0f;}\n div {background: yellow !important;}\n body {\n max-width: 50em;\n margin: 1em 2em 1em 5em;\n }\n </style>\n </head>\n <body>\n <h1>Mixed HTML Example</h1>\n <script>\n function jsFunc(arg1, arg2) {\n if (arg1 && arg2) document.body.innerHTML = \"achoo\";\n }\n </script>\n </body>\n</html>\n\n \n\n The HTML mixed mode depends on the XML, JavaScript, and CSS modes.\n\n It takes an optional mode configuration\n option, scriptTypes, which can be used to add custom\n behavior for specific <script type=\"...\"> tags. If\n given, it should hold an array of {matches, mode}\n objects, where matches is a string or regexp that\n matches the script type, and mode is\n either null, for script types that should stay in\n HTML mode, or a mode\n spec corresponding to the mode that should be used for the\n script.\n\n MIME types defined: text/html\n (redefined, only takes effect if you load this parser after the\n XML parser).\n\n
\nHTTP mode\n\n\n\nPOST /somewhere HTTP/1.1\nHost: example.com\nIf-Modified-Since: Sat, 29 Oct 1994 19:43:31 GMT\nContent-Type: application/x-www-form-urlencoded;\n\tcharset=utf-8\nUser-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/536.11 (KHTML, like Gecko) Ubuntu/12.04 Chromium/20.0.1132.47 Chrome/20.0.1132.47 Safari/536.11\n\nThis is the request body!\n\n\n \n\n MIME types defined: message/http.\n
\n\nLanguage modes\n\nThis is a list of every mode in the distribution. Each mode lives\nin a subdirectory of the mode/ directory, and typically\ndefines a single JavaScript file that implements the mode. Loading\nsuch file will make the language available to CodeMirror, through\nthe mode\noption.\n\n\n \n APL\n Asterisk dialplan\n C, C++, C#\n Clojure\n COBOL\n CoffeeScript\n Common Lisp\n CSS\n Cypher\n Cython\n D\n Django (templating language)\n diff\n DTD\n Dylan\n ECL\n Eiffel\n Erlang\n Fortran\n F#\n Gas (AT&T-style assembly)\n Gherkin\n Go\n Groovy\n HAML\n Haskell\n Haxe\n HTML embedded scripts\n HTML mixed-mode\n HTTP\n Java\n Jade\n JavaScript\n Jinja2\n Julia\n Kotlin\n LESS\n LiveScript\n Lua\n Markdown (GitHub-flavour)\n mIRC\n Modelica\n Nginx\n NTriples\n OCaml\n Octave (MATLAB)\n Pascal\n PEG.js\n Perl\n PHP\n Pig Latin\n Properties files\n Puppet\n Python\n Q\n R\n RPM\n reStructuredText\n Ruby\n Rust\n Sass\n Scala\n Scheme\n SCSS\n Shell\n Sieve\n Slim\n Smalltalk\n Smarty\n Smarty/HTML mixed\n Solr\n SQL (several dialects)\n SPARQL\n sTeX, LaTeX\n Tcl\n Textile\n Tiddlywiki\n Tiki wiki\n TOML\n Tornado (templating language)\n Turtle\n VB.NET\n VBScript\n Velocity\n Verilog/SystemVerilog\n XML/HTML\n XQuery\n YAML\n Z80\n \n \n\n
\nJade Templating Mode\n\ndoctype html\n html\n head\n title= \"Jade Templating CodeMirror Mode Example\"\n link(rel='stylesheet', href='/css/bootstrap.min.css')\n link(rel='stylesheet', href='/css/index.css')\n script(type='text/javascript', src='/js/jquery-1.9.1.min.js')\n script(type='text/javascript', src='/js/bootstrap.min.js')\n body\n div.header\n h1 Welcome to this Example\n div.spots\n if locals.spots\n each spot in spots\n div.spot.well\n div\n if spot.logo\n img.img-rounded.logo(src=spot.logo)\n else\n img.img-rounded.logo(src=\"img/placeholder.png\")\n h3\n a(href=spot.hash) ##{spot.hash}\n if spot.title\n span.title #{spot.title}\n if spot.desc\n div #{spot.desc}\n else\n h3 There are no spots currently available.\n\n \n The Jade Templating Mode\n Created by Forbes Lindesay. Managed as part of a Brackets extension at https://github.com/ForbesLindesay/jade-brackets.\n MIME type defined: text/x-jade.\n
\nJavaScript mode\n\n\n\n// Demo code (the actual new parser character stream implementation)\n\nfunction StringStream(string) {\n this.pos = 0;\n this.string = string;\n}\n\nStringStream.prototype = {\n done: function() {return this.pos >= this.string.length;},\n peek: function() {return this.string.charAt(this.pos);},\n next: function() {\n if (this.pos < this.string.length)\n return this.string.charAt(this.pos++);\n },\n eat: function(match) {\n var ch = this.string.charAt(this.pos);\n if (typeof match == \"string\") var ok = ch == match;\n else var ok = ch && match.test ? match.test(ch) : match(ch);\n if (ok) {this.pos++; return ch;}\n },\n eatWhile: function(match) {\n var start = this.pos;\n while (this.eat(match));\n if (this.pos > start) return this.string.slice(start, this.pos);\n },\n backUp: function(n) {this.pos -= n;},\n column: function() {return this.pos;},\n eatSpace: function() {\n var start = this.pos;\n while (/\\s/.test(this.string.charAt(this.pos))) this.pos++;\n return this.pos - start;\n },\n match: function(pattern, consume, caseInsensitive) {\n if (typeof pattern == \"string\") {\n function cased(str) {return caseInsensitive ? str.toLowerCase() : str;}\n if (cased(this.string).indexOf(cased(pattern), this.pos) == this.pos) {\n if (consume !== false) this.pos += str.length;\n return true;\n }\n }\n else {\n var match = this.string.slice(this.pos).match(pattern);\n if (match && consume !== false) this.pos += match[0].length;\n return match;\n }\n }\n};\n\n\n \n\n \n JavaScript mode supports several configuration options:\n \n json which will set the mode to expect JSON\n data rather than a JavaScript program.\n jsonld which will set the mode to expect\n JSON-LD linked data rather\n than a JavaScript program (demo).\n typescript which will activate additional\n syntax highlighting and some other things for TypeScript code\n (demo).\n statementIndent which (given a number) will\n determine the amount of indentation to use for statements\n continued on a new line.\n wordCharacters, a regexp that indicates which\n characters should be considered part of an identifier.\n Defaults to /[\\w$]/, which does not handle\n non-ASCII identifiers. Can be set to something more elaborate\n to improve Unicode support.\n \n \n\n MIME types defined: text/javascript, application/json, application/ld+json, text/typescript, application/typescript.\n
\nJSON-LD mode\n\n\n\n{\n \"@context\": {\n \"name\": \"http://schema.org/name\",\n \"description\": \"http://schema.org/description\",\n \"image\": {\n \"@id\": \"http://schema.org/image\",\n \"@type\": \"@id\"\n },\n \"geo\": \"http://schema.org/geo\",\n \"latitude\": {\n \"@id\": \"http://schema.org/latitude\",\n \"@type\": \"xsd:float\"\n },\n \"longitude\": {\n \"@id\": \"http://schema.org/longitude\",\n \"@type\": \"xsd:float\"\n },\n \"xsd\": \"http://www.w3.org/2001/XMLSchema#\"\n },\n \"name\": \"The Empire State Building\",\n \"description\": \"The Empire State Building is a 102-story landmark in New York City.\",\n \"image\": \"http://www.civil.usherbrooke.ca/cours/gci215a/empire-state-building.jpg\",\n \"geo\": {\n \"latitude\": \"40.75\",\n \"longitude\": \"73.98\"\n }\n}\n\n\n \n \n This is a specialization of the JavaScript mode.\n
\nTypeScript mode\n\n\n\nclass Greeter {\n\tgreeting: string;\n\tconstructor (message: string) {\n\t\tthis.greeting = message;\n\t}\n\tgreet() {\n\t\treturn \"Hello, \" + this.greeting;\n\t}\n} \n\nvar greeter = new Greeter(\"world\");\n\nvar button = document.createElement('button')\nbutton.innerText = \"Say Hello\"\nbutton.onclick = function() {\n\talert(greeter.greet())\n}\n\ndocument.body.appendChild(button)\n\n\n\n \n\n This is a specialization of the JavaScript mode.\n
\nJinja2 mode\n\n{# this is a comment #}\n{%- for item in li -%}\n <li>{{ item.label }}</li>\n{% endfor -%}\n{{ item.sand == true and item.keyword == false ? 1 : 0 }}\n{{ app.get(55, 1.2, true) }}\n{% if app.get('_route') == ('_home') %}home{% endif %}\n{% if app.session.flashbag.has('message') %}\n {% for message in app.session.flashbag.get('message') %}\n {{ message.content }}\n {% endfor %}\n{% endif %}\n{{ path('_home', {'section': app.request.get('section')}) }}\n{{ path('_home', {\n 'section': app.request.get('section'),\n 'boolean': true,\n 'number': 55.33\n })\n}}\n{% include ('test.incl.html.twig') %}\n\n \n
\nJulia mode\n\n \n#numbers\n1234\n1234im\n.234\n.234im\n2.23im\n2.3f3\n23e2\n0x234\n\n#strings\n'a'\n\"asdf\"\nr\"regex\"\nb\"bytestring\"\n\n\"\"\"\nmultiline string\n\"\"\"\n\n#identifiers\na\nas123\nfunction_name!\n\n#unicode identifiers\n# a = x\\ddot\na⃗ = ẍ\n# a = v\\dot\na⃗ = v̇\n#F\\vec = m \\cdotp a\\vec\nF⃗ = m·a⃗\n\n#literal identifier multiples\n3x\n4[1, 2, 3]\n\n#dicts and indexing\nx=[1, 2, 3]\nx[end-1]\nx={\"julia\"=>\"language of technical computing\"}\n\n\n#exception handling\ntry\n f()\ncatch\n @printf \"Error\"\nfinally\n g()\nend\n\n#types\nimmutable Color{T<:Number}\n r::T\n g::T\n b::T\nend\n\n#functions\nfunction change!(x::Vector{Float64})\n for i = 1:length(x)\n x[i] *= 2\n end\nend\n\n#function invocation\nf('b', (2, 3)...)\n\n#operators\n|=\n&=\n^=\n\\-\n%=\n*=\n+=\n-=\n<=\n>=\n!=\n==\n%\n*\n+\n-\n<\n>\n!\n=\n|\n&\n^\n\\\n?\n~\n:\n$\n<:\n.<\n.>\n<<\n<<=\n>>\n>>>>\n>>=\n>>>=\n<<=\n<<<=\n.<=\n.>=\n.==\n->\n//\nin\n...\n//\n:=\n.//=\n.*=\n./=\n.^=\n.%=\n.+=\n.-=\n\\=\n\\\\=\n||\n===\n&&\n|=\n.|=\n<:\n>:\n|>\n<|\n::\nx ? y : z\n\n#macros\n@spawnat 2 1+1\n@eval(:x)\n\n#keywords and operators\nif else elseif while for\n begin let end do\ntry catch finally return break continue\nglobal local const \nexport import importall using\nfunction macro module baremodule \ntype immutable quote\ntrue false enumerate\n\n\n \n \n\n MIME types defined: text/x-julia.\n
\nKotlin mode\n\n\n\npackage org.wasabi.http\n\nimport java.util.concurrent.Executors\nimport java.net.InetSocketAddress\nimport org.wasabi.app.AppConfiguration\nimport io.netty.bootstrap.ServerBootstrap\nimport io.netty.channel.nio.NioEventLoopGroup\nimport io.netty.channel.socket.nio.NioServerSocketChannel\nimport org.wasabi.app.AppServer\n\npublic class HttpServer(private val appServer: AppServer) {\n\n val bootstrap: ServerBootstrap\n val primaryGroup: NioEventLoopGroup\n val workerGroup: NioEventLoopGroup\n\n {\n // Define worker groups\n primaryGroup = NioEventLoopGroup()\n workerGroup = NioEventLoopGroup()\n\n // Initialize bootstrap of server\n bootstrap = ServerBootstrap()\n\n bootstrap.group(primaryGroup, workerGroup)\n bootstrap.channel(javaClass<NioServerSocketChannel>())\n bootstrap.childHandler(NettyPipelineInitializer(appServer))\n }\n\n public fun start(wait: Boolean = true) {\n val channel = bootstrap.bind(appServer.configuration.port)?.sync()?.channel()\n\n if (wait) {\n channel?.closeFuture()?.sync()\n }\n }\n\n public fun stop() {\n // Shutdown all event loops\n primaryGroup.shutdownGracefully()\n workerGroup.shutdownGracefully()\n\n // Wait till all threads are terminated\n primaryGroup.terminationFuture().sync()\n workerGroup.terminationFuture().sync()\n }\n}\n\n\n \n Mode for Kotlin (http://kotlin.jetbrains.org/)\n Developed by Hadi Hariri (https://github.com/hhariri).\n MIME type defined: text/x-kotlin.\n
\nLiveScript mode\n\n# LiveScript mode for CodeMirror\n# The following script, prelude.ls, is used to\n# demonstrate LiveScript mode for CodeMirror.\n# https://github.com/gkz/prelude-ls\n\nexport objToFunc = objToFunc = (obj) ->\n (key) -> obj[key]\n\nexport each = (f, xs) -->\n if typeof! xs is \\Object\n for , x of xs then f x\n else\n for x in xs then f x\n xs\n\nexport map = (f, xs) -->\n f = objToFunc f if typeof! f isnt \\Function\n type = typeof! xs\n if type is \\Object\n {[key, f x] for key, x of xs}\n else\n result = [f x for x in xs]\n if type is \\String then result * '' else result\n\nexport filter = (f, xs) -->\n f = objToFunc f if typeof! f isnt \\Function\n type = typeof! xs\n if type is \\Object\n {[key, x] for key, x of xs when f x}\n else\n result = [x for x in xs when f x]\n if type is \\String then result * '' else result\n\nexport reject = (f, xs) -->\n f = objToFunc f if typeof! f isnt \\Function\n type = typeof! xs\n if type is \\Object\n {[key, x] for key, x of xs when not f x}\n else\n result = [x for x in xs when not f x]\n if type is \\String then result * '' else result\n\nexport partition = (f, xs) -->\n f = objToFunc f if typeof! f isnt \\Function\n type = typeof! xs\n if type is \\Object\n passed = {}\n failed = {}\n for key, x of xs\n (if f x then passed else failed)[key] = x\n else\n passed = []\n failed = []\n for x in xs\n (if f x then passed else failed)push x\n if type is \\String\n passed *= ''\n failed *= ''\n [passed, failed]\n\nexport find = (f, xs) -->\n f = objToFunc f if typeof! f isnt \\Function\n if typeof! xs is \\Object\n for , x of xs when f x then return x\n else\n for x in xs when f x then return x\n void\n\nexport head = export first = (xs) ->\n return void if not xs.length\n xs.0\n\nexport tail = (xs) ->\n return void if not xs.length\n xs.slice 1\n\nexport last = (xs) ->\n return void if not xs.length\n xs[*-1]\n\nexport initial = (xs) ->\n return void if not xs.length\n xs.slice 0 xs.length - 1\n\nexport empty = (xs) ->\n if typeof! xs is \\Object\n for x of xs then return false\n return yes\n not xs.length\n\nexport values = (obj) ->\n [x for , x of obj]\n\nexport keys = (obj) ->\n [x for x of obj]\n\nexport len = (xs) ->\n xs = values xs if typeof! xs is \\Object\n xs.length\n\nexport cons = (x, xs) -->\n if typeof! xs is \\String then x + xs else [x] ++ xs\n\nexport append = (xs, ys) -->\n if typeof! ys is \\String then xs + ys else xs ++ ys\n\nexport join = (sep, xs) -->\n xs = values xs if typeof! xs is \\Object\n xs.join sep\n\nexport reverse = (xs) ->\n if typeof! xs is \\String\n then (xs / '')reverse! * ''\n else xs.slice!reverse!\n\nexport fold = export foldl = (f, memo, xs) -->\n if typeof! xs is \\Object\n for , x of xs then memo = f memo, x\n else\n for x in xs then memo = f memo, x\n memo\n\nexport fold1 = export foldl1 = (f, xs) --> fold f, xs.0, xs.slice 1\n\nexport foldr = (f, memo, xs) --> fold f, memo, xs.slice!reverse!\n\nexport foldr1 = (f, xs) -->\n xs.=slice!reverse!\n fold f, xs.0, xs.slice 1\n\nexport unfoldr = export unfold = (f, b) -->\n if (f b)?\n [that.0] ++ unfoldr f, that.1\n else\n []\n\nexport andList = (xs) ->\n for x in xs when not x\n return false\n true\n\nexport orList = (xs) ->\n for x in xs when x\n return true\n false\n\nexport any = (f, xs) -->\n f = objToFunc f if typeof! f isnt \\Function\n for x in xs when f x\n return yes\n no\n\nexport all = (f, xs) -->\n f = objToFunc f if typeof! f isnt \\Function\n for x in xs when not f x\n return no\n yes\n\nexport unique = (xs) ->\n result = []\n if typeof! xs is \\Object\n for , x of xs when x not in result then result.push x\n else\n for x in xs when x not in result then result.push x\n if typeof! xs is \\String then result * '' else result\n\nexport sort = (xs) ->\n xs.concat!sort (x, y) ->\n | x > y => 1\n | x < y => -1\n | _ => 0\n\nexport sortBy = (f, xs) -->\n return [] unless xs.length\n xs.concat!sort f\n\nexport compare = (f, x, y) -->\n | (f x) > (f y) => 1\n | (f x) < (f y) => -1\n | otherwise => 0\n\nexport sum = (xs) ->\n result = 0\n if typeof! xs is \\Object\n for , x of xs then result += x\n else\n for x in xs then result += x\n result\n\nexport product = (xs) ->\n result = 1\n if typeof! xs is \\Object\n for , x of xs then result *= x\n else\n for x in xs then result *= x\n result\n\nexport mean = export average = (xs) -> (sum xs) / len xs\n\nexport concat = (xss) -> fold append, [], xss\n\nexport concatMap = (f, xs) --> fold ((memo, x) -> append memo, f x), [], xs\n\nexport listToObj = (xs) ->\n {[x.0, x.1] for x in xs}\n\nexport maximum = (xs) -> fold1 (>?), xs\n\nexport minimum = (xs) -> fold1 (<?), xs\n\nexport scan = export scanl = (f, memo, xs) -->\n last = memo\n if typeof! xs is \\Object\n then [memo] ++ [last = f last, x for , x of xs]\n else [memo] ++ [last = f last, x for x in xs]\n\nexport scan1 = export scanl1 = (f, xs) --> scan f, xs.0, xs.slice 1\n\nexport scanr = (f, memo, xs) -->\n xs.=slice!reverse!\n scan f, memo, xs .reverse!\n\nexport scanr1 = (f, xs) -->\n xs.=slice!reverse!\n scan f, xs.0, xs.slice 1 .reverse!\n\nexport replicate = (n, x) -->\n result = []\n i = 0\n while i < n, ++i then result.push x\n result\n\nexport take = (n, xs) -->\n | n <= 0\n if typeof! xs is \\String then '' else []\n | not xs.length => xs\n | otherwise => xs.slice 0, n\n\nexport drop = (n, xs) -->\n | n <= 0 => xs\n | not xs.length => xs\n | otherwise => xs.slice n\n\nexport splitAt = (n, xs) --> [(take n, xs), (drop n, xs)]\n\nexport takeWhile = (p, xs) -->\n return xs if not xs.length\n p = objToFunc p if typeof! p isnt \\Function\n result = []\n for x in xs\n break if not p x\n result.push x\n if typeof! xs is \\String then result * '' else result\n\nexport dropWhile = (p, xs) -->\n return xs if not xs.length\n p = objToFunc p if typeof! p isnt \\Function\n i = 0\n for x in xs\n break if not p x\n ++i\n drop i, xs\n\nexport span = (p, xs) --> [(takeWhile p, xs), (dropWhile p, xs)]\n\nexport breakIt = (p, xs) --> span (not) << p, xs\n\nexport zip = (xs, ys) -->\n result = []\n for zs, i in [xs, ys]\n for z, j in zs\n result.push [] if i is 0\n result[j]?push z\n result\n\nexport zipWith = (f,xs, ys) -->\n f = objToFunc f if typeof! f isnt \\Function\n if not xs.length or not ys.length\n []\n else\n [f.apply this, zs for zs in zip.call this, xs, ys]\n\nexport zipAll = (...xss) ->\n result = []\n for xs, i in xss\n for x, j in xs\n result.push [] if i is 0\n result[j]?push x\n result\n\nexport zipAllWith = (f, ...xss) ->\n f = objToFunc f if typeof! f isnt \\Function\n if not xss.0.length or not xss.1.length\n []\n else\n [f.apply this, xs for xs in zipAll.apply this, xss]\n\nexport compose = (...funcs) ->\n ->\n args = arguments\n for f in funcs\n args = [f.apply this, args]\n args.0\n\nexport curry = (f) ->\n curry$ f # using util method curry$ from livescript\n\nexport id = (x) -> x\n\nexport flip = (f, x, y) --> f y, x\n\nexport fix = (f) ->\n ( (g, x) -> -> f(g g) ...arguments ) do\n (g, x) -> -> f(g g) ...arguments\n\nexport lines = (str) ->\n return [] if not str.length\n str / \\\\n\n\nexport unlines = (strs) -> strs * \\\\n\n\nexport words = (str) ->\n return [] if not str.length\n str / /[ ]+/\n\nexport unwords = (strs) -> strs * ' '\n\nexport max = (>?)\n\nexport min = (<?)\n\nexport negate = (x) -> -x\n\nexport abs = Math.abs\n\nexport signum = (x) ->\n | x < 0 => -1\n | x > 0 => 1\n | otherwise => 0\n\nexport quot = (x, y) --> ~~(x / y)\n\nexport rem = (%)\n\nexport div = (x, y) --> Math.floor x / y\n\nexport mod = (%%)\n\nexport recip = (1 /)\n\nexport pi = Math.PI\n\nexport tau = pi * 2\n\nexport exp = Math.exp\n\nexport sqrt = Math.sqrt\n\n# changed from log as log is a\n# common function for logging things\nexport ln = Math.log\n\nexport pow = (^)\n\nexport sin = Math.sin\n\nexport tan = Math.tan\n\nexport cos = Math.cos\n\nexport asin = Math.asin\n\nexport acos = Math.acos\n\nexport atan = Math.atan\n\nexport atan2 = (x, y) --> Math.atan2 x, y\n\n# sinh\n# tanh\n# cosh\n# asinh\n# atanh\n# acosh\n\nexport truncate = (x) -> ~~x\n\nexport round = Math.round\n\nexport ceiling = Math.ceil\n\nexport floor = Math.floor\n\nexport isItNaN = (x) -> x isnt x\n\nexport even = (x) -> x % 2 == 0\n\nexport odd = (x) -> x % 2 != 0\n\nexport gcd = (x, y) -->\n x = Math.abs x\n y = Math.abs y\n until y is 0\n z = x % y\n x = y\n y = z\n x\n\nexport lcm = (x, y) -->\n Math.abs Math.floor (x / (gcd x, y) * y)\n\n# meta\nexport installPrelude = !(target) ->\n unless target.prelude?isInstalled\n target <<< out$ # using out$ generated by livescript\n target <<< target.prelude.isInstalled = true\n\nexport prelude = out$\n\n \n\n MIME types defined: text/x-livescript.\n\n The LiveScript mode was written by Kenneth Bentley.\n\n
\nLua mode\n\n--[[\nexample useless code to show lua syntax highlighting\nthis is multiline comment\n]]\n\nfunction blahblahblah(x)\n\n local table = {\n \"asd\" = 123,\n \"x\" = 0.34, \n }\n if x ~= 3 then\n print( x )\n elseif x == \"string\"\n my_custom_function( 0x34 )\n else\n unknown_function( \"some string\" )\n end\n\n --single line comment\n \nend\n\nfunction blablabla3()\n\n for k,v in ipairs( table ) do\n --abcde..\n y=[=[\n x=[[\n x is a multi line string\n ]]\n but its definition is iside a highest level string!\n ]=]\n print(\" \\\"\\\" \")\n\n s = math.sin( x )\n end\n\nend\n\n \n\n Loosely based on Franciszek\n Wawrzak's CodeMirror\n 1 mode. One configuration parameter is\n supported, specials, to which you can provide an\n array of strings to have those identifiers highlighted with\n the lua-special style.\n MIME types defined: text/x-lua.\n\n
\nMarkdown mode\n\nMarkdown: Basics\n================\n\n<ul id=\"ProjectSubmenu\">\n <li><a href=\"/projects/markdown/\" title=\"Markdown Project Page\">Main</a></li>\n <li><a class=\"selected\" title=\"Markdown Basics\">Basics</a></li>\n <li><a href=\"/projects/markdown/syntax\" title=\"Markdown Syntax Documentation\">Syntax</a></li>\n <li><a href=\"/projects/markdown/license\" title=\"Pricing and License Information\">License</a></li>\n <li><a href=\"/projects/markdown/dingus\" title=\"Online Markdown Web Form\">Dingus</a></li>\n</ul>\n\n\nGetting the Gist of Markdown's Formatting Syntax\n------------------------------------------------\n\nThis page offers a brief overview of what it's like to use Markdown.\nThe [syntax page] [s] provides complete, detailed documentation for\nevery feature, but Markdown should be very easy to pick up simply by\nlooking at a few examples of it in action. The examples on this page\nare written in a before/after style, showing example syntax and the\nHTML output produced by Markdown.\n\nIt's also helpful to simply try Markdown out; the [Dingus] [d] is a\nweb application that allows you type your own Markdown-formatted text\nand translate it to XHTML.\n\n**Note:** This document is itself written using Markdown; you\ncan [see the source for it by adding '.text' to the URL] [src].\n\n [s]: /projects/markdown/syntax \"Markdown Syntax\"\n [d]: /projects/markdown/dingus \"Markdown Dingus\"\n [src]: /projects/markdown/basics.text\n\n\n## Paragraphs, Headers, Blockquotes ##\n\nA paragraph is simply one or more consecutive lines of text, separated\nby one or more blank lines. (A blank line is any line that looks like\na blank line -- a line containing nothing but spaces or tabs is\nconsidered blank.) Normal paragraphs should not be indented with\nspaces or tabs.\n\nMarkdown offers two styles of headers: *Setext* and *atx*.\nSetext-style headers for `<h1>` and `<h2>` are created by\n\"underlining\" with equal signs (`=`) and hyphens (`-`), respectively.\nTo create an atx-style header, you put 1-6 hash marks (`#`) at the\nbeginning of the line -- the number of hashes equals the resulting\nHTML header level.\n\nBlockquotes are indicated using email-style '`>`' angle brackets.\n\nMarkdown:\n\n A First Level Header\n ====================\n \n A Second Level Header\n ---------------------\n\n Now is the time for all good men to come to\n the aid of their country. This is just a\n regular paragraph.\n\n The quick brown fox jumped over the lazy\n dog's back.\n \n ### Header 3\n\n > This is a blockquote.\n > \n > This is the second paragraph in the blockquote.\n >\n > ## This is an H2 in a blockquote\n\n\nOutput:\n\n <h1>A First Level Header</h1>\n \n <h2>A Second Level Header</h2>\n \n <p>Now is the time for all good men to come to\n the aid of their country. This is just a\n regular paragraph.</p>\n \n <p>The quick brown fox jumped over the lazy\n dog's back.</p>\n \n <h3>Header 3</h3>\n \n <blockquote>\n <p>This is a blockquote.</p>\n \n <p>This is the second paragraph in the blockquote.</p>\n \n <h2>This is an H2 in a blockquote</h2>\n </blockquote>\n\n\n\n### Phrase Emphasis ###\n\nMarkdown uses asterisks and underscores to indicate spans of emphasis.\n\nMarkdown:\n\n Some of these words *are emphasized*.\n Some of these words _are emphasized also_.\n \n Use two asterisks for **strong emphasis**.\n Or, if you prefer, __use two underscores instead__.\n\nOutput:\n\n <p>Some of these words <em>are emphasized</em>.\n Some of these words <em>are emphasized also</em>.</p>\n \n <p>Use two asterisks for <strong>strong emphasis</strong>.\n Or, if you prefer, <strong>use two underscores instead</strong>.</p>\n \n\n\n## Lists ##\n\nUnordered (bulleted) lists use asterisks, pluses, and hyphens (`*`,\n`+`, and `-`) as list markers. These three markers are\ninterchangable; this:\n\n * Candy.\n * Gum.\n * Booze.\n\nthis:\n\n + Candy.\n + Gum.\n + Booze.\n\nand this:\n\n - Candy.\n - Gum.\n - Booze.\n\nall produce the same output:\n\n <ul>\n <li>Candy.</li>\n <li>Gum.</li>\n <li>Booze.</li>\n </ul>\n\nOrdered (numbered) lists use regular numbers, followed by periods, as\nlist markers:\n\n 1. Red\n 2. Green\n 3. Blue\n\nOutput:\n\n <ol>\n <li>Red</li>\n <li>Green</li>\n <li>Blue</li>\n </ol>\n\nIf you put blank lines between items, you'll get `<p>` tags for the\nlist item text. You can create multi-paragraph list items by indenting\nthe paragraphs by 4 spaces or 1 tab:\n\n * A list item.\n \n With multiple paragraphs.\n\n * Another item in the list.\n\nOutput:\n\n <ul>\n <li><p>A list item.</p>\n <p>With multiple paragraphs.</p></li>\n <li><p>Another item in the list.</p></li>\n </ul>\n \n\n\n### Links ###\n\nMarkdown supports two styles for creating links: *inline* and\n*reference*. With both styles, you use square brackets to delimit the\ntext you want to turn into a link.\n\nInline-style links use parentheses immediately after the link text.\nFor example:\n\n This is an [example link](http://example.com/).\n\nOutput:\n\n <p>This is an <a href=\"http://example.com/\">\n example link</a>.</p>\n\nOptionally, you may include a title attribute in the parentheses:\n\n This is an [example link](http://example.com/ \"With a Title\").\n\nOutput:\n\n <p>This is an <a href=\"http://example.com/\" title=\"With a Title\">\n example link</a>.</p>\n\nReference-style links allow you to refer to your links by names, which\nyou define elsewhere in your document:\n\n I get 10 times more traffic from [Google][1] than from\n [Yahoo][2] or [MSN][3].\n\n [1]: http://google.com/ \"Google\"\n [2]: http://search.yahoo.com/ \"Yahoo Search\"\n [3]: http://search.msn.com/ \"MSN Search\"\n\nOutput:\n\n <p>I get 10 times more traffic from <a href=\"http://google.com/\"\n title=\"Google\">Google</a> than from <a href=\"http://search.yahoo.com/\"\n title=\"Yahoo Search\">Yahoo</a> or <a href=\"http://search.msn.com/\"\n title=\"MSN Search\">MSN</a>.</p>\n\nThe title attribute is optional. Link names may contain letters,\nnumbers and spaces, but are *not* case sensitive:\n\n I start my morning with a cup of coffee and\n [The New York Times][NY Times].\n\n [ny times]: http://www.nytimes.com/\n\nOutput:\n\n <p>I start my morning with a cup of coffee and\n <a href=\"http://www.nytimes.com/\">The New York Times</a>.</p>\n\n\n### Images ###\n\nImage syntax is very much like link syntax.\n\nInline (titles are optional):\n\n ![alt text](/path/to/img.jpg \"Title\")\n\nReference-style:\n\n ![alt text][id]\n\n [id]: /path/to/img.jpg \"Title\"\n\nBoth of the above examples produce the same output:\n\n <img src=\"/path/to/img.jpg\" alt=\"alt text\" title=\"Title\" />\n\n\n\n### Code ###\n\nIn a regular paragraph, you can create code span by wrapping text in\nbacktick quotes. Any ampersands (`&`) and angle brackets (`<` or\n`>`) will automatically be translated into HTML entities. This makes\nit easy to use Markdown to write about HTML example code:\n\n I strongly recommend against using any `<blink>` tags.\n\n I wish SmartyPants used named entities like `—`\n instead of decimal-encoded entites like `—`.\n\nOutput:\n\n <p>I strongly recommend against using any\n <code><blink></code> tags.</p>\n \n <p>I wish SmartyPants used named entities like\n <code>&mdash;</code> instead of decimal-encoded\n entites like <code>&#8212;</code>.</p>\n\n\nTo specify an entire block of pre-formatted code, indent every line of\nthe block by 4 spaces or 1 tab. Just like with code spans, `&`, `<`,\nand `>` characters will be escaped automatically.\n\nMarkdown:\n\n If you want your page to validate under XHTML 1.0 Strict,\n you've got to put paragraph tags in your blockquotes:\n\n <blockquote>\n <p>For example.</p>\n </blockquote>\n\nOutput:\n\n <p>If you want your page to validate under XHTML 1.0 Strict,\n you've got to put paragraph tags in your blockquotes:</p>\n \n <pre><code><blockquote>\n <p>For example.</p>\n </blockquote>\n </code></pre>\n\n\n \n\n Optionally depends on the XML mode for properly highlighted inline XML blocks.\n\n MIME types defined: text/x-markdown.\n\n Parsing/Highlighting Tests: normal, verbose.\n\n
\nmIRC mode\n\n;AKA Nick Tracker by Ford_Lawnmower irc.GeekShed.net #Script-Help\n;*****************************************************************************;\n;**Start Setup\n;Change JoinDisplay, below, for On Join AKA Display. On = 1 - Off = 0\nalias -l JoinDisplay { return 1 }\n;Change MaxNicks, below, to the number of nicknames you want to store for each hostmask. I wouldn't go over 400 with this ;/\nalias -l MaxNicks { return 20 }\n;Change AKALogo, below, To the text you want displayed before each AKA result.\nalias -l AKALogo { return \u000306\u0007 \u000305A\u000306K\u000307A \u000306\u0007 }\n;**End Setup\n;*****************************************************************************;\nOn *:Join:#: {\n if ($nick == $me) { .timer 1 1 ialupdateCheck $chan }\n NickNamesAdd $nick $+($network,$wildsite)\n if ($JoinDisplay) { .timerNickNames $+ $nick 1 2 NickNames.display $nick $chan $network $wildsite }\n}\non *:Nick: { NickNamesAdd $newnick $+($network,$wildsite) $nick }\nalias -l NickNames.display {\n if ($gettok($hget(NickNames,$+($3,$4)),0,126) > 1) {\n echo -g $2 $AKALogo $+(\u000309,$1) $AKALogo \u000307 $mid($replace($hget(NickNames,$+($3,$4)),$chr(126),$chr(44)),2,-1)\n }\n}\nalias -l NickNamesAdd {\n if ($hget(NickNames,$2)) {\n if (!$regex($hget(NickNames,$2),/~\\Q $+ $replacecs($1,\\E,\\E\\\\E\\Q) $+ \\E~/i)) {\n if ($gettok($hget(NickNames,$2),0,126) <= $MaxNicks) {\n hadd NickNames $2 $+($hget(NickNames,$2),$1,~)\n }\n else {\n hadd NickNames $2 $+($mid($hget(NickNames,$2),$pos($hget(NickNames,$2),~,2)),$1,~)\n }\n }\n }\n else {\n hadd -m NickNames $2 $+(~,$1,~,$iif($3,$+($3,~)))\n }\n}\nalias -l Fix.All.MindUser {\n var %Fix.Count = $hfind(NickNames,/[^~]+[0-9]{4}~/,0,r).data\n while (%Fix.Count) {\n if ($Fix.MindUser($hget(NickNames,$hfind(NickNames,/[^~]+[0-9]{4}~/,%Fix.Count,r).data))) {\n echo -ag Record %Fix.Count - $v1 - Was Cleaned\n hadd NickNames $hfind(NickNames,/[^~]+[0-9]{4}~/,%Fix.Count,r).data $v1\n }\n dec %Fix.Count\n }\n}\nalias -l Fix.MindUser { return $regsubex($1,/[^~]+[0-9]{4}~/g,$null) }\nmenu nicklist,query {\n -\n .AKA\n ..Check $$1: {\n if ($gettok($hget(NickNames,$+($network,$address($1,2))),0,126) > 1) {\n NickNames.display $1 $active $network $address($1,2)\n }\n else { echo -ag $AKALogo $+(\u000309,$1) \u000307has not been known by any other nicknames while I have been watching. }\n }\n ..Cleanup $$1:hadd NickNames $+($network,$address($1,2)) $fix.minduser($hget(NickNames,$+($network,$address($1,2))))\n ..Clear $$1:hadd NickNames $+($network,$address($1,2)) $+(~,$1,~)\n ..AKA Search Dialog:dialog $iif($dialog(AKA_Search),-v,-m) AKA_Search AKA_Search\n -\n}\nmenu status,channel {\n -\n .AKA\n ..AKA Search Dialog:dialog $iif($dialog(AKA_Search),-v,-m) AKA_Search AKA_Search\n ..Clean All Records:Fix.All.Minduser\n -\n}\ndialog AKA_Search {\n title \"AKA Search Engine\"\n size -1 -1 206 221\n option dbu\n edit \"\", 1, 8 5 149 10, autohs\n button \"Search\", 2, 163 4 32 12\n radio \"Search HostMask\", 4, 61 22 55 10\n radio \"Search Nicknames\", 5, 123 22 56 10\n list 6, 8 38 190 169, sort extsel vsbar\n button \"Check Selected\", 7, 67 206 40 12\n button \"Close\", 8, 160 206 38 12, cancel\n box \"Search Type\", 3, 11 17 183 18\n button \"Copy to Clipboard\", 9, 111 206 46 12\n}\nOn *:Dialog:Aka_Search:init:*: { did -c $dname 5 }\nOn *:Dialog:Aka_Search:Sclick:2,7,9: {\n if ($did == 2) && ($did($dname,1)) {\n did -r $dname 6\n var %search $+(*,$v1,*), %type $iif($did($dname,5).state,data,item), %matches = $hfind(NickNames,%search,0,w). [ $+ [ %type ] ]\n while (%matches) {\n did -a $dname 6 $hfind(NickNames,%search,%matches,w). [ $+ [ %type ] ]\n dec %matches\n }\n did -c $dname 6 1\n }\n elseif ($did == 7) && ($did($dname,6).seltext) { echo -ga $AKALogo \u000307 $mid($replace($hget(NickNames,$v1),$chr(126),$chr(44)),2,-1) }\n elseif ($did == 9) && ($did($dname,6).seltext) { clipboard $mid($v1,$pos($v1,*,1)) }\n}\nOn *:Start:{\n if (!$hget(NickNames)) { hmake NickNames 10 }\n if ($isfile(NickNames.hsh)) { hload NickNames NickNames.hsh }\n}\nOn *:Exit: { if ($hget(NickNames)) { hsave NickNames NickNames.hsh } }\nOn *:Disconnect: { if ($hget(NickNames)) { hsave NickNames NickNames.hsh } }\nOn *:Unload: { hfree NickNames }\nalias -l ialupdateCheck {\n inc -z $+(%,ialupdateCheck,$network) $calc($nick($1,0) / 4)\n ;If your ial is already being updated on join .who $1 out.\n ;If you are using /names to update ial you will still need this line.\n .who $1\n}\nRaw 352:*: {\n if ($($+(%,ialupdateCheck,$network),2)) haltdef\n NickNamesAdd $6 $+($network,$address($6,2))\n}\nRaw 315:*: {\n if ($($+(%,ialupdateCheck,$network),2)) haltdef\n}\n\n\n \n\n MIME types defined: text/mirc.\n\n
\nOCaml mode\n\n\n\n(* Summing a list of integers *)\nlet rec sum xs =\n match xs with\n | [] -> 0\n | x :: xs' -> x + sum xs'\n\n(* Quicksort *)\nlet rec qsort = function\n | [] -> []\n | pivot :: rest ->\n let is_less x = x < pivot in\n let left, right = List.partition is_less rest in\n qsort left @ [pivot] @ qsort right\n\n(* Fibonacci Sequence *)\nlet rec fib_aux n a b =\n match n with\n | 0 -> a\n | _ -> fib_aux (n - 1) (a + b) a\nlet fib n = fib_aux n 0 1\n\n(* Birthday paradox *)\nlet year_size = 365.\n\nlet rec birthday_paradox prob people =\n let prob' = (year_size -. float people) /. year_size *. prob in\n if prob' < 0.5 then\n Printf.printf \"answer = %d\\n\" (people+1)\n else\n birthday_paradox prob' (people+1) ;;\n\nbirthday_paradox 1.0 1\n\n(* Church numerals *)\nlet zero f x = x\nlet succ n f x = f (n f x)\nlet one = succ zero\nlet two = succ (succ zero)\nlet add n1 n2 f x = n1 f (n2 f x)\nlet to_string n = n (fun k -> \"S\" ^ k) \"0\"\nlet _ = to_string (add (succ two) two)\n\n(* Elementary functions *)\nlet square x = x * x;;\nlet rec fact x =\n if x <= 1 then 1 else x * fact (x - 1);;\n\n(* Automatic memory management *)\nlet l = 1 :: 2 :: 3 :: [];;\n[1; 2; 3];;\n5 :: l;;\n\n(* Polymorphism: sorting lists *)\nlet rec sort = function\n | [] -> []\n | x :: l -> insert x (sort l)\n\nand insert elem = function\n | [] -> [elem]\n | x :: l ->\n if elem < x then elem :: x :: l else x :: insert elem l;;\n\n(* Imperative features *)\nlet add_polynom p1 p2 =\n let n1 = Array.length p1\n and n2 = Array.length p2 in\n let result = Array.create (max n1 n2) 0 in\n for i = 0 to n1 - 1 do result.(i) <- p1.(i) done;\n for i = 0 to n2 - 1 do result.(i) <- result.(i) + p2.(i) done;\n result;;\nadd_polynom [| 1; 2 |] [| 1; 2; 3 |];;\n\n(* We may redefine fact using a reference cell and a for loop *)\nlet fact n =\n let result = ref 1 in\n for i = 2 to n do\n result := i * !result\n done;\n !result;;\nfact 5;;\n\n(* Triangle (graphics) *)\nlet () =\n ignore( Glut.init Sys.argv );\n Glut.initDisplayMode ~double_buffer:true ();\n ignore (Glut.createWindow ~title:\"OpenGL Demo\");\n let angle t = 10. *. t *. t in\n let render () =\n GlClear.clear [ `color ];\n GlMat.load_identity ();\n GlMat.rotate ~angle: (angle (Sys.time ())) ~z:1. ();\n GlDraw.begins `triangles;\n List.iter GlDraw.vertex2 [-1., -1.; 0., 1.; 1., -1.];\n GlDraw.ends ();\n Glut.swapBuffers () in\n GlMat.mode `modelview;\n Glut.displayFunc ~cb:render;\n Glut.idleFunc ~cb:(Some Glut.postRedisplay);\n Glut.mainLoop ()\n\n(* A Hundred Lines of Caml - http://caml.inria.fr/about/taste.en.html *)\n(* OCaml page on Wikipedia - http://en.wikipedia.org/wiki/OCaml *)\n\n\nF# mode\n\nmodule CodeMirror.FSharp\n\nlet rec fib = function\n | 0 -> 0\n | 1 -> 1\n | n -> fib (n - 1) + fib (n - 2)\n\ntype Point =\n {\n x : int\n y : int\n }\n\ntype Color =\n | Red\n | Green\n | Blue\n\n[0 .. 10]\n|> List.map ((+) 2)\n|> List.fold (fun x y -> x + y) 0\n|> printf \"%i\"\n\n\n\n\n\nMIME types defined: text/x-ocaml (OCaml) and text/x-fsharp (F#).\n
\nModelica mode\n\n\nmodel BouncingBall\n parameter Real e = 0.7;\n parameter Real g = 9.81;\n Real h(start=1);\n Real v;\n Boolean flying(start=true);\n Boolean impact;\n Real v_new;\nequation\n impact = h <= 0.0;\n der(v) = if flying then -g else 0;\n der(h) = v;\n when {h <= 0.0 and v <= 0.0, impact} then\n v_new = if edge(impact) then -e*pre(v) else 0;\n flying = v_new > 0;\n reinit(v, v_new);\n end when;\n annotation (uses(Modelica(version=\"3.2\")));\nend BouncingBall;\n\n\n \n\n Simple mode that tries to handle Modelica as well as it can.\n\n MIME types defined: text/x-modelica\n (Modlica code).\n
\nNGINX mode\n\nserver {\n listen 173.255.219.235:80;\n server_name website.com.au;\n rewrite / $scheme://www.$host$request_uri permanent; ## Forcibly prepend a www\n}\n\nserver {\n listen 173.255.219.235:443;\n server_name website.com.au;\n rewrite / $scheme://www.$host$request_uri permanent; ## Forcibly prepend a www\n}\n\nserver {\n\n listen 173.255.219.235:80;\n server_name www.website.com.au;\n\n\n\n root /data/www;\n index index.html index.php;\n\n location / {\n index index.html index.php; ## Allow a static html file to be shown first\n try_files $uri $uri/ @handler; ## If missing pass the URI to Magento's front handler\n expires 30d; ## Assume all files are cachable\n }\n\n ## These locations would be hidden by .htaccess normally\n location /app/ { deny all; }\n location /includes/ { deny all; }\n location /lib/ { deny all; }\n location /media/downloadable/ { deny all; }\n location /pkginfo/ { deny all; }\n location /report/config.xml { deny all; }\n location /var/ { deny all; }\n\n location /var/export/ { ## Allow admins only to view export folder\n auth_basic \"Restricted\"; ## Message shown in login window\n auth_basic_user_file /rs/passwords/testfile; ## See /etc/nginx/htpassword\n autoindex on;\n }\n\n location /. { ## Disable .htaccess and other hidden files\n return 404;\n }\n\n location @handler { ## Magento uses a common front handler\n rewrite / /index.php;\n }\n\n location ~ .php/ { ## Forward paths like /js/index.php/x.js to relevant handler\n rewrite ^/(.*.php)/ /$1 last;\n }\n\n location ~ \\.php$ {\n if (!-e $request_filename) { rewrite / /index.php last; } ## Catch 404s that try_files miss\n\n fastcgi_pass 127.0.0.1:9000;\n fastcgi_index index.php;\n fastcgi_param PATH_INFO $fastcgi_script_name;\n fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;\n include /rs/confs/nginx/fastcgi_params;\n }\n\n}\n\n\nserver {\n\n listen 173.255.219.235:443;\n server_name website.com.au www.website.com.au;\n\n root /data/www;\n index index.html index.php;\n\n ssl on;\n ssl_certificate /rs/ssl/ssl.crt;\n ssl_certificate_key /rs/ssl/ssl.key;\n\n ssl_session_timeout 5m;\n\n ssl_protocols SSLv2 SSLv3 TLSv1;\n ssl_ciphers ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP;\n ssl_prefer_server_ciphers on;\n\n\n\n location / {\n index index.html index.php; ## Allow a static html file to be shown first\n try_files $uri $uri/ @handler; ## If missing pass the URI to Magento's front handler\n expires 30d; ## Assume all files are cachable\n }\n\n ## These locations would be hidden by .htaccess normally\n location /app/ { deny all; }\n location /includes/ { deny all; }\n location /lib/ { deny all; }\n location /media/downloadable/ { deny all; }\n location /pkginfo/ { deny all; }\n location /report/config.xml { deny all; }\n location /var/ { deny all; }\n\n location /var/export/ { ## Allow admins only to view export folder\n auth_basic \"Restricted\"; ## Message shown in login window\n auth_basic_user_file htpasswd; ## See /etc/nginx/htpassword\n autoindex on;\n }\n\n location /. { ## Disable .htaccess and other hidden files\n return 404;\n }\n\n location @handler { ## Magento uses a common front handler\n rewrite / /index.php;\n }\n\n location ~ .php/ { ## Forward paths like /js/index.php/x.js to relevant handler\n rewrite ^/(.*.php)/ /$1 last;\n }\n\n location ~ .php$ { ## Execute PHP scripts\n if (!-e $request_filename) { rewrite /index.php last; } ## Catch 404s that try_files miss\n\n fastcgi_pass 127.0.0.1:9000;\n fastcgi_index index.php;\n fastcgi_param PATH_INFO $fastcgi_script_name;\n fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;\n include /rs/confs/nginx/fastcgi_params;\n\n fastcgi_param HTTPS on;\n }\n\n}\n\n \n\n MIME types defined: text/nginx.\n\n
\nNTriples mode\n\n \n<http://Sub1> <http://pred1> <http://obj> .\n<http://Sub2> <http://pred2#an2> \"literal 1\" .\n<http://Sub3#an3> <http://pred3> _:bnode3 .\n_:bnode4 <http://pred4> \"literal 2\"@lang .\n_:bnode5 <http://pred5> \"literal 3\"^^<http://type> .\n\n\n\n \n MIME types defined: text/n-triples.\n
\nOctave mode\n\n \n%numbers\n[1234 1234i 1234j]\n[.234 .234j 2.23i]\n[23e2 12E1j 123D-4 0x234]\n\n%strings\n'asda''a'\n\"asda\"\"a\"\n\n%identifiers\na + as123 - __asd__\n\n%operators\n-\n+\n=\n==\n>\n<\n>=\n<=\n&\n~\n...\nbreak zeros default margin round ones rand\nceil floor size clear zeros eye mean std cov\nerror eval function\nabs acos atan asin cos cosh exp log prod sum\nlog10 max min sign sin sinh sqrt tan reshape\nreturn\ncase switch\nelse elseif end if otherwise\ndo for while\ntry catch\nclassdef properties events methods\nglobal persistent\n\n%one line comment\n%{ multi \nline commment %}\n\n \n \n\n MIME types defined: text/x-octave.\n
\nPascal mode\n\n\n\n(* Example Pascal code *)\n\nwhile a <> b do writeln('Waiting');\n \nif a > b then \n writeln('Condition met')\nelse \n writeln('Condition not met');\n \nfor i := 1 to 10 do \n writeln('Iteration: ', i:1);\n \nrepeat\n a := a + 1\nuntil a = 10;\n \ncase i of\n 0: write('zero');\n 1: write('one');\n 2: write('two')\nend;\n\n\n \n\n MIME types defined: text/x-pascal.\n
\n PEG.js Mode\n \n/*\n * Classic example grammar, which recognizes simple arithmetic expressions like\n * \"2*(3+4)\". The parser generated from this grammar then computes their value.\n */\n\nstart\n = additive\n\nadditive\n = left:multiplicative \"+\" right:additive { return left + right; }\n / multiplicative\n\nmultiplicative\n = left:primary \"*\" right:multiplicative { return left * right; }\n / primary\n\nprimary\n = integer\n / \"(\" additive:additive \")\" { return additive; }\n\ninteger \"integer\"\n = digits:[0-9]+ { return parseInt(digits.join(\"\"), 10); }\n\nletter = [a-z]+\n \n The PEG.js Mode\n Created by Forbes Lindesay.\n
\nPerl mode\n\n\n\n#!/usr/bin/perl\n\nuse Something qw(func1 func2);\n\n# strings\nmy $s1 = qq'single line';\nour $s2 = q(multi-\n line);\n\n=item Something\n\tExample.\n=cut\n\nmy $html=<<'HTML'\n<html>\n<title>hi!</title>\n</html>\nHTML\n\nprint \"first,\".join(',', 'second', qq~third~);\n\nif($s1 =~ m[(?<!\\s)(l.ne)\\z]o) {\n\t$h->{$1}=$$.' predefined variables';\n\t$s2 =~ s/\\-line//ox;\n\t$s1 =~ s[\n\t\t line ]\n\t\t[\n\t\t block\n\t\t]ox;\n}\n\n1; # numbers and comments\n\n__END__\nsomething...\n\n\n\n \n\n MIME types defined: text/x-perl.\n
\nPHP mode\n\n<?php\n$a = array('a' => 1, 'b' => 2, 3 => 'c');\n\necho \"$a[a] ${a[3] /* } comment */} {$a[b]} \\$a[a]\";\n\nfunction hello($who) {\n\treturn \"Hello $who!\";\n}\n?>\n<p>The program says <?= hello(\"World\") ?>.</p>\n<script>\n\talert(\"And here is some JS code\"); // also colored\n</script>\n\n\n \n\n Simple HTML/PHP mode based on\n the C-like mode. Depends on XML,\n JavaScript, CSS, HTMLMixed, and C-like modes.\n\n MIME types defined: application/x-httpd-php (HTML with PHP code), text/x-php (plain, non-wrapped PHP code).\n
\nPig Latin mode\n\n-- Apache Pig (Pig Latin Language) Demo\n/* \nThis is a multiline comment.\n*/\na = LOAD \"\\path\\to\\input\" USING PigStorage('\\t') AS (x:long, y:chararray, z:bytearray);\nb = GROUP a BY (x,y,3+4);\nc = FOREACH b GENERATE flatten(group) as (x,y), SUM(group.$2) as z;\nSTORE c INTO \"\\path\\to\\output\";\n\n--\n\n\n \n\n \n Simple mode that handles Pig Latin language.\n \n\n MIME type defined: text/x-pig\n (PIG code)\n
![](\"https://raw.githubusercontent.com/laravel/art/master/logo-lockup/5%20SVG/2%20CMYK/1%20Full%20Color/laravel-logolockup-cmyk-red.svg\"){kind=logo}
![\"Build](\"https://travis-ci.org/laravel/framework.svg\")
\n![\"Total](\"https://img.shields.io/packagist/dt/laravel/framework\")
![\"Latest](\"https://img.shields.io/packagist/v/laravel/framework\")
![\"License\"](\"https://img.shields.io/packagist/l/laravel/framework\")