void
define_type (symbol_t * type_symbol,
unsigned block_level,
pascal_type type,
void * type_ptr)
{
translate_type (type, type_ptr);
out_s (" ");
#if 1 // experimental
if (type == POINTER_NODE)
{
out_s ("*");
}
#endif
out_s (type_symbol->s_repr);
if (type == ARRAY_NODE)
{
out_dimensions (reinterpret_cast<array_node*>(type_ptr));
}
if (type == NAMED_TYPE_NODE)
{
if (NT->name->s_kind != TYPE_IDENTIFIER)
{
c4p_error ("`%s' is no a type identifier", NT->name->s_repr);
}
type = NT->name->s_type;
type_ptr = NT->name->s_type_ptr;
}
define_symbol (type_symbol, TYPE_IDENTIFIER, block_level, type, type_ptr, 0);
}
void
declare_var_list (declarator_node * vars,
unsigned kind,
unsigned block_level,
pascal_type type,
void * type_ptr)
{
declarator_node * start = vars;
const char * translated_type = translate_type(type, type_ptr);
out_s (" ");
while (vars != 0)
{
if (is_fast_var (vars->name->s_repr))
{
vars->name->s_flags |= S_FAST;
}
if (type == POINTER_NODE)
{
out_s ("*");
}
if (block_level == 0 && kind == VARIABLE_IDENTIFIER)
{
out_s (var_name_prefix.c_str());
}
out_s (vars->name->s_repr);
if (type == ARRAY_NODE)
{
out_dimensions (reinterpret_cast<array_node*>(type_ptr));
}
vars->name->s_translated_type = translated_type;
vars = vars->next;
if (vars != 0)
{
out_s (", ");
}
}
type = flatten_type(type, type_ptr, &type_ptr);
vars = start;
while (vars != 0)
{
vars->name = define_symbol(vars->name, kind, block_level,
type, type_ptr, 0);
vars = vars->next;
}
}
const char *
translate_type (pascal_type type,
const void * type_ptr)
{
const char * ret = 0;
switch (type)
{
case NAMED_TYPE_NODE:
ret = (NT->name->s_translated_type
? NT->name->s_translated_type
: NT->name->s_repr);
out_s (ret);
break;
case BOOLEAN_TYPE:
NT->name->s_repr = "C4P_boolean";
out_s ("C4P_boolean");
break;
case CHARACTER_TYPE:
NT->name->s_repr = "char";
out_s ("char");
break;
case INTEGER_TYPE:
NT->name->s_repr = "C4P_integer";
out_s ("C4P_integer");
break;
case LONG_INTEGER_TYPE:
NT->name->s_repr = "C4P_longinteger";
out_s ("C4P_longinteger");
break;
case REAL_TYPE:
NT->name->s_repr = "float";
out_s ("float");
break;
case LONG_REAL_TYPE:
NT->name->s_repr = "double";
out_s ("double");
break;
case ARRAY_NODE:
ret = translate_type (ARR->component_type, ARR->component_type_ptr);
break;
case POINTER_NODE:
#if 1
ret = translate_type (PTR->component_type, PTR->component_type_ptr);
#else
ret = translate_type (PTR->component_type, PTR->component_type_ptr);
#endif
break;
case SUBRANGE_NODE:
ret = subrange (SUB->lower_bound, SUB->upper_bound);
out_s (ret);
break;
case RECORD_NODE:
out_s ("struct {\n");
++ curly_brace_level;
translate_type (FIELD_LIST_NODE, REC->field_list);
-- curly_brace_level;
out_s ("}");
break;
case FIELD_LIST_NODE:
if (FL->fixed_part != 0)
{
translate_type (RECORD_SECTION_NODE, FL->fixed_part);
}
if (FL->variant_part != 0)
{
translate_type (VARIANT_NODE, FL->variant_part);
}
break;
case RECORD_SECTION_NODE:
declare_var_list (RS->name, FIELD_IDENTIFIER, UINT_MAX,
RS->type, RS->type_ptr);
out_s (";\n");
if (RS->next != 0)
{
translate_type (RECORD_SECTION_NODE, RS->next);
}
break;
case VARIANT_NODE:
out_s ("union {\n");
++ curly_brace_level;
if (V->variant_field_list != 0)
{
translate_type (VARIANT_FIELD_LIST_NODE, V->variant_field_list);
}
-- curly_brace_level;
out_form ("} %s;\n", V->pseudo_name->s_repr);
break;
case VARIANT_FIELD_LIST_NODE:
if (VFL->pseudo_name != 0)
{
out_s ("struct {\n");
++ curly_brace_level;
}
if (VFL->fixed_part != 0)
{
translate_type (RECORD_SECTION_NODE, VFL->fixed_part);
}
if (VFL->variant_part != 0)
{
translate_type (VARIANT_NODE, VFL->variant_part);
}
if (VFL->pseudo_name != 0)
{
-- curly_brace_level;
out_form ("} %s;\n", VFL->pseudo_name->s_repr);
}
if (VFL->next != 0)
{
translate_type (VARIANT_FIELD_LIST_NODE, VFL->next);
}
break;
case FILE_NODE:
if (FIL->type == CHARACTER_TYPE
|| (FIL->type == NAMED_TYPE_NODE
&& (((named_type_node *) FIL->type_ptr)->name->s_type
== CHARACTER_TYPE)))
{
out_s ("C4P_text");
}
else
{
out_s ("C4P_FILE_STRUCT(");
translate_type (FIL->type, FIL->type_ptr);
out_s (")");
}
FIL->type = flatten_type(FIL->type, FIL->type_ptr, &FIL->type_ptr);
break;
default:
c4p_error ("internal error: translate_type: unknown node type: %u", type);
}
return (ret);
}
/*
* Init the control interface - Creates a list of controls
*/
JNIEXPORT jobjectArray JNICALL Java_au_edu_jcu_v4l4j_VideoDevice_doGetControlList(JNIEnv *e, jobject t, jlong object){
dprint(LOG_CALLS, "[CALL] Entering %s\n",__PRETTY_FUNCTION__);
struct v4l4j_device *d = (struct v4l4j_device *) (uintptr_t) object;
struct control_list *l;
jclass v4l2ControlClass;
jmethodID ctor;
jobjectArray ctrls, names_array;
jintArray values_array;
jobject element;
int i, type;
dprint(LOG_LIBVIDEO, "[LIBVIDEO] Calling get_control_list()\n");
l = get_control_list(d->vdev);
//Creates the java objects matching v4l2 controls
dprint(LOG_V4L4J, "[V4L4J] Creating the Control array[%d]\n", l->count);
v4l2ControlClass = (*e)->FindClass(e,CONTROL_CLASS);
if(v4l2ControlClass == NULL){
info("[V4L4J] Error looking up the Control class\n");
release_control_list(d->vdev);
THROW_EXCEPTION(e, JNI_EXCP, "Error looking up Control class");
return 0;
}
ctor = (*e)->GetMethodID(e, v4l2ControlClass, "<init>", "(ILjava/lang/String;IIII[Ljava/lang/String;[IJ)V");
if(ctor == NULL){
info("[V4L4J] Error looking up the Control class constructor\n");
release_control_list(d->vdev);
THROW_EXCEPTION(e, JNI_EXCP, "Error looking up Control class constructor");
return 0;
}
//initialise the ctrls field of FrameGrabber object (this)
ctrls = (*e)->NewObjectArray(e, l->count, v4l2ControlClass, NULL);
if(ctrls == NULL){
info("[V4L4J] Error creating the control array\n");
release_control_list(d->vdev);
THROW_EXCEPTION(e, JNI_EXCP, "Error creating the control array");
return 0;
}
//Construct a V4L2Control Java object for each V4L2control in l
for(i = 0; i< l->count; i++) {
if(l->controls[i].count_menu==0) {
values_array = NULL;
names_array = NULL;
} else {
//create the values and names arrays
if((values_array = get_values(e,&l->controls[i])) == NULL) {
release_control_list(d->vdev);
return 0;
}
if((names_array = get_names(e,&l->controls[i])) ==NULL){
release_control_list(d->vdev);
return 0;
}
}
if((type = translate_type(e, l->controls[i].v4l2_ctrl->type))==-1)
return 0;
dprint(LOG_V4L4J, "[V4L4J] Creating Control %d - name: %s - type: %d\n", i, l->controls[i].v4l2_ctrl->name, type);
element = (*e)->NewObject(e, v4l2ControlClass, ctor, i,\
(*e)->NewStringUTF(e, (const char *)l->controls[i].v4l2_ctrl->name),\
l->controls[i].v4l2_ctrl->minimum, l->controls[i].v4l2_ctrl->maximum, \
l->controls[i].v4l2_ctrl->step, type, names_array, values_array, object);
if(element == NULL){
info("[V4L4J] Error creating the control '%s'\n", l->controls[i].v4l2_ctrl->name);
release_control_list(d->vdev);
THROW_EXCEPTION(e, JNI_EXCP, "Error creating the control '%s'", l->controls[i].v4l2_ctrl->name);
return 0;
}
(*e)->SetObjectArrayElement(e, ctrls, i, element);
}
return ctrls;
}
