My Project  debian-1:4.1.2-p1+ds-2
Data Structures | Typedefs | Enumerations | Functions | Variables
subexpr.h File Reference
#include <string.h>
#include "polys/monomials/ring.h"
#include "kernel/mod2.h"
#include "Singular/grammar.h"
#include "Singular/tok.h"
#include "Singular/attrib.h"
#include "Singular/fevoices.h"

Go to the source code of this file.

Data Structures

class  proc_singular
 
struct  proc_object
 
union  procinfodata
 
class  procinfo
 
struct  Subexpr
 
class  sleftv
 Class used for (list of) interpreter objects. More...
 
class  libstack
 

Typedefs

typedef procinfoprocinfov
 
typedef sleftvleftv
 
typedef libstacklibstackv
 

Enumerations

enum  language_defs {
  LANG_NONE, LANG_TOP, LANG_SINGULAR, LANG_C,
  LANG_MIX, LANG_MAX
}
 

Functions

BOOLEAN RingDependend (int t)
 
void syMake (leftv v, const char *name, package pa=NULL)
 
BOOLEAN assumeStdFlag (leftv h)
 
procinfov piCopy (procinfov pi)
 
BOOLEAN piKill (procinfov l)
 
const char * piProcinfo (procinfov pi, const char *request)
 
void piShowProcinfo (procinfov pi, char *txt)
 
void s_internalDelete (const int t, void *d, const ring r)
 

Variables

EXTERN_VAR BOOLEAN siq
 
EXTERN_INST_VAR sleftv sLastPrinted
 
EXTERN_VAR omBin sSubexpr_bin
 
EXTERN_VAR omBin procinfo_bin
 
EXTERN_VAR omBin libstack_bin
 

Data Structure Documentation

◆ proc_singular

class proc_singular

Definition at line 22 of file subexpr.h.

Data Fields
char * body
long body_end
int body_lineno
long body_start
long def_end
int example_lineno
long example_start
long help_chksum
long help_end
long help_start
long proc_end
long proc_start

◆ uprocinfodata

union uprocinfodata

Definition at line 44 of file subexpr.h.

Data Fields
struct proc_object o
proc_singular s

◆ procinfo

class procinfo

Definition at line 52 of file subexpr.h.

Data Fields
procinfodata data
char is_static
language_defs language
char * libname
package pack
char * procname
short ref
char trace_flag

◆ _ssubexpr

struct _ssubexpr

Definition at line 67 of file subexpr.h.

Data Fields
struct _ssubexpr * next
int start

Typedef Documentation

◆ leftv

typedef sleftv* leftv

Definition at line 77 of file subexpr.h.

◆ libstackv

typedef libstack* libstackv

Definition at line 156 of file subexpr.h.

◆ procinfov

typedef procinfo* procinfov

Definition at line 65 of file subexpr.h.

Enumeration Type Documentation

◆ language_defs

Enumerator
LANG_NONE 
LANG_TOP 
LANG_SINGULAR 
LANG_C 
LANG_MIX 
LANG_MAX 

Definition at line 21 of file subexpr.h.

Function Documentation

◆ assumeStdFlag()

BOOLEAN assumeStdFlag ( leftv  h)

Definition at line 1551 of file subexpr.cc.

