static ssize_t
ftp_readfn(void *v, void *buf, size_t len)
{
struct ftpio *io;
int r;
io = (struct ftpio *)v;
if (io == NULL) {
errno = EBADF;
return (-1);
}
if (io->cconn == NULL || io->dconn == NULL || io->dir == O_WRONLY) {
errno = EBADF;
return (-1);
}
if (io->err) {
errno = io->err;
return (-1);
}
if (io->eof)
return (0);
r = fetch_read(io->dconn, buf, len);
if (r > 0)
return (r);
if (r == 0) {
io->eof = 1;
return (0);
}
if (errno != EINTR)
io->err = errno;
return (-1);
}
int
fetch_getln(conn_t *conn)
{
char *tmp, *next;
size_t tmpsize;
ssize_t len;
if (conn->buf == NULL) {
if ((conn->buf = malloc(MIN_BUF_SIZE)) == NULL) {
errno = ENOMEM;
return (-1);
}
conn->bufsize = MIN_BUF_SIZE;
}
conn->buflen = 0;
next = NULL;
do {
/*
* conn->bufsize != conn->buflen at this point,
* so the buffer can be NUL-terminated below for
* the case of len == 0.
*/
len = fetch_read(conn, conn->buf + conn->buflen,
conn->bufsize - conn->buflen);
if (len == -1)
return (-1);
if (len == 0)
break;
next = memchr(conn->buf + conn->buflen, '\n', len);
conn->buflen += len;
if (conn->buflen == conn->bufsize && next == NULL) {
tmp = conn->buf;
tmpsize = conn->bufsize * 2;
if (tmpsize < conn->bufsize) {
errno = ENOMEM;
return (-1);
}
if ((tmp = realloc(tmp, tmpsize)) == NULL) {
errno = ENOMEM;
return (-1);
}
conn->buf = tmp;
conn->bufsize = tmpsize;
}
} while (next == NULL);
if (next != NULL) {
*next = '\0';
conn->next_buf = next + 1;
conn->next_len = conn->buflen - (conn->next_buf - conn->buf);
conn->buflen = next - conn->buf;
} else {
conn->buf[conn->buflen] = '\0';
conn->next_len = 0;
}
return (0);
}
int
fetch_getln(conn_t *conn)
{
char *tmp, *next;
size_t tmpsize;
ssize_t len;
if (conn->buf == NULL) {
if ((conn->buf = malloc(MIN_BUF_SIZE + 1)) == NULL) {
errno = ENOMEM;
return (-1);
}
conn->bufsize = MIN_BUF_SIZE;
}
conn->buf[0] = '\0';
conn->buflen = 0;
next = NULL;
do {
len = fetch_read(conn, conn->buf + conn->buflen,
conn->bufsize - conn->buflen);
if (len == -1)
return (-1);
if (len == 0)
break;
next = memchr(conn->buf + conn->buflen, '\n', len);
conn->buflen += len;
if (conn->buflen == conn->bufsize &&
(next == NULL || next[1] == '\0')) {
tmp = conn->buf;
tmpsize = conn->bufsize * 2 + 1;
if ((tmp = realloc(tmp, tmpsize)) == NULL) {
errno = ENOMEM;
return (-1);
}
conn->buf = tmp;
conn->bufsize = tmpsize;
}
} while (next == NULL);
if (next != NULL) {
conn->next_buf = next + 1;
conn->next_len = conn->buflen - (conn->next_buf - conn->buf);
conn->buflen = next - conn->buf;
}
conn->buf[conn->buflen] = '\0';
return (0);
}
int
fetch_getln(conn_t *conn)
{
char *tmp;
size_t tmpsize;
ssize_t len;
char c;
if (conn->buf == NULL) {
if ((conn->buf = malloc(MIN_BUF_SIZE)) == NULL) {
errno = ENOMEM;
return (-1);
}
conn->bufsize = MIN_BUF_SIZE;
}
conn->buf[0] = '\0';
conn->buflen = 0;
do {
len = fetch_read(conn, &c, 1);
if (len == -1)
return (-1);
if (len == 0)
break;
conn->buf[conn->buflen++] = c;
if (conn->buflen == conn->bufsize) {
tmp = conn->buf;
tmpsize = conn->bufsize * 2 + 1;
if ((tmp = realloc(tmp, tmpsize)) == NULL) {
errno = ENOMEM;
return (-1);
}
conn->buf = tmp;
conn->bufsize = tmpsize;
}
} while (c != '\n');
conn->buf[conn->buflen] = '\0';
DEBUG(fprintf(stderr, "<<< %s", conn->buf));
return (0);
}
void divergences_input(char *filename, char *constant, int *n_divergences, struct DIVERGENCE **divergence)
{
//open the file
FILE *file = fopen(filename,"r");
exit_if_false(file != NULL,"opening input file");
//fetch the data
FETCH fetch = fetch_new(DIVERGENCE_FORMAT,MAX_DIVERGENCES);
exit_if_false(fetch != NULL,"allocating fetch");
int n_fetch = fetch_read(file,DIVERGENCE_LABEL,fetch);
exit_if_false(n_fetch > 1,"no divergences found in input file");
warn_if_false(n_fetch < MAX_DIVERGENCES,"maximum number of divergences reached");
//allocate pointers
struct DIVERGENCE *d = divergences_new(n_fetch,NULL);
exit_if_false(d != NULL,"allocating divergences");
//counters
int i, j, n = 0, info;
//temporary storage
char direction;
int var_offset, dif_offset, pow_offset, dif[2];
char *var_string = (char *)malloc(MAX_STRING_LENGTH * sizeof(char));
char *dif_string = (char *)malloc(MAX_STRING_LENGTH * sizeof(char));
char *pow_string = (char *)malloc(MAX_STRING_LENGTH * sizeof(char));
char *temp = (char *)malloc(MAX_STRING_LENGTH * sizeof(char));
exit_if_false(var_string != NULL && dif_string != NULL && pow_string != NULL && temp != NULL,"allocating temporary strings");
int *vars = (int *)malloc(MAX_DIVERGENCE_VARIABLES * sizeof(int));
int *difs = (int *)malloc(MAX_DIVERGENCE_VARIABLES * sizeof(int));
int *pows = (int *)malloc(MAX_DIVERGENCE_VARIABLES * sizeof(int));
exit_if_false(vars != NULL && difs != NULL && pows != NULL,"allocating temporary data");
for(i = 0; i < n_fetch; i ++)
{
//equation
fetch_get(fetch, i, 0, &d[n].equation);
//direction
fetch_get(fetch, i, 1, &direction);
if(direction == 'x') {
d[n].direction = 0;
} else if(direction == 'y') {
d[n].direction = 1;
} else {
warn_if_false(info = 0,"skipping divergence with unrecognised direction");
continue;
}
//get the variable, differential and power strings
fetch_get(fetch, i, 2, var_string);
fetch_get(fetch, i, 3, dif_string);
fetch_get(fetch, i, 4, pow_string);
for(j = 0; j < strlen(var_string); j ++) if(var_string[j] == ',') var_string[j] = ' ';
for(j = 0; j < strlen(dif_string); j ++) if(dif_string[j] == ',') dif_string[j] = ' ';
for(j = 0; j < strlen(pow_string); j ++) if(pow_string[j] == ',') pow_string[j] = ' ';
//read each variable in turn
var_offset = dif_offset = pow_offset = d[n].n_variables = 0;
while(var_offset < strlen(var_string))
{
info = 1;
//read the variable index from the string
info *= sscanf(&var_string[var_offset],"%s",temp) == 1;
info *= sscanf(temp,"%i",&vars[d[n].n_variables]) == 1;
var_offset += strlen(temp) + 1;
//read the x and y differentials and convert to a differential index
info *= sscanf(&dif_string[dif_offset],"%s",temp) == 1;
j = dif[0] = dif[1] = 0;
if(info)
{
while(temp[j] != '\0')
{
dif[0] += (temp[j] == 'x');
dif[1] += (temp[j] == 'y');
j ++;
}
difs[d[n].n_variables] = differential_index[dif[0]][dif[1]];
}
dif_offset += strlen(temp) + 1;
//read the variable powers from the string
info *= sscanf(&pow_string[pow_offset],"%s",temp) == 1;
info *= sscanf(temp,"%i",&pows[d[n].n_variables]) == 1;
pow_offset += strlen(temp) + 1;
warn_if_false(info,"skipping divergence with unrecognised variable format");
if(!info) continue;
//next variable
d[n].n_variables ++;
}
//allocate the variable and differential arrays
d[n].variable = (int *)malloc(d[n].n_variables * sizeof(int)); //?? SHOULD BE MEMORY FUNCTIONS DOING THIS
d[n].differential = (int *)malloc(d[n].n_variables * sizeof(int));
d[n].power = (int *)malloc(d[n].n_variables * sizeof(int));
exit_if_false(d[n].variable != NULL && d[n].differential != NULL && d[n].power != NULL,"allocating divergence variables and differentials");
//copy over
for(j = 0; j < d[n].n_variables; j ++)
{
d[n].variable[j] = vars[j];
d[n].differential[j] = difs[j];
d[n].power[j] = pows[j];
}
//implicit fraction
fetch_get(fetch, i, 5, &d[n].implicit);
//constant expression
strcpy(temp, constant);
j = strlen(temp);
fetch_get(fetch, i, 6, &temp[j]);
d[n].constant = expression_generate(temp);
warn_if_false(d[n].constant != NULL,"skipping divergence for which the expression generation failed");
if(d[n].constant == NULL) continue;
//printf("divergence %i expression -> ",n); expression_print(d[n].constant); printf("\n");
//increment the number of divergences
n ++;
}
//check numbers
fetch_destroy(fetch);
fetch = fetch_new("",MAX_DIVERGENCES);
warn_if_false(fetch_read(file,DIVERGENCE_LABEL,fetch) == n,"skipping divergences with unrecognised formats");
//copy over
*n_divergences = n;
*divergence = d;
//clean up
fclose(file);
fetch_destroy(fetch);
free(var_string);
free(dif_string);
free(pow_string);
free(temp);
free(vars);
free(difs);
free(pows);
}
void zones_input(char *filename, int n_faces, struct FACE *face, int n_cells, struct CELL *cell, int *n_zones, struct ZONE **zone)
{
//counters
int i, j, n = 0, info;
//open the file
FILE *file = fopen(filename,"r");
exit_if_false(file != NULL,"opening input file");
//fetch the data from the file
FETCH fetch = fetch_new(ZONE_FORMAT, MAX_ZONES);
exit_if_false(fetch != NULL,"allocating zone input");
int n_fetch = fetch_read(file, ZONE_LABEL, fetch);
exit_if_false(n_fetch > 1,"no zones found in input file");
warn_if_false(n_fetch < MAX_ZONES,"maximum number of zones reached");
//allocate zones
struct ZONE *z = zones_new(n_fetch, NULL);
exit_if_false(z != NULL,"allocating zones");
//temporary storage
int offset, index[2];
char *range = (char *)malloc(MAX_STRING_LENGTH * sizeof(char));
char *temp = (char *)malloc(MAX_STRING_LENGTH * sizeof(char));
exit_if_false(range != NULL && temp != NULL,"allocating temporary storage");
//consider each feteched line
for(i = 0; i < n_fetch; i ++)
{
//get zone parameters
fetch_get(fetch, i, 0, &z[n].location);
fetch_get(fetch, i, 2, &z[n].variable);
fetch_get(fetch, i, 3, z[n].condition);
fetch_get(fetch, i, 4, &z[n].value);
//get the range string
fetch_get(fetch, i, 1, range);
//convert comma delimiters to whitespace
for(j = 0; j < strlen(range); j ++) if(range[j] == ',') range[j] = ' ';
//sequentially read ranges
offset = info = 0;
while(offset < strlen(range))
{
//read the range from the string
info = sscanf(&range[offset],"%s",temp) == 1;
info *= sscanf(temp,"%i:%i",&index[0],&index[1]) == 2;
warn_if_false(info,"skipping zone with unrecognised range");
if(!info) break;
//store zone in the elements in the range
if(z[n].location == 'f') for(j = index[0]; j <= index[1]; j ++) exit_if_false(face_zone_add(&face[j],&z[n]),"adding a face zone");
if(z[n].location == 'c') for(j = index[0]; j <= index[1]; j ++) exit_if_false(cell_zone_add(&cell[j],&z[n]),"adding a cell zone");
//move to the next range in the string
offset += strlen(temp) + 1;
}
//increment zone
n += info;
}
//check numbers
fetch_destroy(fetch);
fetch = fetch_new("",MAX_ZONES);
warn_if_false(fetch_read(file,ZONE_LABEL,fetch) == n,"skipping zones with unrecognised formats");
//resize zone list
struct ZONE *z_new = zones_new(n, z);
exit_if_false(zone != NULL,"re-allocating zones");
for(i = 0; i < n_faces; i ++) for(j = 0; j < face[i].n_zones; j ++) face[i].zone[j] += z_new - z;
for(i = 0; i < n_cells; i ++) for(j = 0; j < cell[i].n_zones; j ++) cell[i].zone[j] += z_new - z;
//copy over
*n_zones = n;
*zone = z_new;
//clean up
fclose(file);
fetch_destroy(fetch);
free(range);
free(temp);
}
