Changeset 38500a in git


Ignore:
Timestamp:
Feb 2, 2011, 6:07:23 PM (13 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
4581a96e8a3be34bc5a0c30e5cc4415cf45006fc
Parents:
35eaf8ae5934ce9436edde9d1dca609b9055264d
git-author:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2011-02-02 18:07:23+01:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:59:27+01:00
Message:
- further template fix: added "__T" suffix to _all_ labels (incl. func. names!)
- todo: finish p_Numbers.h
Location:
libpolys/polys
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • libpolys/polys/monomials/p_polys.cc

    r35eaf8 r38500a  
    30543054#undef LINKAGE
    30553055#define LINKAGE
    3056 #undef p_Delete
    3057 #define p_Delete p_ShallowDelete
     3056#undef p_Delete__T
     3057#define p_Delete__T p_ShallowDelete
    30583058#undef n_Delete__T
    30593059#define n_Delete__T(n, r) ((void)0)
  • libpolys/polys/templates/for_future_ref

    r35eaf8 r38500a  
    99#define n_InpMult       n_InpMult_FieldGeneral
    1010#define n_InpAdd        n_InpAdd_FieldGeneral
     11
    1112#define p_MemCopy       p_MemCopy_LengthGeneral
    1213#define p_MemAdd        p_MemAdd_LengthGeneral
     
    1415#define p_MemDiff       p_MemDiff_LengthGeneral
    1516#define p_MemCmp        p_MemCmp_LengthGeneral_OrdGeneral
    16 #define DECLARE_LENGTH(what) what
    1717#define p_MemAddAdjust(p, r) p_MemAdd_NegWeightAdjust(p, r)
    18 #define DECLARE_ORDSGN(what) what
    19 #define p_Copy p_Copy__FieldGeneral_LengthGeneral_OrdGeneral
     18
     19
     20
     21
     22
    2023
    2124add extra suffix __T
     25
     26+ names:
     27#define p_Copy p_Copy__FieldGeneral_LengthGeneral_OrdGeneral
  • libpolys/polys/templates/p_Add_q__T.cc

    r35eaf8 r38500a  
    1717 *
    1818 ***************************************************************/
    19 LINKAGE poly p_Add_q(poly p, poly q, int &Shorter, const ring r)
     19LINKAGE poly p_Add_q__T(poly p, poly q, int &Shorter, const ring r)
    2020{
    2121  p_Test(p, r);
     
    3838
    3939  Top:     // compare p and q w.r.t. monomial ordering
    40   p_MemCmp(p->exp, q->exp, length, ordsgn, goto Equal, goto Greater , goto Smaller);
     40  p_MemCmp__T(p->exp, q->exp, length, ordsgn, goto Equal, goto Greater , goto Smaller);
    4141
    4242  Equal:
     
    4444  n2 = pGetCoeff(q);
    4545  #if 0
    46   t = n_Add(n1,n2, r);
    47   n_Delete(&n1, r);
     46  t = n_Add__T(n1,n2, r);
     47  n_Delete__T(&n1, r);
    4848  #else
    49   t=n_InpAdd(n1,n2,r);
     49  n_InpAdd__T(n1,n2,r);
     50  t = n1;
    5051  #endif
    51   n_Delete(&n2, r);
     52  n_Delete__T(&n2, r);
    5253  q = p_LmFreeAndNext(q, r);
    5354
    54   if (n_IsZero(t, r))
     55  if (n_IsZero__T(t, r))
    5556  {
    5657    shorter += 2;
    57     n_Delete(&t, r);
     58    n_Delete__T(&t, r);
    5859    p = p_LmFreeAndNext(p, r);
    5960  }
  • libpolys/polys/templates/p_Copy__T.cc

    r35eaf8 r38500a  
    44/***************************************************************
    55 *  File:    p_Copy__Template.cc
    6  *  Purpose: template for p_Copy
     6 *  Purpose: template for p_Copy__T
    77 *  Author:  obachman (Olaf Bachmann)
    88 *  Created: 8/00
     
    1010 *******************************************************************/
    1111
    12 LINKAGE poly p_Copy(poly s_p, const ring r)
     12LINKAGE poly p_Copy__T(poly s_p, const ring r)
    1313{
    1414  // let's not do tests here -- but instead allow
  • libpolys/polys/templates/p_Delete__T.cc

    r35eaf8 r38500a  
    1010 *******************************************************************/
    1111
    12 LINKAGE void p_Delete(poly* pp, const ring r)
     12LINKAGE void p_Delete__T(poly* pp, const ring r)
    1313{
    1414  poly p = *pp;
  • libpolys/polys/templates/p_Merge_q__T.cc

    r35eaf8 r38500a  
    1616 *
    1717 ***************************************************************/
    18 LINKAGE poly p_Merge_q(poly p, poly q, const ring r)
     18LINKAGE poly p_Merge_q__T(poly p, poly q, const ring r)
    1919{
    2020  assume(p != NULL && q != NULL);
     
    3131
    3232  Top:     // compare p and q w.r.t. monomial ordering
    33   p_MemCmp(p->exp, q->exp, length, ordsgn, goto Equal, goto Greater , goto Smaller);
     33  p_MemCmp__T(p->exp, q->exp, length, ordsgn, goto Equal, goto Greater , goto Smaller);
    3434
    3535  Equal:
  • libpolys/polys/templates/p_Minus_mm_Mult_qq__T.cc

    r35eaf8 r38500a  
    1818 *
    1919 ***************************************************************/
    20 LINKAGE poly p_Minus_mm_Mult_qq(poly p, poly m, poly q, int& Shorter, const poly spNoether, const ring r, poly &last)
     20LINKAGE poly p_Minus_mm_Mult_qq__T(poly p, poly m, poly q, int& Shorter, const poly spNoether, const ring r, poly &last)
    2121{
    2222  p_Test(p, r);
     
    3838
    3939  number tm = pGetCoeff(m),           // coefficient of m
    40     tneg = n_Neg(n_Copy(tm, r), r),    // - (coefficient of m)
     40    tneg = n_Neg__T(n_Copy__T(tm, r), r),    // - (coefficient of m)
    4141    tb,                            // used for tm*coeff(a1)
    4242    tc;                            // used as intermediate number
     
    5757  p_AllocBin(qm, bin, r);
    5858  SumTop:
    59   p_MemSum(qm->exp, q->exp, m_e, length);
    60   p_MemAddAdjust(qm, r);
     59  p_MemSum__T(qm->exp, q->exp, m_e, length);
     60  p_MemAddAdjust__T(qm, r);
    6161
    6262  CmpTop:
    6363  // compare qm = m*q and p w.r.t. monomial ordering
    64   p_MemCmp(qm->exp, p->exp, length, ordsgn, goto Equal, goto Greater, goto Smaller );
     64  p_MemCmp__T(qm->exp, p->exp, length, ordsgn, goto Equal, goto Greater, goto Smaller );
    6565
    6666  Equal:   // qm equals p
    67   tb = n_Mult(pGetCoeff(q), tm, r);
     67  tb = n_Mult__T(pGetCoeff(q), tm, r);
    6868#ifdef HAVE_ZERODIVISORS
    6969  if (!nIsZero(tb)) {
    7070#endif
    7171  tc = pGetCoeff(p);
    72   if (!n_Equal(tc, tb, r))
     72  if (!n_Equal__T(tc, tb, r))
    7373  {
    7474    shorter++;
    75     tc = n_Sub(tc, tb, r);
    76     n_Delete(&(pGetCoeff(p)), r);
     75    tc = n_Sub__T(tc, tb, r);
     76    n_Delete__T(&(pGetCoeff(p)), r);
    7777    pSetCoeff0(p,tc); // adjust coeff of p
    7878    a = pNext(a) = p; // append p to result and advance p
     
    8282  { // coeffs are equal, so their difference is 0:
    8383    shorter += 2;
    84     n_Delete(&tc, r);
     84    n_Delete__T(&tc, r);
    8585    p = p_LmFreeAndNext(p, r);
    8686  }
     
    9292  }
    9393#endif
    94   n_Delete(&tb, r);
     94  n_Delete__T(&tb, r);
    9595  pIter(q);
    9696  if (q == NULL || p == NULL) goto Finish; // are we done ?
     
    101101  Greater:
    102102#ifdef HAVE_ZERODIVISORS
    103   tb = n_Mult(pGetCoeff(q), tneg, r);
     103  tb = n_Mult__T(pGetCoeff(q), tneg, r);
    104104  if (!nIsZero(tb))
    105105  {
    106106#endif
    107     pSetCoeff0(qm, n_Mult(pGetCoeff(q), tneg, r));
     107    pSetCoeff0(qm, n_Mult__T(pGetCoeff(q), tneg, r));
    108108    a = pNext(a) = qm;       // append qm to result and advance q
    109109#ifdef HAVE_ZERODIVISORS
     
    113113    shorter++;
    114114  }
    115   n_Delete(&tb, r);
     115  n_Delete__T(&tb, r);
    116116#endif
    117117  pIter(q);
     
    160160  }
    161161
    162   n_Delete(&tneg, r);
     162  n_Delete__T(&tneg, r);
    163163  if (qm != NULL) p_FreeBinAddr(qm, r);
    164164  Shorter = shorter;
  • libpolys/polys/templates/p_Mult_mm__T.cc

    r35eaf8 r38500a  
    1717 *
    1818 ***************************************************************/
    19 LINKAGE poly p_Mult_mm(poly p, const poly m, const ring ri)
     19LINKAGE poly p_Mult_mm__T(poly p, const poly m, const ring ri)
    2020{
    2121  p_Test(p, ri);
     
    2828  DECLARE_LENGTH(const unsigned long length = ri->ExpL_Size);
    2929  const unsigned long* m_e = m->exp;
    30   pAssume(!n_IsZero(ln,ri));
     30  pAssume(!n_IsZero__T(ln,ri));
    3131
    3232#ifdef HAVE_ZERODIVISORS
     
    3636  {
    3737    pn = pGetCoeff(p);
    38     number tmp = n_Mult(ln, pn, ri);
     38    number tmp = n_Mult__T(ln, pn, ri);
    3939#ifdef HAVE_ZERODIVISORS
    40     if (n_IsZero(tmp, ri))
     40    if (n_IsZero__T(tmp, ri))
    4141    {
    42       n_Delete(&tmp, ri);
     42      n_Delete__T(&tmp, ri);
    4343      if (before == p)
    4444      {
     
    5757    {
    5858      pSetCoeff0(p, tmp);
    59       n_Delete(&pn, ri);
    60       p_MemAdd(p->exp, m_e, length);
    61       p_MemAddAdjust(p, ri);
     59      n_Delete__T(&pn, ri);
     60      p_MemAdd__T(p->exp, m_e, length);
     61      p_MemAddAdjust__T(p, ri);
    6262#ifdef HAVE_ZERODIVISORS
    6363      before = p;
  • libpolys/polys/templates/p_Mult_nn__T.cc

    r35eaf8 r38500a  
    1717 *
    1818 ***************************************************************/
    19 LINKAGE poly p_Mult_nn(poly p, const number n, const ring r)
     19LINKAGE poly p_Mult_nn__T(poly p, const number n, const ring r)
    2020{
    21   pAssume(!n_IsZero(n,r));
     21  pAssume(!n_IsZero__T(n,r));
    2222  p_Test(p, r);
    2323
     
    2929  {
    3030#ifndef HAVE_ZERODIVISORS
    31     n_InpMult(pGetCoeff(p), n, r);
     31    n_InpMult__T(pGetCoeff(p), n, r);
    3232    pIter(p);
    3333#else
    34     number tmp = n_Mult(n, pGetCoeff(p), r);
     34    number tmp = n_Mult__T(n, pGetCoeff(p), r);
    3535    if (!nIsZero(tmp))
    3636    {
    3737       number nc = pGetCoeff(p);
    3838       p_SetCoeff0(p, tmp, r);
    39        n_Delete(&nc, r);
     39       n_Delete__T(&nc, r);
    4040       old = p;
    4141       pIter(p);
     
    4343    else
    4444    {
    45       n_Delete(&tmp, r);
     45      n_Delete__T(&tmp, r);
    4646      if (old == NULL)
    4747      {
  • libpolys/polys/templates/p_Neg__T.cc

    r35eaf8 r38500a  
    1616 *
    1717 ***************************************************************/
    18 LINKAGE poly p_Neg(poly p, const ring r)
     18LINKAGE poly p_Neg__T(poly p, const ring r)
    1919{
    2020  poly q = p;
    2121  while (p != NULL)
    2222  {
    23     pSetCoeff0(p, n_Neg(pGetCoeff(p), r));
     23    pSetCoeff0(p, n_Neg__T(pGetCoeff(p), r));
    2424    pIter(p);
    2525  }
  • libpolys/polys/templates/p_Procs_Generate.cc

    r35eaf8 r38500a  
    194194  }
    195195
    196   printf("#undef %s\n#define %s__T %s\n", s_what, s_what, s_full_proc_name);
     196  printf("#undef %s__T\n#define %s__T %s\n", s_what, s_what, s_full_proc_name);
    197197  printf("#include \"polys/templates/%s__T.cc\"\n", s_what);
    198198  printf("#undef %s\n", s_what);
  • libpolys/polys/templates/p_ShallowCopyDelete__T.cc

    r35eaf8 r38500a  
    1616 * Returns:
    1717 ***************************************************************/
    18 LINKAGE poly p_ShallowCopyDelete(poly s_p, const ring r, omBin d_bin)
     18LINKAGE poly p_ShallowCopyDelete__T(poly s_p, const ring r, omBin d_bin)
    1919{
    2020  spolyrec dp;
     
    3131    h = s_p;
    3232    s_p =  pNext(s_p);
    33     p_MemCopy(d_p->exp, h->exp, length);
     33    p_MemCopy__T(d_p->exp, h->exp, length);
    3434    p_FreeBinAddr(h, r);
    3535  }
  • libpolys/polys/templates/p_kBucketSetLm__T.cc

    r35eaf8 r38500a  
    2626#endif
    2727#ifndef USE_COEF_BUCKETS
    28 LINKAGE void p_kBucketSetLm(kBucket_pt bucket)
     28LINKAGE void p_kBucketSetLm__T(kBucket_pt bucket)
    2929{
    3030  int j = 0;
     
    5252        }
    5353        assume(p != NULL);
    54         p_MemCmp(bucket->buckets[i]->exp, p->exp, length, ordsgn, goto Equal, goto Greater, goto Continue);
     54        p_MemCmp__T(bucket->buckets[i]->exp, p->exp, length, ordsgn, goto Equal, goto Greater, goto Continue);
    5555
    5656        Greater:
    5757        {
    58           if (n_IsZero(pGetCoeff(p), r))
     58          if (n_IsZero__T(pGetCoeff(p), r))
    5959          {
    60             n_Delete(&pGetCoeff(p), r);
     60            n_Delete__T(&pGetCoeff(p), r);
    6161            pIter(bucket->buckets[j]);
    6262            p_FreeBinAddr(p, r);
     
    7272          number tn = pGetCoeff(p);
    7373          #if 0
    74           pSetCoeff0(p, n_Add(pGetCoeff(bucket->buckets[i]), tn, r));
    75           n_Delete(&tn, r);
     74          pSetCoeff0(p, n_Add__T(pGetCoeff(bucket->buckets[i]), tn, r));
     75          n_Delete__T(&tn, r);
    7676          #else
    77           pSetCoeff0(p, n_InpAdd(tn,pGetCoeff(bucket->buckets[i]), r));
     77          n_InpAdd__T(tn,pGetCoeff(bucket->buckets[i]), r);
     78          pSetCoeff0(p, tn);
    7879          #endif
    7980          p = bucket->buckets[i];
    8081          pIter(bucket->buckets[i]);
    81           n_Delete(&pGetCoeff(p), r);
     82          n_Delete__T(&pGetCoeff(p), r);
    8283          p_FreeBinAddr(p, r);
    8384          (bucket->buckets_length[i])--;
     
    8889    }
    8990    p = bucket->buckets[j];
    90     if (j > 0 && n_IsZero(pGetCoeff(p), r))
     91    if (j > 0 && n_IsZero__T(pGetCoeff(p), r))
    9192    {
    92       n_Delete(&pGetCoeff(p), r);
     93      n_Delete__T(&pGetCoeff(p), r);
    9394      pIter(bucket->buckets[j]);
    9495      p_FreeBinAddr(p, r);
     
    115116}
    116117#else
    117 LINKAGE void p_kBucketSetLm(kBucket_pt bucket)
     118LINKAGE void p_kBucketSetLm__T(kBucket_pt bucket)
    118119{
    119120  //int j = 0;
     
    138139            }
    139140            assume(p != NULL);
    140             p_MemCmp(bucket->buckets[i]->exp, p->exp, length, ordsgn, goto Continue, goto Greater, goto Continue);
     141            p_MemCmp__T(bucket->buckets[i]->exp, p->exp, length, ordsgn, goto Continue, goto Greater, goto Continue);
    141142            //assume(p_LmCmp(bucket->buckets[i],p,r)==1);
    142143          Greater:
  • libpolys/polys/templates/pp_Mult_Coeff_mm_DivSelectMult__T.cc

    r35eaf8 r38500a  
    1919 *
    2020 ***************************************************************/
    21 LINKAGE poly pp_Mult_Coeff_mm_DivSelectMult
    22   (poly p,const poly m, const poly a, const poly b, int &shorter,const ring r)
     21LINKAGE poly pp_Mult_Coeff_mm_DivSelectMult__T(poly p,const poly m, const poly a, const poly b, int &shorter,const ring r)
    2322{
    2423  assume(rOrd_is_Comp_dp(r) && r->ExpL_Size > 2);
     
    2726  number n = pGetCoeff(m);
    2827  number nc;
    29   pAssume(!n_IsZero(n,r));
     28  pAssume(!n_IsZero__T(n,r));
    3029
    3130  spolyrec rp;
     
    4039  unsigned long* ab_e = &(ab->exp[0]);
    4140
    42   p_MemDiff(ab_e, ((unsigned long*) &(a->exp[0])), ((unsigned long*) &(b->exp[0])),
     41  p_MemDiff__T(ab_e, ((unsigned long*) &(a->exp[0])), ((unsigned long*) &(b->exp[0])),
    4342            length);
    4443
     
    6160    q = pNext(q);
    6261    nc = pGetCoeff(p);
    63     pSetCoeff0(q, n_Mult(n, nc, r));
    64     p_MemSum(q->exp, p->exp, ab_e, length);
     62    pSetCoeff0(q, n_Mult__T(n, nc, r));
     63    p_MemSum__T(q->exp, p->exp, ab_e, length);
    6564
    6665    Iter:
  • libpolys/polys/templates/pp_Mult_Coeff_mm_DivSelect__T.cc

    r35eaf8 r38500a  
    1717 *
    1818 ***************************************************************/
    19 LINKAGE poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, int &shorter,
     19LINKAGE poly pp_Mult_Coeff_mm_DivSelect__T(poly p, const poly m, int &shorter,
    2020                                        const ring r)
    2121{
    2222  number n = pGetCoeff(m);
    23   pAssume(!n_IsZero(n,r));
     23  pAssume(!n_IsZero__T(n,r));
    2424  p_Test(p, r);
    2525  if (p == NULL) return NULL;
     
    3737      q = pNext(q);
    3838      number nc = pGetCoeff(p);
    39       pSetCoeff0(q, n_Mult(n, nc, r));
    40       p_MemCopy(q->exp, p->exp, length);
     39      pSetCoeff0(q, n_Mult__T(n, nc, r));
     40      p_MemCopy__T(q->exp, p->exp, length);
    4141    }
    4242    else
  • libpolys/polys/templates/pp_Mult_mm_Noether__T.cc

    r35eaf8 r38500a  
    1818 *
    1919 ***************************************************************/
    20 LINKAGE poly pp_Mult_mm_Noether(poly p, const poly m, const poly spNoether, int &ll, const ring ri, poly &last)
     20LINKAGE poly pp_Mult_mm_Noether__T(poly p, const poly m, const poly spNoether, int &ll, const ring ri, poly &last)
    2121{
    2222  p_Test(p, ri);
     
    3737  DECLARE_ORDSGN(const long* ordsgn = ri->ordsgn);
    3838  const unsigned long* m_e = m->exp;
    39   pAssume(!n_IsZero(ln,ri));
     39  pAssume(!n_IsZero__T(ln,ri));
    4040  pAssume1(p_GetComp(m, ri) == 0 || p_MaxComp(p, ri) == 0);
    4141  int l = 0;
     
    4444  {
    4545    p_AllocBin(r, bin, ri);
    46     p_MemSum(r->exp, p->exp, m_e, length);
    47     p_MemAddAdjust(r, ri);
     46    p_MemSum__T(r->exp, p->exp, m_e, length);
     47    p_MemAddAdjust__T(r, ri);
    4848
    49     p_MemCmp(r->exp, spNoether_exp, length, ordsgn, goto Continue, goto Continue, goto Break);
     49    p_MemCmp__T(r->exp, spNoether_exp, length, ordsgn, goto Continue, goto Continue, goto Break);
    5050
    5151    Break:
     
    5656    l++;
    5757    q = pNext(q) = r;
    58     pSetCoeff0(q, n_Mult(ln, pGetCoeff(p), ri));
     58    pSetCoeff0(q, n_Mult__T(ln, pGetCoeff(p), ri));
    5959    pIter(p);
    6060  } while (p != NULL);
  • libpolys/polys/templates/pp_Mult_mm__T.cc

    r35eaf8 r38500a  
    1616 *
    1717 ***************************************************************/
    18 LINKAGE poly pp_Mult_mm(poly p, const poly m, const ring ri, poly &last)
     18LINKAGE poly pp_Mult_mm__T(poly p, const poly m, const ring ri, poly &last)
    1919{
    2020  p_Test(p, ri);
     
    3434  DECLARE_LENGTH(const unsigned long length = ri->ExpL_Size);
    3535  const unsigned long* m_e = m->exp;
    36   pAssume(!n_IsZero(ln,ri));
     36  pAssume(!n_IsZero__T(ln,ri));
    3737  pAssume1(p_GetComp(m, ri) == 0 || p_MaxComp(p, ri) == 0);
    3838  number tmp;
     
    4040  do
    4141  {
    42     tmp = n_Mult(ln, pGetCoeff(p), ri);
     42    tmp = n_Mult__T(ln, pGetCoeff(p), ri);
    4343#ifdef HAVE_ZERODIVISORS
    44     if (! n_IsZero(tmp, ri))
     44    if (! n_IsZero__T(tmp, ri))
    4545    {
    4646#endif
     
    4848      q = pNext(q);
    4949      pSetCoeff0(q, tmp);
    50       p_MemSum(q->exp, p->exp, m_e, length);
    51       p_MemAddAdjust(q, ri);
     50      p_MemSum__T(q->exp, p->exp, m_e, length);
     51      p_MemAddAdjust__T(q, ri);
    5252#ifdef HAVE_ZERODIVISORS
    5353    }
    54     else n_Delete(&tmp, ri);
     54    else n_Delete__T(&tmp, ri);
    5555#endif
    5656    p = pNext(p);
  • libpolys/polys/templates/pp_Mult_nn__T.cc

    r35eaf8 r38500a  
    1616 *
    1717 ***************************************************************/
    18 LINKAGE poly pp_Mult_nn(poly p, const number n, const ring r)
     18LINKAGE poly pp_Mult_nn__T(poly p, const number n, const ring r)
    1919{
    20   pAssume(!n_IsZero(n,r));
     20  pAssume(!n_IsZero__T(n,r));
    2121  p_Test(p, r);
    2222  if (p == NULL) return NULL;
     
    3535    pIter(q);
    3636    number nc = pGetCoeff(p);
    37     pSetCoeff0(q, n_Mult(n, nc, r));
    38     p_MemCopy(q->exp, p->exp, length);
     37    pSetCoeff0(q, n_Mult__T(n, nc, r));
     38    p_MemCopy__T(q->exp, p->exp, length);
    3939#else
    4040    number nc = pGetCoeff(p);
    41     number tmp = n_Mult(n, nc, r);
     41    number tmp = n_Mult__T(n, nc, r);
    4242    if (! nIsZero(tmp))
    4343    {
     
    4545      pIter(q);
    4646      pSetCoeff0(q, tmp);
    47       p_MemCopy(q->exp, p->exp, length);
     47      p_MemCopy__T(q->exp, p->exp, length);
    4848    }
    4949    else
    50       n_Delete(&tmp,r);
     50      n_Delete__T(&tmp,r);
    5151#endif
    5252    pIter(p);
Note: See TracChangeset for help on using the changeset viewer.