示例#1
0
文件: main.c 项目: eddyem/BTA_utils
int main(int argc, char *argv[]){
    check4running(PIDFILE, NULL);
    initial_setup();
    Global_parameters = parse_args(argc, argv);
    assert(Global_parameters);
    if(!get_shm_block(&sdat, ClientSide) || !check_shm_block(&sdat)){
        ERRX("Can't get SHM block!");
    }
    #ifndef EBUG
    PRINT(_("Test multicast connection\n"));
    double last = M_time;
    WAIT_EVENT((fabs(M_time - last) > 0.02), 5.);
    if(tmout && fabs(M_time - last) < 4.)
        ERRX(_("Multicasts stale!"));
    #endif

    signal(SIGTERM, signals); // kill (-15)
    signal(SIGHUP, SIG_IGN);  // hup - daemon
    signal(SIGINT, signals);  // ctrl+C
    signal(SIGQUIT, signals); // ctrl+\   .
    signal(SIGTSTP, SIG_IGN); // ctrl+Z
    setbuf(stdout, NULL);

    setup_pins();
    if(Global_parameters->absmove && gotozero()) ERRX(_("Can't locate zero-endswitch"));

    if(Global_parameters->gotoangle > -360. && Global_parameters->gotoangle < 360.){
        if(Global_parameters->absmove) Global_parameters->gotoangle += PA_ZEROVAL;
        if(gotoangle(Global_parameters->gotoangle)) ERRX(_("Can't move for given angle"));
    }

    stepper_process();
    return 0;
}
示例#2
0
static void
receiver(const int fd, const char *host, const char *port, size_t n, bool conn,
    bool bug)
{
	int s;
	ssize_t l;
	size_t seq;
	struct message msg;
	struct pollfd pfd;
	socklen_t slen;

	s = getsocket(host, port, bind, &slen, bug);
	pfd.fd = s;
	pfd.events = POLLIN;

	/* Tell I'm ready */
	synchronize(fd, false);

	for (seq = 0; seq < n; seq++) {
		if (poll(&pfd, 1, 10000) == -1)
			ERRX(EXIT_FAILURE, "poll (%s)", strerror(errno));
		l = conn ? recv(s, &msg, sizeof(msg), 0) :
		    recvfrom(s, &msg, sizeof(msg), 0, (void *)&ss, &slen);
		if (l == -1)
			ERRX(EXIT_FAILURE, "recv (%s)", strerror(errno));
		if (debug)
			show("got", &msg);
		if (seq != msg.seq)
			ERRX(EXIT_FAILURE, "seq: expect=%zu actual=%zu",
			    seq, msg.seq);
	}

	/* Tell I'm finished */
	synchronize(fd, false);
}
示例#3
0
static int
synchronize(const int fd, bool waiter)
{
	int syncmsg = 0;
	int r;
	struct pollfd pfd;

	if (waiter) {
		pfd.fd = fd;
		pfd.events = POLLIN;

		/* We use poll to avoid lock up when the peer died unexpectedly */
		r = poll(&pfd, 1, 10000);
		if (r == -1)
			ERRX(EXIT_FAILURE, "poll (%s)", strerror(errno));
		if (r == 0)
			/* Timed out */
			return -1;

		if (read(fd, &syncmsg, sizeof(syncmsg)) == -1)
			ERRX(EXIT_FAILURE, "read (%s)", strerror(errno));
	} else {
		if (write(fd, &syncmsg, sizeof(syncmsg)) == -1)
			ERRX(EXIT_FAILURE, "write (%s)", strerror(errno));
	}

	return 0;
}
示例#4
0
static int
getsocket(const char *host, const char *port,
    int (*f)(int, const struct sockaddr *, socklen_t), socklen_t *slen,
    bool bug)
{
	int e, s, lasterrno = 0;
	struct addrinfo hints, *ai0, *ai;
	const char *cause = "?";

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_DGRAM;
	e = getaddrinfo(host, port, &hints, &ai0);
	if (e)
		ERRX(EXIT_FAILURE, "Can't resolve %s:%s (%s)", host, port,
		    gai_strerror(e));

	s = -1;
	for (ai = ai0; ai; ai = ai->ai_next) {
		s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
		if (s == -1) {
			lasterrno = errno;
			cause = "socket";
			continue;
		}
		if (allowv4mapped(s, ai) == -1) {
			cause = "allow v4 mapped";
			goto out;
		}
		if ((*f)(s, ai->ai_addr, ai->ai_addrlen) == -1) {
			cause = f == bind ? "bind" : "connect";
			goto out;
		}
		if ((f == bind || f == connector) && addmc(s, ai, bug) == -1) {
			cause = "join group";
			goto out;
		}
		*slen = ai->ai_addrlen;
		break;
out:
		lasterrno = errno;
		close(s);
		s = -1;
		continue;
	}
	freeaddrinfo(ai0);
	if (s == -1)
		ERRX(EXIT_FAILURE, "%s (%s)", cause, strerror(lasterrno));
	return s;
}
示例#5
0
static void
run(const char *host, const char *port, size_t n, bool conn, bool bug)
{
	pid_t pid;
	int status;
	int syncfds[2];
	int error;

	if (socketpair(AF_UNIX, SOCK_STREAM, 0, syncfds) == -1)
		ERRX(EXIT_FAILURE, "socketpair (%s)", strerror(errno));

	switch ((pid = fork())) {
	case 0:
		receiver(syncfds[0], host, port, n, conn, bug);
		return;
	case -1:
		ERRX(EXIT_FAILURE, "fork (%s)", strerror(errno));
	default:
		error = sender(syncfds[1], host, port, n, conn, bug);
	again:
		switch (waitpid(pid, &status, WNOHANG)) {
		case -1:
			ERRX(EXIT_FAILURE, "wait (%s)", strerror(errno));
		case 0:
			if (error == 0)
				/*
				 * Receiver is still alive, but we know
				 * it will exit soon.
				 */
				goto again;

			if (kill(pid, SIGTERM) == -1)
				ERRX(EXIT_FAILURE, "kill (%s)",
				    strerror(errno));
			goto again;
		default:
			if (WIFSIGNALED(status)) {
				if (WTERMSIG(status) == SIGTERM)
					ERRX0(EXIT_FAILURE,
					    "receiver failed and was killed" \
					    "by sender");
				else
					ERRX(EXIT_FAILURE,
					    "receiver got signaled (%s)",
					    strsignal(WTERMSIG(status)));
			} else if (WIFEXITED(status)) {
				if (WEXITSTATUS(status) != 0)
					ERRX(EXIT_FAILURE,
					    "receiver exited with status %d",
					    WEXITSTATUS(status));
			} else {
				ERRX(EXIT_FAILURE,
				    "receiver exited with unexpected status %d",
				    status);
			}
			break;
		}
		return;
	}
}
示例#6
0
static int
sender(const int fd, const char *host, const char *port, size_t n, bool conn,
    bool bug)
{
	int s;
	ssize_t l;
	struct message msg;

	socklen_t slen;

	s = getsocket(host, port, conn ? connect : connector, &slen, bug);

	/* Wait until receiver gets ready. */
	if (synchronize(fd, true) == -1)
		return -1;

	for (msg.seq = 0; msg.seq < n; msg.seq++) {
#ifdef CLOCK_MONOTONIC
		if (clock_gettime(CLOCK_MONOTONIC, &msg.ts) == -1)
			ERRX(EXIT_FAILURE, "clock (%s)", strerror(errno));
#else
		struct timeval tv;
		if (gettimeofday(&tv, NULL) == -1)
			ERRX(EXIT_FAILURE, "clock (%s)", strerror(errno));
		msg.ts.tv_sec = tv.tv_sec;
		msg.ts.tv_nsec = tv.tv_usec * 1000;
#endif
		if (debug)
			show("sending", &msg);
		l = conn ? send(s, &msg, sizeof(msg), 0) :
		    sendto(s, &msg, sizeof(msg), 0, (void *)&ss, slen);
		if (l == -1)
			ERRX(EXIT_FAILURE, "send (%s)", strerror(errno));
		usleep(100);
	}

	/* Wait until receiver finishes its work. */
	if (synchronize(fd, true) == -1)
		return -1;

	return 0;
}
示例#7
0
文件: dump.c 项目: azryve/arb_api
int main(int argc, char *argv[])
{
	struct nl_sock *sock;
	struct nl_cache *cache;
	struct nl_dump_params params = {
		.dp_type = NL_DUMP_LINE,
		.dp_fd = stdout,
	};

	if ((sock = nl_socket_alloc()) == 0)
		ERRX("Failed nl_socket_alloc");
	if (genl_connect(sock))
		ERRX("Failed genl_connect");
	
	if (genl_ctrl_alloc_cache(sock, &cache))
		ERRX("Failed genl_ctrl_alloc_cache");

	nl_cache_dump(cache, &params);


	return 0;
}
示例#8
0
文件: fits.c 项目: eddyem/fits_filter
/**
 * build IMAGE image from data array indata
 */
