示例#1
0
int main(int argc, char **argv)
{
	int fd_rd = -1, fd_wr = -1;

	test_init(argc, argv);

	snprintf(filename_rd, sizeof(filename_rd), "%s.0", filename);
	snprintf(filename_wr, sizeof(filename_wr), "%s.1", filename);

	if (open_files(&fd_rd, &fd_wr)) {
		pr_err("Can't open files\n");
		return -1;
	}
	if (fcntl(fd_rd, F_SETLEASE, F_RDLCK) < 0 ||
		fcntl(fd_wr, F_SETLEASE, F_WRLCK) < 0) {
		pr_perror("Can't set leases\n");
		close_files(fd_rd, fd_wr);
		return -1;
	}

	test_daemon();
	test_waitsig();

	if (check_lease_type(fd_rd, F_RDLCK))
		fail("Read lease check failed\n");
	else if (check_lease_type(fd_wr, F_WRLCK))
		fail("Write lease check failed\n");
	else
		pass();

	close_files(fd_rd, fd_wr);
	return 0;
}
示例#2
0
int main(int argc,char *argv[])
{
  //check number of command line arguments
  if(argc < 3) {
    printf("usage:  %s infile outfile [loader]\n",argv[0]);
    return(-1);
  }

  //save pointers to the filename
  in_filename = argv[1];
  out_filename = argv[2];
  if(argc > 3) {
    loader_filename = argv[3];
  }

  //open all necessary files
  in = fopen(in_filename,"rb");
  out = fopen(out_filename,"wb");
  loader = fopen(loader_filename,"rb");

  //check for errors
  if(in == 0 || out == 0 || loader == 0) {
    if(in == 0)     printf("error opening input file '%s'\n",in_filename);
    if(out == 0)    printf("error opening output file '%s'\n",out_filename);
    if(loader == 0) printf("error opening loader '%s'\n",loader_filename);
    close_files();
    return(1);
  }

  convert_rom();

  //close all open files and exit
  close_files();
  return(0);
}
示例#3
0
int
main(int argc, char *argv[])
{
	int file_count, opt;
	char *opath = NULL;
	int targetfd;
	struct file_stripe_info *finfo;

	while ((opt = getopt(argc, argv, "o:")) != -1) {
		switch (opt) {
		case 'o':
			opath = optarg;
			break;
		default:
			usage(argv[0]);
			return -1;
		}
	}

	file_count = argc - optind;

	if (!opath || !file_count) {
		usage(argv[0]);
		return -1;
	}

	finfo = validate_and_open_files(&argv[optind], file_count);
	if (!finfo)
		goto err;

	targetfd = open(opath, O_RDWR|O_CREAT, finfo->mode);
	if (targetfd < 0)
		goto err;

	if (generate_file(targetfd, finfo) < 0)
		goto err;

	if (fsync(targetfd) < 0)
		fprintf(stderr, "ERROR: %s\n", strerror(errno));
	if (close(targetfd) < 0)
		fprintf(stderr, "ERROR: %s\n", strerror(errno));

	close_files(finfo);
	free(finfo);

	return 0;

err:
	if (finfo) {
		close_files(finfo);
		free(finfo);
	}

	return -1;
}
/* Print the quantum yield (QY) values obtained by using the 2MM measurement
 * method and by using the 3MM method. 2MM will be obtained for each of 
 * IN_BEAM_DATA and OUT_DATA that are provided, 3MM will be obtained only if
 * both are provided. LMIN, LMAX, PMIN, and PMAX set bounds on peak integration.
 * Emission correction for the sensitivity of the detector is specified as
 * EMISSION_CORRECTION, and can be either "default" or "quanta" or any prefix
 * of them.
 */
