#include <kernel/mod2.h>
#include <omalloc/omalloc.h>
#include <misc/intvec.h>
#include <misc/options.h>
#include <coeffs/numbers.h>
#include <coeffs/bigintmat.h>
#include <coeffs/ffields.h>
#include <polys/monomials/maps.h>
#include <polys/matpol.h>
#include <polys/monomials/ring.h>
#include <kernel/polys.h>
#include <kernel/ideals.h>
#include <kernel/GBEngine/kstd1.h>
#include <kernel/GBEngine/syz.h>
#include <kernel/oswrapper/timer.h>
#include <Singular/tok.h>
#include <Singular/ipid.h>
#include <Singular/ipshell.h>
#include <Singular/lists.h>
#include <Singular/attrib.h>
#include <Singular/links/silink.h>
#include <Singular/subexpr.h>
#include <Singular/blackbox.h>
#include <Singular/number2.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>

Functions
static void *	s_internalCopy (const int t, void *d)

void	s_internalDelete (const int t, void *d, const ring r)

void *	slInternalCopy (leftv source, const int t, void *d, Subexpr e)

BOOLEAN	assumeStdFlag (leftv h)

void	syMake (leftv v, const char *id, idhdl packhdl)

const char *	iiSleftv2name (leftv v)

Variables
omBin	sSubexpr_bin = omGetSpecBin(sizeof(_ssubexpr))

omBin	sleftv_bin = omGetSpecBin(sizeof(sleftv))

omBin	procinfo_bin = omGetSpecBin(sizeof(procinfo))

omBin	libstack_bin = omGetSpecBin(sizeof(libstack))

static omBin	size_two_bin = omGetSpecBin(2)

sleftv	sLastPrinted

const char	sNoName [] ="_"

BOOLEAN	siq =FALSE

static snumber2	iiNumber2Data [4]

static int	iiCmatrix_index =0

Function Documentation

BOOLEAN assumeStdFlag ( leftv h )

Definition at line 1428 of file subexpr.cc.

 {
   if (h->e!=NULL)
   {
     leftv hh=h->LData();
     if (h!=hh) return assumeStdFlag(h->LData());
   }
   if (!hasFlag(h,FLAG_STD))
   {
     if (!TEST_VERB_NSB)
     {
       if (TEST_V_ALLWARN)
         Warn("%s is no standard basis in >>%s<<",h->Name(),my_yylinebuf);
       else
         Warn("%s is no standard basis",h->Name());
     }
     return FALSE;
   }
   return TRUE;
 }

const char* iiSleftv2name ( leftv v )

Definition at line 1907 of file subexpr.cc.

 {
   return(v->name);
 }

static void* s_internalCopy	(	const int	t,
		void *	d
	)

inlinestatic

Definition at line 381 of file subexpr.cc.

 {
   switch (t)
   {
 #ifdef SINGULAR_4_1
     case CRING_CMD:
       {
         coeffs cf=(coeffs)d;
         cf->ref++;
         return (void*)d;
       }
     case CNUMBER_CMD:
       return (void*)n2Copy((number2)d);
     case CMATRIX_CMD: // like BIGINTMAT
 #endif
     case BIGINTMAT_CMD:
       return (void*)bimCopy((bigintmat *)d);
     case INTVEC_CMD:
     case INTMAT_CMD:
       return (void *)ivCopy((intvec *)d);
     case MATRIX_CMD:
       return (void *)mp_Copy((matrix)d, currRing);
     case IDEAL_CMD:
     case MODUL_CMD:
       return  (void *)idCopy((ideal)d);
     case STRING_CMD:
         return (void *)omStrDup((char *)d);
     case PACKAGE_CMD:
       return  (void *)paCopy((package) d);
     case PROC_CMD:
       return  (void *)piCopy((procinfov) d);
     case POLY_CMD:
     case VECTOR_CMD:
       return  (void *)pCopy((poly)d);
     case INT_CMD:
       return  d;
     case NUMBER_CMD:
       return  (void *)nCopy((number)d);
     case BIGINT_CMD:
       return  (void *)n_Copy((number)d, coeffs_BIGINT);
     case MAP_CMD:
       return  (void *)maCopy((map)d, currRing);
     case LIST_CMD:
       return  (void *)lCopy((lists)d);
     case LINK_CMD:
       return (void *)slCopy((si_link) d);
     case RING_CMD:
     case QRING_CMD:
       {
         ring r=(ring)d;
         if (r!=NULL) r->ref++;
         //Print("+  ring %d, ref %d\n",r,r->ref);
         return d;
       }
     case RESOLUTION_CMD:
       return (void*)syCopy((syStrategy)d);
     case DEF_CMD:
     case NONE:
     case 0: /* type in error case */
       break; /* error recovery: do nothing */
     //case COMMAND:
     default:
     {
       if (t>MAX_TOK)
       {
         blackbox *b=getBlackboxStuff(t);
         if (b!=NULL) return b->blackbox_Copy(b,d);
         return NULL;
       }
       else
       Warn("s_internalCopy: cannot copy type %s(%d)",
             Tok2Cmdname(t),t);
     }
   }
   return NULL;
 }

