Changeset 8141412 in git


Ignore:
Timestamp:
Aug 11, 1997, 5:53:22 PM (27 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b21a664aa22dc6e196223af8a74ad4885e83547c')
Children:
9e76269b6654f6e38d3546d04b318c6693f2f4d9
Parents:
dcda1da7afba419dfbea63850d4522601c5ee3a7
Message:
* hannes: removed SIC/sic from grammar.y, iparith.cc, ipconv, ipshell,
    ring, subexpr, tok.h
    added PROC_BUG: PowerMac variant of INIT_BUG (iparith.cc)


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

Legend:

Unmodified
Added
Removed
  • Singular/grammar.y

    rdcda1da r8141412  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: grammar.y,v 1.17 1997-08-08 10:58:07 Singular Exp $ */
     4/* $Id: grammar.y,v 1.18 1997-08-11 15:53:15 Singular Exp $ */
    55/*
    66* ABSTRACT: SINGULAR shell grammatik
     
    286286        | lines pprompt
    287287          {
    288             if (timerv
    289             #ifdef SIC
    290             && (!sic)
    291             #endif
    292             )
     288            if (timerv)
    293289            {
    294290              writeTime("used time:");
     
    296292            }
    297293            #ifdef HAVE_RTIMER
    298             if (rtimerv
    299             #ifdef SIC
    300             && (!sic)
    301             #endif
    302             )
     294            if (rtimerv)
    303295            {
    304296              writeRTime("used real time:");
     
    340332        | returncmd
    341333          {
    342             #ifdef SIC
    343             if (!sic)
    344             #endif
    345334            YYACCEPT;
    346335          }
    347336        | SYS_BREAK
    348337          {
    349             #ifdef SIC
    350             if (sic)
    351               emStoreOp(SYS_BREAK,0);
    352             else
    353             #endif
    354             {
    355               ifswitch[voice]=0;
    356               iiDebug();
    357             }
     338            ifswitch[voice]=0;
     339            iiDebug();
    358340          }
    359341        | ';'                    /* ignore empty statements */
     
    376358            yyerror("");
    377359            yyerrok;
    378             #ifdef SIC
    379             if (sic) YYABORT;
    380             #endif
    381360            if (myynest>0)
    382361            {
     
    414393        RINGVAR
    415394          {
    416             #ifdef SIC
    417             if (!sic)
    418             #endif
    419               if (currRing==NULL) MYYERROR("no ring active");
     395            if (currRing==NULL) MYYERROR("no ring active");
    420396            syMake(&$$,$1);
    421397          }
     
    829805        | RING_DECL elemexpr
    830806          {
    831             #ifdef SIC
    832             if ((sic) && (currRing==NULL))
    833             {
    834               if (iiDeclCommand(&$$,&$2,myynest,$1,NULL)) YYERROR;
    835             }
    836             else
    837             #endif
    838             {
    839               if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
    840             }
     807            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
    841808          }
    842809        | currring_lists elemexpr
    843810          {
    844             #ifdef SIC
    845             if ((sic) && (currRing==NULL))
    846             {
    847               if (iiDeclCommand(&$$,&$2,myynest,$1,NULL)) YYERROR;
    848             }
    849             else
    850             #endif
    851             {
    852               if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
    853             }
     811            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
    854812          }
    855813        | MATRIX_CMD elemexpr '[' expr ']' '[' expr ']'
    856814          {
    857815            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
    858             #ifdef SIC
    859             if (sic)
    860             {
    861             }
    862             else
    863             #endif
    864             {
    865               int r; TESTSETINT($4,r);
    866               int c; TESTSETINT($7,c);
    867               if (r < 1)
    868                 MYYERROR("rows must be greater than 0");
    869               if (c < 0)
    870                 MYYERROR("cols must be greater than -1");
    871               leftv v=&$$;
    872               //while (v->next!=NULL) { v=v->next; }
    873               idhdl h=(idhdl)v->data;
    874               idDelete(&IDIDEAL(h));
    875               IDMATRIX(h) = mpNew(r,c);
    876               if (IDMATRIX(h)==NULL) YYERROR;
    877             }
     816            int r; TESTSETINT($4,r);
     817            int c; TESTSETINT($7,c);
     818            if (r < 1)
     819              MYYERROR("rows must be greater than 0");
     820            if (c < 0)
     821              MYYERROR("cols must be greater than -1");
     822            leftv v=&$$;
     823            //while (v->next!=NULL) { v=v->next; }
     824            idhdl h=(idhdl)v->data;
     825            idDelete(&IDIDEAL(h));
     826            IDMATRIX(h) = mpNew(r,c);
     827            if (IDMATRIX(h)==NULL) YYERROR;
    878828          }
    879829        | MATRIX_CMD elemexpr
     
    884834          {
    885835            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
    886             #ifdef SIC
    887             if (sic)
    888             {
    889             }
    890             else
    891             #endif
    892             {
    893               int r; TESTSETINT($4,r);
    894               int c; TESTSETINT($7,c);
    895               if (r < 1)
    896                 MYYERROR("rows must be greater than 0");
    897               if (c < 0)
    898                 MYYERROR("cols must be greater than -1");
    899               leftv v=&$$;
    900               //while (v->next!=NULL) { v=v->next; }
    901               idhdl h=(idhdl)v->data;
    902               delete IDINTVEC(h);
    903               IDINTVEC(h) = new intvec(r,c,0);
    904               if (IDINTVEC(h)==NULL) YYERROR;
    905             }
     836            int r; TESTSETINT($4,r);
     837            int c; TESTSETINT($7,c);
     838            if (r < 1)
     839              MYYERROR("rows must be greater than 0");
     840            if (c < 0)
     841              MYYERROR("cols must be greater than -1");
     842            leftv v=&$$;
     843            //while (v->next!=NULL) { v=v->next; }
     844            idhdl h=(idhdl)v->data;
     845            delete IDINTVEC(h);
     846            IDINTVEC(h) = new intvec(r,c,0);
     847            if (IDINTVEC(h)==NULL) YYERROR;
    906848          }
    907849        | INTMAT_CMD elemexpr
     
    939881        | PROC_CMD elemexpr
    940882          {
    941             #ifdef SIC
    942             if (sic)
    943             {
    944               FreeL((ADDRESS)$2);
    945               MYYERROR("not implemented");
    946             }
    947             #endif
    948883            if (iiDeclCommand(&$$,&$2,myynest,PROC_CMD,&idroot,TRUE)) YYERROR;
    949884          }
     
    1063998        EXECUTE_CMD expr
    1064999          {
    1065             #ifdef SIC
    1066             if (sic) MYYERROR("execute not supported");
    1067             #endif
    10681000            if ($2.Typ() == STRING_CMD)
    10691001            {
     
    11881120        | LISTVAR_CMD '(' RING_CMD ')'
    11891121          {
    1190             #ifdef SIC
    1191             if (sic) MYYERROR("not implemented yet");
    1192             #endif
    11931122            list_cmd(RING_CMD,NULL,"// ",TRUE);
    11941123          }
    11951124        | LISTVAR_CMD '(' MATRIX_CMD ')'
    11961125          {
    1197             #ifdef SIC
    1198             if (sic) MYYERROR("not implemented yet");
    1199             #endif
    12001126            list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
    12011127           }
    12021128        | LISTVAR_CMD '(' INTMAT_CMD ')'
    12031129          {
    1204             #ifdef SIC
    1205             if (sic) MYYERROR("not implemented yet");
    1206             #endif
    12071130            list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
    12081131          }
    12091132        | LISTVAR_CMD '(' PROC_CMD ')'
    12101133          {
    1211             #ifdef SIC
    1212             if (sic) MYYERROR("not implemented yet");
    1213             #endif
    12141134            list_cmd(PROC_CMD,NULL,"// ",TRUE);
    12151135          }
    12161136        | LISTVAR_CMD '(' elemexpr ')'
    12171137          {
    1218             #ifdef SIC
    1219             if (sic) MYYERROR("not implemented yet");
    1220             #endif
    12211138            list_cmd(0,$3.Name(),"// ",TRUE);
    12221139            $3.CleanUp();
     
    12241141        | LISTVAR_CMD '(' ')'
    12251142          {
    1226             #ifdef SIC
    1227             if (sic) MYYERROR("not implemented yet");
    1228             #endif
    12291143            list_cmd(-1,NULL,"// ",TRUE);
    12301144          }
     
    12421156          ordering           /* list of (multiplier ordering (weight(s))) */
    12431157          {
    1244             #ifdef SIC
    1245             if (sic)
    1246             {
    1247             }
    1248             #endif
    12491158            //noringvars = FALSE;
    12501159            if(!rInit($2.name,        /* ringname */
     
    13601269          {
    13611270            if ($2.rtyp!=IDHDL) MYYERROR("identifier expected");
    1362             #ifdef SIC
    1363             if (sic)
    1364             {
    1365             }
    1366             else
    1367             #endif
    1368             {
    1369               idhdl h = (idhdl)$2.data;
    1370               type_cmd(h);
    1371             }
     1271            idhdl h = (idhdl)$2.data;
     1272            type_cmd(h);
    13721273          }
    13731274        | exprlist
     
    14011302ifcmd: IF_CMD '(' expr ')' BLOCKTOK
    14021303          {
    1403             #ifdef SIC
    1404             if (sic)
    1405             {
    1406               //egPrint(IF_CMD,1,"if, 1\n");
    1407               //egPrint(&$3);
     1304            int i; TESTSETINT($3,i);
     1305            if (i!=0)
     1306            {
    14081307              newBuffer( $5, BT_if);
     1308              //printf("if:new level %d\n",voice);
    14091309            }
    14101310            else
    1411             #endif
    1412             {
    1413               int i; TESTSETINT($3,i);
    1414               if (i!=0)
     1311            {
     1312              FreeL((ADDRESS)$5);
     1313              ifswitch[voice]=1;
     1314              //printf("if:(0):set ifsw=1 in voice %d\n",voice);
     1315            }
     1316          }
     1317        | ELSE_CMD BLOCKTOK
     1318          {
     1319            if (ifswitch[voice]==1)
     1320            {
     1321              ifswitch[voice]=0;
     1322              newBuffer( $2, BT_else);
     1323            }
     1324            else
     1325            {
     1326              if (ifswitch[voice]!=2)
    14151327              {
    1416                 newBuffer( $5, BT_if);
    1417                 //printf("if:new level %d\n",voice);
     1328                char *s=$2+strlen($2)-1;
     1329                while ((*s=='\0')||(*s=='\n')) s--;
     1330                s[1]='\0';
     1331                Warn("`else` without `if` in level %d",myynest);
    14181332              }
    1419               else
    1420               {
    1421                 FreeL((ADDRESS)$5);
    1422                 ifswitch[voice]=1;
    1423                 //printf("if:(0):set ifsw=1 in voice %d\n",voice);
    1424               }
    1425             }
    1426           }
    1427         | ELSE_CMD BLOCKTOK
    1428           {
    1429             #ifdef SIC
    1430             if (sic)
    1431             {
    1432             //egPrint(ELSE_CMD,0,"op: else, 0\n");
    1433             newBuffer( $2, BT_else);
    1434             }
    1435             else
    1436             #endif
    1437             {
    1438               if (ifswitch[voice]==1)
    1439               {
    1440                 ifswitch[voice]=0;
    1441                 newBuffer( $2, BT_else);
    1442               }
    1443               else
    1444               {
    1445                 if (ifswitch[voice]!=2)
    1446                 {
    1447                   char *s=$2+strlen($2)-1;
    1448                   while ((*s=='\0')||(*s=='\n')) s--;
    1449                   s[1]='\0';
    1450                   Warn("`else` without `if` in level %d",myynest);
    1451                 }
    1452                 FreeL((ADDRESS)$2);
    1453               }
    1454               ifswitch[voice]=0;
    1455             }
     1333              FreeL((ADDRESS)$2);
     1334            }
     1335            ifswitch[voice]=0;
    14561336          }
    14571337        | IF_CMD '(' expr ')' BREAK_CMD
    14581338          {
    1459             #ifdef SIC
    1460             if (sic)
    1461             {
    1462               //egPrint(IFBREAK,1,"ifbreak, 1\n");
    1463               //egPrint(&$3);
    1464             }
    1465             else
    1466             #endif
    1467             {
    1468               int i; TESTSETINT($3,i);
    1469               if (i)
    1470               {
    1471                 if (exitBuffer(BT_break)) YYERROR;
    1472               }
    1473               ifswitch[voice]=0;
    1474             }
     1339            int i; TESTSETINT($3,i);
     1340            if (i)
     1341            {
     1342              if (exitBuffer(BT_break)) YYERROR;
     1343            }
     1344            ifswitch[voice]=0;
    14751345          }
    14761346        | BREAK_CMD
    14771347          {
    1478             #ifdef SIC
    1479             if (sic)
    1480             {
    1481             }
    1482             else
    1483             #endif
    1484             {
    1485               if (exitBuffer(BT_break)) YYERROR;
    1486               ifswitch[voice]=0;
    1487             }
     1348            if (exitBuffer(BT_break)) YYERROR;
     1349            ifswitch[voice]=0;
    14881350          }
    14891351        | CONTINUE_CMD
    14901352          {
    1491             #ifdef SIC
    1492             if (sic)
    1493             {
    1494             }
    1495             else
    1496             #endif
    1497             {
    1498               contBuffer(BT_break);
    1499               ifswitch[voice]=0;
    1500             }
     1353            contBuffer(BT_break);
     1354            ifswitch[voice]=0;
    15011355          }
    15021356      ;
     
    15361390        PROC_CMD extendedid BLOCKTOK
    15371391          {
    1538             #ifdef SIC
    1539             if (sic)
    1540             {
    1541               FreeL((ADDRESS)$2);
    1542               FreeL((ADDRESS)$3);
    1543               MYYERROR("not implemented");
    1544             }
    1545             #endif
    15461392            idhdl h = enterid($2,myynest,PROC_CMD,&idroot,FALSE);
    15471393            if (h==NULL) {FreeL((ADDRESS)$3); YYERROR;}
     
    15741420            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
    15751421            yylineno--;
    1576             #ifdef SIC
    1577             if (sic)
    1578             {
    1579               //egParameter(&$2);
    1580             }
    1581             else
    1582             #endif
    1583             {
    1584               if (iiParameter(&$2)) YYERROR;
    1585             }
     1422            if (iiParameter(&$2)) YYERROR;
    15861423          }
    15871424        | PARAMETER expr
     
    15891426            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
    15901427            sleftv tmp_expr;
    1591             #ifdef SIC
    1592             if (sic)
    1593             {
    1594               if (iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
    1595                 YYERROR;
    1596               //egParameter(&$2);
    1597             }
    1598             else
    1599             #endif
    1600             {
    1601               if ((iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
    1602               || (iiParameter(&tmp_expr)))
    1603                 YYERROR;
    1604             }
     1428            if ((iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
     1429            || (iiParameter(&tmp_expr)))
     1430              YYERROR;
    16051431          }
    16061432        ;
  • Singular/iparith.cc

    rdcda1da r8141412  
    248248  { "resultant",   0, RESULTANT_CMD,      CMD_3},
    249249  { "return",      0, RETURN ,            RETURN},
    250 #ifdef SIC
     250#if 0
    251251  { "RETURN",      0, END_PROC ,          RETURN},
    252252#else
     
    27292729static BOOLEAN jjSTRING_PROC(leftv res, leftv v)
    27302730{
    2731 #ifdef SIC
    2732   if (sic) { MYYERROR("not implemented"); return TRUE;}
    2733 #endif
    27342731  res->data=mstrdup(IDSTRING((idhdl)v->data));
    27352732  return FALSE;
     
    28922889    }
    28932890  }
     2891}
     2892#elif defined(PROC_BUG)
     2893static BOOLEAN jjstrlen(leftv res, leftv v)
     2894{
     2895  res->data = (char *)strlen(v->Data());
     2896  return FALSE;
     2897}
     2898static BOOLEAN jjpLength(leftv res, leftv v)
     2899{
     2900  res->data = (char *)pLength((poly)v->Data());
     2901  return FALSE;
     2902}
     2903static BOOLEAN jjidElem(leftv res, leftv v)
     2904{
     2905  res->data = (char *)idElem((ideal)v->Data());
     2906  return FALSE;
     2907}
     2908static BOOLEAN jjmpDet(leftv res, leftv v)
     2909{
     2910  res->data = (char *)mpDet((matrix)v->Data());
     2911  return FALSE;
     2912}
     2913static BOOLEAN jjidFreeModule(leftv res, leftv v)
     2914{
     2915  res->data = (char *)idFreeModule((int)v->Data());
     2916  return FALSE;
     2917}
     2918static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
     2919{
     2920  res->data = (char *)idVec2Ideal((poly)v->Data());
     2921  return FALSE;
     2922}
     2923static BOOLEAN jjrCharStr(leftv res, leftv v)
     2924{
     2925  res->data = rCharStr((ring)v->Data());
     2926  return FALSE;
     2927}
     2928#ifndef MDEBUG
     2929static BOOLEAN jjpHead(leftv res, leftv v)
     2930{
     2931  res->data = (char *)pHead((poly)v->Data());
     2932  return FALSE;
     2933}
     2934#endif
     2935static BOOLEAN jjidHead(leftv res, leftv v)
     2936{
     2937  res->data = (char *)idHead((ideal)v->Data());
     2938  return FALSE;
     2939}
     2940static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
     2941{
     2942  res->data = (char *)idMaxIdeal((int)v->Data());
     2943  return FALSE;
     2944}
     2945static BOOLEAN jjidMinBase(leftv res, leftv v)
     2946{
     2947  res->data = (char *)idMinBase((ideal)v->Data());
     2948  return FALSE;
     2949}
     2950static BOOLEAN jjsyMinBase(leftv res, leftv v)
     2951{
     2952  res->data = (char *)syMinBase((ideal)v->Data());
     2953  return FALSE;
     2954}
     2955static BOOLEAN jjpMaxComp(leftv res, leftv v)
     2956{
     2957  res->data = (char *)pMaxComp((poly)v->Data());
     2958  return FALSE;
     2959}
     2960static BOOLEAN jjmpTrace(leftv res, leftv v)
     2961{
     2962  res->data = (char *)mpTrace((matrix)v->Data());
     2963  return FALSE;
     2964}
     2965static BOOLEAN jjmpTransp(leftv res, leftv v)
     2966{
     2967  res->data = (char *)mpTransp((matrix)v->Data());
     2968  return FALSE;
     2969}
     2970static BOOLEAN jjrOrdStr(leftv res, leftv v)
     2971{
     2972  res->data = rOrdStr((ring)v->Data());
     2973  return FALSE;
     2974}
     2975static BOOLEAN jjrVarStr(leftv res, leftv v)
     2976{
     2977  res->data = rVarStr((ring)v->Data());
     2978  return FALSE;
     2979}
     2980static BOOLEAN jjrParStr(leftv res, leftv v)
     2981{
     2982  res->data = rParStr((ring)v->Data());
     2983  return FALSE;
     2984}
     2985static BOOLEAN jjidMinEmbedding(leftv res, leftv v)
     2986{
     2987  res->data = (char *)idMinEmbedding((ideal)v->Data());
     2988  return FALSE;
     2989}
     2990static BOOLEAN jjBETTI_R(leftv res, leftv v)
     2991{
     2992  res->data = (char *)BETTI_R((resolvente)v->Data());
     2993  return FALSE;
     2994}
     2995static BOOLEAN jjCOUNT_R(leftv res, leftv v)
     2996{
     2997  res->data = (char *)COUNT_R((resolvente)v->Data());
     2998  return FALSE;
     2999}
     3000static BOOLEAN jjDIM_R(leftv res, leftv v)
     3001{
     3002  res->data = (char *)DIM_R((resolvente)v->Data());
     3003  return FALSE;
     3004}
     3005static BOOLEAN jjMINRES_R(leftv res, leftv v)
     3006{
     3007  res->data = (char *)MINRES_R((resolvente)v->Data());
     3008  return FALSE;
    28943009}
    28953010#else
     
    45384653  if (!errorreported)
    45394654  {
    4540 #ifdef SIC
    4541     if (sic)
    4542     {
    4543       emStoreExpr(a);
    4544       emStoreExpr(b);
    4545       emStoreOp(op,2);
    4546       res->rtyp=SIC_MASK;
    4547       return FALSE;
    4548     }
    4549 #endif
    45504655#ifdef SIQ
    45514656    if (siq>0)
     
    46954800  if (!errorreported)
    46964801  {
    4697 #ifdef SIC
    4698     if (sic && (a->rtyp==SIC_MASK))
    4699     {
    4700       emStoreOp(op,1);
    4701       res->rtyp=SIC_MASK;
    4702       return FALSE;
    4703     }
    4704 #endif
    47054802#ifdef SIQ
    47064803    if (siq>0)
     
    47264823      {
    47274824        res->rtyp=dArith1[i].res;
    4728 #ifdef SIC
    4729         if (sic)
    4730         {
    4731           emStoreExpr(a);
    4732           emStoreOp(op,1);
    4733           res->rtyp=ABS(res->rtyp)|SIC_MASK;
    4734           a->CleanUp();
    4735           return FALSE;
    4736         }
    4737 #endif
    47384825        if (dArith1[i].res<0)
    47394826        {
    47404827          res->rtyp=-res->rtyp;
     4828          #ifdef PROC_BUG
     4829          dArith1[i].p(res,a);
     4830          #else
    47414831          res->data=(char *)((Proc1)dArith1[i].p)((char *)a->Data());
     4832          #endif
    47424833        }
    47434834        else if (dArith1[i].p(res,a))
     
    47684859        {
    47694860          res->rtyp=dArith1[i].res;
    4770 #ifdef SIC
    4771           if (sic)
    4772           {
    4773             emStoreExpr(a);
    4774             emStoreOp(op,1);
    4775             res->rtyp=ABS(res->rtyp)|SIC_MASK;
    4776             a->CleanUp();
    4777             return FALSE;
    4778           }
    4779 #endif
    47804861          if (dArith1[i].res<0)
    47814862          {
     
    47834864            failed= iiConvert(at,dArith1[i].arg,ai,a,an);
    47844865            if (!failed)
     4866            {
     4867              #ifdef PROC_BUG
     4868              dArith1[i].p(res,a);
     4869              #else
    47854870              res->data=(char *)((Proc1)dArith1[i].p)((char *)an->Data());
     4871              #endif
     4872            }
    47864873          }
    47874874          else
     
    48524939  if (!errorreported)
    48534940  {
    4854 #ifdef SIC
    4855     if (sic)
    4856     {
    4857       emStoreExpr(a);
    4858       emStoreExpr(b);
    4859       emStoreExpr(c);
    4860       emStoreOp(op,3);
    4861       res->rtyp=SIC_MASK;
    4862       return FALSE;
    4863     }
    4864 #endif
    48654941#ifdef SIQ
    48664942    if (siq>0)
     
    50215097  if (!errorreported)
    50225098  {
    5023 #ifdef SIC
    5024     if (sic)
    5025     {
    5026       emStoreExpr(a);
    5027       emStoreOp(op,a->listLength());
    5028       res->rtyp=SIC_MASK;
    5029       return FALSE;
    5030     }
    5031 #endif
    50325099#ifdef SIQ
    50335100    if (siq>0)
     
    51665233    cmds[i].alias=1;
    51675234  }
    5168   #ifndef SIC
    51695235  if (currRingHdl==NULL)
    51705236  {
     
    51825248    #endif
    51835249  }
    5184   #endif
    51855250  if (!expected_parms)
    51865251  {
  • Singular/ipconv.cc

    rdcda1da r8141412  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipconv.cc,v 1.6 1997-07-09 15:54:00 Singular Exp $ */
     4/* $Id: ipconv.cc,v 1.7 1997-08-11 15:53:18 Singular Exp $ */
    55/*
    66* ABSTRACT: automatic type conversions
     
    340340{
    341341  if ((inputType==outputType)
    342 #ifdef SIC
    343   || (inputType==0)
    344 #endif
    345342  || (outputType==DEF_CMD)
    346343  || (outputType==IDHDL)
  • Singular/ipshell.cc

    rdcda1da r8141412  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipshell.cc,v 1.12 1997-07-04 14:14:51 Singular Exp $ */
     4/* $Id: ipshell.cc,v 1.13 1997-08-11 15:53:19 Singular Exp $ */
    55/*
    66* ABSTRACT:
     
    3737char *lastreserved=NULL;
    3838
    39 #ifdef SIC
    40 int  myynest = 0;
    41 #else
    4239int  myynest = -1;
    43 #endif
    4440
    4541static BOOLEAN iiNoKeepRing=TRUE;
     
    688684  else
    689685  {
    690     #ifdef SIC
    691     if (root==NULL)
    692     {
    693       idhdl h=rDefault(mstrdup("? default_ring"));
    694       ring r=IDRING(h);
    695       char **n=r->names;
    696       int a=r->N;
    697       while ((*n!=NULL)&&(a>0)) { *n[0]='?'; n++;a--; }
    698       root=&(IDRING(h)->idroot);
    699     }
    700     //egPrint(DEFINE_VAR,t,"def %s type=%d,lev=%d\n",name->name,t,lev);
    701     //egPrint(name);
    702     #endif
    703686    sy->data = (char *)enterid(name->name,lev,t,root,init_b);
    704687    if (sy->data!=NULL)
     
    849832BOOLEAN iiCheckRing(int i)
    850833{
    851   #ifndef SIC
    852834  if (currRingHdl==NULL)
    853835  {
     
    865847    #endif
    866848  }
    867   #endif
    868849  return FALSE;
    869850}
  • Singular/ring.cc

    rdcda1da r8141412  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ring.cc,v 1.10 1997-07-11 11:10:09 obachman Exp $ */
     4/* $Id: ring.cc,v 1.11 1997-08-11 15:53:20 Singular Exp $ */
    55
    66/*
     
    440440      if (h==sNoName)
    441441      {
    442         #ifndef SIC
    443442        WerrorS("expected name of ring variable");
    444443        sl->CleanUp();
    445444        ord->CleanUp();
    446445        return NULL;
    447         #endif
    448446      }
    449447      tmpR.names[i] = mstrdup(h);
     
    600598      {
    601599        tmpR.block1[n]=tmpR.N;
    602         #ifndef SIC
    603600        if (tmpR.block0[n]>tmpR.N/*tmpR.block1[n]*/)
    604601        {
     
    609606          //return NULL;
    610607        }
    611         #endif
    612       }
    613       #ifndef SIC
     608      }
    614609      else
    615610      {
     
    619614        return NULL;
    620615      }
    621       #endif
    622616    }
    623617  }
  • Singular/subexpr.cc

    rdcda1da r8141412  
    312312        break;
    313313      default:
    314 #ifdef SIC
    315         if (rtyp<SIC_MASK)
    316 #endif
    317314        ::Print("CleanUp: unknown type %d\n",rtyp);  /* DEBUG */
    318 #endif
     315#endif         
    319316    } /* end switch: (rtyp) */
    320317    data=NULL;
     
    449446{
    450447  memset(this,0,sizeof(*this));
    451 #ifdef SIC
    452   if (source->rtyp>SIC_MASK)
    453   {
    454     rtyp=source->rtyp;
    455     return;
    456   }
    457   else
    458 #endif
    459448  rtyp=source->Typ();
    460449  void *d=source->Data();
  • Singular/tok.h

    rdcda1da r8141412  
    77* ABSTRACT: token for interpreter, as types; general macros
    88*/
    9 /* $Id: tok.h,v 1.9 1997-06-24 16:52:45 Singular Exp $ */
     9/* $Id: tok.h,v 1.10 1997-08-11 15:53:22 Singular Exp $ */
    1010
    1111#ifndef MYYSTYPE
     
    127127#define NONE END_RING
    128128#define UNKNOWN 0
    129 #define SIC_MASK 1024
    130129
    131130/*
Note: See TracChangeset for help on using the changeset viewer.