inline static VALUE
f_divide(VALUE self, VALUE other,
VALUE (*func)(VALUE, VALUE), ID id)
{
if (k_complex_p(other)) {
int flo;
get_dat2(self, other);
flo = (k_float_p(adat->real) || k_float_p(adat->imag) ||
k_float_p(bdat->real) || k_float_p(bdat->imag));
if (f_gt_p(f_abs(bdat->real), f_abs(bdat->imag))) {
VALUE r, n;
r = (*func)(bdat->imag, bdat->real);
n = f_mul(bdat->real, f_add(ONE, f_mul(r, r)));
if (flo)
return f_complex_new2(CLASS_OF(self),
(*func)(self, n),
(*func)(f_negate(f_mul(self, r)), n));
return f_complex_new2(CLASS_OF(self),
(*func)(f_add(adat->real,
f_mul(adat->imag, r)), n),
(*func)(f_sub(adat->imag,
f_mul(adat->real, r)), n));
}
else {
VALUE r, n;
r = (*func)(bdat->real, bdat->imag);
n = f_mul(bdat->imag, f_add(ONE, f_mul(r, r)));
if (flo)
return f_complex_new2(CLASS_OF(self),
(*func)(f_mul(self, r), n),
(*func)(f_negate(self), n));
return f_complex_new2(CLASS_OF(self),
(*func)(f_add(f_mul(adat->real, r),
adat->imag), n),
(*func)(f_sub(f_mul(adat->imag, r),
adat->real), n));
}
}
if (k_numeric_p(other) && f_real_p(other)) {
get_dat1(self);
return f_complex_new2(CLASS_OF(self),
(*func)(dat->real, other),
(*func)(dat->imag, other));
}
return rb_num_coerce_bin(self, other, id);
}
inline static VALUE
f_addsub(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k)
{
VALUE num, den;
if (FIXNUM_P(anum) && FIXNUM_P(aden) &&
FIXNUM_P(bnum) && FIXNUM_P(bden)) {
long an = FIX2LONG(anum);
long ad = FIX2LONG(aden);
long bn = FIX2LONG(bnum);
long bd = FIX2LONG(bden);
long ig = i_gcd(ad, bd);
VALUE g = LONG2NUM(ig);
VALUE a = f_imul(an, bd / ig);
VALUE b = f_imul(bn, ad / ig);
VALUE c;
if (k == '+')
c = f_add(a, b);
else
c = f_sub(a, b);
b = f_idiv(aden, g);
g = f_gcd(c, g);
num = f_idiv(c, g);
a = f_idiv(bden, g);
den = f_mul(a, b);
}
else {
VALUE g = f_gcd(aden, bden);
VALUE a = f_mul(anum, f_idiv(bden, g));
VALUE b = f_mul(bnum, f_idiv(aden, g));
VALUE c;
if (k == '+')
c = f_add(a, b);
else
c = f_sub(a, b);
b = f_idiv(aden, g);
g = f_gcd(c, g);
num = f_idiv(c, g);
a = f_idiv(bden, g);
den = f_mul(a, b);
}
return f_rational_new_no_reduce2(CLASS_OF(self), num, den);
}
/*
* call-seq:
* rat + numeric -> numeric_result
*
* Performs addition.
*
* For example:
*
* Rational(2, 3) + Rational(2, 3) #=> (4/3)
* Rational(900) + Rational(1) #=> (900/1)
* Rational(-2, 9) + Rational(-9, 2) #=> (-85/18)
* Rational(9, 8) + 4 #=> (41/8)
* Rational(20, 9) + 9.8 #=> 12.022222222222222
*/
static VALUE
nurat_add(VALUE self, SEL sel, VALUE other)
{
switch (TYPE(other)) {
case T_FIXNUM:
case T_BIGNUM:
{
get_dat1(self);
return f_addsub(self,
dat->num, dat->den,
other, ONE, '+');
}
case T_FLOAT:
return f_add(f_to_f(self), other);
case T_RATIONAL:
{
get_dat2(self, other);
return f_addsub(self,
adat->num, adat->den,
bdat->num, bdat->den, '+');
}
default:
return rb_num_coerce_bin(self, other, '+');
}
}
/*
void adder2::unpack(s_grid2& G, const Region2& R, double *buf)
add buf to s_grid g when called
*/
void adder2::unpack(s_grid2& G, const Region2& R, double *buf)
{
FortranRegion g_extents(G.region());
FortranRegion b_extents(R);
f_add(FORTRAN_DATA(G), FORTRAN_REGION2(g_extents),
buf, FORTRAN_REGION2(b_extents), FORTRAN_REGION2(b_extents));
}
/*
* call-seq:
* cmp * numeric -> complex
*
* Performs multiplication.
*
* Complex(2, 3) * Complex(2, 3) #=> (-5+12i)
* Complex(900) * Complex(1) #=> (900+0i)
* Complex(-2, 9) * Complex(-9, 2) #=> (0-85i)
* Complex(9, 8) * 4 #=> (36+32i)
* Complex(20, 9) * 9.8 #=> (196.0+88.2i)
*/
VALUE
rb_nucomp_mul(VALUE self, VALUE other)
{
if (k_complex_p(other)) {
VALUE real, imag;
VALUE areal, aimag, breal, bimag;
int arzero, aizero, brzero, bizero;
get_dat2(self, other);
arzero = !!f_zero_p(areal = adat->real);
aizero = !!f_zero_p(aimag = adat->imag);
brzero = !!f_zero_p(breal = bdat->real);
bizero = !!f_zero_p(bimag = bdat->imag);
real = f_sub(safe_mul(areal, breal, arzero, brzero),
safe_mul(aimag, bimag, aizero, bizero));
imag = f_add(safe_mul(areal, bimag, arzero, bizero),
safe_mul(aimag, breal, aizero, brzero));
return f_complex_new2(CLASS_OF(self), real, imag);
}
if (k_numeric_p(other) && f_real_p(other)) {
get_dat1(self);
return f_complex_new2(CLASS_OF(self),
f_mul(dat->real, other),
f_mul(dat->imag, other));
}
return rb_num_coerce_bin(self, other, '*');
}
/*
* call-seq:
* cmp.abs2 -> real
*
* Returns square of the absolute value.
*
* Complex(-1).abs2 #=> 1
* Complex(3.0, -4.0).abs2 #=> 25.0
*/
static VALUE
nucomp_abs2(VALUE self)
{
get_dat1(self);
return f_add(f_mul(dat->real, dat->real),
f_mul(dat->imag, dat->imag));
}
/* evaluate an expression, eval_err will indicate it any expression
evaluation occurs */
static struct eval_value_t /* value of the expression */
expr(struct eval_state_t *es) /* expression evaluator */
{
enum eval_token_t tok;
struct eval_value_t val;
val = term(es);
if (eval_error)
return err_value;
tok = peek_next_token(es);
switch (tok)
{
case tok_plus:
(void)get_next_token(es);
val = f_add(val, expr(es));
if (eval_error)
return err_value;
break;
case tok_minus:
(void)get_next_token(es);
val = f_sub(val, expr(es));
if (eval_error)
return err_value;
break;
default:;
}
return val;
}
int main()
{
Any x = Int(1);
Any y = Int(3);
Any r = f_add(x, y);
println(r);
}
static VALUE
nurat_round(VALUE self)
{
get_dat1(self);
if (f_negative_p(dat->num)) {
VALUE num, den;
num = f_negate(dat->num);
num = f_add(f_mul(num, TWO), dat->den);
den = f_mul(dat->den, TWO);
return f_negate(f_idiv(num, den));
}
else {
VALUE num = f_add(f_mul(dat->num, TWO), dat->den);
VALUE den = f_mul(dat->den, TWO);
return f_idiv(num, den);
}
}
/*
void adder2::copy(const s_grid2& S, const Region2& F, s_grid2& D, const Region2& T)
add s_grid D to s_grid S when called
*/
void adder2::copy(const s_grid2& S, const Region2& F, s_grid2& D, const Region2& T)
{
FortranRegion s_extents(S.region());
FortranRegion d_extents(D.region());
FortranRegion t_extents(T);
f_add(FORTRAN_DATA(D), FORTRAN_REGION2(d_extents),
FORTRAN_DATA(S), FORTRAN_REGION2(s_extents),
FORTRAN_REGION2(t_extents));
}
void foo() {
if(s->type == T_INT && count->type == T_INT)
s->u.integer+=count->u.integer;
else {
push_svalue(s); push_svalue(count); f_add(2);
mapping_string_insert(mappingen, key, Pike_sp-1); pop_stack();
}
if(s->type == T_INT && count->type == T_INT &&
!INT_TYPE_ADD_OVERFLOW(count->u.integer, s->u.integer))
{ /*fast
add*/} else { /*f_add*/ }
}
static VALUE
nucomp_add(VALUE self, VALUE other)
{
if (k_complex_p(other)) {
VALUE real, imag;
get_dat2(self, other);
real = f_add(adat->real, bdat->real);
imag = f_add(adat->imag, bdat->imag);
return f_complex_new2(CLASS_OF(self), real, imag);
}
if (k_numeric_p(other) && f_real_p(other)) {
get_dat1(self);
return f_complex_new2(CLASS_OF(self),
f_add(dat->real, other), dat->imag);
}
return rb_num_coerce_bin(self, other, '+');
}
void main( ){
// stress testing join (for perf)
t t0;
t t1;
t t2;
t t;
// add several randomly chosen vectors
f_zero( & t );
if( rand )
f_zero( & t0 );
else
f_set( & t0, 1, 2 );
f_add( & t, & t0 );
if( rand )
f_zero( & t0 );
else
f_set( & t0, 1, 2 );
f_add( & t, & t0 );
if( rand )
f_zero( & t0 );
else
f_set( & t0, 1, 2 );
f_add( & t, & t0 );
if( rand )
f_zero( & t1 );
else
f_set( & t1, 1, 2 );
f_add( & t, & t1 );
if( rand )
f_zero( & t2 );
else
f_set( & t2, 1, 2 );
f_add( & t, & t2 );
// check-up assertions
assert( 0 <= t.x );
assert( t.x <= 5 );
assert( 0 <= t.y );
assert( t.y <= 10 );
}
inline static VALUE
nucomp_s_canonicalize_internal(VALUE klass, VALUE real, VALUE imag)
{
#ifdef CANON
#define CL_CANON
#ifdef CL_CANON
if (k_exact_zero_p(imag) && canonicalization)
return real;
#else
if (f_zero_p(imag) && canonicalization)
return real;
#endif
#endif
if (f_real_p(real) && f_real_p(imag))
return nucomp_s_new_internal(klass, real, imag);
else if (f_real_p(real)) {
get_dat1(imag);
return nucomp_s_new_internal(klass,
f_sub(real, dat->imag),
f_add(ZERO, dat->real));
}
else if (f_real_p(imag)) {
get_dat1(real);
return nucomp_s_new_internal(klass,
dat->real,
f_add(dat->imag, imag));
}
else {
get_dat2(real, imag);
return nucomp_s_new_internal(klass,
f_sub(adat->real, bdat->imag),
f_add(adat->imag, bdat->real));
}
}
int main(int argc, char**argv){
fun_t *f;
f = f_mult(f_window(f_cu(0,SEC),f_cu(3,SEC)),
f_sin(f_c(1),f_cu(50,HZ),f_c(0)) );
f = f_add(f,
f_mult(f_window(f_cu(3,SEC),f_cu(6,SEC)),
f_tri(f_c(1),f_cu(50,HZ),f_c(0)) ));
f = f_add(f,
f_mult(f_window(f_cu(6,SEC),f_cu(9,SEC)),
f_square(f_c(1),f_cu(50,HZ),f_c(0),f_c(0.5)) ));
set_bpm(f_ramp(f_cu(2,SEC),f_cu(8,SEC),f_c(60),f_c(70)));
set_period(f_c(4));
/*
fun_print(f);
*/
f = s_down_sample(f_c(10),f);
fun_record_16b(f,0,SAMPLING_RATE*10,2,buffer);
audio_write_stereo_16b(buffer,SAMPLING_RATE*2*2*10,"test.wav");
return 0;
}
static VALUE
m_sqrt(VALUE x)
{
if (f_real_p(x)) {
if (f_positive_p(x))
return m_sqrt_bang(x);
return f_complex_new2(rb_cComplex, ZERO, m_sqrt_bang(f_negate(x)));
}
else {
get_dat1(x);
if (f_negative_p(dat->imag))
return f_conj(m_sqrt(f_conj(x)));
else {
VALUE a = f_abs(x);
return f_complex_new2(rb_cComplex,
m_sqrt_bang(f_div(f_add(a, dat->real), TWO)),
m_sqrt_bang(f_div(f_sub(a, dat->real), TWO)));
}
}
}
/*
* This actually does the interpolation, using the coefficients
* computed by sInterp(). Uses shares at offset byteNumber within the
* bodies.
* The Lagrange values come from the headers of the "shares" array.
*/
static PGPByte
sDoInterp(PGPByte *shares, PGPSize bodySize, PGPUInt32 nShares,
PGPUInt32 byteNumber)
{
PGPByte x, y;
PGPByte lagrange;
PGPUInt32 i;
x = 0;
for( i=0; i < nShares; ++i )
{
y = BODY(shares, bodySize, i)[byteNumber];
if (y != 0)
{
lagrange = HEADER(shares, bodySize, i)->lagrange;
y = f_exp[lagrange + f_log[y]];
}
x = f_add(x,y);
}
return x;
}
static VALUE
nurat_round(VALUE self, SEL sel)
{
VALUE num, den, neg;
get_dat1(self);
num = dat->num;
den = dat->den;
neg = f_negative_p(num);
if (neg)
num = f_negate(num);
num = f_add(f_mul(num, TWO), den);
den = f_mul(den, TWO);
num = f_idiv(num, den);
if (neg)
num = f_negate(num);
return num;
}
int main(int argc, char **argv) {
FILE *fd = fopen(argv[1], "r");
heap *h = h_init(NULL);
fraction *sum = malloc(f_size);
sum->n = 0;
sum->d = 1;
bool cont = true;
while (cont) {
fraction *f = malloc(f_size);
f->n = 0;
f->d = 1;
if (f_read(f, fd)) {
if (f->d != 0) {
f_add(sum, f);
h_push(h, f);
}
else {
cont = false;
}
}
else {
return -1;
}
}
printf("The sum of the fractions is: ");
f_print(sum, stdout);
fraction *f;
while ((f = h_pop(h)) != null) {
f_print(f, stdout);
}
return 0;
}
static VALUE
nucomp_s_convert(int argc, VALUE *argv, VALUE klass)
{
VALUE a1, a2, backref;
rb_scan_args(argc, argv, "11", &a1, &a2);
backref = rb_backref_get();
rb_match_busy(backref);
switch (TYPE(a1)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
break;
case T_STRING:
a1 = string_to_c_strict(a1);
break;
}
switch (TYPE(a2)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
break;
case T_STRING:
a2 = string_to_c_strict(a2);
break;
}
rb_backref_set(backref);
switch (TYPE(a1)) {
case T_COMPLEX:
{
get_dat1(a1);
if (k_exact_p(dat->imag) && f_zero_p(dat->imag))
a1 = dat->real;
}
}
switch (TYPE(a2)) {
case T_COMPLEX:
{
get_dat1(a2);
if (k_exact_p(dat->imag) && f_zero_p(dat->imag))
a2 = dat->real;
}
}
switch (TYPE(a1)) {
case T_COMPLEX:
if (argc == 1 || (k_exact_p(a2) && f_zero_p(a2)))
return a1;
}
if (argc == 1) {
if (k_numeric_p(a1) && !f_real_p(a1))
return a1;
}
else {
if ((k_numeric_p(a1) && k_numeric_p(a2)) &&
(!f_real_p(a1) || !f_real_p(a2)))
return f_add(a1,
f_mul(a2,
f_complex_new_bang2(rb_cComplex, ZERO, ONE)));
}
{
VALUE argv2[2];
argv2[0] = a1;
argv2[1] = a2;
return nucomp_s_new(argc, argv2, klass);
}
}
static VALUE
nucomp_expt(VALUE self, VALUE other)
{
if (k_exact_p(other) && f_zero_p(other))
return f_complex_new_bang1(CLASS_OF(self), ONE);
if (k_rational_p(other) && f_one_p(f_denominator(other)))
other = f_numerator(other); /* good? */
if (k_complex_p(other)) {
VALUE a, r, theta, ore, oim, nr, ntheta;
get_dat1(other);
a = f_polar(self);
r = RARRAY_PTR(a)[0];
theta = RARRAY_PTR(a)[1];
ore = dat->real;
oim = dat->imag;
nr = m_exp_bang(f_sub(f_mul(ore, m_log_bang(r)),
f_mul(oim, theta)));
ntheta = f_add(f_mul(theta, ore), f_mul(oim, m_log_bang(r)));
return f_complex_polar(CLASS_OF(self), nr, ntheta);
}
if (k_integer_p(other)) {
if (f_gt_p(other, ZERO)) {
VALUE x, z, n;
x = self;
z = x;
n = f_sub(other, ONE);
while (f_nonzero_p(n)) {
VALUE a;
while (a = f_divmod(n, TWO),
f_zero_p(RARRAY_PTR(a)[1])) {
get_dat1(x);
x = f_complex_new2(CLASS_OF(self),
f_sub(f_mul(dat->real, dat->real),
f_mul(dat->imag, dat->imag)),
f_mul(f_mul(TWO, dat->real), dat->imag));
n = RARRAY_PTR(a)[0];
}
z = f_mul(z, x);
n = f_sub(n, ONE);
}
return z;
}
return f_expt(f_div(f_to_r(ONE), self), f_negate(other));
}
if (k_numeric_p(other) && f_real_p(other)) {
VALUE a, r, theta;
a = f_polar(self);
r = RARRAY_PTR(a)[0];
theta = RARRAY_PTR(a)[1];
return f_complex_polar(CLASS_OF(self), f_expt(r, other),
f_mul(theta, other));
}
return rb_num_coerce_bin(self, other, id_expt);
}
main(int argc, char *argv[])
{
FILE* out;
FILE* pack;
s_main_head mhead;
s_pack_head phead;
s_file_rec rec[20];
s_file_rec frec;
t_dword len, cksum=0, i=0,j;
f_clear(&mhead,sizeof(s_main_head));
f_clear(&phead,sizeof(s_pack_head));
f_clear(rec,sizeof(s_file_rec)*20);
if (argc < 2)
printf("eospack outfile [firm version]");
if (argc > 2)
strcpy(mhead.version, argv[2]);
else
strcpy(mhead.version, "eos test firm1");
if ((out = fopen(argv[1], "wb")) == NULL) {
printf("Cant't open file name %s\n", argv[1]);
exit(-1);
}
if ((pack = fopen("tmp.pack", "wb+")) == NULL) {
printf("Cant't open file name tmp.pack\n");
exit(-1);
}
printf("File to write: %s\n", argv[1]);
printf("Writing pack\n");
cksum = 0;
if (f_add(&cksum, &(rec[i]), pack, 8, "firm", "MAIN_FIRMWARE")) i++;
if (f_add(&cksum, &(rec[i]), pack, 8, "ver", "FirmwareVersion")) i++;
fseek(pack, 0, SEEK_SET);
phead.tableOffset = sizeof(s_pack_head);
phead.rec_num = i;
phead.tableLenght = i*sizeof(s_file_rec);
phead.packOffset = phead.tableLenght+phead.tableOffset;
for (j=0; j<i; j++)
{
rec[j].Offset = phead.packLenght + phead.packOffset;
phead.packLenght += rec[j].lenght;
cksum += f_cksum(&(rec[j]), sizeof(s_file_rec));
}
phead.cksum = CK(cksum + f_cksum(&phead,sizeof(s_pack_head)));
printf("Writing main\n");
cksum=0;
len=0;
mhead.modelID= 0x80000236;
mhead.cksum= 0x00000000;
mhead.firstOffset = sizeof(s_main_head);
fwrite(&mhead, sizeof(s_main_head), 1, out);
len =f_add(&cksum, &frec, out, 0, "loader", "LOADER");
mhead.secondOffset = mhead.firstOffset + len;
fwrite (&phead, sizeof(s_pack_head), 1, out);
fwrite (rec, sizeof(s_file_rec), phead.rec_num, out);
cksum += f_filecpy(&frec, out, pack);
mhead.cksum = CK(cksum +
f_cksum(&mhead, sizeof(s_main_head)) +
f_cksum(&phead, sizeof(s_pack_head)) +
f_cksum(rec, sizeof(s_file_rec)*phead.rec_num));
fseek(out, 0, SEEK_SET);
fwrite(&mhead, sizeof(s_main_head), 1, out);
fclose(pack);
fclose(out);
exit(0);
}
/*
* call-seq:
* cmp ** numeric -> complex
*
* Performs exponentiation.
*
* Complex('i') ** 2 #=> (-1+0i)
* Complex(-8) ** Rational(1, 3) #=> (1.0000000000000002+1.7320508075688772i)
*/
static VALUE
nucomp_expt(VALUE self, VALUE other)
{
if (k_numeric_p(other) && k_exact_zero_p(other))
return f_complex_new_bang1(CLASS_OF(self), ONE);
if (k_rational_p(other) && f_one_p(f_denominator(other)))
other = f_numerator(other); /* c14n */
if (k_complex_p(other)) {
get_dat1(other);
if (k_exact_zero_p(dat->imag))
other = dat->real; /* c14n */
}
if (k_complex_p(other)) {
VALUE r, theta, nr, ntheta;
get_dat1(other);
r = f_abs(self);
theta = f_arg(self);
nr = m_exp_bang(f_sub(f_mul(dat->real, m_log_bang(r)),
f_mul(dat->imag, theta)));
ntheta = f_add(f_mul(theta, dat->real),
f_mul(dat->imag, m_log_bang(r)));
return f_complex_polar(CLASS_OF(self), nr, ntheta);
}
if (k_fixnum_p(other)) {
if (f_gt_p(other, ZERO)) {
VALUE x, z;
long n;
x = self;
z = x;
n = FIX2LONG(other) - 1;
while (n) {
long q, r;
while (1) {
get_dat1(x);
q = n / 2;
r = n % 2;
if (r)
break;
x = nucomp_s_new_internal(CLASS_OF(self),
f_sub(f_mul(dat->real, dat->real),
f_mul(dat->imag, dat->imag)),
f_mul(f_mul(TWO, dat->real), dat->imag));
n = q;
}
z = f_mul(z, x);
n--;
}
return z;
}
return f_expt(f_reciprocal(self), f_negate(other));
}
if (k_numeric_p(other) && f_real_p(other)) {
VALUE r, theta;
if (k_bignum_p(other))
rb_warn("in a**b, b may be too big");
r = f_abs(self);
theta = f_arg(self);
return f_complex_polar(CLASS_OF(self), f_expt(r, other),
f_mul(theta, other));
}
return rb_num_coerce_bin(self, other, id_expt);
}
static VALUE
nucomp_s_convert(int argc, VALUE *argv, VALUE klass)
{
VALUE a1, a2, backref;
rb_scan_args(argc, argv, "11", &a1, &a2);
if (NIL_P(a1) || (argc == 2 && NIL_P(a2)))
rb_raise(rb_eTypeError, "can't convert nil into Complex");
backref = rb_backref_get();
rb_match_busy(backref);
if (RB_TYPE_P(a1, T_STRING)) {
a1 = string_to_c_strict(a1);
}
if (RB_TYPE_P(a2, T_STRING)) {
a2 = string_to_c_strict(a2);
}
rb_backref_set(backref);
if (RB_TYPE_P(a1, T_COMPLEX)) {
{
get_dat1(a1);
if (k_exact_zero_p(dat->imag))
a1 = dat->real;
}
}
if (RB_TYPE_P(a2, T_COMPLEX)) {
{
get_dat1(a2);
if (k_exact_zero_p(dat->imag))
a2 = dat->real;
}
}
if (RB_TYPE_P(a1, T_COMPLEX)) {
if (argc == 1 || (k_exact_zero_p(a2)))
return a1;
}
if (argc == 1) {
if (k_numeric_p(a1) && !f_real_p(a1))
return a1;
/* should raise exception for consistency */
if (!k_numeric_p(a1))
return rb_convert_type(a1, T_COMPLEX, "Complex", "to_c");
}
else {
if ((k_numeric_p(a1) && k_numeric_p(a2)) &&
(!f_real_p(a1) || !f_real_p(a2)))
return f_add(a1,
f_mul(a2,
f_complex_new_bang2(rb_cComplex, ZERO, ONE)));
}
{
VALUE argv2[2];
argv2[0] = a1;
argv2[1] = a2;
return nucomp_s_new(argc, argv2, klass);
}
}
static void f_create_process( INT32 args ) {
struct perishables storage;
struct array *cmd = 0;
struct mapping *optional = 0;
struct svalue *tmp;
int e;
int stds[3];
int *fds;
int num_fds = 3;
int wanted_gid=0, wanted_uid=0;
int gid_request=0, uid_request=0;
char *tmp_cwd = NULL;
pid_t pid=-2;
extern char **environ;
fds = stds;
storage.env = NULL;
storage.argv = NULL;
storage.disabled = 0;
storage.fds = NULL;
storage.limits = NULL;
check_all_args("create_process",args, BIT_ARRAY, BIT_MAPPING | BIT_VOID, 0);
switch(args)
{
default:
optional=Pike_sp[1-args].u.mapping;
mapping_fix_type_field(optional);
if(m_ind_types(optional) & ~BIT_STRING)
Pike_error("Bad index type in argument 2 to Caudium.create_process()\n");
case 1: cmd=Pike_sp[-args].u.array;
if(cmd->size < 1)
Pike_error("Too few elements in argument array.\n");
for(e=0; e<cmd->size; e++)
if(ITEM(cmd)[e].type!=T_STRING)
Pike_error("Argument is not a string.\n");
array_fix_type_field(cmd);
if(cmd->type_field & ~BIT_STRING)
Pike_error("Bad argument 1 to Caudium.create_process().\n");
}
if (optional) {
if ((tmp = simple_mapping_string_lookup(optional, "gid"))) {
switch(tmp->type)
{
case T_INT:
wanted_gid = tmp->u.integer;
gid_request = 1;
break;
default:
Pike_error("Invalid argument for gid.");
break;
}
}
if ((tmp = simple_mapping_string_lookup(optional, "uid"))) {
switch(tmp->type)
{
case T_INT:
wanted_uid = tmp->u.integer;
uid_request = 1;
break;
default:
Pike_error("Invalid argument for uid.");
break;
}
}
if((tmp = simple_mapping_string_lookup( optional, "cwd" )) &&
tmp->type == T_STRING && !tmp->u.string->size_shift)
tmp_cwd = tmp->u.string->str;
if((tmp = simple_mapping_string_lookup( optional, "stdin" )) &&
tmp->type == T_OBJECT)
{
fds[0] = fd_from_object( tmp->u.object );
if(fds[0] == -1)
Pike_error("Invalid stdin file\n");
}
if((tmp = simple_mapping_string_lookup( optional, "stdout" )) &&
tmp->type == T_OBJECT)
{
fds[1] = fd_from_object( tmp->u.object );
if(fds[1] == -1)
Pike_error("Invalid stdout file\n");
}
if((tmp = simple_mapping_string_lookup( optional, "stderr" )) &&
tmp->type == T_OBJECT)
{
fds[2] = fd_from_object( tmp->u.object );
if(fds[2] == -1)
Pike_error("Invalid stderr file\n");
}
if((tmp=simple_mapping_string_lookup(optional, "rlimit"))) {
struct svalue *tmp2;
if(tmp->type != T_MAPPING)
Pike_error("Wrong type of argument for the 'rusage' option. "
"Should be mapping.\n");
#define ADD_LIMIT(X,Y,Z) internal_add_limit(&storage,X,Y,Z);
#ifdef RLIMIT_NPROC
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "nproc")))
ADD_LIMIT( "nproc", RLIMIT_NPROC, tmp2 );
#endif
#ifdef RLIMIT_MEMLOCK
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "memlock")))
ADD_LIMIT( "memlock", RLIMIT_MEMLOCK, tmp2 );
#endif
#ifdef RLIMIT_RSS
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "rss")))
ADD_LIMIT( "rss", RLIMIT_RSS, tmp2 );
#endif
#ifdef RLIMIT_CORE
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "core")))
ADD_LIMIT( "core", RLIMIT_CORE, tmp2 );
#endif
#ifdef RLIMIT_CPU
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "cpu")))
ADD_LIMIT( "cpu", RLIMIT_CPU, tmp2 );
#endif
#ifdef RLIMIT_DATA
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "data")))
ADD_LIMIT( "data", RLIMIT_DATA, tmp2 );
#endif
#ifdef RLIMIT_FSIZE
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "fsize")))
ADD_LIMIT( "fsize", RLIMIT_FSIZE, tmp2 );
#endif
#ifdef RLIMIT_NOFILE
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "nofile")))
ADD_LIMIT( "nofile", RLIMIT_NOFILE, tmp2 );
#endif
#ifdef RLIMIT_STACK
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "stack")))
ADD_LIMIT( "stack", RLIMIT_STACK, tmp2 );
#endif
#ifdef RLIMIT_VMEM
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "map_mem"))
||(tmp2=simple_mapping_string_lookup(tmp->u.mapping, "vmem")))
ADD_LIMIT( "map_mem", RLIMIT_VMEM, tmp2 );
#endif
#ifdef RLIMIT_AS
if((tmp2=simple_mapping_string_lookup(tmp->u.mapping, "as"))
||(tmp2=simple_mapping_string_lookup(tmp->u.mapping, "mem")))
ADD_LIMIT( "mem", RLIMIT_AS, tmp2 );
#endif
#undef ADD_LIMIT
}
}
if((tmp=simple_mapping_string_lookup(optional, "env"))) {
if(tmp->type == T_MAPPING) {
struct mapping *m=tmp->u.mapping;
struct array *i,*v;
int ptr=0;
i=mapping_indices(m);
v=mapping_values(m);
storage.env=(char **)xalloc((1+m_sizeof(m)) * sizeof(char *));
for(e=0;e<i->size;e++)
{
if(ITEM(i)[e].type == T_STRING &&
ITEM(v)[e].type == T_STRING)
{
check_stack(3);
ref_push_string(ITEM(i)[e].u.string);
push_string(make_shared_string("="));
ref_push_string(ITEM(v)[e].u.string);
f_add(3);
storage.env[ptr++]=Pike_sp[-1].u.string->str;
}
}
storage.env[ptr++]=0;
free_array(i);
free_array(v);
}
}
storage.argv = (char **)xalloc((1 + cmd->size) * sizeof(char *));
for (e = 0; e < cmd->size; e++) storage.argv[e] = ITEM(cmd)[e].u.string->str;
storage.argv[e] = 0;
th_atfork_prepare();
pid = fork();
if (pid) {
th_atfork_parent();
} else {
th_atfork_child();
}
if (pid == -1) {
Pike_error("Caudium.create_process() failed.");
} else if (pid) {
pop_n_elems(args);
push_int(pid);
return;
} else {
if(storage.limits) {
struct plimit *l = storage.limits;
while(l) {
int tmpres = setrlimit( l->resource, &l->rlp );
l = l->next;
}
}
if(storage.env) environ = storage.env;
chdir(tmp_cwd);
seteuid(0);
setegid(0);
setgroups(0, NULL);
if (gid_request) setgid(wanted_gid);
if (uid_request) setuid(wanted_uid);
dup2(fds[0], 0);
dup2(fds[1], 1);
dup2(fds[2], 2);
set_close_on_exec(0,0);
set_close_on_exec(1,0);
set_close_on_exec(2,0);
execvp(storage.argv[0],storage.argv);
exit(99);
}
pop_n_elems(args);
push_int(0);
}
int main(int argc, char * argv[])
{
int x = 0, z = 1;
if (argv[1] != NULL)
{
do
{
if (strcmp(argv[z], help) == 0)
{
f_help();
}
if (strcmp(argv[z], print) == 0)
{
x = 0;
f_print(x);
}
if (strcmp(argv[z], removeall) == 0)
{
f_removeall();
}
if (strcmp(argv[z], add) == 0)
{
f_add();
}
if (strcmp(argv[z], remov) == 0)
{
f_remov();
}
if (strcmp(argv[z], findname) == 0)
{
x = 0;
f_find(x);
}
if (strcmp(argv[z], findsname) == 0)
{
x = 1;
f_find(x);
}
if (strcmp(argv[z], findlname) == 0)
{
x = 2;
f_find(x);
}
if (strcmp(argv[z], findgr) == 0)
{
x = 3;
f_find(x);
}
if (strcmp(argv[z], sortname) == 0)
{
x = 1;
f_sort(x);
}
if (strcmp(argv[z], sortsname) == 0)
{
x = 2;
f_sort(x);
}
if (strcmp(argv[z], sortlname) == 0)
{
x = 3;
f_sort(x);
}
if (strcmp(argv[z], sortgr) == 0)
{
x = 4;
f_sort(x);
}
if (strcmp(argv[z], kol) == 0)
{
x = 1;
f_print(x);
}
z++;
} while (argv[z] != NULL);
}
return 0;
}
static VALUE
string_to_r_internal(VALUE self)
{
VALUE s, m;
s = self;
if (RSTRING_LEN(s) == 0)
return rb_assoc_new(Qnil, self);
m = f_match(rat_pat, s);
if (!NIL_P(m)) {
VALUE v, ifp, exp, ip, fp;
VALUE si = f_aref(m, INT2FIX(1));
VALUE nu = f_aref(m, INT2FIX(2));
VALUE de = f_aref(m, INT2FIX(3));
VALUE re = f_post_match(m);
{
VALUE a;
a = f_split(nu, an_e_pat);
ifp = RARRAY_PTR(a)[0];
if (RARRAY_LEN(a) != 2)
exp = Qnil;
else
exp = RARRAY_PTR(a)[1];
a = f_split(ifp, a_dot_pat);
ip = RARRAY_PTR(a)[0];
if (RARRAY_LEN(a) != 2)
fp = Qnil;
else
fp = RARRAY_PTR(a)[1];
}
v = rb_rational_new1(f_to_i(ip));
if (!NIL_P(fp)) {
char *p = StringValuePtr(fp);
long count = 0;
VALUE l;
while (*p) {
if (rb_isdigit(*p))
count++;
p++;
}
l = f_expt(INT2FIX(10), LONG2NUM(count));
v = f_mul(v, l);
v = f_add(v, f_to_i(fp));
v = f_div(v, l);
}
if (!NIL_P(si) && *StringValuePtr(si) == '-')
v = f_negate(v);
if (!NIL_P(exp))
v = f_mul(v, f_expt(INT2FIX(10), f_to_i(exp)));
#if 0
if (!NIL_P(de) && (!NIL_P(fp) || !NIL_P(exp)))
return rb_assoc_new(v, rb_usascii_str_new2("dummy"));
#endif
if (!NIL_P(de))
v = f_div(v, f_to_i(de));
return rb_assoc_new(v, re);
}
return rb_assoc_new(Qnil, self);
}