Merged Netgen 4.3.1: a Delaunay/Frontal 2D/3D mesh generator.

Thanks a lot to Nicolas Tardieu for this!

Netgen/libsrc/csg/geometry.h

+#ifndef BISON_GEOMETRY_H
+# define BISON_GEOMETRY_H
+
+#ifndef YYSTYPE
+typedef union {
+double val;
+char * chptr;
+Solid * solidtype;
+} yystype;
+# define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+# define	NUM	257
+# define	TOK_SOLID	258
+# define	TOK_RECO	259
+# define	TOK_TLO	260
+# define	TOK_BOUNDINGBOX	261
+# define	IDENT	262
+# define	IDENTSOLID	263
+# define	TOK_SPHERE	264
+# define	TOK_CYLINDER	265
+# define	TOK_CONE	266
+# define	TOK_PLAIN	267
+# define	TOK_TUBE	268
+# define	TOK_GENCYL	269
+# define	TOK_ORTHOBRICK	270
+# define	TOK_POLYHEDRON	271
+# define	TOK_REVOLUTION	272
+# define	TOK_OR	273
+# define	TOK_AND	274
+# define	TOK_NOT	275
+# define	TOK_TRANSLATE	276
+# define	TOK_MULTITRANSLATE	277
+# define	TOK_ROTATE	278
+# define	TOK_MULTIROTATE	279
+# define	TOK_SINGULAR	280
+# define	TOK_EDGE	281
+# define	TOK_POINT	282
+# define	TOK_IDENTIFY	283
+# define	TOK_CLOSESURFACES	284
+# define	TOK_CLOSEEDGES	285
+# define	TOK_PERIODIC	286
+# define	TOK_BOUNDARYCONDITION	287
+
+
+extern YYSTYPE yylval;
+
+#endif /* not BISON_GEOMETRY_H */

Netgen/libsrc/csg/geometry.ll

+%{
+#include <mystdlib.h>
+#include <myadt.hpp> 
+
+#include <linalg.hpp> 
+#include <csg.hpp>
+
+
+
+
+// extern SYMBOLTABLE<Solid*> solids;
+namespace netgen {
+extern CSGeometry * parsegeom;
+}
+using namespace netgen;
+
+#include "geometry.h"
+
+
+ARRAY<char*> parsestrings;
+int linenum;
+%}
+
+dig     [0-9]
+id      [a-zA-Z][a-zA-Z0-9]*
+num1    [-+]?{dig}+\.?([eE][-+]?{dig}+)?
+num2    [-+]?{dig}*\.{dig}+([eE][-+]?{dig}+)?
+number  {num1}|{num2}
+%x      incl
+%x      comment
+
+%%
+algebraic3d     { return TOK_RECO; }
+solid           { return TOK_SOLID; }
+tlo		{ return TOK_TLO; }
+and             { return TOK_AND; }
+or              { return TOK_OR; }
+not             { return TOK_NOT; }
+translate	{ return TOK_TRANSLATE; }
+multitranslate	{ return TOK_MULTITRANSLATE; }
+rotate		{ return TOK_ROTATE; }
+multirotate	{ return TOK_MULTIROTATE; }
+sphere          { return TOK_SPHERE; }
+cylinder        { return TOK_CYLINDER; }
+cone		{ return TOK_CONE; }
+plain           { return TOK_PLAIN; }
+plane		{ return TOK_PLAIN; }
+tube	 	{ return TOK_TUBE; }
+gencyl		{ return TOK_GENCYL; }
+orthobrick	{ return TOK_ORTHOBRICK; }
+polyhedron	{ return TOK_POLYHEDRON; }
+revolution	{ return TOK_REVOLUTION; }
+
+singular	{ return TOK_SINGULAR; }
+edge		{ return TOK_EDGE; }
+point		{ return TOK_POINT; }
+
+identify	{ return TOK_IDENTIFY; }
+closesurfaces 	{ return TOK_CLOSESURFACES; }
+closeedges 	{ return TOK_CLOSEEDGES; }
+periodic	{ return TOK_PERIODIC; }
+boundarycondition { return TOK_BOUNDARYCONDITION; }
+boundingbox	{ return TOK_BOUNDINGBOX; }
+
+{number}        { yylval.val = atof (YYText()); return NUM; }
+{id}+           {
+                  yylval.chptr = new char [YYLeng()+1];
+		  parsestrings.Append (yylval.chptr);
+                  strcpy (yylval.chptr, YYText());
+                  if (parsegeom->GetSolid (yylval.chptr))
+                    return IDENTSOLID;
+                  else
+                    return IDENT;
+                }
+[ \t]             /* eat up ws */
+.               { return int(*YYText()); }
+\n		{ linenum++; }
+"##".*\n        { linenum++; cout << (YYText()+2) ; }  /* line comment */
+"#".*\n        { linenum++; }  /* line comment */
+
+
+%%
+
+extern FlexLexer * lexer;
+
+int yylex ()
+  {
+  return lexer -> yylex();
+  }
+
+extern "C" int yywrap ()
+  {
+  return 1;
+  }

Netgen/libsrc/csg/geometry.yy

