Merge branch 'master' into cvm

Conflicts:
	applications/utilities/surface/surfaceFeatureConvert/surfaceFeatureConvert.C
	applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
	src/Allwmake
	src/edgeMesh/Make/files
	src/edgeMesh/edgeMesh.C
	src/edgeMesh/edgeMesh.H
	src/edgeMesh/edgeMeshI.H
	src/edgeMesh/edgeMeshIO.C
	src/edgeMesh/featureEdgeMesh.C
	src/edgeMesh/featureEdgeMesh.H
	src/edgeMesh/featureEdgeMesh/featureEdgeMesh.C
	src/edgeMesh/featureEdgeMesh/featureEdgeMesh.H
	src/meshTools/searchableSurface/closedTriSurfaceMesh.C
	src/meshTools/searchableSurface/closedTriSurfaceMesh.H

Merged Mark's work on edgeMesh with my featureEdgeMesh.

applications/solvers/basic/potentialFoam/potentialFoam.C

@@ -38,11 +38,9 @@ Description
 
 int main(int argc, char *argv[])
 {
-
+    argList::addBoolOption("writep", "write the final pressure field");
-    argList::validOptions.insert("writep", "");
 
 #   include "setRootCase.H"
-
 #   include "createTime.H"
 #   include "createMesh.H"
 #   include "createFields.H"

applications/solvers/combustion/PDRFoam/XiEqns

@@ -22,7 +22,7 @@
         volScalarField GEta = GEtaCoef/tauEta;
         volScalarField XiEqEta = 1.0 + XiCoef*sqrt(up/(Su + SuMin))*Reta;
 
-        volScalarField R = 
+        volScalarField R =
             GEta*XiEqEta/(XiEqEta - 0.999) + GIn*XiIn/(XiIn - 0.999);
 
         volScalarField XiEqStar = R/(R - GEta - GIn);
@@ -42,7 +42,7 @@
         volScalarField GEta = GEtaCoef/tauEta;
         volScalarField XiEqEta = 1.0 + XiCoef*sqrt(up/(Su + SuMin))*Reta;
 
-        volScalarField R = 
+        volScalarField R =
             GEta*XiEqEta/(XiEqEta - 0.999) + GIn*XiIn/(XiIn - 0.999);
 
         volScalarField XiEqStar = R/(R - GEta - GIn);

applications/solvers/combustion/PDRFoam/XiModels/algebraic/algebraic.C

@@ -91,7 +91,7 @@ bool Foam::XiModels::algebraic::read(const dictionary& XiProperties)
     XiModel::read(XiProperties);
 
     XiModelCoeffs_.lookup("XiShapeCoef") >> XiShapeCoef;
-    
+
     return true;
 }
 

applications/solvers/combustion/PDRFoam/laminarFlameSpeed/SCOPE/SCOPELaminarFlameSpeed.C

@@ -117,7 +117,7 @@ inline Foam::scalar Foam::laminarFlameSpeedModels::SCOPE::polyPhi
 {
     scalar x = phi - 1.0;
 
-    return 
+    return
         a[0]
        *(
            scalar(1)

applications/solvers/combustion/PDRFoam/setDeltaT.H

@@ -45,7 +45,7 @@ if (adjustTimeStep)
             maxDeltaT
         )
     );
-    
+
     Info<< "deltaT = " <<  runTime.deltaTValue() << endl;
 }
 

applications/solvers/combustion/dieselEngineFoam/createFields.H

@@ -88,7 +88,7 @@ volScalarField DpDt =
 
 multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-forAll (Y, i)
+forAll(Y, i)
 {
     fields.add(Y[i]);
 }

applications/solvers/combustion/reactingFoam/createFields.H

@@ -77,7 +77,7 @@ volScalarField DpDt =
 
 multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-forAll (Y, i)
+forAll(Y, i)
 {
     fields.add(Y[i]);
 }

applications/solvers/combustion/rhoReactingFoam/createFields.H

@@ -77,7 +77,7 @@ volScalarField DpDt =
 
 multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-forAll (Y, i)
+forAll(Y, i)
 {
     fields.add(Y[i]);
 }

applications/solvers/compressible/rhoCentralFoam/Allwmake

