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 1776 additions and 137 deletions
lib/c/2014/labcomm2014_compat_osx.h 0 → 100644
View file @ d3921882
#ifndef __APPLE__
#error "__APPLE__" not defined
#endif
#ifndef LABCOMM_COMPAT_OSX
#define LABCOMM_COMPAT_OSX
#include <machine/endian.h>
#include <stdio.h>
#include <time.h>
#include <mach/clock.h>
#include <mach/mach.h>
#define CLOCK_REALTIME 0
static inline void clock_gettime(int garbage, struct timespec *ts)
{
(void) garbage;
clock_serv_t cclock;
mach_timespec_t mts;
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
clock_get_time(cclock, &mts);
mach_port_deallocate(mach_task_self(), cclock);
ts->tv_sec = mts.tv_sec;
ts->tv_nsec = mts.tv_nsec;
}
#endif
lib/c/labcomm_compat_vxworks.h → lib/c/2014/labcomm2014_compat_vxworks.h
View file @ d3921882
#ifndef _LABCOMM_COMPAT_VXWORKS_H_
#define _LABCOMM_COMPAT_VXWORKS_H_
#ifndef __VXWORKS__
#error "__VXWORKS__" not defined
#endif
#include <types/vxTypes.h>
#include <selectLib.h>
#include <types.h>
#include <timers.h>
#include <stdio.h>
#include <private/stdioP.h>
#ifdef __INT64_MAX__
#undef INT64_MAX
#define INT64_MAX __INT64_MAX__
#endif
#if (CPU == PPC603)
#undef _LITTLE_ENDIAN
#endif
......@@ -10,3 +25,6 @@
#undef _BIG_ENDIAN
#endif
extern unsigned int cpuFrequency;
#endif
lib/c/2014/labcomm2014_decoder.c 0 → 100644
View file @ d3921882
/*
labcomm2014_decoder.c -- runtime for handling decoding of labcomm2014 samples.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define CURRENT_VERSION "LabComm2014"
#include <errno.h>
#include "labcomm2014.h"
#include "labcomm2014_private.h"
#include "labcomm2014_ioctl.h"
#include "labcomm2014_dynamic_buffer_writer.h"
#ifdef DEBUG
#define DEBUG_FPRINTF(str, ...) fprintf(str, ##__VA_ARGS__)
#else
#define DEBUG_FPRINTF(str, ...)
#endif
#ifdef DECODER_DEBUG
#define DECODER_DEBUG_FPRINTF(str, ...) fprintf(str, ##__VA_ARGS__)
#else
#define DECODER_DEBUG_FPRINTF(str, ...)
#endif
struct sample_entry {
int remote_index;
const struct labcomm2014_signature *signature;
labcomm2014_decoder_function decode;
labcomm2014_handler_function handler;
void *context;
};
struct decoder {
struct labcomm2014_decoder decoder;
LABCOMM_SIGNATURE_ARRAY_DEF(local, struct sample_entry);
LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local, int);
LABCOMM_SIGNATURE_ARRAY_DEF(local_ref, const struct labcomm2014_signature *);
LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local_ref, int);
};
static int handle_sample_def(struct labcomm2014_decoder *d, int remote_index,
const struct labcomm2014_signature *signature)
{
struct decoder *id = d->context;
int result;
int i;
const struct labcomm2014_signature *local_signature = NULL;
int local_index = 0;
labcomm2014_scheduler_data_lock(d->scheduler);
LABCOMM_SIGNATURE_ARRAY_FOREACH(id->local, struct sample_entry, i) {
struct sample_entry *s;
int *remote_to_local;
result = -ENOENT;
s = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->local, struct sample_entry, i);
if (s->signature &&
s->signature->size == signature->size &&
strcmp(s->signature->name, signature->name) == 0 &&
memcmp((void*)s->signature->signature, (void*)signature->signature,
signature->size) == 0) {
s->remote_index = remote_index;
local_signature = s->signature;
local_index = i;
remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->remote_to_local, int,
remote_index);
*remote_to_local = i;
result = remote_index;
break;
}
}
labcomm2014_scheduler_data_unlock(d->scheduler);
if (local_signature) {
labcomm2014_reader_start(d->reader, d->reader->action_context,
local_index, remote_index, local_signature,
NULL);
labcomm2014_reader_end(d->reader, d->reader->action_context);
}
return result;
}
static int handle_sample_ref(struct labcomm2014_decoder *d, int remote_index,
const struct labcomm2014_signature *signature)
{
struct decoder *id = d->context;
int result;
int i;
labcomm2014_scheduler_data_lock(d->scheduler);
LABCOMM_SIGNATURE_ARRAY_FOREACH(id->local_ref,
const struct labcomm2014_signature *, i) {
const struct labcomm2014_signature *s;
int *remote_to_local_ref;
result = -ENOENT;
s = LABCOMM_SIGNATURE_ARRAY_GET(id->local_ref, const struct labcomm2014_signature *, i, 0);
if (s &&
s->signature &&
s->size == signature->size &&
strcmp(s->name, signature->name) == 0 &&
memcmp((void*)s->signature, (void*)signature->signature, signature->size) == 0) {
remote_to_local_ref = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->remote_to_local_ref,
int,
remote_index);
*remote_to_local_ref = i;
result = remote_index;
break;
}
}
labcomm2014_scheduler_data_unlock(d->scheduler);
return result;
}
static int reader_skip(struct labcomm2014_reader *r, int len, int tag)
{
int i;
DECODER_DEBUG_FPRINTF(stdout, "got tag 0x%x, skipping %d bytes\n", tag, len);
for(i = 0; i <len; i++){
DECODER_DEBUG_FPRINTF(stderr, ".");
labcomm2014_read_byte(r);
if (r->error < 0) {
DECODER_DEBUG_FPRINTF(stderr, "\nerror while skipping: %d\n", r->error);
return r->error;
}
}
DECODER_DEBUG_FPRINTF(stderr, "\n");
return tag;
}
static char* TODO_read_intentions(struct labcomm2014_reader *r)
{
int numInts = labcomm2014_read_byte(r);
int i;
char *name=NULL;
printf("TODO_read_intentions: numInts=%d\n", numInts);
for(i=0; i <numInts; i++){
int klen = labcomm2014_read_packed32(r);
printf("TODO_read_intentions: klen=%d\n", klen);
if(klen == 0) {
name = labcomm2014_read_string(r);
printf("TODO_read_intentions: name=%s\n", name);
}else{
int vlen;
reader_skip(r, klen, 1);
vlen = labcomm2014_read_packed32(r);
reader_skip(r, vlen, 1);
printf("TODO_read_intentions: skipping value, %d bytes\n", vlen);
}
}
return name;
}
static int decode_sample_def_or_ref(struct labcomm2014_decoder *d, int kind)
{
int result;
struct labcomm2014_signature signature;
int i, remote_index;
remote_index = labcomm2014_read_packed32(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
signature.name = TODO_read_intentions(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto free_signature_name;
}
signature.size = labcomm2014_read_packed32(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto free_signature_name;
}
signature.signature = labcomm2014_memory_alloc(d->memory, 1, signature.size);
if (d->reader->error < 0) {
result = d->reader->error;
goto free_signature_name;
}
for (i = 0 ; i < signature.size ; i++) {
signature.signature[i] = labcomm2014_read_byte(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto free_signature_signature;
}
}
switch (kind) {
case LABCOMM_SAMPLE_DEF: {
result = handle_sample_def(d, remote_index, &signature);
break;
}
case LABCOMM_SAMPLE_REF: {
result = handle_sample_ref(d, remote_index, &signature);
if (result == -ENOENT) {
/* Dummy value to silently continue */
result = LABCOMM_SAMPLE_REF;
}
break;
}
default:
result = -EINVAL;
}
free_signature_signature:
labcomm2014_memory_free(d->memory, 1, signature.signature);
free_signature_name:
if (signature.name) {
if (result == -ENOENT) {
labcomm2014_error_warning(d->error,
LABCOMM2014_ERROR_DEC_NO_REG_SIGNATURE,
"Signature not found: %s\n",
signature.name);
}
labcomm2014_memory_free(d->memory, 0, signature.name);
}
out:
return result;
}
struct call_handler_context {
struct labcomm2014_reader *reader;
int local_index;
int remote_index;
const struct labcomm2014_signature *signature;
labcomm2014_handler_function handler;
void *context;
};
static void call_handler(void *value, void *context)
{
struct call_handler_context *wrap = context;
if (wrap->reader->error >= 0) {
labcomm2014_reader_start(wrap->reader, wrap->reader->action_context,
wrap->local_index, wrap->remote_index, wrap->signature,
value);
wrap->handler(value, wrap->context);
labcomm2014_reader_end(wrap->reader, wrap->reader->action_context);
}
}
static void reader_alloc(struct labcomm2014_decoder *d)
{
if (!d->reader_allocated) {
d->reader_allocated = 1;
labcomm2014_reader_alloc(d->reader, d->reader->action_context);
}
}
/* d - decoder to read from
registry - decoder to lookup signatures (registry != d only if
nesting decoders, e.g., when decoding pragma)
len - length of the labcomm2014 packet )
*/
static int decode_pragma(struct labcomm2014_decoder *d,
struct labcomm2014_decoder *registry,
int len)
{
char *pragma_type;
int result;
pragma_type = labcomm2014_read_string(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
int bytes = labcomm2014_size_string(pragma_type);
int psize = len-bytes;
result = reader_skip(d->reader, psize, LABCOMM_PRAGMA);
out:
return result;
}
static labcomm2014_decoder_function lookup_h(struct labcomm2014_decoder *d,
struct call_handler_context *wrap,
int remote_index,
int *r_local_index)
{
struct decoder *id = d->context;
labcomm2014_decoder_function do_decode = NULL;
int *local_index;
labcomm2014_scheduler_data_lock(d->scheduler);
local_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->remote_to_local, int,
remote_index);
*r_local_index = *local_index;
if (*local_index != 0) {
struct sample_entry *entry;
entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->local, struct sample_entry,
*local_index);
wrap->local_index = *local_index;
wrap->signature = entry->signature;
wrap->handler = entry->handler;
wrap->context = entry->context;
do_decode = entry->decode;
}
labcomm2014_scheduler_data_unlock(d->scheduler);
return do_decode;
}
/* d - decoder to read from
registry - decoder to lookup signatures (registry != d only if
nesting decoders, e.g., when decoding pragma)
remote_index - received type index )
*/
static int decode_and_handle(struct labcomm2014_decoder *d,
struct labcomm2014_decoder *registry,
int remote_index)
{
int result;
int local_index;
struct call_handler_context wrap = {
.reader = d->reader,
.remote_index = remote_index,
.signature = NULL,
.handler = NULL,
.context = NULL,
};
labcomm2014_decoder_function do_decode = lookup_h(registry, &wrap, remote_index, &local_index);
result = local_index;
if (do_decode) {
do_decode(d->reader, call_handler, &wrap);
if (d->reader->error < 0) {
result = d->reader->error;
}
} else {
result = -ENOENT;
}
return result;
}
int labcomm2014_decoder_decode_one(struct labcomm2014_decoder *d)
{
return d->decode_one(d);
}
static int do_decode_one(struct labcomm2014_decoder *d)
{
int result, remote_index, length;
reader_alloc(d);
remote_index = labcomm2014_read_packed32(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
length = labcomm2014_read_packed32(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
if (remote_index == LABCOMM_VERSION) {
char *version = labcomm2014_read_string(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
} else if (strcmp(version, CURRENT_VERSION) == 0) {
result = LABCOMM_VERSION;
d->version_ok = 1;
} else {
result = -ECONNRESET;
}
labcomm2014_memory_free(d->memory, 1, version);
if (result < 0) {
goto out;
}
} else if (! d->version_ok) {
DEBUG_FPRINTF(stderr, "No VERSION %d %d\n", remote_index, length);
result = -ECONNRESET;
} else if (remote_index == LABCOMM_SAMPLE_DEF) {
result = decode_sample_def_or_ref(d, LABCOMM_SAMPLE_DEF);
} else if (remote_index == LABCOMM_SAMPLE_REF) {
result = decode_sample_def_or_ref(d, LABCOMM_SAMPLE_REF);
} else if (remote_index == LABCOMM_TYPE_DEF) {
result = decode_and_handle(d, d, remote_index);
if(result == -ENOENT) {
//No handler for type_defs, skip
result = reader_skip(d->reader, length, remote_index);
}
} else if (remote_index == LABCOMM_TYPE_BINDING) {
result = decode_and_handle(d, d, remote_index);
if(result == -ENOENT) {
//No handler for type_bindings, skip
result = reader_skip(d->reader, length, remote_index);
}
} else if (remote_index == LABCOMM_PRAGMA) {
result = decode_pragma(d, d, length);
} else if (remote_index < LABCOMM_USER) {
DECODER_DEBUG_FPRINTF(stderr, "SKIP %d %d\n", remote_index, length);
result = reader_skip(d->reader, length, remote_index);
} else {
result = decode_and_handle(d, d, remote_index);
}
out:
return result;
}
void labcomm2014_decoder_run(struct labcomm2014_decoder *d)
{
while (labcomm2014_decoder_decode_one(d) > 0) {
}
}
int labcomm2014_decoder_ioctl(struct labcomm2014_decoder *d,
uint32_t action,
...)
{
int result;
va_list va;
va_start(va, action);
result = d->ioctl(d, NULL, action, va);
va_end(va);
return result;
}
int labcomm2014_decoder_sample_ref_register(
struct labcomm2014_decoder *d,
const struct labcomm2014_signature *signature)
{
return d->ref_register(d, signature);
}
static int do_ref_register(
struct labcomm2014_decoder *d,
const struct labcomm2014_signature *signature)
{
struct decoder *id = d->context;
int local_index, *remote_to_local_ref;
const struct labcomm2014_signature **s;
local_index = labcomm2014_get_local_index(signature);
if (local_index <= 0) { goto out; }
labcomm2014_scheduler_data_lock(d->scheduler);
s = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->local_ref,
const struct labcomm2014_signature*, local_index);
if (s == NULL) { local_index = -ENOMEM; goto unlock; };
if (*s) { goto unlock; }
*s = signature;
remote_to_local_ref = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->remote_to_local_ref,
int, local_index);
*remote_to_local_ref = 0;
unlock:
labcomm2014_scheduler_data_unlock(d->scheduler);
out:
return local_index;
}
static int do_ioctl(struct labcomm2014_decoder *d,
const struct labcomm2014_signature *signature,
uint32_t action, va_list va)
{
struct decoder *id = d->context;
int result;
int local_index, remote_index;
local_index = labcomm2014_get_local_index(signature);
if (local_index == 0) {
remote_index = 0;
} else {
labcomm2014_scheduler_data_lock(d->scheduler);
remote_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->local,
struct sample_entry,
local_index)->remote_index;
labcomm2014_scheduler_data_unlock(d->scheduler);
}
result = labcomm2014_reader_ioctl(d->reader, d->reader->action_context,
local_index, remote_index,
signature, action, va);
return result;
}
#ifndef LABCOMM_NO_TYPEDECL
//// Code for allowing user code to handle type_defs
//// (should perhaps be moved to another file)
static void decode_raw_type_def(
struct labcomm2014_reader *r,
void (*handle)(
struct labcomm2014_raw_type_def *v,
void *context
),
void *context
)
{
struct labcomm2014_raw_type_def v;
v.index = labcomm2014_read_packed32(r);
if (r->error < 0) { goto out; }
v.name = TODO_read_intentions(r);
if (r->error < 0) { goto free_name; }
v.length = labcomm2014_read_packed32(r);
if (r->error < 0) { goto free_name; }
int i;
v.signature_data = labcomm2014_memory_alloc(r->memory, 1, v.length);
if(v.signature_data) {
for(i=0; i<v.length; i++) {
v.signature_data[i] = labcomm2014_read_byte(r);
if (r->error < 0) { goto free_sig; }
}
handle(&v, context);
}
free_sig:
labcomm2014_memory_free(r->memory, 1, v.signature_data);
free_name:
labcomm2014_memory_free(r->memory, 1, v.name);
out:
return;
}
int labcomm2014_decoder_register_labcomm2014_type_def(
struct labcomm2014_decoder *d,
void (*handler)(
struct labcomm2014_raw_type_def *v,
void *context
),
void *context
)
{
struct decoder *id = d->context;
int tag = LABCOMM_TYPE_DEF;
struct sample_entry *entry;
int *remote_to_local;
labcomm2014_scheduler_data_lock(d->scheduler);
entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->local, struct sample_entry,
tag);
if (entry == NULL) { tag = -ENOMEM; goto unlock; }
entry->remote_index = tag;
entry->signature = NULL;
entry->decode = (labcomm2014_decoder_function) decode_raw_type_def;
entry->handler =(labcomm2014_handler_function) handler;
entry->context = context;
remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->remote_to_local, int,
tag);
*remote_to_local = tag;
unlock:
labcomm2014_scheduler_data_unlock(d->scheduler);
return tag;
}
static void decode_type_binding(
struct labcomm2014_reader *r,
void (*handle)(
struct labcomm2014_type_binding *v,
void *context
),
void *context
)
{
struct labcomm2014_type_binding v;
v.sample_index = labcomm2014_read_packed32(r);
if (r->error < 0) { goto out; }
v.type_index = labcomm2014_read_packed32(r);
if (r->error < 0) { goto out; }
handle(&v, context);
out:
return;
}
int labcomm2014_decoder_register_labcomm2014_type_binding(
struct labcomm2014_decoder *d,
void (*handler)(
struct labcomm2014_type_binding *v,
void *context
),
void *context
)
{
struct decoder *id = d->context;
int tag = LABCOMM_TYPE_BINDING;
struct sample_entry *entry;
int *remote_to_local;
labcomm2014_scheduler_data_lock(d->scheduler);
entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->local, struct sample_entry,
tag);
if (entry == NULL) { tag = -ENOMEM; goto unlock; }
entry->remote_index = tag;
entry->signature = NULL;
entry->decode = (labcomm2014_decoder_function) decode_type_binding;
entry->handler =(labcomm2014_handler_function) handler;
entry->context = context;
remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->remote_to_local, int,
tag);
*remote_to_local = tag;
unlock:
labcomm2014_scheduler_data_unlock(d->scheduler);
return tag;
}
//// End type_def handling
#endif
static int do_register_sample(
struct labcomm2014_decoder *d,
const struct labcomm2014_signature *signature,
labcomm2014_decoder_function decode,
labcomm2014_handler_function handler,
void *context)
{
struct decoder *id = d->context;
int local_index;
struct sample_entry *entry;
reader_alloc(d);
local_index = labcomm2014_get_local_index(signature);
if (local_index <= 0) { goto out; }
labcomm2014_reader_start(d->reader, d->reader->action_context,
local_index, 0, signature,
NULL);
labcomm2014_reader_end(d->reader, d->reader->action_context);
labcomm2014_scheduler_data_lock(d->scheduler);
entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
id->local, struct sample_entry,
local_index);
if (entry == NULL) { local_index = -ENOMEM; goto unlock; }
entry->remote_index = 0;
entry->signature = signature;
entry->decode = decode;
entry->handler = handler;
entry->context = context;
unlock:
labcomm2014_scheduler_data_unlock(d->scheduler);
out:
return local_index;
}
static const struct labcomm2014_sample_ref *do_index_to_sample_ref(
struct labcomm2014_decoder *d, int index)
{
const struct labcomm2014_signature *result = 0;
struct decoder *id = d->context;
int local_index;
labcomm2014_scheduler_data_lock(d->scheduler);
local_index = LABCOMM_SIGNATURE_ARRAY_GET(id->remote_to_local_ref,
int, index, 0);
if (local_index) {
result = LABCOMM_SIGNATURE_ARRAY_GET(id->local_ref,
const struct labcomm2014_signature*,
local_index, 0);
}
labcomm2014_scheduler_data_unlock(d->scheduler);
return labcomm2014_signature_to_sample_ref(result);
}
static const struct labcomm2014_sample_ref *do_ref_get(
struct labcomm2014_decoder *d,
const struct labcomm2014_signature *signature)
{
return (const struct labcomm2014_sample_ref *) signature;
}
static void do_free(struct labcomm2014_decoder* d)
{
struct decoder *id = d->context;
struct labcomm2014_memory *memory = d->memory;
labcomm2014_reader_free(d->reader, d->reader->action_context);
LABCOMM_SIGNATURE_ARRAY_FREE(memory, id->local, struct sample_entry);
LABCOMM_SIGNATURE_ARRAY_FREE(memory, id->remote_to_local, int);
LABCOMM_SIGNATURE_ARRAY_FREE(memory, id->local_ref,
const struct labcomm2014_signature*);
LABCOMM_SIGNATURE_ARRAY_FREE(memory, id->remote_to_local_ref, int);
labcomm2014_memory_free(memory, 0, id);
}
void labcomm2014_decoder_free(struct labcomm2014_decoder* d)
{
d->free(d);
}
struct labcomm2014_decoder *labcomm2014_decoder_new(
struct labcomm2014_reader *reader,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler)
{
struct decoder *result;
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result) {
result->decoder.context = result;
result->decoder.reader = reader;
result->decoder.reader->decoder = &result->decoder;
result->decoder.reader->data = 0;
result->decoder.reader->data_size = 0;
result->decoder.reader->count = 0;
result->decoder.reader->pos = 0;
result->decoder.reader->error = 0;
result->decoder.reader_allocated = 0;
result->decoder.version_ok = 0;
result->decoder.error = error;
result->decoder.memory = memory;
result->decoder.scheduler = scheduler;
result->decoder.on_error = labcomm20142014_on_error_fprintf;
result->decoder.free = do_free;
result->decoder.decode_one = do_decode_one;
result->decoder.ref_register = do_ref_register;
result->decoder.sample_register = do_register_sample;
result->decoder.ioctl = do_ioctl;
result->decoder.index_to_sample_ref = do_index_to_sample_ref;
result->decoder.ref_get = do_ref_get;
LABCOMM_SIGNATURE_ARRAY_INIT(result->local, struct sample_entry);
LABCOMM_SIGNATURE_ARRAY_INIT(result->remote_to_local, int);
LABCOMM_SIGNATURE_ARRAY_INIT(result->local_ref,
const struct labcomm2014_signature*);
LABCOMM_SIGNATURE_ARRAY_INIT(result->remote_to_local_ref, int);
}
return &(result->decoder);
}
const struct labcomm2014_sample_ref *labcomm2014_decoder_get_sample_ref(
struct labcomm2014_decoder *decoder,
const struct labcomm2014_signature *signature)
{
return decoder->ref_get(decoder, signature);
}
lib/c/labcomm_default_error_handler.c → lib/c/2014/labcomm2014_default_error_handler.c
View file @ d3921882
......@@ -19,6 +19,6 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "labcomm.h"
#include "labcomm2014.h"
struct labcomm_error_handler *labcomm_default_error_handler = NULL;
struct labcomm2014_error_handler *labcomm2014_default_error_handler = NULL;
lib/c/labcomm_default_error_handler.h → lib/c/2014/labcomm2014_default_error_handler.h
View file @ d3921882
......@@ -18,7 +18,11 @@
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_DEFAULT_ERROR_HANDLER_H__
#define __LABCOMM2014_DEFAULT_ERROR_HANDLER_H__
#include "labcomm.h"
#include "labcomm2014.h"
extern struct labcomm_error_handler *labcomm_default_error_handler;
extern struct labcomm2014_error_handler *labcomm2014_default_error_handler;
#endif
lib/c/labcomm_default_memory.c → lib/c/2014/labcomm2014_default_memory.c
View file @ d3921882
......@@ -20,30 +20,30 @@
*/
#include <stdlib.h>
#include "labcomm.h"
#include "labcomm_private.h"
#include "labcomm2014.h"
#include "labcomm2014_private.h"
void *default_alloc(struct labcomm_memory *m, int lifetime, size_t size)
void *default_alloc(struct labcomm2014_memory *m, int lifetime, size_t size)
{
return malloc(size);
}
void *default_realloc(struct labcomm_memory *m, int lifetime,
void *default_realloc(struct labcomm2014_memory *m, int lifetime,
void *ptr, size_t size)
{
return realloc(ptr, size);
}
void default_free(struct labcomm_memory *m, int lifetime, void *ptr)
void default_free(struct labcomm2014_memory *m, int lifetime, void *ptr)
{
free(ptr);
}
struct labcomm_memory memory = {
struct labcomm2014_memory memory = {
.alloc = default_alloc,
.realloc = default_realloc,
.free = default_free,
.context = NULL
};
struct labcomm_memory *labcomm_default_memory = &memory;
struct labcomm2014_memory *labcomm2014_default_memory = &memory;
lib/c/labcomm_default_memory.h → lib/c/2014/labcomm2014_default_memory.h
View file @ d3921882
......@@ -18,10 +18,12 @@
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_DEFAULT_MEMORY_H__
#define __LABCOMM2014_DEFAULT_MEMORY_H__
#include <stdlib.h>
#include "labcomm.h"
#include "labcomm_private.h"
#include "labcomm2014.h"
extern struct labcomm_memory *labcomm_default_memory;
extern struct labcomm2014_memory *labcomm2014_default_memory;
#endif
lib/c/labcomm_default_scheduler.c → lib/c/2014/labcomm2014_default_scheduler.c
View file @ d3921882
......@@ -21,11 +21,11 @@
#include <stdio.h>
#include <stdlib.h>
#include "labcomm_default_scheduler.h"
#include "labcomm_scheduler.h"
#include "labcomm_scheduler_private.h"
#include "labcomm2014_default_scheduler.h"
#include "labcomm2014_scheduler.h"
#include "labcomm2014_scheduler_private.h"
static int scheduler_free(struct labcomm_scheduler *s)
static int scheduler_free(struct labcomm2014_scheduler *s)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
......@@ -33,27 +33,27 @@ static int scheduler_free(struct labcomm_scheduler *s)
return 0;
}
static int scheduler_writer_lock(struct labcomm_scheduler *s)
static int scheduler_writer_lock(struct labcomm2014_scheduler *s)
{
return 0;
}
static int scheduler_writer_unlock(struct labcomm_scheduler *s)
static int scheduler_writer_unlock(struct labcomm2014_scheduler *s)
{
return 0;
}
static int scheduler_data_lock(struct labcomm_scheduler *s)
static int scheduler_data_lock(struct labcomm2014_scheduler *s)
{
return 0;
}
static int scheduler_data_unlock(struct labcomm_scheduler *s)
static int scheduler_data_unlock(struct labcomm2014_scheduler *s)
{
return 0;
}
static struct labcomm_time *scheduler_now(struct labcomm_scheduler *s)
static struct labcomm2014_time *scheduler_now(struct labcomm2014_scheduler *s)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
......@@ -61,8 +61,8 @@ static struct labcomm_time *scheduler_now(struct labcomm_scheduler *s)
return NULL;
}
static int scheduler_sleep(struct labcomm_scheduler *s,
struct labcomm_time *t)
static int scheduler_sleep(struct labcomm2014_scheduler *s,
struct labcomm2014_time *t)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
......@@ -70,7 +70,7 @@ static int scheduler_sleep(struct labcomm_scheduler *s,
return 0;
}
static int scheduler_wakeup(struct labcomm_scheduler *s)
static int scheduler_wakeup(struct labcomm2014_scheduler *s)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
......@@ -78,8 +78,8 @@ static int scheduler_wakeup(struct labcomm_scheduler *s)
return 0;
}
static int scheduler_enqueue(struct labcomm_scheduler *s,
useconds_t delay,
static int scheduler_enqueue(struct labcomm2014_scheduler *s,
uint32_t delay,
void (*deferred)(void *context),
void *context)
{
......@@ -89,7 +89,7 @@ static int scheduler_enqueue(struct labcomm_scheduler *s,
return 0;
}
static const struct labcomm_scheduler_action scheduler_action = {
static const struct labcomm2014_scheduler_action scheduler_action = {
.free = scheduler_free,
.writer_lock = scheduler_writer_lock,
.writer_unlock = scheduler_writer_unlock,
......@@ -101,9 +101,9 @@ static const struct labcomm_scheduler_action scheduler_action = {
.enqueue = scheduler_enqueue
};
static struct labcomm_scheduler scheduler = {
static struct labcomm2014_scheduler scheduler = {
.action = &scheduler_action,
.context = NULL
};
struct labcomm_scheduler *labcomm_default_scheduler = &scheduler;
struct labcomm2014_scheduler *labcomm2014_default_scheduler = &scheduler;
lib/c/labcomm_default_scheduler.h → lib/c/2014/labcomm2014_default_scheduler.h
View file @ d3921882
......@@ -18,7 +18,11 @@
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_DEFAULT_SCHEDULER_H__
#define __LABCOMM2014_DEFAULT_SCHEDULER_H__
#include "labcomm.h"
#include "labcomm2014.h"
extern struct labcomm_scheduler *labcomm_default_scheduler;
extern struct labcomm2014_scheduler *labcomm2014_default_scheduler;
#endif
lib/c/labcomm_dynamic_buffer_writer.c → lib/c/2014/labcomm2014_dynamic_buffer_writer.c
View file @ d3921882
/*
labcomm_dynamic_buffer_writer.c -- LabComm dynamic memory writer.
labcomm2014_dynamic_buffer_writer.c -- LabComm dynamic memory writer.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
......@@ -22,18 +22,17 @@
#include <errno.h>
#include <stdlib.h>
#include <stdarg.h>
#include "labcomm.h"
#include "labcomm_private.h"
#include "labcomm_ioctl.h"
#include "labcomm_dynamic_buffer_writer.h"
static int dyn_alloc(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
char *labcomm_version)
#include "labcomm2014.h"
#include "labcomm2014_private.h"
#include "labcomm2014_ioctl.h"
#include "labcomm2014_dynamic_buffer_writer.h"
static int dyn_alloc(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
w->data_size = 1000;
w->count = w->data_size;
w->data = labcomm_memory_alloc(w->memory, 1, w->data_size);
w->data = labcomm2014_memory_alloc(w->memory, 1, w->data_size);
if (w->data == NULL) {
w->error = -ENOMEM;
}
......@@ -42,29 +41,29 @@ static int dyn_alloc(struct labcomm_writer *w,
return w->error;
}
static int dyn_free(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context)
static int dyn_free(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
labcomm_memory_free(w->memory, 1, w->data);
labcomm2014_memory_free(w->memory, 1, w->data);
w->data = 0;
w->data_size = 0;
w->count = 0;
w->pos = 0;
labcomm_memory_free(w->memory, 0, action_context->context);
labcomm2014_memory_free(w->memory, 0, action_context->context);
return 0;
}
static int dyn_start(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
static int dyn_start(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int index,
struct labcomm_signature *signature,
const struct labcomm2014_signature *signature,
void *value)
{
void *tmp;
w->data_size = 1000;
w->count = w->data_size;
tmp = labcomm_memory_realloc(w->memory, 1, w->data, w->data_size);
tmp = labcomm2014_memory_realloc(w->memory, 1, w->data, w->data_size);
if (tmp != NULL) {
w->data = tmp;
w->error = 0;
......@@ -76,20 +75,20 @@ static int dyn_start(struct labcomm_writer *w,
return w->error;
}
static int dyn_end(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context)
static int dyn_end(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
return 0;
}
static int dyn_flush(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context)
static int dyn_flush(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
void *tmp;
w->data_size += 1000;
w->count = w->data_size;
tmp = labcomm_memory_realloc(w->memory, 1, w->data, w->data_size);
tmp = labcomm2014_memory_realloc(w->memory, 1, w->data, w->data_size);
if (tmp != NULL) {
w->data = tmp;
w->error = 0;
......@@ -101,10 +100,10 @@ static int dyn_flush(struct labcomm_writer *w,
return w->error;
}
static int dyn_ioctl(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
static int dyn_ioctl(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int signature_index,
struct labcomm_signature *signature,
const struct labcomm2014_signature *signature,
uint32_t action, va_list arg)
{
int result = -ENOTSUP;
......@@ -123,7 +122,7 @@ static int dyn_ioctl(struct labcomm_writer *w,
return result;
}
static const struct labcomm_writer_action action = {
static const struct labcomm2014_writer_action action = {
.alloc = dyn_alloc,
.free = dyn_free,
.start = dyn_start,
......@@ -131,18 +130,18 @@ static const struct labcomm_writer_action action = {
.flush = dyn_flush,
.ioctl = dyn_ioctl
};
const struct labcomm_writer_action *labcomm_dynamic_buffer_writer_action =
const struct labcomm2014_writer_action *labcomm2014_dynamic_buffer_writer_action =
&action;
struct labcomm_writer *labcomm_dynamic_buffer_writer_new(
struct labcomm_memory *memory)
struct labcomm2014_writer *labcomm2014_dynamic_buffer_writer_new(
struct labcomm2014_memory *memory)
{
struct result {
struct labcomm_writer writer;
struct labcomm_writer_action_context action_context;
struct labcomm2014_writer writer;
struct labcomm2014_writer_action_context action_context;
} *result;
result = labcomm_memory_alloc(memory, 0, sizeof(*result));
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result != NULL) {
result->action_context.next = NULL;
result->action_context.context = result;
......
lib/c/labcomm_dynamic_buffer_writer.h → lib/c/2014/labcomm2014_dynamic_buffer_writer.h
View file @ d3921882
/*
labcomm_dynamic_buffer_writer.h -- LabComm dynamic memory writer.
labcomm2014_dynamic_buffer_writer.h -- LabComm dynamic memory writer.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
......@@ -19,14 +19,14 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _LABCOMM_DYNAMIC_BUFFER_READER_WRITER_H_
#define _LABCOMM_DYNAMIC_BUFFER_READER_WRITER_H_
#ifndef __LABCOMM2014_DYNAMIC_BUFFER_READER_WRITER_H__
#define __LABCOMM2014_DYNAMIC_BUFFER_READER_WRITER_H__
#include "labcomm.h"
#include "labcomm2014.h"
extern const struct labcomm_writer_action *labcomm_dynamic_buffer_writer_action;
extern const struct labcomm2014_writer_action *labcomm2014_dynamic_buffer_writer_action;
struct labcomm_writer *labcomm_dynamic_buffer_writer_new(
struct labcomm_memory *memory);
struct labcomm2014_writer *labcomm2014_dynamic_buffer_writer_new(
struct labcomm2014_memory *memory);
#endif
lib/c/2014/labcomm2014_encoder.c 0 → 100644
View file @ d3921882
/*
labcomm2014_encoder.c -- handling encoding of labcomm2014 samples.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define CURRENT_VERSION "LabComm2014"
#include <errno.h>
#include "labcomm2014.h"
#include "labcomm2014_private.h"
#include "labcomm2014_ioctl.h"
#include "labcomm2014_dynamic_buffer_writer.h"
//define the following to disable encoding of typedefs
#undef LABCOMM_WITHOUT_TYPE_DEFS
#undef LABCOMM2014_WITH_SANITY_CHECKS
struct encoder {
struct labcomm2014_encoder encoder;
LABCOMM_SIGNATURE_ARRAY_DEF(registered, int);
LABCOMM_SIGNATURE_ARRAY_DEF(sample_ref, int);
LABCOMM_SIGNATURE_ARRAY_DEF(typedefs, int);
};
#ifdef LABCOMM2014_WITH_SANITY_CHECKS
static int expectedByteCount;
static void encoder_check_write_start(struct labcomm2014_encoder *e, int numBytes)
{
int previouslyWritten = 0;
int err = labcomm2014_encoder_ioctl(e, LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN, &previouslyWritten);
if(err) {
printf("ERROR: get_bytes_written returned %d (%s)\n", err, strerror(err));
}
expectedByteCount = numBytes + previouslyWritten;
#ifdef LABCOMM2014_ENCODER_DEBUG
printf("previously written: %d bytes, length = %d bytes, expected = %d bytes\n",
previouslyWritten, numBytes, expectedByteCount);
#endif
}
static int encoder_check_write_end(struct labcomm2014_encoder *e)
{
int written = 0;
int err = labcomm2014_encoder_ioctl(e, LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN, &written);
if(err) {
printf("ERROR: get_bytes_written returned %d (%s)\n", err, strerror(err));
}
int result = 0;
#ifdef LABCOMM2014_ENCODER_DEBUG
printf("DEBUG: encoder_check_write_end: expected: %d, was: %d\n",
expectedByteCount, written);
#endif
if(written != expectedByteCount) {
printf("WARNING! encoder_check_write_end: expected: %d, was: %d\n",
expectedByteCount, written);
result = -EINVAL;
}
return result;
}
#endif
/* XXX: TEMPORARY PLACEHOLDERS FOR INTENTIONS */
static int TODO_sizeof_intentions(const struct labcomm2014_signature *signature) {
int res = labcomm2014_size_string(signature->name) + 2;
return res;
}
static int TODO_encode_intentions(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature)
{
int result = -EINVAL;
labcomm2014_write_packed32(e->writer, 1); // one intention: the name
labcomm2014_write_packed32(e->writer, 0); // key: the empty string
labcomm2014_write_string(e->writer, signature->name);
result = e->writer->error;
return result;
}
static int do_sample_register(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature,
labcomm2014_encoder_function encode)
{
int result = -EINVAL;
struct encoder *ie = e->context;
int index, *done, err, i, length;
index = labcomm2014_get_local_index(signature);
labcomm2014_scheduler_writer_lock(e->scheduler);
if (index <= 0) { goto out; }
done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, ie->registered, int, index);
if (*done) {
goto out; }
*done = 1;
err = labcomm2014_writer_start(e->writer, e->writer->action_context,
index, signature, NULL);
if (err == -EALREADY) { result = 0; goto out; }
if (err != 0) { result = err; goto out; }
labcomm2014_write_packed32(e->writer, LABCOMM_SAMPLE_DEF);
length = (labcomm2014_size_packed32(index) +
TODO_sizeof_intentions(signature) +
labcomm2014_size_packed32(signature->size) +
signature->size);
labcomm2014_write_packed32(e->writer, length);
labcomm2014_write_packed32(e->writer, index);
TODO_encode_intentions(e, signature);
labcomm2014_write_packed32(e->writer, signature->size);
for (i = 0 ; i < signature->size ; i++) {
if (e->writer->pos >= e->writer->count) {
labcomm2014_writer_flush(e->writer, e->writer->action_context);
}
e->writer->data[e->writer->pos] = signature->signature[i];
e->writer->pos++;
}
labcomm2014_writer_end(e->writer, e->writer->action_context);
result = e->writer->error;
out:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
}
static int do_encode(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature,
labcomm2014_encoder_function encode,
void *value)
{
int result, index, length;
struct encoder *ie = e->context;
index = labcomm2014_get_local_index(signature);
length = (signature->encoded_size(signature, value));
labcomm2014_scheduler_writer_lock(e->scheduler);
if (! LABCOMM_SIGNATURE_ARRAY_GET(ie->registered, int, index, 0)) {
result = -EINVAL;
goto no_end;
}
result = labcomm2014_writer_start(e->writer, e->writer->action_context,
index, signature, value);
if (result == -EALREADY) { result = 0; goto no_end; }
if (result != 0) { goto out; }
result = labcomm2014_write_packed32(e->writer, index);
result = labcomm2014_write_packed32(e->writer, length);
if (result != 0) { goto out; }
result = encode(e->writer, value);
out:
labcomm2014_writer_end(e->writer, e->writer->action_context);
no_end:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
}
int labcomm2014_encoder_sample_ref_register(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature)
{
return e->ref_register(e, signature);
}
static int do_ref_register(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature)
{
int result = -EINVAL;
struct encoder *ie = e->context;
int index, *done, err, i, length;
index = labcomm2014_get_local_index(signature);
labcomm2014_scheduler_writer_lock(e->scheduler);
if (index <= 0) { goto out; }
done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, ie->sample_ref, int, index);
if (*done) { goto out; }
*done = 1;
err = labcomm2014_writer_start(e->writer, e->writer->action_context,
index, signature, NULL);
if (err == -EALREADY) { result = 0; goto out; }
if (err != 0) { result = err; goto out; }
labcomm2014_write_packed32(e->writer, LABCOMM_SAMPLE_REF);
length = (labcomm2014_size_packed32(index) +
TODO_sizeof_intentions(signature) +
labcomm2014_size_packed32(signature->size) +
signature->size);
labcomm2014_write_packed32(e->writer, length);
labcomm2014_write_packed32(e->writer, index);
TODO_encode_intentions(e, signature);
labcomm2014_write_packed32(e->writer, signature->size);
for (i = 0 ; i < signature->size ; i++) {
if (e->writer->pos >= e->writer->count) {
labcomm2014_writer_flush(e->writer, e->writer->action_context);
}
e->writer->data[e->writer->pos] = signature->signature[i];
e->writer->pos++;
}
labcomm2014_writer_end(e->writer, e->writer->action_context);
result = e->writer->error;
out:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
}
int labcomm2014_encoder_ioctl(struct labcomm2014_encoder *encoder,
uint32_t action,
...)
{
int result;
va_list va;
if (LABCOMM_IOC_SIG(action) != LABCOMM_IOC_NOSIG) {
result = -EINVAL;
goto out;
}
va_start(va, action);
result = encoder->ioctl(encoder, NULL, action, va);
va_end(va);
out:
return result;
}
static int do_ioctl(
struct labcomm2014_encoder *encoder,
const struct labcomm2014_signature *signature,
uint32_t action, va_list va)
{
int result = -ENOTSUP;
int index;
index = labcomm2014_get_local_index(signature);
result = labcomm2014_writer_ioctl(encoder->writer,
encoder->writer->action_context,
index, signature, action, va);
return result;
}
static int do_sample_ref_to_index(
struct labcomm2014_encoder *e,
const struct labcomm2014_sample_ref *sample_ref)
{
/* writer_lock should be held at this point */
struct encoder *ie = e->context;
int index = 0;
if (sample_ref != NULL) {
index = labcomm2014_get_local_index(
(struct labcomm2014_signature *)sample_ref);
if (! LABCOMM_SIGNATURE_ARRAY_GET(ie->sample_ref, int, index, 0)) {
index = 0;
}
}
return index;
}
/**********************************************************
* Start of code related to sending (hierarchical)
* typedefs. Define LABCOMM_WITHOUT_TYPEDEFS to disable
**********************************************************/
#ifndef LABCOMM_WITHOUT_TYPE_DEFS
static void write_sig_tree_byte(char b, const struct labcomm2014_signature *signature,
void *context)
{
struct labcomm2014_encoder *e = context;
if(signature) {
labcomm2014_write_packed32(e->writer, labcomm2014_get_local_index(signature));
}else {
if (e->writer->pos >= e->writer->count) {
labcomm2014_writer_flush(e->writer, e->writer->action_context);
}
e->writer->data[e->writer->pos] = b;
e->writer->pos++;
}
}
static void do_write_signature(struct labcomm2014_encoder * e,
const struct labcomm2014_signature *signature,
unsigned char flatten)
{
map_signature(write_sig_tree_byte, e, signature, flatten);
}
static void sig_size(char b, const struct labcomm2014_signature *signature,
void *context)
{
int *result = context;
int diff;
if(signature) {
int idx = labcomm2014_get_local_index(signature);
diff = labcomm2014_size_packed32(idx);
}else {
diff = 1;
}
(*result)+=diff;
}
static int calc_sig_encoded_size(struct labcomm2014_encoder *e,
const struct labcomm2014_signature *sig)
{
int result=0;
map_signature(sig_size, &result, sig, LABCOMM2014_FALSE);
return result;
}
static int internal_reg_type(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature,
labcomm2014_bool flatten)
{
int result = -EINVAL;
int index, *done, err;
struct encoder *ie = e->context;
index = labcomm2014_get_local_index(signature);
labcomm2014_scheduler_writer_lock(e->scheduler);
if (index <= 0) { goto out; }
done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, ie->typedefs, int, index);
if (*done) { goto out; }
*done = 1;
err = labcomm2014_writer_start(e->writer, e->writer->action_context,
index, signature, NULL);
if (err == -EALREADY) { result = 0; goto out; }
if (err != 0) { result = err; goto out; }
printf("internal_reg_type: %s\n", signature->name);
int sig_size = calc_sig_encoded_size(e, signature);
int len_idx= labcomm2014_size_packed32(index);
int len_ints =TODO_sizeof_intentions(signature);
int len_sigsize =labcomm2014_size_packed32(sig_size);
int len_sig =sig_size;
int len = len_idx + len_ints + len_sigsize + len_sig;
labcomm2014_write_packed32(e->writer, LABCOMM_TYPE_DEF);
labcomm2014_write_packed32(e->writer, len);
#ifdef LABCOMM2014_WITH_SANITY_CHECKS
encoder_check_write_start(e, len);
#endif
labcomm2014_write_packed32(e->writer, index);
TODO_encode_intentions(e, signature);
labcomm2014_write_packed32(e->writer, sig_size);
do_write_signature(e, signature, LABCOMM2014_FALSE);
#ifdef LABCOMM2014_WITH_SANITY_CHECKS
encoder_check_write_end(e);
#endif
labcomm2014_writer_end(e->writer, e->writer->action_context);
result = e->writer->error;
out:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
}
#endif
static int do_type_register(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature)
{
#ifndef LABCOMM_WITHOUT_TYPE_DEFS
return internal_reg_type(e, signature, LABCOMM2014_FALSE);
#else
return 0;
#endif
}
static int do_type_bind(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature,
char has_deps)
{
#ifndef LABCOMM_WITHOUT_TYPE_DEFS
int result = -EINVAL;
int err;
int sindex = labcomm2014_get_local_index(signature);
int tindex = has_deps ? labcomm2014_get_local_type_index(signature) : LABCOMM_BIND_SELF;
labcomm2014_scheduler_writer_lock(e->scheduler);
if(sindex <= 0 || (has_deps && tindex <= 0)) {goto out;}
err = labcomm2014_writer_start(e->writer, e->writer->action_context,
LABCOMM_TYPE_BINDING, signature, NULL);
if (err == -EALREADY) { result = 0; goto out; }
if (err != 0) { result = err; goto out; }
int length = (labcomm2014_size_packed32(sindex) +
labcomm2014_size_packed32(tindex));
labcomm2014_write_packed32(e->writer, LABCOMM_TYPE_BINDING);
labcomm2014_write_packed32(e->writer, length);
labcomm2014_write_packed32(e->writer, sindex);
labcomm2014_write_packed32(e->writer, tindex);
labcomm2014_writer_end(e->writer, e->writer->action_context);
result = e->writer->error;
out:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
#else
return 0;
#endif
}
static const struct labcomm2014_sample_ref *do_ref_get(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature)
{
return (const struct labcomm2014_sample_ref *) signature;
}
void labcomm2014_encoder_free(struct labcomm2014_encoder* e)
{
e->free(e);
}
static void do_free(struct labcomm2014_encoder* e)
{
struct encoder *ie = e->context;
struct labcomm2014_memory *memory = e->memory;
labcomm2014_writer_free(e->writer, e->writer->action_context);
LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, ie->registered, int);
LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, ie->sample_ref, int);
LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, ie->typedefs, int);
labcomm2014_memory_free(memory, 0, ie);
}
static struct labcomm2014_encoder *internal_encoder_new(
struct labcomm2014_writer *writer,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler,
labcomm2014_bool outputVer)
{
struct encoder *result;
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result) {
int length;
result->encoder.context = result;
result->encoder.writer = writer;
result->encoder.writer->encoder = &result->encoder;
result->encoder.writer->data = NULL;
result->encoder.writer->data_size = 0;
result->encoder.writer->count = 0;
result->encoder.writer->pos = 0;
result->encoder.writer->error = 0;
result->encoder.error = error;
result->encoder.memory = memory;
result->encoder.scheduler = scheduler;
result->encoder.free = do_free;
result->encoder.type_register = do_type_register;
result->encoder.type_bind = do_type_bind;
result->encoder.sample_register = do_sample_register;
result->encoder.ref_register = do_ref_register;
result->encoder.encode = do_encode;
result->encoder.ioctl = do_ioctl;
result->encoder.sample_ref_to_index = do_sample_ref_to_index;
result->encoder.ref_get = do_ref_get;
LABCOMM_SIGNATURE_ARRAY_INIT(result->registered, int);
LABCOMM_SIGNATURE_ARRAY_INIT(result->sample_ref, int);
LABCOMM_SIGNATURE_ARRAY_INIT(result->typedefs, int);
labcomm2014_writer_alloc(result->encoder.writer,
result->encoder.writer->action_context);
if(outputVer) {
labcomm2014_writer_start(result->encoder.writer,
result->encoder.writer->action_context,
LABCOMM_VERSION, NULL, CURRENT_VERSION);
labcomm2014_write_packed32(result->encoder.writer, LABCOMM_VERSION);
length = labcomm2014_size_string(CURRENT_VERSION);
labcomm2014_write_packed32(result->encoder.writer, length);
labcomm2014_write_string(result->encoder.writer, CURRENT_VERSION);
labcomm2014_writer_end(result->encoder.writer,
result->encoder.writer->action_context);
}
}
return &(result->encoder);
}
struct labcomm2014_encoder *labcomm2014_encoder_new(
struct labcomm2014_writer *writer,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler)
{
return internal_encoder_new(writer,error,memory,scheduler,LABCOMM2014_TRUE);
}
const struct labcomm2014_sample_ref *labcomm2014_encoder_get_sample_ref(
struct labcomm2014_encoder *encoder,
const struct labcomm2014_signature *signature)
{
return encoder->ref_get(encoder, signature);
}
lib/c/2014/labcomm2014_error.c 0 → 100644
View file @ d3921882
/*
labcomm2014_error.c -- labcomm2014 error handling
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include "labcomm2014_error.h"
static char *description[] = {
#define LABCOMM2014_ERROR(name, description) description ,
#include "labcomm2014_error.h"
#undef LABCOMM2014_ERROR
};
void labcomm2014_error_fatal_global(enum labcomm2014_error error,
char *format,
...)
{
va_list args;
fprintf(stderr, "Fatal error %d (%s)\n", error, description[error]);
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
exit(1);
}
void labcomm2014_error_warning(struct labcomm2014_error_handler *e,
enum labcomm2014_error error,
char *format,
...)
{
va_list args;
fprintf(stderr, "Fatal warning %d (%s)\n", error, description[error]);
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
exit(1);
}
lib/c/2014/labcomm2014_error.h 0 → 100644
View file @ d3921882
/*
labcomm2014_error.h -- labcomm2014 error declarations
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_ERROR_H___
#define __LABCOMM2014_ERROR_H___
enum labcomm2014_error {
#define LABCOMM2014_ERROR(name, description) name ,
#include "labcomm2014_error.h"
#undef LABCOMM2014_ERROR
};
struct labcomm2014_error_handler;
void labcomm2014_error_warning(struct labcomm2014_error_handler *e,
enum labcomm2014_error,
char *format,
...);
void labcomm2014_error_fatal_global(enum labcomm2014_error error,
char *format,
...);
#endif
#ifdef LABCOMM2014_ERROR
LABCOMM2014_ERROR(LABCOMM2014_ERROR_SIGNATURE_ALREADY_SET,
"Signature has already been set")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_SIGNATURE_NOT_SET,
"Signature has not been set")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_ENC_NO_REG_SIGNATURE,
"Encoder has no registration for this signature")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_ENC_BUF_FULL,
"The labcomm2014 buffer is full")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_NO_REG_SIGNATURE,
"Decoder has no registration for this signature")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_UNKNOWN_DATATYPE,
"Decoder: Unknown datatype")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_INDEX_MISMATCH,
"Decoder: index mismatch")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_TYPE_NOT_FOUND,
"Decoder: type not found")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_UNIMPLEMENTED_FUNC,
"This function is not yet implemented")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_MEMORY,
"Could not allocate memory")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_USER_DEF,
"User defined error")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_BAD_WRITER,
"Decoder: writer_ioctl() failed")
#endif
lib/c/labcomm_fd_reader.c → lib/c/2014/labcomm2014_fd_reader.c
View file @ d3921882
/*
labcomm_fd_reader.c -- LabComm reader for Unix file descriptors.
labcomm2014_fd_reader.c -- LabComm reader for Unix file descriptors.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
......@@ -23,27 +23,26 @@
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "labcomm_private.h"
#include "labcomm_fd_reader.h"
#include "labcomm2014_private.h"
#include "labcomm2014_fd_reader.h"
#define BUFFER_SIZE 2048
struct labcomm_fd_reader {
struct labcomm_reader reader;
struct labcomm_reader_action_context action_context;
struct labcomm2014_fd_reader {
struct labcomm2014_reader reader;
struct labcomm2014_reader_action_context action_context;
int fd;
int close_fd_on_free;
};
static int fd_alloc(struct labcomm_reader *r,
struct labcomm_reader_action_context *action_context,
char *version)
static int fd_alloc(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
int result = 0;
r->count = 0;
r->pos = 0;
r->data = labcomm_memory_alloc(r->memory, 0, BUFFER_SIZE);
r->data = labcomm2014_memory_alloc(r->memory, 0, BUFFER_SIZE);
if (! r->data) {
r->data_size = 0;
result = -ENOMEM;
......@@ -51,28 +50,17 @@ static int fd_alloc(struct labcomm_reader *r,
r->data_size = BUFFER_SIZE;
result = r->data_size;
if (version && version[0]) {
char *tmp;
tmp = labcomm_read_string(r);
if (strcmp(tmp, version) != 0) {
result = -EINVAL;
} else {
result = r->data_size;
}
labcomm_memory_free(r->memory, 1, tmp);
}
}
return result;
}
static int fd_free(struct labcomm_reader *r,
struct labcomm_reader_action_context *action_context)
static int fd_free(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
struct labcomm_fd_reader *fd_reader = action_context->context;
struct labcomm_memory *memory = r->memory;
struct labcomm2014_fd_reader *fd_reader = action_context->context;
struct labcomm2014_memory *memory = r->memory;
labcomm_memory_free(memory, 0, r->data);
labcomm2014_memory_free(memory, 0, r->data);
r->data = 0;
r->data_size = 0;
r->count = 0;
......@@ -81,16 +69,16 @@ static int fd_free(struct labcomm_reader *r,
if (fd_reader->close_fd_on_free) {
close(fd_reader->fd);
}
labcomm_memory_free(memory, 0, fd_reader);
labcomm2014_memory_free(memory, 0, fd_reader);
return 0;
}
static int fd_fill(struct labcomm_reader *r,
struct labcomm_reader_action_context *action_context)
static int fd_fill(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
int result = 0;
struct labcomm_fd_reader *fd_reader = action_context->context;
struct labcomm2014_fd_reader *fd_reader = action_context->context;
if (r->pos < r->count) {
result = r->count - r->pos;
......@@ -98,7 +86,7 @@ static int fd_fill(struct labcomm_reader *r,
int err;
r->pos = 0;
err = read(fd_reader->fd, r->data, r->data_size);
err = read(fd_reader->fd, (char *)r->data, r->data_size);
if (err <= 0) {
r->count = 0;
r->error = -EPIPE;
......@@ -111,7 +99,7 @@ static int fd_fill(struct labcomm_reader *r,
return result;
}
static const struct labcomm_reader_action action = {
static const struct labcomm2014_reader_action action = {
.alloc = fd_alloc,
.free = fd_free,
.start = NULL,
......@@ -120,12 +108,12 @@ static const struct labcomm_reader_action action = {
.ioctl = NULL
};
struct labcomm_reader *labcomm_fd_reader_new(struct labcomm_memory *memory,
struct labcomm2014_reader *labcomm2014_fd_reader_new(struct labcomm2014_memory *memory,
int fd, int close_fd_on_free)
{
struct labcomm_fd_reader *result;
struct labcomm2014_fd_reader *result;
result = labcomm_memory_alloc(memory, 0, sizeof(*result));
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result == NULL) {
return NULL;
} else {
......
lib/c/labcomm_fd_reader.h → lib/c/2014/labcomm2014_fd_reader.h
View file @ d3921882
/*
labcomm_fd_reader.c -- a reader for unix style file-descriptors
labcomm2014_fd_reader.c -- a reader for unix style file-descriptors
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
......@@ -19,12 +19,12 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _LABCOMM_FD_READER_H_
#define _LABCOMM_FD_READER_H_
#ifndef __LABCOMM2014_FD_READER_H__
#define __LABCOMM2014_FD_READER_H__
#include "labcomm.h"
#include "labcomm2014.h"
struct labcomm_reader *labcomm_fd_reader_new(struct labcomm_memory *memory,
struct labcomm2014_reader *labcomm2014_fd_reader_new(struct labcomm2014_memory *memory,
int fd, int close_fd_on_free);
#endif
......
lib/c/labcomm_fd_writer.c → lib/c/2014/labcomm2014_fd_writer.c
View file @ d3921882
/*
labcomm_fd_writer.c -- LabComm writer for Unix file descriptors.
labcomm2014_fd_writer.c -- LabComm writer for Unix file descriptors.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
......@@ -24,26 +24,30 @@
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "labcomm_private.h"
#include "labcomm_fd_writer.h"
#include "labcomm2014_private.h"
#include "labcomm2014_fd_writer.h"
#include "labcomm2014_ioctl.h"
#define BUFFER_SIZE 2048
struct labcomm_fd_writer {
struct labcomm_writer writer;
struct labcomm_writer_action_context action_context;
#ifdef LABCOMM_WITH_SANITY_CHECKS
static int bytecount_carry = 0;
#endif
struct labcomm2014_fd_writer {
struct labcomm2014_writer writer;
struct labcomm2014_writer_action_context action_context;
int fd;
int close_fd_on_free;
};
static int fd_flush(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context);
static int fd_flush(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context);
static int fd_alloc(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
char *version)
static int fd_alloc(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
w->data = labcomm_memory_alloc(w->memory, 0, BUFFER_SIZE);
w->data = labcomm2014_memory_alloc(w->memory, 0, BUFFER_SIZE);
if (! w->data) {
w->error = -ENOMEM;
w->data_size = 0;
......@@ -53,22 +57,18 @@ static int fd_alloc(struct labcomm_writer *w,
w->data_size = BUFFER_SIZE;
w->count = BUFFER_SIZE;
w->pos = 0;
if (version && version[0]) {
labcomm_write_string(w, version);
fd_flush(w, action_context);
}
}
return w->error;
}
static int fd_free(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context)
static int fd_free(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
struct labcomm_fd_writer *fd_writer = action_context->context;
struct labcomm_memory *memory = w->memory;
struct labcomm2014_fd_writer *fd_writer = action_context->context;
struct labcomm2014_memory *memory = w->memory;
labcomm_memory_free(memory, 0, w->data);
labcomm2014_memory_free(memory, 0, w->data);
w->data = 0;
w->data_size = 0;
w->count = 0;
......@@ -77,31 +77,34 @@ static int fd_free(struct labcomm_writer *w,
if (fd_writer->close_fd_on_free) {
close(fd_writer->fd);
}
labcomm_memory_free(memory, 0, fd_writer);
labcomm2014_memory_free(memory, 0, fd_writer);
return 0;
}
static int fd_start(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
static int fd_start(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int index,
struct labcomm_signature *signature,
const struct labcomm2014_signature *signature,
void *value)
{
#ifdef LABCOMM_WITH_SANITY_CHECKS
bytecount_carry = w->pos;
#endif
w->pos = 0;
return w->error;
}
static int fd_flush(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context)
static int fd_flush(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
struct labcomm_fd_writer *fd_context = action_context->context;
struct labcomm2014_fd_writer *fd_context = action_context->context;
int start, err;
start = 0;
err = 0;
while (start < w->pos) {
err = write(fd_context->fd, &w->data[start], w->pos - start);
err = write(fd_context->fd, (char *)&w->data[start], w->pos - start);
if (err <= 0) {
break;
}
......@@ -112,26 +115,53 @@ static int fd_flush(struct labcomm_writer *w,
} else if (err == 0) {
w->error = -EINVAL;
}
#ifdef LABCOMM_WITH_SANITY_CHECKS
bytecount_carry = w->pos;
#endif
w->pos = 0;
return w->error;
}
static const struct labcomm_writer_action action = {
#ifdef LABCOMM_WITH_SANITY_CHECKS
static int fd_ioctl(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int signature_index,
const struct labcomm2014_signature *signature,
uint32_t action, va_list arg)
{
int result = -ENOTSUP;
switch (action) {
case LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN: {
int *value = va_arg(arg, int*);
*value = w->pos + bytecount_carry;
result = 0;
} break;
}
return result;
}
#endif
static const struct labcomm2014_writer_action action = {
.alloc = fd_alloc,
.free = fd_free,
.start = fd_start,
.end = fd_flush,
.flush = fd_flush,
#ifdef LABCOMM_WITH_SANITY_CHECKS
.ioctl = fd_ioctl
#else
.ioctl = NULL
#endif
};
struct labcomm_writer *labcomm_fd_writer_new(struct labcomm_memory *memory,
struct labcomm2014_writer *labcomm2014_fd_writer_new(struct labcomm2014_memory *memory,
int fd, int close_fd_on_free)
{
struct labcomm_fd_writer *result;
struct labcomm2014_fd_writer *result;
result = labcomm_memory_alloc(memory, 0, sizeof(*result));
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result == NULL) {
return NULL;
} else {
......
lib/c/labcomm_fd_writer.h → lib/c/2014/labcomm2014_fd_writer.h
View file @ d3921882
/*
labcomm_fd_writer.c -- a writer for unix style file-descriptors
labcomm2014_fd_writer.c -- a writer for unix style file-descriptors
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
......@@ -19,12 +19,12 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _LABCOMM_FD_WRITER_H_
#define _LABCOMM_FD_WRITER_H_
#ifndef __LABCOMM2014_FD_WRITER_H__
#define __LABCOMM2014_FD_WRITER_H__
#include "labcomm.h"
#include "labcomm2014.h"
struct labcomm_writer *labcomm_fd_writer_new(struct labcomm_memory *memory,
struct labcomm2014_writer *labcomm2014_fd_writer_new(struct labcomm2014_memory *memory,
int fd, int close_on_free);
#endif
......
lib/c/labcomm_ioctl.h → lib/c/2014/labcomm2014_ioctl.h
View file @ d3921882
#ifndef __LABCOMM_IOCTL_H__
#define __LABCOMM_IOCTL_H__
/*
labcomm2014_ioctl.h -- labcomm2014 ioctl declarations
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_IOCTL_H___
#define __LABCOMM2014_IOCTL_H___
#include "labcomm.h"
#include "labcomm2014.h"
/*
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
......@@ -14,7 +35,7 @@
* | +----------------------------------------------- direction (2)
* +------------------------------------------------- signature (1)
*
* type 0-31 are reserved for labcomm library use
* type 0-31 are reserved for labcomm2014 library use
*/
......@@ -63,23 +84,14 @@
LABCOMM_IOC(LABCOMM_IOC_NOSIG,LABCOMM_IOC_NONE,type,nr,0)
#define LABCOMM_IOR(type,nr,size) \
LABCOMM_IOC(LABCOMM_IOC_NOSIG,LABCOMM_IOC_READ,type,nr,sizeof(size))
/* FIXME: add flag to differentiate between size and nargs */
#define LABCOMM_IORN(type,nr,nargs) \
LABCOMM_IOC(LABCOMM_IOC_NOSIG,LABCOMM_IOC_READ,type,nr,nargs)
#define LABCOMM_IOW(type,nr,size) \
LABCOMM_IOC(LABCOMM_IOC_NOSIG,LABCOMM_IOC_WRITE,type,nr,sizeof(size))
#define LABCOMM_IOWN(type,nr,nargs) \
LABCOMM_IOC(LABCOMM_IOC_NOSIG,LABCOMM_IOC_WRITE,type,nr,nargs)
#define LABCOMM_IOS(type,nr) \
#define LABCOMM_IOS(type,nr) \
LABCOMM_IOC(LABCOMM_IOC_USESIG,LABCOMM_IOC_READ,type,nr,0)
#define LABCOMM_IOSR(type,nr,size) \
LABCOMM_IOC(LABCOMM_IOC_USESIG,LABCOMM_IOC_READ,type,nr,sizeof(size))
#define LABCOMM_IOSRN(type,nr,nargs) \
LABCOMM_IOC(LABCOMM_IOC_USESIG,LABCOMM_IOC_READ,type,nr,nargs)
#define LABCOMM_IOSW(type,nr,size) \
LABCOMM_IOC(LABCOMM_IOC_USESIG,LABCOMM_IOC_WRITE,type,nr,sizeof(size))
#define LABCOMM_IOSWN(type,nr,nargs) \
LABCOMM_IOC(LABCOMM_IOC_USESIG,LABCOMM_IOC_WRITE,type,nr,nargs)
#define LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN \
LABCOMM_IOR(0,1,int)
......
lib/c/labcomm_memory.c → lib/c/2014/labcomm2014_memory.c
View file @ d3921882
/*
labcomm_memory.c -- dynamic memory handlig dispatcher
labcomm2014_memory.c -- dynamic memory handlig dispatcher
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
......@@ -19,21 +19,21 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "labcomm_private.h"
#include "labcomm2014_private.h"
void *labcomm_memory_alloc(struct labcomm_memory *m, int lifetime,
void *labcomm2014_memory_alloc(struct labcomm2014_memory *m, int lifetime,
size_t size)
{
return m->alloc(m, lifetime, size);
}
void *labcomm_memory_realloc(struct labcomm_memory *m, int lifetime,
void *labcomm2014_memory_realloc(struct labcomm2014_memory *m, int lifetime,
void *ptr, size_t size)
{
return m->realloc(m, lifetime, ptr, size);
}
void labcomm_memory_free(struct labcomm_memory *m, int lifetime,
void labcomm2014_memory_free(struct labcomm2014_memory *m, int lifetime,
void *ptr)
{
m->free(m, lifetime, ptr);
......