Fix names in the trap rasterizer.

s/Shift4/SHIFT_4/g;
s/Get4/GET_4/g;
s/Put4/PUT_4/g;
s/DefineAlpha/DEFINE_ALPHA/g;
s/AddAlpha/ADD_ALPHA/g;
s/StepAlpha/STEP_ALPHA/g;
s/add_saturate_8/ADD_SATURATE_8/g;
s/RenderEdgeStepSmall/RENDER_EDGE_STEP_SMALL/g;
s/RenderEdgeStepBig/RENDER_EDGE_STEP_BIG/g;
s/fbRasterizeEdges/b00_re/g;
s/rasterizeEdges/RASTERIZE_EDGES/g;
s/b00_re/rasterize_edges_/g;

diff --git a/pixman/pixman-edge-imp.h b/pixman/pixman-edge-imp.h
index 1687c0b..58957e3 100644 (file)
--- a/pixman/pixman-edge-imp.h
+++ b/pixman/pixman-edge-imp.h
@@ -24,7 +24,7 @@
 #endif
 
 static void
-rasterizeEdges (pixman_image_t  *image,
+RASTERIZE_EDGES (pixman_image_t  *image,
                pixman_edge_t   *l,
                pixman_edge_t   *r,
                pixman_fixed_t          t,
@@ -132,7 +132,7 @@ rasterizeEdges (pixman_image_t  *image,
            }
 #else
            {
-               DefineAlpha(line,lxi);
+               DEFINE_ALPHA(line,lxi);
                int         lxs;
                int     rxs;
 
@@ -143,20 +143,20 @@ rasterizeEdges (pixman_image_t  *image,
                /* Add coverage across row */
                if (lxi == rxi)
                {
-                   AddAlpha (rxs - lxs);
+                   ADD_ALPHA (rxs - lxs);
                }
                else
                {
                    int xi;
 
-                   AddAlpha (N_X_FRAC(N_BITS) - lxs);
-                   StepAlpha;
+                   ADD_ALPHA (N_X_FRAC(N_BITS) - lxs);
+                   STEP_ALPHA;
                    for (xi = lxi + 1; xi < rxi; xi++)
                    {
-                       AddAlpha (N_X_FRAC(N_BITS));
-                       StepAlpha;
+                       ADD_ALPHA (N_X_FRAC(N_BITS));
+                       STEP_ALPHA;
                    }
-                   AddAlpha (rxs);
+                   ADD_ALPHA (rxs);
                }
            }
 #endif
@@ -168,15 +168,15 @@ rasterizeEdges (pixman_image_t  *image,
 #if N_BITS > 1
        if (pixman_fixed_frac (y) != Y_FRAC_LAST(N_BITS))
        {
-           RenderEdgeStepSmall (l);
-           RenderEdgeStepSmall (r);
+           RENDER_EDGE_STEP_SMALL (l);
+           RENDER_EDGE_STEP_SMALL (r);
            y += STEP_Y_SMALL(N_BITS);
        }
        else
 #endif
        {
-           RenderEdgeStepBig (l);
-           RenderEdgeStepBig (r);
+           RENDER_EDGE_STEP_BIG (l);
+           RENDER_EDGE_STEP_BIG (r);
            y += STEP_Y_BIG(N_BITS);
            line += stride;
        }

diff --git a/pixman/pixman-edge.c b/pixman/pixman-edge.c
index 43e9604..f6a580e 100644 (file)
--- a/pixman/pixman-edge.c
+++ b/pixman/pixman-edge.c
@@ -32,7 +32,7 @@
 /*
  * Step across a small sample grid gap
  */
-#define RenderEdgeStepSmall(edge) { \
+#define RENDER_EDGE_STEP_SMALL(edge) { \
     edge->x += edge->stepx_small;   \
     edge->e += edge->dx_small;     \
     if (edge->e > 0)               \
@@ -45,7 +45,7 @@
 /*
  * Step across a large sample grid gap
  */
-#define RenderEdgeStepBig(edge) {   \
+#define RENDER_EDGE_STEP_BIG(edge) {   \
     edge->x += edge->stepx_big;            \
     edge->e += edge->dx_big;       \
     if (edge->e > 0)               \
@@ -66,35 +66,35 @@
  */
 
 #define N_BITS 4
-#define rasterizeEdges fbRasterizeEdges4
+#define RASTERIZE_EDGES        rasterize_edges_4
 
 #ifndef WORDS_BIG_ENDIAN
-#define Shift4(o)      ((o) << 2)
+#define SHIFT_4(o)     ((o) << 2)
 #else
-#define Shift4(o)      ((1-(o)) << 2)
+#define SHIFT_4(o)     ((1-(o)) << 2)
 #endif
 
-#define Get4(x,o)      (((x) >> Shift4(o)) & 0xf)
-#define Put4(x,o,v)    (((x) & ~(0xf << Shift4(o))) | (((v) & 0xf) << Shift4(o)))
+#define GET_4(x,o)     (((x) >> SHIFT_4(o)) & 0xf)
+#define PUT_4(x,o,v)   (((x) & ~(0xf << SHIFT_4(o))) | (((v) & 0xf) << SHIFT_4(o)))
 
-#define DefineAlpha(line,x)                         \
+#define DEFINE_ALPHA(line,x)                        \
     uint8_t   *__ap = (uint8_t *) line + ((x) >> 1); \
     int            __ao = (x) & 1
 
-#define StepAlpha      ((__ap += __ao), (__ao ^= 1))
+#define STEP_ALPHA     ((__ap += __ao), (__ao ^= 1))
 
-#define AddAlpha(a) {                                                  \
+#define ADD_ALPHA(a) {                                                 \
        uint8_t   __o = READ(image, __ap);                              \
-       uint8_t   __a = (a) + Get4(__o, __ao);                          \
-       WRITE(image, __ap, Put4 (__o, __ao, __a | (0 - ((__a) >> 4)))); \
+       uint8_t   __a = (a) + GET_4(__o, __ao);                         \
+       WRITE(image, __ap, PUT_4 (__o, __ao, __a | (0 - ((__a) >> 4))));        \
     }
 
 #include "pixman-edge-imp.h"
 
-#undef AddAlpha
-#undef StepAlpha
-#undef DefineAlpha
-#undef rasterizeEdges
+#undef ADD_ALPHA
+#undef STEP_ALPHA
+#undef DEFINE_ALPHA
+#undef RASTERIZE_EDGES
 #undef N_BITS
 
 
@@ -103,11 +103,11 @@
  */
 
 #define N_BITS 1
-#define rasterizeEdges fbRasterizeEdges1
+#define RASTERIZE_EDGES        rasterize_edges_1
 
 #include "pixman-edge-imp.h"
 
-#undef rasterizeEdges
+#undef RASTERIZE_EDGES
 #undef N_BITS
 
 /*
@@ -121,7 +121,7 @@ clip255 (int x)
     return x;
 }
 
-#define add_saturate_8(buf,val,length)                         \
+#define ADD_SATURATE_8(buf,val,length)                         \
     do {                                                       \
        int i__ = (length);                                     \
        uint8_t *buf__ = (buf);                                 \
@@ -146,7 +146,7 @@ clip255 (int x)
  *                   fill_start       fill_end
  */
 static void
-fbRasterizeEdges8 (pixman_image_t       *image,
+rasterize_edges_8 (pixman_image_t       *image,
                   pixman_edge_t        *l,
                   pixman_edge_t        *r,
                   pixman_fixed_t       t,
@@ -220,7 +220,7 @@ fbRasterizeEdges8 (pixman_image_t       *image,
                        if (lxi >= fill_end || rxi < fill_start)
                        {
                            /* We're beyond what we saved, just fill it */
-                           add_saturate_8 (ap + fill_start,
+                           ADD_SATURATE_8 (ap + fill_start,
                                            fill_size * N_X_FRAC(8),
                                            fill_end - fill_start);
                            fill_start = lxi;
@@ -232,28 +232,28 @@ fbRasterizeEdges8 (pixman_image_t       *image,
                            /* Update fill_start */
                            if (lxi > fill_start)
                            {
-                               add_saturate_8 (ap + fill_start,
+                               ADD_SATURATE_8 (ap + fill_start,
                                                fill_size * N_X_FRAC(8),
                                                lxi - fill_start);
                                fill_start = lxi;
                            }
                            else if (lxi < fill_start)
                            {
-                               add_saturate_8 (ap + lxi, N_X_FRAC(8),
+                               ADD_SATURATE_8 (ap + lxi, N_X_FRAC(8),
                                                fill_start - lxi);
                            }
 
                            /* Update fill_end */
                            if (rxi < fill_end)
                            {
-                               add_saturate_8 (ap + rxi,
+                               ADD_SATURATE_8 (ap + rxi,
                                                fill_size * N_X_FRAC(8),
                                                fill_end - rxi);
                                fill_end = rxi;
                            }
                            else if (fill_end < rxi)
                            {
-                               add_saturate_8 (ap + fill_end,
+                               ADD_SATURATE_8 (ap + fill_end,
                                                N_X_FRAC(8),
                                                rxi - fill_end);
                            }
@@ -263,7 +263,7 @@ fbRasterizeEdges8 (pixman_image_t       *image,
                }
                else
                {
-                   add_saturate_8 (ap + lxi, N_X_FRAC(8), rxi - lxi);
+                   ADD_SATURATE_8 (ap + lxi, N_X_FRAC(8), rxi - lxi);
                }
 
                WRITE(image, ap + rxi, clip255 (READ(image, ap + rxi) + rxs));
@@ -279,7 +279,7 @@ fbRasterizeEdges8 (pixman_image_t       *image,
                }
                else
                {
-                   add_saturate_8 (ap + fill_start, fill_size * N_X_FRAC(8),
+                   ADD_SATURATE_8 (ap + fill_start, fill_size * N_X_FRAC(8),
                                    fill_end - fill_start);
                }
             }
@@ -288,14 +288,14 @@ fbRasterizeEdges8 (pixman_image_t       *image,
 
        if (pixman_fixed_frac (y) != Y_FRAC_LAST(8))
        {
-           RenderEdgeStepSmall (l);
-           RenderEdgeStepSmall (r);
+           RENDER_EDGE_STEP_SMALL (l);
+           RENDER_EDGE_STEP_SMALL (r);
            y += STEP_Y_SMALL(8);
        }
        else
        {
-           RenderEdgeStepBig (l);
-           RenderEdgeStepBig (r);
+           RENDER_EDGE_STEP_BIG (l);
+           RENDER_EDGE_STEP_BIG (r);
            y += STEP_Y_BIG(8);
             if (fill_start != fill_end)
             {
@@ -305,7 +305,7 @@ fbRasterizeEdges8 (pixman_image_t       *image,
                }
                else
                {
-                   add_saturate_8 (ap + fill_start, fill_size * N_X_FRAC(8),
+                   ADD_SATURATE_8 (ap + fill_start, fill_size * N_X_FRAC(8),
                                    fill_end - fill_start);
                }
                 fill_start = fill_end = -1;
@@ -329,13 +329,13 @@ PIXMAN_RASTERIZE_EDGES (pixman_image_t *image,
     switch (PIXMAN_FORMAT_BPP (image->bits.format))
     {
     case 1:
-       fbRasterizeEdges1 (image, l, r, t, b);
+       rasterize_edges_1 (image, l, r, t, b);
        break;
     case 4:
-       fbRasterizeEdges4 (image, l, r, t, b);
+       rasterize_edges_4 (image, l, r, t, b);
        break;
     case 8:
-       fbRasterizeEdges8 (image, l, r, t, b);
+       rasterize_edges_8 (image, l, r, t, b);
        break;
     }
 }