int
_mpq_cmp_si (mpq_srcptr q, long n, unsigned long d)
{
/* need canonical sign to get right result */
ASSERT (SIZ(DEN(q)) > 0);
if (SIZ(NUM(q)) >= 0)
{
if (n >= 0)
return _mpq_cmp_ui (q, n, d); /* >=0 cmp >=0 */
else
return 1; /* >=0 cmp <0 */
}
else
{
if (n >= 0)
return -1; /* <0 cmp >=0 */
else
{
mpq_t qabs;
SIZ(NUM(qabs)) = ABSIZ(NUM(q));
PTR(NUM(qabs)) = PTR(NUM(q));
SIZ(DEN(qabs)) = SIZ(DEN(q));
PTR(DEN(qabs)) = PTR(DEN(q));
return - _mpq_cmp_ui (qabs, NEG_CAST (unsigned long, n), d); /* <0 cmp <0 */
}
}
}
Object *Builtin_subtract(ListObject *arg, ListObject *context)
{
NumberObject *ret = NULL;
int i = 0;
while (i < arg->len)
{
Object *term = arg->arr[i];
if (Object_istype(term, NUMBER_OBJECT))
{
if (i == 0)
{
double init = NUM(term)->value;
if (arg->len == 1)
init = -init;
ret = new_NumberObject(init);
}
else
NUM(ret)->value -= NUM(term)->value;
}
else
{
if (ret != NULL)
del_Object(OBJ(ret));
ret = NULL;
break;
}
i++;
}
if (ret == NULL)
cause_error(INCORRECT_ARGUMENT_ERROR, "(<number> <number> ...)", 23);
return OBJ(ret);
}
void
mpq_set_ui (MP_RAT *dest, unsigned long int num, unsigned long int den)
{
if (GMP_NUMB_BITS < BITS_PER_ULONG)
{
if (num == 0) /* Canonicalize 0/d to 0/1. */
den = 1;
mpz_set_ui (mpq_numref (dest), num);
mpz_set_ui (mpq_denref (dest), den);
return;
}
if (num == 0)
{
/* Canonicalize 0/n to 0/1. */
den = 1;
SIZ(NUM(dest)) = 0;
}
else
{
PTR(NUM(dest))[0] = num;
SIZ(NUM(dest)) = 1;
}
PTR(DEN(dest))[0] = den;
SIZ(DEN(dest)) = (den != 0);
}
int main(){
int n,k,year,m,i,j;
char mon[12][12]={"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};
printf("输入年份\n");
scanf("%d",&year);
if(isleayear(year)==1 || year<2000)
n=(int)(fabs(year-2000)*365+(int)fabs(year-2000)/4)%7; //判断某年一月一号为星期几
else
n=(int)(fabs(year-2000)*365+(int)fabs(year-2000)/4+1)%7;
if(year<2000)n=7-n; //当年份小于2000是一月一号星期几
for(k=0;k<12;++k){
printf("%s\n日 一 二 三 四 五 六\n",mon[k]);
if(n==0) n+=7;
else
if(n==8)
n=1;
m=1;
for(j=0;j<n-1;++j)
printf(" ");
for(j=n-1;j<7;++j){
printf("%2d%c",m,j==6? '\n': ' ');
m=m+1;
}
for(i=1;i<=5;++i){
for(j=0;j<7&&m<=NUM(year,k);++j){
printf("%2d%c",m,j==6? '\n': ' ');
m=m+1;
if(m-1==NUM(year,k)){n=j+2;printf("\n");break;} //输出年历
}
}
}
return 0;
}
void
mpq_clear (MP_RAT *m)
{
(*__gmp_free_func) (PTR(NUM(m)),
ALLOC(NUM(m)) * BYTES_PER_MP_LIMB);
(*__gmp_free_func) (PTR(DEN(m)),
ALLOC(DEN(m)) * BYTES_PER_MP_LIMB);
}
void
mpq_clear (mpq_t m)
{
(*__gmp_free_func) (PTR(NUM(m)),
(size_t) ALLOC(NUM(m)) * GMP_LIMB_BYTES);
(*__gmp_free_func) (PTR(DEN(m)),
(size_t) ALLOC(DEN(m)) * GMP_LIMB_BYTES);
}
int
set_option_var(const option_t *options, const char *var, const char *val,
char *buf, size_t len)
{
char *s;
size_t i;
#define NUM(type) \
if (!*val) { \
*(type *)options[i].value = 1; \
break; \
} \
*(type *)options[i].value = (type)strsuftoll(options[i].desc, val, \
options[i].minimum, options[i].maximum); break
for (i = 0; options[i].name != NULL; i++) {
if (var[1] == '\0') {
if (options[i].letter != var[0])
continue;
} else if (strcmp(options[i].name, var) != 0)
continue;
switch (options[i].type) {
case OPT_BOOL:
*(bool *)options[i].value = 1;
break;
case OPT_STRARRAY:
strlcpy((void *)options[i].value, val, (size_t)
options[i].maximum);
break;
case OPT_STRPTR:
s = estrdup(val);
*(char **)options[i].value = s;
break;
case OPT_STRBUF:
if (buf == NULL)
abort();
strlcpy(buf, val, len);
break;
case OPT_INT64:
NUM(uint64_t);
case OPT_INT32:
NUM(uint32_t);
case OPT_INT16:
NUM(uint16_t);
case OPT_INT8:
NUM(uint8_t);
default:
warnx("Unknown type %d in option %s", options[i].type,
val);
return 0;
}
return i;
}
warnx("Unknown option `%s'", var);
return -1;
}
fz_off_t pdf_to_offset(fz_context *ctx, pdf_obj *obj)
{
RESOLVE(obj);
if (obj < PDF_OBJ__LIMIT)
return 0;
if (obj->kind == PDF_INT)
return NUM(obj)->u.i;
if (obj->kind == PDF_REAL)
return (fz_off_t)(NUM(obj)->u.f + 0.5f); /* No roundf in MSVC */
return 0;
}
float pdf_to_real(fz_context *ctx, pdf_obj *obj)
{
RESOLVE(obj);
if (obj < PDF_OBJ__LIMIT)
return 0;
if (obj->kind == PDF_REAL)
return NUM(obj)->u.f;
if (obj->kind == PDF_INT)
return NUM(obj)->u.i;
return 0;
}
PUBLIC INLINE void apply_closure(VMSTATE vms, OVECTOR closure, VECTOR argvec) {
if (closure == NULL || TAGGEDP(closure)) {
vm_raise(vms, (OBJ) newsym("invalid-callable"), (OBJ) closure);
} else if (closure->type == T_PRIM) {
int primargc;
prim_fn fnp = lookup_prim(NUM(AT(closure, PR_NUMBER)), &primargc);
if (fnp != NULL) {
if ((primargc >= 0 && argvec->_.length-1 != primargc) ||
(primargc < 0 && argvec->_.length-1 < -primargc))
vm_raise(vms, (OBJ) newsym("wrong-argc"), (OBJ) closure);
else
vms->r->vm_acc = fnp(vms, argvec);
} else
vm_raise(vms, (OBJ) newsym("invalid-primitive"), AT(closure, PR_NUMBER));
} else if (closure->type == T_CLOSURE) {
OVECTOR meth = (OVECTOR) AT(closure, CL_METHOD);
if (!MS_CAN_X(meth, vms->r->vm_effuid)) {
vm_raise(vms, (OBJ) newsym("no-permission"), AT(meth, ME_NAME));
return;
}
if (argvec->_.length-1 != NUM(AT(meth, ME_ARGC))) {
vm_raise(vms, (OBJ) newsym("wrong-argc"), (OBJ) meth);
return;
}
push_frame(vms);
vms->r->vm_env = argvec;
ATPUT(vms->r->vm_env, 0, AT(meth, ME_ENV));
vms->r->vm_lits = (VECTOR) AT(meth, ME_LITS);
vms->r->vm_code = (BVECTOR) AT(meth, ME_CODE);
vms->r->vm_self = (OBJECT) AT(closure, CL_SELF);
vms->c.vm_ip = 0;
vms->r->vm_method = meth;
if (NUM(AT(meth, ME_FLAGS)) & O_SETUID)
vms->r->vm_effuid = (OBJECT) AT(meth, ME_OWNER);
} else if (closure->type == T_CONTINUATION) {
int i;
VECTOR cstk = (VECTOR) AT(closure, CONT_STACK);
for (i = 0; i < cstk->_.length; i++)
ATPUT(vms->r->vm_stack, i, AT(cstk, i));
vms->c.vm_top = cstk->_.length;
restoreframe(vms, (OVECTOR) AT(closure, CONT_FRAME));
vms->r->vm_acc = AT(argvec, 1);
} else {
vm_raise(vms, (OBJ) newsym("invalid-callable"), (OBJ) closure);
}
}
void
mpq_set_num (mpq_ptr dest, mpz_srcptr num)
{
mp_size_t size = SIZ (num);
mp_size_t abs_size = ABS (size);
mp_ptr dp;
dp = MPZ_NEWALLOC (NUM(dest), abs_size);
SIZ(NUM(dest)) = size;
MPN_COPY (dp, PTR(num), abs_size);
}
int scull_w_open (struct inode *inode, struct file *filp)
{
Scull_Dev *dev = &scull_w_device; /* device information */
int num = NUM(inode->i_rdev);
if (num > 0) return -ENODEV; /* 1 device only */
while (scull_w_count &&
(scull_w_owner != current->uid) && /* allow user */
(scull_w_owner != current->euid) && /* allow whoever did su */
!suser()) {
if (filp->f_flags & O_NONBLOCK) return -EAGAIN;
interruptible_sleep_on(&scull_w_wait);
if (current->signal & ~current->blocked) /* a signal arrived */
return -ERESTARTSYS; /* tell the fs layer to handle it */
/* else, loop */
}
if (scull_w_count == 0)
scull_w_owner = current->uid; /* grab it */
scull_w_count++;
/* then, everything else is copied from the bare scull device */
if ( (filp->f_flags & O_ACCMODE) == O_WRONLY)
scull_trim(dev);
filp->private_data = dev;
MOD_INC_USE_COUNT;
return 0; /* success */
}
object *number_str(const char *s)
{
object *p = ALLOC(object);
TYPE(p) = OBJ_NUMBER;
sscanf(s, "%d", &NUM(p));
return p;
}
static void
fillstat(Dir *d, uint32_t path)
{
Tab *t;
int type;
char buf[32];
memset(d, 0, sizeof(*d));
d->uid = estrdup("exec");
d->gid = estrdup("exec");
d->qid.path = path;
d->atime = d->mtime = time0;
d->length = 0;
type = TYPE(path);
t = &tab[type];
if(t->name)
d->name = estrdup(t->name);
else{
snprint(buf, sizeof buf, "%u", NUM(path));
d->name = estrdup(buf);
}
d->qid.type = t->mode>>24;
d->mode = t->mode;
}
int scull_u_open (struct inode *inode, struct file *filp)
{
Scull_Dev *dev = &scull_u_device; /* device information */
int num = NUM(inode->i_rdev);
if (num > 0) return -ENODEV; /* 1 device only */
if (scull_u_count &&
(scull_u_owner != current->uid) && /* allow user */
(scull_u_owner != current->euid) && /* allow whoever did su */
!suser()) /* still allow root */
return -EBUSY; /* -EPERM would confuse the user */
if (scull_u_count == 0)
scull_u_owner = current->uid; /* grab it */
scull_u_count++;
/* then, everything else is copied from the bare scull device */
if ( (filp->f_flags & O_ACCMODE) == O_WRONLY)
scull_trim(dev);
filp->private_data = dev;
MOD_INC_USE_COUNT;
return 0; /* success */
}
int scull_open (struct inode *inode, struct file *filp)
{
int type = TYPE(inode->i_rdev);
int num = NUM(inode->i_rdev);
Scull_Dev *dev; /* device information */
/* manage peculiar types first */
if (type) {
if (type > SCULL_MAX_TYPE) return -ENODEV;
filp->f_op = scull_fop_array[type];
return filp->f_op->open(inode, filp); /* dispatch to specific open */
}
/* type 0, check the device number */
if (num >= scull_nr_devs) return -ENODEV;
dev = &scull_devices[num];
/* now trim to 0 the length of the device if open was write-only */
if ( (filp->f_flags & O_ACCMODE) == O_WRONLY)
scull_trim(dev); /* ignore errors */
/* and use filp->private_data to point to the device data */
filp->private_data = dev;
MOD_INC_USE_COUNT;
return 0; /* success */
}
/* Early initialization of comm channels.
*/
void
cyg_hal_plf_serial_init(void)
{
hal_virtual_comm_table_t* comm;
int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
int chan = 0;
struct port_info *port;
static int init = 0;
if (init) return;
init++;
// Setup procs in the vector table
for (port = ports, chan = 0; chan < NUM(ports); chan++, port++) {
CYGACC_CALL_IF_SET_CONSOLE_COMM(chan);
comm = CYGACC_CALL_IF_CONSOLE_PROCS();
CYGACC_COMM_IF_CH_DATA_SET(*comm, port);
CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_serial_write);
CYGACC_COMM_IF_READ_SET(*comm, cyg_hal_plf_serial_read);
CYGACC_COMM_IF_PUTC_SET(*comm, cyg_hal_plf_serial_putc);
CYGACC_COMM_IF_GETC_SET(*comm, cyg_hal_plf_serial_getc);
CYGACC_COMM_IF_CONTROL_SET(*comm, cyg_hal_plf_serial_control);
CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_serial_getc_timeout);
if (port->is_smc) {
cyg_hal_plf_smcx_init_channel(port, port->cpm_page);
CYGACC_COMM_IF_DBG_ISR_SET(*comm, cyg_hal_plf_smcx_isr);
} else {
cyg_hal_plf_sccx_init_channel(port, port->cpm_page);
CYGACC_COMM_IF_DBG_ISR_SET(*comm, cyg_hal_plf_sccx_isr);
}
}
// Restore original console
CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);
}
void
mpq_set_z (mpq_ptr dest, mpz_srcptr src)
{
mp_size_t num_size;
mp_size_t abs_num_size;
mp_ptr dp;
num_size = SIZ (src);
abs_num_size = ABS (num_size);
dp = MPZ_NEWALLOC (NUM(dest), abs_num_size);
SIZ(NUM(dest)) = num_size;
MPN_COPY (dp, PTR(src), abs_num_size);
PTR(DEN(dest))[0] = 1;
SIZ(DEN(dest)) = 1;
}
void
mpq_init (MP_RAT *x)
{
ALLOC(NUM(x)) = 1;
PTR(NUM(x)) = (mp_ptr) (*__gmp_allocate_func) (BYTES_PER_MP_LIMB);
SIZ(NUM(x)) = 0;
ALLOC(DEN(x)) = 1;
PTR(DEN(x)) = (mp_ptr) (*__gmp_allocate_func) (BYTES_PER_MP_LIMB);
PTR(DEN(x))[0] = 1;
SIZ(DEN(x)) = 1;
#ifdef __CHECKER__
/* let the low limb look initialized, for the benefit of mpz_get_ui etc */
PTR(NUM(x))[0] = 0;
#endif
}
object *number_int(int n)
{
object *p = ALLOC(object);
TYPE(p) = OBJ_NUMBER;
NUM(p) = n;
return p;
}
void
mpq_init (mpq_t x)
{
ALLOC(NUM(x)) = 1;
PTR(NUM(x)) = __GMP_ALLOCATE_FUNC_LIMBS (1);
SIZ(NUM(x)) = 0;
ALLOC(DEN(x)) = 1;
PTR(DEN(x)) = __GMP_ALLOCATE_FUNC_LIMBS (1);
PTR(DEN(x))[0] = 1;
SIZ(DEN(x)) = 1;
#ifdef __CHECKER__
/* let the low limb look initialized, for the benefit of mpz_get_ui etc */
PTR(NUM(x))[0] = 0;
#endif
}
int scull_p_open (struct inode *inode, struct file *filp)
{
Scull_Pipe *dev;
int num = NUM(inode->i_rdev);
if (num >= scull_p_nr_devs) return -ENODEV;
dev = &scull_p_devices[num];
if (down_interruptible (&dev->sem))
return -ERESTARTSYS;
if (!dev->buffer) { /* allocate the buffer */
dev->buffer = kmalloc(scull_p_buffer, GFP_KERNEL);
if (!dev->buffer) {
up (&dev->sem);
return -ENOMEM;
}
}
dev->buffersize = scull_p_buffer;
dev->end = dev->buffer + dev->buffersize;
dev->rp = dev->wp = dev->buffer; /* rd and wr from the beginning */
/* use f_mode,not f_flags: it's cleaner (fs/open.c tells why) */
if (filp->f_mode & FMODE_READ)
dev->nreaders++;
if (filp->f_mode & FMODE_WRITE)
dev->nwriters++;
up (&dev->sem);
filp->private_data = dev;
MOD_INC_USE_COUNT;
return 0;
}
void Ulong_bigmult(BigInt a,
unsigned long sb,
BigInt c,
int offset)
#endif
{
unsigned long m, carry;
unsigned long *ap, *cp;
int gap, i;
i = LENGTH(a) + offset;
GUARANTEE(c, (int)(i + 2));
gap = LENGTH(c) - i;
if (gap < 0) {
i = -gap;
cp = NUM(c) + LENGTH(c);
do {
*cp++ = (unsigned long)0;
} while (--i >= 0);
}
ap = NUM(a);
m = sb;
cp = NUM(c) + offset;
carry = LMULT(cp, m, ap, (int)LENGTH(a));
cp += LENGTH(a);
if ((i=gap) > 0) {
do {
cp[0] = cp[0] + carry;
carry = (cp[0] < carry);
cp++;
} while ((carry != 0) && (--i > 0));
}
else
LENGTH(c) = (int)(offset + LENGTH(a));
if (carry) {
*cp++ = carry;
LENGTH(c)++;
}
trim(c);
}
SEXP graph_prior_prob(SEXP prior, SEXP target, SEXP cache, SEXP beta,
SEXP debug) {
double *b = NULL;
const char *pr = CHAR(STRING_ELT(prior, 0));
SEXP prob, parents, children;
/* allocate the return value. */
PROTECT(prob = allocVector(REALSXP, 1));
/* match the label of the prior. */
if (strcmp(pr, "uniform") == 0) {
/* constant prior, log(1) = 0 for backward compatibility. */
NUM(prob) = 0;
}/*THEN*/
else if (strcmp(pr, "vsp") == 0) {
parents = getListElement(cache, "parents");
/* variable selection prior, each arc has independent beta probability
* fo inclusion. */
b = REAL(beta);
NUM(prob) = LENGTH(parents) * log(*b / (1 - *b));
}/*THEN*/
else if (strcmp(pr, "cs") == 0) {
parents = getListElement(cache, "parents");
children = getListElement(cache, "children");
/* completed prior from Castelo and Siebes. */
if (beta == R_NilValue)
NUM(prob) = 0;
else
NUM(prob) = castelo_prior(beta, target, parents, children, debug);
}/*THEN*/
UNPROTECT(1);
return prob;
}/*GRAPH_PRIOR_PROB*/
void
mpq_set (mpq_ptr dest, mpq_srcptr src)
{
mp_size_t num_size, den_size;
mp_size_t abs_num_size;
mp_ptr dp;
num_size = SIZ(NUM(src));
SIZ(NUM(dest)) = num_size;
abs_num_size = ABS (num_size);
dp = MPZ_NEWALLOC (NUM(dest), abs_num_size);
MPN_COPY (dp, PTR(NUM(src)), abs_num_size);
den_size = SIZ(DEN(src));
SIZ(DEN(dest)) = den_size;
dp = MPZ_NEWALLOC (DEN(dest), den_size);
MPN_COPY (dp, PTR(DEN(src)), den_size);
}
int
tr_httpResponseCode( const char * data, int len )
{
char code[4];
int ret;
/* check for the minimum legal length */
if( 12 > len ||
/* check for valid http version */
0 != tr_strncasecmp( data, "HTTP/1.", 7 ) ||
( '1' != data[7] && '0' != data[7] ) ||
/* there should be at least one space after the version */
!SP( data[8] ) )
{
return -1;
}
/* skip any extra spaces */
data += 9;
len -= 9;
while( 0 < len && SP( *data ) )
{
data++;
len--;
}
/* check for a valid three-digit code */
if( 3 > len || !NUM( data[0] ) || !NUM( data[1] ) || !NUM( data[2] ) ||
( 3 < len && NUM( data[3] ) ) )
{
return -1;
}
/* parse and return the code */
memcpy( code, data, 3 );
code[3] = '\0';
ret = strtol( code, NULL, 10 );
if( 100 > ret )
{
ret = -1;
}
return ret;
}
PRIVATE INLINE void restoreframe(VMSTATE vms, OVECTOR f) {
vms->r->vm_code = (BVECTOR) AT(f, FR_CODE);
vms->c.vm_ip = NUM(AT(f, FR_IP));
vms->r->vm_self = (OBJECT) AT(f, FR_SELF);
vms->r->vm_lits = (VECTOR) AT(f, FR_LITS);
vms->r->vm_env = (VECTOR) AT(f, FR_ENV);
vms->r->vm_frame = (OVECTOR) AT(f, FR_FRAME);
vms->r->vm_method = (OVECTOR) AT(f, FR_METHOD);
vms->r->vm_effuid = (OBJECT) AT(f, FR_EFFUID);
}
/*
* Helper function used in show_stat: received a size,
* it changes the unit from Kb to Mb to Gb if size > 1024(previous unit)
*/
void change_unit(float size, char *str) {
char *unit[] = {"B", "KB", "MB", "GB", "TB"};
int i = 0;
while ((size > 1024) && (i < NUM(unit) - 1)) {
size /= 1024;
i++;
}
sprintf(str, "%.2f%s", size, unit[i]);
}
void
mpq_abs (mpq_ptr dst, mpq_srcptr src)
{
mp_size_t num_abs_size = ABSIZ(NUM(src));
if (dst != src)
{
mp_size_t den_size = SIZ(DEN(src));
mp_ptr dp;
dp = MPZ_NEWALLOC (NUM(dst), num_abs_size);
MPN_COPY (dp, PTR(NUM(src)), num_abs_size);
dp = MPZ_NEWALLOC (DEN(dst), den_size);
SIZ(DEN(dst)) = den_size;
MPN_COPY (dp, PTR(DEN(src)), den_size);
}
SIZ(NUM(dst)) = num_abs_size;
}
static void exec_help(const char* args, context_t* ctx, debug_t* dbg)
{
(void)args;
(void)ctx;
(void)dbg;
printf("The following commands are supported:\n");
for (size_t i = 0; i < NUM(commands); i++) {
printf("\t%s\n", commands[i].verb);
}
}
