Changeset cf74099 in git


Ignore:
Timestamp:
Nov 17, 1999, 7:22:56 PM (24 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')
Children:
3922e33bebab34b16642a6fbb08394474eac7666
Parents:
68297e89c8c24c38656fd40ec740a03c2fdff568
Message:
* hannes: ring(cf,vars,ord)- construction
  (grammar.y iparith.cc ring.cc ring.h)
  feread.cc: change message, if dyn.loading failed


git-svn-id: file:///usr/local/Singular/svn/trunk@3840 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • Singular/feread.cc

    r68297e rcf74099  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: feread.cc,v 1.29 1999-11-15 14:37:01 Singular Exp $ */
     4/* $Id: feread.cc,v 1.30 1999-11-17 18:22:52 Singular Exp $ */
    55/*
    66* ABSTRACT: input from ttys, simulating fgets
    … …  
    361361  if (res!=0)
    362362  {
    363     Warn("dynamic loading failed: %d\n",res);
     363    if (res==1)
     364      WarnS("dynamic loading of libreadline failed");
     365    else
     366      Warn("dynamic loading failed: %d\n",res);
    364367    fe_fgets_stdin=fe_fgets_stdin_emu;
    365368    return fe_fgets_stdin_emu(pr,s,size);

  • Singular/grammar.y

    r68297e rcf74099  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: grammar.y,v 1.74 1999-11-15 17:20:04 obachman Exp $ */
     4/* $Id: grammar.y,v 1.75 1999-11-17 18:22:53 Singular Exp $ */
    55/*
    66* ABSTRACT: SINGULAR shell grammatik
    … …  
    326326            #endif
    327327            prompt_char = '>';
    328             if (sdb_flags & 2) { sdb_flags=1; YYERROR; }
     328            if (sdb_flags & 2) { sdb_flags=1; YYERROR; }
    329329            if(siCntrlc)
    330330            {
    … …  
    365365            siq=0;
    366366            #endif
    367             yyInRingConstruction = FALSE;
     367            yyInRingConstruction = FALSE;
    368368            currentVoice->ifsw=0;
    369369            if (inerror)
    … …  
    381381            yyerror("");
    382382            yyerrok;
    383             if ((sdb_flags & 1) && currentVoice->pi!=NULL)
    384             {
    385               currentVoice->pi->trace_flag |=1;
    386             }
    387             else
     383            if ((sdb_flags & 1) && currentVoice->pi!=NULL)
     384            {
     385              currentVoice->pi->trace_flag |=1;
     386            }
     387            else
    388388            if (myynest>0)
    389389            {
    … …  
    400400              exitVoice();
    401401            }
    402             if (sdb_flags &2) sdb_flags=1;
     402            if (sdb_flags &2) sdb_flags=1;
    403403          }
    404404        ;
    … …  
    478478              memset(&tmp,0,sizeof(tmp));
    479479              i=iiTestConvert((t=v->Typ()),POLY_CMD);
    480               if((i==0) || (iiConvert(t /*v->Typ()*/,POLY_CMD,i,v,&tmp))) 
     480              if((i==0) || (iiConvert(t /*v->Typ()*/,POLY_CMD,i,v,&tmp)))
    481481              {
    482482                pDelete((poly *)&$$.data);
    … …  
    664664            if(iiExprArith1(&$$,&$3,INTMAT_CMD)) YYERROR;
    665665          }
     666        | RING_CMD '(' rlist ',' rlist ',' ordering ')'
     667          {
     668            if(iiExprArith3(&$$,RING_CMD,&$3,&$5,&$7)) YYERROR;
     669          }
     670        | RING_CMD '(' expr ')'
     671          {
     672            if(iiExprArith1(&$$,&$3,RING_CMD)) YYERROR;
     673          }
    666674        | quote_start expr quote_end
    667675          {
    … …  
    950958        UNKNOWN_IDENT
    951959        {
    952           // let rInit take care of any errors 
     960          // let rInit take care of any errors
    953961          $$=rOrderName($1);
    954962        }
    … …  
    11291137            else
    11301138            {
    1131 #ifdef HAVE_NAMESPACES
    1132             if (v->packhdl != NULL)
    1133             {
    1134               namespaceroot->push( IDPACKAGE(v->packhdl) , IDID(v->packhdl));
    1135               killhdl((idhdl)v->data);
    1136               namespaceroot->pop();
    1137             }
    1138             else
    1139 #endif /* HAVE_NAMESPACES */
    1140               killhdl((idhdl)v->data);
     1139            #ifdef HAVE_NAMESPACES
     1140              if (v->packhdl != NULL)
     1141              {
     1142                namespaceroot->push( IDPACKAGE(v->packhdl) , IDID(v->packhdl));
     1143                killhdl((idhdl)v->data);
     1144                namespaceroot->pop();
     1145              }
     1146              else
     1147              #endif /* HAVE_NAMESPACES */
     1148                killhdl((idhdl)v->data);
    11411149            }
    11421150            v=v->next;
    … …  
    13321340              }
    13331341            #endif /* HAVE_NAMESPACES */
    1334             idhdl b=
    1335             rInit(ring_name,      /* ringname */
    1336                   &$4,            /* characteristik and list of parameters*/
     1342            ring b=
     1343            rInit(&$4,            /* characteristik and list of parameters*/
    13371344                  &$6,            /* names of ringvariables */
    13381345                  &$8);            /* ordering */
    1339 #ifdef HAVE_NAMESPACES
    1340             if(do_pop) namespaceroot->pop();
    1341 #endif /* HAVE_NAMESPACES */
    1342             yyInRingConstruction = FALSE;
    1343             if (b==NULL)
     1346            idhdl newRingHdl=NULL;
     1347            if (b!=NULL)
     1348            {
     1349              newRingHdl=enterid(ring_name, myynest, RING_CMD, &IDROOT);
     1350              if (newRingHdl!=NULL)
     1351              {
     1352                Free(IDRING(newRingHdl),sizeof(ip_sring));
     1353                IDRING(newRingHdl)=b;
     1354              }
     1355              else
     1356              {
     1357                rKill(b);
     1358              }
     1359            }
     1360            #ifdef HAVE_NAMESPACES
     1361              if(do_pop) namespaceroot->pop();
     1362            #endif /* HAVE_NAMESPACES */
     1363            yyInRingConstruction = FALSE;
     1364            if (newRingHdl==NULL)
    13441365            {
    13451366              MYYERROR("cannot make ring");
    … …  
    13471368            else
    13481369            {
    1349               rSetHdl(b);
     1370              rSetHdl(newRingHdl);
    13501371            }
    13511372          }
    … …  
    13541375            BOOLEAN do_pop = FALSE;
    13551376            char *ring_name = $2.name;
    1356 #ifdef HAVE_NAMESPACES
    1357             if (((sleftv)$2).req_packhdl != NULL)
    1358             {
    1359               namespaceroot->push( IDPACKAGE(((sleftv)$2).req_packhdl) , "");
    1360               do_pop = TRUE;
    1361               if( (((sleftv)$2).req_packhdl != NULL) &&
     1377            #ifdef HAVE_NAMESPACES
     1378              if (((sleftv)$2).req_packhdl != NULL)
     1379              {
     1380                namespaceroot->push( IDPACKAGE(((sleftv)$2).req_packhdl) , "");
     1381                do_pop = TRUE;
     1382                if( (((sleftv)$2).req_packhdl != NULL) &&
    13621383                  (((sleftv)$2).packhdl != ((sleftv)$2).req_packhdl))
    1363                 ring_name = mstrdup($2.name);
    1364             }
    1365 #endif /* HAVE_NAMESPACES */
     1384                  ring_name = mstrdup($2.name);
     1385              }
     1386            #endif /* HAVE_NAMESPACES */
    13661387            if (!inerror) rDefault(ring_name);
    1367 #ifdef HAVE_NAMESPACES
    1368             if(do_pop) namespaceroot->pop();
    1369 #endif /* HAVE_NAMESPACES */
    1370             yyInRingConstruction = FALSE;
    1371           }
    1372         | DRING_CMD { yyInRingConstruction = TRUE; }
    1373           elemexpr cmdeq
    1374           rlist     ','       /* description of coeffs */
    1375           rlist     ','       /* var names */
    1376           ordering           /* list of (multiplier ordering (weight(s))) */
    1377           {
    1378             #ifdef DRING
    1379             BOOLEAN do_pop = FALSE;
    1380             idhdl h;
    1381             char *ring_name = $3.name;
    1382 #ifdef HAVE_NAMESPACES
    1383             if (((sleftv)$3).req_packhdl != NULL)
    1384             {
    1385               namespaceroot->push( IDPACKAGE(((sleftv)$3).req_packhdl) , "");
    1386               do_pop = TRUE;
    1387               if( (((sleftv)$2).req_packhdl != NULL) &&
    1388                   (((sleftv)$3).packhdl != ((sleftv)$3).req_packhdl))
    1389                 ring_name = mstrdup($3.name);
    1390             }
    1391 #endif /* HAVE_NAMESPACES */
    1392             h=rInit($3.name,    /* ringname */
    1393                    &$5,         /* characteristik and list of parameters*/
    1394                    &$7,         /* names of ringvariables */
    1395                    &$9,         /* ordering */
    1396                    TRUE);       /* is a dring */
    1397 #ifdef HAVE_NAMESPACES
    1398             if(do_pop) namespaceroot->pop();
    1399 #endif /* HAVE_NAMESPACES */
    1400             if(h==NULL)
    1401             {
    1402               YYERROR;
    1403             }
    1404             rSetHdl(h);
    1405             setFlag(h,FLAG_DRING);
    1406             rDSet();
    1407             #endif
    1408             yyInRingConstruction = FALSE;
     1388            #ifdef HAVE_NAMESPACES
     1389              if(do_pop) namespaceroot->pop();
     1390            #endif /* HAVE_NAMESPACES */
     1391            yyInRingConstruction = FALSE;
    14091392          }
    14101393        ;

  • Singular/iparith.cc

    r68297e rcf74099  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iparith.cc,v 1.186 1999-11-15 17:20:08 obachman Exp $ */
     4/* $Id: iparith.cc,v 1.187 1999-11-17 18:22:54 Singular Exp $ */
    55
    66/*
    … …  
    42384238}
    42394239#endif
     4240static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
     4241{
     4242  res->data=(void *)rInit(u,v,w);
     4243  return (res->data==NULL);
     4244}
    42404245static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
    42414246{
    … …  
    43344339,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
    43354340#endif
     4341,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD }
    43364342#ifdef HAVE_SPECTRUM
    43374343,{semicProc3,       SEMIC_CMD,  INT_CMD,    LIST_CMD,   LIST_CMD,   INT_CMD }

  • Singular/ring.cc

    r68297e rcf74099  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ring.cc,v 1.83 1999-11-17 10:51:02 obachman Exp $ */
     4/* $Id: ring.cc,v 1.84 1999-11-17 18:22:55 Singular Exp $ */
    55
    66/*
    … …  
    483483// NOTE:   * makes new ring to current ring, on success
    484484//         * considers input sleftv's as read-only
    485 idhdl rInit(char *s, sleftv* pn, sleftv* rv, sleftv* ord)
     485//idhdl rInit(char *s, sleftv* pn, sleftv* rv, sleftv* ord)
     486ring rInit(sleftv* pn, sleftv* rv, sleftv* ord)
    486487{
    487488  int ch;
    … …  
    637638  rTest(R);
    638639
    639   // try to enter the ring into the name list //
     640  // try to enter the ring into the name list
    640641  // need to clean up sleftv here, before this ring can be set to
    641642  // new currRing or currRing can be killed beacuse new ring has
    … …  
    644645  if (rv != NULL) rv->CleanUp();
    645646  if (ord != NULL) ord->CleanUp();
    646   if ((tmp = enterid(s, myynest, RING_CMD, &IDROOT))==NULL)
    647     goto rInitError;
    648 
    649   memcpy(IDRING(tmp),R,sizeof(*R));
     647  //if ((tmp = enterid(s, myynest, RING_CMD, &IDROOT))==NULL)
     648  //  goto rInitError;
     649
     650  //memcpy(IDRING(tmp),R,sizeof(*R));
    650651  // set current ring
    651   FreeSizeOf(R,  ip_sring);
    652   return tmp;
     652  //FreeSizeOf(R,  ip_sring);
     653  //return tmp;
     654  return R;
    653655
    654656  // error case:
    … …  
    17321734 * DOES NOT CALL rComplete
    17331735 */
    1734 static ring rCopy0(ring r, BOOLEAN copy_qideal = TRUE, 
     1736static ring rCopy0(ring r, BOOLEAN copy_qideal = TRUE,
    17351737                   BOOLEAN copy_ordering = TRUE)
    17361738{
    … …  
    17881790  }
    17891791  res->idroot = NULL;
    1790   if (r->qideal!=NULL) 
     1792  if (r->qideal!=NULL)
    17911793  {
    17921794    if (copy_qideal) res->qideal= idCopy(r->qideal);
    … …  
    30713073  if (r->order[0] == ringorder_s)
    30723074  {
    3073     if (r->pCompIndex == r->ExpESize-3) 
     3075    if (r->pCompIndex == r->ExpESize-3)
    30743076      r->pOrdIndex = r->ExpLSize-3;
    30753077    else
    30763078      r->pOrdIndex = r->ExpLSize-2;
    30773079  }
    3078   else if (r->pCompIndex == r->ExpESize-1) 
     3080  else if (r->pCompIndex == r->ExpESize-1)
    30793081    r->pOrdIndex=r->ExpLSize-2;
    3080   else                               
     3082  else
    30813083    r->pOrdIndex=r->ExpLSize-1;
    30823084#endif
    … …  
    30953097    if (r->order[0] == ringorder_s && r->typ[0].data.syz.limit > 0)
    30963098    {
    3097       Free(r->typ[0].data.syz.syz_index, 
     3099      Free(r->typ[0].data.syz.syz_index,
    30983100           (r->typ[0].data.syz.limit +1)*sizeof(int));
    30993101    }
    … …  
    32803282// where R has a certain property. P might be equal r in which case r
    32813283// had already this property
    3282 // 
     3284//
    32833285// Without argument, these functions work on currRing and change it,
    32843286// if necessary
    … …  
    32893291{
    32903292  ring r = rAssureSyzComp(currRing);
    3291   if (r != currRing) 
     3293  if (r != currRing)
    32923294  {
    32933295    ring old_ring = currRing;
    32943296    rChangeCurrRing(r, TRUE);
    3295     if (old_ring->qideal != NULL) 
     3297    if (old_ring->qideal != NULL)
    32963298    {
    32973299      r->qideal = idrCopyR_NoSort(old_ring->qideal, old_ring);
    … …  
    33223324
    33233325  int ** wvhdl =(int **)Alloc0((i+1)*sizeof(int**));
    3324   for(j=i;j>0;j--) 
     3326  for(j=i;j>0;j--)
    33253327  {
    33263328    if (r->wvhdl[j-1] != NULL)
    … …  
    33353337  return res;
    33363338}
    3337  
     3339
    33383340
    33393341// use this for global orderings consisting of two blocks
    … …  
    33423344  int r_blocks = rBlocks(currRing);
    33433345  int i;
    3344  
    3345   assume(b1 == ringorder_c || b1 == ringorder_C || 
    3346          b2 == ringorder_c || b1 == ringorder_C || 
     3346
     3347  assume(b1 == ringorder_c || b1 == ringorder_C ||
     3348         b2 == ringorder_c || b1 == ringorder_C ||
    33473349         b2 == ringorder_S);
    3348  
     3350
    33493351  if (r_blocks == 2 && currRing->order[0] == b1 && currRing->order[2] == 0)
    33503352    return currRing;
    3351  
     3353
    33523354  ring res = rCopy0(currRing, FALSE, FALSE);
    33533355  res->order = (int*)Alloc0(3*sizeof(int));
    … …  
    34073409    {
    34083410      currRing->typ[0].data.syz.syz_index = (int*)
    3409         ReAlloc(currRing->typ[0].data.syz.syz_index, 
     3411        ReAlloc(currRing->typ[0].data.syz.syz_index,
    34103412                (currRing->typ[0].data.syz.limit+1)*sizeof(int),
    34113413                (k+1)*sizeof(int));
    … …  
    34133415    for (i=currRing->typ[0].data.syz.limit + 1; i<= k; i++)
    34143416    {
    3415       currRing->typ[0].data.syz.syz_index[i] = 
     3417      currRing->typ[0].data.syz.syz_index[i] =
    34163418        currRing->typ[0].data.syz.curr_index;
    34173419    }
    … …  
    34493451  }
    34503452}
    3451 
    3452    

  • Singular/ring.h

    r68297e rcf74099  
    77* ABSTRACT - the interpreter related ring operations
    88*/
    9 /* $Id: ring.h,v 1.41 1999-11-17 10:51:04 obachman Exp $ */
     9/* $Id: ring.h,v 1.42 1999-11-17 18:22:56 Singular Exp $ */
    1010
    1111/* includes */
    … …  
    1818void   rChangeCurrRing(ring r, BOOLEAN complete = TRUE);
    1919void   rSetHdl(idhdl h, BOOLEAN complete = TRUE);
    20 idhdl  rInit(char *s, sleftv* pn, sleftv* rv, sleftv* ord);
     20ring   rInit(sleftv* pn, sleftv* rv, sleftv* ord);
    2121idhdl  rDefault(char *s);
    2222int    rIsRingVar(char *n);
    … …  
    143143}
    144144
    145 typedef enum rRingOrder_t 
     145typedef enum rRingOrder_t
    146146{
    147147  ringorder_no = 0,
    … …  
    187187
    188188inline int rGetCurrSyzLimit()
    189 { return (currRing->order[0] == ringorder_s ? 
     189{ return (currRing->order[0] == ringorder_s ?
    190190          currRing->typ[0].data.syz.limit : 0);}
    191191
    … …  
    199199// Assume: i<= syzIndex_limit
    200200int rGetMaxSyzComp(int i);
    201  
     201
    202202BOOLEAN rHasSimpleOrder(ring r);
    203203// returns TRUE, if simple lp or ls ordering
Note: See TracChangeset for help on using the changeset viewer.