CC Mode 5.28 (C++); /* */ C style comments to not comment out all the commented code, but just a portion of it as you can see in this example!

[Drosos Kourounis]

CC Mode 5.28 (C++);
/* */ C style comments to not comment out all the commented code,
but just a portion of it as you can see in this example!

Emacs  : GNU Emacs 21.3.1 (i586-suse-linux, X toolkit, Xaw3d scroll bars)
of 2004-10-05 on chip
Package: CC Mode 5.28 (C++)
Buffer Style: stroustrup

c-emacs-features: (1-bit)

current state:
==============
(setq
c-basic-offset 4
c-comment-only-line-offset 0
c-block-comment-prefix "* "
c-comment-prefix-regexp '((pike-mode . "//+!?\\|\\**") (other . 
"//+\\|\\**"))
c-cleanup-list '(scope-operator)
c-hanging-braces-alist '((brace-list-open) (brace-entry-open) 
(substatement-open after)
                         (block-close . c-snug-do-while) 
(extern-lang-open after)
                         (inexpr-class-open after) (inexpr-class-close 
before))
c-hanging-colons-alist nil
c-hanging-semi&comma-criteria '(c-semi&comma-inside-parenlist)
c-backslash-column 48
c-label-minimum-indentation 1
c-offsets-alist '((string . c-lineup-dont-change)
                  (c . c-lineup-C-comments)
                  (defun-open . 0)
                  (defun-close . 0)
                  (defun-block-intro . +)
                  (class-open . 0)
                  (class-close . 0)
                  (inline-open . +)
                  (inline-close . 0)
                  (func-decl-cont . +)
                  (knr-argdecl-intro . +)
                  (knr-argdecl . 0)
                  (topmost-intro . 0)
                  (topmost-intro-cont . 0)
                  (member-init-intro . +)
                  (member-init-cont . c-lineup-multi-inher)
                  (inher-intro . +)
                  (inher-cont . c-lineup-multi-inher)
                  (block-open . 0)
                  (block-close . 0)
                  (brace-list-open . 0)
                  (brace-list-close . 0)
                  (brace-list-intro . +)
                  (brace-list-entry . 0)
                  (brace-entry-open . 0)
                  (statement . 0)
                  (statement-case-intro . +)
                  (statement-case-open . 0)
                  (substatement . +)
                  (case-label . 0)
                  (access-label . -)
                  (do-while-closure . 0)
                  (else-clause . 0)
                  (catch-clause . 0)
                  (comment-intro . c-lineup-comment)
                  (arglist-intro . +)
                  (arglist-cont . 0)
                  (arglist-cont-nonempty . c-lineup-arglist)
                  (arglist-close . +)
                  (stream-op . c-lineup-streamop)
                  (inclass . +)
                  (cpp-macro . [0])
                  (cpp-macro-cont . c-lineup-dont-change)
                  (friend . 0)
                  (objc-method-intro . [0])
                  (objc-method-args-cont . c-lineup-ObjC-method-args)
                  (objc-method-call-cont . c-lineup-ObjC-method-call)
                  (extern-lang-open . 0)
                  (extern-lang-close . 0)
                  (inextern-lang . +)
                  (namespace-open . 0)
                  (namespace-close . 0)
                  (innamespace . +)
                  (template-args-cont c-lineup-template-args +)
                  (inlambda . c-lineup-inexpr-block)
                  (lambda-intro-cont . +)
                  (inexpr-statement . 0)
                  (inexpr-class . +)
                  (statement-block-intro . +)
                  (substatement-open . 0)
                  (label . 0)
                  (statement-cont . +)
                  )
