static int feature_index_lua_get_features_for_range(lua_State *L)
{
GtFeatureIndex **feature_index;
const char *seqid;
GtRange *range;
GtError *err;
bool has_seqid;
GtArray *features;
GT_UNUSED int had_err;
feature_index = check_feature_index(L, 1);
seqid = luaL_checkstring(L, 2);
err = gt_error_new();
if (gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err))
return gt_lua_error(L, err);
gt_error_delete(err);
luaL_argcheck(L, has_seqid, 2,
"feature_index does not contain seqid");
range = check_range(L, 3);
features = gt_array_new(sizeof (GtGenomeNode*));
err = gt_error_new();
had_err = gt_feature_index_get_features_for_range(*feature_index, features,
seqid, range, err);
if (had_err)
return gt_lua_error(L, err);
gt_error_delete(err);
push_features_as_table(L, features);
gt_array_delete(features);
return 1;
}
static int feature_index_lua_add_feature_node(lua_State *L)
{
GtFeatureIndex **fi;
GtGenomeNode **gn;
GtFeatureNode *fn;
GtStr *seqid;
GtError *err;
bool has_seqid;
gt_assert(L);
fi = check_feature_index(L, 1);
gn = check_genome_node(L, 2);
fn = gt_feature_node_cast(*gn);
luaL_argcheck(L, fn, 2, "not a feature node");
seqid = gt_genome_node_get_seqid(*gn);
luaL_argcheck(L, seqid, 2, "feature does not have a sequence id");
err = gt_error_new();
if (gt_feature_index_has_seqid(*fi, &has_seqid, gt_str_get(seqid), err))
return gt_lua_error(L, err);
gt_error_delete(err);
luaL_argcheck(L, has_seqid, 2,
"feature index does not contain corresponding sequence region");
err = gt_error_new();
if (gt_feature_index_add_feature_node(*fi, fn, err))
return gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int feature_node_lua_extract_sequence(lua_State *L)
{
GtGenomeNode **gn;
GtFeatureNode *fn;
const char *type;
bool join;
GtRegionMapping **region_mapping;
GtStr *sequence;
GtError *err;
gn = check_genome_node(L, 1);
/* make sure we get a feature node */
fn = gt_feature_node_try_cast(*gn);
luaL_argcheck(L, fn, 1, "not a feature node");
type = luaL_checkstring(L, 2);
join = lua_toboolean(L, 3);
region_mapping = check_region_mapping(L, 4);
err = gt_error_new();
sequence = gt_str_new();
if (gt_extract_feature_sequence(sequence, *gn, type, join, NULL, NULL,
*region_mapping, err)) {
gt_str_delete(sequence);
return gt_lua_error(L, err);
}
if (gt_str_length(sequence))
lua_pushstring(L, gt_str_get(sequence));
else
lua_pushnil(L);
gt_str_delete(sequence);
gt_error_delete(err);
return 1;
}
static int canvas_cairo_file_lua_new_generic(lua_State *L, GtGraphicsOutType t)
{
GtCanvas **canvas;
GtImageInfo **ii;
unsigned int width,
height;
GtError *err;
GtStyle *style;
width = luaL_checkint(L, 1);
height = luaL_checkint(L, 2);
/* create canvas */
style = gt_lua_get_style_from_registry(L);
canvas = lua_newuserdata(L, sizeof (GtCanvas*));
gt_assert(canvas);
/* if a imageinfo object is passed, it must be correct type */
if (lua_isnil(L, 3)) {
err = gt_error_new();
*canvas = gt_canvas_cairo_file_new(style, t, width, height, NULL, err);
} else {
ii = check_imageinfo(L, 3);
err = gt_error_new();
*canvas = gt_canvas_cairo_file_new(style, t, width, height, *ii, err);
}
if (gt_error_is_set(err))
return gt_lua_error(L, err);
gt_error_delete(err);
luaL_getmetatable(L, CANVAS_METATABLE);
lua_setmetatable(L, -2);
return 1;
}
static int feature_index_lua_get_range_for_seqid(lua_State *L)
{
GtFeatureIndex **feature_index;
const char *seqid;
GtError *err;
GtRange range;
bool has_seqid;
feature_index = check_feature_index(L, 1);
seqid = luaL_checkstring(L, 2);
err = gt_error_new();
if (gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err))
return gt_lua_error(L, err);
gt_error_delete(err);
luaL_argcheck(L, has_seqid, 2,
"feature_index does not contain seqid");
err = gt_error_new();
if (gt_feature_index_get_range_for_seqid(*feature_index, &range, seqid, err))
return gt_lua_error(L, err);
gt_error_delete(err);
return gt_lua_range_push(L, range);
}
static int encseq_lua_mirror(lua_State *L)
{
GtEncseq **encseq;
GtError *err = gt_error_new();
encseq = check_encseq(L, 1);
gt_assert(*encseq);
luaL_argcheck(L, !gt_encseq_is_mirrored(*encseq), 1, "is already mirrored");
if (gt_encseq_mirror(*encseq, err) != 0)
gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int genome_node_lua_accept(lua_State *L)
{
GtGenomeNode **gn;
GtNodeVisitor **gv;
GtError *err;
gn = check_genome_node(L, 1);
gv = check_genome_visitor(L, 2);
err = gt_error_new();
if (gt_genome_node_accept(*gn, *gv, err))
return gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int encseq_encoder_lua_encode(lua_State *L)
{
GtEncseqEncoder **encoder;
GtStrArray *seqfiles = gt_str_array_new();
GtError *err;
const char *indexname;
encoder = check_encseq_encoder(L, 1);
err = gt_error_new();
if (gt_lua_get_table_as_strarray(L, 2, seqfiles, err) != 0) {
gt_str_array_delete(seqfiles);
gt_lua_error(L, err);
}
indexname = luaL_checkstring(L, 3);
gt_assert(*encoder);
if (gt_encseq_encoder_encode(*encoder, seqfiles, indexname, err) != 0) {
gt_str_array_delete(seqfiles);
gt_lua_error(L, err);
}
gt_str_array_delete(seqfiles);
gt_error_delete(err);
return 0;
}
static int encseq_encoder_lua_use_symbolmap_file(lua_State *L)
{
GtEncseqEncoder **encoder;
const char *smapfile;
GtError *err;
encoder = check_encseq_encoder(L, 1);
smapfile = luaL_checkstring(L, 2);
gt_assert(*encoder);
err = gt_error_new();
if (gt_encseq_encoder_use_symbolmap_file(*encoder, smapfile, err) != 0)
gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int encseq_encoder_lua_use_representation(lua_State *L)
{
GtEncseqEncoder **encoder;
const char *repr;
GtError *err;
encoder = check_encseq_encoder(L, 1);
repr = luaL_checkstring(L, 2);
gt_assert(*encoder);
err = gt_error_new();
if (gt_encseq_encoder_use_representation(*encoder, repr, err) != 0)
gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int feature_index_lua_add_gff3file(lua_State *L)
{
GtFeatureIndex **fi;
const char *filename;
GtError *err;
gt_assert(L);
fi = check_feature_index(L, 1);
filename = luaL_checkstring(L, 2);
err = gt_error_new();
if (gt_feature_index_add_gff3file(*fi, filename, err))
return gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int gt_node_stream_lua_next_tree(lua_State *L)
{
GtNodeStream **gs = check_genome_stream(L, 1);
GtGenomeNode *gn;
GtError *err = gt_error_new();
if (gt_node_stream_next(*gs, &gn, err))
return gt_lua_error(L, err); /* handle error */
else if (gn)
gt_lua_genome_node_push(L, gn);
else
lua_pushnil(L);
gt_error_delete(err);
return 1;
}
static int layout_lua_sketch(lua_State *L)
{
GtLayout **layout;
GtCanvas **canvas;
GtError *err;
int had_err = 0;
layout = check_layout(L, 1);
canvas = check_canvas(L, 2);
err = gt_error_new();
had_err = gt_layout_sketch(*layout, *canvas, err);
if (had_err < 0)
return gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int layout_lua_get_height(lua_State *L)
{
GtLayout **layout;
GtError *err;
int had_err = 0;
unsigned long height;
layout = check_layout(L, 1);
err = gt_error_new();
had_err = gt_layout_get_height(*layout, &height, err);
lua_pushnumber(L, height);
if (had_err < 0)
return gt_lua_error(L, err);
gt_error_delete(err);
return 1;
}
static int encseq_builder_lua_build(lua_State *L)
{
GtEncseqBuilder **builder;
GtEncseq *encseq;
GtError *err;
builder = check_encseq_builder(L, 1);
err = gt_error_new();
encseq = gt_encseq_builder_build(*builder, err);
if (encseq == NULL) {
gt_lua_error(L, err);
} else
gt_lua_encseq_push(L, encseq);
gt_error_delete(err);
return 1;
}
static int feature_index_lua_get_seqids(lua_State *L)
{
GtFeatureIndex **feature_index;
GtStrArray *seqids;
GtError *err;
feature_index = check_feature_index(L, 1);
err = gt_error_new();
seqids = gt_feature_index_get_seqids(*feature_index, err);
if (!seqids)
return gt_lua_error(L, err);
gt_error_delete(err);
/* push table containing sequence ids onto the stack */
gt_lua_push_strarray_as_table(L, seqids);
gt_str_array_delete(seqids);
return 1;
}
static int feature_index_lua_add_region_node(lua_State *L)
{
GtFeatureIndex **fi;
GtGenomeNode **gn;
GtRegionNode *rn;
GtError *err;
gt_assert(L);
fi = check_feature_index(L, 1);
gn = check_genome_node(L, 2);
rn = gt_region_node_try_cast(*gn);
luaL_argcheck(L, rn, 2, "not a region node");
err = gt_error_new();
if (gt_feature_index_add_region_node(*fi, rn, err))
return gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int feature_index_lua_has_seqid(lua_State *L)
{
GtFeatureIndex **feature_index;
bool has_seqid;
const char *seqid;
GtError *err;
int had_err = 0;
feature_index = check_feature_index(L, 1);
seqid = luaL_checkstring(L, 2);
err = gt_error_new();
had_err = gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err);
if (had_err)
return gt_lua_error(L, err);
gt_error_delete(err);
lua_pushboolean(L, has_seqid);
return 1;
}
static int feature_index_lua_get_features_for_seqid(lua_State *L)
{
GtFeatureIndex **feature_index;
const char *seqid;
GtArray *features;
GtError *err;
feature_index = check_feature_index(L, 1);
seqid = luaL_checkstring(L, 2);
err = gt_error_new();
features = gt_feature_index_get_features_for_seqid(*feature_index, seqid,
err);
if (!features)
return gt_lua_error(L, err);
gt_error_delete(err);
push_features_as_table(L, features);
gt_array_delete(features);
return 1;
}
static int feature_index_lua_get_first_seqid(lua_State *L)
{
GtFeatureIndex **feature_index;
char *seqid;
GtError *err;
feature_index = check_feature_index(L, 1);
err = gt_error_new();
seqid = gt_feature_index_get_first_seqid(*feature_index, err);
if (gt_error_is_set(err))
return gt_lua_error(L, err);
gt_error_delete(err);
if (seqid) {
lua_pushstring(L, seqid);
gt_free(seqid);
} else
lua_pushnil(L);
return 1;
}
static int encseq_loader_lua_load(lua_State *L)
{
GtEncseqLoader **loader;
const char *indexname;
GtError *err = gt_error_new();
GtEncseq *encseq;
loader = check_encseq_loader(L, 1);
indexname = luaL_checkstring(L, 2);
gt_assert(*loader);
encseq = gt_encseq_loader_load(*loader, indexname, err);
if (encseq == NULL)
gt_lua_error(L, err);
else {
gt_lua_encseq_push(L, encseq);
}
gt_error_delete(err);
return 1;
}
static int imageinfo_lua_num_of_recmaps(lua_State *L)
{
GtImageInfo **ii;
GtUword nof_rm;
GtError *err = NULL;
ii = check_imageinfo(L, 1);
gt_assert(ii);
nof_rm = gt_image_info_num_of_rec_maps(*ii);
if (nof_rm > DBL_MAX)
{
err = gt_error_new();
gt_error_set(err, "number of recmaps exceeds %f!", DBL_MAX);
return gt_lua_error(L, err);
}
else
lua_pushnumber(L, (double) nof_rm);
gt_error_delete(err);
return 0;
}
static int imageinfo_lua_get_height(lua_State *L)
{
GtImageInfo **ii;
GtUword height;
GtError *err = NULL;
ii = check_imageinfo(L, 1);
gt_assert(ii);
height = gt_image_info_get_height(*ii);
if (height > DBL_MAX)
{
err = gt_error_new();
gt_error_set(err, "image height exceeds %f!", DBL_MAX);
return gt_lua_error(L, err);
}
else
lua_pushnumber(L, (double) height);
gt_error_delete(err);
return 0;
}
static int canvas_cairo_file_lua_to_file(lua_State *L)
{
GtCanvas **canvas;
GtCanvasCairoFile *ccf = NULL;
GtError *err;
const char *fn;
int had_err = 0;
canvas = check_canvas(L, 1);
ccf = canvas_cairo_file_try_cast(*canvas);
luaL_argcheck(L, ccf, 1, "must be a CanvasCairoFile object");
fn = luaL_checkstring(L, 2);
gt_assert(canvas);
err = gt_error_new();
had_err = gt_canvas_cairo_file_to_file(ccf, fn, err);
if (had_err)
return gt_lua_error(L, err);
gt_error_delete(err);
return 0;
}
static int stream_evaluator_lua_evaluate(lua_State *L)
{
GtStreamEvaluator **stream_evaluator;
GtNodeVisitor **genome_visitor;
GtError *err;
stream_evaluator = check_stream_evaluator(L);
if (lua_gettop(L) >= 2) {
genome_visitor = check_genome_visitor(L, 2);
}
else
genome_visitor = NULL;
err = gt_error_new();
if (gt_stream_evaluator_evaluate(*stream_evaluator, false, false,
genome_visitor ? *genome_visitor : NULL, err)) {
return gt_lua_error(L, err);
}
gt_error_delete(err);
return 0;
}
static int layout_lua_new(lua_State *L)
{
GtLayout **layout;
GtDiagram **diagram;
unsigned int width;
GtStyle *style;
GtError *err;
diagram = check_diagram(L, 1);
width = luaL_checkint(L, 2);
/* create layout */
style = gt_lua_get_style_from_registry(L);
layout = lua_newuserdata(L, sizeof (GtLayout*));
gt_assert(layout);
err = gt_error_new();
*layout = gt_layout_new(*diagram, width, style, err);
if (gt_error_is_set(err))
return gt_lua_error(L, err);
gt_error_delete(err);
luaL_getmetatable(L, LAYOUT_METATABLE);
lua_setmetatable(L, -2);
return 1;
}
static int encseq_builder_lua_add_encoded(lua_State *L)
{
GtEncseqBuilder **builder;
const char *desc;
unsigned char *arr = NULL;
GtUword arrlen = 0;
GtError *err;
builder = check_encseq_builder(L, 1);
err = gt_error_new();
if (gt_lua_get_table_as_uchararray(L, 2, &arr, &arrlen, err) != 0) {
gt_lua_error(L, err);
}
if (lua_isnil(L, 3))
desc = "";
else
desc = luaL_checkstring(L, 3);
gt_assert(*builder);
gt_encseq_builder_add_encoded_own(*builder, arr, arrlen, desc);
gt_free(arr);
gt_error_delete(err);
return 0;
}
/* This stub only reports an error if trying to run a custom stream with no
custom behaviour implemented. */
static int gt_node_stream_lua_next_tree_fail(lua_State *L)
{
GtError *err = gt_error_new();
gt_error_set(err, "no custom 'next_tree' method defined in custom stream");
return gt_lua_error(L, err);
}