+%{
+//define YYDEBUG 1
+
+extern int yylex ();
+
+#include <mystdlib.h>
+
+#include <myadt.hpp>
+
+#include <linalg.hpp>
+#include <csg.hpp>
+
+namespace netgen
+{
+netgen::CSGeometry * parsegeom;
+}
+
+using namespace netgen;
+
+// extern ARRAY<Surface*> surfaces;
+// extern SYMBOLTABLE<Solid*> solids;
+
+
+int yyerror (char * s);
+splinetube * tube;
+spline3d * middlecurve;
+Point<3> splinep1;
+BSplineCurve2d *bspline;
+Flags parseflags;
+extern int linenum;
+ARRAY<double> doublearray;
+ARRAY<char*> stringarray;
+
+Polyhedra * polyhedron;
+// Revolution * revolution;
+%}
+
+%union {
+double val;
+char * chptr;
+Solid * solidtype;
+}
+
+%token <val> NUM
+%token TOK_SOLID, TOK_RECO, TOK_TLO, TOK_BOUNDINGBOX
+%token <chptr> IDENT IDENTSOLID
+%token <solidtype> TOK_SPHERE TOK_CYLINDER TOK_CONE TOK_PLAIN TOK_TUBE TOK_GENCYL TOK_ORTHOBRICK TOK_POLYHEDRON TOK_REVOLUTION
+%left <solidtype> TOK_OR TOK_AND TOK_NOT
+%token <solidtype> TOK_TRANSLATE TOK_MULTITRANSLATE TOK_ROTATE TOK_MULTIROTATE
+%type <solidtype> solid solidprimitive 
+%type <void> splinesegmentlist splinesegment readbspline bsplinepointlist
+%type <chptr> anyident
+%token TOK_SINGULAR TOK_EDGE TOK_POINT
+%token TOK_IDENTIFY TOK_CLOSESURFACES TOK_CLOSEEDGES TOK_PERIODIC
+%token TOK_BOUNDARYCONDITION
+%type <void> polyhedronpoints polyhedronfaces polyhedronpoint polyhedronface
+%type <void> revolutionpoints revolutionpoint
+
+
+%%
+input: 	
+		{
+		  linenum = 1;
+		}
+	TOK_RECO
+	recsoliddef
+	recadddef
+	
+		{
+		int i;
+		extern ARRAY<char*> parsestrings;
+		for (i = 0; i < parsestrings.Size(); i++)
+ 		  delete [] parsestrings[i];
+		parsestrings.SetSize(0);
+		}
+	;
+
+
+recsoliddef:
+	/* empty */
+        | recsoliddef soliddef ';'
+        ;
+
+soliddef:
+          TOK_SOLID IDENT '=' solid
+                  { parsegeom->SetSolid($2, new Solid (Solid::ROOT, $4)); 
+		  }
+	  flaglist
+		  { 
+		  parsegeom->SetFlags($2, parseflags); 
+		  }		
+        ;
+
+solid:
+          solidprimitive
+        | IDENTSOLID              { $$ = (Solid*)parsegeom->GetSolid($1);  }
+        | solid TOK_OR solid      { $$ = new Solid (Solid::UNION, $1, $3); }
+        | solid TOK_AND solid     { $$ = new Solid (Solid::SECTION, $1, $3); }
+        | TOK_NOT solid           { $$ = new Solid (Solid::SUB, $2); }
+        | '(' solid ')'           { $$ = $2; }
+        ;
+
+solidprimitive:
+          TOK_SPHERE '(' NUM ',' NUM ',' NUM ';'
+                         NUM ')'
+                 { 
+		   OneSurfacePrimitive * surf = new Sphere (Point<3> ($3, $5, $7), $9); 
+		   parsegeom -> AddSurface (surf);
+		   surf->SetSurfaceId (0, parsegeom->GetNSurf()-1);
+                   $$ = new Solid (surf);
+                 }
+        | TOK_CYLINDER '(' NUM ',' NUM ',' NUM ';'
+                           NUM ',' NUM ',' NUM ';'
+                           NUM ')'
+
+                 {
+		   OneSurfacePrimitive * surf = new Cylinder (Point<3> ($3, $5, $7),
+	                                       Point<3> ($9, $11, $13), $15);
+		   parsegeom->AddSurface (surf);
+		   surf->SetSurfaceId (0, parsegeom->GetNSurf()-1);
+                   $$ = new Solid (surf);
+                 }
+        | TOK_CONE '(' NUM ',' NUM ',' NUM ';'
+                       NUM ';' 
+                       NUM ',' NUM ',' NUM ';'
+                       NUM ')'
+
+                 {
+		   OneSurfacePrimitive * surf = new Cone (Point<3> ($3, $5, $7),
+	                                     	 Point<3> ($11, $13, $15), $9, $17);
+		   parsegeom->AddSurface (surf);
+		   surf->SetSurfaceId (0, parsegeom->GetNSurf()-1);
+                   $$ = new Solid (surf);
+                 }
+        | TOK_PLAIN '(' NUM ',' NUM ',' NUM ';'
+                           NUM ',' NUM ',' NUM ')'
+                 {
+		   OneSurfacePrimitive * surf = new Plane ( Point<3> ($3, $5, $7),
+	                                        Vec<3> ($9, $11, $13) );
+		   parsegeom->AddSurface (surf);
+		   surf->SetSurfaceId (0, parsegeom->GetNSurf()-1);
+                   $$ = new Solid (surf);
+                 }
+	| TOK_ORTHOBRICK  '(' NUM ',' NUM ',' NUM ';'
+	                      NUM ',' NUM ',' NUM ')'
+		{
+		  Primitive * nprim = new OrthoBrick (Point<3> ($3, $5, $7),
+		                                      Point<3> ($9, $11, $13));
+                  for (int j = 0; j < nprim->GetNSurfaces(); j++)
+		    {
+		      parsegeom->AddSurface (&nprim->GetSurface(j));
+		      nprim->SetSurfaceId (j, parsegeom->GetNSurf()-1);
+		      $$ = new Solid (nprim);
+		    }
+		} 
+
+
+	| TOK_POLYHEDRON '(' 
+		{
+		  polyhedron = new Polyhedra ();
+		}
+		polyhedronpoints ';' ';'
+		polyhedronfaces ')'
+		{
+		  int j;
+                  for (j = 0; j < polyhedron->GetNSurfaces(); j++)
+		    {
+		      parsegeom->AddSurface (&polyhedron->GetSurface(j));
+		      polyhedron->SetSurfaceId (j, parsegeom->GetNSurf()-1);
+		      $$ = new Solid (polyhedron);
+		    }	
+		}
+
+
+/*
+	| TOK_REVOLUTION '(' NUM ',' NUM ',' NUM ';'
+	                     NUM ',' NUM ',' NUM ';' 
+		{
+                    revolution = new Revolution (Point<3> ($3, $5, $7),
+						 Point<3> ($9, $11, $13));
+		}
+ 		    revolutionpoints
+			  ')'
+	        {
+		  revolution -> Finish ();
+		  int j;
+                  for (j = 0; j < revolution->GetNSurfaces(); j++)
+		    {
+		      parsegeom->AddSurface (&revolution->GetSurface(j));
+		      revolution->SetSurfaceId (j, parsegeom->GetNSurf()-1);
+		      $$ = new Solid (revolution);
+		    }	
+	        }
+*/
+
+
+	| TOK_TRANSLATE  '(' NUM ',' NUM ',' NUM ';' solid ')'
+		{
+                  Solid * nsol = $9 -> Copy(*parsegeom);
+                  Vec<3> v($3, $5, $7);
+                  Transformation<3> trans(v);
+		  nsol -> Transform (trans);
+                  $$ = nsol;
+		}
+
+	| TOK_MULTITRANSLATE  '(' NUM ',' NUM ',' NUM ';' NUM ';' solid ')'
+		{
+		  int i;
+                  Solid * hsol = $11;
+	          for (i = 1; i <= $9; i++)
+                    {
+                      Solid * nsol = $11 -> Copy(*parsegeom);
+                      Vec<3> v($3, $5, $7);
+		      v *= i;
+                      Transformation<3> trans(v);
+		      nsol -> Transform (trans);
+                      hsol = new Solid (Solid::UNION, hsol, nsol); 
+                    }
+		  $$ = hsol;
+		}
+
+	| TOK_ROTATE  '(' NUM ',' NUM ',' NUM ';' NUM ',' NUM ',' NUM ';' solid ')'
+		{
+                  Solid * nsol = $15 -> Copy(*parsegeom);
+                  Point<3> c($3, $5, $7);
+                  Transformation<3> rot(c, $9, $11, $13);
+		  nsol -> Transform (rot);
+                  $$ = nsol;
+		}
+
+	| TOK_MULTIROTATE  '(' NUM ',' NUM ',' NUM ';'
+			       NUM ',' NUM ',' NUM ';'
+			       NUM ';' solid ')'
+		{
+		  int i;
+                  Solid * hsol = $17;                      
+
+		  Point<3> c($3, $5, $7);
+                  Transformation<3> trans(c, $9, $11, $13);
+		  Transformation<3> multi(Vec<3>(0,0,0));
+		  Transformation<3> ht;
+
+	          for (i = 1; i <= $15; i++)
+                    {
+                      Solid * nsol = $17 -> Copy(*parsegeom);
+		      nsol -> Transform (multi);
+                      hsol = new Solid (Solid::UNION, hsol, nsol); 
+
+		      ht=multi;
+                      multi.Combine (trans, ht);
+                    }
+		  $$ = hsol;
+		}
+
+
+/*
+	| TOK_TUBE '(' NUM ',' NUM ',' NUM ','
+		{
+		middlecurve = new spline3d;
+		splinep1.X() = $3; splinep1.Y() = $5; splinep1.Z() = $7;
+		}
+	 splinesegmentlist ';' NUM ')'
+		{
+		   Surface * surf = new splinetube (*middlecurve, $12);
+		   parsegeom->AddSurface (surf);
+                   $$ = new Solid (surf, parsegeom->GetNSurf());
+		}
+		
+	| TOK_GENCYL '(' NUM ',' NUM ',' NUM ';'
+	                 NUM ',' NUM ',' NUM ';' 
+	                 NUM ',' NUM ',' NUM ';'
+			readbspline
+			')'
+	        {
+		   Surface * surf = new GeneralizedCylinder
+	           (*bspline, Point<3> ($3, $5, $7), Vec<3> ($9, $11, $13),
+	             Vec<3> ($15, $17, $19) );
+		   parsegeom->AddSurface (surf);
+                   $$ = new Solid (surf, parsegeom->GetNSurf());
+	        }
+*/	             
+	;
+
+
+polyhedronpoints:
+	  polyhedronpoints ';' polyhedronpoint
+	| polyhedronpoint
+	;
+polyhedronfaces:
+	  polyhedronfaces ';' polyhedronface
+	| polyhedronface
+	;
+polyhedronpoint:
+	  NUM ',' NUM ',' NUM
+	{
+		polyhedron->AddPoint (Point<3> ($1, $3, $5));
+ 		cout << " " << $1 << " " << $3 << " " << $5 << endl;
+	}
+	;
+polyhedronface:
+	  NUM ',' NUM ',' NUM
+ 	{ 
+		polyhedron->AddFace (int($1)-1, int($3)-1, int($5)-1);
+		cout << $1 << " " << $3 << " " << $5 << endl; 
+	}
+	| NUM ',' NUM ',' NUM ',' NUM
+ 	{ 	
+		cout << "face, 1 = " << $1 << " " << $3 << " "  << $5 << " " << $7 << endl; 
+		polyhedron->AddFace (int($1)-1, int($3)-1, int($5)-1);
+		polyhedron->AddFace (int($1)-1, int($5)-1, int($7)-1);
+		cout << $1 << $3 << $5 << $7 << endl; 
+	}
+	;
+
+revolutionpoints:
+	  revolutionpoints ';' revolutionpoint
+	| revolutionpoint
+	;
+revolutionpoint:
+	  NUM ',' NUM 
+	{
+//		revolution->AddPoint (Point<2> ($1, $3));
+ 		cout << " " << $1 << " " << $3 << endl;
+	}
+	;
+
+
+
+
+	
+splinesegmentlist:
+	  splinesegment
+        | splinesegment ',' splinesegmentlist
+	;
+splinesegment:
+	  NUM ',' NUM ',' NUM ','
+	  NUM ',' NUM ',' NUM
+	 	{
+	        middlecurve->AddSegment (splinep1, Point<3> ($1, $3, $5), Point<3> ($7, $9, $11));
+		splinep1(0) = $7; splinep1(1) = $9; splinep1(2) = $11;
+		}
+	;
+	
+	
+readbspline:
+          NUM ',' NUM
+                {
+                bspline = new BSplineCurve2d;
+                bspline -> AddPoint (Point<2> ($1, $3));
+		cout << "first point" << endl;
+                }
+          bsplinepointlist
+        ;
+bsplinepointlist: 
+          /* empty */ { } 
+        | ',' NUM ',' NUM
+               {
+               bspline -> AddPoint (Point<2> ($2, $4));
+		cout << "Add Point: " << $2 << "-" << $4 << endl;
+               }
+          bsplinepointlist
+        ;
+
+
+
+
+
+
+
+
+
+recadddef:
+	/* empty */
+        | recadddef adddef ';'
+        ;
+
+adddef:
+	TOK_SINGULAR TOK_EDGE  NUM IDENTSOLID IDENTSOLID
+	{ cout << "singular edge:" << $3 << " between "
+		 << $4 << " and " << $5 << endl; 
+	  parsegeom->singedges.Append 
+	    (new SingularEdge ($3, parsegeom->GetSolid($4), 
+				parsegeom->GetSolid($5)));
+	}
+	|
+	TOK_SINGULAR TOK_POINT  NUM IDENTSOLID IDENTSOLID IDENTSOLID
+	{ cout << "singular point:" << $3 << " between "
+		 << $4 << ", " << $5 << " and " << $6 << endl; 
+	  parsegeom->singpoints.Append 
+	    (new SingularPoint ($3, parsegeom->GetSolid($4), 
+				parsegeom->GetSolid($5),
+				parsegeom->GetSolid($6)));
+	}
+	|
+	TOK_IDENTIFY TOK_CLOSESURFACES IDENTSOLID IDENTSOLID flaglist
+	{ 	
+	  ARRAY<int> si1, si2;
+	  parsegeom->GetSolid($3)->GetSurfaceIndices(si1);
+	  parsegeom->GetSolid($4)->GetSurfaceIndices(si2);
+
+	  parsegeom->AddIdentification (
+		new CloseSurfaceIdentification (
+			parsegeom->GetNIdentifications()+1,
+			*parsegeom, 
+			parsegeom->GetSurface (si1[0]),
+			parsegeom->GetSurface (si2[0]),
+			parseflags));
+	}
+	|
+	TOK_IDENTIFY TOK_CLOSEEDGES IDENTSOLID IDENTSOLID IDENTSOLID
+	{ 	
+	  ARRAY<int> si1, si2, si3;
+	  parsegeom->GetSolid($3)->GetSurfaceIndices(si1);
+	  parsegeom->GetSolid($4)->GetSurfaceIndices(si2);
+	  parsegeom->GetSolid($5)->GetSurfaceIndices(si3);
+
+	  parsegeom->AddIdentification (
+		new CloseEdgesIdentification (
+			parsegeom->GetNIdentifications()+1,
+			*parsegeom, 
+			parsegeom->GetSurface (si1.Get(1)),
+			parsegeom->GetSurface (si2.Get(1)),
+			parsegeom->GetSurface (si3.Get(1))));
+	}
+	|
+	TOK_IDENTIFY TOK_PERIODIC IDENTSOLID IDENTSOLID 
+	{ 
+	  ARRAY<int> si1, si2;
+	  parsegeom->GetSolid($3)->GetSurfaceIndices(si1);
+	  parsegeom->GetSolid($4)->GetSurfaceIndices(si2);
+
+	  parsegeom->AddIdentification (
+		new PeriodicIdentification (
+			parsegeom->GetNIdentifications()+1,
+			*parsegeom,
+			parsegeom->GetSurface (si1.Get(1)),
+			parsegeom->GetSurface (si2.Get(1))));
+	}
+	| 
+	TOK_TLO IDENTSOLID flaglist
+	{
+	  int tlonr = 
+            parsegeom->SetTopLevelObject ((Solid*)parsegeom->GetSolid($2));
+	  TopLevelObject * tlo = parsegeom->GetTopLevelObject (tlonr);
+	  if (parseflags.NumListFlagDefined ("col"))
+	    {
+	      const ARRAY<double> & col = parseflags.GetNumListFlag ("col");
+	      tlo->SetRGB (col[0], col[1], col[2]);
+	    }
+	  if (parseflags.GetDefineFlag ("transparent"))
+	    tlo->SetTransparent (1);
+	}
+	|
+	TOK_TLO IDENTSOLID IDENTSOLID flaglist
+	{
+	  ARRAY<int> si;
+	  parsegeom->GetSolid($3)->GetSurfaceIndices(si);
+	  int tlonr = 
+	    parsegeom->SetTopLevelObject ((Solid*)parsegeom->GetSolid($2),
+					  (Surface*)parsegeom->GetSurface(si.Get(1)));
+	  TopLevelObject * tlo = parsegeom->GetTopLevelObject (tlonr);
+	  if (parseflags.NumListFlagDefined ("col"))
+	    {
+	      const ARRAY<double> & col = parseflags.GetNumListFlag ("col");
+	      tlo->SetRGB (col.Get(1), col.Get(2), col.Get(3));
+	    }
+	  if (parseflags.GetDefineFlag ("transparent"))
+	    tlo->SetTransparent (1);
+	}
+	|
+	TOK_BOUNDINGBOX '(' NUM ',' NUM ',' NUM ';' 
+			    NUM ',' NUM ',' NUM ')'
+	{
+	  parsegeom->SetBoundingBox (Box<3> (Point<3> ($3, $5, $7), 
+                                             Point<3> ($9, $11, $13)));
+	}
+	| 
+	TOK_POINT '(' NUM ',' NUM ',' NUM ')' 
+	{
+	  parsegeom->AddUserPoint (Point<3> ($3, $5, $7));
+	}
+	|
+	TOK_BOUNDARYCONDITION IDENTSOLID IDENTSOLID NUM
+	{
+  	  CSGeometry::BCModification bcm;
+	  ARRAY<int> si;
+
+	  parsegeom->GetSolid($2)->GetSurfaceIndices(si);
+	
+          bcm.tlonr = -1;
+	  int i;	
+	  for (i = 0; i < parsegeom->GetNTopLevelObjects(); i++)
+	    if (strcmp (parsegeom->GetTopLevelObject(i)->GetSolid()->Name(), $3) == 0)
+	      {
+	        bcm.tlonr = i;
+	        break;
+              }
+
+	  bcm.bcnr = int($4);
+	  for (i = 0; i < si.Size(); i++)
+            {
+	      bcm.si = si[i];
+              parsegeom->bcmodifications.Append (bcm);
+            }
+	}
+	;	
+
+
+
+
+flaglist:
+	      { parseflags.DeleteFlags (); }
+	  recflaglist
+	;
+
+recflaglist:
+	  /* empty */
+	| flag recflaglist
+	;
+	
+flag:
+	  '-' anyident
+	                   { parseflags.SetFlag ($2); }
+	| '-' anyident '=' anyident
+	                   { parseflags.SetFlag ($2, $4); }
+	| '-' anyident '=' NUM
+	                   { parseflags.SetFlag ($2, $4); }
+	| '-' anyident '=' numlistbrack
+			   { parseflags.SetFlag ($2, doublearray); }
+	| '-' anyident '=' stringlistbrack
+			   { parseflags.SetFlag ($2, stringarray); }
+	;     	
+
+
+numlistbrack:
+	  '['   			{ doublearray.SetSize (0); }
+	   numlist ']'
+	;
+
+numlist:
+          NUM                        { doublearray.Append ($1); }
+        | numlist ',' NUM            { doublearray.Append ($3); }
+        ;
+
+stringlistbrack:
+	'['
+	{
+	  int i;
+	  for (i = 0; i < stringarray.Size(); i++)
+	     delete stringarray[i];
+	  stringarray.SetSize (0);
+	}
+	  stringlist  ']'
+	;
+
+stringlist:
+	  anyident
+	        {
+			stringarray.Append (new char[strlen($1)+1]);
+			strcpy (stringarray.Last(), $1);
+		}
+					
+	| stringlist ',' anyident
+           	{
+			stringarray.Append (new char[strlen($3)+1]);
+			strcpy (stringarray.Last(), $3);
+		}
+	;
+
+
+
+
+
+anyident:
+	  IDENT            { $$ = $1; }
+	| IDENTSOLID       { $$ = $1; }
+%%
+
+
+int yyerror (char * s)
+{	
+  cerr << s << " in line " << linenum << endl;
+  return 0;
+}
+