@@ -2,7 +2,7 @@
 cd ${0%/*} || exit 1    # run from this directory
 set -x
 
-wmake libso BCs 
+wmake libso BCs
 wmake
 
 # ----------------------------------------------------------------- end-of-file

applications/solvers/compressible/rhoCentralFoam/BCs/Make/options

@@ -6,5 +6,5 @@ EXE_INC = \
 EXE_LIBS = \
     -lfiniteVolume \
     -lbasicThermophysicalModels \
-	-lspecie
+    -lspecie
 

applications/solvers/compressible/rhoCentralFoam/BCs/U/maxwellSlipUFvPatchVectorField.C

@@ -22,8 +22,6 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-
 \*---------------------------------------------------------------------------*/
 
 #include "maxwellSlipUFvPatchVectorField.H"

applications/solvers/compressible/rhoCentralFoam/BCs/mixedFixedValueSlip/mixedFixedValueSlipFvPatchFields.C

@@ -22,8 +22,6 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
-Description
-
 \*---------------------------------------------------------------------------*/
 
 #include "mixedFixedValueSlipFvPatchFields.H"

applications/solvers/compressible/rhoSonicFoam/rhoSonicFoam.C

@@ -84,7 +84,7 @@ int main(int argc, char *argv[])
         (
             fvm::ddt(rhoU)
           + fvm::div(phiv, rhoU)
-         == 
+         ==
           - fvc::grad(p)
         );
 

applications/solvers/compressible/rhopSonicFoam/Allwmake

@@ -2,7 +2,7 @@
 cd ${0%/*} || exit 1    # run from this directory
 set -x
 
-wmake libso BCs 
+wmake libso BCs
 wmake
 
 # ----------------------------------------------------------------- end-of-file

applications/solvers/compressible/rhopSonicFoam/BCs/p/inviscidWallPFvPatchScalarField.C

@@ -131,7 +131,7 @@ void inviscidWallPFvPatchScalarField::updateCoeffs()
     const fvPatchField<vector>& rhoUp =
         patch().lookupPatchField<volVectorField, vector>("rhoU");
 
-    const fvsPatchField<scalar>& phip = 
+    const fvsPatchField<scalar>& phip =
         patch().lookupPatchField<surfaceScalarField, scalar>("phi");
 
     const fvsPatchField<scalar>& rAp =
@@ -147,7 +147,7 @@ void inviscidWallPFvPatchScalarField::updateCoeffs()
 void inviscidWallPFvPatchScalarField::write(Ostream& os) const
 {
     fixedGradientFvPatchScalarField::write(os);
-    os.writeKeyword("fluxFraction") 
+    os.writeKeyword("fluxFraction")
         << fluxFraction_ << token::END_STATEMENT << nl;
     writeEntry("value", os);
 }

applications/solvers/compressible/rhopSonicFoam/BCs/rhoE/mixedRhoEFvPatchScalarField.C

@@ -145,7 +145,7 @@ void mixedRhoEFvPatchScalarField::updateCoeffs()
 
     const volScalarField& T = db().lookupObject<volScalarField>("T");
     const label patchi = patch().index();
-    fvPatchScalarField& Tp = 
+    fvPatchScalarField& Tp =
         const_cast<fvPatchScalarField&>(T.boundaryField()[patchi]);
 
     Tp.evaluate();
@@ -164,7 +164,7 @@ void mixedRhoEFvPatchScalarField::updateCoeffs()
     refGrad() =
         rhop*Cv.value()*Tp.snGrad()
       + (
-            refValue() 
+            refValue()
           - (0.5*rhop.patchInternalField()*
                 magSqr(rhoUp.patchInternalField()/rhop.patchInternalField()))
         )*patch().deltaCoeffs();

applications/solvers/compressible/rhopSonicFoam/BCs/rhoU/fixedRhoUFvPatchVectorField.H

@@ -66,7 +66,7 @@ public:
             const dictionary&
         );
 
-        //- Construct by mapping given fixedRhoUFvPatchVectorField 
+        //- Construct by mapping given fixedRhoUFvPatchVectorField
         //  onto a new patch
         fixedRhoUFvPatchVectorField
         (

applications/solvers/electromagnetics/electrostaticFoam/Make/files

@@ -1,3 +1,3 @@
-electrostaticFoam.C  
+electrostaticFoam.C
 
 EXE = $(FOAM_APPBIN)/electrostaticFoam

applications/solvers/incompressible/icoFoam/Make/files

@@ -1,3 +1,3 @@
-icoFoam.C  
+icoFoam.C
 
 EXE = $(FOAM_APPBIN)/icoFoam

applications/solvers/incompressible/nonNewtonianIcoFoam/Make/files

@@ -1,3 +1,3 @@
-nonNewtonianIcoFoam.C  
+nonNewtonianIcoFoam.C
 
 EXE = $(FOAM_APPBIN)/nonNewtonianIcoFoam

applications/solvers/incompressible/simpleFoam/Make/files

@@ -1,3 +1,3 @@
-simpleFoam.C 
+simpleFoam.C
 
 EXE = $(FOAM_APPBIN)/simpleFoam

applications/solvers/lagrangian/coalChemistryFoam/createFields.H

@@ -28,7 +28,7 @@
 
     multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-    forAll (Y, i)
+    forAll(Y, i)
     {
         fields.add(Y[i]);
     }

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/createFields.H

@@ -84,7 +84,7 @@
     Info<< "Creating multi-variate interpolation scheme\n" << endl;
     multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-    forAll (Y, i)
+    forAll(Y, i)
     {
         fields.add(Y[i]);
     }

applications/solvers/lagrangian/reactingParcelFoam/createFields.H

@@ -90,7 +90,7 @@
 
     multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-    forAll (Y, i)
+    forAll(Y, i)
     {
         fields.add(Y[i]);
     }

applications/solvers/lagrangian/uncoupledKinematicParcelFoam/createFields.H

@@ -47,8 +47,10 @@
         )
     );
 
-    word kinematicCloudName("kinematicCloud");
+    const word kinematicCloudName
-    args.optionReadIfPresent("cloudName", kinematicCloudName);
+    (
+        args.optionLookupOrDefault<word>("cloudName", "kinematicCloud")
+    );
 
     Info<< "Constructing kinematicCloud " << kinematicCloudName << endl;
     basicKinematicCloud kinematicCloud

applications/solvers/lagrangian/uncoupledKinematicParcelFoam/uncoupledKinematicParcelFoam.C

@@ -42,7 +42,7 @@ Description
 
 int main(int argc, char *argv[])
 {
-    argList::validOptions.insert("cloudName", "cloud name");
+    argList::addOption("cloudName", "cloud name");
 
     #include "setRootCase.H"
     #include "createTime.H"

applications/solvers/multiphase/bubbleFoam/UEqns.H

@@ -41,7 +41,7 @@ fvVectorMatrix UbEqn(Ub, Ub.dimensions()*dimVol/dimTime);
        - fvc::interpolate(nuEffb)
         *mesh.magSf()*fvc::snGrad(beta)/fvc::interpolate(beta + scalar(0.001));
 
-    UbEqn = 
+    UbEqn =
     (
         (scalar(1) + Cvm*rhob*alpha/rhob)*
         (

applications/solvers/multiphase/cavitatingFoam/CourantNo.H

@@ -36,7 +36,7 @@ scalar acousticCoNum = 0.0;
 
 if (mesh.nInternalFaces())
 {
-    surfaceScalarField SfUfbyDelta = 
+    surfaceScalarField SfUfbyDelta =
         mesh.surfaceInterpolation::deltaCoeffs()*mag(phiv);
 
     CoNum = max(SfUfbyDelta/mesh.magSf())

applications/solvers/multiphase/cavitatingFoam/continuityErrs.H

@@ -3,12 +3,12 @@
 
     dimensionedScalar totalMass = fvc::domainIntegrate(rho);
 
-    scalar sumLocalContErr = 
+    scalar sumLocalContErr =
     (
         fvc::domainIntegrate(mag(rho - thermoRho))/totalMass
     ).value();
 
-    scalar globalContErr = 
+    scalar globalContErr =
     (
         fvc::domainIntegrate(rho - thermoRho)/totalMass
     ).value();

applications/solvers/multiphase/cavitatingFoam/setDeltaT.H

@@ -47,7 +47,7 @@ if (adjustTimeStep)
             maxDeltaT
         )
     );
-    
+
     Info<< "deltaT = " <<  runTime.deltaTValue() << endl;
 }
 

applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/alphaContactAngle/alphaContactAngleFvPatchScalarField.C

@@ -63,7 +63,7 @@ Ostream& operator<<
 )
 {
     os  << tp.theta0_ << token::SPACE
-        << tp.uTheta_ << token::SPACE 
+        << tp.uTheta_ << token::SPACE
         << tp.thetaA_ << token::SPACE
         << tp.thetaR_;
 

applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/phase/phase.C

@@ -28,7 +28,7 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::phase::phase 
+Foam::phase::phase
 (
     const word& name,
     const dictionary& phaseDict,

applications/solvers/multiphase/settlingFoam/correctViscosity.H

@@ -1,5 +1,5 @@
 {
-    mul = muc + 
+    mul = muc +
         plasticViscosity
         (
             plasticViscosityCoeff,

applications/solvers/multiphase/twoPhaseEulerFoam/UEqns.H

@@ -56,7 +56,7 @@ fvVectorMatrix UbEqn(Ub, Ub.dimensions()*dimVol/dimTime);
             -fvc::interpolate(nuEffb)*mesh.magSf()*fvc::snGrad(beta)
             /fvc::interpolate(beta + scalar(0.001));
 
-        UbEqn = 
+        UbEqn =
         (
             (scalar(1) + Cvm*rhob*alpha/rhob)*
             (

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/GidaspowErgunWenYu/GidaspowErgunWenYu.C

@@ -89,7 +89,7 @@ Foam::tmp<Foam::volScalarField> Foam::GidaspowErgunWenYu::K
     volScalarField& KWenYu = tKWenYu();
 
     // Ergun
-    forAll (beta, cellj)
+    forAll(beta, cellj)
     {
         if (beta[cellj] <= 0.8)
         {

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/SyamlalOBrien/SyamlalOBrien.C

@@ -73,7 +73,7 @@ Foam::tmp<Foam::volScalarField> Foam::SyamlalOBrien::K
     volScalarField A = pow(beta, 4.14);
     volScalarField B = 0.8*pow(beta, 1.28);
 
-    forAll (beta, celli)
+    forAll(beta, celli)
     {
         if (beta[celli] > 0.85)
         {

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/conductivityModel/conductivityModel/newConductivityModel.C

@@ -35,9 +35,9 @@ Foam::autoPtr<Foam::conductivityModel> Foam::conductivityModel::New
 {
     word conductivityModelType(dict.lookup("conductivityModel"));
 
-    Info<< "Selecting conductivityModel " 
+    Info<< "Selecting conductivityModel "
         << conductivityModelType << endl;
-        
+
     dictionaryConstructorTable::iterator cstrIter =
         dictionaryConstructorTablePtr_->find(conductivityModelType);
 

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/frictionalStressModel/JohnsonJackson/JohnsonJacksonFrictionalStress.C

@@ -73,7 +73,7 @@ frictionalPressure
 ) const
 {
 
-    return 
+    return
         Fr*pow(max(alpha - alphaMinFriction, scalar(0)), eta)
        /pow(max(alphaMax - alpha, scalar(5.0e-2)), p);
 }
@@ -104,9 +104,9 @@ Foam::tmp<Foam::volScalarField> Foam::JohnsonJacksonFrictionalStress::muf
     const dimensionedScalar& alphaMax,
     const volScalarField& pf,
     const volTensorField& D,
-    const dimensionedScalar& phi            
+    const dimensionedScalar& phi
 ) const
-{    
+{
     return dimensionedScalar("0.5", dimTime, 0.5)*pf*sin(phi);
 }
 

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/frictionalStressModel/Schaeffer/SchaefferFrictionalStress.C

@@ -125,7 +125,7 @@ Foam::tmp<Foam::volScalarField> Foam::SchaefferFrictionalStress::muf
 
     volScalarField& muff = tmuf();
 
-    forAll (D, celli)
+    forAll(D, celli)
     {
         if (alpha[celli] > alphaMax.value()-5e-2)
         {

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/frictionalStressModel/frictionalStressModel/newFrictionalStressModel.C

@@ -35,9 +35,9 @@ Foam::autoPtr<Foam::frictionalStressModel> Foam::frictionalStressModel::New
 {
     word frictionalStressModelType(dict.lookup("frictionalStressModel"));
 
-    Info<< "Selecting frictionalStressModel " 
+    Info<< "Selecting frictionalStressModel "
         << frictionalStressModelType << endl;
-        
+
     dictionaryConstructorTable::iterator cstrIter =
         dictionaryConstructorTablePtr_->find(frictionalStressModelType);
 

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/granularPressureModel/granularPressureModel/newGranularPressureModel.C

@@ -35,9 +35,9 @@ Foam::autoPtr<Foam::granularPressureModel> Foam::granularPressureModel::New
 {
     word granularPressureModelType(dict.lookup("granularPressureModel"));
 
-    Info<< "Selecting granularPressureModel " 
+    Info<< "Selecting granularPressureModel "
         << granularPressureModelType << endl;
-        
+
     dictionaryConstructorTable::iterator cstrIter =
         dictionaryConstructorTablePtr_->find(granularPressureModelType);
 

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/CarnahanStarling/CarnahanStarlingRadial.C

@@ -65,7 +65,7 @@ Foam::tmp<Foam::volScalarField> Foam::CarnahanStarlingRadial::g0
 ) const
 {
 
-    return 
+    return
         1.0/(1.0 - alpha)
       + 3.0*alpha/(2.0*sqr(1.0 - alpha))
       + sqr(alpha)/(2.0*pow(1.0 - alpha, 3));
@@ -78,8 +78,8 @@ Foam::tmp<Foam::volScalarField> Foam::CarnahanStarlingRadial::g0prime
     const dimensionedScalar& alphaMax
 ) const
 {
-    return 
+    return
-        - alpha/sqr(1.0 - alpha) 
+        - alpha/sqr(1.0 - alpha)
         + (3.0*(1.0 - alpha) + 6.0*sqr(alpha))/(2.0*(1.0 - alpha))
         + (2.0*alpha*(1.0 - alpha) + 3.0*pow(alpha, 3))
          /(2.0*pow(1.0 - alpha, 4));

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/Gidaspow/GidaspowRadial.C

@@ -74,7 +74,7 @@ Foam::tmp<Foam::volScalarField> Foam::GidaspowRadial::g0prime
     const dimensionedScalar& alphaMax
 ) const
 {
-    return 
+    return
         (-1.0/5.0)*pow(alpha/alphaMax, -2.0/3.0)
        /(alphaMax*sqr(1.0 - pow(alpha/alphaMax, 1.0/3.0)));
 }

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C

@@ -74,7 +74,7 @@ Foam::tmp<Foam::volScalarField> Foam::SinclairJacksonRadial::g0prime
     const dimensionedScalar& alphaMax
 ) const
 {
-    return 
+    return
         (-1.0/3.0)*pow(alpha/alphaMax, -2.0/3.0)
        /(alphaMax*sqr(1.0 - pow(alpha/alphaMax, 1.0/3.0)));
 }

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/radialModel/newRadialModel.C

@@ -35,9 +35,9 @@ Foam::autoPtr<Foam::radialModel> Foam::radialModel::New
 {
     word radialModelType(dict.lookup("radialModel"));
 
-    Info<< "Selecting radialModel " 
+    Info<< "Selecting radialModel "
         << radialModelType << endl;
-        
+
     dictionaryConstructorTable::iterator cstrIter =
         dictionaryConstructorTablePtr_->find(radialModelType);
 

applications/solvers/multiphase/twoPhaseEulerFoam/pEqn.H

@@ -42,7 +42,7 @@
 
     phib = (fvc::interpolate(Ub) & mesh.Sf()) + fvc::ddtPhiCorr(rUbA, Ub, phib)
          + phiDragb;
-    
+
     phi = alphaf*phia + betaf*phib;
 
     surfaceScalarField Dp("(rho*(1|A(U)))", alphaf*rUaAf/rhoa + betaf*rUbAf/rhob);

applications/solvers/multiphase/twoPhaseEulerFoam/packingLimiter.H

@@ -7,20 +7,20 @@
         labelListList neighbour = mesh.cellCells();
         scalarField cellVolumes = mesh.cellVolumes();
 
-        forAll (alphaEx, celli)
+        forAll(alphaEx, celli)
         {
             // Finding the labels of the neighbouring cells
             labelList neighbourCell = neighbour[celli];
 
             // Initializing neighbouring cells contribution
             scalar neighboursEx = 0.0;
-           
+
-            forAll (neighbourCell, cellj)
+            forAll(neighbourCell, cellj)
             {
                 labelList neighboursNeighbour = neighbour[neighbourCell[cellj]];
                 scalar neighboursNeighbourCellVolumes = 0.0;
-        
+
-                forAll (neighboursNeighbour, cellk)
+                forAll(neighboursNeighbour, cellk)
                 {
                     neighboursNeighbourCellVolumes +=
                         cellVolumes[neighboursNeighbour[cellk]];

applications/solvers/stressAnalysis/solidDisplacementFoam/tractionDisplacement/tractionDisplacementFvPatchVectorField.C

@@ -177,7 +177,7 @@ void tractionDisplacementFvPatchVectorField::updateCoeffs()
     gradient() =
     (
         (traction_ + pressure_*n)/rho.value()
-      + twoMuLambda*fvPatchField<vector>::snGrad() - (n & sigmaD) 
+      + twoMuLambda*fvPatchField<vector>::snGrad() - (n & sigmaD)
     )/twoMuLambda;
 
     Switch thermalStress(thermalProperties.lookup("thermalStress"));
@@ -187,7 +187,7 @@ void tractionDisplacementFvPatchVectorField::updateCoeffs()
         dimensionedScalar alpha(thermalProperties.lookup("alpha"));
         dimensionedScalar threeKalpha = threeK*alpha;
 
-        const fvPatchField<scalar>& T = 
+        const fvPatchField<scalar>& T =
             patch().lookupPatchField<volScalarField, scalar>("T");
 
         gradient() += n*threeKalpha.value()*T/twoMuLambda;

applications/solvers/stressAnalysis/solidEquilibriumDisplacementFoam/solidEquilibriumDisplacementFoam.C

@@ -72,7 +72,7 @@ int main(int argc, char *argv[])
         {
             volTensorField gradDcorr = fvc::grad(Dcorr);
 
-            sigmaExp = 
+            sigmaExp =
                 (lambda - mu)*gradDcorr + mu*gradDcorr.T()
               + (lambda*I)*tr(gradDcorr);
 

applications/solvers/stressAnalysis/solidEquilibriumDisplacementFoam/tractionDisplacementCorrection/tractionDisplacementCorrectionFvPatchVectorField.C

@@ -171,7 +171,7 @@ void tractionDisplacementCorrectionFvPatchVectorField::updateCoeffs()
     const fvPatchField<symmTensor>& sigmaD =
         patch().lookupPatchField<volSymmTensorField, symmTensor>("sigmaD");
 
-    const fvPatchField<tensor>& sigmaExp = 
+    const fvPatchField<tensor>& sigmaExp =
         patch().lookupPatchField<volTensorField, tensor>("sigmaExp");
 
     gradient() =

applications/test/BSpline/Make/files

@@ -1,3 +0,0 @@
-BSplineTest.C
-
-EXE = $(FOAM_USER_APPBIN)/BSplineTest

applications/test/BSpline/test-splines

@@ -1,69 +0,0 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  1.6                                   |
-|   \\  /    A nd           | Web:      http://www.OpenFOAM.org               |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-(
-    // Upper body longitudinal splines.
-    (
-        (-0.22685 -0.01125166 0)       // 7
-        (-0.21685 -0.01340204 0)
-        (-0.20685 -0.01529684 0)
-        (-0.19685 -0.01694748 0)
-        (-0.18685 -0.01836538 0)
-        (-0.17685 -0.01956197 0)
-        (-0.16685 -0.02054868 0)
-        (-0.15685 -0.02133693 0)
-        (-0.14685 -0.02193816 0)
-        (-0.13685 -0.02236377 0)
-        (-0.12685 -0.02262521 0)
-        (-0.11685 -0.02273389 0)       // 2
-    )
-
-    (
-        (-0.22685 0 0.01125166)        // 8
-        (-0.21685 0 0.01340204)
-        (-0.20685 0 0.01529684)
-        (-0.19685 0 0.01694748)
-        (-0.18685 0 0.01836538)
-        (-0.17685 0 0.01956197)
-        (-0.16685 0 0.02054868)
-        (-0.15685 0 0.02133693)
-        (-0.14685 0 0.02193816)
-        (-0.13685 0 0.02236377)
-        (-0.12685 0 0.02262521)
-        (-0.11685 0 0.02273389)        // 3
-    )
-
-    (
-        (-0.22685 0.01125166 0)        // 9
-        (-0.21685 0.01340204 0)
-        (-0.20685 0.01529684 0)
-        (-0.19685 0.01694748 0)
-        (-0.18685 0.01836538 0)
-        (-0.17685 0.01956197 0)
-        (-0.16685 0.02054868 0)
-        (-0.15685 0.02133693 0)
-        (-0.14685 0.02193816 0)
-        (-0.13685 0.02236377 0)
-        (-0.12685 0.02262521 0)
-        (-0.11685 0.02273389 0)        // 4
-    )
-
-    (
-        (-0.22685 0 -0.01125166)       // 6
-        (-0.21685 0 -0.01340204)
-        (-0.20685 0 -0.01529684)
-        (-0.19685 0 -0.01694748)
-        (-0.18685 0 -0.01836538)
-        (-0.17685 0 -0.01956197)
-        (-0.16685 0 -0.02054868)
-        (-0.15685 0 -0.02133693)
-        (-0.14685 0 -0.02193816)
-        (-0.13685 0 -0.02236377)
-        (-0.12685 0 -0.02262521)
-        (-0.11685 0 -0.02273389)       // 1
-    )
-);

applications/test/List/ListTest.C

@@ -47,11 +47,11 @@ using namespace Foam;
 int main(int argc, char *argv[])
 {
     argList::noParallel();
-    argList::validOptions.insert("reList", "reList");
+    argList::addOption("reList", "reList");
-    argList::validOptions.insert("wordList", "wordList");
+    argList::addOption("wordList", "wordList");
-    argList::validOptions.insert("stringList", "stringList");
+    argList::addOption("stringList", "stringList");
-    argList::validOptions.insert("float", "xx");
+    argList::addOption("float", "xx");
-    argList::validOptions.insert("flag", "");
+    argList::addBoolOption("flag");
 
 #   include "setRootCase.H"
 

applications/test/PackedList/PackedListTest.C

@@ -82,9 +82,13 @@ int main(int argc, char *argv[])
     argList::noParallel();
     argList::validArgs.insert("file .. fileN");
 
-    argList::validOptions.insert("mask", "");
+    argList::addBoolOption("mask", "report information about the bit masks");
-    argList::validOptions.insert("count", "");
+    argList::addBoolOption("count", "test the count() method");
-    argList::validOptions.insert("info", "");
+    argList::addBoolOption
+    (
+        "info",
+        "print an ascii representation of the storage"
+    );
 
     argList args(argc, argv, false, true);
 

applications/test/PackedList1/PackedListTest1.C

@@ -58,9 +58,15 @@ int main(int argc, char *argv[])
     list1.print(Info);
 
     Info<< "\ntest set() with default argument (max_value)\n";
+    list1.set(1);
     list1.set(3);
     list1.print(Info);
 
+    Info<< "\ntest unset() with in-range and out-of-range\n";
+    list1.unset(3);
+    list1.unset(100000);
+    list1.print(Info);
+
     Info<< "\ntest assign between references\n";
     list1[2] = 3;
     list1[4] = list1[2];

applications/test/PackedList3/Make/files

@@ -0,0 +1,3 @@
+PackedListTest3.C
+
+EXE = $(FOAM_USER_APPBIN)/PackedListTest3

applications/test/PackedList3/PackedListTest3.C

@@ -22,43 +22,51 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-\*---------------------------------------------------------------------------*/
+Application
-#include "argList.H"
 
-#include "vector.H"
+Description
-#include "IFstream.H"
+
-#include "BSpline.H"
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "boolList.H"
+#include "HashSet.H"
+#include "StaticHashTable.H"
+#include "cpuTime.H"
+#include <vector>
+#include "PackedList.H"
+#include "PackedBoolList.H"
 
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
 // Main program:
 
 int main(int argc, char *argv[])
 {
-    argList::noParallel();
+    const label n = 100000000;
-    argList::validArgs.insert("file .. fileN");
+    const label nReport = 1000000;
 
-    argList args(argc, argv, false, true);
+    cpuTime timer;
 
-    forAll(args.additionalArgs(), argI)
+    // test inserts
+    // PackedBoolList
+    PackedBoolList packed;
+    for (label i = 0; i < n; i++)
     {
-        const string& srcFile = args.additionalArgs()[argI];
+        if ((i % nReport) == 0 && i)
-        Info<< nl << "reading " << srcFile << nl;
-        IFstream ifs(srcFile);
-
-        List<pointField> splinePointFields(ifs);
-
-        forAll(splinePointFields, splineI)
         {
-            Info<<"convert " << splinePointFields[splineI] << " to bspline" << endl;
+            Info<< "i:" << i << " in " << timer.cpuTimeIncrement() << " s" 
-
+                <<endl;
-            BSpline spl(splinePointFields[splineI], vector::zero, vector::zero);
-
-            Info<< "1/2 = " << spl.position(0.5) << endl;
         }
+        packed[i] = 1;
     }
+    Info<< "insert test: " << n << " elements in "
+        << timer.cpuTimeIncrement() << " s\n\n";
 
+    Info << "\nEnd\n" << endl;
 
     return 0;
 }

applications/test/Polynomial/Make/files

@@ -0,0 +1,3 @@
+PolynomialTest.C
+
+EXE = $(FOAM_USER_APPBIN)/PolynomialTest

applications/test/Polynomial/Make/options

@@ -0,0 +1,3 @@
+EXE_INC = \
+
+EXE_LIBS = \

applications/test/Polynomial/PolynomialTest.C

@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Application
+    PolynomialTest
+
+Description
+    Test application for the templated Polynomial class
+
+\*---------------------------------------------------------------------------*/
+
+#include "IFstream.H"
+#include "Polynomial.H"
+#include "Random.H"
+
+using namespace Foam;
+
+scalar polyValue(const scalar x)
+{
+    // Hard-coded polynomial 8 coeff (7th order)
+    return
+        0.11
+      + 0.45*x
+      - 0.94*sqr(x)
+      + 1.58*pow3(x)
+      - 2.58*pow4(x)
+      + 0.08*pow5(x)
+      + 3.15*pow6(x)
+      - 4.78*x*pow6(x);
+}
+
+
+scalar intPolyValue(const scalar x)
+{
+    // Hard-coded integrated form of above polynomial
+    return
+        0.11*x
+      + 0.45/2.0*sqr(x)
+      - 0.94/3.0*pow3(x)
+      + 1.58/4.0*pow4(x)
+      - 2.58/5.0*pow5(x)
+      + 0.08/6.0*pow6(x)
+      + 3.15/7.0*x*pow6(x)
+      - 4.78/8.0*x*x*pow6(x);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    IFstream is("polyTestInput");
+
+    Polynomial<8> poly("testPoly", is);
+    Polynomial<9> intPoly(poly.integrate(0.0));
+
+    Info<< "poly = " << poly << endl;
+    Info<< "intPoly = " << intPoly << nl << endl;
+
+    Info<< "2*poly = " << 2*poly << endl;
+    Info<< "poly+poly = " << poly + poly << nl << endl;
+
+    Info<< "3*poly = " << 3*poly << endl;
+    Info<< "poly+poly+poly = " << poly + poly + poly << nl << endl;
+
+    Info<< "3*poly - 2*poly = " << 3*poly - 2*poly << nl << endl;
+
+    Polynomial<8> polyCopy = poly;
+    Info<< "poly, polyCopy = " << poly << ", " << polyCopy << nl << endl;
+    polyCopy = 2.5*poly;
+    Info<< "2.5*polyCopy = " << polyCopy << nl << endl;
+
+    Random rnd(123456);
+    for (int i=0; i<10; i++)
+    {
+        scalar x = rnd.scalar01()*100;
+
+        scalar px = polyValue(x);
+        scalar ipx = intPolyValue(x);
+
+        scalar pxTest = poly.evaluate(x);
+        scalar ipxTest = intPoly.evaluate(x);
+
+        Info<<"\nx = " << x << endl;
+        Info<< "    px, pxTest = " << px << ", " << pxTest << endl;
+        Info<< "    ipx, ipxTest = " << ipx << ", " << ipxTest << endl;
+
+        if (mag(px - pxTest) > SMALL)
+        {
+            Info<< "    *** WARNING: px != pxTest: " << px - pxTest << endl;
+        }
+
+        if (mag(ipx - ipxTest) > SMALL)
+        {
+            Info<< "    *** WARNING: ipx != ipxTest: " << ipx - ipxTest << endl;
+        }
+
+        Info<< endl;
+    }
+
+    Info<< nl << "Done." << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/Polynomial/polyTestInput

@@ -0,0 +1,11 @@
+    testPoly
+    (
+        0.11
+        0.45
+       -0.94
+        1.58
+       -2.58
+        0.08
+        3.15
+       -4.78
+    )

applications/test/dictionary/Make/files

@@ -1,4 +1,7 @@
-calcEntry/calcEntry.C
 dictionaryTest.C
 
+calcEntry/calcEntry.C
+calcEntry/calcEntryParser.cpp
+calcEntry/calcEntryScanner.cpp
+
 EXE = $(FOAM_USER_APPBIN)/dictionaryTest

applications/test/dictionary/calcEntry/CocoParserErrors.H

@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::CocoParserErrors
+
+Description
+    Templated class to shadow the error handling for Coco/R parsers
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef CocoParserErrors_H
+#define CocoParserErrors_H
+
+#include "error.H"
+#include "wchar.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class CocoParserErrors Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class BaseClass>
+class CocoParserErrors
+:
+    public BaseClass
+{
+    // Private data
+
+        //- The name issued in warnings and errors
+        word   name_;
+
+public:
+
+    // Constructors
+
+        //- Construct with given name
+        CocoParserErrors(const word& name)
+        :
+            BaseClass(),
+            name_(name)
+        {}
+
+
+    //- Destructor
+    virtual ~CocoParserErrors()
+    {}
+
+
+    // Member functions
+
+        //- Return the name issued for warnings
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Return the name issued for warnings
+        virtual word& name()
+        {
+            return name_;
+        }
+
+
+    // Error Handling
+
+        //- Handle a general warning 'msg'
+        virtual void Warning(const wchar_t* msg)
+        {
+            WarningIn(name_)
+                << msg << endl;
+        }
+
+        //- Handle a general warning 'msg'
+        virtual void Warning(int line, int col, const wchar_t* msg)
+        {
+            WarningIn(name_)
+                <<"line " << line << " col " << col << ": "
+                << msg << endl;
+        }
+
+        //- Handle general error 'msg' (eg, a semantic error)
+        virtual void Error(int line, int col, const wchar_t* msg)
+        {
+            FatalErrorIn(name_)
+                << "line " << line << " col " << col <<": " << msg << endl
+                << exit(FatalError);
+        }
+
+        //- Handle general error 'msg' (eg, a semantic error)
+        virtual void Error(const wchar_t* msg)
+        {
+            FatalErrorIn(name_)
+                << msg << endl
+                << exit(FatalError);
+        }
+
+        //- Handle a general exception 'msg'
+        virtual void Exception(const wchar_t* msg)
+        {
+            this->Error(msg);
+        }
+
+};
+
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/test/dictionary/calcEntry/SimpleCalc.atg

@@ -0,0 +1,225 @@
+/*-------------------------------------------------------------------------
+ compile with:
+ Coco \
+    -frames $WM_THIRD_PARTY_DIR/coco-r \
+    -prefix calcEntry \
+    -namespace Foam::functionEntries::calcEntryInternal \
+    SimpleCalc.atg
+-------------------------------------------------------------------------*/
+
+#include "dictionary.H"
+#include "scalar.H"
+#include "error.H"
+#include "wchar.H"
+
+
+COMPILER SimpleCalc
+    // Simple four function calculator for OpenFOAM dictionaries
+
+    //! with debug
+    static const int debug = 0;
+
+    //! The parent dictionary
+    mutable dictionary* dict_;
+
+    //! The calculation result
+    scalar val;
+
+    //! token -> scalar
+    scalar getScalar() const
+    {
+        return coco_string_toDouble(t->val);
+    }
+
+    //! token -> string
+    std::string getString() const
+    {
+        char* str = coco_string_create_char(t->val);
+        std::string s(str);
+        coco_string_delete(str);
+        return s;
+    }
+
+
+    //! attach a dictionary
+    void dict(const dictionary& dict) const
+    {
+        dict_ = const_cast<dictionary*>(&dict);
+    }
+
+
+    //! lookup dictionary entry
+    scalar getDictLookup() const
+    {
+        scalar dictValue = 0;
+
+        if (!dict_)
+        {
+            FatalErrorIn
+            (
+                "SimpleCalc::getDictEntry() const"
+            )   << "No dictionary attached!"
+                << exit(FatalError);
+
+            return 0;
+        }
+
+        char* chars = coco_string_create_char
+        (
+            t->val,
+            1,
+            (coco_string_length(t->val) - 1)
+        );
+        word keyword(chars);
+        coco_string_delete(chars);
+
+        if (debug)
+        {
+            Info<<"lookup: " << keyword << nl;
+        }
+
+        entry* entryPtr = dict_->lookupEntryPtr(keyword, true, false);
+        if (entryPtr && !entryPtr->isDict())
+        {
+            entryPtr->stream() >> dictValue;
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "SimpleCalc::getDictEntry() const"
+            )   << "keyword " << keyword << " is undefined in dictionary "
+                << exit(FatalError);
+        }
+
+
+        return dictValue;
+    }
+
+    scalar Result() const
+    {
+        return val;
+    }
+
+
+// * * * * * * * * * * * * * * *  CHARACTERS * * * * * * * * * * * * * * * * //
+
+CHARACTERS
+    letter    = 'A'..'Z' + 'a'..'z'.
+    qualifier = '_' + ':'.
+    dollar    = '$'.
+    digit     = "0123456789".
+    sign      = '+' + '-'.
+    cr        = '\r'.
+    lf        = '\n'.
+    tab       = '\t'.
+    stringCh  = ANY - '"' - '\\' - cr - lf.
+    printable = '\u0020' .. '\u007e'.
+
+
+// * * * * * * * * * * * * * * * *  TOKENS * * * * * * * * * * * * * * * * * //
+
+TOKENS
+
+// identifier
+ident  =
+    letter { letter | digit | qualifier }.
+
+// string
+string =
+    '"' { stringCh | '\\' printable } '"'.
+
+// dictionary lookup identifier
+// starts with '$' and otherwise limited to a normal indentifier
+variable  =
+    dollar letter { letter | digit | qualifier }.
+
+// floating point and integer numbers
+number  =
+    [sign] ('.' digit { digit } ) | ( digit { digit } [ '.' { digit } ])
+    [ ('E' | 'e') [sign] digit { digit } ].
+
+
+// * * * * * * * * * * *  PRAGMAS / COMMENTS / IGNORE  * * * * * * * * * * * //
+
+COMMENTS FROM "/*" TO "*/" NESTED
+COMMENTS FROM "//" TO lf
+
+// ignore unprintables
+IGNORE  ANY - printable
+
+
+// * * * * * * * * * * * * * * *  PRODUCTIONS  * * * * * * * * * * * * * * * //
+
+PRODUCTIONS
+
+SimpleCalc                      (. val = 0;
+                                   if (debug){Info<<"start val"<< nl;}
+                                 .)
+=
+  ( '{' Expr<val> '}' | Expr<val> )
+  EOF
+.
+
+
+/*---------------------------------------------------------------------------*/
+
+Expr<scalar& val>               (. scalar val2 = 0;
+                                   if (debug) {Info<<"Expr:"<< val<< nl;}
+                                 .)
+=
+  Term<val>
+  {
+      "+" Term<val2>            (. if (debug) {Info<<"+Term:"<<val2 <<nl;}
+                                   val += val2;
+                                   if (debug) {Info<<"="<< val << nl;}
+                                 .)
+    | "-" Term<val2>            (. if (debug) {Info<<"-Term:"<<val2 <<nl;}
+                                   val -= val2;
+                                   if (debug) {Info<<"="<< val << nl;}
+                                 .)
+  }
+.
+
+
+/*---------------------------------------------------------------------------*/
+
+Term<scalar& val>               (. scalar val2 = 0;
+                                   if (debug) {Info<<"Term:"<< val<< nl;}
+                                 .)
+=
+  Factor<val>
+  {
+     "*" Factor<val2>           (. if (debug) {Info<<"*Factor:"<<val2 << nl;}
+                                   val *= val2;
+                                   if (debug) {Info<<"="<< val << nl; }
+                                 .)
+  |  "/" Factor<val2>           (. if (debug) {Info<<"/Factor:"<<val2 << nl;}
+                                   val /= val2;
+                                   if (debug) {Info<<"="<< val << nl; }
+                                 .)
+  }
+.
+
+
+/*---------------------------------------------------------------------------*/
+Factor<scalar& val>
+=
+    variable                    (. val = getDictLookup();
+                                   if (debug) {Info<<"lookup:"<<val<<nl;}
+                                 .)
+  | number                      (. val = getScalar();
+                                   if (debug) {Info<<"got num:"<<val<<nl;}
+                                 .)
+  | '-' '(' Expr<val> ')'       (. val = -val;
+                                   if (debug) {Info<<"inv:"<<val<<nl;}
+                                 .)
+  | '(' Expr<val> ')'           (. if (debug){Info<<"got Expr:"<<val<<nl;} .)
+.
+
+
+/*---------------------------------------------------------------------------*/
+
+END SimpleCalc.
+
+// ************************************************************************* //

applications/test/dictionary/calcEntry/build.sh

@@ -0,0 +1,11 @@
+#/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# this will have to do until we make a makefile rule
+
+Coco \
+    -frames $WM_THIRD_PARTY_DIR/coco-r \
+    -prefix calcEntry \
+    -namespace Foam::functionEntries::calcEntryInternal \
+    SimpleCalc.atg
+

applications/test/dictionary/calcEntry/calcEntry.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,6 +30,10 @@ License
 #include "OStringStream.H"
 #include "addToMemberFunctionSelectionTable.H"
 
+#include "ISstream.H"
+#include "CocoParserErrors.H"
+#include "calcEntryParser.h"
+
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
@@ -56,14 +60,121 @@ bool Foam::functionEntries::calcEntry::execute
 (
     const dictionary& parentDict,
     primitiveEntry& entry,
-    Istream& is
+    Istream& istr
 )
 {
-    dictionary args(parentDict, is);
+    static const int maxLen = 1024;
-    OStringStream resultStream;
+    static const int errLen = 80; // truncate error message for readability
-    resultStream
+    static char buf[maxLen];
-        << (args.lookup("x")[0].number() + args.lookup("y")[0].number());
+
-    entry.read(parentDict, IStringStream(resultStream.str())());
+    ISstream& is = dynamicCast<ISstream>(istr);
+
+    // get the { ... } argument without the enclosing brace brackets
+    //
+    // THIS NEEDS REWORKING (LATER) ...
+
+    char c = 0;
+
+    if (!is.read(c).good() || c != token::BEGIN_BLOCK)
+    {
+        is.setBad();
+        FatalIOErrorIn("functionEntries::calcEntry::execute()", is)
+            << "Expected a '" << token::BEGIN_BLOCK
+            << "', found '" << c << "'" << exit(FatalIOError);
+
+        return false;
+    }
+
+    register int nChar = 0;
+    buf[nChar++] = token::BEGIN_BLOCK;
+    int listDepth = 1;       // already saw the first '{'
+
+    while (is.get(c).good())
+    {
+        buf[nChar++] = c;
+        if (nChar == maxLen)
+        {
+            buf[errLen] = '\0';
+
+            FatalIOErrorIn("functionEntries::calcEntry::execute()", is)
+                << "argument \"" << buf << "...\"\n"
+                << "    is too long (max. " << maxLen << " characters)"
+                << exit(FatalIOError);
+
+            return false;
+        }
+
+        // handle nested blocks, even if we don't know what they'd
+        // be useful for
+        if (c == token::BEGIN_BLOCK)
+        {
+            ++listDepth;
+        }
+        else if (c == token::END_BLOCK)
+        {
+            if (--listDepth == 0)
+            {
+                // done reading - overwrite the final '}'
+                // --nChar;
+                break;
+            }
+        }
+    }
+
+    buf[nChar] = '\0';
+
+
+    // emit some info
+    Info<< "grabbed " << nChar << " characters:" << nl
+        << "----------\n"
+        << buf << nl
+        << "----------\n"
+        << nl;
+
+
+    // define parser error handler
+    CocoParserErrors<calcEntryInternal::Errors>
+        myErrorHandler("calcEntry::Parser--");
+
+    calcEntryInternal::Scanner scanner(buf, nChar);
+    calcEntryInternal::Parser  parser(&scanner, &myErrorHandler);
+
+    // Attach dictionary context
+    parser.dict(parentDict);
+
+    parser.Parse();
+
+//    Info<<"got: " << parser.Result() << endl;
+
+    tokenList tokens(2);
+    tokens[0] = parser.Result();
+    tokens[1] = token::END_STATEMENT;
+
+//     Info<<"tokens[0] = " << tokens[0].info() <<nl;
+//     Info<<"tokens[1] = " << tokens[1].info() <<nl;
+//
+//     {
+//     const tokenList& toks = entry;
+//
+//     forAll(toks, tokI)
+//     {
+//         Info<< tokI <<":= " << toks[tokI].info() << endl;
+//     }
+//     }
+
+    ITstream its("ParserResult", tokens);
+    entry.read(parentDict, its);
+//    Info<< "size: " << entry.size() << endl;
+//    entry = newente;
+//    entry.print(Info);
+
+///     const tokenList& toks = entry;
+///
+///     forAll(toks, tokI)
+///     {
+///         Info<< tokI <<":= " << toks[tokI].info() << endl;
+///     }
+///
     return true;
 }
 

applications/test/dictionary/calcEntry/calcEntry.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -26,6 +26,8 @@ Class
     Foam::functionEntries::calcEntry
 
 Description
+    This dictionary function entry may or may not do anything particularly
+    useful - depending upon what is currently being used to test.
 
 SourceFiles
     calcEntry.C
@@ -45,7 +47,7 @@ namespace functionEntries
 {
 
 /*---------------------------------------------------------------------------*\
-                           Class calcEntry Declaration
+                          Class calcEntry Declaration
 \*---------------------------------------------------------------------------*/
 
 class calcEntry

applications/test/dictionary/calcEntry/calcEntryParser.cpp

@@ -0,0 +1,324 @@
+
+
+#include <wchar.h>
+#include "calcEntryParser.h"
+
+
+namespace Foam {
+namespace functionEntries {
+namespace calcEntryInternal {
+
+
+// ----------------------------------------------------------------------------
+// Parser Implementation
+// ----------------------------------------------------------------------------
+
+void Parser::SynErr(int n) {
+	if (errDist >= minErrDist) errors->SynErr(la->line, la->col, n);
+	errDist = 0;
+}
+
+
+void Parser::SemErr(const wchar_t* msg) {
+	if (errDist >= minErrDist) errors->Error(t->line, t->col, msg);
+	errDist = 0;
+}
+
+
+void Parser::Get() {
+	for (;;) {
+		t = la;
+		la = scanner->Scan();
+		if (la->kind <= maxT) {
+			++errDist;
+			break;
+		}
+
+		if (dummyToken != t) {
+			dummyToken->kind = t->kind;
+			dummyToken->pos = t->pos;
+			dummyToken->col = t->col;
+			dummyToken->line = t->line;
+			dummyToken->next = NULL;
+			coco_string_delete(dummyToken->val);
+			dummyToken->val = coco_string_create(t->val);
+			t = dummyToken;
+		}
+		la = t;
+	}
+}
+
+
+void Parser::Expect(int n) {
+	if (la->kind == n) {
+		Get();
+	}
+	else {
+		SynErr(n);
+	}
+}
+
+
+void Parser::ExpectWeak(int n, int follow) {
+	if (la->kind == n) {
+		Get();
+	}
+	else {
+		SynErr(n);
+		while (!StartOf(follow)) {
+			Get();
+		}
+	}
+}
+
+
+bool Parser::WeakSeparator(int n, int syFol, int repFol) {
+	if (la->kind == n) {
+		Get();
+		return true;
+	}
+	else if (StartOf(repFol)) {
+		return false;
+	}
+	else {
+		SynErr(n);
+		while (!(StartOf(syFol) || StartOf(repFol) || StartOf(0))) {
+			Get();
+		}
+		return StartOf(syFol);
+	}
+}
+
+
+void Parser::SimpleCalc() {
+		val = 0;
+		if (debug){Info<<"start val"<< nl;}
+		
+		if (la->kind == 5) {
+			Get();
+			Expr(val);
+			Expect(6);
+		} else if (StartOf(1)) {
+			Expr(val);
+		} else SynErr(14);
+		Expect(0);
+}
+
+void Parser::Expr(scalar& val) {
+		scalar val2 = 0;
+		if (debug) {Info<<"Expr:"<< val<< nl;}
+		
+		Term(val);
+		while (la->kind == 7 || la->kind == 8) {
+			if (la->kind == 7) {
+				Get();
+				Term(val2);
+				if (debug) {Info<<"+Term:"<<val2 <<nl;}
+				val += val2;
+				if (debug) {Info<<"="<< val << nl;}
+				
+			} else {
+				Get();
+				Term(val2);
+				if (debug) {Info<<"-Term:"<<val2 <<nl;}
+				val -= val2;
+				if (debug) {Info<<"="<< val << nl;}
+				
+			}
+		}
+}
+
+void Parser::Term(scalar& val) {
+		scalar val2 = 0;
+		if (debug) {Info<<"Term:"<< val<< nl;}
+		
+		Factor(val);
+		while (la->kind == 9 || la->kind == 10) {
+			if (la->kind == 9) {
+				Get();
+				Factor(val2);
+				if (debug) {Info<<"*Factor:"<<val2 << nl;}
+				val *= val2;
+				if (debug) {Info<<"="<< val << nl; }
+				
+			} else {
+				Get();
+				Factor(val2);
+				if (debug) {Info<<"/Factor:"<<val2 << nl;}
+				val /= val2;
+				if (debug) {Info<<"="<< val << nl; }
+				
+			}
+		}
+}
+
+void Parser::Factor(scalar& val) {
+		if (la->kind == 3) {
+			Get();
+			val = getDictLookup();
+			if (debug) {Info<<"lookup:"<<val<<nl;}
+			
+		} else if (la->kind == 4) {
+			Get();
+			val = getScalar();
+			if (debug) {Info<<"got num:"<<val<<nl;}
+			
+		} else if (la->kind == 8) {
+			Get();
+			Expect(11);
+			Expr(val);
+			Expect(12);
+			val = -val;
+			if (debug) {Info<<"inv:"<<val<<nl;}
+			
+		} else if (la->kind == 11) {
+			Get();
+			Expr(val);
+			Expect(12);
+			if (debug){Info<<"got Expr:"<<val<<nl;} 
+		} else SynErr(15);
+}
+
+
+
+void Parser::Parse() {
+	t = NULL;
+	if (dummyToken) {    // safety: someone might call Parse() twice
+		delete dummyToken;
+	}
+	la = dummyToken = new Token();
+	la->val = coco_string_create(L"Dummy Token");
+	Get();
+	SimpleCalc();
+
+	Expect(0);
+}
+
+
+Parser::Parser(Scanner* scan, Errors* err)
+:
+	dummyToken(NULL),
+	deleteErrorsDestruct_(!err),
+	minErrDist(2),
+	errDist(minErrDist),
+	scanner(scan),
+	errors(err),
+	t(NULL),
+	la(NULL)
+{
+	maxT = 13;
+
+	if (!errors) {   // add in default error handling
+		errors = new Errors();
+	}
+}
+
+
+bool Parser::StartOf(int s) {
+	const bool T = true;
+	const bool x = false;
+
+	static bool set[2][15] = {
+		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,x,x,T, T,x,x,x, T,x,x,T, x,x,x}
+	};
+
+
+
+	return set[s][la->kind];
+}
+
+
+Parser::~Parser() {
+	if (deleteErrorsDestruct_) {    // delete default error handling
+		delete errors;
+	}
+	delete dummyToken;
+}
+
+
+// ----------------------------------------------------------------------------
+// Errors Implementation
+// ----------------------------------------------------------------------------
+
+Errors::Errors()
+:
+	count(0)
+{}
+
+
+Errors::~Errors()
+{}
+
+
+void Errors::clear() {
+	count = 0;
+}
+
+
+wchar_t* Errors::strerror(int n)
+{
+	wchar_t* s;
+	switch (n) {
+			case 0: s = coco_string_create(L"EOF expected"); break;
+			case 1: s = coco_string_create(L"ident expected"); break;
+			case 2: s = coco_string_create(L"string expected"); break;
+			case 3: s = coco_string_create(L"variable expected"); break;
+			case 4: s = coco_string_create(L"number expected"); break;
+			case 5: s = coco_string_create(L"\"{\" expected"); break;
+			case 6: s = coco_string_create(L"\"}\" expected"); break;
+			case 7: s = coco_string_create(L"\"+\" expected"); break;
+			case 8: s = coco_string_create(L"\"-\" expected"); break;
+			case 9: s = coco_string_create(L"\"*\" expected"); break;
+			case 10: s = coco_string_create(L"\"/\" expected"); break;
+			case 11: s = coco_string_create(L"\"(\" expected"); break;
+			case 12: s = coco_string_create(L"\")\" expected"); break;
+			case 13: s = coco_string_create(L"??? expected"); break;
+			case 14: s = coco_string_create(L"invalid SimpleCalc"); break;
+			case 15: s = coco_string_create(L"invalid Factor"); break;
+
+		default:
+		{
+			wchar_t format[20];
+			coco_swprintf(format, 20, L"error %d", n);
+			s = coco_string_create(format);
+		}
+		break;
+	}
+	return s;
+}
+
+
+void Errors::Warning(const wchar_t* msg) {
+	wprintf(L"%ls\n", msg);
+}
+
+
+void Errors::Warning(int line, int col, const wchar_t* msg) {
+	wprintf(L"-- line %d col %d: %ls\n", line, col, msg);
+}
+
+
+void Errors::Error(int line, int col, const wchar_t* msg) {
+	wprintf(L"-- line %d col %d: %ls\n", line, col, msg);
+	count++;
+}
+
+
+void Errors::SynErr(int line, int col, int n) {
+	wchar_t* msg = this->strerror(n);
+	this->Error(line, col, msg);
+	coco_string_delete(msg);
+}
+
+
+void Errors::Exception(const wchar_t* msg) {
+	wprintf(L"%ls", msg);
+	::exit(1);
+}
+
+} // namespace
+} // namespace
+} // namespace
+
+

applications/test/dictionary/calcEntry/calcEntryParser.h

@@ -0,0 +1,192 @@
+
+
+#ifndef COCO_calcEntryPARSER_H__
+#define COCO_calcEntryPARSER_H__
+
+#include "dictionary.H"
+#include "scalar.H"
+#include "error.H"
+#include "wchar.H"
+
+
+#include "calcEntryScanner.h"
+
+namespace Foam {
+namespace functionEntries {
+namespace calcEntryInternal {
+
+
+//! Parser error handing
+class Errors {
+public:
+	int count;      //!< The number of errors detected
+
+	//! Allocate and return a string describing the given error code.
+	/** It is the responsibility of the caller to free this string,
+	 *  eg, with coco_string_delete()
+	 */
+	static wchar_t* strerror(int n);
+
+	Errors();               //!< Construct null - start with no errors
+	virtual ~Errors();      //!< Destructor
+	virtual void clear();   //!< Clear the error count
+
+	//! Handle a general warning 'msg'
+	virtual void Warning(const wchar_t* msg);
+	//! Handle a general warning 'msg'
+	virtual void Warning(int line, int col, const wchar_t* msg);
+	//! Handle general error 'msg' (eg, a semantic error)
+	virtual void Error(int line, int col, const wchar_t* msg);
+	//! Handle syntax error 'n', uses strerror for the message, calls Error()
+	virtual void SynErr(int line, int col, int n);
+	//! Handle a general exception 'msg'
+	virtual void Exception(const wchar_t* msg);
+
+}; // Errors
+
+
+//! A Coco/R Parser
+class Parser {
+private:
+	enum {
+		_EOF=0,
+		_ident=1,
+		_string=2,
+		_variable=3,
+		_number=4,
+	};
+	int maxT;
+
+	Token *dummyToken;
+	bool deleteErrorsDestruct_; //!< delete the 'errors' member in destructor
+	int  minErrDist;
+	int  errDist;
+
+	void SynErr(int n);         //!< Handle syntax error 'n'
+	void Get();
+	void Expect(int n);
+	bool StartOf(int s);
+	void ExpectWeak(int n, int follow);
+	bool WeakSeparator(int n, int syFol, int repFol);
+
+public:
+	Scanner *scanner;
+	Errors  *errors;
+
+	Token *t;                   //!< last recognized token
+	Token *la;                  //!< lookahead token
+
+static const int debug = 0;
+
+    //! The parent dictionary
+    mutable dictionary* dict_;
+
+    //! The calculation result
+    scalar val;
+
+    //! token -> scalar
+    scalar getScalar() const
+    {
+        return coco_string_toDouble(t->val);
+    }
+
+    //! token -> string
+    std::string getString() const
+    {
+        char* str = coco_string_create_char(t->val);
+        std::string s(str);
+        coco_string_delete(str);
+        return s;
+    }
+
+
+    //! attach a dictionary
+    void dict(const dictionary& dict) const
+    {
+        dict_ = const_cast<dictionary*>(&dict);
+    }
+
+
+    //! lookup dictionary entry
+    scalar getDictLookup() const
+    {
+        scalar dictValue = 0;
+
+        if (!dict_)
+        {
+            FatalErrorIn
+            (
+                "SimpleCalc::getDictEntry() const"
+            )   << "No dictionary attached!"
+                << exit(FatalError);
+
+            return 0;
+        }
+
+        char* chars = coco_string_create_char
+        (
+            t->val,
+            1,
+            (coco_string_length(t->val) - 1)
+        );
+        word keyword(chars);
+        coco_string_delete(chars);
+
+        if (debug)
+        {
+            Info<<"lookup: " << keyword << nl;
+        }
+
+        entry* entryPtr = dict_->lookupEntryPtr(keyword, true, false);
+        if (entryPtr && !entryPtr->isDict())
+        {
+            entryPtr->stream() >> dictValue;
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "SimpleCalc::getDictEntry() const"
+            )   << "keyword " << keyword << " is undefined in dictionary "
+                << exit(FatalError);
+        }
+
+
+        return dictValue;
+    }
+
+    scalar Result() const
+    {
+        return val;
+    }
+
+
+// * * * * * * * * * * * * * * *  CHARACTERS * * * * * * * * * * * * * * * * //
+
+
+
+	//! Construct for the specified scanner
+	/**
+	 *  Use the default error handling, or optionally provide an error
+	 *  handler, which will not be deleted upon destruction.
+	 */
+	Parser(Scanner* scan, Errors* err = 0);
+	~Parser();      //!< Destructor - cleanup errors and dummyToken
+	void SemErr(const wchar_t* msg);    //!< Handle semantic error
+
+	void SimpleCalc();
+	void Expr(scalar& val);
+	void Term(scalar& val);
+	void Factor(scalar& val);
+
+	void Parse();                       //!< Execute the parse operation
+
+}; // end Parser
+
+} // namespace
+} // namespace
+} // namespace
+
+
+#endif // COCO_calcEntryPARSER_H__
+

applications/test/dictionary/calcEntry/calcEntryScanner.cpp

@@ -0,0 +1,825 @@
+
+
+#include <memory.h>
+#include <string.h>
+#include "calcEntryScanner.h"
+
+namespace Foam {
+namespace functionEntries {
+namespace calcEntryInternal {
+
+
+// * * * * * * * * * *  Wide Character String Routines * * * * * * * * * * * //
+
+// string handling, wide character
+
+wchar_t* coco_string_create(const wchar_t* str) {
+	int len = coco_string_length(str);
+	wchar_t* dest = new wchar_t[len + 1];
+	if (len) {
+		wcsncpy(dest, str, len);
+	}
+	dest[len] = 0;
+	return dest;
+}
+
+wchar_t* coco_string_create(const wchar_t* str, int index, int length) {
+	int len = coco_string_length(str);
+	if (len) {
+		len = length;
+	}
+	wchar_t* dest = new wchar_t[len + 1];
+	if (len) {
+		wcsncpy(dest, &(str[index]), len);
+	}
+	dest[len] = 0;
+	return dest;
+}
+
+wchar_t* coco_string_create_upper(const wchar_t* str) {
+	if (!str) { return NULL; }
+	return coco_string_create_upper(str, 0, wcslen(str));
+}
+
+
+wchar_t* coco_string_create_upper(const wchar_t* str, int index, int len) {
+	if (!str) { return NULL; }
+	wchar_t* dest = new wchar_t[len + 1];
+
+	for (int i = 0; i < len; i++) {
+		const wchar_t ch = str[index + i];
+		if ((L'a' <= ch) && (ch <= L'z')) {
+			dest[i] = ch + (L'A' - L'a');
+		}
+		else {
+			dest[i] = ch;
+		}
+	}
+	dest[len] = L'\0';
+	return dest;
+}
+
+
+wchar_t* coco_string_create_lower(const wchar_t* str) {
+	if (!str) { return NULL; }
+	return coco_string_create_lower(str, 0, wcslen(str));
+}
+
+
+wchar_t* coco_string_create_lower(const wchar_t* str, int index, int len) {
+	if (!str) { return NULL; }
+	wchar_t* dest = new wchar_t[len + 1];
+
+	for (int i = 0; i < len; i++) {
+		const wchar_t ch = str[index + i];
+		if ((L'A' <= ch) && (ch <= L'Z')) {
+			dest[i] = ch - (L'A' - L'a');
+		}
+		else {
+			dest[i] = ch;
+		}
+	}
+	dest[len] = L'\0';
+	return dest;
+}
+
+
+wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t* str2) {
+	int str1Len = coco_string_length(str1);
+	int str2Len = coco_string_length(str2);
+
+	wchar_t* dest = new wchar_t[str1Len + str2Len + 1];
+
+	if (str1Len) { wcscpy(dest, str1); }
+	if (str2Len) { wcscpy(dest + str1Len, str2); }
+
+	dest[str1Len + str2Len] = 0;
+	return dest;
+}
+
+wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t ch) {
+	int len = coco_string_length(str1);
+	wchar_t* dest = new wchar_t[len + 2];
+	wcsncpy(dest, str1, len);   // or use if (len) { wcscpy(dest, str1); }
+	dest[len] = ch;
+	dest[len + 1] = 0;
+	return dest;
+}
+
+void coco_string_delete(wchar_t* &str) {
+	delete [] str;
+	str = NULL;
+}
+
+int coco_string_length(const wchar_t* str) {
+	return str ? wcslen(str) : 0;
+}
+
+bool coco_string_endswith(const wchar_t* str, const wchar_t* endstr) {
+	int strLen = wcslen(str);
+	int endLen = wcslen(endstr);
+	return (endLen <= strLen) && (wcscmp(str + strLen - endLen, endstr) == 0);
+}
+
+int coco_string_indexof(const wchar_t* str, const wchar_t ch) {
+	const wchar_t* fnd = wcschr(str, ch);
+	return fnd ? (fnd - str) : -1;
+}
+
+int coco_string_lastindexof(const wchar_t* str, const wchar_t ch) {
+	const wchar_t* fnd = wcsrchr(str, ch);
+	return fnd ? (fnd - str) : -1;
+}
+
+void coco_string_merge(wchar_t* &dest, const wchar_t* str) {
+	if (!str) { return; }
+	wchar_t* newstr = coco_string_create_append(dest, str);
+	delete [] dest;
+	dest = newstr;
+}
+
+bool coco_string_equal(const wchar_t* str1, const wchar_t* str2) {
+	return wcscmp(str1, str2) == 0;
+}
+
+int coco_string_compareto(const wchar_t* str1, const wchar_t* str2) {
+	return wcscmp(str1, str2);
+}
+
+int coco_string_hash(const wchar_t* str) {
+	int h = 0;
+	if (!str) { return 0; }
+	while (*str != 0) {
+		h = (h * 7) ^ *str;
+		++str;
+	}
+	if (h < 0) { h = -h; }
+	return h;
+}
+
+
+double coco_string_toDouble(const wchar_t* str)
+{
+	return str ? wcstod(str, NULL) : 0;
+}
+
+float coco_string_toFloat(const wchar_t* str)
+{
+	return str ? wcstof(str, NULL) : 0;
+}
+
+
+
+//
+// string handling, byte character
+//
+
+wchar_t* coco_string_create(const char* str) {
+	int len = str ? strlen(str) : 0;
+	wchar_t* dest = new wchar_t[len + 1];
+	for (int i = 0; i < len; ++i) {
+		dest[i] = (wchar_t) str[i];
+	}
+	dest[len] = 0;
+	return dest;
+}
+
+wchar_t* coco_string_create(const char* str, int index, int length) {
+	int len = str ? length : 0;
+	wchar_t* dest = new wchar_t[len + 1];
+	for (int i = 0; i < len; ++i) {
+		dest[i] = (wchar_t) str[index + i];
+	}
+	dest[len] = 0;
+	return dest;
+}
+
+
+char* coco_string_create_char(const wchar_t* str) {
+	int len = coco_string_length(str);
+	char *dest = new char[len + 1];
+	for (int i = 0; i < len; ++i)
+	{
+		dest[i] = (char) str[i];
+	}
+	dest[len] = 0;
+	return dest;
+}
+
+char* coco_string_create_char(const wchar_t* str, int index, int length) {
+	int len = coco_string_length(str);
+	if (len) {
+		len = length;
+	}
+	char *dest = new char[len + 1];
+	for (int i = 0; i < len; ++i) {
+		dest[i] = (char) str[index + i];
+	}
+	dest[len] = 0;
+	return dest;
+}
+
+
+void coco_string_delete(char* &str) {
+	delete [] str;
+	str = NULL;
+}
+
+
+double coco_string_toDouble(const char* str)
+{
+	return str ? strtod(str, NULL) : 0;
+}
+
+float coco_string_toFloat(const char* str)
+{
+	return str ? strtof(str, NULL) : 0;
+}
+
+
+// * * * * * * * * * End of Wide Character String Routines * * * * * * * * * //
+
+
+Token::Token()
+:
+    kind(0),
+    pos(0),
+    col(0),
+    line(0),
+    val(NULL),
+    next(NULL)
+{}
+
+
+Token::~Token() {
+	coco_string_delete(val);
+}
+
+
+Buffer::Buffer(FILE* s, bool isUserStream) {
+// ensure binary read on windows
+#if _MSC_VER >= 1300
+	_setmode(_fileno(s), _O_BINARY);
+#endif
+	stream = s; this->isUserStream = isUserStream;
+	if (CanSeek()) {
+		fseek(s, 0, SEEK_END);
+		fileLen = ftell(s);
+		fseek(s, 0, SEEK_SET);
+		bufLen = (fileLen < MAX_BUFFER_LENGTH) ? fileLen : MAX_BUFFER_LENGTH;
+		bufStart = INT_MAX; // nothing in the buffer so far
+	}
+	else {
+		fileLen = bufLen = bufStart = 0;
+	}
+	bufCapacity = (bufLen > 0) ? bufLen : MIN_BUFFER_LENGTH;
+	buf = new unsigned char[bufCapacity];
+	if (fileLen > 0) SetPos(0);          // setup buffer to position 0 (start)
+	else bufPos = 0; // index 0 is already after the file, thus Pos = 0 is invalid
+	if (bufLen == fileLen && CanSeek()) Close();
+}
+
+
+Buffer::Buffer(Buffer* b) {
+	buf = b->buf;
+	bufCapacity = b->bufCapacity;
+	b->buf = NULL;
+	bufStart = b->bufStart;
+	bufLen = b->bufLen;
+	fileLen = b->fileLen;
+	bufPos = b->bufPos;
+	stream = b->stream;
+	b->stream = NULL;
+	isUserStream = b->isUserStream;
+}
+
+
+Buffer::Buffer(const unsigned char* buf, int len) {
+	this->buf = new unsigned char[len];
+	memcpy(this->buf, buf, len*sizeof(unsigned char));
+	bufStart = 0;
+	bufCapacity = bufLen = len;
+	fileLen = len;
+	bufPos = 0;
+	stream = NULL;
+}
+
+
+Buffer::Buffer(const char* buf, int len) {
+	this->buf = new unsigned char[len];
+	memcpy(this->buf, buf, len*sizeof(unsigned char));
+	bufStart = 0;
+	bufCapacity = bufLen = len;
+	fileLen = len;
+	bufPos = 0;
+	stream = NULL;
+}
+
+
+Buffer::~Buffer() {
+	Close();
+	if (buf != NULL) {
+		delete [] buf;
+		buf = NULL;
+	}
+}
+
+
+void Buffer::Close() {
+	if (!isUserStream && stream != NULL) {
+		fclose(stream);
+		stream = NULL;
+	}
+}
+
+
+int Buffer::Read() {
+	if (bufPos < bufLen) {
+		return buf[bufPos++];
+	} else if (GetPos() < fileLen) {
+		SetPos(GetPos()); // shift buffer start to Pos
+		return buf[bufPos++];
+	} else if ((stream != NULL) && !CanSeek() && (ReadNextStreamChunk() > 0)) {
+		return buf[bufPos++];
+	} else {
+		return EoF;
+	}
+}
+
+
+int Buffer::Peek() {
+	int curPos = GetPos();
+	int ch = Read();
+	SetPos(curPos);
+	return ch;
+}
+
+
+wchar_t* Buffer::GetString(int beg, int end) {
+	int len = 0;
+	wchar_t *buf = new wchar_t[end - beg];
+	int oldPos = GetPos();
+	SetPos(beg);
+	while (GetPos() < end) buf[len++] = (wchar_t) Read();
+	SetPos(oldPos);
+	wchar_t *res = coco_string_create(buf, 0, len);
+	coco_string_delete(buf);
+	return res;
+}
+
+
+int Buffer::GetPos() {
+	return bufPos + bufStart;
+}
+
+
+void Buffer::SetPos(int value) {
+	if ((value >= fileLen) && (stream != NULL) && !CanSeek()) {
+		// Wanted position is after buffer and the stream
+		// is not seek-able e.g. network or console,
+		// thus we have to read the stream manually till
+		// the wanted position is in sight.
+		while ((value >= fileLen) && (ReadNextStreamChunk() > 0))
+		{}
+	}
+
+	if ((value < 0) || (value > fileLen)) {
+		wprintf(L"--- buffer out of bounds access, position: %d\n", value);
+		::exit(1);
+	}
+
+	if ((value >= bufStart) && (value < (bufStart + bufLen))) { // already in buffer
+		bufPos = value - bufStart;
+	} else if (stream != NULL) { // must be swapped in
+		fseek(stream, value, SEEK_SET);
+		bufLen = fread(buf, sizeof(unsigned char), bufCapacity, stream);
+		bufStart = value; bufPos = 0;
+	} else {
+		bufPos = fileLen - bufStart; // make Pos return fileLen
+	}
+}
+
+
+// Read the next chunk of bytes from the stream, increases the buffer
+// if needed and updates the fields fileLen and bufLen.
+// Returns the number of bytes read.
+int Buffer::ReadNextStreamChunk() {
+	int freeLen = bufCapacity - bufLen;
+	if (freeLen == 0) {
+		// in the case of a growing input stream
+		// we can neither seek in the stream, nor can we
+		// foresee the maximum length, thus we must adapt
+		// the buffer size on demand.
+		bufCapacity = bufLen * 2;
+		unsigned char *newBuf = new unsigned char[bufCapacity];
+		memcpy(newBuf, buf, bufLen*sizeof(unsigned char));
+		delete [] buf;
+		buf = newBuf;
+		freeLen = bufLen;
+	}
+	int read = fread(buf + bufLen, sizeof(unsigned char), freeLen, stream);
+	if (read > 0) {
+		fileLen = bufLen = (bufLen + read);
+		return read;
+	}
+	// end of stream reached
+	return 0;
+}
+
+
+bool Buffer::CanSeek() {
+	return (stream != NULL) && (ftell(stream) != -1);
+}
+
+
+int UTF8Buffer::Read() {
+	int ch;
+	do {
+		ch = Buffer::Read();
+		// until we find a utf8 start (0xxxxxxx or 11xxxxxx)
+	} while ((ch >= 128) && ((ch & 0xC0) != 0xC0) && (ch != EoF));
+	if (ch < 128 || ch == EoF) {
+		// nothing to do, first 127 chars are the same in ascii and utf8
+		// 0xxxxxxx or end of file character
+	} else if ((ch & 0xF0) == 0xF0) {
+		// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+		int c1 = ch & 0x07; ch = Buffer::Read();
+		int c2 = ch & 0x3F; ch = Buffer::Read();
+		int c3 = ch & 0x3F; ch = Buffer::Read();
+		int c4 = ch & 0x3F;
+		ch = (((((c1 << 6) | c2) << 6) | c3) << 6) | c4;
+	} else if ((ch & 0xE0) == 0xE0) {
+		// 1110xxxx 10xxxxxx 10xxxxxx
+		int c1 = ch & 0x0F; ch = Buffer::Read();
+		int c2 = ch & 0x3F; ch = Buffer::Read();
+		int c3 = ch & 0x3F;
+		ch = (((c1 << 6) | c2) << 6) | c3;
+	} else if ((ch & 0xC0) == 0xC0) {
+		// 110xxxxx 10xxxxxx
+		int c1 = ch & 0x1F; ch = Buffer::Read();
+		int c2 = ch & 0x3F;
+		ch = (c1 << 6) | c2;
+	}
+	return ch;
+}
+
+
+Scanner::Scanner(const unsigned char* buf, int len) {
+	buffer = new Buffer(buf, len);
+	Init();
+}
+
+
+Scanner::Scanner(const char* buf, int len) {
+	buffer = new Buffer(buf, len);
+	Init();
+}
+
+
+Scanner::Scanner(const wchar_t* fileName) {
+	FILE* stream;
+	char *chFileName = coco_string_create_char(fileName);
+	if ((stream = fopen(chFileName, "rb")) == NULL) {
+		wprintf(L"--- Cannot open file %ls\n", fileName);
+		::exit(1);
+	}
+	coco_string_delete(chFileName);
+	buffer = new Buffer(stream, false);
+	Init();
+}
+
+
+Scanner::Scanner(FILE* s) {
+	buffer = new Buffer(s, true);
+	Init();
+}
+
+
+Scanner::~Scanner() {
+	char* cur = (char*) firstHeap;
+
+	while (cur != NULL) {
+		cur = *(char**) (cur + HEAP_BLOCK_SIZE);
+		free(firstHeap);
+		firstHeap = cur;
+	}
+	delete [] tval;
+	delete buffer;
+}
+
+
+void Scanner::Init() {
+	maxT = 13;
+	noSym = 13;
+	int i;
+	for (i = 65; i <= 90; ++i) start.set(i, 1);
+	for (i = 97; i <= 122; ++i) start.set(i, 1);
+	for (i = 36; i <= 36; ++i) start.set(i, 5);
+	start.set(45, 20);
+	for (i = 48; i <= 57; ++i) start.set(i, 9);
+	start.set(34, 2);
+	start.set(46, 7);
+	start.set(123, 14);
+	start.set(125, 15);
+	start.set(43, 21);
+	start.set(42, 16);
+	start.set(47, 17);
+	start.set(40, 18);
+	start.set(41, 19);
+		start.set(Buffer::EoF, -1);
+
+
+	tvalLength = 128;
+	tval = new wchar_t[tvalLength]; // text of current token
+
+	// HEAP_BLOCK_SIZE byte heap + pointer to next heap block
+	heap = malloc(HEAP_BLOCK_SIZE + sizeof(void*));
+	firstHeap = heap;
+	heapEnd = (void**) (((char*) heap) + HEAP_BLOCK_SIZE);
+	*heapEnd = 0;
+	heapTop = heap;
+	if (sizeof(Token) > HEAP_BLOCK_SIZE) {
+		wprintf(L"--- Too small HEAP_BLOCK_SIZE\n");
+		::exit(1);
+	}
+
+	pos = -1; line = 1; col = 0;
+	oldEols = 0;
+	NextCh();
+	if (ch == 0xEF) { // check optional byte order mark for UTF-8
+		NextCh(); int ch1 = ch;
+		NextCh(); int ch2 = ch;
+		if (ch1 != 0xBB || ch2 != 0xBF) {
+			wprintf(L"Illegal byte order mark at start of file");
+			::exit(1);
+		}
+		Buffer *oldBuf = buffer;
+		buffer = new UTF8Buffer(buffer); col = 0;
+		delete oldBuf; oldBuf = NULL;
+		NextCh();
+	}
+
+
+	pt = tokens = CreateToken(); // first token is a dummy
+}
+
+
+void Scanner::NextCh() {
+	if (oldEols > 0) {
+		ch = EOL;
+		oldEols--;
+	}
+	else {
+		pos = buffer->GetPos();
+		ch = buffer->Read(); col++;
+		// replace isolated '\r' by '\n' in order to make
+		// eol handling uniform across Windows, Unix and Mac
+		if (ch == L'\r' && buffer->Peek() != L'\n') ch = EOL;
+		if (ch == EOL) { line++; col = 0; }
+	}
+
+}
+
+
+void Scanner::AddCh() {
+	if (tlen >= tvalLength) {
+		tvalLength *= 2;
+		wchar_t *newBuf = new wchar_t[tvalLength];
+		memcpy(newBuf, tval, tlen*sizeof(wchar_t));
+		delete [] tval;
+		tval = newBuf;
+	}
+	if (ch != Buffer::EoF) {
+		tval[tlen++] = ch;
+		NextCh();
+	}
+}
+
+
+
+bool Scanner::Comment0() {
+	int level = 1, pos0 = pos, line0 = line, col0 = col;
+	NextCh();
+	if (ch == L'/') {
+		NextCh();
+		for(;;) {
+			if (ch == 10) {
+				level--;
+				if (level == 0) { oldEols = line - line0; NextCh(); return true; }
+				NextCh();
+			} else if (ch == buffer->EoF) return false;
+			else NextCh();
+		}
+	} else {
+		buffer->SetPos(pos0); NextCh(); line = line0; col = col0;
+	}
+	return false;
+}
+
+bool Scanner::Comment1() {
+	int level = 1, pos0 = pos, line0 = line, col0 = col;
+	NextCh();
+	if (ch == L'*') {
+		NextCh();
+		for(;;) {
+			if (ch == L'*') {
+				NextCh();
+				if (ch == L'/') {
+					level--;
+					if (level == 0) { oldEols = line - line0; NextCh(); return true; }
+					NextCh();
+				}
+			} else if (ch == L'/') {
+				NextCh();
+				if (ch == L'*') {
+					level++; NextCh();
+				}
+			} else if (ch == buffer->EoF) return false;
+			else NextCh();
+		}
+	} else {
+		buffer->SetPos(pos0); NextCh(); line = line0; col = col0;
+	}
+	return false;
+}
+
+
+void Scanner::CreateHeapBlock() {
+	void* newHeap;
+	char* cur = (char*) firstHeap;
+
+	while (((char*) tokens < cur) || ((char*) tokens > (cur + HEAP_BLOCK_SIZE))) {
+		cur = *((char**) (cur + HEAP_BLOCK_SIZE));
+		free(firstHeap);
+		firstHeap = cur;
+	}
+
+	// HEAP_BLOCK_SIZE byte heap + pointer to next heap block
+	newHeap = malloc(HEAP_BLOCK_SIZE + sizeof(void*));
+	*heapEnd = newHeap;
+	heapEnd = (void**) (((char*) newHeap) + HEAP_BLOCK_SIZE);
+	*heapEnd = 0;
+	heap = newHeap;
+	heapTop = heap;
+}
+
+
+Token* Scanner::CreateToken() {
+	Token *t;
+	if (((char*) heapTop + (int) sizeof(Token)) >= (char*) heapEnd) {
+		CreateHeapBlock();
+	}
+	t = (Token*) heapTop;
+	heapTop = (void*) ((char*) heapTop + sizeof(Token));
+	t->val = NULL;
+	t->next = NULL;
+	return t;
+}
+
+
+void Scanner::AppendVal(Token *t) {
+	int reqMem = (tlen + 1) * sizeof(wchar_t);
+	if (((char*) heapTop + reqMem) >= (char*) heapEnd) {
+		if (reqMem > HEAP_BLOCK_SIZE) {
+			wprintf(L"--- Too long token value\n");
+			::exit(1);
+		}
+		CreateHeapBlock();
+	}
+	t->val = (wchar_t*) heapTop;
+	heapTop = (void*) ((char*) heapTop + reqMem);
+
+	wcsncpy(t->val, tval, tlen);
+	t->val[tlen] = L'\0';
+}
+
+
+Token* Scanner::NextToken() {
+	while (ch == ' ' ||
+			ch <= 31 || (ch >= 127 && ch <= 65535)
+	) NextCh();
+	if ((ch == L'/' && Comment0()) || (ch == L'/' && Comment1())) return NextToken();
+	t = CreateToken();
+	t->pos = pos; t->col = col; t->line = line;
+	int state = start.state(ch);
+	tlen = 0; AddCh();
+
+	switch (state) {
+		case -1: { t->kind = eofSym; break; } // NextCh already done
+		case 0: { t->kind = noSym; break; }   // NextCh already done
+		case 1:
+			case_1:
+			if ((ch >= L'0' && ch <= L':') || (ch >= L'A' && ch <= L'Z') || ch == L'_' || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_1;}
+			else {t->kind = 1; break;}
+		case 2:
+			case_2:
+			if (ch <= 9 || (ch >= 11 && ch <= 12) || (ch >= 14 && ch <= L'!') || (ch >= L'#' && ch <= L'[') || (ch >= L']' && ch <= 65535)) {AddCh(); goto case_2;}
+			else if (ch == L'"') {AddCh(); goto case_4;}
+			else if (ch == 92) {AddCh(); goto case_3;}
+			else {t->kind = noSym; break;}
+		case 3:
+			case_3:
+			if ((ch >= L' ' && ch <= L'~')) {AddCh(); goto case_2;}
+			else {t->kind = noSym; break;}
+		case 4:
+			case_4:
+			{t->kind = 2; break;}
+		case 5:
+			if ((ch >= L'A' && ch <= L'Z') || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_6;}
+			else {t->kind = noSym; break;}
+		case 6:
+			case_6:
+			if ((ch >= L'0' && ch <= L':') || (ch >= L'A' && ch <= L'Z') || ch == L'_' || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_6;}
+			else {t->kind = 3; break;}
+		case 7:
+			case_7:
+			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_8;}
+			else {t->kind = noSym; break;}
+		case 8:
+			case_8:
+			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_8;}
+			else {t->kind = 4; break;}
+		case 9:
+			case_9:
+			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_9;}
+			else if (ch == L'E' || ch == L'e') {AddCh(); goto case_10;}
+			else if (ch == L'.') {AddCh(); goto case_13;}
+			else {t->kind = 4; break;}
+		case 10:
+			case_10:
+			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
+			else if (ch == L'+' || ch == L'-') {AddCh(); goto case_11;}
+			else {t->kind = noSym; break;}
+		case 11:
+			case_11:
+			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
+			else {t->kind = noSym; break;}
+		case 12:
+			case_12:
+			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
+			else {t->kind = 4; break;}
+		case 13:
+			case_13:
+			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_13;}
+			else if (ch == L'E' || ch == L'e') {AddCh(); goto case_10;}
+			else {t->kind = 4; break;}
+		case 14:
+			{t->kind = 5; break;}
+		case 15:
+			{t->kind = 6; break;}
+		case 16:
+			{t->kind = 9; break;}
+		case 17:
+			{t->kind = 10; break;}
+		case 18:
+			{t->kind = 11; break;}
+		case 19:
+			{t->kind = 12; break;}
+		case 20:
+			if (ch == L'.') {AddCh(); goto case_7;}
+			else {t->kind = 8; break;}
+		case 21:
+			if (ch == L'.') {AddCh(); goto case_7;}
+			else {t->kind = 7; break;}
+
+	}
+	AppendVal(t);
+	return t;
+}
+
+
+// get the next token (possibly a token already seen during peeking)
+Token* Scanner::Scan() {
+	if (tokens->next == NULL) {
+		return pt = tokens = NextToken();
+	} else {
+		pt = tokens = tokens->next;
+		return tokens;
+	}
+}
+
+
+// peek for the next token, ignore pragmas
+Token* Scanner::Peek() {
+	do {
+		if (pt->next == NULL) {
+			pt->next = NextToken();
+		}
+		pt = pt->next;
+	} while (pt->kind > maxT); // skip pragmas
+
+	return pt;
+}
+
+
+// make sure that peeking starts at the current scan position
+void Scanner::ResetPeek() {
+	pt = tokens;
+}
+
+
+} // namespace
+} // namespace
+} // namespace
+
+