IMAGE *buildFITSfromdat(size_t h, size_t w, int dtype, uint8_t *indata){
	size_t stride = 0;
	double (*fconv)(uint8_t *data) = NULL;
	double ubyteconv(uint8_t *data){return (double)*data;}
	double ushortconv(uint8_t *data){return (double)*(int16_t*)data;}
	double ulongconv(uint8_t *data){return (double)*(uint32_t*)data;}
	double ulonglongconv(uint8_t *data){return (double)*(uint64_t*)data;}
	double floatconv(uint8_t *data){return (double)*(float*)data;}
	IMAGE *out = newFITS(h, w, dtype);
	switch (dtype){
		case BYTE_IMG:
			stride = 1;
			fconv = ubyteconv;
		break;
		case SHORT_IMG:
			stride = 2;
			fconv = ushortconv;
		break;
		case LONG_IMG:
			stride = 4;
			fconv = ulongconv;
		break;
		case FLOAT_IMG:
			stride = 4;
			fconv = floatconv;
		break;
		case LONGLONG_IMG:
			fconv = ulonglongconv;
			stride = 8;
		break;
		case DOUBLE_IMG:
			memcpy(out->data, indata, sizeof(double)*w*h);
			return out;
		break;
		default:
		/// Неправильный тип данных
			ERRX(_("Wrong data type"));
	}
	size_t y, W = w*stride;
	Item *data = out->data;
	OMP_FOR(shared(data))
	for(y = 0; y < h; ++y){
		Item *dout = &data[y*w];
		uint8_t *din = &indata[y*W];
		size_t x;
		for(x = 0; x < w; ++x, din += stride)
			*dout++ = fconv(din);
	}
	return out;
}
示例#9
0
/*
 * makes array of pipeline parameters
 * if any found, return TRUE
 * else return FALSE
 */