Netgen/libsrc/general/stack.icc

+/*****************************************************************************/
+/*  File: stack.hh                                                           */
+/*  Author: Wolfram Muehlhuber                                               */
+/*  Date: September 98                                                       */
+/*****************************************************************************/
+
+/*
+  
+  Stack class, based on a resizable array
+
+ */
+
+template <class T>
+inline STACK<T> :: STACK (INDEX asize, INDEX ainc)
+  : elems(asize, ainc)
+{
+  size = 0;
+}
+
+
+template <class T>
+inline STACK<T> :: ~STACK ()
+{
+  ;
+}
+
+
+template <class T> 
+inline void STACK<T> :: Push (const T & el)
+{
+  if (size < elems.Size())
+    elems.Elem(++size) = el;
+  else
+    {
+      elems.Append(el);
+      size++;
+    }
+}
+
+
+template <class T> 
+inline T & STACK<T> :: Pop ()
+{
+  return elems.Elem(size--);
+}
+
+
+template <class T>
+const inline T & STACK<T> :: Top () const
+{
+  return elems.Get(size);
+}
+
+template <class T>
+inline int STACK<T> :: IsEmpty () const
+{
+  return (size == 0);
+}
+
+
+template <class T>
+inline void STACK<T> :: MakeEmpty ()
+{
+  size = 0;
+}
+
+

