Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 1207 additions and 99 deletions
examples/twoway/decimating_messages.lc
View file @ d3921882
sample struct {
int decimation;
int signature_index;
} set_decimation;
\ No newline at end of file
} set_decimation;
examples/twoway/introspecting.c
View file @ d3921882
......@@ -23,18 +23,18 @@
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include "labcomm_private.h"
#include "labcomm2014_private.h"
#include "introspecting.h"
#include "gen/introspecting_messages.h"
struct introspecting_private {
struct introspecting introspecting;
struct labcomm_error_handler *error;
struct labcomm_memory *memory;
struct labcomm_scheduler *scheduler;
struct labcomm2014_error_handler *error;
struct labcomm2014_memory *memory;
struct labcomm2014_scheduler *scheduler;
struct labcomm_reader_action_context reader_action_context;
struct labcomm_writer_action_context writer_action_context;
struct labcomm2014_reader_action_context reader_action_context;
struct labcomm2014_writer_action_context writer_action_context;
LABCOMM_SIGNATURE_ARRAY_DEF(remote,
struct remote {
char *name;
......@@ -44,13 +44,13 @@ struct introspecting_private {
LABCOMM_SIGNATURE_ARRAY_DEF(local,
struct local {
enum introspecting_status status;
struct labcomm_signature *signature;
const struct labcomm2014_signature *signature;
});
};
static struct local *get_local(struct introspecting_private *introspecting,
int index,
struct labcomm_signature *signature)
const struct labcomm2014_signature *signature)
{
/* Called with data_lock held */
struct local *local;
......@@ -91,7 +91,7 @@ static void handles_signature(
struct introspecting_private *introspecting = context;
struct remote *remote;
labcomm_scheduler_data_lock(introspecting->scheduler);
labcomm2014_scheduler_data_lock(introspecting->scheduler);
remote = LABCOMM_SIGNATURE_ARRAY_REF(introspecting->memory,
introspecting->remote,
struct remote,
......@@ -119,26 +119,25 @@ static void handles_signature(
}
}
}
labcomm_scheduler_data_unlock(introspecting->scheduler);
labcomm2014_scheduler_data_unlock(introspecting->scheduler);
}
static int wrap_reader_alloc(
struct labcomm_reader *r,
struct labcomm_reader_action_context *action_context,
char *labcomm_version)
struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
struct introspecting_private *introspecting = action_context->context;
labcomm_decoder_register_introspecting_messages_handles_signature(
labcomm2014_decoder_register_introspecting_messages_handles_signature(
introspecting->introspecting.reader->decoder,
handles_signature, introspecting);
return labcomm_reader_alloc(r, action_context->next, labcomm_version);
return labcomm2014_reader_alloc(r, action_context->next);
}
struct handles_signature {
struct introspecting_private *introspecting;
int index;
struct labcomm_signature *signature;
const struct labcomm2014_signature *signature;
};
static void send_handles_signature(void *arg)
......@@ -150,14 +149,14 @@ static void send_handles_signature(void *arg)
handles_signature.name = h->signature->name;
handles_signature.signature.n_0 = h->signature->size;
handles_signature.signature.a = h->signature->signature;
labcomm_encode_introspecting_messages_handles_signature(
labcomm2014_encode_introspecting_messages_handles_signature(
h->introspecting->introspecting.writer->encoder, &handles_signature);
}
static int wrap_reader_start(
struct labcomm_reader *r,
struct labcomm_reader_action_context *action_context,
int local_index, int remote_index, struct labcomm_signature *signature,
struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context,
int local_index, int remote_index, const struct labcomm2014_signature *signature,
void *value)
{
struct introspecting_private *introspecting = action_context->context;
......@@ -165,23 +164,23 @@ static int wrap_reader_start(
if (value == NULL) {
struct handles_signature *handles_signature;
handles_signature = labcomm_memory_alloc(introspecting->memory, 1,
handles_signature = labcomm2014_memory_alloc(introspecting->memory, 1,
sizeof(*handles_signature));
handles_signature->introspecting = introspecting;
handles_signature->index = local_index;
handles_signature->signature = signature;
labcomm_scheduler_enqueue(introspecting->scheduler,
labcomm2014_scheduler_enqueue(introspecting->scheduler,
0, send_handles_signature, handles_signature);
}
return labcomm_reader_start(r, action_context->next,
return labcomm2014_reader_start(r, action_context->next,
local_index, remote_index, signature, value);
}
void encode_handles_signature(
struct labcomm_encoder *encoder,
struct labcomm2014_encoder *encoder,
void *context)
{
struct labcomm_signature *signature = context;
const struct labcomm2014_signature *signature = context;
introspecting_messages_handles_signature handles_signature;
int index = 0;
......@@ -190,11 +189,11 @@ static int wrap_reader_start(
handles_signature.signature.n_0 = signature->size;
handles_signature.signature.a = signature->signature;
labcomm_encode_introspecting_messages_handles_signature(
labcomm2014_encode_introspecting_messages_handles_signature(
NULL, &handles_signature);
}
struct labcomm_reader_action introspecting_reader_action = {
struct labcomm2014_reader_action introspecting_reader_action = {
.alloc = wrap_reader_alloc,
.free = NULL,
.start = wrap_reader_start,
......@@ -207,45 +206,44 @@ static void register_encoder_signatures(void *context)
{
struct introspecting_private *introspecting = context;
labcomm_encoder_register_introspecting_messages_handles_signature(
labcomm2014_encoder_register_introspecting_messages_handles_signature(
introspecting->introspecting.writer->encoder);
}
static int wrap_writer_alloc(
struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
char *labcomm_version)
struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
struct introspecting_private *introspecting = action_context->context;
labcomm_scheduler_enqueue(introspecting->scheduler,
labcomm2014_scheduler_enqueue(introspecting->scheduler,
0, register_encoder_signatures, introspecting);
return labcomm_writer_alloc(w, action_context->next, labcomm_version);
return labcomm2014_writer_alloc(w, action_context->next);
}
static int wrap_writer_start(
struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
int index, struct labcomm_signature *signature,
struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int index, const struct labcomm2014_signature *signature,
void *value)
{
struct introspecting_private *introspecting = action_context->context;
if (value == NULL) {
if (index >= LABCOMM_USER && value == NULL) {
struct local *local;
labcomm_scheduler_data_lock(introspecting->scheduler);
labcomm2014_scheduler_data_lock(introspecting->scheduler);
local = get_local(introspecting, index, signature);
local->status = introspecting_registered;
labcomm_scheduler_data_unlock(introspecting->scheduler);
labcomm2014_scheduler_data_unlock(introspecting->scheduler);
}
return labcomm_writer_start(w, action_context->next, index, signature, value);
return labcomm2014_writer_start(w, action_context->next, index, signature, value);
}
static int wrap_writer_ioctl(
struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
int index, struct labcomm_signature *signature,
struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int index, const struct labcomm2014_signature *signature,
uint32_t ioctl_action, va_list args)
{
struct introspecting_private *introspecting = action_context->context;
......@@ -255,20 +253,20 @@ static int wrap_writer_ioctl(
struct local *local;
int result;
labcomm_scheduler_data_lock(introspecting->scheduler);
labcomm2014_scheduler_data_lock(introspecting->scheduler);
local = get_local(introspecting, index, signature);
result = local->status;
labcomm_scheduler_data_unlock(introspecting->scheduler);
labcomm2014_scheduler_data_unlock(introspecting->scheduler);
return result;
}
default: {
return labcomm_writer_ioctl(w, action_context->next, index, signature,
return labcomm2014_writer_ioctl(w, action_context->next, index, signature,
ioctl_action, args);
} break;
}
}
struct labcomm_writer_action introspecting_writer_action = {
struct labcomm2014_writer_action introspecting_writer_action = {
.alloc = wrap_writer_alloc,
.free = NULL,
.start = wrap_writer_start,
......@@ -278,11 +276,11 @@ struct labcomm_writer_action introspecting_writer_action = {
};
extern struct introspecting *introspecting_new(
struct labcomm_reader *reader,
struct labcomm_writer *writer,
struct labcomm_error_handler *error,
struct labcomm_memory *memory,
struct labcomm_scheduler *scheduler)
struct labcomm2014_reader *reader,
struct labcomm2014_writer *writer,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler)
{
struct introspecting_private *result;
......
examples/twoway/introspecting.h
View file @ d3921882
......@@ -23,22 +23,22 @@
#ifndef __INTROSPECTING_H__
#define __INTROSPECTING_H__
#include <labcomm.h>
#include <labcomm_ioctl.h>
#include <labcomm_fd_reader.h>
#include <labcomm_fd_writer.h>
#include <labcomm2014.h>
#include <labcomm2014_ioctl.h>
#include <labcomm2014_fd_reader.h>
#include <labcomm2014_fd_writer.h>
struct introspecting {
struct labcomm_reader *reader;
struct labcomm_writer *writer;
struct labcomm2014_reader *reader;
struct labcomm2014_writer *writer;
};
extern struct introspecting *introspecting_new(
struct labcomm_reader *reader,
struct labcomm_writer *writer,
struct labcomm_error_handler *error,
struct labcomm_memory *memory,
struct labcomm_scheduler *scheduler);
struct labcomm2014_reader *reader,
struct labcomm2014_writer *writer,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler);
#define HAS_SIGNATURE LABCOMM_IOS('i',2)
enum introspecting_status { introspecting_unknown,
......
examples/twoway/server.c
View file @ d3921882
......@@ -20,7 +20,12 @@
*/
#include <arpa/inet.h>
#ifndef LABCOMM_OS_DARWIN
#include <linux/tcp.h>
#else
#include <netinet/in.h>
#include <netinet/tcp.h>
#endif
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
......@@ -28,11 +33,11 @@
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <labcomm_default_error_handler.h>
#include <labcomm_default_memory.h>
#include <labcomm_pthread_scheduler.h>
#include <labcomm_fd_reader.h>
#include <labcomm_fd_writer.h>
#include <labcomm2014_default_error_handler.h>
#include <labcomm2014_default_memory.h>
#include <labcomm2014_pthread_scheduler.h>
#include <labcomm2014_fd_reader.h>
#include <labcomm2014_fd_writer.h>
#include "decimating.h"
#include "introspecting.h"
#include "gen/types.h"
......@@ -44,9 +49,9 @@ struct client {
struct sockaddr_in adr;
unsigned int adrlen;
int32_t A, B, Sum, Diff, Product;
struct labcomm_decoder *decoder;
struct labcomm_encoder *encoder;
struct labcomm_scheduler *scheduler;
struct labcomm2014_decoder *decoder;
struct labcomm2014_encoder *encoder;
struct labcomm2014_scheduler *scheduler;
};
static void handle_A(int32_t *value, void *context)
......@@ -62,22 +67,22 @@ static void handle_B(int32_t *value, void *context)
int status;
client->B = *value;
status = labcomm_encoder_ioctl_types_Product(client->encoder, HAS_SIGNATURE);
status = labcomm2014_encoder_ioctl_types_Product(client->encoder, HAS_SIGNATURE);
switch (status) {
case introspecting_unregistered:
labcomm_encoder_register_types_Product(client->encoder);
labcomm2014_encoder_register_types_Product(client->encoder);
/* fall through */
case introspecting_registered:
client->Product = client->A * client->B;
labcomm_encode_types_Product(client->encoder, &client->Product);
labcomm2014_encode_types_Product(client->encoder, &client->Product);
break;
default:
break;
}
client->Sum = client->A + client->B;
client->Diff = client->A - client->B;
labcomm_encode_types_Sum(client->encoder, &client->Sum);
labcomm_encode_types_Diff(client->encoder, &client->Diff);
labcomm2014_encode_types_Sum(client->encoder, &client->Sum);
labcomm2014_encode_types_Diff(client->encoder, &client->Diff);
}
static void handle_Terminate(types_Terminate *value, void *context)
......@@ -90,14 +95,14 @@ static void *run_decoder(void *arg)
struct client *client = arg;
int result;
labcomm_decoder_register_types_A(client->decoder, handle_A, client);
labcomm_decoder_register_types_B(client->decoder, handle_B, client);
labcomm_decoder_register_types_Terminate(client->decoder, handle_Terminate,
labcomm2014_decoder_register_types_A(client->decoder, handle_A, client);
labcomm2014_decoder_register_types_B(client->decoder, handle_B, client);
labcomm2014_decoder_register_types_Terminate(client->decoder, handle_Terminate,
NULL);
do {
result = labcomm_decoder_decode_one(client->decoder);
result = labcomm2014_decoder_decode_one(client->decoder);
} while (result >= 0);
labcomm_scheduler_wakeup(client->scheduler);
labcomm2014_scheduler_wakeup(client->scheduler);
return NULL;
}
......@@ -110,13 +115,13 @@ static void *run_client(void *arg)
printf("Client start\n");
client->A = 0;
client->B = 0;
client->scheduler = labcomm_pthread_scheduler_new(labcomm_default_memory);
decimating = decimating_new(labcomm_fd_reader_new(labcomm_default_memory,
client->scheduler = labcomm2014_pthread_scheduler_new(labcomm2014_default_memory);
decimating = decimating_new(labcomm2014_fd_reader_new(labcomm2014_default_memory,
client->fd, 1),
labcomm_fd_writer_new(labcomm_default_memory,
labcomm2014_fd_writer_new(labcomm2014_default_memory,
client->fd, 0),
labcomm_default_error_handler,
labcomm_default_memory,
labcomm2014_default_error_handler,
labcomm2014_default_memory,
client->scheduler);
if (decimating == NULL) {
/* Warning: might leak reader and writer at this point */
......@@ -124,26 +129,26 @@ static void *run_client(void *arg)
}
introspecting = introspecting_new(decimating->reader,
decimating->writer,
labcomm_default_error_handler,
labcomm_default_memory,
labcomm2014_default_error_handler,
labcomm2014_default_memory,
client->scheduler);
if (introspecting == NULL) {
/* Warning: might leak reader and writer at this point */
goto out;
}
client->decoder = labcomm_decoder_new(introspecting->reader,
labcomm_default_error_handler,
labcomm_default_memory,
client->decoder = labcomm2014_decoder_new(introspecting->reader,
labcomm2014_default_error_handler,
labcomm2014_default_memory,
client->scheduler);
client->encoder = labcomm_encoder_new(introspecting->writer,
labcomm_default_error_handler,
labcomm_default_memory,
client->encoder = labcomm2014_encoder_new(introspecting->writer,
labcomm2014_default_error_handler,
labcomm2014_default_memory,
client->scheduler);
pthread_t rdt;
pthread_create(&rdt, NULL, run_decoder, client);
labcomm_encoder_register_types_Sum(client->encoder);
labcomm_encoder_register_types_Diff(client->encoder);
labcomm_scheduler_sleep(client->scheduler, NULL);
labcomm2014_encoder_register_types_Sum(client->encoder);
labcomm2014_encoder_register_types_Diff(client->encoder);
labcomm2014_scheduler_sleep(client->scheduler, NULL);
printf("Awoken\n");
pthread_join(rdt, NULL);
out:
......
examples/twoway/types.lc
View file @ d3921882
......@@ -3,4 +3,4 @@ sample int B;
sample int Sum;
sample int Diff;
sample int Product;
sample void Terminate;
\ No newline at end of file
sample void Terminate;
examples/user_types/.gitignore 0 → 100644
View file @ d3921882
gen
labcomm2014.dll
ExampleDecoder.exe
ExampleEncoder.exe
encoded_data_c
encoded_data_cs
encoded_data_j
encoded_data_p
example_decoder
example_encoder
examples/user_types/Decoder.java 0 → 100644
View file @ d3921882
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import se.lth.control.labcomm2014.DecoderChannel;
import se.lth.control.labcomm2014.TypeDef;
import se.lth.control.labcomm2014.TypeDefParser;
import se.lth.control.labcomm2014.SigTypeDef;
//import se.lth.control.labcomm2014.TypeBinding;
public class Decoder
implements twoLines.Handler,
// TypeDef.Handler,
// TypeBinding.Handler,
TypeDefParser.TypeDefListener,
twoInts.Handler,
theFirstInt.Handler,
theSecondInt.Handler,
doavoid.Handler,
intAndRef.Handler
{
private DecoderChannel decoder;
private TypeDefParser tdp;
public Decoder(InputStream in)
throws Exception
{
decoder = new DecoderChannel(in);
doavoid.register(decoder, this);
twoInts.register(decoder, this);
twoLines.register(decoder, this);
theFirstInt.register(decoder, this);
theSecondInt.register(decoder, this);
intAndRef.register(decoder, this);
doavoid.registerSampleRef(decoder);
this.tdp = TypeDefParser.registerTypeDefParser(decoder);
// TypeDef.register(decoder, this);
// TypeBinding.register(decoder, this);
tdp.addListener(this);
try {
System.out.println("Running decoder.");
decoder.run();
} catch (java.io.EOFException e) {
System.out.println("Decoder reached end of file.");
}
}
private String genPoint(point p) {
return "("+p.x.val+", "+p.y.val+")";
}
private String genLine(line l) {
return "Line from "+genPoint(l.start)+" to "+genPoint(l.end);
}
// public void handle_TypeDef(TypeDef d) throws java.io.IOException {
// System.out.println("Got TypeDef: "+d.getName()+"("+d.getIndex()+")");
// }
//
// public void handle_TypeBinding(TypeBinding d) throws java.io.IOException {
// System.out.println("Got TypeBinding: "+d.getSampleIndex()+" --> "+d.getTypeIndex()+"");
// }
public void onTypeDef(SigTypeDef d) {
System.out.println("ontype_def: ");
if(d != null) {
System.out.print((d.isSampleDef()?"sample ":"typedef ")+d);
System.out.println(" "+d.getName()+";");
} else {
System.out.println(" null???");
}
//for(byte b: d.getSignature()) {
// System.out.print(Integer.toHexString(b)+" ");
//}
//System.out.println();
//try {
// tdp.parseSignature(d.getIndex());
//} catch(IOException ex) { ex.printStackTrace();}
}
public void handle_doavoid() throws java.io.IOException {
System.out.println("Got a void.");
}
public void handle_twoInts(twoInts d) throws java.io.IOException {
System.out.print("Got twoInts: ");
System.out.println(d.a +", "+d.b);
}
public void handle_theFirstInt(int d) throws java.io.IOException {
System.out.println("Got theFirstInt: "+d);
}
public void handle_theSecondInt(int d) throws java.io.IOException {
System.out.println("Got theSecondInt: "+d);
}
public void handle_intAndRef(intAndRef d) throws java.io.IOException {
System.out.println("Got intAndRef: "+d.x+", "+d.reference);
}
public void handle_twoLines(twoLines d) throws java.io.IOException {
System.out.print("Got twoLines: ");
System.out.println("Line l1: "+genLine(d.l1));
System.out.println(" Line l2: "+genLine(d.l2));
}
public static void main(String[] arg) throws Exception {
Decoder example = new Decoder(
new FileInputStream(new File(arg[0]))
);
}
}
examples/user_types/Encoder.java 0 → 100644
View file @ d3921882
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import se.lth.control.labcomm2014.EncoderChannel;
/**
* Simple encoder
*/
public class Encoder
{
EncoderChannel encoder;
public Encoder(OutputStream out)
throws Exception
{
encoder = new EncoderChannel(out);
doavoid.register(encoder);
twoInts.register(encoder);
twoLines.register(encoder);
theFirstInt.register(encoder);
theSecondInt.register(encoder);
intAndRef.register(encoder);
doavoid.registerSampleRef(encoder);
}
public void doEncode() throws java.io.IOException {
System.out.println("Encoding doavoid");
doavoid.encode(encoder);
intAndRef iar = new intAndRef();
iar.x = 17;
iar.reference = doavoid.class;
System.out.println("Encoding intAndRef");
intAndRef.encode(encoder, iar);
twoInts ti = new twoInts();
ti.a = 12;
ti.b = 21;
System.out.println("Encoding twoInts");
twoInts.encode(encoder, ti);
System.out.println("Encoding the Ints");
theFirstInt.encode(encoder, 71);
theSecondInt.encode(encoder, 24);
twoLines x = new twoLines();
line l1 = new line();
point p11 = new point();
coord c11x = new coord();
coord c11y = new coord();
c11x.val = 11;
c11y.val = 99;
p11.x = c11x;
p11.y = c11y;
l1.start = p11;
point p12 = new point();
coord c12x = new coord();
coord c12y = new coord();
c12x.val = 22;
c12y.val = 88;
p12.x = c12x;
p12.y = c12y;
l1.end = p12;
line l2 = new line();
point p21 = new point();
coord c21x = new coord();
coord c21y = new coord();
c21x.val = 17;
c21y.val = 42;
p21.x = c21x;
p21.y = c21y;
l2.start = p21;
point p22 = new point();
coord c22x = new coord();
coord c22y = new coord();
c22x.val = 13;
c22y.val = 37;
p22.x = c22x;
p22.y = c22y;
l2.end = p22;
foo f = new foo();
f.a = 10;
f.b = 20;
f.c = false;
x.l1 = l1;
x.l2 = l2;
x.f = f;
System.out.println("Encoding theTwoLines");
twoLines.encode(encoder, x);
}
public static void main(String[] arg) throws Exception {
FileOutputStream fos = new FileOutputStream(arg[0]);
Encoder example = new Encoder(fos);
example.doEncode();
fos.close();
}
}
examples/user_types/ExampleDecoder.cs 0 → 100644
View file @ d3921882
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using se.lth.control.labcomm2014;
namespace user_types
{
class Decoder : twoLines.Handler,
twoInts.Handler,
theFirstInt.Handler,
theSecondInt.Handler,
doavoid.Handler,
intAndRef.Handler
{
DecoderChannel dec;
public Decoder(Stream stream)
{
dec = new DecoderChannel(stream);
twoLines.register(dec, this);
twoInts.register(dec, this);
theFirstInt.register(dec, this);
theSecondInt.register(dec, this);
doavoid.register(dec, this);
intAndRef.register(dec, this);
doavoid.registerSampleRef(dec);
try
{
Console.WriteLine("Running decoder.");
dec.run();
}
catch (EndOfStreamException)
{
Console.WriteLine("EOF reached");
}
}
private string genPoint(point p)
{
return "(" + p.x.val + ", " + p.y.val + ")";
}
private String genLine(line l)
{
return "Line from " + genPoint(l.start) + " to " + genPoint(l.end);
}
public void handle(twoLines d)
{
Console.WriteLine("Got twoLines: ");
Console.WriteLine("Line l1: "+genLine(d.l1));
Console.WriteLine("Line l2: " + genLine(d.l2));
}
public void handle(twoInts d)
{
Console.WriteLine("Got twoInts: ");
Console.WriteLine("a: "+d.a);
Console.WriteLine("b: "+d.b);
}
void theFirstInt.Handler.handle(int d)
{
Console.WriteLine("Got theFirstInt: "+d);
}
void theSecondInt.Handler.handle(int d)
{
Console.WriteLine("Got theSecondInt: "+d);
}
void doavoid.Handler.handle()
{
Console.WriteLine("Got a void.");
}
void intAndRef.Handler.handle(intAndRef d)
{
Console.WriteLine("Got intAndRef: "+d.x+" : "+d.reference);
}
static void Main(string[] args)
{
new Decoder(new FileStream(args[0], FileMode.Open));
}
}
}
examples/user_types/ExampleEncoder.cs 0 → 100644
View file @ d3921882
using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using se.lth.control.labcomm2014;
namespace user_types
{
public class Encoder
{
private EncoderChannel enc;
public Encoder(Stream stream)
{
enc = new EncoderChannel(stream);
twoLines.register(enc);
}
public void doEncode()
{
twoLines x = new twoLines();
line l1 = new line();
point p11 = new point();
coord c11x = new coord();
coord c11y = new coord();
c11x.val = 11;
c11y.val = 99;
p11.x = c11x;
p11.y = c11y;
l1.start = p11;
point p12 = new point();
coord c12x = new coord();
coord c12y = new coord();
c12x.val = 22;
c12y.val = 88;
p12.x = c12x;
p12.y = c12y;
l1.end = p12;
line l2 = new line();
point p21 = new point();
coord c21x = new coord();
coord c21y = new coord();
c21x.val = 17;
c21y.val = 42;
p21.x = c21x;
p21.y = c21y;
l2.start = p21;
point p22 = new point();
coord c22x = new coord();
coord c22y = new coord();
c22x.val = 13;
c22y.val = 37;
p22.x = c22x;
p22.y = c22y;
l2.end = p22;
foo f = new foo();
f.a = 10;
f.b = 20;
f.c = false;
x.l1 = l1;
x.l2 = l2;
x.f = f;
Console.WriteLine("Encoding theTwoLines");
twoLines.encode(enc, x);
}
static void Main(string[] args)
{
FileStream stream = new FileStream(args[0],FileMode.Create);
Encoder example = new Encoder(stream);
example.doEncode();
stream.Close();
}
}
}
examples/user_types/Makefile 0 → 100644
View file @ d3921882
LCDIR=../..
LCCJAR=${LCDIR}/compiler/labcomm2014_compiler.jar# the LabComm compiler
LCLJAR=${LCDIR}/lib/java/labcomm2014.jar# the LabComm library
EXECUTABLES=example_encoder example_decoder \
Encoder.class Decoder.class TDDecoder.class \
TestDataType.class \
ExampleEncoder.exe ExampleDecoder.exe
include ${LCDIR}/lib/c/os_compat.mk
GENDIR=gen
.PHONY: all cleanbuild clean distclean build run allall buildcs runwcs runjastadd
all: cleanbuild run
allall: clean build buildcs runwcs
test: allall
###############################################
### dependencies and parts ####################
###############################################
LCC=java -jar ${LCCJAR}
CLASSPATH=.:${LCLJAR}
${LCCJAR} :
$MAKE -C ${LCDIR} make-compiler
${LCLJAR} :
$MAKE -C ${LCDIR} labcomm2014.jar
cleanbuild: clean build
labcomm2014.dll:
ln -sf ../../lib/csharp/labcomm2014.dll $@
ExampleEncoder.exe: ExampleEncoder.cs gen/test.cs labcomm2014.dll Makefile
mcs -out:$@ $(filter %.cs, $^) -lib:../../lib/csharp/ -r:labcomm2014
chmod a+x $@
ExampleDecoder.exe: ExampleDecoder.cs gen/test.cs labcomm2014.dll Makefile
mcs -out:$@ $(filter %.cs, $^) -lib:../../lib/csharp/ -r:labcomm2014
chmod a+x $@
build :
mkdir -p ${GENDIR}
java -jar ${LCDIR}/compiler/labcomm2014_compiler.jar --java=${GENDIR} --c=${GENDIR}/test.c --h=${GENDIR}/test.h --python=${GENDIR}/test.py --cs=${GENDIR}/test.cs test.lc
javac -cp ${LCDIR}/lib/java/labcomm2014.jar:. ${GENDIR}/*.java Encoder.java Decoder.java
javac -cp ${LCDIR}/lib/java/labcomm2014.jar:${LCCJAR}:${GENDIR}:. TDDecoder.java
javac -cp ${LCDIR}/lib/java/labcomm2014.jar:${LCCJAR}:${GENDIR}:. TestDataType.java
${CC} ${CFLAGS} ${LDFLAGS} -Wall -Werror -Wno-unused-function \
-I. -I${LCDIR}/lib/c/2014 -L${LCDIR}/lib/c \
-o example_encoder example_encoder.c ${GENDIR}/test.c \
-llabcomm2014
${CC} ${CFLAGS} ${LDFLAGS} -Wall -Werror -I . -I ${LCDIR}/lib/c/2014 -L${LCDIR}/lib/c \
-o example_decoder example_decoder.c ${GENDIR}/test.c \
-llabcomm2014
buildcs: ExampleEncoder.exe ExampleDecoder.exe
run:
@echo
@echo "********************************************"
@echo "*** ************ running example for version 2014 ***"
@echo "********************************************"
@echo
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Encoder encoded_data_j
@echo "************ running Java decoder: *****************"
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_j
@echo "************ running C decoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_j
@echo "************ running python decoder (from wiki_example):"
@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_j LabComm2014
@echo "************ running python decoder (with handlers):"
@PYTHONPATH=${LCDIR}/lib/python:gen:. ./example_handlers.py encoded_data_j LabComm2014
@echo "************ running C encoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_encoder encoded_data_c
@echo "************ running Java decoder: *****************"
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_c
@echo "************ running C decoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_c
@echo "************ running python decoder (from wiki_example):"
@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_c LabComm2014
@echo "************ running python decoder (with handlers):"
@PYTHONPATH=${LCDIR}/lib/python:gen:. ./example_handlers.py encoded_data_j LabComm2014
@echo "************ running python encoder: *****************"
@PYTHONPATH=${LCDIR}/lib/python:${GENDIR} ./example_encoder.py encoded_data_p LabComm2014
@echo "************ running Java decoder: *****************"
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_p
@echo "************ running C decoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_p
@echo "************ running python decoder (from wiki_example):"
PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_p LabComm2014
@echo "************ running python decoder (with handlers):"
@PYTHONPATH=${LCDIR}/lib/python:gen:. ./example_handlers.py encoded_data_j LabComm2014
runwcs: build ExampleEncoder.exe ExampleDecoder.exe
@echo
@echo "********************************************"
@echo "*** ************ running example for version 2014 ***"
@echo "********************************************"
@echo
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Encoder encoded_data_j
@echo "************ running Java decoder: *****************"
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_j
@echo "************ running C decoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_j
@echo "************ running python decoder (from wiki_example):"
@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_j LabComm2014
@echo "************ running C# decoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ mono ./ExampleDecoder.exe encoded_data_j
@echo "************ running C encoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_encoder encoded_data_c
@echo "************ running Java decoder: *****************"
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_c
@echo "************ running C decoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_c
@echo "************ running python decoder (from wiki_example):"
@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_c LabComm2014
@echo "************ running C# decoder: *****************"
@mono ./ExampleDecoder.exe encoded_data_c
@echo "************ running python encoder: *****************"
@PYTHONPATH=${LCDIR}/lib/python:${GENDIR} ./example_encoder.py encoded_data_p LabComm2014
@echo "************ running Java decoder: *****************"
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_p
@echo "************ running C decoder: *****************"
@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_p
@echo "************ running C# decoder: *****************"
@mono ./ExampleDecoder.exe encoded_data_p
@echo "************ running python decoder (from wiki_example):"
PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_p LabComm2014
@echo "************ running C# encoder: *****************"
@mono ./ExampleEncoder.exe encoded_data_cs
@echo "************ running Java decoder: *****************"
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_cs
@echo "************ running C decoder: *****************"
@LD_LIBRARY_PATH=${LCDIR}/lib/c/ ./example_decoder encoded_data_cs
@echo "************ running python decoder (from wiki_example):"
@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_cs LabComm2014
@echo "************ running C# decoder: *****************"
@mono ./ExampleDecoder.exe encoded_data_cs
runjastadd: cleanbuild
@echo
@echo "********************************************"
@echo "*** ************ running example with JastAdd unparsing ***"
@echo "********************************************"
@echo
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Encoder encoded_data_j
@echo "************ running Java TypeDefdecoder: *****************"
java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${LCCJAR}:${GENDIR} TDDecoder encoded_data_j
rundatatype: cleanbuild
@echo
@echo "********************************************"
@echo "*************** running datatype example ***"
@echo "********************************************"
@echo
@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} TestDataType
clean:
rm -rf ${GENDIR}
distclean: clean
rm -f ${EXECUTABLES}
rm -f encoded_data_c
rm -f encoded_data_cs
rm -f encoded_data_j
rm -f encoded_data_p
rm -f labcomm.dll
examples/user_types/TDDecoder.java 0 → 100644
View file @ d3921882
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import se.lth.control.labcomm2014.DecoderChannel;
import se.lth.control.labcomm2014.TypeDef;
import se.lth.control.labcomm2014.TypeDefParser;
import se.lth.control.labcomm2014.SigTypeDef;
import se.lth.control.labcomm2014.ParsedSampleDef;
import se.lth.control.labcomm2014.ASTbuilder;
//import se.lth.control.labcomm2014.TypeBinding;
import se.lth.control.labcomm2014.DataType;
import se.lth.control.labcomm2014.compiler.Specification;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.Vector;
import java.util.LinkedList;
import java.util.Iterator;
public class TDDecoder
implements twoLines.Handler,
// TypeDef.Handler,
// TypeBinding.Handler,
TypeDefParser.TypeDefListener,
twoInts.Handler,
theFirstInt.Handler,
theSecondInt.Handler,
doavoid.Handler,
intAndRef.Handler
{
private DecoderChannel decoder;
private TypeDefParser tdp;
public TDDecoder(InputStream in)
throws Exception
{
decoder = new DecoderChannel(in);
twoInts.register(decoder, this);
twoLines.register(decoder, this);
theFirstInt.register(decoder, this);
theSecondInt.register(decoder, this);
doavoid.register(decoder, this);
intAndRef.register(decoder, this);
doavoid.registerSampleRef(decoder);
this.tdp = TypeDefParser.registerTypeDefParser(decoder);
// TypeDef.register(decoder, this);
// TypeBinding.register(decoder, this);
tdp.addListener(this);
try {
System.out.println("Running decoder.");
decoder.run();
} catch (java.io.EOFException e) {
System.out.println("Decoder reached end of file.");
}
}
private String genPoint(point p) {
return "("+p.x.val+", "+p.y.val+")";
}
private String genLine(line l) {
return "Line from "+genPoint(l.start)+" to "+genPoint(l.end);
}
// public void handle_TypeDef(TypeDef d) throws java.io.IOException {
// System.out.println("Got TypeDef: "+d.getName()+"("+d.getIndex()+")");
// }
//
// public void handle_TypeBinding(TypeBinding d) throws java.io.IOException {
// System.out.println("Got TypeBinding: "+d.getSampleIndex()+" --> "+d.getTypeIndex()+"");
// }
public void onTypeDef(SigTypeDef d) {
if(d != null && d.isSampleDef()){
System.out.println("onTypeDef (sample): ");
//------------
try {
System.out.println("==================== DataType ======");
DataType.printDataType(System.out, d);
System.out.println();
System.out.println("==================== end ======");
} catch (IOException ioe) {
ioe.printStackTrace();
}
ASTbuilder v = new ASTbuilder();
Specification p = v.makeSpecification((ParsedSampleDef) d);
try {
FileOutputStream f = new FileOutputStream("/tmp/foopp"+d.getName()+".txt");
PrintStream out = new PrintStream(f);
p.pp(System.out);
//p.C_genC(System.out, new Vector(), "lcname", "prefix", 2014);
p.J_gen(out, "testpackage", 2014);
out.close();
} catch (Throwable e) {
System.err.println("Exception: " + e);
e.printStackTrace();
}
}
//System.out.println(" "+d.getName()+";");
//for(byte b: d.getSignature()) {
// System.out.print(Integer.toHexString(b)+" ");
//}
//System.out.println();
//try {
// tdp.parseSignature(d.getIndex());
//} catch(IOException ex) { ex.printStackTrace();}
}
public void handle_twoInts(twoInts d) throws java.io.IOException {
System.out.print("Got twoInts: ");
System.out.println(d.a +", "+d.b);
}
public void handle_theFirstInt(int d) throws java.io.IOException {
System.out.println("Got theFirstInt: "+d);
}
public void handle_theSecondInt(int d) throws java.io.IOException {
System.out.println("Got theSecondInt: "+d);
}
public void handle_doavoid() throws java.io.IOException {
System.out.println("Got a void.");
}
public void handle_intAndRef(intAndRef d) throws java.io.IOException {
System.out.println("Got intAndRef: "+d.x+", "+d.reference);
}
public void handle_twoLines(twoLines d) throws java.io.IOException {
System.out.print("Got twoLines: ");
System.out.println("Line l1: "+genLine(d.l1));
System.out.println(" Line l2: "+genLine(d.l2));
}
public static void main(String[] arg) throws Exception {
TDDecoder example = new TDDecoder(
new FileInputStream(new File(arg[0]))
);
}
}
examples/user_types/TestDataType.java 0 → 100644
View file @ d3921882
import java.io.PrintStream;
import se.lth.control.labcomm2014.*;
/**
* Test data type tree
*/
public class TestDataType
{
private PrintStream out;
public TestDataType(PrintStream out)
throws Exception
{
this.out = out;
}
public void doTest() throws java.io.IOException {
twoLines x = new twoLines();
DataType.printDataType(out, x.getDispatcher());
twoStructsAndInt y = new twoStructsAndInt();
DataType.printDataType(out, y.getDispatcher());
theFirstInt z = new theFirstInt();
DataType.printDataType(out, z.getDispatcher());
doavoid a = new doavoid();
DataType.printDataType(out, a.getDispatcher());
}
public static void main(String[] arg) throws Exception {
TestDataType example = new TestDataType(System.out);
example.doTest();
}
}
examples/user_types/example_decoder.c 0 → 100644
View file @ d3921882
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <labcomm2014_fd_reader.h>
#include <labcomm2014_default_error_handler.h>
#include <labcomm2014_default_memory.h>
#include <labcomm2014_default_scheduler.h>
#include "gen/test.h"
#include <stdio.h>
static void handle_test_doavoid(test_doavoid *v,void *context) {
printf("Got a void.\n");
}
static void handle_test_intAndRef(test_intAndRef *v,void *context) {
printf("Got intAndRef. (%d : %p) \n", v->x, v->reference);
}
static void handle_test_twoInts(test_twoInts *v,void *context) {
printf("Got twoInts. (%d,%d) \n", v->a, v->b);
}
static void handle_test_theFirstInt(int *v,void *context) {
printf("Got theFirstInt. (%d) \n", *v);
}
static void handle_test_theSecondInt(int *v,void *context) {
printf("Got theSecondInt. (%d) \n", *v);
}
static void handle_type_def(struct labcomm2014_raw_type_def *v,void *context) {
printf("Got type_def. (0x%x) %s\n", v->index, v->name);
}
static void handle_type_binding(struct labcomm2014_type_binding *v,void *context) {
printf("Got type binding. 0x%x --> 0x%x\n", v->sample_index, v->type_index);
}
static void handle_test_twoLines(test_twoLines *v,void *context) {
printf("Got twoLines. (%d,%d) -> (%d,%d), (%d,%d) -> (%d,%d)\n", v->l1.start.x.val, v->l1.start.y.val,
v->l1.end.x.val, v->l1.end.y.val,
v->l2.start.x.val, v->l2.start.y.val,
v->l2.end.x.val, v->l2.end.y.val);
}
int main(int argc, char *argv[]) {
int fd;
struct labcomm2014_decoder *decoder;
void *context = NULL;
char *filename = argv[1];
printf("C decoder reading from %s\n", filename);
fd = open(filename, O_RDONLY);
decoder = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
labcomm2014_default_memory, fd, 1),
labcomm2014_default_error_handler,
labcomm2014_default_memory,
labcomm2014_default_scheduler);
if (!decoder) {
printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
return 1;
}
labcomm2014_decoder_register_test_doavoid(decoder, handle_test_doavoid, context);
labcomm2014_decoder_register_test_intAndRef(decoder, handle_test_intAndRef, context);
labcomm2014_decoder_sample_ref_register(decoder,labcomm2014_signature_test_doavoid );
labcomm2014_decoder_register_test_twoInts(decoder, handle_test_twoInts, context);
labcomm2014_decoder_register_test_theFirstInt(decoder, handle_test_theFirstInt, context);
labcomm2014_decoder_register_test_theSecondInt(decoder, handle_test_theSecondInt, context);
labcomm2014_decoder_register_test_twoLines(decoder, handle_test_twoLines, context);
labcomm2014_decoder_register_labcomm2014_type_def(decoder, handle_type_def, context);
labcomm2014_decoder_register_labcomm2014_type_binding(decoder, handle_type_binding, context);
printf("Decoding:\n");
labcomm2014_decoder_run(decoder);
printf("--- End Of File ---:\n");
labcomm2014_decoder_free(decoder);
return 0;
}
examples/user_types/example_encoder.c 0 → 100644
View file @ d3921882
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <labcomm2014_fd_writer.h>
#include <labcomm2014_default_error_handler.h>
#include <labcomm2014_default_memory.h>
#include <labcomm2014_default_scheduler.h>
#include "gen/test.h"
#include <stdio.h>
int main(int argc, char *argv[]) {
int fd;
struct labcomm2014_encoder *encoder;
char *filename = argv[1];
printf("C encoder writing to %s\n", filename);
fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);
encoder = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
labcomm2014_default_memory, fd, 1),
labcomm2014_default_error_handler,
labcomm2014_default_memory,
labcomm2014_default_scheduler);
labcomm2014_encoder_register_test_twoLines(encoder);
test_twoLines tl;
tl.l1.start.x.val = 11;
tl.l1.start.y.val = 13;
tl.l1.end.x.val = 21;
tl.l1.end.y.val = 23;
tl.l2.start.x.val = 11;
tl.l2.start.y.val = 13;
tl.l2.end.x.val = 21;
tl.l2.end.y.val = 23;
printf("Encoding twoLines...\n");
labcomm2014_encode_test_twoLines(encoder, &tl);
return 0;
}
examples/user_types/example_encoder.py 0 → 100755
View file @ d3921882
#!/usr/bin/python
import labcomm2014
import sys
import test
if __name__ == '__main__':
version = sys.argv[2] if len(sys.argv) == 3 else "LabComm2014"
encoder = labcomm2014.Encoder(labcomm2014.StreamWriter(open(sys.argv[1], 'w')), version)
encoder.add_decl(test.twoLines.signature)
tl = {
(('','l1'),):{
(('','start'),):{
(('','x'),):{(('','val'),):1},
(('','y'),):{(('','val'),):11}
},
(('','end'),):{
(('','x'),):{(('','val'),):2},
(('','y'),):{(('','val'),):22}
}
},
(('','l2'),):{
(('','start'),):{
(('','x'),):{(('','val'),):3},
(('','y'),):{(('','val'),):33}
},
(('','end'),):{
(('','x'),):{(('','val'),):4},
(('','y'),):{(('','val'),):44}
}
},
(('','f'),):{
(('','a'),):10,
(('','b'),):20,
(('','c'),):False
}
}
encoder.encode(tl, test.twoLines.signature)
examples/user_types/example_handlers.py 0 → 100755
View file @ d3921882
#!/usr/bin/python
import labcomm2014
import sys,traceback
import test
def handle_twoInts(val):
print "got twoInts: %s" % val
def handle_twoLines(val):
print "got twoLines: %s" % val
if __name__ == "__main__":
version = sys.argv[2] if len(sys.argv) == 3 else "LabComm2014"
d = labcomm2014.Decoder(labcomm2014.StreamReader(open(sys.argv[1])), version)
d.register_handler(test.twoInts.signature, handle_twoInts)
d.register_handler(test.twoLines.signature, handle_twoLines)
while True:
try:
d.runOne()
except EOFError:
print "got EOF"
break
except Exception, e:
print "got Exception"
print e
traceback.print_exc()
break
examples/user_types/test.lc 0 → 100644
View file @ d3921882
typedef struct {
(foo:bar) int val;
} coord;
typedef int anInt;
typedef void avoid;
sample (function:"a trigger")(foo:bar) avoid doavoid;
sample (a:b) "A struct: an int and a ref." struct {
(e:f)(c:d) int x;
sample reference;
} intAndRef;
typedef struct {
coord x;
coord y;
} point;
typedef struct {
point start;
point end;
} line;
typedef struct {
int a;
int b;
boolean c;
} foo;
sample struct {
(name:l1)line l1;
(name:l2)line l2;
(b:"kalle anka")(c:hejdu)(a:"kalle anka")foo f;
} twoLines;
sample struct {
int a;
int b;
} twoInts;
sample anInt theFirstInt;
sample anInt theSecondInt;
sample struct {
struct {
int x;
int y;
} s1;
struct {
int a;
int b;
} s2;
int i;
double double_array[2,3,_][3][_];
} twoStructsAndInt;
examples/wiki_example/.gitignore 0 → 100644
View file @ d3921882
data.java
example.c
example.cs
example.encoded
example.h
example.javaencoded
example.py
example_encoder
log_message.java
examples/wiki_example/Makefile 0 → 100644
View file @ d3921882
GENERATED=\
data.java \
example.c \
example.cs \
example.encoded \
example.h \
example.javaencoded \
example.py \
example_encoder \
log_message.java
all:
test:
./run
clean:
rm -f $(GENERATED) *.class
distclean: clean