diff options
Diffstat (limited to 'public/plugins/codemirror-5.17.0/mode/clike/index.html')
-rw-r--r-- | public/plugins/codemirror-5.17.0/mode/clike/index.html | 360 |
1 files changed, 360 insertions, 0 deletions
diff --git a/public/plugins/codemirror-5.17.0/mode/clike/index.html b/public/plugins/codemirror-5.17.0/mode/clike/index.html new file mode 100644 index 0000000000..45c670ae58 --- /dev/null +++ b/public/plugins/codemirror-5.17.0/mode/clike/index.html @@ -0,0 +1,360 @@ +<!doctype html> + +<title>CodeMirror: C-like mode</title> +<meta charset="utf-8"/> +<link rel=stylesheet href="../../doc/docs.css"> + +<link rel="stylesheet" href="../../lib/codemirror.css"> +<script src="../../lib/codemirror.js"></script> +<script src="../../addon/edit/matchbrackets.js"></script> +<link rel="stylesheet" href="../../addon/hint/show-hint.css"> +<script src="../../addon/hint/show-hint.js"></script> +<script src="clike.js"></script> +<style>.CodeMirror {border: 2px inset #dee;}</style> +<div id=nav> + <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> + + <ul> + <li><a href="../../index.html">Home</a> + <li><a href="../../doc/manual.html">Manual</a> + <li><a href="https://github.com/codemirror/codemirror">Code</a> + </ul> + <ul> + <li><a href="../index.html">Language modes</a> + <li><a class=active href="#">C-like</a> + </ul> +</div> + +<article> +<h2>C-like mode</h2> + +<div><textarea id="c-code"> +/* C demo code */ + +#include <zmq.h> +#include <pthread.h> +#include <semaphore.h> +#include <time.h> +#include <stdio.h> +#include <fcntl.h> +#include <malloc.h> + +typedef struct { + void* arg_socket; + zmq_msg_t* arg_msg; + char* arg_string; + unsigned long arg_len; + int arg_int, arg_command; + + int signal_fd; + int pad; + void* context; + sem_t sem; +} acl_zmq_context; + +#define p(X) (context->arg_##X) + +void* zmq_thread(void* context_pointer) { + acl_zmq_context* context = (acl_zmq_context*)context_pointer; + char ok = 'K', err = 'X'; + int res; + + while (1) { + while ((res = sem_wait(&context->sem)) == EINTR); + if (res) {write(context->signal_fd, &err, 1); goto cleanup;} + switch(p(command)) { + case 0: goto cleanup; + case 1: p(socket) = zmq_socket(context->context, p(int)); break; + case 2: p(int) = zmq_close(p(socket)); break; + case 3: p(int) = zmq_bind(p(socket), p(string)); break; + case 4: p(int) = zmq_connect(p(socket), p(string)); break; + case 5: p(int) = zmq_getsockopt(p(socket), p(int), (void*)p(string), &p(len)); break; + case 6: p(int) = zmq_setsockopt(p(socket), p(int), (void*)p(string), p(len)); break; + case 7: p(int) = zmq_send(p(socket), p(msg), p(int)); break; + case 8: p(int) = zmq_recv(p(socket), p(msg), p(int)); break; + case 9: p(int) = zmq_poll(p(socket), p(int), p(len)); break; + } + p(command) = errno; + write(context->signal_fd, &ok, 1); + } + cleanup: + close(context->signal_fd); + free(context_pointer); + return 0; +} + +void* zmq_thread_init(void* zmq_context, int signal_fd) { + acl_zmq_context* context = malloc(sizeof(acl_zmq_context)); + pthread_t thread; + + context->context = zmq_context; + context->signal_fd = signal_fd; + sem_init(&context->sem, 1, 0); + pthread_create(&thread, 0, &zmq_thread, context); + pthread_detach(thread); + return context; +} +</textarea></div> + +<h2>C++ example</h2> + +<div><textarea id="cpp-code"> +#include <iostream> +#include "mystuff/util.h" + +namespace { +enum Enum { + VAL1, VAL2, VAL3 +}; + +char32_t unicode_string = U"\U0010FFFF"; +string raw_string = R"delim(anything +you +want)delim"; + +int Helper(const MyType& param) { + return 0; +} +} // namespace + +class ForwardDec; + +template <class T, class V> +class Class : public BaseClass { + const MyType<T, V> member_; + + public: + const MyType<T, V>& Method() const { + return member_; + } + + void Method2(MyType<T, V>* value); +} + +template <class T, class V> +void Class::Method2(MyType<T, V>* value) { + std::out << 1 >> method(); + value->Method3(member_); + member_ = value; +} +</textarea></div> + +<h2>Objective-C example</h2> + +<div><textarea id="objectivec-code"> +/* +This is a longer comment +That spans two lines +*/ + +#import <Test/Test.h> +@implementation YourAppDelegate + +// This is a one-line comment + +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{ + char myString[] = "This is a C character array"; + int test = 5; + return YES; +} +</textarea></div> + +<h2>Java example</h2> + +<div><textarea id="java-code"> +import com.demo.util.MyType; +import com.demo.util.MyInterface; + +public enum Enum { + VAL1, VAL2, VAL3 +} + +public class Class<T, V> implements MyInterface { + public static final MyType<T, V> member; + + private class InnerClass { + public int zero() { + return 0; + } + } + + @Override + public MyType method() { + return member; + } + + public void method2(MyType<T, V> value) { + method(); + value.method3(); + member = value; + } +} +</textarea></div> + +<h2>Scala example</h2> + +<div><textarea id="scala-code"> +object FilterTest extends App { + def filter(xs: List[Int], threshold: Int) = { + def process(ys: List[Int]): List[Int] = + if (ys.isEmpty) ys + else if (ys.head < threshold) ys.head :: process(ys.tail) + else process(ys.tail) + process(xs) + } + println(filter(List(1, 9, 2, 8, 3, 7, 4), 5)) +} +</textarea></div> + +<h2>Kotlin mode</h2> + +<div><textarea id="kotlin-code"> +package org.wasabi.http + +import java.util.concurrent.Executors +import java.net.InetSocketAddress +import org.wasabi.app.AppConfiguration +import io.netty.bootstrap.ServerBootstrap +import io.netty.channel.nio.NioEventLoopGroup +import io.netty.channel.socket.nio.NioServerSocketChannel +import org.wasabi.app.AppServer + +public class HttpServer(private val appServer: AppServer) { + + val bootstrap: ServerBootstrap + val primaryGroup: NioEventLoopGroup + val workerGroup: NioEventLoopGroup + + init { + // Define worker groups + primaryGroup = NioEventLoopGroup() + workerGroup = NioEventLoopGroup() + + // Initialize bootstrap of server + bootstrap = ServerBootstrap() + + bootstrap.group(primaryGroup, workerGroup) + bootstrap.channel(javaClass<NioServerSocketChannel>()) + bootstrap.childHandler(NettyPipelineInitializer(appServer)) + } + + public fun start(wait: Boolean = true) { + val channel = bootstrap.bind(appServer.configuration.port)?.sync()?.channel() + + if (wait) { + channel?.closeFuture()?.sync() + } + } + + public fun stop() { + // Shutdown all event loops + primaryGroup.shutdownGracefully() + workerGroup.shutdownGracefully() + + // Wait till all threads are terminated + primaryGroup.terminationFuture().sync() + workerGroup.terminationFuture().sync() + } +} +</textarea></div> + +<h2>Ceylon mode</h2> + +<div><textarea id="ceylon-code"> +"Produces the [[stream|Iterable]] that results from repeated + application of the given [[function|next]] to the given + [[first]] element of the stream, until the function first + returns [[finished]]. If the given function never returns + `finished`, the resulting stream is infinite. + + For example: + + loop(0)(2.plus).takeWhile(10.largerThan) + + produces the stream `{ 0, 2, 4, 6, 8 }`." +tagged("Streams") +shared {Element+} loop<Element>( + "The first element of the resulting stream." + Element first)( + "The function that produces the next element of the + stream, given the current element. The function may + return [[finished]] to indicate the end of the + stream." + Element|Finished next(Element element)) + => let (start = first) + object satisfies {Element+} { + first => start; + empty => false; + function nextElement(Element element) + => next(element); + iterator() + => object satisfies Iterator<Element> { + variable Element|Finished current = start; + shared actual Element|Finished next() { + if (!is Finished result = current) { + current = nextElement(result); + return result; + } + else { + return finished; + } + } + }; + }; +</textarea></div> + + <script> + var cEditor = CodeMirror.fromTextArea(document.getElementById("c-code"), { + lineNumbers: true, + matchBrackets: true, + mode: "text/x-csrc" + }); + var cppEditor = CodeMirror.fromTextArea(document.getElementById("cpp-code"), { + lineNumbers: true, + matchBrackets: true, + mode: "text/x-c++src" + }); + var javaEditor = CodeMirror.fromTextArea(document.getElementById("java-code"), { + lineNumbers: true, + matchBrackets: true, + mode: "text/x-java" + }); + var objectivecEditor = CodeMirror.fromTextArea(document.getElementById("objectivec-code"), { + lineNumbers: true, + matchBrackets: true, + mode: "text/x-objectivec" + }); + var scalaEditor = CodeMirror.fromTextArea(document.getElementById("scala-code"), { + lineNumbers: true, + matchBrackets: true, + mode: "text/x-scala" + }); + var kotlinEditor = CodeMirror.fromTextArea(document.getElementById("kotlin-code"), { + lineNumbers: true, + matchBrackets: true, + mode: "text/x-kotlin" + }); + var ceylonEditor = CodeMirror.fromTextArea(document.getElementById("ceylon-code"), { + lineNumbers: true, + matchBrackets: true, + mode: "text/x-ceylon" + }); + var mac = CodeMirror.keyMap.default == CodeMirror.keyMap.macDefault; + CodeMirror.keyMap.default[(mac ? "Cmd" : "Ctrl") + "-Space"] = "autocomplete"; + </script> + + <p>Simple mode that tries to handle C-like languages as well as it + can. Takes two configuration parameters: <code>keywords</code>, an + object whose property names are the keywords in the language, + and <code>useCPP</code>, which determines whether C preprocessor + directives are recognized.</p> + + <p><strong>MIME types defined:</strong> <code>text/x-csrc</code> + (C), <code>text/x-c++src</code> (C++), <code>text/x-java</code> + (Java), <code>text/x-csharp</code> (C#), + <code>text/x-objectivec</code> (Objective-C), + <code>text/x-scala</code> (Scala), <code>text/x-vertex</code> + <code>x-shader/x-fragment</code> (shader programs), + <code>text/x-squirrel</code> (Squirrel) and + <code>text/x-ceylon</code> (Ceylon)</p> +</article> |