"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "Interface/ProData.cpp" between
getdp-3.4.0-source.tgz and getdp-3.5.0-source.tgz

About: GetDP is a general finite element solver using mixed elements to discretize de Rham-type complexes in one, two and three dimensions.

ProData.cpp  (getdp-3.4.0-source.tgz)	:	ProData.cpp  (getdp-3.5.0-source.tgz)
// GetDP - Copyright (C) 1997-2021 P. Dular and C. Geuzaine, University of Liege		// GetDP - Copyright (C) 1997-2022 P. Dular and C. Geuzaine, University of Liege
//		//
// See the LICENSE.txt file for license information. Please report all		// See the LICENSE.txt file for license information. Please report all
// issues on https://gitlab.onelab.info/getdp/getdp/issues.		// issues on https://gitlab.onelab.info/getdp/getdp/issues.
#include <stdlib.h>		#include <stdlib.h>
#include <string.h>		#include <string.h>
#include <string>		#include <string>
#include <set>		#include <set>
#include "GetDPConfig.h"		#include "GetDPConfig.h"
#include "ProData.h"		#include "ProData.h"
skipping to change at line 35		skipping to change at line 35
struct Problem Problem_S;		struct Problem Problem_S;
// Global run-time current data: this is the only current data		// Global run-time current data: this is the only current data
// structure that is instantiated		// structure that is instantiated
struct CurrentData Current;		struct CurrentData Current;
// Sorting functions		// Sorting functions
int fcmp_Integer(const void *a, const void *b)		int fcmp_Integer(const void *a, const void *b)
{		{
return(*(int*)a - *(int*)b );		return (*(int *)a - *(int *)b);
}		}
int fcmp_Integer2(const void *a, const void *b)		int fcmp_Integer2(const void *a, const void *b)
{		{
static int result ;		static int result;
if ( ( result = (*(int*)a - *(int*)b ) ) != 0 ) return result ;		if((result = (*(int *)a - *(int *)b)) != 0) return result;
return (*((int*)a+1) - *((int*)b+1) );		return (*((int *)a + 1) - *((int *)b + 1));
}		}
int fcmp_Constant (const void *a, const void *b)		int fcmp_Constant(const void *a, const void *b)
{		{
return ( strcmp(((struct Constant *)a)->Name, ((struct Constant *)b)->Name));		return (strcmp(((struct Constant *)a)->Name, ((struct Constant *)b)->Name));
}		}
int fcmp_Expression_Name(const void *a, const void *b)		int fcmp_Expression_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct Expression *)b)->Name ) );		return (strcmp((char *)a, ((struct Expression *)b)->Name));
}		}
int fcmp_Group_Name(const void *a, const void *b)		int fcmp_Group_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct Group *)b)->Name ) );		return (strcmp((char *)a, ((struct Group *)b)->Name));
}		}
int fcmp_Constraint_Name(const void *a, const void *b)		int fcmp_Constraint_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct Constraint *)b)->Name ) );		return (strcmp((char *)a, ((struct Constraint *)b)->Name));
}		}
int fcmp_JacobianMethod_Name(const void *a, const void *b)		int fcmp_JacobianMethod_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct JacobianMethod *)b)->Name ) );		return (strcmp((char *)a, ((struct JacobianMethod *)b)->Name));
}		}
int fcmp_IntegrationMethod_Name(const void *a, const void *b)		int fcmp_IntegrationMethod_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct IntegrationMethod *)b)->Name ) );		return (strcmp((char *)a, ((struct IntegrationMethod *)b)->Name));
}		}
int fcmp_BasisFunction_Name(const void *a, const void *b)		int fcmp_BasisFunction_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct BasisFunction *)b)->Name ) );		return (strcmp((char *)a, ((struct BasisFunction *)b)->Name));
}		}
int fcmp_FunctionSpace_Name(const void *a, const void *b)		int fcmp_FunctionSpace_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct FunctionSpace *)b)->Name ) );		return (strcmp((char *)a, ((struct FunctionSpace *)b)->Name));
}		}
int fcmp_BasisFunction_NameOfCoef(const void *a, const void *b)		int fcmp_BasisFunction_NameOfCoef(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct BasisFunction *)b)->NameOfCoef ) );		return (strcmp((char *)a, ((struct BasisFunction *)b)->NameOfCoef));
}		}
int fcmp_SubSpace_Name(const void *a, const void *b)		int fcmp_SubSpace_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct SubSpace *)b)->Name ) );		return (strcmp((char *)a, ((struct SubSpace *)b)->Name));
}		}
int fcmp_GlobalQuantity_Name(const void *a, const void *b)		int fcmp_GlobalQuantity_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct GlobalQuantity *)b)->Name ) );		return (strcmp((char *)a, ((struct GlobalQuantity *)b)->Name));
}		}
int fcmp_Formulation_Name(const void *a, const void *b)		int fcmp_Formulation_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct Formulation *)b)->Name ) );		return (strcmp((char *)a, ((struct Formulation *)b)->Name));
}		}
int fcmp_DefineQuantity_Name(const void *a, const void *b)		int fcmp_DefineQuantity_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct DefineQuantity *)b)->Name ) );		return (strcmp((char *)a, ((struct DefineQuantity *)b)->Name));
}		}
int fcmp_DefineSystem_Name(const void *a, const void *b)		int fcmp_DefineSystem_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct DefineSystem *)b)->Name ) );		return (strcmp((char *)a, ((struct DefineSystem *)b)->Name));
}		}
int fcmp_Resolution_Name(const void *a, const void *b)		int fcmp_Resolution_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct Resolution *)b)->Name ) );		return (strcmp((char *)a, ((struct Resolution *)b)->Name));
}		}
int fcmp_PostProcessing_Name(const void *a, const void *b)		int fcmp_PostProcessing_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct PostProcessing *)b)->Name ) );		return (strcmp((char *)a, ((struct PostProcessing *)b)->Name));
}		}
int fcmp_PostQuantity_Name(const void *a, const void *b)		int fcmp_PostQuantity_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct PostQuantity *)b)->Name ) );		return (strcmp((char *)a, ((struct PostQuantity *)b)->Name));
}		}
int fcmp_PostOperation_Name(const void *a, const void *b)		int fcmp_PostOperation_Name(const void *a, const void *b)
{		{
return ( strcmp((char *)a, ((struct PostOperation *)b)->Name ) );		return (strcmp((char *)a, ((struct PostOperation *)b)->Name));
}		}
// I/O routines		// I/O routines
void Init_ProblemStructure()		void Init_ProblemStructure()
{		{
Problem_S.Group = NULL ;		Problem_S.Group = NULL;
Problem_S.Expression = NULL ;		Problem_S.Expression = NULL;
Problem_S.FunctionSpace = NULL ;		Problem_S.FunctionSpace = NULL;
Problem_S.Constraint = NULL ;		Problem_S.Constraint = NULL;
Problem_S.Formulation = NULL ;		Problem_S.Formulation = NULL;
Problem_S.JacobianMethod = NULL ;		Problem_S.JacobianMethod = NULL;
Problem_S.IntegrationMethod = NULL ;		Problem_S.IntegrationMethod = NULL;
Problem_S.Resolution = NULL ;		Problem_S.Resolution = NULL;
Problem_S.PostProcessing = NULL ;		Problem_S.PostProcessing = NULL;
Problem_S.PostOperation = NULL ;		Problem_S.PostOperation = NULL;
Current.Name = NULL;		Current.Name = NULL;
Current.NbrSystem = 0;		Current.NbrSystem = 0;
Current.DefineSystem_P = NULL ;		Current.DefineSystem_P = NULL;
Current.DofData_P0 = NULL;		Current.DofData_P0 = NULL;
Current.DofData = NULL;		Current.DofData = NULL;
Current.GeoData = NULL;		Current.GeoData = NULL;
Current.PostOpData_L = NULL;		Current.PostOpData_L = NULL;
Current.PostOpDataIndex = 0;		Current.PostOpDataIndex = 0;
Current.NbrHar = 0;		Current.NbrHar = 0;
Current.Region = 0;		Current.Region = 0;
Current.SubRegion = 0;		Current.SubRegion = 0;
Current.NumEntity = 0;		Current.NumEntity = 0;
Current.NumEntityInElement = 0;		Current.NumEntityInElement = 0;
skipping to change at line 227		skipping to change at line 227
Current.RelaxFac = 0.0; //+++		Current.RelaxFac = 0.0; //+++
Current.NbrTestedFac = 0.0; //+++		Current.NbrTestedFac = 0.0; //+++
Current.SolveJacAdaptFailed = 0.0; //+++		Current.SolveJacAdaptFailed = 0.0; //+++
Current.KSPIterations = 0.0;		Current.KSPIterations = 0.0;
Current.KSPIteration = 0.0;		Current.KSPIteration = 0.0;
Current.KSPResidual = 0.0;		Current.KSPResidual = 0.0;
Current.KSPSystemSize = 0.0;		Current.KSPSystemSize = 0.0;
}		}
// FIXME: TODO to remove parser memory leaks!		// FIXME: TODO to remove parser memory leaks!
void Free_Group(struct Group* a)		void Free_Group(struct Group *a)
{		{
// we should convert all the structs into classes and add a default		// we should convert all the structs into classes and add a default
// constructor with proper initializations ; cleanup the parser to make sure		// constructor with proper initializations ; cleanup the parser to make sure
// who owns what, so we can safely delete		// who owns what, so we can safely delete
//		//
// List_Delete(a->ExtendedList); List_Delete(a->ExtendedSuppList);		// List_Delete(a->ExtendedList); List_Delete(a->ExtendedSuppList);
}		}
void Free_Expression(struct Expression* a){}		void Free_Expression(struct Expression *a) {}
void Free_FunctinSpace(struct FunctionSpace* a){}		void Free_FunctinSpace(struct FunctionSpace *a) {}
void Free_Constraint(struct Constraint* a){}		void Free_Constraint(struct Constraint *a) {}
void Free_Formulation(struct Formuation* a){}		void Free_Formulation(struct Formuation *a) {}
void Free_JacobianMethod(struct JacobianMethod* a){}		void Free_JacobianMethod(struct JacobianMethod *a) {}
void Free_IntegrationMethod(struct IntegrationMethod* a){}		void Free_IntegrationMethod(struct IntegrationMethod *a) {}
void Free_Resolution(struct Resolution* a){}		void Free_Resolution(struct Resolution *a) {}
void Free_PostProcessing(struct PostProcessing* a){}		void Free_PostProcessing(struct PostProcessing *a) {}
void Free_PostOperation(struct PostOperation* a){}		void Free_PostOperation(struct PostOperation *a) {}
void Free_ProblemStructure()		void Free_ProblemStructure()
{		{
if(Problem_S.Group){		if(Problem_S.Group) {
for(int i = 0; i < List_Nbr(Problem_S.Group); i++)		for(int i = 0; i < List_Nbr(Problem_S.Group); i++)
Free_Group((Group*)List_Pointer(Problem_S.Group, i));		Free_Group((Group *)List_Pointer(Problem_S.Group, i));
List_Delete(Problem_S.Group);		List_Delete(Problem_S.Group);
}		}
if(Problem_S.Expression){		if(Problem_S.Expression) {
for(int i = 0; i < List_Nbr(Problem_S.Expression); i++)		for(int i = 0; i < List_Nbr(Problem_S.Expression); i++)
Free_Expression((Expression*)List_Pointer(Problem_S.Expression, i));		Free_Expression((Expression *)List_Pointer(Problem_S.Expression, i));
List_Delete(Problem_S.Expression);		List_Delete(Problem_S.Expression);
}		}
if(Problem_S.FunctionSpace){		if(Problem_S.FunctionSpace) {
for(int i = 0; i < List_Nbr(Problem_S.FunctionSpace); i++)		for(int i = 0; i < List_Nbr(Problem_S.FunctionSpace); i++)
Free_FunctinSpace((FunctionSpace*)List_Pointer(Problem_S.FunctionSpace, i)		Free_FunctinSpace(
);		(FunctionSpace *)List_Pointer(Problem_S.FunctionSpace, i));
List_Delete(Problem_S.FunctionSpace);		List_Delete(Problem_S.FunctionSpace);
}		}
if(Problem_S.Constraint){		if(Problem_S.Constraint) {
for(int i = 0; i < List_Nbr(Problem_S.Constraint); i++)		for(int i = 0; i < List_Nbr(Problem_S.Constraint); i++)
Free_Constraint((Constraint*)List_Pointer(Problem_S.Constraint, i));		Free_Constraint((Constraint *)List_Pointer(Problem_S.Constraint, i));
List_Delete(Problem_S.Constraint);		List_Delete(Problem_S.Constraint);
}		}
if(Problem_S.Formulation){		if(Problem_S.Formulation) {
for(int i = 0; i < List_Nbr(Problem_S.Formulation); i++)		for(int i = 0; i < List_Nbr(Problem_S.Formulation); i++)
Free_Formulation((Formuation*)List_Pointer(Problem_S.Formulation, i));		Free_Formulation((Formuation *)List_Pointer(Problem_S.Formulation, i));
List_Delete(Problem_S.Formulation);		List_Delete(Problem_S.Formulation);
}		}
if(Problem_S.JacobianMethod){		if(Problem_S.JacobianMethod) {
for(int i = 0; i < List_Nbr(Problem_S.JacobianMethod); i++)		for(int i = 0; i < List_Nbr(Problem_S.JacobianMethod); i++)
Free_JacobianMethod((JacobianMethod*)List_Pointer(Problem_S.JacobianMethod		Free_JacobianMethod(
, i));		(JacobianMethod *)List_Pointer(Problem_S.JacobianMethod, i));
List_Delete(Problem_S.JacobianMethod);		List_Delete(Problem_S.JacobianMethod);
}		}
if(Problem_S.IntegrationMethod){		if(Problem_S.IntegrationMethod) {
for(int i = 0; i < List_Nbr(Problem_S.IntegrationMethod); i++)		for(int i = 0; i < List_Nbr(Problem_S.IntegrationMethod); i++)
Free_IntegrationMethod((IntegrationMethod*)List_Pointer(Problem_S.Integrat		Free_IntegrationMethod(
ionMethod, i));		(IntegrationMethod *)List_Pointer(Problem_S.IntegrationMethod, i));
List_Delete(Problem_S.IntegrationMethod);		List_Delete(Problem_S.IntegrationMethod);
}		}
if(Problem_S.Resolution){		if(Problem_S.Resolution) {
for(int i = 0; i < List_Nbr(Problem_S.Resolution); i++)		for(int i = 0; i < List_Nbr(Problem_S.Resolution); i++)
Free_Resolution((Resolution*)List_Pointer(Problem_S.Resolution, i));		Free_Resolution((Resolution *)List_Pointer(Problem_S.Resolution, i));
List_Delete(Problem_S.Resolution);		List_Delete(Problem_S.Resolution);
}		}
if(Problem_S.PostProcessing){		if(Problem_S.PostProcessing) {
for(int i = 0; i < List_Nbr(Problem_S.PostProcessing); i++)		for(int i = 0; i < List_Nbr(Problem_S.PostProcessing); i++)
Free_PostProcessing((PostProcessing*)List_Pointer(Problem_S.PostProcessing		Free_PostProcessing(
, i));		(PostProcessing *)List_Pointer(Problem_S.PostProcessing, i));
List_Delete(Problem_S.PostProcessing);		List_Delete(Problem_S.PostProcessing);
}		}
if(Problem_S.PostOperation){		if(Problem_S.PostOperation) {
for(int i = 0; i < List_Nbr(Problem_S.PostOperation); i++)		for(int i = 0; i < List_Nbr(Problem_S.PostOperation); i++)
Free_PostOperation((PostOperation*)List_Pointer(Problem_S.PostOperation, i		Free_PostOperation(
));		(PostOperation *)List_Pointer(Problem_S.PostOperation, i));
List_Delete(Problem_S.PostOperation);		List_Delete(Problem_S.PostOperation);
}		}
Init_ProblemStructure();		Init_ProblemStructure();
}		}
std::string Fix_RelativePath(const char *name, const char *reference)		std::string Fix_RelativePath(const char *name, const char *reference)
{		{
if(!name || !strlen(name)) return "";		if(!name || !strlen(name)) return "";
std::string in(name);		std::string in(name);
if(in[0] == '/' || in[0] == '\\' ||		if(in[0] == '/' || in[0] == '\\' ||
(in.size() > 3 && in[1] == ':' && (in[2] == '/' || in[2] == '\\'))){		(in.size() > 3 && in[1] == ':' && (in[2] == '/' || in[2] == '\\'))) {
// do nothing: 'in' is an absolute path		// do nothing: 'in' is an absolute path
return in;		return in;
}		}
else{		else {
char AbsPath[2048];		char AbsPath[2048];
strcpy(AbsPath, reference ? reference : getdp_yyname.c_str());		strcpy(AbsPath, reference ? reference : getdp_yyname.c_str());
int i = strlen(AbsPath) - 1;		int i = strlen(AbsPath) - 1;
while(i >= 0 && AbsPath[i] != '/' && AbsPath[i] != '\\') i--;		while(i >= 0 && AbsPath[i] != '/' && AbsPath[i] != '\\') i--;
AbsPath[i+1] = '\0';		AbsPath[i + 1] = '\0';
return std::string(AbsPath) + in;		return std::string(AbsPath) + in;
}		}
}		}
#if !defined(HAVE_NX)		#if !defined(HAVE_NX)
void Read_ProblemPreamble()		void Read_ProblemPreamble()
{		{
// no-op ; could be used to fill getdp_yystring in order to parse some		// no-op ; could be used to fill getdp_yystring in order to parse some
// definitions before the actuel .pro file processing starts.		// definitions before the actuel .pro file processing starts.
}		}
#endif		#endif
static std::vector<FILE*> openFiles;		static std::vector<FILE *> openFiles;
void Read_ProblemStructure(const char *name)		void Read_ProblemStructure(const char *name)
{		{
int Last_yylinenum = getdp_yylinenum;		int Last_yylinenum = getdp_yylinenum;
std::string Last_yyname = getdp_yyname;		std::string Last_yyname = getdp_yyname;
int Last_ErrorLevel = getdp_yyerrorlevel;		int Last_ErrorLevel = getdp_yyerrorlevel;
int Last_yyincludenum = getdp_yyincludenum;		int Last_yyincludenum = getdp_yyincludenum;
char AbsPath[4096];		char AbsPath[4096];
int i;		int i;
bool absolute = false;		bool absolute = false;
if((strlen(name) > 0 && (name[0] == '/' || name[0] == '\\')) ||		if((strlen(name) > 0 && (name[0] == '/' || name[0] == '\\')) ||
(strlen(name) > 3 && name[1] == ':' && (name[2] == '\\' || name[2] == '/'))		(strlen(name) > 3 && name[1] == ':' &&
){		(name[2] == '\\' || name[2] == '/'))) {
// name is an absolute path		// name is an absolute path
absolute = true;		absolute = true;
strcpy(AbsPath, name);		strcpy(AbsPath, name);
}		}
else{		else {
strcpy(AbsPath, getdp_yyname.c_str());		strcpy(AbsPath, getdp_yyname.c_str());
i = getdp_yyname.size() - 1;		i = getdp_yyname.size() - 1;
while(i >= 0 && getdp_yyname[i] != '/' && getdp_yyname[i] != '\\') i--;		while(i >= 0 && getdp_yyname[i] != '/' && getdp_yyname[i] != '\\') i--;
AbsPath[i+1] = '\0';		AbsPath[i + 1] = '\0';
strcat(AbsPath, name);		strcat(AbsPath, name);
}		}
Message::Info("Loading problem definition '%s'", AbsPath);		Message::Info("Loading problem definition '%s'", AbsPath);
Message::AddOnelabStringChoice(Message::GetOnelabClientName() + "/{Input files		Message::AddOnelabStringChoice(Message::GetOnelabClientName() +
",		"/{Input files",
"file", AbsPath, true, true);		"file", AbsPath, true, true);
// opening the file in text mode messes up the loops (they use		// opening the file in text mode messes up the loops (they use
// fsetpos/fgetpos) on Windows without Cygwin; not sure why, but		// fsetpos/fgetpos) on Windows without Cygwin; not sure why, but
// opening the file in binary mode fixes the problem		// opening the file in binary mode fixes the problem
if(!(getdp_yyin = FOpen(AbsPath, "rb"))){		if(!(getdp_yyin = FOpen(AbsPath, "rb"))) {
if(getdp_yyincludenum > 0 && !absolute){		if(getdp_yyincludenum > 0 && !absolute) {
// try to find included files in a standard directory		// try to find included files in a standard directory
Message::Info("File `%s' not found, looking in $GETDP_TEMPLATES", AbsPath)		Message::Info("File `%s' not found, looking in $GETDP_TEMPLATES",
;		AbsPath);
const char* template_dir = getenv("GETDP_TEMPLATES");		const char *template_dir = getenv("GETDP_TEMPLATES");
if(template_dir){		if(template_dir) {
strcpy(AbsPath, template_dir);		strcpy(AbsPath, template_dir);
strcat(AbsPath, "/");		strcat(AbsPath, "/");
strcat(AbsPath, name);		strcat(AbsPath, name);
printf("trying to open %s\n", AbsPath);		printf("trying to open %s\n", AbsPath);
if(!(getdp_yyin = FOpen(AbsPath, "rb"))){		if(!(getdp_yyin = FOpen(AbsPath, "rb"))) {
Message::Error("Unable to open file '%s'", AbsPath);		Message::Error("Unable to open file '%s'", AbsPath);
return;		return;
}		}
}		}
else{		else {
Message::Error("No template directory defined");		Message::Error("No template directory defined");
return;		return;
}		}
}		}
else{		else {
Message::Error("Unable to open file '%s'", AbsPath);		Message::Error("Unable to open file '%s'", AbsPath);
return;		return;
}		}
}		}
getdp_yyerrorlevel = 0; getdp_yylinenum = 1; getdp_yyincludenum = 0;		getdp_yyerrorlevel = 0;
		getdp_yylinenum = 1;
		getdp_yyincludenum = 0;
getdp_yyname = std::string(AbsPath);		getdp_yyname = std::string(AbsPath);
getdp_yyrestart(getdp_yyin); getdp_yyparse();		getdp_yyrestart(getdp_yyin);
		getdp_yyparse();
// don't close the file here: we'll need it if there is a Macro in it:		// don't close the file here: we'll need it if there is a Macro in it:
//fclose(getdp_yyin);		// fclose(getdp_yyin);
openFiles.push_back(getdp_yyin);		openFiles.push_back(getdp_yyin);
if(getdp_yyerrorlevel) return;		if(getdp_yyerrorlevel) return;
while(getdp_yyincludenum > 0){		while(getdp_yyincludenum > 0) {
Read_ProblemStructure(getdp_yyincludename);		Read_ProblemStructure(getdp_yyincludename);
getdp_yyin = FOpen(getdp_yyname.c_str(), "rb"); // same comment as above		getdp_yyin = FOpen(getdp_yyname.c_str(), "rb"); // same comment as above
getdp_yyrestart(getdp_yyin);		getdp_yyrestart(getdp_yyin);
for(i = 0; i < getdp_yylinenum; i++){		for(i = 0; i < getdp_yylinenum; i++) {
if(!fgets(AbsPath, sizeof(AbsPath), getdp_yyin))		if(!fgets(AbsPath, sizeof(AbsPath), getdp_yyin))
Message::Warning("Could not read line %d", getdp_yylinenum);		Message::Warning("Could not read line %d", getdp_yylinenum);
}		}
getdp_yylinenum++;		getdp_yylinenum++;
getdp_yyparse();		getdp_yyparse();
// don't close the file here: we'll need it if there is a Macro in it:		// don't close the file here: we'll need it if there is a Macro in it:
//fclose(getdp_yyin);		// fclose(getdp_yyin);
openFiles.push_back(getdp_yyin);		openFiles.push_back(getdp_yyin);
if(getdp_yyerrorlevel) return;		if(getdp_yyerrorlevel) return;
}		}
level_include--;		level_include--;
getdp_yylinenum = Last_yylinenum;		getdp_yylinenum = Last_yylinenum;
getdp_yyname = Last_yyname;		getdp_yyname = Last_yyname;
getdp_yyerrorlevel = Last_ErrorLevel;		getdp_yyerrorlevel = Last_ErrorLevel;
getdp_yyincludenum = Last_yyincludenum;		getdp_yyincludenum = Last_yyincludenum;
}		}
void Finalize_ProblemStructure()		void Finalize_ProblemStructure()
{		{
for(unsigned int i = 0; i < openFiles.size(); i++)		for(unsigned int i = 0; i < openFiles.size(); i++) fclose(openFiles[i]);
fclose(openFiles[i]);
openFiles.clear();		openFiles.clear();
MacroManager::Instance()->clear();		MacroManager::Instance()->clear();
}		}
char *Get_ExpressionName(int Index)		char *Get_ExpressionName(int Index)
{		{
return(((struct Expression *)List_Pointer(Problem_S.Expression, Index))->Name)		return (
;		((struct Expression *)List_Pointer(Problem_S.Expression, Index))->Name);
}		}
void Print_WholeQuantity(List_T *WholeQuantity, List_T *DQ_L)		void Print_WholeQuantity(List_T *WholeQuantity, List_T *DQ_L)
{		{
int j, k;		int j, k;
struct WholeQuantity *WQ;		struct WholeQuantity *WQ;
WQ = (struct WholeQuantity*)List_Pointer(WholeQuantity, 0);		WQ = (struct WholeQuantity *)List_Pointer(WholeQuantity, 0);
for (k = 0; k < List_Nbr(WholeQuantity); k++) {
switch ((WQ+k)->Type) {
case WQ_OPERATORANDQUANTITY :
Message::Check(" {%s %s}",
Get_StringForDefine
(Operator_Type, (WQ+k)->Case.OperatorAndQuantity.TypeOperat
or),
((struct DefineQuantity *)
List_Pointer(DQ_L, (WQ+k)->Case.OperatorAndQuantity.Index)
)
->Name);
break;
case WQ_OPERATORANDQUANTITYEVAL :		for(k = 0; k < List_Nbr(WholeQuantity); k++) {
Message::Check(" {%s %s} ExplicitEvaluation",		switch((WQ + k)->Type) {
Get_StringForDefine		case WQ_OPERATORANDQUANTITY:
(Operator_Type, (WQ+k)->Case.OperatorAndQuantity.TypeOperat		Message::Check(
or),		" {%s %s}",
((struct DefineQuantity *)		Get_StringForDefine(Operator_Type,
List_Pointer(DQ_L, (WQ+k)->Case.OperatorAndQuantity.Index)		(WQ + k)->Case.OperatorAndQuantity.TypeOperator),
)		((struct DefineQuantity *)List_Pointer(
->Name);		DQ_L, (WQ + k)->Case.OperatorAndQuantity.Index))
		->Name);
		break;
		case WQ_OPERATORANDQUANTITYEVAL:
		Message::Check(
		" {%s %s} ExplicitEvaluation",
		Get_StringForDefine(Operator_Type,
		(WQ + k)->Case.OperatorAndQuantity.TypeOperator),
		((struct DefineQuantity *)List_Pointer(
		DQ_L, (WQ + k)->Case.OperatorAndQuantity.Index))
		->Name);
		break;
		case WQ_BINARYOPERATOR:
		switch((WQ + k)->Case.Operator.TypeOperator) {
		case OP_PLUS: Message::Check(" +"); break;
		case OP_MINUS: Message::Check(" -"); break;
		case OP_TIME: Message::Check(" *"); break;
		case OP_DIVIDE: Message::Check(" /"); break;
		case OP_MODULO: Message::Check(" %%"); break;
		case OP_POWER: Message::Check(" ^"); break;
		case OP_CROSSPRODUCT: Message::Check(" x"); break;
		case OP_LESS: Message::Check(" <"); break;
		case OP_GREATER: Message::Check(" >"); break;
		case OP_LESSOREQUAL: Message::Check(" <="); break;
		case OP_GREATEROREQUAL: Message::Check(" >="); break;
		case OP_EQUAL: Message::Check(" =="); break;
		case OP_NOTEQUAL: Message::Check(" !="); break;
		case OP_APPROXEQUAL: Message::Check(" ~="); break;
		case OP_AND: Message::Check(" &&"); break;
		case OP_OR: Message::Check(" ||"); break;
		default: Message::Check(" UnknownBinaryOperator[]"); break;
		}
break;		break;
case WQ_BINARYOPERATOR :		case WQ_UNARYOPERATOR:
switch ((WQ+k)->Case.Operator.TypeOperator) {		switch((WQ + k)->Case.Operator.TypeOperator) {
case OP_PLUS : Message::Check(" +"); break;		case OP_NEG: Message::Check(" -(unary)"); break;
case OP_MINUS : Message::Check(" -"); break;		case OP_NOT: Message::Check(" !"); break;
case OP_TIME : Message::Check(" *"); break;		default: Message::Check(" UnknownUnaryOperator[]"); break;
case OP_DIVIDE : Message::Check(" /"); break;
case OP_MODULO : Message::Check(" %%"); break;
case OP_POWER : Message::Check(" ^"); break;
case OP_CROSSPRODUCT : Message::Check(" x"); break;
case OP_LESS : Message::Check(" <"); break;
case OP_GREATER : Message::Check(" >"); break;
case OP_LESSOREQUAL : Message::Check(" <="); break;
case OP_GREATEROREQUAL : Message::Check(" >="); break;
case OP_EQUAL : Message::Check(" =="); break;
case OP_NOTEQUAL : Message::Check(" !="); break;
case OP_APPROXEQUAL : Message::Check(" ~="); break;
case OP_AND : Message::Check(" &&"); break;
case OP_OR : Message::Check(" ||"); break;
default : Message::Check(" UnknownBinaryOperator[]"); brea
k;
}		}
break;		break;
case WQ_UNARYOPERATOR :		case WQ_EXPRESSION:
switch ((WQ+k)->Case.Operator.TypeOperator) {		Message::Check(" %s[]",
case OP_NEG : Message::Check(" -(unary)"); break;		((struct Expression *)List_Pointer(
case OP_NOT : Message::Check(" !"); break;		Problem_S.Expression, (WQ + k)->Case.Expression.Index))
default : Message::Check(" UnknownUnaryOperator[]"); break		->Name);
;
}
break;		break;
case WQ_EXPRESSION :		case WQ_BUILTINFUNCTION:
Message::Check(" %s[]", ((struct Expression *)		case WQ_EXTERNBUILTINFUNCTION:
List_Pointer(Problem_S.Expression,		Message::Check(" %s", Get_StringForFunction2Nbr(
(WQ+k)->Case.Expression.Index))->Nam		F_Function, (WQ + k)->Case.Function.Fct));
e);		if((WQ + k)->Type == WQ_EXTERNBUILTINFUNCTION) Message::Check("[.]");
break;		if((WQ + k)->Type == WQ_BUILTINFUNCTION) Message::Check("[]");
		if((WQ + k)->Case.Function.NbrParameters) {
case WQ_BUILTINFUNCTION :		Message::Check("{");
case WQ_EXTERNBUILTINFUNCTION :		for(j = 0; j < (WQ + k)->Case.Function.NbrParameters; j++) {
Message::Check(" %s", Get_StringForFunction2Nbr(F_Function,		if(j) Message::Check(",");
(WQ+k)->Case.Function.Fct)		Message::Check(" %.10g", (WQ + k)->Case.Function.Para[j]);
);		}
if ((WQ+k)->Type == WQ_EXTERNBUILTINFUNCTION) Message::Check("[.]");		Message::Check(" }");
if ((WQ+k)->Type == WQ_BUILTINFUNCTION) Message::Check("[]");
if ((WQ+k)->Case.Function.NbrParameters) {
Message::Check("{");
for (j = 0; j < (WQ+k)->Case.Function.NbrParameters; j++) {
if (j) Message::Check(",");
Message::Check(" %.10g", (WQ+k)->Case.Function.Para[j]);
} Message::Check(" }");
}		}
break;		break;
case WQ_CONSTANT :		case WQ_CONSTANT: Message::Check(" %.8g", (WQ + k)->Case.Constant); break;
Message::Check(" %.8g", (WQ+k)->Case.Constant);
break;
case WQ_MHTRANSFORM :		case WQ_MHTRANSFORM:
Message::Check(" MHTransform[ ");		Message::Check(" MHTransform[ ");
Message::Check("%s", Get_ExpressionName((WQ+k)->Case.MHTransform.Index));		Message::Check("%s",
		Get_ExpressionName((WQ + k)->Case.MHTransform.Index));
Message::Check("[");		Message::Check("[");
for(int i = 0; i < List_Nbr((WQ+k)->Case.MHTransform.WholeQuantity_L); i++		for(int i = 0; i < List_Nbr((WQ + k)->Case.MHTransform.WholeQuantity_L);
){		i++) {
List_T *wq; List_Read((WQ+k)->Case.MHTransform.WholeQuantity_L, i, &wq);		List_T *wq;
		List_Read((WQ + k)->Case.MHTransform.WholeQuantity_L, i, &wq);
Print_WholeQuantity(wq, DQ_L);		Print_WholeQuantity(wq, DQ_L);
}		}
Message::Check(" ] ]{ %d }", (WQ+k)->Case.MHTransform.NbrPoints);		Message::Check(" ] ]{ %d }", (WQ + k)->Case.MHTransform.NbrPoints);
break;		break;
case WQ_MHBILINEAR :		case WQ_MHBILINEAR:
Message::Check(" MHBilinear[ ");		Message::Check(" MHBilinear[ ");
Message::Check("%s",		Message::Check("%s", Get_ExpressionName((WQ + k)->Case.MHBilinear.Index));
Get_ExpressionName((WQ+k)->Case.MHBilinear.Index));		Message::Check("]{ %d, %d}", (WQ + k)->Case.MHBilinear.NbrPoints,
Message::Check("]{ %d, %d}", (WQ+k)->Case.MHBilinear.NbrPoints, (WQ+k)->Ca		(WQ + k)->Case.MHBilinear.FreqOffSet);
se.MHBilinear.FreqOffSet);
break;		break;
case WQ_TIMEDERIVATIVE :		case WQ_TIMEDERIVATIVE:
Message::Check(" Dt[");		Message::Check(" Dt[");
Print_WholeQuantity((WQ+k)->Case.TimeDerivative.WholeQuantity, DQ_L);		Print_WholeQuantity((WQ + k)->Case.TimeDerivative.WholeQuantity, DQ_L);
Message::Check(" ]");		Message::Check(" ]");
break;		break;
case WQ_TRACE :		case WQ_TRACE:
Message::Check(" Trace[");		Message::Check(" Trace[");
Print_WholeQuantity((WQ+k)->Case.Trace.WholeQuantity, DQ_L);		Print_WholeQuantity((WQ + k)->Case.Trace.WholeQuantity, DQ_L);
Message::Check(" , %s ]", ((struct Group*)		Message::Check(
List_Pointer(Problem_S.Group,		" , %s ]", ((struct Group *)List_Pointer(Problem_S.Group,
(WQ+k)->Case.Trace.InIndex))->Name		(WQ + k)->Case.Trace.InIndex))
);		->Name);
break;		break;
case WQ_CAST :		case WQ_CAST:
if(!(WQ+k)->Case.Cast.NbrHar)		if(!(WQ + k)->Case.Cast.NbrHar)
Message::Check(" <%s>[",		Message::Check(" <%s>[",
((struct FunctionSpace *)		((struct FunctionSpace *)List_Pointer(
List_Pointer(Problem_S.FunctionSpace,		Problem_S.FunctionSpace,
(WQ+k)->Case.Cast.FunctionSpaceIndexForType		(WQ + k)->Case.Cast.FunctionSpaceIndexForType))
))->Name);		->Name);
else		else
Message::Check(" <Real>[");		Message::Check(" <Real>[");
Print_WholeQuantity((WQ+k)->Case.Cast.WholeQuantity, DQ_L);		Print_WholeQuantity((WQ + k)->Case.Cast.WholeQuantity, DQ_L);
Message::Check(" ]");		Message::Check(" ]");
break;		break;
case WQ_CURRENTVALUE :		case WQ_CURRENTVALUE:
Message::Check(" $%s",		Message::Check(
Get_StringForPointer(Current_Value,		" $%s", Get_StringForPointer(
(void *)((WQ+k)->Case.CurrentValue.Val		Current_Value, (void *)((WQ + k)->Case.CurrentValue.Value)));
ue)));
break;		break;
case WQ_ARGUMENT :		case WQ_ARGUMENT:
Message::Check(" $%d", (WQ+k)->Case.Argument.Index);		Message::Check(" $%d", (WQ + k)->Case.Argument.Index);
break;		break;
case WQ_TEST :		case WQ_TEST:
Message::Check(" ?");		Message::Check(" ?");
Print_WholeQuantity((WQ+k)->Case.Test.WholeQuantity_True , DQ_L);		Print_WholeQuantity((WQ + k)->Case.Test.WholeQuantity_True, DQ_L);
Message::Check(" :");		Message::Check(" :");
Print_WholeQuantity((WQ+k)->Case.Test.WholeQuantity_False, DQ_L);		Print_WholeQuantity((WQ + k)->Case.Test.WholeQuantity_False, DQ_L);
break;		break;
case WQ_SAVEVALUE :		case WQ_SAVEVALUE:
Message::Check(" ->#%d", (WQ+k)->Case.SaveValue.Index + 1);		Message::Check(" ->#%d", (WQ + k)->Case.SaveValue.Index + 1);
break;		break;
case WQ_VALUESAVED :		case WQ_VALUESAVED:
Message::Check(" #%d", (WQ+k)->Case.ValueSaved.Index + 1);		Message::Check(" #%d", (WQ + k)->Case.ValueSaved.Index + 1);
break;		break;
case WQ_SAVENAMEDVALUE :		case WQ_SAVENAMEDVALUE:
Message::Check(" ->$%s", (WQ+k)->Case.NamedValue.Name);		Message::Check(" ->$%s", (WQ + k)->Case.NamedValue.Name);
break ;		break;
case WQ_NAMEDVALUESAVED :
Message::Check(" $%s", (WQ+k)->Case.NamedValue.Name);
break ;
case WQ_SHOWVALUE :		case WQ_NAMEDVALUESAVED:
Message::Check(" ->show with prefix #%d", (WQ+k)->Case.ShowValue.Index + 1		Message::Check(" $%s", (WQ + k)->Case.NamedValue.Name);
);
break;		break;
default :		case WQ_SHOWVALUE:
Message::Check(" ???");		Message::Check(" ->show with prefix #%d",
		(WQ + k)->Case.ShowValue.Index + 1);
break;		break;
		default: Message::Check(" ???"); break;
}		}
}		}
}		}
void Print_Group()		void Print_Group()
{		{
int i, Nbr, j;		int i, Nbr, j;
struct Group *GR;		struct Group *GR;
Nbr = List_Nbr(Problem_S.Group);		Nbr = List_Nbr(Problem_S.Group);
Message::Check("Group { /* nbr = %d */\n", Nbr);		Message::Check("Group { /* nbr = %d */\n", Nbr);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbr; i++) {		for(i = 0; i < Nbr; i++) {
		GR = (struct Group *)List_Pointer(Problem_S.Group, i);
GR = (struct Group*)List_Pointer(Problem_S.Group, i);		Message::Check(
		" %s = %s [", GR->Name,
		Get_StringForDefine(FunctionForGroup_Type, GR->FunctionType));
Message::Check(" %s = %s [", GR->Name,		if(GR->InitialList != NULL) {
Get_StringForDefine(FunctionForGroup_Type, GR->FunctionType))
;
if (GR->InitialList != NULL) {
Message::Check(" {");		Message::Check(" {");
for (j = 0; j < List_Nbr(GR->InitialList); j++)		for(j = 0; j < List_Nbr(GR->InitialList); j++)
Message::Check(" %d", *((int *)List_Pointer(GR->InitialList, j)) );		Message::Check(" %d", *((int *)List_Pointer(GR->InitialList, j)));
Message::Check(" }");		Message::Check(" }");
}		}
else Message::Check(" All");		else
		Message::Check(" All");
if (GR->InitialSuppList != NULL) {		if(GR->InitialSuppList != NULL) {
if (GR->SuppListType != SUPPLIST_INSUPPORT) {		if(GR->SuppListType != SUPPLIST_INSUPPORT) {
Message::Check(", %s {",		Message::Check(", %s {", Get_StringForDefine(FunctionForGroup_SuppList,
Get_StringForDefine(FunctionForGroup_SuppList, GR->SuppLi		GR->SuppListType));
stType));		for(j = 0; j < List_Nbr(GR->InitialSuppList); j++)
for (j = 0; j < List_Nbr(GR->InitialSuppList); j++)		Message::Check(" %d", *((int *)List_Pointer(GR->InitialSuppList, j)));
Message::Check(" %d", *((int *)List_Pointer(GR->InitialSuppList, j)) );		Message::Check(" }");
Message::Check(" }");
}		}
else {		else {
Message::Check(", %s",		Message::Check(", %s", Get_StringForDefine(FunctionForGroup_SuppList,
Get_StringForDefine(FunctionForGroup_SuppList, GR->SuppLi		GR->SuppListType));
stType));		Message::Check(
Message::Check(" %s",		" %s",
((struct Group *)		((struct Group *)List_Pointer(
List_Pointer(Problem_S.Group,		Problem_S.Group, *((int *)List_Pointer(GR->InitialSuppList, 0))))
*((int *)List_Pointer(GR->InitialSuppList,		->Name);
0))))
->Name);
}		}
}		}
if (GR->InitialSuppList2 != NULL) {		if(GR->InitialSuppList2 != NULL) {
if (GR->SuppListType2 != SUPPLIST_INSUPPORT) {		if(GR->SuppListType2 != SUPPLIST_INSUPPORT) {
Message::Check(", %s {",		Message::Check(", %s {", Get_StringForDefine(FunctionForGroup_SuppList,
Get_StringForDefine(FunctionForGroup_SuppList, GR->SuppLi		GR->SuppListType2));
stType2));		for(j = 0; j < List_Nbr(GR->InitialSuppList2); j++)
for (j = 0; j < List_Nbr(GR->InitialSuppList2); j++)		Message::Check(" %d",
Message::Check(" %d", *((int *)List_Pointer(GR->InitialSuppList2, j)) )		*((int *)List_Pointer(GR->InitialSuppList2, j)));
;		Message::Check(" }");
Message::Check(" }");
}		}
else {		else {
Message::Check(", %s",		Message::Check(", %s", Get_StringForDefine(FunctionForGroup_SuppList,
Get_StringForDefine(FunctionForGroup_SuppList, GR->SuppLi		GR->SuppListType2));
stType2));		Message::Check(
Message::Check(" %s",		" %s",
((struct Group *)		((struct Group *)List_Pointer(
List_Pointer(Problem_S.Group,		Problem_S.Group, *((int *)List_Pointer(GR->InitialSuppList2, 0))))
*((int *)List_Pointer(GR->InitialSuppList2,		->Name);
0))))
->Name);
}		}
}		}
Message::Check(" ]");		Message::Check(" ]");
if (GR->Type == MOVINGBAND2D) {		if(GR->Type == MOVINGBAND2D) {
Message::Check(" = MovingBand2D [ {");		Message::Check(" = MovingBand2D [ {");
for (j = 0; j < List_Nbr(GR->MovingBand2D->InitialList1); j++)		for(j = 0; j < List_Nbr(GR->MovingBand2D->InitialList1); j++)
Message::Check(" %d", *((int *)List_Pointer(GR->MovingBand2D->InitialList		Message::Check(
1, j)) );		" %d", *((int *)List_Pointer(GR->MovingBand2D->InitialList1, j)));
Message::Check(" } , {");		Message::Check(" } , {");
for (j = 0; j < List_Nbr(GR->MovingBand2D->InitialList2); j++)		for(j = 0; j < List_Nbr(GR->MovingBand2D->InitialList2); j++)
Message::Check(" %d", *((int *)List_Pointer(GR->MovingBand2D->InitialList		Message::Check(
2, j)) );		" %d", *((int *)List_Pointer(GR->MovingBand2D->InitialList2, j)));
Message::Check(" } ]");		Message::Check(" } ]");
}		}
Message::Check("; /* Num %d */\n", i);		Message::Check("; /* Num %d */\n", i);
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
void Print_Expression()		void Print_Expression()
{		{
int i, Nbr, j;		int i, Nbr, j;
struct Expression *EX;		struct Expression *EX;
struct ExpressionPerRegion *EXPR;		struct ExpressionPerRegion *EXPR;
Nbr = List_Nbr(Problem_S.Expression);		Nbr = List_Nbr(Problem_S.Expression);
Message::Check("Function { /* nbr = %d */\n", Nbr);		Message::Check("Function { /* nbr = %d */\n", Nbr);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbr; i++) {		for(i = 0; i < Nbr; i++) {
EX = (struct Expression*)List_Pointer(Problem_S.Expression, i);		EX = (struct Expression *)List_Pointer(Problem_S.Expression, i);
switch (EX->Type) {		switch(EX->Type) {
case CONSTANT :		case CONSTANT:
Message::Check(" %s[] = %.10g;\n", EX->Name, EX->Case.Constant);		Message::Check(" %s[] = %.10g;\n", EX->Name, EX->Case.Constant);
break;		break;
case WHOLEQUANTITY :		case WHOLEQUANTITY:
Message::Check(" %s[] = ", EX->Name);		Message::Check(" %s[] = ", EX->Name);
Print_WholeQuantity(EX->Case.WholeQuantity, NULL);		Print_WholeQuantity(EX->Case.WholeQuantity, NULL);
Message::Check(";\n");		Message::Check(";\n");
break;		break;
case PIECEWISEFUNCTION :		case PIECEWISEFUNCTION:
for (j = 0;		for(j = 0; j < List_Nbr(EX->Case.PieceWiseFunction.ExpressionPerRegion);
j < List_Nbr(EX->Case.PieceWiseFunction.ExpressionPerRegion); j++) {		j++) {
EXPR = (struct ExpressionPerRegion*)		EXPR = (struct ExpressionPerRegion *)List_Pointer(
List_Pointer(EX->Case.PieceWiseFunction.ExpressionPerRegion, j);		EX->Case.PieceWiseFunction.ExpressionPerRegion, j);
Message::Check(" %s[%d] = Exp[%s];\n",		Message::Check(" %s[%d] = Exp[%s];\n", EX->Name, EXPR->RegionIndex,
EX->Name, EXPR->RegionIndex,
Get_ExpressionName(EXPR->ExpressionIndex));		Get_ExpressionName(EXPR->ExpressionIndex));
}		}
if (EX->Case.PieceWiseFunction.ExpressionIndex_Default >= 0) {		if(EX->Case.PieceWiseFunction.ExpressionIndex_Default >= 0) {
Message::		Message::Check(" %s[All] = Exp[%s];\n", EX->Name,
Check(" %s[All] = Exp[%s];\n",		Get_ExpressionName(
EX->Name,		EX->Case.PieceWiseFunction.ExpressionIndex_Default));
Get_ExpressionName(EX->Case.PieceWiseFunction.ExpressionIndex_De		}
fault));		if(!List_Nbr(EX->Case.PieceWiseFunction.ExpressionPerRegion) &&
}		EX->Case.PieceWiseFunction.ExpressionIndex_Default < 0)
if (!List_Nbr(EX->Case.PieceWiseFunction.ExpressionPerRegion) &&		Message::Check(" DefineFunction[ %s ];\n", EX->Name);
EX->Case.PieceWiseFunction.ExpressionIndex_Default < 0)
Message::Check(" DefineFunction[ %s ];\n", EX->Name);
break;		break;
case PIECEWISEFUNCTION2 :		case PIECEWISEFUNCTION2:
for (j = 0;		for(j = 0; j < List_Nbr(EX->Case.PieceWiseFunction2.ExpressionPerRegion);
j < List_Nbr(EX->Case.PieceWiseFunction2.ExpressionPerRegion); j++) {		j++) {
struct ExpressionPerRegion2 *EXPR;		struct ExpressionPerRegion2 *EXPR;
EXPR = (struct ExpressionPerRegion2*)		EXPR = (struct ExpressionPerRegion2 *)List_Pointer(
List_Pointer(EX->Case.PieceWiseFunction2.ExpressionPerRegion, j);		EX->Case.PieceWiseFunction2.ExpressionPerRegion, j);
Message::Check(" %s[%d,%d] = Exp[%s];\n",		Message::Check(" %s[%d,%d] = Exp[%s];\n", EX->Name,
EX->Name, EXPR->RegionIndex[0], EXPR->RegionIndex[1],		EXPR->RegionIndex[0], EXPR->RegionIndex[1],
Get_ExpressionName(EXPR->ExpressionIndex));		Get_ExpressionName(EXPR->ExpressionIndex));
}		}
if (EX->Case.PieceWiseFunction2.ExpressionIndex_Default >= 0) {		if(EX->Case.PieceWiseFunction2.ExpressionIndex_Default >= 0) {
Message::		Message::Check(" %s[All,All] = Exp[%s];\n", EX->Name,
Check(" %s[All,All] = Exp[%s];\n",		Get_ExpressionName(
EX->Name,		EX->Case.PieceWiseFunction.ExpressionIndex_Default));
Get_ExpressionName(EX->Case.PieceWiseFunction.ExpressionIndex_De		}
fault));		if(!List_Nbr(EX->Case.PieceWiseFunction2.ExpressionPerRegion) &&
}		EX->Case.PieceWiseFunction2.ExpressionIndex_Default < 0)
if (!List_Nbr(EX->Case.PieceWiseFunction2.ExpressionPerRegion) &&		Message::Check(" DefineFunction[ %s ];\n", EX->Name);
EX->Case.PieceWiseFunction2.ExpressionIndex_Default < 0)
Message::Check(" DefineFunction[ %s ];\n", EX->Name);
break;		break;
case UNDEFINED_EXP :		case UNDEFINED_EXP:
Message::Check(" DefineFunction[ %s ];\n", EX->Name);		Message::Check(" DefineFunction[ %s ];\n", EX->Name);
break;		break;
default :		default: Message::Check("???;\n"); break;
Message::Check("???;\n");
break;
}		}
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
void Print_Network(struct MultiConstraintPerRegion *MCPR_P)		void Print_Network(struct MultiConstraintPerRegion *MCPR_P)
{		{
int i, j;		int i, j;
struct ConstraintActive *CA;		struct ConstraintActive *CA;
CA = MCPR_P->Active;		CA = MCPR_P->Active;
Message::Check("NbrNode = %d, NbrBranch = %d\n",		Message::Check("NbrNode = %d, NbrBranch = %d\n", CA->Case.Network.NbrNode,
CA->Case.Network.NbrNode, CA->Case.Network.NbrBranch);		CA->Case.Network.NbrBranch);
Message::Check("\n");		Message::Check("\n");
Message::Check("MatNode (NbrNode x NbrBranch):\n");		Message::Check("MatNode (NbrNode x NbrBranch):\n");
for (i = 0; i < CA->Case.Network.NbrNode; i++) {		for(i = 0; i < CA->Case.Network.NbrNode; i++) {
for (j = 0; j < CA->Case.Network.NbrBranch; j++) {		for(j = 0; j < CA->Case.Network.NbrBranch; j++) {
Message::Check("%2d ", CA->Case.Network.MatNode[i][j]);		Message::Check("%2d ", CA->Case.Network.MatNode[i][j]);
}		}
Message::Check("\n");		Message::Check("\n");
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("MatLoop (NbrLoop x NbrBranch):\n");		Message::Check("MatLoop (NbrLoop x NbrBranch):\n");
for (i = 0; i < CA->Case.Network.NbrLoop; i++) {		for(i = 0; i < CA->Case.Network.NbrLoop; i++) {
for (j = 0; j < CA->Case.Network.NbrBranch; j++) {		for(j = 0; j < CA->Case.Network.NbrBranch; j++) {
Message::Check("%2d ", CA->Case.Network.MatLoop[i][j]);		Message::Check("%2d ", CA->Case.Network.MatLoop[i][j]);
}		}
Message::Check("\n");		Message::Check("\n");
}		}
}		}
void Print_Constraint()		void Print_Constraint()
{		{
int i, Nbr, j, Nbrj, k, Nbrk, index, index2;		int i, Nbr, j, Nbrj, k, Nbrk, index, index2;
struct Constraint *CO;		struct Constraint *CO;
struct ConstraintPerRegion *CPR;		struct ConstraintPerRegion *CPR;
struct MultiConstraintPerRegion MCPR_S;		struct MultiConstraintPerRegion MCPR_S;
Nbr = List_Nbr(Problem_S.Constraint);		Nbr = List_Nbr(Problem_S.Constraint);
Message::Check("Constraint { /* nbr = %d */\n", Nbr);		Message::Check("Constraint { /* nbr = %d */\n", Nbr);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" /* Num : %d */\n", i);		Message::Check(" /* Num : %d */\n", i);
CO = (struct Constraint*)List_Pointer(Problem_S.Constraint, i);		CO = (struct Constraint *)List_Pointer(Problem_S.Constraint, i);
Message::Check(" { Name %s; Type %s;\n", CO->Name,		Message::Check(" { Name %s; Type %s;\n", CO->Name,
Get_StringForDefine(Constraint_Type, CO->Type));		Get_StringForDefine(Constraint_Type, CO->Type));
if (CO->Type == NETWORK){		if(CO->Type == NETWORK) {
Nbrk = List_Nbr(CO->MultiConstraintPerRegion);		Nbrk = List_Nbr(CO->MultiConstraintPerRegion);
for (k = 0; k < Nbrk; k++) {		for(k = 0; k < Nbrk; k++) {
List_Read(CO->MultiConstraintPerRegion, k, &MCPR_S);		List_Read(CO->MultiConstraintPerRegion, k, &MCPR_S);
Message::Check(" Case %s {\n", MCPR_S.Name);		Message::Check(" Case %s {\n", MCPR_S.Name);
Nbrj = List_Nbr(MCPR_S.ConstraintPerRegion);		Nbrj = List_Nbr(MCPR_S.ConstraintPerRegion);
for (j = 0; j < Nbrj; j++) {		for(j = 0; j < Nbrj; j++) {
CPR = (struct ConstraintPerRegion*)		CPR = (struct ConstraintPerRegion *)List_Pointer(
List_Pointer(MCPR_S.ConstraintPerRegion, j);		MCPR_S.ConstraintPerRegion, j);
Message::Check(" { Region %s;",		Message::Check(
((struct Group *)		" { Region %s;",
List_Pointer(Problem_S.Group, CPR->RegionIndex))->Name		((struct Group *)List_Pointer(Problem_S.Group, CPR->RegionIndex))
);		->Name);
Message::Check(" Branch { %d, %d };",		Message::Check(" Branch { %d, %d };", CPR->Case.Network.Node1,
CPR->Case.Network.Node1, CPR->Case.Network.Node2);		CPR->Case.Network.Node2);
Message::Check(" }\n");		Message::Check(" }\n");
}		}
#if defined(HAVE_KERNEL)		#if defined(HAVE_KERNEL)
if (!MCPR_S.Active)		if(!MCPR_S.Active)
MCPR_S.Active = Generate_Network(MCPR_S.Name, MCPR_S.ConstraintPerRegio		MCPR_S.Active =
n);		Generate_Network(MCPR_S.Name, MCPR_S.ConstraintPerRegion);
#endif		#endif
Print_Network(&MCPR_S);		Print_Network(&MCPR_S);
}		}
}		}
else {		else {
Message::Check(" Case {\n");		Message::Check(" Case {\n");
Nbrj = List_Nbr(CO->ConstraintPerRegion);		Nbrj = List_Nbr(CO->ConstraintPerRegion);
for (j = 0; j < Nbrj; j++) {		for(j = 0; j < Nbrj; j++) {
CPR = (struct ConstraintPerRegion*)List_Pointer(CO->ConstraintPerRegion,		CPR = (struct ConstraintPerRegion *)List_Pointer(
j);		CO->ConstraintPerRegion, j);
Message::Check(" { Region %s;",		Message::Check(
((struct Group *)		" { Region %s;",
List_Pointer(Problem_S.Group, CPR->RegionIndex))->Name);		((struct Group *)List_Pointer(Problem_S.Group, CPR->RegionIndex))
if (CPR->SubRegionIndex >= 0)		->Name);
Message::Check(" SubRegion %s;",		if(CPR->SubRegionIndex >= 0)
((struct Group *)		Message::Check(
List_Pointer(Problem_S.Group, CPR->SubRegionIndex))->N		" SubRegion %s;",
ame);		((struct Group *)List_Pointer(Problem_S.Group, CPR->SubRegionIndex))
if (CPR->Type != CO->Type)		->Name);
Message::Check(" Type %s;", Get_StringForDefine(Constraint_Type, CPR->T		if(CPR->Type != CO->Type)
ype));		Message::Check(" Type %s;",
		Get_StringForDefine(Constraint_Type, CPR->Type));
switch (CPR->Type) {
case ASSIGN :		switch(CPR->Type) {
case INIT :		case ASSIGN:
Message::Check(" Value Exp[%s];",		case INIT:
		Message::Check(" Value Exp[%s];",
Get_ExpressionName(CPR->Case.Fixed.ExpressionIndex));		Get_ExpressionName(CPR->Case.Fixed.ExpressionIndex));
break;		break;
case ASSIGNFROMRESOLUTION :		case ASSIGNFROMRESOLUTION:
case INITFROMRESOLUTION :		case INITFROMRESOLUTION:
Message::Check(" NameOfResolution %s;", CPR->Case.Solve.ResolutionName)		Message::Check(" NameOfResolution %s;",
;		CPR->Case.Solve.ResolutionName);
break;		break;
case CST_LINK :		case CST_LINK:
case CST_LINKCPLX :		case CST_LINKCPLX:
if ( (index = CPR->Case.Link.RegionRefIndex) >= 0)		if((index = CPR->Case.Link.RegionRefIndex) >= 0)
Message::Check(" RegionRef %s;",		Message::Check(
((struct Group *)		" RegionRef %s;",
List_Pointer(Problem_S.Group, index))->Name);		((struct Group *)List_Pointer(Problem_S.Group, index))->Name);
if ( (index = CPR->Case.Link.SubRegionRefIndex) >= 0)		if((index = CPR->Case.Link.SubRegionRefIndex) >= 0)
Message::Check(" SubRegionRef %s;",		Message::Check(
((struct Group *)		" SubRegionRef %s;",
List_Pointer(Problem_S.Group, index))->Name);		((struct Group *)List_Pointer(Problem_S.Group, index))->Name);
if ( (index = CPR->Case.Link.FilterIndex) >= 0) {		if((index = CPR->Case.Link.FilterIndex) >= 0) {
if ( (index2 = CPR->Case.Link.FilterIndex2) < 0)		if((index2 = CPR->Case.Link.FilterIndex2) < 0)
Message::Check(" Filter Exp[%s];", Get_ExpressionName(index));		Message::Check(" Filter Exp[%s];", Get_ExpressionName(index));
else		else
Message::Check(" Filter [ Exp[%s], Exp[%s] ];",		Message::Check(" Filter [ Exp[%s], Exp[%s] ];",
Get_ExpressionName(index), Get_ExpressionName(index		Get_ExpressionName(index),
2));		Get_ExpressionName(index2));
}		}
if ( (index = CPR->Case.Link.FunctionIndex) >= 0) {		if((index = CPR->Case.Link.FunctionIndex) >= 0) {
if ( (index2 = CPR->Case.Link.FunctionIndex2) < 0)		if((index2 = CPR->Case.Link.FunctionIndex2) < 0)
Message::Check(" Function Exp[%s];", Get_ExpressionName(index));		Message::Check(" Function Exp[%s];", Get_ExpressionName(index));
else		else
Message::Check(" Function [ Exp[%s], Exp[%s] ];",		Message::Check(" Function [ Exp[%s], Exp[%s] ];",
Get_ExpressionName(index), Get_ExpressionName(index		Get_ExpressionName(index),
2));		Get_ExpressionName(index2));
}		}
if ( (index = CPR->Case.Link.CoefIndex) >= 0) {		if((index = CPR->Case.Link.CoefIndex) >= 0) {
if ( (index2 = CPR->Case.Link.CoefIndex2) < 0)		if((index2 = CPR->Case.Link.CoefIndex2) < 0)
Message::Check(" Coefficient Exp[%s];", Get_ExpressionName(index))		Message::Check(" Coefficient Exp[%s];",
;		Get_ExpressionName(index));
else		else
Message::Check(" Coefficient [ Exp[%s], Exp[%s] ];",		Message::Check(" Coefficient [ Exp[%s], Exp[%s] ];",
Get_ExpressionName(index), Get_ExpressionName(index		Get_ExpressionName(index),
2));		Get_ExpressionName(index2));
}		}
Message::Check(" ToleranceFactor %g;",		Message::Check(" ToleranceFactor %g;",
CPR->Case.Link.ToleranceFactor);		CPR->Case.Link.ToleranceFactor);
break;		break;
}		}
if (CPR->TimeFunctionIndex >= 0)		if(CPR->TimeFunctionIndex >= 0)
Message::Check(" TimeFunction Exp[%s];",		Message::Check(" TimeFunction Exp[%s];",
Get_ExpressionName(CPR->TimeFunctionIndex));		Get_ExpressionName(CPR->TimeFunctionIndex));
Message::Check(" }\n");		Message::Check(" }\n");
}		}
}		}
Message::Check(" }\n");		Message::Check(" }\n");
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
void Print_Jacobian()		void Print_Jacobian()
{		{
int i, Nbr, j, Nbrj, k;		int i, Nbr, j, Nbrj, k;
struct JacobianMethod *JM;		struct JacobianMethod *JM;
struct JacobianCase *JC;		struct JacobianCase *JC;
Nbr = List_Nbr(Problem_S.JacobianMethod);		Nbr = List_Nbr(Problem_S.JacobianMethod);
Message::Check("Jacobian { /* nbr = %d */\n", Nbr);		Message::Check("Jacobian { /* nbr = %d */\n", Nbr);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" /* Num : %d */\n", i);		Message::Check(" /* Num : %d */\n", i);
JM = (struct JacobianMethod*)List_Pointer(Problem_S.JacobianMethod, i);		JM = (struct JacobianMethod *)List_Pointer(Problem_S.JacobianMethod, i);
Message::Check(" { Name %s;\n", JM->Name);		Message::Check(" { Name %s;\n", JM->Name);
Message::Check(" Case {\n");		Message::Check(" Case {\n");
Nbrj = List_Nbr(JM->JacobianCase);		Nbrj = List_Nbr(JM->JacobianCase);
for (j = 0; j < Nbrj; j++) {		for(j = 0; j < Nbrj; j++) {
JC = (struct JacobianCase*)List_Pointer(JM->JacobianCase, j);		JC = (struct JacobianCase *)List_Pointer(JM->JacobianCase, j);
Message::Check(" { Region ");		Message::Check(" { Region ");
if (JC->RegionIndex >= 0)		if(JC->RegionIndex >= 0)
Message::Check("%s;", ((struct Group *)		Message::Check("%s;", ((struct Group *)List_Pointer(Problem_S.Group,
List_Pointer(Problem_S.Group, JC->RegionIndex))->		JC->RegionIndex))
Name);		->Name);
else Message::Check("All;");		else
		Message::Check("All;");
Message::Check(" Jacobian %s",		Message::Check(" Jacobian %s",
Get_StringForDefine1Nbr(Jacobian_Type, JC->TypeJacobian));		Get_StringForDefine1Nbr(Jacobian_Type, JC->TypeJacobian));
if (JC->NbrParameters) {		if(JC->NbrParameters) {
for (k = 0; k < JC->NbrParameters; k++) {		for(k = 0; k < JC->NbrParameters; k++) {
if (k) Message::Check(","); else Message::Check(" {");		if(k)
Message::Check(" %.10g", JC->Para[k]);		Message::Check(",");
} Message::Check(" }");		else
		Message::Check(" {");
		Message::Check(" %.10g", JC->Para[k]);
		}
		Message::Check(" }");
}		}
Message::Check(";");		Message::Check(";");
if (JC->CoefficientIndex >= 0)		if(JC->CoefficientIndex >= 0)
Message::Check(" Coefficient Exp[%s];",		Message::Check(" Coefficient Exp[%s];",
Get_ExpressionName(JC->CoefficientIndex));		Get_ExpressionName(JC->CoefficientIndex));
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check(" }\n");		Message::Check(" }\n");
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
void Print_Integration()		void Print_Integration()
{		{
int i, j, k, Nbrm, Nbrc, Nbrq;		int i, j, k, Nbrm, Nbrc, Nbrq;
struct IntegrationMethod *IM;		struct IntegrationMethod *IM;
struct IntegrationCase *IC;		struct IntegrationCase *IC;
struct Quadrature *Q;		struct Quadrature *Q;
Nbrm = List_Nbr(Problem_S.IntegrationMethod);		Nbrm = List_Nbr(Problem_S.IntegrationMethod);
Message::Check("Integration { /* nbr = %d */\n", Nbrm);		Message::Check("Integration { /* nbr = %d */\n", Nbrm);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbrm; i++) {		for(i = 0; i < Nbrm; i++) {
Message::Check(" /* Num : %d */\n", i);		Message::Check(" /* Num : %d */\n", i);
IM = (struct IntegrationMethod*)List_Pointer(Problem_S.IntegrationMethod, i)		IM =
;		(struct IntegrationMethod *)List_Pointer(Problem_S.IntegrationMethod, i);
Message::Check(" { Name %s; \n", IM->Name);		Message::Check(" { Name %s; \n", IM->Name);
if(IM->CriterionIndex>=0)		if(IM->CriterionIndex >= 0)
Message::Check(" Criterion Exp[%s]; \n",		Message::Check(" Criterion Exp[%s]; \n",
Get_ExpressionName(IM->CriterionIndex));		Get_ExpressionName(IM->CriterionIndex));
Nbrc = List_Nbr(IM->IntegrationCase);		Nbrc = List_Nbr(IM->IntegrationCase);
Message::Check(" Case {");		Message::Check(" Case {");
Message::Check(" /* nbr = %d */\n", Nbrc);		Message::Check(" /* nbr = %d */\n", Nbrc);
for (j = 0; j < Nbrc; j++) {		for(j = 0; j < Nbrc; j++) {
IC = (struct IntegrationCase*)List_Pointer(IM->IntegrationCase, j);		IC = (struct IntegrationCase *)List_Pointer(IM->IntegrationCase, j);
Message::Check(" { Type %s;",		Message::Check(" { Type %s;",
Get_StringForDefine(Integration_Type, IC->Type));		Get_StringForDefine(Integration_Type, IC->Type));
switch (IC->Type) {		switch(IC->Type) {
case GAUSS :		case GAUSS:
Message::Check("\n");		Message::Check("\n");
Message::Check(" Case {\n");		Message::Check(" Case {\n");
Nbrq = List_Nbr(IC->Case);		Nbrq = List_Nbr(IC->Case);
for (k = 0; k < Nbrq; k++) {		for(k = 0; k < Nbrq; k++) {
Q = (struct Quadrature*)List_Pointer(IC->Case, k);		Q = (struct Quadrature *)List_Pointer(IC->Case, k);
Message::Check(" { GeoElement %s; NumberOfPoints %d; }\n",		Message::Check(" { GeoElement %s; NumberOfPoints %d; }\n",
Get_StringForDefine(Element_Type, Q->ElementType),		Get_StringForDefine(Element_Type, Q->ElementType),
Q->NumberOfPoints);		Q->NumberOfPoints);
}		}
Message::Check(" }\n");		Message::Check(" }\n");
Message::Check(" }\n"); break;		Message::Check(" }\n");
		break;
default :		default: Message::Check(" }\n"); break;
Message::Check(" }\n"); break;
}		}
}		}
Message::Check(" }\n");		Message::Check(" }\n");
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
void Print_FunctionSpace()		void Print_FunctionSpace()
{		{
struct FunctionSpace *FS;		struct FunctionSpace *FS;
struct BasisFunction *BF;		struct BasisFunction *BF;
struct SubSpace *SS;		struct SubSpace *SS;
struct GlobalQuantity *GQ;		struct GlobalQuantity *GQ;
struct ConstraintInFS *CO;		struct ConstraintInFS *CO;
List_T *BF_L, *SS_L, *GQ_L, *CO_L;		List_T *BF_L, *SS_L, *GQ_L, *CO_L;
int i0, i, Nbr0, Nbr, j, Nbrj;		int i0, i, Nbr0, Nbr, j, Nbrj;
Nbr0 = List_Nbr(Problem_S.FunctionSpace);		Nbr0 = List_Nbr(Problem_S.FunctionSpace);
Message::Check("FunctionSpace { /* nbr = %d */\n", Nbr0);		Message::Check("FunctionSpace { /* nbr = %d */\n", Nbr0);
Message::Check("\n");		Message::Check("\n");
for (i0=0; i0<Nbr0; i0++) {		for(i0 = 0; i0 < Nbr0; i0++) {
Message::Check(" /* Num : %d */\n", i0);		Message::Check(" /* Num : %d */\n", i0);
FS = (struct FunctionSpace*)List_Pointer(Problem_S.FunctionSpace, i0);		FS = (struct FunctionSpace *)List_Pointer(Problem_S.FunctionSpace, i0);
BF_L = FS->BasisFunction; SS_L = FS->SubSpace;		BF_L = FS->BasisFunction;
GQ_L = FS->GlobalQuantity; CO_L = FS->Constraint;		SS_L = FS->SubSpace;
		GQ_L = FS->GlobalQuantity;
		CO_L = FS->Constraint;
Message::Check(" { Name %s; Type %s;",		Message::Check(" { Name %s; Type %s;", FS->Name,
FS->Name, Get_StringForDefine(Field_Type, FS->Type));		Get_StringForDefine(Field_Type, FS->Type));
Message::Check("\n");		Message::Check("\n");
Nbr = List_Nbr(BF_L);		Nbr = List_Nbr(BF_L);
if (Nbr > 0) {		if(Nbr > 0) {
Message::Check(" BasisFunction {\n");		Message::Check(" BasisFunction {\n");
BF = (struct BasisFunction*)List_Pointer(BF_L, 0);		BF = (struct BasisFunction *)List_Pointer(BF_L, 0);
for (i=0; i<Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" /* GlobalNum : %d */\n", BF->Num);		Message::Check(" /* GlobalNum : %d */\n", BF->Num);
Message::Check(" Name %s; NameOfCoef %s; Function %s;\n",		Message::Check(" Name %s; NameOfCoef %s; Function %s;\n", BF->Name,
BF->Name, BF->NameOfCoef,		BF->NameOfCoef,
Get_StringFor3Function3Nbr(BF_Function, BF->Function));		Get_StringFor3Function3Nbr(BF_Function, BF->Function));
if (BF->SubFunction) {		if(BF->SubFunction) {
Message::Check(" SubFunction {");		Message::Check(" SubFunction {");
Nbrj = List_Nbr(BF->SubFunction);		Nbrj = List_Nbr(BF->SubFunction);
for (j=0; j<Nbrj; j++)		for(j = 0; j < Nbrj; j++)
Message::Check(" %s",		Message::Check(" %s",
((struct Expression *)		((struct Expression *)List_Pointer(
List_Pointer(Problem_S.Expression,		Problem_S.Expression,
*((int *)List_Pointer(BF->SubFunction,		*((int *)List_Pointer(BF->SubFunction, j))))
j))))->Name);		->Name);
Message::Check(" };\n");		Message::Check(" };\n");
}		}
if (BF->SubdFunction) {		if(BF->SubdFunction) {
Message::Check(" SubdFunction {");		Message::Check(" SubdFunction {");
Nbrj = List_Nbr(BF->SubdFunction);		Nbrj = List_Nbr(BF->SubdFunction);
for (j=0; j<Nbrj; j++)		for(j = 0; j < Nbrj; j++)
Message::Check(" %s",		Message::Check(" %s",
((struct Expression *)		((struct Expression *)List_Pointer(
List_Pointer(Problem_S.Expression,		Problem_S.Expression,
*((int *)List_Pointer(BF->SubdFunction,		*((int *)List_Pointer(BF->SubdFunction, j))))
j))))->Name);		->Name);
Message::Check(" };\n");		Message::Check(" };\n");
}		}
Message::Check(" Support %s;",
(BF->SupportIndex >=0)?
((struct Group *)List_Pointer(Problem_S.Group, BF->Suppor
tIndex))
->Name : "?");
Message::Check(" Entity %s;\n",
(BF->EntityIndex >=0)?
((struct Group *)List_Pointer(Problem_S.Group, BF->Entity
Index))
->Name : "?");
BF += 1;		Message::Check(
		" Support %s;",
		(BF->SupportIndex >= 0) ?
		((struct Group *)List_Pointer(Problem_S.Group, BF->SupportIndex))
		->Name :
		"?");
		Message::Check(" Entity %s;\n", (BF->EntityIndex >= 0) ?
		((struct Group *)List_Pointer(
		Problem_S.Group, BF->EntityIndex))
		->Name :
		"?");
		BF += 1;
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
BF = (Nbr>0)? (struct BasisFunction*)List_Pointer(BF_L, 0) : NULL;		BF = (Nbr > 0) ? (struct BasisFunction *)List_Pointer(BF_L, 0) : NULL;
Nbr = List_Nbr(SS_L);		Nbr = List_Nbr(SS_L);
if (Nbr > 0) {		if(Nbr > 0) {
Message::Check(" SubSpace {\n");		Message::Check(" SubSpace {\n");
SS = (struct SubSpace*)List_Pointer(SS_L, 0);		SS = (struct SubSpace *)List_Pointer(SS_L, 0);
for (i=0; i<Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" Name %s; NameOfBasisFunction {", SS->Name);		Message::Check(" Name %s; NameOfBasisFunction {", SS->Name);
Nbrj = List_Nbr(SS->BasisFunction);		Nbrj = List_Nbr(SS->BasisFunction);
for (j=0; j<Nbrj; j++)		for(j = 0; j < Nbrj; j++)
Message::Check(" %s /* n%d */",		Message::Check(" %s /* n%d */",
((struct BasisFunction *)		((struct BasisFunction *)List_Pointer(
List_Pointer(BF_L, *((int *)List_Pointer(SS->BasisFunc		BF_L, *((int *)List_Pointer(SS->BasisFunction, j))))
tion, j))))		->Name,
->Name, *((int *)List_Pointer(SS->BasisFunction, j)));		*((int *)List_Pointer(SS->BasisFunction, j)));
Message::Check(" };\n");		Message::Check(" };\n");
SS += 1;		SS += 1;
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Nbr = List_Nbr(GQ_L);		Nbr = List_Nbr(GQ_L);
if (Nbr > 0) {		if(Nbr > 0) {
Message::Check(" GlobalQuantity {\n");		Message::Check(" GlobalQuantity {\n");
GQ = (struct GlobalQuantity*)List_Pointer(GQ_L, 0);		GQ = (struct GlobalQuantity *)List_Pointer(GQ_L, 0);
for (i=0; i<Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" /* GlobalNum : %d */\n", GQ->Num);		Message::Check(" /* GlobalNum : %d */\n", GQ->Num);
Message::Check(" Name %s; Type %s;",		Message::Check(" Name %s; Type %s;", GQ->Name,
GQ->Name,
Get_StringForDefine(GlobalQuantity_Type, GQ->Type));		Get_StringForDefine(GlobalQuantity_Type, GQ->Type));
Message::Check(" NameOfCoef %s;\n",		Message::Check(
((struct BasisFunction *)		" NameOfCoef %s;\n",
List_Pointer(BF_L, GQ->ReferenceIndex))->NameOfCoef);		((struct BasisFunction *)List_Pointer(BF_L, GQ->ReferenceIndex))
GQ += 1;		->NameOfCoef);
		GQ += 1;
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Nbr = List_Nbr(CO_L);		Nbr = List_Nbr(CO_L);
if (Nbr > 0) {		if(Nbr > 0) {
Message::Check(" Constraint {\n");		Message::Check(" Constraint {\n");
CO = (struct ConstraintInFS*)List_Pointer(CO_L, 0);		CO = (struct ConstraintInFS *)List_Pointer(CO_L, 0);
for (i=0; i<Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" NameOfCoef ");		Message::Check(" NameOfCoef ");
if (CO->QuantityType == LOCALQUANTITY)		if(CO->QuantityType == LOCALQUANTITY)
Message::Check("%s;", ((struct BasisFunction *)		Message::Check("%s;", ((struct BasisFunction *)List_Pointer(
List_Pointer(BF_L, CO->ReferenceIndex))->NameOf		BF_L, CO->ReferenceIndex))
Coef);		->NameOfCoef);
else if (CO->QuantityType == GLOBALQUANTITY)		else if(CO->QuantityType == GLOBALQUANTITY)
Message::Check("%s;", ((struct GlobalQuantity *)		Message::Check("%s;", ((struct GlobalQuantity *)List_Pointer(
List_Pointer(GQ_L, CO->ReferenceIndex))->Name);		GQ_L, CO->ReferenceIndex))
else Message::Check("?;");		->Name);
		else
Message::Check(" // Entity %s;\n",		Message::Check("?;");
((struct Group *)List_Pointer(Problem_S.Group, CO->Entity
Index))		Message::Check(" // Entity %s;\n", ((struct Group *)List_Pointer(
->Name );		Problem_S.Group, CO->EntityIndex))
		->Name);
switch(CO->ConstraintPerRegion->Type) {
case INIT :		switch(CO->ConstraintPerRegion->Type) {
Message::Check(" // Type Init;");		case INIT: Message::Check(" // Type Init;");
case ASSIGN :		case ASSIGN:
Message::Check(" // Value Exp[%s];", Get_ExpressionName		Message::Check(
(CO->ConstraintPerRegion->Case.Fixed.ExpressionIndex));		" // Value Exp[%s];",
break;		Get_ExpressionName(
case ASSIGNFROMRESOLUTION :		CO->ConstraintPerRegion->Case.Fixed.ExpressionIndex));
case INITFROMRESOLUTION :		break;
Message::Check(" // Resolution %s;",		case ASSIGNFROMRESOLUTION:
		case INITFROMRESOLUTION:
		Message::Check(" // Resolution %s;",
CO->ConstraintPerRegion->Case.Solve.ResolutionName);		CO->ConstraintPerRegion->Case.Solve.ResolutionName);
break;		break;
}		}
if (CO->ConstraintPerRegion->TimeFunctionIndex >= 0)		if(CO->ConstraintPerRegion->TimeFunctionIndex >= 0)
Message::Check(" TimeFunction Exp[%s];",		Message::Check(
Get_ExpressionName(CO->ConstraintPerRegion->TimeFunctio		" TimeFunction Exp[%s];",
nIndex));		Get_ExpressionName(CO->ConstraintPerRegion->TimeFunctionIndex));
Message::Check("\n");		Message::Check("\n");
CO += 1;		CO += 1;
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
void Print_Formulation()		void Print_Formulation()
{		{
struct Formulation *FO;		struct Formulation *FO;
struct DefineQuantity *DQ;		struct DefineQuantity *DQ;
struct EquationTerm *FE;		struct EquationTerm *FE;
struct GlobalEquationTerm *GET;		struct GlobalEquationTerm *GET;
List_T *DQ_L, *FE_L;		List_T *DQ_L, *FE_L;
int i, Nbr, j, Nbrj, k, Nbrk;		int i, Nbr, j, Nbrj, k, Nbrk;
Nbr = List_Nbr(Problem_S.Formulation);		Nbr = List_Nbr(Problem_S.Formulation);
Message::Check("Formulation { /* nbr = %d */\n", Nbr);		Message::Check("Formulation { /* nbr = %d */\n", Nbr);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" /* Num : %d */\n", i);		Message::Check(" /* Num : %d */\n", i);
FO = (struct Formulation*)List_Pointer(Problem_S.Formulation, i);		FO = (struct Formulation *)List_Pointer(Problem_S.Formulation, i);
Message::Check(" { Name %s; Type %s;\n", FO->Name,		Message::Check(" { Name %s; Type %s;\n", FO->Name,
Get_StringForDefine(Formulation_Type, FO->Type));		Get_StringForDefine(Formulation_Type, FO->Type));
DQ_L = FO->DefineQuantity; FE_L = FO->Equation;		DQ_L = FO->DefineQuantity;
		FE_L = FO->Equation;
Message::Check(" Quantity {\n");		Message::Check(" Quantity {\n");
Nbrj = List_Nbr(DQ_L);		Nbrj = List_Nbr(DQ_L);
for (j=0; j<Nbrj; j++) {		for(j = 0; j < Nbrj; j++) {
DQ = (struct DefineQuantity*)List_Pointer(DQ_L, j);		DQ = (struct DefineQuantity *)List_Pointer(DQ_L, j);
Message::Check(" { Name %s; Type %s; NameOfSpace %s",		Message::Check(" { Name %s; Type %s; NameOfSpace %s", DQ->Name,
DQ->Name,
Get_StringForDefine(DefineQuantity_Type, DQ->Type),		Get_StringForDefine(DefineQuantity_Type, DQ->Type),
(DQ->FunctionSpaceIndex < 0) ? "?" :		(DQ->FunctionSpaceIndex < 0) ?
((struct FunctionSpace *)		"?" :
List_Pointer(Problem_S.FunctionSpace, DQ->FunctionSpaceInd		((struct FunctionSpace *)List_Pointer(
ex))->Name);		Problem_S.FunctionSpace, DQ->FunctionSpaceIndex))
if (DQ->IndexInFunctionSpace) {		->Name);
if (DQ->Type == GLOBALQUANTITY)		if(DQ->IndexInFunctionSpace) {
Message::Check("[%s]",		if(DQ->Type == GLOBALQUANTITY)
((struct GlobalQuantity *)		Message::Check(
List_Pointer		"[%s]", ((struct GlobalQuantity *)List_Pointer(
(((struct FunctionSpace *)		((struct FunctionSpace *)List_Pointer(
List_Pointer(Problem_S.FunctionSpace, DQ->FunctionSp		Problem_S.FunctionSpace, DQ->FunctionSpaceIndex))
aceIndex))		->GlobalQuantity,
->GlobalQuantity,		*((int *)List_Pointer(DQ->IndexInFunctionSpace, 0))))
*((int *)List_Pointer(DQ->IndexInFunctionSpace, 0))))		->Name);
->Name);		else if(DQ->Type == LOCALQUANTITY) {
else if (DQ->Type == LOCALQUANTITY) {		Message::Check("[");
Message::Check("[");		Nbrk = List_Nbr(DQ->IndexInFunctionSpace);
Nbrk = List_Nbr(DQ->IndexInFunctionSpace);		for(k = 0; k < Nbrk; k++)
for (k=0; k<Nbrk; k++)		Message::Check(" %d",
Message::Check(" %d", *((int *)List_Pointer(DQ->IndexInFunctionSpace,		*((int *)List_Pointer(DQ->IndexInFunctionSpace, k)));
k)));		Message::Check("]");
Message::Check("]");		}
}
}		}
Message::Check(";");		Message::Check(";");
if (DQ->Type == INTEGRALQUANTITY) {		if(DQ->Type == INTEGRALQUANTITY) {
Message::Check("\n");		Message::Check("\n");
Message::Check(" Integration %s;\n",		Message::Check(" Integration %s;\n",
((struct IntegrationMethod *)		((struct IntegrationMethod *)List_Pointer(
List_Pointer(Problem_S.IntegrationMethod,		Problem_S.IntegrationMethod,
DQ->IntegralQuantity.IntegrationMethodIndex		DQ->IntegralQuantity.IntegrationMethodIndex))
))->Name);		->Name);
Message::Check(" Jacobian %s;",		Message::Check(" Jacobian %s;",
((struct JacobianMethod *)		((struct JacobianMethod *)List_Pointer(
List_Pointer(Problem_S.JacobianMethod,		Problem_S.JacobianMethod,
DQ->IntegralQuantity.JacobianMethodIndex))-		DQ->IntegralQuantity.JacobianMethodIndex))
>Name);		->Name);
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check(" }\n");		Message::Check(" }\n");
Message::Check(" Equation {\n");		Message::Check(" Equation {\n");
Nbrj = List_Nbr(FE_L);		Nbrj = List_Nbr(FE_L);
for (j=0; j<Nbrj; j++) {		for(j = 0; j < Nbrj; j++) {
FE = (struct EquationTerm*)List_Pointer(FE_L, j);		FE = (struct EquationTerm *)List_Pointer(FE_L, j);
if (FE->Type == GALERKIN || FE->Type == DERHAM) {		if(FE->Type == GALERKIN || FE->Type == DERHAM) {
if(FE->Type == GALERKIN) Message::Check(" Galerkin { Density [ ... ]		if(FE->Type == GALERKIN)
;\n");		Message::Check(" Galerkin { Density [ ... ];\n");
if(FE->Type == DERHAM) Message::Check(" deRham { Density [ ... ]		if(FE->Type == DERHAM)
;\n");		Message::Check(" deRham { Density [ ... ];\n");
Message::Check(" In %s;\n",		Message::Check(" In %s;\n",
((struct Group *)		((struct Group *)List_Pointer(
List_Pointer(Problem_S.Group, FE->Case.LocalTerm.InIndex		Problem_S.Group, FE->Case.LocalTerm.InIndex))
))->Name );		->Name);
Message::Check(" Jacobian %s; \n",		Message::Check(
((struct JacobianMethod *)		" Jacobian %s; \n",
List_Pointer(Problem_S.JacobianMethod,		((struct JacobianMethod *)List_Pointer(
FE->Case.LocalTerm.JacobianMethodIndex))->N		Problem_S.JacobianMethod, FE->Case.LocalTerm.JacobianMethodIndex))
ame );		->Name);
Message::Check(" Integration %s; }\n",		Message::Check(" Integration %s; }\n",
((struct IntegrationMethod *)		((struct IntegrationMethod *)List_Pointer(
List_Pointer(Problem_S.IntegrationMethod,		Problem_S.IntegrationMethod,
FE->Case.LocalTerm.IntegrationMethodIndex))		FE->Case.LocalTerm.IntegrationMethodIndex))
->Name );		->Name);
Message::Check(" /* Inventaire des DQ (%d) [%d] :",		Message::Check(" /* Inventaire des DQ (%d) [%d] :",
FE->Case.LocalTerm.Term.NbrQuantityIndex,		FE->Case.LocalTerm.Term.NbrQuantityIndex,
FE->Case.LocalTerm.Term.QuantityIndexPost);		FE->Case.LocalTerm.Term.QuantityIndexPost);
for (k = 0; k < FE->Case.LocalTerm.Term.NbrQuantityIndex; k++)		for(k = 0; k < FE->Case.LocalTerm.Term.NbrQuantityIndex; k++)
Message::Check(" {%s}",		Message::Check(
((struct DefineQuantity *)		" {%s}", ((struct DefineQuantity *)List_Pointer(
List_Pointer		DQ_L, FE->Case.LocalTerm.Term.QuantityIndexTable[k]))
(DQ_L, FE->Case.LocalTerm.Term.QuantityIndexTable[k]))		->Name);
->Name);		Message::Check(" */\n");
Message::Check(" */\n");
Message::Check(" /* WholeQuantity (%d) :",		Message::Check(" /* WholeQuantity (%d) :",
List_Nbr(FE->Case.LocalTerm.Term.WholeQuantity));		List_Nbr(FE->Case.LocalTerm.Term.WholeQuantity));
Print_WholeQuantity(FE->Case.LocalTerm.Term.WholeQuantity, DQ_L);		Print_WholeQuantity(FE->Case.LocalTerm.Term.WholeQuantity, DQ_L);
Message::Check(" */\n");		Message::Check(" */\n");
}		}
else if (FE->Type == GLOBALTERM ) {		else if(FE->Type == GLOBALTERM) {
Message::Check(" GlobalTerm { [ ... ];\n");		Message::Check(" GlobalTerm { [ ... ];\n");
Message::Check(" In %s;\n",		Message::Check(" In %s;\n",
((struct Group *)		((struct Group *)List_Pointer(
List_Pointer(Problem_S.Group, FE->Case.GlobalTerm.InInde		Problem_S.Group, FE->Case.GlobalTerm.InIndex))
x))->Name );		->Name);
		if(FE->Case.GlobalTerm.SubType != EQ_ST_SELF)
		Message::Check(
		" SubType %s;\n",
		Get_StringForDefine(Equation_SubType, FE->Case.GlobalTerm.SubType));
if (FE->Case.GlobalTerm.SubType != EQ_ST_SELF)		Message::Check(" /* Inventaire des DQ (%d) [%d,%d] :",
Message::Check(" SubType %s;\n",
Get_StringForDefine(Equation_SubType, FE->Case.GlobalTe
rm.SubType));
Message::Check(" /* Inventaire des DQ (%d) [%d,%d] :",
FE->Case.GlobalTerm.Term.NbrQuantityIndex,		FE->Case.GlobalTerm.Term.NbrQuantityIndex,
FE->Case.GlobalTerm.Term.DefineQuantityIndexDof,		FE->Case.GlobalTerm.Term.DefineQuantityIndexDof,
FE->Case.GlobalTerm.Term.DefineQuantityIndexEqu);		FE->Case.GlobalTerm.Term.DefineQuantityIndexEqu);
for (k = 0; k < FE->Case.GlobalTerm.Term.NbrQuantityIndex; k++)		for(k = 0; k < FE->Case.GlobalTerm.Term.NbrQuantityIndex; k++)
Message::Check(" {%s}",		Message::Check(
((struct DefineQuantity *)		" {%s}", ((struct DefineQuantity *)List_Pointer(
List_Pointer		DQ_L, FE->Case.GlobalTerm.Term.QuantityIndexTable[k]))
(DQ_L, FE->Case.GlobalTerm.Term.QuantityIndexTable[k])		->Name);
)->Name);		Message::Check(" */\n");
Message::Check(" */\n");
Message::Check(" /* WholeQuantity (%d) :",		Message::Check(" /* WholeQuantity (%d) :",
List_Nbr(FE->Case.GlobalTerm.Term.WholeQuantity));		List_Nbr(FE->Case.GlobalTerm.Term.WholeQuantity));
Print_WholeQuantity(FE->Case.GlobalTerm.Term.WholeQuantity, DQ_L);		Print_WholeQuantity(FE->Case.GlobalTerm.Term.WholeQuantity, DQ_L);
Message::Check(" */\n");		Message::Check(" */\n");
}		}
else if (FE->Type == GLOBALEQUATION) {		else if(FE->Type == GLOBALEQUATION) {
Message::Check(" GlobalEquation { Type %s; UsingConstraint %s;\n",		Message::Check(
Get_StringForDefine(Constraint_Type, FE->Case.GlobalEquat		" GlobalEquation { Type %s; UsingConstraint %s;\n",
ion.Type),		Get_StringForDefine(Constraint_Type, FE->Case.GlobalEquation.Type),
(FE->Case.GlobalEquation.ConstraintIndex >= 0)?		(FE->Case.GlobalEquation.ConstraintIndex >= 0) ?
((struct Constraint *)		((struct Constraint *)List_Pointer(
List_Pointer(Problem_S.Constraint,		Problem_S.Constraint, FE->Case.GlobalEquation.ConstraintIndex))
FE->Case.GlobalEquation.ConstraintIndex))->		->Name :
Name		"undefined_constraint");
:		Nbrk = List_Nbr(FE->Case.GlobalEquation.GlobalEquationTerm);
"undefined_constraint"		for(k = 0; k < Nbrk; k++) {
);		GET = (struct GlobalEquationTerm *)List_Pointer(
Nbrk = List_Nbr(FE->Case.GlobalEquation.GlobalEquationTerm);		FE->Case.GlobalEquation.GlobalEquationTerm, k);
for (k = 0; k < Nbrk; k++) {		Message::Check(" { Node {%s}; Loop {%s}; Equation {%s};",
GET = (struct GlobalEquationTerm*)		((struct DefineQuantity *)List_Pointer(
List_Pointer(FE->Case.GlobalEquation.GlobalEquationTerm, k);		DQ_L, GET->DefineQuantityIndexNode))
Message::Check(" { Node {%s}; Loop {%s}; Equation {%s};",		->Name,
((struct DefineQuantity *)		((struct DefineQuantity *)List_Pointer(
List_Pointer(DQ_L, GET->DefineQuantityIndexNode))->Nam		DQ_L, GET->DefineQuantityIndexLoop))
e,		->Name,
((struct DefineQuantity *)		((struct DefineQuantity *)List_Pointer(
List_Pointer(DQ_L, GET->DefineQuantityIndexLoop))->Nam		DQ_L, GET->DefineQuantityIndexEqu))
e,		->Name);
((struct DefineQuantity *)		Message::Check(" In %s; }\n", ((struct Group *)List_Pointer(
List_Pointer(DQ_L, GET->DefineQuantityIndexEqu))->Name		Problem_S.Group, GET->InIndex))
);		->Name);
Message::Check(" In %s; }\n",		}
((struct Group *)
List_Pointer(Problem_S.Group, GET->InIndex))->Name);
}
}		}
}		}
Message::Check(" }\n");		Message::Check(" }\n");
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
void Print_Operation(struct Resolution *RE, List_T *Operation_L)		void Print_Operation(struct Resolution *RE, List_T *Operation_L)
{		{
struct Operation *OPE;		struct Operation *OPE;
int i, j, Nbrj;		int i, j, Nbrj;
static int NbrBlk = -1;		static int NbrBlk = -1;
NbrBlk++;		NbrBlk++;
Nbrj = List_Nbr(Operation_L);		Nbrj = List_Nbr(Operation_L);
for (j=0; j<Nbrj; j++) {		for(j = 0; j < Nbrj; j++) {
OPE = (struct Operation*)List_Pointer(Operation_L, j);		OPE = (struct Operation *)List_Pointer(Operation_L, j);
switch (OPE->Type) {
case OPERATION_GENERATE :		switch(OPE->Type) {
case OPERATION_GENERATEONLY :		case OPERATION_GENERATE:
case OPERATION_SOLVE :		case OPERATION_GENERATEONLY:
case OPERATION_GENERATEJAC :		case OPERATION_SOLVE:
case OPERATION_SOLVEJAC :		case OPERATION_GENERATEJAC:
case OPERATION_SOLVENL :		case OPERATION_SOLVEJAC:
case OPERATION_GENERATESEPARATE :		case OPERATION_SOLVENL:
case OPERATION_INITSOLUTION :		case OPERATION_GENERATESEPARATE:
case OPERATION_SAVESOLUTION :		case OPERATION_INITSOLUTION:
case OPERATION_SAVESOLUTIONS :		case OPERATION_SAVESOLUTION:
case OPERATION_READSOLUTION :		case OPERATION_SAVESOLUTIONS:
case OPERATION_TRANSFERSOLUTION :		case OPERATION_READSOLUTION:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		case OPERATION_TRANSFERSOLUTION:
		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" %s [%s];\n",		Message::Check(" %s [%s];\n",
Get_StringForDefine(Operation_Type, OPE->Type),		Get_StringForDefine(Operation_Type, OPE->Type),
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		RE->DefineSystem, OPE->DefineSystemIndex))
ame);		->Name);
break;		break;
case OPERATION_UPDATE :		case OPERATION_UPDATE:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" Update [ %s, Exp[%s] ];\n",		Message::Check(" Update [ %s, Exp[%s] ];\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		RE->DefineSystem, OPE->DefineSystemIndex))
ame,		->Name,
Get_ExpressionName(OPE->Case.Update.ExpressionIndex));		Get_ExpressionName(OPE->Case.Update.ExpressionIndex));
break;		break;
case OPERATION_SELECTCORRECTION :		case OPERATION_SELECTCORRECTION:
for (i=0 ; i<2*NbrBlk ; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" SelectCorrection [ %s, %d ] ;\n",		Message::Check(" SelectCorrection [ %s, %d ] ;\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		RE->DefineSystem, OPE->DefineSystemIndex))
ame,		->Name,
OPE->Case.SelectCorrection.Iteration) ;		OPE->Case.SelectCorrection.Iteration);
break ;		break;
case OPERATION_ADDCORRECTION :		case OPERATION_ADDCORRECTION:
for (i=0 ; i<2*NbrBlk ; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" AddCorrection [ %s, %g ] ;\n",		Message::Check(" AddCorrection [ %s, %g ] ;\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		RE->DefineSystem, OPE->DefineSystemIndex))
ame,		->Name,
OPE->Case.AddCorrection.Alpha) ;		OPE->Case.AddCorrection.Alpha);
break ;		break;
case OPERATION_UPDATECONSTRAINT :		case OPERATION_UPDATECONSTRAINT:
for (i=0 ; i<2*NbrBlk ; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" UpdateConstraint [ %s ] ;\n",		Message::Check(" UpdateConstraint [ %s ] ;\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		RE->DefineSystem, OPE->DefineSystemIndex))
ame) ;		->Name);
break ;		break;
case OPERATION_FOURIERTRANSFORM :		case OPERATION_FOURIERTRANSFORM:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" FourierTransform [ %s, %s, {...} ];\n",		Message::Check(
((struct DefineSystem *)		" FourierTransform [ %s, %s, {...} ];\n",
List_Pointer(RE->DefineSystem,		((struct DefineSystem *)List_Pointer(
OPE->Case.FourierTransform.DefineSystemIndex[		RE->DefineSystem, OPE->Case.FourierTransform.DefineSystemIndex[0]))
0]))->Name,		->Name,
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem,		RE->DefineSystem, OPE->Case.FourierTransform.DefineSystemIndex[1]))
OPE->Case.FourierTransform.DefineSystemIndex[		->Name);
1]))->Name);		break;
break;
		case OPERATION_TIMELOOPTHETA:
case OPERATION_TIMELOOPTHETA :		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		Message::Check(
Message::Check(" TimeLoopTheta [ %.10g, %.10g, Exp[%s], Exp[%s] ] {\n		" TimeLoopTheta [ %.10g, %.10g, Exp[%s], Exp[%s] ] {\n",
",		OPE->Case.TimeLoopTheta.Time0, OPE->Case.TimeLoopTheta.TimeMax,
OPE->Case.TimeLoopTheta.Time0, OPE->Case.TimeLoopTheta.Time		Get_ExpressionName(OPE->Case.TimeLoopTheta.DTimeIndex),
Max,		Get_ExpressionName(OPE->Case.TimeLoopTheta.ThetaIndex));
Get_ExpressionName(OPE->Case.TimeLoopTheta.DTimeIndex),
Get_ExpressionName(OPE->Case.TimeLoopTheta.ThetaIndex));
Print_Operation(RE, OPE->Case.TimeLoopTheta.Operation);		Print_Operation(RE, OPE->Case.TimeLoopTheta.Operation);
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" }\n");		Message::Check(" }\n");
break;		break;
case OPERATION_TIMELOOPNEWMARK :		case OPERATION_TIMELOOPNEWMARK:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" TimeLoopNewmark [ %.10g, %.10g, Exp[%s], %.10g, %.10		Message::Check(
g ] {\n",		" TimeLoopNewmark [ %.10g, %.10g, Exp[%s], %.10g, %.10g ] {\n",
OPE->Case.TimeLoopNewmark.Time0, OPE->Case.TimeLoopNewmark.		OPE->Case.TimeLoopNewmark.Time0, OPE->Case.TimeLoopNewmark.TimeMax,
TimeMax,		Get_ExpressionName(OPE->Case.TimeLoopNewmark.DTimeIndex),
Get_ExpressionName(OPE->Case.TimeLoopNewmark.DTimeIndex),		OPE->Case.TimeLoopNewmark.Beta, OPE->Case.TimeLoopNewmark.Gamma);
OPE->Case.TimeLoopNewmark.Beta, OPE->Case.TimeLoopNewmark.G
amma);
Print_Operation(RE, OPE->Case.TimeLoopNewmark.Operation);		Print_Operation(RE, OPE->Case.TimeLoopNewmark.Operation);
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" }\n");		Message::Check(" }\n");
break;		break;
case OPERATION_ITERATIVELOOP :		case OPERATION_ITERATIVELOOP:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" IterativeLoop [ %d, %.10g, Exp[%s] ] {\n",		Message::Check(
OPE->Case.IterativeLoop.NbrMaxIteration,		" IterativeLoop [ %d, %.10g, Exp[%s] ] {\n",
OPE->Case.IterativeLoop.Criterion,		OPE->Case.IterativeLoop.NbrMaxIteration,
Get_ExpressionName(OPE->Case.IterativeLoop.RelaxationFactor		OPE->Case.IterativeLoop.Criterion,
Index));		Get_ExpressionName(OPE->Case.IterativeLoop.RelaxationFactorIndex));
Print_Operation(RE, OPE->Case.IterativeLoop.Operation);		Print_Operation(RE, OPE->Case.IterativeLoop.Operation);
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" }\n");		Message::Check(" }\n");
break;		break;
case OPERATION_LANCZOS :		case OPERATION_LANCZOS:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" Lanczos [ %s, %d, { ... } , %.10g ];\n",		Message::Check(" Lanczos [ %s, %d, { ... } , %.10g ];\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		RE->DefineSystem, OPE->DefineSystemIndex))
ame,		->Name,
OPE->Case.Lanczos.Size,		OPE->Case.Lanczos.Size, OPE->Case.Lanczos.Shift);
OPE->Case.Lanczos.Shift);
break;		break;
case OPERATION_EIGENSOLVE :		case OPERATION_EIGENSOLVE:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" EigenSolve [ %s, %d, %.10g , %.10g ];\n",		Message::Check(" EigenSolve [ %s, %d, %.10g , %.10g ];\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		RE->DefineSystem, OPE->DefineSystemIndex))
ame,		->Name,
OPE->Case.EigenSolve.NumEigenvalues,		OPE->Case.EigenSolve.NumEigenvalues,
OPE->Case.EigenSolve.Shift_r, OPE->Case.EigenSolve.Shift_i)		OPE->Case.EigenSolve.Shift_r,
;		OPE->Case.EigenSolve.Shift_i);
break;		break;
case OPERATION_POSTOPERATION :		case OPERATION_POSTOPERATION:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" PostOperation [ ... ];\n");		Message::Check(" PostOperation [ ... ];\n");
break;		break;
case OPERATION_EVALUATE :		case OPERATION_EVALUATE:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" Evaluate [ ... ];\n");		Message::Check(" Evaluate [ ... ];\n");
break;		break;
case OPERATION_SETTIME :		case OPERATION_SETTIME:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" SetTime [ Exp[%s] ];\n",		Message::Check(" SetTime [ Exp[%s] ];\n",
Get_ExpressionName(OPE->Case.SetTime.ExpressionIndex));		Get_ExpressionName(OPE->Case.SetTime.ExpressionIndex));
break;		break;
case OPERATION_SETFREQUENCY :		case OPERATION_SETFREQUENCY:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" SetFrequency [ %s, Exp[%s] ];\n",		Message::Check(
((struct DefineSystem *)		" SetFrequency [ %s, Exp[%s] ];\n",
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		((struct DefineSystem *)List_Pointer(RE->DefineSystem,
ame,		OPE->DefineSystemIndex))
Get_ExpressionName(OPE->Case.SetFrequency.ExpressionIndex))		->Name,
;		Get_ExpressionName(OPE->Case.SetFrequency.ExpressionIndex));
break;		break;
case OPERATION_BREAK :		case OPERATION_BREAK:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" Break;\n");		Message::Check(" Break;\n");
break;		break;
case OPERATION_SYSTEMCOMMAND :		case OPERATION_SYSTEMCOMMAND:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" SystemCommand \" %s \";\n",		Message::Check(" SystemCommand \" %s \";\n",
OPE->Case.SystemCommand.String);		OPE->Case.SystemCommand.String);
break;		break;
case OPERATION_TEST :		case OPERATION_TEST:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" If [ Exp[%s] ] {\n",		Message::Check(" If [ Exp[%s] ] {\n",
Get_ExpressionName(OPE->Case.Test.ExpressionIndex));		Get_ExpressionName(OPE->Case.Test.ExpressionIndex));
Print_Operation(RE, OPE->Case.Test.Operation_True);		Print_Operation(RE, OPE->Case.Test.Operation_True);
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" }\n");		Message::Check(" }\n");
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
if(OPE->Case.Test.Operation_False){		if(OPE->Case.Test.Operation_False) {
Message::Check(" Else {\n");		Message::Check(" Else {\n");
Print_Operation(RE, OPE->Case.Test.Operation_False);		Print_Operation(RE, OPE->Case.Test.Operation_False);
Message::Check(" }\n");		Message::Check(" }\n");
}		}
break;		break;
case OPERATION_CHANGEOFCOORDINATES :		case OPERATION_CHANGEOFCOORDINATES:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" ChangeOfCoordinates [ %s, Exp[%s] ];\n",		Message::Check(
((struct Group *)		" ChangeOfCoordinates [ %s, Exp[%s] ];\n",
List_Pointer(Problem_S.Group,		((struct Group *)List_Pointer(Problem_S.Group,
OPE->Case.ChangeOfCoordinates.GroupIndex))->N		OPE->Case.ChangeOfCoordinates.GroupIndex))
ame,		->Name,
Get_ExpressionName(OPE->Case.ChangeOfCoordinates.Expression		Get_ExpressionName(OPE->Case.ChangeOfCoordinates.ExpressionIndex));
Index));		break;
break;
		case OPERATION_INIT_MOVINGBAND2D:
case OPERATION_INIT_MOVINGBAND2D :		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		Message::Check(
Message::Check(" Init_MovingBand2D [ %s ];\n",		" Init_MovingBand2D [ %s ];\n",
((struct Group *)		((struct Group *)List_Pointer(Problem_S.Group,
List_Pointer(Problem_S.Group,		OPE->Case.Init_MovingBand2D.GroupIndex))
OPE->Case.Init_MovingBand2D.GroupIndex))->Nam		->Name);
e);		break;
break;
		case OPERATION_MESH_MOVINGBAND2D:
case OPERATION_MESH_MOVINGBAND2D :		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		Message::Check(
Message::Check(" Mesh_MovingBand2D [ %s ];\n",		" Mesh_MovingBand2D [ %s ];\n",
((struct Group *)		((struct Group *)List_Pointer(Problem_S.Group,
List_Pointer(Problem_S.Group,		OPE->Case.Mesh_MovingBand2D.GroupIndex))
OPE->Case.Mesh_MovingBand2D.GroupIndex))->Nam		->Name);
e);		break;
break;		case OPERATION_GENERATE_MH_MOVING:
case OPERATION_GENERATE_MH_MOVING :		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		Message::Check(
Message::Check(" GenerateMHMoving [ %s, %s, %g, %d ];\n",		" GenerateMHMoving [ %s, %s, %g, %d ];\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(RE->DefineSystem,
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		OPE->DefineSystemIndex))
ame,		->Name,
((struct Group *)		((struct Group *)List_Pointer(Problem_S.Group,
List_Pointer(Problem_S.Group,		OPE->Case.Generate_MH_Moving.GroupIndex))
OPE->Case.Generate_MH_Moving.GroupIndex))->Na		->Name,
me,		OPE->Case.Generate_MH_Moving.Period,
OPE->Case.Generate_MH_Moving.Period,		OPE->Case.Generate_MH_Moving.NbrStep);
OPE->Case.Generate_MH_Moving.NbrStep);		break;
break;		case OPERATION_GENERATE_MH_MOVING_S:
case OPERATION_GENERATE_MH_MOVING_S :		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		Message::Check(
Message::Check(" GenerateMHMovingSeparate [ %s, %s, %g, %d ];\n",		" GenerateMHMovingSeparate [ %s, %s, %g, %d ];\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(RE->DefineSystem,
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		OPE->DefineSystemIndex))
ame,		->Name,
((struct Group *)		((struct Group *)List_Pointer(
List_Pointer(Problem_S.Group,		Problem_S.Group, OPE->Case.Generate_MH_Moving_S.GroupIndex))
OPE->Case.Generate_MH_Moving_S.GroupIndex))->		->Name,
Name,		OPE->Case.Generate_MH_Moving_S.Period,
OPE->Case.Generate_MH_Moving_S.Period,		OPE->Case.Generate_MH_Moving_S.NbrStep);
OPE->Case.Generate_MH_Moving_S.NbrStep);
break;		break;
case OPERATION_ADDMHMOVING :		case OPERATION_ADDMHMOVING:
for (i=0; i<2*NbrBlk; i++) Message::Check(" ");		for(i = 0; i < 2 * NbrBlk; i++) Message::Check(" ");
Message::Check(" AddMHMoving [%s];\n",		Message::Check(" AddMHMoving [%s];\n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->N		RE->DefineSystem, OPE->DefineSystemIndex))
ame);		->Name);
break;		break;
case OPERATION_DEFORMMESH :		case OPERATION_DEFORMMESH:
if(OPE->Case.DeformMesh.Quantity && OPE->Case.DeformMesh.Quantity2 &&		if(OPE->Case.DeformMesh.Quantity && OPE->Case.DeformMesh.Quantity2 &&
OPE->Case.DeformMesh.Quantity3)		OPE->Case.DeformMesh.Quantity3)
Message::Check(" DeformMesh [%s, {%s, %s, %s}, '%s']; \n",		Message::Check(
((struct DefineSystem *)		" DeformMesh [%s, {%s, %s, %s}, '%s']; \n",
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))-		((struct DefineSystem *)List_Pointer(RE->DefineSystem,
>Name,		OPE->DefineSystemIndex))
OPE->Case.DeformMesh.Quantity, OPE->Case.DeformMesh.Quant		->Name,
ity2,		OPE->Case.DeformMesh.Quantity, OPE->Case.DeformMesh.Quantity2,
OPE->Case.DeformMesh.Quantity3, OPE->Case.DeformMesh.Name		OPE->Case.DeformMesh.Quantity3, OPE->Case.DeformMesh.Name_MshFile);
_MshFile);
else		else
Message::Check(" DeformMesh [%s, %s, '%s']; \n",		Message::Check(" DeformMesh [%s, %s, '%s']; \n",
((struct DefineSystem *)		((struct DefineSystem *)List_Pointer(
List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))-		RE->DefineSystem, OPE->DefineSystemIndex))
>Name,		->Name,
OPE->Case.DeformMesh.Quantity,		OPE->Case.DeformMesh.Quantity,
OPE->Case.DeformMesh.Name_MshFile);		OPE->Case.DeformMesh.Name_MshFile);
break;		break;
case OPERATION_GMSHREAD :		case OPERATION_GMSHREAD:
Message::Check(" GmshRead [%s]; \n", OPE->Case.GmshRead.FileName);		Message::Check(" GmshRead [%s]; \n", OPE->Case.GmshRead.FileName);
break;		break;
case OPERATION_GMSHMERGE :		case OPERATION_GMSHMERGE:
Message::Check(" GmshMerge [%s]; \n", OPE->Case.GmshRead.FileName);		Message::Check(" GmshMerge [%s]; \n", OPE->Case.GmshRead.FileName);
break;		break;
case OPERATION_GMSHOPEN :		case OPERATION_GMSHOPEN:
Message::Check(" GmshOpen [%s]; \n", OPE->Case.GmshRead.FileName);		Message::Check(" GmshOpen [%s]; \n", OPE->Case.GmshRead.FileName);
break;		break;
case OPERATION_GMSHWRITE :		case OPERATION_GMSHWRITE:
Message::Check(" GmshWrite [%s]; \n", OPE->Case.GmshRead.FileName);		Message::Check(" GmshWrite [%s]; \n", OPE->Case.GmshRead.FileName);
break;		break;
case OPERATION_GMSHCLEARALL :		case OPERATION_GMSHCLEARALL:
Message::Check(" GmshClearAll; \n");		Message::Check(" GmshClearAll; \n");
break;		break;
case OPERATION_DELETEFILE:		case OPERATION_DELETEFILE:
Message::Check(" DeleteFile [%s]; \n", OPE->Case.DeleteFile.FileName)		Message::Check(" DeleteFile [%s]; \n",
;		OPE->Case.DeleteFile.FileName);
break;		break;
case OPERATION_RENAMEFILE:		case OPERATION_RENAMEFILE:
Message::Check(" RenameFile [%s, %s]; \n",		Message::Check(" RenameFile [%s, %s]; \n",
OPE->Case.RenameFile.OldFileName,		OPE->Case.RenameFile.OldFileName,
OPE->Case.RenameFile.NewFileName);		OPE->Case.RenameFile.NewFileName);
break;		break;
case OPERATION_CREATEDIR:		case OPERATION_CREATEDIR:
Message::Check(" CreateDir [%s]; \n",		Message::Check(" CreateDir [%s]; \n", OPE->Case.CreateDir.DirName);
OPE->Case.CreateDir.DirName);
break;		break;
default :		default: Message::Check(" ???;\n"); break;
Message::Check(" ???;\n");
break;
}		}
}		}
NbrBlk--;		NbrBlk--;
}		}
void Print_Resolution()		void Print_Resolution()
{		{
struct Resolution *RE;		struct Resolution *RE;
struct DefineSystem *DS;		struct DefineSystem *DS;
List_T *DS_L;		List_T *DS_L;
int i, Nbr, j, Nbrj, k;		int i, Nbr, j, Nbrj, k;
Nbr = List_Nbr(Problem_S.Resolution);		Nbr = List_Nbr(Problem_S.Resolution);
Message::Check("Resolution { /* nbr = %d */\n", Nbr);		Message::Check("Resolution { /* nbr = %d */\n", Nbr);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" /* Num : %d */\n", i);		Message::Check(" /* Num : %d */\n", i);
RE = (struct Resolution*)List_Pointer(Problem_S.Resolution, i);		RE = (struct Resolution *)List_Pointer(Problem_S.Resolution, i);
Message::Check(" { Name %s\n", RE->Name);		Message::Check(" { Name %s\n", RE->Name);
DS_L = RE->DefineSystem;		DS_L = RE->DefineSystem;
Message::Check(" System {\n");		Message::Check(" System {\n");
Nbrj = List_Nbr(DS_L);		Nbrj = List_Nbr(DS_L);
for (j=0; j<Nbrj; j++) {		for(j = 0; j < Nbrj; j++) {
DS = (struct DefineSystem*)List_Pointer(DS_L, j);		DS = (struct DefineSystem *)List_Pointer(DS_L, j);
Message::Check(" { Name %s; Type %s; ",		Message::Check(" { Name %s; Type %s; ", DS->Name,
DS->Name,
Get_StringForDefine(DefineSystem_Type, DS->Type));		Get_StringForDefine(DefineSystem_Type, DS->Type));
Message::Check("NameOfFormulation {");		Message::Check("NameOfFormulation {");
for (k = 0; k < List_Nbr(DS->FormulationIndex); k++)		for(k = 0; k < List_Nbr(DS->FormulationIndex); k++)
Message::Check(" %s",		Message::Check(" %s",
((struct Formulation *)		((struct Formulation *)List_Pointer(
List_Pointer(Problem_S.Formulation,		Problem_S.Formulation,
*((int *)List_Pointer(DS->FormulationIndex,		*((int *)List_Pointer(DS->FormulationIndex, k))))
k))))->Name);		->Name);
Message::Check(" }; ");		Message::Check(" }; ");
if(DS->MeshName)		if(DS->MeshName) Message::Check("NameOfMesh %s; ", DS->MeshName);
Message::Check("NameOfMesh %s; ", DS->MeshName);
if(DS->OriginSystemIndex) {		if(DS->OriginSystemIndex) {
Message::Check("OriginSystem {") ;		Message::Check("OriginSystem {");
		for(k = 0; k < List_Nbr(DS->OriginSystemIndex); k++) {
		if(k) Message::Check(",");
		Message::Check(" %d",
		*((int *)List_Pointer(DS->OriginSystemIndex, k)));
		}
		Message::Check(" } ;");
		}
for (k = 0 ; k < List_Nbr(DS->OriginSystemIndex) ; k++) {		if(DS->Type == VAL_COMPLEX) {
if (k) Message::Check(",") ;		Message::Check("Frequency {");
Message::Check(" %d", *((int *)List_Pointer(DS->OriginSystemIndex, k)))
;		for(k = 0; k < List_Nbr(DS->FrequencyValue); k++) {
}		if(k) Message::Check(",");
Message::Check(" } ;") ;		Message::Check(" %.10g",
}		*((double *)List_Pointer(DS->FrequencyValue, k)));
		}
if (DS->Type == VAL_COMPLEX) {		Message::Check(" };");
Message::Check("Frequency {");
for (k = 0; k < List_Nbr(DS->FrequencyValue); k++) {
if (k) Message::Check(",");
Message::Check(" %.10g", *((double *)List_Pointer(DS->FrequencyValue, k
)));
}
Message::Check(" };");
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check(" }\n");		Message::Check(" }\n");
Message::Check(" Operation {\n");		Message::Check(" Operation {\n");
Print_Operation(RE, RE->Operation);		Print_Operation(RE, RE->Operation);
Message::Check(" }\n");		Message::Check(" }\n");
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
void Print_PostProcessing()		void Print_PostProcessing()
{		{
struct PostProcessing *PP;		struct PostProcessing *PP;
struct PostQuantity *PQ;		struct PostQuantity *PQ;
struct PostQuantityTerm *PQT;		struct PostQuantityTerm *PQT;
int i, Nbr, j, Nbrj, k, Nbrk;		int i, Nbr, j, Nbrj, k, Nbrk;
Nbr = List_Nbr(Problem_S.PostProcessing);		Nbr = List_Nbr(Problem_S.PostProcessing);
Message::Check("PostProcessing { /* nbr = %d */\n", Nbr);		Message::Check("PostProcessing { /* nbr = %d */\n", Nbr);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbr; i++) {		for(i = 0; i < Nbr; i++) {
Message::Check(" /* Num : %d */\n", i);		Message::Check(" /* Num : %d */\n", i);
PP = (struct PostProcessing*)List_Pointer(Problem_S.PostProcessing, i);		PP = (struct PostProcessing *)List_Pointer(Problem_S.PostProcessing, i);
Message::Check(" { Name %s; NameOfFormulation %s; \n", PP->Name,		Message::Check(" { Name %s; NameOfFormulation %s; \n", PP->Name,
((struct Formulation *)		((struct Formulation *)List_Pointer(Problem_S.Formulation,
List_Pointer(Problem_S.Formulation, PP->FormulationIndex))->		PP->FormulationIndex))
Name);		->Name);
if(PP->NameOfSystem)		if(PP->NameOfSystem) Message::Check("NameOfSystem %s;", PP->NameOfSystem);
Message::Check("NameOfSystem %s;", PP->NameOfSystem);
Nbrj = List_Nbr(PP->PostQuantity);		Nbrj = List_Nbr(PP->PostQuantity);
if (Nbrj > 0) {		if(Nbrj > 0) {
Message::Check(" Quantity {\n");		Message::Check(" Quantity {\n");
for (j = 0; j < Nbrj; j++) {		for(j = 0; j < Nbrj; j++) {
PQ = (struct PostQuantity*)List_Pointer(PP->PostQuantity, j);		PQ = (struct PostQuantity *)List_Pointer(PP->PostQuantity, j);
Message::Check(" { Name %s;\n", PQ->Name);		Message::Check(" { Name %s;\n", PQ->Name);
Message::Check(" Value {\n");		Message::Check(" Value {\n");
Nbrk = List_Nbr(PQ->PostQuantityTerm);		Nbrk = List_Nbr(PQ->PostQuantityTerm);
for (k = 0; k < Nbrk; k++) {		for(k = 0; k < Nbrk; k++) {
PQT = (struct PostQuantityTerm*)List_Pointer(PQ->PostQuantityTerm, k);		PQT =
Message::Check(" { %s { ['",		(struct PostQuantityTerm *)List_Pointer(PQ->PostQuantityTerm, k);
		Message::Check(" { %s { ['",
Get_StringForDefine(PostQuantityTerm_EvaluationType,		Get_StringForDefine(PostQuantityTerm_EvaluationType,
PQT->EvaluationType));		PQT->EvaluationType));
Print_WholeQuantity		Print_WholeQuantity(PQT->WholeQuantity,
(PQT->WholeQuantity,		((struct Formulation *)List_Pointer(
((struct Formulation *)		Problem_S.Formulation, PP->FormulationIndex))
List_Pointer(Problem_S.Formulation, PP->FormulationIndex))		->DefineQuantity);
->DefineQuantity);		Message::Check(" ']; /* DefineQuantityType %s */\n",
Message::Check(" ']; /* DefineQuantityType %s */\n",
Get_StringForDefine(DefineQuantity_Type, PQT->Type));		Get_StringForDefine(DefineQuantity_Type, PQT->Type));
if(PQT->InIndex > 0)		if(PQT->InIndex > 0)
Message::Check(" In %s;\n",		Message::Check(
((struct Group *)List_Pointer(Problem_S.Group, PQT->I		" In %s;\n",
nIndex))->Name);		((struct Group *)List_Pointer(Problem_S.Group, PQT->InIndex))
if(PQT->IntegrationMethodIndex > 0)		->Name);
Message::Check(" Integration %s;\n",		if(PQT->IntegrationMethodIndex > 0)
((struct IntegrationMethod *)		Message::Check(
List_Pointer(Problem_S.IntegrationMethod,		" Integration %s;\n",
PQT->IntegrationMethodIndex))->Name);		((struct IntegrationMethod *)List_Pointer(
if(PQT->JacobianMethodIndex > 0)		Problem_S.IntegrationMethod, PQT->IntegrationMethodIndex))
Message::Check(" Jacobian %s;\n",		->Name);
((struct JacobianMethod *)		if(PQT->JacobianMethodIndex > 0)
List_Pointer(Problem_S.JacobianMethod,		Message::Check(
PQT->JacobianMethodIndex))->Name);		" Jacobian %s;\n",
		((struct JacobianMethod *)List_Pointer(Problem_S.JacobianMethod,
}		PQT->JacobianMethodIndex))
Message::Check(" } } }\n"); Message::Check(" }\n");		->Name);
		}
		Message::Check(" } } }\n");
		Message::Check(" }\n");
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check("\n}");		Message::Check("\n}");
Message::Check("\n");		Message::Check("\n");
}		}
void Print_PostOperation()		void Print_PostOperation()
{		{
struct PostProcessing *PP;		struct PostProcessing *PP;
struct PostOperation *PO;		struct PostOperation *PO;
struct PostSubOperation *PSO;		struct PostSubOperation *PSO;
int i, Nbr, k, Nbrk;		int i, Nbr, k, Nbrk;
Nbr = List_Nbr(Problem_S.PostOperation);		Nbr = List_Nbr(Problem_S.PostOperation);
Message::Check("PostOperation { /* nbr = %d */\n", Nbr);		Message::Check("PostOperation { /* nbr = %d */\n", Nbr);
Message::Check("\n");		Message::Check("\n");
for (i = 0; i < Nbr; i++) {		for(i = 0; i < Nbr; i++) {
PO = (struct PostOperation*)List_Pointer(Problem_S.PostOperation, i);		PO = (struct PostOperation *)List_Pointer(Problem_S.PostOperation, i);
PP = (struct PostProcessing*)List_Pointer(Problem_S.PostProcessing,		PP = (struct PostProcessing *)List_Pointer(Problem_S.PostProcessing,
PO->PostProcessingIndex);		PO->PostProcessingIndex);
Message::Check(" { Name %s; NameOfPostProcessing %s;\n", PO->Name, PP->Name		Message::Check(" { Name %s; NameOfPostProcessing %s;\n", PO->Name,
);		PP->Name);
Message::Check(" Operation {\n");		Message::Check(" Operation {\n");
Nbrk = List_Nbr(PO->PostSubOperation);		Nbrk = List_Nbr(PO->PostSubOperation);
for (k = 0; k < Nbrk; k++) {		for(k = 0; k < Nbrk; k++) {
PSO = (struct PostSubOperation*)List_Pointer(PO->PostSubOperation, k);		PSO = (struct PostSubOperation *)List_Pointer(PO->PostSubOperation, k);
switch (PSO->Type) {		switch(PSO->Type) {
case POP_PRINT :		case POP_PRINT:
Message::Check(" Print[%s",		Message::Check(" Print[%s",
((struct PostQuantity *)		((struct PostQuantity *)List_Pointer(
List_Pointer(PP->PostQuantity, PSO->PostQuantityIndex[0]		PP->PostQuantity, PSO->PostQuantityIndex[0]))
))->Name);		->Name);
if(PSO->PostQuantitySupport[0] >= 0)		if(PSO->PostQuantitySupport[0] >= 0)
Message::Check(" [%s]",		Message::Check(
((struct Group *)		" [%s]", ((struct Group *)List_Pointer(Problem_S.Group,
List_Pointer(Problem_S.Group, PSO->PostQuantitySupport		PSO->PostQuantitySupport[0]))
[0]))->Name);		->Name);
if(PSO->PostQuantityIndex[1] >= 0) {		if(PSO->PostQuantityIndex[1] >= 0) {
Message::Check(" %s %s",		Message::Check(" %s %s",
Get_StringForDefine(PostSubOperation_CombinationType,		Get_StringForDefine(PostSubOperation_CombinationType,
PSO->CombinationType),		PSO->CombinationType),
((struct PostQuantity *)		((struct PostQuantity *)List_Pointer(
List_Pointer(PP->PostQuantity, PSO->PostQuantityIndex[		PP->PostQuantity, PSO->PostQuantityIndex[1]))
1]))->Name);		->Name);
if(PSO->PostQuantitySupport[1] >= 0)		if(PSO->PostQuantitySupport[1] >= 0)
Message::Check(" [%s]",		Message::Check(" [%s]",
((struct Group *)		((struct Group *)List_Pointer(
List_Pointer(Problem_S.Group, PSO->PostQuantitySuppo		Problem_S.Group, PSO->PostQuantitySupport[1]))
rt[1]))->Name);		->Name);
}		}
switch (PSO->SubType) {		switch(PSO->SubType) {
case PRINT_ONREGION :		case PRINT_ONREGION:
if (PSO->Case.OnRegion.RegionIndex >=0)		if(PSO->Case.OnRegion.RegionIndex >= 0)
Message::Check(", OnRegion %s",		Message::Check(", OnRegion %s",
((struct Group *)		((struct Group *)List_Pointer(
List_Pointer(Problem_S.Group,		Problem_S.Group, PSO->Case.OnRegion.RegionIndex))
PSO->Case.OnRegion.RegionIndex))->Name		->Name);
);		else
else		Message::Check(", OnGlobal");
Message::Check(", OnGlobal");		break;
break;		case PRINT_ONELEMENTSOF:
case PRINT_ONELEMENTSOF :		Message::Check(", OnElementsOf %s",
Message::Check(", OnElementsOf %s",		((struct Group *)List_Pointer(
((struct Group *)		Problem_S.Group, PSO->Case.OnRegion.RegionIndex))
List_Pointer(Problem_S.Group,		->Name);
PSO->Case.OnRegion.RegionIndex))->Name );		break;
break;		case PRINT_ONGRID:
case PRINT_ONGRID :		Message::Check(", OnGrid %s",
Message::Check(", OnGrid %s",		((struct Group *)List_Pointer(
((struct Group *)		Problem_S.Group, PSO->Case.OnRegion.RegionIndex))
List_Pointer(Problem_S.Group,		->Name);
PSO->Case.OnRegion.RegionIndex))->Name );		break;
break;		case PRINT_ONGRID_0D:
case PRINT_ONGRID_0D :		Message::Check(", OnPoint {%.10g,%.10g,%.10g}", PSO->Case.OnGrid.x[0],
Message::Check(", OnPoint {%.10g,%.10g,%.10g}",		PSO->Case.OnGrid.y[0], PSO->Case.OnGrid.z[0]);
PSO->Case.OnGrid.x[0], PSO->Case.OnGrid.y[0],		break;
PSO->Case.OnGrid.z[0]);		case PRINT_ONGRID_1D:
break;		Message::Check(
case PRINT_ONGRID_1D :		", OnLine {{%.10g,%.10g,%.10g}{%.10g,%.10g,%.10g}} {%d}",
Message::Check(", OnLine {{%.10g,%.10g,%.10g}{%.10g,%.10g,%.10g}} {%d}"		PSO->Case.OnGrid.x[0], PSO->Case.OnGrid.y[0], PSO->Case.OnGrid.z[0],
,		PSO->Case.OnGrid.x[1], PSO->Case.OnGrid.y[1], PSO->Case.OnGrid.z[1],
PSO->Case.OnGrid.x[0], PSO->Case.OnGrid.y[0],		PSO->Case.OnGrid.n[0]);
PSO->Case.OnGrid.z[0],		break;
PSO->Case.OnGrid.x[1], PSO->Case.OnGrid.y[1],		case PRINT_ONGRID_2D:
PSO->Case.OnGrid.z[1], PSO->Case.OnGrid.n[0]);		Message::Check(
break;		", OnPlane {{%.10g,%.10g,%.10g}{%.10g,%.10g,%.10g}"
case PRINT_ONGRID_2D :		"{%.10g,%.10g,%.10g}} {%d,%d}",
Message::Check(", OnPlane {{%.10g,%.10g,%.10g}{%.10g,%.10g,%.10g}"		PSO->Case.OnGrid.x[0], PSO->Case.OnGrid.y[0], PSO->Case.OnGrid.z[0],
"{%.10g,%.10g,%.10g}} {%d,%d}",		PSO->Case.OnGrid.x[1], PSO->Case.OnGrid.y[1], PSO->Case.OnGrid.z[1],
PSO->Case.OnGrid.x[0], PSO->Case.OnGrid.y[0],		PSO->Case.OnGrid.x[2], PSO->Case.OnGrid.y[2], PSO->Case.OnGrid.z[2],
PSO->Case.OnGrid.z[0],		PSO->Case.OnGrid.n[0], PSO->Case.OnGrid.n[1]);
PSO->Case.OnGrid.x[1], PSO->Case.OnGrid.y[1],		break;
PSO->Case.OnGrid.z[1],		default: /* parametric grid, ... */ break;
PSO->Case.OnGrid.x[2], PSO->Case.OnGrid.y[2],		}
PSO->Case.OnGrid.z[2],		break;
PSO->Case.OnGrid.n[0], PSO->Case.OnGrid.n[1]);		default: /* POP_EXPRESSION, POP_GROUP, etc. */ break;
break;		}
default : /* parametric grid, ... */
break;
}
break;
default : /* POP_EXPRESSION, POP_GROUP, etc. */
break;
}
if(PSO->Depth != 1)
Message::Check(", Depth %d", PSO->Depth);
if(PSO->Skin)		if(PSO->Depth != 1) Message::Check(", Depth %d", PSO->Depth);
Message::Check(", Skin");
if(PSO->NoNewLine)		if(PSO->Skin) Message::Check(", Skin");
Message::Check(", NoNewLine");
if(PSO->Smoothing)		if(PSO->NoNewLine) Message::Check(", NoNewLine");
Message::Check(", Smoothing %d", PSO->Smoothing);
		if(PSO->Smoothing) Message::Check(", Smoothing %d", PSO->Smoothing);
if(PSO->Dimension != DIM_ALL)		if(PSO->Dimension != DIM_ALL)
Message::Check(", Dimension %d", PSO->Dimension);		Message::Check(", Dimension %d", PSO->Dimension);
if(PSO->HarmonicToTime > 1)		if(PSO->HarmonicToTime > 1)
Message::Check(", HarmonicToTime %d", PSO->HarmonicToTime);		Message::Check(", HarmonicToTime %d", PSO->HarmonicToTime);
if(PSO->TimeToHarmonic)		if(PSO->TimeToHarmonic)
Message::Check(", TimeToHarmonic %d", PSO->TimeToHarmonic);		Message::Check(", TimeToHarmonic %d", PSO->TimeToHarmonic);
if(PSO->FourierTransform == 1)		if(PSO->FourierTransform == 1) Message::Check(", FourierTransform");
Message::Check(", FourierTransform");		if(PSO->FourierTransform == 2) Message::Check(", CosineTransform");
if(PSO->FourierTransform == 2)
Message::Check(", CosineTransform");
if(PSO->TimeInterval_Flag)		if(PSO->TimeInterval_Flag)
Message::Check(", TimeInterval {%g, %g}",		Message::Check(", TimeInterval {%g, %g}", PSO->TimeInterval[0],
PSO->TimeInterval[0], PSO->TimeInterval[1]);		PSO->TimeInterval[1]);
if(PSO->Sort)		if(PSO->Sort)
Message::Check(", Sort %s",		Message::Check(", Sort %s", Get_StringForDefine(
Get_StringForDefine(PostSubOperation_SortType, PSO->Adapt		PostSubOperation_SortType, PSO->Adapt));
));
if(PSO->Adapt)		if(PSO->Adapt)
Message::Check(", Adapt %s",		Message::Check(
Get_StringForDefine(PostSubOperation_AdaptationType, PSO-		", Adapt %s",
>Adapt));		Get_StringForDefine(PostSubOperation_AdaptationType, PSO->Adapt));
if(PSO->Target >= 0)		if(PSO->Target >= 0) Message::Check(", Target %g", PSO->Target);
Message::Check(", Target %g", PSO->Target);
		if(PSO->Iso) {
if(PSO->Iso){		if(PSO->Iso < 0) {
if(PSO->Iso < 0){		Message::Check(", Iso {");
Message::Check(", Iso {");		for(i = 0; i < List_Nbr(PSO->Iso_L); i++) {
for(i=0; i<List_Nbr(PSO->Iso_L); i++){		if(i != List_Nbr(PSO->Iso_L) - 1)
if(i!=List_Nbr(PSO->Iso_L)-1)		Message::Check("%g,", *(double *)List_Pointer(PSO->Iso_L, i));
Message::Check("%g,", *(double*)List_Pointer(PSO->Iso_L,i));		else
else		Message::Check("%g}", *(double *)List_Pointer(PSO->Iso_L, i));
Message::Check("%g}", *(double*)List_Pointer(PSO->Iso_L,i));		}
}		}
}		else {
else{		Message::Check(", Iso %d", PSO->Iso);
Message::Check(", Iso %d", PSO->Iso);		}
}
}		}
/* todo: time steps, frequencies, values, changeofcoord, ... */		/* todo: time steps, frequencies, values, changeofcoord, ... */
Message::Check(", Format %s",		Message::Check(", Format %s",
Get_StringForDefine(PostSubOperation_Format, PSO->Format));		Get_StringForDefine(PostSubOperation_Format, PSO->Format));
if(PSO->FileOut){		if(PSO->FileOut) {
Message::Check(", File %s\"%s\"",		Message::Check(", File %s\"%s\"",
(PSO->CatFile==2)?">> ":(PSO->CatFile==1)?"> ":"", PSO->F		(PSO->CatFile == 2) ? ">> " :
ileOut);		(PSO->CatFile == 1) ? "> " :
		"",
		PSO->FileOut);
}		}
Message::Check("];\n");		Message::Check("];\n");
}		}
Message::Check(" }\n ");		Message::Check(" }\n ");
Message::Check(" }\n");		Message::Check(" }\n");
}		}
Message::Check("\n");		Message::Check("\n");
Message::Check("}\n");		Message::Check("}\n");
}		}
int Print_Object(int ichoice)		int Print_Object(int ichoice)
{		{
switch (ichoice) {		switch(ichoice) {
case 0 : Print_Constants (); break;		case 0: Print_Constants(); break;
case 1 : Print_Group (); break;		case 1: Print_Group(); break;
case 2 : Print_Expression (); break;		case 2: Print_Expression(); break;
case 3 : Print_Constraint (); break;		case 3: Print_Constraint(); break;
case 4 : Print_Jacobian (); break;		case 4: Print_Jacobian(); break;
case 5 : Print_Integration (); break;		case 5: Print_Integration(); break;
case 6 : Print_FunctionSpace (); break;		case 6: Print_FunctionSpace(); break;
case 7 : Print_Formulation (); break;		case 7: Print_Formulation(); break;
case 8 : Print_Resolution (); break;		case 8: Print_Resolution(); break;
case 9 : Print_PostProcessing(); break;		case 9: Print_PostProcessing(); break;
case 10 : Print_PostOperation (); break;		case 10: Print_PostOperation(); break;
default : return 1;		default: return 1;
}		}
return 0;		return 0;
}		}
void Print_ProblemStructure()		void Print_ProblemStructure()
{		{
char buff[128];		char buff[128];
int ichoice;		int ichoice;
while (1) {		while(1) {
Message::Info("Checking");		Message::Info("Checking");
Message::Direct("(1) Constants (2) Groups (3) Functions");		Message::Direct("(1) Constants (2) Groups (3) Functions");
Message::Direct("(4) Constraints (5) Jacobians (6) Integrations")		Message::Direct(
;		"(4) Constraints (5) Jacobians (6) Integrations");
Message::Direct("(7) FunctionSpaces (8) Formulations (9) Resolutions");		Message::Direct("(7) FunctionSpaces (8) Formulations (9) Resolutions");
Message::Direct("(10) PostProcessings (11) PostOperations (other) Quit");		Message::Direct("(10) PostProcessings (11) PostOperations (other) Quit");
Message::Check("Choice: ");		Message::Check("Choice: ");
if(!fgets(buff, 128, stdin))		if(!fgets(buff, 128, stdin)) break;
break;
ichoice = atoi(buff);		ichoice = atoi(buff);
if(Print_Object(ichoice ? ichoice - 1 : -1)){		if(Print_Object(ichoice ? ichoice - 1 : -1)) {
Message::Check("E n d C h e c k i n g\n");		Message::Check("E n d C h e c k i n g\n");
return;		return;
}		}
}		}
}		}
void Print_ListResolution(int choose, int Flag_LRES, char **name)		void Print_ListResolution(int choose, int Flag_LRES, char **name)
{		{
struct Resolution *RE;		struct Resolution *RE;
int ichoice = 0;		int ichoice = 0;
char buff[128];		char buff[128];
bool print = (!choose || (!Message::UseSocket() && !Message::UseOnelab()));		bool print = (!choose || (!Message::UseSocket() && !Message::UseOnelab()));
std::vector<std::string> choices;		std::vector<std::string> choices;
for (int i = 0; i < List_Nbr(Problem_S.Resolution); i++) {		for(int i = 0; i < List_Nbr(Problem_S.Resolution); i++) {
RE = (struct Resolution*)List_Pointer(Problem_S.Resolution, i);		RE = (struct Resolution *)List_Pointer(Problem_S.Resolution, i);
if(!RE->Hidden) choices.push_back(RE->Name);		if(!RE->Hidden) choices.push_back(RE->Name);
}		}
if(choices.size()){		if(choices.size()) {
if(Flag_LRES < 0){		if(Flag_LRES < 0) { ichoice = -Flag_LRES; }
ichoice = - Flag_LRES;		else {
}
else{
if(print) Message::Info("Available Resolutions");		if(print) Message::Info("Available Resolutions");
for (unsigned i = 0; i < choices.size(); i++) {		for(unsigned i = 0; i < choices.size(); i++) {
if(print) Message::Direct("(%d) %s", i + 1, choices[i].c_str());		if(print) Message::Direct("(%d) %s", i + 1, choices[i].c_str());
if(Message::UseSocket()) Message::SendOptionOnSocket(1, choices[i].c_str		if(Message::UseSocket())
());		Message::SendOptionOnSocket(1, choices[i].c_str());
}		}
if(Message::UseOnelab() && choices.size()){		if(Message::UseOnelab() && choices.size()) {
Constant c;		Constant c;
c.Name = (char*)"ResolutionChoices";		c.Name = (char *)"ResolutionChoices";
c.Type = VAR_CHAR;		c.Type = VAR_CHAR;
c.Value.Char = strSave(choices[0].c_str());		c.Value.Char = strSave(choices[0].c_str());
std::map<std::string, std::vector<double> > floatOptions;		std::map<std::string, std::vector<double> > floatOptions;
// force *not* read-only here, in case the parameter already exists *as		// force *not* read-only here, in case the parameter already exists *as
// read-only* in the DB, in which case we do want to keep the value		// read-only* in the DB, in which case we do want to keep the value
// from the server		// from the server
floatOptions["ReadOnly"].push_back(0);		floatOptions["ReadOnly"].push_back(0);
std::map<std::string, std::vector<std::string> > charOptions;		std::map<std::string, std::vector<std::string> > charOptions;
charOptions["Choices"] = choices;		charOptions["Choices"] = choices;
charOptions["Name"].push_back(Message::GetOnelabClientName() + "/1Resolu		charOptions["Name"].push_back(Message::GetOnelabClientName() +
tionChoices");		"/1ResolutionChoices");
charOptions["Label"].push_back("Resolution");		charOptions["Label"].push_back("Resolution");
Message::ExchangeOnelabParameter(&c, floatOptions, charOptions);		Message::ExchangeOnelabParameter(&c, floatOptions, charOptions);
if(choose){		if(choose) {
*name = c.Value.Char;		*name = c.Value.Char;
return;		return;
}		}
}		}
if(choose){		if(choose) {
Message::Check("Choice: ");		Message::Check("Choice: ");
if(fgets(buff, 128, stdin))		if(fgets(buff, 128, stdin)) ichoice = atoi(buff);
ichoice = atoi(buff);
}		}
}		}
if(ichoice > 0 && ichoice < (int)choices.size() + 1){		if(ichoice > 0 && ichoice < (int)choices.size() + 1) {
*name = strSave(choices[ichoice - 1].c_str());		*name = strSave(choices[ichoice - 1].c_str());
return;		return;
}		}
else if(choose)		else if(choose)
Message::Error("Unknown Resolution");		Message::Error("Unknown Resolution");
}		}
else		else
Message::Info("No Resolution available");		Message::Info("No Resolution available");
}		}
skipping to change at line 2062		skipping to change at line 2138
{		{
std::string::size_type beg = s.find_first_not_of(' ');		std::string::size_type beg = s.find_first_not_of(' ');
std::string::size_type end = s.find_last_not_of(' ');		std::string::size_type end = s.find_last_not_of(' ');
if(beg == std::string::npos || end == std::string::npos) return "";		if(beg == std::string::npos || end == std::string::npos) return "";
return s.substr(beg, end + 1 - beg);		return s.substr(beg, end + 1 - beg);
}		}
void Print_ListPostOperation(int choose, int Flag_LPOS, char *name[NBR_MAX_POS])		void Print_ListPostOperation(int choose, int Flag_LPOS, char *name[NBR_MAX_POS])
{		{
struct PostOperation *PO;		struct PostOperation *PO;
int ichoice = 0;		int ichoice = 0;
char buff[128];		char buff[128];
bool print = (!choose || (!Message::UseSocket() && !Message::UseOnelab()));		bool print = (!choose || (!Message::UseSocket() && !Message::UseOnelab()));
std::vector<std::string> choices;		std::vector<std::string> choices;
for (int i = 0; i < List_Nbr(Problem_S.PostOperation); i++) {		for(int i = 0; i < List_Nbr(Problem_S.PostOperation); i++) {
PO = (struct PostOperation*)List_Pointer(Problem_S.PostOperation, i);		PO = (struct PostOperation *)List_Pointer(Problem_S.PostOperation, i);
if(!PO->Hidden) choices.push_back(PO->Name);		if(!PO->Hidden) choices.push_back(PO->Name);
}		}
if(choices.size()){		if(choices.size()) {
if(Flag_LPOS < 0){		if(Flag_LPOS < 0) { ichoice = -Flag_LPOS; }
ichoice = - Flag_LPOS;		else {
}
else{
if(print) Message::Info("Available PostOperations");		if(print) Message::Info("Available PostOperations");
for (unsigned i = 0; i < choices.size(); i++) {		for(unsigned i = 0; i < choices.size(); i++) {
if(print) Message::Direct("(%d) %s", i + 1, choices[i].c_str());		if(print) Message::Direct("(%d) %s", i + 1, choices[i].c_str());
if(Message::UseSocket()) Message::SendOptionOnSocket(2, choices[i].c_str(		if(Message::UseSocket())
));		Message::SendOptionOnSocket(2, choices[i].c_str());
}		}
if(Message::UseOnelab() && choices.size()){		if(Message::UseOnelab() && choices.size()) {
Constant c;		Constant c;
c.Name = (char*)"PostOperationChoices";		c.Name = (char *)"PostOperationChoices";
c.Type = VAR_CHAR;		c.Type = VAR_CHAR;
c.Value.Char = strSave(choices[0].c_str());		c.Value.Char = strSave(choices[0].c_str());
std::map<std::string, std::vector<double> > floatOptions;		std::map<std::string, std::vector<double> > floatOptions;
// force *not* read-only here, in case the parameter already exists *as		// force *not* read-only here, in case the parameter already exists *as
// read-only* in the DB, in which case we do want to keep the value		// read-only* in the DB, in which case we do want to keep the value
// from the server		// from the server
floatOptions["ReadOnly"].push_back(0);		floatOptions["ReadOnly"].push_back(0);
std::map<std::string, std::vector<std::string> > charOptions;		std::map<std::string, std::vector<std::string> > charOptions;
charOptions["Choices"] = choices;		charOptions["Choices"] = choices;
charOptions["Name"].push_back(Message::GetOnelabClientName() + "/2PostOp		charOptions["Name"].push_back(Message::GetOnelabClientName() +
erationChoices");		"/2PostOperationChoices");
charOptions["Label"].push_back("Post-processing");		charOptions["Label"].push_back("Post-processing");
charOptions["MultipleSelection"].push_back("0");		charOptions["MultipleSelection"].push_back("0");
Message::ExchangeOnelabParameter(&c, floatOptions, charOptions);		Message::ExchangeOnelabParameter(&c, floatOptions, charOptions);
if(choose){		if(choose) {
std::string str(c.Value.Char);		std::string str(c.Value.Char);
int i = 0;		int i = 0;
std::string::size_type first = 0;		std::string::size_type first = 0;
while(1){		while(1) {
std::string::size_type last = str.find_first_of(",", first);		std::string::size_type last = str.find_first_of(",", first);
std::string next = str.substr(first, last - first);		std::string next = str.substr(first, last - first);
name[i++] = strSave(removeWhiteSpace(next).c_str());		name[i++] = strSave(removeWhiteSpace(next).c_str());
if(last == std::string::npos) break;		if(last == std::string::npos) break;
first = last + 1;		first = last + 1;
if(i == NBR_MAX_POS - 1) break;		if(i == NBR_MAX_POS - 1) break;
}		}
name[i] = NULL;		name[i] = NULL;
return;		return;
}		}
}		}
if(choose){		if(choose) {
Message::Check("Choice: ");		Message::Check("Choice: ");
if(fgets(buff, 128, stdin))		if(fgets(buff, 128, stdin)) ichoice = atoi(buff);
ichoice = atoi(buff);
}		}
}		}
if(ichoice > 0 && ichoice < (int)choices.size() + 1){		if(ichoice > 0 && ichoice < (int)choices.size() + 1) {
name[0] = strSave(choices[ichoice - 1].c_str());		name[0] = strSave(choices[ichoice - 1].c_str());
name[1] = NULL;		name[1] = NULL;
return;		return;
}		}
else if(choose)		else if(choose)
Message::Error("Unknown PostOperation");		Message::Error("Unknown PostOperation");
}		}
else		else
Message::Info("No PostOperation available");		Message::Info("No PostOperation available");
}		}
End of changes. 310 change blocks.
1175 lines changed or deleted		1123 lines changed or added

---