h4iku/coconut_c2005_preprocessed · Datasets at Hugging Face

return _MPCI_Send_request_packet(

return (rtems_status_code) _MPCI_Send_request_packet(

rtems_status_code _Region_MP_Send_request_packet ( Region_MP_Remote_operations operation, Objects_Id region_id, void *segment, unsigned32 size, rtems_option option_set, rtems_interval timeout){ Region_MP_Packet *the_packet; switch ( operation ) { case REGION_MP_GET_SEGMENT_REQUEST: case REGION_MP_RETURN_SEGMENT_REQUEST: the_packet = _Region_MP_Get_packet(); the_packet->Prefix.the_class = MP_PACKET_REGION; the_packet->Prefix.length = sizeof ( Region_MP_Packet ); the_packet->Prefix.to_convert = sizeof ( Region_MP_Packet ); if ( ! _Options_Is_no_wait(option_set)) the_packet->Prefix.timeout = timeout; the_packet->operation = operation; the_packet->Prefix.id = region_id; the_packet->segment = segment; the_packet->size = size; the_packet->option_set = option_set; return _MPCI_Send_request_packet( rtems_get_node( region_id ), &the_packet->Prefix, STATES_READY /* Not used */ ); break; case REGION_MP_ANNOUNCE_CREATE: case REGION_MP_ANNOUNCE_DELETE: case REGION_MP_EXTRACT_PROXY: case REGION_MP_GET_SEGMENT_RESPONSE: case REGION_MP_RETURN_SEGMENT_RESPONSE: break; } /* * The following line is included to satisfy compilers which * produce warnings when a function does not end with a return. */ return RTEMS_INTERNAL_ERROR;}

outport_byte (sc->port + DCR, MSK_FT10 | MSK_BMS | MSK_WTS);

if (sc->byte_transfers) { outport_byte (sc->port + DCR, MSK_FT10 | MSK_BMS); } else { outport_byte (sc->port + DCR, MSK_FT10 | MSK_BMS | MSK_WTS); }

rtems_ne_driver_attach (struct rtems_bsdnet_ifconfig *config){ int i; struct ne_softc *sc; struct ifnet *ifp; int mtu; /* Find a free driver. */ sc = NULL; for (i = 0; i < NNEDRIVER; ++i) { sc = &ne_softc[i]; ifp = &sc->arpcom.ac_if; if (ifp->if_softc == NULL) break; } if (sc == NULL) { printf ("Too many NE2000 drivers.\n"); return 0; } memset (sc, 0, sizeof *sc); /* Handle the options passed in by the caller. */ if (config->mtu != 0) mtu = config->mtu; else mtu = ETHERMTU; if (config->irno != 0) sc->irno = config->irno; else { /* We use 5 as the default IRQ. */ sc->irno = 5; } if (config->port != 0) sc->port = config->port; else { /* We use 0x300 as the default IO port number. */ sc->port = 0x300; } sc->accept_broadcasts = ! config->ignore_broadcast; if (config->hardware_address != NULL) memcpy (sc->arpcom.ac_enaddr, config->hardware_address, ETHER_ADDR_LEN); else { unsigned char prom[16]; int ia; /* Read the PROM to get the Ethernet hardware address. */ outport_byte (sc->port + CMDR, MSK_PG0 | MSK_RD2 | MSK_STP); outport_byte (sc->port + DCR, MSK_FT10 | MSK_BMS | MSK_WTS); outport_byte (sc->port + RBCR0, 0); outport_byte (sc->port + RBCR1, 0); outport_byte (sc->port + RCR, MSK_MON); outport_byte (sc->port + TCR, MSK_LOOP); outport_byte (sc->port + IMR, 0); outport_byte (sc->port + ISR, 0xff); ne_read_data (sc, 0, sizeof prom, prom); outport_byte (sc->port + CMDR, MSK_PG0 | MSK_RD2 | MSK_STP); for (ia = 0; ia < ETHER_ADDR_LEN; ++ia) sc->arpcom.ac_enaddr[ia] = prom[ia * 2]; } /* Set up the network interface. */ ifp->if_softc = sc; ifp->if_unit = i + 1; ifp->if_name = "ne"; ifp->if_mtu = mtu; ifp->if_init = ne_init; ifp->if_ioctl = ne_ioctl; ifp->if_start = ne_start; ifp->if_output = ether_output; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX; if (ifp->if_snd.ifq_maxlen == 0) ifp->if_snd.ifq_maxlen = ifqmaxlen; /* Attach the interface. */ if_attach (ifp); ether_ifattach (ifp); return 1;}

volatile unsigned32 *dma_control_status_reg; volatile unsigned16 *card_resource_reg; unsigned16 v;

volatile uint32_t *dma_control_status_reg; volatile uint16_t *card_resource_reg; uint16_t v;

boolean dmv177_z85c30_probe(int minor){ volatile unsigned32 *dma_control_status_reg; volatile unsigned16 *card_resource_reg; unsigned16 v; card_resource_reg = (volatile unsigned16 *) DMV170_CARD_RESORCE_REG; v = *card_resource_reg & DMV170_SCC_INST_MASK; if ( v != DMV170_SCC_INSTALLED ) return FALSE; /* * Figure out the clock speed of the Z85C30 SCC */ dma_control_status_reg = (volatile unsigned32 *)DMV170_DMA_CONTROL_STATUS_REG; if ( *dma_control_status_reg & DMV170_SCC_10MHZ ) Console_Port_Tbl[minor].ulClock = Z85C30_CLOCK_10; else Console_Port_Tbl[minor].ulClock = Z85C30_CLOCK_2; return TRUE;}

card_resource_reg = (volatile unsigned16 *) DMV170_CARD_RESORCE_REG;

card_resource_reg = (volatile uint16_t*) DMV170_CARD_RESORCE_REG;

boolean dmv177_z85c30_probe(int minor){ volatile unsigned32 *dma_control_status_reg; volatile unsigned16 *card_resource_reg; unsigned16 v; card_resource_reg = (volatile unsigned16 *) DMV170_CARD_RESORCE_REG; v = *card_resource_reg & DMV170_SCC_INST_MASK; if ( v != DMV170_SCC_INSTALLED ) return FALSE; /* * Figure out the clock speed of the Z85C30 SCC */ dma_control_status_reg = (volatile unsigned32 *)DMV170_DMA_CONTROL_STATUS_REG; if ( *dma_control_status_reg & DMV170_SCC_10MHZ ) Console_Port_Tbl[minor].ulClock = Z85C30_CLOCK_10; else Console_Port_Tbl[minor].ulClock = Z85C30_CLOCK_2; return TRUE;}

dma_control_status_reg = (volatile unsigned32 *)DMV170_DMA_CONTROL_STATUS_REG;

dma_control_status_reg = (volatile uint32_t*)DMV170_DMA_CONTROL_STATUS_REG;

boolean dmv177_z85c30_probe(int minor){ volatile unsigned32 *dma_control_status_reg; volatile unsigned16 *card_resource_reg; unsigned16 v; card_resource_reg = (volatile unsigned16 *) DMV170_CARD_RESORCE_REG; v = *card_resource_reg & DMV170_SCC_INST_MASK; if ( v != DMV170_SCC_INSTALLED ) return FALSE; /* * Figure out the clock speed of the Z85C30 SCC */ dma_control_status_reg = (volatile unsigned32 *)DMV170_DMA_CONTROL_STATUS_REG; if ( *dma_control_status_reg & DMV170_SCC_10MHZ ) Console_Port_Tbl[minor].ulClock = Z85C30_CLOCK_10; else Console_Port_Tbl[minor].ulClock = Z85C30_CLOCK_2; return TRUE;}

pari_sp av = avma;

mkintn(long n, ...){ va_list ap; pari_sp av = avma; GEN x, y; long i; int iszero = 1; va_start(ap,n);#ifdef LONG_IS_64BIT n >>= 1;#endif x = cgeti(n+2); x[1] = evallgefint(n+2) | evalsigne(1); y = int_MSW(x); for (i=0; i <n; i++) {#ifdef LONG_IS_64BIT ulong a = va_arg(ap, long); ulong b = va_arg(ap, long); *y = (a << 32) | b;#else *y = va_arg(ap, long);#endif if (*y) iszero = 0; y = int_precW(y); } va_end(ap); if (iszero) { avma = av; return gen_0; } return x;}

int iszero = 1;

mkintn(long n, ...){ va_list ap; pari_sp av = avma; GEN x, y; long i; int iszero = 1; va_start(ap,n);#ifdef LONG_IS_64BIT n >>= 1;#endif x = cgeti(n+2); x[1] = evallgefint(n+2) | evalsigne(1); y = int_MSW(x); for (i=0; i <n; i++) {#ifdef LONG_IS_64BIT ulong a = va_arg(ap, long); ulong b = va_arg(ap, long); *y = (a << 32) | b;#else *y = va_arg(ap, long);#endif if (*y) iszero = 0; y = int_precW(y); } va_end(ap); if (iszero) { avma = av; return gen_0; } return x;}

ulong a = va_arg(ap, long);

ulong a = (e && !i)? 0: va_arg(ap, long);

mkintn(long n, ...){ va_list ap; pari_sp av = avma; GEN x, y; long i; int iszero = 1; va_start(ap,n);#ifdef LONG_IS_64BIT n >>= 1;#endif x = cgeti(n+2); x[1] = evallgefint(n+2) | evalsigne(1); y = int_MSW(x); for (i=0; i <n; i++) {#ifdef LONG_IS_64BIT ulong a = va_arg(ap, long); ulong b = va_arg(ap, long); *y = (a << 32) | b;#else *y = va_arg(ap, long);#endif if (*y) iszero = 0; y = int_precW(y); } va_end(ap); if (iszero) { avma = av; return gen_0; } return x;}

if (*y) iszero = 0;

mkintn(long n, ...){ va_list ap; pari_sp av = avma; GEN x, y; long i; int iszero = 1; va_start(ap,n);#ifdef LONG_IS_64BIT n >>= 1;#endif x = cgeti(n+2); x[1] = evallgefint(n+2) | evalsigne(1); y = int_MSW(x); for (i=0; i <n; i++) {#ifdef LONG_IS_64BIT ulong a = va_arg(ap, long); ulong b = va_arg(ap, long); *y = (a << 32) | b;#else *y = va_arg(ap, long);#endif if (*y) iszero = 0; y = int_precW(y); } va_end(ap); if (iszero) { avma = av; return gen_0; } return x;}

if (iszero) { avma = av; return gen_0; } return x;

return int_normalize(x, 0);

mkintn(long n, ...){ va_list ap; pari_sp av = avma; GEN x, y; long i; int iszero = 1; va_start(ap,n);#ifdef LONG_IS_64BIT n >>= 1;#endif x = cgeti(n+2); x[1] = evallgefint(n+2) | evalsigne(1); y = int_MSW(x); for (i=0; i <n; i++) {#ifdef LONG_IS_64BIT ulong a = va_arg(ap, long); ulong b = va_arg(ap, long); *y = (a << 32) | b;#else *y = va_arg(ap, long);#endif if (*y) iszero = 0; y = int_precW(y); } va_end(ap); if (iszero) { avma = av; return gen_0; } return x;}

return out;

friend std::ostream& operator<<(std::ostream& out, const pair& v) { out << *(v.first) << " " << *(v.second); }

long pp,llist,i,nn,N,vf; GEN listpotbl,ff,A,delta,rootsA,CSF,ESF,p1,LSB,p; GEN DATA, pol = (GEN)nf[1];

long llist,i,nn; GEN listpotbl,ff,A,delta,rootsA,CSF,ESF,p1,LSB,p,T,DATA, pol = (GEN)nf[1];

subfields_of_given_degree(GEN nf,GEN dpol,long d){ ulong av,av2,tetpil; long pp,llist,i,nn,N,vf; GEN listpotbl,ff,A,delta,rootsA,CSF,ESF,p1,LSB,p; GEN DATA, pol = (GEN)nf[1]; if (DEBUGLEVEL) fprintferr("\n*** Looking for subfields of degree %ld\n\n", d); TR = 0; av = avma; vf = fetch_var(); N = deg(pol); pp = choose_prime(pol,dpol,N/d,&ff,&listpotbl,&nn); if (!listpotbl) { avma=av; return cgetg(1,t_VEC); } llist=lg(listpotbl); p = stoi(pp); LSB = cgetg(1,t_VEC); i = 1; DATA = NULL;CHANGE: DATA = compute_data(DATA,nf,ff,p,d,nn,vf); for (; i<llist; i++) { av2 = avma; A=(GEN)listpotbl[i]; if (DEBUGLEVEL > 1) fprintferr("\n* Potential block # %ld: %Z\n",i,A); CSF = cand_for_subfields(A,DATA,&delta,&rootsA); if (typ(CSF)==t_INT) { avma = av2; if (DEBUGLEVEL > 1) switch(itos(CSF)) { case 0: fprintferr("changing f(x): non separable g(x)\n"); break; case 1: fprintferr("coeff too big for pol g(x)\n"); break; case 2: fprintferr("changing f(x): p divides disc(g(x))\n"); break; case 3: fprintferr("non irreducible polynomial g(x)\n"); break; case 4: fprintferr("prime to d(L) part of d(g) not a square\n"); break; case 5: fprintferr("too small exponent of a prime factor in d(L)\n"); break; case 6: fprintferr("the d-th power of d(K) does not divide d(L)\n"); } switch(itos(CSF)) { case 0: case 2: goto CHANGE; } } else { if (DEBUGLEVEL) fprintferr("candidate = %Z\n",CSF); ESF = embedding_of_potential_subfields(nf,CSF,DATA,rootsA,delta); if (!ESF) avma = av2; else { if (DEBUGLEVEL) fprintferr("embedding = %Z\n",ESF); p1 = cgetg(3,t_VEC); p1[1] = (long)CSF; p1[2] = (long)ESF; p1 = _vec(p1); tetpil = avma; LSB = gerepile(av2,tetpil, concat(LSB, p1)); } } } for (i=1; i<llist; i++) free((void*)listpotbl[i]); delete_var(); free((void*)(listpotbl-1)); tetpil=avma; if (DEBUGLEVEL) fprintferr("\nSubfields of degree %ld: %Z\n",d, LSB); return gerepile(av,tetpil,gcopy(LSB));}

if (DEBUGLEVEL) fprintferr("\n*** Looking for subfields of degree %ld\n\n", d); TR = 0; av = avma; vf = fetch_var(); N = deg(pol); pp = choose_prime(pol,dpol,N/d,&ff,&listpotbl,&nn);

if (DEBUGLEVEL) fprintferr("\n*** Look for subfields of degree %ld\n\n", d); TR = 0; av = avma; p = choose_prime(pol,dpol,deg(pol)/d,&ff,&listpotbl,&nn);

subfields_of_given_degree(GEN nf,GEN dpol,long d){ ulong av,av2,tetpil; long pp,llist,i,nn,N,vf; GEN listpotbl,ff,A,delta,rootsA,CSF,ESF,p1,LSB,p; GEN DATA, pol = (GEN)nf[1]; if (DEBUGLEVEL) fprintferr("\n*** Looking for subfields of degree %ld\n\n", d); TR = 0; av = avma; vf = fetch_var(); N = deg(pol); pp = choose_prime(pol,dpol,N/d,&ff,&listpotbl,&nn); if (!listpotbl) { avma=av; return cgetg(1,t_VEC); } llist=lg(listpotbl); p = stoi(pp); LSB = cgetg(1,t_VEC); i = 1; DATA = NULL;CHANGE: DATA = compute_data(DATA,nf,ff,p,d,nn,vf); for (; i<llist; i++) { av2 = avma; A=(GEN)listpotbl[i]; if (DEBUGLEVEL > 1) fprintferr("\n* Potential block # %ld: %Z\n",i,A); CSF = cand_for_subfields(A,DATA,&delta,&rootsA); if (typ(CSF)==t_INT) { avma = av2; if (DEBUGLEVEL > 1) switch(itos(CSF)) { case 0: fprintferr("changing f(x): non separable g(x)\n"); break; case 1: fprintferr("coeff too big for pol g(x)\n"); break; case 2: fprintferr("changing f(x): p divides disc(g(x))\n"); break; case 3: fprintferr("non irreducible polynomial g(x)\n"); break; case 4: fprintferr("prime to d(L) part of d(g) not a square\n"); break; case 5: fprintferr("too small exponent of a prime factor in d(L)\n"); break; case 6: fprintferr("the d-th power of d(K) does not divide d(L)\n"); } switch(itos(CSF)) { case 0: case 2: goto CHANGE; } } else { if (DEBUGLEVEL) fprintferr("candidate = %Z\n",CSF); ESF = embedding_of_potential_subfields(nf,CSF,DATA,rootsA,delta); if (!ESF) avma = av2; else { if (DEBUGLEVEL) fprintferr("embedding = %Z\n",ESF); p1 = cgetg(3,t_VEC); p1[1] = (long)CSF; p1[2] = (long)ESF; p1 = _vec(p1); tetpil = avma; LSB = gerepile(av2,tetpil, concat(LSB, p1)); } } } for (i=1; i<llist; i++) free((void*)listpotbl[i]); delete_var(); free((void*)(listpotbl-1)); tetpil=avma; if (DEBUGLEVEL) fprintferr("\nSubfields of degree %ld: %Z\n",d, LSB); return gerepile(av,tetpil,gcopy(LSB));}

llist=lg(listpotbl); p = stoi(pp); LSB = cgetg(1,t_VEC); i = 1; DATA = NULL; CHANGE: DATA = compute_data(DATA,nf,ff,p,d,nn,vf);

T = lift_intern(ffinit(p,nn, fetch_var())); DATA = NULL; LSB = cgetg(1,t_VEC); i = 1; llist = lg(listpotbl); CHANGE: DATA = compute_data(DATA,d,nf,ff,T,p);

subfields_of_given_degree(GEN nf,GEN dpol,long d){ ulong av,av2,tetpil; long pp,llist,i,nn,N,vf; GEN listpotbl,ff,A,delta,rootsA,CSF,ESF,p1,LSB,p; GEN DATA, pol = (GEN)nf[1]; if (DEBUGLEVEL) fprintferr("\n*** Looking for subfields of degree %ld\n\n", d); TR = 0; av = avma; vf = fetch_var(); N = deg(pol); pp = choose_prime(pol,dpol,N/d,&ff,&listpotbl,&nn); if (!listpotbl) { avma=av; return cgetg(1,t_VEC); } llist=lg(listpotbl); p = stoi(pp); LSB = cgetg(1,t_VEC); i = 1; DATA = NULL;CHANGE: DATA = compute_data(DATA,nf,ff,p,d,nn,vf); for (; i<llist; i++) { av2 = avma; A=(GEN)listpotbl[i]; if (DEBUGLEVEL > 1) fprintferr("\n* Potential block # %ld: %Z\n",i,A); CSF = cand_for_subfields(A,DATA,&delta,&rootsA); if (typ(CSF)==t_INT) { avma = av2; if (DEBUGLEVEL > 1) switch(itos(CSF)) { case 0: fprintferr("changing f(x): non separable g(x)\n"); break; case 1: fprintferr("coeff too big for pol g(x)\n"); break; case 2: fprintferr("changing f(x): p divides disc(g(x))\n"); break; case 3: fprintferr("non irreducible polynomial g(x)\n"); break; case 4: fprintferr("prime to d(L) part of d(g) not a square\n"); break; case 5: fprintferr("too small exponent of a prime factor in d(L)\n"); break; case 6: fprintferr("the d-th power of d(K) does not divide d(L)\n"); } switch(itos(CSF)) { case 0: case 2: goto CHANGE; } } else { if (DEBUGLEVEL) fprintferr("candidate = %Z\n",CSF); ESF = embedding_of_potential_subfields(nf,CSF,DATA,rootsA,delta); if (!ESF) avma = av2; else { if (DEBUGLEVEL) fprintferr("embedding = %Z\n",ESF); p1 = cgetg(3,t_VEC); p1[1] = (long)CSF; p1[2] = (long)ESF; p1 = _vec(p1); tetpil = avma; LSB = gerepile(av2,tetpil, concat(LSB, p1)); } } } for (i=1; i<llist; i++) free((void*)listpotbl[i]); delete_var(); free((void*)(listpotbl-1)); tetpil=avma; if (DEBUGLEVEL) fprintferr("\nSubfields of degree %ld: %Z\n",d, LSB); return gerepile(av,tetpil,gcopy(LSB));}

case 5: fprintferr("too small exponent of a prime factor in d(L)\n"); break;

case 5: fprintferr("exponent too small in factor( d(L) )\n"); break;

subfields_of_given_degree(GEN nf,GEN dpol,long d){ ulong av,av2,tetpil; long pp,llist,i,nn,N,vf; GEN listpotbl,ff,A,delta,rootsA,CSF,ESF,p1,LSB,p; GEN DATA, pol = (GEN)nf[1]; if (DEBUGLEVEL) fprintferr("\n*** Looking for subfields of degree %ld\n\n", d); TR = 0; av = avma; vf = fetch_var(); N = deg(pol); pp = choose_prime(pol,dpol,N/d,&ff,&listpotbl,&nn); if (!listpotbl) { avma=av; return cgetg(1,t_VEC); } llist=lg(listpotbl); p = stoi(pp); LSB = cgetg(1,t_VEC); i = 1; DATA = NULL;CHANGE: DATA = compute_data(DATA,nf,ff,p,d,nn,vf); for (; i<llist; i++) { av2 = avma; A=(GEN)listpotbl[i]; if (DEBUGLEVEL > 1) fprintferr("\n* Potential block # %ld: %Z\n",i,A); CSF = cand_for_subfields(A,DATA,&delta,&rootsA); if (typ(CSF)==t_INT) { avma = av2; if (DEBUGLEVEL > 1) switch(itos(CSF)) { case 0: fprintferr("changing f(x): non separable g(x)\n"); break; case 1: fprintferr("coeff too big for pol g(x)\n"); break; case 2: fprintferr("changing f(x): p divides disc(g(x))\n"); break; case 3: fprintferr("non irreducible polynomial g(x)\n"); break; case 4: fprintferr("prime to d(L) part of d(g) not a square\n"); break; case 5: fprintferr("too small exponent of a prime factor in d(L)\n"); break; case 6: fprintferr("the d-th power of d(K) does not divide d(L)\n"); } switch(itos(CSF)) { case 0: case 2: goto CHANGE; } } else { if (DEBUGLEVEL) fprintferr("candidate = %Z\n",CSF); ESF = embedding_of_potential_subfields(nf,CSF,DATA,rootsA,delta); if (!ESF) avma = av2; else { if (DEBUGLEVEL) fprintferr("embedding = %Z\n",ESF); p1 = cgetg(3,t_VEC); p1[1] = (long)CSF; p1[2] = (long)ESF; p1 = _vec(p1); tetpil = avma; LSB = gerepile(av2,tetpil, concat(LSB, p1)); } } } for (i=1; i<llist; i++) free((void*)listpotbl[i]); delete_var(); free((void*)(listpotbl-1)); tetpil=avma; if (DEBUGLEVEL) fprintferr("\nSubfields of degree %ld: %Z\n",d, LSB); return gerepile(av,tetpil,gcopy(LSB));}

ESF = embedding_of_potential_subfields(nf,CSF,DATA,rootsA,delta);

ESF = embedding_of_potential_subfields(CSF,DATA,rootsA,delta);

subfields_of_given_degree(GEN nf,GEN dpol,long d){ ulong av,av2,tetpil; long pp,llist,i,nn,N,vf; GEN listpotbl,ff,A,delta,rootsA,CSF,ESF,p1,LSB,p; GEN DATA, pol = (GEN)nf[1]; if (DEBUGLEVEL) fprintferr("\n*** Looking for subfields of degree %ld\n\n", d); TR = 0; av = avma; vf = fetch_var(); N = deg(pol); pp = choose_prime(pol,dpol,N/d,&ff,&listpotbl,&nn); if (!listpotbl) { avma=av; return cgetg(1,t_VEC); } llist=lg(listpotbl); p = stoi(pp); LSB = cgetg(1,t_VEC); i = 1; DATA = NULL;CHANGE: DATA = compute_data(DATA,nf,ff,p,d,nn,vf); for (; i<llist; i++) { av2 = avma; A=(GEN)listpotbl[i]; if (DEBUGLEVEL > 1) fprintferr("\n* Potential block # %ld: %Z\n",i,A); CSF = cand_for_subfields(A,DATA,&delta,&rootsA); if (typ(CSF)==t_INT) { avma = av2; if (DEBUGLEVEL > 1) switch(itos(CSF)) { case 0: fprintferr("changing f(x): non separable g(x)\n"); break; case 1: fprintferr("coeff too big for pol g(x)\n"); break; case 2: fprintferr("changing f(x): p divides disc(g(x))\n"); break; case 3: fprintferr("non irreducible polynomial g(x)\n"); break; case 4: fprintferr("prime to d(L) part of d(g) not a square\n"); break; case 5: fprintferr("too small exponent of a prime factor in d(L)\n"); break; case 6: fprintferr("the d-th power of d(K) does not divide d(L)\n"); } switch(itos(CSF)) { case 0: case 2: goto CHANGE; } } else { if (DEBUGLEVEL) fprintferr("candidate = %Z\n",CSF); ESF = embedding_of_potential_subfields(nf,CSF,DATA,rootsA,delta); if (!ESF) avma = av2; else { if (DEBUGLEVEL) fprintferr("embedding = %Z\n",ESF); p1 = cgetg(3,t_VEC); p1[1] = (long)CSF; p1[2] = (long)ESF; p1 = _vec(p1); tetpil = avma; LSB = gerepile(av2,tetpil, concat(LSB, p1)); } } } for (i=1; i<llist; i++) free((void*)listpotbl[i]); delete_var(); free((void*)(listpotbl-1)); tetpil=avma; if (DEBUGLEVEL) fprintferr("\nSubfields of degree %ld: %Z\n",d, LSB); return gerepile(av,tetpil,gcopy(LSB));}

delete_var();

subfields_of_given_degree(GEN nf,GEN dpol,long d){ ulong av,av2,tetpil; long pp,llist,i,nn,N,vf; GEN listpotbl,ff,A,delta,rootsA,CSF,ESF,p1,LSB,p; GEN DATA, pol = (GEN)nf[1]; if (DEBUGLEVEL) fprintferr("\n*** Looking for subfields of degree %ld\n\n", d); TR = 0; av = avma; vf = fetch_var(); N = deg(pol); pp = choose_prime(pol,dpol,N/d,&ff,&listpotbl,&nn); if (!listpotbl) { avma=av; return cgetg(1,t_VEC); } llist=lg(listpotbl); p = stoi(pp); LSB = cgetg(1,t_VEC); i = 1; DATA = NULL;CHANGE: DATA = compute_data(DATA,nf,ff,p,d,nn,vf); for (; i<llist; i++) { av2 = avma; A=(GEN)listpotbl[i]; if (DEBUGLEVEL > 1) fprintferr("\n* Potential block # %ld: %Z\n",i,A); CSF = cand_for_subfields(A,DATA,&delta,&rootsA); if (typ(CSF)==t_INT) { avma = av2; if (DEBUGLEVEL > 1) switch(itos(CSF)) { case 0: fprintferr("changing f(x): non separable g(x)\n"); break; case 1: fprintferr("coeff too big for pol g(x)\n"); break; case 2: fprintferr("changing f(x): p divides disc(g(x))\n"); break; case 3: fprintferr("non irreducible polynomial g(x)\n"); break; case 4: fprintferr("prime to d(L) part of d(g) not a square\n"); break; case 5: fprintferr("too small exponent of a prime factor in d(L)\n"); break; case 6: fprintferr("the d-th power of d(K) does not divide d(L)\n"); } switch(itos(CSF)) { case 0: case 2: goto CHANGE; } } else { if (DEBUGLEVEL) fprintferr("candidate = %Z\n",CSF); ESF = embedding_of_potential_subfields(nf,CSF,DATA,rootsA,delta); if (!ESF) avma = av2; else { if (DEBUGLEVEL) fprintferr("embedding = %Z\n",ESF); p1 = cgetg(3,t_VEC); p1[1] = (long)CSF; p1[2] = (long)ESF; p1 = _vec(p1); tetpil = avma; LSB = gerepile(av2,tetpil, concat(LSB, p1)); } } } for (i=1; i<llist; i++) free((void*)listpotbl[i]); delete_var(); free((void*)(listpotbl-1)); tetpil=avma; if (DEBUGLEVEL) fprintferr("\nSubfields of degree %ld: %Z\n",d, LSB); return gerepile(av,tetpil,gcopy(LSB));}

z=Flx_recipspec(x+2+lead,ld,ld); z=Flx_mulspec(z+2,mg+2,p,min(ld,lgpol(z)),lm); z=Flx_recipspec(z+2,lgpol(z),ld); z=Flx_mulspec(z+2,T+2,p,min(ld,lgpol(z)),lt);

z=Flx_recipspec(x+2+lead,ld,ld); z=Flx_mulspec(z+2,mg+2,p,lgpol(z),lm); z=Flx_recipspec(z+2,min(ld,lgpol(z)),ld); z=Flx_mulspec(z+2,T+2,p,lgpol(z),lt);

Flx_rem_montgomery(GEN x, GEN mg, GEN T, ulong p){ pari_sp ltop=avma; GEN z; long l=lgpol(x); long lt=degpol(T); /*We discard the leading term*/ long lead=lt-1; long ld=l-lt+1; long lm=min(ld,lgpol(mg)); if (l<=lt) return vecsmall_copy(x); new_chunk(lt); z=Flx_recipspec(x+2+lead,ld,ld); /* z = rec(x)*/ z=Flx_mulspec(z+2,mg+2,p,min(ld,lgpol(z)),lm);/* z = rec(x) * mg */ z=Flx_recipspec(z+2,lgpol(z),ld); /* z = rec (rec(x) * mg) */ z=Flx_mulspec(z+2,T+2,p,min(ld,lgpol(z)),lt); /* z *= pol */ avma=ltop; z=Flx_subspec(x+2,z+2,p,lt,min(lt,lgpol(z))); /* z = x - z */ z[1]=T[1]; return z;}

if ( diop == 0 ) return -1;

if ( diop == 0 ) { ret = -1; break; }

int fcntl( int fd, int cmd, ...){ va_list ap; rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; va_start( ap, cmd ); rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); /* * Now process the fcntl(). */ /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); if ( diop == 0 ) return -1; } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; return 0; case F_GETFD: /* get f_flags */ if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0; case F_SETFD: /* set f_flags */ /* * Interpret the third argument as the "close on exec()" flag. * If this argument is 1, then the file descriptor is to be closed * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; return 0; case F_GETFL: /* more flags (cloexec) */ return rtems_libio_to_fcntl_flags( iop->flags ); case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); /* * XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK)); /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = flags; return 0; case F_GETLK: return -1; case F_SETLK: return -1; case F_SETLKW: return -1; case F_SETOWN: /* for sockets. */ return -1; case F_GETOWN: /* for sockets. */ return -1; default: break; } return -1;}

return 0;

break;

int fcntl( int fd, int cmd, ...){ va_list ap; rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; va_start( ap, cmd ); rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); /* * Now process the fcntl(). */ /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); if ( diop == 0 ) return -1; } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; return 0; case F_GETFD: /* get f_flags */ if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0; case F_SETFD: /* set f_flags */ /* * Interpret the third argument as the "close on exec()" flag. * If this argument is 1, then the file descriptor is to be closed * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; return 0; case F_GETFL: /* more flags (cloexec) */ return rtems_libio_to_fcntl_flags( iop->flags ); case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); /* * XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK)); /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = flags; return 0; case F_GETLK: return -1; case F_SETLK: return -1; case F_SETLKW: return -1; case F_SETOWN: /* for sockets. */ return -1; case F_GETOWN: /* for sockets. */ return -1; default: break; } return -1;}