Netgen/libsrc/include/FlexLexer.h

+// $Header: /cvsroot/gmsh/Netgen/libsrc/include/FlexLexer.h,v 1.1 2004-06-26 18:03:24 geuzaine Exp $
+
+// FlexLexer.h -- define interfaces for lexical analyzer classes generated
+//		  by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+// Redistribution and use in source and binary forms are permitted provided
+// that: (1) source distributions retain this entire copyright notice and
+// comment, and (2) distributions including binaries display the following
+// acknowledgement:  ``This product includes software developed by the
+// University of California, Berkeley and its contributors'' in the
+// documentation or other materials provided with the distribution and in
+// all advertising materials mentioning features or use of this software.
+// Neither the name of the University nor the names of its contributors may
+// be used to endorse or promote products derived from this software without
+// specific prior written permission.
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+// This file defines FlexLexer, an abstract class which specifies the
+// external interface provided to flex C++ lexer objects, and yyFlexLexer,
+// which defines a particular lexer class.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// to rename each yyFlexLexer to some other xxFlexLexer.  You then
+// include <FlexLexer.h> in your other sources once per lexer class:
+//
+//	#undef yyFlexLexer
+//	#define yyFlexLexer xxFlexLexer
+//	#include <FlexLexer.h>
+//
+//	#undef yyFlexLexer
+//	#define yyFlexLexer zzFlexLexer
+//	#include <FlexLexer.h>
+//	...
+
+#ifndef __FLEX_LEXER_H
+// Never included before - need to define base class.
+#define __FLEX_LEXER_H
+
+
+extern "C++" {
+struct yy_buffer_state;
+typedef int yy_state_type;
+
+class FlexLexer {
+public:
+	virtual ~FlexLexer()	{ }
+
+	const char* YYText()	{ return yytext; }
+	int YYLeng()		{ return yyleng; }
+
+	virtual void
+		yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
+	virtual struct yy_buffer_state*
+		yy_create_buffer( istream* s, int size ) = 0;
+	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
+	virtual void yyrestart( istream* s ) = 0;
+
+	virtual int yylex() = 0;
+
+	// Call yylex with new input/output sources.
+	int yylex( istream* new_in, ostream* new_out = 0 )
+		{
+		switch_streams( new_in, new_out );
+		return yylex();
+		}
+
+	// Switch to new input/output streams.  A nil stream pointer
+	// indicates "keep the current one".
+	virtual void switch_streams( istream* new_in = 0,
+					ostream* new_out = 0 ) = 0;
+
+	int lineno() const		{ return yylineno; }
+
+	int debug() const		{ return yy_flex_debug; }
+	void set_debug( int flag )	{ yy_flex_debug = flag; }
+
+protected:
+	char* yytext;
+	int yyleng;
+	int yylineno;		// only maintained if you use %option yylineno
+	int yy_flex_debug;	// only has effect with -d or "%option debug"
+};
+
+}
+#endif
+
+#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
+// Either this is the first time through (yyFlexLexerOnce not defined),
+// or this is a repeated include to define a different flavor of
+// yyFlexLexer, as discussed in the flex man page.
+#define yyFlexLexerOnce
+
+class yyFlexLexer : public FlexLexer {
+public:
+	// arg_yyin and arg_yyout default to the cin and cout, but we
+	// only make that assignment when initializing in yylex().
+	yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 );
+
+	virtual ~yyFlexLexer();
+
+	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
+	struct yy_buffer_state* yy_create_buffer( istream* s, int size );
+	void yy_delete_buffer( struct yy_buffer_state* b );
+	void yyrestart( istream* s );
+
+	virtual int yylex();
+	virtual void switch_streams( istream* new_in, ostream* new_out );
+
+protected:
+	virtual int LexerInput( char* buf, int max_size );
+	virtual void LexerOutput( const char* buf, int size );
+	virtual void LexerError( const char* msg );
+
+	void yyunput( int c, char* buf_ptr );
+	int yyinput();
+
+	void yy_load_buffer_state();
+	void yy_init_buffer( struct yy_buffer_state* b, istream* s );
+	void yy_flush_buffer( struct yy_buffer_state* b );
+
+	int yy_start_stack_ptr;
+	int yy_start_stack_depth;
+	int* yy_start_stack;
+
+	void yy_push_state( int new_state );
+	void yy_pop_state();
+	int yy_top_state();
+
+	yy_state_type yy_get_previous_state();
+	yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+	int yy_get_next_buffer();
+
+	istream* yyin;	// input source for default LexerInput
+	ostream* yyout;	// output sink for default LexerOutput
+
+	struct yy_buffer_state* yy_current_buffer;
+
+	// yy_hold_char holds the character lost when yytext is formed.
+	char yy_hold_char;
+
+	// Number of characters read into yy_ch_buf.
+	int yy_n_chars;
+
+	// Points to current character in buffer.
+	char* yy_c_buf_p;
+
+	int yy_init;		// whether we need to initialize
+	int yy_start;		// start state number
+
+	// Flag which is used to allow yywrap()'s to do buffer switches
+	// instead of setting up a fresh yyin.  A bit of a hack ...
+	int yy_did_buffer_switch_on_eof;
+
+	// The following are not always needed, but may be depending
+	// on use of certain flex features (like REJECT or yymore()).
+
+	yy_state_type yy_last_accepting_state;
+	char* yy_last_accepting_cpos;
+
+	yy_state_type* yy_state_buf;
+	yy_state_type* yy_state_ptr;
+
+	char* yy_full_match;
+	int* yy_full_state;
+	int yy_full_lp;
+
+	int yy_lp;
+	int yy_looking_for_trail_begin;
+
+	int yy_more_flag;
+	int yy_more_len;
+	int yy_more_offset;
+	int yy_prev_more_offset;
+};
+
+#endif

Netgen/libsrc/include/mystdlib.h

+#ifndef FILE_MYSTDLIB
+#define FILE_MYSTDLIB
+
+
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+#include <sstream>
+
+#ifdef OLDCINCLUDE
+
+// e.g., CC compiler on SGI
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <malloc.h>
+#include <ctype.h>
+#include <time.h>
+
+#else
+ 
+// new standard
+#include <cstdlib>
+#include <cstdio>
+#include <cmath>
+#include <cctype>
+#include <ctime>
+#endif
+
+
+
+#include <new>
+#include <string>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+
+/*** Windows headers ***/
+#ifdef WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <afxwin.h>
+#include <afxmt.h>
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+#include <winnt.h>
+#endif /* WIN32 */
+
+
+/*
+extern void* operator new(std::size_t) throw (std::bad_alloc);
+extern void* operator new[](std::size_t) throw (std::bad_alloc);
+extern void operator delete(void*) throw();
+extern void operator delete[](void*) throw();
+*/
+
+
+extern int mem_alloc;
+extern int mem_total_alloc;
+extern int mem_max_alloc;
+extern int mem_total_alloc_array;
+extern int mem_total_alloc_table;
+
+
+using namespace std;
+
+#endif

Netgen/libsrc/interface/nginterface.h

+#ifndef NGINTERFACE
+#define NGINTERFACE
+
+/**************************************************************************/
+/* File:   nginterface.hh                                                 */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   20. Nov. 99                                                    */
+/**************************************************************************/
+
+/*
+  
+  Application program interface to Netgen
+  
+
+ */
+
+
+// max number of nodes per element
+#define NG_ELEMENT_MAXPOINTS 12
+
+// max number of nodes per surface element
+#define NG_SURFACE_ELEMENT_MAXPOINTS 6
+
+
+
+// implemented element types:
+enum NG_ELEMENT_TYPE { 
+  NG_SEGM = 1, NG_SEGM3 = 2,
+  NG_TRIG = 10, NG_QUAD=11, NG_TRIG6 = 12, NG_QUAD6 = 13,
+  NG_TET = 20, NG_TET10 = 21, 
+  NG_PYRAMID = 22, NG_PRISM = 23, NG_PRISM12 = 24,
+  NG_HEX = 25
+};
+
+typedef double NG_POINT[3];  // coordinates
+typedef int NG_EDGE[2];      // initial point, end point
+typedef int NG_FACE[4];      // points, last one is 0 for trig
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  
+  // load geomtry from file 
+  void Ng_LoadGeometry (char * filename);
+  
+  // load netgen mesh
+  void Ng_LoadMesh (char * filename);
+
+
+  // space dimension (2 or 3)
+  int Ng_GetDimension ();
+
+  // number of mesh points
+  int Ng_GetNP ();
+  
+  // number of mesh vertices (differs from GetNP for 2nd order elements)
+  int Ng_GetNV ();
+  
+  // number of mesh elements
+  int Ng_GetNE ();
+  
+  // number of surface triangles
+  int Ng_GetNSE ();
+  
+  // Get Point coordintes, index from 1 .. np
+  void Ng_GetPoint (int pi, double * p);
+  
+  // Get Element Points
+  NG_ELEMENT_TYPE Ng_GetElement (int ei, int * epi, int * np = 0);
+
+  // Get Element Type
+  NG_ELEMENT_TYPE Ng_GetElementType (int ei);
+
+  // Get sub-domain of element ei
+  int Ng_GetElementIndex (int ei);
+
+  // Get Material of element ei
+  char * Ng_GetElementMaterial (int ei);
+
+  // Get Surface Element Points
+  NG_ELEMENT_TYPE Ng_GetSurfaceElement (int ei, int * epi, int * np = 0);
+
+  // Get Surface Element Index
+  int Ng_GetSurfaceElementIndex (int ei);
+  
+  // Get normal vector of surface element node
+  void Ng_GetNormalVector (int sei, int locpi, double * nv);     
+  
+
+  // Find element of point, returns local coordinates
+  int Ng_FindElementOfPoint (double * p, double * lami);
+  
+
+  /// Curved Elemens:
+  /// xi..local coordinates
+  /// x ..global coordinates
+  /// dxdxi...D x D Jacobian matrix (row major storage)
+  void Ng_GetElementTransformation (int ei, const double * xi, 
+				    double * x, double * dxdxi);
+
+  /// Curved Elemens:
+  /// xi..local coordinates
+  /// x ..global coordinates
+  /// dxdxi...D x D-1 Jacobian matrix (row major storage)
+  void Ng_GetSurfaceElementTransformation (int sei, const double * xi, double * x, double * dxdxi);
+
+  
+  // Mark element for refinement
+  void Ng_SetRefinementFlag (int ei, int flag);
+  void Ng_SetSurfaceRefinementFlag (int sei, int flag);
+
+  // Do local refinement
+  enum NG_REFINEMENT_TYPE { NG_REFINE_H = 0, NG_REFINE_P = 1, NG_REFINE_HP = 2 };
+  void Ng_Refine (NG_REFINEMENT_TYPE reftype);
+
+  // Use second order elements
+  void Ng_SecondOrder ();
+  void Ng_HighOrder (int order);
+  void Ng_HPRefinement (int levels);
+
+
+  // Topology and coordinate information of master element:
+
+  int Ng_ME_GetNVertices (NG_ELEMENT_TYPE et);
+  int Ng_ME_GetNEdges (NG_ELEMENT_TYPE et);
+  int Ng_ME_GetNFaces (NG_ELEMENT_TYPE et);
+
+  const NG_POINT * Ng_ME_GetVertices (NG_ELEMENT_TYPE et);
+  const NG_EDGE * Ng_ME_GetEdges (NG_ELEMENT_TYPE et);
+  const NG_FACE * Ng_ME_GetFaces (NG_ELEMENT_TYPE et);
+
+  int Ng_GetNEdges();
+  int Ng_GetNFaces();
+
+  
+  int Ng_GetElement_Edges (int elnr, int * edges, int * orient = 0);
+  int Ng_GetElement_Faces (int elnr, int * faces, int * orient = 0);
+
+  int Ng_GetSurfaceElement_Edges (int selnr, int * edges, int * orient = 0);
+  int Ng_GetSurfaceElement_Face (int selnr, int * orient = 0);
+
+  int Ng_GetFace_Vertices (int fnr, int * vert);
+  void Ng_GetEdge_Vertices (int ednr, int * vert);
+  int Ng_GetFace_Edges (int fnr, int * edge);
+
+  int Ng_GetElementOrder (int enr);
+
+  // Multilevel functions:
+
+  // number of levels:
+  int Ng_GetNLevels ();
+  // get two parent nodes of node ni
+  void Ng_GetParentNodes (int ni, int * parents);
+
+  // get parent element (first child has always same number)
+  int Ng_GetParentElement (int ei);
+
+  // get parent surface element (first child has always same number)
+  int Ng_GetParentSElement (int ei);
+
+  // representant of anisotropic cluster
+  int Ng_GetClusterRepVertex (int vi);
+  int Ng_GetClusterRepEdge (int edi);
+  int Ng_GetClusterRepFace (int fai);
+  int Ng_GetClusterRepElement (int eli);
+
+
+  void Ng_SurfaceElementTransformation (int eli, double x, double y, 
+					double * p3d, double * jacobian);
+  
+namespace netgen {
+#include "../visualization/soldata.hpp"
+}
+
+  enum Ng_SolutionType
+  { NG_SOLUTION_NODAL = 1, 
+    NG_SOLUTION_ELEMENT = 2, 
+    NG_SOLUTION_SURFACE_ELEMENT = 3, 
+    NG_SOLUTION_NONCONTINUOUS = 4,
+    NG_SOLUTION_SURFACE_NONCONTINUOUS = 5,
+    NG_SOLUTION_VIRTUAL_FUNCTION = 6,
+    NG_SOLUTION_MARKED_ELEMENTS = 10,
+    NG_SOLUTION_ELEMENT_ORDER = 11
+  };
+  
+  struct Ng_SolutionData
+  {
+    char * name;      // name of gridfunction
+    double * data;    // solution values
+    int components;   // relevant (double) components in solution vector
+    int dist;         // # doubles per entry alignment! 
+    int iscomplex;    // complex vector ? 
+    bool draw_surface;
+    bool draw_volume;
+    int order;        // order of elements, only partially supported 
+    Ng_SolutionType soltype;  // type of solution function
+    netgen::SolutionData * solclass;
+  };
+  
+  // initialize solution data with default arguments
+  void Ng_InitSolutionData (Ng_SolutionData * soldata);
+  // set solution data
+  void Ng_SetSolutionData (Ng_SolutionData * soldata);
+  // redraw 
+  void Ng_Redraw();
+  //
+  void Ng_SetVisualizationParameter (const char * name, 
+				     const char * value);
+
+
+  // number of periodic vertices  
+  int Ng_GetNPeriodicVertices ();
+  // pairs should be an integer array of 2*npairs
+  void Ng_GetPeriodicVertices (int * pairs);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Netgen/libsrc/interface/nglib.h

+#ifndef NGLIB
+#define NGLIB
+
+/**************************************************************************/
+/* File:   nglib.hh                                                       */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   7. May. 2000                                                   */
+/**************************************************************************/
+
+/*
+  
+  Interface to the netgen meshing kernel
+  
+*/
+
+
+
+/// Data type for NETGEN mesh
+typedef void * Ng_Mesh;
+
+/// Data type for NETGEN CSG geomty
+typedef void * Ng_CSG_Geometry;
+
+/// Data type for NETGEN 2D geomty
+typedef void * Ng_Geometry_2D;
+
+/// Data type for NETGEN STL geomty
+typedef void * Ng_STL_Geometry;
+
+
+
+// max number of nodes per element
+#define NG_VOLUME_ELEMENT_MAXPOINTS 10
+
+// implemented element types:
+enum Ng_Volume_Element_Type { NG_TET = 1, NG_PYRAMID = 2, NG_PRISM = 3,
+			      NG_TET10 = 4 };
+
+// max number of nodes per surface element
+#define NG_SURFACE_ELEMENT_MAXPOINTS 6
+
+// implemented element types:
+enum Ng_Surface_Element_Type { NG_TRIG = 1, NG_QUAD = 2, 
+			       NG_TRIG6 = 3 };
+
+
+
+class Ng_Meshing_Parameters 
+{
+ public:
+
+  double maxh;
+  double fineness;   // 0 .. coarse, 1 .. fine
+  int secondorder;
+  char * meshsize_filename;
+
+  Ng_Meshing_Parameters();
+};
+
+
+enum Ng_Result { NG_OK = 0, 
+		 NG_SURFACE_INPUT_ERROR = 1,
+		 NG_VOLUME_FAILURE = 2, 
+		 NG_STL_INPUT_ERROR = 3,
+		 NG_SURFACE_FAILURE = 4,
+		 NG_FILE_NOT_FOUND = 5 };
+
+
+
+
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+  
+  // initialize, deconstruct Netgen library:
+  void Ng_Init ();
+  void Ng_Exit ();
+  
+
+  // Generates new mesh structure
+  Ng_Mesh * Ng_NewMesh ();
+  void Ng_DeleteMesh (Ng_Mesh * mesh);
+  
+  // feeds points, surface elements and volume elements to the mesh
+  void Ng_AddPoint (Ng_Mesh * mesh, double * x);
+  void Ng_AddSurfaceElement (Ng_Mesh * mesh, Ng_Surface_Element_Type et,
+			     int * pi);
+  void Ng_AddVolumeElement (Ng_Mesh * mesh, Ng_Volume_Element_Type et,
+			    int * pi);
+  
+  // ask for number of points, surface and volume elements
+  int Ng_GetNP (Ng_Mesh * mesh);
+  int Ng_GetNSE (Ng_Mesh * mesh);
+  int Ng_GetNE (Ng_Mesh * mesh);
+
+  
+  //  return point coordinates
+  void Ng_GetPoint (Ng_Mesh * mesh, int num, double * x);
+
+  // return surface and volume element in pi
+  Ng_Surface_Element_Type 
+  Ng_GetSurfaceElement (Ng_Mesh * mesh, int num, int * pi);
+
+  Ng_Volume_Element_Type
+  Ng_GetVolumeElement (Ng_Mesh * mesh, int num, int * pi);
+
+
+  // Defines MeshSize Functions
+  void Ng_RestrictMeshSizeGlobal (Ng_Mesh * mesh, double h);
+  void Ng_RestrictMeshSizePoint (Ng_Mesh * mesh, double * p, double h);
+  void Ng_RestrictMeshSizeBox (Ng_Mesh * mesh, double * pmin, double * pmax, double h);
+  
+  // generates volume mesh from surface mesh
+  Ng_Result Ng_GenerateVolumeMesh (Ng_Mesh * mesh, Ng_Meshing_Parameters * mp);
+
+  void Ng_SaveMesh(Ng_Mesh * mesh, char* filename);
+
+
+
+
+
+  // **********************************************************
+  // **   2D Meshing                                         **
+  // **********************************************************
+
+
+  // feeds points and boundary to mesh
+
+  void Ng_AddPoint_2D (Ng_Mesh * mesh, double * x);
+  void Ng_AddBoundarySeg_2D (Ng_Mesh * mesh, int pi1, int pi2);
+  
+  // ask for number of points, elements and boundary segments
+  int Ng_GetNP_2D (Ng_Mesh * mesh);
+  int Ng_GetNE_2D (Ng_Mesh * mesh);
+  int Ng_GetNSeg_2D (Ng_Mesh * mesh);
+  
+  //  return point coordinates
+  void Ng_GetPoint_2D (Ng_Mesh * mesh, int num, double * x);
+
+  // return 2d triangles
+  void Ng_GetElement_2D (Ng_Mesh * mesh, int num, int * pi, int * matnum = NULL);
+
+  // return 2d boundary segment
+  void Ng_GetSegment_2D (Ng_Mesh * mesh, int num, int * pi, int * matnum = NULL);
+
+
+  // load 2d netgen spline geometry
+  Ng_Geometry_2D * Ng_LoadGeometry_2D (char * filename);
+
+  // generate 2d mesh, mesh is allocated by function
+  Ng_Result Ng_GenerateMesh_2D (Ng_Geometry_2D * geom,
+				Ng_Mesh ** mesh,
+				Ng_Meshing_Parameters * mp);
+  
+
+  
+
+
+
+
+  // **********************************************************
+  // **   STL Meshing                                        **
+  // **********************************************************
+
+
+  // loads geometry from STL file
+  Ng_STL_Geometry * Ng_STL_LoadGeometry (char * filename, int binary = 0);
+
+
+  // generate new STL Geometry
+  Ng_STL_Geometry * Ng_STL_NewGeometry ();
+  
+
+  // fills STL Geometry
+  // positive orientation
+  // normal vector may be null-pointer
+  void Ng_STL_AddTriangle (Ng_STL_Geometry * geom, 
+			   double * p1, double * p2, double * p3, 
+			   double * nv = NULL);
+
+  // add (optional) edges :
+  void Ng_STL_AddEdge (Ng_STL_Geometry * geom, 
+		       double * p1, double * p2);
+
+  // after adding triangles (and edges) initialize
+  Ng_Result Ng_STL_InitSTLGeometry (Ng_STL_Geometry * geom);
+
+  // automatically generates edges:
+  Ng_Result Ng_STL_MakeEdges (Ng_STL_Geometry * geom,
+			      Ng_Mesh* mesh,
+			      Ng_Meshing_Parameters * mp);
+
+  
+  // generates mesh, empty mesh must be already created.
+  Ng_Result Ng_STL_GenerateSurfaceMesh (Ng_STL_Geometry * geom,
+					Ng_Mesh * mesh,
+					Ng_Meshing_Parameters * mp);
+
+#ifdef __cplusplus
+  }
+#endif
+
+
+#endif

