<!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(&amp;context->sem)) == EINTR);
   if (res) {write(context->signal_fd, &amp;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), &amp;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, &amp;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(&amp;context->sem, 1, 0);
pthread_create(&amp;thread, 0, &amp;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>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>

<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 scalaEditor = CodeMirror.fromTextArea(document.getElementById("scala-code"), {
    lineNumbers: true,
    matchBrackets: true,
    mode: "text/x-scala"
  });
  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-scala</code> (Scala), <code>text/x-vertex</code>
and <code>x-shader/x-fragment</code> (shader programs).</p>

</article>