if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0;

ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); break;

int fcntl( int fd, int cmd, ...){ va_list ap; rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; va_start( ap, cmd ); rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); /* * Now process the fcntl(). */ /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); if ( diop == 0 ) return -1; } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; return 0; case F_GETFD: /* get f_flags */ if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0; case F_SETFD: /* set f_flags */ /* * Interpret the third argument as the "close on exec()" flag. * If this argument is 1, then the file descriptor is to be closed * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; return 0; case F_GETFL: /* more flags (cloexec) */ return rtems_libio_to_fcntl_flags( iop->flags ); case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); /* * XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK)); /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = flags; return 0; case F_GETLK: return -1; case F_SETLK: return -1; case F_SETLKW: return -1; case F_SETOWN: /* for sockets. */ return -1; case F_GETOWN: /* for sockets. */ return -1; default: break; } return -1;}

return rtems_libio_to_fcntl_flags( iop->flags );

ret = rtems_libio_to_fcntl_flags( iop->flags );

int fcntl( int fd, int cmd, ...){ va_list ap; rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; va_start( ap, cmd ); rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); /* * Now process the fcntl(). */ /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); if ( diop == 0 ) return -1; } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; return 0; case F_GETFD: /* get f_flags */ if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0; case F_SETFD: /* set f_flags */ /* * Interpret the third argument as the "close on exec()" flag. * If this argument is 1, then the file descriptor is to be closed * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; return 0; case F_GETFL: /* more flags (cloexec) */ return rtems_libio_to_fcntl_flags( iop->flags ); case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); /* * XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK)); /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = flags; return 0; case F_GETLK: return -1; case F_SETLK: return -1; case F_SETLKW: return -1; case F_SETOWN: /* for sockets. */ return -1; case F_GETOWN: /* for sockets. */ return -1; default: break; } return -1;}

* XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK));

int fcntl( int fd, int cmd, ...){ va_list ap; rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; va_start( ap, cmd ); rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); /* * Now process the fcntl(). */ /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); if ( diop == 0 ) return -1; } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; return 0; case F_GETFD: /* get f_flags */ if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0; case F_SETFD: /* set f_flags */ /* * Interpret the third argument as the "close on exec()" flag. * If this argument is 1, then the file descriptor is to be closed * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; return 0; case F_GETFL: /* more flags (cloexec) */ return rtems_libio_to_fcntl_flags( iop->flags ); case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); /* * XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK)); /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = flags; return 0; case F_GETLK: return -1; case F_SETLK: return -1; case F_SETLKW: return -1; case F_SETOWN: /* for sockets. */ return -1; case F_GETOWN: /* for sockets. */ return -1; default: break; } return -1;}

iop->flags = flags; return 0;

iop->flags = (iop->flags & ~(O_APPEND | O_NONBLOCK)) | (flags & (O_APPEND | O_NONBLOCK)); break;

int fcntl( int fd, int cmd, ...){ va_list ap; rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; va_start( ap, cmd ); rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); /* * Now process the fcntl(). */ /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); if ( diop == 0 ) return -1; } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; return 0; case F_GETFD: /* get f_flags */ if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0; case F_SETFD: /* set f_flags */ /* * Interpret the third argument as the "close on exec()" flag. * If this argument is 1, then the file descriptor is to be closed * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; return 0; case F_GETFL: /* more flags (cloexec) */ return rtems_libio_to_fcntl_flags( iop->flags ); case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); /* * XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK)); /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = flags; return 0; case F_GETLK: return -1; case F_SETLK: return -1; case F_SETLKW: return -1; case F_SETOWN: /* for sockets. */ return -1; case F_GETOWN: /* for sockets. */ return -1; default: break; } return -1;}

return -1;

errno = ENOTSUP; ret = -1; break;

int fcntl( int fd, int cmd, ...){ va_list ap; rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; va_start( ap, cmd ); rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); /* * Now process the fcntl(). */ /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); if ( diop == 0 ) return -1; } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; return 0; case F_GETFD: /* get f_flags */ if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0; case F_SETFD: /* set f_flags */ /* * Interpret the third argument as the "close on exec()" flag. * If this argument is 1, then the file descriptor is to be closed * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; return 0; case F_GETFL: /* more flags (cloexec) */ return rtems_libio_to_fcntl_flags( iop->flags ); case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); /* * XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK)); /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = flags; return 0; case F_GETLK: return -1; case F_SETLK: return -1; case F_SETLKW: return -1; case F_SETOWN: /* for sockets. */ return -1; case F_GETOWN: /* for sockets. */ return -1; default: break; } return -1;}

return -1;

if ((ret >= 0) && iop->handlers->fcntl) { int err = (*iop->handlers->fcntl)( cmd, iop ); if (err) { errno = err; ret = -1; } } return ret;

int fcntl( int fd, int cmd, ...){ va_list ap; rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; va_start( ap, cmd ); rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); /* * Now process the fcntl(). */ /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); if ( diop == 0 ) return -1; } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; return 0; case F_GETFD: /* get f_flags */ if ( iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC ) return 1; return 0; case F_SETFD: /* set f_flags */ /* * Interpret the third argument as the "close on exec()" flag. * If this argument is 1, then the file descriptor is to be closed * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; return 0; case F_GETFL: /* more flags (cloexec) */ return rtems_libio_to_fcntl_flags( iop->flags ); case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); /* * XXX Double check this in the POSIX spec. According to the Linux * XXX man page, only these flags can be added. */ flags = (iop->flags & ~(O_APPEND|O_NONBLOCK)) | (flags & (O_APPEND|O_NONBLOCK)); /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = flags; return 0; case F_GETLK: return -1; case F_SETLK: return -1; case F_SETLKW: return -1; case F_SETOWN: /* for sockets. */ return -1; case F_GETOWN: /* for sockets. */ return -1; default: break; } return -1;}

_Thread_Heir == _Thread_Executing)

_Thread_Heir == _Thread_Executing);

