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 <kourouni@wias-berlin.de>]

 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


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


-------------------------------------------------------
This SF.Net email is sponsored by the JBoss Inc.
Get Certified Today * Register for a JBoss Training Course
Free Certification Exam for All Training Attendees Through End of 2005
Visit http://www.jboss.com/services/certification for more information