bool get_pipeline_params(){
	int i, N;
	char **p = G.conv;
	Filter *f;
	for(N = 0; *p; ++N, ++p);
	farray_size = N;
	if(N == 0) return FALSE;
	farray = MALLOC(Filter*, farray_size);
	p = G.conv;
	for(i = 0; i < N; ++i, ++p){
		DBG("filter: %s", *p);
		if(!(f = parse_filter(*p))){
			/// "Неправильно заданы параметры конвейера"
			ERRX(_("Wrong pipeline parameters!"));
		}
		farray[i] = f;
	}
	return TRUE;
}
示例#10
0
/**
 * Mmap file to a memory area
 *
 * @param filename (i) - name of file to mmap
 * @return stuct with mmap'ed file or die
 */
mmapbuf *My_mmap(char *filename){
	int fd;
	char *ptr;
	size_t Mlen;
	struct stat statbuf;
	if(!filename) ERRX(_("No filename given!"));
	if((fd = open(filename, O_RDONLY)) < 0)
		ERR(_("Can't open %s for reading"), filename);
	if(fstat (fd, &statbuf) < 0)
		ERR(_("Can't stat %s"), filename);
	Mlen = statbuf.st_size;
	if((ptr = mmap (0, Mlen, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED)
		ERR(_("Mmap error for input"));
	if(close(fd)) ERR(_("Can't close mmap'ed file"));
	mmapbuf *ret = MALLOC(mmapbuf, 1);
	ret->data = ptr;
	ret->len = Mlen;
	return  ret;
}
示例#11
0
/**
 * Run daemon service
 */
void daemonize(char *port){
    FNAME();
    int sock = -1;
    struct addrinfo hints, *res, *p;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;
    if(getaddrinfo(NULL, port, &hints, &res) != 0){
        ERR("getaddrinfo");
    }
    struct sockaddr_in *ia = (struct sockaddr_in*)res->ai_addr;
    char str[INET_ADDRSTRLEN];
    inet_ntop(AF_INET, &(ia->sin_addr), str, INET_ADDRSTRLEN);
    // loop through all the results and bind to the first we can
    for(p = res; p != NULL; p = p->ai_next){
        if((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1){
            WARN("socket");
            continue;
        }
        int reuseaddr = 1;
        if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int)) == -1){
            ERR("setsockopt");
        }
        if(bind(sock, p->ai_addr, p->ai_addrlen) == -1){
            close(sock);
            WARN("bind");
            continue;
        }
        break; // if we get here, we have a successfull connection
    }
    if(p == NULL){
        putlog("failed to bind socket, exit");
        // looped off the end of the list with no successful bind
        ERRX("failed to bind socket");
    }
    freeaddrinfo(res);
    daemon_(sock);
    close(sock);
    putlog("socket closed, exit");
    signals(0);
}
示例#12
0
IMAGE *process_pipeline(IMAGE *image){
	if(!image){
		/// "Не задано входное изображение"
		ERRX(_("No input image given"));
	}
	if(!farray || !farray_size){
		/// "Не заданы параметры конвейера"
		WARNX(_("No pipeline parameters given"));
	}
	size_t i;
	Filter **far = farray;
	IMAGE *in = copyFITS(image); // copy original image to leave it unchanged
	IMAGE *processed = NULL;
	for(i = 0; i < farray_size; ++i, ++far){
		Filter *f = *far;
		DBG("Got filter #%d: w=%d, h=%d, sx=%g, sy=%g\n", f->FilterType,
			f->w, f->h, f->sx, f->sy);
		printf("try filter %zd\n", i);
		Itmarray oarg = {NULL, 0};
		processed = f->imfunc(in, f, &oarg);
		/// "Ошибка в обработке конвейера"
		if(!processed) ERRX(_("Error on pipeline processing!"));
		// TODO: what should I do with oarg???
		if(oarg.size){
			size_t i, l = oarg.size;
			//if(verbose_level){
				green("got oarg: \n");
				for(i = 0; i < l; ++i){
					printf("%5zd: %g\n", i, oarg.data[i]);
				}
			//}
			char tabname[80];
			snprintf(tabname, 80, "%s_CONVERSION", f->name);
			FITStable *tab = table_new(processed, tabname);
			if(tab){
				table_column col = {
					.width = sizeof(int32_t),
					.repeat = l,
					.coltype = TINT
				};
				int32_t *levls = MALLOC(int32_t, l);
				for(i = 0; i < l; ++i) levls[i] = (int32_t) i;
				col.contents = levls;
				sprintf(col.colname, "level");
				*col.unit = 0;
				table_addcolumn(tab, &col);
				FREE(levls);
				col.contents = oarg.data;
				col.coltype = TDOUBLE;
				col.width = sizeof(double),
				sprintf(col.colname, "value");
				sprintf(col.unit, "ADU");
				table_addcolumn(tab, &col);
				printf("Create table:\n");
				table_print(tab);
			}
			FREE(oarg.data);
		}
		processed->keylist = in->keylist;
		char changes[FLEN_CARD];
		snprintf(changes, FLEN_CARD, "HISTORY modified by routine %s",  f->name);
		list_add_record(&(processed->keylist), changes);
		//list_print(processed->keylist);
		in->keylist = NULL; // prevent deleting global keylist
		imfree(&in);
		in = processed;
	}
	return processed;
}
示例#13
0
Filter *parse_filter(char *pars){
	Filter *fltr;
	int idx = -1;
	pipepars popts;
	mysuboption pipeopts[] = {
		// help for given conversion
		{"help", NO_ARGS,  arg_none,   &popts.help},
		// type of conversion
		{"type", NEED_ARG, arg_string, &popts.ftype},
		// radius of median filter
		{"r",    NEED_ARG, arg_int,    &popts.xsz},
		// sigmax, sigmay for gauss/lapgauss
		{"sx",   NEED_ARG, arg_double, &popts.xhw},
		{"sy",   NEED_ARG, arg_double, &popts.yhw},
		// & window size for them
		{"w",    NEED_ARG, arg_int,    &popts.xsz},
		{"h",    NEED_ARG, arg_int,    &popts.ysz},
		// posterisation
		{"nsteps",NEED_ARG,arg_int,    &popts.xsz},
		{"scale",NEED_ARG, arg_string, &popts.scale},
		end_suboption
	};
	memset(&popts, 0, sizeof(pipepars));
	if(!get_suboption(pars, pipeopts)){
		return NULL;
	}else{
		if(!popts.ftype){ // no type given
			/// "Необходимо по крайней мере задать параметр 'type', например: '-p type=help'"
			ERRX(_("You should at least give parameter 'type', for example: '-p type=help'"));
		}
		DBG("type: %s", popts.ftype);
		if(strcmp(popts.ftype, "help") == 0){ // info about pipeline names
			show_pipeline_pars();
		}
		int i = 0;
		while(filter_names[i].parname){
			if(!strcmp(filter_names[i].parname, popts.ftype)){
				idx = i;
				break;
			}
			++i;
		}
		if(idx == -1){ // wrong type
			/// "Неправильный параметр 'type' конвейера"
			WARNX(_("Wrong pipeline 'type' parameter: %s"), popts.ftype);
			show_pipeline_pars();
		}
	}
	if(popts.help){ // help about current filter options
		showparhelp(idx);
	}
	fltr = MALLOC(Filter, 1);
	fltr->FilterType = filter_names[idx].FilterType;
	fltr->name = strdup(filter_names[idx].parname);
	popts.imfunc = filter_names[idx].imfunc;
	DBG("idx: %d, ftype: %d", idx, fltr->FilterType);
	// check parameters & fill Filer fields
	if(popts.imfunc ==  get_median || popts.imfunc == get_adaptive_median){
		fltr->w = popts.xsz;
	}else if(popts.imfunc ==  DiffFilter &&
			(fltr->FilterType == LAPGAUSS || fltr->FilterType == GAUSS)){
		if(popts.xsz < 5){
			// "Ширина фильтра изменена на 5"
			WARNX(_("Filter window width changed to 5"));
			popts.xsz = 5;
		}
		if(popts.ysz < 5){
			// "Высота фильтра изменена на 5"
			WARNX(_("Filter window height changed to 5"));
			popts.ysz = 5;
		}
		if(popts.xhw < 1. || popts.yhw < 1.){
			/// "Полуширина фильтра должна быть не меньше 1."
			ERRX(_("Filter FWHM should be not less than 1."));
		}
		fltr->w = popts.xsz; fltr->h = popts.ysz;
		fltr->sx = popts.xhw; fltr->sy = popts.yhw;
	}else if(popts.imfunc ==  StepFilter){ // check levels & type
		if(popts.xsz < 2 || popts.xsz > 255){
			/// "Количество уровней градаций яркости должно быть от 2 до 255"
			ERRX(_("Brightness levels amount shoul be from 2 to 255"));
		}
		fltr->w = popts.xsz;
		int i = 0, idx = -1;
		DBG("name: %s", popts.scale);
		if(!popts.scale){
			/// "Не указан параметр scale"
			ERRX(_("You should set 'scale' parameter"));
		}
		while(scales[i].name){
			if(!strcmp(popts.scale, scales[i].name)){
				idx = i; break;
			}
			++i;
		}
		if(idx == -1){
			/// "Параметры фильтра постеризации должны быть такими:\n%s"
			ERRX(_("Posterisation filter parameters should be:\n%s"), stepargs);
		}
		DBG("idx: %d", idx);
		fltr->h = scales[idx].type;
	}
	fltr->imfunc = popts.imfunc;
	DBG("Got filter #%d: w=%d, h=%d, sx=%g, sy=%g\n", fltr->FilterType,
		fltr->w, fltr->h, fltr->sx, fltr->sy);
	return fltr;
}
示例#14
0
文件: fits.c 项目: eddyem/fits_filter
/**
 * add to table 'tbl' column 'column'
 * Be carefull all fields of 'column' exept of 'format' should be filled
 * - if data is character array, 'width' should be equal 0
 * - all input data will be copied, so caller should run 'free' after this function!
 */