rtems_isr Clock_isr( rtems_vector_number vector){#ifdef CLOCK_DRIVER_USE_FAST_IDLE do { Clock_driver_ticks += 1; rtems_clock_tick(); } while ( _Thread_Executing == _Thread_Idle && _Thread_Heir == _Thread_Executing) Clock_driver_support_at_tick(); return;#else /* * Do the hardware specific per-tick action. * * The counter/timer may or may not be set to automatically reload. */ Clock_driver_support_at_tick(); /* * The driver has seen another tick. */ Clock_driver_ticks += 1; /* */#ifndef CLOCK_DRIVER_ISRS_ARE_ONE_MILLISECOND rtems_clock_tick();#else#error "Clock driver shell: Does not currently support counting mseconds."#endif#endif}

outport_byte ( TMRCFG , 0x80 ); outport_byte ( TMRCON , 0x34 ); outport_byte ( TMR0 , 0xA8 ); outport_byte ( TMR0 , 0x04 ); outport_byte ( TMRCFG , 0x00 );

outport_byte ( TMRCFG , 0x00 );

void ClockOn(const rtems_irq_connect_data* unused){ outport_byte ( TMRCFG , 0x80 ); outport_byte ( TMRCON , 0x34 ); outport_byte ( TMR0 , 0xA8 ); outport_byte ( TMR0 , 0x04 ); outport_byte ( TMRCFG , 0x00 ); }

rtems_unsigned32 s;

uint32_t s;

rtems_symbol_name_lookup( rtems_symbol_table_t *table, char *name ){ rtems_unsigned32 s; rtems_symbol_t *sp; if (table == 0) { table = rtems_monitor_symbols; if (table == 0) return NULL; } for (s = 0, sp = table->addresses; s < table->next; s++, sp++) { if ( strcasecmp(sp->name, name) == 0 ) return sp; } return NULL;}

rtems_unsigned32 value

uint32_t value

rtems_symbol_value_lookup( rtems_symbol_table_t *table, rtems_unsigned32 value ){ rtems_symbol_t *sp; rtems_symbol_t *base; rtems_symbol_t *best = 0; rtems_unsigned32 distance; rtems_unsigned32 best_distance = ~0; rtems_unsigned32 elements; if (table == 0) table = rtems_monitor_symbols; if ((table == 0) || (table->size == 0)) return 0; if (table->sorted == 0) rtems_symbol_sort(table); base = table->addresses; elements = table->next; while (elements) { sp = base + (elements / 2); if (value < sp->value) elements /= 2; else if (value > sp->value) { distance = value - sp->value; if (distance < best_distance) { best_distance = distance; best = sp; } base = sp + 1; elements = (elements / 2) - (elements % 2 ? 0 : 1); } else return sp; } if (value == base->value) return base; return best;}

rtems_unsigned32 distance; rtems_unsigned32 best_distance = ~0; rtems_unsigned32 elements;

uint32_t distance; uint32_t best_distance = ~0; uint32_t elements;

rtems_symbol_value_lookup( rtems_symbol_table_t *table, rtems_unsigned32 value ){ rtems_symbol_t *sp; rtems_symbol_t *base; rtems_symbol_t *best = 0; rtems_unsigned32 distance; rtems_unsigned32 best_distance = ~0; rtems_unsigned32 elements; if (table == 0) table = rtems_monitor_symbols; if ((table == 0) || (table->size == 0)) return 0; if (table->sorted == 0) rtems_symbol_sort(table); base = table->addresses; elements = table->next; while (elements) { sp = base + (elements / 2); if (value < sp->value) elements /= 2; else if (value > sp->value) { distance = value - sp->value; if (distance < best_distance) { best_distance = distance; best = sp; } base = sp + 1; elements = (elements / 2) - (elements % 2 ? 0 : 1); } else return sp; } if (value == base->value) return base; return best;}

rtems_unsigned32 s;

uint32_t s;

rtems_monitor_symbol_dump_all( rtems_symbol_table_t *table, boolean verbose){ rtems_unsigned32 s; rtems_symbol_t *sp; if (table == 0) { table = rtems_monitor_symbols; if (table == 0) return; } if (table->sorted == 0) rtems_symbol_sort(table); for (s = 0, sp = table->addresses; s < table->next; s++, sp++) { rtems_monitor_symbol_t canonical_symbol; rtems_monitor_symbol_canonical(&canonical_symbol, sp); rtems_monitor_symbol_dump(&canonical_symbol, TRUE); printf("\n"); }}

* trap 0 which we will use as a shutdown.

* trap 0 which we will use as a shutdown. Also avoid trap 0x70 - 0x7f * which cannot happen and where some of the space is used to pass * paramaters to the program.

void bsp_spurious_initialize(){ rtems_unsigned32 trap; for ( trap=0 ; trap<256 ; trap++ ) { /* * Skip window overflow, underflow, and flush as well as software * trap 0 which we will use as a shutdown. */ if ( trap == 5 || trap == 6 || trap == 0x83 || trap == 0x80) continue; set_vector( bsp_spurious_handler, SPARC_SYNCHRONOUS_TRAP( trap ), 1 ); }}

if ( trap == 5 || trap == 6 || trap == 0x83 || trap == 0x80)

if (( trap == 5 || trap == 6 || trap == 0x83 ) || (( trap >= 0x70 ) && ( trap <= 0x80 )))

void bsp_spurious_initialize(){ rtems_unsigned32 trap; for ( trap=0 ; trap<256 ; trap++ ) { /* * Skip window overflow, underflow, and flush as well as software * trap 0 which we will use as a shutdown. */ if ( trap == 5 || trap == 6 || trap == 0x83 || trap == 0x80) continue; set_vector( bsp_spurious_handler, SPARC_SYNCHRONOUS_TRAP( trap ), 1 ); }}

ERC32_MEC.Interrupt_Mask = mask; sparc_enable_interrupts(level);

void bsp_spurious_initialize(){ rtems_unsigned32 trap; for ( trap=0 ; trap<256 ; trap++ ) { /* * Skip window overflow, underflow, and flush as well as software * trap 0 which we will use as a shutdown. */ if ( trap == 5 || trap == 6 || trap == 0x83 || trap == 0x80) continue; set_vector( bsp_spurious_handler, SPARC_SYNCHRONOUS_TRAP( trap ), 1 ); }}

unsigned32 status

uint32_t status

void Stack_check_Fatal_extension( Internal_errors_Source source, boolean is_internal, unsigned32 status){#ifndef DONT_USE_FATAL_EXTENSION if (status == 0) Stack_check_Dump_usage();#endif}

unsigned32 *p;

uint32_t *p;

void Stack_check_Initialize( void ){#if 0 rtems_status_code status; Objects_Id id_ignored;#endif unsigned32 *p;#if 0 unsigned32 i; unsigned32 api_index; Thread_Control *the_thread; Objects_Information *information;#endif if (stack_check_initialized) return; /* * Dope the pattern and fill areas */ for ( p = Stack_check_Pattern.pattern; p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS]; p += 4 ) { p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */ p[1] = 0x0BAD0D06; p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */ p[3] = 0x600D0D06; };#if 0 status = rtems_extension_create( rtems_build_name( 'S', 'T', 'C', 'K' ), &Stack_check_Extension_table, &id_ignored ); assert ( status == RTEMS_SUCCESSFUL );#endif Stack_check_Blown_task = 0; /* * If installed by a task, that task will not get setup properly * since it missed out on the create hook. This will cause a * failure on first switch out of that task. * So pretend here that we actually ran create and begin extensions. */ /* XXX * * Technically this has not been done for any task created before this * happened. So just run through them and fix the situation. */#if 0 if (_Thread_Executing) { Stack_check_Create_extension(_Thread_Executing, _Thread_Executing); }#endif#if 0 for ( api_index = 1; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; Stack_check_Create_extension( the_thread, the_thread ); } } }#endif /* * If appropriate, setup the interrupt stack for high water testing * also. */#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) { stack_check_interrupt_stack.area = _CPU_Interrupt_stack_low; stack_check_interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - (char *) _CPU_Interrupt_stack_low; stack_check_dope_stack(&stack_check_interrupt_stack); }#endif#ifdef DONT_USE_FATAL_EXTENSION#ifdef RTEMS_DEBUG /* * this would normally be called by a fatal extension * handler, but we don't run fatal extensions unless * we fatal error. */ atexit(Stack_check_Dump_usage);#endif#endif stack_check_initialized = 1;}

unsigned32 i; unsigned32 api_index;

uint32_t i; uint32_t api_index;

void Stack_check_Initialize( void ){#if 0 rtems_status_code status; Objects_Id id_ignored;#endif unsigned32 *p;#if 0 unsigned32 i; unsigned32 api_index; Thread_Control *the_thread; Objects_Information *information;#endif if (stack_check_initialized) return; /* * Dope the pattern and fill areas */ for ( p = Stack_check_Pattern.pattern; p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS]; p += 4 ) { p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */ p[1] = 0x0BAD0D06; p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */ p[3] = 0x600D0D06; };#if 0 status = rtems_extension_create( rtems_build_name( 'S', 'T', 'C', 'K' ), &Stack_check_Extension_table, &id_ignored ); assert ( status == RTEMS_SUCCESSFUL );#endif Stack_check_Blown_task = 0; /* * If installed by a task, that task will not get setup properly * since it missed out on the create hook. This will cause a * failure on first switch out of that task. * So pretend here that we actually ran create and begin extensions. */ /* XXX * * Technically this has not been done for any task created before this * happened. So just run through them and fix the situation. */#if 0 if (_Thread_Executing) { Stack_check_Create_extension(_Thread_Executing, _Thread_Executing); }#endif#if 0 for ( api_index = 1; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; Stack_check_Create_extension( the_thread, the_thread ); } } }#endif /* * If appropriate, setup the interrupt stack for high water testing * also. */#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) { stack_check_interrupt_stack.area = _CPU_Interrupt_stack_low; stack_check_interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - (char *) _CPU_Interrupt_stack_low; stack_check_dope_stack(&stack_check_interrupt_stack); }#endif#ifdef DONT_USE_FATAL_EXTENSION#ifdef RTEMS_DEBUG /* * this would normally be called by a fatal extension * handler, but we don't run fatal extensions unless * we fatal error. */ atexit(Stack_check_Dump_usage);#endif#endif stack_check_initialized = 1;}

unsigned32 i; unsigned32 api_index;

uint32_t i; uint32_t api_index;

void Stack_check_Dump_usage( void ){ unsigned32 i; unsigned32 api_index; Thread_Control *the_thread; unsigned32 hit_running = 0; Objects_Information *information; if (stack_check_initialized == 0) return; printf("Stack usage by thread\n"); printf( " ID NAME LOW HIGH AVAILABLE USED\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; Stack_check_Dump_threads_usage( the_thread ); if ( the_thread == _Thread_Executing ) hit_running = 1; } } } if ( !hit_running ) Stack_check_Dump_threads_usage( _Thread_Executing ); /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1);}

unsigned32 hit_running = 0;

uint32_t hit_running = 0;

void Stack_check_Dump_usage( void ){ unsigned32 i; unsigned32 api_index; Thread_Control *the_thread; unsigned32 hit_running = 0; Objects_Information *information; if (stack_check_initialized == 0) return; printf("Stack usage by thread\n"); printf( " ID NAME LOW HIGH AVAILABLE USED\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; Stack_check_Dump_threads_usage( the_thread ); if ( the_thread == _Thread_Executing ) hit_running = 1; } } } if ( !hit_running ) Stack_check_Dump_threads_usage( _Thread_Executing ); /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1);}

unsigned32 vector,

uint32_t vector,

void _CPU_ISR_install_vector( unsigned32 vector, proc_ptr new_handler, proc_ptr *old_handler){ proc_ptr ignored; *old_handler = _ISR_Vector_table[ vector ]; _CPU_ISR_install_raw_handler( vector, _ISR_Handler, &ignored ); _ISR_Vector_table[ vector ] = new_handler;}

unsigned32 slot;

uint32_t slot;

void _CPU_Initialize( rtems_cpu_table *cpu_table, void (*thread_dispatch) /* ignored on this CPU */){#if ( M68K_HAS_VBR == 0 ) /* fill the isr redirect table with the code to place the format/id onto the stack */ unsigned32 slot; for (slot = 0; slot < CPU_INTERRUPT_NUMBER_OF_VECTORS; slot++) { _CPU_ISR_jump_table[slot].move_a7 = M68K_MOVE_A7; _CPU_ISR_jump_table[slot].format_id = slot << 2; _CPU_ISR_jump_table[slot].jmp = M68K_JMP; _CPU_ISR_jump_table[slot].isr_handler = (unsigned32) 0xDEADDEAD; }#endif /* M68K_HAS_VBR */ _CPU_Table = *cpu_table;}

_CPU_ISR_jump_table[slot].isr_handler = (unsigned32) 0xDEADDEAD;

_CPU_ISR_jump_table[slot].isr_handler = (uint32_t ) 0xDEADDEAD;

void _CPU_Initialize( rtems_cpu_table *cpu_table, void (*thread_dispatch) /* ignored on this CPU */){#if ( M68K_HAS_VBR == 0 ) /* fill the isr redirect table with the code to place the format/id onto the stack */ unsigned32 slot; for (slot = 0; slot < CPU_INTERRUPT_NUMBER_OF_VECTORS; slot++) { _CPU_ISR_jump_table[slot].move_a7 = M68K_MOVE_A7; _CPU_ISR_jump_table[slot].format_id = slot << 2; _CPU_ISR_jump_table[slot].jmp = M68K_JMP; _CPU_ISR_jump_table[slot].isr_handler = (unsigned32) 0xDEADDEAD; }#endif /* M68K_HAS_VBR */ _CPU_Table = *cpu_table;}

while(gcmp0((GEN)cff[k-1])) k--; setlg(cff, k); if (DEBUGLEVEL > 3) fprintferr(" coeff_of_phi_ms: %ld coefficients kept out of %ld\n", k-1, N);

coeff_of_phi_ms(ulong p, GEN q, long m, GEN s, long N, GEN vz){ GEN bn, cff = cgetg(N+1, t_VEC); long k, j, l; bn = new_chunk(N+2); /* bn[i] = binom(k, i), i <= k */ l = lg(q); for (k = 0; k <= N; k++) { GEN t = cgeti(l); affsi(1, t); bn[k] = (long)t; } for (k = 1; k <= N; k++) { pari_sp av2 = avma; GEN p1 = gzero, A = phi_ms(p, q, m, s, k, vz); for (j = k - 1; j > 0; j--) { GEN b = addii((GEN)bn[j], (GEN)bn[j-1]); if (cmpii(b, q) >= 0) b = subii(b, q); affii(b, (GEN)bn[j]); /* = binom(k, j+1) */ } for (j = 1; j < k; j++) p1 = addii(p1, mulii((GEN)bn[j], (GEN)cff[j])); cff[k] = (long)gerepileuptoint(av2, modii(subii(A, p1), q)); } return cff;}

0

timer_overhead

rtems_task Task_2( rtems_task_argument argument){#if (MUST_WAIT_FOR_INTERRUPT == 1) while ( Interrupt_occurred == 0 );#endif end_time = Read_timer(); put_time( "interrupt entry overhead: returns to preempting task", Interrupt_enter_time, 1, 0, 0 ); put_time( "interrupt exit overhead: returns to preempting task", end_time, 1, 0, 0 ); fflush( stdout ); /* * Switch back to the other task to exit the test. */ _Thread_Dispatch_disable_level = 0; _Thread_Heir = (rtems_tcb *) _Thread_Ready_chain[254].first; _Context_Switch_necessary = 1; _Thread_Dispatch();}

lx=lg(x); if (lx!=lg(x[1])) err(mattype1,"gtrace"); if (lx==1) return gzero;

lx=lg(x); if (lx==1) return gzero; if (lx!=lg(x[1])) err(mattype1,"gtrace");

gtrace(GEN x){ long i,l,n,tx=typ(x),lx,tetpil; GEN y,p1,p2; switch(tx) { case t_INT: case t_REAL: case t_FRAC: case t_FRACN: return gmul2n(x,1); case t_COMPLEX: return gmul2n((GEN)x[1],1); case t_QUAD: p1=(GEN)x[1]; if (!gcmp0((GEN) p1[3])) { l=avma; p2=gmul2n((GEN)x[2],1); tetpil=avma; return gerepile(l,tetpil,gadd((GEN)x[3],p2)); } return gmul2n((GEN)x[2],1); case t_POL: lx=lgef(x); y=cgetg(lx,tx); y[1]=x[1]; for (i=2; i<lx; i++) y[i]=ltrace((GEN)x[i]); return y; case t_SER: lx=lg(x); y=cgetg(lx,tx); y[1]=x[1]; for (i=2; i<lx; i++) y[i]=ltrace((GEN)x[i]); return y; case t_POLMOD: l=avma; n=(lgef(x[1])-4); p1=polsym((GEN)x[1],n); p2=gzero; for (i=0; i<=n; i++) p2=gadd(p2,gmul(truecoeff((GEN)x[2],i),(GEN)p1[i+1])); return gerepileupto(l,p2); case t_RFRAC: case t_RFRACN: return gadd(x,gconj(x)); case t_VEC: case t_COL: lx=lg(x); y=cgetg(lx,tx); for (i=1; i<lx; i++) y[i]=ltrace((GEN)x[i]); return y; case t_MAT: lx=lg(x); if (lx!=lg(x[1])) err(mattype1,"gtrace"); if (lx==1) return gzero;/*now lx>=2*/ l=avma; p1=gcoeff(x,1,1); if (lx==2) return gcopy(p1); for (i=2; i<lx-1; i++) p1=gadd(p1,gcoeff(x,i,i)); tetpil=avma; return gerepile(l,tetpil,gadd(p1,gcoeff(x,i,i))); } err(typeer,"gtrace"); return NULL; /* not reached */}

case 12: return (GEN)x[11]; case 6:

case 14: return (GEN)x[11];

_checkrnfeq(GEN x){ if (typ(x) == t_VEC) switch(lg(x)) { case 12: /* checkrnf(x); */ return (GEN)x[11]; case 6: /* rnf[11]. FIXME: change the rnf struct */ case 4: return x; } return NULL;}

unsigned int ret, noparen, has_pointer=0;

unsigned int ret, noparen, ind_pointer=0;

identifier(void){ long m, i, matchcomma, deriv; pari_sp av; char *ch1; entree *ep; GEN res, newfun, ptr; mark.identifier = analyseur; ep = entry(); if (EpVALENCE(ep)==EpVAR || EpVALENCE(ep)==EpGVAR) { /* optimized for simple variables */ switch (*analyseur) { case ')': case ',': return (GEN)ep->value; case '.': { long len, v; analyseur++; ch1 = analyseur; if ((res = read_member((GEN)ep->value))) { if (*analyseur == '[') { matcomp c; res = matcell(res, &c); } return res; } /* define a new member function */ v = varn(initial_value(ep)); len = analyseur - ch1; analyseur++; /* skip = */ ep = installep(NULL,ch1,len,EpMEMBER,0, members_hash + hashvalue(ch1)); ch1 = analyseur; skipseq(); len = analyseur-ch1; newfun=ptr= (GEN) newbloc(2 + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ *newfun++ = v; /* record text */ strncpy((char *)newfun, ch1, len); ((char *) newfun)[len] = 0; ep->value = (void *)ptr; return gnil; } } if (*analyseur != '[') { /* whole variable, no component */ F2GEN fun = affect_block(&res); if (res) { if (fun) res = fun((GEN)ep->value, res); changevalue(ep,res); } return (GEN)ep->value; } return matrix_block((GEN)ep->value); } ep = do_alias(ep);#ifdef STACK_CHECK if (PARI_stack_limit && (void*) &ptr <= PARI_stack_limit) err(talker2, "deep recursion", mark.identifier, mark.start);#endif if (ep->code) { char *s = ep->code, *oldanalyseur = NULL, *buf, *limit, *bp; unsigned int ret, noparen, has_pointer=0; long fake; void *call = ep->value; GEN argvec[9]; matcomp *init[9]; char *flags = NULL; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; if (*analyseur == '(') { analyseur++; noparen=0; /* expect matching ')' */ } else { /* if no mandatory argument, no () needed */ if (EpVALENCE(ep)) match('('); /* error */ if (!*s || (!s[1] && *s == 'p')) return ((GEN (*)(long))call)(prec); noparen=1; /* no argument, but valence is ok */ } /* return type */ if (*s < 'a') ret = RET_GEN; else if (*s == 'v') { ret = RET_VOID; s++; } else if (*s == 'i') { ret = RET_INT; s++; } else if (*s == 'l') { ret = RET_LONG; s++; } else ret = RET_GEN; /* Optimized for G and p. */ i = 0; matchcomma = 0; while (*s == 'G') { s++; match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); } if (*s == 'p') { argvec[i++] = (GEN) prec; s++; } while (*s && *s != '\n') switch (*s++) { case 'G': /* GEN */ match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); break; case 'L': /* long */ match_comma(); argvec[i++] = (GEN) readlong(); break; case 'n': /* var number */ match_comma(); argvec[i++] = (GEN) readvar(); break; case 'S': /* symbol */ match_comma(); mark.symbol=analyseur; argvec[i++] = (GEN)entry(); break; case 'V': /* variable */ match_comma(); mark.symbol=analyseur; { entree *e = entry(); long v = EpVALENCE(e); if (v != EpVAR && v != EpGVAR) err(talker2,"not a variable:",mark.symbol,mark.start); argvec[i++] = (GEN)e; break; } case '&': /* *GEN */ match_comma(); match('&'); mark.symbol=analyseur; { matcomp *c = (matcomp*)malloc(sizeof(matcomp)); entree *ep = entry(); if (*analyseur == '[') (void)matcell((GEN)ep->value, c); else { c->parent = NULL; c->ptcell = (GEN*)&ep->value; c->extra = (GEN*)ep->value; } has_pointer |= (1 << i); init[i] = c; argvec[i++] = (GEN)c->ptcell; break; } /* Input position */ case 'E': /* expr */ case 'I': /* seq */ match_comma(); argvec[i++] = (GEN) analyseur; skipseq(); break; case 'r': /* raw */ match_comma(); mark.raw = analyseur; bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; if (*analyseur == '"') bp = readstring_i(bp, &buf,&limit); else { if (bp > limit) bp = realloc_buf(bp,1, &buf,&limit); *bp++ = *analyseur++; } } *bp++ = 0; argvec[i++] = (GEN) buf; break; case 'M': /* Mnemonic flag */ match_comma(); ch1 = analyseur; argvec[i] = expr(); NO_BREAK("here (reading arguments)", ch1); if (typ(argvec[i]) == t_STR) { if (!flags) flags = ep->code; flags = strchr(flags, '\n'); /* Skip to the following '\n' */ if (!flags) err(talker, "not enough flags in string function signature"); flags++; argvec[i] = (GEN) parse_option_string((char*)(argvec[i] + 1), flags, PARSEMNU_ARG_WHITESP | PARSEMNU_TEMPL_TERM_NL, NULL, NULL); } else argvec[i] = (GEN)itos(argvec[i]); i++; break; case 's': /* expanded string; empty arg yields "" */ match_comma(); if (*s == '*') /* any number of string objects */ { argvec[i++] = any_string(); s++; break; } bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; bp = expand_string(bp, &buf,&limit); } *bp++ = 0; argvec[i++] = (GEN)buf; break; case 'p': /* precision */ argvec[i++] = (GEN) prec; break; case '=': match('='); matchcomma = 0; break; case 'D': /* Has a default value */ if (do_switch(noparen,matchcomma)) switch (*s) { case 'G': case '&': case 'I': case 'V': matchcomma=1; argvec[i++]=DFT_GEN; s++; break; case 'n': matchcomma=1; argvec[i++]=DFT_VAR; s++; break; default: oldanalyseur = analyseur; analyseur = s; matchcomma = 0; while (*s++ != ','); } else switch (*s) { case 'G': case '&': case 'I': case 'V': case 'n': break; default: while (*s++ != ','); } break; case 'P': /* series precision */ argvec[i++] = (GEN) precdl; break; case 'f': /* Fake *long argument */ argvec[i++] = (GEN) &fake; break; case 'x': /* Foreign function */ argvec[i++] = (GEN) ep; call = foreignHandler; break; case ',': /* Clean up default */ if (oldanalyseur) { analyseur = oldanalyseur; oldanalyseur = NULL; matchcomma=1; } break; default: err(bugparier,"identifier (unknown code)"); }#if 0 /* uncomment if using purify: UMR otherwise */ for ( ; i<9; i++) argvec[i]=NULL;#endif{ char *oldname = gp_function_name; gp_function_name = ep->name; if (deriv) { if (!i || (ep->code)[0] != 'G') err(talker2, "can't derive this", mark.identifier, mark.start); res = num_deriv(call, argvec); } else switch (ret) { case RET_GEN: res = ((PFGEN)call)(_ARGS_); break; case RET_INT: m = (long)((int (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_LONG: m = ((long (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_VOID: ((void (*)(ANYARG))call)(_ARGS_); res = gnil; break; } gp_function_name = oldname;} if (has_pointer) check_pointers(has_pointer,init); if (!noparen) match(')'); return res; } if (EpPREDEFINED(ep)) { if (*analyseur != '(') { if (EpVALENCE(ep) == 88) return global0(); match('('); /* error */ } analyseur++; ch1 = analyseur; switch(EpVALENCE(ep)) { case 50: /* O */ res = truc(); NO_BREAK("in O()", ch1); if (*analyseur=='^') { analyseur++; m = readlong(); } else m = 1; res = ggrando(res,m); break; case 80: /* if then else */ av = avma; res = expr(); NO_BREAK("in test expression", ch1); m = gcmp0(res); avma = av; match(','); if (m) /* false */ { skipseq(); if (*analyseur == ')') res = gnil; else { match(','); res = seq(); if (br_status) { res = NULL; skipseq(); } } } else /* true */ { res = seq(); if (br_status) { res = NULL; skipseq(); } if (*analyseur != ')') { match(','); skipseq(); } } break; case 81: /* while do */ av = avma; for(;;) { res = expr(); NO_BREAK("in test expression", ch1); if (gcmp0(res)) { match(','); break; } avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; } avma = av; skipseq(); res = gnil; break; case 82: /* repeat until */ av = avma; skipexpr(); for(;;) { avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; res = expr(); NO_BREAK("in test expression", ch1); if (!gcmp0(res)) { match(','); break; } } avma = av; skipseq(); res = gnil; break; case 88: /* global */ if (*analyseur == ')') return global0(); matchcomma = 0; while (*analyseur != ')') { match_comma(); ch1 = analyseur; check_var_name(); ep = skipentry(); switch(EpVALENCE(ep)) { case EpGVAR: case EpVAR: break; default: err(talker2,"symbol already in use",ch1,mark.start); } analyseur = ch1; ep = entry(); if (*analyseur == '=') { pari_sp av=avma; analyseur++; ch1 = analyseur; res = expr(); NO_BREAK("here (defining global var)", ch1); changevalue(ep, res); avma=av; } ep->valence = EpGVAR; } res = gnil; break; default: err(valencer1); return NULL; /* not reached */ } match(')'); return res; } switch (EpVALENCE(ep)) { GEN *defarg; /* = default args, and values for local variables */ GEN *arglist; gp_args *f; case EpUSER: /* user-defined functions */ f = (gp_args*)ep->args; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; arglist = (GEN*) new_chunk(f->narg); if (*analyseur != '(') /* no args */ { if (*analyseur != '=' || analyseur[1] == '=') { for (i=0; i<f->narg; i++) arglist[i] = make_arg(f->arg[i]); return call_fun((GEN)ep->value, arglist, f); } match('('); /* ==> error */ } analyseur++; /* skip '(' */ ch1 = analyseur; skip_arg_block(f); if (*analyseur == ')' && (analyseur[1] != '=' || analyseur[2] == '=')) { matchcomma = 0; analyseur = ch1; for (i=0; i<f->narg; i++) { if (do_switch(0,matchcomma)) { /* default arg */ arglist[i] = make_arg(f->arg[i]); matchcomma = 1; } else { /* user supplied */ char *old; match_comma(); old = analyseur; arglist[i] = expr(); NO_BREAK("here (reading function args)", old); } } analyseur++; /* skip ')' */ if (deriv) { if (!f->narg) err(talker2, "can't derive this", mark.identifier, mark.start); return num_derivU((GEN)ep->value, arglist, f); } return call_fun((GEN)ep->value, arglist, f); } /* REDEFINE function */ if (*analyseur != ',' && *analyseur != ')') skipexpr(); while (*analyseur == ',') { analyseur++; skipexpr(); } match(')'); if (*analyseur != '=' || analyseur[1] == '=') err(talker2,"too many parameters in user-defined function call", mark.identifier,mark.start); analyseur = ch1-1; /* points to '(' */ free_args((gp_args*)ep->args); free(ep->args); ep->args = NULL; ep->valence = EpNEW; /* Fall through */ case EpNEW: /* new function */ { GEN tmpargs = (GEN)avma; char *start; long len, narg, nloc; check_new_fun = ep; /* checking arguments */ narg = check_args(); nloc = 0; /* Dirty, but don't want to define a local() function */ if (*analyseur != '=' && strcmp(ep->name, "local") == 0) err(talker2, "local() bloc must appear before any other expression", mark.identifier,mark.start); match('='); { /* checking function definition */ skipping_fun_def++; while (strncmp(analyseur,"local(",6) == 0) { analyseur += 5; /* on '(' */ nloc += check_args(); while(separe(*analyseur)) analyseur++; } start = analyseur; skipseq(); len = analyseur-start; skipping_fun_def--; } /* function is ok. record it */ /* record default args */ f = (gp_args*) gpmalloc((narg+nloc)*sizeof(GEN) + sizeof(gp_args)); ep->args = (void*) f; f->nloc = nloc; f->narg = narg; f->arg = defarg = (GEN*)(f + 1); narg += nloc; /* record default args and local variables */ newfun = ptr = (GEN) newbloc(1 + narg + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ for (i = 1; i <= narg; i++) { GEN cell = tmpargs-(i<<1); *newfun++ = cell[0]; *defarg++ = (GEN)cell[1]; } if (narg > 1) { /* check for duplicates */ GEN x = new_chunk(narg), v = ptr+1; long k; for (i=0; i<narg; i++) x[i] = v[i]; qsort(x,narg,sizeof(long),(QSCOMP)pari_compare_long); for (k=x[0],i=1; i<narg; k=x[i],i++) if (x[i] == k) err(talker,"user function %s: variable %Z declared twice", ep->name, polx[k]); } /* record text */ strncpy((char *)newfun, start, len); ((char *) newfun)[len] = 0; /* wait till here for gunclone because of strncopy above. In pathological * cases, e.g. (f()=f()=x), new text is given by value of old one! */ if (EpVALENCE(ep) == EpUSER) gunclone((GEN)ep->value); ep->value = (void *)ptr; ep->valence = EpUSER; check_new_fun=NULL; avma = (pari_sp)tmpargs; return gnil; } } err(valencer1); return NULL; /* not reached */}

matcomp *init[9];

gp_pointer ptrs[9];

identifier(void){ long m, i, matchcomma, deriv; pari_sp av; char *ch1; entree *ep; GEN res, newfun, ptr; mark.identifier = analyseur; ep = entry(); if (EpVALENCE(ep)==EpVAR || EpVALENCE(ep)==EpGVAR) { /* optimized for simple variables */ switch (*analyseur) { case ')': case ',': return (GEN)ep->value; case '.': { long len, v; analyseur++; ch1 = analyseur; if ((res = read_member((GEN)ep->value))) { if (*analyseur == '[') { matcomp c; res = matcell(res, &c); } return res; } /* define a new member function */ v = varn(initial_value(ep)); len = analyseur - ch1; analyseur++; /* skip = */ ep = installep(NULL,ch1,len,EpMEMBER,0, members_hash + hashvalue(ch1)); ch1 = analyseur; skipseq(); len = analyseur-ch1; newfun=ptr= (GEN) newbloc(2 + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ *newfun++ = v; /* record text */ strncpy((char *)newfun, ch1, len); ((char *) newfun)[len] = 0; ep->value = (void *)ptr; return gnil; } } if (*analyseur != '[') { /* whole variable, no component */ F2GEN fun = affect_block(&res); if (res) { if (fun) res = fun((GEN)ep->value, res); changevalue(ep,res); } return (GEN)ep->value; } return matrix_block((GEN)ep->value); } ep = do_alias(ep);#ifdef STACK_CHECK if (PARI_stack_limit && (void*) &ptr <= PARI_stack_limit) err(talker2, "deep recursion", mark.identifier, mark.start);#endif if (ep->code) { char *s = ep->code, *oldanalyseur = NULL, *buf, *limit, *bp; unsigned int ret, noparen, has_pointer=0; long fake; void *call = ep->value; GEN argvec[9]; matcomp *init[9]; char *flags = NULL; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; if (*analyseur == '(') { analyseur++; noparen=0; /* expect matching ')' */ } else { /* if no mandatory argument, no () needed */ if (EpVALENCE(ep)) match('('); /* error */ if (!*s || (!s[1] && *s == 'p')) return ((GEN (*)(long))call)(prec); noparen=1; /* no argument, but valence is ok */ } /* return type */ if (*s < 'a') ret = RET_GEN; else if (*s == 'v') { ret = RET_VOID; s++; } else if (*s == 'i') { ret = RET_INT; s++; } else if (*s == 'l') { ret = RET_LONG; s++; } else ret = RET_GEN; /* Optimized for G and p. */ i = 0; matchcomma = 0; while (*s == 'G') { s++; match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); } if (*s == 'p') { argvec[i++] = (GEN) prec; s++; } while (*s && *s != '\n') switch (*s++) { case 'G': /* GEN */ match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); break; case 'L': /* long */ match_comma(); argvec[i++] = (GEN) readlong(); break; case 'n': /* var number */ match_comma(); argvec[i++] = (GEN) readvar(); break; case 'S': /* symbol */ match_comma(); mark.symbol=analyseur; argvec[i++] = (GEN)entry(); break; case 'V': /* variable */ match_comma(); mark.symbol=analyseur; { entree *e = entry(); long v = EpVALENCE(e); if (v != EpVAR && v != EpGVAR) err(talker2,"not a variable:",mark.symbol,mark.start); argvec[i++] = (GEN)e; break; } case '&': /* *GEN */ match_comma(); match('&'); mark.symbol=analyseur; { matcomp *c = (matcomp*)malloc(sizeof(matcomp)); entree *ep = entry(); if (*analyseur == '[') (void)matcell((GEN)ep->value, c); else { c->parent = NULL; c->ptcell = (GEN*)&ep->value; c->extra = (GEN*)ep->value; } has_pointer |= (1 << i); init[i] = c; argvec[i++] = (GEN)c->ptcell; break; } /* Input position */ case 'E': /* expr */ case 'I': /* seq */ match_comma(); argvec[i++] = (GEN) analyseur; skipseq(); break; case 'r': /* raw */ match_comma(); mark.raw = analyseur; bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; if (*analyseur == '"') bp = readstring_i(bp, &buf,&limit); else { if (bp > limit) bp = realloc_buf(bp,1, &buf,&limit); *bp++ = *analyseur++; } } *bp++ = 0; argvec[i++] = (GEN) buf; break; case 'M': /* Mnemonic flag */ match_comma(); ch1 = analyseur; argvec[i] = expr(); NO_BREAK("here (reading arguments)", ch1); if (typ(argvec[i]) == t_STR) { if (!flags) flags = ep->code; flags = strchr(flags, '\n'); /* Skip to the following '\n' */ if (!flags) err(talker, "not enough flags in string function signature"); flags++; argvec[i] = (GEN) parse_option_string((char*)(argvec[i] + 1), flags, PARSEMNU_ARG_WHITESP | PARSEMNU_TEMPL_TERM_NL, NULL, NULL); } else argvec[i] = (GEN)itos(argvec[i]); i++; break; case 's': /* expanded string; empty arg yields "" */ match_comma(); if (*s == '*') /* any number of string objects */ { argvec[i++] = any_string(); s++; break; } bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; bp = expand_string(bp, &buf,&limit); } *bp++ = 0; argvec[i++] = (GEN)buf; break; case 'p': /* precision */ argvec[i++] = (GEN) prec; break; case '=': match('='); matchcomma = 0; break; case 'D': /* Has a default value */ if (do_switch(noparen,matchcomma)) switch (*s) { case 'G': case '&': case 'I': case 'V': matchcomma=1; argvec[i++]=DFT_GEN; s++; break; case 'n': matchcomma=1; argvec[i++]=DFT_VAR; s++; break; default: oldanalyseur = analyseur; analyseur = s; matchcomma = 0; while (*s++ != ','); } else switch (*s) { case 'G': case '&': case 'I': case 'V': case 'n': break; default: while (*s++ != ','); } break; case 'P': /* series precision */ argvec[i++] = (GEN) precdl; break; case 'f': /* Fake *long argument */ argvec[i++] = (GEN) &fake; break; case 'x': /* Foreign function */ argvec[i++] = (GEN) ep; call = foreignHandler; break; case ',': /* Clean up default */ if (oldanalyseur) { analyseur = oldanalyseur; oldanalyseur = NULL; matchcomma=1; } break; default: err(bugparier,"identifier (unknown code)"); }#if 0 /* uncomment if using purify: UMR otherwise */ for ( ; i<9; i++) argvec[i]=NULL;#endif{ char *oldname = gp_function_name; gp_function_name = ep->name; if (deriv) { if (!i || (ep->code)[0] != 'G') err(talker2, "can't derive this", mark.identifier, mark.start); res = num_deriv(call, argvec); } else switch (ret) { case RET_GEN: res = ((PFGEN)call)(_ARGS_); break; case RET_INT: m = (long)((int (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_LONG: m = ((long (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_VOID: ((void (*)(ANYARG))call)(_ARGS_); res = gnil; break; } gp_function_name = oldname;} if (has_pointer) check_pointers(has_pointer,init); if (!noparen) match(')'); return res; } if (EpPREDEFINED(ep)) { if (*analyseur != '(') { if (EpVALENCE(ep) == 88) return global0(); match('('); /* error */ } analyseur++; ch1 = analyseur; switch(EpVALENCE(ep)) { case 50: /* O */ res = truc(); NO_BREAK("in O()", ch1); if (*analyseur=='^') { analyseur++; m = readlong(); } else m = 1; res = ggrando(res,m); break; case 80: /* if then else */ av = avma; res = expr(); NO_BREAK("in test expression", ch1); m = gcmp0(res); avma = av; match(','); if (m) /* false */ { skipseq(); if (*analyseur == ')') res = gnil; else { match(','); res = seq(); if (br_status) { res = NULL; skipseq(); } } } else /* true */ { res = seq(); if (br_status) { res = NULL; skipseq(); } if (*analyseur != ')') { match(','); skipseq(); } } break; case 81: /* while do */ av = avma; for(;;) { res = expr(); NO_BREAK("in test expression", ch1); if (gcmp0(res)) { match(','); break; } avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; } avma = av; skipseq(); res = gnil; break; case 82: /* repeat until */ av = avma; skipexpr(); for(;;) { avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; res = expr(); NO_BREAK("in test expression", ch1); if (!gcmp0(res)) { match(','); break; } } avma = av; skipseq(); res = gnil; break; case 88: /* global */ if (*analyseur == ')') return global0(); matchcomma = 0; while (*analyseur != ')') { match_comma(); ch1 = analyseur; check_var_name(); ep = skipentry(); switch(EpVALENCE(ep)) { case EpGVAR: case EpVAR: break; default: err(talker2,"symbol already in use",ch1,mark.start); } analyseur = ch1; ep = entry(); if (*analyseur == '=') { pari_sp av=avma; analyseur++; ch1 = analyseur; res = expr(); NO_BREAK("here (defining global var)", ch1); changevalue(ep, res); avma=av; } ep->valence = EpGVAR; } res = gnil; break; default: err(valencer1); return NULL; /* not reached */ } match(')'); return res; } switch (EpVALENCE(ep)) { GEN *defarg; /* = default args, and values for local variables */ GEN *arglist; gp_args *f; case EpUSER: /* user-defined functions */ f = (gp_args*)ep->args; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; arglist = (GEN*) new_chunk(f->narg); if (*analyseur != '(') /* no args */ { if (*analyseur != '=' || analyseur[1] == '=') { for (i=0; i<f->narg; i++) arglist[i] = make_arg(f->arg[i]); return call_fun((GEN)ep->value, arglist, f); } match('('); /* ==> error */ } analyseur++; /* skip '(' */ ch1 = analyseur; skip_arg_block(f); if (*analyseur == ')' && (analyseur[1] != '=' || analyseur[2] == '=')) { matchcomma = 0; analyseur = ch1; for (i=0; i<f->narg; i++) { if (do_switch(0,matchcomma)) { /* default arg */ arglist[i] = make_arg(f->arg[i]); matchcomma = 1; } else { /* user supplied */ char *old; match_comma(); old = analyseur; arglist[i] = expr(); NO_BREAK("here (reading function args)", old); } } analyseur++; /* skip ')' */ if (deriv) { if (!f->narg) err(talker2, "can't derive this", mark.identifier, mark.start); return num_derivU((GEN)ep->value, arglist, f); } return call_fun((GEN)ep->value, arglist, f); } /* REDEFINE function */ if (*analyseur != ',' && *analyseur != ')') skipexpr(); while (*analyseur == ',') { analyseur++; skipexpr(); } match(')'); if (*analyseur != '=' || analyseur[1] == '=') err(talker2,"too many parameters in user-defined function call", mark.identifier,mark.start); analyseur = ch1-1; /* points to '(' */ free_args((gp_args*)ep->args); free(ep->args); ep->args = NULL; ep->valence = EpNEW; /* Fall through */ case EpNEW: /* new function */ { GEN tmpargs = (GEN)avma; char *start; long len, narg, nloc; check_new_fun = ep; /* checking arguments */ narg = check_args(); nloc = 0; /* Dirty, but don't want to define a local() function */ if (*analyseur != '=' && strcmp(ep->name, "local") == 0) err(talker2, "local() bloc must appear before any other expression", mark.identifier,mark.start); match('='); { /* checking function definition */ skipping_fun_def++; while (strncmp(analyseur,"local(",6) == 0) { analyseur += 5; /* on '(' */ nloc += check_args(); while(separe(*analyseur)) analyseur++; } start = analyseur; skipseq(); len = analyseur-start; skipping_fun_def--; } /* function is ok. record it */ /* record default args */ f = (gp_args*) gpmalloc((narg+nloc)*sizeof(GEN) + sizeof(gp_args)); ep->args = (void*) f; f->nloc = nloc; f->narg = narg; f->arg = defarg = (GEN*)(f + 1); narg += nloc; /* record default args and local variables */ newfun = ptr = (GEN) newbloc(1 + narg + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ for (i = 1; i <= narg; i++) { GEN cell = tmpargs-(i<<1); *newfun++ = cell[0]; *defarg++ = (GEN)cell[1]; } if (narg > 1) { /* check for duplicates */ GEN x = new_chunk(narg), v = ptr+1; long k; for (i=0; i<narg; i++) x[i] = v[i]; qsort(x,narg,sizeof(long),(QSCOMP)pari_compare_long); for (k=x[0],i=1; i<narg; k=x[i],i++) if (x[i] == k) err(talker,"user function %s: variable %Z declared twice", ep->name, polx[k]); } /* record text */ strncpy((char *)newfun, start, len); ((char *) newfun)[len] = 0; /* wait till here for gunclone because of strncopy above. In pathological * cases, e.g. (f()=f()=x), new text is given by value of old one! */ if (EpVALENCE(ep) == EpUSER) gunclone((GEN)ep->value); ep->value = (void *)ptr; ep->valence = EpUSER; check_new_fun=NULL; avma = (pari_sp)tmpargs; return gnil; } } err(valencer1); return NULL; /* not reached */}

matcomp *c = (matcomp*)malloc(sizeof(matcomp));

identifier(void){ long m, i, matchcomma, deriv; pari_sp av; char *ch1; entree *ep; GEN res, newfun, ptr; mark.identifier = analyseur; ep = entry(); if (EpVALENCE(ep)==EpVAR || EpVALENCE(ep)==EpGVAR) { /* optimized for simple variables */ switch (*analyseur) { case ')': case ',': return (GEN)ep->value; case '.': { long len, v; analyseur++; ch1 = analyseur; if ((res = read_member((GEN)ep->value))) { if (*analyseur == '[') { matcomp c; res = matcell(res, &c); } return res; } /* define a new member function */ v = varn(initial_value(ep)); len = analyseur - ch1; analyseur++; /* skip = */ ep = installep(NULL,ch1,len,EpMEMBER,0, members_hash + hashvalue(ch1)); ch1 = analyseur; skipseq(); len = analyseur-ch1; newfun=ptr= (GEN) newbloc(2 + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ *newfun++ = v; /* record text */ strncpy((char *)newfun, ch1, len); ((char *) newfun)[len] = 0; ep->value = (void *)ptr; return gnil; } } if (*analyseur != '[') { /* whole variable, no component */ F2GEN fun = affect_block(&res); if (res) { if (fun) res = fun((GEN)ep->value, res); changevalue(ep,res); } return (GEN)ep->value; } return matrix_block((GEN)ep->value); } ep = do_alias(ep);#ifdef STACK_CHECK if (PARI_stack_limit && (void*) &ptr <= PARI_stack_limit) err(talker2, "deep recursion", mark.identifier, mark.start);#endif if (ep->code) { char *s = ep->code, *oldanalyseur = NULL, *buf, *limit, *bp; unsigned int ret, noparen, has_pointer=0; long fake; void *call = ep->value; GEN argvec[9]; matcomp *init[9]; char *flags = NULL; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; if (*analyseur == '(') { analyseur++; noparen=0; /* expect matching ')' */ } else { /* if no mandatory argument, no () needed */ if (EpVALENCE(ep)) match('('); /* error */ if (!*s || (!s[1] && *s == 'p')) return ((GEN (*)(long))call)(prec); noparen=1; /* no argument, but valence is ok */ } /* return type */ if (*s < 'a') ret = RET_GEN; else if (*s == 'v') { ret = RET_VOID; s++; } else if (*s == 'i') { ret = RET_INT; s++; } else if (*s == 'l') { ret = RET_LONG; s++; } else ret = RET_GEN; /* Optimized for G and p. */ i = 0; matchcomma = 0; while (*s == 'G') { s++; match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); } if (*s == 'p') { argvec[i++] = (GEN) prec; s++; } while (*s && *s != '\n') switch (*s++) { case 'G': /* GEN */ match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); break; case 'L': /* long */ match_comma(); argvec[i++] = (GEN) readlong(); break; case 'n': /* var number */ match_comma(); argvec[i++] = (GEN) readvar(); break; case 'S': /* symbol */ match_comma(); mark.symbol=analyseur; argvec[i++] = (GEN)entry(); break; case 'V': /* variable */ match_comma(); mark.symbol=analyseur; { entree *e = entry(); long v = EpVALENCE(e); if (v != EpVAR && v != EpGVAR) err(talker2,"not a variable:",mark.symbol,mark.start); argvec[i++] = (GEN)e; break; } case '&': /* *GEN */ match_comma(); match('&'); mark.symbol=analyseur; { matcomp *c = (matcomp*)malloc(sizeof(matcomp)); entree *ep = entry(); if (*analyseur == '[') (void)matcell((GEN)ep->value, c); else { c->parent = NULL; c->ptcell = (GEN*)&ep->value; c->extra = (GEN*)ep->value; } has_pointer |= (1 << i); init[i] = c; argvec[i++] = (GEN)c->ptcell; break; } /* Input position */ case 'E': /* expr */ case 'I': /* seq */ match_comma(); argvec[i++] = (GEN) analyseur; skipseq(); break; case 'r': /* raw */ match_comma(); mark.raw = analyseur; bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; if (*analyseur == '"') bp = readstring_i(bp, &buf,&limit); else { if (bp > limit) bp = realloc_buf(bp,1, &buf,&limit); *bp++ = *analyseur++; } } *bp++ = 0; argvec[i++] = (GEN) buf; break; case 'M': /* Mnemonic flag */ match_comma(); ch1 = analyseur; argvec[i] = expr(); NO_BREAK("here (reading arguments)", ch1); if (typ(argvec[i]) == t_STR) { if (!flags) flags = ep->code; flags = strchr(flags, '\n'); /* Skip to the following '\n' */ if (!flags) err(talker, "not enough flags in string function signature"); flags++; argvec[i] = (GEN) parse_option_string((char*)(argvec[i] + 1), flags, PARSEMNU_ARG_WHITESP | PARSEMNU_TEMPL_TERM_NL, NULL, NULL); } else argvec[i] = (GEN)itos(argvec[i]); i++; break; case 's': /* expanded string; empty arg yields "" */ match_comma(); if (*s == '*') /* any number of string objects */ { argvec[i++] = any_string(); s++; break; } bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; bp = expand_string(bp, &buf,&limit); } *bp++ = 0; argvec[i++] = (GEN)buf; break; case 'p': /* precision */ argvec[i++] = (GEN) prec; break; case '=': match('='); matchcomma = 0; break; case 'D': /* Has a default value */ if (do_switch(noparen,matchcomma)) switch (*s) { case 'G': case '&': case 'I': case 'V': matchcomma=1; argvec[i++]=DFT_GEN; s++; break; case 'n': matchcomma=1; argvec[i++]=DFT_VAR; s++; break; default: oldanalyseur = analyseur; analyseur = s; matchcomma = 0; while (*s++ != ','); } else switch (*s) { case 'G': case '&': case 'I': case 'V': case 'n': break; default: while (*s++ != ','); } break; case 'P': /* series precision */ argvec[i++] = (GEN) precdl; break; case 'f': /* Fake *long argument */ argvec[i++] = (GEN) &fake; break; case 'x': /* Foreign function */ argvec[i++] = (GEN) ep; call = foreignHandler; break; case ',': /* Clean up default */ if (oldanalyseur) { analyseur = oldanalyseur; oldanalyseur = NULL; matchcomma=1; } break; default: err(bugparier,"identifier (unknown code)"); }#if 0 /* uncomment if using purify: UMR otherwise */ for ( ; i<9; i++) argvec[i]=NULL;#endif{ char *oldname = gp_function_name; gp_function_name = ep->name; if (deriv) { if (!i || (ep->code)[0] != 'G') err(talker2, "can't derive this", mark.identifier, mark.start); res = num_deriv(call, argvec); } else switch (ret) { case RET_GEN: res = ((PFGEN)call)(_ARGS_); break; case RET_INT: m = (long)((int (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_LONG: m = ((long (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_VOID: ((void (*)(ANYARG))call)(_ARGS_); res = gnil; break; } gp_function_name = oldname;} if (has_pointer) check_pointers(has_pointer,init); if (!noparen) match(')'); return res; } if (EpPREDEFINED(ep)) { if (*analyseur != '(') { if (EpVALENCE(ep) == 88) return global0(); match('('); /* error */ } analyseur++; ch1 = analyseur; switch(EpVALENCE(ep)) { case 50: /* O */ res = truc(); NO_BREAK("in O()", ch1); if (*analyseur=='^') { analyseur++; m = readlong(); } else m = 1; res = ggrando(res,m); break; case 80: /* if then else */ av = avma; res = expr(); NO_BREAK("in test expression", ch1); m = gcmp0(res); avma = av; match(','); if (m) /* false */ { skipseq(); if (*analyseur == ')') res = gnil; else { match(','); res = seq(); if (br_status) { res = NULL; skipseq(); } } } else /* true */ { res = seq(); if (br_status) { res = NULL; skipseq(); } if (*analyseur != ')') { match(','); skipseq(); } } break; case 81: /* while do */ av = avma; for(;;) { res = expr(); NO_BREAK("in test expression", ch1); if (gcmp0(res)) { match(','); break; } avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; } avma = av; skipseq(); res = gnil; break; case 82: /* repeat until */ av = avma; skipexpr(); for(;;) { avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; res = expr(); NO_BREAK("in test expression", ch1); if (!gcmp0(res)) { match(','); break; } } avma = av; skipseq(); res = gnil; break; case 88: /* global */ if (*analyseur == ')') return global0(); matchcomma = 0; while (*analyseur != ')') { match_comma(); ch1 = analyseur; check_var_name(); ep = skipentry(); switch(EpVALENCE(ep)) { case EpGVAR: case EpVAR: break; default: err(talker2,"symbol already in use",ch1,mark.start); } analyseur = ch1; ep = entry(); if (*analyseur == '=') { pari_sp av=avma; analyseur++; ch1 = analyseur; res = expr(); NO_BREAK("here (defining global var)", ch1); changevalue(ep, res); avma=av; } ep->valence = EpGVAR; } res = gnil; break; default: err(valencer1); return NULL; /* not reached */ } match(')'); return res; } switch (EpVALENCE(ep)) { GEN *defarg; /* = default args, and values for local variables */ GEN *arglist; gp_args *f; case EpUSER: /* user-defined functions */ f = (gp_args*)ep->args; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; arglist = (GEN*) new_chunk(f->narg); if (*analyseur != '(') /* no args */ { if (*analyseur != '=' || analyseur[1] == '=') { for (i=0; i<f->narg; i++) arglist[i] = make_arg(f->arg[i]); return call_fun((GEN)ep->value, arglist, f); } match('('); /* ==> error */ } analyseur++; /* skip '(' */ ch1 = analyseur; skip_arg_block(f); if (*analyseur == ')' && (analyseur[1] != '=' || analyseur[2] == '=')) { matchcomma = 0; analyseur = ch1; for (i=0; i<f->narg; i++) { if (do_switch(0,matchcomma)) { /* default arg */ arglist[i] = make_arg(f->arg[i]); matchcomma = 1; } else { /* user supplied */ char *old; match_comma(); old = analyseur; arglist[i] = expr(); NO_BREAK("here (reading function args)", old); } } analyseur++; /* skip ')' */ if (deriv) { if (!f->narg) err(talker2, "can't derive this", mark.identifier, mark.start); return num_derivU((GEN)ep->value, arglist, f); } return call_fun((GEN)ep->value, arglist, f); } /* REDEFINE function */ if (*analyseur != ',' && *analyseur != ')') skipexpr(); while (*analyseur == ',') { analyseur++; skipexpr(); } match(')'); if (*analyseur != '=' || analyseur[1] == '=') err(talker2,"too many parameters in user-defined function call", mark.identifier,mark.start); analyseur = ch1-1; /* points to '(' */ free_args((gp_args*)ep->args); free(ep->args); ep->args = NULL; ep->valence = EpNEW; /* Fall through */ case EpNEW: /* new function */ { GEN tmpargs = (GEN)avma; char *start; long len, narg, nloc; check_new_fun = ep; /* checking arguments */ narg = check_args(); nloc = 0; /* Dirty, but don't want to define a local() function */ if (*analyseur != '=' && strcmp(ep->name, "local") == 0) err(talker2, "local() bloc must appear before any other expression", mark.identifier,mark.start); match('='); { /* checking function definition */ skipping_fun_def++; while (strncmp(analyseur,"local(",6) == 0) { analyseur += 5; /* on '(' */ nloc += check_args(); while(separe(*analyseur)) analyseur++; } start = analyseur; skipseq(); len = analyseur-start; skipping_fun_def--; } /* function is ok. record it */ /* record default args */ f = (gp_args*) gpmalloc((narg+nloc)*sizeof(GEN) + sizeof(gp_args)); ep->args = (void*) f; f->nloc = nloc; f->narg = narg; f->arg = defarg = (GEN*)(f + 1); narg += nloc; /* record default args and local variables */ newfun = ptr = (GEN) newbloc(1 + narg + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ for (i = 1; i <= narg; i++) { GEN cell = tmpargs-(i<<1); *newfun++ = cell[0]; *defarg++ = (GEN)cell[1]; } if (narg > 1) { /* check for duplicates */ GEN x = new_chunk(narg), v = ptr+1; long k; for (i=0; i<narg; i++) x[i] = v[i]; qsort(x,narg,sizeof(long),(QSCOMP)pari_compare_long); for (k=x[0],i=1; i<narg; k=x[i],i++) if (x[i] == k) err(talker,"user function %s: variable %Z declared twice", ep->name, polx[k]); } /* record text */ strncpy((char *)newfun, start, len); ((char *) newfun)[len] = 0; /* wait till here for gunclone because of strncopy above. In pathological * cases, e.g. (f()=f()=x), new text is given by value of old one! */ if (EpVALENCE(ep) == EpUSER) gunclone((GEN)ep->value); ep->value = (void *)ptr; ep->valence = EpUSER; check_new_fun=NULL; avma = (pari_sp)tmpargs; return gnil; } } err(valencer1); return NULL; /* not reached */}

if (*analyseur == '[') (void)matcell((GEN)ep->value, c);

gp_pointer *g = &ptrs[ind_pointer++]; if (*analyseur == '[') { (void)matcell((GEN)ep->value, &(g->c)); g->ep = NULL; }

identifier(void){ long m, i, matchcomma, deriv; pari_sp av; char *ch1; entree *ep; GEN res, newfun, ptr; mark.identifier = analyseur; ep = entry(); if (EpVALENCE(ep)==EpVAR || EpVALENCE(ep)==EpGVAR) { /* optimized for simple variables */ switch (*analyseur) { case ')': case ',': return (GEN)ep->value; case '.': { long len, v; analyseur++; ch1 = analyseur; if ((res = read_member((GEN)ep->value))) { if (*analyseur == '[') { matcomp c; res = matcell(res, &c); } return res; } /* define a new member function */ v = varn(initial_value(ep)); len = analyseur - ch1; analyseur++; /* skip = */ ep = installep(NULL,ch1,len,EpMEMBER,0, members_hash + hashvalue(ch1)); ch1 = analyseur; skipseq(); len = analyseur-ch1; newfun=ptr= (GEN) newbloc(2 + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ *newfun++ = v; /* record text */ strncpy((char *)newfun, ch1, len); ((char *) newfun)[len] = 0; ep->value = (void *)ptr; return gnil; } } if (*analyseur != '[') { /* whole variable, no component */ F2GEN fun = affect_block(&res); if (res) { if (fun) res = fun((GEN)ep->value, res); changevalue(ep,res); } return (GEN)ep->value; } return matrix_block((GEN)ep->value); } ep = do_alias(ep);#ifdef STACK_CHECK if (PARI_stack_limit && (void*) &ptr <= PARI_stack_limit) err(talker2, "deep recursion", mark.identifier, mark.start);#endif if (ep->code) { char *s = ep->code, *oldanalyseur = NULL, *buf, *limit, *bp; unsigned int ret, noparen, has_pointer=0; long fake; void *call = ep->value; GEN argvec[9]; matcomp *init[9]; char *flags = NULL; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; if (*analyseur == '(') { analyseur++; noparen=0; /* expect matching ')' */ } else { /* if no mandatory argument, no () needed */ if (EpVALENCE(ep)) match('('); /* error */ if (!*s || (!s[1] && *s == 'p')) return ((GEN (*)(long))call)(prec); noparen=1; /* no argument, but valence is ok */ } /* return type */ if (*s < 'a') ret = RET_GEN; else if (*s == 'v') { ret = RET_VOID; s++; } else if (*s == 'i') { ret = RET_INT; s++; } else if (*s == 'l') { ret = RET_LONG; s++; } else ret = RET_GEN; /* Optimized for G and p. */ i = 0; matchcomma = 0; while (*s == 'G') { s++; match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); } if (*s == 'p') { argvec[i++] = (GEN) prec; s++; } while (*s && *s != '\n') switch (*s++) { case 'G': /* GEN */ match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); break; case 'L': /* long */ match_comma(); argvec[i++] = (GEN) readlong(); break; case 'n': /* var number */ match_comma(); argvec[i++] = (GEN) readvar(); break; case 'S': /* symbol */ match_comma(); mark.symbol=analyseur; argvec[i++] = (GEN)entry(); break; case 'V': /* variable */ match_comma(); mark.symbol=analyseur; { entree *e = entry(); long v = EpVALENCE(e); if (v != EpVAR && v != EpGVAR) err(talker2,"not a variable:",mark.symbol,mark.start); argvec[i++] = (GEN)e; break; } case '&': /* *GEN */ match_comma(); match('&'); mark.symbol=analyseur; { matcomp *c = (matcomp*)malloc(sizeof(matcomp)); entree *ep = entry(); if (*analyseur == '[') (void)matcell((GEN)ep->value, c); else { c->parent = NULL; c->ptcell = (GEN*)&ep->value; c->extra = (GEN*)ep->value; } has_pointer |= (1 << i); init[i] = c; argvec[i++] = (GEN)c->ptcell; break; } /* Input position */ case 'E': /* expr */ case 'I': /* seq */ match_comma(); argvec[i++] = (GEN) analyseur; skipseq(); break; case 'r': /* raw */ match_comma(); mark.raw = analyseur; bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; if (*analyseur == '"') bp = readstring_i(bp, &buf,&limit); else { if (bp > limit) bp = realloc_buf(bp,1, &buf,&limit); *bp++ = *analyseur++; } } *bp++ = 0; argvec[i++] = (GEN) buf; break; case 'M': /* Mnemonic flag */ match_comma(); ch1 = analyseur; argvec[i] = expr(); NO_BREAK("here (reading arguments)", ch1); if (typ(argvec[i]) == t_STR) { if (!flags) flags = ep->code; flags = strchr(flags, '\n'); /* Skip to the following '\n' */ if (!flags) err(talker, "not enough flags in string function signature"); flags++; argvec[i] = (GEN) parse_option_string((char*)(argvec[i] + 1), flags, PARSEMNU_ARG_WHITESP | PARSEMNU_TEMPL_TERM_NL, NULL, NULL); } else argvec[i] = (GEN)itos(argvec[i]); i++; break; case 's': /* expanded string; empty arg yields "" */ match_comma(); if (*s == '*') /* any number of string objects */ { argvec[i++] = any_string(); s++; break; } bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; bp = expand_string(bp, &buf,&limit); } *bp++ = 0; argvec[i++] = (GEN)buf; break; case 'p': /* precision */ argvec[i++] = (GEN) prec; break; case '=': match('='); matchcomma = 0; break; case 'D': /* Has a default value */ if (do_switch(noparen,matchcomma)) switch (*s) { case 'G': case '&': case 'I': case 'V': matchcomma=1; argvec[i++]=DFT_GEN; s++; break; case 'n': matchcomma=1; argvec[i++]=DFT_VAR; s++; break; default: oldanalyseur = analyseur; analyseur = s; matchcomma = 0; while (*s++ != ','); } else switch (*s) { case 'G': case '&': case 'I': case 'V': case 'n': break; default: while (*s++ != ','); } break; case 'P': /* series precision */ argvec[i++] = (GEN) precdl; break; case 'f': /* Fake *long argument */ argvec[i++] = (GEN) &fake; break; case 'x': /* Foreign function */ argvec[i++] = (GEN) ep; call = foreignHandler; break; case ',': /* Clean up default */ if (oldanalyseur) { analyseur = oldanalyseur; oldanalyseur = NULL; matchcomma=1; } break; default: err(bugparier,"identifier (unknown code)"); }#if 0 /* uncomment if using purify: UMR otherwise */ for ( ; i<9; i++) argvec[i]=NULL;#endif{ char *oldname = gp_function_name; gp_function_name = ep->name; if (deriv) { if (!i || (ep->code)[0] != 'G') err(talker2, "can't derive this", mark.identifier, mark.start); res = num_deriv(call, argvec); } else switch (ret) { case RET_GEN: res = ((PFGEN)call)(_ARGS_); break; case RET_INT: m = (long)((int (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_LONG: m = ((long (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_VOID: ((void (*)(ANYARG))call)(_ARGS_); res = gnil; break; } gp_function_name = oldname;} if (has_pointer) check_pointers(has_pointer,init); if (!noparen) match(')'); return res; } if (EpPREDEFINED(ep)) { if (*analyseur != '(') { if (EpVALENCE(ep) == 88) return global0(); match('('); /* error */ } analyseur++; ch1 = analyseur; switch(EpVALENCE(ep)) { case 50: /* O */ res = truc(); NO_BREAK("in O()", ch1); if (*analyseur=='^') { analyseur++; m = readlong(); } else m = 1; res = ggrando(res,m); break; case 80: /* if then else */ av = avma; res = expr(); NO_BREAK("in test expression", ch1); m = gcmp0(res); avma = av; match(','); if (m) /* false */ { skipseq(); if (*analyseur == ')') res = gnil; else { match(','); res = seq(); if (br_status) { res = NULL; skipseq(); } } } else /* true */ { res = seq(); if (br_status) { res = NULL; skipseq(); } if (*analyseur != ')') { match(','); skipseq(); } } break; case 81: /* while do */ av = avma; for(;;) { res = expr(); NO_BREAK("in test expression", ch1); if (gcmp0(res)) { match(','); break; } avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; } avma = av; skipseq(); res = gnil; break; case 82: /* repeat until */ av = avma; skipexpr(); for(;;) { avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; res = expr(); NO_BREAK("in test expression", ch1); if (!gcmp0(res)) { match(','); break; } } avma = av; skipseq(); res = gnil; break; case 88: /* global */ if (*analyseur == ')') return global0(); matchcomma = 0; while (*analyseur != ')') { match_comma(); ch1 = analyseur; check_var_name(); ep = skipentry(); switch(EpVALENCE(ep)) { case EpGVAR: case EpVAR: break; default: err(talker2,"symbol already in use",ch1,mark.start); } analyseur = ch1; ep = entry(); if (*analyseur == '=') { pari_sp av=avma; analyseur++; ch1 = analyseur; res = expr(); NO_BREAK("here (defining global var)", ch1); changevalue(ep, res); avma=av; } ep->valence = EpGVAR; } res = gnil; break; default: err(valencer1); return NULL; /* not reached */ } match(')'); return res; } switch (EpVALENCE(ep)) { GEN *defarg; /* = default args, and values for local variables */ GEN *arglist; gp_args *f; case EpUSER: /* user-defined functions */ f = (gp_args*)ep->args; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; arglist = (GEN*) new_chunk(f->narg); if (*analyseur != '(') /* no args */ { if (*analyseur != '=' || analyseur[1] == '=') { for (i=0; i<f->narg; i++) arglist[i] = make_arg(f->arg[i]); return call_fun((GEN)ep->value, arglist, f); } match('('); /* ==> error */ } analyseur++; /* skip '(' */ ch1 = analyseur; skip_arg_block(f); if (*analyseur == ')' && (analyseur[1] != '=' || analyseur[2] == '=')) { matchcomma = 0; analyseur = ch1; for (i=0; i<f->narg; i++) { if (do_switch(0,matchcomma)) { /* default arg */ arglist[i] = make_arg(f->arg[i]); matchcomma = 1; } else { /* user supplied */ char *old; match_comma(); old = analyseur; arglist[i] = expr(); NO_BREAK("here (reading function args)", old); } } analyseur++; /* skip ')' */ if (deriv) { if (!f->narg) err(talker2, "can't derive this", mark.identifier, mark.start); return num_derivU((GEN)ep->value, arglist, f); } return call_fun((GEN)ep->value, arglist, f); } /* REDEFINE function */ if (*analyseur != ',' && *analyseur != ')') skipexpr(); while (*analyseur == ',') { analyseur++; skipexpr(); } match(')'); if (*analyseur != '=' || analyseur[1] == '=') err(talker2,"too many parameters in user-defined function call", mark.identifier,mark.start); analyseur = ch1-1; /* points to '(' */ free_args((gp_args*)ep->args); free(ep->args); ep->args = NULL; ep->valence = EpNEW; /* Fall through */ case EpNEW: /* new function */ { GEN tmpargs = (GEN)avma; char *start; long len, narg, nloc; check_new_fun = ep; /* checking arguments */ narg = check_args(); nloc = 0; /* Dirty, but don't want to define a local() function */ if (*analyseur != '=' && strcmp(ep->name, "local") == 0) err(talker2, "local() bloc must appear before any other expression", mark.identifier,mark.start); match('='); { /* checking function definition */ skipping_fun_def++; while (strncmp(analyseur,"local(",6) == 0) { analyseur += 5; /* on '(' */ nloc += check_args(); while(separe(*analyseur)) analyseur++; } start = analyseur; skipseq(); len = analyseur-start; skipping_fun_def--; } /* function is ok. record it */ /* record default args */ f = (gp_args*) gpmalloc((narg+nloc)*sizeof(GEN) + sizeof(gp_args)); ep->args = (void*) f; f->nloc = nloc; f->narg = narg; f->arg = defarg = (GEN*)(f + 1); narg += nloc; /* record default args and local variables */ newfun = ptr = (GEN) newbloc(1 + narg + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ for (i = 1; i <= narg; i++) { GEN cell = tmpargs-(i<<1); *newfun++ = cell[0]; *defarg++ = (GEN)cell[1]; } if (narg > 1) { /* check for duplicates */ GEN x = new_chunk(narg), v = ptr+1; long k; for (i=0; i<narg; i++) x[i] = v[i]; qsort(x,narg,sizeof(long),(QSCOMP)pari_compare_long); for (k=x[0],i=1; i<narg; k=x[i],i++) if (x[i] == k) err(talker,"user function %s: variable %Z declared twice", ep->name, polx[k]); } /* record text */ strncpy((char *)newfun, start, len); ((char *) newfun)[len] = 0; /* wait till here for gunclone because of strncopy above. In pathological * cases, e.g. (f()=f()=x), new text is given by value of old one! */ if (EpVALENCE(ep) == EpUSER) gunclone((GEN)ep->value); ep->value = (void *)ptr; ep->valence = EpUSER; check_new_fun=NULL; avma = (pari_sp)tmpargs; return gnil; } } err(valencer1); return NULL; /* not reached */}

{ c->parent = NULL; c->ptcell = (GEN*)&ep->value; c->extra = (GEN*)ep->value; } has_pointer |= (1 << i); init[i] = c; argvec[i++] = (GEN)c->ptcell; break;

g->ep = ep; argvec[i++] = (GEN)&(g->x); break;

identifier(void){ long m, i, matchcomma, deriv; pari_sp av; char *ch1; entree *ep; GEN res, newfun, ptr; mark.identifier = analyseur; ep = entry(); if (EpVALENCE(ep)==EpVAR || EpVALENCE(ep)==EpGVAR) { /* optimized for simple variables */ switch (*analyseur) { case ')': case ',': return (GEN)ep->value; case '.': { long len, v; analyseur++; ch1 = analyseur; if ((res = read_member((GEN)ep->value))) { if (*analyseur == '[') { matcomp c; res = matcell(res, &c); } return res; } /* define a new member function */ v = varn(initial_value(ep)); len = analyseur - ch1; analyseur++; /* skip = */ ep = installep(NULL,ch1,len,EpMEMBER,0, members_hash + hashvalue(ch1)); ch1 = analyseur; skipseq(); len = analyseur-ch1; newfun=ptr= (GEN) newbloc(2 + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ *newfun++ = v; /* record text */ strncpy((char *)newfun, ch1, len); ((char *) newfun)[len] = 0; ep->value = (void *)ptr; return gnil; } } if (*analyseur != '[') { /* whole variable, no component */ F2GEN fun = affect_block(&res); if (res) { if (fun) res = fun((GEN)ep->value, res); changevalue(ep,res); } return (GEN)ep->value; } return matrix_block((GEN)ep->value); } ep = do_alias(ep);#ifdef STACK_CHECK if (PARI_stack_limit && (void*) &ptr <= PARI_stack_limit) err(talker2, "deep recursion", mark.identifier, mark.start);#endif if (ep->code) { char *s = ep->code, *oldanalyseur = NULL, *buf, *limit, *bp; unsigned int ret, noparen, has_pointer=0; long fake; void *call = ep->value; GEN argvec[9]; matcomp *init[9]; char *flags = NULL; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; if (*analyseur == '(') { analyseur++; noparen=0; /* expect matching ')' */ } else { /* if no mandatory argument, no () needed */ if (EpVALENCE(ep)) match('('); /* error */ if (!*s || (!s[1] && *s == 'p')) return ((GEN (*)(long))call)(prec); noparen=1; /* no argument, but valence is ok */ } /* return type */ if (*s < 'a') ret = RET_GEN; else if (*s == 'v') { ret = RET_VOID; s++; } else if (*s == 'i') { ret = RET_INT; s++; } else if (*s == 'l') { ret = RET_LONG; s++; } else ret = RET_GEN; /* Optimized for G and p. */ i = 0; matchcomma = 0; while (*s == 'G') { s++; match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); } if (*s == 'p') { argvec[i++] = (GEN) prec; s++; } while (*s && *s != '\n') switch (*s++) { case 'G': /* GEN */ match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); break; case 'L': /* long */ match_comma(); argvec[i++] = (GEN) readlong(); break; case 'n': /* var number */ match_comma(); argvec[i++] = (GEN) readvar(); break; case 'S': /* symbol */ match_comma(); mark.symbol=analyseur; argvec[i++] = (GEN)entry(); break; case 'V': /* variable */ match_comma(); mark.symbol=analyseur; { entree *e = entry(); long v = EpVALENCE(e); if (v != EpVAR && v != EpGVAR) err(talker2,"not a variable:",mark.symbol,mark.start); argvec[i++] = (GEN)e; break; } case '&': /* *GEN */ match_comma(); match('&'); mark.symbol=analyseur; { matcomp *c = (matcomp*)malloc(sizeof(matcomp)); entree *ep = entry(); if (*analyseur == '[') (void)matcell((GEN)ep->value, c); else { c->parent = NULL; c->ptcell = (GEN*)&ep->value; c->extra = (GEN*)ep->value; } has_pointer |= (1 << i); init[i] = c; argvec[i++] = (GEN)c->ptcell; break; } /* Input position */ case 'E': /* expr */ case 'I': /* seq */ match_comma(); argvec[i++] = (GEN) analyseur; skipseq(); break; case 'r': /* raw */ match_comma(); mark.raw = analyseur; bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; if (*analyseur == '"') bp = readstring_i(bp, &buf,&limit); else { if (bp > limit) bp = realloc_buf(bp,1, &buf,&limit); *bp++ = *analyseur++; } } *bp++ = 0; argvec[i++] = (GEN) buf; break; case 'M': /* Mnemonic flag */ match_comma(); ch1 = analyseur; argvec[i] = expr(); NO_BREAK("here (reading arguments)", ch1); if (typ(argvec[i]) == t_STR) { if (!flags) flags = ep->code; flags = strchr(flags, '\n'); /* Skip to the following '\n' */ if (!flags) err(talker, "not enough flags in string function signature"); flags++; argvec[i] = (GEN) parse_option_string((char*)(argvec[i] + 1), flags, PARSEMNU_ARG_WHITESP | PARSEMNU_TEMPL_TERM_NL, NULL, NULL); } else argvec[i] = (GEN)itos(argvec[i]); i++; break; case 's': /* expanded string; empty arg yields "" */ match_comma(); if (*s == '*') /* any number of string objects */ { argvec[i++] = any_string(); s++; break; } bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; bp = expand_string(bp, &buf,&limit); } *bp++ = 0; argvec[i++] = (GEN)buf; break; case 'p': /* precision */ argvec[i++] = (GEN) prec; break; case '=': match('='); matchcomma = 0; break; case 'D': /* Has a default value */ if (do_switch(noparen,matchcomma)) switch (*s) { case 'G': case '&': case 'I': case 'V': matchcomma=1; argvec[i++]=DFT_GEN; s++; break; case 'n': matchcomma=1; argvec[i++]=DFT_VAR; s++; break; default: oldanalyseur = analyseur; analyseur = s; matchcomma = 0; while (*s++ != ','); } else switch (*s) { case 'G': case '&': case 'I': case 'V': case 'n': break; default: while (*s++ != ','); } break; case 'P': /* series precision */ argvec[i++] = (GEN) precdl; break; case 'f': /* Fake *long argument */ argvec[i++] = (GEN) &fake; break; case 'x': /* Foreign function */ argvec[i++] = (GEN) ep; call = foreignHandler; break; case ',': /* Clean up default */ if (oldanalyseur) { analyseur = oldanalyseur; oldanalyseur = NULL; matchcomma=1; } break; default: err(bugparier,"identifier (unknown code)"); }#if 0 /* uncomment if using purify: UMR otherwise */ for ( ; i<9; i++) argvec[i]=NULL;#endif{ char *oldname = gp_function_name; gp_function_name = ep->name; if (deriv) { if (!i || (ep->code)[0] != 'G') err(talker2, "can't derive this", mark.identifier, mark.start); res = num_deriv(call, argvec); } else switch (ret) { case RET_GEN: res = ((PFGEN)call)(_ARGS_); break; case RET_INT: m = (long)((int (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_LONG: m = ((long (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_VOID: ((void (*)(ANYARG))call)(_ARGS_); res = gnil; break; } gp_function_name = oldname;} if (has_pointer) check_pointers(has_pointer,init); if (!noparen) match(')'); return res; } if (EpPREDEFINED(ep)) { if (*analyseur != '(') { if (EpVALENCE(ep) == 88) return global0(); match('('); /* error */ } analyseur++; ch1 = analyseur; switch(EpVALENCE(ep)) { case 50: /* O */ res = truc(); NO_BREAK("in O()", ch1); if (*analyseur=='^') { analyseur++; m = readlong(); } else m = 1; res = ggrando(res,m); break; case 80: /* if then else */ av = avma; res = expr(); NO_BREAK("in test expression", ch1); m = gcmp0(res); avma = av; match(','); if (m) /* false */ { skipseq(); if (*analyseur == ')') res = gnil; else { match(','); res = seq(); if (br_status) { res = NULL; skipseq(); } } } else /* true */ { res = seq(); if (br_status) { res = NULL; skipseq(); } if (*analyseur != ')') { match(','); skipseq(); } } break; case 81: /* while do */ av = avma; for(;;) { res = expr(); NO_BREAK("in test expression", ch1); if (gcmp0(res)) { match(','); break; } avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; } avma = av; skipseq(); res = gnil; break; case 82: /* repeat until */ av = avma; skipexpr(); for(;;) { avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; res = expr(); NO_BREAK("in test expression", ch1); if (!gcmp0(res)) { match(','); break; } } avma = av; skipseq(); res = gnil; break; case 88: /* global */ if (*analyseur == ')') return global0(); matchcomma = 0; while (*analyseur != ')') { match_comma(); ch1 = analyseur; check_var_name(); ep = skipentry(); switch(EpVALENCE(ep)) { case EpGVAR: case EpVAR: break; default: err(talker2,"symbol already in use",ch1,mark.start); } analyseur = ch1; ep = entry(); if (*analyseur == '=') { pari_sp av=avma; analyseur++; ch1 = analyseur; res = expr(); NO_BREAK("here (defining global var)", ch1); changevalue(ep, res); avma=av; } ep->valence = EpGVAR; } res = gnil; break; default: err(valencer1); return NULL; /* not reached */ } match(')'); return res; } switch (EpVALENCE(ep)) { GEN *defarg; /* = default args, and values for local variables */ GEN *arglist; gp_args *f; case EpUSER: /* user-defined functions */ f = (gp_args*)ep->args; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; arglist = (GEN*) new_chunk(f->narg); if (*analyseur != '(') /* no args */ { if (*analyseur != '=' || analyseur[1] == '=') { for (i=0; i<f->narg; i++) arglist[i] = make_arg(f->arg[i]); return call_fun((GEN)ep->value, arglist, f); } match('('); /* ==> error */ } analyseur++; /* skip '(' */ ch1 = analyseur; skip_arg_block(f); if (*analyseur == ')' && (analyseur[1] != '=' || analyseur[2] == '=')) { matchcomma = 0; analyseur = ch1; for (i=0; i<f->narg; i++) { if (do_switch(0,matchcomma)) { /* default arg */ arglist[i] = make_arg(f->arg[i]); matchcomma = 1; } else { /* user supplied */ char *old; match_comma(); old = analyseur; arglist[i] = expr(); NO_BREAK("here (reading function args)", old); } } analyseur++; /* skip ')' */ if (deriv) { if (!f->narg) err(talker2, "can't derive this", mark.identifier, mark.start); return num_derivU((GEN)ep->value, arglist, f); } return call_fun((GEN)ep->value, arglist, f); } /* REDEFINE function */ if (*analyseur != ',' && *analyseur != ')') skipexpr(); while (*analyseur == ',') { analyseur++; skipexpr(); } match(')'); if (*analyseur != '=' || analyseur[1] == '=') err(talker2,"too many parameters in user-defined function call", mark.identifier,mark.start); analyseur = ch1-1; /* points to '(' */ free_args((gp_args*)ep->args); free(ep->args); ep->args = NULL; ep->valence = EpNEW; /* Fall through */ case EpNEW: /* new function */ { GEN tmpargs = (GEN)avma; char *start; long len, narg, nloc; check_new_fun = ep; /* checking arguments */ narg = check_args(); nloc = 0; /* Dirty, but don't want to define a local() function */ if (*analyseur != '=' && strcmp(ep->name, "local") == 0) err(talker2, "local() bloc must appear before any other expression", mark.identifier,mark.start); match('='); { /* checking function definition */ skipping_fun_def++; while (strncmp(analyseur,"local(",6) == 0) { analyseur += 5; /* on '(' */ nloc += check_args(); while(separe(*analyseur)) analyseur++; } start = analyseur; skipseq(); len = analyseur-start; skipping_fun_def--; } /* function is ok. record it */ /* record default args */ f = (gp_args*) gpmalloc((narg+nloc)*sizeof(GEN) + sizeof(gp_args)); ep->args = (void*) f; f->nloc = nloc; f->narg = narg; f->arg = defarg = (GEN*)(f + 1); narg += nloc; /* record default args and local variables */ newfun = ptr = (GEN) newbloc(1 + narg + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ for (i = 1; i <= narg; i++) { GEN cell = tmpargs-(i<<1); *newfun++ = cell[0]; *defarg++ = (GEN)cell[1]; } if (narg > 1) { /* check for duplicates */ GEN x = new_chunk(narg), v = ptr+1; long k; for (i=0; i<narg; i++) x[i] = v[i]; qsort(x,narg,sizeof(long),(QSCOMP)pari_compare_long); for (k=x[0],i=1; i<narg; k=x[i],i++) if (x[i] == k) err(talker,"user function %s: variable %Z declared twice", ep->name, polx[k]); } /* record text */ strncpy((char *)newfun, start, len); ((char *) newfun)[len] = 0; /* wait till here for gunclone because of strncopy above. In pathological * cases, e.g. (f()=f()=x), new text is given by value of old one! */ if (EpVALENCE(ep) == EpUSER) gunclone((GEN)ep->value); ep->value = (void *)ptr; ep->valence = EpUSER; check_new_fun=NULL; avma = (pari_sp)tmpargs; return gnil; } } err(valencer1); return NULL; /* not reached */}

if (has_pointer) check_pointers(has_pointer,init);

if (ind_pointer) check_pointers(ptrs, ind_pointer);

identifier(void){ long m, i, matchcomma, deriv; pari_sp av; char *ch1; entree *ep; GEN res, newfun, ptr; mark.identifier = analyseur; ep = entry(); if (EpVALENCE(ep)==EpVAR || EpVALENCE(ep)==EpGVAR) { /* optimized for simple variables */ switch (*analyseur) { case ')': case ',': return (GEN)ep->value; case '.': { long len, v; analyseur++; ch1 = analyseur; if ((res = read_member((GEN)ep->value))) { if (*analyseur == '[') { matcomp c; res = matcell(res, &c); } return res; } /* define a new member function */ v = varn(initial_value(ep)); len = analyseur - ch1; analyseur++; /* skip = */ ep = installep(NULL,ch1,len,EpMEMBER,0, members_hash + hashvalue(ch1)); ch1 = analyseur; skipseq(); len = analyseur-ch1; newfun=ptr= (GEN) newbloc(2 + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ *newfun++ = v; /* record text */ strncpy((char *)newfun, ch1, len); ((char *) newfun)[len] = 0; ep->value = (void *)ptr; return gnil; } } if (*analyseur != '[') { /* whole variable, no component */ F2GEN fun = affect_block(&res); if (res) { if (fun) res = fun((GEN)ep->value, res); changevalue(ep,res); } return (GEN)ep->value; } return matrix_block((GEN)ep->value); } ep = do_alias(ep);#ifdef STACK_CHECK if (PARI_stack_limit && (void*) &ptr <= PARI_stack_limit) err(talker2, "deep recursion", mark.identifier, mark.start);#endif if (ep->code) { char *s = ep->code, *oldanalyseur = NULL, *buf, *limit, *bp; unsigned int ret, noparen, has_pointer=0; long fake; void *call = ep->value; GEN argvec[9]; matcomp *init[9]; char *flags = NULL; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; if (*analyseur == '(') { analyseur++; noparen=0; /* expect matching ')' */ } else { /* if no mandatory argument, no () needed */ if (EpVALENCE(ep)) match('('); /* error */ if (!*s || (!s[1] && *s == 'p')) return ((GEN (*)(long))call)(prec); noparen=1; /* no argument, but valence is ok */ } /* return type */ if (*s < 'a') ret = RET_GEN; else if (*s == 'v') { ret = RET_VOID; s++; } else if (*s == 'i') { ret = RET_INT; s++; } else if (*s == 'l') { ret = RET_LONG; s++; } else ret = RET_GEN; /* Optimized for G and p. */ i = 0; matchcomma = 0; while (*s == 'G') { s++; match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); } if (*s == 'p') { argvec[i++] = (GEN) prec; s++; } while (*s && *s != '\n') switch (*s++) { case 'G': /* GEN */ match_comma(); ch1 = analyseur; argvec[i++] = expr(); NO_BREAK("here (reading arguments)", ch1); break; case 'L': /* long */ match_comma(); argvec[i++] = (GEN) readlong(); break; case 'n': /* var number */ match_comma(); argvec[i++] = (GEN) readvar(); break; case 'S': /* symbol */ match_comma(); mark.symbol=analyseur; argvec[i++] = (GEN)entry(); break; case 'V': /* variable */ match_comma(); mark.symbol=analyseur; { entree *e = entry(); long v = EpVALENCE(e); if (v != EpVAR && v != EpGVAR) err(talker2,"not a variable:",mark.symbol,mark.start); argvec[i++] = (GEN)e; break; } case '&': /* *GEN */ match_comma(); match('&'); mark.symbol=analyseur; { matcomp *c = (matcomp*)malloc(sizeof(matcomp)); entree *ep = entry(); if (*analyseur == '[') (void)matcell((GEN)ep->value, c); else { c->parent = NULL; c->ptcell = (GEN*)&ep->value; c->extra = (GEN*)ep->value; } has_pointer |= (1 << i); init[i] = c; argvec[i++] = (GEN)c->ptcell; break; } /* Input position */ case 'E': /* expr */ case 'I': /* seq */ match_comma(); argvec[i++] = (GEN) analyseur; skipseq(); break; case 'r': /* raw */ match_comma(); mark.raw = analyseur; bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; if (*analyseur == '"') bp = readstring_i(bp, &buf,&limit); else { if (bp > limit) bp = realloc_buf(bp,1, &buf,&limit); *bp++ = *analyseur++; } } *bp++ = 0; argvec[i++] = (GEN) buf; break; case 'M': /* Mnemonic flag */ match_comma(); ch1 = analyseur; argvec[i] = expr(); NO_BREAK("here (reading arguments)", ch1); if (typ(argvec[i]) == t_STR) { if (!flags) flags = ep->code; flags = strchr(flags, '\n'); /* Skip to the following '\n' */ if (!flags) err(talker, "not enough flags in string function signature"); flags++; argvec[i] = (GEN) parse_option_string((char*)(argvec[i] + 1), flags, PARSEMNU_ARG_WHITESP | PARSEMNU_TEMPL_TERM_NL, NULL, NULL); } else argvec[i] = (GEN)itos(argvec[i]); i++; break; case 's': /* expanded string; empty arg yields "" */ match_comma(); if (*s == '*') /* any number of string objects */ { argvec[i++] = any_string(); s++; break; } bp = init_buf(256, &buf,&limit); while (*analyseur) { if (*analyseur == ',' || *analyseur == ')') break; bp = expand_string(bp, &buf,&limit); } *bp++ = 0; argvec[i++] = (GEN)buf; break; case 'p': /* precision */ argvec[i++] = (GEN) prec; break; case '=': match('='); matchcomma = 0; break; case 'D': /* Has a default value */ if (do_switch(noparen,matchcomma)) switch (*s) { case 'G': case '&': case 'I': case 'V': matchcomma=1; argvec[i++]=DFT_GEN; s++; break; case 'n': matchcomma=1; argvec[i++]=DFT_VAR; s++; break; default: oldanalyseur = analyseur; analyseur = s; matchcomma = 0; while (*s++ != ','); } else switch (*s) { case 'G': case '&': case 'I': case 'V': case 'n': break; default: while (*s++ != ','); } break; case 'P': /* series precision */ argvec[i++] = (GEN) precdl; break; case 'f': /* Fake *long argument */ argvec[i++] = (GEN) &fake; break; case 'x': /* Foreign function */ argvec[i++] = (GEN) ep; call = foreignHandler; break; case ',': /* Clean up default */ if (oldanalyseur) { analyseur = oldanalyseur; oldanalyseur = NULL; matchcomma=1; } break; default: err(bugparier,"identifier (unknown code)"); }#if 0 /* uncomment if using purify: UMR otherwise */ for ( ; i<9; i++) argvec[i]=NULL;#endif{ char *oldname = gp_function_name; gp_function_name = ep->name; if (deriv) { if (!i || (ep->code)[0] != 'G') err(talker2, "can't derive this", mark.identifier, mark.start); res = num_deriv(call, argvec); } else switch (ret) { case RET_GEN: res = ((PFGEN)call)(_ARGS_); break; case RET_INT: m = (long)((int (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_LONG: m = ((long (*)(ANYARG))call)(_ARGS_); res = stoi(m); break; case RET_VOID: ((void (*)(ANYARG))call)(_ARGS_); res = gnil; break; } gp_function_name = oldname;} if (has_pointer) check_pointers(has_pointer,init); if (!noparen) match(')'); return res; } if (EpPREDEFINED(ep)) { if (*analyseur != '(') { if (EpVALENCE(ep) == 88) return global0(); match('('); /* error */ } analyseur++; ch1 = analyseur; switch(EpVALENCE(ep)) { case 50: /* O */ res = truc(); NO_BREAK("in O()", ch1); if (*analyseur=='^') { analyseur++; m = readlong(); } else m = 1; res = ggrando(res,m); break; case 80: /* if then else */ av = avma; res = expr(); NO_BREAK("in test expression", ch1); m = gcmp0(res); avma = av; match(','); if (m) /* false */ { skipseq(); if (*analyseur == ')') res = gnil; else { match(','); res = seq(); if (br_status) { res = NULL; skipseq(); } } } else /* true */ { res = seq(); if (br_status) { res = NULL; skipseq(); } if (*analyseur != ')') { match(','); skipseq(); } } break; case 81: /* while do */ av = avma; for(;;) { res = expr(); NO_BREAK("in test expression", ch1); if (gcmp0(res)) { match(','); break; } avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; } avma = av; skipseq(); res = gnil; break; case 82: /* repeat until */ av = avma; skipexpr(); for(;;) { avma = av; match(','); (void)seq(); if (loop_break()) break; analyseur = ch1; res = expr(); NO_BREAK("in test expression", ch1); if (!gcmp0(res)) { match(','); break; } } avma = av; skipseq(); res = gnil; break; case 88: /* global */ if (*analyseur == ')') return global0(); matchcomma = 0; while (*analyseur != ')') { match_comma(); ch1 = analyseur; check_var_name(); ep = skipentry(); switch(EpVALENCE(ep)) { case EpGVAR: case EpVAR: break; default: err(talker2,"symbol already in use",ch1,mark.start); } analyseur = ch1; ep = entry(); if (*analyseur == '=') { pari_sp av=avma; analyseur++; ch1 = analyseur; res = expr(); NO_BREAK("here (defining global var)", ch1); changevalue(ep, res); avma=av; } ep->valence = EpGVAR; } res = gnil; break; default: err(valencer1); return NULL; /* not reached */ } match(')'); return res; } switch (EpVALENCE(ep)) { GEN *defarg; /* = default args, and values for local variables */ GEN *arglist; gp_args *f; case EpUSER: /* user-defined functions */ f = (gp_args*)ep->args; deriv = (*analyseur == '\'' && analyseur[1] == '(') && analyseur++; arglist = (GEN*) new_chunk(f->narg); if (*analyseur != '(') /* no args */ { if (*analyseur != '=' || analyseur[1] == '=') { for (i=0; i<f->narg; i++) arglist[i] = make_arg(f->arg[i]); return call_fun((GEN)ep->value, arglist, f); } match('('); /* ==> error */ } analyseur++; /* skip '(' */ ch1 = analyseur; skip_arg_block(f); if (*analyseur == ')' && (analyseur[1] != '=' || analyseur[2] == '=')) { matchcomma = 0; analyseur = ch1; for (i=0; i<f->narg; i++) { if (do_switch(0,matchcomma)) { /* default arg */ arglist[i] = make_arg(f->arg[i]); matchcomma = 1; } else { /* user supplied */ char *old; match_comma(); old = analyseur; arglist[i] = expr(); NO_BREAK("here (reading function args)", old); } } analyseur++; /* skip ')' */ if (deriv) { if (!f->narg) err(talker2, "can't derive this", mark.identifier, mark.start); return num_derivU((GEN)ep->value, arglist, f); } return call_fun((GEN)ep->value, arglist, f); } /* REDEFINE function */ if (*analyseur != ',' && *analyseur != ')') skipexpr(); while (*analyseur == ',') { analyseur++; skipexpr(); } match(')'); if (*analyseur != '=' || analyseur[1] == '=') err(talker2,"too many parameters in user-defined function call", mark.identifier,mark.start); analyseur = ch1-1; /* points to '(' */ free_args((gp_args*)ep->args); free(ep->args); ep->args = NULL; ep->valence = EpNEW; /* Fall through */ case EpNEW: /* new function */ { GEN tmpargs = (GEN)avma; char *start; long len, narg, nloc; check_new_fun = ep; /* checking arguments */ narg = check_args(); nloc = 0; /* Dirty, but don't want to define a local() function */ if (*analyseur != '=' && strcmp(ep->name, "local") == 0) err(talker2, "local() bloc must appear before any other expression", mark.identifier,mark.start); match('='); { /* checking function definition */ skipping_fun_def++; while (strncmp(analyseur,"local(",6) == 0) { analyseur += 5; /* on '(' */ nloc += check_args(); while(separe(*analyseur)) analyseur++; } start = analyseur; skipseq(); len = analyseur-start; skipping_fun_def--; } /* function is ok. record it */ /* record default args */ f = (gp_args*) gpmalloc((narg+nloc)*sizeof(GEN) + sizeof(gp_args)); ep->args = (void*) f; f->nloc = nloc; f->narg = narg; f->arg = defarg = (GEN*)(f + 1); narg += nloc; /* record default args and local variables */ newfun = ptr = (GEN) newbloc(1 + narg + nchar2nlong(len+1)); newfun++; /* this bloc is no GEN, leave the first cell alone ( = 0) */ for (i = 1; i <= narg; i++) { GEN cell = tmpargs-(i<<1); *newfun++ = cell[0]; *defarg++ = (GEN)cell[1]; } if (narg > 1) { /* check for duplicates */ GEN x = new_chunk(narg), v = ptr+1; long k; for (i=0; i<narg; i++) x[i] = v[i]; qsort(x,narg,sizeof(long),(QSCOMP)pari_compare_long); for (k=x[0],i=1; i<narg; k=x[i],i++) if (x[i] == k) err(talker,"user function %s: variable %Z declared twice", ep->name, polx[k]); } /* record text */ strncpy((char *)newfun, start, len); ((char *) newfun)[len] = 0; /* wait till here for gunclone because of strncopy above. In pathological * cases, e.g. (f()=f()=x), new text is given by value of old one! */ if (EpVALENCE(ep) == EpUSER) gunclone((GEN)ep->value); ep->value = (void *)ptr; ep->valence = EpUSER; check_new_fun=NULL; avma = (pari_sp)tmpargs; return gnil; } } err(valencer1); return NULL; /* not reached */}

y=x; j=1+bfffo(m); m<<=j; j = BITS_IN_LONG-j;

y=x; j=1+bfffo((ulong)m); m<<=j; j = BITS_IN_LONG-j;

Kronecker_powmod(GEN x, GEN mod, GEN n){ long lim,av,av0 = avma, i,j,m,v = varn(x); GEN y, p1, p = NULL, pol = NULL; for (i=lgef(mod)-1; i>1; i--) { p1 = (GEN)mod[i]; if (typ(p1) == t_POLMOD) { pol = (GEN)p1[1] ; break; } } if (!pol) err(talker,"need POLMOD coeffs in Kronecker_powmod"); for (i=lgef(pol)-1; i>1; i--) { p1 = (GEN)pol[i]; if (typ(p1) == t_INTMOD) { p = (GEN)p1[1] ; break; } } if (!p) err(talker,"need Fq coeffs in Kronecker_powmod"); x = lift_intern(to_Kronecker(x,pol)); /* adapted from powgi */ av=avma; lim=stack_lim(av,1); p1 = n+2; m = *p1; y=x; j=1+bfffo(m); m<<=j; j = BITS_IN_LONG-j; for (i=lgefint(n)-2;;) { for (; j; m<<=1,j--) { y = gsqr(y); y = from_Kronecker(FpX(y,p), pol); setvarn(y, v); y = gres(y, mod); y = lift_intern(to_Kronecker(y,pol)); if (m<0) { y = gmul(y,x); y = from_Kronecker(FpX(y,p), pol); setvarn(y, v); y = gres(y, mod); y = lift_intern(to_Kronecker(y,pol)); } if (low_stack(lim, stack_lim(av,1))) { if(DEBUGMEM>1) err(warnmem,"Kronecker_powmod"); y = gerepilecopy(av, y); } } if (--i == 0) break; m = *++p1; j = BITS_IN_LONG; } y = from_Kronecker(FpX(y,p),pol); setvarn(y, v); return gerepileupto(av0, y);}

bnf=bnfinit0(pol,signe(D)>1?1:0,NULL,prec);

bnf=bnfinit0(pol,signe(D)>0?1:0,NULL,prec);

quadray(GEN D, GEN f, GEN flag, long prec){ long av=avma,tetpil; GEN bnr,y,p1,pol,bnf,flagnew; if (typ(D)!=t_INT) { bnf = checkbnf(D); if (degree(gmael(bnf,7,1))!=2) err(talker,"not a polynomial of degree 2 in quadray"); D=gmael(bnf,7,3); } else { if (!isfundamental(D)) err(talker,"quadray needs a fundamental discriminant"); pol=quadpoly(D); setvarn(pol, fetch_user_var("y")); bnf=bnfinit0(pol,signe(D)>1?1:0,NULL,prec); } bnr=bnrinit0(bnf,f,1,prec); if (gcmp1(gmael(bnr,5,1))) { avma=av; if (!flag || gcmp0(flag)) return polx[0]; y=cgetg(2,t_VEC); p1=cgetg(3,t_VEC); y[1]=(long)p1; p1[1]=(long)idmat(2); p1[2]=(long)polx[0]; return y; } tetpil=avma; if (signe(D)>0) { if (flag && !gcmp0(flag)) err(warner,"ignoring flag in quadray"); y=bnrstark(bnr,gzero,1,prec); } else { if (!flag) flag = gzero; flagnew=flag; if (typ(flagnew)==t_INT) { flagnew=absi(flagnew); if (cmpis(flagnew,1)<=0) y=quadrayimagsigma(bnr,flagnew,prec); else y=quadrayimagwei(bnr,mpodd(flagnew) ? gun : gzero,prec); } else { if (typ(flagnew)!=t_VEC || lg(flagnew)<=2) err(flagerr,"quadray"); y=computeP2(bnr,(GEN)flagnew[1],(GEN)flagnew[2],prec); } if (typ(y)==t_VEC && lg(y)==1) { prec=(prec<<1)-2; avma=av; if (DEBUGLEVEL) err(warnprec,"quadray",prec); return quadray(D,f,flag,prec); } } return gerepile(av,tetpil,y);}

minSFB = (expi(D) > 10)? 3: 2;

minSFB = (expi(D) > 20)? 3: 2;

subFBquad(GEN D, double PROD, long KC){ long i, j, minSFB, lgsub = 1, ino = 1, lv = KC+1; double prod = 1.; pari_sp av; GEN no; minSFB = (expi(D) > 10)? 3: 2; vperm = cgetg(lv, t_VECSMALL); av = avma; no = cgetg(lv, t_VECSMALL); for (j = 1; j < lv; j++) { ulong p = FB[j]; if (!umodiu(D, p)) no[ino++] = j; /* ramified */ else { vperm[lgsub++] = j; prod *= p; if (lgsub > minSFB && prod > PROD) break; } } if (j == lv) return NULL; i = lgsub; for (j = 1; j < ino;i++,j++) vperm[i] = no[j]; for ( ; i < lv; i++) vperm[i] = i; if (DEBUGLEVEL) msgtimer("subFBquad (%ld elt.)", lgsub-1); no = gclone(vecslice(vperm, 1, lgsub-1)); avma = av; return no;}

if (DEBUGLEVEL>=3)

if (DEBUGLEVEL>5)

dbasis(GEN p, GEN f, long mf, GEN alpha, GEN U){ long n=degpol(f),dU,i; GEN b,ha,pd,pdp; if (n == 1) return gscalmat(gun, 1); if (DEBUGLEVEL>=3) { fprintferr(" entering Dedekind Basis "); if (DEBUGLEVEL>5) { fprintferr("with parameters p=%Z\n",p); fprintferr(" f = %Z,\n alpha = %Z",f,alpha); } fprintferr("\n"); } ha = pd = gpowgs(p,mf/2); pdp = mulii(pd,p); dU = typ(U)==t_POL? degpol(U): 0; b = cgetg(n,t_MAT); /* Z[a] + U/p Z[a] is maximal */ /* skip first column = gscalcol(pd,n) */ for (i=1; i<n; i++) { if (i == dU) { ha = gdiv(gmul(pd,RX_RXQ_compo(U,alpha,f)),p); ha = polmodi(ha,pdp); } else { GEN d, mod; ha = gmul(ha,alpha); ha = Q_remove_denom(ha, &d); mod = d? mulii(pdp,d): pdp; ha = FpX_res(ha, f, mod); if (d) ha = gdivexact(ha,d); } b[i] = (long)pol_to_vec(ha,n); } b = hnfmodid(b,pd); if (DEBUGLEVEL>5) fprintferr(" new order: %Z\n",b); return gdiv(b, pd);}

fprintferr(" entering Dedekind Basis "); if (DEBUGLEVEL>5) { fprintferr("with parameters p=%Z\n",p); fprintferr(" f = %Z,\n alpha = %Z",f,alpha); } fprintferr("\n");

fprintferr(" entering Dedekind Basis with parameters p=%Z\n",p); fprintferr(" f = %Z,\n alpha = %Z\n",f,alpha);

dbasis(GEN p, GEN f, long mf, GEN alpha, GEN U){ long n=degpol(f),dU,i; GEN b,ha,pd,pdp; if (n == 1) return gscalmat(gun, 1); if (DEBUGLEVEL>=3) { fprintferr(" entering Dedekind Basis "); if (DEBUGLEVEL>5) { fprintferr("with parameters p=%Z\n",p); fprintferr(" f = %Z,\n alpha = %Z",f,alpha); } fprintferr("\n"); } ha = pd = gpowgs(p,mf/2); pdp = mulii(pd,p); dU = typ(U)==t_POL? degpol(U): 0; b = cgetg(n,t_MAT); /* Z[a] + U/p Z[a] is maximal */ /* skip first column = gscalcol(pd,n) */ for (i=1; i<n; i++) { if (i == dU) { ha = gdiv(gmul(pd,RX_RXQ_compo(U,alpha,f)),p); ha = polmodi(ha,pdp); } else { GEN d, mod; ha = gmul(ha,alpha); ha = Q_remove_denom(ha, &d); mod = d? mulii(pdp,d): pdp; ha = FpX_res(ha, f, mod); if (d) ha = gdivexact(ha,d); } b[i] = (long)pol_to_vec(ha,n); } b = hnfmodid(b,pd); if (DEBUGLEVEL>5) fprintferr(" new order: %Z\n",b); return gdiv(b, pd);}

GEN z,L,P,p,q,qfp,qfq,up,uq,u;

GEN z,L,P,p,q,qfp,u;

quadhilbertimag(GEN D, GEN flag){ long h, i, e, prec; pari_sp av=avma; GEN z,L,P,p,q,qfp,qfq,up,uq,u; int raw = ((typ(flag)==t_INT && signe(flag))); if (DEBUGLEVEL>=2) (void)timer2(); if (gcmpgs(D,-11) >= 0) return polx[0]; L = getallforms(D,&h,&z); if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h); if (h == 1) { avma=av; return polx[0]; } get_pq(D, z, flag, &p, &q); e = 24 / cgcd((smodis(p,24)-1) * (smodis(q,24)-1), 24); if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1)); if (egalii(p,q)) { u = (GEN)compimagraw(qfp,qfp)[2]; u = gmodulcp(u, shifti(mulii(p,q),1)); } else { qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1)); u = chinois(up,uq); } prec = raw? DEFAULTPREC: 3; for(;;) { long ex, exmax = 0; pari_sp av0 = avma; GEN lead, sqd = gsqrt(negi(D),prec); P = cgetg(h+1,t_VEC); for (i=1; i<=h; i++) { GEN v, s = gpq((GEN)L[i], p, q, e, sqd, u, prec); if (raw) { v = cgetg(3,t_VEC); P[i] = (long)v; v[1] = L[i]; v[2] = (long)s; } else P[i] = (long)s; ex = gexpo(s); if (ex > 0) exmax += ex; } if (DEBUGLEVEL>=2) msgtimer("roots"); if (raw) { P = gcopy(P); break; } /* to avoid integer overflow (1 + 0.) */ lead = (exmax < bit_accuracy(prec))? gun: realun(prec); P = greal(roots_to_pol_intern(lead,P,0,0)); P = grndtoi(P,&exmax); if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax); if (exmax <= -10) { if (typ(flag)==t_VEC && !issquarefree(P)) { avma=av; return gzero; } break; } avma = av0; prec += (DEFAULTPREC-2) + (1 + (exmax >> TWOPOTBITS_IN_LONG)); if (DEBUGLEVEL) err(warnprec,"quadhilbertimag",prec); } return gerepileupto(av,P);}

if (DEBUGLEVEL>=2) (void)timer2();

if (DEBUGLEVEL>1) (void)timer2();

quadhilbertimag(GEN D, GEN flag){ long h, i, e, prec; pari_sp av=avma; GEN z,L,P,p,q,qfp,qfq,up,uq,u; int raw = ((typ(flag)==t_INT && signe(flag))); if (DEBUGLEVEL>=2) (void)timer2(); if (gcmpgs(D,-11) >= 0) return polx[0]; L = getallforms(D,&h,&z); if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h); if (h == 1) { avma=av; return polx[0]; } get_pq(D, z, flag, &p, &q); e = 24 / cgcd((smodis(p,24)-1) * (smodis(q,24)-1), 24); if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1)); if (egalii(p,q)) { u = (GEN)compimagraw(qfp,qfp)[2]; u = gmodulcp(u, shifti(mulii(p,q),1)); } else { qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1)); u = chinois(up,uq); } prec = raw? DEFAULTPREC: 3; for(;;) { long ex, exmax = 0; pari_sp av0 = avma; GEN lead, sqd = gsqrt(negi(D),prec); P = cgetg(h+1,t_VEC); for (i=1; i<=h; i++) { GEN v, s = gpq((GEN)L[i], p, q, e, sqd, u, prec); if (raw) { v = cgetg(3,t_VEC); P[i] = (long)v; v[1] = L[i]; v[2] = (long)s; } else P[i] = (long)s; ex = gexpo(s); if (ex > 0) exmax += ex; } if (DEBUGLEVEL>=2) msgtimer("roots"); if (raw) { P = gcopy(P); break; } /* to avoid integer overflow (1 + 0.) */ lead = (exmax < bit_accuracy(prec))? gun: realun(prec); P = greal(roots_to_pol_intern(lead,P,0,0)); P = grndtoi(P,&exmax); if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax); if (exmax <= -10) { if (typ(flag)==t_VEC && !issquarefree(P)) { avma=av; return gzero; } break; } avma = av0; prec += (DEFAULTPREC-2) + (1 + (exmax >> TWOPOTBITS_IN_LONG)); if (DEBUGLEVEL) err(warnprec,"quadhilbertimag",prec); } return gerepileupto(av,P);}

if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h);

if (DEBUGLEVEL>1) msgtimer("class number = %ld",h);

quadhilbertimag(GEN D, GEN flag){ long h, i, e, prec; pari_sp av=avma; GEN z,L,P,p,q,qfp,qfq,up,uq,u; int raw = ((typ(flag)==t_INT && signe(flag))); if (DEBUGLEVEL>=2) (void)timer2(); if (gcmpgs(D,-11) >= 0) return polx[0]; L = getallforms(D,&h,&z); if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h); if (h == 1) { avma=av; return polx[0]; } get_pq(D, z, flag, &p, &q); e = 24 / cgcd((smodis(p,24)-1) * (smodis(q,24)-1), 24); if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1)); if (egalii(p,q)) { u = (GEN)compimagraw(qfp,qfp)[2]; u = gmodulcp(u, shifti(mulii(p,q),1)); } else { qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1)); u = chinois(up,uq); } prec = raw? DEFAULTPREC: 3; for(;;) { long ex, exmax = 0; pari_sp av0 = avma; GEN lead, sqd = gsqrt(negi(D),prec); P = cgetg(h+1,t_VEC); for (i=1; i<=h; i++) { GEN v, s = gpq((GEN)L[i], p, q, e, sqd, u, prec); if (raw) { v = cgetg(3,t_VEC); P[i] = (long)v; v[1] = L[i]; v[2] = (long)s; } else P[i] = (long)s; ex = gexpo(s); if (ex > 0) exmax += ex; } if (DEBUGLEVEL>=2) msgtimer("roots"); if (raw) { P = gcopy(P); break; } /* to avoid integer overflow (1 + 0.) */ lead = (exmax < bit_accuracy(prec))? gun: realun(prec); P = greal(roots_to_pol_intern(lead,P,0,0)); P = grndtoi(P,&exmax); if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax); if (exmax <= -10) { if (typ(flag)==t_VEC && !issquarefree(P)) { avma=av; return gzero; } break; } avma = av0; prec += (DEFAULTPREC-2) + (1 + (exmax >> TWOPOTBITS_IN_LONG)); if (DEBUGLEVEL) err(warnprec,"quadhilbertimag",prec); } return gerepileupto(av,P);}

if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1));

if(DEBUGLEVEL>1) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0);

quadhilbertimag(GEN D, GEN flag){ long h, i, e, prec; pari_sp av=avma; GEN z,L,P,p,q,qfp,qfq,up,uq,u; int raw = ((typ(flag)==t_INT && signe(flag))); if (DEBUGLEVEL>=2) (void)timer2(); if (gcmpgs(D,-11) >= 0) return polx[0]; L = getallforms(D,&h,&z); if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h); if (h == 1) { avma=av; return polx[0]; } get_pq(D, z, flag, &p, &q); e = 24 / cgcd((smodis(p,24)-1) * (smodis(q,24)-1), 24); if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1)); if (egalii(p,q)) { u = (GEN)compimagraw(qfp,qfp)[2]; u = gmodulcp(u, shifti(mulii(p,q),1)); } else { qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1)); u = chinois(up,uq); } prec = raw? DEFAULTPREC: 3; for(;;) { long ex, exmax = 0; pari_sp av0 = avma; GEN lead, sqd = gsqrt(negi(D),prec); P = cgetg(h+1,t_VEC); for (i=1; i<=h; i++) { GEN v, s = gpq((GEN)L[i], p, q, e, sqd, u, prec); if (raw) { v = cgetg(3,t_VEC); P[i] = (long)v; v[1] = L[i]; v[2] = (long)s; } else P[i] = (long)s; ex = gexpo(s); if (ex > 0) exmax += ex; } if (DEBUGLEVEL>=2) msgtimer("roots"); if (raw) { P = gcopy(P); break; } /* to avoid integer overflow (1 + 0.) */ lead = (exmax < bit_accuracy(prec))? gun: realun(prec); P = greal(roots_to_pol_intern(lead,P,0,0)); P = grndtoi(P,&exmax); if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax); if (exmax <= -10) { if (typ(flag)==t_VEC && !issquarefree(P)) { avma=av; return gzero; } break; } avma = av0; prec += (DEFAULTPREC-2) + (1 + (exmax >> TWOPOTBITS_IN_LONG)); if (DEBUGLEVEL) err(warnprec,"quadhilbertimag",prec); } return gerepileupto(av,P);}

