slang_typeinfo.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

               default:
                  break;
               }
               break;
            case 4:
               switch (base) {
               case SLANG_SPEC_FLOAT:
                  ti->spec.type = SLANG_SPEC_VEC4;
                  break;
               case SLANG_SPEC_INT:
                  ti->spec.type = SLANG_SPEC_IVEC4;
                  break;
               case SLANG_SPEC_BOOL:
                  ti->spec.type = SLANG_SPEC_BVEC4;
                  break;
               default:
                  break;
               }
               break;
            default:
               break;
            }
         }
         slang_typeinfo_destruct(&_ti);
      }
      break;
   case SLANG_OPER_POSTINCREMENT:
   case SLANG_OPER_POSTDECREMENT:
      if (!_slang_typeof_operation_(op->children, space, ti, atoms, log))
         return GL_FALSE;
      ti->can_be_referenced = GL_FALSE;
      ti->is_swizzled = GL_FALSE;
      break;
   default:
      return GL_FALSE;
   }

   return GL_TRUE;
}


/**
 * Lookup a function according to name and parameter count/types.
 */
slang_function *
_slang_locate_function(const slang_function_scope * funcs, slang_atom a_name,
                       slang_operation * args, GLuint num_args,
                       const slang_name_space * space, slang_atom_pool * atoms,
                       slang_info_log *log, GLboolean *error)
{
   slang_typeinfo arg_ti[100];
   GLuint i;

   *error = GL_FALSE;

   /* determine type of each argument */
   assert(num_args < 100);
   for (i = 0; i < num_args; i++) {
      if (!slang_typeinfo_construct(&arg_ti[i]))
         return NULL;
      if (!_slang_typeof_operation_(&args[i], space, &arg_ti[i], atoms, log)) {
         return NULL;
      }
   }

   /* loop over function scopes */
   while (funcs) {

      /* look for function with matching name and argument/param types */
      for (i = 0; i < funcs->num_functions; i++) {
         slang_function *f = &funcs->functions[i];
         const GLuint haveRetValue = _slang_function_has_return_value(f);
         GLuint j;

         if (a_name != f->header.a_name)
            continue;
         if (f->param_count - haveRetValue != num_args)
            continue;

         /* compare parameter / argument types */
         for (j = 0; j < num_args; j++) {
            if (!slang_type_specifier_compatible(&arg_ti[j].spec,
                              &f->parameters->variables[j]->type.specifier)) {
               /* param/arg types don't match */
               break;
            }

            /* "out" and "inout" formal parameter requires the actual
             * argument to be an l-value.
             */
            if (!arg_ti[j].can_be_referenced &&
                (f->parameters->variables[j]->type.qualifier == SLANG_QUAL_OUT ||
                 f->parameters->variables[j]->type.qualifier == SLANG_QUAL_INOUT)) {
               /* param is not an lvalue! */
               *error = GL_TRUE;
               return NULL;
            }
         }

         if (j == num_args) {
            /* name and args match! */
            return f;
         }
      }

      funcs = funcs->outer_scope;
   }

   return NULL;
}


/**
 * Determine if a type is a matrix.
 * \return GL_TRUE if is a matrix, GL_FALSE otherwise.
 */
GLboolean
_slang_type_is_matrix(slang_type_specifier_type ty)
{
   switch (ty) {
   case SLANG_SPEC_MAT2:
   case SLANG_SPEC_MAT3:
   case SLANG_SPEC_MAT4:
   case SLANG_SPEC_MAT23:
   case SLANG_SPEC_MAT32:
   case SLANG_SPEC_MAT24:
   case SLANG_SPEC_MAT42:
   case SLANG_SPEC_MAT34:
   case SLANG_SPEC_MAT43:
      return GL_TRUE;
   default:
      return GL_FALSE;
   }
}


/**
 * Determine if a type is a vector.
 * \return GL_TRUE if is a vector, GL_FALSE otherwise.
 */
