Return to builtins.c CVS log

Up to [Research Unix] / researchv10no / cmd / pico

Annotation of researchv10no/cmd/pico/builtins.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <math.h>
                      3: #include <ctype.h>
                      4: #include "pico.h"
                      5: 
                      6: extern struct  SRC src[MANY];
                      7: extern short   CURSCRATCH, CUROLD;
                      8: extern char    frameb, metheus;
                      9: extern int     DEF_LL, DEF_NL;
                     10: extern float   fsqrt();
                     11: 
                     12: println(s, aa)
                     13:        char *s;
                     14:        long aa;
                     15: {
                     16:        char c, *t = s;
                     17:        int argc=1;
                     18:        long *aaa = &aa;
                     19: 
                     20:        for (;;)
                     21:        switch (c = *t++) {
                     22:        case '\0': return argc;
                     23:        case  '%': switch (c = *t++) {
                     24:                   case '\0': putc('%', stderr); return argc;
                     25:                   case  'd': fprintf(stderr, "%d", (int)*aaa);
                     26:                              aaa++; argc++; break;
                     27:                   case  's': fprintf(stderr, "%s", (char *)*aaa);
                     28:                              aaa++; argc++; break;
                     29:                   case  '%': putc('%', stderr); break;
                     30:                   default  : putc('%', stderr); putc(c, stderr); break;
                     31:                   }
                     32:                   break;
                     33:        default  : putc(c, stderr); break;
                     34:        }
                     35: }
                     36: 
                     37: Clamp(a){ return ((a < 0)?0:((a>=DEF_LL)?(DEF_LL-1):a)); }
                     38: Abs(a) { return ((a<0)?(-a):a); }
                     39: 
                     40: int Midx = 256, Midy = 256;
                     41: 
                     42: setmid()
                     43: {
                     44:        Midx = (Old->sx + (Old->ex - Old->sx)/2);
                     45:        Midy = (Old->sy + (Old->ey - Old->sy)/2);
                     46: }
                     47: 
                     48: r_polar(x, y)
                     49: {      register float dx = (float) (x - Midx);
                     50:        register float dy = (float) (y - Midy);
                     51: 
                     52:        return (int) fsqrt(dx*dx + dy*dy);
                     53: }
                     54: 
                     55: a_polar(x, y)
                     56: {
                     57:        return patan2(x-Midx, y-Midy);
                     58: }
                     59: A_polar(x, y)
                     60: {
                     61:        return Patan2(x-Midx, y-Midy);
                     62: }
                     63: 
                     64: Y_cart(r, a)
                     65: {
                     66:        return Midy+(r*Psin(a)/10000);
                     67: }
                     68: y_cart(r, a)
                     69: {      int b = Midy+(r*psin(a)/10000);
                     70:        return (b >= 0 && b < DEF_NL)?b:0;
                     71: }
                     72: 
                     73: X_cart(r, a)
                     74: {
                     75:        return Midx+(r*Pcos(a)/10000);
                     76: }
                     77: x_cart(r, a)
                     78: {      int b = Midx+(r*pcos(a)/10000);
                     79:        return (b >= 0 && b < DEF_LL)?b:0;
                     80: }
                     81: 
                     82: setzmap(i, z)
                     83: {
                     84:        redcmap(i, z);
                     85:        grncmap(i, z);
                     86:        blucmap(i, z);
                     87:        return z;
                     88: }
                     89: 
                     90: setcmap(i, r,g,b)
                     91: {
                     92:        redcmap(i, r);
                     93:        grncmap(i, g);
                     94:        blucmap(i, b);
                     95:        return r;
                     96: }
                     97: 
                     98: putframe(n)
                     99: {      char nr[128];
                    100:        int i;
                    101: 
                    102:        sprintf(nr, "frame.%6d", n);
                    103:        for (i = 11; i > 5; i--)
                    104:                if (nr[i] == ' ') nr[i] = '0';
                    105:        i = CUROLD; CUROLD = CURSCRATCH; CURSCRATCH = i;
                    106:        putdpix(nr, 0);
                    107:        i = CUROLD; CUROLD = CURSCRATCH; CURSCRATCH = i;
                    108:        return 1;
                    109: }
                    110: 
                    111: swap()
                    112: {
                    113:        setscratch(Scratch, Old);
                    114:        return 1;
                    115: }
                    116: 
                    117: getframe(n)
                    118: {      char nr[128];
                    119:        int i;
                    120: 
                    121:        sprintf(nr, "frame.%6d", n);
                    122:        for (i = 11; i > 5; i--)
                    123:                if (nr[i] == ' ') nr[i] = '0';
                    124:        return newscreen(nr);
                    125: }
                    126: 
                    127: yank(x, y)
                    128: {      if (frameb) fbyank(x, y);
                    129:        else if (metheus) metyank(x,y);
                    130: }
                    131: 
                    132: intexp(a) int a; {     return (int) exp((double) a); }
                    133: intlog(a) int a; {     return (int) 1024*log((double) a); }
                    134: intlog10(a) int a; {   return (int) 1024*log10((double) a); }
                    135: intsqrt(a) int a; {    return (int) sqrt((double) a); }
                    136: intpow(a, b) int a,b; {        return (int) pow((double) a, (double) b); }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.