void s_internalDelete	(	const int	t,
		void *	d,
		const ring	r
	)

Definition at line 458 of file subexpr.cc.

 {
   assume(d!=NULL);
   switch (t)
   {
 #ifdef SINGULAR_4_1
     case CRING_CMD:
       nKillChar((coeffs)d);
       break;
     case CNUMBER_CMD:
       {
         number2 n=(number2)d;
         n2Delete(n);
         break;
       }
     case CMATRIX_CMD: //like BIGINTMAT
 #endif
     case BIGINTMAT_CMD:
     {
       bigintmat *v=(bigintmat*)d;
       delete v;
       break;
     }
     case INTVEC_CMD:
     case INTMAT_CMD:
     {
       intvec *v=(intvec*)d;
       delete v;
       break;
     }
     case MAP_CMD:
     {
       map m=(map)d;
       omFreeBinAddr((ADDRESS)m->preimage);
       m->preimage=NULL;
       /* no break: continue as IDEAL*/
     }
     case MATRIX_CMD:
     case IDEAL_CMD:
     case MODUL_CMD:
     {
       ideal i=(ideal)d;
       id_Delete(&i,r);
       break;
     }
     case STRING_CMD:
       omFree(d);
       break;
     //case PACKAGE_CMD:
     //  return  (void *)paCopy((package) d);
     case PROC_CMD:
       piKill((procinfo*)d);
       break;
     case POLY_CMD:
     case VECTOR_CMD:
     {
       poly p=(poly)d;
       p_Delete(&p,r);
       break;
     }
     case NUMBER_CMD:
     {
       number n=(number)d;
       n_Delete(&n,r);
       break;
     }
     case BIGINT_CMD:
     {
       number n=(number)d;
       n_Delete(&n,coeffs_BIGINT);
       break;
     }
     case LIST_CMD:
     {
       lists l=(lists)d;
       l->Clean(r);
       break;
     }
     case LINK_CMD:
     {
       si_link l=(si_link)d;
       slKill(l);
       break;
     }
     case RING_CMD:
     case QRING_CMD:
     {
       ring R=(ring)d;
       if ((R!=currRing)||(R->ref>=0))
         rKill(R);
       #ifdef TEST
       else
         Print("currRing? ref=%d\n",R->ref);
       #endif
       break;
     }
     case RESOLUTION_CMD:
     {
       syStrategy s=(syStrategy)d;
       if (s!=NULL) syKillComputation(s,r);
       break;
     }
     case COMMAND:
     {
      command cmd=(command)d;
      if (cmd->arg1.rtyp!=0) cmd->arg1.CleanUp(r);
      if (cmd->arg2.rtyp!=0) cmd->arg2.CleanUp(r);
      if (cmd->arg3.rtyp!=0) cmd->arg3.CleanUp(r);
      omFreeBin((ADDRESS)d, sip_command_bin);
      break;
     }
     case INT_CMD:
     case DEF_CMD:
     case ALIAS_CMD:
     case PACKAGE_CMD:
     case IDHDL:
     case NONE:
     case ANY_TYPE:
     case VECHO:
     case VPRINTLEVEL:
     case VCOLMAX:
     case VTIMER:
     case VRTIMER:
     case VOICE:
     case VMAXDEG:
     case VMAXMULT:
     case TRACE:
     case VSHORTOUT:
     case VNOETHER:
     case VMINPOLY:
     case LIB_CMD:
     case 0: /* type in error case */
       break; /* error recovery: do nothing */
     //case COMMAND:
     //case COMMAND:
     default:
     {
       if (t>MAX_TOK)
       {
         blackbox *b=getBlackboxStuff(t);
         if (b!=NULL) b->blackbox_destroy(b,d);
         break;
       }
       else
       Warn("s_internalDelete: cannot delete type %s(%d)",
             Tok2Cmdname(t),t);
     }
   }
 }

void* slInternalCopy	(	leftv	source,
		const int	t,
		void *	d,
		Subexpr	e
	)