GLboolean
_slang_type_is_vector(slang_type_specifier_type ty)
{
   switch (ty) {
   case SLANG_SPEC_VEC2:
   case SLANG_SPEC_VEC3:
   case SLANG_SPEC_VEC4:
   case SLANG_SPEC_IVEC2:
   case SLANG_SPEC_IVEC3:
   case SLANG_SPEC_IVEC4:
   case SLANG_SPEC_BVEC2:
   case SLANG_SPEC_BVEC3:
   case SLANG_SPEC_BVEC4:
      return GL_TRUE;
   default:
      return GL_FALSE;
   }
}


/**
 * Determine if a type is a float, float vector or float matrix.
 * \return GL_TRUE if so, GL_FALSE otherwise
 */
GLboolean
_slang_type_is_float_vec_mat(slang_type_specifier_type ty)
{
   switch (ty) {
   case SLANG_SPEC_FLOAT:
   case SLANG_SPEC_VEC2:
   case SLANG_SPEC_VEC3:
   case SLANG_SPEC_VEC4:
   case SLANG_SPEC_MAT2:
   case SLANG_SPEC_MAT3:
   case SLANG_SPEC_MAT4:
   case SLANG_SPEC_MAT23:
   case SLANG_SPEC_MAT32:
   case SLANG_SPEC_MAT24:
   case SLANG_SPEC_MAT42:
   case SLANG_SPEC_MAT34:
   case SLANG_SPEC_MAT43:
      return GL_TRUE;
   default:
      return GL_FALSE;
   }
}


/**
 * Given a vector type, return the type of the vector's elements.
 * For a matrix, return the type of the columns.
 */
slang_type_specifier_type
_slang_type_base(slang_type_specifier_type ty)
{
   switch (ty) {
   case SLANG_SPEC_FLOAT:
   case SLANG_SPEC_VEC2:
   case SLANG_SPEC_VEC3:
   case SLANG_SPEC_VEC4:
      return SLANG_SPEC_FLOAT;
   case SLANG_SPEC_INT:
   case SLANG_SPEC_IVEC2:
   case SLANG_SPEC_IVEC3:
   case SLANG_SPEC_IVEC4:
      return SLANG_SPEC_INT;
   case SLANG_SPEC_BOOL:
   case SLANG_SPEC_BVEC2:
   case SLANG_SPEC_BVEC3:
   case SLANG_SPEC_BVEC4:
      return SLANG_SPEC_BOOL;
   case SLANG_SPEC_MAT2:
      return SLANG_SPEC_VEC2;
   case SLANG_SPEC_MAT3:
      return SLANG_SPEC_VEC3;
   case SLANG_SPEC_MAT4:
      return SLANG_SPEC_VEC4;
   case SLANG_SPEC_MAT23:
      return SLANG_SPEC_VEC3;
   case SLANG_SPEC_MAT32:
      return SLANG_SPEC_VEC2;
   case SLANG_SPEC_MAT24:
      return SLANG_SPEC_VEC4;
   case SLANG_SPEC_MAT42:
      return SLANG_SPEC_VEC2;
   case SLANG_SPEC_MAT34:
      return SLANG_SPEC_VEC4;
   case SLANG_SPEC_MAT43:
      return SLANG_SPEC_VEC3;
   default:
      return SLANG_SPEC_VOID;
   }
}


/**
 * Return the dimensionality of a vector, or for a matrix, return number
 * of columns.
 */
GLuint
_slang_type_dim(slang_type_specifier_type ty)
{
   switch (ty) {
   case SLANG_SPEC_FLOAT:
   case SLANG_SPEC_INT:
   case SLANG_SPEC_BOOL:
      return 1;
   case SLANG_SPEC_VEC2:
   case SLANG_SPEC_IVEC2:
   case SLANG_SPEC_BVEC2:
   case SLANG_SPEC_MAT2:
      return 2;
   case SLANG_SPEC_VEC3:
   case SLANG_SPEC_IVEC3:
   case SLANG_SPEC_BVEC3:
   case SLANG_SPEC_MAT3:
      return 3;
   case SLANG_SPEC_VEC4:
   case SLANG_SPEC_IVEC4:
   case SLANG_SPEC_BVEC4:
   case SLANG_SPEC_MAT4:
      return 4;

   case SLANG_SPEC_MAT23:
      return 2;
   case SLANG_SPEC_MAT32:
      return 3;
   case SLANG_SPEC_MAT24:
      return 2;
   case SLANG_SPEC_MAT42:
      return 4;
   case SLANG_SPEC_MAT34:
      return 3;
   case SLANG_SPEC_MAT43:
      return 4;

   default:
      return 0;
   }
}


/**
 * Return the GL_* type that corresponds to a SLANG_SPEC_* type.
 */
GLenum
_slang_gltype_from_specifier(const slang_type_specifier *type)
{
   switch (type->type) {
   case SLANG_SPEC_BOOL:
      return GL_BOOL;
   case SLANG_SPEC_BVEC2:
      return GL_BOOL_VEC2;
   case SLANG_SPEC_BVEC3:
      return GL_BOOL_VEC3;
   case SLANG_SPEC_BVEC4:
      return GL_BOOL_VEC4;
   case SLANG_SPEC_INT:
      return GL_INT;
   case SLANG_SPEC_IVEC2:
      return GL_INT_VEC2;
   case SLANG_SPEC_IVEC3:
      return GL_INT_VEC3;
   case SLANG_SPEC_IVEC4:
      return GL_INT_VEC4;
   case SLANG_SPEC_FLOAT:
      return GL_FLOAT;
   case SLANG_SPEC_VEC2:
      return GL_FLOAT_VEC2;
   case SLANG_SPEC_VEC3:
      return GL_FLOAT_VEC3;
   case SLANG_SPEC_VEC4:
      return GL_FLOAT_VEC4;
   case SLANG_SPEC_MAT2:
      return GL_FLOAT_MAT2;
   case SLANG_SPEC_MAT3:
      return GL_FLOAT_MAT3;
   case SLANG_SPEC_MAT4:
      return GL_FLOAT_MAT4;
   case SLANG_SPEC_MAT23:
      return GL_FLOAT_MAT2x3;
   case SLANG_SPEC_MAT32:
      return GL_FLOAT_MAT3x2;
   case SLANG_SPEC_MAT24:
      return GL_FLOAT_MAT2x4;
   case SLANG_SPEC_MAT42:
      return GL_FLOAT_MAT4x2;
   case SLANG_SPEC_MAT34:
      return GL_FLOAT_MAT3x4;
   case SLANG_SPEC_MAT43:
      return GL_FLOAT_MAT4x3;
   case SLANG_SPEC_SAMPLER1D:
      return GL_SAMPLER_1D;
   case SLANG_SPEC_SAMPLER2D:
      return GL_SAMPLER_2D;
   case SLANG_SPEC_SAMPLER3D:
      return GL_SAMPLER_3D;
   case SLANG_SPEC_SAMPLERCUBE:
      return GL_SAMPLER_CUBE;
   case SLANG_SPEC_SAMPLER1DSHADOW:
      return GL_SAMPLER_1D_SHADOW;
   case SLANG_SPEC_SAMPLER2DSHADOW:
      return GL_SAMPLER_2D_SHADOW;
   case SLANG_SPEC_SAMPLER2DRECT:
      return GL_SAMPLER_2D_RECT_ARB;
   case SLANG_SPEC_SAMPLER2DRECTSHADOW:
      return GL_SAMPLER_2D_RECT_SHADOW_ARB;
   case SLANG_SPEC_ARRAY:
      return _slang_gltype_from_specifier(type->_array);
   case SLANG_SPEC_STRUCT:
      /* fall-through */
   default:
      return GL_NONE;
   }
}