void QuantumYield(char* solvent_data_file = "",
                     char* in_beam_data = "",
                     int lmin = 0, int lmax = 0,
                     int pmin = 0, int pmax = 0,
                     char* out_beam_data = "",
                     char* emission_correction = "d") {
    double QY;
    double error;
    
    FILE* solvent = open_data(solvent_data_file);
    FILE* in_data = open_data(in_beam_data);
    FILE* out_data = open_data(out_beam_data);
    FILE* correction = open_correction(emission_correction);

    if (!solvent || (!in_data && !out_data)) {
        printf("Invalid data file.\n");
        printf("Arguments: reference data file, in-beam data file, lmin, lmax, pmin, pmax, indirect data file, correction name.\n");
        close_files(solvent, in_data, out_data, correction);
        return;
    }

    if (is_corr) {
        read_correction(correction);
    }

    get_L_a(solvent, lmin, lmax);
    
    if (in_data) {
        QY = TwoMMQY(in_data, lmin, lmax, pmin, pmax);
        error = get_error();
        printf("\n\nL_a %f\nL_b %f\nP_b %f\n2MMQY %f +/- %f\n", L_a, L_b, P_b,
                                                              QY, error);
        printf("L_a - L_b = %f\n", L_a - L_b);
        if (out_data) {
            QY = ThreeMMQY(out_data, lmin, lmax, pmin, pmax);
            error = get_error();
            printf("L_c %f\nP_c %f\n3MMQY %f +/- %f\n", L_c, P_c, QY, error);
            printf("L_a - L_c = %f\n", L_a - L_c);
        }
    }
    if (out_data) {
        rewind(out_data);
        L_b = 0;
        P_b = 0;
        QY = TwoMMQY(out_data, lmin, lmax, pmin, pmax);
        error = get_error();
        printf("2MMQY (out data) %f +/- %f\n", QY, error);
    }
    printf("\n");
    
    close_files(solvent, in_data, out_data, correction);
}
示例#5
0
文件: errc.cpp 项目: rsandila/errconv
int C_Errors::execute()
{
  int result;
  if (!isOk()) 
    {
      fprintf( stderr, _("Class did not initialize properly.\n") );
      return( 1 );
    }
  result=create_files();
  if (result) return( result );
  result=parse_errors();
  if (result) { close_files(); return( result ); }
  return( close_files() );
}
示例#6
0
static void remove_cb(GtkWidget * w, gpointer data)
{
	vcedit_state *state;
	vorbis_comment *comment;

	if (!g_strncasecmp(vte.filename, "http://", 7))
		return;

	state = vcedit_new_state();

	pthread_mutex_lock(&vf_mutex);
	if (init_files(state) < 0)
	{
		fail(_("Failed to modify tag"));
		goto close;
	}

	comment = vcedit_comments(state);

	vorbis_comment_clear(comment);

	if (close_files(state) < 0) 
		fail(_("Failed to modify tag"));

close:
	vcedit_clear(state);
	pthread_mutex_unlock(&vf_mutex);
	gtk_widget_destroy(window);
}
示例#7
0
bool runReachability(double* start, double simTime, double wallTimeMs, double startMs)
{
	LiftingSettings set;

	for (int d = 0; d < NUM_DIMS; ++d)
	{
		set.init.dims[d].min = start[d];
		set.init.dims[d].max = start[d];
	}

	set.reachTime = simTime;
	set.maxRuntimeMilliseconds = wallTimeMs;

	set.initialStepSize = set.reachTime / 10;
	set.maxRectWidthBeforeError = 100;

	set.reachedAtFinalTime = finalState;
	set.reachedAtIntermediateTime = intermediateState;
	set.restartedComputation = restartedComputation;

	open_files(true);
	hyperrectangle_to_file(f_initial, &set.init, 0);

	bool safe =  face_lifting_iterative_improvement(startMs, &set);
	close_files(true);

	return safe;
}
示例#8
0
static void fortran_prescanner_process(prescanner_t* prescanner)
{
	file_lines = NULL;
	last_line = file_lines;

	// Load all the file into memory
	read_lines(prescanner);

	// Cut lines to be of width 'prescanner.width'
	cut_lines(prescanner);

	// We used to remove comments here but it is better to convert them
	convert_whole_line_comments();

	// Join continuated lines
	join_continuated_lines(prescanner);

#if 0
	// Lines that were not appended any continuation line have not been trimmed
	// their inline comments
	remove_inlined_comments();
#endif

	convert_lines(prescanner);

	if (!prescanner->append)
	{
		continuate_lines(prescanner);
	}

	print_lines(prescanner);

    close_files(prescanner);
}
示例#9
0
int spell_check(struct sc_config const *config)
{
    int i = 0;
    int ret = -1;
    char ch;
    char buf[MAX_WORD_LENGTH];
    FILE *files[FILE_COUNT];

    if (open_files(config, files))
        goto ERROR;
    while ((ch = getc(files[FILE_DOC])) != EOF) {
        if (isspace(ch)) {
            buf[i] = '\0';
            if (i != 0) {
                if (handle_word(buf, files, config))
                    goto ERROR;
                i = 0;
            }
            fprintf(files[FILE_OUT], "%c", ch);
        } else {
            buf[i++] = ch;
        }
    }
    ret = 0;

ERROR:
    close_files(files);
    return ret;
}
示例#10
0
main(int argc,char *argv[])
  {

  if (argc<2)
     {
     puts("\nPouziti:  MGFSOUND film.mgf zvuk.wav [i]");
     puts("\nnebo:     MGFSOUND script.scr");
     puts("\nKde _i_ je komprimacni krivka (viz SNDPACK) (default:4)");
     exit(0);
     }
  if (argc>3)
     {
     sscanf(argv[3],"%d",&difftype);
     }
  Create_table_16();
  if (argc==2)
     call_script(argv[1]);
  else
     {
     open_wav(argv[2]);
     open_files(argv[1]);
     ozvuceni();
     }
  close_files();
  }
