[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.13

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

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