Definition at line 608 of file subexpr.cc.

 {
   if (t==STRING_CMD)
   {
       if ((e==NULL)
       || (source->rtyp==LIST_CMD)
       || ((source->rtyp==IDHDL)
           &&((IDTYP((idhdl)source->data)==LIST_CMD)
             || (IDTYP((idhdl)source->data)>MAX_TOK)))
       || (source->rtyp>MAX_TOK))
         return (void *)omStrDup((char *)d);
       else if (e->next==NULL)
       {
         char *s=(char*)omAllocBin(size_two_bin);
         s[0]=*(char *)d;
         s[1]='\0';
         return s;
       }
       #ifdef TEST
       else
       {
         Werror("not impl. string-op in `%s`",my_yylinebuf);
         return NULL;
       }
       #endif
   }
   return s_internalCopy(t,d);
 }

void syMake	(	leftv	v,
		const char *	id,
		idhdl	packhdl
	)

Definition at line 1454 of file subexpr.cc.

 {
   /* resolv an identifier: (to DEF_CMD, if siq>0)
   * 1) reserved id: done by scanner
   * 2) `basering` / 'Current`
   * 3) existing identifier, local
   * 4) ringvar, ringpar, local ring
   * 5) existing identifier, global
   * 6) monom (resp. number), local ring: consisting of:
   * 6') ringvar,  ringpar,global ring
   * 6'') monom (resp. number), local ring
   * 7) monom (resp. number), non-local ring
   * 8) basering
   * 9) `_`
   * 10) everything else is of type 0
   */
 #ifdef TEST
   if ((*id<' ')||(*id>(char)126))
   {
     Print("wrong id :%s:\n",id);
   }
 #endif
   idhdl save_ring=currRingHdl;
   v->Init();
   if(packhdl != NULL)
   {
   //  Print("setting req_packhdl to %s\n",IDID(packhdl));
     v->req_packhdl = IDPACKAGE(packhdl);
   }
   else v->req_packhdl = currPack;
 //  if (v->req_packhdl!=basePack)
 //    Print("search %s in %s\n",id,v->req_packhdl->libname);
   idhdl h=NULL;
 #ifdef SIQ
   if (siq<=0)
 #endif
   {
     if (!isdigit(id[0]))
     {
       if (strcmp(id,"basering")==0)
       {
         if (currRingHdl!=NULL)
         {
           if (id!=IDID(currRingHdl)) omFreeBinAddr((ADDRESS)id);
           h=currRingHdl;
           goto id_found;
         }
         else
         {
           v->name = id;
           return; /* undefined */
         }
       }
       else if (strcmp(id,"Current")==0)
       {
         if (currPackHdl!=NULL)
         {
           omFreeBinAddr((ADDRESS)id);
           h=currPackHdl;
           goto id_found;
         }
         else
         {
           v->name = id;
           return; /* undefined */
         }
       }
       if(v->req_packhdl!=currPack)
       {
         h=v->req_packhdl->idroot->get(id,myynest);
       }
       else
       h=ggetid(id);
       /* 3) existing identifier, local */
       if ((h!=NULL) && (IDLEV(h)==myynest))
       {
         if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
         goto id_found;
       }
     }
     if (yyInRingConstruction)
     {
       currRingHdl=NULL;
     }
     /* 4. local ring: ringvar */
     if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest)
     /*&& (!yyInRingConstruction)*/)
     {
       int vnr;
       if ((vnr=r_IsRingVar(id, currRing->names,currRing->N))>=0)
       {
         poly p=pOne();
         pSetExp(p,vnr+1,1);
         pSetm(p);
         v->data = (void *)p;
         v->name = id;
         v->rtyp = POLY_CMD;
         return;
       }
       if((n_NumberOfParameters(currRing->cf)>0)
       &&((vnr=r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
                               n_NumberOfParameters(currRing->cf))>=0)))
       {
         BOOLEAN ok=FALSE;
         poly p = pmInit(id,ok);
         if (ok && (p!=NULL))
         {
           v->data = pGetCoeff(p);
           pGetCoeff(p)=NULL;
           pLmFree(p);
           v->rtyp = NUMBER_CMD;
           v->name = id;
           return;
         }
       }
     }
     /* 5. existing identifier, global */
     if (h!=NULL)
     {
       if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id);  /*assume strlen(id) <1000 */
       goto id_found;
     }
     /* 6. local ring: number/poly */
     if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
     {
       BOOLEAN ok=FALSE;
       /*poly p = (!yyInRingConstruction) ? pmInit(id,ok) : (poly)NULL;*/
       poly p = pmInit(id,ok);
       if (ok)
       {
         if (p==NULL)
         {
           v->data = (void *)nInit(0);
           v->rtyp = NUMBER_CMD;
           #ifdef HAVE_PLURAL
           // in this case we may have monomials equal to 0 in p_Read
           v->name = id;
           #else
           omFreeBinAddr((ADDRESS)id);
           #endif
         }
         else if (pIsConstant(p))
         {
           v->data = pGetCoeff(p);
           pGetCoeff(p)=NULL;
           pLmFree(p);
           v->rtyp = NUMBER_CMD;
           v->name = id;
         }
         else
         {
           v->data = p;
           v->rtyp = POLY_CMD;
           v->name = id;
         }
         return;
       }
     }
     /* 7. non-local ring: number/poly */
     {
       BOOLEAN ok=FALSE;
       poly p = ((currRing!=NULL)     /* ring required */
                && (currRingHdl!=NULL)
                /*&& (!yyInRingConstruction) - not in decl */
                && (IDLEV(currRingHdl)!=myynest)) /* already in case 4/6 */
                      ? pmInit(id,ok) : (poly)NULL;
       if (ok)
       {
         if (p==NULL)
         {
           v->data = (void *)nInit(0);
           v->rtyp = NUMBER_CMD;
           #ifdef HAVE_PLURAL
           // in this case we may have monomials equal to 0 in p_Read
           v->name = id;
           #else
           omFreeBinAddr((ADDRESS)id);
           #endif
         }
         else
         if (pIsConstant(p))
         {
           v->data = pGetCoeff(p);
           pGetCoeff(p)=NULL;
           pLmFree(p);
           v->rtyp = NUMBER_CMD;
           v->name = id;
         }
         else
         {
           v->data = p;
           v->rtyp = POLY_CMD;
           v->name = id;
         }
         //if (TEST_V_ALLWARN /*&& (myynest>0)*/
         //&& ((r_IsRingVar(id, currRing->names,currRing->N)>=0)
         //  || ((n_NumberOfParameters(currRing->cf)>0)
         //     &&(r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
         //                        n_NumberOfParameters(currRing->cf))>=0))))
         //{
         //// WARNING: do not use ring variable names in procedures
         //  Warn("use of variable >>%s<< in a procedure in line %s",id,my_yylinebuf);
         //}
         return;
       }
     }
     /* 8. basering ? */
     if ((myynest>1)&&(currRingHdl!=NULL))
     {
       if (strcmp(id,IDID(currRingHdl))==0)
       {
         if (IDID(currRingHdl)!=id) omFreeBinAddr((ADDRESS)id); /*assume strlen (id) <1000 */
         h=currRingHdl;
         goto id_found;
       }
     }
     if((v->req_packhdl!=basePack) && (v->req_packhdl==currPack))
     {
       h=basePack->idroot->get(id,myynest);
       if (h!=NULL)
       {
         if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
         v->req_packhdl=basePack;
         goto id_found;
       }
     }
   }
 #ifdef SIQ
   else
     v->rtyp=DEF_CMD;
 #endif
   /* 9: _ */
   if (strcmp(id,"_")==0)
   {
     omFreeBinAddr((ADDRESS)id);
     v->Copy(&sLastPrinted);
   }
   else
   {
     /* 10: everything else */
     /* v->rtyp = UNKNOWN;*/
     v->name = id;
   }
   currRingHdl=save_ring;
   return;
 id_found: // we have an id (in h) found, to set the data in from h
   if (IDTYP(h)!=ALIAS_CMD)
   {
     v->rtyp = IDHDL;
     v->flag = IDFLAG(h);
     v->attribute=IDATTR(h);
   }
   else
   {
     v->rtyp = ALIAS_CMD;
   }
   v->name = IDID(h);
   v->data = (char *)h;
   currRingHdl=save_ring;
 }

Variable Documentation

int iiCmatrix_index =0

static

Definition at line 1089 of file subexpr.cc.

snumber2 iiNumber2Data[4]

static

Definition at line 1088 of file subexpr.cc.

omBin libstack_bin = omGetSpecBin(sizeof(libstack))

Definition at line 52 of file subexpr.cc.

omBin procinfo_bin = omGetSpecBin(sizeof(procinfo))

Definition at line 51 of file subexpr.cc.

BOOLEAN siq =FALSE

Definition at line 58 of file subexpr.cc.

omBin size_two_bin = omGetSpecBin(2)

static

Definition at line 53 of file subexpr.cc.

sleftv sLastPrinted

Definition at line 55 of file subexpr.cc.

omBin sleftv_bin = omGetSpecBin(sizeof(sleftv))

Definition at line 50 of file subexpr.cc.

const char sNoName[] ="_"

Definition at line 56 of file subexpr.cc.

omBin sSubexpr_bin = omGetSpecBin(sizeof(_ssubexpr))

Definition at line 49 of file subexpr.cc.

Functions

Variables

Function Documentation

Variable Documentation