示例#11
0
static void
get_options(int argc, char *argv[])
{
	char ch;
	struct stat sb;

	i_opt = o_opt = f_opt = v_opt = t_opt = 0;
	while ((ch = getopt(argc, argv, "i:o:f:t:v")) != -1) {
		switch (ch) {
		    case 'v':
			v_opt = 1;
			break;

		    case 'i':
			if ((fmr_fp = fopen(optarg, "rb")) == NULL)
				OPEN_ERR_EXIT(optarg);
			i_opt = 1;
			break;

		    case 'f':	// Fingerprint image list file
			if ((img_fp = fopen(optarg, "r")) == NULL)
				OPEN_ERR_EXIT(optarg);
			f_opt = 1;
			break;

		    case 'o':
			if (stat(optarg, &sb) == 0) {
		    	    fprintf(stderr,
				"File '%s' exists, remove it first.\n", optarg);
			    exit(EXIT_FAILURE);
			}
			if ((an2k_fp = fopen(optarg, "wb")) == NULL)
				OPEN_ERR_EXIT(optarg);
			o_opt = 1;
			break;
				
		    case 't':
			if ((text_fp = fopen(optarg, "r")) == NULL)
				OPEN_ERR_EXIT(optarg);
			t_opt = 1;
			break;

		    case '?':
		    default:
			usage();
			break;
		}
	}

	if ((i_opt && o_opt) == 0) {
		usage();
		goto err_out;
	}
	return;

err_out:
	close_files();
	exit(EXIT_FAILURE);
}
示例#12
0
struct runner *
runner_new(const char *filename)
{
    struct runner *r;
    const char *buf;
    size_t size;
    int err;

    SOL_NULL_CHECK(filename, NULL);

    r = calloc(1, sizeof(*r));
    SOL_NULL_CHECK(r, NULL);

    sol_ptr_vector_init(&r->file_readers);

    r->parser_client.api_version = SOL_FLOW_PARSER_CLIENT_API_VERSION;
    r->parser_client.data = r;
    r->parser_client.read_file = read_file;

    r->parser = sol_flow_parser_new(&r->parser_client, NULL);
    if (!r->parser)
        goto error;

    r->filename = filename;
    r->dirname = strdup(dirname(strdupa(filename)));
    r->basename = strdup(basename(strdupa(filename)));

    err = read_file(r, r->basename, &buf, &size);
    if (err < 0) {
        errno = -err;
        goto error;
    }

    r->root_type = sol_flow_parse_buffer(r->parser, buf, size, filename);
    if (!r->root_type)
        goto error;

    close_files(r);

    return r;

error:
    close_files(r);
    runner_del(r);
    return NULL;
}
示例#13
0
void regenerate_fds(void)
{
	if (no_files == TRUE)
		return;

	close_files();
	open_files();
}
示例#14
0
/* Runs the two-pass assembler. Most of the actual work is done in pass_one()
   and pass_two().
 */
