static int parse(int c, char **argv, int invert, unsigned int *flags,
const struct ipt_entry *entry, unsigned int *nfcache,
struct ipt_entry_match **match)
{
struct ipt_addrtype_info *info =
(struct ipt_addrtype_info *) (*match)->data;
switch (c) {
case '1':
if (*flags&IPT_ADDRTYPE_OPT_SRCTYPE)
exit_error(PARAMETER_PROBLEM,
"addrtype: can't specify src-type twice");
check_inverse(optarg, &invert, &optind, 0);
parse_types(argv[optind-1], &info->source);
if (invert)
info->invert_source = 1;
*flags |= IPT_ADDRTYPE_OPT_SRCTYPE;
break;
case '2':
if (*flags&IPT_ADDRTYPE_OPT_DSTTYPE)
exit_error(PARAMETER_PROBLEM,
"addrtype: can't specify dst-type twice");
check_inverse(optarg, &invert, &optind, 0);
parse_types(argv[optind-1], &info->dest);
if (invert)
info->invert_dest = 1;
*flags |= IPT_ADDRTYPE_OPT_DSTTYPE;
break;
default:
return 0;
}
return 1;
}
static int
addrtype_parse_v1(int c, char **argv, int invert, unsigned int *flags,
const void *entry, struct xt_entry_match **match)
{
struct ipt_addrtype_info_v1 *info =
(struct ipt_addrtype_info_v1 *) (*match)->data;
switch (c) {
case '1':
if (*flags & IPT_ADDRTYPE_OPT_SRCTYPE)
xtables_error(PARAMETER_PROBLEM,
"addrtype: can't specify src-type twice");
xtables_check_inverse(optarg, &invert, &optind, 0);
parse_types(argv[optind-1], &info->source);
if (invert)
info->flags |= IPT_ADDRTYPE_INVERT_SOURCE;
*flags |= IPT_ADDRTYPE_OPT_SRCTYPE;
break;
case '2':
if (*flags & IPT_ADDRTYPE_OPT_DSTTYPE)
xtables_error(PARAMETER_PROBLEM,
"addrtype: can't specify dst-type twice");
xtables_check_inverse(optarg, &invert, &optind, 0);
parse_types(argv[optind-1], &info->dest);
if (invert)
info->flags |= IPT_ADDRTYPE_INVERT_DEST;
*flags |= IPT_ADDRTYPE_OPT_DSTTYPE;
break;
case '3':
if (*flags & IPT_ADDRTYPE_OPT_LIMIT_IFACE_IN)
xtables_error(PARAMETER_PROBLEM,
"addrtype: can't specify limit-iface-in twice");
info->flags |= IPT_ADDRTYPE_LIMIT_IFACE_IN;
*flags |= IPT_ADDRTYPE_OPT_LIMIT_IFACE_IN;
break;
case '4':
if (*flags & IPT_ADDRTYPE_OPT_LIMIT_IFACE_OUT)
xtables_error(PARAMETER_PROBLEM,
"addrtype: can't specify limit-iface-out twice");
info->flags |= IPT_ADDRTYPE_LIMIT_IFACE_OUT;
*flags |= IPT_ADDRTYPE_OPT_LIMIT_IFACE_OUT;
break;
default:
return 0;
}
return 1;
}
int rtapi_app_main(void)
{
int n, numchan, max_depth, retval;
fifo_t tmp_fifo[MAX_SAMPLERS];
/* validate config info */
for ( n = 0 ; n < MAX_SAMPLERS ; n++ ) {
if (( cfg[n] == NULL ) || ( *cfg == '\0' ) || ( depth[n] <= 0 )) {
break;
}
tmp_fifo[n].num_pins = parse_types(&(tmp_fifo[n]), cfg[n]);
if ( tmp_fifo[n].num_pins == 0 ) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SAMPLER: ERROR: bad config string '%s'\n", cfg[n]);
return -EINVAL;
}
/* allow one extra "slot" for the sample number */
max_depth = MAX_SHMEM / (sizeof(shmem_data_t) * (tmp_fifo[n].num_pins + 1));
if ( depth[n] > max_depth ) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SAMPLER: ERROR: depth too large, max is %d\n", max_depth);
return -ENOMEM;
}
tmp_fifo[n].depth = depth[n];
}
if ( n == 0 ) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SAMPLER: ERROR: no channels specified\n");
return -EINVAL;
}
numchan = n;
/* clear shmem IDs */
for ( n = 0 ; n < MAX_SAMPLERS ; n++ ) {
shmem_id[n] = -1;
}
/* have good config info, connect to the HAL */
comp_id = hal_init("sampler");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "SAMPLER: ERROR: hal_init() failed\n");
return -EINVAL;
}
/* create the samplers - allocate memory, export pins, etc. */
for (n = 0; n < numchan; n++) {
retval = init_sampler(n, &(tmp_fifo[n]));
if (retval != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SAMPLER: ERROR: sampler %d init failed\n", n);
hal_exit(comp_id);
return retval;
}
}
rtapi_print_msg(RTAPI_MSG_INFO,
"SAMPLER: installed %d data samplers\n", numchan);
hal_ready(comp_id);
return 0;
}
static void addrtype_parse_v0(struct xt_option_call *cb)
{
struct ipt_addrtype_info *info = cb->data;
xtables_option_parse(cb);
switch (cb->entry->id) {
case O_SRC_TYPE:
parse_types(cb->arg, &info->source);
if (cb->invert)
info->invert_source = 1;
break;
case O_DST_TYPE:
parse_types(cb->arg, &info->dest);
if (cb->invert)
info->invert_dest = 1;
break;
}
}
static void addrtype_parse_v1(struct xt_option_call *cb)
{
struct ipt_addrtype_info_v1 *info = cb->data;
xtables_option_parse(cb);
switch (cb->entry->id) {
case O_SRC_TYPE:
parse_types(cb->arg, &info->source);
if (cb->invert)
info->flags |= IPT_ADDRTYPE_INVERT_SOURCE;
break;
case O_DST_TYPE:
parse_types(cb->arg, &info->dest);
if (cb->invert)
info->flags |= IPT_ADDRTYPE_INVERT_DEST;
break;
case O_LIMIT_IFACE_IN:
info->flags |= IPT_ADDRTYPE_LIMIT_IFACE_IN;
break;
case O_LIMIT_IFACE_OUT:
info->flags |= IPT_ADDRTYPE_LIMIT_IFACE_OUT;
break;
}
}
int parse_config(const string & filename, config::config & conf) {
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(filename.c_str());
if (! result) {
cerr << "XML [" << filename << "] parsed with errors, attr value: [" << doc.child("node").attribute("attr").value() << "]" << endl;
cerr << "Error description: " << result.description() << endl;
cerr << "Error offset: " << result.offset << endl;
return 0;
}
pugi::xml_node root = doc.child("generator");
pugi::xml_node graph_node = root.child("graph");
unsigned int nodes = graph_node.child("nodes").text().as_uint();
unsigned int edges = graph_node.child("edges").text().as_uint();
if(conf.nb_nodes == 0) {
conf.nb_nodes = nodes;
}
conf.input = filename;
conf.nb_edges = edges;
pugi::xml_node predicates = root.child("predicates");
if (!predicates.empty()) {
parse_predicates(predicates, conf);
}
pugi::xml_node types = root.child("types");
if (!types.empty()) {
parse_types(types, conf);
}
pugi::xml_node schema = root.child("schema");
if (!schema.empty()) {
parse_schema(schema, conf);
}
parse_workloads(root, conf);
return 1;
}
TypeDescriptor TypeParser::parse_types(bool is_reversed) {
CassValueType value_type = parse_one_type();
std::list<TypeDescriptor> type_args;
bool list_open = false;
size_t i;
while (index_ < type_buffer_.size() &&
(i = type_buffer_.find_first_of(",() ", index_)) != std::string::npos) {
switch (type_buffer_[i]) {
case ' ':
++index_;
break;
case ',':
if (list_open) {
CassValueType inner_type = parse_one_type(i);
type_args.push_back(TypeDescriptor(inner_type));
}
++index_;
break;
case '(':
list_open = true;
++index_;
type_args.push_back(parse_types(false));
break;
case ')':
{
CassValueType inner_type = parse_one_type(i);
type_args.push_back(TypeDescriptor(inner_type));
}
list_open = false;
++index_;
break;
default: // unexpected state
index_ = type_buffer_.size();
break;
}
if (!list_open) {
break;
}
}
return TypeDescriptor(value_type, is_reversed, type_args);
}
