void zline_3(SDL_Surface *_screen,int x0, int y0, int x1, int y1,Uint16 _color)
{ // demonstration of functional polymorphism #3
float slope, j=0;
int dx=abs(x1-x0), dy=abs(y1-y0);
int sx=(x0 < x1)?1:-1, sy=(y0 < y1)?1:-1;
int f=(dx >= dy)?1:0, k=(f)?dx:dy, c=(f)?sx:sy, d=(f)?sy:sx, i;
slope=(float)(d)*((f)?(float)dy/(float)dx:(float)dx/(float)dy);
    for (i=0;abs(i)<=k;i+=c)
    {
    setpixel(_screen,x0+f*i+(f^1)*round(j),y0+f*round(j)+(f^1)*i,_color);
    j+=slope;
    }
}    

#define __clone__( __clone__to, __clone__from )   __typeof__ (__clone__from)  (__clone__to) = (__clone__from)

//  macro var name vs last level variable collision
#define lroundfz( _float_t_ ) ({                                    \
    float_t  f = (float_t)(_float_t_);                          \
    int64_t __tf__ = truncf(f);                                 \
    float_t  __fz__ = ( f - (float_t)__tf__ );                  \
    int32_t result,                                                 \
              __y__ = ( __fz__ > 0.0 ) - ( __fz__ < 0.0 ),          \
              __z__ = ( ( __fz__ *  __y__ ) >= ( 0.5f ) ) * __y__;  \
   result = ( __tf__ + __z__ );                                     \
   result;                                                          \
})

// rasterize a line on screen with starting position p1 (x0,y0), ending position p2 (x1,y1), draw with color
void zline_5(void* s, p2f_t ip1, p2f_t ip2, uint32_t icolor)
{ // demonstration of functional polymorphism #5    //  multiply version
__clone__(p1, ip1); __clone__(p2, ip2); __clone__(color, icolor);
float dx = fabsf( p2.x - p1.x ), dy = fabsf( p2.y - p1.y );
int sx = ( p1.x < p2.x )?1:-1, sy = ( p1.y < p2.y )?1:-1, f = ( dx >= dy )?1:0, c = (f)?sx:sy, d = (f)?sy:sx, i;
float k = (f) ? dx : dy, slope = (float)(d) * ( (f) ? dy / dx : dx / dy);
  for ( i = 0; abs(i) <= k; i += c ) {
  float   absis = abs(i) * slope;
  putpixel(s, lroundfz(p1.x + (f^1) * absis) + f * i, lroundfz(p1.y + f * absis) + (f^1) * i, color);
  }
}
    

Why is it that C programmers like to use single letter variable names? i, j, f, z, y, x, c, d, g, i2, c5 etc. They communicate no information to the reader IMO and server to confuse things more.

Let's have a campaign against the use of short and uninformative variable names. Let's be more verbose and communicate more to the reader. It's not like there isn't enough disk space to store the source code or something.

[/rant]

Quote:

when you come back to the code after 12 months and wonder what hell you were doing.

The solution for this is documentation.

In the documentation you can describe how your program works, what every single function does and why.

Apart from that, we also have comments. But it is annoying when you have more comments than actual code in your source (that is where the documentation shines).

Just my opinion.

The solution for this is documentation.

The best documentation is automatically created by well-written self-documenting source e.g. by using meaningful variable names Razz imo

The solution for this is documentation.

;...
proc f356 p1,p2,p3,p4 ;documentation for this function is on page 49
;code with no comments goes here
endp

proc f357 p1,p2,p3,p4,p5 ;documentation for this function is on page 13
;code with no comments goes here
endp
;...