applications/test/dictionary/calcEntry/calcEntryScanner.h

@@ -0,0 +1,379 @@
+
+
+#ifndef COCO_calcEntrySCANNER_H__
+#define COCO_calcEntrySCANNER_H__
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+// io.h and fcntl are used to ensure binary read from streams on windows
+#if _MSC_VER >= 1300
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+#if _MSC_VER >= 1400
+#define coco_swprintf swprintf_s
+#elif _MSC_VER >= 1300
+#define coco_swprintf _snwprintf
+#else
+// assume every other compiler knows swprintf
+#define coco_swprintf swprintf
+#endif
+
+#define COCO_WCHAR_MAX    65535
+#define MIN_BUFFER_LENGTH 1024
+#define MAX_BUFFER_LENGTH (64*MIN_BUFFER_LENGTH)
+#define HEAP_BLOCK_SIZE   (64*1024)
+
+
+namespace Foam {
+namespace functionEntries {
+namespace calcEntryInternal {
+
+
+
+// * * * * * * * * * *  Wide Character String Routines * * * * * * * * * * * //
+
+//
+// string handling, wide character
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+//! Create by copying str
+wchar_t* coco_string_create(const wchar_t* str);
+
+//! Create a substring of str starting at index and length characters long
+wchar_t* coco_string_create(const wchar_t* str, int index, int length);
+
+//! Create an uppercase string from str
+wchar_t* coco_string_create_upper(const wchar_t* str);
+
+//! Create an uppercase substring from str starting at index and length characters long
+wchar_t* coco_string_create_upper(const wchar_t* str, int index, int length);
+
+//! Create a lowercase string from str
+wchar_t* coco_string_create_lower(const wchar_t* str);
+
+//! Create a lowercase substring from str starting at index and length characters long
+wchar_t* coco_string_create_lower(const wchar_t* str, int index, int length);
+
+//! Create a string by concatenating str1 and str2
+wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t* str2);
+
+//! Create a string by concatenating a character to the end of str
+wchar_t* coco_string_create_append(const wchar_t* str, const wchar_t ch);
+
+//! Free storage and nullify the argument
+void  coco_string_delete(wchar_t* &str);
+
+//! The length of the str, or 0 if the str is NULL
+int   coco_string_length(const wchar_t* str);
+
+//! Return true if the str ends with the endstr
+bool  coco_string_endswith(const wchar_t* str, const wchar_t* endstr);
+
+//! Return the index of the first occurrence of ch.
+//  Return -1 if nothing is found.
+int   coco_string_indexof(const wchar_t* str, const wchar_t ch);
+
+//! Return the index of the last occurrence of ch.
+//  Return -1 if nothing is found.
+int   coco_string_lastindexof(const wchar_t* str, const wchar_t ch);
+
+//! Append str to dest
+void  coco_string_merge(wchar_t* &dest, const wchar_t* str);
+
+//! Compare strings, return true if they are equal
+bool  coco_string_equal(const wchar_t* str1, const wchar_t* str2);
+
+//! Compare strings, return 0 if they are equal
+int   coco_string_compareto(const wchar_t* str1, const wchar_t* str2);
+
+//! Simple string hashing function
+int   coco_string_hash(const wchar_t* str);
+
+//
+// String conversions
+// ~~~~~~~~~~~~~~~~~~
+
+//! Convert wide string to double
+double coco_string_toDouble(const wchar_t* str);
+
+//! Convert wide string to float
+float coco_string_toFloat(const wchar_t* str);
+
+//
+// String handling, byte character
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+//! Create by copying byte str
+wchar_t* coco_string_create(const char* str);
+
+//! Create a substring of byte str starting at index and length characters long
+wchar_t* coco_string_create(const char* str, int index, int length);
+
+//! Create a byte string by copying str
+char* coco_string_create_char(const wchar_t* str);
+
+//! Create a byte substring of str starting at index and length characters long
+char* coco_string_create_char(const wchar_t* str, int index, int length);
+
+//! Free storage and nullify the argument
+void  coco_string_delete(char* &str);
+
+
+//
+// String conversions, byte character
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+//! Convert byte string to double
+double coco_string_toDouble(const char* str);
+
+//! Convert byte string to float
+float coco_string_toFloat(const char* str);
+
+// * * * * * * * * * End of Wide Character String Routines * * * * * * * * * //
+
+
+
+//! Scanner Token
+class Token
+{
+public:
+	int kind;       //!< token kind
+	int pos;        //!< token position in the source text (starting at 0)
+	int col;        //!< token column (starting at 1)
+	int line;       //!< token line (starting at 1)
+	wchar_t* val;   //!< token value
+	Token *next;    //!< Peek tokens are kept in linked list
+
+	Token();        //!< Construct null
+	~Token();       //!< Destructor - cleanup allocated val
+};
+
+
+//! Scanner Buffer
+//
+//! This Buffer supports the following cases:
+//! -# seekable stream (file)
+//!    -# whole stream in buffer
+//!    -# part of stream in buffer
+//! -# non seekable stream (network, console)
+class Buffer {
+private:
+	unsigned char *buf; //!< input buffer
+	int bufCapacity;    //!< capacity of buf
+	int bufStart;       //!< position of first byte in buffer relative to input stream
+	int bufLen;         //!< length of buffer
+	int fileLen;        //!< length of input stream (may change if the stream is no file)
+	int bufPos;         //!< current position in buffer
+	FILE* stream;       //!< input stream (seekable)
+	bool isUserStream;  //!< was the stream opened by the user?
+
+	int ReadNextStreamChunk();
+	bool CanSeek();     //!< true if stream can be seeked otherwise false
+
+public:
+	static const int EoF = COCO_WCHAR_MAX + 1;
+
+	Buffer(FILE*, bool isUserStream);
+	Buffer(const unsigned char* buf, int len);
+	Buffer(const char* buf, int len);
+	Buffer(Buffer*);
+	virtual ~Buffer();
+
+	virtual void Close();
+	virtual int Read();
+	virtual int Peek();
+	virtual wchar_t* GetString(int beg, int end);
+	virtual int GetPos();
+	virtual void SetPos(int value);
+};
+
+
+//! A Scanner buffer that handles UTF-8 characters
+class UTF8Buffer : public Buffer {
+public:
+	UTF8Buffer(Buffer* b) : Buffer(b) {}
+	virtual int Read();
+};
+
+
+//------------------------------------------------------------------------------
+// StartStates
+//------------------------------------------------------------------------------
+//! maps characters to start states of tokens
+class StartStates {
+private:
+	class Elem {
+	public:
+		int key, val;
+		Elem *next;
+		Elem(int key, int val) {
+			this->key = key;
+			this->val = val;
+			next = NULL;
+		}
+	};
+
+	Elem **tab;
+
+public:
+	StartStates() {
+		tab = new Elem*[128];
+		memset(tab, 0, 128 * sizeof(Elem*));
+	}
+	virtual ~StartStates() {
+		for (int i = 0; i < 128; ++i) {
+			Elem *e = tab[i];
+			while (e != NULL) {
+				Elem *next = e->next;
+				delete e;
+				e = next;
+			}
+		}
+		delete [] tab;
+	}
+
+	void set(int key, int val) {
+		Elem *e = new Elem(key, val);
+		int k = ((unsigned int) key) % 128;
+		e->next = tab[k];
+		tab[k] = e;
+	}
+
+	int state(int key) {
+		Elem *e = tab[((unsigned int) key) % 128];
+		while (e != NULL && e->key != key) e = e->next;
+		return e == NULL ? 0 : e->val;
+	}
+};
+
+
+//------------------------------------------------------------------------------
+// KeywordMap
+//------------------------------------------------------------------------------
+//! maps strings to integers (identifiers to keyword kinds)
+class KeywordMap {
+private:
+	class Elem {
+	public:
+		wchar_t *key;
+		int val;
+		Elem *next;
+		Elem(const wchar_t *key, int val) {
+			this->key = coco_string_create(key);
+			this->val = val;
+			next = NULL;
+		}
+		virtual ~Elem() {
+			coco_string_delete(key);
+		}
+	};
+
+	Elem **tab;
+
+public:
+	KeywordMap() {
+		tab = new Elem*[128];
+		memset(tab, 0, 128 * sizeof(Elem*));
+	}
+	virtual ~KeywordMap() {
+		for (int i = 0; i < 128; ++i) {
+			Elem *e = tab[i];
+			while (e != NULL) {
+				Elem *next = e->next;
+				delete e;
+				e = next;
+			}
+		}
+		delete [] tab;
+	}
+
+	void set(const wchar_t *key, int val) {
+		Elem *e = new Elem(key, val);
+		int k = coco_string_hash(key) % 128;
+		e->next = tab[k]; tab[k] = e;
+	}
+
+	int get(const wchar_t *key, int defaultVal) {
+		Elem *e = tab[coco_string_hash(key) % 128];
+		while (e != NULL && !coco_string_equal(e->key, key)) e = e->next;
+		return e == NULL ? defaultVal : e->val;
+	}
+};
+
+
+//! A Coco/R Scanner
+class Scanner {
+private:
+	static const unsigned char EOL = '\n';   // end-of-line character
+	static const int eofSym = 0;             // end-of-file token id
+
+	void *firstHeap;
+	void *heap;
+	void *heapTop;
+	void **heapEnd;
+
+	int noSym;        //!< noSym gets highest number, set in Parser
+	int maxT;
+	int charSetSize;  //!< unused?
+	StartStates start;
+	KeywordMap keywords;
+
+	Token *t;         //!< current token
+	wchar_t *tval;    //!< text of current token
+	int tvalLength;   //!< length of text of current token
+	int tlen;         //!< length of current token
+
+	Token *tokens;    //!< list of tokens already peeked (first token is a dummy)
+	Token *pt;        //!< current peek token
+
+	int ch;           //!< current input character
+
+	int pos;          //!< byte position of current character
+	int line;         //!< line number of current character
+	int col;          //!< column number of current character
+	int oldEols;      //!< EOLs that appeared in a comment;
+
+	void CreateHeapBlock();
+	Token* CreateToken();
+	void AppendVal(Token*);
+
+	void Init();
+	void NextCh();
+	void AddCh();
+	bool Comment0();
+	bool Comment1();
+
+	Token* NextToken();
+
+public:
+	//! scanner buffer
+	Buffer *buffer;
+
+	//! Attach scanner to an existing character buffer
+	Scanner(const unsigned char* buf, int len);
+	//! Attach scanner to an existing character buffer
+	Scanner(const char* buf, int len);
+	//! Open a file for reading and attach scanner
+	Scanner(const wchar_t* fileName);
+	//! Using an existing open file handle for the scanner
+	Scanner(FILE* s);
+	~Scanner();
+	Token* Scan();
+	Token* Peek();
+	void ResetPeek();
+
+}; // end Scanner
+
+} // namespace
+} // namespace
+} // namespace
+
+
+#endif // COCO_calcEntrySCANNER_H__
+

