Changeset 538512 in git


Ignore:
Timestamp:
Jan 10, 2013, 12:47:19 PM (11 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'd08f5f0bb3329b8ca19f23b74cb1473686415c3a')
Children:
80c703d0b975055386088b85c7bcdd5c7684adc0
Parents:
c2ff4132e497bb884e85e7bcb9974f183308e2bb
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2013-01-10 12:47:19+01:00
git-committer:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2013-01-10 12:48:14+01:00
Message:
chg: StringAppend/StringSetS/StringEndS: use multiple times
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • Singular/extra.cc

    rc2ff413 r538512  
    421421      {
    422422        res->rtyp=STRING_CMD;
    423         res->data=(void *)omStrDup(versionString());
     423        res->data=(void *)versionString();
    424424        return FALSE;
    425425      }
    … …  
    473473      {
    474474        res->rtyp = STRING_CMD;
    475         char* b = StringSetS("");
     475        StringSetS("");
    476476        feStringAppendBrowsers(0);
    477         res->data = omStrDup(b);
     477        res->data = StringEndS();
    478478        return FALSE;
    479479      }

  • Singular/feOpt.cc

    rc2ff413 r538512  
    241241
    242242      case FE_OPT_VERSION:
    243         printf("%s",versionString());
    244         return NULL;
     243        {
     244        char *s=versionString();
     245        printf("%s",s);
     246        omFree(s);
     247        return NULL;
     248        }
    245249
    246250      case FE_OPT_ECHO:

  • Singular/fehelp.cc

    rc2ff413 r538512  
    144144#endif
    145145
    146     char* matches = StringSetS("");
     146    StringSetS("");
    147147    int found = heReKey2Entry(idxfile, str, &hentry);
    148148
    … …  
    185185      Warn("No help for topic '%s'", str);
    186186    Warn("Try one of");
     187    char *matches=StringEndS();
    187188    PrintS(matches);
    188     PrintS("\n");
     189    PrintLn();
     190    omFree(matches);
    189191    return;
    190192  }
    … …  
    846848    //}
    847849    Warn("Use 'system(\"--browser\", <browser>);' to change browser,");
    848     char* browsers = StringSetS("where <browser> can be: ");
     850    StringSetS("where <browser> can be: ");
    849851    int i = 0;
    850852    i = 0;
    … …  
    855857      i++;
    856858    }
     859    char *browsers=StringEndS();
    857860    if (browsers[strlen(browsers)-2] == ',')
    858861    {
    … …  
    861864    }
    862865    WarnS(browsers);
     866    omFree(browsers);
    863867  }
    864868

  • Singular/ipprint.cc

    rc2ff413 r538512  
    7979    i=MATCOLS(m)*MATROWS(m)-1;
    8080    ss=pString(m->m[i]);
    81     if ((int)strlen(ss)>colmax) s[i]=NULL;
    82     else                        s[i]=omStrDup(ss);
     81    if ((int)strlen(ss)>colmax) { s[i]=NULL; omFree(ss); }
     82    else                        s[i]=ss;
    8383    for(i--;i>=0;i--)
    8484    {
    85       pString(m->m[i]);
    86       ss=StringAppendS(",");
     85      StringSetS("");
     86      pString0(m->m[i]);
     87      StringAppendS(",");
     88      ss=StringEndS();
    8789      if ((int)strlen(ss)>colmax) s[i]=NULL;
    88       else                        s[i]=omStrDup(ss);
     90      else                        s[i]=ss;
    8991    }
    9092    /* look up the width of all columns, put it in l[col_nr] */

  • Singular/links/silink.cc

    rc2ff413 r538512  
    785785      StringSetS("");
    786786      p_Write(IDRING(h)->cf->extRing->qideal->m[0],IDRING(h)->cf->extRing);
    787       rhs = StringAppendS("");
    788       if (fprintf(fd, "; minpoly = %s", rhs) == EOF) return EOF;
     787      rhs = StringEndS();
     788      if (fprintf(fd, "; minpoly = %s", rhs) == EOF) { omFree(rhs); return EOF;}
     789      omFree(rhs);
    789790    }
    790791    else if (type_id == INTVEC_CMD) fprintf(fd, ")");

  • Singular/misc_ip.cc

    rc2ff413 r538512  
    721721      }
    722722    }
    723     return omStrDup(StringAppendS(""));
    724   }
    725   return omStrDup(StringAppendS(" none"));
     723    return StringEndS();
     724  }
     725  StringAppendS(" none");
     726  return StringEndS();
    726727}
    727728
    728729char * versionString()
    729730{
    730   char* str = StringSetS("");
     731  StringSetS("");
    731732  StringAppend("Singular for %s version %s (%d-%s)  %s\nwith\n",
    732733               S_UNAME, S_VERSION1, SINGULAR_VERSION,
    … …  
    842843              feStringAppendBrowsers(0);
    843844              StringAppendS("\n");
    844               return str;
     845              return StringEndS();
    845846}
    846847

  • Singular/newstruct.cc

    rc2ff413 r538512  
    8787    {
    8888      StringAppendS(a->name);
    89       char *tmp=omStrDup(StringAppendS("="));
     89      StringAppendS("=");
    9090      if ((!RingDependend(a->typ))
    9191      || ((l->m[a->pos-1].data==(void *)currRing)
    … …  
    9898        else
    9999        {
    100           StringSetS("");
    101100          char *tmp2=omStrDup(l->m[a->pos].String());
    102           StringSetS(tmp);
    103101          if ((strlen(tmp2)>80)||(strchr(tmp2,'\n')!=NULL))
    104102          {
    … …  
    110108      }
    111109      else StringAppendS("??");
    112       omFree(tmp);
    113110      if (a->next==NULL) break;
    114111      StringAppendS("\n");
    … …  
    116113      a=a->next;
    117114    }
    118     return omStrDup(StringAppendS(""));
     115    return StringEndS();
    119116  }
    120117}

  • Singular/subexpr.cc

    rc2ff413 r538512  
    767767            nDelete(&n);
    768768          }
    769           s = StringAppendS((char*) (typed ? ")" : ""));
    770           return omStrDup(s);
     769          StringAppendS((char*) (typed ? ")" : ""));
     770          return StringEndS();
    771771
    772772        case BIGINT_CMD:
    … …  
    775775          number nl=(number)d;
    776776          n_Write(nl,coeffs_BIGINT);
    777           s = StringAppendS((char*) (typed ? ")" : ""));
    778           return omStrDup(s);
     777          StringAppendS((char*) (typed ? ")" : ""));
     778          return StringEndS();
    779779          }
    780780

  • dyn_modules/bigintm/bigintm.cc

    rc2ff413 r538512  
    3636     StringSetS("");
    3737     number n=(number)d; n_Write(n, coeffs_BIGINT); d=(void*)n;
    38      return omStrDup(StringAppendS(""));
     38     return StringEndS();
    3939    }
    4040}

  • kernel/polys.h

    rc2ff413 r538512  
    273273// let's inline those, so that we can call them from the debugger
    274274inline char*   pString(poly p)    {return p_String(p, currRing, currRing);}
    275 inline char*   pString0(poly p)   {return p_String0(p, currRing, currRing);}
     275inline void    pString0(poly p)   {p_String0(p, currRing, currRing);}
    276276inline void    pWrite(poly p)     {p_Write(p, currRing, currRing);}
    277277inline void    pWrite0(poly p)    {p_Write0(p, currRing, currRing);}

  • kernel/tgbgauss.cc

    rc2ff413 r538512  
    507507      StringSetS("");
    508508      n_Write(n[i][j],currRing);
    509       PrintS(StringAppendS(""));
     509      char *s=StringEndS(); PrintS(s); omFree(s);
    510510      PrintS("\t");
    511511    }
    … …  
    706706      number n=get(i,j);
    707707      n_Write(n,currRing);
    708       PrintS(StringAppendS(""));
     708      char *s=StringEndS(); PrintS(s); omFree(s);
    709709      PrintS("\t");
    710710    }

  • libpolys/coeffs/bigintmat.cc

    rc2ff413 r538512  
    371371  StringAppendS("\n");
    372372  }   */
    373   return StringAppendS("");
     373  return StringEndS();
    374374}
    375375
    … …  
    438438      StringSetS("");
    439439      n_Write(v[col*i+j], basecoeffs());
    440       char * tmp = StringAppendS("");
     440      char * tmp = StringEndS();
    441441      const int _nl = strlen(tmp);
    442442      wv[col*i+j] = _nl;
    443443      if (_nl > cwv[j])
    444444        cwv[j]=_nl;
     445      omFree(tmp);
    445446    }
    446447  }
    … …  
    479480      StringSetS("");
    480481      n_Write(v[i], basecoeffs());
    481       char * temp = StringAppendS("");
    482       char * ts = omStrDup(temp);
     482      char * ts = StringEndS();
    483483      const int _nl = strlen(ts);
    484484      int cj = i%col;
    … …  
    488488        int ci = floor(i/col);
    489489        StringAppend("[%d,%d]", ci+1, cj+1);
    490         char *tmp = StringAppendS("");
    491         char * ph = omStrDup(tmp);
     490        char * ph = StringEndS();
    492491        int phl = strlen(ph);
    493492        if (phl > colwid[cj])

  • libpolys/coeffs/ffields.cc

    rc2ff413 r538512  
    970970    StringSetS("//   minpoly        : ");
    971971    nfShowMipo(r);
    972     PrintS(StringAppendS("\n"));
     972    StringAppendS("\n");
     973    char *s=StringEndS(); PrintS(s); omFree(s);
    973974  }
    974975  else PrintS("//   minpoly        : ...\n");

  • libpolys/misc/int64vec.cc

    rc2ff413 r538512  
    8989    }
    9090  }
    91   return StringAppendS("");
     91  return StringEndS();
    9292}
    9393

  • libpolys/misc/intvec.cc

    rc2ff413 r538512  
    114114    }
    115115  }
    116   return StringAppendS("");
     116  return StringEndS();
    117117}
    118118

  • libpolys/polys/clapsing.cc

    rc2ff413 r538512  
    13721372    }
    13731373  }
    1374   char * s=omStrDup(StringAppendS(""));
     1374  char * s=StringEndS();
    13751375  if (s[strlen(s)-1]==',') s[strlen(s)-1]='\0';
    13761376  return s;

  • libpolys/polys/matpol.cc

    rc2ff413 r538512  
    777777  int j,jj = MATCOLS(im);
    778778  poly *pp = im->m;
    779   char *s=StringSetS("");
     779  StringSetS("");
    780780
    781781  for (i=0; i<ii; i++)
    … …  
    784784    {
    785785      p_String0(*pp++, r);
    786       s=StringAppend("%c",ch);
    787       if (dim > 1) s = StringAppendS("\n");
    788     }
    789   }
     786      StringAppend("%c",ch);
     787      if (dim > 1) StringAppendS("\n");
     788    }
     789  }
     790  char *s=StringEndS();
    790791  s[strlen(s)- (dim > 1 ? 2 : 1)]='\0';
    791792  return s;

  • libpolys/polys/monomials/p_polys.h

    rc2ff413 r538512  
    338338 ***************************************************************/
    339339/// print p according to ShortOut in lmRing & tailRing
    340 char*     p_String0(poly p, ring lmRing, ring tailRing);
     340void      p_String0(poly p, ring lmRing, ring tailRing);
    341341char*     p_String(poly p, ring lmRing, ring tailRing);
    342342void      p_Write(poly p, ring lmRing, ring tailRing);
    … …  
    345345
    346346/// print p in a short way, if possible
    347 char* p_String0Short(const poly p, ring lmRing, ring tailRing);
     347void p_String0Short(const poly p, ring lmRing, ring tailRing);
    348348
    349349/// print p in a long way
    350 char* p_String0Long(const poly p, ring lmRing, ring tailRing);
     350void  p_String0Long(const poly p, ring lmRing, ring tailRing);
    351351
    352352
    … …  
    11541154  return p_String(p, p_ring, p_ring);
    11551155}
    1156 static inline char*     p_String0(poly p, ring p_ring)
    1157 {
    1158   return p_String0(p, p_ring, p_ring);
     1156static inline void     p_String0(poly p, ring p_ring)
     1157{
     1158  p_String0(p, p_ring, p_ring);
    11591159}
    11601160static inline void      p_Write(poly p, ring p_ring)

  • libpolys/polys/monomials/ring.cc

    rc2ff413 r538512  
    589589    }
    590590
    591     if (l==nblocks) return omStrDup(StringAppendS(""));
     591    if (l==nblocks) return StringEndS();
    592592    StringAppendS(",");
    593593  }

  • libpolys/polys/polys0.cc

    rc2ff413 r538512  
    9696
    9797/// if possible print p in a short way...
    98 char* p_String0Short(const poly p, ring lmRing, ring tailRing)
     98void p_String0Short(const poly p, ring lmRing, ring tailRing)
    9999{
    100100  // NOTE: the following (non-thread-safe!) UGLYNESS
    … …  
    108108  tailRing->ShortOut = rCanShortOut(tailRing);
    109109 
    110   char* res = p_String0(p, lmRing, tailRing);
     110  p_String0(p, lmRing, tailRing);
    111111
    112112  lmRing->ShortOut = bLMShortOut;
    113113  tailRing->ShortOut = bTAILShortOut;
    114 
    115   return res;
    116114}
    117115
    118116/// print p in a long way...
    119 char* p_String0Long(const poly p, ring lmRing, ring tailRing)
     117void p_String0Long(const poly p, ring lmRing, ring tailRing)
    120118{
    121119  // NOTE: the following (non-thread-safe!) UGLYNESS
    … …  
    129127  tailRing->ShortOut = FALSE;
    130128
    131   char* res = p_String0(p, lmRing, tailRing);
     129  p_String0(p, lmRing, tailRing);
    132130
    133131  lmRing->ShortOut = bLMShortOut;
    134132  tailRing->ShortOut = bTAILShortOut;
    135 
    136   return res;
    137 }
    138 
    139 
    140 char* p_String0(poly p, ring lmRing, ring tailRing)
     133}
     134
     135
     136void p_String0(poly p, ring lmRing, ring tailRing)
    141137{
    142138  if (p == NULL)
    143139  {
    144     return StringAppendS("0");
     140    StringAppendS("0");
     141    return;
    145142  }
    146143  if ((p_GetComp(p, lmRing) == 0) || (!lmRing->VectorOut))
    … …  
    156153      p = pNext(p);
    157154    }
    158     return StringAppendS("");
     155    return;
    159156  }
    160157
    … …  
    180177    k++;
    181178  }
    182   return StringAppendS("]");
     179  StringAppendS("]");
    183180}
    184181
    … …  
    186183{
    187184  StringSetS("");
    188   return p_String0(p, lmRing, tailRing);
     185  p_String0(p, lmRing, tailRing);
     186  return StringEndS();
    189187}
    190188

  • libpolys/reporter/reporter.cc

    rc2ff413 r538512  
    3535// this is an upper limit for the size of monomials/numbers read via the interpreter
    3636#define MAX_FILE_BUFFER 4*4096
    37 static long feBufferLength=INITIAL_PRINT_BUFFER;
    38 static char * feBuffer=(char *)omAlloc(INITIAL_PRINT_BUFFER);
     37static long feBufferLength=0;
     38static char * feBuffer=NULL;
     39static long feBufferLength_save[8];
     40static char * feBuffer_save[8];
     41static int feBuffer_cnt=0;
     42static char * feBufferStart_save[8];
     43
    3944
    4045char *  feErrors=NULL;
    … …  
    5257static char * feBufferStart;
    5358  /* only used in StringSet(S)/StringAppend(S)*/
    54 char * StringAppend(const char *fmt, ...)
     59void StringAppend(const char *fmt, ...)
    5560{
    5661  va_list ap;
    … …  
    96101  omCheckAddrSize(feBuffer, feBufferLength);
    97102  va_end(ap);
    98   return feBuffer;
    99 }
    100 
    101 char * StringAppendS(const char *st)
     103}
     104
     105void StringAppendS(const char *st)
    102106{
    103107  if (*st!='\0')
    … …  
    118122    feBufferStart +=l;
    119123  }
    120   return feBuffer;
    121 }
    122 
    123 char * StringSetS(const char *st)
    124 {
     124}
     125
     126void StringSetS(const char *st)
     127{
     128  feBuffer_save[feBuffer_cnt]=feBuffer;
     129  feBuffer=(char*)omAlloc0(INITIAL_PRINT_BUFFER);
     130  feBufferLength_save[feBuffer_cnt]=feBufferLength;
     131  feBufferLength=INITIAL_PRINT_BUFFER;
     132  feBufferStart_save[feBuffer_cnt]=feBufferStart;
     133  feBufferStart=feBuffer;
     134  feBuffer_cnt++;
    125135  int l;
    126136  long more;
    … …  
    128138  {
    129139    more = ((l + (4*1024-1))/(4*1024))*(4*1024);
    130     feBuffer=(char *)omReallocSize((void *)feBuffer,feBufferLength,
     140    feBuffer=(char *)omReallocSize((ADDRESS)feBuffer,feBufferLength,
    131141                                                     more);
    132142    feBufferLength=more;
    … …  
    134144  strcpy(feBuffer,st);
    135145  feBufferStart=feBuffer+l;
    136   return feBuffer;
     146}
     147
     148char * StringEndS()
     149{
     150  char *r=feBuffer;
     151  feBuffer_cnt--;
     152  feBuffer=feBuffer_save[feBuffer_cnt];
     153  feBufferLength=feBufferLength_save[feBuffer_cnt];
     154  feBufferStart=feBufferStart_save[feBuffer_cnt];
     155  if (strlen(r)<1024)
     156  {
     157    char *s=omStrDup(r); omFree(r); r=s;
     158  }
     159  return r;
    137160}
    138161

  • libpolys/reporter/reporter.h

    rc2ff413 r538512  
    5757/* the C++-part: */
    5858
    59 char *  StringAppend(const char *fmt, ...);
    60 char *  StringAppendS(const char *s);
    61 char *  StringSetS(const char* s);
    62 void    Warn(const char *fmt, ...);
     59void  StringAppend(const char *fmt, ...);
     60void  StringAppendS(const char *s);
     61void  StringSetS(const char* s);
     62char * StringEndS();
     63void  Warn(const char *fmt, ...);
    6364
    6465const char *  eati(const char *s, int *i);
Note: See TracChangeset for help on using the changeset viewer.