00001 #include <stdlib.h>
00002 #include <stdio.h>
00003 #include <string.h>
00004 #include "petsc.h"
00005 #include "sysprotransform.h"
00006 #include "syspro_impl.h"
00007
00008 #define TFINC 20
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #undef __FUNCT__
00027 #define __FUNCT__ "NewTransform"
00028
00029
00030
00031 PetscErrorCode NewTransform(char *name,SalsaTransform *tf)
00032 {
00033 SalsaTransform snew; PetscErrorCode ierr;
00034 PetscFunctionBegin;
00035 ierr = PetscNew(struct SalsaTransform_,&snew); CHKERRQ(ierr);
00036 ierr = PetscMemzero(snew,sizeof(struct SalsaTransform_)); CHKERRQ(ierr);
00037 snew->name = strdup(name);
00038
00039 snew->alloc_objects = TFINC; snew->n_objects = 0;
00040 ierr = PetscMalloc(snew->alloc_objects*sizeof(SalsaTransformObject),&snew->transformobjects); CHKERRQ(ierr);
00041 ierr = PetscMemzero(snew->transformobjects,snew->alloc_objects*sizeof(SalsaTransformObject)); CHKERRQ(ierr);
00042 ierr = PetscMalloc(snew->alloc_objects*sizeof(int),&snew->aprioriselection); CHKERRQ(ierr);
00043 ierr = PetscMemzero(snew->aprioriselection,snew->alloc_objects*sizeof(int)); CHKERRQ(ierr);
00044
00045 *tf = snew;
00046 PetscFunctionReturn(0);
00047 }
00048
00049 PetscErrorCode DeregisterTransform(SalsaTransform tf)
00050 {
00051 int i; PetscErrorCode ierr;
00052 PetscFunctionBegin;
00053 for (i=0; i<tf->n_objects; i++) {
00054 ierr = FreeTransformObject(tf->transformobjects[i]); CHKERRQ(ierr);
00055 }
00056 ierr = PetscFree(tf->transformobjects); CHKERRQ(ierr);
00057 ierr = PetscFree(tf->aprioriselection); CHKERRQ(ierr);
00058 if (tf->annotations_i) {ierr = PetscFree(tf->annotations_i); CHKERRQ(ierr);}
00059 if (tf->annotations_c) {ierr = PetscFree(tf->annotations_c); CHKERRQ(ierr);}
00060 ierr = PetscFree(tf); CHKERRQ(ierr);
00061 PetscFunctionReturn(0);
00062 }
00063
00064 #undef __FUNCT__
00065 #define __FUNCT__ "TransformGetName"
00066 PetscErrorCode TransformGetName(SalsaTransform tf,char **name)
00067 {
00068 PetscFunctionBegin;
00069 *name = tf->name;
00070 PetscFunctionReturn(0);
00071 }
00072
00073 #undef __FUNCT__
00074 #define __FUNCT__ "TransformGetObjects"
00075 PetscErrorCode TransformGetObjects
00076 (SalsaTransform tf,int *n,SalsaTransformObject **objs)
00077 {
00078 PetscFunctionBegin;
00079 if (n) *n = tf->n_objects;
00080 if (objs) *objs = tf->transformobjects;
00081 PetscFunctionReturn(0);
00082 }
00083
00084 #undef __FUNCT__
00085 #define __FUNCT__ "NewTransformObject"
00086
00087
00088
00089
00090
00091 PetscErrorCode NewTransformObject
00092 (char *transform,char *name,SalsaTransformObject *to)
00093 {
00094 SalsaTransform tf; SalsaTransformObject snew; PetscErrorCode ierr;
00095 PetscFunctionBegin;
00096 ierr = TransformGetByName(transform,&tf); CHKERRQ(ierr);
00097 ierr = PetscNew(struct SalsaTransformObject_,&snew); CHKERRQ(ierr);
00098 ierr = PetscMemzero(snew,sizeof(struct SalsaTransformObject_)); CHKERRQ(ierr);
00099 snew->name = strdup(name); snew->transform = tf;
00100 if (tf->n_objects>=tf->alloc_objects)
00101 SETERRQ(1,"Can not realloc transform objects");
00102 tf->transformobjects[tf->n_objects++] = snew;
00103 if (to) *to = snew;
00104 PetscFunctionReturn(0);
00105 }
00106
00107 #undef __FUNCT__
00108 #define __FUNCT__ "FreeTransformObject"
00109 PetscErrorCode FreeTransformObject(SalsaTransformObject tf)
00110 {
00111 int iopt; PetscErrorCode ierr;
00112 PetscFunctionBegin;
00113 if (tf->options) {
00114 ierr = PetscFree(tf->options); CHKERRQ(ierr);
00115 ierr = PetscFree(tf->options_marked); CHKERRQ(ierr);
00116 for (iopt=0; iopt<tf->n_options; iopt++) {
00117 free(tf->optionexplanation[iopt]);
00118 }
00119 ierr = PetscFree(tf->optionexplanation); CHKERRQ(ierr);
00120 }
00121 if (tf->annotate_i) {ierr = PetscFree(tf->annotate_i); CHKERRQ(ierr);}
00122 if (tf->annotate_c) {ierr = PetscFree(tf->annotate_c); CHKERRQ(ierr);}
00123 free(tf->name);
00124 ierr = PetscFree(tf); CHKERRQ(ierr);
00125 PetscFunctionReturn(0);
00126 }
00127
00128 #undef __FUNCT__
00129 #define __FUNCT__ "TransformObjectGetName"
00130 PetscErrorCode TransformObjectGetName(SalsaTransformObject tf,char **name)
00131 {
00132 PetscFunctionBegin;
00133 *name = tf->name;
00134 PetscFunctionReturn(0);
00135 }
00136
00137 #undef __FUNCT__
00138 #define __FUNCT__ "TransformObjectSetExplanation"
00139 PetscErrorCode TransformObjectSetExplanation(SalsaTransformObject tf,char *x)
00140 {
00141 PetscFunctionBegin;
00142 tf->explanation = x;
00143 PetscFunctionReturn(0);
00144 }
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164 #undef __FUNCT__
00165 #define __FUNCT__ "TransformObjectSetSuitabilityFunction"
00166
00167 PetscErrorCode TransformObjectSetSuitabilityFunction
00168 (SalsaTransformObject tf,void *sctx,PetscErrorCode(*f)(NumericalProblem,void*,SuitabilityValue*))
00169 {
00170 PetscFunctionBegin;
00171 tf->suitabilityfunction = f;
00172 tf->suitabilityctx = sctx;
00173 PetscFunctionReturn(0);
00174 }
00175
00176 #undef __FUNCT__
00177 #define __FUNCT__ "TransformObjectGetSuitabilityFunction"
00178
00179
00180
00181 PetscErrorCode TransformObjectGetSuitabilityFunction
00182 (SalsaTransformObject tf,void **sctx,PetscErrorCode(**f)(NumericalProblem,void*,SuitabilityValue*))
00183 {
00184 PetscFunctionBegin;
00185 if (sctx) *sctx = tf->suitabilityctx;
00186 if (f) *f = tf->suitabilityfunction;
00187 PetscFunctionReturn(0);
00188 }
00189
00190 #undef __FUNCT__
00191 #define __FUNCT__ "TransformObjectGetTransformName"
00192 PetscErrorCode TransformObjectGetTransformName(SalsaTransformObject tf,char **name)
00193 {
00194 PetscFunctionBegin;
00195 *name = tf->transform->name;
00196 PetscFunctionReturn(0);
00197 }
00198
00199 #undef __FUNCT__
00200 #define __FUNCT__ "TransformObjectGetByName"
00201 PetscErrorCode TransformObjectGetByName
00202 (char *trans,char *name,SalsaTransformObject *tf)
00203 {
00204 SalsaTransform tt; int i; PetscErrorCode ierr;
00205 PetscFunctionBegin;
00206 ierr = TransformGetByName(trans,&tt); CHKERRQ(ierr);
00207 for (i=0; i<tt->n_objects; i++) {
00208 if (!strcmp(name,tt->transformobjects[i]->name)) {
00209 *tf = tt->transformobjects[i];
00210 PetscFunctionReturn(0);
00211 }
00212 }
00213 SETERRQ2(1,"Could not find transform <%s:%s>",trans,name)
00214 PetscFunctionReturn(0);
00215 }
00216
00217 #undef __FUNCT__
00218 #define __FUNCT__ "TransformObjectsGetNames"
00219
00220
00221
00222
00223 PetscErrorCode TransformObjectsGetNames(SalsaTransform tf,char ***names)
00224 {
00225 int i; char **thenames; PetscErrorCode ierr;
00226 PetscFunctionBegin;
00227 ierr = PetscMalloc(tf->n_objects*sizeof(char*),&thenames); CHKERRQ(ierr);
00228 for (i=0; i<tf->n_objects; i++)
00229 thenames[i] = tf->transformobjects[i]->name;
00230 *names = thenames;
00231 PetscFunctionReturn(0);
00232 }
00233
00234
00235
00236
00237 #undef __FUNCT__
00238 #define __FUNCT__ "SysProDefineCharAnnotation"
00239
00240
00241
00242
00243 PetscErrorCode SysProDefineCharAnnotation(char *transform,char *ann)
00244 {
00245 SalsaTransform tf; int loc; PetscErrorCode ierr;
00246 PetscFunctionBegin;
00247
00248 ierr = TransformGetByName(transform,&tf); CHKERRQ(ierr);
00249
00250
00251
00252
00253 if (tf->n_annotate_c==0) {
00254
00255 ierr = PetscMalloc
00256 (TFINC*sizeof(char*),&(tf->annotations_c)); CHKERRQ(ierr);
00257 ierr = PetscMemzero
00258 (tf->annotations_c,TFINC*sizeof(char*)); CHKERRQ(ierr);
00259 loc = 0;
00260 } else if (tf->n_annotate_c==TFINC) {
00261 SETERRQ(1,"Can not realloc annotations yet");
00262 } else {
00263 loc = tf->n_annotate_c;
00264 }
00265
00266
00267
00268
00269 tf->annotations_c[loc] = strdup(ann);
00270
00271 tf->n_annotate_c++;
00272 PetscFunctionReturn(0);
00273 }
00274
00275 #undef __FUNCT__
00276 #define __FUNCT__ "TransformCharAnnotationGetIndex"
00277 PetscErrorCode TransformCharAnnotationGetIndex(SalsaTransform tf,char *ann,int *idx,PetscTruth *flg)
00278 {
00279 int i; PetscTruth f; PetscErrorCode ierr;
00280 PetscFunctionBegin;
00281 *idx = -1;
00282 for (i=0; i<tf->n_annotate_c; i++) {
00283 ierr = PetscStrcmp(ann,tf->annotations_c[i],&f); CHKERRQ(ierr);
00284 if (f) {
00285 *idx = i; if (flg) *flg = f; break;
00286 }
00287 }
00288 PetscFunctionReturn(0);
00289 }
00290
00291 #undef __FUNCT__
00292 #define __FUNCT__ "SysProDefineIntAnnotation"
00293
00294
00295
00296
00297 PetscErrorCode SysProDefineIntAnnotation(char *transform,char *ann)
00298 {
00299 SalsaTransform tf; int loc; PetscErrorCode ierr;
00300 PetscFunctionBegin;
00301 ierr = TransformGetByName(transform,&tf); CHKERRQ(ierr);
00302
00303
00304
00305 if (tf->n_annotate_i==0) {
00306
00307 ierr = PetscMalloc
00308 (TFINC*sizeof(char*),&(tf->annotations_i)); CHKERRQ(ierr);
00309 ierr = PetscMemzero
00310 (tf->annotations_i,TFINC*sizeof(char*)); CHKERRQ(ierr);
00311 loc = 0;
00312 } else if (tf->n_annotate_i==TFINC) {
00313 SETERRQ(1,"Can not realloc annotations yet");
00314 } else {
00315 loc = tf->n_annotate_i;
00316 }
00317
00318
00319
00320
00321 tf->annotations_i[loc] = strdup(ann);
00322
00323 tf->n_annotate_i++;
00324 PetscFunctionReturn(0);
00325 }
00326
00327 #undef __FUNCT__
00328 #define __FUNCT__ "TransformIntAnnotationGetIndex"
00329 PetscErrorCode TransformIntAnnotationGetIndex(SalsaTransform tf,char *ann,int *idx,PetscTruth *flg)
00330 {
00331 int i; PetscTruth f; PetscErrorCode ierr;
00332 PetscFunctionBegin;
00333 *idx = -1;
00334 for (i=0; i<tf->n_annotate_i; i++) {
00335 ierr = PetscStrcmp(ann,tf->annotations_i[i],&f); CHKERRQ(ierr);
00336 if (f) {
00337 *idx = i; if (flg) *flg = f; break;
00338 }
00339 }
00340 PetscFunctionReturn(0);
00341 }
00342
00343 #undef __FUNCT__
00344 #define __FUNCT__ "TransformObjectMark"
00345 PetscErrorCode TransformObjectMark(SalsaTransformObject tf)
00346 {
00347 int j;
00348 PetscFunctionBegin;
00349 for (j=0; j<tf->n_options; j++)
00350 tf->options_marked[j] = 1;
00351 tf->marked = 1;
00352 PetscFunctionReturn(0);
00353 }
00354
00355 #undef __FUNCT__
00356 #define __FUNCT__ "TransformObjectUnmark"
00357 PetscErrorCode TransformObjectUnmark(SalsaTransformObject tf)
00358 {
00359 int j;
00360 PetscFunctionBegin;
00361 for (j=0; j<tf->n_options; j++)
00362 tf->options_marked[j] = 0;
00363 tf->marked = 0;
00364 PetscFunctionReturn(0);
00365 }
00366
00367 #undef __FUNCT__
00368 #define __FUNCT__ "TransformObjectsMarkAll"
00369 PetscErrorCode TransformObjectsMarkAll(SalsaTransform tf)
00370 {
00371 int i; PetscErrorCode ierr;
00372 PetscFunctionBegin;
00373 for (i=0; i<tf->n_objects; i++) {
00374 ierr = TransformObjectMark(tf->transformobjects[i]); CHKERRQ(ierr);
00375 }
00376 PetscFunctionReturn(0);
00377 }
00378
00379 #undef __FUNCT__
00380 #define __FUNCT__ "TransformObjectsUnmarkAll"
00381 PetscErrorCode TransformObjectsUnmarkAll(SalsaTransform tf)
00382 {
00383 int i; PetscErrorCode ierr;
00384 PetscFunctionBegin;
00385 for (i=0; i<tf->n_objects; i++) {
00386 ierr = TransformObjectUnmark(tf->transformobjects[i]); CHKERRQ(ierr);
00387 }
00388 PetscFunctionReturn(0);
00389 }
00390
00391 #undef __FUNCT__
00392 #define __FUNCT__ "TransformObjectGetMark"
00393 PetscErrorCode TransformObjectGetMark(SalsaTransformObject tf,int *m)
00394 {
00395 PetscFunctionBegin;
00396 *m = tf->marked;
00397 PetscFunctionReturn(0);
00398 }
00399
00400 #undef __FUNCT__
00401 #define __FUNCT__ "TransformGetNUnmarked"
00402 PetscErrorCode TransformGetNUnmarked(SalsaTransform tf,int *n)
00403 {
00404 int i;
00405 PetscFunctionBegin;
00406 *n = 0;
00407 for (i=0; i<tf->n_objects; i++)
00408 if (!tf->transformobjects[i]->marked) (*n)++;
00409 PetscFunctionReturn(0);
00410 }
00411
00412 #undef __FUNCT__
00413 #define __FUNCT__ "PreprocessorSaveAprioriSelection"
00414 PetscErrorCode PreprocessorSaveAprioriSelection(SystemPreprocessor pp)
00415 {
00416 SalsaTransform tf = pp->transform; int ipp;
00417 PetscFunctionBegin;
00418 for (ipp=0; ipp<tf->n_objects; ipp++) {
00419 tf->aprioriselection[ipp] = tf->transformobjects[ipp]->marked;
00420 }
00421 PetscFunctionReturn(0);
00422 }
00423
00424 #undef __FUNCT__
00425 #define __FUNCT__ "PreprocessorApplyAprioriSelection"
00426 PetscErrorCode PreprocessorApplyAprioriSelection(SystemPreprocessor pp)
00427 {
00428 SalsaTransform tf = pp->transform; int ipp;
00429 PetscFunctionBegin;
00430 for (ipp=0; ipp<tf->n_objects; ipp++) {
00431 tf->transformobjects[ipp]->marked = tf->aprioriselection[ipp];
00432 }
00433 PetscFunctionReturn(0);
00434 }
00435
00436 #undef __FUNCT__
00437 #define __FUNCT__ "TransformObjectsUseOnly"
00438
00439
00440
00441
00442
00443
00444
00445 PetscErrorCode TransformObjectsUseOnly(SalsaTransform tf,char *list)
00446 {
00447 char *c; PetscErrorCode ierr; PetscTruth eliminate;
00448 PetscFunctionBegin;
00449 c = strtok(list,",");
00450 eliminate = (PetscTruth)(c && (PetscTruth)!strcmp(c,"not"));
00451 if (eliminate) {
00452 ierr = TransformObjectsUnmarkAll(tf); CHKERRQ(ierr);
00453 c = strtok(NULL,",");
00454 } else {
00455 ierr = TransformObjectsMarkAll(tf); CHKERRQ(ierr);
00456 }
00457 while (c) {
00458 SalsaTransformObject to;
00459 ierr = TransformObjectGetByName(tf->name,c,&to); CHKERRQ(ierr);
00460 if (eliminate) {
00461 ierr = TransformObjectMark(to); CHKERRQ(ierr);
00462 } else {
00463 ierr = TransformObjectUnmark(to); CHKERRQ(ierr);
00464 }
00465 c = strtok(NULL,",");
00466 }
00467 PetscFunctionReturn(0);
00468 }
00469
00470 #undef __FUNCT__
00471 #define __FUNCT__ "TransformGetNextUnmarkedItem"
00472
00473
00474
00475
00476 PetscErrorCode TransformGetNextUnmarkedItem
00477 (SalsaTransform tf,char *old,SalsaTransformObject *snew,PetscTruth *f)
00478 {
00479 int idx; PetscTruth foundtheoldone,found;
00480 PetscFunctionBegin;
00481 found = PETSC_FALSE;
00482 foundtheoldone = TRUTH(old==NULL);
00483 for (idx=0; idx<tf->n_objects; idx++) {
00484 SalsaTransformObject to = tf->transformobjects[idx];
00485 if (!foundtheoldone) {
00486
00487
00488
00489 foundtheoldone = (PetscTruth)!strcmp(old,to->name);
00490 continue;
00491 }
00492 found = (PetscTruth)(!to->marked);
00493 if (found) {
00494 *snew = to;
00495 if (f) *f = PETSC_TRUE;
00496 PetscFunctionReturn(0);
00497 }
00498 }
00499 if (f) *f = found;
00500 else SETERRQ(1,"Could not find, but no flag given to report");
00501 PetscFunctionReturn(0);
00502 }
00503
00504 #define STRDUP(a) ( (a) ? strdup(a) : NULL)
00505
00506 #undef __FUNCT__
00507 #define __FUNCT__ "TransformObjectDefineOption"
00508 PetscErrorCode TransformObjectDefineOption(SalsaTransformObject tf,char *opt)
00509 {
00510 PetscFunctionBegin;
00511 tf->option = strdup(opt);
00512 PetscFunctionReturn(0);
00513 }
00514
00515 #undef __FUNCT__
00516 #define __FUNCT__ "TransformObjectAddOption"
00517 PetscErrorCode TransformObjectAddOption(SalsaTransformObject tf,int v)
00518 {
00519 PetscErrorCode ierr;
00520 PetscFunctionBegin;
00521 if (!tf->options) {
00522 ierr = PetscMalloc(TFINC*sizeof(int),&tf->options); CHKERRQ(ierr);
00523 ierr = PetscMemzero(tf->options,TFINC*sizeof(int)); CHKERRQ(ierr);
00524 ierr = PetscMalloc(TFINC*sizeof(int),&(tf->options_marked)); CHKERRQ(ierr);
00525 ierr = PetscMemzero(tf->options_marked,TFINC*sizeof(int)); CHKERRQ(ierr);
00526 ierr = PetscMalloc(TFINC*sizeof(char*),&(tf->optionexplanation)); CHKERRQ(ierr);
00527 ierr = PetscMemzero(tf->optionexplanation,TFINC*sizeof(char*)); CHKERRQ(ierr);
00528 tf->n_options = 0; tf->alloc_options = TFINC;
00529 }
00530 if (tf->n_options>=tf->alloc_options)
00531 SETERRQ1(1,"No space for further options in tranform %s",tf->name);
00532 tf->options[tf->n_options++] = v;
00533 PetscFunctionReturn(0);
00534 }
00535
00536 #undef __FUNCT__
00537 #define __FUNCT__ "TransformObjectAddOptionExplanation"
00538 PetscErrorCode TransformObjectAddOptionExplanation
00539 (SalsaTransformObject tf,int opt,char *ex)
00540 {
00541 int i;
00542 PetscFunctionBegin;
00543 for (i=0; i<tf->n_options; i++) {
00544 if (tf->options[i]==opt) {
00545 tf->optionexplanation[i] = strdup(ex);
00546 goto out;
00547 }
00548 }
00549 out:
00550 PetscFunctionReturn(0);
00551 }
00552
00553 #undef __FUNCT__
00554 #define __FUNCT__ "TransformItemOptionsUseOnly"
00555 PetscErrorCode TransformItemOptionsUseOnly(SalsaTransformObject tf,char *opt)
00556 {
00557 char *c; PetscErrorCode ierr;
00558 PetscFunctionBegin;
00559 c = strtok(opt,",");
00560 tf->n_options = 0;
00561 while (c) {
00562 int cv;
00563 sscanf(c,"%d",&cv);
00564 ierr = TransformObjectAddOption(tf,cv); CHKERRQ(ierr);
00565 c = strtok(NULL,",");
00566 }
00567 PetscFunctionReturn(0);
00568 }
00569
00570 #undef __FUNCT__
00571 #define __FUNCT__ "TransformItemGetFirstOption"
00572 PetscErrorCode TransformItemGetFirstOption(char* tf,char *it,int *v,PetscTruth *f)
00573 {
00574 SalsaTransformObject to; PetscTruth found,flg;
00575 int i; PetscErrorCode ierr;
00576
00577 PetscFunctionBegin;
00578 ierr = TransformObjectGetByName(tf,it,&to); CHKERRQ(ierr);
00579 found = PETSC_FALSE; flg = PETSC_FALSE;
00580 for (i=0; i<to->n_options; i++) {
00581 if (!to->options_marked[i]) {
00582 flg = PETSC_TRUE;
00583 *v = to->options[i];
00584 goto out;
00585 }
00586 }
00587
00588 out:
00589 if (f) *f = flg;
00590 PetscFunctionReturn(0);
00591 }
00592
00593 #undef __FUNCT__
00594 #define __FUNCT__ "TransformItemGetNextOption"
00595 PetscErrorCode TransformItemGetNextOption(char* tf,char *it,int *v,PetscTruth *f)
00596 {
00597 SalsaTransformObject to; PetscTruth found,flg;
00598 int i; PetscErrorCode ierr;
00599
00600 PetscFunctionBegin;
00601 ierr = TransformObjectGetByName(tf,it,&to); CHKERRQ(ierr);
00602 found = PETSC_FALSE; flg = PETSC_FALSE;
00603 for (i=0; i<to->n_options; i++) {
00604 if (found && !to->options_marked[i]) {
00605 flg = PETSC_TRUE;
00606 *v = to->options[i];
00607 goto out;
00608 }
00609 if (to->options[i]==*v) found = PETSC_TRUE;
00610 }
00611
00612 out:
00613 if (f) *f = flg;
00614 PetscFunctionReturn(0);
00615 }
00616
00617 #undef __FUNCT__
00618 #define __FUNCT__ "TransformItemOptionMark"
00619 PetscErrorCode TransformItemOptionMark(SalsaTransform tf,char *it,int o)
00620 {
00621 SalsaTransformObject to; int i; PetscErrorCode ierr;
00622 PetscFunctionBegin;
00623
00624 ierr = TransformObjectGetByName(tf->name,it,&to); CHKERRQ(ierr);
00625 to->marked = 0;
00626 for (i=0; i<to->n_options; i++)
00627 if (to->options[i]==o) to->options_marked[i] = 1;
00628
00629 PetscFunctionReturn(0);
00630 }
00631
00632 #undef __FUNCT__
00633 #define __FUNCT__ "TransformObjectCharAnnotate"
00634 PetscErrorCode TransformObjectCharAnnotate(SalsaTransformObject tf,char *an,char *v)
00635 {
00636 int idx; PetscTruth f; PetscErrorCode ierr;
00637 PetscFunctionBegin;
00638 if (!tf->annotate_c) {
00639 ierr = PetscMalloc(TFINC*sizeof(char*),&tf->annotate_c); CHKERRQ(ierr);
00640 ierr = PetscMemzero(tf->annotate_c,TFINC*sizeof(char*)); CHKERRQ(ierr);
00641 tf->alloc_annotate_c = TFINC;
00642 }
00643 ierr = TransformCharAnnotationGetIndex
00644 (tf->transform,an,&idx,&f); CHKERRQ(ierr);
00645 if (!f) SETERRQ1(1,"Could not find annotation %s",an);
00646 if (idx>=tf->alloc_annotate_c)
00647 SETERRQ1(1,"Char annotate index too large: %d.",idx);
00648 tf->annotate_c[idx] = v;
00649 PetscFunctionReturn(0);
00650 }
00651
00652 #undef __FUNCT__
00653 #define __FUNCT__ "TransformObjectIntAnnotate"
00654 PetscErrorCode TransformObjectIntAnnotate
00655 (SalsaTransformObject tf,char *an,int v)
00656 {
00657 int idx; PetscTruth f; PetscErrorCode ierr;
00658 PetscFunctionBegin;
00659 if (!tf->annotate_i) {
00660 ierr = PetscMalloc(TFINC*sizeof(int),&tf->annotate_i); CHKERRQ(ierr);
00661 ierr = PetscMemzero(tf->annotate_i,TFINC*sizeof(int)); CHKERRQ(ierr);
00662 tf->alloc_annotate_i = TFINC;
00663 }
00664 ierr = TransformIntAnnotationGetIndex
00665 (tf->transform,an,&idx,&f); CHKERRQ(ierr);
00666 if (!f) SETERRQ1(1,"Could not find annotation %s",an);
00667 if (idx>=tf->alloc_annotate_i)
00668 SETERRQ1(1,"Int annotate index too large: %d.",idx);
00669 tf->annotate_i[idx] = v;
00670 PetscFunctionReturn(0);
00671 }
00672
00673 #undef __FUNCT__
00674 #define __FUNCT__ "TransformObjectGetIntAnnotation"
00675 PetscErrorCode TransformObjectGetIntAnnotation
00676 (SalsaTransformObject tf,char *an,int *v,PetscTruth *f)
00677 {
00678 SalsaTransform tt = tf->transform; int ian;
00679 PetscFunctionBegin;
00680 *f = PETSC_FALSE;
00681 for (ian=0; ian<tt->n_annotate_i; ian++) {
00682 if (!strcmp(tt->annotations_i[ian],an)) {
00683 *f = TRUTH(tf->annotate_i!=NULL);
00684 if (*f) *v = tf->annotate_i[ian];
00685 PetscFunctionReturn(0);
00686 }
00687 }
00688 PetscFunctionReturn(0);
00689 }
00690
00691 #undef __FUNCT__
00692 #define __FUNCT__ "TransformReportTeXTable"
00693 PetscErrorCode TransformReportTeXTable(SalsaTransform tf,FILE *f)
00694 {
00695 int i,j;
00696 PetscFunctionBegin;
00697 for (i=0; i<tf->n_objects; i++) {
00698 SalsaTransformObject to = tf->transformobjects[i];
00699 fprintf(f,"%s&%s",to->name,to->explanation);
00700 if (to->n_options>0) {
00701
00702
00703
00704 for (j=0; j<to->n_options; j++) {
00705 fprintf(f,"%d,",to->options[j]);
00706 }
00707 } else fprintf(f,"&&");
00708 fprintf(f,"\\\\\n");
00709 }
00710 PetscFunctionReturn(0);
00711 }
00712
00713 #undef __FUNCT__
00714 #define __FUNCT__ "TransformReportEnabled"
00715 PetscErrorCode TransformReportEnabled(SalsaTransform tf,char **rs)
00716 {
00717 char *s,**names; int i; size_t l; PetscErrorCode ierr;
00718 PetscFunctionBegin;
00719 ierr = PetscMalloc(1000*sizeof(char),&s); CHKERRQ(ierr);
00720 ierr = PetscMemzero(s,1000*sizeof(char)); CHKERRQ(ierr);
00721 ierr = TransformObjectsGetNames(tf,&names); CHKERRQ(ierr);
00722 for (i=0; i<tf->n_objects; i++) {
00723 int mark;
00724 ierr = TransformObjectGetMark(tf->transformobjects[i],&mark); CHKERRQ(ierr);
00725 if (!mark) {
00726 ierr = PetscStrlen(s,&l); CHKERRQ(ierr);
00727 if (l) {sprintf(s+l," "); l++;} sprintf(s+l,"%s",names[i]);
00728 }
00729 }
00730 ierr = PetscFree(names); CHKERRQ(ierr);
00731 *rs = s;
00732 PetscFunctionReturn(0);
00733 }
00734
00735 #undef __FUNCT__
00736 #define __FUNCT__ "TransformItemDescribeShort"
00737 PetscErrorCode TransformItemDescribeShort(SalsaTransform tf,char *it,int opt,char **s)
00738 {
00739 SalsaTransformObject to; char *ss; size_t l; PetscErrorCode ierr;
00740 PetscFunctionBegin;
00741 ierr = TransformObjectGetByName(tf->name,it,&to); CHKERRQ(ierr);
00742 ierr = PetscMalloc(200*sizeof(char),&ss); CHKERRQ(ierr);
00743 sprintf(ss,"%s",to->name); CHKERRQ(ierr);
00744 ierr = PetscStrlen(ss,&l); CHKERRQ(ierr);
00745 if (to->n_options) {
00746 sprintf(ss+l,"(%d)",opt);
00747 ierr = PetscStrlen(ss,&l); CHKERRQ(ierr);
00748 }
00749 *s = ss;
00750 PetscFunctionReturn(0);
00751 }
00752
00753 #undef __FUNCT__
00754 #define __FUNCT__ "TransformItemDescribeLong"
00755 PetscErrorCode TransformItemDescribeLong(SalsaTransform tf,char *it,int opt,char **s)
00756 {
00757 SalsaTransformObject to;
00758 char *ss; size_t l; PetscErrorCode ierr;
00759
00760 PetscFunctionBegin;
00761 ierr = TransformObjectGetByName(tf->name,it,&to); CHKERRQ(ierr);
00762 ierr = PetscMalloc(200*sizeof(char),&ss); CHKERRQ(ierr);
00763 sprintf(ss,"%s",to->explanation); CHKERRQ(ierr);
00764 ierr = PetscStrlen(ss,&l); CHKERRQ(ierr);
00765 #if 0
00766 if (to->options[idx]) {
00767 sprintf(ss+l,"; %s",tf->options[idx]);
00768 ierr = PetscStrlen(ss,&l); CHKERRQ(ierr);
00769 }
00770 if (tf->noptions[idx]) {
00771 ierr = TransformItemGetOptionIndex(tf,idx,opt,&odx); CHKERRQ(ierr);
00772 if (odx>=0)
00773 sprintf(ss+l," %s",tf->options_texts[idx][odx]);
00774 else
00775 sprintf(ss+l,"(%d)",opt);
00776 ierr = PetscStrlen(ss,&l); CHKERRQ(ierr);
00777 }
00778 #endif
00779 *s = ss;
00780 PetscFunctionReturn(0);
00781 }
00782
00783 #undef __FUNCT__
00784 #define __FUNCT__ "TransformSetUserChoices"
00785 PetscErrorCode TransformSetUserChoices(SalsaTransform tf,PetscTruth ch)
00786 {
00787 PetscFunctionBegin;
00788 tf->userchoices = ch;
00789 PetscFunctionReturn(0);
00790 }
00791
00792 #undef __FUNCT__
00793 #define __FUNCT__ "TransformGetUserChoices"
00794 PetscErrorCode TransformGetUserChoices(SalsaTransform tf,PetscTruth *ch)
00795 {
00796 PetscFunctionBegin;
00797 *ch = tf->userchoices;
00798 PetscFunctionReturn(0);
00799 }
00800