Annotation of OpenXM/src/k097/dic.c, Revision 1.1
1.1 ! maekawa 1: #include <stdio.h>
! 2: #include "d.h"
! 3:
! 4:
! 5: static int K00debug0 = 0; /* If it is set to 1, context will be printed. */
! 6:
! 7: static int K00Initialized = 0;
! 8:
! 9: struct context *K00CurrentContextp = NULL;
! 10: struct context *K00PrimitiveContextp = NULL;
! 11: /* It is initialize at K00InitDic() */
! 12:
! 13: objectp K00NullObject = NULL;
! 14: int K00Strict2 = 1;
! 15:
! 16:
! 17: static void myerror(char *s) {
! 18: fprintf(stderr,"Error in dic.c : ");
! 19: fprintf(stderr,s);
! 20: }
! 21:
! 22: int K00putUserDictionary(str,h0,h1,ob,cp)
! 23: char *str; /* key */
! 24: int h0,h1; /* Hash values of the key */
! 25: objectp ob; /* value */
! 26: struct context *cp;
! 27: {
! 28: int x,r;
! 29: extern int K00Strict2;
! 30: struct dictionary *dic;
! 31: dic = cp->userDictionary;
! 32: x = h0;
! 33: if (str[0] == '\0') {
! 34: K00errorDic("putUserDictionary(): You are defining a value with the null key.\n");
! 35: }
! 36: while (1) {
! 37: if ((dic[x]).key == EMPTY) break;
! 38: if (strcmp((dic[x]).key,str) == 0) break;
! 39: x = (x+h1) % USER_DICTIONARY_SIZE;
! 40: if (x == h0) {
! 41: K00errorDic("User dictionary is full. loop hashing.\n");
! 42: }
! 43: }
! 44: r = x;
! 45: if (K00Strict2) {
! 46: switch((dic[x]).attr) {
! 47: case PROTECT:
! 48: r = -PROTECT; /* Protected, but we rewrite it. */
! 49: break;
! 50: case ABSOLUTE_PROTECT:
! 51: r = -ABSOLUTE_PROTECT; /* Protected and we do not rewrite it. */
! 52: return(r);
! 53: default:
! 54: (dic[x]).attr = 0;
! 55: break;
! 56: }
! 57: }
! 58: (dic[x]).key = str;
! 59: (dic[x]).obj = ob;
! 60: (dic[x]).h0 = h0;
! 61: (dic[x]).h1 = h1;
! 62: return(r);
! 63: }
! 64:
! 65: objectp K00findUserDictionary(str,h0,h1,cp)
! 66: /* returns K00NullObject, if there is no item. */
! 67: char *str; /* key */
! 68: int h0,h1; /* The hashing values of the key. */
! 69: struct context *cp;
! 70: {
! 71: int x;
! 72: struct dictionary *dic;
! 73: dic = cp->userDictionary;
! 74: x = h0;
! 75: while (1) {
! 76: if ((dic[x]).key == EMPTY) { break; }
! 77: if (strcmp((dic[x]).key,str) == 0) {
! 78: return( (dic[x]).obj );
! 79: }
! 80: x = (x+h1) % USER_DICTIONARY_SIZE;
! 81: if (x == h0) {
! 82: K00errorDic("User dictionary is full. loop hashing in findUserDictionary.\n");
! 83: }
! 84: }
! 85: if (cp->super == (struct context *)NULL) return(K00NullObject);
! 86: else return(K00findUserDictionary(str,h0,h1,cp->super));
! 87:
! 88: }
! 89:
! 90: objectp K00findUserDictionary0(str,h0,h1,cp)
! 91: /* returns K00NullObject, if there is no item. */
! 92: /* This function does not look up the super class. */
! 93: char *str; /* key */
! 94: int h0,h1; /* The hashing values of the key. */
! 95: struct context *cp;
! 96: {
! 97: int x;
! 98: struct dictionary *dic;
! 99: dic = cp->userDictionary;
! 100: x = h0;
! 101: while (1) {
! 102: if ((dic[x]).key == EMPTY) { break; }
! 103: if (strcmp((dic[x]).key,str) == 0) {
! 104: return( (dic[x]).obj );
! 105: }
! 106: x = (x+h1) % USER_DICTIONARY_SIZE;
! 107: if (x == h0) {
! 108: K00errorDic("User dictionary is full. loop hashing in findUserDictionary.\n");
! 109: }
! 110: }
! 111: return(K00NullObject);
! 112:
! 113: }
! 114:
! 115: int K00putUserDictionary2(str,h0,h1,attr,cp)
! 116: char *str; /* key */
! 117: int h0,h1; /* Hash values of the key */
! 118: int attr; /* attribute field */
! 119: struct context *cp;
! 120: {
! 121: int x;
! 122: int i;
! 123: struct dictionary *dic;
! 124: dic = cp->userDictionary;
! 125: if (SET_ATTR_FOR_ALL_WORDS & attr) {
! 126: for (i=0; i<USER_DICTIONARY_SIZE; i++) {
! 127: if ((dic[i]).key !=EMPTY) (dic[i]).attr = attr&(~SET_ATTR_FOR_ALL_WORDS);
! 128: }
! 129: return(0);
! 130: }
! 131: x = h0;
! 132: if (str[0] == '\0') {
! 133: K00errorDic("K00putUserDictionary2(): You are defining a value with the null key.\n");
! 134: }
! 135: while (1) {
! 136: if ((dic[x]).key == EMPTY) return(-1);
! 137: if (strcmp((dic[x]).key,str) == 0) break;
! 138: x = (x+h1) % USER_DICTIONARY_SIZE;
! 139: if (x == h0) {
! 140: K00errorDic("User dictionary is full. loop hashing.\n");
! 141: }
! 142: }
! 143: (dic[x]).attr = attr;
! 144: return(x);
! 145: }
! 146:
! 147:
! 148:
! 149:
! 150: int K00hash0(str)
! 151: char *str;
! 152: {
! 153: int h=0;
! 154: while (*str != '\0') {
! 155: h = ((h*128)+(*str)) % USER_DICTIONARY_SIZE;
! 156: str++;
! 157: }
! 158: return(h);
! 159: }
! 160:
! 161: int K00hash1(str)
! 162: char *str;
! 163: {
! 164: return(8-(str[0]%8));
! 165: }
! 166:
! 167: void K00hashInitialize(struct dictionary *dic)
! 168: {
! 169: int i;
! 170: for (i=0; i<USER_DICTIONARY_SIZE; i++) {
! 171: (dic[i]).key = EMPTY; (dic[i]).attr = 0;
! 172: }
! 173: }
! 174:
! 175: /* functions to handle contexts. */
! 176: void K00fprintContext(FILE *fp,struct context *cp) {
! 177: if (cp == (struct context *)NULL) {
! 178: fprintf(fp," Context=NIL \n");
! 179: return;
! 180: }
! 181: fprintf(fp," ContextName = %s, ",cp->contextName);
! 182: fprintf(fp,"Super = ");
! 183: if (cp->super == (struct context *)NULL) fprintf(fp,"NIL");
! 184: else {
! 185: fprintf(fp,"%s",cp->super->contextName);
! 186: }
! 187: fprintf(fp,"\n");
! 188: }
! 189:
! 190: void K00fprintContextAndDictionary(FILE *fp,struct context *cp) {
! 191: int i,j;
! 192: int maxl;
! 193: char format[1000];
! 194: int nl;
! 195: struct dictionary *dic;
! 196:
! 197: if (cp == (struct context *)NULL) {
! 198: fprintf(fp," Context=NIL \n");
! 199: return;
! 200: }
! 201: fprintf(fp," ContextName = %s, ",cp->contextName);
! 202: fprintf(fp,"Super = ");
! 203: if (cp->super == (struct context *)NULL) fprintf(fp,"NIL");
! 204: else {
! 205: fprintf(fp,"%s",cp->super->contextName);
! 206: }
! 207: fprintf(fp,"\n");
! 208:
! 209: dic = cp->userDictionary;
! 210: maxl = 1;
! 211: for (i=0; i<USER_DICTIONARY_SIZE; i++) {
! 212: if ((dic[i]).key != EMPTY) {
! 213: if (strlen((dic[i]).key) >maxl)
! 214: maxl = strlen((dic[i]).key);
! 215: }
! 216: }
! 217: maxl += 3;
! 218: nl = 80/maxl;
! 219: if (nl < 2) nl = 2;
! 220: sprintf(format,"%%-%ds",maxl);
! 221: for (i=0,j=0; i<USER_DICTIONARY_SIZE; i++) {
! 222: if ((dic[i]).key != EMPTY) {
! 223: fprintf(fp,format,(dic[i]).key);
! 224: /*{ char *sss; int ii,h0,h1;
! 225: sss = dic[i].key;
! 226: h0 = dic[i].h0;
! 227: h1 = dic[i].h1;
! 228: for (ii=0; ii<strlen(sss); ii++) fprintf(fp,"%x ",sss[ii]);
! 229: fprintf(fp,": h0=%d, h1=%d, %d\n",h0,h1,i);
! 230: }*/
! 231: if (j % nl == nl-1) fprintf(fp,"\n");
! 232: j++;
! 233: }
! 234: }
! 235: fprintf(fp,"\n");
! 236: for (i=0; i<USER_DICTIONARY_SIZE; i++) {
! 237: if ((dic[i]).key != EMPTY) {
! 238: fprintf(fp,"%s ",(dic[i]).key);
! 239: printObject_d(fp,(dic[i]).obj);
! 240: fprintf(fp," \n");
! 241: }
! 242: }
! 243: fprintf(fp,"\n");
! 244: }
! 245:
! 246: struct context *K00newContext0(struct context *super,char *name) {
! 247: struct context *cp;
! 248: cp = mymalloc(sizeof(struct context));
! 249: if (cp == (struct context *)NULL) K00errorDic("No memory (newContext0)");
! 250: cp->userDictionary=mymalloc(sizeof(struct dictionary)*USER_DICTIONARY_SIZE);
! 251: if (cp->userDictionary==(struct dictionary *)NULL)
! 252: K00errorDic("No memory (newContext0)");
! 253: K00hashInitialize(cp->userDictionary);
! 254: cp->contextName = name;
! 255: cp->super = super;
! 256: return(cp);
! 257: }
! 258:
! 259: void K00contextControl(actionOfContextControl ctl) {
! 260: static struct context *cstack[CSTACK_SIZE];
! 261: static int cstackp = 0;
! 262: switch(ctl) {
! 263: case CCRESTORE:
! 264: if (cstackp == 0) return;
! 265: else {
! 266: K00CurrentContextp = cstack[0];
! 267: cstackp = 0;
! 268: }
! 269: break;
! 270: case CCPUSH:
! 271: if (cstackp < CSTACK_SIZE) {
! 272: cstack[cstackp] = K00CurrentContextp;
! 273: cstackp++;
! 274: }else{
! 275: K00contextControl(CCRESTORE);
! 276: K00errorDic("Context stack (cstack) is overflow. CurrentContext is restored.\n");
! 277: }
! 278: break;
! 279: case CCPOP:
! 280: if (cstackp > 0) {
! 281: cstackp--;
! 282: K00CurrentContextp = cstack[cstackp];
! 283: }
! 284: break;
! 285: default:
! 286: break;
! 287: }
! 288: return;
! 289: }
! 290:
! 291: void K00InitDic() {
! 292: extern struct context *K00CurrentContextp;
! 293: extern struct context *K00PrimitiveContextp;
! 294: char *start = "K00start";
! 295: char *size = "K00sizeof";
! 296: char *primitiveObject = "PrimitiveObject";
! 297: K00CurrentContextp = K00newContext0((struct context *)NULL,primitiveObject);
! 298: K00PrimitiveContextp = K00CurrentContextp;
! 299: K00putUserDictionary(start,K00hash0(start),K00hash1(start),
! 300: K00integerToObject(1),
! 301: K00CurrentContextp);
! 302: K00putUserDictionary2(start,K00hash0(start),K00hash1(start),
! 303: ABSOLUTE_PROTECT,
! 304: K00CurrentContextp);
! 305: K00putUserDictionary(size,K00hash0(size),K00hash1(size),
! 306: K00integerToObject(0),
! 307: K00CurrentContextp);
! 308: K00putUserDictionary2(size,K00hash0(size),K00hash1(size),
! 309: ABSOLUTE_PROTECT,
! 310: K00CurrentContextp);
! 311: K00putUserDictionary(primitiveObject,K00hash0(primitiveObject),
! 312: K00hash1("primitiveObject"),
! 313: K00contextToObject(K00CurrentContextp),
! 314: K00CurrentContextp);
! 315: K00putUserDictionary2(primitiveObject,K00hash0(primitiveObject),
! 316: K00hash1("primitiveObject"),
! 317: ABSOLUTE_PROTECT,
! 318: K00CurrentContextp);
! 319:
! 320: }
! 321:
! 322:
! 323: void K00errorDic(char *s) {
! 324: fprintf(stderr,"Error in dic.c: %s",s);
! 325: exit(10);
! 326: }
! 327:
! 328: int K00objectToInteger(objectp op) {
! 329: return(op->lc.ival);
! 330: }
! 331:
! 332: objectp K00integerToObject(int k) {
! 333: objectp op;
! 334: op = newObject_d();
! 335: op->tag = Sinteger;
! 336: op->lc.ival = k;
! 337: return(op);
! 338: }
! 339:
! 340: objectp K00contextToObject(struct context *cp) {
! 341: objectp op;
! 342: op = newObject_d();
! 343: op->tag = op->lc.ival = CLASSNAME_CONTEXT;
! 344: op->rc.voidp = cp;
! 345: return(op);
! 346: }
! 347:
! 348: struct context *K00objectToContext(objectp op) {
! 349: return((struct context *)(op->rc.voidp));
! 350: }
! 351:
! 352: int K00putIncetanceVariable(actionOfPutIncetanceVariable action,char *s) {
! 353: /* typedef enum {IRESET,IPUT,IEXIT} actionOfPutIncetanceVariable; */
! 354: extern struct context *K00CurrentContextp;
! 355: static int K00start;
! 356: static int serial;
! 357: static int initialized = 0;
! 358: objectp op1;
! 359: objectp op2;
! 360: if (K00CurrentContextp == K00PrimitiveContextp) {
! 361: myerror("You cannot define incetanceVariables in PrimitiveContext.\n");
! 362: return(-1);
! 363: }
! 364: if (action == IRESET) {
! 365: serial = 0;
! 366: op1 = K00findUserDictionary0("K00start",K00hash0("K00start"),
! 367: K00hash1("K00start"),
! 368: K00CurrentContextp->super);
! 369: if (op1 == K00NullObject) {
! 370: myerror("K00start is not found.\n");
! 371: return(-1);
! 372: }
! 373: op2 = K00findUserDictionary0("K00sizeof",K00hash0("K00sizeof"),
! 374: K00hash1("K00sizeof"),
! 375: K00CurrentContextp->super);
! 376: if (op2 == K00NullObject) {
! 377: myerror("K00sizeof is not found.\n");
! 378: return(-1);
! 379: }
! 380: K00start = K00objectToInteger(op1)+K00objectToInteger(op2);
! 381: initialized = 1;
! 382: return(0);
! 383: }else if (action == IEXIT) {
! 384: if (initialized) {
! 385: K00putUserDictionary("K00start",K00hash0("K00start"), K00hash1("K00start"),
! 386: K00integerToObject(K00start),
! 387: K00CurrentContextp);
! 388: K00putUserDictionary("K00sizeof",K00hash0("K00sizeof"), K00hash1("K00sizeof"),
! 389: K00integerToObject(serial),
! 390: K00CurrentContextp);
! 391: }
! 392: initialized = 0;
! 393: return(0);
! 394:
! 395: }else if (action == IPUT) {
! 396: if (initialized) {
! 397: K00putUserDictionary(s,K00hash0(s),K00hash1(s),
! 398: K00integerToObject(K00start+serial),
! 399: K00CurrentContextp);
! 400: serial++;
! 401: }else{
! 402: myerror("K00putIncetanceVariable() is not initialized.\n");
! 403: }
! 404: return(0);
! 405: }
! 406: return(-1);
! 407: }
! 408:
! 409: int K00getIncetanceVariable(char *s) {
! 410: objectp op;
! 411: extern struct context *K00CurrentContextp;
! 412: extern int K00Initialized;
! 413: if (!K00Initialized) {K00InitDic(); K00Initialized = 1;}
! 414: op = K00findUserDictionary0(s,K00hash0(s),K00hash1(s),K00CurrentContextp);
! 415: if (op == K00NullObject) {
! 416: return(-1);
! 417: }else if (op->tag != Sinteger) {
! 418: return(-1);
! 419: }else{
! 420: return( K00objectToInteger(op) );
! 421: }
! 422: }
! 423:
! 424: void K00recoverFromError() {
! 425: K00toPrimitiveClass();
! 426: }
! 427:
! 428: int K00declareClass(char *name,char *supername) {
! 429: extern struct context *K00CurrentContextp;
! 430: extern struct context *K00PrimitiveContextp;
! 431: struct context *sup;
! 432: objectp op1;
! 433: extern int K00Initialized;
! 434: if (!K00Initialized) { K00InitDic(); K00Initialized = 1;}
! 435: op1 = K00findUserDictionary0(supername,K00hash0(supername),K00hash1(supername),
! 436: K00PrimitiveContextp);
! 437: if (op1 == K00NullObject) {
! 438: myerror("Super class is not in the top dictionary.\n");
! 439: /* debug */ K00fooPrimitive();
! 440: return(-1);
! 441: }
! 442: if (op1->tag != CLASSNAME_CONTEXT) {
! 443: myerror("It is not class.context.\n");
! 444: /* debug */ K00fooPrimitive();
! 445: return(-1);
! 446: }
! 447: K00CurrentContextp = K00newContext0(K00objectToContext(op1),name);
! 448: K00putUserDictionary(name,K00hash0(name),K00hash1(name),
! 449: K00contextToObject(K00CurrentContextp),
! 450: K00PrimitiveContextp);
! 451: K00putIncetanceVariable(IRESET," ");
! 452: return(0);
! 453: }
! 454:
! 455: void K00toPrimitiveClass() {
! 456: extern struct context *K00CurrentContextp;
! 457: extern struct context *K00PrimitiveContextp;
! 458: K00CurrentContextp = K00PrimitiveContextp;
! 459: }
! 460:
! 461: char *K00getCurrentContextName() {
! 462: extern struct context *K00CurrentContextp;
! 463: if (!K00Initialized) {
! 464: K00InitDic(); K00Initialized = 1;
! 465: }
! 466: return(K00CurrentContextp->contextName);
! 467: }
! 468:
! 469: void pkkanInteger(int k) {
! 470: char tmp[256]; /* pkkan creates a new memory area. */
! 471: sprintf(tmp," %d ",k);
! 472: pkkan(tmp);
! 473: }
! 474:
! 475:
! 476: K00foo1() {
! 477: extern struct context *K00CurrentContextp;
! 478: extern int K00debug0;
! 479: if (K00debug0) K00fprintContextAndDictionary(stderr,K00CurrentContextp);
! 480: }
! 481:
! 482: K00fooPrimitive() {
! 483: extern struct context *K00PrimitiveContextp;
! 484: extern int K00debug0;
! 485: if (K00debug0) {
! 486: printf("--------- PrimitiveContext ------------\n");
! 487: K00fprintContextAndDictionary(stderr,K00PrimitiveContextp);
! 488: }
! 489: }
! 490:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dic.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / k097