FITStable *table_addcolumn(FITStable *tbl, table_column *column){
	FNAME();
	if(!tbl || !column || !column->contents) return NULL;
	long nrows = column->repeat;
	int width = column->width;
	if(tbl->nrows < nrows) tbl->nrows = nrows;
	size_t datalen = nrows * width, cols = ++tbl->ncols;
	char *curformat = column->format;
	DBG("add column; width: %d, nrows: %ld, name: %s", width, nrows, column->colname);
	/*void convchar(){ // count maximum length of strings in array
		char **charr = (char**)column->contents, *dptr = charr;
		size_t n, N = column->repeat;
		for(n = 0; n < N; ++n){
			if(strlen(
			if(*dptr++ == 0){ --processed; if(len > maxlen) maxlen = len; len = 0; }
			else{ ++len; }
		}
	}*/
	#define CHKLEN(type) do{if(width != sizeof(type)) datalen = sizeof(type) * nrows;}while(0)
	switch(column->coltype){
		case TBIT:
			snprintf(curformat, FLEN_FORMAT, "%ldX", nrows);
			CHKLEN(int8_t);
		break;
		case TBYTE:
			snprintf(curformat, FLEN_FORMAT, "%ldB", nrows);
			CHKLEN(int8_t);
		break;
		case TLOGICAL:
			snprintf(curformat, FLEN_FORMAT, "%ldL", nrows);
			CHKLEN(int8_t);
		break;
		case TSTRING:
			if(width == 0){
				snprintf(curformat, FLEN_FORMAT, "%ldA", nrows);
				datalen = nrows;
			}else
				snprintf(curformat, FLEN_FORMAT, "%ldA%d", nrows, width);
		break;
		case TSHORT:
			snprintf(curformat, FLEN_FORMAT, "%ldI", nrows);
			CHKLEN(int16_t);
		break;
		case TLONG:
			snprintf(curformat, FLEN_FORMAT, "%ldJ", nrows);
			CHKLEN(int32_t);
		break;
		case TLONGLONG:
			snprintf(curformat, FLEN_FORMAT, "%ldK", nrows);
			CHKLEN(int64_t);
		break;
		case TFLOAT:
			snprintf(curformat, FLEN_FORMAT, "%ldE", nrows);
			CHKLEN(float);
		break;
		case TDOUBLE:
			snprintf(curformat, FLEN_FORMAT, "%ldD", nrows);
			CHKLEN(double);
		break;
		case TCOMPLEX:
			snprintf(curformat, FLEN_FORMAT, "%ldM", nrows);
			if(width != sizeof(float)*2) datalen = sizeof(float) * nrows * 2;
		break;
		case TDBLCOMPLEX:
			snprintf(curformat, FLEN_FORMAT, "%ldM", nrows);
			if(width != sizeof(double)*2) datalen = sizeof(double) * nrows * 2;
		break;
		case TINT:
			snprintf(curformat, FLEN_FORMAT, "%ldJ", nrows);
			CHKLEN(int32_t);
		break;
		case TSBYTE:
			snprintf(curformat, FLEN_FORMAT, "%ldS", nrows);
			CHKLEN(int8_t);
		break;
		case TUINT:
			snprintf(curformat, FLEN_FORMAT, "%ldV", nrows);
			CHKLEN(int32_t);
		break;
		case TUSHORT:
			snprintf(curformat, FLEN_FORMAT, "%ldU", nrows);
			CHKLEN(int16_t);
		break;
		default:
			WARNX(_("Unsupported column data type!"));
			return NULL;
	}

	DBG("new size: %ld, old: %ld", sizeof(table_column)*cols, sizeof(table_column)*(cols-1));
	if(!(tbl->columns = realloc(tbl->columns, sizeof(table_column)*cols))) ERRX("malloc");
	table_column *newcol = &(tbl->columns[cols-1]);
	memcpy(newcol, column, sizeof(table_column));
	newcol->contents = calloc(datalen, 1);
	if(!newcol->contents) ERRX("malloc");
	DBG("copy %zd bytes", datalen);
	if(column->coltype == TSTRING && width){
		long n;
		char **optr = (char**)newcol->contents, **iptr = (char**)column->contents;
		for(n = 0; n < nrows; ++n, ++optr, ++iptr) *optr = strdup(*iptr);
	}else
		memcpy(newcol->contents, column->contents, datalen);
	return tbl;
}
示例#15
0
文件: fits.c 项目: eddyem/fits_filter
/**
 * add FITS table to image structure
 */