c-delete-function 'delete-char
c-electric-pound-behavior nil
c-indent-comments-syntactically-p nil
c-tab-always-indent nil
defun-prompt-regexp nil
tab-width 8
comment-column 32
parse-sexp-ignore-comments t
auto-fill-function nil
comment-multi-line t
comment-start-skip "/\\*+ *\\|//+ *"
fill-prefix nil
paragraph-start "[     ]*\\(//+\\|\\**\\)[     ]*$\\|^\f"
adaptive-fill-mode t
adaptive-fill-regexp "[     ]*\\(//+\\|\\**\\)[     ]*\\([    
]*\\([-|#;>*]+[     ]*\\|(?[0-9]+[.)][     ]*\\)*\\)"
)

.cc file
---------------------------------------------------------------

#ifndef pdes_hpp
#define pdes_hpp

//#include "cubature.hpp"
#include "sparsematrix.hpp"
#include "makesparsestruct.hpp"
#include "weakterm.hpp"
#include "fedemixer.hpp"
/*
template<ElementShape S, ApproxType P>
class NavierStokes
{
public:
   enum { HighOrderType = FEDemixer<P>::HighOrderType };
   enum { LowOrderType = FEDemixer<P>::LowOrderType };
   enum { Dim = FEDimension<S>::Dim };

   typedef Var<Dim, S, HighOrderType> VelocityType;
   typedef Var<_1D, S, LowOrderType> PressureType;

   //typedef Mass<S, Dim, HighOrderType, Dim, HighOrderType> MassType;
   typedef Diff<S, Dim, HighOrderType, Dim, HighOrderType> DiffType;
   //typedef Conv<S, Dim, HighOrderType, Dim, HighOrderType> ConvType;
   //typedef Press<S, _1D, LowOrderType, Dim, HighOrderType> PressType;
   //typedef Incompr<S, Dim, HighOrderType, _1D, LowOrderType> IncomprType;

public:
   //VelocityType u, v;
   //PressureType p, q;

   //MassType mass;
   DiffType diff;
   //ConvType conv;
   //PressType press;
   //IncomprType incompr;

public:
//     NavierStokes(double reynoldsnumber,
//                  const Dofs<S, P>& rd,
//                  const PHolder<TRIANGLES, LINEAR>& ph,
//                  const VelocityType& u, const PressureType v);

   NavierStokes(double reynoldsnumber,
                const Dofs<S, P>& rd,
                const PHolder<S, P>& ph,
                const VelocityType& u);
               
  
};

template<ElementShape S, ApproxType P>
NavierStokes<S, P>::NavierStokes(double reynoldsnumber,
                                const PHolder<S, P>& ph,
                                const VelocityType& u)
   : diff(reynoldsnumber, ph, u, u)
{
}


*/

template<ElementShape S, ApproxType P>
class Poisson
{
public:
   enum { Dim = FEDimension<S>::Dim };
   typedef Var<Dimension(Dim), S, P> VelocityType;
   typedef Diff<S, Dimension(Dim), P, Dimension(Dim), P> DiffType;

public:
   VelocityType u;
   DiffType diff;
  
public:
   Poisson(double reynoldsnumber,
           const PHolder<S, P>& ph,
           const VelocityType& u);

   Poisson(const Poisson& rpde);

   void assemble(const int e);
  
};

template<ElementShape S, ApproxType P>
Poisson<S, P>::Poisson(double reynoldsnumber,
                      const PHolder<S, P>& ph,
                      const VelocityType& ru)
   : u(ru), diff(reynoldsnumber, ph, ru, ru)
{
}

template<ElementShape S, ApproxType P>
Poisson<S, P>::Poisson(const Poisson& rpde)
   : u(rpde.u), diff(rpde.diff)
{}

/*
template<typename T>
PdeSystem<T>::PdeSystem(const T& rpde, const ReadData* prd,
                       const AutoPtr<DofStruct>& pds)
   : pde1(rpde), cub1(rpde, pds)
{
   // collect dofptrs necessary to construct
   // the sparse structure.


   dofmatptrsType dofmatptrs;
   dofvecptrsType dofvecptrs;
   dofvecptrs.push_back(pde1.v.v.pdofstruct.getPtr());
  
  
   dofvecptrsType mat1;
   mat1.push_back(pde1.v.u.pdofstruct.getPtr());

   dofmatptrs.push_back(mat1);
  
   // create sparsematrix structure
   makeSparseMatrix(prd, dofmatptrs, dofvecptrs, spstruct);

   spstruct.setShareability(true);

   lhs.copyStructure(spstruct);
   cout <<  "Memory allocated for Sparse Matrix: "
        << lhs.memoryAllocated() << "\n";

   spstruct.write2filedebug("structure.txt"); 
}
*/

#endif


----------------------------------------------------------------