u = gmodulcp(u, shifti(mulii(p,q),1));

u = gmodulcp(u, shifti(sqri(p),1));

quadhilbertimag(GEN D, GEN flag){ long h, i, e, prec; pari_sp av=avma; GEN z,L,P,p,q,qfp,qfq,up,uq,u; int raw = ((typ(flag)==t_INT && signe(flag))); if (DEBUGLEVEL>=2) (void)timer2(); if (gcmpgs(D,-11) >= 0) return polx[0]; L = getallforms(D,&h,&z); if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h); if (h == 1) { avma=av; return polx[0]; } get_pq(D, z, flag, &p, &q); e = 24 / cgcd((smodis(p,24)-1) * (smodis(q,24)-1), 24); if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1)); if (egalii(p,q)) { u = (GEN)compimagraw(qfp,qfp)[2]; u = gmodulcp(u, shifti(mulii(p,q),1)); } else { qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1)); u = chinois(up,uq); } prec = raw? DEFAULTPREC: 3; for(;;) { long ex, exmax = 0; pari_sp av0 = avma; GEN lead, sqd = gsqrt(negi(D),prec); P = cgetg(h+1,t_VEC); for (i=1; i<=h; i++) { GEN v, s = gpq((GEN)L[i], p, q, e, sqd, u, prec); if (raw) { v = cgetg(3,t_VEC); P[i] = (long)v; v[1] = L[i]; v[2] = (long)s; } else P[i] = (long)s; ex = gexpo(s); if (ex > 0) exmax += ex; } if (DEBUGLEVEL>=2) msgtimer("roots"); if (raw) { P = gcopy(P); break; } /* to avoid integer overflow (1 + 0.) */ lead = (exmax < bit_accuracy(prec))? gun: realun(prec); P = greal(roots_to_pol_intern(lead,P,0,0)); P = grndtoi(P,&exmax); if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax); if (exmax <= -10) { if (typ(flag)==t_VEC && !issquarefree(P)) { avma=av; return gzero; } break; } avma = av0; prec += (DEFAULTPREC-2) + (1 + (exmax >> TWOPOTBITS_IN_LONG)); if (DEBUGLEVEL) err(warnprec,"quadhilbertimag",prec); } return gerepileupto(av,P);}

qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1));

GEN qfq = primeform(D,q,0); GEN up = gmodulcp((GEN)qfp[2], shifti(p,1)); GEN uq = gmodulcp((GEN)qfq[2], shifti(q,1));

quadhilbertimag(GEN D, GEN flag){ long h, i, e, prec; pari_sp av=avma; GEN z,L,P,p,q,qfp,qfq,up,uq,u; int raw = ((typ(flag)==t_INT && signe(flag))); if (DEBUGLEVEL>=2) (void)timer2(); if (gcmpgs(D,-11) >= 0) return polx[0]; L = getallforms(D,&h,&z); if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h); if (h == 1) { avma=av; return polx[0]; } get_pq(D, z, flag, &p, &q); e = 24 / cgcd((smodis(p,24)-1) * (smodis(q,24)-1), 24); if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1)); if (egalii(p,q)) { u = (GEN)compimagraw(qfp,qfp)[2]; u = gmodulcp(u, shifti(mulii(p,q),1)); } else { qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1)); u = chinois(up,uq); } prec = raw? DEFAULTPREC: 3; for(;;) { long ex, exmax = 0; pari_sp av0 = avma; GEN lead, sqd = gsqrt(negi(D),prec); P = cgetg(h+1,t_VEC); for (i=1; i<=h; i++) { GEN v, s = gpq((GEN)L[i], p, q, e, sqd, u, prec); if (raw) { v = cgetg(3,t_VEC); P[i] = (long)v; v[1] = L[i]; v[2] = (long)s; } else P[i] = (long)s; ex = gexpo(s); if (ex > 0) exmax += ex; } if (DEBUGLEVEL>=2) msgtimer("roots"); if (raw) { P = gcopy(P); break; } /* to avoid integer overflow (1 + 0.) */ lead = (exmax < bit_accuracy(prec))? gun: realun(prec); P = greal(roots_to_pol_intern(lead,P,0,0)); P = grndtoi(P,&exmax); if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax); if (exmax <= -10) { if (typ(flag)==t_VEC && !issquarefree(P)) { avma=av; return gzero; } break; } avma = av0; prec += (DEFAULTPREC-2) + (1 + (exmax >> TWOPOTBITS_IN_LONG)); if (DEBUGLEVEL) err(warnprec,"quadhilbertimag",prec); } return gerepileupto(av,P);}

