Main Page | Class Hierarchy | Alphabetical List | Data Structures | File List | Data Fields | Globals | Search for 

e:/XFree86 for RH 8.0/XFree86-4.2.0/xc/programs/Xserver/XIE/mixie/process/mparith.c File Reference

Go to the source code of this file.

Data Structures

struct  _mparithdef

Typedefs

typedef _mparithdef mpArithPvtRec
typedef _mparithdef * mpArithPvtPtr

Functions

int miAnalyzeArith ()
int miAnalyzeMath ()
int CreateArith ()
int InitializeArith ()
int ResetArith ()
int DestroyArith ()
int ActivateArithMROI ()
int ActivateArithDROI ()
int SetupArith ()
void ClearArith ()
int CreateMath ()
int InitializeMath ()
int SetupMath ()
int miAnalyzeArith (floDefPtr flo, peDefPtr ped)
int miAnalyzeMath (floDefPtr flo, peDefPtr ped)
int CreateArith (floDefPtr flo, peDefPtr ped)
int CreateMath (floDefPtr flo, peDefPtr ped)
int InitializeArith (floDefPtr flo, peDefPtr ped)
int InitializeMath (floDefPtr flo, peDefPtr ped)
int ActivateArithMROI (floDefPtr flo, peDefPtr ped, peTexPtr pet)
int ActivateArithDROI (floDefPtr flo, peDefPtr ped, peTexPtr pet)
int ResetArith (floDefPtr flo, peDefPtr ped)
int DestroyArith (floDefPtr flo, peDefPtr ped)
 MakeLutI (pr_a, AADD)
 MakeLook (lr_B, BytePixel)
 DakePix (dr_B_a, DakePix(BytePixel, AADD)
 MakeLutF1 (mpr_exp, FEXP)
int SetupArith (floDefPtr flo, peDefPtr ped, int modify)
int SetupMath (floDefPtr flo, peDefPtr ped, int modify)
void ClearArith (floDefPtr flo, peDefPtr ped)

Variables

ddElemVecRec ArithVec
ddElemVecRec MathVec
void(* action_dyadROI [5][xieValGamma])()=
void(* passive_copy [5])()
void(* prep_math [xieValSqrt])()=

Typedef Documentation

typedef struct _mparithdef mpArithPvtRec
 

typedef struct _mparithdef * mpArithPvtPtr
 

Referenced by ActivateArithDROI(), ActivateArithMROI(), ClearArith(), SetupArith(), and SetupMath().

Function Documentation

int miAnalyzeArith (   ) 
 

Referenced by DAGalyze().

int miAnalyzeMath (   ) 
 

Referenced by DAGalyze().

int CreateArith (   )  [static]
 

int InitializeArith (   )  [static]
 

int ResetArith (   )  [static]
 

int DestroyArith (   )  [static]
 

int ActivateArithMROI (   )  [static]
 

Referenced by InitializeArith().

int ActivateArithDROI (   )  [static]
 

Referenced by InitializeArith().

int SetupArith (   )  [static]
 

Referenced by CreateArith(), and InitializeArith().

void ClearArith (   )  [static]
 

Referenced by DestroyArith(), and ResetArith().

int CreateMath (   )  [static]
 

int InitializeMath (   )  [static]
 

int SetupMath (   )  [static]
 

Referenced by CreateMath(), and InitializeMath().

int miAnalyzeArith (  floDefPtr  flo,
peDefPtr  ped
) 
 

Definition at line 216 of file mparith.c.

References ArithVec, and _pedef::ddVec. 

00219 {
00220     ped->ddVec = ArithVec;
00221     return TRUE;
00222 }

int miAnalyzeMath (  floDefPtr  flo,
peDefPtr  ped
) 
 

Definition at line 224 of file mparith.c.

References _pedef::ddVec, and MathVec. 

00227 {
00228     ped->ddVec = MathVec;
00229     return TRUE;
00230 }

int CreateArith (  floDefPtr  flo,
peDefPtr  ped
)  [static]
 

Definition at line 235 of file mparith.c.

References MakePETex(), and SetupArith(). 

00238 {
00239     /* always force syncing between inputs (is nop if only one input) */
00240     if (!MakePETex(flo,ped,
00241                      xieValMaxBands * sizeof(mpArithPvtRec),
00242                      SYNC,      /* InSync: */
00243                      NO_SYNC    /* bandSync: */))
00244         return FALSE;
00245 
00246 #if defined(KEEP_LUTS)
00247     if (!SetupArith(flo, ped, 0 /* modify ?? */))
00248         return FALSE;
00249 #endif
00250  
00251     return TRUE;
00252 
00253 }

int CreateMath (  floDefPtr  flo,
peDefPtr  ped
)  [static]
 

Definition at line 255 of file mparith.c.

References MakePETex(), and SetupMath(). 

00258 {
00259     /* always force syncing between inputs (is nop if only one input) */
00260     if (!MakePETex(flo,ped,
00261                      xieValMaxBands * sizeof(mpArithPvtRec),
00262                      SYNC,      /* InSync: */
00263                      NO_SYNC    /* bandSync: */))
00264         return FALSE;
00265 
00266 #if defined(KEEP_LUTS)
00267     if (!SetupMath(flo, ped, 0 /* modify ?? */))
00268         return FALSE;
00269 #endif
00270  
00271     return TRUE;
00272 
00273 }

int InitializeArith (  floDefPtr  flo,
peDefPtr  ped
)  [static]
 

Definition at line 279 of file mparith.c.

References _ddelemvec::activate, ActivateArithDROI(), ActivateArithMROI(), _receptor::band, _pedef::ddVec, _pedef::elemRaw, _pedef::inCnt, InitEmitter(), InitProcDomain(), InitReceptor(), _pedef::peTex, _petex::receptor, _band::replicate, and SetupArith(). 

00282 {
00283     xieFloArithmetic *raw = (xieFloArithmetic *) ped->elemRaw;
00284     peTexPtr         pet = ped->peTex;
00285     receptorPtr      rcp = pet->receptor;
00286     CARD8            msk = raw->bandMask;
00287 
00288 #if !defined(KEEP_LUTS)
00289     if (!SetupArith(flo, ped, 0 /* modify ?? */))
00290         return FALSE;
00291 #endif
00292 
00293     ped->ddVec.activate = raw->src2 ? ActivateArithDROI : ActivateArithMROI;
00294 
00295     /* If processing domain, allow replication */
00296     if (raw->domainPhototag)
00297         rcp[ped->inCnt-1].band[0].replicate = msk;
00298 
00299     InitReceptor(flo, ped, &rcp[SRCt1], NO_DATAMAP, 1, msk, ~msk);
00300 
00301     if (raw->src2)
00302         InitReceptor(flo, ped, &rcp[SRCt2], NO_DATAMAP, 1, msk, NO_BANDS);
00303 
00304     InitProcDomain(flo, ped, raw->domainPhototag, raw->domainOffsetX, 
00305                                                   raw->domainOffsetY);
00306     InitEmitter(flo, ped, NO_DATAMAP, SRCt1);
00307 
00308     return !ferrCode(flo);
00309 }

int InitializeMath (  floDefPtr  flo,
peDefPtr  ped
)  [static]
 

Definition at line 311 of file mparith.c.

References _receptor::band, _pedef::elemRaw, _pedef::inCnt, InitEmitter(), InitProcDomain(), InitReceptor(), _pedef::peTex, _petex::receptor, _band::replicate, and SetupMath(). 

00314 {
00315     xieFloMath      *raw = (xieFloMath *) ped->elemRaw;
00316     peTexPtr         pet = ped->peTex;
00317     receptorPtr      rcp = pet->receptor;
00318     CARD8            msk = raw->bandMask;
00319 
00320 #if !defined(KEEP_LUTS)
00321     if (!SetupMath(flo, ped, 0 /* modify ?? */))
00322         return FALSE;
00323 #endif
00324     if (raw->domainPhototag)
00325         rcp[ped->inCnt-1].band[0].replicate = msk;
00326     InitReceptor(flo, ped, &rcp[SRCt1], NO_DATAMAP, 1, msk, ~msk);
00327     InitProcDomain(flo, ped, raw->domainPhototag, raw->domainOffsetX, 
00328                                                   raw->domainOffsetY);
00329     InitEmitter(flo, ped, NO_DATAMAP, SRCt1);
00330 
00331     return !ferrCode(flo);
00332 }

int ActivateArithMROI (  floDefPtr  flo,
peDefPtr  ped,
peTexPtr  pet
)  [static]
 

Definition at line 338 of file mparith.c.

References _mpconstraindef::action, _receptor::band, band, _inflo::bands, _petex::emitter, _receptor::inFlo, INT32, mpArithPvtPtr, pointer, _petex::private, pvt, _petex::receptor, and _petex::scheduled. 

00342 {
00343     mpArithPvtPtr pvt = (mpArithPvtPtr) pet->private;
00344     int band, nbands  = pet->receptor[SRCt1].inFlo->bands;
00345     bandPtr sband     = &(pet->receptor[SRCt1].band[0]);
00346     bandPtr dband     = &(pet->emitter[0]);
00347 
00348     for(band = 0; band < nbands; band++, pvt++, sband++, dband++) {
00349         pointer svoid, dvoid;
00350 
00351         if (!(pet->scheduled & 1<<band)) continue;
00352 
00353         if (!(svoid = GetCurrentSrc(flo,pet,sband)) ||
00354             !(dvoid = GetCurrentDst(flo,pet,dband))) continue;
00355 
00356         while (!ferrCode(flo) && svoid && dvoid && 
00357                                 SyncDomain(flo,ped,dband,FLUSH)) {
00358             INT32 run, ix = 0;
00359            
00360             while (run = GetRun(flo,pet,dband)) {
00361                 if (run > 0) {
00362                     (*(pvt->action)) (dvoid, svoid, run, ix, pvt);
00363                     ix += run;
00364                 } else {
00365                     if (dvoid != svoid)
00366                         (*(pvt->passive)) (dvoid, svoid, -run, ix);
00367                     ix -= run;
00368                 }
00369             }
00370             svoid = GetNextSrc(flo,pet,sband,FLUSH);
00371             dvoid = GetNextDst(flo,pet,dband,FLUSH);
00372         }
00373 
00374         FreeData(flo, pet, sband, sband->current);
00375     }
00376     return TRUE;
00377 }

int ActivateArithDROI (  floDefPtr  flo,
peDefPtr  ped,
peTexPtr  pet
)  [static]
 

Definition at line 379 of file mparith.c.

References _mpconstraindef::action, _receptor::band, band, _inflo::bands, _petex::emitter, _receptor::inFlo, INT32, mpArithPvtPtr, pointer, _petex::private, pvt, _petex::receptor, _petex::scheduled, and w. 

00383 {
00384     mpArithPvtPtr pvt = (mpArithPvtPtr) pet->private;
00385     int band, nbands  = pet->receptor[SRCt1].inFlo->bands;
00386     bandPtr sband     = &(pet->receptor[SRCt1].band[0]);
00387     bandPtr tband     = &(pet->receptor[SRCt2].band[0]);
00388     bandPtr dband     = &(pet->emitter[0]);
00389 
00390     for(band = 0; band < nbands; band++, pvt++, sband++, tband++, dband++) {
00391         pointer svoid, tvoid, dvoid;
00392         CARD32 w;
00393 
00394         if (!(pet->scheduled & 1<<band)) continue;
00395 
00396         w = sband->format->width;
00397         if (w > tband->format->width) w = tband->format->width;
00398 
00399         if (!(svoid = GetCurrentSrc(flo,pet,sband)) ||
00400             !(tvoid = GetCurrentSrc(flo,pet,tband)) ||
00401             !(dvoid = GetCurrentDst(flo,pet,dband))) continue;
00402 
00403         while (!ferrCode(flo) && svoid && tvoid && dvoid && 
00404                                 SyncDomain(flo,ped,dband,FLUSH)) {
00405             INT32 run, ix = 0;
00406            
00407             while (run = GetRun(flo,pet,dband)) {
00408                 if (run > 0) {
00409                     /* needs to clip to second source, yuck */
00410                     if ((ix + run) > w) {
00411                         if (ix < w)
00412                             (*(pvt->action)) (dvoid,svoid,tvoid, w-ix, ix, pvt);
00413                         if (dvoid != svoid) {
00414                             run = sband->format->width - w;
00415                             if (run > 0)
00416                                 (*(pvt->passive)) (dvoid, svoid, run, w);
00417                         }
00418                         break;
00419                     }
00420                     (*(pvt->action)) (dvoid, svoid, tvoid, run, ix, pvt);
00421                     ix += run;
00422                 } else {
00423                     if (dvoid != svoid)
00424                         (*(pvt->passive)) (dvoid, svoid, -run, ix);
00425                     ix -= run; 
00426                 }
00427             }
00428             svoid = GetNextSrc(flo,pet,sband,FLUSH);
00429             tvoid = GetNextSrc(flo,pet,tband,FLUSH);
00430             dvoid = GetNextDst(flo,pet,dband,FLUSH);
00431         }
00432 
00433         if(!svoid && sband->final) {
00434             DisableSrc(flo,pet,tband,FLUSH);
00435         } else if(!tvoid && tband->final) { 
00436             BypassSrc(flo,pet,sband);
00437         } else {
00438             /* both inputs still active, keep the scheduler up to date  */
00439             FreeData(flo,pet,sband,sband->current);
00440             FreeData(flo,pet,tband,tband->current);
00441         }
00442     }
00443     return TRUE;
00444 }

int ResetArith (  floDefPtr  flo,
peDefPtr  ped
)  [static]
 

Definition at line 449 of file mparith.c.

References ClearArith(), ResetEmitter(), ResetProcDomain(), and ResetReceptors(). 

00452 {
00453 
00454 #if !defined(KEEP_LUTS)
00455     ClearArith(flo,ped);
00456 #endif
00457 
00458     ResetReceptors(ped);
00459     ResetProcDomain(ped);
00460     ResetEmitter(ped);
00461     return TRUE;
00462 }

int DestroyArith (  floDefPtr  flo,
peDefPtr  ped
)  [static]
 

Definition at line 467 of file mparith.c.

References _ddelemvec::activate, ClearArith(), _ddelemvec::create, _pedef::ddVec, _ddelemvec::destroy, _ddelemvec::initialize, _pedef::peTex, _ddelemvec::reset, XieFree(), and xieIntProc. 

00470 {
00471 
00472 #if defined(KEEP_LUTS)
00473     ClearArith(flo,ped);
00474 #endif
00475 
00476     /* get rid of the peTex structure and private structures  */
00477     ped->peTex = (peTexPtr) XieFree(ped->peTex);
00478 
00479     /* zap this element's entry point vector */
00480     ped->ddVec.create = (xieIntProc)NULL;
00481     ped->ddVec.initialize = (xieIntProc)NULL;
00482     ped->ddVec.activate = (xieIntProc)NULL;
00483     ped->ddVec.reset = (xieIntProc)NULL;
00484     ped->ddVec.destroy = (xieIntProc)NULL;
00485 
00486     return TRUE;
00487 }

MakeLutI (  pr_a  ,
AADD 
) 
 

Definition at line 637 of file mparith.c. 

00648                                           {
00649 pr_a, pr_s, pr_sr, pr_m, pr_d, pr_dr, pr_mn, pr_mx, pr_gm
00650 };

MakeLook (  lr_B  ,
BytePixel 
) 
 

Definition at line 652 of file mparith.c. 

00656                                  {
00657     NADA,
00658     NADA,
00659     lr_B,
00660     lr_P,
00661     lr_Q
00662 };

DakePix (  dr_B_a  ,
DakePix (  BytePixel,
AADD 
) 
 

Definition at line 838 of file mparith.c. 

00898                                                   {
00899 mr_R_a, mr_R_s, mr_R_sr, mr_R_m, mr_R_d, mr_R_dr, mr_R_mn, mr_R_mx, mr_R_gm,
00900 mr_b_a, mr_b_s, mr_b_sr, mr_b_m, mr_b_d, mr_b_dr, mr_b_mn, mr_b_mx, mr_b_gm,
00901 NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA,
00902 NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA,
00903 NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA,   NADA
00904 };

MakeLutF1 (  mpr_exp  ,
FEXP 
) 
 

Definition at line 983 of file mparith.c. 

01009                                                  {
01010 /* EXP,   LOG,      LOG2,     LOG10,    SQUARE,   SQRT */
01011 m_R_exp,  m_R_lgN,  m_R_lg2,  m_R_lg10, m_R_sqr,  m_R_sqrt,     /* floats */
01012 m_b_exp,  m_b_lgN,  m_b_lg2,  m_b_lg10, m_b_sqr,  m_b_sqrt,     /* bits */
01013 NADA,     NADA,     NADA,     NADA,     NADA,     NADA,         /* bytes */
01014 NADA,     NADA,     NADA,     NADA,     m_P_sqr,  NADA,         /* pairs */
01015 NADA,     NADA,     NADA,     NADA,     m_Q_sqr,  NADA          /* quads */
01016 /* EXP,   LOG,      LOG2,     LOG10,    SQUARE,   SQRT */
01017 };

int SetupArith (  floDefPtr  flo,
peDefPtr  ped,
int  modify
)  [static]
 

Definition at line 1027 of file mparith.c.

References act, _mpconstraindef::action, action_dyadROI, band, _band::band, _inflo::bands, _parith::constant, _pedef::elemPvt, _pedef::elemRaw, _petex::emitter, _receptor::inFlo, mpArithPvtPtr, passive_copy, _pedef::peTex, _petex::private, pvt, RealPixel, _petex::receptor, and XieMalloc(). 

01031 {
01032     xieFloArithmetic *raw = (xieFloArithmetic *) ped->elemRaw;
01033     peTexPtr         pet = ped->peTex;
01034     pArithDefPtr    epvt = (pArithDefPtr)  ped->elemPvt;
01035     mpArithPvtPtr    pvt = (mpArithPvtPtr) pet->private;
01036     receptorPtr      rcp = pet->receptor;
01037     CARD32        nbands = rcp[SRCt1].inFlo->bands;
01038     bandPtr        sband = &(rcp[SRCt1].band[0]);
01039     bandPtr        tband = &(rcp[SRCt2].band[0]);
01040     bandPtr        dband = &(pet->emitter[0]);
01041     CARD32          band;
01042 
01043     for (band=0; band<nbands; band++, pvt++, sband++, tband++, dband++) {
01044         CARD32 iclass = IndexClass(sband->format->class);
01045         void (*act)() = 0;
01046 
01047         if ((raw->bandMask & (1<<band)) == 0) 
01048             continue;
01049 
01050         if (!raw->src2) /* only used for mul, div, divrev, gamma */
01051             pvt->fconstant = (RealPixel) epvt->constant[band];
01052 
01053         switch(raw->operator) {
01054             case xieValDiv:     if (pvt->fconstant == 0.0) /* epsilon ?? */
01055                                     pvt->fconstant = 1.0;
01056                                 break;
01057         }
01058 
01059         if (IsConstrained(sband->format->class)) {
01060             pvt->nlev = sband->format->levels;
01061             if (!raw->src2) {
01062                 CARD32 deep;
01063                 SetDepthFromLevels(pvt->nlev,deep); pvt->nclip = 1 << deep;
01064                 /* only used for add, sub, subrev, min, max */
01065                 pvt->iconstant = ConstrainConst(epvt->constant[band],pvt->nlev);
01066             }
01067         }
01068 
01069         /* Try to find a dyadic operator */
01070         if (!act && raw->src2)
01071             act = action_dyadROI[iclass][raw->operator-1];
01072 
01073         /*
01074         **  NOTE:
01075         **      For larger pixels a look up table begins to be less
01076         **      attractive since the malloc is larger, it takes longer
01077         **      to compute, and the cache hit rate may go down.  So
01078         **      we may want to add more actual monodaic arithmetic
01079         **      elements to the table (see MakePixel, it worked once
01080         **      upon a time) and choose between an arithmetic and lookup
01081         **      version based on number of levels.
01082         */
01083 
01084         /* Try to find a monadic operator */
01085         if (!act && !raw->src2)
01086             act = action_monoROI[iclass][raw->operator-1];
01087 
01088         /* Or maybe a monadic look up table op */
01089         if (!act && !raw->src2) {
01090              act = action_lut[iclass];
01091              if (act) {
01092                 /* Allocate Lut and Fill it in */
01093                 if (!(pvt->lutptr = (CARD32 *)
01094                         XieMalloc(pvt->nclip * sizeof(CARD32))))
01095                     AllocError(flo,ped,return(FALSE));
01096                 (*prep_mono[raw->operator-1]) (pvt);
01097              }
01098         }
01099 
01100         if (!act)
01101             ImplementationError(flo,ped,return(FALSE));
01102         pvt->action = act;
01103         pvt->passive = passive_copy[iclass];
01104     }
01105     return TRUE;
01106 }

int SetupMath (  floDefPtr  flo,
peDefPtr  ped,
int  modify
)  [static]
 

Definition at line 1108 of file mparith.c.

References act, _mpconstraindef::action, band, _inflo::bands, _pedef::elemRaw, _petex::emitter, _receptor::inFlo, mpArithPvtPtr, passive_copy, _pedef::peTex, prep_math, _petex::private, pvt, _petex::receptor, and XieMalloc(). 

01112 {
01113     xieFloMath      *raw = (xieFloMath *) ped->elemRaw;
01114     peTexPtr         pet = ped->peTex;
01115     mpArithPvtPtr    pvt = (mpArithPvtPtr) pet->private;
01116     receptorPtr      rcp = pet->receptor;
01117     CARD32        nbands = rcp[SRCt1].inFlo->bands;
01118     bandPtr        sband = &(rcp[SRCt1].band[0]);
01119     bandPtr        dband = &(pet->emitter[0]);
01120     CARD32          band;
01121 
01122     for (band=0; band<nbands; band++, pvt++, sband++, dband++) {
01123         CARD32 iclass = IndexClass(sband->format->class);
01124         void (*act)() = 0;
01125 
01126         if ((raw->bandMask & (1<<band)) == 0) 
01127             continue;
01128 
01129         if (IsConstrained(sband->format->class)) {
01130             CARD32 deep;
01131             pvt->nlev = sband->format->levels;
01132             SetDepthFromLevels(pvt->nlev,deep); pvt->nclip = 1 << deep;
01133         }
01134 
01135         /*
01136         **  NOTE:
01137         **      For larger sized pixels, a lookup table my be counter
01138         **      productive.  In addition to the malloc space (eg 64k 
01139         **      words), and the low cache hit rate, the time to fill the
01140         **      lookup table can become significant.  Even for medium
01141         **      sized pixels, some sort of hashed cache might be a 
01142         **      better solution.  But I seriously doubt anyone will
01143         **      use these operations on integer pixels very much ...
01144         */
01145 
01146         /* Try to find a monadic operator */
01147         if (!act)
01148             act = action_mathROI[iclass][raw->operator-1];
01149 
01150         /* Or maybe a monadic look up table operator */
01151         if (!act) {
01152              act = action_lut[iclass];
01153              if (act) {
01154                 /* Allocate Lut and Fill it in */
01155                 if (!(pvt->lutptr = (CARD32 *)
01156                         XieMalloc(pvt->nclip * sizeof(CARD32))))
01157                     AllocError(flo,ped,return(FALSE));
01158                 (*prep_math[raw->operator-1]) (pvt);
01159              }
01160         }
01161         if (!act)
01162             ImplementationError(flo,ped,return(FALSE));
01163 
01164         pvt->action = act;
01165         pvt->passive = passive_copy[iclass];
01166     }
01167     return TRUE;
01168 }

void ClearArith (  floDefPtr  flo,
peDefPtr  ped
)  [static]
 

Definition at line 1170 of file mparith.c.

References band, mpArithPvtPtr, _pedef::peTex, _petex::private, pvt, and XieFree(). 

01173 {
01174     mpArithPvtPtr pvt = (mpArithPvtPtr) (ped->peTex->private);
01175     int band;
01176 
01177     /* free any dynamic private data */
01178     if (pvt)
01179         for (band = 0 ; band < xieValMaxBands ; band++, pvt++)
01180             if (pvt->lutptr)
01181                 pvt->lutptr = (CARD32 *) XieFree(pvt->lutptr);
01182 
01183 }

Variable Documentation

ddElemVecRec ArithVec [static]
 

Initial value:

 {
  CreateArith,
  InitializeArith,
  (xieIntProc) NULL,
  (xieIntProc) NULL,
  ResetArith,
  DestroyArith
  }

Definition at line 169 of file mparith.c.

Referenced by miAnalyzeArith().

ddElemVecRec MathVec [static]
 

Initial value:

 {
  CreateMath,
  InitializeMath,
  ActivateArithMROI,    
  (xieIntProc) NULL,
  ResetArith,           
  DestroyArith          
  }

Definition at line 178 of file mparith.c.

Referenced by miAnalyzeMath().

void(* action_dyadROI[5][xieValGamma])()= [static]
 

Definition at line 906 of file mparith.c.

Referenced by SetupArith(). 

00906                                                   {
00907 dr_R_a, dr_R_s, dr_R_sr, NADA, NADA, NADA, dr_R_mn, dr_R_mx, NADA,
00908 dr_b_a, dr_b_s, dr_b_sr, NADA, NADA, NADA, dr_b_mn, dr_b_mx, NADA,
00909 dr_B_a, dr_B_s, dr_B_sr, NADA, NADA, NADA, dr_B_mn, dr_B_mx, NADA,
00910 dr_P_a, dr_P_s, dr_P_sr, NADA, NADA, NADA, dr_P_mn, dr_P_mx, NADA,
00911 dr_Q_a, dr_Q_s, dr_Q_sr, NADA, NADA, NADA, dr_Q_mn, dr_Q_mx, NADA
00912 };

void(* passive_copy[5])()
 

Definition at line 915 of file mparith.c.

Referenced by SetupArith(), and SetupMath().

void(* prep_math[xieValSqrt])()= [static]
 

Definition at line 1019 of file mparith.c.

Referenced by SetupMath(). 

01019                                          {
01020 mpr_exp, mpr_lgN, mpr_lg2, mpr_lg10, mpr_sqr, mpr_sqrt
01021 };

Generated on Tue May 11 14:49:34 2004 for XFree86 by doxygen 1.3.7