int build_index(UCHAR *text, ULONG length, char *build_options, void **index){
char delimiters[] = " =;";
char filename[256];
int j,num_parameters;
char ** parameters;
int rankb_w=16,rankb_w2=128;
int free_text=false; /* don't free text by default */
if (build_options != NULL) {
// printf("build_options=%s\n",build_options);
parse_parameters(build_options,&num_parameters, ¶meters, delimiters);
for (j=0; j<num_parameters;j++) {
if ((strcmp(parameters[j], "samplerate") == 0 ) && (j < num_parameters-1) ) {
rankb_w=atoi(parameters[j+1]);
j++;
} else if ((strcmp(parameters[j], "samplepsi") == 0 ) && (j < num_parameters-1) ) {
rankb_w2=atoi(parameters[j+1]);
j++;
} else if ((strcmp(parameters[j], "filename") == 0 ) && (j < num_parameters-1) ) {
strcpy(filename,parameters[j+1]);
j++;
} else if (strcmp(parameters[j], "free_text") == 0 )
free_text=true;
}
free_parameters(num_parameters, ¶meters);
}
int n=length;
char fname1[128],fname2[128];
/* make the SA */
int i, *x, *p;
int k, l;
p= (int *)malloc((n+1)*sizeof *p);
x= (int *)malloc((n+1)*sizeof *x);
if (! p || ! x) {
return 1;
}
for ( i=0; i<n; i++) {
x[i]=text[i];
}
l=0;
k=UCHAR_MAX+1;
suffixsort(x, p, n, k, l);
free(x);
p[0] = n;
/* End Make SA */
/* ³Ì¶ñÍ 0..n-1 Å n ÔÚÉÍ 0 ªüéB
p[0] ÍK¸ n ÉÈéBp[1..n]É0..n-1ªüÁÄ¢éB*/
for (i=0; i<=n; ++i) p[i]++; /* p[1..n]É1..nªüÁÄ¢éBp[0]=n+1*/
sprintf(fname1,"%s.psi",filename);
sprintf(fname2,"%s.idx",filename);
csa_new(n,p,text,fname1,fname2,rankb_w,rankb_w2);
free(p);
if (free_text) free(text);
load_index(filename, index);
return 0;
}
/**
* soup_soap_response_from_string:
* @response: the #SoupSoapResponse object.
* @xmlstr: XML string to parse.
*
* Parses the string contained in @xmlstr and sets all properties from
* it in the @response object.
*
* Return value: %TRUE if successful, %FALSE otherwise.
*/
gboolean
soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr)
{
SoupSoapResponsePrivate *priv;
xmlDocPtr old_doc = NULL;
xmlNodePtr xml_root, xml_body, xml_method = NULL;
g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), FALSE);
priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
g_return_val_if_fail (xmlstr != NULL, FALSE);
/* clear the previous contents */
if (priv->xmldoc)
old_doc = priv->xmldoc;
/* parse the string */
priv->xmldoc = xmlParseMemory (xmlstr, strlen (xmlstr));
if (!priv->xmldoc) {
priv->xmldoc = old_doc;
return FALSE;
}
xml_root = xmlDocGetRootElement (priv->xmldoc);
if (!xml_root) {
xmlFreeDoc (priv->xmldoc);
priv->xmldoc = old_doc;
return FALSE;
}
if (strcmp ((const char *)xml_root->name, "Envelope") != 0) {
xmlFreeDoc (priv->xmldoc);
priv->xmldoc = old_doc;
return FALSE;
}
xml_body = soup_xml_real_node (xml_root->children);
if (xml_body != NULL) {
if (strcmp ((const char *)xml_body->name, "Header") == 0)
xml_body = soup_xml_real_node (xml_body->next);
if (strcmp ((const char *)xml_body->name, "Body") != 0) {
xmlFreeDoc (priv->xmldoc);
priv->xmldoc = old_doc;
return FALSE;
}
xml_method = soup_xml_real_node (xml_body->children);
/* read all parameters */
if (xml_method)
parse_parameters (priv, xml_method);
}
xmlFreeDoc (old_doc);
priv->xml_root = xml_root;
priv->xml_body = xml_body;
priv->xml_method = xml_method;
return TRUE;
}
int main(int argn, char **argv) {
Config config;
std::string graph_filename;
int ret_code = parse_parameters(argn, argv,
config,
graph_filename);
if(ret_code) {
return 0;
}
graph_access G;
timer t;
graph_io::readGraphWeighted(G, graph_filename);
std::cout << "io time: " << t.elapsed() << std::endl;
t.restart(); // restart timer for time measurements of our algorithms
//iterate over all nodes of the graph
forall_nodes(G, node) {
std::cout << "currently looking at node " << node << " : ";
//get all neighbors of the vertex node
forall_out_edges(G, e, node) {
//get the edge head of the current edge
NodeID target = G.getEdgeTarget(e);
std::cout << target << " ";
} endfor
int
main(int argc, char **argv)
{
int loop_number = 0;
startup_win_network();
parse_parameters(argc, argv);
init_network();
signal(SIGINT, sig_handler);
if (!quiet)
{
fprintf(stderr, "listening on port %d for packets .... \n", port_num);
if (continuous)
fprintf(stderr, "looping tests.\n");
fprintf(stderr, "\n");
}
fprintf(stdout, "# run no., loss rate in %%, packets_sent, packets_received, payload_size\n");
do
{
loop_number++;
fprintf(stdout, "%2d. ", loop_number);
run_server();
}
while (continuous);
return 1;
}
bool XMLParameterReader::read_xml_file(QIODevice *device)
{
xml.setDevice(device);
// We look for a StartElement "ParameterHandler"
// and start parsing after this.
// <ParameterHandler>
// <subsection>
// ...
// </subsection>
// </ParameterHandler>
while (xml.readNext() != QXmlStreamReader::Invalid)
{
if (xml.isStartElement())
if (xml.name() == "ParameterHandler")
{
parse_parameters();
return !xml.error();;
};
};
xml.raiseError(QObject::tr("The file is not an ParameterHandler XML file."));
return !xml.error();
}
static int parse_parameters_str(const char *str)
{
char *ptrs[64];
int num_ptrs = 0;
char buffer[1024];
char *start = buffer;
char *current = start;
char *end = buffer+sizeof(buffer);
int string_parse = 0;
ptrs[0] = start;
while(1)
{
/* fetch next character */
char c = *str++;
if(string_parse)
{
if(c == '"')
string_parse = 0;
else if(*str == 0)
{
printf("%s: error: unterminated \"\n", session.name);
return -1;
}
else
*current++ = c;
}
else
{
if(c == ' ' || c == '\t' || c == 0)
{
/* zero term and add this ptr */
*current++ = 0;
num_ptrs++;
ptrs[num_ptrs] = current;
}
else if(c == '"')
string_parse = 1;
else
*current++ = c;
}
if(current == end)
{
printf("%s: error: argument too long\n", session.name);
return -1;
}
/* break out on zero term */
if(!c)
break;
}
/* parse all the parameters */
return parse_parameters(num_ptrs, ptrs);
}
int main(int argc, char **argv)
{
int i;
struct details details;
struct gges_population *pop;
struct gges_parameters *params;
struct gges_bnf_grammar *G;
char bufvar[255];
struct timeval t;
gettimeofday(&t, NULL);
init_genrand(t.tv_usec);
details.b = atoi(argv[2]);
details.n = 1 << details.b;
details.data = generate_data(details.b);
params = gges_default_parameters();
params->rnd = genrand_real2;
i = 3; while (i < argc) {
if (strncmp(argv[i], "-p", 2) == 0) {
process_parameter(argv[i + 1], params);
i += 2;
} else {
parse_parameters(argv[i++], params);
}
}
G = gges_load_bnf(argv[1]);
/* add the features to the grammar, starting from the second
* variable. The current implementation requires us to
* "completely" specify the grammar in the source file, meaning
* that no non-terminals can be left incomplete, therefore, we
* have to include the first variable in the source file, and then
* start from the second one */
if (gges_grammar_has_non_terminal(G, "<bit>")) {
for (i = 1; i < details.b; ++i) {
sprintf(bufvar, "<bit> ::= b%d", i);
gges_extend_grammar(G, bufvar, true);
}
} else {
for (i = 1; i < details.b; ++i) {
sprintf(bufvar, "<B> ::= b%d", i);
gges_extend_grammar(G, bufvar, true);
}
}
pop = gges_run_system(params, G, eval, NULL, report, &details);
gges_release_population(pop);
free(params);
gges_release_grammar(G);
free_data(details.data);
return EXIT_SUCCESS;
}
static TpBaseConnection *
_tp_legacy_protocol_new_connection (TpBaseProtocol *protocol,
GHashTable *asv,
GError **error)
{
_TpLegacyProtocol *self = (_TpLegacyProtocol *) protocol;
const TpCMProtocolSpec *protospec = self->protocol_spec;
TpBaseConnectionManagerClass *cls;
TpBaseConnection *conn = NULL;
void *params = NULL;
TpIntset *params_present = NULL;
TpCMParamSetter set_param;
if (self->cm == NULL)
{
g_set_error (error, TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"Connection manager no longer available");
return NULL;
}
g_object_ref (self->cm);
g_assert (protospec->parameters != NULL);
g_assert (protospec->params_new != NULL);
g_assert (protospec->params_free != NULL);
cls = TP_BASE_CONNECTION_MANAGER_GET_CLASS (self->cm);
params_present = tp_intset_new ();
params = protospec->params_new ();
set_param = protospec->set_param;
if (set_param == NULL)
set_param = tp_cm_param_setter_offset;
if (!parse_parameters (protospec->parameters, (GHashTable *) asv,
params_present, set_param, params, error))
{
goto finally;
}
conn = (cls->new_connection) (self->cm, protospec->name, params_present,
params, error);
finally:
if (params_present != NULL)
tp_intset_destroy (params_present);
if (params != NULL)
protospec->params_free (params);
g_object_unref (self->cm);
return conn;
}
/*
* keymgr zone add <name> [policy <policy>]
*/
static int cmd_zone_add(int argc, char *argv[])
{
if (argc < 1) {
error("Missing zone name.");
return 1;
}
char *zone_name = argv[0];
char *policy = NULL;
static const parameter_t params[] = {
{ "policy", value_policy },
{ NULL }
};
if (parse_parameters(params, argc - 1, argv + 1, &policy) != 0) {
return 1;
}
// create zone
_cleanup_kasp_ dnssec_kasp_t *kasp = get_kasp();
if (!kasp) {
return 1;
}
int r = dnssec_kasp_zone_exists(kasp, zone_name);
if (r == DNSSEC_EOK) {
error("Zone with given name alredy exists.");
return 1;
} else if (r != DNSSEC_NOT_FOUND) {
error("Failed to check if given zone exists (%s).", dnssec_strerror(r));
return 1;
}
_cleanup_zone_ dnssec_kasp_zone_t *zone = dnssec_kasp_zone_new(zone_name);
if (!zone) {
error("Failed to create new zone.");
return 1;
}
r = dnssec_kasp_zone_set_policy(zone, policy);
if (r != DNSSEC_EOK) {
error("Unable to set zone policy.");
return 1;
}
r = dnssec_kasp_zone_save(kasp, zone);
if (r != DNSSEC_EOK) {
error("Failed to save new zone (%s).", dnssec_strerror(r));
return 1;
}
return 0;
}
int main(int ac, char **av)
{
t_env env;
if (ac < 2)
ft_exit("server: invalid arguments\nserver <port>", EXIT_FAILURE);
parse_parameters(&env, av);
build_host(&env);
run(&env);
return (EXIT_SUCCESS);
}
/*////////////////////
//Building the Index//
////////////////////*/
int build_index(uchar *text, ulong length, char *build_options, void **index){
/*if (text[length-1]!='\0') return 2;*/
ulong i, *p;
long overshoot;
TSA_Un *_index= (TSA_Un *) malloc(sizeof(TSA_Un));
uchar *x;
char delimiters[] = " =;";
int j,num_parameters;
char ** parameters;
int copy_text=false; /* don't copy text by default */
int free_text=false; /* don't free text by default */
if (!_index) return 1;
if (build_options != NULL) {
parse_parameters(build_options,&num_parameters, ¶meters, delimiters);
for (j=0; j<num_parameters;j++) {
if (strcmp(parameters[j], "copy_text") == 0 )
copy_text=true;
else if (strcmp(parameters[j], "free_text") == 0 )
free_text=true;
}
free_parameters(num_parameters, ¶meters);
}
/* Consistence of parameters */
if ((!copy_text) && (free_text))
return 5;
/* */
if ( !copy_text ) {
_index->text = text;
_index->own=false;
} else {
_index->text = (uchar *) malloc(sizeof(uchar)*length);
if (!_index->text) return 1;
for (i=0;i<length;i++) _index->text[i]=text[i];
_index->own=true;
}
if ( free_text )
free(text);
_index->n=length;
/* Make suffix array */
overshoot = init_ds_ssort(500, 2000);
p= (ulong *) malloc (sizeof(ulong)*(length));
if (!p) return 1;
x= (uchar *) malloc (sizeof(uchar)*(length+overshoot));
if (!x) return 1;
for (i=0;i<length;i++) x[i]=_index->text[i];
ds_ssort( x, p, _index->n);
free(x);
_index->pos = p;
(*index) = _index;
return 0;
}
int setDefaultSearchOptions_il (void *ail, char *search_options){
t_il *il = (t_il *) ail;
il->defs.defaultFsearch = NULL;
il->defs.defaultIntersect2 = NULL;
il->defs.defaultIntersectN = NULL;
/** processing the parameters */
char delimiters[] = " =;";
int j,num_parameters;
char ** parameters;
if (search_options != NULL) {
parse_parameters(search_options,&num_parameters, ¶meters, delimiters);
for (j=0; j<num_parameters;j++) {
//setting the default function to Intersect-2-lists
if ((strcmp(parameters[j], "int2") == 0 ) && (j < num_parameters-1) ) {
if (strcmp(parameters[j+1], "svs") == 0 )
il->defs.defaultIntersect2 = svs2;
else if (strcmp(parameters[j+1], "merge") == 0 )
il->defs.defaultIntersect2 = merge2;
j++;
}
//setting the default function to Intersect-N-lists
else if ((strcmp(parameters[j], "intn") == 0 ) && (j < num_parameters-1) ) {
if (strcmp(parameters[j+1], "svs") == 0 )
il->defs.defaultIntersectN = svsn;
else if (strcmp(parameters[j+1], "merge") == 0 )
il->defs.defaultIntersectN = mergeN;
j++;
}
//setting the default fSearch function used in svs-based algoritms.
else if ((strcmp(parameters[j], "fsearch") == 0 ) && (j < num_parameters-1) ) {
if (strcmp(parameters[j+1], "unc") == 0 )
il->defs.defaultFsearch = fsearchUnc;
//else if (strcmp(parameters[j+1], "dec") == 0 )
// il->defs.defaultFsearch = fsearchDec;
//else if (strcmp(parameters[j+1], "seq") == 0 )
// il->defs.defaultFsearch = fsearchSeq;
else if (strcmp(parameters[j+1], "seqM") == 0 )
il->defs.defaultFsearch = fsearchSeqMem;
j++;
}
}
free_parameters(num_parameters, ¶meters);
}
fprintf(stderr,"\n ** Call to setDefaultSearchOptions_il: \"%s\"\n", search_options);
return 0;
}
Polynomial::Polynomial( const std::string& e, const std::string& n, Object *p )
: Algorithm( n, p )
{
char* f = strdup( e.c_str() );
m_e = evaluator_create( f );
free( f );
if( !m_e )
{
throw std::invalid_argument( e + ": invalid polynomial" );
}
parse_parameters();
}
static status_t
parse_settings(settings_handle *handle)
{
char *text = handle->text;
memset(&handle->settings, 0, sizeof(struct driver_settings));
// empty settings are allowed
if (text == NULL)
return B_OK;
return parse_parameters(&handle->settings.parameters, &handle->settings.parameter_count, &text, 0);
}
static status_t
parse_parameters(struct driver_parameter **_parameters, int *_count, char **_pos, int32 level)
{
if (level > MAX_SETTINGS_LEVEL)
return B_LINK_LIMIT;
while (true) {
struct driver_parameter parameter;
struct driver_parameter *newArray;
status_t status;
status = parse_parameter(¶meter, _pos, level);
if (status < B_OK)
return status;
if (status != NO_PARAMETER) {
driver_parameter *newParameter;
newArray = realloc(*_parameters, (*_count + 1) * sizeof(struct driver_parameter));
if (newArray == NULL)
return B_NO_MEMORY;
memcpy(&newArray[*_count], ¶meter, sizeof(struct driver_parameter));
newParameter = &newArray[*_count];
*_parameters = newArray;
(*_count)++;
// check for level beginning and end
if (**_pos == '{') {
// if we go a level deeper, just start all over again...
(*_pos)++;
status = parse_parameters(&newParameter->parameters,
&newParameter->parameter_count, _pos, level + 1);
if (status < B_OK)
return status;
}
}
if ((**_pos == '}' && level > 0)
|| (**_pos == '\0' && level == 0)) {
// take the closing bracket from the stack
(*_pos)++;
return B_OK;
}
// obviously, something has gone wrong
if (**_pos == '}' || **_pos == '\0')
return B_ERROR;
}
}
int main(int argc, char **argv)
{
void *hnd;
int ret = 1;
int flags;
/* Parse command line options */
flags = parse_parameters(argc, argv);
/* Open the USB device */
hnd = open_ftdi_device(usb_vid, usb_pid, usb_interface, usb_serial);
if (hnd == NULL)
return 1;
/* Trigger embedded monitor detection */
if (send_special_waveform(hnd) < 0)
goto terminate;
if (config_i2c(hnd) < 0)
goto terminate;
if (check_chipid(hnd) < 0)
goto terminate;
if (flags & FLAG_UNPROTECT)
command_write_unprotect(hnd);
if (flags & FLAG_ERASE || output_filename)
command_erase(hnd, flash_size, 0);
if (input_filename) {
ret = read_flash(hnd, input_filename, 0, flash_size);
if (ret)
goto terminate;
}
if (output_filename) {
ret = write_flash(hnd, output_filename, 0);
if (ret)
goto terminate;
}
/* Normal exit */
ret = 0;
terminate:
/* Close the FTDI USB handle */
ftdi_usb_close(hnd);
ftdi_free(hnd);
return ret;
}
int main(int argc, char* argv[])
{
tool_initialization(argc, (const char**)argv);
initialize_default_values();
parse_parameters(argc, argv);
if (!prescanner.quiet)
{
fprintf(stderr, PACKAGE " Prescanner - Version " VERSION "\n");
}
fortran_prescanner_run(&prescanner);
return 0;
}
int main(int argn, char **argv) {
mis_log::instance()->restart_total_timer();
mis_log::instance()->print_title();
MISConfig mis_config;
std::string graph_filepath;
// Parse the command line parameters;
int ret_code = parse_parameters(argn, argv, mis_config, graph_filepath);
if (ret_code) {
return 0;
}
mis_config.graph_filename = graph_filepath.substr(graph_filepath.find_last_of( '/' ) +1);
mis_log::instance()->set_config(mis_config);
// Read the graph
graph_access G;
graph_io::readGraphWeighted(G, graph_filepath);
mis_log::instance()->set_graph(G);
// Print setup information
mis_log::instance()->print_graph();
mis_log::instance()->print_config();
// Perform the evolutionary algorithm
std::vector<bool> independent_set(G.number_of_nodes(), false);
reduction_evolution evo;
std::vector<NodeID> best_nodes;
evo.perform_mis_search(mis_config, G, independent_set, best_nodes);
mis_log::instance()->print_results();
if (mis_config.print_log) mis_log::instance()->write_log();
if (mis_config.write_graph) graph_io::writeIndependentSet(G, mis_config.output_filename);
std::cout << "checking solution ..." << std::endl;
int counter = 0;
forall_nodes(G, node) {
if( independent_set[node] ) {
counter++;
forall_out_edges(G, e, node) {
NodeID target = G.getEdgeTarget(e);
if(independent_set[target]) {
std::cout << "not an independent set!" << std::endl;
exit(0);
}
} endfor
}
} endfor
void sap_dump(int level, struct frame *frm)
{
uint8_t msg, params;
msg = get_u8(frm);
params = get_u8(frm);
/* Skip reserved field */
get_u16(frm);
p_indent(level, frm);
printf("SAP: %s: params %d\n", msg2str(msg), params);
parse_parameters(level, frm);
}
// Initializes the parameters of the index.
uint parametersCSA(ticsa *myicsa, char *build_options){
char delimiters[] = " =;";
int j,num_parameters;
char ** parameters;
int ssA,ssAinv,ssPsi,nsHuff,psiSearchFactor;
ssA = DEFAULT_A_SAMPLING_PERIOD;
ssAinv = DEFAULT_A_INV_SAMPLING_PERIOD;
ssPsi = DEFAULT_PSI_SAMPLING_PERIOD;
nsHuff = DEFAULT_nsHUFF;
psiSearchFactor = DEFAULT_PSI_BINARY_SEARCH_FACTOR;
if (build_options != NULL) {
parse_parameters(build_options,&num_parameters, ¶meters, delimiters);
for (j=0; j<num_parameters;j++) {
if ((strcmp(parameters[j], "sA") == 0 ) && (j < num_parameters-1) ) {
ssA=atoi(parameters[j+1]);
}
if ((strcmp(parameters[j], "sAinv") == 0 ) && (j < num_parameters-1) ) {
ssAinv=atoi(parameters[j+1]);
}
if ((strcmp(parameters[j], "sPsi") == 0 ) && (j < num_parameters-1) ) {
ssPsi=atoi(parameters[j+1]);
}
if ((strcmp(parameters[j], "nsHuff") == 0 ) && (j < num_parameters-1) ) {
nsHuff=atoi(parameters[j+1]);
nsHuff *=1024;
}
if ((strcmp(parameters[j], "psiSF") == 0 ) && (j < num_parameters-1) ) {
psiSearchFactor=atoi(parameters[j+1]);
}
j++;
}
free_parameters(num_parameters, ¶meters);
}
myicsa->T_A = ssA;
myicsa->T_AInv = ssAinv;
myicsa->T_Psi = ssPsi;
myicsa->tempNSHUFF = nsHuff;
myicsa->psiSearchFactorJump = psiSearchFactor * ssPsi;
printf("\n\t parameters for iCSA: sampleA=%d, sampleAinv=%d, samplePsi=%d",ssA,ssAinv,ssPsi);
printf("\n\t : nsHuff=%d, psiSearchFactor = %d --> jump = %d", nsHuff,psiSearchFactor, myicsa->psiSearchFactorJump);
}
int main(int argc, char **argv)
{
time_seed = time(0);
parse_parameters(argc, argv);
if (getuid() == 0)
{
if (UID == -1)
error("user not set");
if (setgid(GID) != 0)
error("Unable to drop group privileges");
if (setuid(UID) != 0)
error("Unable to drop user privileges");
}
if (BASEDIR == NULL)
set_basedir();
startup_message();
int listen_socket, optval = 1;
struct sockaddr_in server_address;
listen_socket = create_socket();
setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval , sizeof(int));
server_address = set_address(server_address);
bind_to_port(listen_socket, server_address);
if (DAEMON)
{
pid_t pid;
pid = fork();
if (pid == -1)
error("Failed to fork");
if (pid == 0)
while (1) perform_connection(listen_socket);
}
else
while (1) perform_connection(listen_socket);
return 0;
}
int main(int argc, char **argv) {
srandom(17);
int runlong = parse_parameters(argc, argv);
gf2e *ff;
int fail_ret = 0;
for(int k=2; k<=16; k++) {
ff = gf2e_init(irreducible_polynomials[k][1]);
fail_ret += test_batch(ff, 2, 5);
fail_ret += test_batch(ff, 5, 10);
fail_ret += test_batch(ff, 1, 1);
fail_ret += test_batch(ff, 1, 2);
fail_ret += test_batch(ff, 11, 12);
fail_ret += test_batch(ff, 21, 22);
fail_ret += test_batch(ff, 13, 2);
fail_ret += test_batch(ff, 32, 33);
fail_ret += test_batch(ff, 63, 64);
if (k <= 12 || runlong) {
fail_ret += test_batch(ff, 127, 128);
fail_ret += test_batch(ff, 200, 20);
}
fail_ret += test_batch(ff, 1, 1);
fail_ret += test_batch(ff, 1, 3);
fail_ret += test_batch(ff, 11, 13);
fail_ret += test_batch(ff, 21, 23);
fail_ret += test_batch(ff, 13, 90);
fail_ret += test_batch(ff, 32, 34);
fail_ret += test_batch(ff, 63, 65);
if (k <= 12 || runlong) {
fail_ret += test_batch(ff, 127, 129);
fail_ret += test_batch(ff, 200, 112);
fail_ret += test_batch(ff, 10, 200);
}
gf2e_free(ff);
}
return fail_ret;
}
int main(int argn, char **argv) {
PartitionConfig partition_config;
std::string graph_filename;
bool is_graph_weighted = false;
bool suppress_output = false;
bool recursive = false;
int ret_code = parse_parameters(argn, argv,
partition_config,
graph_filename,
is_graph_weighted,
suppress_output, recursive);
if(ret_code) {
return 0;
}
std::streambuf* backup = std::cout.rdbuf();
std::ofstream ofs;
ofs.open("/dev/null");
if(suppress_output) {
std::cout.rdbuf(ofs.rdbuf());
}
partition_config.LogDump(stdout);
graph_access G;
timer t;
graph_io::readGraphWeighted(G, graph_filename);
std::cout << "io time: " << t.elapsed() << std::endl;
G.set_partition_count(partition_config.k);
NodeWeight largest_graph_weight = 0;
forall_nodes(G, node) {
largest_graph_weight += G.getNodeWeight(node);
} endfor
bool http_request_headers_finalize(http_request_t * const request) {
header_list_t * header_list = request->headers;
if (header_list) {
char * method = http_request_header_get(request, ":method");
if (!method) {
log_append(request->log, LOG_ERROR, "Missing :method header");
return NULL;
}
request->method = strdup(method);
char * scheme = http_request_header_get(request, ":scheme");
if (!scheme) {
log_append(request->log, LOG_ERROR, "Missing :scheme header");
return NULL;
}
request->scheme = strdup(scheme);
if (!parse_path(request)) {
return NULL;
}
parse_authority(request);
parse_parameters(request->params, request->query_string);
header_list_remove_pseudo_headers(header_list);
} else {
request->headers = header_list_init(NULL);
}
return request;
}
/**
* Create parameters for the given request. Returns FALSE if an error
* occurs.
*/
static int create_parameters(HttpRequest req) {
char query_string[REQ_STRLEN]= {0};
if(IS(req->method, METHOD_POST) && get_header(req, "Content-Length")) {
int n;
int len;
Socket_T S = req->S;
const char *cl = get_header(req, "Content-Length");
if(! cl || sscanf(cl, "%d", &len) != 1) {
return FALSE;
}
if(len < 0 || len >= REQ_STRLEN)
return FALSE;
if(len==0)
return TRUE;
if(((n= socket_read(S, query_string, len)) <= 0) || (n != len)) {
return FALSE;
}
query_string[n]= 0;
} else if(IS(req->method, METHOD_GET)) {
char *p;
if(NULL != (p= strchr(req->url, '?'))) {
*p++= 0;
strncpy(query_string, p, sizeof(query_string) - 1);
query_string[sizeof(query_string) - 1] = 0;
}
}
if(*query_string) {
char *p;
if(NULL != (p= strchr(query_string, '/'))) {
*p++= 0;
req->pathinfo= Str_dup(p);
}
req->params= parse_parameters(query_string);
}
return TRUE;
}
int setDefaultSearchOptions_il (void *ail, char *search_options){
t_il *il = (t_il *) ail;
//il->defs.defaultFsearch = NULL;
il->defs.defaultIntersect2 = NULL;
il->defs.defaultIntersectN = NULL;
/** processing the parameters */
char delimiters[] = " =;";
int j,num_parameters;
char ** parameters;
if (search_options != NULL) {
parse_parameters(search_options,&num_parameters, ¶meters, delimiters);
for (j=0; j<num_parameters;j++) {
//setting the default function to Intersect-2-lists
if ((strcmp(parameters[j], "int2") == 0 ) && (j < num_parameters-1) ) {
if (strcmp(parameters[j+1], "merge") == 0 )
il->defs.defaultIntersect2 = merge2;
j++;
}
//setting the default function to Intersect-N-lists
else if ((strcmp(parameters[j], "intn") == 0 ) && (j < num_parameters-1) ) {
if (strcmp(parameters[j+1], "merge") == 0 )
il->defs.defaultIntersectN = merge_N_SIMD;
j++;
}
}
free_parameters(num_parameters, ¶meters);
}
fprintf(stderr,"\n ** Call to setDefaultSearchOptions_il: \"%s\"\n", search_options);
return 0;
}
return 0;
}
int main ( int argc, char* argv[] ) {
// char *pwd = NULL;
size_t found;
if ( argc <= 1 ) {
SHOW_HELPTEXT
return 0;
}
int ret= parse_parameters( argc, argv );
if ( 0 != ret ) return 100;
map< uint32_t, set< uint32_t > >::const_iterator it= replacementMap.begin();
map< uint32_t, set< uint32_t > >::const_iterator itend= replacementMap.end();
for ( ; it != itend ; ++it ) {
/*cout << " " << it->first << " : ";*/
set< uint32_t >::const_iterator jt= it->second.begin();
set< uint32_t >::const_iterator jtend= it->second.end();
for ( ; jt != jtend ; ++jt ) {
if (*jt != it->first) {
int
space_main(
int argc,
char ** argv)
{
int rc;
globus_xio_stack_t stack;
globus_xio_handle_t handle;
globus_result_t res;
globus_xio_attr_t attr;
globus_condattr_t condattr;
globus_l_closed = GLOBUS_FALSE;
globus_l_close_called = GLOBUS_FALSE;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
res = globus_xio_attr_init(&attr);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_stack_init(&stack, NULL);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
parse_parameters(argc, argv, stack, attr);
globus_callback_space_init(&globus_l_space, NULL);
globus_condattr_init(&condattr);
globus_condattr_setspace(&condattr, globus_l_space);
globus_mutex_init(&globus_l_mutex, NULL);
globus_cond_init(&globus_l_cond, &condattr);
res = globus_xio_handle_create(&handle, stack);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_attr_cntl(attr, NULL, GLOBUS_XIO_ATTR_SET_SPACE, globus_l_space);
res = globus_xio_register_open(
handle,
"whatever",
attr,
open_cb,
argv[argc-1]);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
globus_mutex_lock(&globus_l_mutex);
{
while(!globus_l_closed)
{
globus_cond_wait(&globus_l_cond, &globus_l_mutex);
}
}
globus_mutex_unlock(&globus_l_mutex);
globus_xio_attr_destroy(attr);
globus_xio_stack_destroy(stack);
test_common_end();
globus_callback_space_destroy(globus_l_space);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
fprintf(stdout, "Success.\n");
return 0;
}
int
framework_main(
int argc,
char ** argv)
{
int rc;
globus_xio_stack_t stack;
globus_xio_handle_t handle;
globus_xio_attr_t attr;
globus_result_t res;
globus_xio_server_t server;
globus_l_closed = GLOBUS_FALSE;
globus_l_accepted = GLOBUS_FALSE;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
globus_mutex_init(&globus_l_mutex, NULL);
globus_cond_init(&globus_l_cond, NULL);
res = globus_xio_attr_init(&attr);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_stack_init(&stack, NULL);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
parse_parameters(argc, argv, stack, attr);
if(globus_l_test_info.server)
{
res = globus_xio_server_create(&server, attr, stack);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_server_register_accept(
server,
accept_cb,
&handle);
test_res(GLOBUS_XIO_TEST_FAIL_PASS_ACCEPT, res, __LINE__, __FILE__);
globus_mutex_lock(&globus_l_mutex);
{
while(!globus_l_accepted)
{
globus_cond_wait(&globus_l_cond, &globus_l_mutex);
}
}
globus_mutex_unlock(&globus_l_mutex);
}
else
{
res = globus_xio_handle_create(&handle, stack);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
res = globus_xio_register_open(
handle,
"whatever",
attr,
open_cb,
(void *)&globus_l_test_info);
test_res(GLOBUS_XIO_TEST_FAIL_PASS_OPEN, res, __LINE__, __FILE__);
globus_mutex_lock(&globus_l_mutex);
{
while(!globus_l_closed)
{
globus_cond_wait(&globus_l_cond, &globus_l_mutex);
}
}
globus_mutex_unlock(&globus_l_mutex);
globus_xio_attr_destroy(attr);
globus_xio_stack_destroy(stack);
if(globus_l_test_info.server)
{
res = globus_xio_server_close(server);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
test_common_end();
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
fprintf(stdout, "Success.\n");
return 0;
}
int main(int argc, char *argv[])
{
struct lib_ccx_ctx *ctx;
struct lib_cc_decode *dec_ctx = NULL;
int ret = 0;
enum ccx_stream_mode_enum stream_mode;
init_options (&ccx_options);
parse_configuration(&ccx_options);
ret = parse_parameters (&ccx_options, argc, argv);
if (ret == EXIT_NO_INPUT_FILES)
{
usage ();
fatal (EXIT_NO_INPUT_FILES, "(This help screen was shown because there were no input files)\n");
}
else if (ret == EXIT_WITH_HELP)
{
return EXIT_OK;
}
else if (ret != EXIT_OK)
{
exit(ret);
}
// Initialize libraries
ctx = init_libraries(&ccx_options);
if (!ctx && errno == ENOMEM)
fatal (EXIT_NOT_ENOUGH_MEMORY, "Not enough memory\n");
else if (!ctx && errno == EINVAL)
fatal (CCX_COMMON_EXIT_BUG_BUG, "Invalid option to CCextractor Library\n");
else if (!ctx && errno == EPERM)
fatal (CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Unable to create Output File\n");
else if (!ctx && errno == EACCES)
fatal (CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Unable to create Output File\n");
else if (!ctx)
fatal (EXIT_NOT_CLASSIFIED, "Unable to create Library Context %d\n",errno);
int show_myth_banner = 0;
params_dump(ctx);
// default teletext page
if (tlt_config.page > 0) {
// dec to BCD, magazine pages numbers are in BCD (ETSI 300 706)
tlt_config.page = ((tlt_config.page / 100) << 8) | (((tlt_config.page / 10) % 10) << 4) | (tlt_config.page % 10);
}
if (ccx_options.transcript_settings.xds)
{
if (ccx_options.write_format != CCX_OF_TRANSCRIPT)
{
ccx_options.transcript_settings.xds = 0;
mprint ("Warning: -xds ignored, XDS can only be exported to transcripts at this time.\n");
}
}
time_t start, final;
time(&start);
if (ccx_options.binary_concat)
{
ctx->total_inputsize=gettotalfilessize(ctx);
if (ctx->total_inputsize==-1)
fatal (EXIT_UNABLE_TO_DETERMINE_FILE_SIZE, "Failed to determine total file size.\n");
}
#ifndef _WIN32
signal_ctx = ctx;
m_signal(SIGINT, sigint_handler);
#endif
while (switch_to_next_file(ctx, 0))
{
prepare_for_new_file(ctx);
stream_mode = ctx->demux_ctx->get_stream_mode(ctx->demux_ctx);
// Disable sync check for raw formats - they have the right timeline.
// Also true for bin formats, but -nosync might have created a
// broken timeline for debug purposes.
// Disable too in MP4, specs doesn't say that there can't be a jump
switch (stream_mode)
{
case CCX_SM_MCPOODLESRAW:
case CCX_SM_RCWT:
case CCX_SM_MP4:
#ifdef WTV_DEBUG
case CCX_SM_HEX_DUMP:
#endif
ccx_common_timing_settings.disable_sync_check = 1;
break;
default:
break;
}
/* -----------------------------------------------------------------
MAIN LOOP
----------------------------------------------------------------- */
switch (stream_mode)
{
case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
if (!ccx_options.use_gop_as_pts) // If !0 then the user selected something
ccx_options.use_gop_as_pts = 1; // Force GOP timing for ES
ccx_common_timing_settings.is_elementary_stream = 1;
case CCX_SM_TRANSPORT:
case CCX_SM_PROGRAM:
case CCX_SM_ASF:
case CCX_SM_WTV:
case CCX_SM_GXF:
#ifdef ENABLE_FFMPEG
case CCX_SM_FFMPEG:
#endif
if (!ccx_options.use_gop_as_pts) // If !0 then the user selected something
ccx_options.use_gop_as_pts = 0;
mprint ("\rAnalyzing data in general mode\n");
general_loop(ctx);
break;
case CCX_SM_MCPOODLESRAW:
mprint ("\rAnalyzing data in McPoodle raw mode\n");
raw_loop(ctx);
break;
case CCX_SM_RCWT:
mprint ("\rAnalyzing data in CCExtractor's binary format\n");
rcwt_loop(ctx);
break;
case CCX_SM_MYTH:
mprint ("\rAnalyzing data in MythTV mode\n");
show_myth_banner = 1;
myth_loop(ctx);
break;
case CCX_SM_MP4:
mprint ("\rAnalyzing data with GPAC (MP4 library)\n");
close_input_file(ctx); // No need to have it open. GPAC will do it for us
processmp4 (ctx, &ctx->mp4_cfg, ctx->inputfile[0]);
if (ccx_options.print_file_reports)
print_file_report(ctx);
break;
#ifdef WTV_DEBUG
case CCX_SM_HEX_DUMP:
close_input_file(ctx); // processhex will open it in text mode
processhex (ctx, ctx->inputfile[0]);
break;
#endif
case CCX_SM_AUTODETECT:
fatal(CCX_COMMON_EXIT_BUG_BUG, "Cannot be reached!");
break;
}
#if 0
if (ctx->total_pulldownframes)
mprint ("incl. pulldown frames: %s (%u frames at %.2ffps)\n",
print_mstime( (LLONG)(ctx->total_pulldownframes*1000/current_fps) ),
ctx->total_pulldownframes, current_fps);
if (pts_set >= 1 && min_pts != 0x01FFFFFFFFLL)
{
LLONG postsyncms = (LLONG) (ctx->frames_since_last_gop*1000/current_fps);
mprint ("\nMin PTS: %s\n",
print_mstime( min_pts/(MPEG_CLOCK_FREQ/1000) - fts_offset));
if (pts_big_change)
mprint ("(Reference clock was reset at some point, Min PTS is approximated)\n");
mprint ("Max PTS: %s\n",
print_mstime( sync_pts/(MPEG_CLOCK_FREQ/1000) + postsyncms));
mprint ("Length: %s\n",
print_mstime( sync_pts/(MPEG_CLOCK_FREQ/1000) + postsyncms
- min_pts/(MPEG_CLOCK_FREQ/1000) + fts_offset ));
}
// dvr-ms files have invalid GOPs
if (gop_time.inited && first_gop_time.inited && stream_mode != CCX_SM_ASF)
{
mprint ("\nInitial GOP time: %s\n",
print_mstime(first_gop_time.ms));
mprint ("Final GOP time: %s%+3dF\n",
print_mstime(gop_time.ms),
ctx->frames_since_last_gop);
mprint ("Diff. GOP length: %s%+3dF",
print_mstime(gop_time.ms - first_gop_time.ms),
ctx->frames_since_last_gop);
mprint (" (%s)\n",
print_mstime(gop_time.ms - first_gop_time.ms
+(LLONG) ((ctx->frames_since_last_gop)*1000/29.97)) );
}
if (ctx->false_pict_header)
mprint ("\nNumber of likely false picture headers (discarded): %d\n",ctx->false_pict_header);
if (ctx->stat_numuserheaders)
mprint("\nTotal user data fields: %d\n", ctx->stat_numuserheaders);
if (ctx->stat_dvdccheaders)
mprint("DVD-type user data fields: %d\n", ctx->stat_dvdccheaders);
if (ctx->stat_scte20ccheaders)
mprint("SCTE-20 type user data fields: %d\n", ctx->stat_scte20ccheaders);
if (ctx->stat_replay4000headers)
mprint("ReplayTV 4000 user data fields: %d\n", ctx->stat_replay4000headers);
if (ctx->stat_replay5000headers)
mprint("ReplayTV 5000 user data fields: %d\n", ctx->stat_replay5000headers);
if (ctx->stat_hdtv)
mprint("HDTV type user data fields: %d\n", ctx->stat_hdtv);
if (ctx->stat_dishheaders)
mprint("Dish Network user data fields: %d\n", ctx->stat_dishheaders);
if (ctx->stat_divicom)
{
mprint("CEA608/Divicom user data fields: %d\n", ctx->stat_divicom);
mprint("\n\nNOTE! The CEA 608 / Divicom standard encoding for closed\n");
mprint("caption is not well understood!\n\n");
mprint("Please submit samples to the developers.\n\n\n");
}
#endif
list_for_each_entry(dec_ctx, &ctx->dec_ctx_head, list, struct lib_cc_decode)
{
mprint("\n");
dbg_print(CCX_DMT_DECODER_608, "\nTime stamps after last caption block was written:\n");
dbg_print(CCX_DMT_DECODER_608, "GOP: %s \n", print_mstime(gop_time.ms) );
dbg_print(CCX_DMT_DECODER_608, "GOP: %s (%+3dms incl.)\n",
print_mstime((LLONG)(gop_time.ms
-first_gop_time.ms
+get_fts_max(dec_ctx->timing)-fts_at_gop_start)),
(int)(get_fts_max(dec_ctx->timing)-fts_at_gop_start));
// When padding is active the CC block time should be within
// 1000/29.97 us of the differences.
dbg_print(CCX_DMT_DECODER_608, "Max. FTS: %s (without caption blocks since then)\n",
print_mstime(get_fts_max(dec_ctx->timing)));
if (dec_ctx->codec == CCX_CODEC_ATSC_CC)
{
mprint ("\nTotal frames time: %s (%u frames at %.2ffps)\n",
print_mstime( (LLONG)(total_frames_count*1000/current_fps) ),
total_frames_count, current_fps);
}
if (ctx->stat_hdtv)
{
mprint ("\rCC type 0: %d (%s)\n", dec_ctx->cc_stats[0], cc_types[0]);
mprint ("CC type 1: %d (%s)\n", dec_ctx->cc_stats[1], cc_types[1]);
mprint ("CC type 2: %d (%s)\n", dec_ctx->cc_stats[2], cc_types[2]);
mprint ("CC type 3: %d (%s)\n", dec_ctx->cc_stats[3], cc_types[3]);
}
// Add one frame as fts_max marks the beginning of the last frame,
// but we need the end.
dec_ctx->timing->fts_global += dec_ctx->timing->fts_max + (LLONG) (1000.0/current_fps);
// CFS: At least in Hauppage mode, cb_field can be responsible for ALL the
// timing (cb_fields having a huge number and fts_now and fts_global being 0 all
// the time), so we need to take that into account in fts_global before resetting
// counters.
if (cb_field1!=0)
dec_ctx->timing->fts_global += cb_field1*1001/3;
else if (cb_field2!=0)
dec_ctx->timing->fts_global += cb_field2*1001/3;
else
dec_ctx->timing->fts_global += cb_708*1001/3;
// Reset counters - This is needed if some captions are still buffered
// and need to be written after the last file is processed.
cb_field1 = 0; cb_field2 = 0; cb_708 = 0;
dec_ctx->timing->fts_now = 0;
dec_ctx->timing->fts_max = 0;
}
if(is_decoder_processed_enough(ctx) == CCX_TRUE)
break;
} // file loop
close_input_file(ctx);
prepare_for_new_file (ctx); // To reset counters used by handle_end_of_data()
time (&final);
long proc_time=(long) (final-start);
mprint ("\rDone, processing time = %ld seconds\n", proc_time);
#if 0
if (proc_time>0)
{
LLONG ratio=(get_fts_max()/10)/proc_time;
unsigned s1=(unsigned) (ratio/100);
unsigned s2=(unsigned) (ratio%100);
mprint ("Performance (real length/process time) = %u.%02u\n",
s1, s2);
}
#endif
dbg_print(CCX_DMT_708, "[CEA-708] The 708 decoder was reset [%d] times.\n", ctx->freport.data_from_708->reset_count);
if (is_decoder_processed_enough(ctx) == CCX_TRUE)
{
mprint ("\rNote: Processing was cancelled before all data was processed because\n");
mprint ("\rone or more user-defined limits were reached.\n");
}
mprint ("This is beta software. Report issues to carlos at ccextractor org...\n");
if (show_myth_banner)
{
mprint ("NOTICE: Due to the major rework in 0.49, we needed to change part of the timing\n");
mprint ("code in the MythTV's branch. Please report results to the address above. If\n");
mprint ("something is broken it will be fixed. Thanks\n");
}
dinit_libraries(&ctx);
return EXIT_OK;
}