if (DEBUGLEVEL>=2) msgtimer("roots");

if (DEBUGLEVEL>1) msgtimer("roots");

quadhilbertimag(GEN D, GEN flag){ long h, i, e, prec; pari_sp av=avma; GEN z,L,P,p,q,qfp,qfq,up,uq,u; int raw = ((typ(flag)==t_INT && signe(flag))); if (DEBUGLEVEL>=2) (void)timer2(); if (gcmpgs(D,-11) >= 0) return polx[0]; L = getallforms(D,&h,&z); if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h); if (h == 1) { avma=av; return polx[0]; } get_pq(D, z, flag, &p, &q); e = 24 / cgcd((smodis(p,24)-1) * (smodis(q,24)-1), 24); if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1)); if (egalii(p,q)) { u = (GEN)compimagraw(qfp,qfp)[2]; u = gmodulcp(u, shifti(mulii(p,q),1)); } else { qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1)); u = chinois(up,uq); } prec = raw? DEFAULTPREC: 3; for(;;) { long ex, exmax = 0; pari_sp av0 = avma; GEN lead, sqd = gsqrt(negi(D),prec); P = cgetg(h+1,t_VEC); for (i=1; i<=h; i++) { GEN v, s = gpq((GEN)L[i], p, q, e, sqd, u, prec); if (raw) { v = cgetg(3,t_VEC); P[i] = (long)v; v[1] = L[i]; v[2] = (long)s; } else P[i] = (long)s; ex = gexpo(s); if (ex > 0) exmax += ex; } if (DEBUGLEVEL>=2) msgtimer("roots"); if (raw) { P = gcopy(P); break; } /* to avoid integer overflow (1 + 0.) */ lead = (exmax < bit_accuracy(prec))? gun: realun(prec); P = greal(roots_to_pol_intern(lead,P,0,0)); P = grndtoi(P,&exmax); if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax); if (exmax <= -10) { if (typ(flag)==t_VEC && !issquarefree(P)) { avma=av; return gzero; } break; } avma = av0; prec += (DEFAULTPREC-2) + (1 + (exmax >> TWOPOTBITS_IN_LONG)); if (DEBUGLEVEL) err(warnprec,"quadhilbertimag",prec); } return gerepileupto(av,P);}

