static int loadline(lua_State *L)
{
int status;
size_t len;
const char *line;
lua_settop(L, 0);
if (!pushline(L, 1))
return -1; /* no input */
line = lua_tolstring(L, 1, &len);
if (strcmp (line, "exit") == 0)
return -1;
/* try to load the string as an expression */
if (yield_expr(L, 1, line, len) == 0)
return 0;
/* try to load it as a simple Lua chunk */
status = luaL_loadbuffer(L, line, len, "=stdin");
if (incomplete(L, status))
{
for (;;) { /* repeat until gets a complete line */
if (!pushline(L, 0)) /* no more input? */
return -1;
lua_pushliteral(L, "\n"); /* add a new line... */
lua_insert(L, -2); /* ...between the two lines */
lua_concat(L, 3); /* join them */
line = lua_tolstring(L, 1, &len);
status = luaL_loadbuffer(L, line, len, "=stdin");
if (!incomplete(L, status)) break; /* cannot try to add lines? */
}
/* even if previous "load" was successfull we try to load the string as
an expression */
if (yield_expr(L, 1, line, len) == 0)
{
/* remove old eval function */
lua_remove(L, 1);
return 0;
}
}
my_saveline(L, 1);
lua_remove(L, 1); /* remove line */
return status;
}
static int loadline(lua_State *L) {
int status;
lua_settop(L, 0);
if (!pushline(L, 1))
return -1; /* no input */
for (;;) { /* repeat until gets a complete line */
size_t l;
const char *line = lua_tolstring(L, 1, &l);
status = luaL_loadbuffer(L, line, l, "=stdin");
if (!incomplete(L, status))
break; /* cannot try to add lines? */
if (!pushline(L, 0)) /* no more input? */
return -1;
lua_pushliteral(L, "\n"); /* add a new line... */
lua_insert(L, -2); /* ...between the two lines */
lua_concat(L, 3); /* join them */
}
lua_saveline(L, 1);
lua_remove(L, 1); /* remove line */
return status;
}
/*---------------------------------------------------------------------*/
static int
loadline(lua_State *L)
{
TRACE_LUA_FUNC_START();
int status;
lua_settop(L, 0);
if (!pushline(L, 1)) {
TRACE_LUA_FUNC_END();
return -1; /* no input */
}
for (;;) { /* repeat until gets a complete line */
status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
if (!incomplete(L, status)) break; /* cannot try to add lines? */
if (!pushline(L, 0)) {/* no more input? */
TRACE_LUA_FUNC_END();
return -1;
}
lua_pushliteral(L, "\n"); /* add a new line... */
lua_insert(L, -2); /* ...between the two lines */
lua_concat(L, 3); /* join them */
}
TRACE_DEBUG_LOG("%s\n", lua_tostring(L, 1));
TRACE_LUA_FUNC_END();
return status;
}
static int loadline(lua_State *L)
{
int status;
lua_settop(L, 0);
if(!pushline(L, 1))
{
return -1; /* no input */
}
for(;;) /* repeat until gets a complete line */
{
status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
if(!incomplete(L, status))
{
break; /* cannot try to add lines? */
}
if(!pushline(L, 0)) /* no more input? */
{
return -1;
}
lua_pushliteral(L, "\n"); /* add a new line... */
lua_insert(L, -2); /* ...between the two lines */
lua_concat(L, 3); /* join them */
}
lua_remove(L, 1); /* remove line */
return status;
}
void testmain() {
print("struct");
t1();
t2();
t3();
t4();
t5();
t6();
t7();
t8();
t9();
t10();
t11();
t12();
t13();
t14();
unnamed();
assign();
arrow();
incomplete();
bitfield_basic();
bitfield_mix();
bitfield_union();
bitfield_unnamed();
bitfield_initializer();
test_offsetof();
flexible_member();
empty_struct();
}
void announce_bag(size_t x) {
if(_nva==x){
}else{ untested();
incomplete(); //?
}
_s << "\nb " << ++_nva;
}
void lua_engine::periodic_check()
{
osd_lock_acquire(lock);
if (msg.ready == 1) {
lua_settop(m_lua_state, 0);
int status = luaL_loadbuffer(m_lua_state, msg.text.cstr(), strlen(msg.text.cstr()), "=stdin");
if (incomplete(status)==0) /* cannot try to add lines? */
{
if (status == LUA_OK) status = docall(0, LUA_MULTRET);
report(status);
if (status == LUA_OK && lua_gettop(m_lua_state) > 0) /* any result to print? */
{
luaL_checkstack(m_lua_state, LUA_MINSTACK, "too many results to print");
lua_getglobal(m_lua_state, "print");
lua_insert(m_lua_state, 1);
if (lua_pcall(m_lua_state, lua_gettop(m_lua_state) - 1, 0, 0) != LUA_OK)
luai_writestringerror("%s\n", lua_pushfstring(m_lua_state,
"error calling " LUA_QL("print") " (%s)",
lua_tostring(m_lua_state, -1)));
}
}
else
{
status = -1;
}
msg.status = status;
msg.response = msg.text;
msg.text = "";
msg.ready = 0;
msg.done = 1;
}
osd_lock_release(lock);
}
virtual void head(size_t numbags=0, size_t bagsize=0, size_t numvert=0) {
auto ngv=boost::num_vertices(_g);
if(numbags==0 && bagsize==0 && ngv){ incomplete();
// need to cache results... not now.
}else{
}
_s << "s " << _reason << " " << numbags
<< " " << bagsize << " " << ngv;
_num_vertices=numvert;
}
/*
** Read multiple lines until a complete Lua statement
*/
static int multiline (lua_State *L) {
for (;;) { /* repeat until gets a complete statement */
size_t len;
const char *line = lua_tolstring(L, 1, &len); /* get what it has */
int status = luaL_loadbuffer(L, line, len, "=stdin"); /* try it */
if (!incomplete(L, status) || !pushline(L, 0))
return status; /* cannot or should not try to add continuation line */
lua_pushliteral(L, "\n"); /* add newline... */
lua_insert(L, -2); /* ...between the two lines */
lua_concat(L, 3); /* join them */
}
}
static int loadline (lua_State *L) {
int status;
lua_settop(L, 0);
if (!pushline(L, 1))
return -1;
for (;;) {
status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
if (!incomplete(L, status)) break;
if (!pushline(L, 0))
return -1;
lua_pushliteral(L, "\n");
lua_insert(L, -2);
lua_concat(L, 3);
}
lua_saveline(L, 1);
lua_remove(L, 1);
return status;
}
static int load_string (void) {
int status;
lua_settop(L, 0);
if (lua_readline(L, get_prompt(1)) == 0) /* no input? */
return -1;
if (lua_tostring(L, -1)[0] == '=') { /* line starts with `=' ? */
lua_pushfstring(L, "return %s", lua_tostring(L, -1)+1);/* `=' -> `return' */
lua_remove(L, -2); /* remove original line */
}
for (;;) { /* repeat until gets a complete line */
status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
if (!incomplete(status)) break; /* cannot try to add lines? */
if (lua_readline(L, get_prompt(0)) == 0) /* no more input? */
return -1;
lua_concat(L, lua_gettop(L)); /* join lines */
}
lua_saveline(L, lua_tostring(L, 1));
lua_remove(L, 1); /* remove line */
return status;
}
/**
* Set an integer-valued texture parameter
* \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
*/
static GLboolean
set_tex_parameteri(struct gl_context *ctx,
struct gl_texture_object *texObj,
GLenum pname, const GLint *params)
{
switch (pname) {
case GL_TEXTURE_MIN_FILTER:
if (texObj->Sampler.MinFilter == params[0])
return GL_FALSE;
switch (params[0]) {
case GL_NEAREST:
case GL_LINEAR:
incomplete(ctx, texObj);
texObj->Sampler.MinFilter = params[0];
return GL_TRUE;
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_LINEAR:
incomplete(ctx, texObj);
texObj->Sampler.MinFilter = params[0];
return GL_TRUE;
/* fall-through */
default:
goto invalid_param;
}
return GL_FALSE;
case GL_TEXTURE_MAG_FILTER:
if (texObj->Sampler.MagFilter == params[0])
return GL_FALSE;
switch (params[0]) {
case GL_NEAREST:
case GL_LINEAR:
flush(ctx); /* does not effect completeness */
texObj->Sampler.MagFilter = params[0];
return GL_TRUE;
default:
goto invalid_param;
}
return GL_FALSE;
case GL_TEXTURE_WRAP_S:
if (texObj->Sampler.WrapS == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
texObj->Sampler.WrapS = params[0];
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_WRAP_T:
if (texObj->Sampler.WrapT == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
texObj->Sampler.WrapT = params[0];
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_WRAP_R:
if (texObj->Sampler.WrapR == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
texObj->Sampler.WrapR = params[0];
return GL_TRUE;
}
return GL_FALSE;
default:
goto invalid_pname;
}
invalid_pname:
_mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=%s)",
_mesa_lookup_enum_by_nr(pname));
return GL_FALSE;
invalid_param:
_mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(param=%s)",
_mesa_lookup_enum_by_nr(params[0]));
return GL_FALSE;
}
/**
* Set an integer-valued texture parameter
* \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
*/
static GLboolean
set_tex_parameteri(struct gl_context *ctx,
struct gl_texture_object *texObj,
GLenum pname, const GLint *params)
{
switch (pname) {
case GL_TEXTURE_MIN_FILTER:
if (texObj->Sampler.MinFilter == params[0])
return GL_FALSE;
switch (params[0]) {
case GL_NEAREST:
case GL_LINEAR:
incomplete(ctx, texObj);
texObj->Sampler.MinFilter = params[0];
return GL_TRUE;
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_LINEAR:
if (texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
incomplete(ctx, texObj);
texObj->Sampler.MinFilter = params[0];
return GL_TRUE;
}
/* fall-through */
default:
goto invalid_param;
}
return GL_FALSE;
case GL_TEXTURE_MAG_FILTER:
if (texObj->Sampler.MagFilter == params[0])
return GL_FALSE;
switch (params[0]) {
case GL_NEAREST:
case GL_LINEAR:
flush(ctx); /* does not effect completeness */
texObj->Sampler.MagFilter = params[0];
return GL_TRUE;
default:
goto invalid_param;
}
return GL_FALSE;
case GL_TEXTURE_WRAP_S:
if (texObj->Sampler.WrapS == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
texObj->Sampler.WrapS = params[0];
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_WRAP_T:
if (texObj->Sampler.WrapT == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
texObj->Sampler.WrapT = params[0];
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_WRAP_R:
if (texObj->Sampler.WrapR == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
texObj->Sampler.WrapR = params[0];
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_BASE_LEVEL:
if (texObj->BaseLevel == params[0])
return GL_FALSE;
if (params[0] < 0 ||
(texObj->Target == GL_TEXTURE_RECTANGLE_ARB && params[0] != 0)) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glTexParameter(param=%d)", params[0]);
return GL_FALSE;
}
incomplete(ctx, texObj);
texObj->BaseLevel = params[0];
return GL_TRUE;
case GL_TEXTURE_MAX_LEVEL:
if (texObj->MaxLevel == params[0])
return GL_FALSE;
if (params[0] < 0 || texObj->Target == GL_TEXTURE_RECTANGLE_ARB) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glTexParameter(param=%d)", params[0]);
return GL_FALSE;
}
incomplete(ctx, texObj);
texObj->MaxLevel = params[0];
return GL_TRUE;
case GL_GENERATE_MIPMAP_SGIS:
if (texObj->GenerateMipmap != params[0]) {
/* no flush() */
texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_COMPARE_MODE_ARB:
if (ctx->Extensions.ARB_shadow) {
if (texObj->Sampler.CompareMode == params[0])
return GL_FALSE;
if (params[0] == GL_NONE ||
params[0] == GL_COMPARE_R_TO_TEXTURE_ARB) {
flush(ctx);
texObj->Sampler.CompareMode = params[0];
return GL_TRUE;
}
goto invalid_param;
}
goto invalid_pname;
case GL_TEXTURE_COMPARE_FUNC_ARB:
if (ctx->Extensions.ARB_shadow) {
if (texObj->Sampler.CompareFunc == params[0])
return GL_FALSE;
switch (params[0]) {
case GL_LEQUAL:
case GL_GEQUAL:
flush(ctx);
texObj->Sampler.CompareFunc = params[0];
return GL_TRUE;
case GL_EQUAL:
case GL_NOTEQUAL:
case GL_LESS:
case GL_GREATER:
case GL_ALWAYS:
case GL_NEVER:
if (ctx->Extensions.EXT_shadow_funcs) {
flush(ctx);
texObj->Sampler.CompareFunc = params[0];
return GL_TRUE;
}
/* fall-through */
default:
goto invalid_param;
}
}
goto invalid_pname;
case GL_DEPTH_TEXTURE_MODE_ARB:
if (ctx->Extensions.ARB_depth_texture) {
if (texObj->Sampler.DepthMode == params[0])
return GL_FALSE;
if (params[0] == GL_LUMINANCE ||
params[0] == GL_INTENSITY ||
params[0] == GL_ALPHA ||
(ctx->Extensions.ARB_texture_rg && params[0] == GL_RED)) {
flush(ctx);
texObj->Sampler.DepthMode = params[0];
return GL_TRUE;
}
goto invalid_param;
}
goto invalid_pname;
#if FEATURE_OES_draw_texture
case GL_TEXTURE_CROP_RECT_OES:
texObj->CropRect[0] = params[0];
texObj->CropRect[1] = params[1];
texObj->CropRect[2] = params[2];
texObj->CropRect[3] = params[3];
return GL_TRUE;
#endif
case GL_TEXTURE_SWIZZLE_R_EXT:
case GL_TEXTURE_SWIZZLE_G_EXT:
case GL_TEXTURE_SWIZZLE_B_EXT:
case GL_TEXTURE_SWIZZLE_A_EXT:
if (ctx->Extensions.EXT_texture_swizzle) {
const GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
const GLint swz = comp_to_swizzle(params[0]);
if (swz < 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glTexParameter(swizzle 0x%x)", params[0]);
return GL_FALSE;
}
ASSERT(comp < 4);
if (swz >= 0) {
flush(ctx);
texObj->Swizzle[comp] = params[0];
set_swizzle_component(&texObj->_Swizzle, comp, swz);
return GL_TRUE;
}
}
goto invalid_pname;
case GL_TEXTURE_SWIZZLE_RGBA_EXT:
if (ctx->Extensions.EXT_texture_swizzle) {
GLuint comp;
flush(ctx);
for (comp = 0; comp < 4; comp++) {
const GLint swz = comp_to_swizzle(params[comp]);
if (swz >= 0) {
texObj->Swizzle[comp] = params[comp];
set_swizzle_component(&texObj->_Swizzle, comp, swz);
}
else {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glTexParameter(swizzle 0x%x)", params[comp]);
return GL_FALSE;
}
}
return GL_TRUE;
}
goto invalid_pname;
case GL_TEXTURE_SRGB_DECODE_EXT:
if (ctx->Extensions.EXT_texture_sRGB_decode) {
GLenum decode = params[0];
if (decode == GL_DECODE_EXT || decode == GL_SKIP_DECODE_EXT) {
if (texObj->Sampler.sRGBDecode != decode) {
flush(ctx);
texObj->Sampler.sRGBDecode = decode;
_mesa_update_fetch_functions(texObj);
}
return GL_TRUE;
}
}
goto invalid_pname;
case GL_TEXTURE_CUBE_MAP_SEAMLESS:
if (ctx->Extensions.AMD_seamless_cubemap_per_texture) {
GLenum param = params[0];
if (param != GL_TRUE && param != GL_FALSE) {
goto invalid_param;
}
if (param != texObj->Sampler.CubeMapSeamless) {
flush(ctx);
texObj->Sampler.CubeMapSeamless = param;
}
return GL_TRUE;
}
goto invalid_pname;
default:
goto invalid_pname;
}
invalid_pname:
_mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=%s)",
_mesa_lookup_enum_by_nr(pname));
return GL_FALSE;
invalid_param:
_mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(param=%s)",
_mesa_lookup_enum_by_nr(params[0]));
return GL_FALSE;
}
/**
* Examine a texture object to determine if it is complete.
*
* The gl_texture_object::Complete flag will be set to GL_TRUE or GL_FALSE
* accordingly.
*
* \param ctx GL context.
* \param t texture object.
*
* According to the texture target, verifies that each of the mipmaps is
* present and has the expected size.
*/
void
_mesa_test_texobj_completeness( const struct gl_context *ctx,
struct gl_texture_object *t )
{
const GLint baseLevel = t->BaseLevel;
GLint maxLog2 = 0, maxLevels = 0;
t->_Complete = GL_TRUE; /* be optimistic */
/* Detect cases where the application set the base level to an invalid
* value.
*/
if ((baseLevel < 0) || (baseLevel >= MAX_TEXTURE_LEVELS)) {
incomplete(t, "base level = %d is invalid", baseLevel);
return;
}
/* Always need the base level image */
if (!t->Image[0][baseLevel]) {
incomplete(t, "Image[baseLevel=%d] == NULL", baseLevel);
return;
}
/* Check width/height/depth for zero */
if (t->Image[0][baseLevel]->Width == 0 ||
t->Image[0][baseLevel]->Height == 0 ||
t->Image[0][baseLevel]->Depth == 0) {
incomplete(t, "texture width = 0");
return;
}
/* Compute _MaxLevel */
if (t->Target == GL_TEXTURE_1D) {
maxLog2 = t->Image[0][baseLevel]->WidthLog2;
maxLevels = ctx->Const.MaxTextureLevels;
}
else if (t->Target == GL_TEXTURE_2D) {
maxLog2 = MAX2(t->Image[0][baseLevel]->WidthLog2,
t->Image[0][baseLevel]->HeightLog2);
maxLevels = ctx->Const.MaxTextureLevels;
}
else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
maxLog2 = MAX2(t->Image[0][baseLevel]->WidthLog2,
t->Image[0][baseLevel]->HeightLog2);
maxLevels = ctx->Const.MaxCubeTextureLevels;
}
else {
_mesa_problem(ctx, "Bad t->Target in _mesa_test_texobj_completeness");
return;
}
ASSERT(maxLevels > 0);
if (t->MaxLevel < t->BaseLevel) {
incomplete(t, "MAX_LEVEL (%d) < BASE_LEVEL (%d)",
t->MaxLevel, t->BaseLevel);
return;
}
t->_MaxLevel = baseLevel + maxLog2;
t->_MaxLevel = MIN2(t->_MaxLevel, t->MaxLevel);
t->_MaxLevel = MIN2(t->_MaxLevel, maxLevels - 1);
/* Compute _MaxLambda = q - b (see the 1.2 spec) used during mipmapping */
t->_MaxLambda = (GLfloat) (t->_MaxLevel - t->BaseLevel);
if (t->Immutable) {
/* This texture object was created with glTexStorage1/2/3D() so we
* know that all the mipmap levels are the right size and all cube
* map faces are the same size.
* We don't need to do any of the additional checks below.
*/
return;
}
if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
/* make sure that all six cube map level 0 images are the same size */
const GLuint w = t->Image[0][baseLevel]->Width2;
const GLuint h = t->Image[0][baseLevel]->Height2;
GLuint face;
for (face = 1; face < 6; face++) {
if (t->Image[face][baseLevel] == NULL ||
t->Image[face][baseLevel]->Width2 != w ||
t->Image[face][baseLevel]->Height2 != h) {
incomplete(t, "Cube face missing or mismatched size");
return;
}
}
}
/* extra checking for mipmaps */
if (t->Sampler.MinFilter != GL_NEAREST && t->Sampler.MinFilter != GL_LINEAR) {
/*
* Mipmapping: determine if we have a complete set of mipmaps
*/
GLint i;
GLint minLevel = baseLevel;
GLint maxLevel = t->_MaxLevel;
if (minLevel > maxLevel) {
incomplete(t, "minLevel > maxLevel");
return;
}
/* Test dimension-independent attributes */
for (i = minLevel; i <= maxLevel; i++) {
if (t->Image[0][i]) {
if (t->Image[0][i]->TexFormat != t->Image[0][baseLevel]->TexFormat) {
incomplete(t, "Format[i] != Format[baseLevel]");
return;
}
if (t->Image[0][i]->Border != t->Image[0][baseLevel]->Border) {
incomplete(t, "Border[i] != Border[baseLevel]");
return;
}
}
}
/* Test things which depend on number of texture image dimensions */
if (t->Target == GL_TEXTURE_1D) {
/* Test 1-D mipmaps */
GLuint width = t->Image[0][baseLevel]->Width2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (i >= minLevel && i <= maxLevel) {
const struct gl_texture_image *img = t->Image[0][i];
if (!img) {
incomplete(t, "1D Image[%d] is missing", i);
return;
}
if (img->Width2 != width ) {
incomplete(t, "1D Image[%d] bad width %u", i, img->Width2);
return;
}
}
if (width == 1) {
return; /* found smallest needed mipmap, all done! */
}
}
}
else if (t->Target == GL_TEXTURE_2D) {
/* Test 2-D mipmaps */
GLuint width = t->Image[0][baseLevel]->Width2;
GLuint height = t->Image[0][baseLevel]->Height2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (height > 1) {
height /= 2;
}
if (i >= minLevel && i <= maxLevel) {
const struct gl_texture_image *img = t->Image[0][i];
if (!img) {
incomplete(t, "2D Image[%d of %d] is missing", i, maxLevel);
return;
}
if (img->Width2 != width) {
incomplete(t, "2D Image[%d] bad width %u", i, img->Width2);
return;
}
if (img->Height2 != height) {
incomplete(t, "2D Image[i] bad height %u", i, img->Height2);
return;
}
if (width==1 && height==1) {
return; /* found smallest needed mipmap, all done! */
}
}
}
}
else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
/* make sure 6 cube faces are consistant */
GLuint width = t->Image[0][baseLevel]->Width2;
GLuint height = t->Image[0][baseLevel]->Height2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (height > 1) {
height /= 2;
}
if (i >= minLevel && i <= maxLevel) {
GLuint face;
for (face = 0; face < 6; face++) {
/* check that we have images defined */
if (!t->Image[face][i]) {
incomplete(t, "CubeMap Image[n][i] == NULL");
return;
}
/* Don't support GL_DEPTH_COMPONENT for cube maps */
if (ctx->VersionMajor < 3) {
if (t->Image[face][i]->_BaseFormat == GL_DEPTH_COMPONENT) {
incomplete(t, "GL_DEPTH_COMPONENT only works with 1/2D tex");
return;
}
}
/* check that all six images have same size */
if (t->Image[face][i]->Width2 != width ||
t->Image[face][i]->Height2 != height) {
incomplete(t, "CubeMap Image[n][i] bad size");
return;
}
}
}
if (width == 1 && height == 1) {
return; /* found smallest needed mipmap, all done! */
}
}
}
else {
/* Target = ??? */
_mesa_problem(ctx, "Bug in gl_test_texture_object_completeness\n");
}
}
}
/**
* Examine a texture object to determine if it is complete.
*
* The gl_texture_object::Complete flag will be set to GL_TRUE or GL_FALSE
* accordingly.
*
* \param ctx GL context.
* \param t texture object.
*
* According to the texture target, verifies that each of the mipmaps is
* present and has the expected size.
*/
void
_mesa_test_texobj_completeness( const GLcontext *ctx,
struct gl_texture_object *t )
{
const GLint baseLevel = t->BaseLevel;
GLint maxLog2 = 0, maxLevels = 0;
t->Complete = GL_TRUE; /* be optimistic */
t->_IsPowerOfTwo = GL_TRUE; /* may be set FALSE below */
/* Always need the base level image */
if (!t->Image[0][baseLevel]) {
char s[100];
sprintf(s, "obj %p (%d) Image[baseLevel=%d] == NULL",
(void *) t, t->Name, baseLevel);
incomplete(t, s);
t->Complete = GL_FALSE;
return;
}
/* Check width/height/depth for zero */
if (t->Image[0][baseLevel]->Width == 0 ||
t->Image[0][baseLevel]->Height == 0 ||
t->Image[0][baseLevel]->Depth == 0) {
incomplete(t, "texture width = 0");
t->Complete = GL_FALSE;
return;
}
/* Compute _MaxLevel */
if (t->Target == GL_TEXTURE_1D) {
maxLog2 = t->Image[0][baseLevel]->WidthLog2;
maxLevels = ctx->Const.MaxTextureLevels;
}
else if (t->Target == GL_TEXTURE_2D) {
maxLog2 = MAX2(t->Image[0][baseLevel]->WidthLog2,
t->Image[0][baseLevel]->HeightLog2);
maxLevels = ctx->Const.MaxTextureLevels;
}
else if (t->Target == GL_TEXTURE_3D) {
GLint max = MAX2(t->Image[0][baseLevel]->WidthLog2,
t->Image[0][baseLevel]->HeightLog2);
maxLog2 = MAX2(max, (GLint)(t->Image[0][baseLevel]->DepthLog2));
maxLevels = ctx->Const.Max3DTextureLevels;
}
else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
maxLog2 = MAX2(t->Image[0][baseLevel]->WidthLog2,
t->Image[0][baseLevel]->HeightLog2);
maxLevels = ctx->Const.MaxCubeTextureLevels;
}
else if (t->Target == GL_TEXTURE_RECTANGLE_NV) {
maxLog2 = 0; /* not applicable */
maxLevels = 1; /* no mipmapping */
}
else {
_mesa_problem(ctx, "Bad t->Target in _mesa_test_texobj_completeness");
return;
}
ASSERT(maxLevels > 0);
t->_MaxLevel = baseLevel + maxLog2;
t->_MaxLevel = MIN2(t->_MaxLevel, t->MaxLevel);
t->_MaxLevel = MIN2(t->_MaxLevel, maxLevels - 1);
/* Compute _MaxLambda = q - b (see the 1.2 spec) used during mipmapping */
t->_MaxLambda = (GLfloat) (t->_MaxLevel - t->BaseLevel);
if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
/* make sure that all six cube map level 0 images are the same size */
const GLuint w = t->Image[0][baseLevel]->Width2;
const GLuint h = t->Image[0][baseLevel]->Height2;
GLuint face;
for (face = 1; face < 6; face++) {
if (t->Image[face][baseLevel] == NULL ||
t->Image[face][baseLevel]->Width2 != w ||
t->Image[face][baseLevel]->Height2 != h) {
t->Complete = GL_FALSE;
incomplete(t, "Non-quare cubemap image");
return;
}
}
}
/* check for non power of two */
if (!t->Image[0][baseLevel]->_IsPowerOfTwo) {
t->_IsPowerOfTwo = GL_FALSE;
}
/* extra checking for mipmaps */
if (t->MinFilter != GL_NEAREST && t->MinFilter != GL_LINEAR) {
/*
* Mipmapping: determine if we have a complete set of mipmaps
*/
GLint i;
GLint minLevel = baseLevel;
GLint maxLevel = t->_MaxLevel;
if (minLevel > maxLevel) {
t->Complete = GL_FALSE;
incomplete(t, "minLevel > maxLevel");
return;
}
/* Test dimension-independent attributes */
for (i = minLevel; i <= maxLevel; i++) {
if (t->Image[0][i]) {
if (t->Image[0][i]->TexFormat != t->Image[0][baseLevel]->TexFormat) {
t->Complete = GL_FALSE;
incomplete(t, "Format[i] != Format[baseLevel]");
return;
}
if (t->Image[0][i]->Border != t->Image[0][baseLevel]->Border) {
t->Complete = GL_FALSE;
incomplete(t, "Border[i] != Border[baseLevel]");
return;
}
}
}
/* Test things which depend on number of texture image dimensions */
if (t->Target == GL_TEXTURE_1D) {
/* Test 1-D mipmaps */
GLuint width = t->Image[0][baseLevel]->Width2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (i >= minLevel && i <= maxLevel) {
if (!t->Image[0][i]) {
t->Complete = GL_FALSE;
incomplete(t, "1D Image[0][i] == NULL");
return;
}
if (t->Image[0][i]->Width2 != width ) {
t->Complete = GL_FALSE;
incomplete(t, "1D Image[0][i] bad width");
return;
}
}
if (width == 1) {
return; /* found smallest needed mipmap, all done! */
}
}
}
else if (t->Target == GL_TEXTURE_2D) {
/* Test 2-D mipmaps */
GLuint width = t->Image[0][baseLevel]->Width2;
GLuint height = t->Image[0][baseLevel]->Height2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (height > 1) {
height /= 2;
}
if (i >= minLevel && i <= maxLevel) {
if (!t->Image[0][i]) {
t->Complete = GL_FALSE;
incomplete(t, "2D Image[0][i] == NULL");
return;
}
if (t->Image[0][i]->Width2 != width) {
t->Complete = GL_FALSE;
incomplete(t, "2D Image[0][i] bad width");
return;
}
if (t->Image[0][i]->Height2 != height) {
t->Complete = GL_FALSE;
incomplete(t, "2D Image[0][i] bad height");
return;
}
if (width==1 && height==1) {
return; /* found smallest needed mipmap, all done! */
}
}
}
}
else if (t->Target == GL_TEXTURE_3D) {
/* Test 3-D mipmaps */
GLuint width = t->Image[0][baseLevel]->Width2;
GLuint height = t->Image[0][baseLevel]->Height2;
GLuint depth = t->Image[0][baseLevel]->Depth2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (height > 1) {
height /= 2;
}
if (depth > 1) {
depth /= 2;
}
if (i >= minLevel && i <= maxLevel) {
if (!t->Image[0][i]) {
incomplete(t, "3D Image[0][i] == NULL");
t->Complete = GL_FALSE;
return;
}
if (t->Image[0][i]->Format == GL_DEPTH_COMPONENT) {
t->Complete = GL_FALSE;
incomplete(t, "GL_DEPTH_COMPONENT only works with 1/2D tex");
return;
}
if (t->Image[0][i]->Width2 != width) {
t->Complete = GL_FALSE;
incomplete(t, "3D Image[0][i] bad width");
return;
}
if (t->Image[0][i]->Height2 != height) {
t->Complete = GL_FALSE;
incomplete(t, "3D Image[0][i] bad height");
return;
}
if (t->Image[0][i]->Depth2 != depth) {
t->Complete = GL_FALSE;
incomplete(t, "3D Image[0][i] bad depth");
return;
}
}
if (width == 1 && height == 1 && depth == 1) {
return; /* found smallest needed mipmap, all done! */
}
}
}
else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
/* make sure 6 cube faces are consistant */
GLuint width = t->Image[0][baseLevel]->Width2;
GLuint height = t->Image[0][baseLevel]->Height2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (height > 1) {
height /= 2;
}
if (i >= minLevel && i <= maxLevel) {
GLuint face;
for (face = 0; face < 6; face++) {
/* check that we have images defined */
if (!t->Image[face][i]) {
t->Complete = GL_FALSE;
incomplete(t, "CubeMap Image[n][i] == NULL");
return;
}
/* Don't support GL_DEPTH_COMPONENT for cube maps */
if (t->Image[face][i]->Format == GL_DEPTH_COMPONENT) {
t->Complete = GL_FALSE;
incomplete(t, "GL_DEPTH_COMPONENT only works with 1/2D tex");
return;
}
/* check that all six images have same size */
if (t->Image[face][i]->Width2!=width ||
t->Image[face][i]->Height2!=height) {
t->Complete = GL_FALSE;
incomplete(t, "CubeMap Image[n][i] bad size");
return;
}
}
}
if (width == 1 && height == 1) {
return; /* found smallest needed mipmap, all done! */
}
}
}
else if (t->Target == GL_TEXTURE_RECTANGLE_NV) {
/* XXX special checking? */
}
else {
/* Target = ??? */
_mesa_problem(ctx, "Bug in gl_test_texture_object_completeness\n");
}
}
}
static grub_err_t
interactive (void)
{
const char *ps1 = "lua> ";
const char *ps2 = "lua>> ";
const char *prompt = ps1;
char *line;
char *chunk = NULL;
size_t len;
size_t oldlen = 0;
int r;
grub_printf ("%s", N_ ("Welcome to lua, press the escape key to exit."));
while ((line = grub_cmdline_get (prompt)) != NULL)
{
/* len = lenght of chunk + line + newline character */
len = oldlen + grub_strlen (line) + 1;
chunk = grub_realloc (chunk, len + 1);
grub_strcpy (chunk + oldlen , line);
chunk[len - 1] = '\n';
chunk[len] = '\0';
grub_free (line);
r = luaL_loadbuffer (state, chunk, len, "stdin");
if (!r)
{
/* No error: Execute this chunk and prepare to read another */
r = lua_pcall (state, 0, 0, 0);
if (r)
{
handle_lua_error ("Lua");
grub_print_error ();
}
grub_free (chunk);
chunk = NULL;
len = 0;
prompt = ps1;
}
else if (incomplete (state, r))
{
/* Chunk is incomplete, try reading another line */
prompt = ps2;
}
else if (r == LUA_ERRSYNTAX)
{
handle_lua_error ("Lua");
grub_print_error ();
/* This chunk is garbage, try starting another one */
grub_free (chunk);
chunk = NULL;
len = 0;
prompt = ps1;
}
else
{
/* Handle errors other than syntax errors (out of memory, etc.) */
grub_free (chunk);
handle_lua_error ("Lua parser failed");
return grub_errno;
}
oldlen = len;
}
grub_free (chunk);
lua_gc (state, LUA_GCCOLLECT, 0);
return grub_errno;
}
void put(property_map<treedec::grtdprinter<G>, vertex_all_t> const&,
std::vector<unsigned>&, const treedec::bag_t)
{ incomplete();
}
void put(property_map<treedec::grtdprinter<G>, vertex_all_t,
treedec::bag_t> const&, size_t&, const treedec::bag_t)
{ incomplete();
}
/**
* Examine a texture object to determine if it is complete.
*
* The gl_texture_object::Complete flag will be set to GL_TRUE or GL_FALSE
* accordingly.
*
* \param ctx GL context.
* \param t texture object.
*
* According to the texture target, verifies that each of the mipmaps is
* present and has the expected size.
*/
void
_mesa_test_texobj_completeness( const struct gl_context *ctx,
struct gl_texture_object *t )
{
const GLint baseLevel = t->BaseLevel;
const struct gl_texture_image *baseImage;
GLint maxLog2 = 0, maxLevels = 0;
/* We'll set these to FALSE if tests fail below */
t->_BaseComplete = GL_TRUE;
t->_MipmapComplete = GL_TRUE;
if (t->Target == GL_TEXTURE_BUFFER) {
/* Buffer textures are always considered complete. The obvious case where
* they would be incomplete (no BO attached) is actually specced to be
* undefined rendering results.
*/
return;
}
/* Detect cases where the application set the base level to an invalid
* value.
*/
if ((baseLevel < 0) || (baseLevel >= MAX_TEXTURE_LEVELS)) {
incomplete(t, BASE, "base level = %d is invalid", baseLevel);
return;
}
if (t->MaxLevel < baseLevel) {
incomplete(t, BASE, "MAX_LEVEL (%d) < BASE_LEVEL (%d)",
t->MaxLevel, baseLevel);
return;
}
baseImage = t->Image[0][baseLevel];
/* Always need the base level image */
if (!baseImage) {
incomplete(t, BASE, "Image[baseLevel=%d] == NULL", baseLevel);
return;
}
/* Check width/height/depth for zero */
if (baseImage->Width == 0 ||
baseImage->Height == 0 ||
baseImage->Depth == 0) {
incomplete(t, BASE, "texture width or height or depth = 0");
return;
}
/* Check if the texture values are integer */
{
GLenum datatype = _mesa_get_format_datatype(baseImage->TexFormat);
t->_IsIntegerFormat = datatype == GL_INT || datatype == GL_UNSIGNED_INT;
}
/* Compute _MaxLevel (the maximum mipmap level we'll sample from given the
* mipmap image sizes and GL_TEXTURE_MAX_LEVEL state).
*/
switch (t->Target) {
case GL_TEXTURE_1D:
case GL_TEXTURE_1D_ARRAY_EXT:
maxLog2 = baseImage->WidthLog2;
maxLevels = ctx->Const.MaxTextureLevels;
break;
case GL_TEXTURE_2D:
case GL_TEXTURE_2D_ARRAY_EXT:
maxLog2 = MAX2(baseImage->WidthLog2,
baseImage->HeightLog2);
maxLevels = ctx->Const.MaxTextureLevels;
break;
case GL_TEXTURE_3D:
maxLog2 = MAX3(baseImage->WidthLog2,
baseImage->HeightLog2,
baseImage->DepthLog2);
maxLevels = ctx->Const.Max3DTextureLevels;
break;
case GL_TEXTURE_CUBE_MAP_ARB:
maxLog2 = MAX2(baseImage->WidthLog2,
baseImage->HeightLog2);
maxLevels = ctx->Const.MaxCubeTextureLevels;
break;
case GL_TEXTURE_RECTANGLE_NV:
case GL_TEXTURE_BUFFER:
case GL_TEXTURE_EXTERNAL_OES:
maxLog2 = 0; /* not applicable */
maxLevels = 1; /* no mipmapping */
break;
default:
_mesa_problem(ctx, "Bad t->Target in _mesa_test_texobj_completeness");
return;
}
ASSERT(maxLevels > 0);
t->_MaxLevel = baseLevel + maxLog2; /* 'p' in the GL spec */
t->_MaxLevel = MIN2(t->_MaxLevel, t->MaxLevel);
t->_MaxLevel = MIN2(t->_MaxLevel, maxLevels - 1); /* 'q' in the GL spec */
/* Compute _MaxLambda = q - b (see the 1.2 spec) used during mipmapping */
t->_MaxLambda = (GLfloat) (t->_MaxLevel - baseLevel);
if (t->Immutable) {
/* This texture object was created with glTexStorage1/2/3D() so we
* know that all the mipmap levels are the right size and all cube
* map faces are the same size.
* We don't need to do any of the additional checks below.
*/
return;
}
if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
/* Make sure that all six cube map level 0 images are the same size.
* Note: we know that the image's width==height (we enforce that
* at glTexImage time) so we only need to test the width here.
*/
GLuint face;
assert(baseImage->Width2 == baseImage->Height);
for (face = 1; face < 6; face++) {
assert(t->Image[face][baseLevel] == NULL ||
t->Image[face][baseLevel]->Width2 ==
t->Image[face][baseLevel]->Height2);
if (t->Image[face][baseLevel] == NULL ||
t->Image[face][baseLevel]->Width2 != baseImage->Width2) {
incomplete(t, BASE, "Cube face missing or mismatched size");
return;
}
}
}
/*
* Do mipmap consistency checking.
* Note: we don't care about the current texture sampler state here.
* To determine texture completeness we'll either look at _BaseComplete
* or _MipmapComplete depending on the current minification filter mode.
*/
{
GLint i;
const GLint minLevel = baseLevel;
const GLint maxLevel = t->_MaxLevel;
const GLuint numFaces = _mesa_num_tex_faces(t->Target);
GLuint width, height, depth, face;
if (minLevel > maxLevel) {
incomplete(t, BASE, "minLevel > maxLevel");
return;
}
/* Get the base image's dimensions */
width = baseImage->Width2;
height = baseImage->Height2;
depth = baseImage->Depth2;
/* Note: this loop will be a no-op for RECT, BUFFER, EXTERNAL textures */
for (i = baseLevel + 1; i < maxLevels; i++) {
/* Compute the expected size of image at level[i] */
if (width > 1) {
width /= 2;
}
if (height > 1 && t->Target != GL_TEXTURE_1D_ARRAY) {
height /= 2;
}
if (depth > 1 && t->Target != GL_TEXTURE_2D_ARRAY) {
depth /= 2;
}
/* loop over cube faces (or single face otherwise) */
for (face = 0; face < numFaces; face++) {
if (i >= minLevel && i <= maxLevel) {
const struct gl_texture_image *img = t->Image[face][i];
if (!img) {
incomplete(t, MIPMAP, "TexImage[%d] is missing", i);
return;
}
if (img->TexFormat != baseImage->TexFormat) {
incomplete(t, MIPMAP, "Format[i] != Format[baseLevel]");
return;
}
if (img->Border != baseImage->Border) {
incomplete(t, MIPMAP, "Border[i] != Border[baseLevel]");
return;
}
if (img->Width2 != width) {
incomplete(t, MIPMAP, "TexImage[%d] bad width %u", i, img->Width2);
return;
}
if (img->Height2 != height) {
incomplete(t, MIPMAP, "TexImage[%d] bad height %u", i, img->Height2);
return;
}
if (img->Depth2 != depth) {
incomplete(t, MIPMAP, "TexImage[%d] bad depth %u", i, img->Depth2);
return;
}
/* Extra checks for cube textures */
if (face > 0) {
/* check that cube faces are the same size */
if (img->Width2 != t->Image[0][i]->Width2 ||
img->Height2 != t->Image[0][i]->Height2) {
incomplete(t, MIPMAP, "CubeMap Image[n][i] bad size");
return;
}
}
}
}
if (width == 1 && height == 1 && depth == 1) {
return; /* found smallest needed mipmap, all done! */
}
}
}
}
int main ( void )
{
FILE *fcost,*fp_extra,*fp_entries;
int ask,cost_exists;
char i='0',ar_ext[8], ch='&',entries[13]="Entries.txt",cost[9]="Cost.txt",extra[10]="Extra.txt";
fcost=fopen(cost,"r");
if(fcost==NULL)
{
printf("Couldn't find %s\nThe file will now be created. Please insert the different cost values, before advancing to menu.\n",cost);
edit_cost(cost,1);
}
else
{
printf("Cost file detected. Advancing to menu.\n",cost);
fclose(fcost);
}
while(ch!='8')
{
printf("\n1. New entry\n2. Calculate cost\n3. Print entry status\n4. Print non delivered entries\n5. Profits\n6. Services cost\n7. Update services cost\n8. Quit\n Your input:");
ch=getchar();
printf("\n** Your input was: %c ** \n",ch);
switch (ch)
{
case '1': {
ask=0;
add_entry(entries,extra,cost,ask);
}break;//don't ask.
case '2': {
ask=1;
add_entry(entries,extra,cost,ask);
//fflushnew(&ch);
}break;//ask.
case '3':
{fflushnew(&ch);search_entry(entries);
}
break;
case '4': {incomplete(entries);
}
break;
case '5': {profits(entries);}
break;
case '6': {edit_cost(cost,0);}
break;//view cost file
case '7': {edit_cost(cost,1);fflushnew(&ch);}
break;//edit cost file
case '8': break;//quit
default: printf("Please enter correct input (1-8)");
}
if(ch!='8')fflushnew(&ch);
}
system ("pause");
return 0;
}
