Changeset 95e3732 in git


Ignore:
Timestamp:
Jun 17, 2020, 3:32:54 PM (4 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '79dfb9a6d258bfeb991428bdb25b8f55e9e809b2')
Children:
48e0bcb3839c4f7cc786ac37fa187054f0536239
Parents:
2d01c0be713d6cd59565d47887f8ddd83ab95e8f
Message:
compiler warnings about memset
Location:
Singular
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • Singular/iparith.cc

    r2d01c0 r95e3732  
    743743        syMake(v, v->name, pa);
    744744        memcpy(res, v, sizeof(sleftv));
    745         memset(v, 0, sizeof(sleftv));
     745        v->Init();
    746746      }
    747747      break;
     
    14101410  int i;
    14111411  sleftv t;
    1412   memset(&t,0,sizeof(t));
     1412  t.Init();
    14131413  t.rtyp=INT_CMD;
    14141414  for (i=0;i<iv->length(); i++)
     
    15881588static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v)
    15891589{
    1590   leftv tmp=(leftv)omAllocBin(sleftv_bin);
    1591   memset(tmp,0,sizeof(sleftv));
     1590  leftv tmp=(leftv)omAlloc0Bin(sleftv_bin);
    15921591  BOOLEAN b;
    15931592  if (v->Typ()==INTVEC_CMD)
     
    16651664  u->next=(leftv)omAlloc(sizeof(sleftv));
    16661665  memcpy(u->next,v,sizeof(sleftv));
    1667   memset(v,0,sizeof(sleftv));
     1666  v->Init();
    16681667  BOOLEAN bo=iiExprArithM(res,u,'[');
    16691668  u->next=NULL;
     
    22162215    if (IDTYP(w)==ALIAS_CMD) w=(idhdl)IDDATA(w);
    22172216    sleftv tmpW;
    2218     memset(&tmpW,0,sizeof(sleftv));
     2217    tmpW.Init();
    22192218    tmpW.rtyp=IDTYP(w);
    22202219    tmpW.data=IDDATA(w);
     
    25132512{
    25142513  sleftv h;
    2515   memset(&h,0,sizeof(sleftv));
     2514  h.Init();
    25162515  h.rtyp=INT_CMD;
    25172516  h.data=(void *)(long)IDELEMS((ideal)v->Data());
     
    44884487     valid bound for the prime factors has been given) */
    44894488  sleftv tmp;
    4490   memset(&tmp, 0, sizeof(tmp));
     4489  tmp.Init();
    44914490  tmp.rtyp = INT_CMD;
    44924491  return jjPFAC2(res, v, &tmp);
     
    45264525  // clean out "_":
    45274526  sLastPrinted.CleanUp();
    4528   memset(&sLastPrinted,0,sizeof(sleftv));
    45294527  // collect all info:
    45304528  omUpdateInfo();
     
    57105708static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
    57115709{
    5712   sleftv t;
    5713   sleftv ut;
     5710  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
     5711  {
     5712    WerrorS("cannot build expression lists from unnamed objects");
     5713    return TRUE;
     5714  }
     5715
    57145716  leftv p=NULL;
    57155717  intvec *iv=(intvec *)w->Data();
    57165718  int l;
    57175719  BOOLEAN nok;
    5718 
    5719   if ((u->rtyp!=IDHDL)||(u->e!=NULL))
    5720   {
    5721     WerrorS("cannot build expression lists from unnamed objects");
    5722     return TRUE;
    5723   }
     5720  sleftv ut;
    57245721  memcpy(&ut,u,sizeof(ut));
    5725   memset(&t,0,sizeof(t));
     5722  sleftv t;
     5723  t.Init();
    57265724  t.rtyp=INT_CMD;
    57275725  for (l=0;l< iv->length(); l++)
     
    57605758static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
    57615759{
    5762   sleftv t;
    5763   sleftv ut;
     5760  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
     5761  {
     5762    WerrorS("cannot build expression lists from unnamed objects");
     5763    return TRUE;
     5764  }
    57645765  leftv p=NULL;
    57655766  intvec *iv=(intvec *)v->Data();
    57665767  int l;
    57675768  BOOLEAN nok;
    5768 
    5769   if ((u->rtyp!=IDHDL)||(u->e!=NULL))
    5770   {
    5771     WerrorS("cannot build expression lists from unnamed objects");
    5772     return TRUE;
    5773   }
     5769  sleftv ut;
    57745770  memcpy(&ut,u,sizeof(ut));
    5775   memset(&t,0,sizeof(t));
     5771  sleftv t;
     5772  t.Init();
    57765773  t.rtyp=INT_CMD;
    57775774  for (l=0;l< iv->length(); l++)
     
    58105807static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
    58115808{
    5812   sleftv t1,t2,ut;
     5809  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
     5810  {
     5811    WerrorS("cannot build expression lists from unnamed objects");
     5812    return TRUE;
     5813  }
    58135814  leftv p=NULL;
    58145815  intvec *vv=(intvec *)v->Data();
     
    58185819  BOOLEAN nok;
    58195820
    5820   if ((u->rtyp!=IDHDL)||(u->e!=NULL))
    5821   {
    5822     WerrorS("cannot build expression lists from unnamed objects");
    5823     return TRUE;
    5824   }
     5821  sleftv t1,t2,ut;
    58255822  memcpy(&ut,u,sizeof(ut));
    5826   memset(&t1,0,sizeof(sleftv));
    5827   memset(&t2,0,sizeof(sleftv));
     5823  t1.Init();
    58285824  t1.rtyp=INT_CMD;
     5825  t2.Init();
    58295826  t2.rtyp=INT_CMD;
    58305827  for (vl=0;vl< vv->length(); vl++)
     
    58635860  v->next=(leftv)omAllocBin(sleftv_bin);
    58645861  memcpy(v->next,w,sizeof(sleftv));
    5865   memset(w,0,sizeof(sleftv));
     5862  w->Init();
    58665863  return jjPROC(res,u,v);
    58675864}
     
    58705867  u->next=(leftv)omAlloc(sizeof(sleftv));
    58715868  memcpy(u->next,v,sizeof(sleftv));
    5872   memset(v,0,sizeof(sleftv));
     5869  v->Init();
    58735870  u->next->next=(leftv)omAlloc(sizeof(sleftv));
    58745871  memcpy(u->next->next,w,sizeof(sleftv));
    5875   memset(w,0,sizeof(sleftv));
     5872  w->Init();
    58765873  BOOLEAN bo=iiExprArithM(res,u,'[');
    58775874  u->next=NULL;
     
    59355932  i->m[0]=p;
    59365933  sleftv t;
    5937   memset(&t,0,sizeof(t));
     5934  t.Init();
    59385935  t.data=(char *)i;
    59395936  t.rtyp=IDEAL_CMD;
     
    66106607{
    66116608  sleftv tmp;
    6612   memset(&tmp,0,sizeof(tmp));
     6609  tmp.Init();
    66136610  // do not check the result, conversion from int/number to poly works always
    66146611  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
     
    71807177    if (IDTYP(w)==ALIAS_CMD) w=(idhdl)IDDATA(w);
    71817178    sleftv tmpW;
    7182     memset(&tmpW,0,sizeof(sleftv));
     7179    tmpW.Init();
    71837180    tmpW.rtyp=IDTYP(w);
    71847181    tmpW.data=IDDATA(w);
     
    75527549  }
    75537550  #else
    7554   memset(res,0,sizeof(sleftv));
     7551  res->Init();
    75557552  res->rtyp=NONE;
    75567553  return TRUE;
     
    75647561  {
    75657562    memcpy(res,u,sizeof(sleftv));
    7566     memset(u,0,sizeof(sleftv));
     7563    u->Init();
    75677564    return FALSE;
    75687565  }
     
    81808177  if ((rest!=NULL) && (!b))
    81818178  {
    8182     sleftv tmp_res;
    81838179    leftv tmp_next=res->next;
    81848180    res->next=rest;
    8185     memset(&tmp_res,0,sizeof(tmp_res));
     8181    sleftv tmp_res;
     8182    tmp_res.Init();
    81868183    b = iiExprArithM(&tmp_res,res,iiOp);
    81878184    memcpy(res,&tmp_res,sizeof(tmp_res));
     
    83548351                                    const struct sConvertTypes *dConvertTypes)
    83558352{
    8356   memset(res,0,sizeof(sleftv));
    83578353  BOOLEAN call_failed=FALSE;
    83588354
     
    85138509                                    const struct sConvertTypes *dConvertTypes)
    85148510{
     8511  res->Init();
    85158512  leftv b=a->next;
    85168513  a->next=NULL;
     
    85238520BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
    85248521{
    8525   memset(res,0,sizeof(sleftv));
     8522  res->Init();
    85268523
    85278524  if (!errorreported)
     
    85828579BOOLEAN iiExprArith1Tab(leftv res, leftv a, int op, const struct sValCmd1* dA1, int at, const struct sConvertTypes *dConvertTypes)
    85838580{
    8584   memset(res,0,sizeof(sleftv));
     8581  res->Init();
    85858582  BOOLEAN call_failed=FALSE;
    85868583
     
    87128709BOOLEAN iiExprArith1(leftv res, leftv a, int op)
    87138710{
    8714   memset(res,0,sizeof(sleftv));
     8711  res->Init();
    87158712
    87168713  if (!errorreported)
     
    87738770  const struct sConvertTypes *dConvertTypes)
    87748771{
    8775   memset(res,0,sizeof(sleftv));
    87768772  BOOLEAN call_failed=FALSE;
    87778773
     
    89258921BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
    89268922{
    8927   memset(res,0,sizeof(sleftv));
     8923  res->Init();
    89288924
    89298925  if (!errorreported)
     
    89808976                                    const struct sConvertTypes *dConvertTypes)
    89818977{
     8978  res->Init();
    89828979  leftv b=a->next;
    89838980  a->next=NULL;
     
    90159012BOOLEAN iiExprArithM(leftv res, leftv a, int op)
    90169013{
    9017   memset(res,0,sizeof(sleftv));
     9014  res->Init();
    90189015
    90199016  if (!errorreported)
     
    97829779  int tab_pos=iiTabIndex(dArithTab2,JJTAB2LEN,'<');
    97839780  sleftv tmp;
    9784   memset(&tmp,0,sizeof(sleftv));
     9781  tmp.Init();
    97859782  iiOp='<';
    97869783  BOOLEAN bo=iiExprArith2TabIntern(&tmp,a,'<',b,FALSE,dArith2+tab_pos,at,bt,dConvertTypes);
  • Singular/ipconv.cc

    r2d01c0 r95e3732  
    435435BOOLEAN iiConvert (int inputType, int outputType, int index, leftv input, leftv output,const struct sConvertTypes *dConvertTypes)
    436436{
    437   memset(output,0,sizeof(sleftv));
     437  output->Init();
    438438  if ((inputType==outputType)
    439439  || (outputType==DEF_CMD)
     
    441441  {
    442442    memcpy(output,input,sizeof(*output));
    443     memset(input,0,sizeof(*input));
     443    input->Init();
    444444    return FALSE;
    445445  }
  • Singular/ipid.cc

    r2d01c0 r95e3732  
    269269{
    270270  sleftv tmp;
    271   memset(&tmp,0,sizeof(sleftv));
     271  tmp.Init();
    272272  tmp.rtyp=IDTYP(this);
    273273  tmp.data=IDDATA(this);
  • Singular/iplib.cc

    r2d01c0 r95e3732  
    398398    iiCurrArgs=(leftv)omAllocBin(sleftv_bin);
    399399    memcpy(iiCurrArgs,v,sizeof(sleftv)); // keeps track of v->next etc.
    400     memset(v,0,sizeof(sleftv));
     400    v->Init();
    401401  }
    402402  else
     
    740740    leftv h=(leftv)omAllocBin(sleftv_bin);
    741741    memcpy(h,&iiRETURNEXPR,sizeof(sleftv));
    742     memset(&iiRETURNEXPR,0,sizeof(sleftv));
     742    iiRETURNEXPR.Init();
    743743    return h;
    744744  }
     
    11901190  char FullName[256];
    11911191
    1192   memset(FullName,0,256);
     1192  memset(FullName,0,sizeof(FullName));
    11931193
    11941194  if( *fullname != '/' &&  *fullname != '.' )
  • Singular/ipshell.cc

    r2d01c0 r95e3732  
    204204                     char *s;
    205205                     l=strlen(IDSTRING(h));
    206                      memset(buffer,0,22);
     206                     memset(buffer,0,sizeof(buffer));
    207207                     strncpy(buffer,IDSTRING(h),si_min(l,20));
    208208                     if ((s=strchr(buffer,'\n'))!=NULL)
     
    652652      v=(leftv)omAlloc0Bin(sleftv_bin);
    653653      sleftv tmpW;
    654       memset(&tmpW,0,sizeof(sleftv));
     654      tmpW.Init();
    655655      tmpW.rtyp=IDTYP(w);
    656656      if (tmpW.rtyp==MAP_CMD)
     
    891891{
    892892  sleftv tmp;
    893   memset(&tmp,0,sizeof(tmp));
     893  tmp.Init();
    894894  tmp.rtyp=INT_CMD;
    895895  tmp.data=(void *)1;
     
    911911  l->m[0].attribute=*a;
    912912  sleftv tmp2;
    913   memset(&tmp2,0,sizeof(tmp2));
     913  tmp2.Init();
    914914  tmp2.rtyp=LIST_CMD;
    915915  tmp2.data=(void *)l;
     
    998998  loop
    999999  {
    1000     memset(s,0,80);
     1000    memset(s,0,BREAK_LINE_LENGTH+4);
    10011001    fe_fgets_stdin("",s,BREAK_LINE_LENGTH);
    10021002    if (s[BREAK_LINE_LENGTH-1]!='\0')
     
    10491049  hwork = (scfmon)omAlloc(hNexist * sizeof(scmon));
    10501050  hvar = (varset)omAlloc((rVar(currRing) + 1) * sizeof(int));
    1051   hpure = (scmon)omAlloc((1 + (rVar(currRing) * rVar(currRing))) * sizeof(long));
     1051  hpure = (scmon)omAlloc0((1 + (rVar(currRing) * rVar(currRing))) * sizeof(long));
    10521052  hrad = hexist;
    10531053  hNrad = hNexist;
     
    10601060  {
    10611061    hCo = hNvar;
    1062     memset(hpure, 0, (rVar(currRing) + 1) * sizeof(long));
    10631062    hPure(hrad, 0, &hNrad, hvar, hNvar, hpure, &hNpure);
    10641063    hLexR(hrad, hNrad, hvar, hNvar);
     
    11301129  const char *id = name->name;
    11311130
    1132   memset(sy,0,sizeof(sleftv));
     1131  sy->Init();
    11331132  if ((name->name==NULL)||(isdigit(name->name[0])))
    11341133  {
     
    11941193    return FALSE;
    11951194  sleftv tmp;
    1196   memset(&tmp,0,sizeof(sleftv));
     1195  tmp.Init();
    11971196  tmp.rtyp=at->atyp;
    11981197  tmp.data=at->CopyA();
     
    15831582  {
    15841583    sLastPrinted.CleanUp();
    1585     memset(&sLastPrinted,0,sizeof(sleftv));
    15861584  }
    15871585
     
    31823180{
    31833181  sleftv tmp;
    3184   memset(&tmp,0,sizeof(tmp));
     3182  tmp.Init();
    31853183  tmp.rtyp=INT_CMD;
    31863184  tmp.data=(void *)1;
     
    45614559{
    45624560  sleftv tmp;
    4563   memset(&tmp,0,sizeof(tmp));
     4561  tmp.Init();
    45644562  tmp.rtyp=INT_CMD;
    4565   /* tmp.data = (void *)0;  -- done by memset */
     4563  /* tmp.data = (void *)0;  -- done by Init */
    45664564
    45674565  return  semicProc3(res,u,v,&tmp);
     
    51405138    {
    51415139      sLastPrinted.CleanUp();
    5142       //memset(&sLastPrinted,0,sizeof(sleftv)); // done by Cleanup,Init
    51435140    }
    51445141
     
    62836280    IDRING(currRingHdl)=currRing;
    62846281  }
    6285   sleftv v; memset(&v,0,sizeof(v)); v.rtyp=IDEAL_CMD; v.data=(char *) F;
     6282  sleftv v; v.Init(); v.rtyp=IDEAL_CMD; v.data=(char *) F;
    62866283  idhdl h=ggetid("groebner");
    6287   sleftv u; memset(&u,0,sizeof(u)); u.rtyp=IDHDL; u.data=(char *) h;
     6284  sleftv u; u.Init(); u.rtyp=IDHDL; u.data=(char *) h;
    62886285            u.name=IDID(h);
    62896286
    6290   sleftv res; memset(&res,0,sizeof(res));
     6287  sleftv res; res.Init();
    62916288  if(jjPROC(&res,&u,&v))
    62926289  {
     
    63876384  for(int i=0;i<aa->length(); i++)
    63886385  {
    6389     memset(&tmp_in,0,sizeof(tmp_in));
     6386    tmp_in.Init();
    63906387    tmp_in.rtyp=INT_CMD;
    63916388    tmp_in.data=(void*)(long)(*aa)[i];
     
    64296426  for(int i=0;i<=aa->nr; i++)
    64306427  {
    6431     memset(&tmp_in,0,sizeof(tmp_in));
     6428    tmp_in.Init();
    64326429    tmp_in.Copy(&(aa->m[i]));
    64336430    if (proc==NULL)
     
    64546451BOOLEAN iiApply(leftv res, leftv a, int op, leftv proc)
    64556452{
    6456   memset(res,0,sizeof(sleftv));
     6453  res->Init();
    64576454  res->rtyp=a->Typ();
    64586455  switch (res->rtyp /*a->Typ()*/)
     
    65226519    sprintf(ss,"parameter def %s;%s;return(%s);\n",a,s,s+start_s+1);
    65236520  }
    6524   memset(r,0,sizeof(*r));
     6521  r->Init();
    65256522  // now produce procinfo for PROC_CMD:
    65266523  r->data = (void *)omAlloc0Bin(procinfo_bin);
     
    65426539  {
    65436540    sleftv tmp;
    6544     memset(&tmp,0,sizeof(tmp));
     6541    tmp.Init();
    65456542    tmp.rtyp=IDHDL;
    65466543    idhdl h=rDefault(ring_name);
     
    65626559    sleftv tmp;
    65636560    sleftv n;
    6564     memset(&n,0,sizeof(n));
     6561    n.Init();
    65656562    n.name=ring_name;
    65666563    if (iiDeclCommand(&tmp,&n,myynest,CRING_CMD,&IDROOT)) return TRUE;
     
    66376634      &&(IDTYP((idhdl)source->data)!=RING_CMD))
    66386635      {
    6639         memset(&iiRETURNEXPR,0,sizeof(sleftv));
     6636        iiRETURNEXPR.Init();
    66406637        iiRETURNEXPR.rtyp=IDTYP((idhdl)source->data);
    66416638        iiRETURNEXPR.data=IDDATA((idhdl)source->data);
  • Singular/newstruct.cc

    r2d01c0 r95e3732  
    5959    {
    6060      sleftv tmp;
    61       memset(&tmp,0,sizeof(tmp));
     61      tmp.Init();
    6262      tmp.rtyp=ad->id;
    6363      void * newstruct_Copy(blackbox*, void *); //forward declaration
    6464      tmp.data=(void*)newstruct_Copy(b,d);
    6565      idrec hh;
    66       memset(&hh,0,sizeof(hh));
     66      hh.Init();
    6767      hh.id=Tok2Cmdname(p->t);
    6868      hh.typ=PROC_CMD;
     
    182182    BOOLEAN sl;
    183183    idrec hh;
    184     memset(&hh,0,sizeof(hh));
     184    hh.Init();
    185185    hh.id=Tok2Cmdname(p->t);
    186186    hh.typ=PROC_CMD;
    187187    hh.data.pinf=p->p;
    188188    sleftv tmp;
    189     memset(&tmp,0,sizeof(sleftv));
    190189    tmp.Copy(r);
    191190    sl = iiMake_proc(&hh, NULL, &tmp);
     
    259258  {
    260259    idrec hh;
    261     memset(&hh,0,sizeof(hh));
     260    hh.Init();
    262261    hh.id=Tok2Cmdname(p->t);
    263262    hh.typ=PROC_CMD;
     
    438437          r->start = nm->pos+1;
    439438          memcpy(res,a1,sizeof(sleftv));
    440           memset(a1,0,sizeof(sleftv));
     439          a1->Init();
    441440          if (res->e==NULL) res->e=r;
    442441          else
     
    446445            sh->next=r;
    447446          }
    448           //a1->CleanUp();// see memset above
     447          //a1->CleanUp();// see Init() above
    449448          a2->CleanUp();
    450449          return FALSE;
     
    469468  {
    470469    sleftv tmp;
    471     memset(&tmp,0,sizeof(sleftv));
    472470    tmp.Copy(a1);
    473471    tmp.next=(leftv)omAlloc0(sizeof(sleftv));
    474472    tmp.next->Copy(a2);
    475473    idrec hh;
    476     memset(&hh,0,sizeof(hh));
     474    hh.Init();
    477475    hh.id=Tok2Cmdname(p->t);
    478476    hh.typ=PROC_CMD;
     
    517515  {
    518516    idrec hh;
    519     memset(&hh,0,sizeof(hh));
     517    hh.Init();
    520518    hh.id=Tok2Cmdname(p->t);
    521519    hh.typ=PROC_CMD;
     
    613611  newstruct_desc dd=(newstruct_desc)b->data;
    614612  sleftv l;
    615   memset(&l,0,sizeof(l));
     613  l.Init();
    616614  l.rtyp=STRING_CMD;
    617615  l.data=(void*)getBlackboxName(dd->id);
     
    684682    BOOLEAN sl;
    685683    sleftv tmp;
    686     memset(&tmp,0,sizeof(tmp));
     684    tmp.Init();
    687685    tmp.rtyp=dd->id;
    688686    tmp.data=(void*)newstruct_Copy(b,d);
    689687    idrec hh;
    690     memset(&hh,0,sizeof(hh));
     688    hh.Init();
    691689    hh.id=Tok2Cmdname(p->t);
    692690    hh.typ=PROC_CMD;
  • Singular/subexpr.cc

    r2d01c0 r95e3732  
    148148        {
    149149          PrintNSpaces(spaces);
    150           const ring r = (const ring)d;
     150          const ring r = (ring)d;
    151151          rWrite(r, currRing == r);
    152152          break;
     
    18301830  v->Init();
    18311831  v->req_packhdl = currPack;
    1832   idhdl h=NULL;
    18331832#ifdef SIQ
    18341833  if (siq<=0)
     
    19281927          {
    19291928            memcpy(this,&iiRETURNEXPR,sizeof(sleftv));
    1930             memset(&iiRETURNEXPR,0,sizeof(sleftv));
     1929            iiRETURNEXPR.Init();
    19311930          }
    19321931        }
     
    19731972          if (!nok)
    19741973          {
    1975             memset(&d->arg1,0,sizeof(sleftv));
     1974            d->arg1.Init();
    19761975            this->CleanUp();
    19771976            rtyp=NONE;
Note: See TracChangeset for help on using the changeset viewer.