FITStable *table_read(IMAGE *img, fitsfile *fp){
	int ncols, i;
	long nrows;
	char extname[FLEN_VALUE];
	#define TRYRET(f, ...) do{TRYFITS(f, fp, __VA_ARGS__); if(fitsstatus) goto ret;}while(0)
	TRYRET(fits_get_num_rows, &nrows);
	TRYRET(fits_get_num_cols, &ncols);
	TRYRET(fits_read_key, TSTRING, "EXTNAME", extname, NULL);
	DBG("Table named %s with %ld rows and %d columns", extname, nrows, ncols);
	FITStable *tbl = table_new(img, extname);
	if(!tbl) return NULL;
	for(i = 1; i <= ncols; ++i){
		int typecode;
		long repeat, width;
		FITSFUN(fits_get_coltype, fp, i, &typecode, &repeat, &width);
		if(fitsstatus){
			WARNX(_("Can't read column %d!"), i);
			continue;
		}
		DBG("typecode=%d, repeat=%ld, width=%ld", typecode, repeat, width);
		table_column col = {.repeat = repeat, .width = width, .coltype = typecode};
		void *array = malloc(width*repeat);
		if(!array) ERRX("malloc");
		int anynul;
		int64_t nullval = 0;
		int j;
		for(j = 0; j < repeat; ++j){
			FITSFUN(fits_read_col, fp, typecode, i, j=1, 1, 1, (void*)nullval, array, &anynul);
			if(fitsstatus){
				WARNX(_("Can't read column %d row %d!"), i, j);
				continue;
			}
		}
		DBG("done");
		continue;
		col.contents = array;
		char keyword[FLEN_KEYWORD];
		int stat = 0;
		fits_make_keyn("TTYPE", i, keyword, &stat);
		if(stat){WARNX("???"); stat = 0;}
		fits_read_key(fp, TSTRING, keyword, col.colname, NULL, &stat);
		if(stat){ sprintf(col.colname, "noname"); stat = 0;}
		fits_make_keyn("TUNIT", i, keyword, &stat);
		if(stat){WARNX("???"); stat = 0;}
		fits_read_key(fp, TSTRING, keyword, col.unit, NULL, &stat);
		if(stat) *col.unit = 0;
		DBG("Column, cont[2]=%d, type=%d, w=%ld, r=%ld, nm=%s, u=%s", ((int*)col.contents)[2], col.coltype,
			col.width, col.repeat, col.colname, col.unit);
		//table_addcolumn(tbl, &col);
		FREE(array);
	}
//	DBG("fits_create_tbl nrows=%zd, ncols=%zd, colnms[0]=%s, formats[0]=%s, "
//			"units[0]=%s, name=%s", tbl->nrows, cols, tbl->colnames[0], tbl->formats[0], tbl->units[0], tbl->tabname);

	#undef TRYRET
ret:
	if(fitsstatus){
		tablefree(&tbl);
		--img->tables->amount;
	}
	return tbl;
}
示例#16
0
int main(int argc, char **argv){
	int i, j, L;
	mmapbuf *input;
	initial_setup();
	parce_args(argc, argv);
	if(!G.ifile){
		ERRX("You shold give input file name\n");
		return(-1);
	}
	if(G.format) DBG("Format: %s\n", G.format);
	else{
		DBG("No format defined, use \"%%s.%%d\"\n");
		G.format = "%s.%d";
	}
	if(G.nparts) DBG("Use first %d copies of list\n", G.nparts);
	else DBG("Use all list given\n");
	if(!G.list){
		WARNX("Error! You should say\n\t\t%s -L list\n", __progname);
		ERR("\twhere \"list\" is a comma-separated list of sheets\n");
		return(-1);
	}
	L = build_list();
	DBG("Found %d sheets in list:\n", L);
	if(L == 0){
		ERRX("Error: empty list\n");
		return(-1);
	}
	for(i = 0; i < L; i++) DBG("\titem %d: %s\n", i, List[i]);
	if(!(input = My_mmap(G.ifile))){
		ERRX("A strange error: can't mmap input file\n");
		return(-1);
	}
	char *iptr = input->data, *oldptr = iptr;

	i = 0;
	char comp[32], val[32];
	int N1, N2;
	while((iptr = strstr(iptr, "$Comp\n"))){
		DBG("%dth component: ", ++i);
		iptr = strstr(iptr, "\nL ");
		if(!iptr) break;
		iptr += 3;
		if(sscanf(iptr, "%s %s\n", comp, val) != 2) continue;
		DBG("component %s with label %s\n", comp, val);
		iptr = strstr(iptr, "\nU ");
		if(!iptr) break;
		iptr += 3;
		if(sscanf(iptr, "%d %d %s\n",&N1,&N2,comp) != 3) continue;
		DBG("N1 = %d; N2 = %d; comp label: %s\n",N1,N2,comp);
		iptr = strstr(iptr, "\nF"); // go to line "F 0"
		if(!iptr) break;
		iptr++;
		// printout all what was before:
		oldptr = printdata(oldptr, iptr);
		for(j = 0; j < L; j++){
			printf("AR Path=\"/%s/%s\" Ref=\"", List[j], comp);
			printf(G.format, val, j+1);
			printf("\"  Part=\"1\"\n");
		}
	}
	// printout the rest of file
	if(!iptr) iptr = input->data + input->len;
	printdata(oldptr, iptr);
	My_munmap(input);
	return 0;
}