draw.cpp

   1 // Draw a graph
   2 extern "C"{
   3 #include "fxlib.h"
   4 }
   5 #include <string.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <math.h>
   9
  10 #include "stdafx.h"
  11 #include "defs.h"
  12
  13 #define DIMX 128
  14 #define DIMY 64
  15
  16 #define F p3
  17 #define T p4
  18 #define X p5
  19 #define Y p6
  20 #define XT p7
  21 #define YT p8
  22
  23 static double tmin, tmax;
  24 static double xmin, xmax;
  25 static double ymin, ymax;
  26
  27 #define YMAX 1000
  28
  29 typedef struct {
  30         int x, y;
  31         double t;
  32 } DRAWBUF;
  33
  34 DRAWBUF *draw_buf;
  35
  36 static int draw_count;
  37
  38 void
  39 eval_draw(void)
  40 {
  41         draw_buf=(DRAWBUF*)calloc(YMAX,sizeof(DRAWBUF));
  42         F = cadr(p1);
  43         T = caddr(p1);
  44
  45         if (T == symbol(NIL)) {
  46                 push(F);
  47                 rewrite();
  48                 guess();
  49                 T = pop();
  50                 F = pop();
  51         }
  52
  53         push(get_binding(T));
  54         push(get_arglist(T));
  55
  56         draw_main();
  57
  58         p2 = pop();
  59         p1 = pop();
  60         set_binding_and_arglist(T, p1, p2);
  61
  62         // return value
  63
  64         push(symbol(NIL));
  65 }
  66
  67 void
  68 draw_main(void)
  69 {
  70         if (draw_flag) {
  71                 draw_flag = 0; // so "stop" really stops
  72                 stop("draw calls draw");
  73         }
  74
  75         draw_flag++;
  76
  77         setup_trange();
  78
  79         setup_xrange();
  80
  81         setup_yrange();
  82
  83         check_for_parametric_draw();
  84
  85         create_point_set();
  86
  87         emit_graph();
  88
  89         draw_flag--;
  90 }
  91
  92 /*      xrange sets the horizontal scale
  93
  94         yrange sets the vertical scale
  95
  96         Normally, the function F is evaluated from xrange[1] to xrange[2].
  97
  98         However, if F returns a vector then parametric drawing is used. In this
  99         case F is evaluated from trange[1] to trange[2].
 100 */
 101
 102 void
 103 check_for_parametric_draw(void)
 104 {
 105         eval_f(tmin);
 106         p1 = pop();
 107         if (!istensor(p1)) {
 108                 tmin = xmin;
 109                 tmax = xmax;
 110         }
 111 }
 112
 113 #define N 100
 114
 115 void
 116 create_point_set(void)
 117 {
 118         int i, n;
 119         double t;
 120
 121         draw_count = 0;
 122
 123         for (i = 0; i <= N; i++) {
 124                 t = tmin + ((double) i / (double) N) * (tmax - tmin);
 125                 new_point(t);
 126         }
 127
 128         n = draw_count;
 129
 130         for (i = 0; i < n - 1; i++)
 131                 fill(i, i + 1, 0);
 132 }
 133
 134 void
 135 new_point(double t)
 136 {
 137         double x, y;
 138
 139         if (draw_count >= YMAX)
 140                 return;
 141
 142         draw_buf[draw_count].x = -10000;
 143         draw_buf[draw_count].y = -10000;
 144         draw_buf[draw_count].t = t;
 145
 146         draw_count++;
 147
 148         get_xy(t);
 149
 150         if (!isnum(XT) || !isnum(YT))
 151                 return;
 152
 153         push(XT);
 154         x = pop_double();
 155         x = (x - xmin) / (xmax - xmin);
 156         x = (double) DIMX * x + 0.5; // map 0-1 to 0-DIM, +0.5 so draw(x^3) looks right
 157
 158         push(YT);
 159         y = pop_double();
 160         y = (y - ymin) / (ymax - ymin);
 161         y = (double) DIMY * y + 0.5; // map 0-1 to 0-DIM, +0.5 so draw(x^3) looks right
 162
 163         if (x < -10000.0)
 164                 x = -10000.0;
 165         if (x > 10000.0)
 166                 x = 10000.0;
 167         if (y < -10000.0)
 168                 y = -10000.0;
 169         if (y > 10000.0)
 170                 y = 10000.0;
 171
 172         draw_buf[draw_count - 1].x = (int) x;
 173         draw_buf[draw_count - 1].y = (int) y;
 174 }
 175
 176 // Evaluate F(t) and return in XT and YT.
 177
 178 void
 179 get_xy(double t)
 180 {
 181         eval_f(t);
 182
 183         p1 = pop();
 184
 185         if (istensor(p1)) {
 186                 if (p1->u.tensor->nelem >= 2) {
 187                         XT = p1->u.tensor->elem[0];
 188                         YT = p1->u.tensor->elem[1];
 189                 } else {
 190                         XT = symbol(NIL);
 191                         YT = symbol(NIL);
 192                 }
 193                 return;
 194         }
 195
 196         push_double(t);
 197         XT = pop();
 198         YT = p1;
 199 }
 200
 201 // Evaluate F(t) without stopping due to an error such as divide by zero.
 202
 203 void
 204 eval_f(double t)
 205 {
 206         // These must be volatile or it crashes. (Compiler error?)
 207         // Read it backwards, save_tos is a volatile int, etc.
 208
 209         int volatile save_tos;
 210         U ** volatile save_frame;
 211
 212         save();
 213         save_tos = tos;
 214         save_frame = frame;
 215
 216         draw_flag++;
 217
 218         if (setjmp(draw_stop_return)) {
 219                 tos = save_tos;
 220                 push(symbol(NIL));
 221                 frame = save_frame;
 222                 restore();
 223                 draw_flag--;
 224                 return;
 225         }
 226
 227         push_double(t);
 228         p1 = pop();
 229         set_binding(T, p1);
 230
 231         push(F);
 232         eval();
 233         yyfloat();
 234         eval();
 235
 236         restore();
 237         draw_flag--;
 238 }
 239
 240 #define MAX_DEPTH 6
 241
 242 void
 243 fill(int i, int k, int level)
 244 {
 245         int dx, dy, j;
 246         double t;
 247
 248         if (level >= MAX_DEPTH || draw_count >= YMAX)
 249                 return;
 250
 251         dx = abs(draw_buf[i].x - draw_buf[k].x);
 252         dy = abs(draw_buf[i].y - draw_buf[k].y);
 253
 254         if (dx < 1 && dy < 1)
 255                 return;
 256
 257         t = (draw_buf[i].t + draw_buf[k].t) / 2.0;
 258
 259         j = draw_count;
 260
 261         new_point(t);
 262
 263         fill(i, j, level + 1);
 264         fill(j, k, level + 1);
 265 }
 266
 267 //-----------------------------------------------------------------------------
 268 //
 269 //      Normalize x to [0,1]
 270 //
 271 //      Example: xmin = -10, xmax = 10, xmax - xmin = 20
 272 //
 273 //      x               x - xmin        (x - xmin) / (xmax - xmin)
 274 //
 275 //      -10             0               0.00
 276 //
 277 //      -5              5               0.25
 278 //
 279 //      0               10              0.50
 280 //
 281 //      5               15              0.75
 282 //
 283 //      10              20              1.00
 284 //
 285 //-----------------------------------------------------------------------------
 286
 287 void
 288 setup_trange(void)
 289 {
 290         save();
 291         setup_trange_f();
 292         restore();
 293 }
 294
 295 void
 296 setup_trange_f(void)
 297 {
 298         // default range is (-pi, pi)
 299
 300         tmin = -M_PI;
 301
 302         tmax = M_PI;
 303
 304         p1 = usr_symbol("trange");
 305
 306         if (!issymbol(p1))
 307                 return;
 308
 309         p1 = get_binding(p1);
 310
 311         // must be two element vector
 312
 313         if (!istensor(p1) || p1->u.tensor->ndim != 1 || p1->u.tensor->nelem != 2)
 314                 return;
 315
 316         push(p1->u.tensor->elem[0]);
 317         eval();
 318         yyfloat();
 319         eval();
 320         p2 = pop();
 321
 322         push(p1->u.tensor->elem[1]);
 323         eval();
 324         yyfloat();
 325         eval();
 326         p3 = pop();
 327
 328         if (!isnum(p2) || !isnum(p3))
 329                 return;
 330
 331         push(p2);
 332         tmin = pop_double();
 333
 334         push(p3);
 335         tmax = pop_double();
 336
 337         if (tmin == tmax)
 338                 stop("draw: trange is zero");
 339 }
 340
 341 void
 342 setup_xrange(void)
 343 {
 344         save();
 345         setup_xrange_f();
 346         restore();
 347 }
 348
 349 void
 350 setup_xrange_f(void)
 351 {
 352         // default range is (-10,10)
 353
 354         xmin = -10.0;
 355
 356         xmax = 10.0;
 357
 358         p1 = usr_symbol("xrange");
 359
 360         if (!issymbol(p1))
 361                 return;
 362
 363         p1 = get_binding(p1);
 364
 365         // must be two element vector
 366
 367         if (!istensor(p1) || p1->u.tensor->ndim != 1 || p1->u.tensor->nelem != 2)
 368                 return;
 369
 370         push(p1->u.tensor->elem[0]);
 371         eval();
 372         yyfloat();
 373         eval();
 374         p2 = pop();
 375
 376         push(p1->u.tensor->elem[1]);
 377         eval();
 378         yyfloat();
 379         eval();
 380         p3 = pop();
 381
 382         if (!isnum(p2) || !isnum(p3))
 383                 return;
 384
 385         push(p2);
 386         xmin = pop_double();
 387
 388         push(p3);
 389         xmax = pop_double();
 390
 391         if (xmin == xmax)
 392                 stop("draw: xrange is zero");
 393 }
 394
 395 //-----------------------------------------------------------------------------
 396 //
 397 //      Example: yrange=(-10,10)
 398 //
 399 //      y       d       v (vertical pixel coordinate)
 400 //
 401 //      10      0.00    0
 402 //
 403 //      5       0.25    100
 404 //
 405 //      0       0.50    200
 406 //
 407 //      -5      0.75    300
 408 //
 409 //      -10     1.00    400
 410 //
 411 //      We have
 412 //
 413 //              d = (10 - y) / 20
 414 //
 415 //                = (B - y) / (B - A)
 416 //
 417 //      where yrange=(A,B)
 418 //
 419 //      To convert d to v, multiply by N where N = 400.
 420 //
 421 //-----------------------------------------------------------------------------
 422
 423 void
 424 setup_yrange(void)
 425 {
 426         save();
 427         setup_yrange_f();
 428         restore();
 429 }
 430
 431 void
 432 setup_yrange_f(void)
 433 {
 434         // default range is (-10,10)
 435
 436         ymin = -10.0;
 437
 438         ymax = 10.0;
 439
 440         p1 = usr_symbol("yrange");
 441
 442         if (!issymbol(p1))
 443                 return;
 444
 445         p1 = get_binding(p1);
 446
 447         // must be two element vector
 448
 449         if (!istensor(p1) || p1->u.tensor->ndim != 1 || p1->u.tensor->nelem != 2)
 450                 return;
 451
 452         push(p1->u.tensor->elem[0]);
 453         eval();
 454         yyfloat();
 455         eval();
 456         p2 = pop();
 457
 458         push(p1->u.tensor->elem[1]);
 459         eval();
 460         yyfloat();
 461         eval();
 462         p3 = pop();
 463
 464         if (!isnum(p2) || !isnum(p3))
 465                 return;
 466
 467         push(p2);
 468         ymin = pop_double();
 469
 470         push(p3);
 471         ymax = pop_double();
 472
 473         if (ymin == ymax)
 474                 stop("draw: yrange is zero");
 475 }
 476
 477 void get_xyminmax(double* xminp, double* xmaxp, double* yminp, double* ymaxp) {
 478   *xminp = xmin;
 479   *xmaxp = xmax;
 480   *yminp = ymin;
 481   *ymaxp = ymax;
 482 }
 483
 484 #define XOFF 0
 485 #define YOFF 24
 486
 487 static void emit_xaxis(void);
 488 static void emit_yaxis(void);
 489 static void emit_xscale(void);
 490 static void emit_yscale(void);
 491
 492 static void get_xzero(void);
 493 static void get_yzero(void);
 494
 495 static int xzero, yzero;
 496
 497 void
 498 emit_graph(void)
 499 {
 500   int i, x, y;
 501   Bdisp_AllClr_VRAM();
 502   get_xzero();
 503   get_yzero();
 504   emit_xaxis();
 505   emit_yaxis();
 506   emit_xscale();
 507   emit_yscale();
 508
 509   for (i = 0; i < draw_count; i++) {
 510           x = draw_buf[i].x;
 511           y = DIMY - draw_buf[i].y; // flip the y coordinate
 512           if (x < 0 || x > DIMX)
 513                   continue;
 514           if (y < 0 || y > DIMY)
 515                   continue;
 516           Bdisp_SetPoint_VRAM(x+XOFF, y+YOFF, 1);
 517   }
 518   set_has_drawn(1);
 519 }
 520
 521 static void
 522 emit_xaxis(void)
 523 {
 524         int x, y, x2, y2;
 525
 526         if (yzero < 0 || yzero > DIMY)
 527                 return;
 528
 529         x = XOFF;
 530         y = YOFF + yzero;
 531
 532         x2 = XOFF + DIMX;
 533         y2 = YOFF + yzero;
 534
 535         Bdisp_DrawLineVRAM(x, y, x2, y2);
 536 }
 537
 538 static void
 539 emit_yaxis(void)
 540 {
 541         int x, y, x2, y2;
 542
 543         if (xzero < 0 || xzero > DIMX)
 544                 return;
 545
 546         x = XOFF + xzero;
 547         y = YOFF;
 548
 549         x2 = XOFF + xzero;
 550         y2 = YOFF + DIMY;
 551
 552         Bdisp_DrawLineVRAM(x, y, x2, y2);
 553 }
 554
 555 static void
 556 get_xzero(void)
 557 {
 558         double x;
 559         x = -((double) DIMX) * xmin / (xmax - xmin) + 0.5;
 560         if (x < -10000.0)
 561                 x = -10000.0;
 562         if (x > 10000.0)
 563                 x = 10000.0;
 564         xzero = (int) x;
 565 }
 566
 567 static void
 568 get_yzero(void)
 569 {
 570         double y;
 571         y = -((double) DIMY) * ymin / (ymax - ymin) + 0.5;
 572         if (y < -10000.0)
 573                 y = -10000.0;
 574         if (y > 10000.0)
 575                 y = 10000.0;
 576         yzero = DIMY - (int) y; // flip the y coordinate
 577 }
 578
 579 static void emit_xscale_f(int, char *);
 580
 581 static void
 582 emit_xscale(void)
 583 {
 584         static char s[100];
 585         sprintf(s, "%g", xmin);
 586         emit_xscale_f(0, s);
 587         sprintf(s, "%g", xmax);
 588         emit_xscale_f(DIMX, s);
 589 }
 590
 591 static void
 592 emit_xscale_f(int xx, char *s)
 593 {
 594         int w, x, y;
 595         y = 0;
 596         w = 0;
 597         PrintMini( w, y, (unsigned char*)s, 0); // get width
 598
 599         x = XOFF + xx;
 600         if(x >= DIMX) x = x-w;
 601         y = YOFF + yzero - 24+2;
 602
 603         PrintMini( x, y, (unsigned char*)s, 0);
 604 }
 605
 606 static void emit_yscale_f(int, char *);
 607
 608 static void
 609 emit_yscale(void)
 610 {
 611         static char s[100];
 612         sprintf(s, "%g", ymax);
 613         emit_yscale_f(0, s);
 614         sprintf(s, "%g", ymin);
 615         emit_yscale_f(DIMY, s);
 616 }
 617
 618 static void
 619 emit_yscale_f(int yy, char *s)
 620 {
 621         int w, x, y;
 622
 623         y = 0;
 624         w = 0;
 625         PrintMini( w, y, (unsigned char*)s, 0); // get width
 626
 627         x = xzero - w;
 628         y = YOFF + yy;
 629         if(y >= DIMY) y = y-9;
 630         y -= 24;
 631         PrintMini( x, y, (unsigned char*)s, 0);
 632 }
 633 /*
 634 #define XOFF 0
 635 #define YOFF 0
 636
 637 #define SHIM 10
 638
 639 static int k;
 640 static unsigned char *buf;
 641
 642 static void emit_box(void);
 643 static void emit_xaxis(void);
 644 static void emit_yaxis(void);
 645 static void emit_xscale(void);
 646 static void emit_yscale(void);
 647 static void emit_xzero(void);
 648 static void emit_yzero(void);
 649 static void get_xzero(void);
 650 static void get_yzero(void);
 651
 652 static int xzero, yzero;
 653
 654 void
 655 emit_graph(void)
 656 {
 657         int h, i, len, x, y;
 658
 659         get_xzero();
 660         get_yzero();
 661
 662         len = 1000 + 5 * draw_count;
 663
 664         buf = (unsigned char *) malloc(len);
 665
 666         h = DIM + SHIM + text_metric[SMALL_FONT].ascent + text_metric[SMALL_FONT].descent;
 667
 668         //buf[0] = (unsigned char) (h >> 8);
 669         //buf[1] = (unsigned char) h;
 670
 671         //buf[2] = (unsigned char) (DIM >> 8);
 672         //buf[3] = (unsigned char) DIM;
 673
 674         k = 0;
 675
 676         emit_box();
 677
 678         emit_xaxis();
 679         emit_yaxis();
 680
 681         emit_xscale();
 682         emit_yscale();
 683
 684         emit_xzero();
 685         emit_yzero();
 686
 687         for (i = 0; i < draw_count; i++) {
 688                 x = draw_buf[i].x;
 689                 y = DIM - draw_buf[i].y; // flip the y coordinate
 690                 if (x < 0 || x > DIM)
 691                         continue;
 692                 if (y < 0 || y > DIM)
 693                         continue;
 694                 x += XOFF;
 695                 y += YOFF;
 696                 buf[k++] = DRAW_POINT;
 697                 buf[k++] = (unsigned char) (x >> 8);
 698                 buf[k++] = (unsigned char) x;
 699                 buf[k++] = (unsigned char) (y >> 8);
 700                 buf[k++] = (unsigned char) y;
 701         }
 702
 703         buf[k++] = 0;
 704
 705         shipout(buf, DIM + 1, h);
 706 }
 707
 708 static void
 709 get_xzero(void)
 710 {
 711         double x;
 712         x = -((double) DIM) * xmin / (xmax - xmin) + 0.5;
 713         if (x < -10000.0)
 714                 x = -10000.0;
 715         if (x > 10000.0)
 716                 x = 10000.0;
 717         xzero = (int) x;
 718 }
 719
 720 static void
 721 get_yzero(void)
 722 {
 723         double y;
 724         y = -((double) DIM) * ymin / (ymax - ymin) + 0.5;
 725         if (y < -10000.0)
 726                 y = -10000.0;
 727         if (y > 10000.0)
 728                 y = 10000.0;
 729         yzero = DIM - (int) y; // flip the y coordinate
 730 }
 731
 732 static void
 733 emit_box(void)
 734 {
 735         int x, y;
 736
 737         buf[k++] = DRAW_BOX;
 738
 739         x = XOFF;
 740         y = YOFF;
 741         buf[k++] = (unsigned char) (x >> 8);
 742         buf[k++] = (unsigned char) x;
 743         buf[k++] = (unsigned char) (y >> 8);
 744         buf[k++] = (unsigned char) y;
 745
 746         x = XOFF + DIM;
 747         y = YOFF + DIM;
 748         buf[k++] = (unsigned char) (x >> 8);
 749         buf[k++] = (unsigned char) x;
 750         buf[k++] = (unsigned char) (y >> 8);
 751         buf[k++] = (unsigned char) y;
 752 }
 753
 754 static void
 755 emit_xaxis(void)
 756 {
 757         int x, y;
 758
 759         if (yzero < 0 || yzero > DIM)
 760                 return;
 761
 762         buf[k++] = DRAW_LINE;
 763
 764         x = XOFF;
 765         y = YOFF + yzero;
 766
 767         buf[k++] = (unsigned char) (x >> 8);
 768         buf[k++] = (unsigned char) x;
 769         buf[k++] = (unsigned char) (y >> 8);
 770         buf[k++] = (unsigned char) y;
 771
 772         x = XOFF + DIM;
 773         y = YOFF + yzero;
 774
 775         buf[k++] = (unsigned char) (x >> 8);
 776         buf[k++] = (unsigned char) x;
 777         buf[k++] = (unsigned char) (y >> 8);
 778         buf[k++] = (unsigned char) y;
 779 }
 780
 781 static void
 782 emit_yaxis(void)
 783 {
 784         int x, y;
 785
 786         if (xzero < 0 || xzero > DIM)
 787                 return;
 788
 789         buf[k++] = DRAW_LINE;
 790
 791         x = XOFF + xzero;
 792         y = YOFF;
 793
 794         buf[k++] = (unsigned char) (x >> 8);
 795         buf[k++] = (unsigned char) x;
 796         buf[k++] = (unsigned char) (y >> 8);
 797         buf[k++] = (unsigned char) y;
 798
 799         x = XOFF + xzero;
 800         y = YOFF + DIM;
 801
 802         buf[k++] = (unsigned char) (x >> 8);
 803         buf[k++] = (unsigned char) x;
 804         buf[k++] = (unsigned char) (y >> 8);
 805         buf[k++] = (unsigned char) y;
 806 }
 807
 808 static void emit_xscale_f(int, char *);
 809
 810 static void
 811 emit_xscale(void)
 812 {
 813         static char s[100];
 814         sprintf(s, "%g", xmin);
 815         emit_xscale_f(0, s);
 816         sprintf(s, "%g", xmax);
 817         emit_xscale_f(DIM, s);
 818 }
 819
 820 static void
 821 emit_xscale_f(int xx, char *s)
 822 {
 823         int d, i, len, w, x, y;
 824
 825         // want to center the number w/o sign
 826
 827         w = text_width(SMALL_FONT, s);
 828
 829         if (*s == '-')
 830                 d = w - text_width(SMALL_FONT, s + 1);
 831         else
 832                 d = 0;
 833
 834         x = XOFF + xx - (w - d) / 2 - d;
 835         y = YOFF + DIM + SHIM;
 836
 837         buf[k++] = SMALL_FONT;
 838         buf[k++] = (unsigned char) (x >> 8);
 839         buf[k++] = (unsigned char) x;
 840         buf[k++] = (unsigned char) (y >> 8);
 841         buf[k++] = (unsigned char) y;
 842
 843         len = (int) strlen(s);
 844
 845         buf[k++] = (unsigned char) len;
 846
 847         for (i = 0; i < len; i++)
 848                 buf[k++] = (unsigned char) s[i];
 849 }
 850
 851 static void emit_yscale_f(int, char *);
 852
 853 static void
 854 emit_yscale(void)
 855 {
 856         static char s[100];
 857         sprintf(s, "%g", ymax);
 858         emit_yscale_f(0, s);
 859         sprintf(s, "%g", ymin);
 860         emit_yscale_f(DIM, s);
 861 }
 862
 863 static void
 864 emit_yscale_f(int yy, char *s)
 865 {
 866         int i, len, w, x, y;
 867
 868         w = text_width(SMALL_FONT, s);
 869
 870         x = XOFF - SHIM - w;
 871         y = YOFF + yy - text_metric[SMALL_FONT].ascent / 2;
 872
 873         buf[k++] = SMALL_FONT;
 874         buf[k++] = (unsigned char) (x >> 8);
 875         buf[k++] = (unsigned char) x;
 876         buf[k++] = (unsigned char) (y >> 8);
 877         buf[k++] = (unsigned char) y;
 878
 879         len = (int) strlen(s);
 880
 881         buf[k++] = (unsigned char) len;
 882
 883         for (i = 0; i < len; i++)
 884                 buf[k++] = (unsigned char) s[i];
 885 }
 886
 887 // emit the '0' axis label
 888
 889 // make sure it doesn't hit the other labels
 890
 891 static void
 892 emit_xzero(void)
 893 {
 894         int x, y;
 895
 896         if (xzero < DIM / 4 || xzero > 3 * DIM / 4)
 897                 return;
 898
 899         x = XOFF + xzero - text_width(SMALL_FONT, "0") / 2;
 900         y = YOFF + DIM + SHIM;
 901
 902         buf[k++] = SMALL_FONT;
 903         buf[k++] = (unsigned char) (x >> 8);
 904         buf[k++] = (unsigned char) x;
 905         buf[k++] = (unsigned char) (y >> 8);
 906         buf[k++] = (unsigned char) y;
 907         buf[k++] = 1;
 908         buf[k++] = '0';
 909 }
 910
 911 // emit the '0' axis label
 912
 913 // make sure it doesn't hit the other labels
 914
 915 static void
 916 emit_yzero(void)
 917 {
 918         int x, y;
 919
 920         if (yzero < DIM / 4 || yzero > 3 * DIM / 4)
 921                 return;
 922
 923         x = XOFF - SHIM - text_width(SMALL_FONT, "0");
 924         y = YOFF + yzero - text_metric[SMALL_FONT].ascent / 2;
 925
 926         buf[k++] = SMALL_FONT;
 927         buf[k++] = (unsigned char) (x >> 8);
 928         buf[k++] = (unsigned char) x;
 929         buf[k++] = (unsigned char) (y >> 8);
 930         buf[k++] = (unsigned char) y;
 931         buf[k++] = 1;
 932         buf[k++] = '0';
 933 }
 934 */