Changeset 0a3ddd in git


Ignore:
Timestamp:
Oct 21, 1998, 12:25:54 PM (26 years ago)
Author:
Kai Krüger <krueger@…>
Branches:
(u'spielwiese', '6e5adcba05493683b94648c659a729c189812c77')
Children:
c67136b6996540333f40f75592110b036a513219
Parents:
474fb0f7cb536c4ad3eda28eea8a1d8a1cfd6ecb
Message:
 Modified Files:
 	extra.cc grammar.y iparith.cc ipassign.cc ipconv.cc ipid.cc
 	ipid.h iplib.cc ipprint.cc ipshell.cc ipshell.h libparse.h
 	libparse.l lists.h lists.cc misc.cc tok.h tesths.cc subexpr.h
 	subexpr.cc silink.cc ring.cc mpsr_Tok.cc mpsr_Put.h
 	mpsr_Put.cc
	Added major changes for Namespaces. All test, except MP are
	running.


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

Legend:

Unmodified
Added
Removed

  • Singular/extra.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: extra.cc,v 1.69 1998-10-15 14:08:28 krueger Exp $ */
     4/* $Id: extra.cc,v 1.70 1998-10-21 10:25:26 krueger Exp $ */
    55/*
    66* ABSTRACT: general interface to internals of Singular ("system" command)
    … …  
    758758    }
    759759    else
     760/*==================== lib ==================================*/
     761    if(strcmp(sys_cmd,"nn")==0)
     762    {
     763      if ((h!=NULL) && (h->Typ()==STRING_CMD)) {
     764        idhdl pck = NULL, id = NULL;
     765        iiname2hdl(h->Data(), &pck, &id);
     766        if(pck != NULL) Print("Pack: '%s'\n", pck->id);
     767        if(id != NULL)  Print("Rec : '%s'\n", id->id);
     768        return FALSE;
     769      }
     770      else
     771        Warn("`%s` not found",(char*)h->Data());
     772    }
     773    else
    760774#ifdef HAVE_NAMESPACES
    761775/*==================== nspush ===================================*/
    762776    if(strcmp(sys_cmd,"nspush")==0)
    763777    {
    764       idhdl hh=namespaceroot->get((char*)h->Data(),0, TRUE);
    765       if ((hh!=NULL)&&(IDTYP(hh)==PACKAGE_CMD))
    766       {
     778      if (h->Typ()==PACKAGE_CMD)
     779      {
     780        idhdl hh=(idhdl)h->data;
    767781        namespaceroot = namespaceroot->push(IDPACKAGE(hh), IDID(hh));
    768782        return FALSE;
    769783      }
    770784      else
    771         Warn("package `%s` not found",(char*)h->Data());
     785        Warn("argument 2 is not a package");
    772786    }
    773787    else

  • Singular/grammar.y

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: grammar.y,v 1.49 1998-10-15 14:08:29 krueger Exp $ */
     4/* $Id: grammar.y,v 1.50 1998-10-21 10:25:27 krueger Exp $ */
    55/*
    66* ABSTRACT: SINGULAR shell grammatik
    … …  
    245245%token <i> EXECUTE_CMD
    246246%token <i> EXPORT_CMD
     247%token <i> EXPORTTO_CMD
     248%token <i> IMPORTFROM_CMD
    247249%token <i> HELP_CMD
    248250%token <i> KILL_CMD
    … …  
    287289
    288290/*%nonassoc '=' PLUSEQUAL DOTDOT*/
     291/*%nonassoc '=' DOTDOT COLONCOLON*/
    289292%nonassoc '=' DOTDOT COLONCOLON
    290293%left ','
    … …  
    452455            namespaceroot->push( IDPACKAGE((idhdl)$1.data),
    453456                                 ((sleftv)$1).name);
    454             syMake(&$$,$3);
     457            syMake(&$$,$3, ((sleftv)$1).data);
    455458            namespaceroot->pop();
    456459#else /* HAVE_NAMESPACES */
    457             idroot=IDPACKAGE((idhdl)$1.data)->idroot;
    458460            syMake(&$$,$3);
    459             idroot=r;
    460461#endif /* HAVE_NAMESPACES */
    461462          }
    … …  
    802803            if ($1.rtyp==0)
    803804            {
    804               Werror("`%s` is undefined",$1.Name());
     805              Werror("`%s` is undefined",$1.Fullname());
    805806              YYERROR;
    806807            }
    … …  
    839840        | RING_DECL elemexpr
    840841          {
    841             if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
     842            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot), TRUE)) YYERROR;
    842843          }
    843844        | currring_lists elemexpr
    844845          {
    845             if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
     846            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot), TRUE)) YYERROR;
    846847          }
    847848        | MATRIX_CMD elemexpr '[' expr ']' '[' expr ']'
    848849          {
    849             if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
     850            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot), TRUE)) YYERROR;
    850851            int r; TESTSETINT($4,r);
    851852            int c; TESTSETINT($7,c);
    … …  
    863864        | MATRIX_CMD elemexpr
    864865          {
    865             if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
     866            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot), TRUE)) YYERROR;
    866867          }
    867868        | INTMAT_CMD elemexpr '[' expr ']' '[' expr ']'
    … …  
    901902            if ((BEGIN_RING<t) && (t<END_RING))
    902903            {
    903               if (iiDeclCommand(&r,&$3,myynest,t,&(currRing->idroot))) YYERROR;
     904              if (iiDeclCommand(&r,&$3,myynest,t,&(currRing->idroot), TRUE)) YYERROR;
    904905            }
    905906            else
    … …  
    915916        | PROC_CMD elemexpr
    916917          {
    917             if (iiDeclCommand(&$$,&$2,myynest,PROC_CMD,&IDROOT,TRUE)) YYERROR;
     918            if (iiDeclCommand(&$$,&$2,myynest,PROC_CMD,&IDROOT, FALSE, TRUE)) YYERROR;
    918919          }
    919920        ;
    … …  
    10771078        EXPORT_CMD exprlist
    10781079        {
     1080#ifdef HAVE_NAMESPACES
     1081          if (iiExport(&$2,0,namespaceroot->get("Top",0,TRUE))) YYERROR;
     1082#else /* HAVE_NAMESPACES */
    10791083          if (iiExport(&$2,0)) YYERROR;
    1080         }
     1084#endif /* HAVE_NAMESPACES */
     1085            }
    10811086        | EXPORT_CMD exprlist extendedid expr
    10821087        {
    … …  
    10921097          else
    10931098          {
     1099#ifdef HAVE_NAMESPACES
    10941100            if ($4.Typ()==PACKAGE_CMD) {
    1095               if (iiExport(&$2,0,IDPACKAGE((idhdl)$4.data)->idroot))
     1101              if (iiExport(&$2,0,(idhdl)$4.data))
    10961102                YYERROR;
    10971103            }
    10981104            else
     1105#endif /* HAVE_NAMESPACES */
    10991106            {
    11001107             printf("String: %s;\n", (char *)$4.data);
    … …  
    11171124            else
    11181125            {
     1126#ifdef HAVE_NAMESPACES
     1127            if (v->packhdl != NULL)
     1128            {
     1129              namespaceroot->push( IDPACKAGE(v->packhdl) , IDID(v->packhdl));
     1130              killhdl((idhdl)v->data);
     1131              namespaceroot->pop();
     1132            }
     1133            else
     1134#endif /* HAVE_NAMESPACES */
    11191135              killhdl((idhdl)v->data);
    11201136            }
    … …  
    11611177        | LISTVAR_CMD '(' elemexpr ')'
    11621178          {
    1163             list_cmd(0,$3.Name(),"// ",TRUE);
     1179#ifdef HAVE_NAMESPACES
     1180            if($3.Typ() == PACKAGE_CMD) {
     1181              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1182                                   ((sleftv)$3).name);
     1183              list_cmd(-1,NULL,"// ",TRUE);
     1184              namespaceroot->pop();
     1185            }
     1186            else
     1187#endif /* HAVE_NAMESPACES */
     1188              list_cmd(0,$3.Fullname(),"// ",TRUE);
     1189            $3.CleanUp();
     1190          }
     1191        | LISTVAR_CMD '(' elemexpr ',' ROOT_DECL ')'
     1192          {
     1193#ifdef HAVE_NAMESPACES
     1194            if($3.Typ() == PACKAGE_CMD) {
     1195              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1196                                   ((sleftv)$3).name);
     1197              list_cmd($5,NULL,"// ",TRUE);
     1198              namespaceroot->pop();
     1199            }
     1200#endif /* HAVE_NAMESPACES */
     1201            $3.CleanUp();
     1202          }
     1203        | LISTVAR_CMD '(' elemexpr ',' ROOT_DECL_LIST ')'
     1204          {
     1205#ifdef HAVE_NAMESPACES
     1206            if($3.Typ() == PACKAGE_CMD) {
     1207              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1208                                   ((sleftv)$3).name);
     1209              list_cmd($5,NULL,"// ",TRUE);
     1210              namespaceroot->pop();
     1211            }
     1212#endif /* HAVE_NAMESPACES */
     1213            $3.CleanUp();
     1214          }
     1215        | LISTVAR_CMD '(' elemexpr ',' RING_DECL ')'
     1216          {
     1217#ifdef HAVE_NAMESPACES
     1218            if($3.Typ() == PACKAGE_CMD) {
     1219              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1220                                   ((sleftv)$3).name);
     1221              if ($5==QRING_CMD) $5=RING_CMD;
     1222              list_cmd($5,NULL,"// ",TRUE);
     1223              namespaceroot->pop();
     1224            }
     1225#endif /* HAVE_NAMESPACES */
     1226            $3.CleanUp();
     1227          }
     1228        | LISTVAR_CMD '(' elemexpr ',' currring_lists ')'
     1229          {
     1230#ifdef HAVE_NAMESPACES
     1231            if($3.Typ() == PACKAGE_CMD) {
     1232              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1233                                   ((sleftv)$3).name);
     1234              list_cmd($5,NULL,"// ",TRUE);
     1235              namespaceroot->pop();
     1236            }
     1237#endif /* HAVE_NAMESPACES */
     1238            $3.CleanUp();
     1239          }
     1240        | LISTVAR_CMD '(' elemexpr ',' RING_CMD ')'
     1241          {
     1242#ifdef HAVE_NAMESPACES
     1243            if($3.Typ() == PACKAGE_CMD) {
     1244              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1245                                   ((sleftv)$3).name);
     1246              list_cmd(RING_CMD,NULL,"// ",TRUE);
     1247              namespaceroot->pop();
     1248            }
     1249#endif /* HAVE_NAMESPACES */
     1250            $3.CleanUp();
     1251          }
     1252        | LISTVAR_CMD '(' elemexpr ',' MATRIX_CMD ')'
     1253          {
     1254#ifdef HAVE_NAMESPACES
     1255            if($3.Typ() == PACKAGE_CMD) {
     1256              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1257                                   ((sleftv)$3).name);
     1258              list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
     1259              namespaceroot->pop();
     1260            }
     1261#endif /* HAVE_NAMESPACES */
     1262            $3.CleanUp();
     1263          }
     1264        | LISTVAR_CMD '(' elemexpr ',' INTMAT_CMD ')'
     1265          {
     1266#ifdef HAVE_NAMESPACES
     1267            if($3.Typ() == PACKAGE_CMD) {
     1268              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1269                                   ((sleftv)$3).name);
     1270              list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
     1271              namespaceroot->pop();
     1272            }
     1273#endif /* HAVE_NAMESPACES */
     1274            $3.CleanUp();
     1275          }
     1276        | LISTVAR_CMD '(' elemexpr ',' PROC_CMD ')'
     1277          {
     1278#ifdef HAVE_NAMESPACES
     1279            if($3.Typ() == PACKAGE_CMD) {
     1280              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1281                                   ((sleftv)$3).name);
     1282              list_cmd(PROC_CMD,$3.Fullname(),"// ",TRUE);
     1283              namespaceroot->pop();
     1284            }
     1285#endif /* HAVE_NAMESPACES */
     1286            $3.CleanUp();
     1287          }
     1288        | LISTVAR_CMD '(' elemexpr ',' elemexpr ')'
     1289          {
     1290#ifdef HAVE_NAMESPACES
     1291            if($3.Typ() == PACKAGE_CMD) {
     1292              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
     1293                                   ((sleftv)$3).name);
     1294              list_cmd(0,$5.Fullname(),"// ",TRUE);
     1295              namespaceroot->pop();
     1296            }
     1297#endif /* HAVE_NAMESPACES */
    11641298            $3.CleanUp();
    11651299          }
    … …  
    11811315          ordering           /* list of (multiplier ordering (weight(s))) */
    11821316          {
     1317            BOOLEAN do_pop = FALSE;
    11831318            //noringvars = FALSE;
     1319            char *ring_name = $2.name;
     1320#ifdef HAVE_NAMESPACES
     1321            if (((sleftv)$2).req_packhdl != NULL)
     1322            {
     1323              namespaceroot->push( IDPACKAGE(((sleftv)$2).req_packhdl) , "");
     1324              do_pop = TRUE;
     1325              if( (((sleftv)$2).req_packhdl != NULL) &&
     1326                  (((sleftv)$2).packhdl != ((sleftv)$2).req_packhdl))
     1327                ring_name = mstrdup($2.name);
     1328            }
     1329#endif /* HAVE_NAMESPACES */
    11841330            idhdl b=
    1185             rInit($2.name,        /* ringname */
     1331            rInit(ring_name,      /* ringname */
    11861332                  &$4,            /* characteristik and list of parameters*/
    11871333                  &$6,            /* names of ringvariables */
    11881334                  &$8,            /* ordering */
    11891335                  FALSE);         /* is not a dring */
     1336#ifdef HAVE_NAMESPACES
     1337            if(do_pop) namespaceroot->pop();
     1338#endif /* HAVE_NAMESPACES */
    11901339            $4.CleanUp();
    11911340            $6.CleanUp();
    … …  
    11981347        | ringcmd1 elemexpr
    11991348          {
     1349            BOOLEAN do_pop = FALSE;
    12001350            //noringvars = FALSE;
    1201             if (!inerror) rDefault($2.name);
     1351            char *ring_name = $2.name;
     1352#ifdef HAVE_NAMESPACES
     1353            if (((sleftv)$2).req_packhdl != NULL)
     1354            {
     1355              namespaceroot->push( IDPACKAGE(((sleftv)$2).req_packhdl) , "");
     1356              do_pop = TRUE;
     1357              if( (((sleftv)$2).req_packhdl != NULL) &&
     1358                  (((sleftv)$2).packhdl != ((sleftv)$2).req_packhdl))
     1359                ring_name = mstrdup($2.name);
     1360            }
     1361#endif /* HAVE_NAMESPACES */
     1362            if (!inerror) rDefault(ring_name);
     1363#ifdef HAVE_NAMESPACES
     1364            if(do_pop) namespaceroot->pop();
     1365#endif /* HAVE_NAMESPACES */
    12021366          }
    12031367        | DRING_CMD { noringvars = TRUE; }
    … …  
    12081372          {
    12091373            #ifdef DRING
     1374            BOOLEAN do_pop = FALSE;
    12101375            idhdl h;
    12111376            //noringvars = FALSE;
     1377            char *ring_name = $3.name;
     1378#ifdef HAVE_NAMESPACES
     1379            if (((sleftv)$3).req_packhdl != NULL)
     1380            {
     1381              namespaceroot->push( IDPACKAGE(((sleftv)$3).req_packhdl) , "");
     1382              do_pop = TRUE;
     1383              if( (((sleftv)$2).req_packhdl != NULL) &&
     1384                  (((sleftv)$3).packhdl != ((sleftv)$3).req_packhdl))
     1385                ring_name = mstrdup($3.name);
     1386            }
     1387#endif /* HAVE_NAMESPACES */
    12121388            h=rInit($3.name,    /* ringname */
    12131389                   &$5,         /* characteristik and list of parameters*/
    … …  
    12151391                   &$9,         /* ordering */
    12161392                   TRUE);       /* is a dring */
     1393#ifdef HAVE_NAMESPACES
     1394            if(do_pop) namespaceroot->pop();
     1395#endif /* HAVE_NAMESPACES */
    12171396            $5.CleanUp();
    12181397            $7.CleanUp();
    … …  
    12581437                      if (iiExport(&$2,myynest-1)) YYERROR;
    12591438                    } else {
    1260                       if (iiExport(&$2,myynest-1, NSROOT(namespaceroot->next))) YYERROR;
     1439                      if (iiExport(&$2,myynest-1,
     1440                        namespaceroot->get(namespaceroot->next->name,0,TRUE)))
     1441                        YYERROR;
    12611442                    }
    12621443#else /* HAVE_NAMESPACES */

  • Singular/iparith.cc

    r474fb0f r0a3ddd  
    158158  { "execute",     0, EXECUTE_CMD ,       EXECUTE_CMD},
    159159  { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
     160  { "exportto",    0, EXPORTTO_CMD ,      CMD_M},
    160161  { "factorize",   0, FAC_CMD ,           CMD_12},
    161162  { "fetch",       0, FETCH_CMD ,         CMD_2},
    … …  
    175176  { "if",          0, IF_CMD ,            IF_CMD},
    176177  { "imap",        0, IMAP_CMD ,          CMD_2},
     178  { "importfrom",  0, IMPORTFROM_CMD ,    CMD_M},
    177179  { "indepSet",    0, INDEPSET_CMD ,      CMD_12},
    178180  { "insert",      0, INSERT_CMD ,        CMD_23},
    … …  
    198200  { "listvar",     0, LISTVAR_CMD ,       LISTVAR_CMD},
    199201  { "list",        0, LIST_CMD ,          ROOT_DECL_LIST},
     202  { "load",        0, LOAD_CMD ,          CMD_M},
    200203  { "lres",        0, LRES_CMD ,          CMD_2},
    201204  { "map",         0, MAP_CMD ,           RING_DECL},
    … …  
    281284  { "type",        0, TYPE_CMD ,          TYPE_CMD},
    282285  { "typeof",      0, TYPEOF_CMD ,        CMD_1},
     286  { "unload",      0, UNLOAD_CMD ,        CMD_M},
    283287  { "var",         0, VAR_CMD ,           CMD_1},
    284288  { "varstr",      0, VARSTR_CMD ,        CMD_12},
    … …  
    10331037  res->data=u->data; u->data=NULL;
    10341038  res->name=u->name; u->name=NULL;
     1039#ifdef HAVE_NAMESPACES
     1040  res->packhdl=u->packhdl; u->packhdl=NULL;
     1041  res->req_packhdl=u->req_packhdl; u->req_packhdl=NULL;
     1042#endif /* HAVE_NAMESPACES */
    10351043  res->e=u->e;       u->e=NULL;
    10361044  if (res->e==NULL) res->e=jjMakeSub(v);
    … …  
    10721080    p->data=u->data;
    10731081    p->name=u->name;
     1082#ifdef HAVE_NAMESPACES
     1083    p->packhdl=u->packhdl;
     1084#endif /* HAVE_NAMESPACES */
    10741085    p->flag|=u->flag;
    10751086    p->e=jjMakeSub(&t);
    … …  
    11971208  FreeL((ADDRESS)u->name);
    11981209  u->name=NULL;
    1199   syMake(res,n);
     1210#ifdef HAVE_NAMESPACES
     1211  if(u->req_packhdl != NULL) {
     1212    namespaceroot->push( IDPACKAGE(u->req_packhdl), IDID(u->req_packhdl));
     1213    syMake(res,n);
     1214    namespaceroot->pop();
     1215  }
     1216  else
     1217#endif /* HAVE_NAMESPACES */
     1218    syMake(res,n);
    12001219  return FALSE;
    12011220}
    … …  
    12061225  int i;
    12071226  char *n;
    1208 
     1227#ifdef HAVE_NAMESPACES
     1228  BOOLEAN needpop=FALSE;
     1229 
     1230  if(u->req_packhdl != NULL) {
     1231    namespaceroot->push( IDPACKAGE(u->req_packhdl), IDID(u->req_packhdl));
     1232    needpop = TRUE;
     1233  }
     1234#endif /* HAVE_NAMESPACES */
     1235 
    12091236  for (i=0;i<iv->length(); i++)
    12101237  {
    … …  
    12241251  FreeL((ADDRESS)u->name);
    12251252  u->name=NULL;
     1253#ifdef HAVE_NAMESPACES
     1254  if(needpop) namespaceroot->pop();
     1255#endif /* HAVE_NAMESPACES */
    12261256  return FALSE;
    12271257}
    12281258static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
    12291259{
     1260#ifdef HAVE_NAMESPACES
     1261  leftv sl = iiMake_proc((idhdl)u->data,u,v);
     1262#else /* HAVE_NAMESPACES */
    12301263  leftv sl = iiMake_proc((idhdl)u->data,v);
     1264#endif /* HAVE_NAMESPACES */
    12311265  if (sl==NULL)
    12321266  {
    … …  
    14431477  else
    14441478  {
    1445     Werror("%s undefined in %s",v->Name(),u->Name());
     1479    Werror("%s undefined in %s",v->Fullname(),u->Fullname());
    14461480  }
    14471481  return TRUE;
    14481482err_fetch:
    1449   Werror("no identity map from %s",u->Name());
     1483  Werror("no identity map from %s",u->Fullname());
    14501484  return TRUE;
    14511485}
    … …  
    21982232  if ((u->rtyp!=IDHDL) || (u->e!=NULL))
    21992233    return TRUE;
     2234#ifdef HAVE_NAMESPACES
     2235  leftv sl = iiMake_proc((idhdl) u->data,u,NULL);
     2236#else /* HAVE_NAMESPACES */
    22002237  leftv sl = iiMake_proc((idhdl) u->data,NULL);
     2238#endif /* HAVE_NAMESPACES */
    22012239  if (sl==NULL)
    22022240  {
    … …  
    32633301,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD }
    32643302,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE }
     3303,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD }
    32653304,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD }
    32663305,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD }
    … …  
    33603399  if ( (r<1) || (r>l) || (c<0) )
    33613400  {
    3362     Werror("wrong range[%d,%d] in string %s",r,c,u->Name());
     3401    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
    33633402    return TRUE;
    33643403  }
    … …  
    33753414  {
    33763415    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
    3377            r,c,u->Name(),iv->rows(),iv->cols());
     3416           r,c,u->Fullname(),iv->rows(),iv->cols());
    33783417    return TRUE;
    33793418  }
    … …  
    34053444  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
    34063445  {
    3407     Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Name(),
     3446    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
    34083447      MATROWS(m),MATCOLS(m));
    34093448    return TRUE;
    … …  
    42404279      {
    42414280        L->Clean();
    4242         Werror("`%s` is undefined",h->Name());
     4281        Werror("`%s` is undefined",h->Fullname());
    42434282        return TRUE;
    42444283      }
    … …  
    42584297static BOOLEAN jjNAMES0(leftv res, leftv v)
    42594298{
     4299#ifdef HAVE_NAMESPACES
     4300  res->data=(void *)ipNameList(NSROOT(namespaceroot->root));
     4301#else /* HAVE_NAMESPACES */
    42604302  res->data=(void *)ipNameList(IDROOT);
     4303#endif /* HAVE_NAMESPACES */
    42614304  return FALSE;
    42624305}
    … …  
    43774420}
    43784421#endif
     4422
     4423static BOOLEAN jjEXPORTTO(leftv res, leftv v)
     4424{
     4425#ifdef HAVE_NAMESPACES
     4426  BOOLEAN nok=TRUE;
     4427  if(v->rtyp==NSHDL) {
     4428    Print("Export to toplevel\n");
     4429    while(v->next!=NULL) {
     4430      nok = iiInternalExport(v->next, 0, v->data);
     4431      if(nok) return nok;
     4432    }
     4433  }
     4434  if(v->Typ()==PACKAGE_CMD) {
     4435    while(v->next!=NULL) {
     4436      nok = iiInternalExport(v->next, 0, v->data);
     4437      if(nok) return nok;
     4438    }
     4439  }
     4440#else /* HAVE_NAMESPACES */
     4441#endif /* HAVE_NAMESPACES */
     4442  return TRUE;
     4443}
     4444
     4445static BOOLEAN jjIMPORTFROM(leftv res, leftv v)
     4446{
     4447  BOOLEAN nok=FALSE;
     4448  Print("jjIMPORT_FROM()\n");
     4449  if(v->rtyp==NSHDL) {
     4450    Print("Import from toplevel\n");
     4451//While-schleife!!!
     4452    return FALSE;
     4453  }
     4454  if(v->Typ()==PACKAGE_CMD) {
     4455    Print("Import from package %s\n", v->name);
     4456    while(v->next!=NULL) {
     4457      //nok = iiInternalImport(v->next, 0, v->data);
     4458      if(nok) return nok;
     4459    }
     4460    return FALSE;
     4461  }
     4462  return TRUE;
     4463}
     4464
     4465static BOOLEAN jjLOAD(leftv res, leftv v)
     4466{
     4467  BOOLEAN nok=FALSE;
     4468  while( v!= NULL) {
     4469    if(v->Typ()==STRING_CMD) {
     4470      nok = iiLibCmd((char *)v->CopyD(), FALSE);
     4471      if(nok) return nok;
     4472    } else
     4473      return TRUE;
     4474    v = v->next;
     4475  }
     4476  return FALSE;
     4477}
     4478
     4479static BOOLEAN jjUNLOAD(leftv res, leftv v)
     4480{
     4481  if(v->Typ()==PACKAGE_CMD) {
     4482    char *typ;
     4483    idhdl h = (idhdl)v->data;
     4484    package d=v->Data();
     4485    switch (d->language) {
     4486        case LANG_C:        typ="object";   break;
     4487        case LANG_SINGULAR:
     4488        case LANG_NONE:     
     4489        default:
     4490          killhdl(h);
     4491    }
     4492    return FALSE;
     4493  }
     4494  return TRUE;
     4495}
    43794496
    43804497/*=================== operations with many arg.: table =================*/
    … …  
    44114528,{jjSTATUS_M,  STATUS_CMD,      INT_CMD,             4 }
    44124529#endif
    4413 ,{NULL,        0,               0,                  0  }
     4530,{jjIMPORTFROM,IMPORTFROM_CMD,  ANY_TYPE,           -2 }
     4531,{jjEXPORTTO,  EXPORTTO_CMD,    ANY_TYPE,           -2 }
     4532#ifdef HAVE_NAMESPACES
     4533 ,{jjLOAD,      LOAD_CMD,        NONE,              -2 }
     4534 ,{jjUNLOAD,    UNLOAD_CMD,      NONE,              -2 }
     4535#endif /* HAVE_NAMESPACES */
     4536 ,{NULL,        0,               0,                  0  }
    44144537};
    44154538#ifdef MDEBUG
    … …  
    48875010    if (!errorreported)
    48885011    {
    4889       if ((at==0) && (a->Name()!=sNoName))
     5012      if ((at==0) && (a->Fullname()!=sNoName))
    48905013      {
    4891         s=a->Name();
     5014        s=a->Fullname();
    48925015      }
    4893       else if ((bt==0) && (b->Name()!=sNoName))
     5016      else if ((bt==0) && (b->Fullname()!=sNoName))
    48945017      {
    4895         s=b->Name();
     5018        s=b->Fullname();
    48965019      }
    48975020      if (s!=NULL)
    … …  
    50485171    if (!errorreported)
    50495172    {
    5050       if ((at==0) && (a->Name()!=sNoName))
     5173      if ((at==0) && (a->Fullname()!=sNoName))
    50515174      {
    5052         Werror("`%s` is not defined",a->Name());
     5175        Werror("`%s` is not defined",a->Fullname());
    50535176      }
    50545177      else
    … …  
    51875310    {
    51885311      const char *s=NULL;
    5189       if ((at==0) && (a->Name()!=sNoName))
     5312      if ((at==0) && (a->Fullname()!=sNoName))
    51905313      {
    5191         s=a->Name();
     5314        s=a->Fullname();
    51925315      }
    5193       else if ((bt==0) && (b->Name()!=sNoName))
     5316      else if ((bt==0) && (b->Fullname()!=sNoName))
    51945317      {
    5195         s=b->Name();
     5318        s=b->Fullname();
    51965319      }
    5197       else if ((ct==0) && (c->Name()!=sNoName))
     5320      else if ((ct==0) && (c->Fullname()!=sNoName))
    51985321      {
    5199         s=c->Name();
     5322        s=c->Fullname();
    52005323      }
    52015324      if (s!=NULL)
    … …  
    53155438      if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
    53165439      {
    5317         Werror("`%s` is not defined",a->Name());
     5440        Werror("`%s` is not defined",a->Fullname());
    53185441      }
    53195442      else

  • Singular/ipassign.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipassign.cc,v 1.35 1998-10-15 15:15:31 Singular Exp $ */
     4/* $Id: ipassign.cc,v 1.36 1998-10-21 10:25:30 krueger Exp $ */
    55
    66/*
    … …  
    499499  }
    500500  r->ref++;
     501  return FALSE;
     502}
     503static BOOLEAN jiA_PACKAGE(leftv res, leftv a, Subexpr e)
     504{
     505  Print("Currently not supported\n");
     506    return FALSE;
     507  package pack=IDPACKAGE((idhdl)a->data);
     508  printf("Copy package - 1\n");
     509
     510  idhdl rl=(idhdl)res->data;
     511  if(rl == NULL) {
     512    return TRUE;
     513  }
     514  printf("Copy package - 2\n");
     515  if (&IDPACKAGE(rl)!=NULL) Free(IDPACKAGE(rl), sizeof(ip_package));
     516  IDPACKAGE(rl)=pack;
     517  printf("Copy package - 3\n");
     518  pack->ref++;
     519  printf("Copy package - 4\n");
    501520  return FALSE;
    502521}
    … …  
    530549,{jiA_LINK,     LINK_CMD,       STRING_CMD }
    531550,{jiA_LINK,     LINK_CMD,       LINK_CMD }
     551,{jiA_PACKAGE,  PACKAGE_CMD,    PACKAGE_CMD }
    532552,{NULL,         0,              0 }
    533553};
    … …  
    563583  if (rt==0)
    564584  {
    565     if (!errorreported) Werror("`%s` is undefined",r->Name());
     585    if (!errorreported) Werror("`%s` is undefined",r->Fullname());
    566586    return TRUE;
    567587  }
    … …  
    570590  if((lt==0)/*&&(l->name!=NULL)*/)
    571591  {
    572     if (!errorreported) Werror("left side `%s` is undefined",l->Name());
     592    if (!errorreported) Werror("left side `%s` is undefined",l->Fullname());
    573593    return TRUE;
    574594  }
    … …  
    691711  if (rt==0)
    692712  {
    693     if (!errorreported) Werror("`%s` is undefined",r->Name());
     713    if (!errorreported) Werror("`%s` is undefined",r->Fullname());
    694714    return TRUE;
    695715  }
    … …  
    850870    {
    851871      L->Clean();
    852       Werror("`%s` is undefined",h->Name());
     872      Werror("`%s` is undefined",h->Fullname());
    853873      return TRUE;
    854874    }
    … …  
    864884  IDLIST((idhdl)l->data)->Clean();
    865885  IDLIST((idhdl)l->data)=L;
    866   ipMoveId((idhdl)l->data);
     886#ifdef HAVE_NAMESPACES
     887  if (l->req_packhdl != NULL)
     888  {
     889    //Print("jjA_L_LIST: -1 \n");
     890    namespaceroot->push( IDPACKAGE(l->req_packhdl), IDID((idhdl)l));
     891    ipMoveId((idhdl)l->data);
     892    namespaceroot->pop();
     893  }
     894  else
     895#endif /* HAVE_NAMESPACES */
     896    ipMoveId((idhdl)l->data);
    867897  o_r->CleanUp();
    868898  return FALSE;
    … …  
    894924    if ((rt==0)||(rt==DEF_CMD))
    895925    {
     926//<<<<<<< ipassign.cc
     927//      L->Clean();
     928//      Werror("`%s` is undefined",h->Fullname());
     929//      return TRUE;
     930//=======
    896931      Werror("`%s` is undefined",h->Name());
    897932      goto err;
     933//>>>>>>> 1.35
    898934    }
    899935    if ((rt==RING_CMD)||(rt==QRING_CMD))
    … …  
    12271263       if(!b)
    12281264       {
     1265         //Print("jjA_L_LIST: - 2 \n");
    12291266         if((l->rtyp==IDHDL) && (l->data!=NULL))
    12301267         {
    1231            ipMoveId((idhdl)l->data);
     1268#ifdef HAVE_NAMESPACES
     1269           //if (IDTYP((idhdl)l->data)==LIST_CMD)
     1270           if ((l->req_packhdl)!= NULL)
     1271           {
     1272             namespaceroot->push( IDPACKAGE(l->req_packhdl) , IDID(l->req_packhdl));
     1273             ipMoveId((idhdl)l->data);
     1274             namespaceroot->pop();
     1275           }
     1276           else
     1277#endif /* HAVE_NAMESPACES */
     1278             ipMoveId((idhdl)l->data);
    12321279           l->attribute=IDATTR((idhdl)l->data);
    12331280           l->flag=IDFLAG((idhdl)l->data);
    … …  
    12651312        if (l->rtyp==IDHDL)
    12661313        {
    1267           if ((lt==DEF_CMD)||(lt==LIST_CMD)) ipMoveId((idhdl)l->data);
     1314          if ((lt==DEF_CMD)||(lt==LIST_CMD))
     1315          {
     1316#ifdef HAVE_NAMESPACES
     1317            //Print("jjA_L_LIST: - 3 \n");
     1318            if (lt==LIST_CMD && (l->req_packhdl)!= NULL)
     1319            {
     1320              namespaceroot->push( IDPACKAGE(l->req_packhdl) ,
     1321                                   IDID(l->req_packhdl));
     1322              ipMoveId((idhdl)l->data);
     1323              namespaceroot->pop();
     1324            }
     1325            else
     1326#endif /* HAVE_NAMESPACES */
     1327              ipMoveId((idhdl)l->data);
     1328          }
    12681329          l->attribute=IDATTR((idhdl)l->data);
    12691330          l->flag=IDFLAG((idhdl)l->data);
    … …  
    12861347        {
    12871348          if ((lt==DEF_CMD) || (lt==LIST_CMD))
    1288             ipMoveId((idhdl)l->data);
     1349          {
     1350            //Print("ipAssign - 3.0\n");
     1351#ifdef HAVE_NAMESPACES
     1352            //Print("jjA_L_LIST: - 4 \n");
     1353            if (lt==LIST_CMD && (l->req_packhdl)!= NULL)
     1354            {
     1355//              Print("==========>ipAssign() - 3\n");
     1356              namespaceroot->push( IDPACKAGE(l->req_packhdl) ,
     1357                                   IDID(l->req_packhdl));
     1358              ipMoveId((idhdl)l->data);
     1359              namespaceroot->pop();
     1360            }
     1361            else
     1362#endif /* HAVE_NAMESPACES */
     1363              ipMoveId((idhdl)l->data);
     1364          }
    12891365          l->attribute=IDATTR((idhdl)l->data);
    12901366          l->flag=IDFLAG((idhdl)l->data);
    … …  
    13431419      {
    13441420        FreeL((ADDRESS)IDMAP((idhdl)l->data)->preimage);
    1345         IDMAP((idhdl)l->data)->preimage = mstrdup (r->Name());
     1421        IDMAP((idhdl)l->data)->preimage = mstrdup (r->Fullname());
    13461422        /* advance the expressionlist to get the next element after the ring */
    13471423        hh = r->next;
    … …  
    14811557    case NONE:
    14821558    case 0:
    1483       Werror("cannot assign to %s",l->Name());
     1559      Werror("cannot assign to %s",l->Fullname());
    14841560      nok=TRUE;
    14851561      break;

  • Singular/ipconv.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipconv.cc,v 1.11 1998-09-24 09:59:44 Singular Exp $ */
     4/* $Id: ipconv.cc,v 1.12 1998-10-21 10:25:31 krueger Exp $ */
    55/*
    66* ABSTRACT: automatic type conversions
    … …  
    314314      }
    315315    }
     316#ifdef HAVE_NAMESPACES
     317    output->packhdl = input->packhdl;
     318    output->req_packhdl = input->req_packhdl;
     319#endif /* HAVE_NAMESPACES */
    316320    output->next=input->next;
    317321    input->next=NULL;
    … …  
    337341        return TRUE;
    338342      }
     343#ifdef HAVE_NAMESPACES
     344      //output->packhdl = input->packhdl;
     345      //output->req_packhdl = input->req_packhdl;
     346#endif /* HAVE_NAMESPACES */
    339347      output->next=input->next;
    340348      input->next=NULL;

  • Singular/ipid.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipid.cc,v 1.18 1998-10-15 14:08:31 krueger Exp $ */
     4/* $Id: ipid.cc,v 1.19 1998-10-21 10:25:32 krueger Exp $ */
    55
    66/*
    … …  
    147147}
    148148
    149 /* #define KAI */
     149//#define KAI
    150150idhdl enterid(char * s, int lev, idtyp t, idhdl* root, BOOLEAN init)
    151151{
    … …  
    176176        Warn(" redefining %s **",s);
    177177#endif
     178#ifdef HAVE_NAMESPACES
     179        if(strcmp(s,"Top")==0) {
     180        Warn("identifier `%s` in use",s);
     181        return(h);
     182      }
     183#endif /* HAVE_NAMESPACES */
    178184        if (s==IDID(h))
    179185        IDID(h)=NULL;
    … …  
    286292  else
    287293  {
    288     //if(t==PACKAGE_CMD) printf("Achtung\n");
    289     idhdl s=IDROOT;
    290     while ((s!=h) && (s!=NULL)) s=s->next;
    291     if (s==NULL) killhdl(h,&currRing->idroot);
    292     else killhdl(h,&IDROOT);
     294#ifdef HAVE_NAMESPACES
     295    if(t==PACKAGE_CMD) {
     296      killhdl(h,&NSROOT(namespaceroot->root));
     297    } else
     298#endif /* HAVE_NAMESPACES */
     299    {
     300      idhdl s=IDROOT;
     301      while ((s!=h) && (s!=NULL)) s=s->next;
     302      if (s==NULL) killhdl(h,&currRing->idroot);
     303      else killhdl(h,&IDROOT);
     304    }
    293305  }
    294306}
    … …  
    308320  // ring / qring  --------------------------------------------------------
    309321  // package  -------------------------------------------------------------
    310   if ((IDTYP(h) == RING_CMD) || (IDTYP(h) == QRING_CMD)
    311   || (IDTYP(h) == PACKAGE_CMD) /*|| (IDTYP(h) == POINTER_CMD)*/)
     322  if ((IDTYP(h) == RING_CMD) || (IDTYP(h) == QRING_CMD))
    312323  {
    313324    idhdl savecurrRingHdl = currRingHdl;
    … …  
    321332      idhdl  hdh = IDNEXT(*hd);
    322333      idhdl  temp;
    323       killOtherRing=(IDTYP(h)!=PACKAGE_CMD) && (IDRING(h)!=currRing);
     334      killOtherRing=(IDRING(h)!=currRing);
    324335      if (killOtherRing) //we are not killing the base ring, so switch
    325336      {
    … …  
    347358      }
    348359    }
    349 #ifdef HAVE_NAMESPACES
    350     if((IDTYP(h)==PACKAGE_CMD) || (IDTYP(h)==POINTER_CMD))
    351       Print(">>>>>>Free package\n");
    352     else
    353 #endif /* HAVE_NAMESPACES */
    354       rKill(h);
    355   }
     360    rKill(h);
     361  }
     362#ifdef HAVE_NAMESPACES
     363  // package -------------------------------------------------------------
     364  else if (IDTYP(h) == PACKAGE_CMD) {
     365    package pack = IDPACKAGE(h);
     366    if(!checkPackage(pack)) return;
     367    idhdl hdh = pack->idroot;
     368    //idhdl  hdh = IDNEXT(*hd);
     369    idhdl  temp;
     370    //Print(">>>>>>Free package\n");
     371    while (hdh!=NULL)
     372    {
     373      temp = IDNEXT(hdh);
     374      //Print("killing %s\n", IDID(hdh));
     375      killhdl(hdh,&(IDPACKAGE(h)->idroot));
     376      hdh = temp;
     377    }
     378    //Print("killing last %s\n", IDID(*hd));
     379    //killhdl(*hd,hd);
     380    //Print(">>>>>>Free package... done\n");
     381  }
     382  // pointer -------------------------------------------------------------
     383  else if(IDTYP(h)==POINTER_CMD) {
     384    Print(">>>>>>Free pointer\n");
     385  }
     386#endif /* HAVE_NAMESPACES */
    356387  // poly / vector -------------------------------------------------------
    357388  else if ((IDTYP(h) == POLY_CMD) || (IDTYP(h) == VECTOR_CMD))
    … …  
    693724}
    694725
    695 namehdl namerec::push(package pack, char *name, BOOLEAN init)
     726namehdl namerec::push(package pack, char *name, int nesting, BOOLEAN init)
    696727{
    697728  //printf("PUSH: put entry (%s) on stack\n", name);
    698729  namehdl ns = (namerec *)Alloc0(sizeof(namerec));
    699730  extern int myynest;
     731  if(nesting<0) nesting = myynest;
    700732  ns->next   = this;
    701733  if(this==NULL && !init)
    … …  
    712744    ns->isroot  = TRUE;
    713745    ns->lev     = 1;
    714     ns->myynest = 0;
     746    //ns->myynest = 0;
    715747  }
    716748  else
    … …  
    721753#endif /* HAVE_NAMESPACES */
    722754    ns->lev    = this->lev+1;
    723     ns->myynest = myynest+1;
     755    //ns->myynest = myynest+1;
    724756    this->currRing = currRing;
    725757    //printf("Saving Ring %x, %x\n", this->currRing, currRing);
    726758  }
    727759  ns->name    = mstrdup(name);
     760  ns->myynest = nesting;
    728761 
    729  
    730   //if(ns->isroot) Print("PUSH: Add root NameSpace\n");
    731762  //ns->currRing = currRing;
    732763  //ns->currRingHdl = currRingHdl;
    733   //printf("Test 1\n");
    734764  if(ns->isroot) ns->root=ns; else ns->root = this->root;
    735765  namespaceroot = ns;
    … …  
    748778}
    749779
    750 namehdl namerec::pop()
     780namehdl namerec::pop(BOOLEAN change_nesting)
    751781{
    752782  namehdl ns;
    … …  
    757787    return this;
    758788  }
     789  if(!change_nesting && this->myynest!=this->next->myynest) {
     790    return(this);
     791  }
    759792  ns = this;
    760793  namespaceroot = this->next;
    … …  
    780813  return( NSROOT(ns)->get(s, lev));
    781814}
    782 #endif /* HAVE_NAMESPACES */
     815
     816BOOLEAN checkPackage(package pack)
     817{
     818  namehdl nshdl = namespaceroot;
     819     
     820  for(nshdl=namespaceroot; nshdl->isroot != TRUE; nshdl = nshdl->next) {
     821    //Print("NSstack: %s:%d, nesting=%d\n", nshdl->name, nshdl->lev, nshdl->myynest);
     822    if (nshdl->pack==pack) {
     823      Warn("package '%s' still in use on level %d",nshdl->name, nshdl->lev);
     824      return FALSE;
     825    }
     826  }
     827  if (nshdl->pack==pack) {
     828    Warn("package '%s' still in use on level %d",nshdl->name, nshdl->lev);
     829    return FALSE;
     830  }
     831  return TRUE;
     832 
     833}
     834#endif /* HAVE_NAMESPACES */

  • Singular/ipid.h

    r474fb0f r0a3ddd  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: ipid.h,v 1.17 1998-10-15 14:08:32 krueger Exp $ */
     6/* $Id: ipid.h,v 1.18 1998-10-21 10:25:33 krueger Exp $ */
    77/*
    88* ABSTRACT: identfier handling
    … …  
    7676  idhdl      idroot; /* local objects */
    7777  short      ref;
     78  language_defs language;
    7879};
    7980
    … …  
    156157 namerec()  { memset(this,0,sizeof(*this)); }
    157158  //namehdl    Set(idhdl root);
    158   namehdl    pop();
    159   namehdl    push(package pack, char *name, BOOLEAN init=FALSE);
     159  namehdl    pop(BOOLEAN change_nesting=FALSE);
     160  namehdl    push(package pack, char *name, int nesting=-1, BOOLEAN init=FALSE);
    160161  idhdl      get(const char * s, int lev, BOOLEAN root=FALSE);
    161162};
    … …  
    183184lists ipNameList(idhdl root);
    184185void  ipMoveId(idhdl h);
     186BOOLEAN checkPackage(package pack);
    185187
    186188#define FLAG_STD   0

  • Singular/iplib.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iplib.cc,v 1.35 1998-10-19 14:02:31 hannes Exp $ */
     4/* $Id: iplib.cc,v 1.36 1998-10-21 10:25:34 krueger Exp $ */
    55/*
    66* ABSTRACT: interpreter: LIB and help
    … …  
    334334                                   iiRETURNEXPR_len*sizeof(sleftv),
    335335                                   (iiRETURNEXPR_len+16)*sizeof(sleftv));
    336 #ifdef IILOCALRING
     336#ifdef USE_IILOCALRING
    337337    iiLocalRing=(ring *)ReAlloc(iiLocalRing,
    338338                                   iiRETURNEXPR_len*sizeof(ring),
    … …  
    342342  }
    343343}
     344#ifdef HAVE_NAMESPACES
     345sleftv * iiMake_proc(idhdl pn, sleftv* slpn, sleftv* sl)
     346#else /* HAVE_NAMESPACES */
    344347sleftv * iiMake_proc(idhdl pn, sleftv* sl)
     348#endif /* HAVE_NAMESPACES */
    345349{
    346350  int err;
    … …  
    348352  char *plib = iiConvName(pi->libname);
    349353#ifdef HAVE_NAMESPACES
     354//  printf("iiMake_proc: %s %s cur=%s\n", pi->libname, plib, namespaceroot->name);
    350355  idhdl ns = namespaceroot->get(plib,0, TRUE);
     356  if((ns==NULL) && (slpn!=NULL) && (slpn->packhdl != NULL)) ns=slpn->packhdl;
    351357  if(pi->is_static) {
    352358    if(ns==NULL) {
    … …  
    366372  if(ns != NULL)
    367373  {
    368     namespaceroot->push(IDPACKAGE(ns), IDID(ns));
     374    namespaceroot->push(IDPACKAGE(ns), IDID(ns), myynest+1);
    369375    //printf("iiMake_proc: namespace found.\n");
    370376  }
    371377  else
    372378  {
    373     namespaceroot->push(namespaceroot->root->pack, "Top");
     379    namespaceroot->push(namespaceroot->root->pack, "Top", myynest+1);
    374380    //printf("iiMake_proc: staying in TOP-LEVEL\n");
    375381  }
    … …  
    381387    return NULL;
    382388  }
    383   namespaceroot->push(NULL, plib);
     389  namespaceroot->push(NULL, plib, myynest+1);
    384390#endif /* HAVE_NAMESPACES */
    385391  iiCheckNest();
    … …  
    425431    iiRETURNEXPR[myynest+1].Init();
    426432  }
    427 #ifdef HAVE_NAMESPACES
    428   if (namespaceroot->next->currRing != currRing)
    429   //if (iiLocalRing[myynest] != currRing)
    430   {
    431     //Print("RING changed?\n");
    432    
    433     if (((iiRETURNEXPR[myynest+1].Typ()>BEGIN_RING)
    434       && (iiRETURNEXPR[myynest+1].Typ()<END_RING))
    435     || ((iiRETURNEXPR[myynest+1].Typ()==LIST_CMD)
    436       && (lRingDependend((lists)iiRETURNEXPR[myynest+1].Data()))))
    437     {
    438       //idhdl hn;
    439       char *n;
    440       char *o;
    441       if (namespaceroot->next->currRing!=NULL) o=rFindHdl(namespaceroot->next->currRing,NULL, NULL)->id;
    442       //namespaceroot->currRingHdl->id;
    443       else                            o="none";
    444       if (currRing!=NULL)             n=rFindHdl(currRing,NULL, NULL)->id; //currRingHdl->id;
    445       else                            n="none";
    446       Werror("ring change during procedure call: %s -> %s",o,n);
    447       iiRETURNEXPR[myynest+1].CleanUp();
    448       err=TRUE;
    449     }
    450     if (namespaceroot->next->currRing!=NULL)
    451     {
    452       rSetHdl(rFindHdl(namespaceroot->next->currRing,NULL, NULL),TRUE);
    453       iiLocalRing[myynest]=NULL;
    454       namespaceroot->next->currRing = NULL;
    455     }
    456     else
    457     { currRingHdl=NULL; currRing=NULL; }
    458   }
    459   else
    460   {
    461     if(currRingHdl == NULL)
    462     {
    463       //printf("iplib.cc: currRingHdl is NULL\n");
    464       //currRingHdl = namespaceroot->currRingHdl;
    465     }
    466   }
    467 #else /* HAVE_NAMESPACES */
    468433#ifdef USE_IILOCALRING
    469434  if(namespaceroot->next->currRing != iiLocalRing[myynest]) printf("iiMake_proc: 1 ring not saved\n");
    … …  
    503468      && (lRingDependend((lists)iiRETURNEXPR[myynest+1].Data()))))
    504469    {
    505       //idhdl hn;
    506470      char *n;
    507471      char *o;
    … …  
    523487  }
    524488#endif /* USE_IILOCALRING */
    525 #endif /* HAVE_NAMESPACES */
    526489  if (iiCurrArgs!=NULL)
    527490  {
    … …  
    531494    iiCurrArgs=NULL;
    532495  }
    533 // #ifdef HAVE_NAMESPACES
    534   namespaceroot->pop();
    535 // #endif /* HAVE_NAMESPACES */
     496  namespaceroot->pop(TRUE);
    536497  if (err)
    537498    return NULL;
    … …  
    547508  BOOLEAN err;
    548509  int old_echo=si_echo;
     510  char *plib = iiConvName(pi->libname);
     511#ifdef HAVE_NAMESPACES
     512  idhdl ns = namespaceroot->get(plib,0, TRUE);
     513#endif /* HAVE_NAMESPACES */
    549514
    550515  newBuffer( example, BT_example, pi, pi->data.s.example_lineno );
    551516  iiCheckNest();
    552   namespaceroot->push(NULL, "");
    553   if(namespaceroot->next->currRing != currRing) printf("iiEStart: ring not saved\n");
     517#ifdef HAVE_NAMESPACES
     518  if(ns != NULL)  namespaceroot->push(IDPACKAGE(ns), IDID(ns), myynest+1);
     519  else            namespaceroot->push(namespaceroot->root->pack, "Top", myynest+1);
     520#else /* HAVE_NAMESPACES */
     521  namespaceroot->push(NULL, "", myynest+1);
     522#endif /* HAVE_NAMESPACES */
    554523#ifdef USE_IILOCALRING
    555524  iiLocalRing[myynest]=currRing;
    … …  
    599568  }
    600569#endif /* USE_IILOCALRING */
    601   namespaceroot->pop();
     570  namespaceroot->pop(TRUE);
    602571  return err;
    603572}
    604573
    605574/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
     575#ifdef HAVE_NAMESPACES
     576BOOLEAN iiLibCmd( char *newlib, BOOLEAN autoexport, BOOLEAN tellerror )
     577#else /* HAVE_NAMESPACES */
    606578BOOLEAN iiLibCmd( char *newlib, BOOLEAN tellerror )
     579#endif /* HAVE_NAMESPACES */
    607580{
    608581  char buf[256];
    … …  
    700673    pl = enterid( mstrdup(plib),0, PACKAGE_CMD,
    701674                  &NSROOT(namespaceroot->root), TRUE );
     675    IDPACKAGE(pl)->language = LANG_SINGULAR;
    702676  } else {
    703     Print("Found.\n");
    704     if(IDTYP(pl)!=PACKAGE_CMD) Print("not of typ package.\n");
     677    if(IDTYP(pl)!=PACKAGE_CMD) {
     678      Warn("not of typ package.");
     679      return TRUE;
     680    }
    705681  }
    706682  namespaceroot->push(IDPACKAGE(pl), IDID(pl));
    … …  
    716692  print_init();
    717693#  endif
    718 //  if (BVERBOSE(V_LOAD_LIB)) Print( "// ** loading %s...", libnamebuf);
    719694  extern int lpverbose;
    720695  if (BVERBOSE(V_DEBUG_LIB)) lpverbose=1; else lpverbose=0;
    721696# ifdef HAVE_NAMESPACES
    722    yylplex(newlib, libnamebuf, &lib_style, pl);
     697   yylplex(newlib, libnamebuf, &lib_style, pl, autoexport);
    723698# else /* HAVE_NAMESPACES */
    724699  yylplex(newlib, libnamebuf, &lib_style);
    … …  
    744719    Warn( "but for functionality you may wish to change to the new");
    745720    Warn( "format. Please refer to the manual for further information.");
    746   } // else {
    747 //     if (BVERBOSE(V_LOAD_LIB)) Print("\n");
    748 //   }
     721  }
    749722  reinit_yylp();
    750723  fclose( yylpin );
    … …  
    758731        //Print("// Processing id %d LIB:%s\n", ls->cnt, ls->get());
    759732        ls->to_be_done=FALSE;
     733#ifdef HAVE_NAMESPACES
     734        iiLibCmd(ls->get(), autoexport);
     735#else /* HAVE_NAMESPACES */
    760736        iiLibCmd(ls->get());
     737#endif /* HAVE_NAMESPACES */
    761738        ls = ls->pop(newlib);
    762739        //Print("Done\n");

  • Singular/ipprint.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipprint.cc,v 1.6 1998-02-27 14:06:19 Singular Exp $ */
     4/* $Id: ipprint.cc,v 1.7 1998-10-21 10:25:35 krueger Exp $ */
    55/*
    66* ABSTRACT: interpreter: printing
    … …  
    198198{
    199199  matrix m=(matrix)u->Data();
    200   jjPRINT_MA0(m,u->Name());
     200  jjPRINT_MA0(m,u->Fullname());
    201201  return FALSE;
    202202}

  • Singular/ipshell.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipshell.cc,v 1.25 1998-10-15 14:08:35 krueger Exp $ */
     4/* $Id: ipshell.cc,v 1.26 1998-10-21 10:25:35 krueger Exp $ */
    55/*
    66* ABSTRACT:
    … …  
    229229void killlocals(int v)
    230230{
     231#ifndef HAVE_NAMESPACES
    231232  killlocals0(v,&IDROOT);
    232233
    … …  
    245246    h = IDNEXT(h);
    246247  }
     248#else
     249  killlocals0(v,&IDROOT);
     250
     251  idhdl h = NSROOT(namespaceroot->root);
     252  idhdl sh=currRingHdl;
     253  BOOLEAN changed=FALSE;
     254
     255  while (h!=NULL)
     256  {
     257    if (((IDTYP(h)==QRING_CMD) || (IDTYP(h) == RING_CMD))
     258    && (IDRING(h)->idroot!=NULL))
     259    {
     260      //Print("=====> Toplevel: ring %s, lev: %d:\n",IDID(h),IDLEV(h));
     261      if (h!=currRingHdl) {changed=TRUE;rSetHdl(h,FALSE);}
     262      killlocals0(v,&(IDRING(h)->idroot));
     263    }
     264    if (IDTYP(h)==PACKAGE_CMD && (IDPACKAGE(h)->idroot!=NULL))
     265    {
     266      idhdl h0 = (IDPACKAGE(h))->idroot;
     267     
     268      //Print("=====> package: %s, lev: %d:\n",IDID(h),IDLEV(h));
     269      while (h0!=NULL)
     270      {
     271        if (((IDTYP(h0)==QRING_CMD) || (IDTYP(h0) == RING_CMD))
     272            && (IDRING(h0)->idroot!=NULL))
     273        {
     274          //Print("=====> '%s': ring %s, lev: %d:\n",IDID(h),IDID(h0),IDLEV(h0));
     275          if (h0!=currRingHdl) {changed=TRUE;rSetHdl(h0,FALSE);}
     276          killlocals0(v,&(IDRING(h0)->idroot));
     277        }
     278        h0 = IDNEXT(h0);
     279      }
     280      killlocals0(v,&((IDPACKAGE(h))->idroot));
     281    }
     282    h = IDNEXT(h);
     283  }
     284#endif /* HAVE_NAMESPACES */
    247285  if (changed)
    248286  {
    … …  
    251289    rSetHdl(sh,TRUE);
    252290  }
     291
    253292  if (myynest<=1) iiNoKeepRing=TRUE;
    254293}
    … …  
    269308    else
    270309    {
     310#ifdef HAVE_NAMESPACES
     311      idhdl pack;
     312      if(index(what, ':')!= NULL)
     313        iiname2hdl(what, &pack, &h);
     314      else h = ggetid(what);
     315#else /* HAVE_NAMESPACES */
    271316      h = ggetid(what);
     317#endif /* HAVE_NAMESPACES */
    272318      if (h!=NULL)
    273319      {
    … …  
    281327        {
    282328          //Print("list_cmd:package or pointer\n");
    283           h=IDPACKAGE(h)->idroot;
     329          if(strcmp(IDID(h), "Top")!=0) h=IDPACKAGE(h)->idroot;
     330          else return;
    284331        }
    285332        else
    … …  
    486533
    487534#ifdef HAVE_NAMESPACES
    488   r=namespaceroot->get(theMap->preimage,myynest);
     535  idhdl pack;
     536  //r=namespaceroot->get(theMap->preimage,myynest);
     537  iiname2hdl(theMap->preimage,&pack,&r);
    489538#else
    490539  r=idroot->get(theMap->preimage,myynest);
    … …  
    709758}
    710759
    711 int iiDeclCommand(leftv sy, leftv name, int lev,int t, idhdl* root,BOOLEAN init_b)
     760int iiDeclCommand(leftv sy, leftv name, int lev,int t, idhdl* root,BOOLEAN isring, BOOLEAN init_b)
    712761{
    713762  BOOLEAN res=FALSE;
     763  char *id = name->name;
     764 
    714765  memset(sy,0,sizeof(sleftv));
    715766  if ((name->name==NULL)||(isdigit(name->name[0])))
    … …  
    724775    //  Warn("`%s` is already in use",name->name);
    725776    //}
    726     sy->data = (char *)enterid(name->name,lev,t,root,init_b);
     777#ifdef HAVE_NAMESPACES
     778    if(name->req_packhdl != NULL && name->packhdl != NULL &&
     779       name->req_packhdl != name->packhdl)
     780      id = mstrdup(name->name);
     781   
     782    //if(name->req_packhdl != NULL /*&& !isring*/) {
     783    if(name->req_packhdl != NULL && !isring &&
     784       IDPACKAGE(name->req_packhdl) != root) {
     785      //Print("iiDeclCommand: PUSH(%s)\n",IDID(name->req_packhdl));
     786      namespaceroot->push( IDPACKAGE(name->req_packhdl) ,
     787                           IDID(name->req_packhdl));
     788      sy->data = (char *)enterid(id,lev,t,
     789                                 &IDPACKAGE(name->req_packhdl)->idroot,init_b);
     790      namespaceroot->pop();
     791    }
     792    else
     793#endif /* HAVE_NAMESPACES */
     794    {
     795      sy->data = (char *)enterid(id,lev,t,root,init_b);
     796    }
    727797    if (sy->data!=NULL)
    728798    {
    … …  
    734804      {
    735805        sy->next=(leftv)Alloc(sizeof(sleftv));
    736         res=iiDeclCommand(sy->next,name->next,lev,t,root);
     806        res=iiDeclCommand(sy->next,name->next,lev,t,root, isring);
    737807      }
    738808    }
    … …  
    767837}
    768838
    769 BOOLEAN iiExport (leftv v, int toLev)
    770 {
    771   BOOLEAN nok=FALSE;
    772   leftv r=v;
    773   while (v!=NULL)
    774   {
    775     if ((v->name==NULL)||(v->rtyp==0)||(v->e!=NULL))
    776     {
    777       WerrorS("cannot export");
    778       nok=TRUE;
    779     }
    780     else
    781     {
    782       idhdl h=(idhdl)v->data;
    783       if (IDLEV(h)==0) Warn("`%s` is already global",IDID(h));
    784       else
    785       {
     839static BOOLEAN iiInternalExport (leftv v, int toLev)
     840{
     841  idhdl h=(idhdl)v->data;
     842  //Print("iiInternalExport('%s',%d)%s\n", v->name, toLev,"");
     843  if (IDLEV(h)==0) Warn("`%s` is already global",IDID(h));
     844  else
     845  {
     846    h=IDROOT->get(v->name,toLev);
     847    idhdl *root=&IDROOT;
     848    if ((h==NULL)&&(currRing!=NULL))
     849    {
     850      h=currRing->idroot->get(v->name,toLev);
     851      root=&currRing->idroot;
     852    }
     853    if ((h!=NULL)&&(IDLEV(h)==toLev))
     854    {
     855      if (IDTYP(h)==v->Typ())
     856      {
     857#ifdef KAI
     858        Warn("!!! redefining %s",IDID(h));
     859#else
     860        Warn(" redefining %s",IDID(h));
     861#endif
    786862#ifdef HAVE_NAMESPACES
    787         h=namespaceroot->get(v->name,toLev);
    788 #else /* HAVE_NAMESPACES */
    789         h=idroot->get(v->name,toLev);
     863        //if (namespaceroot->currRing==IDRING(h)) namespaceroot->currRing=NULL;
    790864#endif /* HAVE_NAMESPACES */
    791         idhdl *root=&IDROOT;
    792         if ((h==NULL)&&(currRing!=NULL))
    793         {
    794           h=currRing->idroot->get(v->name,toLev);
    795           root=&currRing->idroot;
    796         }
    797         if ((h!=NULL)&&(IDLEV(h)==toLev))
    798         {
    799           if (IDTYP(h)==v->Typ())
    800           {
    801             Warn("redefining %s",IDID(h));
    802865#ifdef USE_IILOCALRING
    803866            if (iiLocalRing[0]==IDRING(h)) iiLocalRing[0]=NULL;
    … …  
    806869              namespaceroot->root->currRing=NULL;
    807870#endif
    808             killhdl(h,root);
    809           }
    810           else
    811           {
    812             r->CleanUp();
    813             return TRUE;
    814           }
     871        killhdl(h,root);
     872      }
     873      else
     874      {
     875        return TRUE;
     876      }
     877    }
     878    h=(idhdl)v->data;
     879    IDLEV(h)=toLev;
     880    iiNoKeepRing=FALSE;
     881  }
     882  return FALSE;
     883}
     884
     885#ifdef HAVE_NAMESPACES
     886BOOLEAN iiInternalExport (leftv v, int toLev, idhdl roothdl)
     887{
     888  idhdl h=(idhdl)v->data;
     889  if(h==NULL) {
     890    Warn("'%s': no such identifier\n", v->name);
     891    return FALSE;
     892  }
     893  package rootpack = IDPACKAGE(roothdl);
     894  //Print("iiInternalExport('%s',%d,%s) %s\n", v->name, toLev, IDID(roothdl),"");
     895//  if (IDLEV(h)==0) Warn("`%s` is already global",IDID(h));
     896//  else
     897  {
     898    /* is not ring or ring-element */
     899    if( (IDTYP(h) == RING_CMD) || (IDTYP(h) == QRING_CMD)) {
     900      sleftv tmp_expr;
     901      //Print("// ==> Ring set nesting to 0\n");
     902      //Print("// ++> make a copy of ring\n");
     903      if(iiInternalExport(v, toLev)) return TRUE;
     904      if(IDPACKAGE(roothdl) != NSPACK(namespaceroot)) {
     905        namespaceroot->push(rootpack, IDID(roothdl));
     906        //namespaceroot->push(NSPACK(namespaceroot->root), "Top");
     907        idhdl rl=enterid(mstrdup(v->name), toLev, IDTYP(h),
     908                         &(rootpack->idroot), FALSE);
     909        namespaceroot->pop();
     910       
     911        if( rl == NULL) return TRUE;
     912        ring r=(ring)v->Data();
     913        if(r != NULL) {
     914          if (&IDRING(rl)!=NULL) rKill(rl);
     915          r->ref++;
     916          IDRING(rl)=r;
    815917        }
    816         h=(idhdl)v->data;
    817         IDLEV(h)=toLev;
    818         iiNoKeepRing=FALSE;
     918        else Print("! ! ! ! ! r is empty!!!!!!!!!!!!\n");
     919      }
     920    }
     921    else if ((BEGIN_RING<IDTYP(h)) && (IDTYP(h)<END_RING)
     922             || ((IDTYP(h)==LIST_CMD) && (lRingDependend(IDLIST(h))))) {
     923      //Print("// ==> Ringdependent set nesting to 0\n");
     924      if(iiInternalExport(v, toLev)) return TRUE;
     925    } else {
     926      if (h==IDROOT)
     927      {
     928        IDROOT=h->next;
     929      }
     930      else
     931      {
     932        idhdl hh=IDROOT;
     933        while ((hh->next!=h)&&(hh->next!=NULL))
     934          hh=hh->next;
     935        if (hh->next==h)
     936          hh->next=h->next;
     937        else
     938          return TRUE;
     939      }
     940      h->next=rootpack->idroot;
     941      rootpack->idroot=h;
     942    }
     943    IDLEV(h)=toLev;
     944  }
     945  return FALSE;
     946}
     947#endif /* HAVE_NAMESAPCES */
     948
     949BOOLEAN iiExport (leftv v, int toLev)
     950{
     951  BOOLEAN nok=FALSE;
     952  leftv r=v;
     953  while (v!=NULL)
     954  {
     955    if ((v->name==NULL)||(v->rtyp==0)||(v->e!=NULL))
     956    {
     957      WerrorS("cannot export");
     958      nok=TRUE;
     959    }
     960    else
     961    {
     962      if(iiInternalExport(v, toLev)) {
     963        r->CleanUp();
     964        return TRUE;
    819965      }
    820966    }
    … …  
    826972
    827973/*assume root!=idroot*/
    828 BOOLEAN iiExport (leftv v, int toLev, idhdl &root)
     974#ifdef HAVE_NAMESPACES
     975BOOLEAN iiExport (leftv v, int toLev, idhdl root)
    829976{
    830977  BOOLEAN nok=FALSE;
    … …  
    8541001        }
    8551002      }
    856       idhdl h=(idhdl)v->data;
    857       if (h==IDROOT)
    858       {
    859         IDROOT=h->next;
    860       }
    861       else
    862       {
    863         idhdl hh=IDROOT;
    864         while ((hh->next!=h)&&(hh->next!=NULL))
    865           hh=hh->next;
    866         if (hh->next==h)
    867           hh->next=h->next;
    868         else
    869           break;
    870       }
    871       h->next=root;
    872       root=h;
    873       IDLEV(h)=toLev;
     1003      if(iiInternalExport(v, toLev, root)) {
     1004        rv->CleanUp();
     1005        return TRUE;
     1006      }
    8741007    }
    8751008    v=v->next;
    … …  
    8781011  return nok;
    8791012}
     1013#endif /* HAVE_NAMESPACES */
    8801014
    8811015BOOLEAN iiCheckRing(int i)

  • Singular/ipshell.h

    r474fb0f r0a3ddd  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: ipshell.h,v 1.13 1998-10-15 14:08:37 krueger Exp $ */
     6/* $Id: ipshell.h,v 1.14 1998-10-21 10:25:36 krueger Exp $ */
    77/*
    88* ABSTRACT
    … …  
    2525extern int     iiRETURNEXPR_len;
    2626extern sleftv *iiRETURNEXPR;
    27 #ifdef IILOCALRING
     27#ifdef USE_IILOCALRING
    2828extern ring   *iiLocalRing;
    2929#endif
    … …  
    4747BOOLEAN iiWRITE(leftv res,leftv exprlist);
    4848BOOLEAN iiExport(leftv v, int toLev);
    49 BOOLEAN iiExport(leftv v, int toLev, idhdl &root);
     49#ifdef HAVE_NAMESPACES
     50BOOLEAN iiExport(leftv v, int toLev, idhdl roothdl);
     51BOOLEAN iiInternalExport (leftv v, int toLev, idhdl roothdl);
     52#endif /* HAVE_NAMESPACES */
    5053char *  iiGetLibName(procinfov v);
    5154char *  iiGetLibProcBuffer( procinfov pi, int part=1 );
    5255char *  iiProcName(char *buf, char & ct, char* &e);
    5356char *  iiProcArgs(char *e,BOOLEAN withParenth);
     57#ifdef HAVE_NAMESPACES
     58BOOLEAN iiLibCmd( char *newlib, BOOLEAN autoexport=TRUE, BOOLEAN tellerror=TRUE );
     59#else /* HAVE_NAMESPACES */
    5460BOOLEAN iiLibCmd( char *newlib, BOOLEAN tellerror=TRUE );
     61#endif /* HAVE_NAMESPACES */
    5562leftv   iiMap(map theMap, char * what);
    5663void    iiMakeResolv(resolvente r, int length, int rlen, char * name, int typ0,
    … …  
    145152/* ================================================================== */
    146153int     iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl* root,
    147   BOOLEAN init_b=TRUE);
     154  BOOLEAN isring = FALSE, BOOLEAN init_b=TRUE);
     155#ifdef HAVE_NAMESPACES
     156sleftv * iiMake_proc(idhdl pn, sleftv* slpn, sleftv* sl);
     157#else /* HAVE_NAMESPACES */
    148158sleftv * iiMake_proc(idhdl pn, sleftv* sl);
     159#endif /* HAVE_NAMESPACES */
    149160// from misc.cc:
    150161char *  showOption();

  • Singular/libparse.h

    r474fb0f r0a3ddd  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: libparse.h,v 1.8 1998-06-13 12:44:43 krueger Exp $ */
     6/* $Id: libparse.h,v 1.9 1998-10-21 10:25:37 krueger Exp $ */
    77/*
    88* ABSTRACT: lib parsing
    … …  
    1919#ifdef HAVE_NAMESPACES
    2020int yylplex(char *libname, char *libfile, lib_style_types *lib_style,
    21            idhdl pl, lp_modes=LOAD_LIB);
     21           idhdl pl, BOOLEAN autoexport=FALSE, lp_modes=LOAD_LIB);
    2222#else /* HAVE_NAMESPACES */
    2323int yylplex(char *libname, char *libfile, lib_style_types *lib_style,

  • Singular/libparse.l

    r474fb0f r0a3ddd  
    33*  Computer Algebra System SINGULAR     *
    44****************************************/
    5 /* $Id: libparse.l,v 1.27 1998-07-21 17:28:31 Singular Exp $ */
     5/* $Id: libparse.l,v 1.28 1998-10-21 10:25:37 krueger Exp $ */
    66#include <stdio.h>
    77#include <string.h>
    … …  
    3535#ifdef HAVE_NAMESPACES
    3636void copy_string(lp_modes mode, idhdl pl);
     37extern void piCleanUp(procinfov pi);
    3738#else /* HAVE_NAMESPACES */
    3839void copy_string(lp_modes mode);
    … …  
    112113#  else /* STANDALONE_PARSER */
    113114idhdl h0;
     115#    ifdef HAVE_NAMESPACES
     116idhdl h_top;
     117extern namehdl namespaceroot;
     118#    endif /* HAVE_NAMESPACES */
    114119#    define pi IDPROC(h0)
    115120extern "C"
    … …  
    154159#    define YY_DECL int yylex(char *newlib, char *libfile, \
    155160                               lib_style_types *lib_style, \
    156                                idhdl pl, lp_modes mode)
     161                               idhdl pl, BOOLEAN autoexport, lp_modes mode)
    157162#  else /* HAVE_NAMESPACES */
    158163#    define YY_DECL int yylex(char *newlib, char *libfile, \
    … …  
    285290#  ifdef HAVE_NAMESPACES
    286291                h0 = enterid( mstrdup(proc), myynest, PROC_CMD,
    287                                   &IDPACKAGE(pl)->idroot, TRUE );
     292                                  &IDPACKAGE(pl)->idroot, TRUE);
     293                if(!p_static && autoexport) {
     294                   namespaceroot->push( NSPACK(namespaceroot->root) ,"");
     295                   h_top = enterid( mstrdup(proc), myynest, PROC_CMD,
     296                                  &NSROOT(namespaceroot->root), FALSE );
     297                   namespaceroot->pop();
     298                }
    288299#  else /* HAVE_NAMESPACES */
    289300               h0 = enterid( mstrdup(proc), myynest, PROC_CMD,
    … …  
    293304                 iiInitSingularProcinfo(IDPROC(h0), newlib, proc,
    294305                                yylplineno, current_pos(0),p_static);
     306#  ifdef HAVE_NAMESPACES
     307                 if (!p_static && h_top != NULL && autoexport) {
     308                   if(IDPROC(h_top)!=NULL) piCleanUp((procinfo *)IDPROC(h_top));
     309                   IDPROC(h_top)=IDPROC(h0);
     310                   IDPROC(h_top)->ref++;
     311                 }
     312#  endif /* HAVE_NAMESPACES */
    295313                 if (BVERBOSE(V_LOAD_PROC))
    296314                   Warn( "     proc '%s' registered", proc );

  • Singular/lists.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: lists.cc,v 1.11 1998-09-24 09:59:46 Singular Exp $ */
     4/* $Id: lists.cc,v 1.12 1998-10-21 10:25:39 krueger Exp $ */
    55/*
    66* ABSTRACT: handling of the list type
    … …  
    2929    N->m[n].Copy(&L->m[n]);
    3030  }
     31#ifdef HAVE_NAMESPACES_N
     32  N->src_packhdl = L->src_packhdl;
     33#endif
    3134  //Print("copy list with %d -> %d elems\n",L->nr,N->nr);
    3235  return N;

  • Singular/lists.h

    r474fb0f r0a3ddd  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: lists.h,v 1.5 1998-08-25 13:33:20 krueger Exp $ */
     6/* $Id: lists.h,v 1.6 1998-10-21 10:25:38 krueger Exp $ */
    77/*
    88* ABSTRACT: handling of the list type
    … …  
    3636    inline void Init(int l=0)
    3737      { nr=l-1; m=(sleftv *)((l>0) ? Alloc0(l*sizeof(sleftv)): NULL);
    38 #ifdef HAVE_NAMESPACES
    39         packhdl = namespaceroot->get(namespaceroot->name, 0, TRUE);
     38#ifdef HAVE_NAMESPACES_N
     39        src_packhdl = namespaceroot->get(namespaceroot->name, 0, TRUE);
    4040#endif /* HAVE_NAMESPACES */
    4141      }
    4242    int    nr; /* the number of elements in the list -1 */
    4343               /* -1: empty list */
    44 #ifdef HAVE_NAMESPACES
    45     idhdl packhdl;
     44#ifdef HAVE_NAMESPACES_N
     45    idhdl src_packhdl;
    4646#endif /* HAVE_NAMESPACES */
    4747    sleftv  *m;  /* field of sleftv */

  • Singular/misc.cc

    r474fb0f r0a3ddd  
    355355  }
    356356#ifdef HAVE_NAMESPACES
    357   char *p1 = AllocL(strlen(s)), *p2 = AllocL(strlen(s));
    358   *p1='\0';
    359   *p2='\0';
    360   sscanf(s, "%[^:]::%s", p1, p2);
    361357  idhdl h, ns;
    362   if(*p2) {
    363     printf("singular_help:(%s, %s)\n", p1, p2);
    364     ns = namespaceroot->get(p1,0);
    365     namespaceroot->push(IDPACKAGE(ns), IDID(ns));
    366     h=namespaceroot->get(p2,myynest);
    367     namespaceroot->pop();
    368   } else {
    369     h=namespaceroot->get(p1,myynest);
    370   }
    371   FreeL(p1);
    372   FreeL(p2);
     358  iiname2hdl(s, &ns, &h);
    373359#else /* HAVE_NAMESPACES */
    374360  /* --------- is it a proc ? --------------------------------*/
    … …  
    421407      yylpin = fp;
    422408#  ifdef HAVE_NAMESPACES
    423       yylplex(str, libnamebuf, &lib_style, IDROOT, GET_INFO);
     409      yylplex(str, libnamebuf, &lib_style, IDROOT, FALSE, GET_INFO);
    424410#  else /* HAVE_NAMESPACES */
    425411      yylplex(str, libnamebuf, &lib_style, GET_INFO);
    … …  
    773759              StringAppendS("info,");
    774760#endif
     761#ifdef HAVE_NAMESPACES
     762              StringAppendS("Namespaces,");
     763#endif
    775764#ifdef TEST
    776765              StringAppendS("TESTs,");

  • Singular/mpsr_Put.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr_Put.cc,v 1.12 1998-09-22 10:29:45 Singular Exp $ */
    5 
     4/* $Id: mpsr_Put.cc,v 1.13 1998-10-21 10:25:54 krueger Exp $ */
     5
     6#define KAI
    67
    78/***************************************************************
    … …  
    128129      case MAP_CMD:
    129130        return mpsr_PutMapLeftv(link, v, cring);
     131
     132      case PACKAGE_CMD:
     133        return mpsr_PutPackageLeftv(link, v);
    130134
    131135      case NONE:
    … …  
    514518
    515519
     520mpsr_Status_t mpsr_PutPackage(MP_Link_pt link, char* pname, idhdl pack)
     521{
     522  MP_DictTag_t dict;
     523  MP_Common_t  cop;
     524
     525  printf("Huhu\n");
     526  failr(mpsr_tok2mp('=', &dict, &cop));
     527  printf("Huhu 1\n");
     528
     529  // A Singular- procedure is sent as a cop with the string as arg
     530  mp_failr(MP_PutCommonOperatorPacket(link,
     531                                        dict,
     532                                        cop,
     533                                        0,
     534                                        2));
     535  printf("Huhu 2\n");
     536  mp_failr(MP_PutIdentifierPacket(link, MP_SingularDict, pname,1));
     537  printf("Huhu 3\n");
     538  mp_failr(MP_PutAnnotationPacket(link,
     539                                  MP_SingularDict,
     540                                  0,
     541                                  0));
     542  printf("Huhu 4\n");
     543  mp_return(MP_Success);
     544}
     545
    516546/***************************************************************
    517547 *
    … …  
    549579    {
    550580      cmd.arg1.name = IDID(h);
    551       //memcpy(&(cmd.arg2), h, sizeof(sleftv));
     581      //cmd.arg2.next = h->next;
     582      cmd.arg1.name = IDID(h);
    552583      cmd.arg2.data=IDDATA(h);
    553584      cmd.arg2.flag=h->flag;
    554585      cmd.arg2.attribute=h->attribute;
    555586      cmd.arg2.rtyp=h->typ;
     587      //cmd.arg2.e = NULL;
     588      //cmd.arg2.muell = 0;
     589      //memcpy(&(cmd.arg2), h, sizeof(sleftv));
    556590      if (mpsr_PutLeftv(link, lv , currRing) != mpsr_Success) break;
    557591#ifdef MPSR_DEBUG
    … …  
    567601        while (h2 != NULL)
    568602        {
     603          //cmd.arg2.next = h->next;
    569604          cmd.arg1.name = IDID(h2);
     605          cmd.arg2.data=IDDATA(h2);
     606          cmd.arg2.flag = h2->flag;
     607          cmd.arg2.attribute = h2->attribute;
     608          cmd.arg2.rtyp = h2->typ;
     609          //cmd.arg2.e = NULL;
     610          //cmd.arg2.muell = 0;
    570611          //memcpy(&(cmd.arg2), h2, sizeof(sleftv));
    571           cmd.arg2.data=IDDATA(h2);
    572           cmd.arg2.flag=h2->flag;
    573           cmd.arg2.attribute=h2->attribute;
    574           cmd.arg2.rtyp=h2->typ;
    575612          if (mpsr_PutLeftv(link, lv, r) != mpsr_Success) break;
    576613#ifdef MPSR_DEBUG

  • Singular/mpsr_Put.h

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr_Put.h,v 1.7 1998-06-02 15:29:59 Singular Exp $ */
     4/* $Id: mpsr_Put.h,v 1.8 1998-10-21 10:25:52 krueger Exp $ */
    55/***************************************************************
    66 *
    … …  
    8181extern mpsr_Status_t mpsr_PutRing(MP_Link_pt link, ring r);
    8282extern mpsr_Status_t mpsr_PutProc(MP_Link_pt link, char *pname,procinfov proc);
     83extern mpsr_Status_t mpsr_PutPackage(MP_Link_pt link, char *pname,idhdl proc);
    8384inline mpsr_Status_t mpsr_PutDef(MP_Link_pt link, char *name)
    8485{
    … …  
    212213  return mpsr_PutMap(link, (map) v->Data(), cring);
    213214}
     215/* inline mpsr_Status_t mpsr_PutAliasLeftv(MP_Link_pt link, leftv v) */
     216/* { */
     217/*   typecheck(v, ALIAS_CMD); */
     218/*   return mpsr_PutAlias(link, v->name, (idhdl) v->Data()); */
     219/* } */
     220inline mpsr_Status_t mpsr_PutPackageLeftv(MP_Link_pt link, leftv v)
     221{
     222  typecheck(v, PACKAGE_CMD);
     223  return mpsr_PutPackage(link, v->name, (idhdl) v->Data());
     224}
    214225
    215226/***************************************************************

  • Singular/mpsr_Tok.cc

    r474fb0f r0a3ddd  
    33****************************************/
    44
    5 /* $Id: mpsr_Tok.cc,v 1.18 1998-10-15 11:46:05 obachman Exp $ */
     5/* $Id: mpsr_Tok.cc,v 1.19 1998-10-21 10:25:50 krueger Exp $ */
    66
    77/***************************************************************
    … …  
    185185  PROC_CMD,
    186186  MAP_CMD,
     187  PACKAGE_CMD,
    187188  '=',
    188189  0

  • Singular/ring.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ring.cc,v 1.32 1998-10-15 14:08:39 krueger Exp $ */
     4/* $Id: ring.cc,v 1.33 1998-10-21 10:25:48 krueger Exp $ */
    55
    66/*
    … …  
    942942void rKill(idhdl h)
    943943{
     944#ifndef HAVE_NAMESPACES1
    944945  ring r = IDRING(h);
    945946  if (r!=NULL) rKill(r);
    946947  if (h==currRingHdl)
    947948  {
    948     currRingHdl=IDROOT;
    949     while (currRingHdl!=NULL)
    950     {
    951       if ((currRingHdl!=h)
     949#ifdef HAVE_NAMESPACES
     950    namehdl nsHdl = namespaceroot;
     951    while(nsHdl!=NULL) {
     952      currRingHdl=NSROOT(nsHdl);
     953#else /* HAVE_NAMESPACES */
     954      currRingHdl=IDROOT;
     955#endif /* HAVE_NAMESPACES */
     956      while (currRingHdl!=NULL)
     957      {
     958        if ((currRingHdl!=h)
     959            && (IDTYP(currRingHdl)==IDTYP(h))
     960            && (h->data.uring==currRingHdl->data.uring))
     961          break;
     962        currRingHdl=IDNEXT(currRingHdl);
     963      }
     964#ifdef HAVE_NAMESPACES
     965      if ((currRingHdl != NULL) && (currRingHdl!=h)
    952966          && (IDTYP(currRingHdl)==IDTYP(h))
    953967          && (h->data.uring==currRingHdl->data.uring))
    954968        break;
    955       currRingHdl=IDNEXT(currRingHdl);
    956     }
    957 #ifdef HAVE_NAMESPACES
     969      nsHdl = nsHdl->next;
     970    }
     971#endif /* HAVE_NAMESPACES */
     972  }
     973#else
    958974    if(currRingHdl==NULL) {
    959975      namehdl ns = namespaceroot;
    960976      BOOLEAN found=FALSE;
    961977     
    962       while(ns->next!=NULL) {
     978      while(!ns->isroot) {
    963979        currRingHdl=NSROOT(namespaceroot->next);
    964980        while (currRingHdl!=NULL)
    … …  
    975991      }
    976992    }
     993    if(currRingHdl == NULL || IDRING(h) != IDRING(currRingHdl)) {
     994      currRingHdl = namespaceroot->currRingHdl;
     995     
     996/*      Print("Running rFind()\n");
     997      currRingHdl = rFindHdl(IDRING(h), NULL, NULL);
     998      if(currRingHdl == NULL) {
     999        Print("rFind()return 0\n");
     1000      } else {
     1001        Print("Huppi rfind return an currRingHDL\n");
     1002        Print("%x, %x\n", IDRING(h),IDRING(currRingHdl) );
     1003      }
     1004*/
     1005    } else {
     1006      //Print("Huppi found an currRingHDL\n");
     1007      //Print("%x, %x\n", IDRING(h),IDRING(currRingHdl) );
     1008     
     1009    }
    9771010#endif /* HAVE_NAMESPACES */
    978   }
    9791011}
    9801012
    … …  
    9831015#ifdef HAVE_NAMESPACES
    9841016  idhdl h;
    985   if(namespaceroot->isroot) h = IDROOT;
    986   else h = NSROOT(namespaceroot->next);
    987 #else
    988   idhdl h=IDROOT;
    989 #endif
     1017  namehdl ns = namespaceroot;
     1018
     1019  while(!ns->isroot) {
     1020    h = NSROOT(ns);
     1021    if(w != NULL) h = w;
     1022    while (h!=NULL)
     1023    {
     1024      if (((IDTYP(h)==RING_CMD)||(IDTYP(h)==QRING_CMD))
     1025          && (h->data.uring==r)
     1026          && (h!=n))
     1027        return h;
     1028      h=IDNEXT(h);
     1029    }
     1030    ns = ns->next;
     1031  }
     1032  h = NSROOT(ns);
    9901033  if(w != NULL) h = w;
    9911034  while (h!=NULL)
    … …  
    9971040    h=IDNEXT(h);
    9981041  }
     1042#if 0
     1043  if(namespaceroot->isroot) h = IDROOT;
     1044  else h = NSROOT(namespaceroot->next);
     1045  if(w != NULL) h = w;
     1046  while (h!=NULL)
     1047  {
     1048    if (((IDTYP(h)==RING_CMD)||(IDTYP(h)==QRING_CMD))
     1049        && (h->data.uring==r)
     1050        && (h!=n))
     1051      return h;
     1052    h=IDNEXT(h);
     1053  }
     1054#endif
     1055#else
     1056  idhdl h=IDROOT;
     1057  if(w != NULL) h = w;
     1058  while (h!=NULL)
     1059  {
     1060    if (((IDTYP(h)==RING_CMD)||(IDTYP(h)==QRING_CMD))
     1061        && (h->data.uring==r)
     1062        && (h!=n))
     1063      return h;
     1064    h=IDNEXT(h);
     1065  }
     1066#endif
    9991067  return NULL;
    10001068}

  • Singular/silink.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: silink.cc,v 1.23 1998-10-14 10:18:54 obachman Exp $ */
     4/* $Id: silink.cc,v 1.24 1998-10-21 10:25:46 krueger Exp $ */
    55
    66/*
    … …  
    563563        == EOF) return TRUE;
    564564  }
     565
     566  if (type_id == PACKAGE_CMD) {
     567    if (fprintf(fd, ";\n") == EOF) return TRUE;
     568    else return FALSE;
     569  }
     570 
    565571  // write the equal sign
    566572  if (fprintf(fd, " = ") == EOF) return TRUE;
    … …  
    590596          if (GetIdString((idhdl) &(l->m[i])) == NULL) return NULL;
    591597      }
     598      case PACKAGE_CMD:
    592599      case INT_CMD:
    593600      case INTVEC_CMD:

  • Singular/subexpr.cc

    r474fb0f r0a3ddd  
    100100        case DEF_CMD:
    101101        case PACKAGE_CMD:
     102#ifdef HAVE_NAMESPACES
     103          {
     104            char *typ;
     105            language_defs lang = ((package)d)->language;
     106            ::Print("// Package : %-*.*s`%s`\n",spaces,spaces," ",n);
     107            switch (lang) {
     108                case LANG_SINGULAR: typ="singular"; break;
     109                case LANG_C:        typ="object";   break;
     110                case LANG_NONE:     typ="none";     break;
     111                default:            typ="unknow language";
     112            }
     113            ::Print("// language: %-*.*s%s",spaces,spaces," ",typ);
     114          }
     115#else /* HAVE_NAMESPACES */
    102116          ::Print("%-*.*s`%s`",spaces,spaces," ",n);
     117#endif /* HAVE_NAMESPACES */
    103118          break;
    104119        case NONE:
    … …  
    539554  }
    540555  flag=source->flag;
     556#ifdef HAVE_NAMESPACES
     557  packhdl = source->packhdl;
     558  req_packhdl = source->req_packhdl;
     559#endif /* HAVE_NAMESPACES */
    541560  if ((source->attribute!=NULL)||(source->e!=NULL))
    542561    attribute=source->CopyA();
    … …  
    10301049*/
    10311050extern BOOLEAN noringvars;
    1032 void syMake(leftv v,char * id)
     1051void syMake(leftv v,char * id, idhdl packhdl)
    10331052{
    10341053  /* resolv an identifier: (to DEF_CMD, if siq>0)
    … …  
    12621281        if(!nok)
    12631282        {
     1283#ifdef HAVE_NAMESPACES
     1284          leftv r=iiMake_proc(h,(sleftv*)NULL,&d->arg2);
     1285#else /* HAVE_NAMESPACES */
    12641286          leftv r=iiMake_proc(h,&d->arg2);
     1287#endif /* HAVE_NAMESPACES */
    12651288          if (r!=NULL)
    12661289            memcpy(this,r,sizeof(sleftv));
    … …  
    13741397}
    13751398
    1376 
    13771399char *iiSleftv2name(leftv v)
    13781400{

  • Singular/subexpr.h

    r474fb0f r0a3ddd  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: subexpr.h,v 1.9 1998-09-29 10:39:11 krueger Exp $ */
     6/* $Id: subexpr.h,v 1.10 1998-10-21 10:25:43 krueger Exp $ */
    77/*
    88* ABSTRACT: handling of leftv
    … …  
    9696typedef ssym * sym;
    9797
    98 void syMake(leftv v,char * name);
     98void syMake(leftv v,char * name, idhdl packhdl = NULL);
    9999BOOLEAN assumeStdFlag(leftv h);
    100100

  • Singular/tesths.cc

    r474fb0f r0a3ddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: tesths.cc,v 1.54 1998-10-15 14:08:43 krueger Exp $ */
     4/* $Id: tesths.cc,v 1.55 1998-10-21 10:25:41 krueger Exp $ */
    55
    66/*
    … …  
    487487  {
    488488    idhdl h;
    489     namespaceroot->push(NULL, "Top", TRUE);
     489    namespaceroot->push(NULL, "Top", 0, TRUE);
    490490#ifdef HAVE_NAMESPACES
    491491    h=enterid(mstrdup("Top"), 0, PACKAGE_CMD, &IDROOT, TRUE);
    … …  
    522522    int vv=verbose;
    523523    verbose &= ~Sy_bit(V_LOAD_LIB);
    524     iiLibCmd(mstrdup("standard.lib"),TRUE);
     524#ifdef HAVE_NAMESPACES
     525    iiLibCmd(mstrdup("standard.lib"),TRUE, TRUE);
     526#else /* HAVE_NAMESPACES */
     527    iiLibCmd(mstrdup("standard.lib"), TRUE);
     528#endif /* HAVE_NAMESPACES */
    525529    verbose=vv;
    526530  }

  • Singular/tok.h

    r474fb0f r0a3ddd  
    77* ABSTRACT: token for interpreter, as types; general macros
    88*/
    9 /* $Id: tok.h,v 1.20 1998-08-25 13:33:24 krueger Exp $ */
     9/* $Id: tok.h,v 1.21 1998-10-21 10:25:40 krueger Exp $ */
    1010
    1111#ifndef MYYSTYPE
    … …  
    7575  LINK_CMD,
    7676  LIST_CMD,
     77  LOAD_CMD,
    7778  LRES_CMD,
    7879  MEMORY_CMD,
    … …  
    106107  TRACE_CMD,
    107108  TYPEOF_CMD,
     109  UNLOAD_CMD,
    108110  VARSTR_CMD,
    109111  WRITE_CMD,
Note: See TracChangeset for help on using the changeset viewer.