benchmarks/3d/Cube-08.geo

+/*****************************      
+A cube with a hole   
+*****************************/      
+  
+Point(1) = {0.0,0.0,0.0,.1};
+Extrude Point {1, {1,0.0,0} };
+Extrude Line {1, {0.0,0.0,1} };
+Extrude Surface {5, {0,1,0} };
+  
+Point(100) = {0.3,0.3,0.3,.1};
+Extrude Point {100, {.4,0.0,0} };
+Extrude Line {28, {0,0.4,0} };
+Extrude Surface {32, {0,0.,0.4} };
+ 
+Surface Loop(55) = {-26,5,-14,-18,-22,-27};
+Surface Loop(56) = {-41,32,-45,-49,-53,-54};
+Volume(57) = {55,56};
+//Volume(57) = {55};

doc/CREDITS

-$Id: CREDITS,v 1.14 2004-06-23 19:53:52 geuzaine Exp $
+$Id: CREDITS,v 1.15 2004-06-26 18:03:24 geuzaine Exp $
 
              Gmsh is copyright (C) 1997-2004 
 
@@ -65,6 +65,10 @@ This version of Gmsh may contain code (in the Triangle subdirectory)
 copyright (C) 1993, 1995, 1997, 1998, 2002, Jonathan Richard Shewchuk:
 check the configuration options.
 
+This version of Gmsh may contain code (in the Netgen subdirectory)
+copyright (C) 1994-2004, Joachim Sch"oberl: check the configuration
+options.
+
 Special thanks to Bill Spitzak <spitzak at users.sourceforge.net>,
 Michael Sweet <easysw at users.sourceforge.net>, Matthias Melcher <mm
 at matthiasm.com> and others for the Fast Light Tool Kit on which