applications/test/dictionary/dictionaryTest.C

@@ -43,70 +43,86 @@ using namespace Foam;
 int main(int argc, char *argv[])
 {
     argList::noParallel();
-    argList args(argc, argv);
+    argList::validArgs.insert("dict .. dictN");
+    argList args(argc, argv, false, true);
 
     Info<< nl
         << "FOAM_CASE=" << getEnv("FOAM_CASE") << nl
         << "FOAM_CASENAME=" << getEnv("FOAM_CASENAME") << nl
         << endl;
 
-
+    if (args.additionalArgs().empty())
     {
-        dictionary dict1(IFstream("testDict")());
+        {
-        Info<< "dict1: " << dict1 << nl
+            dictionary dict1(IFstream("testDict")());
-            << "toc: " << dict1.toc() << nl
+            Info<< "dict1: " << dict1 << nl
-            << "keys: " << dict1.keys() << nl
+                << "toc: " << dict1.toc() << nl
-            << "patterns: " << dict1.keys(true) << endl;
+                << "keys: " << dict1.keys() << nl
+                << "patterns: " << dict1.keys(true) << endl;
 
-        dictionary dict2(dict1.xfer());
+            dictionary dict2(dict1.xfer());
 
-        Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << nl
+            Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << nl
-            << "dict2.toc(): " << dict2.name() << " " << dict2.toc() << endl;
+                << "dict2.toc(): " << dict2.name() << " " << dict2.toc() << endl;
 
-        // copy back
+            // copy back
-        dict1 = dict2;
+            dict1 = dict2;
-        Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << endl;
+            Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << endl;
 
-        dictionary dict3(dict2.subDictPtr("boundaryField"));
+            dictionary dict3(dict2.subDictPtr("boundaryField"));
-        dictionary dict4(dict2.subDictPtr("NONEXISTENT"));
+            dictionary dict4(dict2.subDictPtr("NONEXISTENT"));
 
-        Info<< "dictionary construct from pointer" << nl
+            Info<< "dictionary construct from pointer" << nl
-            << "ok = " << dict3.name() << " " << dict3.toc() << nl
+                << "ok = " << dict3.name() << " " << dict3.toc() << nl
-            << "no = " << dict4.name() << " " << dict4.toc() << endl;
+                << "no = " << dict4.name() << " " << dict4.toc() << endl;
+        }
+
+
+        IOobject::writeDivider(Info);
+
+        {
+            dictionary dict(IFstream("testDictRegex")());
+            dict.add(keyType("fooba[rz]", true), "anything");
+
+            Info<< "dict:" << dict << nl
+                << "toc: " << dict.toc() << nl
+                << "keys: " << dict.keys() << nl
+                << "patterns: " << dict.keys(true) << endl;
+
+            Info<< "Pattern find \"abc\" in top directory : "
+                << dict.lookup("abc") << endl;
+            Info<< "Pattern find \"abc\" in sub directory : "
+                << dict.subDict("someDict").lookup("abc")
+                    << endl;
+            Info<< "Recursive pattern find \"def\" in sub directory : "
+                << dict.subDict("someDict").lookup("def", true)
+                    << endl;
+            Info<< "Recursive pattern find \"foo\" in sub directory : "
+                << dict.subDict("someDict").lookup("foo", true)
+                    << endl;
+            Info<< "Recursive pattern find \"fooz\" in sub directory : "
+                << dict.subDict("someDict").lookup("fooz", true)
+                    << endl;
+            Info<< "Recursive pattern find \"bar\" in sub directory : "
+                << dict.subDict("someDict").lookup("bar", true)
+                    << endl;
+            Info<< "Recursive pattern find \"xxx\" in sub directory : "
+                << dict.subDict("someDict").lookup("xxx", true)
+                    << endl;
+        }
     }
-
+    else
-
-    IOobject::writeDivider(Info);
-
     {
-        dictionary dict(IFstream("testDictRegex")());
+        IOobject::writeDivider(Info);
-        dict.add(keyType("fooba[rz]", true), "anything");
+        forAll(args.additionalArgs(), argI)
+        {
+            const string& dictFile = args.additionalArgs()[argI];
+            IFstream is(dictFile);
 
-        Info<< "dict:" << dict << nl
+            dictionary dict(is);
-            << "toc: " << dict.toc() << nl
-            << "keys: " << dict.keys() << nl
-            << "patterns: " << dict.keys(true) << endl;
 
-        Info<< "Pattern find \"abc\" in top directory : "
+            Info<< dict << endl;
-            << dict.lookup("abc") << endl;
+        }
-        Info<< "Pattern find \"abc\" in sub directory : "
-            << dict.subDict("someDict").lookup("abc")
-            << endl;
-        Info<< "Recursive pattern find \"def\" in sub directory : "
-            << dict.subDict("someDict").lookup("def", true)
-            << endl;
-        Info<< "Recursive pattern find \"foo\" in sub directory : "
-            << dict.subDict("someDict").lookup("foo", true)
-            << endl;
-        Info<< "Recursive pattern find \"fooz\" in sub directory : "
-            << dict.subDict("someDict").lookup("fooz", true)
-            << endl;
-        Info<< "Recursive pattern find \"bar\" in sub directory : "
-            << dict.subDict("someDict").lookup("bar", true)
-            << endl;
-        Info<< "Recursive pattern find \"xxx\" in sub directory : "
-            << dict.subDict("someDict").lookup("xxx", true)
-            << endl;
     }
 
     return 0;

applications/test/dictionary/testDictCalc

@@ -0,0 +1,33 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  Any                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      testDictTest;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+x       10 /* what ever */ 20;
+y       20;
+// z       #test{ // this
+//     123 - 456
+//         // comments // are
+//         /* stripped
+//         * 10
+//          * {}
+//          */
+//         + 1 /*100 */  10
+// };
+
+p       #test{ 1 + 2 + 10 * 15 + $x - $y };
+
+foo     30;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/test/fileNameClean/fileNameCleanTest.C

@@ -66,17 +66,18 @@ int main(int argc, char *argv[])
     argList::noBanner();
     argList::noParallel();
     argList::validArgs.insert("fileName .. fileNameN");
+    argList::addOption("istream", "fileName", "test Istream values");
 
     argList args(argc, argv, false, true);
 
-    if (args.additionalArgs().empty())
+    if (args.additionalArgs().empty() && args.options().empty())
     {
         args.printUsage();
     }
 
-    if (args.optionFound("case"))
+    fileName pathName;
+    if (args.optionReadIfPresent("case", pathName))
     {
-        fileName pathName = args.option("case");
         Info<< nl
             << "-case" << nl
             << "path = " << args.path() << nl
@@ -91,7 +92,23 @@ int main(int argc, char *argv[])
 
     forAll(args.additionalArgs(), argI)
     {
-        fileName pathName = args.additionalArgs()[argI];
+        pathName = args.additionalArgs()[argI];
+        printCleaning(pathName);
+    }
+
+    if (args.optionFound("istream"))
+    {
+        args.optionLookup("istream")() >> pathName;
+
+        Info<< nl
+            << "-case" << nl
+            << "path = " << args.path() << nl
+            << "root = " << args.rootPath() << nl
+            << "case = " << args.caseName() << nl
+            << "FOAM_CASE=" << getEnv("FOAM_CASE") << nl
+            << "FOAM_CASENAME=" << getEnv("FOAM_CASENAME") << nl
+            << endl;
+
         printCleaning(pathName);
     }
 

applications/test/fvSolutionCombine/fvSolutionCombine.C

@@ -98,8 +98,9 @@ bool checkDictionaryContent(const dictionary& dict1, const dictionary& dict2)
 int main(int argc, char *argv[])
 {
     argList::noParallel();
-    argList::validOptions.insert("rewrite", "");
+    argList::addBoolOption("rewrite");
-    argList::validOptions.insert("show", "");
+    argList::addBoolOption("show");
+
     argList args(argc, argv);
 
     Time runTime(args.rootPath(), args.caseName());

applications/test/momentOfInertia/momentOfInertiaTest.C

@@ -27,12 +27,14 @@ Application
 
 Description
     Calculates the inertia tensor and principal axes and moments of a
-    test face.
+    test face and tetrahedron.
 
 \*---------------------------------------------------------------------------*/
 
 #include "ListOps.H"
 #include "face.H"
+#include "tetPointRef.H"
+#include "triFaceList.H"
 #include "OFstream.H"
 #include "meshTools.H"
 
@@ -40,67 +42,310 @@ Description
 
 using namespace Foam;
 
+void massPropertiesSolid
+(
+    const pointField& pts,
+    const triFaceList triFaces,
+    scalar density,
+    scalar& mass,
+    vector& cM,
+    tensor& J
+)
+{
+    // Reimplemented from: Wm4PolyhedralMassProperties.cpp
+    // File Version: 4.10.0 (2009/11/18)
+
+    // Geometric Tools, LC
+    // Copyright (c) 1998-2010
+    // Distributed under the Boost Software License, Version 1.0.
+    // http://www.boost.org/LICENSE_1_0.txt
+    // http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
+
+    // Boost Software License - Version 1.0 - August 17th, 2003
+
+    // Permission is hereby granted, free of charge, to any person or
+    // organization obtaining a copy of the software and accompanying
+    // documentation covered by this license (the "Software") to use,
+    // reproduce, display, distribute, execute, and transmit the
+    // Software, and to prepare derivative works of the Software, and
+    // to permit third-parties to whom the Software is furnished to do
+    // so, all subject to the following:
+
+    // The copyright notices in the Software and this entire
+    // statement, including the above license grant, this restriction
+    // and the following disclaimer, must be included in all copies of
+    // the Software, in whole or in part, and all derivative works of
+    // the Software, unless such copies or derivative works are solely
+    // in the form of machine-executable object code generated by a
+    // source language processor.
+
+    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+    // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+    // NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+    // ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+    // OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+    // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+    // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+    const scalar r6 = 1.0/6.0;
+    const scalar r24 = 1.0/24.0;
+    const scalar r60 = 1.0/60.0;
+    const scalar r120 = 1.0/120.0;
+
+    // order:  1, x, y, z, x^2, y^2, z^2, xy, yz, zx
+    scalarField integrals(10, 0.0);
+
+    forAll(triFaces, i)
+    {
+        const triFace& tri(triFaces[i]);
+
+        // vertices of triangle i
+        vector v0 = pts[tri[0]];
+        vector v1 = pts[tri[1]];
+        vector v2 = pts[tri[2]];
+
+        // cross product of edges
+        vector eA = v1 - v0;
+        vector eB = v2 - v0;
+        vector n = eA ^ eB;
+
+        // compute integral terms
+        scalar tmp0, tmp1, tmp2;
+
+        scalar f1x, f2x, f3x, g0x, g1x, g2x;
+
+        tmp0 = v0.x() + v1.x();
+        f1x = tmp0 + v2.x();
+        tmp1 = v0.x()*v0.x();
+        tmp2 = tmp1 + v1.x()*tmp0;
+        f2x = tmp2 + v2.x()*f1x;
+        f3x = v0.x()*tmp1 + v1.x()*tmp2 + v2.x()*f2x;
+        g0x = f2x + v0.x()*(f1x + v0.x());
+        g1x = f2x + v1.x()*(f1x + v1.x());
+        g2x = f2x + v2.x()*(f1x + v2.x());
+
+        scalar f1y, f2y, f3y, g0y, g1y, g2y;
+
+        tmp0 = v0.y() + v1.y();
+        f1y = tmp0 + v2.y();
+        tmp1 = v0.y()*v0.y();
+        tmp2 = tmp1 + v1.y()*tmp0;
+        f2y = tmp2 + v2.y()*f1y;
+        f3y = v0.y()*tmp1 + v1.y()*tmp2 + v2.y()*f2y;
+        g0y = f2y + v0.y()*(f1y + v0.y());
+        g1y = f2y + v1.y()*(f1y + v1.y());
+        g2y = f2y + v2.y()*(f1y + v2.y());
+
+        scalar f1z, f2z, f3z, g0z, g1z, g2z;
+
+        tmp0 = v0.z() + v1.z();
+        f1z = tmp0 + v2.z();
+        tmp1 = v0.z()*v0.z();
+        tmp2 = tmp1 + v1.z()*tmp0;
+        f2z = tmp2 + v2.z()*f1z;
+        f3z = v0.z()*tmp1 + v1.z()*tmp2 + v2.z()*f2z;
+        g0z = f2z + v0.z()*(f1z + v0.z());
+        g1z = f2z + v1.z()*(f1z + v1.z());
+        g2z = f2z + v2.z()*(f1z + v2.z());
+
+        // update integrals
+        integrals[0] += n.x()*f1x;
+        integrals[1] += n.x()*f2x;
+        integrals[2] += n.y()*f2y;
+        integrals[3] += n.z()*f2z;
+        integrals[4] += n.x()*f3x;
+        integrals[5] += n.y()*f3y;
+        integrals[6] += n.z()*f3z;
+        integrals[7] += n.x()*(v0.y()*g0x + v1.y()*g1x + v2.y()*g2x);
+        integrals[8] += n.y()*(v0.z()*g0y + v1.z()*g1y + v2.z()*g2y);
+        integrals[9] += n.z()*(v0.x()*g0z + v1.x()*g1z + v2.x()*g2z);
+    }
+
+    integrals[0] *= r6;
+    integrals[1] *= r24;
+    integrals[2] *= r24;
+    integrals[3] *= r24;
+    integrals[4] *= r60;
+    integrals[5] *= r60;
+    integrals[6] *= r60;
+    integrals[7] *= r120;
+    integrals[8] *= r120;
+    integrals[9] *= r120;
+
+    // mass
+    mass = integrals[0];
+
+    // center of mass
+    cM = vector(integrals[1], integrals[2], integrals[3])/mass;
+
+    // inertia relative to origin
+    J.xx() = integrals[5] + integrals[6];
+    J.xy() = -integrals[7];
+    J.xz() = -integrals[9];
+    J.yx() = J.xy();
+    J.yy() = integrals[4] + integrals[6];
+    J.yz() = -integrals[8];
+    J.zx() = J.xz();
+    J.zy() = J.yz();
+    J.zz() = integrals[4] + integrals[5];
+
+    // inertia relative to center of mass
+    J -= mass*((cM & cM)*I - cM*cM);
+
+    // Apply density
+    mass *= density;
+    J *= density;
+}
+
+
 int main(int argc, char *argv[])
 {
-    label nPts = 6;
-
-    pointField pts(nPts);
-
-    pts[0] = point(4.495, 3.717, -4.112);
-    pts[1] = point(4.421, 3.932, -4.112);
-    pts[2] = point(4.379, 4.053, -4.112);
-    pts[3] = point(4.301, 4.026, -4.300);
-    pts[4] = point(4.294, 4.024, -4.317);
-    pts[5] = point(4.409, 3.687, -4.317);
-
     scalar density = 1.0;
 
-    face f(identity(nPts));
-
-    point Cf = f.centre(pts);
-
-    tensor J = tensor::zero;
-
-    J = f.inertia(pts, Cf, density);
-
-    vector eVal = eigenValues(J);
-
-    tensor eVec = eigenVectors(J);
-
-    Info<< nl << "Inertia tensor of test face " << J << nl
-        << "eigenValues (principal moments) " << eVal << nl
-        << "eigenVectors (principal axes) " << eVec
-        << endl;
-
-    OFstream str("momentOfInertiaTest.obj");
-
-    Info<< nl << "Writing test face and scaled principal axes to "
-        << str.name() << endl;
-
-    forAll(pts, ptI)
     {
-        meshTools::writeOBJ(str, pts[ptI]);
+        label nPts = 6;
+
+        pointField pts(nPts);
+
+        pts[0] = point(4.495, 3.717, -4.112);
+        pts[1] = point(4.421, 3.932, -4.112);
+        pts[2] = point(4.379, 4.053, -4.112);
+        pts[3] = point(4.301, 4.026, -4.300);
+        pts[4] = point(4.294, 4.024, -4.317);
+        pts[5] = point(4.409, 3.687, -4.317);
+
+        face f(identity(nPts));
+
+        point Cf = f.centre(pts);
+
+        tensor J = tensor::zero;
+
+        J = f.inertia(pts, Cf, density);
+
+        vector eVal = eigenValues(J);
+
+        tensor eVec = eigenVectors(J);
+
+        Info<< nl << "Inertia tensor of test face " << J << nl
+            << "eigenValues (principal moments) " << eVal << nl
+            << "eigenVectors (principal axes) " << eVec
+            << endl;
+
+        OFstream str("momentOfInertiaTestFace.obj");
+
+        Info<< nl << "Writing test face and scaled principal axes to "
+            << str.name() << endl;
+
+        forAll(pts, ptI)
+        {
+            meshTools::writeOBJ(str, pts[ptI]);
+        }
+
+        str << "l";
+
+        forAll(f, fI)
+        {
+            str << ' ' << fI + 1;
+        }
+
+        str << " 1" << endl;
+
+        scalar scale = mag(Cf - pts[f[0]])/eVal.component(findMin(eVal));
+
+        meshTools::writeOBJ(str, Cf);
+        meshTools::writeOBJ(str, Cf + scale*eVal.x()*eVec.x());
+        meshTools::writeOBJ(str, Cf + scale*eVal.y()*eVec.y());
+        meshTools::writeOBJ(str, Cf + scale*eVal.z()*eVec.z());
+
+        for (label i = nPts + 1; i < nPts + 4; i++)
+        {
+            str << "l " << nPts + 1 << ' ' << i + 1 << endl;
+        }
     }
 
-    str << "l";
-
-    forAll(f, fI)
     {
-        str << ' ' << fI + 1;
+        label nPts = 4;
-    }
 
-    str << " 1" << endl;
+        pointField pts(nPts);
 
-    scalar scale = mag(Cf - pts[f[0]])/eVal.component(findMin(eVal));
+        pts[0] = point(0, 0, 0);
+        pts[1] = point(1, 0, 0);
+        pts[2] = point(0.5, 1, 0);
+        pts[3] = point(0.5, 0.5, 1);
 
-    meshTools::writeOBJ(str, Cf);
+        tetPointRef tet(pts[0], pts[1], pts[2], pts[3]);
-    meshTools::writeOBJ(str, Cf + scale*eVal.x()*eVec.x());
+
-    meshTools::writeOBJ(str, Cf + scale*eVal.y()*eVec.y());
+        triFaceList tetFaces(4);
-    meshTools::writeOBJ(str, Cf + scale*eVal.z()*eVec.z());
+
+        tetFaces[0] = triFace(0, 2, 1);
+        tetFaces[1] = triFace(1, 2, 3);
+        tetFaces[2] = triFace(0, 3, 2);
+        tetFaces[3] = triFace(0, 1, 3);
+
+        scalar m = 0.0;
+        vector cM = vector::zero;
+        tensor J = tensor::zero;
+
+        massPropertiesSolid
+        (
+
+            pts,
+            tetFaces,
+            density,
+            m,
+            cM,
+            J
+        );
+
+        vector eVal = eigenValues(J);
+
+        tensor eVec = eigenVectors(J);
+
+        Info<< nl
+            << "Mass of tetrahedron " << m << nl
+            << "Centre of mass of tetrahedron " << cM << nl
+            << "Inertia tensor of tetrahedron " << J << nl
+            << "eigenValues (principal moments) " << eVal << nl
+            << "eigenVectors (principal axes) " << eVec
+            << endl;
+
+        OFstream str("momentOfInertiaTestTet.obj");
+
+        Info<< nl << "Writing test tetrahedron and scaled principal axes to "
+            << str.name() << endl;
+
+        forAll(pts, ptI)
+        {
+            meshTools::writeOBJ(str, pts[ptI]);
+        }
+
+        forAll(tetFaces, tFI)
+        {
+            const triFace& f = tetFaces[tFI];
+
+            str << "l";
+
+            forAll(f, fI)
+            {
+                str << ' ' << f[fI] + 1;
+            }
+
+            str << ' ' << f[0] + 1 << endl;
+        }
+
+        scalar scale = mag(cM - pts[0])/eVal.component(findMin(eVal));
+
+        meshTools::writeOBJ(str, cM);
+        meshTools::writeOBJ(str, cM + scale*eVal.x()*eVec.x());
+        meshTools::writeOBJ(str, cM + scale*eVal.y()*eVec.y());
+        meshTools::writeOBJ(str, cM + scale*eVal.z()*eVec.z());
+
+        for (label i = nPts + 1; i < nPts + 4; i++)
+        {
+            str << "l " << nPts + 1 << ' ' << i + 1 << endl;
+        }
 
-    for (label i = nPts + 1; i < nPts + 4; i++)
-    {
-        str << "l " << nPts + 1 << ' ' << i + 1 << endl;
     }
 
     Info<< nl << "End" << nl << endl;

applications/test/mvBak/mvBakTest.C

@@ -39,8 +39,9 @@ int main(int argc, char *argv[])
     argList::noBanner();
     argList::noParallel();
     argList::validArgs.insert("file .. fileN");
-    argList::validOptions.erase("case");
+
-    argList::validOptions.insert("ext", "bak");
+    argList::removeOption("case");
+    argList::addOption("ext", "bak");
 
     argList args(argc, argv, false, true);
 

applications/test/nearWallDist-wave/testWallDist2.C

@@ -73,7 +73,7 @@ int main(int argc, char *argv[])
 
     // Count walls
     label nWalls = 0;
-    forAll (mesh.boundary(), patchI)
+    forAll(mesh.boundary(), patchI)
     {
         const fvPatch& patch = mesh.boundary()[patchI];
 
@@ -87,13 +87,13 @@ int main(int argc, char *argv[])
     labelList changedFaces(nWalls);
 
     label nChangedFaces = 0;
-    forAll (mesh.boundary(), patchI)
+    forAll(mesh.boundary(), patchI)
     {
         const fvPatch& patch = mesh.boundary()[patchI];
 
         if (isA<wallFvPatch>(patch))
         {
-            forAll (patch.Cf(), patchFaceI)
+            forAll(patch.Cf(), patchFaceI)
             {
                 const polyPatch& polyPatch = mesh.boundaryMesh()[patchI];
 
@@ -170,7 +170,7 @@ int main(int argc, char *argv[])
         }
 
         // Copy boundary values
-        forAll (wallDistUncorrected.boundaryField(), patchI)
+        forAll(wallDistUncorrected.boundaryField(), patchI)
         {
             fvPatchScalarField& patchField =
                 wallDistUncorrected.boundaryField()[patchI];

applications/test/readCHEMKINIII/readCHEMKINIII.C

@@ -38,7 +38,7 @@ int main(int argc, char *argv[])
 {
     argList::validArgs.clear();
     argList::validArgs.append("CHEMKINIIIFile");
-    argList::validOptions.insert("thermo", "fileName");
+    argList::addOption("thermo", "fileName");
     argList args(argc, argv);
 
     fileName thermoFileName = fileName::null;
@@ -72,7 +72,7 @@ int main(int argc, char *argv[])
 
         PtrList<gasReaction> testReactions(nReactions);
 
-        forAll (testReactions, i)
+        forAll(testReactions, i)
         {
             testReactions.set
             (

applications/test/router/processorRouter.C

@@ -53,7 +53,7 @@ labelList procNeighbours(const polyMesh& mesh)
 
     label nNeighbours = 0;
 
-    forAll (mesh.boundaryMesh(), patchI)
+    forAll(mesh.boundaryMesh(), patchI)
     {
         if (isA<processorPolyPatch>(mesh.boundaryMesh()[patchI]))
         {
@@ -65,7 +65,7 @@ labelList procNeighbours(const polyMesh& mesh)
 
     nNeighbours = 0;
 
-    forAll (mesh.boundaryMesh(), patchI)
+    forAll(mesh.boundaryMesh(), patchI)
     {
         if (isA<processorPolyPatch>(mesh.boundaryMesh()[patchI]))
         {

applications/test/sizeof/Make/files

@@ -0,0 +1,3 @@
+sizeofTest.C
+
+EXE = $(FOAM_USER_APPBIN)/sizeofTest

applications/test/sizeof/Make/options

@@ -0,0 +1,2 @@
+/* EXE_INC = -I$(LIB_SRC)/cfdTools/include */
+/* EXE_LIBS = -lfiniteVolume */

applications/test/sizeof/sizeofTest.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,73 +22,83 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
+Description
+    Test the sizeof various classes.
+
 \*---------------------------------------------------------------------------*/
 
-#include "spline.H"
+#include "bool.H"
+#include "Switch.H"
+#include "string.H"
+#include "dictionary.H"
+#include "nil.H"
+#include "IOstreams.H"
+#include "IStringStream.H"
 
-// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+namespace Foam
-
-Foam::scalar Foam::spline::B(const scalar tau)
 {
-    if (tau <= -2.0 || tau >= 2.0)
+   class hasBoolClass
-    {
+   {
-        return 0.0;
+   public:
-    }
+      bool b_;
-    else if (tau <= -1.0)
+
-    {
+      hasBoolClass(const bool val=false)
-        return pow((2.0 + tau), 3.0)/6.0;
+      :
-    }
+          b_(false)
-    else if (tau <= 0.0)
+      {}
-    {
+   };
-        return (4.0 - 6.0*tau*tau - 3.0*tau*tau*tau)/6.0;
-    }
-    else if (tau <= 1.0)
-    {
-        return (4.0 - 6.0*tau*tau + 3.0*tau*tau*tau)/6.0;
-    }
-    else if (tau <= 2.0)
-    {
-        return pow((2.0 - tau), 3.0)/6.0;
-    }
-    else
-    {
-        FatalErrorIn("spline::B(const scalar)")
-            << "Programming error???, "
-            << "tau = " << tau
-            << abort(FatalError);
-    }
 
-    return 0.0;
 }
 
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+using namespace Foam;
 
-Foam::spline::spline(const pointField& knotPoints)
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-:
+// Main program:
-    knots_(knotPoints)
-{}
 
-
+int main(int argc, char *argv[])
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::point Foam::spline::position(const scalar mu) const
 {
-    point loc(point::zero);
+    cout<<"sizeof\n------\n";
-
-    for (register label i=0; i < knots_.size(); i++)
     {
-        loc += B((knots_.size() - 1)*mu - i)*knots_[i];
+        nil x;
+        cout<<"nil:" << sizeof(x) << nl;
+    }
+    {
+        bool x(0);
+        cout<<"bool:" << sizeof(x) << nl;
+    }
+    {
+        hasBoolClass x(true);
+        cout<<"hasBoolClass:" << sizeof(x) << nl;
     }
 
-    return loc;
+    {
-}
+        Switch x("n");
+        cout<<"Switch:" << sizeof(x) << nl;
+        cout<<"Switch::switchType=" << sizeof(Switch::switchType) << nl;
+    }
+
+    {
+        scalar x(0);
+        cout<<"scalar:" << sizeof(x) << nl;
+    }
+
+    {
+        label x(0);
+        cout<<"label:" << sizeof(x) << nl;
+    }
+
+    {
+        cout<<"int:" << sizeof(int) << nl;
+        cout<<"long:" << sizeof(long) << nl;
+        cout<<"float:" << sizeof(float) << nl;
+        cout<<"double:" << sizeof(double) << nl;
+    }
 
 
-Foam::scalar Foam::spline::length() const
+    Info << "---\nEnd\n" << endl;
-{
+
-    notImplemented("spline::length() const");
+    return 0;
-    return 1.0;
 }
 
 

applications/test/spline/Make/files

@@ -0,0 +1,3 @@
+splineTest.C
+
+EXE = $(FOAM_USER_APPBIN)/splineTest

applications/test/spline/splineTest.C

@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+#include "argList.H"
+
+#include "vector.H"
+#include "IFstream.H"
+
+#include "BSpline.H"
+#include "CatmullRomSpline.H"
+
+using namespace Foam;
+
+inline Ostream& printPoint(Ostream& os, const point& p)
+{
+    os  << p.x() << ' ' << p.y() << ' ' << p.z() << nl;
+    return os;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::validArgs.insert("file .. fileN");
+    argList::addBoolOption("B", "B-Spline implementation");
+    argList::addBoolOption("CMR", "catmull-rom spline (default)");
+    argList::addOption
+    (
+        "n",
+        "INT",
+        "number of segments for evaluation - default 20"
+    );
+
+    argList args(argc, argv, false, true);
+
+    if (args.additionalArgs().empty())
+    {
+        args.printUsage();
+    }
+
+    bool useBSpline = args.optionFound("B");
+    bool useCatmullRom = args.optionFound("CMR");
+    label nSeg = args.optionLookupOrDefault<label>("n", 20);
+
+    if (!useCatmullRom && !useBSpline)
+    {
+        Info<<"defaulting to Catmull-Rom spline" << endl;
+        useCatmullRom = true;
+    }
+
+    forAll(args.additionalArgs(), argI)
+    {
+        const string& srcFile = args.additionalArgs()[argI];
+        Info<< nl << "reading " << srcFile << nl;
+        IFstream ifs(srcFile);
+
+        List<pointField> pointFields(ifs);
+
+
+        forAll(pointFields, splineI)
+        {
+            Info<<"\n# points:" << endl;
+            forAll(pointFields[splineI], ptI)
+            {
+                printPoint(Info, pointFields[splineI][ptI]);
+            }
+
+            if (useBSpline)
+            {
+                BSpline spl(pointFields[splineI]);
+
+                Info<< nl << "# B-Spline" << endl;
+
+                for (label segI = 0; segI <= nSeg; ++segI)
+                {
+                    scalar lambda = scalar(segI)/scalar(nSeg);
+                    printPoint(Info, spl.position(lambda));
+                }
+            }
+
+            if (useCatmullRom)
+            {
+                CatmullRomSpline spl(pointFields[splineI]);
+
+                Info<< nl <<"# Catmull-Rom" << endl;
+
+                for (label segI = 0; segI <= nSeg; ++segI)
+                {
+                    scalar lambda = scalar(segI)/scalar(nSeg);
+                    printPoint(Info, spl.position(lambda));
+                }
+            }
+
+            {
+                polyLine pl(pointFields[splineI]);
+
+                Info<< nl <<"# polyList" << endl;
+
+                for (label segI = 0; segI <= nSeg; ++segI)
+                {
+                    scalar lambda = scalar(segI)/scalar(nSeg);
+                    printPoint(Info, pl.position(lambda));
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/spline/test-splines

@@ -0,0 +1,46 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  1.6                                   |
+|   \\  /    A nd           | Web:      http://www.OpenFOAM.org               |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+(
+    // Upper body longitudinal splines
+    (
+        (0.22685 0.01125166 0)       // 7
+        (0.21685 0.01340204 0)
+        (0.20685 0.01529684 0)
+        (0.19685 0.01694748 0)
+        (0.18685 0.01836538 0)
+        (0.17685 0.01956197 0)
+        (0.16685 0.02054868 0)
+        (0.15685 0.02133693 0)
+        (0.14685 0.02193816 0)
+        (0.13685 0.02236377 0)
+        (0.12685 0.02262521 0)
+        (0.11685 0.02273389 0)       // 2
+    )
+
+    // sine function
+    (
+        (0    0 0)
+        (45   0.70707  0)
+        (90   1 0)
+        (135  0.70707  0)
+        (180  0 0)
+        (225 -0.70707  0)
+        (270 -1 0)
+        (315 -0.70707  0)
+        (360  0 0)
+    )
+
+    // cosine function, but with extremely few points
+    (
+        (0    1 0)
+        (180 -1 0)
+        (360  1 0)
+    )
+
+
+);

applications/test/tokenizeTest/tokenizeTest.C

@@ -44,16 +44,14 @@ int main(int argc, char *argv[])
 {
     argList::noParallel();
     argList::validArgs.insert("string .. stringN");
-    argList::validOptions.insert("file", "name");
+    argList::addOption("file", "name");
-    argList::validOptions.insert("repeat", "count");
+    argList::addOption("repeat", "count");
 
     argList args(argc, argv, false, true);
 
-    label repeat = 1;
+    const label repeat = args.optionLookupOrDefault<label>("repeat", 1);
-    args.optionReadIfPresent<label>("repeat", repeat);
 
     cpuTime timer;
-
     for (label count = 0; count < repeat; ++count)
     {
         forAll(args.additionalArgs(), argI)
@@ -69,9 +67,15 @@ int main(int argc, char *argv[])
             while (is.good())
             {
                 token tok(is);
+                // char ch;
+                // is.get(ch);
+                // is.putback(ch);
+                int lookahead = is.peek();
+
                 if (count == 0)
                 {
-                    Info<< "token: " << tok.info() << endl;
+                    Info<< "token: " << tok.info();
+                    Info<< "  lookahead: '" << char(lookahead) << "'" << endl;
                 }
             }
 

applications/utilities/errorEstimation/estimateScalarError/Make/options

@@ -1,5 +1,5 @@
 EXE_INC = \
-	-I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/errorEstimation/lnInclude
 
 EXE_LIBS = \

applications/utilities/errorEstimation/icoErrorEstimate/Make/options

@@ -1,5 +1,5 @@
 EXE_INC = \
-	-I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/errorEstimation/lnInclude
 
 EXE_LIBS = \

applications/utilities/errorEstimation/icoMomentError/Make/options

@@ -1,5 +1,5 @@
 EXE_INC = \
-	-I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/errorEstimation/lnInclude
 
 EXE_LIBS = \

applications/utilities/errorEstimation/momentScalarError/Make/options

@@ -1,5 +1,5 @@
 EXE_INC = \
-	-I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/errorEstimation/lnInclude
 
 EXE_LIBS = \

applications/utilities/mesh/advanced/collapseEdges/collapseEdges.C

@@ -454,7 +454,7 @@ label simplifyFaces
 int main(int argc, char *argv[])
 {
     argList::noParallel();
-    argList::validOptions.insert("overwrite", "");
+    argList::addBoolOption("overwrite");
     argList::validArgs.append("edge length [m]");
     argList::validArgs.append("merge angle (degrees)");
 

applications/utilities/mesh/advanced/combinePatchFaces/combinePatchFaces.C

@@ -59,10 +59,6 @@ using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// Sin of angle between two consecutive edges on a face. If sin(angle) larger
-// than this the face will be considered concave.
-const scalar defaultConcaveAngle = 30;
-
 
 // Same check as snapMesh
 void checkSnapMesh
@@ -433,9 +429,9 @@ label mergeEdges(const scalar minCos, polyMesh& mesh)
 int main(int argc, char *argv[])
 {
     argList::validArgs.append("feature angle [0..180]");
-    argList::validOptions.insert("concaveAngle", "[0..180]");
+    argList::addOption("concaveAngle", "[0..180]");
-    argList::validOptions.insert("snapMesh", "");
+    argList::addBoolOption("snapMesh");
-    argList::validOptions.insert("overwrite", "");
+    argList::addBoolOption("overwrite");
 
 #   include "setRootCase.H"
 #   include "createTime.H"
@@ -447,8 +443,9 @@ int main(int argc, char *argv[])
 
     scalar minCos = Foam::cos(degToRad(featureAngle));
 
-    scalar concaveAngle = defaultConcaveAngle;
+    // Sin of angle between two consecutive edges on a face.
-    args.optionReadIfPresent("concaveAngle", concaveAngle);
+    // If sin(angle) larger than this the face will be considered concave.
+    scalar concaveAngle = args.optionLookupOrDefault("concaveAngle", 30.0);
 
     scalar concaveSin = Foam::sin(degToRad(concaveAngle));
 
@@ -483,8 +480,8 @@ int main(int argc, char *argv[])
     // Merge points on straight edges and remove unused points
     if (snapMeshDict)
     {
-        Info<< "Merging all 'loose' points on surface edges"
+        Info<< "Merging all 'loose' points on surface edges, "
-            << ", regardless of the angle they make." << endl;
+            << "regardless of the angle they make." << endl;
 
         // Surface bnound to be used to extrude. Merge all loose points.
         nChanged += mergeEdges(-1, mesh);
@@ -510,7 +507,7 @@ int main(int argc, char *argv[])
         Info<< "Mesh unchanged." << endl;
     }
 
-    Info<< "End\n" << endl;
+    Info<< "\nEnd\n" << endl;
 
     return 0;
 }

applications/utilities/mesh/advanced/modifyMesh/cellSplitter.C

@@ -22,8 +22,6 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-
 \*---------------------------------------------------------------------------*/
 
 #include "cellSplitter.H"
@@ -39,12 +37,8 @@ Description
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::cellSplitter, 0);
-{
 
-defineTypeNameAndDebug(cellSplitter, 0);
-
-}
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 

applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C

@@ -328,7 +328,7 @@ label findCell(const primitiveMesh& mesh, const point& nearPoint)
 
 int main(int argc, char *argv[])
 {
-    argList::validOptions.insert("overwrite", "");
+    argList::addBoolOption("overwrite");
 
 #   include "setRootCase.H"
 #   include "createTime.H"

applications/utilities/mesh/advanced/refineHexMesh/refineHexMesh.C

@@ -52,7 +52,7 @@ using namespace Foam;
 // Main program:
 int main(int argc, char *argv[])
 {
-    argList::validOptions.insert("overwrite", "");
+    argList::addBoolOption("overwrite");
     argList::validArgs.append("cellSet");
 #   include "setRootCase.H"
 #   include "createTime.H"

applications/utilities/mesh/advanced/refineWallLayer/refineWallLayer.C

@@ -47,11 +47,12 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
-    Foam::argList::noParallel();
+    argList::noParallel();
-    Foam::argList::validArgs.append("patchName");
+    argList::validArgs.append("patchName");
-    Foam::argList::validArgs.append("edgeWeight");
+    argList::validArgs.append("edgeWeight");
-    Foam::argList::validOptions.insert("useSet", "cellSet");
+
-    Foam::argList::validOptions.insert("overwrite", "");
+    argList::addOption("useSet", "cellSet");
+    argList::addBoolOption("overwrite");
 
 #   include "setRootCase.H"
 #   include "createTime.H"

applications/utilities/mesh/advanced/refinementLevel/refinementLevel.C

@@ -97,7 +97,7 @@ bool limitRefinementLevel
 
 int main(int argc, char *argv[])
 {
-    argList::validOptions.insert("readLevel", "");
+    argList::addBoolOption("readLevel");
 
 #   include "setRootCase.H"
 #   include "createTime.H"
@@ -216,7 +216,7 @@ int main(int argc, char *argv[])
 
     List<polyPatch*> p(patches.size());
 
-    forAll (p, patchI)
+    forAll(p, patchI)
     {
         p[patchI] = patches[patchI].clone(fMesh.boundaryMesh()).ptr();
     }