![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pepy_do.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepy|
Return to pepy_do.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepy |
1.1 ! root 1: /* pepy_do.c - PE parser (yacc-based) building routines */ ! 2: ! 3: #ifndef lint ! 4: static char *rcsid = "$Header: /f/osi/pepy/RCS/pepy_do.c,v 7.0 89/11/23 22:11:49 mrose Rel $"; ! 5: #endif ! 6: ! 7: /* ! 8: * $Header: /f/osi/pepy/RCS/pepy_do.c,v 7.0 89/11/23 22:11:49 mrose Rel $ ! 9: * ! 10: * ! 11: * $Log: pepy_do.c,v $ ! 12: * Revision 7.0 89/11/23 22:11:49 mrose ! 13: * Release 6.0 ! 14: * ! 15: */ ! 16: ! 17: /* ! 18: * NOTICE ! 19: * ! 20: * Acquisition, use, and distribution of this module and related ! 21: * materials are subject to the restrictions of a license agreement. ! 22: * Consult the Preface in the User's Manual for the full terms of ! 23: * this agreement. ! 24: * ! 25: */ ! 26: ! 27: #include "pepy.h" ! 28: #include <ctype.h> ! 29: #include <stdio.h> ! 30: ! 31: extern struct tuple tuples[]; ! 32: extern int rflag; ! 33: ! 34: char *gensym (), *modsym (); ! 35: ! 36: YP lookup_type (), lookup_binding (); ! 37: YT lookup_tag (); ! 38: char *add_point (); ! 39: ! 40: /* */ ! 41: ! 42: do_type (yp, level, id, arg) ! 43: register YP yp; ! 44: register int level; ! 45: register char *id, ! 46: *arg; ! 47: { ! 48: register int i; ! 49: register char *narg; ! 50: char *narg2, ! 51: *narg3; ! 52: register struct tuple *t; ! 53: register YP y; ! 54: register YV yv; ! 55: char *class, *value, *form; ! 56: char tbuf1[32], tbuf2[32]; ! 57: int pushdown = 0; ! 58: ! 59: if (yp -> yp_flags & YP_COMPONENTS) { ! 60: warning ("I shouldn't be here!"); ! 61: return; ! 62: } ! 63: ! 64: if (level == 1) { ! 65: printf ("(pe, explicit, len, buffer, parm)\n"); ! 66: printf ("%sPE *pe;\nint\texplicit;\n", ! 67: yp -> yp_code != YP_ANY ! 68: && yp -> yp_code != YP_NULL ! 69: && (yp -> yp_code != YP_CHOICE ! 70: || (yp -> yp_flags & YP_CONTROLLED)) ! 71: ? "register " : ""); ! 72: printf ("integer\tlen;\nchar *buffer;\n%s parm;\n{\n", ! 73: yp -> yp_param_type ? yp -> yp_param_type : "PEPYPARM"); ! 74: ! 75: if (yp -> yp_action0) { ! 76: if (!Pflag && *sysin) ! 77: printf ("# line %d \"%s\"\n", yp -> yp_act0_lineno, sysin); ! 78: printf ("%*s%s\n", level * 4, "", yp -> yp_action0); ! 79: } ! 80: } ! 81: ! 82: pushdown = (yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == YP_TAG; ! 83: ! 84: for (t = tuples; t -> t_type != YP_UNDF; t++) ! 85: if (t -> t_type == yp -> yp_code) { ! 86: class = t -> t_class; ! 87: value = t -> t_id; ! 88: if((form = t -> t_form) == NULL) ! 89: form = "PE_FORM_PRIM"; ! 90: break; ! 91: } ! 92: if ((yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == (YP_TAG | YP_IMPLICIT)) { ! 93: (void) sprintf (tbuf2, "PE_CLASS_%s", ! 94: pe_classlist[yp -> yp_tag -> yt_class]); ! 95: class = tbuf2; ! 96: (void) sprintf (tbuf1, "%d",val2int (yp -> yp_tag -> yt_value)); ! 97: value = tbuf1; ! 98: } ! 99: ! 100: switch (yp -> yp_code) { ! 101: case YP_BOOL: ! 102: printf ("%*sregister int %s = %s;\n\n", level * 4, "", ! 103: narg = gensym (), yp -> yp_intexp ? yp -> yp_intexp ! 104: : level == 1 ? "len" : "0"); ! 105: break; ! 106: case YP_INT: ! 107: case YP_INTLIST: ! 108: case YP_ENUMLIST: ! 109: printf ("%*sregister integer %s = %s;\n\n", level * 4, "", ! 110: narg = gensym (), yp -> yp_intexp ? yp -> yp_intexp ! 111: : level == 1 ? "len" : "0"); ! 112: break; ! 113: ! 114: case YP_REAL: ! 115: printf ("%*sregister double %s = 0.0;\n\n", level * 4, "", ! 116: narg = gensym ()); ! 117: if (yp -> yp_strexp) ! 118: printf ("%*s%s = %s;\n", level * 4, "", narg, ! 119: yp -> yp_strexp); ! 120: break; ! 121: ! 122: case YP_BIT: ! 123: case YP_BITLIST: ! 124: printf ("%*sPE\t%s_z = NULLPE;\n", level * 4, "", ! 125: narg = gensym ()); ! 126: printf ("%*sregister PE *%s = &%s_z;\n\n", level * 4, "", ! 127: narg, narg); ! 128: narg = add_point (narg); ! 129: printf ("%*schar *%s;\n%*sint %s;\n", level * 4, "", ! 130: narg2 = gensym (), level * 4, "", narg3 = gensym ()); ! 131: ! 132: if (yp -> yp_strexp) ! 133: printf ("%*s%s = %s;\n%*s%s = %s;\n", level * 4, "", ! 134: narg2, yp -> yp_strexp, level * 4, "", narg3, ! 135: yp -> yp_intexp); ! 136: else ! 137: if (level == 1) ! 138: printf ("%*s%s = buffer;\n%*s%s = len;\n", level * 4, "", ! 139: narg2, level * 4, "", narg3); ! 140: else ! 141: printf ("%*s%s = NULLCP;\n%*s%s = 0;\n", level * 4, "", ! 142: narg2, level * 4, "", narg3); ! 143: printf ("%*s%s = %s ? strb2bitstr (%s, %s, %s, %s) : NULLPE;\n", ! 144: level * 4, "", narg, narg2, narg2, narg3, class, value); ! 145: break; ! 146: ! 147: case YP_OCT: ! 148: narg = gensym (); ! 149: if (yp -> yp_prfexp != 'q') { ! 150: printf ("%*sregister char *%s;\n%*sint %s_len;\n\n", ! 151: level * 4, "", narg, level * 4, "", narg); ! 152: if (yp -> yp_strexp) { ! 153: printf ("%*s%s = %s;\n", level * 4, "", ! 154: narg, yp -> yp_strexp); ! 155: if (yp -> yp_intexp) ! 156: printf ("%*s%s_len = %s;\n", level * 4, "", ! 157: narg, yp -> yp_intexp); ! 158: else ! 159: printf ("%*s%s_len = strlen (%s);\n", level * 4, "", ! 160: narg, narg); ! 161: } ! 162: else ! 163: if (level == 1) { ! 164: printf ("%*s%s = buffer;\n", level * 4, "", narg); ! 165: printf ("%*sif ((%s_len = len) == 0)\n", level * 4, "", ! 166: narg); ! 167: printf ("%*s%s_len = strlen (%s);\n", ! 168: (level + 1) * 4, "", narg, narg); ! 169: } ! 170: else ! 171: printf ("%*s%s = NULLCP;\n%*s%s_len = 0;\n", ! 172: level * 4, "", narg, level * 4, "", narg); ! 173: } ! 174: else { ! 175: printf ("%*sregister struct qbuf *%s;\n\n", ! 176: level * 4, "", narg); ! 177: printf ("%*s%s = %s;\n", level * 4, "", narg, yp -> yp_strexp); ! 178: } ! 179: break; ! 180: ! 181: case YP_SEQ: ! 182: case YP_SET: ! 183: case YP_ANY: ! 184: if (yp -> yp_strexp) { ! 185: printf ("%*sPE\t%s = %s;\n\n", level * 4, "", ! 186: narg = gensym (), yp -> yp_strexp); ! 187: break; ! 188: } ! 189: /* else fall */ ! 190: case YP_NULL: ! 191: case YP_IDEFINED: ! 192: narg = NULL; ! 193: break; ! 194: ! 195: case YP_CHOICE: ! 196: if (yp -> yp_type && yp -> yp_control) ! 197: printf ("%*sint\t%s;\n\n", level * 4, "", narg2 = gensym ()); ! 198: narg = NULL; ! 199: break; ! 200: ! 201: case YP_OID: ! 202: printf ("%*sregister OID %s;\n\n", level * 4, "", ! 203: narg = gensym ()); ! 204: if (yp -> yp_strexp) ! 205: printf ("%*s%s = %s;\n", level * 4, "", narg, yp -> yp_strexp); ! 206: else if (level == 1) ! 207: printf ("%*s%s = buffer ? str2oid (buffer) : NULLOID;\n", ! 208: level * 4, "", narg); ! 209: else ! 210: printf ("%*s%s = NULLOID;\n", level * 4, "", narg); ! 211: break; ! 212: ! 213: case YP_SEQTYPE: ! 214: case YP_SETTYPE: ! 215: printf ("%*sPE\t%s = NULLPE;\n", level * 4, "", ! 216: narg2 = gensym ()); ! 217: /* and fall ... */ ! 218: case YP_SEQLIST: ! 219: case YP_SETLIST: ! 220: printf ("%*sPE\t%s_z = NULLPE;\n", level * 4, "", ! 221: narg = gensym ()); ! 222: printf ("%*sregister PE *%s = &%s_z;\n\n", level * 4, "", ! 223: narg, narg); ! 224: narg = add_point(narg); ! 225: break; ! 226: ! 227: default: ! 228: myyerror ("unknown type: %d", yp -> yp_code); ! 229: } ! 230: ! 231: switch (yp -> yp_code) { ! 232: case YP_SEQ: ! 233: case YP_SET: ! 234: if (yp -> yp_strexp) ! 235: break; ! 236: /* else fall */ ! 237: case YP_SEQTYPE: ! 238: case YP_SETTYPE: ! 239: case YP_SEQLIST: ! 240: case YP_SETLIST: ! 241: case YP_NULL: ! 242: printf ("%*sif ((%s = pe_alloc (%s, %s, %s)) == NULLPE) {\n", ! 243: level * 4, "", arg, class, form, value); ! 244: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n", ! 245: (level + 1) * 4, "", id); ! 246: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 247: level * 4, ""); ! 248: break; ! 249: } ! 250: ! 251: if (!dflag && yp -> yp_action05) ! 252: do_action (yp -> yp_action05, level, narg ? narg : arg, ! 253: yp -> yp_act05_lineno); ! 254: if (!dflag && yp -> yp_action1) ! 255: do_action (yp -> yp_action1, level, narg ? narg : arg, ! 256: yp -> yp_act1_lineno); ! 257: ! 258: switch (yp -> yp_code) { ! 259: case YP_BOOL: ! 260: printf ("%*sif ((%s = flag2prim (%s, %s, ", ! 261: level * 4, "", arg, narg, class); ! 262: printf ("%s)) == NULLPE) {\n", value); ! 263: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n", ! 264: (level + 1) * 4, "", id); ! 265: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 266: level * 4, ""); ! 267: break; ! 268: ! 269: case YP_INT: ! 270: case YP_INTLIST: ! 271: case YP_ENUMLIST: ! 272: printf ("%*sif ((%s = %snum2prim (%s, %s, ", ! 273: level * 4, "", arg, ! 274: yp->yp_code == YP_ENUMLIST ? "e" : "", ! 275: narg, class); ! 276: printf ("%s)) == NULLPE) {\n", value); ! 277: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n", ! 278: (level + 1) * 4, "", id); ! 279: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 280: level * 4, ""); ! 281: if (yp -> yp_code == YP_INT) ! 282: break; ! 283: uniqint (yp -> yp_value); ! 284: printf ("%*sswitch (%s) {\n", level * 4, "", narg); ! 285: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) { ! 286: printf ("%*scase %d:", (level + 1) * 4, "", val2int (yv)); ! 287: if (yv -> yv_flags & YV_NAMED) ! 288: printf ("\t/* %s */", yv -> yv_named); ! 289: printf ("\n"); ! 290: if (!dflag && yv -> yv_action) ! 291: do_action (yv -> yv_action, level + 2, narg, ! 292: yv -> yv_act_lineno); ! 293: printf ("%*sbreak;\n", (level + 2) * 4, ""); ! 294: } ! 295: if (!rflag && yp -> yp_code == YP_ENUMLIST) { ! 296: printf ("%*sdefault:\n", (level + 1) * 4, ""); ! 297: printf ("%*sadvise (NULLCP, \"%s %%s%%d\", PEPY_ERR_UNK_COMP, %s);\n", ! 298: (level + 2) * 4, "", id, narg); ! 299: printf ("%*sreturn NOTOK;\n", (level + 2) * 4, ""); ! 300: } ! 301: printf ("%*s}\n", level * 4, ""); ! 302: break; ! 303: ! 304: case YP_REAL: ! 305: printf ("%*sif ((%s = real2prim (%s, %s, ", ! 306: level * 4, "", arg, narg, class); ! 307: printf ("%s)) == NULLPE) {\n", value); ! 308: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n", ! 309: (level + 1) * 4, "", id); ! 310: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 311: level * 4, ""); ! 312: break; ! 313: ! 314: case YP_BIT: ! 315: case YP_BITLIST: ! 316: printf ("%*sif (%s == NULLPE) {\n", level * 4, "", narg); ! 317: printf ("%*sadvise (NULLCP, \"%s %%s\", PEPY_ERR_INIT_FAILED);\n", ! 318: (level + 1) * 4, "", id); ! 319: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 320: level * 4, ""); ! 321: if (!yp -> yp_strexp && level != 1) ! 322: printf ("%*s%s -> pe_class = %s;\n%*s%s -> pe_id = %s;\n", ! 323: level * 4, "", narg, class, level * 4, "", narg, value); ! 324: if (yp -> yp_code == YP_BITLIST) { ! 325: register int j; ! 326: ! 327: for (yv = yp -> yp_value, i = -1; yv; yv = yv -> yv_next) ! 328: if ((j = val2int (yv)) > i) ! 329: i = j; ! 330: if (i >= 0) ! 331: printf ("%*sif (bit_test (%s, %d) == NOTOK)\n%*s(void) bit_off (%s, %d);\n", ! 332: level * 4, "", narg, i, ! 333: (level + 1) * 4, "", narg, i); ! 334: } ! 335: printf ("%*sif ((%s = bit2prim (%s)) == NULLPE) {\n", ! 336: level * 4, "", arg, narg); ! 337: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n", ! 338: (level + 1) * 4, "", id); ! 339: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 340: level * 4, ""); ! 341: if (yp -> yp_code == YP_BIT) ! 342: break; ! 343: printf ("#define\tBITS\t\"\\020"); ! 344: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) ! 345: if (yv -> yv_flags & YV_NAMED) ! 346: printf ("\\0%o%s", val2int (yv) + 1, yv -> yv_named); ! 347: else ! 348: printf ("\\0%oBIT%d", val2int (yv) + 1, val2int (yv)); ! 349: printf ("\"\n"); ! 350: uniqint (yp -> yp_value); ! 351: if (!dflag) ! 352: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) { ! 353: if (!yv -> yv_action) ! 354: continue; ! 355: printf ("%*sif (bit_test (%s, %d) > OK) {", ! 356: level * 4, "", narg, val2int (yv)); ! 357: if (yv -> yv_flags & YV_NAMED) ! 358: printf ("\t/* %s */", yv -> yv_named); ! 359: printf ("\n"); ! 360: do_action (yv -> yv_action, level + 1, narg, ! 361: yv -> yv_act_lineno); ! 362: printf ("%*s}\n", level * 4, ""); ! 363: } ! 364: break; ! 365: ! 366: case YP_OCT: ! 367: printf ("%*sif (%s == %s) {\n", ! 368: level * 4, "", narg, ! 369: yp -> yp_prfexp != 'q' ? "NULLCP" : "((struct qbuf *) 0)"); ! 370: printf ("%*sadvise (NULLCP, \"%s %%s\", PEPY_ERR_INIT_FAILED);\n", ! 371: (level + 1) * 4, "", id); ! 372: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 373: level * 4, ""); ! 374: printf ("%*sif ((%s = ", level * 4, "", arg); ! 375: if (yp -> yp_prfexp != 'q') ! 376: printf ("str2prim (%s, %s_len,", narg, narg); ! 377: else ! 378: printf ("qb2prim (%s,", narg); ! 379: printf (" %s, %s)) == NULLPE) {\n", class, value); ! 380: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n", ! 381: (level + 1) * 4, "", id); ! 382: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 383: level * 4, ""); ! 384: break; ! 385: ! 386: case YP_NULL: ! 387: break; ! 388: ! 389: case YP_ANY: ! 390: case YP_SEQ: ! 391: case YP_SET: ! 392: if (!yp -> yp_strexp) ! 393: break; ! 394: printf ("%*sif (%s == NULLPE) {\n", level * 4, "", narg); ! 395: printf ("%*sadvise (NULLCP, \"%s %%s\", PEPY_ERR_INIT_FAILED);\n", ! 396: (level + 1) * 4, "", id); ! 397: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 398: level * 4, ""); ! 399: #ifdef notdef ! 400: printf ("%*sif ((%s = pe_cpy (%s)) == NULLPE) {\n", ! 401: level * 4, "", arg, narg); ! 402: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n", ! 403: (level + 1) * 4, "", id); ! 404: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 405: level * 4, ""); ! 406: #else ! 407: printf ("%*s(%s = %s) -> pe_refcnt++;\n", ! 408: level * 4, "", arg, narg); ! 409: #endif ! 410: break; ! 411: ! 412: case YP_OID: ! 413: printf ("%*sif (%s == NULLOID) {\n", level * 4, "", narg); ! 414: printf ("%*sadvise (NULLCP, \"%s %%s\", PEPY_ERR_INIT_FAILED);\n", ! 415: (level + 1) * 4, "", id); ! 416: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 417: level * 4, ""); ! 418: printf ("%*sif ((%s = obj2prim (%s, %s, %s)) == NULLPE) {\n", ! 419: level * 4, "", arg, narg, class, value); ! 420: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n", ! 421: (level + 1) * 4, "", id); ! 422: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 423: level * 4, ""); ! 424: break; ! 425: ! 426: case YP_SEQTYPE: ! 427: if (yp -> yp_type && yp -> yp_control) { ! 428: printf ("%*sfor (%s) {\n", ! 429: level * 4, "", yp -> yp_control); ! 430: if (!dflag && yp -> yp_action3) { ! 431: do_action (yp -> yp_action3, ++level, narg ? narg : arg, ! 432: yp -> yp_act3_lineno); ! 433: printf ("%*s{\n", level * 4, ""); ! 434: } ! 435: do_type (yp -> yp_type, level + 1, "element", narg); ! 436: if (!dflag && yp -> yp_action3) ! 437: printf ("%*s}\n", level-- * 4, ""); ! 438: #ifndef notdef ! 439: printf ("%*sseq_addon (%s, %s, %s);\n", (level + 1) * 4, "", ! 440: arg, narg2, narg); ! 441: printf ("%*s%s = %s;\n%*s}\n", (level + 1) * 4, "", ! 442: narg2, narg, level * 4, ""); ! 443: #else ! 444: printf ("%*sif (seq_add (%s, %s, -1) == NOTOK) {\n", ! 445: (level + 1) * 4, "", arg, narg); ! 446: printf ("%*sadvise (NULLCP, \"%s %%s: %%s\", PEPY_ERR_BAD_SEQ,\n", ! 447: (level + 2) * 4, "", id); ! 448: printf ("%*spe_error (%s -> pe_errno));\n", (level + 4) * 4, ! 449: "", arg); ! 450: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "", ! 451: (level + 1) * 4, ""); ! 452: printf ("%*s}\n", level * 4, ""); ! 453: #endif ! 454: } ! 455: break; ! 456: ! 457: case YP_SEQLIST: ! 458: for (y = yp -> yp_type, i = 0; y; y = y -> yp_next, i++) { ! 459: if (y -> yp_flags & YP_COMPONENTS) ! 460: do_components_seq (y, level, y -> yp_next == NULLYP, ! 461: id, arg, narg); ! 462: else { ! 463: do_type_element (y, level, y -> yp_next == NULLYP, ! 464: id, narg); ! 465: printf ("%*sif (%s != NULLPE)\n", level * 4, "", narg); ! 466: printf ("%*sif (seq_add (%s, %s, -1) == NOTOK) {\n", ! 467: (level + 1) * 4, "", arg, narg); ! 468: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SEQ,\n", ! 469: (level + 2) * 4, "", id); ! 470: printf ("%*spe_error (%s -> pe_errno));\n", (level + 4) * 4, ! 471: "", arg); ! 472: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "", ! 473: (level + 1) * 4, ""); ! 474: } ! 475: } ! 476: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 477: register YP z; ! 478: ! 479: if (!(y -> yp_flags & (YP_OPTIONAL | YP_DEFAULT)) ! 480: || lookup_tag (y) == NULLYT) ! 481: continue; ! 482: for (z = y -> yp_next; z; z = z -> yp_next) ! 483: if (!(z -> yp_flags & (YP_OPTIONAL | YP_DEFAULT)) ! 484: || lookup_tag (z) == NULLYT) ! 485: break; ! 486: uniqtag (y, z); ! 487: if (z == NULLYP) ! 488: break; ! 489: y = z; ! 490: } ! 491: break; ! 492: ! 493: case YP_SETTYPE: ! 494: if (yp -> yp_type && yp -> yp_control) { ! 495: printf ("%*sfor (%s) {\n", ! 496: level * 4, "", yp -> yp_control); ! 497: if (!dflag && yp -> yp_action3) { ! 498: do_action (yp -> yp_action3, ++level, narg ? narg : arg, ! 499: yp -> yp_act3_lineno); ! 500: printf ("%*s{\n", level * 4, ""); ! 501: } ! 502: do_type (yp -> yp_type, level + 1, "member", narg); ! 503: if (!dflag && yp -> yp_action3) ! 504: printf ("%*s}\n", level-- * 4, ""); ! 505: #ifndef notdef ! 506: printf ("%*sset_addon (%s, %s, %s);\n", (level + 1) * 4, "", ! 507: arg, narg2, narg); ! 508: printf ("%*s%s = %s;\n%*s}\n", (level + 1) * 4, "", ! 509: narg2, narg, level * 4, ""); ! 510: #else ! 511: printf ("%*sif (seq_add (%s, %s, -1) == NOTOK) {\n", ! 512: (level + 1) * 4, "", arg, narg); ! 513: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SET,\n", ! 514: (level + 2) * 4, "", id); ! 515: printf ("%*spe_error (%s -> pe_errno));\n", (level + 4) * 4, ! 516: "", arg); ! 517: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "", ! 518: (level + 1) * 4, ""); ! 519: printf ("%*s}\n", level * 4, ""); ! 520: #endif ! 521: } ! 522: break; ! 523: ! 524: case YP_SETLIST: ! 525: if (yp -> yp_type) { ! 526: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 527: if (y -> yp_flags & YP_COMPONENTS) ! 528: do_components_set (y, level, id, arg, narg); ! 529: else { ! 530: do_type_member (y, level, narg); ! 531: printf ("%*sif (%s != NULLPE)\n", level * 4, "", narg); ! 532: printf ("%*sif (set_add (%s, %s) == NOTOK) {\n", ! 533: (level + 1) * 4, "", arg, narg); ! 534: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SET,\n", ! 535: (level + 2) * 4, "", id); ! 536: printf ("%*spe_error (%s -> pe_errno));\n", ! 537: (level + 4) * 4, "", arg); ! 538: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "", ! 539: (level + 1) * 4, ""); ! 540: } ! 541: } ! 542: /* now pull up fully to check uniqueness */ ! 543: choice_pullup (y = copy_type (yp), CH_FULLY); ! 544: uniqtag (y -> yp_type, NULLYP); ! 545: } ! 546: break; ! 547: ! 548: case YP_CHOICE: ! 549: if (yp -> yp_type && yp -> yp_control) { ! 550: printf ("%*sswitch (%s = (%s)) {\n", ! 551: level * 4, "", narg2, yp -> yp_control); ! 552: for (y = yp -> yp_type, i = 0; y; y = y -> yp_next) ! 553: do_type_choice (y, ++i, level + 1, arg); ! 554: choice_pullup (yp, CH_FULLY); ! 555: uniqtag (yp -> yp_type, NULLYP); ! 556: printf ("\n%*sdefault:\n", (level + 1) * 4, ""); ! 557: printf ("%*sadvise (NULLCP, \"%s %%s%%d\", PEPY_ERR_INVALID_CHOICE, \n", ! 558: (level + 2) * 4, "", id); ! 559: printf ("%*s%s);\n", (level + 4) * 4, "", narg2); ! 560: printf ("%*sreturn NOTOK;\n", (level + 2) * 4, ""); ! 561: printf ("%*s}\n", level * 4, ""); ! 562: if ((yp -> yp_flags & YP_TAG) ! 563: && !(yp -> yp_flags & YP_PULLEDUP)) ! 564: tag_pushdown (yp, level, arg, "choice"); ! 565: } ! 566: break; ! 567: ! 568: case YP_IDEFINED: ! 569: printf ("%*sif (%s (", level * 4, "", modsym (yp -> yp_module, ! 570: yp -> yp_identifier, YP_ENCODER)); ! 571: i = strlen (arg) - 3; ! 572: printf ("%*.*s, 0, ", i, i, arg + 2); ! 573: if (yp -> yp_intexp) ! 574: printf ("%s, ", yp -> yp_intexp); ! 575: else if (level == 1) ! 576: printf ("len, "); ! 577: else ! 578: printf ("NULLINT, "); ! 579: if (yp -> yp_strexp) ! 580: printf ("%s", yp -> yp_strexp); ! 581: else if (level == 1) ! 582: printf ("buffer"); ! 583: else ! 584: printf ("NULLCP"); ! 585: if (yp -> yp_flags & YP_PARMVAL) ! 586: printf (", %s", yp -> yp_parm); ! 587: else ! 588: printf (", NullParm"); ! 589: printf (") == NOTOK)\n%*sreturn NOTOK;\n", (level + 1) * 4, ""); ! 590: if ((yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) ! 591: == (YP_TAG | YP_IMPLICIT)) { ! 592: if (is_nonimplicit_type (yp)) ! 593: pushdown = 1; ! 594: else { ! 595: printf ("%*s%s -> pe_class = %s;\n", level * 4, "", ! 596: arg, class); ! 597: printf ("%*s%s -> pe_id = %s;\n", level * 4, "", ! 598: arg, value); ! 599: } ! 600: } ! 601: break; ! 602: ! 603: default: ! 604: myyerror ("unknown type: %d", yp -> yp_code); ! 605: } ! 606: if (pushdown && !(yp -> yp_flags & YP_PULLEDUP)) { ! 607: switch (yp -> yp_code) { /* sets & seqs are implicit implicit's? */ ! 608: case YP_CHOICE: ! 609: break; ! 610: ! 611: default: ! 612: tag_pushdown (yp, level, arg, id); ! 613: break; ! 614: } ! 615: } ! 616: ! 617: printf ("\n#ifdef DEBUG\n%*s(void) testdebug (%s, \"", ! 618: level * 4, "", arg); ! 619: if (level == 1) ! 620: printf ("%s.", mymodule); ! 621: printf ("%s\");\n#endif\n\n", id); ! 622: ! 623: if (!dflag && yp -> yp_action2) ! 624: do_action (yp -> yp_action2, level, arg, yp -> yp_act2_lineno); ! 625: ! 626: switch (yp -> yp_code) { ! 627: case YP_BITLIST: ! 628: printf ("#undef\tBITS\n"); ! 629: break; ! 630: ! 631: default: ! 632: break; ! 633: } ! 634: } ! 635: ! 636: ! 637: static char *add_point (arg) ! 638: char *arg; ! 639: { ! 640: char buffer[BUFSIZ]; ! 641: ! 642: (void) sprintf (buffer, "(*%s)", arg); ! 643: return new_string (buffer); ! 644: } ! 645: ! 646: /* */ ! 647: ! 648: static do_type_member (yp, level, narg) ! 649: register YP yp; ! 650: register int level; ! 651: char *narg; ! 652: { ! 653: int pushdown = (yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == YP_TAG; ! 654: char *id = yp -> yp_flags & YP_ID ? yp -> yp_id : "member"; ! 655: ! 656: if (!(yp -> yp_flags & YP_TAG)) { ! 657: switch (yp -> yp_code) { ! 658: case YP_CHOICE: ! 659: break; ! 660: case YP_IDEFINED: ! 661: if (lookup_tag (yp) == NULLYT) ! 662: break; ! 663: /* else drop ... */ ! 664: default: ! 665: tag_type (yp); ! 666: break; ! 667: } ! 668: } ! 669: printf ("%*s%s = NULLPE;\n\n", level * 4, "", narg); ! 670: if (yp -> yp_flags & (YP_OPTIONAL | YP_DEFAULT)) { ! 671: if (yp -> yp_flags & YP_OPTCONTROL) ! 672: printf ("%*sif (%s) {\n", level * 4, "", yp -> yp_optcontrol); ! 673: else ! 674: return; ! 675: } ! 676: else ! 677: printf ("%*s{\n", level * 4, ""); ! 678: ! 679: level++; ! 680: yp -> yp_flags |= YP_PULLEDUP; ! 681: ! 682: do_type (yp, level, id, narg); ! 683: ! 684: if (pushdown) ! 685: tag_pushdown (yp, level, narg, id); ! 686: ! 687: level--; ! 688: printf ("%*s}\n", level * 4, ""); ! 689: } ! 690: ! 691: ! 692: /* */ ! 693: ! 694: static do_type_choice (yp, caseindex, level, narg) ! 695: register YP yp; ! 696: register int caseindex, ! 697: level; ! 698: register char *narg; ! 699: { ! 700: int pushdown = (yp -> yp_flags & YP_TAG) ! 701: && !(yp -> yp_flags & YP_IMPLICIT); ! 702: char *id = yp -> yp_flags & YP_ID ? yp -> yp_id : "member"; ! 703: ! 704: printf ("%*scase %d:", level * 4, "", caseindex); ! 705: if (yp -> yp_flags & YP_ID) ! 706: printf ("\t/* %s */", yp -> yp_id); ! 707: printf ("\n"); ! 708: level++; ! 709: ! 710: printf ("%*s{\n", level * 4, ""); ! 711: level++; ! 712: ! 713: yp -> yp_flags |= YP_PULLEDUP; ! 714: ! 715: do_type (yp, level, id, narg); ! 716: ! 717: if (pushdown) { ! 718: tag_pushdown (yp, level, narg, id); ! 719: } ! 720: ! 721: level--; ! 722: printf ("%*s}\n%*sbreak;\n", level * 4, "", level * 4, ""); ! 723: } ! 724: ! 725: /* */ ! 726: ! 727: do_action (action, level, arg, lineno) ! 728: register char *action, ! 729: *arg; ! 730: register int level; ! 731: int lineno; ! 732: { ! 733: register char c, ! 734: d; ! 735: ! 736: printf ("%*s{\n", level * 4, ""); ! 737: ! 738: if (!Pflag && *sysin) ! 739: printf ("# line %d \"%s\"\n", lineno, sysin); ! 740: ! 741: for (d = NULL; c = *action++; d = c) ! 742: switch (d) { ! 743: case '$': ! 744: if (c == '$') { ! 745: printf ("%s", arg); ! 746: c = NULL; ! 747: break; ! 748: } ! 749: putchar ('$'); /* fall */ ! 750: ! 751: default: ! 752: if (c != '$') ! 753: putchar (c); ! 754: break; ! 755: } ! 756: ! 757: switch (d) { ! 758: case '\n': ! 759: break; ! 760: ! 761: case '$': ! 762: putchar ('$'); /* fall */ ! 763: default: ! 764: putchar ('\n'); ! 765: break; ! 766: } ! 767: ! 768: printf ("%*s}\n", level * 4, ""); ! 769: } ! 770: ! 771: /* */ ! 772: ! 773: /* ARGSUSED */ ! 774: ! 775: static do_type_element (yp, level, last, id, narg) ! 776: register YP yp; ! 777: register int level; ! 778: int last; ! 779: char *id; ! 780: register char *narg; ! 781: { ! 782: printf ("%*s%s = NULLPE;\n\n", level * 4, "", narg); ! 783: if (yp -> yp_flags & (YP_OPTIONAL | YP_DEFAULT)) { ! 784: if (yp -> yp_flags & YP_OPTCONTROL) ! 785: printf ("%*sif (%s) {", level * 4, "", yp -> yp_optcontrol); ! 786: else ! 787: return; ! 788: } ! 789: else { ! 790: printf ("%*s{", level * 4, ""); ! 791: } ! 792: level++; ! 793: if (yp -> yp_flags & YP_ID) ! 794: printf ("\t/* %s */", yp -> yp_id); ! 795: printf ("\n"); ! 796: do_type (yp, level, yp -> yp_flags & YP_ID ? yp -> yp_id : "element", ! 797: narg); ! 798: ! 799: level--; ! 800: printf ("%*s}\n\n", level * 4, ""); ! 801: } ! 802: ! 803: static do_components_seq (yp, level, last, id, arg, narg) ! 804: YP yp; ! 805: register int level; ! 806: register char *id, ! 807: *arg, ! 808: *narg; ! 809: { ! 810: YP newyp, y; ! 811: ! 812: if (yp -> yp_module) { ! 813: pyyerror (yp, "Can't do COMPONENTS OF with external types for %s", ! 814: yp -> yp_identifier); ! 815: return; ! 816: } ! 817: ! 818: if (!(newyp = lookup_type (yp->yp_module, yp -> yp_identifier))) { ! 819: pyyerror (yp, "Can't find refernced COMPONENTS OF"); ! 820: return; ! 821: } ! 822: ! 823: if (newyp -> yp_code != YP_SEQLIST) { ! 824: yyerror_aux ("COMPONENTS OF type is not a SEQUENCE"); ! 825: print_type (yp, 0); ! 826: return; ! 827: } ! 828: for (y = newyp -> yp_type; y; y = y -> yp_next) { ! 829: if (y -> yp_flags & YP_COMPONENTS) ! 830: do_components_seq (y, level, last && y -> yp_next == NULLYP, ! 831: id, arg, narg); ! 832: else { ! 833: do_type_element (y, level, last && y -> yp_next == NULLYP, ! 834: id, narg); ! 835: printf ("%*sif (%s != NULLPE)\n", level * 4, "", narg); ! 836: printf ("%*sif (seq_add (%s, %s, -1) == NOTOK) {\n", ! 837: (level + 1) * 4, "", arg, narg); ! 838: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SEQ,\n", ! 839: (level + 2) * 4, "", id); ! 840: printf ("%*spe_error (%s -> pe_errno));\n", (level + 4) * 4, ! 841: "", arg); ! 842: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "", ! 843: (level + 1) * 4, ""); ! 844: } ! 845: } ! 846: for (y = newyp -> yp_type; y; y = y -> yp_next) { ! 847: register YP z; ! 848: ! 849: if (!(y -> yp_flags & (YP_OPTIONAL | YP_DEFAULT)) ! 850: || lookup_tag (y) == NULLYT) ! 851: continue; ! 852: for (z = y -> yp_next; z; z = z -> yp_next) ! 853: if (!(z -> yp_flags & (YP_OPTIONAL | YP_DEFAULT)) ! 854: || lookup_tag (z) == NULLYT) ! 855: break; ! 856: uniqtag (y, z); ! 857: if (z == NULLYP) ! 858: break; ! 859: y = z; ! 860: } ! 861: return; ! 862: } ! 863: ! 864: ! 865: ! 866: static do_components_set (yp, level, arg, id, narg) ! 867: register YP yp; ! 868: register int level; ! 869: char *narg, *arg, *id; ! 870: { ! 871: ! 872: YP newyp, y; ! 873: ! 874: if (yp -> yp_module) { ! 875: pyyerror (yp, "Can't do COMPONENTS OF with external types for %s", ! 876: yp -> yp_identifier); ! 877: return; ! 878: } ! 879: ! 880: if (!(newyp = lookup_type (yp->yp_module, yp -> yp_identifier))) { ! 881: pyyerror (yp, "Can't find refernced COMPONENTS OF"); ! 882: return; ! 883: } ! 884: ! 885: if (newyp -> yp_code != YP_SETLIST) { ! 886: yyerror_aux ("COMPONENTS OF type is not a SET"); ! 887: print_type (yp, 0); ! 888: return; ! 889: } ! 890: ! 891: for (y = newyp -> yp_type; y; y = y -> yp_next) { ! 892: if (y -> yp_flags & YP_COMPONENTS) ! 893: do_components_set (y, level, arg, id, narg); ! 894: else { ! 895: do_type_member (y, level, narg); ! 896: printf ("%*sif (%s != NULLPE)\n", level * 4, "", narg); ! 897: printf ("%*sif (set_add (%s, %s) == NOTOK) {\n", ! 898: (level + 1) * 4, "", arg, narg); ! 899: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SET,\n", ! 900: (level + 2) * 4, "", id); ! 901: printf ("%*spe_error (%s -> pe_errno));\n", ! 902: (level + 4) * 4, "", arg); ! 903: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "", ! 904: (level + 1) * 4, ""); ! 905: } ! 906: } ! 907: choice_pullup (newyp, CH_FULLY); ! 908: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.