if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax);

if (DEBUGLEVEL>1) msgtimer("product, error bits = %ld",exmax);

quadhilbertimag(GEN D, GEN flag){ long h, i, e, prec; pari_sp av=avma; GEN z,L,P,p,q,qfp,qfq,up,uq,u; int raw = ((typ(flag)==t_INT && signe(flag))); if (DEBUGLEVEL>=2) (void)timer2(); if (gcmpgs(D,-11) >= 0) return polx[0]; L = getallforms(D,&h,&z); if (DEBUGLEVEL>=2) msgtimer("class number = %ld",h); if (h == 1) { avma=av; return polx[0]; } get_pq(D, z, flag, &p, &q); e = 24 / cgcd((smodis(p,24)-1) * (smodis(q,24)-1), 24); if(DEBUGLEVEL>=2) fprintferr("p = %Z, q = %Z, e = %ld\n",p,q,e); qfp = primeform(D,p,0); up = gmodulcp((GEN)qfp[2],shifti(p,1)); if (egalii(p,q)) { u = (GEN)compimagraw(qfp,qfp)[2]; u = gmodulcp(u, shifti(mulii(p,q),1)); } else { qfq = primeform(D,q,0); uq = gmodulcp((GEN)qfq[2],shifti(q,1)); u = chinois(up,uq); } prec = raw? DEFAULTPREC: 3; for(;;) { long ex, exmax = 0; pari_sp av0 = avma; GEN lead, sqd = gsqrt(negi(D),prec); P = cgetg(h+1,t_VEC); for (i=1; i<=h; i++) { GEN v, s = gpq((GEN)L[i], p, q, e, sqd, u, prec); if (raw) { v = cgetg(3,t_VEC); P[i] = (long)v; v[1] = L[i]; v[2] = (long)s; } else P[i] = (long)s; ex = gexpo(s); if (ex > 0) exmax += ex; } if (DEBUGLEVEL>=2) msgtimer("roots"); if (raw) { P = gcopy(P); break; } /* to avoid integer overflow (1 + 0.) */ lead = (exmax < bit_accuracy(prec))? gun: realun(prec); P = greal(roots_to_pol_intern(lead,P,0,0)); P = grndtoi(P,&exmax); if (DEBUGLEVEL>=2) msgtimer("product, error bits = %ld",exmax); if (exmax <= -10) { if (typ(flag)==t_VEC && !issquarefree(P)) { avma=av; return gzero; } break; } avma = av0; prec += (DEFAULTPREC-2) + (1 + (exmax >> TWOPOTBITS_IN_LONG)); if (DEBUGLEVEL) err(warnprec,"quadhilbertimag",prec); } return gerepileupto(av,P);}

p2 = get_Char(chi,cyc, prec);

p2 = get_Char(get_chic(chi,cyc), prec);

bnrrootnumber(GEN bnr, GEN chi, long flag, long prec){ long av = avma, l; GEN cond, condc, bnrc, cyc, p1, p2, dtcr; if (flag < 0 || flag > 1) err(flagerr,"bnrrootnumber"); checkbnr(bnr); cond = gmael(bnr, 2, 1); l = lg(gmael(bnr, 5, 2)); if ((typ(chi) != t_VEC) || (lg(chi) != l)) err(talker, "incorrect character in bnrrootnumber"); if (!flag) { condc = bnrconductorofchar(bnr, chi); if (gegal(cond, condc)) flag = 1; } else condc = cond; if (flag) bnrc = bnr; else bnrc = buchrayinitgen((GEN)bnr[1], condc); cyc = gmael(bnr, 5, 2); p2 = get_Char(chi,cyc, prec); dtcr = cgetg(9, t_VEC); dtcr[1] = (long)chi; dtcr[2] = zero; dtcr[3] = (long)bnrc; dtcr[4] = (long)bnr; dtcr[5] = (long)p2; dtcr[6] = zero; dtcr[7] = (long)condc; p1 = GetPrimChar(chi, bnr, bnrc, prec); if (!p1) dtcr[8] = (long)p2; else dtcr[8] = p1[1]; return gerepileupto(av, ComputeArtinNumber(dtcr, 0, prec));}

finda(Cache *Cp, GEN N, int pk, int p)

finda(Cache *Cp, GEN N, long pk, long p)

finda(Cache *Cp, GEN N, int pk, int p){ GEN a, pv; if (Cp && Cp->avite) { a = Cp->avite; pv = Cp->pkvite; } else { GEN gp = utoipos(p), ph, b, q; ulong u = 2; int v = Z_pvalrem(addis(N,-1), gp, &q); ph = gpowgs(gp, v-1); pv = mulis(ph, p); /* N - 1 = p^v q */ if (p > 2) { for (;;u++) { a = Fp_pow(utoipos(u), q, N); b = Fp_pow(a, ph, N); if (!gcmp1(b)) break; } } else { while (krosi(u,N) >= 0) u++; a = Fp_pow(utoipos(u), q, N); b = Fp_pow(a, ph, N); } /* checking b^p = 1 mod N done economically in caller */ b = gcdii(addis(b,-1), N); if (!gcmp1(b)) err(invmoder,"%Z",gmodulcp(b,N)); /* trap this! */ if (Cp) { Cp->avite = a; /* a has order p^v */ Cp->pkvite = pv; } } return Fp_pow(a, divis(pv, pk), N);}

int v = Z_pvalrem(addis(N,-1), gp, &q);

long v = Z_pvalrem(addis(N,-1), gp, &q);

finda(Cache *Cp, GEN N, int pk, int p){ GEN a, pv; if (Cp && Cp->avite) { a = Cp->avite; pv = Cp->pkvite; } else { GEN gp = utoipos(p), ph, b, q; ulong u = 2; int v = Z_pvalrem(addis(N,-1), gp, &q); ph = gpowgs(gp, v-1); pv = mulis(ph, p); /* N - 1 = p^v q */ if (p > 2) { for (;;u++) { a = Fp_pow(utoipos(u), q, N); b = Fp_pow(a, ph, N); if (!gcmp1(b)) break; } } else { while (krosi(u,N) >= 0) u++; a = Fp_pow(utoipos(u), q, N); b = Fp_pow(a, ph, N); } /* checking b^p = 1 mod N done economically in caller */ b = gcdii(addis(b,-1), N); if (!gcmp1(b)) err(invmoder,"%Z",gmodulcp(b,N)); /* trap this! */ if (Cp) { Cp->avite = a; /* a has order p^v */ Cp->pkvite = pv; } } return Fp_pow(a, divis(pv, pk), N);}

long i, j, lx, lz;

long i, j, lz, l = lg(L);

bnrclassnolist(GEN bnf,GEN L){ pari_sp av = avma; long i, j, lx, lz; GEN v, z, V, h; bnf = checkbnf(bnf); h = gmael3(bnf,8,1,1); if (typ(L) != t_VEC) err(typeer,"bnrclassnolist"); lx = lg(L); V = cgetg(lx,t_VEC); for (i = 1; i < lx; i++) { z = gel(L,i); lz = lg(z); gel(V,i) = v = cgetg(lz,t_VEC); for (j=1; j<lz; j++) gel(v,j) = get_classno(gel(z,j), h); } return gerepilecopy(av, V);}

if (typ(L) != t_VEC) err(typeer,"bnrclassnolist"); lx = lg(L); V = cgetg(lx,t_VEC); for (i = 1; i < lx; i++)

V = cgetg(l,t_VEC); for (i = 1; i < l; i++)

bnrclassnolist(GEN bnf,GEN L){ pari_sp av = avma; long i, j, lx, lz; GEN v, z, V, h; bnf = checkbnf(bnf); h = gmael3(bnf,8,1,1); if (typ(L) != t_VEC) err(typeer,"bnrclassnolist"); lx = lg(L); V = cgetg(lx,t_VEC); for (i = 1; i < lx; i++) { z = gel(L,i); lz = lg(z); gel(V,i) = v = cgetg(lz,t_VEC); for (j=1; j<lz; j++) gel(v,j) = get_classno(gel(z,j), h); } return gerepilecopy(av, V);}

rtems_unsigned32 task;

uint32_t task;

void destory_all_tasks( const char *who){ rtems_unsigned32 task; /* * If the id is not zero, signal the task to delete. */ for (task = 0; task < MAX_TASKS; task++) if (task_id[task]) { printf(" %s : signal task %08x to delete, ", who, task_id[task]); fflush(stdout); rtems_event_send(task_id[task], 1); task_id[task] = 0; }}

prec++;

galoisborne(GEN T, GEN dn, struct galois_borne *gb, long ppp){ ulong ltop = avma, av2; GEN borne, borneroots, borneabs; int i, j; int n; GEN L, M, z, prep, den; long prec; n = lgef(T) - 3; prec = 1; for (i = 2; i < lgef(T); i++) if (lg(T[i]) > prec) prec = lg(T[i]); prec++; if (DEBUGLEVEL>=4) gentimer(3); L = roots(T, prec); if (DEBUGLEVEL>=4) genmsgtimer(3,"roots"); for (i = 1; i <= n; i++) { z = (GEN) L[i]; if (signe(z[2])) break; L[i] = z[1]; } if (DEBUGLEVEL>=4) gentimer(3); prep=vandermondeinverseprep(T, L); if (!dn) { GEN res = divide_conquer_prod(gabs(prep,prec), mpmul); GEN dis; disable_dbg(0); dis = ZX_disc_all(T, 1+mylogint(res,gdeux,prec)); disable_dbg(-1); den = gclone(indexpartial(T,dis)); } else den=dn; M = vandermondeinverse(L, gmul(T, realun(prec)), den, prep); if (DEBUGLEVEL>=4) genmsgtimer(3,"vandermondeinverse"); borne = realzero(prec); for (i = 1; i <= n; i++) { z = gzero; for (j = 1; j <= n; j++) z = gadd(z, gabs(gcoeff(M,i,j), prec)); if (gcmp(z, borne) > 0) borne = z; } borneroots = realzero(prec); for (i = 1; i <= n; i++) { z = gabs((GEN) L[i], prec); if (gcmp(z, borneroots) > 0) borneroots = z; } borneabs = addsr(1, gmulsg(n, gpowgs(borneroots, n/ppp))); /*if (ppp == 1) borneabs = addsr(1, gmulsg(n, gpowgs(borneabs, 2)));*/ borneroots = addsr(1, gmul(borne, borneroots)); av2 = avma; /*We use d-1 test, so we must overlift to 2^BITS_IN_LONG*/ gb->valsol = mylogint(gmul2n(borneroots,2+BITS_IN_LONG), gb->l, prec); gb->valabs = mylogint(gmul2n(borneabs,2), gb->l, prec); gb->valabs = max(gb->valsol,gb->valabs); if (DEBUGLEVEL >= 4) fprintferr("GaloisConj:val1=%ld val2=%ld\n", gb->valsol, gb->valabs); avma = av2; gb->bornesol = gerepileupto(ltop, myceil(borneroots)); if (DEBUGLEVEL >= 9) fprintferr("GaloisConj: Bound %Z\n",borneroots); gb->ladicsol = gpowgs(gb->l, gb->valsol); gb->ladicabs = gpowgs(gb->l, gb->valabs); gb->lbornesol = subii(gb->ladicsol,gb->bornesol); if (!dn) { dn=forcecopy(den); gunclone(den); } return dn;}

if (T->subq) p1 = mulis(p1,lg(T->subqpart)-1); if (cmpis(p1,T->countsub))

if (T->fun != list_fun || !((sublist_t*)(T->fundata))->listKer)

dopsub(subgp_iter *T, GEN p, GEN indexsubq){ long *M, *L = T->L; long w,i,j,k, wG = weight(L), wmin = 0, wmax = wG, n = len(L); if (DEBUGLEVEL) { fprintferr("\ngroup:"); printtyp(L); } T->count = 0; switch(T->boundtype) { case b_MAX: /* upper bound */ wmin = (long) (wG - (log(gtodouble(T->bound)) / log(gtodouble(p)))); if (cmpii(gpowgs(p, wG - wmin), T->bound) > 0) wmin++; break; case b_EXACT: /* exact value */ wmin = wmax = wG - ggval(T->bound, p); break; } T->M = M = new_chunk(n+1); M[1] = -1; for (i=2; i<=n; i++) M[i]=0; for(;;) /* go through all vectors mu_{i+1} <= mu_i <= lam_i */ { M[1]++; if (M[1] > L[1]) { for (j=2; j<=n; j++) if (M[j] < L[j] && M[j] < M[j-1]) break; if (j > n) return; M[j]++; for (k=1; k<j; k++) M[k]=M[j]; } for (j=1; j<=n; j++) if (!M[j]) break; setlen(M, j-1); w = weight(M); if (w >= wmin && w <= wmax) { GEN p1 = gun; if (T->subq) /* G not a p-group */ { if (T->bound) { GEN indexH = gpowgs(p, wG - w); GEN B = divii(T->bound, indexH); long k, l = lg(T->subq); T->subqpart = cgetg(l, t_VEC); k = 1; for (i=1; i<l; i++) if (cmpii((GEN)indexsubq[i], B) <= 0) T->subqpart[k++] = T->subq[i]; setlg(T->subqpart, k); } else T->subqpart = T->subq; } if (DEBUGLEVEL) { long *Lp = conjugate(L); long *Mp = conjugate(M); GEN BINMAT = matqpascal(len(L)+1, p); if (DEBUGLEVEL > 3) { fprintferr(" lambda = "); printtyp(L); fprintferr(" lambda'= "); printtyp(Lp); fprintferr(" mu = "); printtyp(M); fprintferr(" mu'= "); printtyp(Mp); } for (j=1; j<=len(Mp); j++) { p1 = mulii(p1, gpuigs(p, Mp[j+1]*(Lp[j]-Mp[j]))); p1 = mulii(p1, gcoeff(BINMAT, Lp[j]-Mp[j+1]+1, Mp[j]-Mp[j+1]+1)); } fprintferr(" alpha_lambda(mu,p) = %Z\n",p1); } T->countsub = 0; dopsubtyp(T); T->count += T->countsub; if (DEBUGLEVEL) { fprintferr(" countsub = %ld\n", T->countsub); msgtimer("for this type"); if (T->subq) p1 = mulis(p1,lg(T->subqpart)-1); if (cmpis(p1,T->countsub)) { fprintferr(" alpha = %Z\n",p1); err(bugparier,"forsubgroup (alpha != countsub)"); } } } }}

fprintferr(" alpha = %Z\n",p1); err(bugparier,"forsubgroup (alpha != countsub)");

if (T->subq) p1 = mulis(p1,lg(T->subqpart)-1); if (cmpis(p1,T->countsub)) { fprintferr(" alpha = %Z\n",p1); err(bugparier,"forsubgroup (alpha != countsub)"); }

dopsub(subgp_iter *T, GEN p, GEN indexsubq){ long *M, *L = T->L; long w,i,j,k, wG = weight(L), wmin = 0, wmax = wG, n = len(L); if (DEBUGLEVEL) { fprintferr("\ngroup:"); printtyp(L); } T->count = 0; switch(T->boundtype) { case b_MAX: /* upper bound */ wmin = (long) (wG - (log(gtodouble(T->bound)) / log(gtodouble(p)))); if (cmpii(gpowgs(p, wG - wmin), T->bound) > 0) wmin++; break; case b_EXACT: /* exact value */ wmin = wmax = wG - ggval(T->bound, p); break; } T->M = M = new_chunk(n+1); M[1] = -1; for (i=2; i<=n; i++) M[i]=0; for(;;) /* go through all vectors mu_{i+1} <= mu_i <= lam_i */ { M[1]++; if (M[1] > L[1]) { for (j=2; j<=n; j++) if (M[j] < L[j] && M[j] < M[j-1]) break; if (j > n) return; M[j]++; for (k=1; k<j; k++) M[k]=M[j]; } for (j=1; j<=n; j++) if (!M[j]) break; setlen(M, j-1); w = weight(M); if (w >= wmin && w <= wmax) { GEN p1 = gun; if (T->subq) /* G not a p-group */ { if (T->bound) { GEN indexH = gpowgs(p, wG - w); GEN B = divii(T->bound, indexH); long k, l = lg(T->subq); T->subqpart = cgetg(l, t_VEC); k = 1; for (i=1; i<l; i++) if (cmpii((GEN)indexsubq[i], B) <= 0) T->subqpart[k++] = T->subq[i]; setlg(T->subqpart, k); } else T->subqpart = T->subq; } if (DEBUGLEVEL) { long *Lp = conjugate(L); long *Mp = conjugate(M); GEN BINMAT = matqpascal(len(L)+1, p); if (DEBUGLEVEL > 3) { fprintferr(" lambda = "); printtyp(L); fprintferr(" lambda'= "); printtyp(Lp); fprintferr(" mu = "); printtyp(M); fprintferr(" mu'= "); printtyp(Mp); } for (j=1; j<=len(Mp); j++) { p1 = mulii(p1, gpuigs(p, Mp[j+1]*(Lp[j]-Mp[j]))); p1 = mulii(p1, gcoeff(BINMAT, Lp[j]-Mp[j+1]+1, Mp[j]-Mp[j+1]+1)); } fprintferr(" alpha_lambda(mu,p) = %Z\n",p1); } T->countsub = 0; dopsubtyp(T); T->count += T->countsub; if (DEBUGLEVEL) { fprintferr(" countsub = %ld\n", T->countsub); msgtimer("for this type"); if (T->subq) p1 = mulis(p1,lg(T->subqpart)-1); if (cmpis(p1,T->countsub)) { fprintferr(" alpha = %Z\n",p1); err(bugparier,"forsubgroup (alpha != countsub)"); } } } }}

char *tmp, *s = analyseur; long len, alloc;

char *tmp; long len; int alloc = 1;

expand_string(char *bp, char **ptbuf, char **ptlimit){ char *tmp, *s = analyseur; long len, alloc; while (is_keyword_char(*s)) s++; if ((*s == '"' || *s == ',' || *s == ')') && !is_entry(analyseur)) { /* Do not create new user variable. Consider as a literal */ tmp = analyseur; len = s - analyseur; analyseur = s; alloc = 0; } else { gpmem_t av = avma; GEN p1 = expr(); if (br_status) err(breaker,"here (expanding string)"); tmp = GENtostr0(p1, &DFLT_OUTPUT, &gen_output); len = strlen(tmp); avma = av; alloc = 1; } if (ptlimit && bp + len > *ptlimit) bp = realloc_buf(bp, len, ptbuf,ptlimit); memcpy(bp,tmp,len); /* ignore trailing \0 */ if (alloc) free(tmp); return bp + len;}

while (is_keyword_char(*s)) s++;

