/**
* gts_file_first_token_after:
* @f: a #GtsFile.
* @type: a #GtsTokenType.
*
* Finds and sets the first token of a type different from @type
* occuring after a token of type @type.
*/
void gts_file_first_token_after (GtsFile * f, GtsTokenType type)
{
g_return_if_fail (f != NULL);
while (f->type != GTS_ERROR &&
f->type != GTS_NONE &&
f->type != type)
gts_file_next_token (f);
while (f->type == type)
gts_file_next_token (f);
}
static void gfs_refine_read (GtsObject ** o, GtsFile * fp)
{
GfsRefine * refine = GFS_REFINE (*o);
GtsObjectClass * klass;
gboolean class_changed = FALSE;
if (fp->type != GTS_STRING) {
gts_file_error (fp, "expecting a string (GfsRefineClass)");
return;
}
klass = gfs_object_class_from_name (fp->token->str);
if (klass == NULL) {
gts_file_error (fp, "unknown class `%s'", fp->token->str);
return;
}
if (!gts_object_class_is_from_class (klass, gfs_refine_class ())) {
gts_file_error (fp, "`%s' is not a GfsRefine", fp->token->str);
return;
}
if (klass != (*o)->klass) {
*o = gts_object_new (klass);
gts_object_destroy (GTS_OBJECT (refine));
refine = GFS_REFINE (*o);
class_changed = TRUE;
}
gts_file_next_token (fp);
gfs_function_read (refine->maxlevel, gfs_object_simulation (refine), fp);
if (fp->type == GTS_ERROR)
return;
if (class_changed && fp->type != '\n' && klass->read)
(* klass->read) (o, fp);
}
/**
* gts_file_new:
* @fp: a file pointer.
*
* Returns: a new #GtsFile.
*/
GtsFile * gts_file_new (FILE * fp)
{
GtsFile * f;
g_return_val_if_fail (fp != NULL, NULL);
f = file_new ();
f->fp = fp;
gts_file_next_token (f);
return f;
}
/**
* gts_file_new_from_buffer:
* @buf: a buffer.
* @len: the size of the buffer.
*
* Returns: a new #GtsFile.
*/
GtsFile * gts_file_new_from_buffer (gchar * buf, size_t len)
{
GtsFile * f;
g_return_val_if_fail (buf != NULL, NULL);
f = file_new ();
f->buf = buf;
f->len = len;
gts_file_next_token (f);
return f;
}
GtsFile *gts_file_new( FILE *fp )
{
int ebx;
GtsFile *f;
{
/* phantom */ int _g_boolean_var_;
if ( fp == 0 )
{
f = 0;
g_return_if_fail_warning( 0, __PRETTY_FUNCTION__, "fp != NULL" );
return f;
}
f = &fp[0]._flags;
gts_file_next_token( file_new( ) );
return *ebp_24;
}
}
/**
* gts_file_assign_start:
* @f: a #GtsFile.
* @vars: a %GTS_NONE terminated array of #GtsFileVariable.
*
* Opens a block delimited by braces to read a list of optional
* arguments specified by @vars.
*
* If an error is encountered the @error field of @f is set.
*/
void gts_file_assign_start (GtsFile * f, GtsFileVariable * vars)
{
GtsFileVariable * var;
g_return_if_fail (f != NULL);
g_return_if_fail (vars != NULL);
var = vars;
while (var->type != GTS_NONE)
(var++)->set = FALSE;
if (f->type != '{') {
gts_file_error (f, "expecting an opening brace");
return;
}
f->scope_max++;
gts_file_next_token (f);
}
GtsFile *gts_file_new_from_string( gchar *s )
{
int ebx;
int esi;
GtsFile *f;
{
/* phantom */ int _g_boolean_var_;
if ( s == 0 )
{
f = 0;
g_return_if_fail_warning( 0, __PRETTY_FUNCTION__, "s != NULL" );
return f;
}
f = file_new( );
f->s = g_strdup( s );
f->s1 = g_strdup( s );
gts_file_next_token( f );
return f;
}
}
/**
* gts_file_assign_next:
* @f: a #GtsFile.
* @vars: a %GTS_NONE terminated array of #GtsFileVariable.
*
* Assigns the next optional argument of @vars read from @f.
*
* Returns: the variable of @vars which has been assigned or %NULL if
* no variable has been assigned (if an error has been encountered the
* @error field of @f is set).
*/
GtsFileVariable * gts_file_assign_next (GtsFile * f, GtsFileVariable * vars)
{
GtsFileVariable * var;
gboolean found = FALSE;
g_return_val_if_fail (f != NULL, NULL);
g_return_val_if_fail (vars != NULL, NULL);
while (f->type == '\n')
gts_file_next_token (f);
if (f->type == '}') {
f->scope_max--;
gts_file_next_token (f);
return NULL;
}
if (f->type == GTS_ERROR)
return NULL;
var = vars;
while (f->type != GTS_ERROR && var->type != GTS_NONE && !found) {
if (!strcmp (var->name, f->token->str)) {
found = TRUE;
if (var->unique && var->set)
gts_file_error (f, "variable `%s' was already set at line %d:%d",
var->name, var->line, var->pos);
else {
var->line = f->line;
var->pos = f->pos;
gts_file_next_token (f);
if (f->type != '=')
gts_file_error (f, "expecting `='");
else {
var->set = TRUE;
switch (var->type) {
case GTS_FILE:
break;
case GTS_INT:
gts_file_next_token (f);
if (f->type != GTS_INT) {
gts_file_error (f, "expecting an integer");
var->set = FALSE;
}
else if (var->data)
*((gint *) var->data) = atoi (f->token->str);
break;
case GTS_UINT:
gts_file_next_token (f);
if (f->type != GTS_INT) {
gts_file_error (f, "expecting an integer");
var->set = FALSE;
}
else if (var->data)
*((guint *) var->data) = atoi (f->token->str);
break;
case GTS_FLOAT:
gts_file_next_token (f);
if (f->type != GTS_INT && f->type != GTS_FLOAT) {
gts_file_error (f, "expecting a number");
var->set = FALSE;
}
else if (var->data)
*((gfloat *) var->data) = atof (f->token->str);
break;
case GTS_DOUBLE:
gts_file_next_token (f);
if (f->type != GTS_INT && f->type != GTS_FLOAT) {
gts_file_error (f, "expecting a number");
var->set = FALSE;
}
else if (var->data)
*((gdouble *) var->data) = atof (f->token->str);
break;
case GTS_OBJ:
gts_file_next_token (f);
if (var->data) {
GtsObject ** object = var->data;
g_return_val_if_fail (GTS_IS_OBJECT (*object), NULL);
(* (*object)->klass->read) (object, f);
}
break;
case GTS_STRING:
gts_file_next_token (f);
if (f->type != GTS_INT &&
f->type != GTS_FLOAT &&
f->type != GTS_STRING) {
gts_file_error (f, "expecting a string");
var->set = FALSE;
}
else {
if (f->token->str[0] != '"') { /* simple string */
if (var->data)
*((gchar **) var->data) = g_strdup (f->token->str);
}
else {
/* quoted string */
gint len = strlen (f->token->str);
if (f->token->str[len - 1] == '"') {
/* simple quoted string */
f->token->str[len - 1] = '\0';
if (var->data)
*((gchar **) var->data) = g_strdup (&(f->token->str[1]));
f->token->str[len - 1] = '"';
}
else {
/* multiple parts */
GString * s = g_string_new (&(f->token->str[1]));
g_string_append_c (s, ' ');
int c = gts_file_getc (f);
while (c != '"' && c != EOF) {
g_string_append_c (s, c);
c = gts_file_getc (f);
}
if (var->data)
*((gchar **) var->data) = g_strdup (s->str);
g_string_free (s, TRUE);
}
}
}
break;
default:
g_assert_not_reached ();
}
}
}
}
else
var++;
}
if (!found)
gts_file_error (f, "unknown identifier `%s'", f->token->str);
else if (f->type != GTS_ERROR) {
g_assert (var->set);
if (f->type != '}')
gts_file_next_token (f);
return var;
}
return NULL;
}
static void gfs_porous_read (GtsObject ** o, GtsFile * fp)
{
/* call read method of parent */
(* GTS_OBJECT_CLASS (gfs_porous_class ())->parent_class->read) (o, fp);
if (fp->type == GTS_ERROR)
return;
GfsPorous * por = GFS_POROUS (*o);
GfsSimulation * sim = GFS_SIMULATION (por);
/* do object-specific read here */
if (fp->type != '{') {
gts_file_error (fp, "expecting an opening brace");
return;
}
fp->scope_max++;
gts_file_next_token (fp);
while (fp->type != GTS_ERROR && fp->type != '}') {
if (fp->type == '\n') {
gts_file_next_token (fp);
continue;
}
if (fp->type != GTS_STRING) {
gts_file_error (fp, "expecting a keyword");
return;
}
if (!strcmp (fp->token->str, "porosity")) {
gts_file_next_token (fp);
if (fp->type != '=')
gts_file_error (fp, "expecting `='");
else{
gts_file_next_token (fp);
gfs_function_read (por->porosity, sim, fp);
}
}
if (!strcmp (fp->token->str, "K")) {
gts_file_next_token (fp);
if (fp->type != '=')
gts_file_error (fp, "expecting `='");
else{
gts_file_next_token (fp);
gfs_function_read (por-> K, sim , fp);
}
}
}
if (fp->type == GTS_ERROR)
return;
if (fp->type != '}') {
gts_file_error (fp, "expecting a closing brace");
return;
fp->scope_max--;
gts_file_next_token (fp);
/* do not forget to prepare for next read */
}
}
static void output_spectra_read (GtsObject ** o, GtsFile * fp)
{
(* GTS_OBJECT_CLASS (gfs_output_spectra_class ())->parent_class->read) (o, fp);
if (fp->type == GTS_ERROR)
return;
GfsOutputSpectra * v = GFS_OUTPUT_SPECTRA (*o);
if (fp->type != GTS_STRING) {
gts_file_error (fp, "expecting a string (v)");
return;
}
GfsDomain * domain = GFS_DOMAIN (gfs_object_simulation (*o));
if (!(v->v = gfs_variable_from_name (domain->variables, fp->token->str))) {
gts_file_error (fp, "unknown variable `%s'", fp->token->str);
return;
}
gts_file_next_token (fp);
GtsFileVariable var[] = {
{GTS_DOUBLE, "x", TRUE, &v->pos.x},
{GTS_DOUBLE, "y", TRUE, &v->pos.y},
{GTS_DOUBLE, "z", TRUE, &v->pos.z},
{GTS_DOUBLE, "Lx", TRUE, &v->L.x},
{GTS_DOUBLE, "Ly", TRUE, &v->L.y},
{GTS_DOUBLE, "Lz", TRUE, &v->L.z},
{GTS_NONE}
};
gts_file_assign_variables (fp, var);
if (fp->type == GTS_ERROR)
return;
if (fp->type == GTS_INT) {
v->level = atoi (fp->token->str);
gts_file_next_token (fp);
}
else
v->level = gfs_domain_depth (domain);
guint i, j, k, size = 1;
v->cgd = gfs_cartesian_grid_new (gfs_cartesian_grid_class ());
/* number of dims of the fft */
v->cgd->N = 3;
v->Ndim = 0;
k = 0;
for (i = 0; i < 3; i++) {
if ((&(v->L.x))[i] != 0) {
v->Ndim++;
v->dir[k] = i;
k++;
}
}
if (v->Ndim == 0) {
gts_file_error (fp, "There must be at least one L component larger than 0");
return;
}
/* number of points in each direction */
v->cgd->n = g_malloc (3*sizeof (guint));
for (i = 0; i < 3; i++) {
if ((&(v->L.x))[i] == 0 )
v->cgd->n[i] = 1;
else
v->cgd->n[i] = pow(2,v->level);
size *= v->cgd->n[i];
}
/* mesh coordinates */
v->cgd->x = g_malloc0 (3*sizeof (gdouble *));
for (i = 0; i < 3; i++) {
v->cgd->x[i] = g_malloc (v->cgd->n[i]*sizeof (gdouble));
if (v->cgd->n[i] != 1)
for (j = 0; j < v->cgd->n[i]; j++)
v->cgd->x[i][j] =
(&(v->pos.x))[i] + (&(v->L.x))[i]*(gdouble)j/((gdouble)(v->cgd->n[i]-1)) - 0.5;
else
v->cgd->x[i][0] = (&(v->pos.x))[i];
}
/* memory data allocation */
v->cgd->v = g_malloc0( sizeof ( gdouble ) * 2*(size/2+1) );
}