int assemble(const char* in_name, const char* tmp_name, const char* out_name) {
    FILE *src, *dst;
    int err = 0;
    SymbolTable* symtbl = create_table(SYMTBL_UNIQUE_NAME);
    SymbolTable* reltbl = create_table(SYMTBL_NON_UNIQUE);

    if (in_name) {
        printf("Running pass one: %s -> %s\n", in_name, tmp_name);
        if (open_files(&src, &dst, in_name, tmp_name) != 0) {
            free_table(symtbl);
            free_table(reltbl);
            exit(1);
        }

        if (pass_one(src, dst, symtbl) != 0) {
            err = 1;
        }
        close_files(src, dst);
    }

    if (out_name) {
        printf("Running pass two: %s -> %s\n", tmp_name, out_name);
        if (open_files(&src, &dst, tmp_name, out_name) != 0) {
            free_table(symtbl);
            free_table(reltbl);
            exit(1);
        }

        fprintf(dst, ".text\n");
        if (pass_two(src, dst, symtbl, reltbl) != 0) {
            err = 1;
        }
        
        fprintf(dst, "\n.symbol\n");
        write_table(symtbl, dst);

        fprintf(dst, "\n.relocation\n");
        write_table(reltbl, dst);

        close_files(src, dst);
    }
    
    free_table(symtbl);
    free_table(reltbl);
    return err;
}
示例#15
0
/*
 * grpck - verify group file integrity
 */
int main (int argc, char **argv)
{
	int errors = 0;
	bool changed = false;

	/*
	 * Get my name so that I can use it to report errors.
	 */
	Prog = Basename (argv[0]);

	(void) setlocale (LC_ALL, "");
	(void) bindtextdomain (PACKAGE, LOCALEDIR);
	(void) textdomain (PACKAGE);

	process_root_flag ("-R", argc, argv);

	OPENLOG ("grpck");

	/* Parse the command line arguments */
	process_flags (argc, argv);

	open_files ();

	if (sort_mode) {
		gr_sort ();
#ifdef	SHADOWGRP
		if (is_shadow) {
			sgr_sort ();
		}
		changed = true;
#endif
	} else {
		check_grp_file (&errors, &changed);
#ifdef	SHADOWGRP
		if (is_shadow) {
			check_sgr_file (&errors, &changed);
		}
#endif
	}

	/* Commit the change in the database if needed */
	close_files (changed);

	nscd_flush_cache ("group");

	/*
	 * Tell the user what we did and exit.
	 */
	if (0 != errors) {
		if (changed) {
			printf (_("%s: the files have been updated\n"), Prog);
		} else {
			printf (_("%s: no changes\n"), Prog);
		}
	}

	return ((0 != errors) ? E_BAD_ENTRY : E_OKAY);
}
示例#16
0
void print_unity_x( project_info_table& info )
{
	FILE* arr[UNITY_NUM] = {NULL,};
	char fname[MAX_PATH];
	
	for (int i=0; i<UNITY_NUM; ++i)
	{
		std::string name = util::string::wc2mb( info.project_dir_path.c_str() );
		sprintf_s(fname, "%sUnity_%d.cpp", name.c_str() , i+1);
		fopen_s(&arr[i], fname, "wt");

		if (!arr[i])
		{
			close_files(arr);
			return;
		}
		
		fputs("#include \"stdafx.h\"\n\n", arr[i]);
	}

	typedef vector<std::string>::const_iterator iterator;

	int i=0;
	for (iterator itr=info.filepath_table.begin(); itr!=info.filepath_table.end(); ++itr) 
	{
		bool val = false;
		for( iterator except = g_except_file_table.begin(); except!=g_except_file_table.end(); ++except)
		{
			if( *except == *itr )
			{
				val = true;
				break;
			}
		}

		if( !val )
			fprintf(arr[i], "#include \"%s\"\n", (*itr).c_str());

		++i;
		if (i>=UNITY_NUM)
			i=0;
	}

	close_files(arr);
}
示例#17
0
/*
 * main - groupadd command
 */
