// Flushes out a queue of interpolation commands
void Mesher::flush_queue()
{
Vec3f low[MIN_VOLUME];
Vec3f high[MIN_VOLUME];
// Go through the list, saving a list of vertex pairs on which
// interpolation should be run into low and high.
unsigned count=0;
for (auto c : queue)
{
if (c.cmd == InterpolateCommand::INTERPOLATE)
{
low[count] = c.v0;
high[count] = c.v1;
count++;
}
}
if (count)
eval_zero_crossings(low, high, count);
// Next, go through and actually load vertices
// (either directly or from the cache)
count = 0;
for (auto c : queue)
{
if (c.cmd == InterpolateCommand::INTERPOLATE)
{
push_vert(ex[count], ey[count], ez[count]);
count++;
}
else if (c.cmd == InterpolateCommand::CACHED)
{
unsigned i = c.cached;
push_vert(ex[i], ey[i], ez[i]);
}
else if (c.cmd == InterpolateCommand::END_OF_VOXEL)
{
if (detect_edges)
{
// Clear voxel_end
// (it will be reset when the next triangle is pushed)
voxel_end = triangles.end();
// Then, iterate until no more features are found in
// the current voxel.
while (voxel_start != voxel_end &&
voxel_start != triangles.end())
{
check_feature();
}
// Clear voxel_start
// (it will be reset when the next triangle is pushed)
voxel_start = triangles.end();
}
}
}
queue.clear();
}
parse_proc_cpuinfo (int bufsize)
{
char *buffer = (char *)malloc(bufsize);
FILE *fd;
simd_support = 0;
if (!buffer)
return 0;
fd = fopen("/proc/cpuinfo", "r");
if (fd) {
while (fgets(buffer, bufsize, fd)) {
if (!strchr(buffer, '\n') && !feof(fd)) {
/* "impossible" happened - insufficient size of the buffer! */
fclose(fd);
free(buffer);
return 0;
}
if (check_feature(buffer, "neon"))
simd_support |= JSIMD_ARM_NEON;
}
fclose(fd);
}
free(buffer);
return 1;
}
int mdt_feature_group_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type, int ifeat1, int ifeat2,
mdt_cb_feature_group getbin, void *data,
mdt_cb_free freefunc, GError **err)
{
struct mdt_feature_group *feat;
int nfeat;
if (!check_feature(ifeat1, mlib, 1, err)
|| !check_feature(ifeat2, mlib, 2, err)) {
return -1;
}
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_GROUP, data,
freefunc)->u.group);
feat->ifeat1 = ifeat1;
feat->ifeat2 = ifeat2;
feat->getbin = getbin;
mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type,
MOD_MDTP_A, MOD_MDTS_PROTEIN, FALSE, 0);
return nfeat;
}
static void check_all_features ( uint *n_supported, uint *n_total )
{
DASSERT(n_supported);
DASSERT(n_total);
uint feat;
for ( feat = 0; feat < FEAT__ALL; feat++ )
{
(*n_total)++;
if (check_feature(feat))
(*n_supported)++;
}
}
int main(int argc,char *argv[])
{
int a,b,c;
FILE *outfile = NULL, *infile = NULL;
char *outfile_name=NULL,*infile_name=NULL;
char tmp[20];
int vflag=0,oflag=0,hflag=0,lflag=0,plusflag=0,minusflag=0;
#ifdef LICENSE
license_struct lstr;
#endif
while ((c = getopt(argc, argv, "lhvo:")) != -1) {
switch (c) {
case 'o':/*set outfile*/
outfile_name=optarg;
oflag = 1;
break;
case 'v':/*print version*/
vflag=1;
break;
case 'h':/*print help (usage)*/
hflag=1;
break;
case 'l':/*list event types*/
lflag=1;
break;
default:
Usage(argv[0]);
return EXIT_FAILURE;
}
}
if (oflag + vflag + hflag + lflag > 1) {
Usage(argv[0]);
return EXIT_FAILURE;
} else if (vflag) {
fputs("Log Filter for the TTCN-3 Test Executor\n"
"Product number: " PRODUCT_NUMBER "\n"
"Build date: " __DATE__ " " __TIME__ "\n"
"Compiled with: " C_COMPILER_VERSION "\n\n"
COPYRIGHT_STRING "\n\n", stderr);
#ifdef LICENSE
print_license_info();
#endif
return EXIT_SUCCESS;
} else if (hflag) {
Usage(argv[0]);
return EXIT_SUCCESS;
} else if(lflag) {
ListTypes();
return EXIT_SUCCESS;
}
#ifdef LICENSE
init_openssl();
load_license(&lstr);
if (!verify_license(&lstr)) {
free_license(&lstr);
free_openssl();
exit(EXIT_FAILURE);
}
if (!check_feature(&lstr, FEATURE_LOGFORMAT)) {
fputs("The license key does not allow the filtering of log files.\n",
stderr);
return 2;
}
free_license(&lstr);
free_openssl();
#endif
/*
switches: -v -o -h -l
filter parameters: parameter+ or parameter-
*/
for(a=0;a<MaxType;a++)Wflags[a]=0;
for(a=1;a<argc;a++) {
if(*argv[a]=='-'){if(*(argv[a]+1)=='o')a++;continue;}/*switch*/
if(*(argv[a]+strlen(argv[a])-1)=='-') {/*type to ignore*/
for(b=0,c=0;b<MaxType;b++)
if(0==strncmp(EventTypeNames[b],argv[a],
strlen(EventTypeNames[b]))&&strlen(EventTypeNames[b])==
strlen(argv[a])-1) {
Wflags[b]=DontWrite;
c=1;
}
if(!c) {/*Undefined type*/
strncpy(tmp,argv[a],sizeof(tmp)-1);
if(strlen(argv[a])>sizeof(tmp)-1)
for(c=2;c<5;c++)tmp[sizeof(tmp)-c]='.';
else tmp[strlen(argv[a])-1]='\0';
tmp[sizeof(tmp)-1]='\0';
if(strlen(tmp))fprintf(stderr,"Warning: %s is not a valid "
"event-type name.\n",tmp);
else fprintf(stderr,"Warning: `-\' without an event-type "
"name.\n");
}
Wothers=Write;
minusflag=1;
continue;
}
if(*(argv[a]+strlen(argv[a])-1)=='+') {/*type to write out*/
for(b=0,c=0;b<MaxType;b++)
if(0==strncmp(EventTypeNames[b],argv[a],
strlen(EventTypeNames[b]))&&strlen(EventTypeNames[b])==
strlen(argv[a])-1) {
Wflags[b]=Write;
c=1;
}
if(!c) {/*Undefined type*/
strncpy(tmp,argv[a],sizeof(tmp)-1);
if(strlen(argv[a])>sizeof(tmp)-1)
for(c=2;c<5;c++)tmp[sizeof(tmp)-c]='.';
else tmp[strlen(argv[a])-1]='\0';
tmp[sizeof(tmp)-1]='\0';
if(strlen(tmp))fprintf(stderr,"Warning: %s is not a valid "
"event-type name.\n",tmp);
else fprintf(stderr,"Warning: `+\' without an event-type "
"name.\n");
}
Wothers=DontWrite;
plusflag=1;
continue;
}
if(infile_name!=NULL) {/*only one input file at once*/
fprintf(stderr,"Error: more than one input file specified.\n");
return EXIT_FAILURE;
}
infile_name=argv[a];
}
if(minusflag&&plusflag) {/*type1+ and type2- at the same time could cause
types that are not defined what to do with, to act based on the
last filter definition. Thus it is not allowed.*/
fprintf(stderr,"Error: include and exclude at the same time.\n");
return EXIT_FAILURE;
}
if(infile_name==NULL)infile=stdin;/*if no infile specified use stdin*/
else {
infile=fopen(infile_name,"r");
if(infile==NULL) {
fprintf(stderr,"Error opening %s : %s\n",infile_name,
strerror(errno));
return EXIT_FAILURE;
}
}
if(oflag) {
outfile=fopen(outfile_name,"w");
if(outfile==NULL) {
fprintf(stderr,"Error creating %s : %s\n",outfile_name,
strerror(errno));
return EXIT_FAILURE;
}
} else outfile=stdout;/*if no outfile specified use stdout*/
a=ProcessFile(outfile,infile);/*filter infile to outfile*/
if(a==ERR_INVALID_LOG) {
if(infile_name!=NULL)fprintf(stderr,"Error: the file %s is not a valid "
"log file.\n",infile_name);
else fprintf(stderr,"Error: invalid format received from standard "
"input.\n");
return EXIT_FAILURE;
} else if(a==ERR_WRITE) {
if(errno)fprintf(stderr,"Error writing to output: %s\n",
strerror(errno));
else fprintf(stderr,"Error writing to output\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
enumError cmd_features()
{
uint n_supported = 0, n_total = 0;
ParamList_t * param;
for ( param = first_param; param; param = param->next )
{
ccp arg = param->arg;
if ( !arg || !*arg )
continue;
int cmd_stat;
const CommandTab_t * cmd = ScanCommand(&cmd_stat,arg,feature_tab);
if ( !cmd || cmd_stat )
{
n_total++;
if ( verbose > 0 )
printf("? Unknown feature: %s.\n",arg);
continue;
}
if ( cmd->id == FEAT__ALL )
check_all_features(&n_supported,&n_total);
else
{
n_total++;
if (check_feature(cmd->id))
n_supported++;
}
}
if (!n_total)
check_all_features(&n_supported,&n_total);
if ( n_supported == n_total )
{
if ( verbose >= -1 )
{
if ( n_total == 1 )
printf("> Exit status 0: The requested features is supported.\n");
else
printf("> Exit status 0: All %u requested features are supported.\n",
n_total);
}
return 0;
}
if ( !n_supported )
{
if ( verbose >= -1 )
{
if ( n_total == 1 )
printf("> Exit status 2: The requested features is not supported.\n");
else
printf("> Exit status 2: All %u requested features are not supported.\n",
n_total);
}
return 2;
}
if ( verbose >= -1 )
printf("> Exit status 1: %u of %u requested features are supported.\n",
n_supported, n_total );
return 1;
}
int main(int argc,char *argv[])
{
int a,b,c,processed_files=0,filename_count=0;
char *outfile_name=NULL;
int vflag=0,oflag=0;
#ifdef LICENSE
license_struct lstr;
#endif
progname=argv[0];
atexit(DelTemp);
signal(SIGINT,ControlChandler);
while ((c = getopt(argc, argv, "vo:")) != -1) {
switch (c) {
case 'o':
outfile_name=optarg;
oflag = 1;
break;
case 'v':
vflag=1;
break;
default: Usage();return 0;
}
}
if(oflag&&vflag){Usage();return 0;}/*both switches are used*/
if(vflag) {
fputs("Log Merger for the TTCN-3 Test Executor\n"
"Product number: " PRODUCT_NUMBER "\n"
"Version: " VERSION_STRING "\n"
"Build date: " __DATE__ " " __TIME__ "\n"
"Compiled with: " C_COMPILER_VERSION "\n\n"
COPYRIGHT_STRING "\n\n", stderr);
#ifdef LICENSE
print_license_info();
#endif
return 0;
}
#ifdef LICENSE
init_openssl();
load_license(&lstr);
if (!verify_license(&lstr)) {
free_license(&lstr);
free_openssl();
exit(EXIT_FAILURE);
}
if (!check_feature(&lstr, FEATURE_LOGFORMAT)) {
fputs("The license key does not allow the merging of log files.\n",
stderr);
return 2;
}
free_license(&lstr);
free_openssl();
#endif
argc-=optind-1;argv+=optind-1;
if(argc<2){Usage();return 0;}/*executed when no input file is given*/
for(a=1;a<argc;a++) {/*find first file with a valid timestamp*/
TimeStampUsed=GetTimeStampFormat(argv[a]);
if(TimeStampUsed!=TSF_Undefined)break;
}
switch(TimeStampUsed) {
case TSF_Seconds: fputs("Merging logs with timestamp "
"format \"seconds\" has no sense.\n", stderr); return 0;
case TSF_Time: TimeStampLength=TIMELENGTH;break;
case TSF_DateTime: TimeStampLength=DATETIMELENGTH;break;
default: fputs("Unsupported timestamp format.\n", stderr); return 1;
}
for(a=1,c=0;a<argc;a++) {/*get files with valid timestamp format*/
b=GetTimeStampFormat(argv[a]);
if(TimeStampUsed==b) {/*file conains at least one valid timestamp*/
c++;
name_list_in=(char **)Realloc(name_list_in,c*sizeof(char *));
name_list_in[c-1] = mcopystr(argv[a]);
} else if(b==TSF_Undefined)/*file contains no timestamp or uses a
different format than the first match*/
fprintf(stderr,"Warning: unknown format in %s\n",argv[a]);
else fprintf(stderr,"Warning: format mismatch in %s\n",argv[a]);
}
num_allfiles=c;
if(num_allfiles<1){Usage();return 0;}/*no valid log file found*/
if(oflag){/*switch [-o outfile] is used -> create outfile*/
outfile = fopen(outfile_name, FOPEN_WRITE);
if(outfile==NULL) {
fprintf(stderr,"Error creating %s %s\n",outfile_name,strerror(errno));
return 1;
}
} else {
outfile = stdout;
}
while(1) {
filename_count=num_allfiles;start_file=0;
while(num_allfiles>0) {/*process files in name_list_in*/
processed_files=OpenMaxFiles(num_allfiles,name_list_in+start_file);
must_use_temp=True;/*if there are infiles remaining use tempfiles
for all*/
if((processed_files<2)&&(num_allfiles>1)){fprintf(stderr,"Error: "
"can not open enough files.\nMore descriptors required "
"(set with the command `limit descriptors\')\n");return 1;}
if(infiles_processed==True)
for(a=0;a<processed_files;a++) {
Free(EventList[a]->str_to_add);
EventList[a]->str_to_add = NULL;
}
num_allfiles-=processed_files;
ProcessOpenFiles();
CloseAllFiles();
start_file+=processed_files;
}
must_use_temp=False;/*all infiles processed*/
/*remove temporary files used in previous step*/
if(infiles_processed==True)
for(a=0;a<filename_count;a++)remove(name_list_in[a]);
infiles_processed=True;
for(a=0;a<filename_count;a++)Free(name_list_in[a]);
Free(name_list_in);
if(num_tempfiles==0)break;/*no more file to process*/
name_list_in=temp_file_list;/*process tempfiles*/
num_allfiles=num_tempfiles;
num_tempfiles=0;temp_file_list=NULL;
}
check_mem_leak(progname);
return 0;
}
/**
* Process 'generate' command.
*
* @return error code (0 - no error)
*/
static int
process_generate (cli_state_t *cli_state_p, /**< cli state */
int argc, /**< number of arguments */
char *prog_name_p) /**< program name */
{
(void) argc;
bool is_save_literals_mode_in_c_format = false;
uint32_t snapshot_flags = 0;
jerry_init_flag_t flags = JERRY_INIT_EMPTY;
const char *file_name_p = NULL;
uint8_t *source_p = input_buffer;
size_t source_length = 0;
const char *save_literals_file_name_p = NULL;
cli_change_opts (cli_state_p, generate_opts);
for (int id = cli_consume_option (cli_state_p); id != CLI_OPT_END; id = cli_consume_option (cli_state_p))
{
switch (id)
{
case OPT_GENERATE_HELP:
{
cli_help (prog_name_p, "generate", generate_opts);
return JERRY_STANDALONE_EXIT_CODE_OK;
}
case OPT_GENERATE_STATIC:
{
snapshot_flags |= JERRY_SNAPSHOT_SAVE_STATIC;
break;
}
case OPT_GENERATE_LITERAL_LIST:
case OPT_GENERATE_LITERAL_C:
{
if (save_literals_file_name_p != NULL)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: literal file name already specified");
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
is_save_literals_mode_in_c_format = (id == OPT_GENERATE_LITERAL_C);
save_literals_file_name_p = cli_consume_string (cli_state_p);
break;
}
case OPT_GENERATE_SHOW_OP:
{
if (check_feature (JERRY_FEATURE_PARSER_DUMP, cli_state_p->arg))
{
jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG);
flags |= JERRY_INIT_SHOW_OPCODES;
}
break;
}
case OPT_GENERATE_OUT:
{
output_file_name_p = cli_consume_string (cli_state_p);
break;
}
case CLI_OPT_DEFAULT:
{
if (file_name_p != NULL)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Exactly one input file must be specified\n");
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
file_name_p = cli_consume_string (cli_state_p);
if (cli_state_p->error == NULL)
{
source_length = read_file (source_p, file_name_p);
if (source_length == 0)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Input file is empty\n");
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
}
break;
}
default:
{
cli_state_p->error = "Internal error";
break;
}
}
}
if (check_cli_error (cli_state_p))
{
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
if (file_name_p == NULL)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Exactly one input file must be specified\n");
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
jerry_init (flags);
if (!jerry_is_valid_utf8_string (source_p, (jerry_size_t) source_length))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Input must be a valid UTF-8 string.\n");
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
jerry_value_t snapshot_result;
snapshot_result = jerry_generate_snapshot ((jerry_char_t *) file_name_p,
(size_t) strlen (file_name_p),
(jerry_char_t *) source_p,
source_length,
snapshot_flags,
output_buffer,
sizeof (output_buffer) / sizeof (uint32_t));
if (jerry_value_has_error_flag (snapshot_result))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Generating snapshot failed!\n");
jerry_value_clear_error_flag (&snapshot_result);
print_unhandled_exception (snapshot_result);
jerry_release_value (snapshot_result);
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
size_t snapshot_size = (size_t) jerry_get_number_value (snapshot_result);
jerry_release_value (snapshot_result);
FILE *snapshot_file_p = fopen (output_file_name_p, "w");
if (snapshot_file_p == NULL)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Unable to write snapshot file: '%s'\n", output_file_name_p);
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
fwrite (output_buffer, sizeof (uint8_t), snapshot_size, snapshot_file_p);
fclose (snapshot_file_p);
printf ("Created snapshot file: '%s' (%lu bytes)\n", output_file_name_p, (unsigned long) snapshot_size);
if (save_literals_file_name_p != NULL)
{
const size_t literal_buffer_size = jerry_parse_and_save_literals ((jerry_char_t *) source_p,
source_length,
false,
output_buffer,
sizeof (output_buffer) / sizeof (uint32_t),
is_save_literals_mode_in_c_format);
if (literal_buffer_size == 0)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Literal saving failed!\n");
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
FILE *literal_file_p = fopen (save_literals_file_name_p, "w");
if (literal_file_p == NULL)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Unable to write literal file: '%s'\n", save_literals_file_name_p);
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
fwrite (output_buffer, sizeof (uint8_t), literal_buffer_size, literal_file_p);
fclose (literal_file_p);
printf ("Created literal file: '%s' (%lu bytes)\n", save_literals_file_name_p, (unsigned long) literal_buffer_size);
}
return 0;
} /* process_generate */
