static int read_command_sub(t_ast **tree, t_list **l, t_ast *n, t_token **t)
{
int i;
int j;
i = 0;
j = 0;
while (*t && is_valid_type((*t)->type))
{
if ((*t)->type == T_ANYTHING)
n->str[i++] = (*t)->str;
else
{
if (read_redir(l, n, t, &j) == FALSE)
return (syntax_error((*t)->str, *tree, n));
}
*l = (*l)->next;
*t = (*l) ? (t_token *)(*l)->content : NULL;
}
if (!*t && i <= 0)
return (FALSE);
if (i <= 0)
return (syntax_error((*t)->str, *tree, n));
*tree = n;
return (TRUE);
}
const xlb_struct_type_info *
xlb_get_struct_type_info(adlb_struct_type type)
{
if (is_valid_type(type))
return &struct_types[type];
else
return NULL;
}
CassError check(const T value) {
IsValidDataType<T> is_valid_type;
size_t index = items_.size();
switch(type()) {
case CASS_COLLECTION_TYPE_MAP:
if (data_type_->types().size() == 2 &&
!is_valid_type(value, data_type_->types()[index % 2])) {
return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
}
break;
case CASS_COLLECTION_TYPE_LIST:
case CASS_COLLECTION_TYPE_SET:
if (data_type_->types().size() == 1 &&
!is_valid_type(value, data_type_->types()[0])) {
return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
}
break;
}
return CASS_OK;
}
static struct Entry decode_id(ID id)
{
struct Entry entry = {-1, -1};
const int type = id / TYPE_ID_OFFSET;
if (!is_valid_type(type))
return entry;
entry.type = type;
entry.index = id - (type * TYPE_ID_OFFSET);
return entry;
}
char *xlb_struct_repr(adlb_struct *s)
{
if (is_valid_type(s->type))
{
xlb_struct_type_info *t = &struct_types[s->type];
int total_len = 0;
char *field_reprs[t->field_count];
total_len += (int)strlen(t->type_name) + 5;
for (int i = 0; i < t->field_count; i++)
{
if (s->fields[i].initialized)
{
field_reprs[i] = ADLB_Data_repr(&s->fields[i].data,
t->field_types[i].type);
total_len += (int)strlen(field_reprs[i]);
}
else
{
field_reprs[i] = NULL;
total_len += 4; // "NULL"
}
total_len += (int)strlen(t->field_names[i]);
total_len += 7; // Extra chars
}
char *result = malloc((size_t)total_len + 1);
char *pos = result;
pos += sprintf(pos, "%s: {", t->type_name);
for (int i = 0; i < t->field_count; i++)
{
if (field_reprs[i] != NULL)
{
pos += sprintf(pos, " {%s}={%s},", t->field_names[i], field_reprs[i]);
free(field_reprs[i]);
}
else
{
pos += sprintf(pos, " {%s}=NULL,", t->field_names[i]);
}
}
sprintf(pos, " }");
return result;
}
else
{
char *result;
int n = asprintf(&result, "<bad struct type %i>", s->type);
assert(n != -1);
return result;
}
}
/**
* mipv6_bcache_delete - delete Binding Cache entry
* @home_addr: MN's home address
* @type: type of entry
*
* Deletes an entry associated with @home_addr from Binding Cache.
* Valid values for @type are %CACHE_ENTRY, %HOME_REGISTRATION and
* %ANY_ENTRY. %ANY_ENTRY deletes any type of entry.
**/
int mipv6_bcache_delete(struct in6_addr *home_addr, __u8 type)
{
unsigned long flags;
struct mipv6_bcache_entry *entry;
DEBUG_FUNC();
if (home_addr == NULL || !is_valid_type(type)) {
DEBUG((DBG_INFO, "error in arguments"));
return -1;
}
write_lock_irqsave(&bcache->lock, flags);
entry = (struct mipv6_bcache_entry *)
hashlist_get(bcache->entries, home_addr);
if (entry == NULL) {
DEBUG((DBG_INFO, "mipv6_bcache_delete: No such entry"));
write_unlock_irqrestore(&bcache->lock, flags);
return -1;
}
if (!(entry->type & type)) {
DEBUG((DBG_INFO, "mipv6_bcache_delete: No entry with "
"type correct type"));
write_unlock_irqrestore(&bcache->lock, flags);
return -1;
}
if (type == HOME_REGISTRATION) {
mipv6_tunnel_route_del(&entry->home_addr,
&entry->coa,
&entry->our_addr);
mipv6_tunnel_del(&entry->coa, &entry->our_addr);
bcache_proxy_nd_rem(entry);
}
hashlist_delete(bcache->entries, &entry->home_addr);
mipv6_bcache_entry_free(entry);
set_timer();
write_unlock_irqrestore(&bcache->lock, flags);
return 0;
}
int read_command(t_ast **tree, t_list **tokens)
{
t_ast *node;
t_token *t;
if (g_syntax_err)
return (FALSE);
if (!*tokens)
return (FALSE);
node = create_node();
node->type = N_CMD;
t = (t_token *)(*tokens)->content;
if (is_valid_type(t->type))
{
if (read_command_sub(tree, tokens, node, &t) == TRUE)
return (TRUE);
}
free(node);
return (FALSE);
}
/***************************************************************************
* set_variant
*
* set the variant based on the type passed in
***************************************************************************/
void set_variant(VARIANT *variant, int var_type, void *data)
{
variant->type = var_type;
variant->state = (is_valid_type(var_type)) ? VARIANT_OK : VARIANT_ERROR;
variant->data = data;
}
int load_cmd_tbl(FILE *fp)
{
int i, k;
int readreq;
char istr[MAX_ISTR_LEN];
char *sp;
PARA_TBL *para_tbl;
if ((i = load_def_enumlist(fp, istr)) < 0)
return i;
readreq = 1;
num_cmd_tbl = 0;
while (1)
{
if (readreq == 0)
if (fgets(istr, MAX_ISTR_LEN, fp) == NULL)
break;
set_istr(istr);
log_print(LOGN_DEBUG, "DEBUG: %s", istr);
readreq = 0;
if ((sp = get_string(NULL)) == NULL)
continue;
i = 0;
cmd_tbl[num_cmd_tbl].com_name = &JCstr_buff[ptr_JCstr];
while (*sp)
{
JCstr_buff[ptr_JCstr + i] = toupper(*sp++);
i++;
}
JCstr_buff[ptr_JCstr + i] = 0;
ptr_JCstr += (i + 1);
if ((cmd_tbl[num_cmd_tbl].code = get_digit_int()) < 0) {
log_print(LOGN_CRI, "INVALID CMD1 : [%d] ",
cmd_tbl[num_cmd_tbl].code );
return eINVALID_CMD;
}
log_print(LOGN_INFO, "num_cmd_tbl[%d] cmd_tbl_mcode[%d]",
num_cmd_tbl, cmd_tbl[num_cmd_tbl].code );
if (cmd_tbl[num_cmd_tbl].code >= MAX_LIB_TABLE)
continue;
if ((sp = get_string(NULL)) == NULL) {
log_print(LOGN_CRI, "INVALID CMD2 : [%s] ",
sp );
return eINVALID_CMD;
}
if (strcmp("MP", sp) != 0) return eINVALID_SUBSYSTEM;
if ((sp = get_string(NULL)) == NULL) {
log_print(LOGN_CRI, "INVALID CMD2 : [%s] ",
sp );
return eINVALID_CMD;
}
if ((para_tbl = get_para_tbl(sp)) == NULL)
{
log_print(LOGN_CRI, "[ERROR] NOT FOUND BLOCK ID: sp=[%s]%s", sp, &cmds_str[cmds_ptr]);
return eINVALID_CMD;
}
cmd_tbl[num_cmd_tbl].dest = para_tbl->code;
if ((cmd_tbl[num_cmd_tbl].access = get_digit_int()) < 0)
return eINVALID_PAPA_IN_CMD;
if ((cmd_tbl[num_cmd_tbl].num_para = get_digit_int()) < 0)
return eINVALID_PAPA_IN_CMD;
if ((cmd_tbl[num_cmd_tbl].p_man = get_digit_int()) < 0)
return eINVALID_PAPA_IN_CMD;
if (cmd_tbl[num_cmd_tbl].num_para >= MAX_PAR_IN_COM)
return eINVALID_PAPA_IN_CMD;
for (i = 0;i < cmd_tbl[num_cmd_tbl].num_para;i++)
{
if ((sp = get_string(NULL)) == NULL)
return eINVALID_PAPA_CONTENT;
if ((para_tbl = get_para_tbl(sp)) == NULL)
{
log_print(LOGN_CRI,"[ERROR] NOT FOUND: sp=[%s]%s I=%d TT()%s\n",
sp, &cmds_str[cmds_ptr], i, cmds_str);
log_print(LOGN_CRI,"[ERROR] NOT FOUND: sp=[%s]%s I=%d TT()%s",
sp, &cmds_str[cmds_ptr], i, cmds_str);
return eINVALID_PAPA_CONTENT;
}
cmd_tbl[num_cmd_tbl].para[i].idx = para_tbl->code;
cmd_tbl[num_cmd_tbl].para[i].para_name = para_tbl->para_name;
if ((sp = get_string(NULL)) == NULL)
return eINVALID_PAPA_CONTENT;
if ((cmd_tbl[num_cmd_tbl].para[i].type = is_valid_type(sp)) < 0)
return cmd_tbl[num_cmd_tbl].para[i].type;
if (cmd_tbl[num_cmd_tbl].para[i].type == VT_ENUM
|| cmd_tbl[num_cmd_tbl].para[i].type == VT_EPOS)
{
if ((sp = get_string(NULL)) == NULL)
return eINVALID_PAPA_IN_CMD;
if ((para_tbl = get_para_tbl(sp)) == NULL)
{
log_print(LOGN_CRI,"[ERROR] ENUM NOT FOUND: %s", sp);
return eENUM_LIST_ELEMENT;
}
cmd_tbl[num_cmd_tbl].para[i].def_value = para_tbl->code;
cmd_tbl[num_cmd_tbl].para[i].def_name = para_tbl->para_name;
if ((k = set_enum_para(&cmd_tbl[num_cmd_tbl].para[i].start,
&cmd_tbl[num_cmd_tbl].para[i].end)) < 0)
return k;
}
else
{
if ((sp = get_string(NULL)) == NULL)
return eINVALID_PAPA_IN_CMD;
cmd_tbl[num_cmd_tbl].para[i].def_value = atol(sp);
cmd_tbl[num_cmd_tbl].para[i].start = get_digit_int64();
cmd_tbl[num_cmd_tbl].para[i].end = get_digit_int64();
}
}
/* #@D,1,2,3 확장 영역 */
if (fgets(istr, MAX_ISTR_LEN, fp) == NULL)
break;
/* 1번째 라인의 MAGIC CODE */
readreq = 1;
if (istr[0] != '#' || istr[1] != '@' || istr[2] != 'D')
continue;
set_istr(&istr[3]);
/* PRN function loading */
if ((sp = get_string(NULL)) == NULL)
return eNOT_FOUND_PRN_FUNC;
if (set_lib_entry(cmd_tbl[num_cmd_tbl].code, sp) <= 0)
return eNOT_FOUND_PRN_FUNC;
/* 메시지 코드 기록 */
if ((sp = get_string(NULL)) == NULL || *sp != 'M')
return eMANDATORY_MISSED;
else
lib_tbl[cmd_tbl[num_cmd_tbl].code].mcode = atoi(sp + 1);
lib_tbl[cmd_tbl[num_cmd_tbl].code].com_name = cmd_tbl[num_cmd_tbl].com_name;
lib_tbl[cmd_tbl[num_cmd_tbl].code].block = cmd_tbl[num_cmd_tbl].dest;
/* MMC HEADER 수록 */
if ((sp = get_string(NULL)) == NULL)
return eMANDATORY_MISSED;
lib_tbl[cmd_tbl[num_cmd_tbl].code].msg_header = &JCstr_buff[ptr_JCstr];
strcpy(&JCstr_buff[ptr_JCstr], sp);
ptr_JCstr += (strlen(&JCstr_buff[ptr_JCstr]) + 1);
/* Option Value 초기화 */
cmd_tbl[num_cmd_tbl].help[0] = NULL;
cmd_tbl[num_cmd_tbl].help[1] = NULL;
cmd_tbl[num_cmd_tbl].help[2] = NULL;
num_cmd_tbl++;
for (i = 0;i < 3;i++)
{
if (fgets(istr, MAX_ISTR_LEN, fp) == NULL)
break;
if (istr[0] == '#' && istr[1] == '@' && istr[2] == '1' + i)
{
set_istr(&istr[3]);
sp = get_string(NULL);
cmd_tbl[num_cmd_tbl - 1].help[i] = &JCstr_buff[ptr_JCstr];
strcpy(&JCstr_buff[ptr_JCstr], sp);
ptr_JCstr += (strlen(&JCstr_buff[ptr_JCstr]) + 1);
readreq = 0;
} else
break;
}
}
/* qsort */
qsort((void *)cmd_tbl, num_cmd_tbl, sizeof(COM_TBL), cmd_cmp_sort);
return 1;
}
void ApplicationWindow::addTabs()
{
v4l2_queryctrl qctrl;
unsigned ctrl_class;
unsigned i;
int id;
memset(&qctrl, 0, sizeof(qctrl));
qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
while (queryctrl(qctrl)) {
if (is_valid_type(qctrl.type) &&
(qctrl.flags & V4L2_CTRL_FLAG_DISABLED) == 0) {
m_ctrlMap[qctrl.id] = qctrl;
if (qctrl.type != V4L2_CTRL_TYPE_CTRL_CLASS)
m_classMap[V4L2_CTRL_ID2CLASS(qctrl.id)].push_back(qctrl.id);
}
qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
}
if (qctrl.id == V4L2_CTRL_FLAG_NEXT_CTRL) {
strcpy((char *)qctrl.name, "User Controls");
qctrl.id = V4L2_CTRL_CLASS_USER | 1;
qctrl.type = V4L2_CTRL_TYPE_CTRL_CLASS;
m_ctrlMap[qctrl.id] = qctrl;
for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
qctrl.id = id;
if (!queryctrl(qctrl))
continue;
if (!is_valid_type(qctrl.type))
continue;
if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
continue;
m_ctrlMap[qctrl.id] = qctrl;
m_classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
}
for (qctrl.id = V4L2_CID_PRIVATE_BASE;
queryctrl(qctrl); qctrl.id++) {
if (!is_valid_type(qctrl.type))
continue;
if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
continue;
m_ctrlMap[qctrl.id] = qctrl;
m_classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
}
}
m_haveExtendedUserCtrls = false;
for (unsigned i = 0; i < m_classMap[V4L2_CTRL_CLASS_USER].size(); i++) {
unsigned id = m_classMap[V4L2_CTRL_CLASS_USER][i];
if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64 ||
m_ctrlMap[id].type == V4L2_CTRL_TYPE_STRING ||
V4L2_CTRL_DRIVER_PRIV(id)) {
m_haveExtendedUserCtrls = true;
break;
}
}
for (ClassMap::iterator iter = m_classMap.begin(); iter != m_classMap.end(); ++iter) {
if (iter->second.size() == 0)
continue;
ctrl_class = V4L2_CTRL_ID2CLASS(iter->second[0]);
id = ctrl_class | 1;
m_col = m_row = 0;
m_cols = 4;
const v4l2_queryctrl &qctrl = m_ctrlMap[id];
QWidget *t = new QWidget(m_tabs);
QVBoxLayout *vbox = new QVBoxLayout(t);
QWidget *w = new QWidget(t);
vbox->addWidget(w);
QGridLayout *grid = new QGridLayout(w);
grid->setSpacing(3);
m_tabs->addTab(t, (char *)qctrl.name);
for (i = 0; i < iter->second.size(); i++) {
if (i & 1)
id = iter->second[(1+iter->second.size()) / 2 + i / 2];
else
id = iter->second[i / 2];
addCtrl(grid, m_ctrlMap[id]);
}
grid->addWidget(new QWidget(w), grid->rowCount(), 0, 1, m_cols);
grid->setRowStretch(grid->rowCount() - 1, 1);
w = new QWidget(t);
vbox->addWidget(w);
grid = new QGridLayout(w);
finishGrid(grid, ctrl_class);
}
}
adlb_data_code
ADLB_Unpack_struct(adlb_struct **s, const void *data, size_t length,
adlb_refc refcounts, bool init_struct)
{
adlb_data_code dc;
assert(s != NULL);
ADLB_CHECK_MSG_CODE(length >= sizeof(adlb_packed_struct_hdr), ADLB_DATA_ERROR_INVALID,
"buffer too small for serialized struct");
const adlb_packed_struct_hdr *hdr = data;
check_valid_type(hdr->type);
xlb_struct_type_info *t = &struct_types[hdr->type];
size_t min_length = sizeof(adlb_packed_struct_hdr) +
sizeof(hdr->field_offsets[0]) * (size_t)t->field_count;
ADLB_CHECK_MSG_CODE((size_t)length >= min_length, ADLB_DATA_ERROR_INVALID,
"buffer too small for header of struct type %s: is %zub, "
"but expected >= %zub", t->type_name, length, min_length);
if (init_struct)
{
*s = alloc_struct(t);
ADLB_CHECK_MSG_CODE(*s != NULL, ADLB_DATA_ERROR_OOM, "Couldn't allocate struct");
(*s)->type = hdr->type;
for (int i = 0; i < t->field_count; i++)
{
// Need to mark fields as uninitialized
(*s)->fields[i].initialized = false;
}
}
else
{
assert(is_valid_type((*s)->type));
ADLB_CHECK_MSG_CODE((*s)->type == hdr->type, ADLB_DATA_ERROR_TYPE,
"Type of target struct doesn't match source data: %s vs. %s",
struct_types[(*s)->type].type_name, t->type_name);
}
// Go through and assign all of the datums from the data in the buffer
for (int i = 0; i < t->field_count; i++)
{
size_t init_offset = hdr->field_offsets[i];
size_t data_offset = init_offset + 1;
bool field_init = (((char*)data)[init_offset] != 0);
if (field_init)
{
const void *field_start = ((const char*)data) + data_offset;
size_t field_len;
if (i == t->field_count - 1)
{
// Remainder of buffer
field_len = length - data_offset;
}
else
{
field_len = hdr->field_offsets[i + 1] - data_offset;
}
if ((*s)->fields[i].initialized)
{
// Free any existing data
dc = ADLB_Free_storage(&(*s)->fields[i].data,
t->field_types[i].type);
ADLB_DATA_CHECK_CODE(dc);
}
ADLB_Unpack(&(*s)->fields[i].data, t->field_types[i].type,
field_start, field_len, refcounts);
(*s)->fields[i].initialized = true;
}
}
return ADLB_DATA_SUCCESS;
}
static int set_property(const struct Entry *entry,
const char *name, const struct PropertyValue *value)
{
const struct Property *src_props = NULL;
void *dst_object = NULL;
/* procedure and shader object properties */
if (entry->type == Type_Procedure) {
struct Procedure *procedure = ScnGetProcedure(scene, entry->index);
if (procedure == NULL)
return SI_FAIL;
return PrcSetProperty(procedure, name, value);
}
else if (entry->type == Type_Shader) {
struct Shader *shader = ScnGetShader(scene, entry->index);
if (shader == NULL)
return SI_FAIL;
return ShdSetProperty(shader, name, value);
}
/* builtin object properties */
switch (entry->type) {
case Type_ObjectInstance:
dst_object = ScnGetObjectInstance(scene, entry->index);
src_props = ObjectInstance_properties;
break;
case Type_Turbulence:
dst_object = ScnGetTurbulence(scene, entry->index);
src_props = Turbulence_properties;
break;
case Type_Procedure:
assert(!is_valid_type(entry->type) && "Should not be here!");
break;
case Type_Renderer:
dst_object = ScnGetRenderer(scene, entry->index);
src_props = Renderer_properties;
break;
case Type_Volume:
dst_object = ScnGetVolume(scene, entry->index);
src_props = Volume_properties;
break;
case Type_Camera:
dst_object = ScnGetCamera(scene, entry->index);
src_props = Camera_properties;
break;
case Type_Shader:
assert(!is_valid_type(entry->type) && "Should not be here!");
break;
case Type_Light:
dst_object = ScnGetLight(scene, entry->index);
src_props = Light_properties;
break;
default:
assert(!is_valid_type(entry->type) && "Some types are not implemented yet");
break;
}
if (dst_object == NULL)
return -1;
return find_and_set_property(dst_object, src_props, name, value);
}
