# 2.11BSD#431 - /usr/src/ucb/pascal/pxp/yycosts.c

##### Functions

    delcost           X
    inscost           X
    repcost           X
    yycosts           X
    yydocost          X

##### Variables

    yysyms            X

       1: #
       2: /*
       3:  * pi - Pascal interpreter code translator
       4:  *
       5:  * Charles Haley, Bill Joy UCB
       6:  * Version 1.2 January 1979
       7:  *
       8:  *
       9:  * pxp - Pascal execution profiler
      10:  *
      11:  * Bill Joy UCB
      12:  * Version 1.2 January 1979
      13:  */
      14:
      15: #include "0.h"
      16: #include "yy.h"
      17:
      18: /*
      19:  * Symbol costs for Pascal.
      20:  *
      21:  * Cost strategy of August 14, 1977.
      22:  *
      23:  * The costs determined by the routines in this file are used by
      24:  * the recovery in choosing appropriate corrections.
      25:  * The cost vectors and the error productions in the grammar
      26:  * work together to define the corrective capacity of the grammar.
      27:  *
      28:  * The costs here largely derive from those given in Steve Rhode's
      29:  * thesis for the Pascal-I error correcting parser which he implemented.
      30:  * Some minor changes have been made to adjust for the fact that
      31:  * the current error recovery is not as "smart", both because of the
      32:  * limited forward move and because of the lack of any type information
      33:  * about identifiers.
      34:  *
      35:  * These adjustments largely take the form of increased costs for certain
      36:  * tokens, noticeably keywords which are major brackets such as "begin"
      37:  * "label", "procedure", etc.
      38:  *
      39:  * The overall weighting strategy is still similar to Rhodes' strategy.
      40:  * The costs can be considered:
      41:  *
      42:  *	LOW	<= 3
      43:  *	MEDIUM	4 or 5
      44:  *	HIGH	>= 6
      45:  */
      46:
      47: /*
      48:  * Insertion costs
      49:  *
      50:  * In addition to the normal symbol insertion costs,
      51:  * there are zero cost insertions here.
      52:  * The current error recovery system treats symbols
      53:  * which have zero insertion cost in a special way,
      54:  * inserting them but suppressing diagnostics.
      55:  * This allows the system to hold of on bracketing
      56:  * error diagnostics about missing end's until the
      57:  * reduction occurs which knows the line number of the
      58:  * corresponding "begin", "repeat", etc.
      59:  * A more intelligent and useful diagnostic can then
      60:  * be printed.
      61:  *
      62:  * Although this routine never allows the insertion
      63:  * of the keyword begin, it can be inserted after a
      64:  * procedure or function body starts, if it was omitted
      65:  * by a special case in the panic routine, which notices
      66:  * the keywords in the statement body of the procedure
      67:  * and inserts the begin to recover.
      68:  *
      69:  * Similarly, we do not insert end-of-file, but
      70:  * the fact that end-of-file is the unique input
      71:  * is noticed by the recovery routines as a special
      72:  * case and handled there.
      73:  */
      74: inscost(sy, before)
      75:     register int sy, before;
      76: {
      77:
      78:     switch (before) {
      79:         case YEND:
      80:             if (sy == YEND)
      81:                 break;
      82:         case YPROCEDURE:
      83:         case YFUNCTION:
      84:             if (sy == YUNTIL || sy == YEND)
      85:                 return (0);
      86:     }
      87:     switch (sy) {
      88:         case ';':
      89:             return (1);
      90:         case ',':
      91:         case ':':
      92:         case YOF:
      93:         case YDO:
      94:         case '.':
      95:             return (2);
      96:         case YARRAY:
      97:         case '+':
      98:         case '*':
      99:             return (3);
     100:         default:
     101:             return (4);
     102:         case '^':
     103:         case YNOT:
     104:         case YLABEL:
     105:         case YCONST:
     106:         case YTYPE:
     107:         case YVAR:
     108:         case YUNTIL:
     109:         case '(':
     110:         case '[':
     111:         case YWHILE:
     112:         case YWITH:
     113:         case YASSERT:
     114:             return (5);
     115:         case YPROCEDURE:
     116:         case YFUNCTION:
     117:         case YCASE:
     118:             return (6);
     119:         case YEND:
     120:             return (8);
     121:         case YBEGIN:
     122:         case YEOF:
     123:         case YREPEAT:
     124:         case YRECORD:
     125:             return (INFINITY);
     126:     }
     127: }
     128:
     129: /*
     130:  * Replacement costs
     131:  *
     132:  * Most replacement costs are the same as an insertion
     133:  * plus a deletion cost.  One special case is the replacement
     134:  * of a large number of keywords by an identifier.
     135:  * These are given lower costs, especially the keyword "to".
     136:  */
     137: repcost(what, with)
     138:     register int what, with;
     139: {
     140:     register int c;
     141:
     142:     if (with == what)
     143:         return (INFINITY);
     144:     if (with == YID && what > ERROR)
     145:         switch (what) {
     146:             case YID:
     147:             case YDOTDOT:
     148:             case YINT:
     149:             case YBINT:
     150:             case YSTRING:
     151:             case YNUMB:
     152:                 break;
     153:             case YTO:
     154:                 return (3);
     155:             default:
     156:                 return (5);
     157:             case YRECORD:
     158:             case YTHEN:
     159:                 return (6);
     160:             case YBEGIN:
     161:                 break;
     162:         }
     163:     if (what == ';' && (with == ',' || with == '.'))
     164:         return (CLIMIT - 1);
     165:     c = delcost(what) + inscost(with);
     166:     /*
     167: 	 * It costs extra to replace something which has
     168: 	 * semantics by something which doesn't.
     169: 	 */
     170:     if (nullsem(what) == NIL && nullsem(with) != NIL)
     171:         c += 4;
     172:     return (c);
     173: }
     174:
     175: /*
     176:  * Deletion costs
     177:  */
     178: delcost(what)
     179:     int what;
     180: {
     181:
     182:     switch (what) {
     183:         case '.':
     184:         case ':':
     185:         case ',':
     186:         case '=':
     187:         case '(':
     188:             return (3);
     189:         case YELSE:
     190:         case YTHEN:
     191:             return (4);
     192:         default:
     193:             return (5);
     194:         case YLABEL:
     195:         case YCONST:
     196:         case YTYPE:
     197:         case YVAR:
     198:             return (10);
     199:         case YPROCEDURE:
     200:         case YFUNCTION:
     201:         case YBEGIN:
     202:         case YEND:
     203:             return ((CLIMIT * 3) / 4);
     204:         case ';':
     205:         case YEOF:
     206:             return (INFINITY);
     207:     }
     208: }
     209: #ifdef DEBUG
     210:
     211: /*
     212:  * Routine to print out costs with "-C" option.
     213:  */
     214: char    yysyms[]    ".;,:=*+/-|&()[]<>~^";
     215:
     216:
     217: yycosts()
     218: {
     219:     register int c;
     220:     register char *cp;
     221:
     222:     printf("Insert\tDelete\tRep(ID)\tSymbol\n");
     223:     for (cp = yysyms; *cp; cp++)
     224:         yydocost(*cp);
     225:     for (c = ERROR + 1; c < YLAST; c++)
     226:         yydocost(c);
     227: #ifdef PXP
     228:     flush();
     229: #endif
     230: }
     231:
     232: yydocost(c)
     233:     int c;
     234: {
     235:
     236:     printf("%4d\t", inscost(c, -1));
     237:     printf("%4d\t", delcost(c));
     238:     if (repcost(c, YID) != inscost(YID) + delcost(c))
     239:         printf("%4d", repcost(c, YID));
     240:     printf("\t%s%s\n", charname(c));
     241: }
     242: #endif

#### Defined functions

delcost defined in line 178; used 5 times

- in line 165, 237-238(2)
- in /usr/src/ucb/pascal/pxp/yyrecover.c line 537-539(2)

inscost defined in line 74; used 5 times

- in line 165, 236-238(2)
- in /usr/src/ucb/pascal/pxp/yyrecover.c line 583-585(2)

repcost defined in line 137; used 5 times

- in line 238-239(2)
- in /usr/src/ucb/pascal/pxp/yyrecover.c line 614-620(3)

yycosts defined in line 217; used 1 times

- in /usr/src/ucb/pascal/pxp/main.c line 81

yydocost defined in line 232; used 2 times

- in line 224-226(2)

#### Defined variables

yysyms defined in line 214; used 1 times

- in line 223

Last modified: 1986-06-01 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 539 |