renderer: CLEANUP: boolean/GLboolean -> bool

use stdbool.h as much as possible some of the gallium code imported uses boolean so leave it alone for now
10 years ago · ca23e98b22
parent a20ce55f73
commit ca23e98b22
7 changed files with 247 additions and 253 deletions
--- a/src/vrend_blitter.c
+++ b/src/vrend_blitter.c
@ -351,7 +351,7 @@ static void get_texcoords(struct vrend_resource *src_res,
                          int x1, int y1, int x2, int y2,
                          float out[4])
 {
-   boolean normalized = src_res->base.target != PIPE_TEXTURE_RECT &&
+   bool normalized = src_res->base.target != PIPE_TEXTURE_RECT &&
       src_res->base.nr_samples <= 1;

   if (normalized) {
@ -468,7 +468,7 @@ void vrend_renderer_blit_gl(struct vrend_context *ctx,
    GLenum filter;
    GLuint pos_loc, tc_loc;
    GLuint samp_loc;
-    boolean has_depth, has_stencil;
+    bool has_depth, has_stencil;
    bool blit_stencil, blit_depth;
    int dst_z;
    const struct util_format_description *src_desc =
--- a/src/vrend_decode.c
+++ b/src/vrend_decode.c
@ -954,7 +954,7 @@ static int vrend_decode_get_query_result(struct vrend_decode_ctx *ctx, int lengt
 static int vrend_decode_set_render_condition(struct vrend_decode_ctx *ctx, int length)
 {
   uint32_t handle = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_HANDLE);
-   boolean condition = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_CONDITION) & 1;
+   bool condition = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_CONDITION) & 1;
   uint mode = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_MODE);

   if (length != VIRGL_RENDER_CONDITION_SIZE)
@ -1061,7 +1061,7 @@ void vrend_renderer_context_destroy(uint32_t handle)
   free(ctx);
   /* switch to ctx 0 */
   if (ret && handle != 0)
-       vrend_hw_switch_context(dec_ctx[0]->grctx, TRUE);
+       vrend_hw_switch_context(dec_ctx[0]->grctx, true);
 }

 struct vrend_context *vrend_lookup_renderer_ctx(uint32_t ctx_id)
@ -1078,7 +1078,7 @@ struct vrend_context *vrend_lookup_renderer_ctx(uint32_t ctx_id)
 int vrend_decode_block(uint32_t ctx_id, uint32_t *block, int ndw)
 {
   struct vrend_decode_ctx *gdctx;
-   boolean bret;
+   bool bret;
   int ret;
   if (ctx_id > VREND_MAX_CTX)
      return EINVAL;
@ -1088,8 +1088,8 @@ int vrend_decode_block(uint32_t ctx_id, uint32_t *block, int ndw)

   gdctx = dec_ctx[ctx_id];

-   bret = vrend_hw_switch_context(gdctx->grctx, TRUE);
-   if (bret == FALSE)
+   bret = vrend_hw_switch_context(gdctx->grctx, true);
+   if (bret == false)
      return EINVAL;

   gdctx->ds->buf = block;
@ -1218,7 +1218,7 @@ void vrend_decode_reset(bool ctx_0_only)
 {
   int i;

-   vrend_hw_switch_context(dec_ctx[0]->grctx, TRUE);
+   vrend_hw_switch_context(dec_ctx[0]->grctx, true);

   if (ctx_0_only == false) {
     for (i = 1; i < VREND_MAX_CTX; i++) {
--- a/src/vrend_formats.c
+++ b/src/vrend_formats.c
@ -248,7 +248,7 @@ static void vrend_add_formats(struct vrend_format_table *table, int num_entries)
   GLuint tex_id, fb_id;
   for (i = 0; i < num_entries; i++) {
      GLenum status;
-      boolean is_depth = FALSE;
+      bool is_depth = false;
      /**/
      glGenTextures(1, &tex_id);
      glGenFramebuffers(1, &fb_id);
@ -295,7 +295,7 @@ static void vrend_add_formats(struct vrend_format_table *table, int num_entries)
            attachment = GL_DEPTH_STENCIL_ATTACHMENT;
         glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, attachment, GL_TEXTURE_2D, tex_id, 0);

-         is_depth = TRUE;
+         is_depth = true;
         glDrawBuffer(GL_NONE);
      } else {
         glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex_id, 0);
--- a/src/vrend_renderer.c
+++ b/src/vrend_renderer.c
@ -101,14 +101,16 @@ struct global_renderer_state {
   struct vrend_context *current_hw_ctx;
   struct list_head waiting_query_list;

-   boolean have_mesa_invert;
-   boolean have_samplers;
-   boolean have_robustness;
-   boolean have_multisample;
-   boolean have_ms_scaled_blit;
-   boolean have_nv_prim_restart, have_gl_prim_restart, have_bit_encoding;
-
-   boolean have_vertex_attrib_binding;
+   bool have_mesa_invert;
+   bool have_samplers;
+   bool have_robustness;
+   bool have_multisample;
+   bool have_ms_scaled_blit;
+   bool have_nv_prim_restart;
+   bool have_gl_prim_restart;
+   bool have_bit_encoding;
+   bool have_vertex_attrib_binding;
+
   uint32_t max_uniform_blocks;
   struct list_head active_ctx_list;
 };
@ -120,7 +122,7 @@ struct vrend_linked_shader_program {
  struct list_head sl[PIPE_SHADER_TYPES];
  GLuint id;

-  boolean dual_src_linked;
+  bool dual_src_linked;
  struct vrend_shader *ss[PIPE_SHADER_TYPES];

  uint32_t samplers_used_mask[PIPE_SHADER_TYPES];
@ -307,7 +309,7 @@ struct vrend_sub_context {
   uint32_t const_bufs_used_mask[PIPE_SHADER_TYPES];

   int num_sampler_states[PIPE_SHADER_TYPES];
-   boolean sampler_state_dirty;
+   bool sampler_state_dirty;

   uint32_t fb_id;
   int nr_cbufs, old_nr_cbufs;
@ -317,13 +319,13 @@ struct vrend_sub_context {
   struct vrend_viewport vps[PIPE_MAX_VIEWPORTS];
   float depth_transform, depth_scale;
   /* viewport is negative */
-   GLboolean viewport_is_negative;
+   bool viewport_is_negative;
   /* this is set if the contents of the FBO look upside down when viewed
      with 0,0 as the bottom corner */
-   GLboolean inverted_fbo_content;
+   bool inverted_fbo_content;
   uint32_t scissor_state_dirty;
   uint32_t viewport_state_dirty;
-   boolean stencil_state_dirty;
+   bool stencil_state_dirty;
   uint32_t fb_height;

   struct pipe_scissor_state ss[PIPE_MAX_VIEWPORTS];
@ -340,10 +342,11 @@ struct vrend_sub_context {

   struct pipe_clip_state ucp_state;

-   GLboolean blend_enabled;
-   GLboolean depth_test_enabled;
-   GLboolean alpha_test_enabled;
-   GLboolean stencil_test_enabled;
+   bool blend_enabled;
+   bool depth_test_enabled;
+   bool alpha_test_enabled;
+   bool stencil_test_enabled;
+
   GLuint program_id;

   struct pipe_rasterizer_state hw_rs_state;
@ -367,15 +370,14 @@ struct vrend_context {
   struct util_hash_table *res_hash;

   struct list_head active_nontimer_query_list;
-   boolean query_on_hw;

   /* has this ctx gotten an error? */
-   boolean in_error;
+   bool in_error;
   enum virgl_ctx_errors last_error;

-   boolean ctx_switch_pending;
+   bool ctx_switch_pending;

-   boolean pstip_inited;
+   bool pstip_inited;
   GLuint pstipple_tex_id;

   struct vrend_shader_cfg shader_cfg;
@ -393,16 +395,16 @@ void vrend_update_stencil_state(struct vrend_context *ctx);

 static struct vrend_format_table tex_conv_table[VIRGL_FORMAT_MAX];

-static inline boolean vrend_format_can_sample(enum virgl_formats format)
+static inline bool vrend_format_can_sample(enum virgl_formats format)
 {
   return tex_conv_table[format].bindings & VREND_BIND_SAMPLER;
 }
-static inline boolean vrend_format_can_render(enum virgl_formats format)
+static inline bool vrend_format_can_render(enum virgl_formats format)
 {
   return tex_conv_table[format].bindings & VREND_BIND_RENDER;
 }

-static inline boolean vrend_format_is_ds(enum virgl_formats format)
+static inline bool vrend_format_is_ds(enum virgl_formats format)
 {
   return tex_conv_table[format].bindings & VREND_BIND_DEPTHSTENCIL;
 }
@ -426,7 +428,7 @@ static const char *vrend_ctx_error_strings[] = { "None", "Unknown", "Illegal sha

 static void __report_context_error(const char *fname, struct vrend_context *ctx, enum virgl_ctx_errors error, uint32_t value)
 {
-   ctx->in_error = TRUE;
+   ctx->in_error = true;
   ctx->last_error = error;
   fprintf(stderr,"%s: context error reported %d \"%s\" %s %d\n", fname, ctx->ctx_id, ctx->debug_name, vrend_ctx_error_strings[error], value);
 }
@ -451,7 +453,7 @@ static void __report_core_warn(const char *fname, struct vrend_context *ctx, enu
   fprintf(stderr,"%s: core profile violation reported %d \"%s\" %s %d\n", fname, ctx->ctx_id, ctx->debug_name, vrend_core_profile_warn_strings[error], value);
 }
 #define report_core_warn(ctx, error, value) __report_core_warn(__func__, ctx, error, value)
-static inline boolean should_invert_viewport(struct vrend_context *ctx)
+static inline bool should_invert_viewport(struct vrend_context *ctx)
 {
   /* if we have a negative viewport then gallium wanted to invert it,
      however since we are rendering to GL FBOs we need to invert it
@ -539,7 +541,7 @@ static void vrend_destroy_shader_selector(struct vrend_shader_selector *sel)
   free(sel);
 }

-static boolean vrend_compile_shader(struct vrend_context *ctx,
+static bool vrend_compile_shader(struct vrend_context *ctx,
                                struct vrend_shader *shader)
 {
   GLint param;
@ -553,9 +555,9 @@ static boolean vrend_compile_shader(struct vrend_context *ctx,
      report_context_error(ctx, VIRGL_ERROR_CTX_ILLEGAL_SHADER, 0);
      fprintf(stderr,"shader failed to compile\n%s\n", infolog);
      fprintf(stderr,"GLSL:\n%s\n", shader->glsl_prog);
-      return FALSE;
+      return false;
   }
-   return TRUE;
+   return true;
 }

 static inline void
@ -586,7 +588,7 @@ vrend_insert_format_swizzle(int override_format, struct vrend_format_table *entr
     tex_conv_table[override_format].swizzle[i] = swizzle[i];
 }

-static boolean vrend_is_timer_query(GLenum gltype)
+static bool vrend_is_timer_query(GLenum gltype)
 {
 	return gltype == GL_TIMESTAMP ||
               gltype == GL_TIME_ELAPSED;
@ -613,7 +615,7 @@ static void vrend_init_pstipple_texture(struct vrend_context *ctx)
   ctx->pstip_inited = true;
 }

-static void vrend_blend_enable(struct vrend_context *ctx, GLboolean blend_enable)
+static void vrend_blend_enable(struct vrend_context *ctx, bool blend_enable)
 {
   if (ctx->sub->blend_enabled != blend_enable) {
      ctx->sub->blend_enabled = blend_enable;
@ -624,7 +626,7 @@ static void vrend_blend_enable(struct vrend_context *ctx, GLboolean blend_enable
   }
 }

-static void vrend_depth_test_enable(struct vrend_context *ctx, GLboolean depth_test_enable)
+static void vrend_depth_test_enable(struct vrend_context *ctx, bool depth_test_enable)
 {
   if (ctx->sub->depth_test_enabled != depth_test_enable) {
      ctx->sub->depth_test_enabled = depth_test_enable;
@ -635,8 +637,7 @@ static void vrend_depth_test_enable(struct vrend_context *ctx, GLboolean depth_t
   }
 }

-static void vrend_alpha_test_enable(struct vrend_context *ctx,
-                                    GLboolean alpha_test_enable)
+static void vrend_alpha_test_enable(struct vrend_context *ctx, bool alpha_test_enable)
 {
   if (vrend_state.use_core_profile) {
       /* handled in shaders */
@ -650,8 +651,7 @@ static void vrend_alpha_test_enable(struct vrend_context *ctx,
         glDisable(GL_ALPHA_TEST);
   }
 }
-static void vrend_stencil_test_enable(struct vrend_context *ctx,
-				      GLboolean stencil_test_enable)
+static void vrend_stencil_test_enable(struct vrend_context *ctx, bool stencil_test_enable)
 {
   if (ctx->sub->stencil_test_enabled != stencil_test_enable) {
      ctx->sub->stencil_test_enabled = stencil_test_enable;
@ -785,7 +785,7 @@ static struct vrend_linked_shader_program *add_shader_program(struct vrend_conte
  /* need to rewrite VS code to add interpolation params */
  if ((gs && gs->compiled_fs_id != fs->id) ||
      (!gs && vs->compiled_fs_id != fs->id)) {
-     boolean ret;
+     bool ret;

     if (gs)
        vrend_patch_vertex_shader_interpolants(gs->glsl_prog,
@ -796,7 +796,7 @@ static struct vrend_linked_shader_program *add_shader_program(struct vrend_conte
                                               &vs->sel->sinfo,
                                               &fs->sel->sinfo, false, fs->key.flatshade);
     ret = vrend_compile_shader(ctx, gs ? gs : vs);
-     if (ret == FALSE) {
+     if (ret == false) {
        glDeleteShader(gs ? gs->id : vs->id);
        free(sprog);
        return NULL;
@ -962,7 +962,7 @@ static struct vrend_linked_shader_program *add_shader_program(struct vrend_conte
 }

 static struct vrend_linked_shader_program *lookup_shader_program(struct vrend_context *ctx,
-                                                                 GLuint vs_id, GLuint fs_id, GLuint gs_id, GLboolean dual_src)
+                                                                 GLuint vs_id, GLuint fs_id, GLuint gs_id, bool dual_src)
 {
  struct vrend_linked_shader_program *ent;
  LIST_FOR_EACH_ENTRY(ent, &ctx->sub->programs, head) {
@ -1425,7 +1425,7 @@ void vrend_set_framebuffer_state(struct vrend_context *ctx,
   int old_num;
   GLenum status;
   GLint new_height = -1;
-   boolean new_ibf = GL_FALSE;
+   bool new_ibf = false;

   glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, ctx->sub->fb_id);

@ -1473,10 +1473,10 @@ void vrend_set_framebuffer_state(struct vrend_context *ctx,
   /* find a buffer to set fb_height from */
   if (ctx->sub->nr_cbufs == 0 && !ctx->sub->zsurf) {
       new_height = 0;
-       new_ibf = FALSE;
+       new_ibf = false;
   } else if (ctx->sub->nr_cbufs == 0) {
       new_height = u_minify(ctx->sub->zsurf->texture->base.height0, ctx->sub->zsurf->val0);
-       new_ibf = ctx->sub->zsurf->texture->y_0_top ? TRUE : FALSE;
+       new_ibf = ctx->sub->zsurf->texture->y_0_top ? true : false;
   } 
   else {
       surf = NULL;
@ -1488,7 +1488,7 @@ void vrend_set_framebuffer_state(struct vrend_context *ctx,
       }
       assert(surf);
       new_height = u_minify(surf->texture->base.height0, surf->val0);
-       new_ibf = surf->texture->y_0_top ? TRUE : FALSE;
+       new_ibf = surf->texture->y_0_top ? true : false;
   }

   if (new_height != -1) {
@ -1522,7 +1522,7 @@ void vrend_set_viewport_states(struct vrend_context *ctx,
   GLint x, y;
   GLsizei width, height;
   GLclampd near_val, far_val;
-   GLboolean viewport_is_negative = (state[0].scale[1] < 0) ? GL_TRUE : GL_FALSE;
+   bool viewport_is_negative = (state[0].scale[1] < 0) ? true : false;
   GLfloat abs_s1 = fabsf(state->scale[1]);
   int i, idx;

@ -1697,7 +1697,7 @@ void vrend_set_constants(struct vrend_context *ctx,
   int i;

   consts = &ctx->sub->consts[shader];
-   ctx->sub->const_dirty[shader] = TRUE;
+   ctx->sub->const_dirty[shader] = true;

   consts->consts = realloc(consts->consts, num_constant * sizeof(float));
   if (!consts->consts)
@ -1873,7 +1873,7 @@ void vrend_set_single_sampler_view(struct vrend_context *ctx,
         }
         if (tex->srgb_decode != view->srgb_decode && util_format_is_srgb(tex->base.base.format)) {
 	    if (vrend_state.have_samplers)
-	       ctx->sub->sampler_state_dirty = TRUE;
+	       ctx->sub->sampler_state_dirty = true;
 	    else {
 	       glTexParameteri(view->texture->target, GL_TEXTURE_SRGB_DECODE_EXT,
 			       view->srgb_decode);
@ -1921,7 +1921,7 @@ static inline void vrend_fill_shader_key(struct vrend_context *ctx,
 {
   if (vrend_state.use_core_profile == true) {
      int i;
-      boolean add_alpha_test = true;
+      bool add_alpha_test = true;
      for (i = 0; i < ctx->sub->nr_cbufs; i++) {
         if (!ctx->sub->surf[i])
            continue;
@ -1938,7 +1938,7 @@ static inline void vrend_fill_shader_key(struct vrend_context *ctx,
      key->color_two_side = ctx->sub->rs_state.light_twoside;

      key->clip_plane_enable = ctx->sub->rs_state.clip_plane_enable;
-      key->flatshade = ctx->sub->rs_state.flatshade ? TRUE : FALSE;
+      key->flatshade = ctx->sub->rs_state.flatshade ? true : false;
   } else {
      key->add_alpha_test = 0;
      key->pstipple_tex = 0;
@ -1975,10 +1975,10 @@ static int vrend_shader_create(struct vrend_context *ctx,
   }
   shader->key = key;
   if (1) {//shader->sel->type == PIPE_SHADER_FRAGMENT || shader->sel->type == PIPE_SHADER_GEOMETRY) {
-      boolean ret;
+      bool ret;

      ret = vrend_compile_shader(ctx, shader);
-      if (ret == FALSE) {
+      if (ret == false) {
         glDeleteShader(shader->id);
         free(shader->glsl_prog);
         return -1;
@ -1989,7 +1989,7 @@ static int vrend_shader_create(struct vrend_context *ctx,

 static int vrend_shader_select(struct vrend_context *ctx,
                               struct vrend_shader_selector *sel,
-                               boolean *dirty)
+                               bool *dirty)
 {
   struct vrend_shader_key key;
   struct vrend_shader *shader = NULL;
@ -2462,7 +2462,7 @@ static void vrend_draw_bind_samplers(struct vrend_context *ctx)
      glBindTexture(GL_TEXTURE_2D, ctx->pstipple_tex_id);
      glUniform1i(ctx->sub->prog->fs_stipple_loc, sampler_id);
   }
-   ctx->sub->sampler_state_dirty = FALSE;
+   ctx->sub->sampler_state_dirty = false;
 }

 static void vrend_draw_bind_ubo(struct vrend_context *ctx)
@ -2503,7 +2503,7 @@ void vrend_draw_vbo(struct vrend_context *ctx,
                    uint32_t cso)
 {
   int i;
-   bool new_program = FALSE;
+   bool new_program = false;
   uint32_t shader_type;

   if (ctx->in_error)
@ -2525,8 +2525,8 @@ void vrend_draw_vbo(struct vrend_context *ctx,

   if (ctx->sub->shader_dirty) {
     struct vrend_linked_shader_program *prog;
-     boolean fs_dirty, vs_dirty, gs_dirty;
-     boolean dual_src = util_blend_state_is_dual(&ctx->sub->blend_state, 0);
+     bool fs_dirty, vs_dirty, gs_dirty;
+     bool dual_src = util_blend_state_is_dual(&ctx->sub->blend_state, 0);
     if (!ctx->sub->vs || !ctx->sub->fs) {
        fprintf(stderr,"dropping rendering due to missing shaders: %s\n", ctx->debug_name);
        return;
@ -2548,7 +2548,7 @@ void vrend_draw_vbo(struct vrend_context *ctx,
           return;
     }
     if (ctx->sub->prog != prog) {
-       new_program = TRUE;
+       new_program = true;
       ctx->sub->prog = prog;
     }
   }
@ -2571,7 +2571,7 @@ void vrend_draw_vbo(struct vrend_context *ctx,
            if (ctx->sub->prog->const_locs[shader_type][i] != -1 && ctx->sub->consts[shader_type].consts)
               glUniform4uiv(ctx->sub->prog->const_locs[shader_type][i], 1, &ctx->sub->consts[shader_type].consts[i * 4]);
         }
-         ctx->sub->const_dirty[shader_type] = FALSE;
+         ctx->sub->const_dirty[shader_type] = false;
      }
   }

@ -2585,7 +2585,6 @@ void vrend_draw_vbo(struct vrend_context *ctx,
   }
   glUniform4f(ctx->sub->prog->vs_ws_adjust_loc, 0.0, ctx->sub->viewport_is_negative ? -1.0 : 1.0, ctx->sub->depth_scale, ctx->sub->depth_transform);

-
   if (ctx->sub->rs_state.clip_plane_enable) {
      for (i = 0 ; i < 8; i++) {
         glUniform4fv(ctx->sub->prog->clip_locs[i], 1, (const GLfloat *)&ctx->sub->ucp_state.ucp[i]);
@ -2781,7 +2780,7 @@ translate_stencil_op(GLuint op)
 #undef CASE
 }

-static inline boolean is_dst_blend(int blend_factor)
+static inline bool is_dst_blend(int blend_factor)
 {
   return (blend_factor == PIPE_BLENDFACTOR_DST_ALPHA ||
           blend_factor == PIPE_BLENDFACTOR_INV_DST_ALPHA);
@ -2895,10 +2894,10 @@ static void vrend_hw_emit_blend(struct vrend_context *ctx)
                             translate_blend_factor(state->rt[0].alpha_dst_factor));
         glBlendEquationSeparate(translate_blend_func(state->rt[0].rgb_func),
                                 translate_blend_func(state->rt[0].alpha_func));
-         vrend_blend_enable(ctx, GL_TRUE);
+         vrend_blend_enable(ctx, true);
      } 
      else
-	 vrend_blend_enable(ctx, GL_FALSE);
+	 vrend_blend_enable(ctx, false);

      if (state->rt[0].colormask != ctx->sub->hw_blend_state.rt[0].colormask) {
         int i;
@ -2931,7 +2930,7 @@ void vrend_object_bind_blend(struct vrend_context *ctx,

   if (handle == 0) {
      memset(&ctx->sub->blend_state, 0, sizeof(ctx->sub->blend_state));
-      vrend_blend_enable(ctx, GL_FALSE);
+      vrend_blend_enable(ctx, false);
      return;
   }
   state = vrend_object_lookup(ctx->sub->object_hash, handle, VIRGL_OBJECT_BLEND);
@ -2950,21 +2949,21 @@ static void vrend_hw_emit_dsa(struct vrend_context *ctx)
   struct pipe_depth_stencil_alpha_state *state = &ctx->sub->dsa_state;

   if (state->depth.enabled) {
-      vrend_depth_test_enable(ctx, GL_TRUE);
+      vrend_depth_test_enable(ctx, true);
      glDepthFunc(GL_NEVER + state->depth.func);
      if (state->depth.writemask)
         glDepthMask(GL_TRUE);
      else
         glDepthMask(GL_FALSE);
   } else
-      vrend_depth_test_enable(ctx, GL_FALSE);
+      vrend_depth_test_enable(ctx, false);
 
   if (state->alpha.enabled) {
-      vrend_alpha_test_enable(ctx, GL_TRUE);
+      vrend_alpha_test_enable(ctx, true);
      if (!vrend_state.use_core_profile)
         glAlphaFunc(GL_NEVER + state->alpha.func, state->alpha.ref_value);
   } else
-      vrend_alpha_test_enable(ctx, GL_FALSE);
+      vrend_alpha_test_enable(ctx, false);


 }
@ -2976,8 +2975,8 @@ void vrend_object_bind_dsa(struct vrend_context *ctx,
   if (handle == 0) {
      memset(&ctx->sub->dsa_state, 0, sizeof(ctx->sub->dsa_state));
      ctx->sub->dsa = NULL;
-      ctx->sub->stencil_state_dirty = TRUE;
-      ctx->sub->shader_dirty = TRUE;
+      ctx->sub->stencil_state_dirty = true;
+      ctx->sub->shader_dirty = true;
      vrend_hw_emit_dsa(ctx);
      return;
   }
@ -2989,8 +2988,8 @@ void vrend_object_bind_dsa(struct vrend_context *ctx,
   }

   if (ctx->sub->dsa != state) {
-      ctx->sub->stencil_state_dirty = TRUE;
-      ctx->sub->shader_dirty = TRUE;
+      ctx->sub->stencil_state_dirty = true;
+      ctx->sub->shader_dirty = true;
   }
   ctx->sub->dsa_state = *state;
   ctx->sub->dsa = state;
@ -3019,7 +3018,7 @@ void vrend_update_stencil_state(struct vrend_context *ctx)

   if (!state->stencil[1].enabled) {
      if (state->stencil[0].enabled) {
-         vrend_stencil_test_enable(ctx, GL_TRUE);
+         vrend_stencil_test_enable(ctx, true);

         glStencilOp(translate_stencil_op(state->stencil[0].fail_op), 
                     translate_stencil_op(state->stencil[0].zfail_op),
@ -3030,9 +3029,9 @@ void vrend_update_stencil_state(struct vrend_context *ctx)
                       state->stencil[0].valuemask);
         glStencilMask(state->stencil[0].writemask);
      } else
-         vrend_stencil_test_enable(ctx, GL_FALSE);
+         vrend_stencil_test_enable(ctx, false);
   } else {
-      vrend_stencil_test_enable(ctx, GL_TRUE);
+      vrend_stencil_test_enable(ctx, true);

      for (i = 0; i < 2; i++) {
         GLenum face = (i == 1) ? GL_BACK : GL_FRONT;
@ -3047,7 +3046,7 @@ void vrend_update_stencil_state(struct vrend_context *ctx)
         glStencilMaskSeparate(face, state->stencil[i].writemask);
      }
   }
-   ctx->sub->stencil_state_dirty = FALSE;
+   ctx->sub->stencil_state_dirty = false;
 }

 static inline GLenum translate_fill(uint32_t mode)
@ -3251,7 +3250,7 @@ void vrend_object_bind_rasterizer(struct vrend_context *ctx,

   ctx->sub->rs_state = *state;
   ctx->sub->scissor_state_dirty = (1 << 0);
-   ctx->sub->shader_dirty = TRUE;
+   ctx->sub->shader_dirty = true;
   vrend_hw_emit_rs(ctx);
 }

@ -3274,7 +3273,7 @@ void vrend_bind_sampler_states(struct vrend_context *ctx,
      
      ctx->sub->sampler_state[shader_type][i + start_slot] = state;
   }
-   ctx->sub->sampler_state_dirty = TRUE;
+   ctx->sub->sampler_state_dirty = true;
 }


@ -3289,7 +3288,7 @@ static void vrend_apply_sampler_state(struct vrend_context *ctx,
   struct vrend_texture *tex = (struct vrend_texture *)res;
   struct vrend_sampler_state *vstate = ctx->sub->sampler_state[shader_type][id];
   struct pipe_sampler_state *state = &vstate->base;
-   bool set_all = FALSE;
+   bool set_all = false;
   GLenum target = tex->base.target;

   if (!state) {
@ -3314,7 +3313,7 @@ static void vrend_apply_sampler_state(struct vrend_context *ctx,
   }

   if (tex->state.max_lod == -1)
-      set_all = TRUE;
+      set_all = true;

   if (tex->state.wrap_s != state->wrap_s || set_all)
      glTexParameteri(target, GL_TEXTURE_WRAP_S, convert_wrap(state->wrap_s));
@ -3412,27 +3411,27 @@ void vrend_renderer_init(struct vrend_if_cbs *cbs)
   }

   if (epoxy_has_gl_extension("GL_ARB_robustness"))
-      vrend_state.have_robustness = TRUE;
+      vrend_state.have_robustness = true;
   else
      fprintf(stderr,"WARNING: running without ARB robustness in place may crash\n");

   if (epoxy_has_gl_extension("GL_MESA_pack_invert"))
-      vrend_state.have_mesa_invert = TRUE;
+      vrend_state.have_mesa_invert = true;
   if (gl_ver >= 43 || epoxy_has_gl_extension("GL_ARB_vertex_attrib_binding"))
-      vrend_state.have_vertex_attrib_binding = TRUE;
+      vrend_state.have_vertex_attrib_binding = true;
   if (gl_ver >= 33 || epoxy_has_gl_extension("GL_ARB_sampler_objects"))
-      vrend_state.have_samplers = TRUE;
+      vrend_state.have_samplers = true;
   if (gl_ver >= 33 || epoxy_has_gl_extension("GL_ARB_shader_bit_encoding"))
-      vrend_state.have_bit_encoding = TRUE;
+      vrend_state.have_bit_encoding = true;
   if (gl_ver >= 31)
-      vrend_state.have_gl_prim_restart = TRUE;
+      vrend_state.have_gl_prim_restart = true;
   else if (epoxy_has_gl_extension("GL_NV_primitive_restart"))
-      vrend_state.have_nv_prim_restart = TRUE;
+      vrend_state.have_nv_prim_restart = true;
   
   if (epoxy_has_gl_extension("GL_EXT_framebuffer_multisample") && epoxy_has_gl_extension("GL_ARB_texture_multisample")) {
      vrend_state.have_multisample = true;
      if (epoxy_has_gl_extension("GL_EXT_framebuffer_multisample_blit_scaled"))
-         vrend_state.have_ms_scaled_blit = TRUE;
+         vrend_state.have_ms_scaled_blit = true;
   }

   /* callbacks for when we are cleaning up the object table */
@ -3717,7 +3716,7 @@ int vrend_renderer_resource_create(struct vrend_renderer_resource_create_args *a
   gr->base.array_size = args->array_size;

   if (args->flags & VIRGL_RESOURCE_Y_0_TOP)
-      gr->y_0_top = TRUE;
+      gr->y_0_top = true;

   pipe_reference_init(&gr->base.reference, 1);

@ -3785,11 +3784,11 @@ int vrend_renderer_resource_create(struct vrend_renderer_resource_create_args *a
         if (gr->target == GL_TEXTURE_2D_MULTISAMPLE) {
            glTexImage2DMultisample(gr->target, args->nr_samples,
                                    internalformat, args->width, args->height,
-                                    TRUE);
+                                    GL_TRUE);
         } else {
            glTexImage3DMultisample(gr->target, args->nr_samples,
                                    internalformat, args->width, args->height, args->array_size,
-                                    TRUE);
+                                    GL_TRUE);
         }

      } else if (gr->target == GL_TEXTURE_CUBE_MAP) {
@ -3844,9 +3843,6 @@ int vrend_renderer_resource_create(struct vrend_renderer_resource_create_args *a

 void vrend_renderer_resource_destroy(struct vrend_resource *res, bool remove)
 {
-//   if (res->scannedout) TODO
-//      (*vrend_clicbs->scanout_resource_info)(0, res->id, 0, 0, 0, 0, 0);
-
   if (res->readback_fb_id)
      glDeleteFramebuffers(1, &res->readback_fb_id);

@ -4094,7 +4090,7 @@ static int vrend_renderer_transfer_write_iov(struct vrend_context *ctx,
      int need_temp = 0;
      int elsize = util_format_get_blocksize(res->base.format);
      int x = 0, y = 0;
-      boolean compressed;
+      bool compressed;
      bool invert = false;
      float depth_scale;
      GLuint send_size = 0;
@ -4168,10 +4164,10 @@ static int vrend_renderer_transfer_write_iov(struct vrend_context *ctx,
            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, res->readback_fb_id);
         }
         glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
-         vrend_blend_enable(ctx, GL_FALSE);
-         vrend_depth_test_enable(ctx, GL_FALSE);
-         vrend_alpha_test_enable(ctx, GL_FALSE);
-         vrend_stencil_test_enable(ctx, GL_FALSE);
+         vrend_blend_enable(ctx, false);
+         vrend_depth_test_enable(ctx, false);
+         vrend_alpha_test_enable(ctx, false);
+         vrend_stencil_test_enable(ctx, false);
         glPixelZoom(1.0f, res->y_0_top ? -1.0f : 1.0f);
         glWindowPos2i(info->box->x, res->y_0_top ? res->base.height0 - info->box->y : info->box->y);
         glDrawPixels(info->box->width, info->box->height, glformat, gltype,
@ -4347,7 +4343,7 @@ static int vrend_transfer_send_readpixels(struct vrend_context *ctx,
   int need_temp = 0;
   GLuint fb_id;
   void *data;
-   boolean actually_invert, separate_invert = FALSE;
+   bool actually_invert, separate_invert = false;
   GLenum format, type;
   GLint y1;
   uint32_t send_size = 0;
@ -4364,7 +4360,7 @@ static int vrend_transfer_send_readpixels(struct vrend_context *ctx,
   actually_invert = res->y_0_top;

   if (actually_invert && !vrend_state.have_mesa_invert)
-      separate_invert = TRUE;
+      separate_invert = true;

   if (num_iovs > 1 || separate_invert)
      need_temp = 1;
@ -4485,7 +4481,7 @@ static int vrend_renderer_transfer_send_iov(struct vrend_context *ctx,
         vrend_transfer_write_return(data, send_size, info->offset, iov, num_iovs);
      glUnmapBuffer(res->target);
   } else {
-      boolean can_readpixels = TRUE;
+      bool can_readpixels = true;

      can_readpixels = vrend_format_can_render(res->base.format) || vrend_format_is_ds(res->base.format);

@ -4547,7 +4543,7 @@ int vrend_renderer_transfer_iov(const struct vrend_transfer_info *info,
   if (!check_iov_bounds(res, info, iov, num_iovs))
      return EINVAL;

-   vrend_hw_switch_context(vrend_lookup_renderer_ctx(0), TRUE);
+   vrend_hw_switch_context(vrend_lookup_renderer_ctx(0), true);

   if (transfer_mode == VREND_TRANSFER_WRITE)
      return vrend_renderer_transfer_write_iov(ctx, res, iov, num_iovs,
@ -4590,7 +4586,7 @@ void vrend_set_stencil_ref(struct vrend_context *ctx,
       ctx->sub->stencil_refs[1] != ref->ref_value[1]) {
      ctx->sub->stencil_refs[0] = ref->ref_value[0];
      ctx->sub->stencil_refs[1] = ref->ref_value[1];
-      ctx->sub->stencil_state_dirty = TRUE;
+      ctx->sub->stencil_state_dirty = true;
   }
   
 }
@ -5145,7 +5141,7 @@ void vrend_renderer_check_fences(void)
   vrend_clicbs->write_fence(latest_id);
 }

-static boolean vrend_get_one_query_result(GLuint query_id, bool use_64, uint64_t *result)
+static bool vrend_get_one_query_result(GLuint query_id, bool use_64, uint64_t *result)
 {
   GLint ready;
   GLuint passed;
@ -5154,7 +5150,7 @@ static boolean vrend_get_one_query_result(GLuint query_id, bool use_64, uint64_t
   glGetQueryObjectiv(query_id, GL_QUERY_RESULT_AVAILABLE_ARB, &ready);

   if (!ready)
-      return FALSE;
+      return false;

   if (use_64) {
      glGetQueryObjectui64v(query_id, GL_QUERY_RESULT_ARB, &pass64);
@ -5163,23 +5159,23 @@ static boolean vrend_get_one_query_result(GLuint query_id, bool use_64, uint64_t
      glGetQueryObjectuiv(query_id, GL_QUERY_RESULT_ARB, &passed);
      *result = passed;
   }
-   return TRUE;
+   return true;
 }

-static boolean vrend_check_query(struct vrend_query *query)
+static bool vrend_check_query(struct vrend_query *query)
 {
   uint64_t result;
   struct virgl_host_query_state *state;
-   boolean ret;
+   bool ret;

-   ret = vrend_get_one_query_result(query->id, FALSE, &result);
-   if (ret == FALSE)
-       return FALSE;
+   ret = vrend_get_one_query_result(query->id, false, &result);
+   if (ret == false)
+       return false;

   state = query->res->ptr;
   state->result = result;
   state->query_state = VIRGL_QUERY_STATE_DONE;
-   return TRUE;
+   return true;
 }

 void vrend_renderer_check_queries(void)
@ -5190,34 +5186,34 @@ void vrend_renderer_check_queries(void)
      return;   
   
   LIST_FOR_EACH_ENTRY_SAFE(query, stor, &vrend_state.waiting_query_list, waiting_queries) {
-      vrend_hw_switch_context(vrend_lookup_renderer_ctx(query->ctx_id), TRUE);
-      if (vrend_check_query(query) == TRUE)
+      vrend_hw_switch_context(vrend_lookup_renderer_ctx(query->ctx_id), true);
+      if (vrend_check_query(query))
         list_delinit(&query->waiting_queries);
   }
 }

-boolean vrend_hw_switch_context(struct vrend_context *ctx, boolean now)
+bool vrend_hw_switch_context(struct vrend_context *ctx, bool now)
 {
-   if (ctx == vrend_state.current_ctx && ctx->ctx_switch_pending == FALSE)
-      return TRUE;
+   if (ctx == vrend_state.current_ctx && ctx->ctx_switch_pending == false)
+      return true;

   if (ctx->ctx_id != 0 && ctx->in_error) {
-      return FALSE;
+      return false;
   }

-   ctx->ctx_switch_pending = TRUE;
-   if (now == TRUE) {
+   ctx->ctx_switch_pending = true;
+   if (now == true) {
      vrend_finish_context_switch(ctx);
   }
   vrend_state.current_ctx = ctx;
-   return TRUE;
+   return true;
 }

 static void vrend_finish_context_switch(struct vrend_context *ctx)
 {
-   if (ctx->ctx_switch_pending == FALSE)
+   if (ctx->ctx_switch_pending == false)
      return;
-   ctx->ctx_switch_pending = FALSE;
+   ctx->ctx_switch_pending = false;

   if (vrend_state.current_hw_ctx == ctx)
      return;
@ -5349,20 +5345,20 @@ void vrend_get_query_result(struct vrend_context *ctx, uint32_t handle,
                            uint32_t wait)
 {
   struct vrend_query *q;
-   boolean ret;
+   bool ret;

   q = vrend_object_lookup(ctx->sub->object_hash, handle, VIRGL_OBJECT_QUERY);
   if (!q)
      return;

   ret = vrend_check_query(q);
-   if (ret == FALSE)
+   if (ret == false)
      list_addtail(&q->waiting_queries, &vrend_state.waiting_query_list);
 }

 void vrend_render_condition(struct vrend_context *ctx,
                            uint32_t handle,
-                            boolean condtion,
+                            bool condition,
                            uint mode)
 {
   struct vrend_query *q;
@ -5684,7 +5680,7 @@ void vrend_renderer_force_ctx_0(void)
   struct vrend_context *ctx0 = vrend_lookup_renderer_ctx(0);
   vrend_state.current_ctx = NULL;
   vrend_state.current_hw_ctx = NULL;
-   vrend_hw_switch_context(ctx0, TRUE);
+   vrend_hw_switch_context(ctx0, true);
   vrend_clicbs->make_current(0, ctx0->sub->gl_context);
 }

--- a/src/vrend_renderer.h
+++ b/src/vrend_renderer.h
@ -56,9 +56,8 @@ struct vrend_resource {

   struct iovec *iov;
   uint32_t num_iovs;
-   boolean y_0_top;
+   bool y_0_top;

-   boolean scannedout;
   GLuint tbo_tex_id;/* tbos have two ids to track */
 };

@ -302,7 +301,7 @@ int vrend_renderer_create_fence(int client_fence_id, uint32_t ctx_id);
 void vrend_renderer_check_fences(void);
 void vrend_renderer_check_queries(void);

-boolean vrend_hw_switch_context(struct vrend_context *ctx, boolean now);
+bool vrend_hw_switch_context(struct vrend_context *ctx, bool now);
 uint32_t vrend_renderer_object_insert(struct vrend_context *ctx, void *data,
                                 uint32_t size, uint32_t handle, enum virgl_object_type type);
 void vrend_renderer_object_destroy(struct vrend_context *ctx, uint32_t handle);
@ -317,7 +316,7 @@ void vrend_get_query_result(struct vrend_context *ctx, uint32_t handle,
                            uint32_t wait);
 void vrend_render_condition(struct vrend_context *ctx,
                            uint32_t handle,
-                            boolean condtion,
+                            bool condtion,
                            uint mode);
 void *vrend_renderer_get_cursor_contents(uint32_t res_handle, uint32_t *width, uint32_t *height);
 void vrend_bind_va(GLuint vaoid);
--- a/src/vrend_shader.c
+++ b/src/vrend_shader.c
@ -50,13 +50,13 @@ struct vrend_shader_io {
   unsigned		done;
   int			sid;
   unsigned		interpolate;
-   boolean                 centroid;
+   bool                 centroid;
   unsigned first;
-   boolean glsl_predefined_no_emit;
-   boolean glsl_no_index;
-   boolean glsl_gl_in;
-   boolean override_no_wm;
-   boolean is_int;
+   bool glsl_predefined_no_emit;
+   bool glsl_no_index;
+   bool glsl_gl_in;
+   bool override_no_wm;
+   bool is_int;
   char glsl_name[64];
 };

@ -117,14 +117,14 @@ struct dump_ctx {
   /* create a shader with lower left if upper left is primary variant
      or vice versa */
   uint32_t shadow_samp_mask;
-   boolean write_all_cbufs;
+   bool write_all_cbufs;
   int fs_coord_origin, fs_pixel_center;

   int gs_in_prim, gs_out_prim, gs_max_out_verts;

   struct vrend_shader_key *key;
-   boolean has_ints;
-   boolean has_instanceid;
+   bool has_ints;
+   bool has_instanceid;
   int indent_level;
   int num_in_clip_dist;
   int num_clip_dist;
@ -173,17 +173,17 @@ static inline int gs_input_prim_to_size(int prim)
   };
 }

-static inline boolean fs_emit_layout(struct dump_ctx *ctx)
+static inline bool fs_emit_layout(struct dump_ctx *ctx)
 {
   if (ctx->fs_pixel_center)
-      return TRUE;
+      return true;
   /* if coord origin is 0 and invert is 0 - emit origin_upper_left,
      if coord_origin is 0 and invert is 1 - emit nothing (lower)
      if coord origin is 1 and invert is 0 - emit nothing (lower)
      if coord_origin is 1 and invert is 1 - emit origin upper left */
   if (!(ctx->fs_coord_origin ^ ctx->key->invert_fs_origin))
-       return TRUE;
-   return FALSE;
+       return true;
+   return false;
 }

 static char *strcat_realloc(char *str, const char *catstr)
@ -218,10 +218,10 @@ iter_declaration(struct tgsi_iterate_context *iter,
      ctx->inputs[i].sid = decl->Semantic.Index;
      ctx->inputs[i].interpolate = decl->Interp.Interpolate;
      ctx->inputs[i].first = decl->Range.First;
-      ctx->inputs[i].glsl_predefined_no_emit = FALSE;
-      ctx->inputs[i].glsl_no_index = FALSE;
-      ctx->inputs[i].override_no_wm = FALSE;
-      ctx->inputs[i].glsl_gl_in = FALSE;
+      ctx->inputs[i].glsl_predefined_no_emit = false;
+      ctx->inputs[i].glsl_no_index = false;
+      ctx->inputs[i].override_no_wm = false;
+      ctx->inputs[i].glsl_gl_in = false;

      switch (ctx->inputs[i].name) {
      case TGSI_SEMANTIC_COLOR:
@ -233,7 +233,7 @@ iter_declaration(struct tgsi_iterate_context *iter,
                  name_prefix = "gl_SecondaryColor";
               else
                  fprintf(stderr, "got illegal color semantic index %d\n", decl->Semantic.Index);
-               ctx->inputs[i].glsl_no_index = TRUE;
+               ctx->inputs[i].glsl_no_index = true;
            } else {
               if (ctx->key->color_two_side) {
                  int j = ctx->num_inputs++;
@ -241,9 +241,9 @@ iter_declaration(struct tgsi_iterate_context *iter,
                  ctx->inputs[j].sid = decl->Semantic.Index;
                  ctx->inputs[j].interpolate = decl->Interp.Interpolate;
                  ctx->inputs[j].first = decl->Range.First;
-                  ctx->inputs[j].glsl_predefined_no_emit = FALSE;
-                  ctx->inputs[j].glsl_no_index = FALSE;
-                  ctx->inputs[j].override_no_wm = FALSE;
+                  ctx->inputs[j].glsl_predefined_no_emit = false;
+                  ctx->inputs[j].glsl_no_index = false;
+                  ctx->inputs[j].override_no_wm = false;

                  ctx->color_in_mask |= (1 << decl->Semantic.Index);

@ -254,9 +254,9 @@ iter_declaration(struct tgsi_iterate_context *iter,
                     ctx->inputs[k].interpolate = 0;
                     ctx->inputs[k].centroid = 0;
                     ctx->inputs[k].first = 0;
-                     ctx->inputs[k].override_no_wm = FALSE;
-                     ctx->inputs[k].glsl_predefined_no_emit = TRUE;
-                     ctx->inputs[k].glsl_no_index = TRUE;
+                     ctx->inputs[k].override_no_wm = false;
+                     ctx->inputs[k].glsl_predefined_no_emit = true;
+                     ctx->inputs[k].glsl_no_index = true;
                  }
                  add_two_side = true;
               }
@ -268,53 +268,53 @@ iter_declaration(struct tgsi_iterate_context *iter,
      case TGSI_SEMANTIC_PRIMID:
         if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
            name_prefix = "gl_PrimitiveIDIn";
-            ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->inputs[i].glsl_no_index = TRUE;
-            ctx->inputs[i].override_no_wm = TRUE;
-            ctx->has_ints = TRUE;
+            ctx->inputs[i].glsl_predefined_no_emit = true;
+            ctx->inputs[i].glsl_no_index = true;
+            ctx->inputs[i].override_no_wm = true;
+            ctx->has_ints = true;
            break;
         } else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
            name_prefix = "gl_PrimitiveID";
-            ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->inputs[i].glsl_no_index = TRUE;
+            ctx->inputs[i].glsl_predefined_no_emit = true;
+            ctx->inputs[i].glsl_no_index = true;
            ctx->glsl_ver_required = 150;
            break;
         }
      case TGSI_SEMANTIC_PSIZE:
         if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
            name_prefix = "gl_PointSize";
-            ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->inputs[i].glsl_no_index = TRUE;
-            ctx->inputs[i].override_no_wm = TRUE;
-            ctx->inputs[i].glsl_gl_in = TRUE;
+            ctx->inputs[i].glsl_predefined_no_emit = true;
+            ctx->inputs[i].glsl_no_index = true;
+            ctx->inputs[i].override_no_wm = true;
+            ctx->inputs[i].glsl_gl_in = true;
            break;
         }
      case TGSI_SEMANTIC_CLIPDIST:
         if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
            name_prefix = "gl_ClipDistance";
-            ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->inputs[i].glsl_no_index = TRUE;
-            ctx->inputs[i].glsl_gl_in = TRUE;
+            ctx->inputs[i].glsl_predefined_no_emit = true;
+            ctx->inputs[i].glsl_no_index = true;
+            ctx->inputs[i].glsl_gl_in = true;
            ctx->num_in_clip_dist += 4;
            break;
         } else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
            name_prefix = "gl_ClipDistance";
-            ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->inputs[i].glsl_no_index = TRUE;
+            ctx->inputs[i].glsl_predefined_no_emit = true;
+            ctx->inputs[i].glsl_no_index = true;
            ctx->num_in_clip_dist += 4;
            break;
         }
      case TGSI_SEMANTIC_POSITION:
         if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
            name_prefix = "gl_Position";
-            ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->inputs[i].glsl_no_index = TRUE;
-            ctx->inputs[i].glsl_gl_in = TRUE;
+            ctx->inputs[i].glsl_predefined_no_emit = true;
+            ctx->inputs[i].glsl_no_index = true;
+            ctx->inputs[i].glsl_gl_in = true;
            break;
         } else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
            name_prefix = "gl_FragCoord";
-            ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->inputs[i].glsl_no_index = TRUE;
+            ctx->inputs[i].glsl_predefined_no_emit = true;
+            ctx->inputs[i].glsl_no_index = true;
            break;
         }
         /* fallthrough for vertex shader */
@ -325,17 +325,17 @@ iter_declaration(struct tgsi_iterate_context *iter,
               return TRUE;
            }
            name_prefix = "gl_FrontFacing";
-            ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->inputs[i].glsl_no_index = TRUE;
-            ctx->front_face_emitted = TRUE;
+            ctx->inputs[i].glsl_predefined_no_emit = true;
+            ctx->inputs[i].glsl_no_index = true;
+            ctx->front_face_emitted = true;
            break;
         }
      case TGSI_SEMANTIC_GENERIC:
         if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
            if (ctx->key->coord_replace & (1 << ctx->inputs[i].sid)) {
               name_prefix = "vec4(gl_PointCoord, 0.0, 1.0)";
-               ctx->inputs[i].glsl_predefined_no_emit = TRUE;
-               ctx->inputs[i].glsl_no_index = TRUE;
+               ctx->inputs[i].glsl_predefined_no_emit = true;
+               ctx->inputs[i].glsl_no_index = true;
               break;
            }
         }
@ -378,10 +378,10 @@ iter_declaration(struct tgsi_iterate_context *iter,
      ctx->outputs[i].sid = decl->Semantic.Index;
      ctx->outputs[i].interpolate = decl->Interp.Interpolate;
      ctx->outputs[i].first = decl->Range.First;
-      ctx->outputs[i].glsl_predefined_no_emit = FALSE;
-      ctx->outputs[i].glsl_no_index = FALSE;
-      ctx->outputs[i].override_no_wm = FALSE;
-      ctx->outputs[i].is_int = FALSE;
+      ctx->outputs[i].glsl_predefined_no_emit = false;
+      ctx->outputs[i].glsl_no_index = false;
+      ctx->outputs[i].override_no_wm = false;
+      ctx->outputs[i].is_int = false;

      switch (ctx->outputs[i].name) {
      case TGSI_SEMANTIC_POSITION:
@ -390,21 +390,21 @@ iter_declaration(struct tgsi_iterate_context *iter,
            if (ctx->outputs[i].first > 0)
               fprintf(stderr,"Illegal position input\n");
            name_prefix = "gl_Position";
-            ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->outputs[i].glsl_no_index = TRUE;
+            ctx->outputs[i].glsl_predefined_no_emit = true;
+            ctx->outputs[i].glsl_no_index = true;
         } else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
            if (ctx->outputs[i].first > 0)
               fprintf(stderr,"Illegal position input\n");
            name_prefix = "gl_FragDepth";
-            ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->outputs[i].glsl_no_index = TRUE;
-            ctx->outputs[i].override_no_wm = TRUE;
+            ctx->outputs[i].glsl_predefined_no_emit = true;
+            ctx->outputs[i].glsl_no_index = true;
+            ctx->outputs[i].override_no_wm = true;
         }
         break;
      case TGSI_SEMANTIC_CLIPDIST:
         name_prefix = "gl_ClipDistance";
-         ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-         ctx->outputs[i].glsl_no_index = TRUE;
+         ctx->outputs[i].glsl_predefined_no_emit = true;
+         ctx->outputs[i].glsl_no_index = true;
         ctx->num_clip_dist += 4;
         if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX &&
             ctx->key->gs_present)
@ -412,9 +412,9 @@ iter_declaration(struct tgsi_iterate_context *iter,
         break;
      case TGSI_SEMANTIC_CLIPVERTEX:
         name_prefix = "gl_ClipVertex";
-         ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-         ctx->outputs[i].glsl_no_index = TRUE;
-         ctx->outputs[i].override_no_wm = TRUE;
+         ctx->outputs[i].glsl_predefined_no_emit = true;
+         ctx->outputs[i].glsl_no_index = true;
+         ctx->outputs[i].override_no_wm = true;
         if (ctx->glsl_ver_required >= 140)
            ctx->has_clipvertex = true;
         break;
@ -422,7 +422,7 @@ iter_declaration(struct tgsi_iterate_context *iter,
      case TGSI_SEMANTIC_COLOR:
         if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) {
            if (ctx->glsl_ver_required < 140) {
-               ctx->outputs[i].glsl_no_index = TRUE;
+               ctx->outputs[i].glsl_no_index = true;
               if (ctx->outputs[i].sid == 0)
                  name_prefix = "gl_FrontColor";
               else if (ctx->outputs[i].sid == 1)
@ -435,7 +435,7 @@ iter_declaration(struct tgsi_iterate_context *iter,
      case TGSI_SEMANTIC_BCOLOR:
         if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) {
            if (ctx->glsl_ver_required < 140) {
-               ctx->outputs[i].glsl_no_index = TRUE;
+               ctx->outputs[i].glsl_no_index = true;
               if (ctx->outputs[i].sid == 0)
                  name_prefix = "gl_BackColor";
               else if (ctx->outputs[i].sid == 1)
@ -447,42 +447,42 @@ iter_declaration(struct tgsi_iterate_context *iter,
         }
      case TGSI_SEMANTIC_PSIZE:
         if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) {
-            ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->outputs[i].glsl_no_index = TRUE;
-            ctx->outputs[i].override_no_wm = TRUE;
+            ctx->outputs[i].glsl_predefined_no_emit = true;
+            ctx->outputs[i].glsl_no_index = true;
+            ctx->outputs[i].override_no_wm = true;
            name_prefix = "gl_PointSize";
            break;
         } else if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
-            ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->outputs[i].glsl_no_index = TRUE;
-            ctx->outputs[i].override_no_wm = TRUE;
+            ctx->outputs[i].glsl_predefined_no_emit = true;
+            ctx->outputs[i].glsl_no_index = true;
+            ctx->outputs[i].override_no_wm = true;
            name_prefix = "gl_PointSize";
            break;
         }
      case TGSI_SEMANTIC_LAYER:
         if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
-            ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->outputs[i].glsl_no_index = TRUE;
-            ctx->outputs[i].override_no_wm = TRUE;
-            ctx->outputs[i].is_int = TRUE;
+            ctx->outputs[i].glsl_predefined_no_emit = true;
+            ctx->outputs[i].glsl_no_index = true;
+            ctx->outputs[i].override_no_wm = true;
+            ctx->outputs[i].is_int = true;
            name_prefix = "gl_Layer";
            break;
         }
      case TGSI_SEMANTIC_PRIMID:
         if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
-            ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->outputs[i].glsl_no_index = TRUE;
-            ctx->outputs[i].override_no_wm = TRUE;
-            ctx->outputs[i].is_int = TRUE;
+            ctx->outputs[i].glsl_predefined_no_emit = true;
+            ctx->outputs[i].glsl_no_index = true;
+            ctx->outputs[i].override_no_wm = true;
+            ctx->outputs[i].is_int = true;
            name_prefix = "gl_PrimitiveID";
            break;
         }
      case TGSI_SEMANTIC_VIEWPORT_INDEX:
         if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
-            ctx->outputs[i].glsl_predefined_no_emit = TRUE;
-            ctx->outputs[i].glsl_no_index = TRUE;
-            ctx->outputs[i].override_no_wm = TRUE;
-            ctx->outputs[i].is_int = TRUE;
+            ctx->outputs[i].glsl_predefined_no_emit = true;
+            ctx->outputs[i].glsl_no_index = true;
+            ctx->outputs[i].override_no_wm = true;
+            ctx->outputs[i].is_int = true;
            name_prefix = "gl_ViewportIndex";
 	    if (ctx->glsl_ver_required >= 140)
 	      ctx->has_viewport_idx = true;
@ -553,16 +553,16 @@ iter_declaration(struct tgsi_iterate_context *iter,
      i = ctx->num_system_values++;
      ctx->system_values[i].name = decl->Semantic.Name;
      ctx->system_values[i].sid = decl->Semantic.Index;
-      ctx->system_values[i].glsl_predefined_no_emit = TRUE;
-      ctx->system_values[i].glsl_no_index = TRUE;
-      ctx->system_values[i].override_no_wm = TRUE;
+      ctx->system_values[i].glsl_predefined_no_emit = true;
+      ctx->system_values[i].glsl_no_index = true;
+      ctx->system_values[i].override_no_wm = true;
      ctx->system_values[i].first = decl->Range.First;
      if (decl->Semantic.Name == TGSI_SEMANTIC_INSTANCEID) {
         name_prefix = "gl_InstanceID";
-         ctx->has_instanceid = TRUE;
+         ctx->has_instanceid = true;
      } else if (decl->Semantic.Name == TGSI_SEMANTIC_VERTEXID) {
 	 name_prefix = "gl_VertexID";
-         ctx->has_ints = TRUE;
+         ctx->has_ints = true;
      } else {
         fprintf(stderr, "unsupported system value %d\n", decl->Semantic.Name);
         name_prefix = "unknown";
@ -574,7 +574,6 @@ iter_declaration(struct tgsi_iterate_context *iter,
      break;
   }

-
   return TRUE;
 }

@ -586,7 +585,7 @@ iter_property(struct tgsi_iterate_context *iter,

   if (prop->Property.PropertyName == TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS) {
      if (prop->u[0].Data == 1)
-         ctx->write_all_cbufs = TRUE;
+         ctx->write_all_cbufs = true;
   }

   if (prop->Property.PropertyName == TGSI_PROPERTY_FS_COORD_ORIGIN) {
@ -630,10 +629,10 @@ iter_immediate(
      if (imm->Immediate.DataType == TGSI_IMM_FLOAT32) {
         ctx->imm[first].val[i].f = imm->u[i].Float;
      } else if (imm->Immediate.DataType == TGSI_IMM_UINT32) {
-         ctx->has_ints = TRUE;
+         ctx->has_ints = true;
         ctx->imm[first].val[i].ui  = imm->u[i].Uint;
      } else if (imm->Immediate.DataType == TGSI_IMM_INT32) {
-         ctx->has_ints = TRUE;
+         ctx->has_ints = true;
         ctx->imm[first].val[i].i = imm->u[i].Int;
      } 
   }
@ -1156,7 +1155,7 @@ iter_instruction(struct tgsi_iterate_context *iter,
      ctx->prog_type = iter->processor.Processor;
   if (dtype == TGSI_TYPE_SIGNED || dtype == TGSI_TYPE_UNSIGNED ||
       stype == TGSI_TYPE_SIGNED || stype == TGSI_TYPE_UNSIGNED)
-      ctx->has_ints = TRUE;
+      ctx->has_ints = true;

   if (inst->Instruction.Opcode == TGSI_OPCODE_TXQ) {
      dtypeprefix = "intBitsToFloat";
@ -1329,7 +1328,7 @@ iter_instruction(struct tgsi_iterate_context *iter,
                snprintf(srcs[i], 255, "%s(%s%subo%dcontents[%d]%s)", stypeprefix, prefix, cname, dim, src->Register.Index, swizzle);
          } else {
             const char *csp;
-             ctx->has_ints = TRUE;
+             ctx->has_ints = true;
             if (stype == TGSI_TYPE_FLOAT || stype == TGSI_TYPE_UNTYPED)
                csp = "uintBitsToFloat";
             else if (stype == TGSI_TYPE_SIGNED)
@ -1387,7 +1386,7 @@ iter_instruction(struct tgsi_iterate_context *iter,
            switch (imd->type) {
            case TGSI_IMM_FLOAT32:
               if (isinf(imd->val[idx].f) || isnan(imd->val[idx].f)) {
-                  ctx->has_ints = TRUE;
+                  ctx->has_ints = true;
                  snprintf(temp, 48, "uintBitsToFloat(%uU)", imd->val[idx].ui);
               } else
                  snprintf(temp, 25, "%.8g", imd->val[idx].f);
@ -1910,7 +1909,7 @@ const char *vrend_shader_samplertypeconv(int sampler_type, int *is_shad)
        }
 }

-static const char *get_interp_string(int interpolate, boolean flatshade)
+static const char *get_interp_string(int interpolate, bool flatshade)
 {
   switch (interpolate) {
   case TGSI_INTERPOLATE_LINEAR:
@ -1937,7 +1936,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)

   if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT) {
      if (fs_emit_layout(ctx)) {
-         boolean upper_left = !(ctx->fs_coord_origin ^ ctx->key->invert_fs_origin); 
+         bool upper_left = !(ctx->fs_coord_origin ^ ctx->key->invert_fs_origin); 
         char comma = (upper_left && ctx->fs_pixel_center) ? ',' : ' ';

         snprintf(buf, 255, "layout(%s%c%s) in vec4 gl_FragCoord;\n",
@ -2268,18 +2267,18 @@ static void replace_interp(char *program,
   memcpy(ptr, pstring, strlen(pstring));
 }

-boolean vrend_patch_vertex_shader_interpolants(char *program,
-                                               struct vrend_shader_info *vs_info,
-                                               struct vrend_shader_info *fs_info, bool is_gs, bool flatshade)
+bool vrend_patch_vertex_shader_interpolants(char *program,
+					    struct vrend_shader_info *vs_info,
+					    struct vrend_shader_info *fs_info, bool is_gs, bool flatshade)
 {
   int i;
   const char *pstring;
   char glsl_name[64];
   if (!vs_info || !fs_info)
-      return TRUE;
+      return true;

   if (!fs_info->interpinfo)
-      return TRUE;
+      return true;

   for (i = 0; i < fs_info->num_interps; i++) {
      pstring = get_interp_string(fs_info->interpinfo[i].interpolate, flatshade);
@ -2313,5 +2312,5 @@ boolean vrend_patch_vertex_shader_interpolants(char *program,

   if (vrend_dump_shaders)
      fprintf(stderr,"GLSL: post interp:  %s\n", program);
-   return TRUE;
+   return true;
 }
--- a/src/vrend_shader.h
+++ b/src/vrend_shader.h
@ -53,15 +53,15 @@ struct vrend_shader_info {

 struct vrend_shader_key {
   uint32_t coord_replace;
-   boolean invert_fs_origin;
-   boolean pstipple_tex;
-   boolean add_alpha_test;
-   boolean color_two_side;
+   bool invert_fs_origin;
+   bool pstipple_tex;
+   bool add_alpha_test;
+   bool color_two_side;
   uint8_t alpha_test;
   uint8_t clip_plane_enable;
   float alpha_ref_val;
-   boolean gs_present;
-   boolean flatshade;
+   bool gs_present;
+   bool flatshade;
 };
  
 struct vrend_shader_cfg {
@ -69,10 +69,10 @@ struct vrend_shader_cfg {
   bool use_core_profile;
 };

-boolean vrend_patch_vertex_shader_interpolants(char *program,
-                                               struct vrend_shader_info *vs_info,
-                                               struct vrend_shader_info *fs_info,
-                                               bool is_gs, bool flatshade);
+bool vrend_patch_vertex_shader_interpolants(char *program,
+					    struct vrend_shader_info *vs_info,
+					    struct vrend_shader_info *fs_info,
+					    bool is_gs, bool flatshade);

 char *vrend_convert_shader(struct vrend_shader_cfg *cfg,
                           const struct tgsi_token *tokens,