if (is_keyword_char(*analyseur)) { char *s = analyseur; do s++; while (is_keyword_char(*s));

expand_string(char *bp, char **ptbuf, char **ptlimit){ char *tmp, *s = analyseur; long len, alloc; while (is_keyword_char(*s)) s++; if ((*s == '"' || *s == ',' || *s == ')') && !is_entry(analyseur)) { /* Do not create new user variable. Consider as a literal */ tmp = analyseur; len = s - analyseur; analyseur = s; alloc = 0; } else { gpmem_t av = avma; GEN p1 = expr(); if (br_status) err(breaker,"here (expanding string)"); tmp = GENtostr0(p1, &DFLT_OUTPUT, &gen_output); len = strlen(tmp); avma = av; alloc = 1; } if (ptlimit && bp + len > *ptlimit) bp = realloc_buf(bp, len, ptbuf,ptlimit); memcpy(bp,tmp,len); /* ignore trailing \0 */ if (alloc) free(tmp); return bp + len;}

if ((*s == '"' || *s == ',' || *s == ')') && !is_entry(analyseur)) { tmp = analyseur; len = s - analyseur; analyseur = s; alloc = 0;

if ((*s == '"' || *s == ',' || *s == ')') && !is_entry(analyseur)) { tmp = analyseur; len = s - analyseur; analyseur = s; alloc = 0; }

expand_string(char *bp, char **ptbuf, char **ptlimit){ char *tmp, *s = analyseur; long len, alloc; while (is_keyword_char(*s)) s++; if ((*s == '"' || *s == ',' || *s == ')') && !is_entry(analyseur)) { /* Do not create new user variable. Consider as a literal */ tmp = analyseur; len = s - analyseur; analyseur = s; alloc = 0; } else { gpmem_t av = avma; GEN p1 = expr(); if (br_status) err(breaker,"here (expanding string)"); tmp = GENtostr0(p1, &DFLT_OUTPUT, &gen_output); len = strlen(tmp); avma = av; alloc = 1; } if (ptlimit && bp + len > *ptlimit) bp = realloc_buf(bp, len, ptbuf,ptlimit); memcpy(bp,tmp,len); /* ignore trailing \0 */ if (alloc) free(tmp); return bp + len;}

else

if (alloc)

expand_string(char *bp, char **ptbuf, char **ptlimit){ char *tmp, *s = analyseur; long len, alloc; while (is_keyword_char(*s)) s++; if ((*s == '"' || *s == ',' || *s == ')') && !is_entry(analyseur)) { /* Do not create new user variable. Consider as a literal */ tmp = analyseur; len = s - analyseur; analyseur = s; alloc = 0; } else { gpmem_t av = avma; GEN p1 = expr(); if (br_status) err(breaker,"here (expanding string)"); tmp = GENtostr0(p1, &DFLT_OUTPUT, &gen_output); len = strlen(tmp); avma = av; alloc = 1; } if (ptlimit && bp + len > *ptlimit) bp = realloc_buf(bp, len, ptbuf,ptlimit); memcpy(bp,tmp,len); /* ignore trailing \0 */ if (alloc) free(tmp); return bp + len;}

alloc = 1;

expand_string(char *bp, char **ptbuf, char **ptlimit){ char *tmp, *s = analyseur; long len, alloc; while (is_keyword_char(*s)) s++; if ((*s == '"' || *s == ',' || *s == ')') && !is_entry(analyseur)) { /* Do not create new user variable. Consider as a literal */ tmp = analyseur; len = s - analyseur; analyseur = s; alloc = 0; } else { gpmem_t av = avma; GEN p1 = expr(); if (br_status) err(breaker,"here (expanding string)"); tmp = GENtostr0(p1, &DFLT_OUTPUT, &gen_output); len = strlen(tmp); avma = av; alloc = 1; } if (ptlimit && bp + len > *ptlimit) bp = realloc_buf(bp, len, ptbuf,ptlimit); memcpy(bp,tmp,len); /* ignore trailing \0 */ if (alloc) free(tmp); return bp + len;}

p1[2] = lpolx[v0]; LSB = _vec(p1);

p1[2] = lpolx[0]; LSB = _vec(p1);

subfieldsall(GEN nf){ long av=avma,av1,N,ld,i,v0; GEN pol,dpol,dg,LSB,NLSB,p1; nf = checknf(nf); pol = (GEN)nf[1]; v0 = varn(pol); N = deg(pol); dg = divisors(stoi(N)); ld = lg(dg)-1; if (DEBUGLEVEL) fprintferr("\n***** Entering subfields\n\npol = %Z\n",pol); p1 = cgetg(3,t_VEC); p1[1] = (long)pol; p1[2] = lpolx[v0]; LSB = _vec(p1); if (ld > 2) { FACTORDL = factor(absi((GEN)nf[3])); dpol = mulii(sqri((GEN)nf[4]),(GEN)nf[3]); for (i=2; i<ld; i++) { av1 = avma; NLSB = subfields_of_given_degree(nf,dpol, N / itos((GEN)dg[i])); if (lg(NLSB) > 1) LSB = concatsp(LSB,NLSB); else avma = av1; } } p1 = cgetg(3,t_VEC); p1[1] = (long)polx[v0]; p1[2] = (long)pol; LSB = concatsp(LSB, _vec(p1)); if (DEBUGLEVEL) fprintferr("\n***** Leaving subfields\n\n"); return gerepileupto(av, gcopy(LSB));}

p1[1] = (long)polx[v0];

p1[1] = (long)polx[0];

subfieldsall(GEN nf){ long av=avma,av1,N,ld,i,v0; GEN pol,dpol,dg,LSB,NLSB,p1; nf = checknf(nf); pol = (GEN)nf[1]; v0 = varn(pol); N = deg(pol); dg = divisors(stoi(N)); ld = lg(dg)-1; if (DEBUGLEVEL) fprintferr("\n***** Entering subfields\n\npol = %Z\n",pol); p1 = cgetg(3,t_VEC); p1[1] = (long)pol; p1[2] = lpolx[v0]; LSB = _vec(p1); if (ld > 2) { FACTORDL = factor(absi((GEN)nf[3])); dpol = mulii(sqri((GEN)nf[4]),(GEN)nf[3]); for (i=2; i<ld; i++) { av1 = avma; NLSB = subfields_of_given_degree(nf,dpol, N / itos((GEN)dg[i])); if (lg(NLSB) > 1) LSB = concatsp(LSB,NLSB); else avma = av1; } } p1 = cgetg(3,t_VEC); p1[1] = (long)polx[v0]; p1[2] = (long)pol; LSB = concatsp(LSB, _vec(p1)); if (DEBUGLEVEL) fprintferr("\n***** Leaving subfields\n\n"); return gerepileupto(av, gcopy(LSB));}

return gerepileupto(av, gcopy(LSB));

return gerepileupto(av, gcopy(fix_var(LSB,v0)));

subfieldsall(GEN nf){ long av=avma,av1,N,ld,i,v0; GEN pol,dpol,dg,LSB,NLSB,p1; nf = checknf(nf); pol = (GEN)nf[1]; v0 = varn(pol); N = deg(pol); dg = divisors(stoi(N)); ld = lg(dg)-1; if (DEBUGLEVEL) fprintferr("\n***** Entering subfields\n\npol = %Z\n",pol); p1 = cgetg(3,t_VEC); p1[1] = (long)pol; p1[2] = lpolx[v0]; LSB = _vec(p1); if (ld > 2) { FACTORDL = factor(absi((GEN)nf[3])); dpol = mulii(sqri((GEN)nf[4]),(GEN)nf[3]); for (i=2; i<ld; i++) { av1 = avma; NLSB = subfields_of_given_degree(nf,dpol, N / itos((GEN)dg[i])); if (lg(NLSB) > 1) LSB = concatsp(LSB,NLSB); else avma = av1; } } p1 = cgetg(3,t_VEC); p1[1] = (long)polx[v0]; p1[2] = (long)pol; LSB = concatsp(LSB, _vec(p1)); if (DEBUGLEVEL) fprintferr("\n***** Leaving subfields\n\n"); return gerepileupto(av, gcopy(LSB));}

lx=lg(x); y=cgetg(lx,tx); y[1]=x[1];

lx=lg(x); y=cgetg(lx,t_POL); y[1]=x[1];

gprec_w(GEN x, long pr){ long tx=typ(x),lx,i; GEN y; switch(tx) { case t_REAL: y=cgetr(pr); affrr(x,y); break; case t_POL: lx=lg(x); y=cgetg(lx,tx); y[1]=x[1]; for (i=2; i<lx; i++) y[i]=(long)gprec_w((GEN)x[i],pr); break; case t_COMPLEX: case t_POLMOD: case t_RFRAC: case t_VEC: case t_COL: case t_MAT: lx=lg(x); y=cgetg(lx,tx); for (i=1; i<lx; i++) y[i]=(long)gprec_w((GEN)x[i],pr); break; default: y=gprec(x,pr); } return y;}

rtems_status_code status; rtems_interval ticks_since_boot;

rtems_status_code status; rtems_interval ticks;

clock_t _times( struct tms *ptms){ rtems_status_code status; rtems_interval ticks_since_boot; if ( !ptms ) { errno = EFAULT; return -1; } /* "POSIX" does not seem to allow for not having a TOD */ status = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &ticks_since_boot ); if ( status != RTEMS_SUCCESSFUL ) { assert( 0 ); return -1; } /* * RTEMS has no notion of system versus user time and does * not (as of 3.2.0) keep track of CPU usage on a per task basis. */ ptms->tms_utime = ticks_since_boot; ptms->tms_stime = 0; ptms->tms_cutime = 0; ptms->tms_cstime = 0; return 0;}

status = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &ticks_since_boot );

status = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &ticks );

clock_t _times( struct tms *ptms){ rtems_status_code status; rtems_interval ticks_since_boot; if ( !ptms ) { errno = EFAULT; return -1; } /* "POSIX" does not seem to allow for not having a TOD */ status = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &ticks_since_boot ); if ( status != RTEMS_SUCCESSFUL ) { assert( 0 ); return -1; } /* * RTEMS has no notion of system versus user time and does * not (as of 3.2.0) keep track of CPU usage on a per task basis. */ ptms->tms_utime = ticks_since_boot; ptms->tms_stime = 0; ptms->tms_cutime = 0; ptms->tms_cstime = 0; return 0;}

* RTEMS has no notion of system versus user time and does * not (as of 3.2.0) keep track of CPU usage on a per task basis.

* RTEMS has no notion of system versus user time and although * a way to keep track of per task CPU usage was added since * 3.6.0, this routine does not utilize it yet.

clock_t _times( struct tms *ptms){ rtems_status_code status; rtems_interval ticks_since_boot; if ( !ptms ) { errno = EFAULT; return -1; } /* "POSIX" does not seem to allow for not having a TOD */ status = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &ticks_since_boot ); if ( status != RTEMS_SUCCESSFUL ) { assert( 0 ); return -1; } /* * RTEMS has no notion of system versus user time and does * not (as of 3.2.0) keep track of CPU usage on a per task basis. */ ptms->tms_utime = ticks_since_boot; ptms->tms_stime = 0; ptms->tms_cutime = 0; ptms->tms_cstime = 0; return 0;}

ptms->tms_utime = ticks_since_boot;

ptms->tms_utime = ticks;

clock_t _times( struct tms *ptms){ rtems_status_code status; rtems_interval ticks_since_boot; if ( !ptms ) { errno = EFAULT; return -1; } /* "POSIX" does not seem to allow for not having a TOD */ status = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &ticks_since_boot ); if ( status != RTEMS_SUCCESSFUL ) { assert( 0 ); return -1; } /* * RTEMS has no notion of system versus user time and does * not (as of 3.2.0) keep track of CPU usage on a per task basis. */ ptms->tms_utime = ticks_since_boot; ptms->tms_stime = 0; ptms->tms_cutime = 0; ptms->tms_cstime = 0; return 0;}

if (typ(x) != t_POL) return gscalcol(x, lg(A[1])-1); l=lgef(x)-1; if (l == 1) return zerocol(lg(A[1])-1);

if (typ(x) != t_POL) return gmul(x,(GEN)A[1]); l=lgef(x)-1; if (l == 1) return typ(A)==t_VEC? gzero: zerocol(lg(A[1])-1);

mulmat_pol(GEN A, GEN x){ long i,l; GEN z; if (typ(x) != t_POL) return gscalcol(x, lg(A[1])-1); l=lgef(x)-1; if (l == 1) return zerocol(lg(A[1])-1); x++; z = gmul((GEN)x[1], (GEN)A[1]); for (i=2; i<l ; i++) if (!gcmp0((GEN)x[i])) z = gadd(z, gmul((GEN)x[i], (GEN)A[i])); return z;}

j=1+bfffo(m); m<<=j; j = BITS_IN_LONG-j;

j=1+bfffo((ulong)m); m<<=j; j = BITS_IN_LONG-j;

element_powid_mod_p(GEN nf, long I, GEN n, GEN p){ ulong av = avma; long s,N,i,j,m; GEN y,p1; if (typ(n)!=t_INT) err(talker,"not an integer exponent in nfpow"); nf=checknf(nf); N=degpol(nf[1]); s=signe(n); if (!s || I == 1) return gscalcol_i(gun,N); p1 = n+2; m = *p1; y = zerocol(N); y[I] = un; j=1+bfffo(m); m<<=j; j = BITS_IN_LONG-j; for (i=lgefint(n)-2;;) { for (; j; m<<=1,j--) { y = element_sqri(nf, y); if (m<0) y=element_mulid(nf, y, I); y = FpV_red(y, p); } if (--i == 0) break; m = *++p1; j = BITS_IN_LONG; } if (s<0) y = FpV_red(element_inv(nf,y), p); return av==avma? gcopy(y): gerepileupto(av,y);}

if (!do_units) return gerepileupto(av0, gcopy(z));

if (!do_units) return gerepilecopy(av0, z);

ideallistzstarall(GEN bnf,long bound,long flag){ byteptr ptdif=diffptr; long lim,av0=avma,av,i,j,k,l,q2,lp1,q; long do_gen = flag & 1, do_units = flag & 2, big_id = !(flag & 4); GEN y,nf,p,z,z2,p1,p2,p3,fa,pr,ideal,lu,lu2,funits,racunit,embunit; nf = checknf(bnf); if (bound <= 0) return cgetg(1,t_VEC); z = cgetg(bound+1,t_VEC); for (i=2; i<=bound; i++) z[i] = lgetg(1,t_VEC); ideal = idmat(degpol(nf[1])); if (big_id) ideal = zidealstarinitall(nf,ideal,do_gen); z[1] = (long)_vec(ideal); if (do_units) { init_units(bnf,&funits,&racunit); lu = cgetg(bound+1,t_VEC); for (i=2; i<=bound; i++) lu[i]=lgetg(1,t_VEC); lu[1] = (long)_vec(logunitmatrix(nf,funits,racunit,ideal)); } p=cgeti(3); p[1]=evalsigne(1) | evallgefint(3); av=avma; lim=stack_lim(av,1); lu2 = embunit = NULL; /* gcc -Wall */ if (bound > (long)maxprime()) err(primer1); for (p[2]=0; p[2]<=bound; ) { p[2] += *ptdif++; if (DEBUGLEVEL>1) { fprintferr("%ld ",p[2]); flusherr(); } fa = primedec(nf,p); for (j=1; j<lg(fa); j++) { pr = (GEN)fa[j]; p1 = powgi(p,(GEN)pr[4]); if (is_bigint(p1) || (q = itos(p1)) > bound) continue; q2=q; ideal=pr; z2=dummycopy(z); if (do_units) lu2=dummycopy(lu); for (l=2; ;l++) { if (big_id) ideal = zidealstarinitall(nf,ideal,do_gen); if (do_units) embunit = logunitmatrix(nf,funits,racunit,ideal); for (i=q; i<=bound; i+=q) { p1 = (GEN)z[i/q]; lp1 = lg(p1); if (lp1 == 1) continue; p2 = cgetg(lp1,t_VEC); for (k=1; k<lp1; k++) if (big_id) p2[k] = (long)zidealstarinitjoin(nf,(GEN)p1[k],ideal,do_gen); else p2[k] = (long)idealmul(nf,(GEN)p1[k],ideal); z2[i] = (long)concatsp((GEN)z2[i],p2); if (do_units) { p1 = (GEN)lu[i/q]; p2 = cgetg(lp1,t_VEC); for (k=1; k<lp1; k++) p2[k] = (long)vconcat((GEN)p1[k],embunit); lu2[i] = (long)concatsp((GEN)lu2[i],p2); } } q *= q2; if ((ulong)q > (ulong)bound) break; ideal = idealpows(nf,pr,l); } z = z2; if (do_units) lu = lu2; } if (low_stack(lim, stack_lim(av,1))) { GEN *gptr[2]; gptr[0]=&z; gptr[1]=&lu; if(DEBUGMEM>1) err(warnmem,"ideallistzstarall"); gerepilemany(av,gptr,do_units?2:1); } } if (!do_units) return gerepileupto(av0, gcopy(z)); y = cgetg(3,t_VEC); y[1] = lcopy(z); lu2 = cgetg(lg(z),t_VEC); for (i=1; i<lg(z); i++) { p1=(GEN)z[i]; p2=(GEN)lu[i]; lp1=lg(p1); p3=cgetg(lp1,t_VEC); lu2[i]=(long)p3; for (j=1; j<lp1; j++) p3[j] = lmul(gmael(p1,j,5),(GEN)p2[j]); } y[2]=(long)lu2; return gerepileupto(av0, y);}

long av,tetpil,i,j,lp1; long do_units = flag & 2;

ulong av; long i,j,lp1, do_units = flag & 2;

ideallistarchall(GEN bnf,GEN list,GEN arch,long flag){ long av,tetpil,i,j,lp1; long do_units = flag & 2; GEN nf = checknf(bnf), p1,p2,p3,racunit,funits,lu2,lu,embunit,z,y; if (typ(list) != t_VEC || (do_units && lg(list) != 3)) err(typeer, "ideallistarch"); if (lg(list) == 1) return cgetg(1,t_VEC); if (do_units) { y = cgetg(3,t_VEC); z = (GEN)list[1]; lu= (GEN)list[2]; if (typ(lu) != t_VEC) err(typeer, "ideallistarch"); } else { z = list; y = lu = NULL; /* gcc -Wall */ } if (typ(z) != t_VEC) err(typeer, "ideallistarch"); z = ideallist_arch(nf,z,arch, flag & 1); if (!do_units) return z; y[1]=(long)z; av=avma; init_units(bnf,&funits,&racunit); lu2=cgetg(lg(z),t_VEC); for (i=1; i<lg(z); i++) { p1=(GEN)z[i]; p2=(GEN)lu[i]; lp1=lg(p1); p3=cgetg(lp1,t_VEC); lu2[i]=(long)p3; for (j=1; j<lp1; j++) { embunit = logunitmatrixarch(nf,funits,racunit,(GEN)p1[j]); p3[j] = lmul(gmael(p1,j,5), vconcat((GEN)p2[j],embunit)); } } tetpil=avma; y[2]=lpile(av,tetpil,gcopy(lu2)); return y;}

tetpil=avma; y[2]=lpile(av,tetpil,gcopy(lu2)); return y;

y[2]=lpilecopy(av,lu2); return y;

ideallistarchall(GEN bnf,GEN list,GEN arch,long flag){ long av,tetpil,i,j,lp1; long do_units = flag & 2; GEN nf = checknf(bnf), p1,p2,p3,racunit,funits,lu2,lu,embunit,z,y; if (typ(list) != t_VEC || (do_units && lg(list) != 3)) err(typeer, "ideallistarch"); if (lg(list) == 1) return cgetg(1,t_VEC); if (do_units) { y = cgetg(3,t_VEC); z = (GEN)list[1]; lu= (GEN)list[2]; if (typ(lu) != t_VEC) err(typeer, "ideallistarch"); } else { z = list; y = lu = NULL; /* gcc -Wall */ } if (typ(z) != t_VEC) err(typeer, "ideallistarch"); z = ideallist_arch(nf,z,arch, flag & 1); if (!do_units) return z; y[1]=(long)z; av=avma; init_units(bnf,&funits,&racunit); lu2=cgetg(lg(z),t_VEC); for (i=1; i<lg(z); i++) { p1=(GEN)z[i]; p2=(GEN)lu[i]; lp1=lg(p1); p3=cgetg(lp1,t_VEC); lu2[i]=(long)p3; for (j=1; j<lp1; j++) { embunit = logunitmatrixarch(nf,funits,racunit,(GEN)p1[j]); p3[j] = lmul(gmael(p1,j,5), vconcat((GEN)p2[j],embunit)); } } tetpil=avma; y[2]=lpile(av,tetpil,gcopy(lu2)); return y;}

rtems_unsigned32 n = rtems_get_index(*next_id);

uint32_t n = rtems_get_index(*next_id);

rtems_monitor_dname_next( void *object_information, rtems_monitor_dname_t *canonical_dname, rtems_id *next_id){ rtems_unsigned32 n = rtems_get_index(*next_id); rtems_driver_name_t *table = _IO_Driver_name_table; rtems_driver_name_t *np = 0;/* XXX should we be using _IO_Number_of_devices */ for (np = table + n ; n<_IO_Number_of_devices; n++, np++) if (np->device_name) goto done; *next_id = RTEMS_OBJECT_ID_FINAL; return 0;done: _Thread_Disable_dispatch(); /* * dummy up a fake id and name for this item */ canonical_dname->id = n; canonical_dname->name = rtems_build_name('-', '-', '-', '-'); *next_id += 1; return np;}

unsigned32 length = 0;

uint32_t length = 0;

rtems_monitor_driver_dump( rtems_monitor_driver_t *monitor_driver, boolean verbose){ unsigned32 length = 0; length += printf(" %d", monitor_driver->id); length += rtems_monitor_pad(13, length); length += printf("init: "); length += rtems_monitor_symbol_dump(&monitor_driver->initialization, verbose); length += printf("; control: "); length += rtems_monitor_symbol_dump(&monitor_driver->control, verbose); length += printf("\n"); length = 0; length += rtems_monitor_pad(13, length); length += printf("open: "); length += rtems_monitor_symbol_dump(&monitor_driver->open, verbose); length += printf("; close: "); length += rtems_monitor_symbol_dump(&monitor_driver->close, verbose); length += printf("\n"); length = 0; length += rtems_monitor_pad(13, length); length += printf("read: "); length += rtems_monitor_symbol_dump(&monitor_driver->read, verbose); length += printf("; write: "); length += rtems_monitor_symbol_dump(&monitor_driver->write, verbose); length += printf("\n"); length = 0;}

if (!group) { avma = av; return gzero; }

rnfconductor(GEN bnf, GEN polrel, long flag, long prec){ long av=avma,tetpil,R1,i,v; GEN nf,module,rnf,arch,bnr,group,p1,pol2; bnf = checkbnf(bnf); nf=(GEN)bnf[7]; if (typ(polrel)!=t_POL) err(typeer,"rnfconductor"); module=cgetg(3,t_VEC); R1=itos(gmael(nf,2,1)); v=varn(polrel); p1=unifpol((GEN)bnf[7],polrel,0); p1=denom(gtovec(p1)); pol2=gsubst(polrel,v,gdiv(polx[v],p1)); pol2=gmul(pol2,gpuigs(p1,degree(pol2))); if (flag) { rnf=rnfinitalg(bnf,pol2,DEFAULTPREC); module[1]=mael(rnf,3,1); } else { rnf=NULL; module[1]=rnfdiscf(nf,pol2)[1]; } arch=cgetg(R1+1,t_VEC); module[2]=(long)arch; for (i=1; i<=R1; i++) arch[i]=un; bnr=buchrayall(bnf,module,nf_INIT | nf_GEN,prec); group=rnfnormgroup0(bnr,pol2,rnf); tetpil=avma; return gerepile(av,tetpil,conductor(bnr,group,1,prec));}

return gerepileupto(av, subfields_of_given_degree(nf,dpol,di));

p1 = subfields_of_given_degree(nf,dpol,di); return gerepileupto(av, fix_var(p1,v0));

subfields(GEN nf,GEN d){ long av=avma,di,N,v0; GEN dpol,p1,pol; nf = checknf(nf); pol = (GEN)nf[1]; v0=varn(pol); N=deg(pol); di=itos(d); if (di==N) { p1 = cgetg(3,t_VEC); p1[1] = lcopy(pol); p1[2] = lpolx[v0]; return _vec(p1); } if (di==1) { p1 = cgetg(3,t_VEC); p1[1] = lpolx[v0]; p1[2] = lcopy(pol); return _vec(p1); } if (di<=0 || di>N || N%di) return cgetg(1,t_VEC); FACTORDL = factor(absi((GEN)nf[3])); dpol = mulii((GEN)nf[3],sqri((GEN)nf[4])); return gerepileupto(av, subfields_of_given_degree(nf,dpol,di));}

return (sem_t *) -1;

return SEM_FAILED;

sem_t *sem_open( const char *name, int oflag, ... /* mode_t mode, */ /* unsigned int value */){ va_list arg; mode_t mode; unsigned int value = 0; int status; Objects_Id the_semaphore_id; POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; if ( oflag & O_CREAT ) { va_start(arg, oflag); /*mode = (mode_t) va_arg( arg, mode_t * );*/ mode = va_arg( arg, mode_t ); /*value = (unsigned int) va_arg( arg, unsigned int * );*/ value = va_arg( arg, unsigned int ); va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); /* * If the name to id translation worked, then the semaphore exists * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { if ( status == EINVAL ) { /* name -> ID translation failed */ if ( !(oflag & O_CREAT) ) { /* willing to create it? */ set_errno_and_return_minus_one_cast( ENOENT, sem_t * ); } /* we are willing to create it */ } /* some type of error */ /*set_errno_and_return_minus_one_cast( status, sem_t * );*/ } else { /* name -> ID translation succeeded */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } /* * XXX In this case we need to do an ID->pointer conversion to * check the mode. This is probably a good place for a subroutine. */ the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); the_semaphore->open_count += 1; return (sem_t *)&the_semaphore->Object.id; } /* XXX verify this comment... * * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status = _POSIX_Semaphore_Create_support( name, FALSE, /* not shared across processes */ value, &the_semaphore ); if ( status == -1 ) return (sem_t *) -1; return (sem_t *) &the_semaphore->Object.id; }

avma = av; y = cgetr(3); y[1] = evalexpo(itos(x)); y[2] = 0; return y;

avma = av; return realzero_bit(itos(x));

gpow(GEN x, GEN n, long prec){ long av,tetpil,i,lx,tx; GEN y; if (typ(n)==t_INT) return powgi(x,n); tx = typ(x); if (is_matvec_t(tx)) { lx=lg(x); y=cgetg(lx,tx); for (i=1; i<lx; i++) y[i]=lpui((GEN)x[i],n,prec); return y; } if (tx==t_SER) { if (valp(x)) err(talker,"not an integer exponent for non invertible series in gpow"); if (lg(x) == 2) return gcopy(x); /* O(1) */ return ser_pui(x,n,prec); } av=avma; if (gcmp0(x)) { long tn = typ(n); if (!is_scalar_t(tn) || tn == t_PADIC || tn == t_INTMOD) err(talker,"zero to a forbidden power in gpow"); n = greal(n); if (gsigne(n) <= 0) err(talker,"zero to a non positive exponent in gpow"); if (!precision(x)) return gcopy(x); x = ground(gmulsg(gexpo(x),n)); if (is_bigint(x) || (ulong)x[2] >= (ulong)HIGHEXPOBIT) err(talker,"underflow or overflow in gpow"); avma = av; y = cgetr(3); y[1] = evalexpo(itos(x)); y[2] = 0; return y; } if (tx==t_INTMOD && typ(n)==t_FRAC) { GEN p1; if (!isprime((GEN)x[1])) err(talker,"modulus must be prime in gpow"); y=cgetg(3,tx); copyifstack(x[1],y[1]); av=avma; p1=mpsqrtnmod((GEN)x[2],(GEN)n[2],(GEN)x[1],NULL); if(!p1) err(talker,"n-root does not exists in gpow"); p1=powmodulo(p1,(GEN)n[1],(GEN)x[1]); y[2]=lpileupto(av,p1); return y; } i = (long) precision(n); if (i) prec=i; y=gmul(n,glog(x,prec)); tetpil=avma; return gerepile(av,tetpil,gexp(y,prec));}

powpolmod(Cache *C, Red *R, int p, int k, GEN jac)

powpolmod(Cache *C, Red *R, long p, long k, GEN jac)

powpolmod(Cache *C, Red *R, int p, int k, GEN jac){ GEN (*_sqr)(GEN, Red *); if (DEBUGLEVEL>2) C->ctsgt++; if (C->matvite) return _powpolmodsimple(C, R, jac); if (p == 2) /* p = 2 */ { if (k == 2) _sqr = &sqrmod4; else _sqr = &sqrmod; R->n = k; R->red = &_red_cyclo2n; } else if (k == 1) { if (p == 3) _sqr = &sqrmod3; else if (p == 5) _sqr = &sqrmod5; else _sqr = &sqrmod; R->n = p; R->red = &_red_cyclop; } else { R->red = &_red; _sqr = &sqrmod; } return _powpolmod(C, jac, R, _sqr);}