[BACK]Return to option.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / Kan

Annotation of OpenXM/src/kan96xx/Kan/option.c, Revision 1.10

1.10    ! takayama    1: /* $OpenXM: OpenXM/src/kan96xx/Kan/option.c,v 1.9 2003/07/29 08:36:40 takayama Exp $ */
1.1       maekawa     2: #include <stdio.h>
                      3: #include "datatype.h"
                      4: #include "stackm.h"
                      5: #include "extern.h"
                      6: #include "gradedset.h"
                      7: #include "kclass.h"
                      8: #include "lookup.h"
                      9: #include <signal.h>
                     10:
                     11: extern void ctrlC();
                     12:
                     13:
                     14: struct object KsystemVariable(ob)
1.5       takayama   15:      struct object ob; /* Sarray */
1.1       maekawa    16: {
                     17:   /* Don't forget to write the keys in usage.c */
                     18:   extern int PrintDollar;
                     19:   extern int Wrap;
                     20:   extern struct ring *CurrentRingp;
                     21:   extern int Verbose;
                     22:   extern int UseCriterion1;
                     23:   extern int UseCriterion2B;
                     24:   extern int ReduceLowerTerms;
                     25:   extern int CheckHomogenization;
                     26:   extern int Homogenize;
                     27:   extern int Statistics;
1.3       takayama   28:   extern int AutoReduce;
1.1       maekawa    29:   extern int Osp;
                     30:   extern struct operandStack StandardStack;
                     31:   extern struct operandStack ErrorStack;
                     32:   extern int ErrorMessageMode;
                     33:   extern int WarningMessageMode;
                     34:   extern int CatchCtrlC;
                     35:   extern int Strict;
                     36:   extern struct context *CurrentContextp;
                     37:   extern struct context *PrimitiveContextp;
                     38:   extern int Strict2;
                     39:   extern int SigIgn;
                     40:   extern int KSPushEnvMode;
                     41:   extern int KanGBmessage;
                     42:   extern int TimerOn;
                     43:   extern int OutputStyle;
                     44:   extern int Sugar;
                     45:   extern int Homogenize_vec;
                     46:   extern int CmoDMSOutputOption;
                     47:   extern int DebugReductionRed; /* hidden option */
1.9       takayama   48:   extern int DebugReductionEcart;
1.1       maekawa    49:   extern char *VersionString;
                     50:   extern int AvoidTheSameRing;
1.2       takayama   51:   extern char *LeftBracket;
                     52:   extern char *RightBracket;
1.4       takayama   53:   extern int SecureMode;
1.7       takayama   54:   extern int Ecart;
1.8       takayama   55:   extern int EcartAutomaticHomogenization;
1.1       maekawa    56:
                     57:   int n,i;
                     58:   struct object ob1,ob2,ob3,ob4;
                     59:   struct object rob = NullObject;
                     60:   switch (getoaSize(ob)) {
                     61:   case 1:   /* get the value */
                     62:     ob1 = getoa(ob,0);
                     63:     switch(ob1.tag) {
                     64:     case Sdollar:
                     65:       if (strcmp(ob1.lc.str,"PrintDollar") == 0) {
1.5       takayama   66:         rob = KpoInteger(PrintDollar);
1.1       maekawa    67:       }else if (strcmp(ob1.lc.str,"Wrap") == 0) {
1.5       takayama   68:         rob = KpoInteger(Wrap);
1.1       maekawa    69:       }else if (strcmp(ob1.lc.str,"P") == 0) {
1.5       takayama   70:         rob = KpoInteger(CurrentRingp->p);
1.1       maekawa    71:       }else if (strcmp(ob1.lc.str,"N") == 0) {
1.5       takayama   72:         rob = KpoInteger(CurrentRingp->n);
1.1       maekawa    73:       }else if (strcmp(ob1.lc.str,"NN") == 0) {
1.5       takayama   74:         rob = KpoInteger(CurrentRingp->nn);
1.1       maekawa    75:       }else if (strcmp(ob1.lc.str,"M") == 0) {
1.5       takayama   76:         rob = KpoInteger(CurrentRingp->m);
1.1       maekawa    77:       }else if (strcmp(ob1.lc.str,"MM") == 0) {
1.5       takayama   78:         rob = KpoInteger(CurrentRingp->mm);
1.1       maekawa    79:       }else if (strcmp(ob1.lc.str,"L") == 0) {
1.5       takayama   80:         rob = KpoInteger(CurrentRingp->l);
1.1       maekawa    81:       }else if (strcmp(ob1.lc.str,"LL") == 0) {
1.5       takayama   82:         rob = KpoInteger(CurrentRingp->ll);
1.1       maekawa    83:       }else if (strcmp(ob1.lc.str,"C") == 0) {
1.5       takayama   84:         rob = KpoInteger(CurrentRingp->c);
1.1       maekawa    85:       }else if (strcmp(ob1.lc.str,"CC") == 0) {
1.5       takayama   86:         rob = KpoInteger(CurrentRingp->cc);
1.1       maekawa    87:       }else if (strcmp(ob1.lc.str,"CurrentRingp") == 0) {
1.5       takayama   88:         rob = KpoRingp(CurrentRingp);
1.1       maekawa    89:       }else if (strcmp(ob1.lc.str,"Verbose") == 0) {
1.5       takayama   90:         rob = KpoInteger(Verbose);
1.1       maekawa    91:       }else if (strcmp(ob1.lc.str,"UseCriterion1") == 0) {
1.5       takayama   92:         rob = KpoInteger(UseCriterion1);
1.1       maekawa    93:       }else if (strcmp(ob1.lc.str,"UseCriterion2B") == 0) {
1.5       takayama   94:         rob = KpoInteger(UseCriterion2B);
1.1       maekawa    95:       }else if (strcmp(ob1.lc.str,"ReduceLowerTerms") == 0) {
1.5       takayama   96:         rob = KpoInteger(ReduceLowerTerms);
1.1       maekawa    97:       }else if (strcmp(ob1.lc.str,"CheckHomogenization") == 0) {
1.5       takayama   98:         rob = KpoInteger(CheckHomogenization);
1.1       maekawa    99:       }else if (strcmp(ob1.lc.str,"Homogenize") == 0) {
1.5       takayama  100:         rob = KpoInteger(Homogenize);
1.1       maekawa   101:       }else if (strcmp(ob1.lc.str,"Statistics") == 0) {
1.5       takayama  102:         rob = KpoInteger(Statistics);
1.3       takayama  103:       }else if (strcmp(ob1.lc.str,"AutoReduce") == 0) {
1.5       takayama  104:         rob = KpoInteger(AutoReduce);
1.1       maekawa   105:       }else if (strcmp(ob1.lc.str,"StackPointer") == 0) {
1.5       takayama  106:         rob = KpoInteger(Osp);
1.1       maekawa   107:       }else if (strcmp(ob1.lc.str,"StandardOperandStack") == 0) {
1.5       takayama  108:         rob.tag = Sclass;
                    109:         rob.lc.ival = CLASSNAME_OPERANDSTACK;
                    110:         rob.rc.voidp = &StandardStack;
1.1       maekawa   111:       }else if (strcmp(ob1.lc.str,"ErrorStack") == 0) {
1.5       takayama  112:         rob.tag = Sclass;
                    113:         rob.lc.ival = CLASSNAME_OPERANDSTACK;
                    114:         rob.rc.voidp = &ErrorStack;
1.1       maekawa   115:       }else if (strcmp(ob1.lc.str,"ErrorMessageMode") == 0) {
1.5       takayama  116:         rob = KpoInteger(ErrorMessageMode);
1.1       maekawa   117:       }else if (strcmp(ob1.lc.str,"WarningMessageMode") == 0) {
1.5       takayama  118:         rob = KpoInteger(WarningMessageMode);
1.1       maekawa   119:       }else if (strcmp(ob1.lc.str,"CatchCtrlC") == 0) {
1.5       takayama  120:         rob = KpoInteger(CatchCtrlC);
                    121:         /* If you catch ctrlc in KSexecuteString. */
1.1       maekawa   122:       }else if (strcmp(ob1.lc.str,"Strict") == 0) {
1.5       takayama  123:         rob = KpoInteger(Strict);
1.1       maekawa   124:       }else if (strcmp(ob1.lc.str,"CurrentContextp") == 0) {
1.5       takayama  125:         rob.tag = Sclass;
                    126:         rob.lc.ival = CLASSNAME_CONTEXT;
                    127:         rob.rc.voidp = CurrentContextp;
1.1       maekawa   128:       }else if (strcmp(ob1.lc.str,"PrimitiveContextp") == 0) {
1.5       takayama  129:         rob.tag = Sclass;
                    130:         rob.lc.ival = CLASSNAME_CONTEXT;
                    131:         rob.rc.voidp = PrimitiveContextp;
1.1       maekawa   132:       }else if (strcmp(ob1.lc.str,"NullContextp") == 0) {
1.5       takayama  133:         rob.tag = Sclass;
                    134:         rob.lc.ival = CLASSNAME_CONTEXT;
                    135:         rob.rc.voidp = (struct context *)NULL;
1.1       maekawa   136:       }else if (strcmp(ob1.lc.str,"Strict2") == 0) {
1.5       takayama  137:         rob = KpoInteger(Strict2);
1.1       maekawa   138:       }else if (strcmp(ob1.lc.str,"SigIgn") == 0) {
1.5       takayama  139:         rob = KpoInteger(SigIgn);
1.1       maekawa   140:       }else if (strcmp(ob1.lc.str,"KSPushEnvMode") == 0) {
1.5       takayama  141:         rob = KpoInteger(KSPushEnvMode);
1.1       maekawa   142:       }else if (strcmp(ob1.lc.str,"KanGBmessage") == 0) {
1.5       takayama  143:         rob = KpoInteger(KanGBmessage);
1.1       maekawa   144:       }else if (strcmp(ob1.lc.str,"TimerOn") == 0) {
1.5       takayama  145:         rob = KpoInteger(TimerOn);
1.1       maekawa   146:       }else if (strcmp(ob1.lc.str,"orderMatrix") == 0) {
1.5       takayama  147:         rob = KgetOrderMatrixOfCurrentRing();
1.1       maekawa   148:       }else if (strcmp(ob1.lc.str,"gbListTower") == 0) {
1.5       takayama  149:         if (CurrentRingp->gbListTower == NULL) rob = NullObject;
                    150:         else rob = *((struct object *)(CurrentRingp->gbListTower));
1.1       maekawa   151:       }else if (strcmp(ob1.lc.str,"outputOrder") == 0) {
1.5       takayama  152:         n = CurrentRingp->n;
                    153:         ob1 = newObjectArray(n*2);
                    154:         for (i=0; i<2*n; i++) {
                    155:           putoa(ob1,i,KpoInteger(CurrentRingp->outputOrder[i]));
                    156:         }
                    157:         rob = ob1;
1.1       maekawa   158:       }else if (strcmp(ob1.lc.str,"multSymbol") == 0) {
1.5       takayama  159:         rob = KpoInteger(OutputStyle);
1.1       maekawa   160:       }else if (strcmp(ob1.lc.str,"Sugar") == 0) {
1.5       takayama  161:         rob = KpoInteger(Sugar);
1.1       maekawa   162:       }else if (strcmp(ob1.lc.str,"Homogenize_vec") == 0) {
1.5       takayama  163:         rob = KpoInteger(Homogenize_vec);
1.1       maekawa   164:       }else if (strcmp(ob1.lc.str,"Schreyer")==0) {
1.5       takayama  165:         rob = KpoInteger( CurrentRingp->schreyer );
1.1       maekawa   166:       }else if (strcmp(ob1.lc.str,"ringName")==0) {
1.5       takayama  167:         rob = KpoString( CurrentRingp->name );
1.1       maekawa   168:       }else if (strcmp(ob1.lc.str,"CmoDMSOutputOption")==0) {
1.5       takayama  169:         rob = KpoInteger( CmoDMSOutputOption );
1.1       maekawa   170:       }else if (strcmp(ob1.lc.str,"Version")==0) {
1.5       takayama  171:         rob = KpoString(VersionString);
1.1       maekawa   172:       }else if (strcmp(ob1.lc.str,"RingStack")==0) {
1.5       takayama  173:         KsetUpRing(NullObject,NullObject,NullObject,NullObject,NullObject);
                    174:         rob = KSpop(); /* This is exceptional style */
1.1       maekawa   175:       }else if (strcmp(ob1.lc.str,"AvoidTheSameRing")==0) {
1.5       takayama  176:         rob = KpoInteger(AvoidTheSameRing);
1.2       takayama  177:       }else if (strcmp(ob1.lc.str,"LeftBracket")==0) {
1.5       takayama  178:         rob = KpoString(LeftBracket);
1.2       takayama  179:       }else if (strcmp(ob1.lc.str,"RightBracket")==0) {
1.5       takayama  180:         rob = KpoString(RightBracket);
1.4       takayama  181:       }else if (strcmp(ob1.lc.str,"SecureMode")==0) {
1.5       takayama  182:         rob = KpoInteger(SecureMode);
1.7       takayama  183:       }else if (strcmp(ob1.lc.str,"Ecart")==0) {
                    184:         rob = KpoInteger(Ecart);
1.8       takayama  185:       }else if (strcmp(ob1.lc.str,"EcartAutomaticHomogenization")==0) {
                    186:         rob = KpoInteger(EcartAutomaticHomogenization);
1.1       maekawa   187:       }else{
1.5       takayama  188:         warningKan("KsystemVariable():Unknown key word.\n");
1.1       maekawa   189:       }
                    190:       break;
                    191:     default:
                    192:       warningKan("KsystemVariable():Invalid argument\n");
                    193:       break;
                    194:     }
                    195:     break;
                    196:   case 2: /* set value */
                    197:     ob1 = getoa(ob,0);
                    198:     ob2 = getoa(ob,1);
                    199:     switch (Lookup[ob1.tag][ob2.tag]) {
                    200:     case SdollarSinteger:
                    201:       if (strcmp(ob1.lc.str,"PrintDollar") == 0) {
1.5       takayama  202:         PrintDollar = ob2.lc.ival;
                    203:         rob = KpoInteger(PrintDollar);
1.1       maekawa   204:       }else if (strcmp(ob1.lc.str,"Wrap") == 0) {
1.5       takayama  205:         Wrap = ob2.lc.ival;
                    206:         rob = KpoInteger(Wrap);
                    207:         /*}else if (strcmp(ob1.lc.str,"P") == 0) {
                    208:           P = ob2.lc.ival;  Q should be set here too.
                    209:           CurrentRingp->p = P;
                    210:           rob = KpoInteger(P); */
1.1       maekawa   211:       }else if (strcmp(ob1.lc.str,"NN") == 0) {
1.5       takayama  212:         if (ob2.lc.ival <= CurrentRingp->n && ob2.lc.ival >= CurrentRingp->m) {
                    213:           CurrentRingp->nn = ob2.lc.ival;
                    214:         }else{
                    215:           warningKan("New value of NN is out of bound.");
                    216:         }
                    217:         rob = KpoInteger(ob1.lc.ival);
1.1       maekawa   218:       }else if (strcmp(ob1.lc.str,"Verbose") == 0) {
1.5       takayama  219:         Verbose = ob2.lc.ival;
                    220:         rob = KpoInteger(Verbose);
1.1       maekawa   221:       }else if (strcmp(ob1.lc.str,"UseCriterion1") == 0) {
1.5       takayama  222:         UseCriterion1 = ob2.lc.ival;
                    223:         rob = KpoInteger(UseCriterion1);
1.1       maekawa   224:       }else if (strcmp(ob1.lc.str,"UseCriterion2B") == 0) {
1.5       takayama  225:         UseCriterion2B = ob2.lc.ival;
                    226:         rob = KpoInteger(UseCriterion2B);
1.1       maekawa   227:       }else if (strcmp(ob1.lc.str,"ReduceLowerTerms") == 0) {
1.5       takayama  228:         ReduceLowerTerms = ob2.lc.ival;
                    229:         rob = KpoInteger(ReduceLowerTerms);
1.1       maekawa   230:       }else if (strcmp(ob1.lc.str,"CheckHomogenization") == 0) {
1.5       takayama  231:         CheckHomogenization = ob2.lc.ival;
                    232:         rob = KpoInteger(CheckHomogenization);
1.1       maekawa   233:       }else if (strcmp(ob1.lc.str,"Homogenize") == 0) {
1.5       takayama  234:         Homogenize = ob2.lc.ival;
                    235:         rob = KpoInteger(Homogenize);
1.1       maekawa   236:       }else if (strcmp(ob1.lc.str,"Statistics") == 0) {
1.5       takayama  237:         Statistics = ob2.lc.ival;
                    238:         rob = KpoInteger(Statistics);
1.3       takayama  239:       }else if (strcmp(ob1.lc.str,"AutoReduce") == 0) {
1.5       takayama  240:         AutoReduce = ob2.lc.ival;
                    241:         rob = KpoInteger(AutoReduce);
1.1       maekawa   242:       }else if (strcmp(ob1.lc.str,"ErrorMessageMode") == 0) {
1.5       takayama  243:         ErrorMessageMode = ob2.lc.ival;
                    244:         rob = KpoInteger(ErrorMessageMode);
1.1       maekawa   245:       }else if (strcmp(ob1.lc.str,"WarningMessageMode") == 0) {
1.5       takayama  246:         WarningMessageMode = ob2.lc.ival;
                    247:         rob = KpoInteger(WarningMessageMode);
1.1       maekawa   248:       }else if (strcmp(ob1.lc.str,"CatchCtrlC") == 0) {
1.5       takayama  249:         CatchCtrlC = ob2.lc.ival;
                    250:         rob = KpoInteger(CatchCtrlC);
1.1       maekawa   251:       }else if (strcmp(ob1.lc.str,"Strict") == 0) {
1.5       takayama  252:         Strict = ob2.lc.ival;
                    253:         rob = KpoInteger(Strict);
1.1       maekawa   254:       }else if (strcmp(ob1.lc.str,"Strict2") == 0) {
1.5       takayama  255:         Strict2 = ob2.lc.ival;
                    256:         rob = KpoInteger(Strict2);
1.1       maekawa   257:       }else if (strcmp(ob1.lc.str,"SigIgn") == 0) {
1.5       takayama  258:         SigIgn = ob2.lc.ival;
                    259:         if (SigIgn) signal(SIGINT,SIG_IGN);
                    260:         else signal(SIGINT,ctrlC);
                    261:         rob = KpoInteger(SigIgn);
1.1       maekawa   262:       }else if (strcmp(ob1.lc.str,"KSPushEnvMode") == 0) {
1.5       takayama  263:         KSPushEnvMode = ob2.lc.ival;
                    264:         rob = KpoInteger(KSPushEnvMode);
1.1       maekawa   265:       }else if (strcmp(ob1.lc.str,"KanGBmessage") == 0) {
1.5       takayama  266:         KanGBmessage = ob2.lc.ival;
                    267:         rob = KpoInteger(KanGBmessage);
1.1       maekawa   268:       }else if (strcmp(ob1.lc.str,"TimerOn") == 0) {
1.5       takayama  269:         TimerOn = ob2.lc.ival;
                    270:         rob = KpoInteger(TimerOn);
1.1       maekawa   271:       }else if (strcmp(ob1.lc.str,"multSymbol") == 0) {
1.5       takayama  272:         OutputStyle = KopInteger(ob2);
                    273:         rob = KpoInteger(OutputStyle);
1.1       maekawa   274:       }else if (strcmp(ob1.lc.str,"Sugar") == 0) {
1.5       takayama  275:         Sugar = KopInteger(ob2);
                    276:         if (Sugar && ReduceLowerTerms) {
                    277:           ReduceLowerTerms = 0;
                    278:           warningKan("ReduceLowerTerms is automatically set to 0, because Sugar = 1.");
                    279:           /* You cannot use both ReduceLowerTerms and sugar.
                    280:              See gb.c, reduction_sugar. */
                    281:         }
                    282:         rob = KpoInteger(Sugar);
1.1       maekawa   283:       }else if (strcmp(ob1.lc.str,"Homogenize_vec") == 0) {
1.5       takayama  284:         Homogenize_vec = KopInteger(ob2);
                    285:         rob = KpoInteger(Homogenize_vec);
1.1       maekawa   286:       }else if (strcmp(ob1.lc.str,"CmoDMSOutputOption") == 0) {
1.5       takayama  287:         CmoDMSOutputOption = KopInteger(ob2);
                    288:         rob = KpoInteger(CmoDMSOutputOption);
1.1       maekawa   289:       }else if (strcmp(ob1.lc.str,"DebugReductionRed") == 0) {
1.5       takayama  290:         DebugReductionRed = KopInteger(ob2);
                    291:         rob = KpoInteger(DebugReductionRed);
1.9       takayama  292:       }else if (strcmp(ob1.lc.str,"DebugReductionEcart") == 0) {
                    293:         DebugReductionEcart = KopInteger(ob2);
                    294:         rob = KpoInteger(DebugReductionEcart);
1.1       maekawa   295:       }else if (strcmp(ob1.lc.str,"AvoidTheSameRing") == 0) {
1.5       takayama  296:         AvoidTheSameRing = KopInteger(ob2);
                    297:         rob = KpoInteger(AvoidTheSameRing);
1.4       takayama  298:       }else if (strcmp(ob1.lc.str,"SecureMode") == 0) {
1.5       takayama  299:         if (KopInteger(ob2) >= SecureMode) {
                    300:           SecureMode = KopInteger(ob2);
                    301:         }else{
                    302:           errorKan1("%s\n","You cannot weaken the security level.");
                    303:         }
                    304:         rob = KpoInteger(SecureMode);
1.7       takayama  305:       }else if (strcmp(ob1.lc.str,"Ecart") == 0) {
                    306:         Ecart = KopInteger(ob2);
                    307:         rob = KpoInteger(Ecart);
1.8       takayama  308:       }else if (strcmp(ob1.lc.str,"EcartAutomaticHomogenization") == 0) {
1.10    ! takayama  309:         EcartAutomaticHomogenization = KopInteger(ob2);
1.8       takayama  310:         rob = KpoInteger(EcartAutomaticHomogenization);
1.1       maekawa   311:       }else{
1.5       takayama  312:         warningKan("KsystemVariable():Unknown key word.\n");
1.1       maekawa   313:       }
                    314:       break;
                    315:     case SdollarSdollar:
                    316:       if (strcmp(ob1.lc.str,"ringName") == 0) {
1.5       takayama  317:         CurrentRingp->name = KopString(ob2);
                    318:         rob = KpoString(CurrentRingp->name);
1.2       takayama  319:       }else if (strcmp(ob1.lc.str,"LeftBracket") == 0) {
1.5       takayama  320:         LeftBracket = KopString(ob2);
                    321:         rob = KpoString(LeftBracket);
1.2       takayama  322:       }else if (strcmp(ob1.lc.str,"RightBracket") == 0) {
1.5       takayama  323:         RightBracket = KopString(ob2);
                    324:         rob = KpoString(RightBracket);
1.1       maekawa   325:       }else{
1.5       takayama  326:         warningKan("KsystemVariable():Unknown key word.\n");
1.1       maekawa   327:       }
                    328:       break;
                    329:     case SdollarSring:
                    330:       if (strcmp(ob1.lc.str,"CurrentRingp") == 0) {
1.5       takayama  331:         CurrentRingp = ob2.lc.ringp;
                    332:         rob = KpoRingp(CurrentRingp);
1.1       maekawa   333:       }else{
1.5       takayama  334:         warningKan("KsystemVariable():Unknown key word.\n");
1.1       maekawa   335:       }
                    336:       break;
                    337:     case SdollarSclass:
                    338:       if (strcmp(ob1.lc.str,"PrimitiveContextp") == 0) {
1.5       takayama  339:         if (ectag(ob2) == CLASSNAME_CONTEXT) {
                    340:           PrimitiveContextp = (struct context *)ob2.rc.voidp;
                    341:           rob = ob2;
                    342:         }else{
                    343:           warningKan("The second argument must be class.context.\n");
                    344:           rob = NullObject;
                    345:         }
1.1       maekawa   346:       }else {
1.5       takayama  347:         warningKan("KsystemVariable():Unknown key word.\n");
1.1       maekawa   348:       }
                    349:       break;
                    350:     case SdollarSlist:
                    351:       if (strcmp(ob1.lc.str,"gbListTower") == 0) {
1.5       takayama  352:         if (AvoidTheSameRing)
                    353:           warningKan("Changing gbListTower may cause a trouble under AvoidTheSameRing == 1.");
                    354:         CurrentRingp->gbListTower = newObject();
                    355:         *((struct object *)(CurrentRingp->gbListTower)) = ob2;
                    356:         rob = *((struct object *)(CurrentRingp->gbListTower));
1.1       maekawa   357:       }else {
1.5       takayama  358:         warningKan("KsystemVariable(): Unknown key word to set value.\n");
1.1       maekawa   359:       }
                    360:       break;
                    361:     case SdollarSarray:
                    362:       if (strcmp(ob1.lc.str,"outputOrder") == 0) {
1.5       takayama  363:         rob = KsetOutputOrder(ob2,CurrentRingp);
1.1       maekawa   364:       }else if (strcmp(ob1.lc.str,"variableNames") == 0) {
1.5       takayama  365:         rob = KsetVariableNames(ob2,CurrentRingp);
1.1       maekawa   366:       }else {
1.5       takayama  367:         warningKan("KsystemVariable(): Unknown key word to set value.\n");
1.1       maekawa   368:       }
                    369:       break;
                    370:     default:
                    371:       warningKan("KsystemVariable():Invalid argument.\n");
                    372:     }
                    373:     break;
                    374:   case 3:
                    375:     ob1 = getoa(ob,0); ob2 = getoa(ob,1); ob3 = getoa(ob,2);
                    376:     switch(Lookup[ob1.tag][ob2.tag]) {
                    377:     case SdollarSdollar:
                    378:       if (strcmp(ob2.lc.str,"var") == 0) {
1.5       takayama  379:         if (strcmp(ob1.lc.str,"x")==0) {
                    380:           if (ob3.tag != Sinteger) {
                    381:             warningKan("[$x$ $var$ ? ] The 3rd argument must be integer.");
                    382:             break;
                    383:           }
                    384:           if (ob3.lc.ival >= 0 && ob3.lc.ival < CurrentRingp->n) {
                    385:             rob = KpoString(CurrentRingp->x[ob3.lc.ival]);
                    386:           }else{
                    387:             warningKan("[$x$ $var$ ? ] The 3rd argument is out of range.");
                    388:             break;
                    389:           }
                    390:         }else if (strcmp(ob1.lc.str,"D")==0) {
                    391:           if (ob3.tag != Sinteger) {
                    392:             warningKan("[$D$ $var$ ? ] The 3rd argument must be integer.");
                    393:             break;
                    394:           }
                    395:           if (ob3.lc.ival >= 0 && ob3.lc.ival < CurrentRingp->n) {
                    396:             rob = KpoString(CurrentRingp->D[ob3.lc.ival]);
                    397:           }else{
                    398:             warningKan("[$D$ $var$ ? ] The 3rd argument is out of range.");
                    399:             break;
                    400:           }
                    401:         }
1.1       maekawa   402:       }else{
1.5       takayama  403:         warningKan("KsystemVariable(): Invalid argument.\n");
1.1       maekawa   404:       }
                    405:       break;
                    406:     default:
                    407:       warningKan("KsystemVariable(): Invalid argument.\n");
                    408:       break;
                    409:     }
                    410:     break;
                    411:   default:
                    412:     warningKan("KsystemVariable():Invalid argument.\n");
                    413:     break;
                    414:   }
                    415:   return(rob);
                    416: }
                    417:
                    418: warningOption(str)
1.5       takayama  419:      char *str;
1.1       maekawa   420: {
                    421:   fprintf(stderr,"Warning(option.c): %s\n",str);
                    422: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>