1: # include <ingres.h> 2: # include <aux.h> 3: # include <tree.h> 4: # include <symbol.h> 5: # include "parser.h" 6: # include <sccs.h> 7: # include <errors.h> 8: 9: SCCSID(@(#)format.c 8.2 2/8/85) 10: 11: /* 12: ** FORMAT 13: ** routine to compute the format of the result relation attributes 14: ** it is called after ATTLOOKUP so the tuple defining the current 15: ** attribute is already available. 16: ** if the element is a function of more than one attribute, the result 17: ** domain format is computed by the following rules: 18: ** - no fcns allowed on character attributes 19: ** - fcn of integer attribs is an integer fcn with 20: ** length = MAX(length of all attributes) 21: ** - fcn of floating point attribs is a floating point 22: ** fcn with length = MIN(length of all attribs) 23: ** - fcn of integer and floating attributes is a 24: ** floating fcn with length = MIN(length of all floating 25: ** attributes) 26: ** 27: ** Trace Flags: 28: ** Format ~~ 52.0, 52.1 29: */ 30: 31: format(result1) 32: QTREE *result1; 33: { 34: register char rfrmt; 35: register char rfrml; 36: register QTREE *result; 37: struct constop *cpt; 38: 39: extern struct out_arg Out_arg; 40: extern struct constop Coptab[]; 41: extern char Trfrml; 42: extern char Trfrmt; 43: extern int Qlflag; 44: 45: # ifdef xPTR2 46: tTfp(52, 0, "format:.\n"); 47: # endif 48: 49: result = result1; 50: switch (result->sym.type) 51: { 52: case VAR: 53: rfrmt = result->sym.value.sym_var.varfrmt; 54: rfrml = result->sym.value.sym_var.varfrml; 55: break; 56: 57: case AOP: 58: switch (result->sym.value.sym_op.opno) 59: { 60: case opAVG: 61: case opAVGU: 62: rfrmt = FLOAT; 63: rfrml = 8; 64: if (result->sym.value.sym_op.agfrmt == CHAR) 65: /* character domain not allowed in these aggs */ 66: par_error(AVGTYPE, WARN, 0); 67: break; 68: 69: case opCOUNT: 70: case opCOUNTU: 71: rfrmt = INT; 72: rfrml = 4; 73: break; 74: 75: case opANY: 76: rfrmt = INT; 77: rfrml = 2; 78: break; 79: 80: case opSUM: 81: case opSUMU: 82: rfrmt = result->sym.value.sym_op.agfrmt; 83: rfrml = result->sym.value.sym_op.agfrml; 84: if (rfrmt == CHAR) 85: /* no char domains for these aggs */ 86: par_error(SUMTYPE, WARN, 0); 87: break; 88: 89: default: 90: rfrmt = result->sym.value.sym_op.agfrmt; 91: rfrml = result->sym.value.sym_op.agfrml; 92: break; 93: } 94: break; 95: 96: case AGHEAD: 97: /* 98: ** can get format info from the AOP node because 99: ** it already has format info computed 100: */ 101: if (result->left->sym.type == AOP) 102: { 103: /* no by-list */ 104: rfrmt = result->left->sym.value.sym_op.opfrmt; 105: rfrml = result->left->sym.value.sym_op.opfrml; 106: } 107: else 108: { 109: /* skip over by-list */ 110: rfrmt = result->left->right->sym.value.sym_resdom.resfrmt; 111: rfrml = result->left->right->sym.value.sym_resdom.resfrml; 112: } 113: break; 114: 115: case RESDOM: 116: format(result->right); 117: return; 118: 119: case INT: 120: case FLOAT: 121: case CHAR: 122: rfrmt = result->sym.type; 123: rfrml = result->sym.len; 124: break; 125: 126: case COP: 127: for (cpt = Coptab; cpt->copname; cpt++) 128: { 129: if (result->sym.value.sym_op.opno == cpt->copnum) 130: { 131: rfrmt = cpt->coptype; 132: rfrml = cpt->coplen; 133: break; 134: } 135: } 136: if (!cpt->copname) 137: syserr("bad cop in format(%d)", result->sym.value.sym_op.opno); 138: break; 139: 140: case UOP: 141: switch (result->sym.value.sym_op.opno) 142: { 143: case opATAN: 144: case opCOS: 145: # ifdef xV6_UNIX 146: case opGAMMA: 147: # endif 148: case opLOG: 149: case opSIN: 150: case opSQRT: 151: case opEXP: 152: format(result->left); 153: if (Trfrmt == CHAR) 154: /* 155: ** no character expr in FOP 156: ** if more ops are added, must change error message */ 157: par_error(FOPTYPE, WARN, 0); 158: 159: case opFLOAT8: 160: /* float8 is type conversion and can have char values */ 161: rfrmt = FLOAT; 162: rfrml = 8; 163: break; 164: 165: case opFLOAT4: 166: rfrmt = FLOAT; 167: rfrml = 4; 168: break; 169: 170: case opINT1: 171: rfrmt = INT; 172: rfrml = 1; 173: break; 174: 175: case opINT2: 176: rfrmt = INT; 177: rfrml = 2; 178: break; 179: 180: case opINT4: 181: rfrmt = INT; 182: rfrml = 4; 183: break; 184: 185: case opASCII: 186: format(result->left); 187: rfrmt = CHAR; 188: rfrml = Trfrml; 189: if (Trfrmt == INT) 190: { 191: if (Trfrml == 2) 192: rfrml = Out_arg.i2width; 193: else if (Trfrml == 4) 194: rfrml = Out_arg.i4width; 195: else if (Trfrml == 1) 196: rfrml = Out_arg.i1width; 197: else 198: syserr("bad length %d for INT", Trfrml); 199: break; 200: } 201: if (Trfrmt == FLOAT) 202: { 203: if (Trfrml == 8) 204: rfrml = Out_arg.f8width; 205: else if (Trfrml == 4) 206: rfrml = Out_arg.f4width; 207: else 208: syserr("bad length %d for FLOAT", Trfrml); 209: break; 210: } 211: if (Trfrmt == CHAR) 212: break; 213: syserr("bad frmt in opASCII %d", Trfrmt); 214: 215: case opNOT: 216: if (!Qlflag) 217: syserr("opNOT in targ list"); 218: return; 219: 220: case opMINUS: 221: case opPLUS: 222: format(result->right); 223: if (Trfrmt == CHAR) 224: /* no chars for these unary ops */ 225: par_error(UOPTYPE, WARN, 0); 226: return; 227: 228: case opABS: 229: format(result->left); 230: if (Trfrmt == CHAR) 231: /* no char values in fcn */ 232: par_error(FOPTYPE, WARN, 0); 233: return; 234: 235: default: 236: syserr("bad UOP in format %d", result->sym.value.sym_op.opno); 237: } 238: break; 239: 240: case BOP: 241: switch (result->sym.value.sym_op.opno) 242: { 243: 244: case opEQ: 245: case opNE: 246: case opLT: 247: case opLE: 248: case opGT: 249: case opGE: 250: if (!Qlflag) 251: syserr("LBOP in targ list"); 252: format(result->right); 253: rfrmt = Trfrmt; 254: format(result->left); 255: if ((rfrmt == CHAR) != (Trfrmt == CHAR)) 256: /* type conflict on relational operator */ 257: par_error(RELTYPE, WARN, 0); 258: return; 259: 260: case opADD: 261: case opSUB: 262: format(result->left); 263: rfrmt = Trfrmt; 264: rfrml = Trfrml; 265: format(result->right); 266: if (rfrmt == FLOAT || Trfrmt == FLOAT) 267: { 268: if (rfrmt == FLOAT && Trfrmt == FLOAT) 269: { 270: if (Trfrml < rfrml) 271: rfrml = Trfrml; 272: } 273: else if (Trfrmt == FLOAT) 274: rfrml = Trfrml; 275: rfrmt = FLOAT; 276: } 277: else 278: if (Trfrml > rfrml) 279: rfrml = Trfrml; 280: break; 281: 282: case opMUL: 283: case opDIV: 284: format(result->left); 285: rfrmt = Trfrmt; 286: rfrml = Trfrml; 287: format(result->right); 288: if ((rfrmt == CHAR || Trfrmt == CHAR)) 289: par_error(NUMTYPE, WARN, 0); 290: if (rfrmt == FLOAT || Trfrmt == FLOAT) 291: { 292: if (rfrmt == FLOAT && Trfrmt == FLOAT) 293: { 294: if (Trfrml < rfrml) 295: rfrml = Trfrml; 296: } 297: else if (Trfrmt == FLOAT) 298: rfrml = Trfrml; 299: rfrmt = FLOAT; 300: } 301: else 302: if (Trfrml > rfrml) 303: rfrml = Trfrml; 304: break; 305: 306: case opMOD: 307: format(result->left); 308: rfrmt = Trfrmt; 309: rfrml = Trfrml; 310: format(result->right); 311: if (rfrmt != INT || Trfrmt != INT) 312: /* mod operator not defined */ 313: par_error(MODTYPE, WARN, 0); 314: if (Trfrml > rfrml) 315: rfrml = Trfrml; 316: break; 317: 318: case opPOW: 319: format(result->right); 320: rfrmt = Trfrmt; 321: rfrml = Trfrml; 322: format(result->left); 323: if (rfrmt == CHAR || Trfrmt == CHAR) 324: /* no char values for pow */ 325: par_error(NUMTYPE, WARN, 0); 326: if ((rfrmt == FLOAT && rfrml == 4) || (Trfrmt == FLOAT && Trfrml == 4)) 327: { 328: rfrmt = FLOAT; 329: rfrml = 4; 330: } 331: else 332: { 333: rfrmt = FLOAT; 334: rfrml = 8; 335: } 336: break; 337: 338: case opCONCAT: 339: format(result->left); 340: rfrmt = Trfrmt; 341: rfrml = Trfrml; 342: format(result->right); 343: if (rfrmt != CHAR || Trfrmt != CHAR) 344: /* only character domains allowed */ 345: par_error(CONCATTYPE, WARN, 0); 346: rfrml += Trfrml; 347: break; 348: 349: default: 350: syserr("bad BOP in format %d", result->sym.value.sym_op.opno); 351: } 352: } 353: Trfrmt = rfrmt; 354: Trfrml = rfrml; 355: # ifdef xPTR2 356: tTfp(52, 2, "format>>: Trfrmt = %d, Trfrml = %d.\n", Trfrmt, Trfrml); 357: # endif 358: }
|
Last modified: 1986-04-17
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 1241 |
|