1553 {
1554  if (h->e!=NULL)
1555  {
1556  leftv hh=h->LData();
1557  if (h!=hh) return assumeStdFlag(h->LData());
1558  }
1559  if (!hasFlag(h,FLAG_STD))
1560  {
1561  if (!TEST_VERB_NSB)
1562  {
1563  if (TEST_V_ALLWARN)
1564  Warn("%s is no standard basis in >>%s<<",h->Name(),my_yylinebuf);
1565  else
1566  Warn("%s is no standard basis",h->Name());
1567  }
1568  return FALSE;
1569  }
1570  return TRUE;

◆ piCopy()

procinfov piCopy ( procinfov  pi)
inline

Definition at line 147 of file subexpr.h.

149 {
150  pi->ref++;
151  return pi;

◆ piKill()

BOOLEAN piKill ( procinfov  l)

Definition at line 663 of file ipid.cc.

665 {
666  (pi->ref)--;
667  if (pi->ref == 0)
668  {
669  if (pi->language==LANG_SINGULAR)
670  {
672  while (p!=NULL)
673  {
674  if (p->pi==pi && pi->ref <= 1)
675  {
676  Warn("`%s` in use, can not be killed",pi->procname);
677  return TRUE;
678  }
679  p=p->next;
680  }
681  }
682  if (pi->libname != NULL) // OB: ????
683  omFree((ADDRESS)pi->libname);
684  if (pi->procname != NULL) // OB: ????
685  omFree((ADDRESS)pi->procname);
686 
687  if( pi->language == LANG_SINGULAR)
688  {
689  if (pi->data.s.body != NULL) // OB: ????
690  omFree((ADDRESS)pi->data.s.body);
691  }
692  if( pi->language == LANG_C)
693  {
694  }
695  memset((void *) pi, 0, sizeof(procinfo));
696  //pi->language=LANG_NONE;
698  }
699  return FALSE;

◆ piProcinfo()

const char* piProcinfo ( procinfov  pi,
const char *  request 
)

Definition at line 639 of file ipid.cc.

641 {
642  if((pi == NULL)||(pi->language==LANG_NONE)) return "empty proc";
643  else if (strcmp(request, "libname") == 0) return pi->libname;
644  else if (strcmp(request, "procname") == 0) return pi->procname;
645  else if (strcmp(request, "type") == 0)
646  {
647  switch (pi->language)
648  {
649  case LANG_SINGULAR: return "singular"; break;
650  case LANG_C: return "object"; break;
651  case LANG_NONE: return "none"; break;
652  default: return "unknown language";
653  }
654  }
655  else if (strcmp(request, "ref") == 0)
656  {
657  char p[8];
658  sprintf(p, "%d", pi->ref);
659  return omStrDup(p); // MEMORY-LEAK
660  }
661  return "??";

◆ piShowProcinfo()

void piShowProcinfo ( procinfov  pi,
char *  txt 
)

◆ RingDependend()

BOOLEAN RingDependend ( int  t)
inline

Definition at line 141 of file subexpr.h.

142 { return (BEGIN_RING<t)&&(t<END_RING); }

◆ s_internalDelete()

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

Definition at line 513 of file subexpr.cc.

515 {
516  assume(d!=NULL);
517  switch (t)
518  {
519  case CRING_CMD:
520  {
521  coeffs cf=(coeffs)d;
522  if ((cf->ref<1)&&
523  ((cf->type <=n_GF)
524  ||((cf->type >=n_long_C)&&(cf->type <=n_CF))))
525  {
526  Warn("cannot kill `%s`",nCoeffName(cf));
527  }
528  else // allow nKillChar for n_long_R, extensions, and user defined:
529  nKillChar((coeffs)d);
530  break;
531  }
532 #ifdef SINGULAR_4_2
533  case CNUMBER_CMD:
534  {
535  number2 n=(number2)d;
536  n2Delete(n);
537  break;
538  }
539  case CPOLY_CMD:
540  {
541  poly2 n=(poly2)d;
542  p2Delete(n);
543  break;
544  }
545  case CMATRIX_CMD: //like BIGINTMAT
546 #endif
547  case BIGINTMAT_CMD:
548  {
549  bigintmat *v=(bigintmat*)d;
550  delete v;
551  break;
552  }
553  case BUCKET_CMD:
554  {
557  break;
558  }
559  case INTVEC_CMD:
560  case INTMAT_CMD:
561  {
562  intvec *v=(intvec*)d;
563  delete v;
564  break;
565  }
566  case MAP_CMD:
567  {
568  map m=(map)d;
569  omFreeBinAddr((ADDRESS)m->preimage);
570  m->preimage=NULL;
571  /* no break: continue as IDEAL*/
572  }
573  case SMATRIX_CMD:
574  case MATRIX_CMD:
575  case IDEAL_CMD:
576  case MODUL_CMD:
577  {
578  ideal i=(ideal)d;
579  id_Delete(&i,r);
580  break;
581  }
582  case STRING_CMD:
583  omFree(d);
584  break;
585  //case PACKAGE_CMD:
586  // return (void *)paCopy((package) d);
587  case PROC_CMD:
588  piKill((procinfo*)d);
589  break;
590  case POLY_CMD:
591  case VECTOR_CMD:
592  {
593  poly p=(poly)d;
594  p_Delete(&p,r);
595  break;
596  }
597  case NUMBER_CMD:
598  {
599  number n=(number)d;
600  n_Delete(&n,r->cf);
601  break;
602  }
603  case BIGINT_CMD:
604  {
605  number n=(number)d;
607  break;
608  }
609  case LIST_CMD:
610  {
611  lists l=(lists)d;
612  l->Clean(r);
613  break;
614  }
615  case LINK_CMD:
616  {
617  si_link l=(si_link)d;
618  slKill(l);
619  break;
620  }
621  case RING_CMD:
622  {
623  ring R=(ring)d;
624  if ((R!=currRing)||(R->ref>=0))
625  rKill(R);
626  #ifdef TEST
627  else
628  Print("currRing? ref=%d\n",R->ref);
629  #endif
630  break;
631  }
632  case RESOLUTION_CMD:
633  {
635  if (s!=NULL) syKillComputation(s,r);
636  break;
637  }
638  case COMMAND:
639  {
640  command cmd=(command)d;
641  if (cmd->arg1.rtyp!=0) cmd->arg1.CleanUp(r);
642  if (cmd->arg2.rtyp!=0) cmd->arg2.CleanUp(r);
643  if (cmd->arg3.rtyp!=0) cmd->arg3.CleanUp(r);
645  break;
646  }
647  case INT_CMD:
648  case DEF_CMD:
649  case ALIAS_CMD:
650  case PACKAGE_CMD:
651  case IDHDL:
652  case NONE:
653  case ANY_TYPE:
654  case VECHO:
655  case VPRINTLEVEL:
656  case VCOLMAX:
657  case VTIMER:
658  case VRTIMER:
659  case VOICE:
660  case VMAXDEG:
661  case VMAXMULT:
662  case TRACE:
663  case VSHORTOUT:
664  case VNOETHER:
665  case VMINPOLY:
666  case 0: /* type in error case */
667  break; /* error recovery: do nothing */
668  //case COMMAND:
669  //case COMMAND:
670  default:
671  {
672  if (t>MAX_TOK)
673  {
674  blackbox *b=getBlackboxStuff(t);
675  if (b!=NULL) b->blackbox_destroy(b,d);
676  break;
677  }
678  else
679  Warn("s_internalDelete: cannot delete type %s(%d)",
680  Tok2Cmdname(t),t);
681  }
682  }

◆ syMake()

void syMake ( leftv  v,
const char *  name,
package  pa = NULL 
)

Definition at line 1577 of file subexpr.cc.

1579 {
1580  /* resolv an identifier: (to DEF_CMD, if siq>0)
1581  * 1) reserved id: done by scanner
1582  * 2) `basering` / 'Current`
1583  * 3) existing identifier, local
1584  * 4) ringvar, ringpar, local ring
1585  * 5) existing identifier, global
1586  * 6) monom (resp. number), local ring: consisting of:
1587  * 6') ringvar, ringpar,global ring
1588  * 6'') monom (resp. number), local ring
1589  * 7) monom (resp. number), non-local ring
1590  * 8) basering
1591  * 9) `_`
1592  * 10) everything else is of type 0
1593  */
1594 #ifdef TEST
1595  if ((*id<' ')||(*id>(char)126))
1596  {
1597  Print("wrong id :%s:\n",id);
1598  }
1599 #endif
1600  idhdl save_ring=currRingHdl;
1601  v->Init();
1602  if(pa != NULL)
1603  {
1604  v->req_packhdl = pa;
1605  }
1606  else v->req_packhdl = currPack;
1607 // if (v->req_packhdl!=basePack)
1608 // Print("search %s in %s\n",id,v->req_packhdl->libname);
1609  idhdl h=NULL;
1610 #ifdef SIQ
1611  if (siq<=0)
1612 #endif
1613  {
1614  if (!isdigit(id[0]))
1615  {
1616  if (strcmp(id,"basering")==0)
1617  {
1618  if (currRingHdl!=NULL)
1619  {
1620  if (id!=IDID(currRingHdl)) omFreeBinAddr((ADDRESS)id);
1621  h=currRingHdl;
1622  goto id_found;
1623  }
1624  else
1625  {
1626  v->name = id;
1627  return; /* undefined */
1628  }
1629  }
1630  else if (strcmp(id,"Current")==0)
1631  {
1632  if (currPackHdl!=NULL)
1633  {
1634  omFreeBinAddr((ADDRESS)id);
1635  h=currPackHdl;
1636  goto id_found;
1637  }
1638  else
1639  {
1640  v->name = id;
1641  return; /* undefined */
1642  }
1643  }
1644  if(v->req_packhdl!=currPack)
1645  {
1646  h=v->req_packhdl->idroot->get(id,myynest);
1647  }
1648  else
1649  h=ggetid(id);
1650  /* 3) existing identifier, local */
1651  if ((h!=NULL) && (IDLEV(h)==myynest))
1652  {
1653  if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1654  goto id_found;
1655  }
1656  }
1658  {
1659  currRingHdl=NULL;
1660  }
1661  /* 4. local ring: ringvar */
1662  if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest)
1663  /*&& (!yyInRingConstruction)*/)
1664  {
1665  int vnr;
1666  if ((vnr=r_IsRingVar(id, currRing->names,currRing->N))>=0)
1667  {
1668  poly p=pOne();
1669  pSetExp(p,vnr+1,1);
1670  pSetm(p);
1671  v->data = (void *)p;
1672  v->name = id;
1673  v->rtyp = POLY_CMD;
1674  return;
1675  }
1676  if((n_NumberOfParameters(currRing->cf)>0)
1677  &&((vnr=r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
1678  n_NumberOfParameters(currRing->cf))>=0)))
1679  {
1680  BOOLEAN ok=FALSE;
1681  poly p = pmInit(id,ok);
1682  if (ok && (p!=NULL))
1683  {
1684  v->data = pGetCoeff(p);
1685  pGetCoeff(p)=NULL;
1686  pLmFree(p);
1687  v->rtyp = NUMBER_CMD;
1688  v->name = id;
1689  return;
1690  }
1691  }
1692  }
1693  /* 5. existing identifier, global */
1694  if (h!=NULL)
1695  {
1696  if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1697  goto id_found;
1698  }
1699  /* 6. local ring: number/poly */
1700  if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
1701  {
1702  BOOLEAN ok=FALSE;
1703  /*poly p = (!yyInRingConstruction) ? pmInit(id,ok) : (poly)NULL;*/
1704  poly p = pmInit(id,ok);
1705  if (ok)
1706  {
1707  if (p==NULL)
1708  {
1709  v->data = (void *)nInit(0);
1710  v->rtyp = NUMBER_CMD;
1711  #ifdef HAVE_PLURAL
1712  // in this case we may have monomials equal to 0 in p_Read
1713  v->name = id;
1714  #else
1715  omFreeBinAddr((ADDRESS)id);
1716  #endif
1717  }
1718  else if (pIsConstant(p))
1719  {
1720  v->data = pGetCoeff(p);
1721  pGetCoeff(p)=NULL;
1722  pLmFree(p);
1723  v->rtyp = NUMBER_CMD;
1724  v->name = id;
1725  }
1726  else
1727  {
1728  v->name = id;
1729  #ifdef HAVE_SHIFTBBA
1730  if ((currRing->isLPring!=0)
1731  && (p_Totaldegree(p,currRing)>1))
1732  {
1733  p_LmDelete(&p,currRing);
1734  /* v->rtyp = UNKNOWN; - already set */
1735  return; /* error, report "unknown id" */
1736  }
1737  #endif
1738  v->data = p;
1739  v->rtyp = POLY_CMD;
1740  }
1741  return;
1742  }
1743  }
1744  /* 7. non-local ring: number/poly */
1745  {
1746  BOOLEAN ok=FALSE;
1747  poly p = ((currRing!=NULL) /* ring required */
1748  && (currRingHdl!=NULL)
1749  /*&& (!yyInRingConstruction) - not in decl */
1750  && (IDLEV(currRingHdl)!=myynest)) /* already in case 4/6 */
1751  ? pmInit(id,ok) : (poly)NULL;
1752  if (ok)
1753  {
1754  if (p==NULL)
1755  {
1756  v->data = (void *)nInit(0);
1757  v->rtyp = NUMBER_CMD;
1758  omFreeBinAddr((ADDRESS)id);
1759  }
1760  else
1761  if (pIsConstant(p))
1762  {
1763  v->data = pGetCoeff(p);
1764  pGetCoeff(p)=NULL;
1765  pLmFree(p);
1766  v->rtyp = NUMBER_CMD;
1767  v->name = id;
1768  }
1769  else
1770  {
1771  v->data = p;
1772  v->rtyp = POLY_CMD;
1773  v->name = id;
1774  }
1775  //if (TEST_V_ALLWARN /*&& (myynest>0)*/
1776  //&& ((r_IsRingVar(id, currRing->names,currRing->N)>=0)
1777  // || ((n_NumberOfParameters(currRing->cf)>0)
1778  // &&(r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
1779  // n_NumberOfParameters(currRing->cf))>=0))))
1780  //{
1781  //// WARNING: do not use ring variable names in procedures
1782  // Warn("use of variable >>%s<< in a procedure in line %s",id,my_yylinebuf);
1783  //}
1784  return;
1785  }
1786  }
1787  /* 8. basering ? */
1788  if ((myynest>1)&&(currRingHdl!=NULL))
1789  {
1790  if (strcmp(id,IDID(currRingHdl))==0)
1791  {
1792  if (IDID(currRingHdl)!=id) omFreeBinAddr((ADDRESS)id); /*assume strlen (id) <1000 */
1793  h=currRingHdl;
1794  goto id_found;
1795  }
1796  }
1797  if((v->req_packhdl!=basePack) && (v->req_packhdl==currPack))
1798  {
1799  h=basePack->idroot->get(id,myynest);
1800  if (h!=NULL)
1801  {
1802  if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1803  v->req_packhdl=basePack;
1804  goto id_found;
1805  }
1806  }
1807  }
1808 #ifdef SIQ
1809  else
1810  v->rtyp=DEF_CMD;
1811 #endif
1812  /* 9: _ */
1813  if (strcmp(id,"_")==0)
1814  {
1815  omFreeBinAddr((ADDRESS)id);
1816  v->Copy(&sLastPrinted);
1817  }
1818  else
1819  {
1820  /* 10: everything else */
1821  /* v->rtyp = UNKNOWN;*/
1822  v->name = id;
1823  }
1824  currRingHdl=save_ring;
1825  return;
1826 id_found: // we have an id (in h) found, to set the data in from h
1827  if (IDTYP(h)!=ALIAS_CMD)
1828  {
1829  v->rtyp = IDHDL;
1830  v->flag = IDFLAG(h);
1831  v->attribute=IDATTR(h);
1832  }
1833  else
1834  {
1835  v->rtyp = ALIAS_CMD;
1836  }
1837  v->name = IDID(h);
1838  v->data = (char *)h;
1839  currRingHdl=save_ring;

Variable Documentation

◆ libstack_bin

EXTERN_VAR omBin libstack_bin

Definition at line 174 of file subexpr.h.

◆ procinfo_bin

EXTERN_VAR omBin procinfo_bin

Definition at line 173 of file subexpr.h.

◆ siq

Definition at line 75 of file subexpr.h.

◆ sLastPrinted

EXTERN_INST_VAR sleftv sLastPrinted

Definition at line 142 of file subexpr.h.

◆ sSubexpr_bin

EXTERN_VAR omBin sSubexpr_bin

Definition at line 172 of file subexpr.h.

VNOETHER
Definition: grammar.cc:308
FALSE
#define FALSE
Definition: auxiliary.h:96
pIsConstant
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:224
TRACE
Definition: tok.h:210
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
pLmFree
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition: polys.h:68
CRING_CMD
Definition: tok.h:55
NUMBER_CMD
Definition: grammar.cc:288
bigintmat
Definition: bigintmat.h:49
LANG_TOP
Definition: subexpr.h:22
LANG_SINGULAR
Definition: subexpr.h:22
BIGINT_CMD
Definition: tok.h:37
n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
LIST_CMD
Definition: tok.h:117
syStrategy
ssyStrategy * syStrategy
Definition: syz.h:34
ADDRESS
void * ADDRESS
Definition: auxiliary.h:135
MODUL_CMD
Definition: grammar.cc:287
STRING_CMD
Definition: tok.h:183
siq
VAR BOOLEAN siq
Definition: subexpr.cc:47
h
STATIC_VAR Poly * h
Definition: janet.cc:971
CNUMBER_CMD
Definition: tok.h:46
LANG_MAX
Definition: subexpr.h:22
map
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
Definition: cf_map_ext.cc:400
NONE
#define NONE
Definition: tok.h:219
cf
CanonicalForm cf
Definition: cfModGcd.cc:4024
sBucketDeleteAndDestroy
void sBucketDeleteAndDestroy(sBucket_pt *bucket_pt)
Definition: sbuckets.cc:108
MAX_TOK
Definition: tok.h:216
rKill
void rKill(ring r)
Definition: ipshell.cc:6123
procinfo
Definition: subexpr.h:52
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:454
VMAXMULT
Definition: grammar.cc:307
DEF_CMD
Definition: tok.h:57
n_GF
\GF{p^n < 2^16}
Definition: coeffs.h:32
BIGINTMAT_CMD
Definition: grammar.cc:278
n_NumberOfParameters
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:795
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:81
RING_CMD
Definition: grammar.cc:281
b
CanonicalForm b
Definition: cfModGcd.cc:4044
VTIMER
Definition: tok.h:208
MATRIX_CMD
Definition: grammar.cc:286
ANY_TYPE
#define ANY_TYPE
Definition: tok.h:29
currPack
VAR package currPack
Definition: ipid.cc:56
VOICE
Definition: tok.h:211
IDLEV
#define IDLEV(a)
Definition: ipid.h:115
r_IsRingVar
int r_IsRingVar(const char *n, char **names, int N)
Definition: ring.cc:211
pi
#define pi
Definition: libparse.cc:1144
VMINPOLY
Definition: grammar.cc:309
VRTIMER
Definition: tok.h:209
BEGIN_RING
Definition: grammar.cc:282
currPackHdl
VAR idhdl currPackHdl
Definition: ipid.cc:54
TRUE
#define TRUE
Definition: auxiliary.h:100
i
int i
Definition: cfEzgcd.cc:125
hasFlag
#define hasFlag(A, F)
Definition: ipid.h:106
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:122
INT_CMD
Definition: tok.h:95
COMMAND
#define COMMAND
Definition: tok.h:28
n_CF
?
Definition: coeffs.h:47
IDFLAG
#define IDFLAG(a)
Definition: ipid.h:114
CPOLY_CMD
Definition: tok.h:47
sip_command_bin
VAR omBin sip_command_bin
Definition: ipid.cc:44
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:87
VPRINTLEVEL
Definition: tok.h:213
PROC_CMD
Definition: grammar.cc:280
omFreeBinAddr
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:256
IDEAL_CMD
Definition: grammar.cc:284
sBucket_pt
sBucket * sBucket_pt
Definition: sbuckets.h:14
p_LmDelete
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:697
coeffs
pOne
#define pOne()
Definition: polys.h:299
piKill
BOOLEAN piKill(procinfov pi)
Definition: ipid.cc:663
IDATTR
#define IDATTR(a)
Definition: ipid.h:117
intvec
Definition: intvec.h:18
LANG_C
Definition: subexpr.h:22
END_RING
Definition: grammar.cc:310
VECTOR_CMD
Definition: grammar.cc:292
IDTYP
#define IDTYP(a)
Definition: ipid.h:113
procinfo_bin
VAR omBin procinfo_bin
Definition: subexpr.cc:41
LANG_NONE
Definition: subexpr.h:22
sBucket
Definition: sbuckets.cc:27
n_ParameterNames
static FORCE_INLINE const char ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:799
slists
Definition: lists.h:22
INTVEC_CMD
Definition: tok.h:100
INTMAT_CMD
Definition: grammar.cc:279
idrec
Definition: idrec.h:33
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:845
ALIAS_CMD
Definition: tok.h:33
VMAXDEG
Definition: grammar.cc:306
VECHO
Definition: tok.h:206
BUCKET_CMD
Definition: grammar.cc:283
pmInit
#define pmInit(a, b)
Definition: polys.h:273
LANG_MIX
Definition: subexpr.h:22
Print
#define Print
Definition: emacs.cc:79
language_defs
language_defs
Definition: subexpr.h:21
PACKAGE_CMD
Definition: tok.h:148
yyInRingConstruction
VAR BOOLEAN yyInRingConstruction
Definition: grammar.cc:172
myynest
VAR int myynest
Definition: febase.cc:40
assumeStdFlag
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1551
command
ip_command * command
Definition: ipid.h:21
IDHDL
#define IDHDL
Definition: tok.h:30
Voice
Definition: fevoices.h:57
m
int m
Definition: cfEzgcd.cc:121
basePack
VAR package basePack
Definition: ipid.cc:57
Variable::name
char name() const
Definition: variable.cc:122
assume
#define assume(x)
Definition: mod2.h:384
NULL
#define NULL
Definition: omList.c:11
MAP_CMD
Definition: grammar.cc:285
VCOLMAX
Definition: tok.h:207
nCoeffName
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:984
lists
slists * lists
Definition: mpr_numeric.h:145
coeffs_BIGINT
VAR coeffs coeffs_BIGINT
Definition: ipid.cc:49
my_yylinebuf
VAR char my_yylinebuf[80]
Definition: febase.cc:42
pSetm
#define pSetm(p)
Definition: polys.h:256
l
int l
Definition: cfEzgcd.cc:93
R
#define R
Definition: sirandom.c:27
currRingHdl
VAR idhdl currRingHdl
Definition: ipid.cc:58
pa
BOOLEAN pa(leftv res, leftv args)
Definition: cohomo.cc:4346
Warn
#define Warn
Definition: emacs.cc:76
pSetExp
#define pSetExp(p, i, v)
Definition: polys.h:41
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1428
p
int p
Definition: cfModGcd.cc:4019
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
ggetid
idhdl ggetid(const char *n)
Definition: ipid.cc:520
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
RESOLUTION_CMD
Definition: grammar.cc:290
nInit
#define nInit(i)
Definition: numbers.h:23
POLY_CMD
Definition: grammar.cc:289
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:140
IDID
#define IDID(a)
Definition: ipid.h:116
currentVoice
VAR Voice * currentVoice
Definition: fevoices.cc:45
FLAG_STD
#define FLAG_STD
Definition: ipid.h:103
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:41
omFreeBin
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:257
sLastPrinted
INST_VAR sleftv sLastPrinted
Definition: subexpr.cc:45
TEST_V_ALLWARN
#define TEST_V_ALLWARN
Definition: options.h:138
getBlackboxStuff
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:16
LINK_CMD
Definition: tok.h:116
CMATRIX_CMD
Definition: tok.h:45
syKillComputation
void syKillComputation(syStrategy syzstr, ring r=currRing)
Definition: syz1.cc:1494
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:510
ssyStrategy
Definition: syz.h:36
VSHORTOUT
Definition: tok.h:212
SMATRIX_CMD
Definition: grammar.cc:291
TEST_VERB_NSB
#define TEST_VERB_NSB
Definition: options.h:132