![]() ![]() | ![]() |
version 1.72, 2007/09/19 05:42:59 | version 1.81, 2010/04/16 07:13:42 | ||
---|---|---|---|
|
|
||
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, | * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, | ||
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. | * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. | ||
* | * | ||
* $OpenXM: OpenXM_contrib2/asir2000/builtin/dp.c,v 1.71 2007/09/17 12:47:45 noro Exp $ | * $OpenXM: OpenXM_contrib2/asir2000/builtin/dp.c,v 1.80 2010/01/19 06:17:22 noro Exp $ | ||
*/ | */ | ||
#include "ca.h" | #include "ca.h" | ||
#include "base.h" | #include "base.h" | ||
|
|
||
void Pdp_cri1(),Pdp_cri2(),Pdp_subd(),Pdp_mod(),Pdp_red_mod(),Pdp_tdiv(); | void Pdp_cri1(),Pdp_cri2(),Pdp_subd(),Pdp_mod(),Pdp_red_mod(),Pdp_tdiv(); | ||
void Pdp_prim(),Pdp_red_coef(),Pdp_mag(),Pdp_set_kara(),Pdp_rat(); | void Pdp_prim(),Pdp_red_coef(),Pdp_mag(),Pdp_set_kara(),Pdp_rat(); | ||
void Pdp_nf(),Pdp_true_nf(),Pdp_true_nf_marked(),Pdp_true_nf_marked_mod(); | void Pdp_nf(),Pdp_true_nf(),Pdp_true_nf_marked(),Pdp_true_nf_marked_mod(); | ||
void Pdp_true_nf_and_quotient_marked(),Pdp_true_nf_and_quotient_marked_mod(); | |||
void Pdp_nf_mod(),Pdp_true_nf_mod(); | void Pdp_nf_mod(),Pdp_true_nf_mod(); | ||
void Pdp_criB(),Pdp_nelim(); | void Pdp_criB(),Pdp_nelim(); | ||
void Pdp_minp(),Pdp_sp_mod(); | void Pdp_minp(),Pdp_sp_mod(); | ||
|
|
||
void Pdp_weyl_f4_main(),Pdp_weyl_f4_mod_main(),Pdp_weyl_f4_f_main(); | void Pdp_weyl_f4_main(),Pdp_weyl_f4_mod_main(),Pdp_weyl_f4_f_main(); | ||
void Pdp_weyl_mul(),Pdp_weyl_mul_mod(); | void Pdp_weyl_mul(),Pdp_weyl_mul_mod(); | ||
void Pdp_weyl_set_weight(); | void Pdp_weyl_set_weight(); | ||
void Pdp_set_weight(),Pdp_set_top_weight(); | void Pdp_set_weight(),Pdp_set_top_weight(),Pdp_set_module_weight(); | ||
void Pdp_nf_f(),Pdp_weyl_nf_f(); | void Pdp_nf_f(),Pdp_weyl_nf_f(); | ||
void Pdp_lnf_f(); | void Pdp_lnf_f(); | ||
void Pnd_gr(),Pnd_gr_trace(),Pnd_f4(),Pnd_f4_trace(); | void Pnd_gr(),Pnd_gr_trace(),Pnd_f4(),Pnd_f4_trace(); | ||
void Pnd_gr_postproc(); | void Pnd_gr_postproc(), Pnd_weyl_gr_postproc(); | ||
void Pnd_weyl_gr(),Pnd_weyl_gr_trace(); | void Pnd_weyl_gr(),Pnd_weyl_gr_trace(); | ||
void Pnd_nf(); | void Pnd_nf(); | ||
void Pdp_initial_term(); | void Pdp_initial_term(); | ||
void Pdp_order(); | void Pdp_order(); | ||
void Pdp_inv_or_split(); | void Pdp_inv_or_split(); | ||
void Pdp_compute_last_t(); | |||
void Pdp_compute_last_w(); | void Pdp_compute_last_w(); | ||
void Pdp_compute_essential_df(); | void Pdp_compute_essential_df(); | ||
void Pdp_get_denomlist(); | void Pdp_get_denomlist(); | ||
void Pdp_symb_add(); | |||
LIST dp_initial_term(); | LIST dp_initial_term(); | ||
LIST dp_order(); | LIST dp_order(); | ||
|
|
||
{"dp_nf_f",Pdp_nf_f,4}, | {"dp_nf_f",Pdp_nf_f,4}, | ||
{"dp_true_nf",Pdp_true_nf,4}, | {"dp_true_nf",Pdp_true_nf,4}, | ||
{"dp_true_nf_marked",Pdp_true_nf_marked,4}, | {"dp_true_nf_marked",Pdp_true_nf_marked,4}, | ||
{"dp_true_nf_and_quotient_marked",Pdp_true_nf_and_quotient_marked,4}, | |||
{"dp_true_nf_and_quotient_marked_mod",Pdp_true_nf_and_quotient_marked_mod,5}, | |||
{"dp_true_nf_marked_mod",Pdp_true_nf_marked_mod,5}, | {"dp_true_nf_marked_mod",Pdp_true_nf_marked_mod,5}, | ||
{"dp_nf_mod",Pdp_nf_mod,5}, | {"dp_nf_mod",Pdp_nf_mod,5}, | ||
{"dp_true_nf_mod",Pdp_true_nf_mod,5}, | {"dp_true_nf_mod",Pdp_true_nf_mod,5}, | ||
|
|
||
{"nd_gr_trace",Pnd_gr_trace,5}, | {"nd_gr_trace",Pnd_gr_trace,5}, | ||
{"nd_f4_trace",Pnd_f4_trace,5}, | {"nd_f4_trace",Pnd_f4_trace,5}, | ||
{"nd_gr_postproc",Pnd_gr_postproc,5}, | {"nd_gr_postproc",Pnd_gr_postproc,5}, | ||
{"nd_weyl_gr_postproc",Pnd_weyl_gr_postproc,5}, | |||
{"nd_weyl_gr",Pnd_weyl_gr,4}, | {"nd_weyl_gr",Pnd_weyl_gr,4}, | ||
{"nd_weyl_gr_trace",Pnd_weyl_gr_trace,5}, | {"nd_weyl_gr_trace",Pnd_weyl_gr_trace,5}, | ||
{"nd_nf",Pnd_nf,5}, | {"nd_nf",Pnd_nf,5}, | ||
|
|
||
/* misc */ | /* misc */ | ||
{"dp_inv_or_split",Pdp_inv_or_split,3}, | {"dp_inv_or_split",Pdp_inv_or_split,3}, | ||
{"dp_set_weight",Pdp_set_weight,-1}, | {"dp_set_weight",Pdp_set_weight,-1}, | ||
{"dp_set_module_weight",Pdp_set_module_weight,-1}, | |||
{"dp_set_top_weight",Pdp_set_top_weight,-1}, | {"dp_set_top_weight",Pdp_set_top_weight,-1}, | ||
{"dp_weyl_set_weight",Pdp_weyl_set_weight,-1}, | {"dp_weyl_set_weight",Pdp_weyl_set_weight,-1}, | ||
|
|
||
{"dp_rest",Pdp_rest,1}, | {"dp_rest",Pdp_rest,1}, | ||
{"dp_initial_term",Pdp_initial_term,1}, | {"dp_initial_term",Pdp_initial_term,1}, | ||
{"dp_order",Pdp_order,1}, | {"dp_order",Pdp_order,1}, | ||
{"dp_symb_add",Pdp_symb_add,2}, | |||
/* degree and size */ | /* degree and size */ | ||
{"dp_td",Pdp_td,1}, | {"dp_td",Pdp_td,1}, | ||
|
|
||
{"dp_tdiv",Pdp_tdiv,2}, | {"dp_tdiv",Pdp_tdiv,2}, | ||
{"dp_minp",Pdp_minp,2}, | {"dp_minp",Pdp_minp,2}, | ||
{"dp_compute_last_w",Pdp_compute_last_w,5}, | {"dp_compute_last_w",Pdp_compute_last_w,5}, | ||
{"dp_compute_last_t",Pdp_compute_last_t,5}, | |||
{"dp_compute_essential_df",Pdp_compute_essential_df,2}, | {"dp_compute_essential_df",Pdp_compute_essential_df,2}, | ||
{0,0,0} | {0,0,0} | ||
}; | }; | ||
NODE compute_last_w(NODE g,NODE gh,int n,int **v,int row1,int **m1,int row2,int **m2); | NODE compute_last_w(NODE g,NODE gh,int n,int **v,int row1,int **m1,int row2,int **m2); | ||
Q compute_last_t(NODE g,NODE gh,Q t,VECT w1,VECT w2,NODE *homo,VECT *wp); | |||
void Pdp_compute_last_t(NODE arg,LIST *rp) | |||
{ | |||
NODE g,gh,homo,n; | |||
LIST hlist; | |||
VECT v1,v2,w; | |||
Q t; | |||
g = (NODE)BDY((LIST)ARG0(arg)); | |||
gh = (NODE)BDY((LIST)ARG1(arg)); | |||
t = (Q)ARG2(arg); | |||
v1 = (VECT)ARG3(arg); | |||
v2 = (VECT)ARG4(arg); | |||
t = compute_last_t(g,gh,t,v1,v2,&homo,&w); | |||
MKLIST(hlist,homo); | |||
n = mknode(3,t,w,hlist); | |||
MKLIST(*rp,n); | |||
} | |||
void Pdp_compute_last_w(NODE arg,LIST *rp) | void Pdp_compute_last_w(NODE arg,LIST *rp) | ||
{ | { | ||
NODE g,gh,r; | NODE g,gh,r; | ||
|
|
||
MKLIST(*rp,n); | MKLIST(*rp,n); | ||
} | } | ||
DP *dp_true_nf_and_quotient_marked (NODE b,DP g,DP *ps,DP *hps,DP *rp,P *dnp); | |||
void Pdp_true_nf_and_quotient_marked(arg,rp) | |||
NODE arg; | |||
LIST *rp; | |||
{ | |||
NODE b,n; | |||
DP *ps,*hps; | |||
DP g; | |||
DP nm; | |||
VECT quo; | |||
P dn; | |||
int full; | |||
do_weyl = 0; dp_fcoeffs = 0; | |||
asir_assert(ARG0(arg),O_LIST,"dp_true_nf_and_quotient_marked"); | |||
asir_assert(ARG1(arg),O_DP,"dp_true_nf_and_quotient_marked"); | |||
asir_assert(ARG2(arg),O_VECT,"dp_true_nf_and_quotient_marked"); | |||
asir_assert(ARG3(arg),O_VECT,"dp_true_nf_and_quotient_marked"); | |||
if ( !(g = (DP)ARG1(arg)) ) { | |||
nm = 0; dn = (P)ONE; | |||
} else { | |||
b = BDY((LIST)ARG0(arg)); | |||
ps = (DP *)BDY((VECT)ARG2(arg)); | |||
hps = (DP *)BDY((VECT)ARG3(arg)); | |||
NEWVECT(quo); quo->len = ((VECT)ARG2(arg))->len; | |||
quo->body = (pointer *)dp_true_nf_and_quotient_marked(b,g,ps,hps,&nm,&dn); | |||
} | |||
n = mknode(3,nm,dn,quo); | |||
MKLIST(*rp,n); | |||
} | |||
DP *dp_true_nf_and_quotient_marked_mod (NODE b,DP g,DP *ps,DP *hps,int mod,DP *rp,P *dnp); | |||
void Pdp_true_nf_and_quotient_marked_mod(arg,rp) | |||
NODE arg; | |||
LIST *rp; | |||
{ | |||
NODE b,n; | |||
DP *ps,*hps; | |||
DP g; | |||
DP nm; | |||
VECT quo; | |||
P dn; | |||
int full,mod; | |||
do_weyl = 0; dp_fcoeffs = 0; | |||
asir_assert(ARG0(arg),O_LIST,"dp_true_nf_and_quotient_marked_mod"); | |||
asir_assert(ARG1(arg),O_DP,"dp_true_nf_and_quotient_marked_mod"); | |||
asir_assert(ARG2(arg),O_VECT,"dp_true_nf_and_quotient_marked_mod"); | |||
asir_assert(ARG3(arg),O_VECT,"dp_true_nf_and_quotient_marked_mod"); | |||
asir_assert(ARG4(arg),O_N,"dp_true_nf_and_quotient_marked_mod"); | |||
if ( !(g = (DP)ARG1(arg)) ) { | |||
nm = 0; dn = (P)ONE; | |||
} else { | |||
b = BDY((LIST)ARG0(arg)); | |||
ps = (DP *)BDY((VECT)ARG2(arg)); | |||
hps = (DP *)BDY((VECT)ARG3(arg)); | |||
mod = QTOS((Q)ARG4(arg)); | |||
NEWVECT(quo); quo->len = ((VECT)ARG2(arg))->len; | |||
quo->body = (pointer *)dp_true_nf_and_quotient_marked_mod(b,g,ps,hps,mod,&nm,&dn); | |||
} | |||
n = mknode(3,nm,dn,quo); | |||
MKLIST(*rp,n); | |||
} | |||
void Pdp_true_nf_marked_mod(arg,rp) | void Pdp_true_nf_marked_mod(arg,rp) | ||
NODE arg; | NODE arg; | ||
LIST *rp; | LIST *rp; | ||
|
|
||
dp_subd(p1,p2,rp); | dp_subd(p1,p2,rp); | ||
} | } | ||
void Pdp_symb_add(arg,rp) | |||
NODE arg; | |||
DP *rp; | |||
{ | |||
DP p1,p2,r; | |||
NODE s0; | |||
MP mp0,mp; | |||
int nv; | |||
p1 = (DP)ARG0(arg); p2 = (DP)ARG1(arg); | |||
asir_assert(p1,O_DP,"dp_symb_add"); | |||
asir_assert(p2,O_DP,"dp_symb_add"); | |||
if ( p1->nv != p2->nv ) | |||
error("dp_sumb_add : invalid input"); | |||
nv = p1->nv; | |||
s0 = symb_merge(dp_dllist(p1),dp_dllist(p2),nv); | |||
for ( mp0 = 0; s0; s0 = NEXT(s0) ) { | |||
NEXTMP(mp0,mp); mp->dl = (DL)BDY(s0); mp->c = (P)ONE; | |||
} | |||
NEXT(mp) = 0; | |||
MKDP(nv,mp0,r); r->sugar = MAX(p1->sugar,p2->sugar); | |||
*rp = r; | |||
} | |||
void Pdp_mul_trunc(arg,rp) | void Pdp_mul_trunc(arg,rp) | ||
NODE arg; | NODE arg; | ||
DP *rp; | DP *rp; | ||
|
|
||
LIST *rp; | LIST *rp; | ||
{ | { | ||
LIST f,v; | LIST f,v; | ||
int m,homo; | int m,find; | ||
Obj homo; | |||
struct order_spec *ord; | struct order_spec *ord; | ||
do_weyl = 0; | do_weyl = 0; | ||
asir_assert(ARG0(arg),O_LIST,"nd_gr"); | asir_assert(ARG0(arg),O_LIST,"nd_f4"); | ||
asir_assert(ARG1(arg),O_LIST,"nd_gr"); | asir_assert(ARG1(arg),O_LIST,"nd_f4"); | ||
asir_assert(ARG2(arg),O_N,"nd_gr"); | asir_assert(ARG2(arg),O_N,"nd_f4"); | ||
f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); | f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); | ||
f = remove_zero_from_list(f); | f = remove_zero_from_list(f); | ||
if ( !BDY(f) ) { | if ( !BDY(f) ) { | ||
|
|
||
} | } | ||
m = QTOS((Q)ARG2(arg)); | m = QTOS((Q)ARG2(arg)); | ||
create_order_spec(0,ARG3(arg),&ord); | create_order_spec(0,ARG3(arg),&ord); | ||
nd_gr(f,v,m,1,ord,rp); | find = get_opt("homo",&homo); | ||
nd_gr(f,v,m,find&&homo,1,ord,rp); | |||
} | } | ||
void Pnd_gr(arg,rp) | void Pnd_gr(arg,rp) | ||
|
|
||
LIST *rp; | LIST *rp; | ||
{ | { | ||
LIST f,v; | LIST f,v; | ||
int m,homo; | int m,find; | ||
Obj homo; | |||
struct order_spec *ord; | struct order_spec *ord; | ||
do_weyl = 0; | do_weyl = 0; | ||
|
|
||
} | } | ||
m = QTOS((Q)ARG2(arg)); | m = QTOS((Q)ARG2(arg)); | ||
create_order_spec(0,ARG3(arg),&ord); | create_order_spec(0,ARG3(arg),&ord); | ||
nd_gr(f,v,m,0,ord,rp); | find = get_opt("homo",&homo); | ||
nd_gr(f,v,m,find&&homo,0,ord,rp); | |||
} | } | ||
void Pnd_gr_postproc(arg,rp) | void Pnd_gr_postproc(arg,rp) | ||
|
|
||
nd_gr_postproc(f,v,m,ord,do_check,rp); | nd_gr_postproc(f,v,m,ord,do_check,rp); | ||
} | } | ||
void Pnd_weyl_gr_postproc(arg,rp) | |||
NODE arg; | |||
LIST *rp; | |||
{ | |||
LIST f,v; | |||
int m,do_check; | |||
struct order_spec *ord; | |||
do_weyl = 1; | |||
asir_assert(ARG0(arg),O_LIST,"nd_gr"); | |||
asir_assert(ARG1(arg),O_LIST,"nd_gr"); | |||
asir_assert(ARG2(arg),O_N,"nd_gr"); | |||
f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); | |||
f = remove_zero_from_list(f); | |||
if ( !BDY(f) ) { | |||
*rp = f; do_weyl = 0; return; | |||
} | |||
m = QTOS((Q)ARG2(arg)); | |||
create_order_spec(0,ARG3(arg),&ord); | |||
do_check = ARG4(arg) ? 1 : 0; | |||
nd_gr_postproc(f,v,m,ord,do_check,rp); | |||
do_weyl = 0; | |||
} | |||
void Pnd_gr_trace(arg,rp) | void Pnd_gr_trace(arg,rp) | ||
NODE arg; | NODE arg; | ||
LIST *rp; | LIST *rp; | ||
|
|
||
LIST *rp; | LIST *rp; | ||
{ | { | ||
LIST f,v; | LIST f,v; | ||
int m,homo; | int m,find; | ||
Obj homo; | |||
struct order_spec *ord; | struct order_spec *ord; | ||
do_weyl = 1; | do_weyl = 1; | ||
|
|
||
f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); | f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); | ||
f = remove_zero_from_list(f); | f = remove_zero_from_list(f); | ||
if ( !BDY(f) ) { | if ( !BDY(f) ) { | ||
*rp = f; return; | *rp = f; do_weyl = 0; return; | ||
} | } | ||
m = QTOS((Q)ARG2(arg)); | m = QTOS((Q)ARG2(arg)); | ||
create_order_spec(0,ARG3(arg),&ord); | create_order_spec(0,ARG3(arg),&ord); | ||
nd_gr(f,v,m,0,ord,rp); | find = get_opt("homo",&homo); | ||
nd_gr(f,v,m,find&&homo,0,ord,rp); | |||
do_weyl = 0; | |||
} | } | ||
void Pnd_weyl_gr_trace(arg,rp) | void Pnd_weyl_gr_trace(arg,rp) | ||
|
|
||
f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); | f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); | ||
f = remove_zero_from_list(f); | f = remove_zero_from_list(f); | ||
if ( !BDY(f) ) { | if ( !BDY(f) ) { | ||
*rp = f; return; | *rp = f; do_weyl = 0; return; | ||
} | } | ||
homo = QTOS((Q)ARG2(arg)); | homo = QTOS((Q)ARG2(arg)); | ||
m = QTOS((Q)ARG3(arg)); | m = QTOS((Q)ARG3(arg)); | ||
create_order_spec(0,ARG4(arg),&ord); | create_order_spec(0,ARG4(arg),&ord); | ||
nd_gr_trace(f,v,m,homo,0,ord,rp); | nd_gr_trace(f,v,m,homo,0,ord,rp); | ||
do_weyl = 0; | |||
} | } | ||
void Pnd_nf(arg,rp) | void Pnd_nf(arg,rp) | ||
|
|
||
} | } | ||
} | } | ||
VECT current_module_weight_vector_obj; | |||
int *current_module_weight_vector; | |||
void Pdp_set_module_weight(arg,rp) | |||
NODE arg; | |||
VECT *rp; | |||
{ | |||
VECT v; | |||
int i,n; | |||
NODE node; | |||
if ( !arg ) | |||
*rp = current_module_weight_vector_obj; | |||
else if ( !ARG0(arg) ) { | |||
current_module_weight_vector_obj = 0; | |||
current_module_weight_vector = 0; | |||
*rp = 0; | |||
} else { | |||
if ( OID(ARG0(arg)) != O_VECT && OID(ARG0(arg)) != O_LIST ) | |||
error("dp_module_set_weight : invalid argument"); | |||
if ( OID(ARG0(arg)) == O_VECT ) | |||
v = (VECT)ARG0(arg); | |||
else { | |||
node = (NODE)BDY((LIST)ARG0(arg)); | |||
n = length(node); | |||
MKVECT(v,n); | |||
for ( i = 0; i < n; i++, node = NEXT(node) ) | |||
BDY(v)[i] = BDY(node); | |||
} | |||
current_module_weight_vector_obj = v; | |||
n = v->len; | |||
current_module_weight_vector = (int *)CALLOC(n,sizeof(int)); | |||
for ( i = 0; i < n; i++ ) | |||
current_module_weight_vector[i] = QTOS((Q)v->body[i]); | |||
*rp = v; | |||
} | |||
} | |||
VECT current_top_weight_vector_obj; | VECT current_top_weight_vector_obj; | ||
N *current_top_weight_vector; | N *current_top_weight_vector; | ||
|
|
||
BDY(v)[i] = BDY(node); | BDY(v)[i] = BDY(node); | ||
} | } | ||
for ( i = 0; i < v->len; i++ ) | for ( i = 0; i < v->len; i++ ) | ||
if ( !INT(BDY(v)[i]) || SGN((Q)BDY(v)[i]) < 0 ) | if ( !INT(BDY(v)[i]) || (BDY(v)[i] && SGN((Q)BDY(v)[i]) < 0) ) | ||
error("dp_set_top_weight : each element must be a non-negative integer"); | error("dp_set_top_weight : each element must be a non-negative integer"); | ||
current_top_weight_vector_obj = v; | current_top_weight_vector_obj = v; | ||
current_top_weight_vector = (N *)MALLOC(v->len*sizeof(N)); | current_top_weight_vector = (N *)MALLOC(v->len*sizeof(N)); | ||
for ( i = 0; i < v->len; i++ ) { | for ( i = 0; i < v->len; i++ ) { | ||
current_top_weight_vector[i] = NM((Q)BDY(v)[i]); | current_top_weight_vector[i] = !BDY(v)[i]?0:NM((Q)BDY(v)[i]); | ||
} | } | ||
*rp = current_top_weight_vector_obj; | *rp = current_top_weight_vector_obj; | ||
} | } | ||
|
|
||
if ( !arg ) | if ( !arg ) | ||
*rp = current_weyl_weight_vector_obj; | *rp = current_weyl_weight_vector_obj; | ||
else { | else if ( !ARG0(arg) ) { | ||
current_weyl_weight_vector_obj = 0; | |||
current_weyl_weight_vector = 0; | |||
*rp = 0; | |||
} else { | |||
asir_assert(ARG0(arg),O_VECT,"dp_weyl_set_weight"); | asir_assert(ARG0(arg),O_VECT,"dp_weyl_set_weight"); | ||
v = (VECT)ARG0(arg); | v = (VECT)ARG0(arg); | ||
current_weyl_weight_vector_obj = v; | current_weyl_weight_vector_obj = v; | ||
|
|
||
break; | break; | ||
} | } | ||
} | } | ||
int get_opt(char *key0,Obj *r) { | |||
NODE tt,p; | |||
char *key; | |||
if ( current_option ) { | |||
for ( tt = current_option; tt; tt = NEXT(tt) ) { | |||
p = BDY((LIST)BDY(tt)); | |||
key = BDY((STRING)BDY(p)); | |||
/* value = (Obj)BDY(NEXT(p)); */ | |||
if ( !strcmp(key,key0) ) { | |||
*r = (Obj)BDY(NEXT(p)); | |||
return 1; | |||
} | |||
} | |||
} | |||
return 0; | |||
} | |||