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