int main (int argc, char **argv)
{
	/*
	 * Get my name so that I can use it to report errors.
	 */
	Prog = Basename (argv[0]);

	(void) setlocale (LC_ALL, "");
	(void) bindtextdomain (PACKAGE, LOCALEDIR);
	(void) textdomain (PACKAGE);

	process_root_flag ("-R", argc, argv);
	prefix = process_prefix_flag ("-P", argc, argv);

	OPENLOG ("groupadd");
#ifdef WITH_AUDIT
	audit_help_open ();
#endif

	if (atexit (do_cleanups) != 0) {
		fprintf (stderr,
		         _("%s: Cannot setup cleanup service.\n"),
		         Prog);
		exit (1);
	}

	/*
	 * Parse the command line options.
	 */
	process_flags (argc, argv);

	check_perms ();

#ifdef SHADOWGRP
	is_shadow_grp = sgr_file_present ();
#endif

	/*
	 * Do the hard stuff - open the files, create the group entries,
	 * then close and update the files.
	 */
	open_files ();

	if (!gflg) {
		if (find_new_gid (rflg, &group_id, NULL) < 0) {
			exit (E_GID_IN_USE);
		}
	}

	grp_update ();
	close_files ();

	nscd_flush_cache ("group");

	return E_SUCCESS;
}
示例#18
0
//------------------------------open_file------------------------------------
int ArchDesc::open_file(bool required, ADLFILE & ADF, const char *action)
{
  if (required &&
      (ADF._fp = fopen(ADF._name, action)) == NULL) {
    printf("ERROR: Cannot open file for %s: %s\n", action, ADF._name);
    close_files(1);
    return 0;
  }
  return 1;
}
示例#19
0
void process(List *from, List *to)
{
    List *l;


    /*
    ** Initialise read
    */
    open_for_read(from);
    open_for_write(to);

    l = read_header(from);
    write_header(to,l);
    destroy_list(l);

    /*
    ** Process Gels
    */
    for (l = read_gel_data(from);
	 !isNil(l);
	 l = read_gel_data(from)) {
	write_gel_data(to,l);
	destroy_list(l);
    }

    /*
    ** Process Contigs
    */
    for (l = read_contig_data(from);
	 !isNil(l);
	 l = read_contig_data(from)) {
	write_contig_data(to,l);
	destroy_list(l);
    }


    /*
    ** Tidy up read
    */
    close_files(from);
    close_files(to);
	
}
示例#20
0
static int open_files(int *fd_rd, int *fd_wr)
{
	*fd_rd = open(filename_rd, O_RDONLY | O_CREAT, 0666);
	*fd_wr = open(filename_wr, O_WRONLY | O_CREAT, 0666);

	if (*fd_rd < 0 || *fd_wr < 0) {
		close_files(*fd_rd, *fd_wr);
		return -1;
	}
	return 0;
}
示例#21
0
文件: adintool.c 项目: xawirq/julius
/* Interrupt signal handling */
static void
interrupt_record(int signum)
{
  fprintf(stderr, "[Interrupt]");
  if (speech_output == SPOUT_FILE) {
    /* close files */
    close_files();
  }
  /* terminate program */
  exit(1);
}
示例#22
0
文件: libfio.c 项目: DCEngines/fio
void clear_io_state(struct thread_data *td, int all)
{
	struct fio_file *f;
	unsigned int i;

	reset_io_counters(td, all);

	close_files(td);
	for_each_file(td, f, i) {
		fio_file_clear_done(f);
		f->file_offset = get_start_offset(td, f);
	}
示例#23
0
文件: main.c 项目: tonylazarew/jwasm
static void genfailure( int signo )
/*********************************/
{
#if CATCHBREAK
    if (signo != SIGBREAK)
#else
    if (signo != SIGTERM)
#endif
        EmitError( GENERAL_FAILURE );
    close_files();
    exit( EXIT_FAILURE );
}
示例#24
0
文件: gen_idt.c 项目: bboozzoo/zephyr
int main(int argc, char *argv[])
{
	get_exec_name(argv[0]);
	get_options(argc, argv);             /* may exit */
	open_files();                        /* may exit */
	read_input_file();                   /* may exit */
	validate_input_file();               /* may exit */
	generate_interrupt_vector_bitmap();  /* may exit */
	generate_idt();                      /* may exit */
	close_files();
	return 0;
}
示例#25
0
文件: scc.c 项目: IPXSam/scc
int main(int argc, char **argv)
{
	FILE* cfiles[BUFSIZ];
	FILE *asmfile = NULL;
	char errstr[BUFSIZ];
	char line[BUFSIZ];
	int i;

	handle_args(argc, argv);

	for (i = 0; i < opts.c_fcount; ++i) {
		printf("C file[%d]: '%s'\n", i + 1, opts.c_fname[i]);
		cfiles[i] = fopen(opts.c_fname[i], "r");
		if (cfiles[i] == NULL) {
			sprintf(errstr, "couldn't open '%s'", opts.c_fname[i]);
			error(errstr);
			error("perhaps it doesn't exist?");
			opts.c_fcount = i;
			goto exit;
		}
	}
	if (opts.asm_name_spec) printf("asm file: '%s'\n", opts.asm_fname);
	else printf("asm file: '%s'\n", defout);

	for (i = 0; i < opts.c_fcount; ++i) {
		cfiles[i] = comment_preprocessor_notes(cfiles[i], 
		    opts.c_fname[i]);
	}
	for (i = 0; i < opts.c_fcount; ++i) {
		while (fgets(line, BUFSIZ, cfiles[i]) != NULL) printf("%s", line);
		rewind(cfiles[i]);
	}
	
	for (i = 0; i < opts.c_fcount; ++i) {
		yyin = cfiles[i];
		yyparse();
	}
	
	if (scc_error == 0) {
		asmfile = fopen(opts.asm_fname, "w");
		if (asmfile == NULL) {
			sprintf(errstr, "couldn't open '%s' for output", opts.asm_fname);
			error(errstr);
		} else {
			fclose(asmfile);
		}
	}
	exit:
	close_files(cfiles, opts.c_fcount);
	opts_free();
	exit(EXIT_SUCCESS);
}
示例#26
0
void do_conversion(m00data_t* data)
{
	debug_print("Beginning file conversion.\n");
	open_files(data);

	fputs(file_head, data->out_file);

	convert_files(data);

	fputs(file_end, data->out_file);

	close_files(data);
}
示例#27
0
/* threads: Each thread opens the files specified */
void * threads(void* thread_id_) {
	int thread_id = (uintptr_t) thread_id_;
	char errmsg[80];
	FILE *fd_list[MAXFILES];
	int i;

	/* Open files */
	for (i = 0; i < numfiles; i++) {
		if (debug)
			printf("Thread  %d : Opening file number %d \n", thread_id, i);
		if ((fd_list[i] = fopen(filename, "rw")) == NULL) {
			sprintf(errmsg, "FAIL - Couldn't open file #%d", i);
			perror(errmsg);
			if (i > 0) {
				close_files(fd_list, i-1);
			}
			unlink(filename);
			pthread_exit((void*) 1);
		}
	}

	/* Grab mutex lock */
	if (pthread_mutex_lock(&c.m)) {
		perror("FAIL - failed to grab mutex lock");
		close_files(fd_list, numfiles);
		unlink(filename);
		pthread_exit((void*) 1);
	}

	/* Check if you should wake up main thread */
	if (++c.thr_sleeping == numthreads)
		if (pthread_cond_signal(&c.init_cv)) {
			perror("FAIL - failed to signal main thread");
			close_files(fd_list, numfiles);
			unlink(filename);
			pthread_exit((void*) 1);
		}

	/* Sleep until woken up */
	if (pthread_cond_wait(&c.thr_cv, &c.m)) {
		perror("FAIL - failed to wake up correctly");
		close_files(fd_list, numfiles);
		unlink(filename);
		pthread_exit((void*) 1);
	}

	/* Release mutex lock */
	if (pthread_mutex_unlock(&c.m)) {
		perror("FAIL - failed to release mutex lock");
		close_files(fd_list, numfiles);
		unlink(filename);
		pthread_exit((void*) 1);
	}

	/* Close file handles and exit */
	close_files(fd_list, numfiles);
	unlink(filename);
	pthread_exit((void*) 0);
}
示例#28
0
void		test_database_is_valid(int fd)
{
	int		fd_1;
	int		fd_2;

	fd_1 = open("test/good.csv", O_RDONLY);
	fd_2 = open("test/bad.csv", O_RDONLY);
	if (database_is_valid(fd_1) != 1)
	{
		ft_putendl_fd("database_is_valid             test 1 failed!", fd);
		close_files(fd_1, fd_2);
		return ;
	}
	if (database_is_valid(fd_2) != 0)
	{
		ft_putendl_fd("database_is_valid             test 1 failed!", fd);
		close_files(fd_1, fd_2);
		return ;
	}
	close_files(fd_1, fd_2);
	ft_putendl_fd("database_is_valid             OK", fd);
}
示例#29
0
int InternalError( const char *file, unsigned line )
/**************************************************/
// it's used by myassert() function in debug version
{
    char buffer[MAX_LINE_LEN];
    DebugMsg(("InternalError enter\n"));
    ModuleInfo.error_count++;
    GetCurrSrcPos( buffer );
    fprintf( errout, "%s", buffer );
    fprintf( errout, MsgGetEx( INTERNAL_ERROR ), file, line );
    close_files();
    exit( EXIT_FAILURE );
    return(0);
}
示例#30
0
static void
get_options(int argc, char *argv[])
{
	int ch;
	int i_opt;

	i_opt = v_opt = 0;
	r_opt = 0;
	while ((ch = getopt(argc, argv, "i:r:v")) != -1) {
		switch (ch) {

		    case 'i':
			if (i_opt == 2) {
				usage();
				goto err_out;
			}
			if ((in_fp[i_opt] = fopen(optarg, "rb")) == NULL)
				OPEN_ERR_EXIT(optarg);
			i_opt++;
			break;

		    case 'r':
			r_opt = strtol(optarg, NULL, 10);
			if (r_opt == 0 && errno == EINVAL)
                                ERR_OUT("Radius must be numeric");
			if (r_opt < 0)
				ERR_OUT("Radius must be greater than 0");
			break;

		    case 'v':
			v_opt++;
			break;

		    default:
			usage();
			break;
		}
	}

	if ((i_opt != 2) | (r_opt == 0)) {
		usage();
		goto err_out;
	}
	return;

err_out:
	close_files();
	exit(EXIT_FAILURE);
}