ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/calexpr.c
(Generate patch)

Comparing ray/src/common/calexpr.c (file contents):
Revision 1.15 by greg, Wed Aug 14 08:18:14 1991 UTC vs.
Revision 2.22 by schorsch, Sat Jun 7 12:50:20 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1991 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  Compute data values using expression parser
6   *
# Line 16 | Line 13 | static char SCCSid[] = "$SunId$ LBL";
13   *  1/29/87  Made variables conditional (VARIABLE)
14   *
15   *  5/19/88  Added constant subexpression elimination (RCONST)
16 + *
17 + *  2/19/03     Eliminated conditional compiles in favor of esupport extern.
18   */
19  
20 < #include  <stdio.h>
20 > #include "copyright.h"
21  
22 + #include  <stdio.h>
23 + #include  <string.h>
24   #include  <ctype.h>
24 –
25   #include  <errno.h>
26 + #include  <math.h>
27 + #include  <stdlib.h>
28  
29   #include  "calcomp.h"
30  
31 < #define  MAXLINE        256             /* maximum line length */
31 > #define  MAXLINE        256             /* maximum line length */
32  
33 < #define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
33 > #define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
34  
35 < #define  isdecimal(c)   (isdigit(c) || (c) == '.')
35 > #define  isdecimal(c)   (isdigit(c) || (c) == '.')
36  
37 < extern double  atof(), pow();
38 < extern char  *fgets(), *savestr();
37 < extern char  *emalloc(), *ecalloc();
38 < extern EPNODE  *curfunc;
39 < extern double  efunc(), evariable();
40 < static double  euminus(), echannel(), eargument(), enumber();
37 > static double  euminus(), eargument(), enumber();
38 > static double  echannel();
39   static double  eadd(), esubtr(), emult(), edivi(), epow();
40   static double  ebotch();
43 – extern int  errno;
41  
42 + unsigned int  esupport =                /* what to support */
43 +                E_VARIABLE | E_FUNCTION ;
44 +
45   int  nextc;                             /* lookahead character */
46  
47 < double  (*eoper[])() = {                /* expression operations */
47 > double  (*eoper[])() = {                /* expression operations */
48          ebotch,
49 – #ifdef  VARIABLE
49          evariable,
51 – #else
52 –        ebotch,
53 – #endif
50          enumber,
51          euminus,
56 – #ifdef  INCHAN
52          echannel,
58 – #else
59 –        ebotch,
60 – #endif
61 – #ifdef  FUNCTION
53          efunc,
54          eargument,
64 – #else
55          ebotch,
56          ebotch,
67 – #endif
68 –        ebotch,
69 –        ebotch,
57          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
58          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
59          emult,
# Line 98 | Line 85 | char  *expr;
85      EPNODE  *ep;
86  
87      initstr(expr, NULL, 0);
101 – #if  defined(VARIABLE) && defined(FUNCTION)
88      curfunc = NULL;
103 – #endif
89      ep = getE1();
90      if (nextc != EOF)
91          syntax("unexpected character");
# Line 122 | Line 107 | char  *expr;
107   }
108  
109  
110 + int
111 + epcmp(ep1, ep2)                 /* compare two expressions for equivalence */
112 + register EPNODE  *ep1, *ep2;
113 + {
114 +        double  d;
115 +
116 +        if (ep1->type != ep2->type)
117 +                return(1);
118 +
119 +        switch (ep1->type) {
120 +
121 +        case VAR:
122 +                return(ep1->v.ln != ep2->v.ln);
123 +
124 +        case NUM:
125 +                if (ep2->v.num == 0)
126 +                        return(ep1->v.num != 0);
127 +                d = ep1->v.num / ep2->v.num;
128 +                return(d > 1.000000000001 | d < 0.999999999999);
129 +
130 +        case CHAN:
131 +        case ARG:
132 +                return(ep1->v.chan != ep2->v.chan);
133 +
134 +        case '=':
135 +        case ':':
136 +                return(epcmp(ep1->v.kid->sibling, ep2->v.kid->sibling));
137 +
138 +        case TICK:
139 +        case SYM:                       /* should never get this one */
140 +                return(0);
141 +
142 +        default:
143 +                ep1 = ep1->v.kid;
144 +                ep2 = ep2->v.kid;
145 +                while (ep1 != NULL) {
146 +                        if (ep2 == NULL)
147 +                                return(1);
148 +                        if (epcmp(ep1, ep2))
149 +                                return(1);
150 +                        ep1 = ep1->sibling;
151 +                        ep2 = ep2->sibling;
152 +                }
153 +                return(ep2 != NULL);
154 +        }
155 + }
156 +
157 +
158 + void
159   epfree(epar)                    /* free a parse tree */
160 < register EPNODE  *epar;
160 > register EPNODE  *epar;
161   {
162      register EPNODE  *ep;
163  
164      switch (epar->type) {
165  
132 – #if  defined(VARIABLE) || defined(FUNCTION)
166          case VAR:
167              varfree(epar->v.ln);
168              break;
136 – #endif
169              
170          case SYM:
171              freestr(epar->v.name);
# Line 146 | Line 178 | register EPNODE  *epar;
178              break;
179  
180          default:
181 <            for (ep = epar->v.kid; ep != NULL; ep = ep->sibling)
181 >            while ((ep = epar->v.kid) != NULL) {
182 >                epar->v.kid = ep->sibling;
183                  epfree(ep);
184 +            }
185              break;
186  
187      }
# Line 156 | Line 190 | register EPNODE  *epar;
190   }
191  
192                                  /* the following used to be a switch */
159 – #ifdef  FUNCTION
193   static double
194   eargument(ep)
195 < EPNODE  *ep;
195 > EPNODE  *ep;
196   {
197      return(argument(ep->v.chan));
198   }
166 – #endif
199  
200   static double
201   enumber(ep)
202 < EPNODE  *ep;
202 > EPNODE  *ep;
203   {
204      return(ep->v.num);
205   }
206  
207   static double
208   euminus(ep)
209 < EPNODE  *ep;
209 > EPNODE  *ep;
210   {
211      register EPNODE  *ep1 = ep->v.kid;
212  
213      return(-evalue(ep1));
214   }
215  
184 – #ifdef  INCHAN
216   static double
217   echannel(ep)
218 < EPNODE  *ep;
218 > EPNODE  *ep;
219   {
220      return(chanvalue(ep->v.chan));
221   }
191 – #endif
222  
223   static double
224   eadd(ep)
225 < EPNODE  *ep;
225 > EPNODE  *ep;
226   {
227      register EPNODE  *ep1 = ep->v.kid;
228  
# Line 201 | Line 231 | EPNODE  *ep;
231  
232   static double
233   esubtr(ep)
234 < EPNODE  *ep;
234 > EPNODE  *ep;
235   {
236      register EPNODE  *ep1 = ep->v.kid;
237  
# Line 210 | Line 240 | EPNODE  *ep;
240  
241   static double
242   emult(ep)
243 < EPNODE  *ep;
243 > EPNODE  *ep;
244   {
245      register EPNODE  *ep1 = ep->v.kid;
246  
# Line 219 | Line 249 | EPNODE  *ep;
249  
250   static double
251   edivi(ep)
252 < EPNODE  *ep;
252 > EPNODE  *ep;
253   {
254      register EPNODE  *ep1 = ep->v.kid;
255      double  d;
# Line 235 | Line 265 | EPNODE  *ep;
265  
266   static double
267   epow(ep)
268 < EPNODE  *ep;
268 > EPNODE  *ep;
269   {
270      register EPNODE  *ep1 = ep->v.kid;
271      double  d;
272 <    int  lasterrno;
272 >    int  lasterrno;
273  
274      lasterrno = errno;
275      errno = 0;
276      d = pow(evalue(ep1), evalue(ep1->sibling));
277 < #ifdef  IEEE
277 > #ifdef  IEEE
278      if (!finite(d))
279          errno = EDOM;
280   #endif
281 <    if (errno) {
281 >    if (errno == EDOM || errno == ERANGE) {
282          wputs("Illegal power\n");
283          return(0.0);
284      }
# Line 258 | Line 288 | EPNODE  *ep;
288  
289   static double
290   ebotch(ep)
291 < EPNODE  *ep;
291 > EPNODE  *ep;
292   {
293      eputs("Bad expression!\n");
294      quit(1);
295 +        return 0.0; /* pro forma return */
296   }
297  
298  
299   EPNODE *
300   ekid(ep, n)                     /* return pointer to a node's nth kid */
301 < register EPNODE  *ep;
301 > register EPNODE  *ep;
302   register int  n;
303   {
304  
# Line 281 | Line 312 | register int  n;
312  
313   int
314   nekids(ep)                      /* return # of kids for node ep */
315 < register EPNODE  *ep;
315 > register EPNODE  *ep;
316   {
317      register int  n = 0;
318  
# Line 292 | Line 323 | register EPNODE  *ep;
323   }
324  
325  
326 + void
327   initfile(fp, fn, ln)            /* prepare input file */
328   FILE  *fp;
329   char  *fn;
330   int  ln;
331   {
332 <    static char  inpbuf[MAXLINE];
332 >    static char  inpbuf[MAXLINE];
333  
334      infp = fp;
335      linbuf = inpbuf;
# Line 309 | Line 341 | int  ln;
341   }
342  
343  
344 + void
345   initstr(s, fn, ln)              /* prepare input string */
346   char  *s;
347   char  *fn;
# Line 323 | Line 356 | int  ln;
356   }
357  
358  
359 + void
360   getscanpos(fnp, lnp, spp, fpp)  /* return current scan position */
361   char  **fnp;
362   int  *lnp;
# Line 369 | Line 403 | scan()                         /* scan next character, return literal next
403  
404  
405   char *
406 < ltoa(l)                         /* convert long to ascii */
406 > long2ascii(l)                         /* convert long to ascii */
407   long  l;
408   {
409 <    static char  buf[16];
409 >    static char  buf[16];
410      register char  *cp;
411 <    int  neg = 0;
411 >    int  neg = 0;
412  
413      if (l == 0)
414          return("0");
# Line 394 | Line 428 | long  l;
428   }
429  
430  
431 + void
432   syntax(err)                     /* report syntax error and quit */
433   char  *err;
434   {
# Line 403 | Line 438 | char  *err;
438          if (infile != NULL) eputs(infile);
439          if (lineno != 0) {
440              eputs(infile != NULL ? ", line " : "line ");
441 <            eputs(ltoa((long)lineno));
441 >            eputs(long2ascii((long)lineno));
442          }
443 <        eputs(": syntax error:\n");
443 >        eputs(":\n");
444      }
445      eputs(linbuf);
446      if (linbuf[strlen(linbuf)-1] != '\n')
# Line 419 | Line 454 | char  *err;
454   }
455  
456  
457 + void
458   addekid(ep, ekid)                       /* add a child to ep */
459 < register EPNODE  *ep;
460 < EPNODE  *ekid;
459 > register EPNODE  *ep;
460 > EPNODE  *ekid;
461   {
462      if (ep->v.kid == NULL)
463          ep->v.kid = ekid;
# Line 437 | Line 473 | EPNODE  *ekid;
473   char *
474   getname()                       /* scan an identifier */
475   {
476 <    static char  str[MAXWORD+1];
476 >    static char  str[MAXWORD+1];
477      register int  i, lnext;
478  
479      lnext = nextc;
# Line 479 | Line 515 | getnum()                       /* scan a positive float */
515          lnext = scan();
516      }
517      if (lnext == '.' && i < MAXWORD) {
518 <        str[i++] = lnext;
519 <        lnext = scan();
518 >        str[i++] = lnext;
519 >        lnext = scan();
520 >        if (i == 1 && !isdigit(lnext))
521 >            syntax("badly formed number");
522          while (isdigit(lnext) && i < MAXWORD) {
523              str[i++] = lnext;
524              lnext = scan();
525          }
526      }
527 <    if ((lnext == 'e' || lnext == 'E') && i < MAXWORD) {
528 <        str[i++] = lnext;
529 <        lnext = scan();
530 <        if ((lnext == '-' || lnext == '+') && i < MAXWORD) {
527 >    if ((lnext == 'e' | lnext == 'E') && i < MAXWORD) {
528 >        str[i++] = lnext;
529 >        lnext = scan();
530 >        if ((lnext == '-' | lnext == '+') && i < MAXWORD) {
531              str[i++] = lnext;
532              lnext = scan();
533          }
534 +        if (!isdigit(lnext))
535 +            syntax("missing exponent");
536          while (isdigit(lnext) && i < MAXWORD) {
537              str[i++] = lnext;
538              lnext = scan();
# Line 506 | Line 546 | getnum()                       /* scan a positive float */
546  
547   EPNODE *
548   getE1()                         /* E1 -> E1 ADDOP E2 */
549 <                                /*       E2 */
549 >                                /*       E2 */
550   {
551      register EPNODE  *ep1, *ep2;
552  
# Line 517 | Line 557 | getE1()                                /* E1 -> E1 ADDOP E2 */
557          scan();
558          addekid(ep2, ep1);
559          addekid(ep2, getE2());
560 < #ifdef  RCONST
561 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
560 >        if (esupport&E_RCONST &&
561 >                        ep1->type == NUM && ep1->sibling->type == NUM)
562                  ep2 = rconst(ep2);
523 – #endif
563          ep1 = ep2;
564      }
565      return(ep1);
# Line 529 | Line 568 | getE1()                                /* E1 -> E1 ADDOP E2 */
568  
569   EPNODE *
570   getE2()                         /* E2 -> E2 MULOP E3 */
571 <                                /*       E3 */
571 >                                /*       E3 */
572   {
573      register EPNODE  *ep1, *ep2;
574  
# Line 540 | Line 579 | getE2()                                /* E2 -> E2 MULOP E3 */
579          scan();
580          addekid(ep2, ep1);
581          addekid(ep2, getE3());
582 < #ifdef  RCONST
583 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
582 >        if (esupport&E_RCONST &&
583 >                        ep1->type == NUM && ep1->sibling->type == NUM)
584                  ep2 = rconst(ep2);
546 – #endif
585          ep1 = ep2;
586      }
587      return(ep1);
# Line 552 | Line 590 | getE2()                                /* E2 -> E2 MULOP E3 */
590  
591   EPNODE *
592   getE3()                         /* E3 -> E4 ^ E3 */
593 <                                /*       E4 */
593 >                                /*       E4 */
594   {
595      register EPNODE  *ep1, *ep2;
596  
# Line 563 | Line 601 | getE3()                                /* E3 -> E4 ^ E3 */
601          scan();
602          addekid(ep2, ep1);
603          addekid(ep2, getE3());
604 < #ifdef  RCONST
605 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
604 >        if (esupport&E_RCONST &&
605 >                        ep1->type == NUM && ep1->sibling->type == NUM)
606                  ep2 = rconst(ep2);
569 – #endif
607          return(ep2);
608      }
609      return(ep1);
# Line 575 | Line 612 | getE3()                                /* E3 -> E4 ^ E3 */
612  
613   EPNODE *
614   getE4()                         /* E4 -> ADDOP E5 */
615 <                                /*       E5 */
615 >                                /*       E5 */
616   {
617      register EPNODE  *ep1, *ep2;
618  
# Line 586 | Line 623 | getE4()                                /* E4 -> ADDOP E5 */
623                  ep2->v.num = -ep2->v.num;
624                  return(ep2);
625          }
626 +        if (ep2->type == UMINUS) {      /* don't generate -(-E5) */
627 +            efree((char *)ep2);
628 +            return(ep2->v.kid);
629 +        }
630          ep1 = newnode();
631          ep1->type = UMINUS;
632          addekid(ep1, ep2);
# Line 599 | Line 640 | getE4()                                /* E4 -> ADDOP E5 */
640  
641   EPNODE *
642   getE5()                         /* E5 -> (E1) */
643 <                                /*       VAR */
644 <                                /*       NUM */
645 <                                /*       $N */
646 <                                /*       FUNC(E1,..) */
647 <                                /*       ARG */
643 >                                /*       VAR */
644 >                                /*       NUM */
645 >                                /*       $N */
646 >                                /*       FUNC(E1,..) */
647 >                                /*       ARG */
648   {
649 <    int  i;
650 <    char  *nam;
651 <    register EPNODE  *ep1, *ep2;
649 >        int      i;
650 >        char  *nam;
651 >        register EPNODE  *ep1, *ep2;
652  
653 <    if (nextc == '(') {
654 <        scan();
655 <        ep1 = getE1();
656 <        if (nextc != ')')
657 <            syntax("')' expected");
658 <        scan();
659 <        return(ep1);
660 <    }
653 >        if (nextc == '(') {
654 >                scan();
655 >                ep1 = getE1();
656 >                if (nextc != ')')
657 >                        syntax("')' expected");
658 >                scan();
659 >                return(ep1);
660 >        }
661  
662 < #ifdef  INCHAN
663 <    if (nextc == '$') {
664 <        scan();
665 <        ep1 = newnode();
666 <        ep1->type = CHAN;
667 <        ep1->v.chan = getinum();
668 <        return(ep1);
628 <    }
629 < #endif
662 >        if (esupport&E_INCHAN && nextc == '$') {
663 >                scan();
664 >                ep1 = newnode();
665 >                ep1->type = CHAN;
666 >                ep1->v.chan = getinum();
667 >                return(ep1);
668 >        }
669  
670 < #if  defined(VARIABLE) || defined(FUNCTION)
671 <    if (isalpha(nextc) || nextc == CNTXMARK) {
672 <        nam = getname();
673 < #if  defined(VARIABLE) && defined(FUNCTION)
674 <        ep1 = NULL;
675 <        if (curfunc != NULL)
676 <            for (i = 1, ep2 = curfunc->v.kid->sibling;
677 <                                ep2 != NULL; i++, ep2 = ep2->sibling)
678 <                if (!strcmp(ep2->v.name, nam)) {
679 <                    ep1 = newnode();
680 <                    ep1->type = ARG;
681 <                    ep1->v.chan = i;
682 <                    break;
670 >        if (esupport&(E_VARIABLE|E_FUNCTION) &&
671 >                        (isalpha(nextc) || nextc == CNTXMARK)) {
672 >                nam = getname();
673 >                ep1 = NULL;
674 >                if ((esupport&(E_VARIABLE|E_FUNCTION)) == (E_VARIABLE|E_FUNCTION)
675 >                                && curfunc != NULL)
676 >                        for (i = 1, ep2 = curfunc->v.kid->sibling;
677 >                                        ep2 != NULL; i++, ep2 = ep2->sibling)
678 >                                if (!strcmp(ep2->v.name, nam)) {
679 >                                        ep1 = newnode();
680 >                                        ep1->type = ARG;
681 >                                        ep1->v.chan = i;
682 >                                        break;
683 >                                }
684 >                if (ep1 == NULL) {
685 >                        ep1 = newnode();
686 >                        ep1->type = VAR;
687 >                        ep1->v.ln = varinsert(nam);
688                  }
689 <        if (ep1 == NULL)
690 < #endif
691 <        {
692 <            ep1 = newnode();
693 <            ep1->type = VAR;
694 <            ep1->v.ln = varinsert(nam);
689 >                if (esupport&E_FUNCTION && nextc == '(') {
690 >                        ep2 = newnode();
691 >                        ep2->type = FUNC;
692 >                        addekid(ep2, ep1);
693 >                        ep1 = ep2;
694 >                        do {
695 >                                scan();
696 >                                addekid(ep1, getE1());
697 >                        } while (nextc == ',');
698 >                        if (nextc != ')')
699 >                                syntax("')' expected");
700 >                        scan();
701 >                } else if (!(esupport&E_VARIABLE))
702 >                        syntax("'(' expected");
703 >                if (esupport&E_RCONST && isconstvar(ep1))
704 >                        ep1 = rconst(ep1);
705 >                return(ep1);
706          }
652 – #ifdef  FUNCTION
653 –        if (nextc == '(') {
654 –            ep2 = newnode();
655 –            ep2->type = FUNC;
656 –            addekid(ep2, ep1);
657 –            ep1 = ep2;
658 –            do {
659 –                scan();
660 –                addekid(ep1, getE1());
661 –            } while (nextc == ',');
662 –            if (nextc != ')')
663 –                syntax("')' expected");
664 –            scan();
665 –        }
666 – #ifndef  VARIABLE
667 –        else
668 –            syntax("'(' expected");
669 – #endif
670 – #endif
671 – #ifdef  RCONST
672 –        if (isconstvar(ep1))
673 –            ep1 = rconst(ep1);
674 – #endif
675 –        return(ep1);
676 –    }
677 – #endif
707  
708 <    if (isdecimal(nextc)) {
709 <        ep1 = newnode();
710 <        ep1->type = NUM;
711 <        ep1->v.num = getnum();
712 <        return(ep1);
713 <    }
714 <    syntax("unexpected character");
708 >        if (isdecimal(nextc)) {
709 >                ep1 = newnode();
710 >                ep1->type = NUM;
711 >                ep1->v.num = getnum();
712 >                return(ep1);
713 >        }
714 >        syntax("unexpected character");
715 >        return NULL; /* pro forma return */
716   }
717  
718  
689 – #ifdef  RCONST
719   EPNODE *
720   rconst(epar)                    /* reduce a constant expression */
721 < register EPNODE  *epar;
721 > register EPNODE  *epar;
722   {
723      register EPNODE  *ep;
724  
# Line 697 | Line 726 | register EPNODE  *epar;
726      ep->type = NUM;
727      errno = 0;
728      ep->v.num = evalue(epar);
729 <    if (errno)
730 <        syntax("bad constant expression");
729 >    if (errno == EDOM || errno == ERANGE)
730 >        syntax("bad constant expression");
731      epfree(epar);
732  
733      return(ep);
734   }
735  
736  
737 + int
738   isconstvar(ep)                  /* is ep linked to a constant expression? */
739 < register EPNODE  *ep;
739 > register EPNODE  *ep;
740   {
711 – #ifdef  VARIABLE
741      register EPNODE  *ep1;
713 – #ifdef  FUNCTION
742  
743 <    if (ep->type == FUNC) {
743 >    if (esupport&E_FUNCTION && ep->type == FUNC) {
744          if (!isconstfun(ep->v.kid))
745                  return(0);
746          for (ep1 = ep->v.kid->sibling; ep1 != NULL; ep1 = ep1->sibling)
# Line 720 | Line 748 | register EPNODE  *ep;
748                  return(0);
749          return(1);
750      }
723 – #endif
751      if (ep->type != VAR)
752          return(0);
753      ep1 = ep->v.ln->def;
754      if (ep1 == NULL || ep1->type != ':')
755          return(0);
756 < #ifdef  FUNCTION
730 <    if (ep1->v.kid->type != SYM)
756 >    if (esupport&E_FUNCTION && ep1->v.kid->type != SYM)
757          return(0);
732 – #endif
758      return(1);
734 – #else
735 –    return(ep->type == FUNC);
736 – #endif
759   }
760  
761  
762 < #if  defined(FUNCTION) && defined(VARIABLE)
762 > int
763   isconstfun(ep)                  /* is ep linked to a constant function? */
764 < register EPNODE  *ep;
764 > register EPNODE  *ep;
765   {
766      register EPNODE  *dp;
767      register LIBR  *lp;
768  
769      if (ep->type != VAR)
770          return(0);
771 <    dp = ep->v.ln->def;
772 <    if (dp != NULL && dp->type != ':')
773 <        return(0);
774 <    if ((dp == NULL || dp->v.kid->type != FUNC)
775 <            && ((lp = liblookup(ep->v.ln->name)) == NULL
776 <                    || lp->atyp != ':'))
777 <        return(0);
778 <    return(1);
771 >    if ((dp = ep->v.ln->def) != NULL)
772 >        if (dp->v.kid->type == FUNC)
773 >            return(dp->type == ':');
774 >        else
775 >            return(0);          /* don't identify masked library functions */
776 >    if ((lp = ep->v.ln->lib) != NULL)
777 >        return(lp->atyp == ':');
778 >    return(0);
779   }
758 – #endif
759 – #endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines