CodeMirror

/* 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;

}

​

#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;

}

​

/*

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;

}

​

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;

  }

}

​

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))

}

​

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()

    }

}

​

"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;

                }

            }

        };

    };

​