自学教程：C++ AAsset_getLength函数代码示例

Shader::Shader(AAssetManager* assetMgr){	AAsset* asset;	long sizeAsset;	asset = AAssetManager_open(assetMgr, "Shaders/triangle.vert", AASSET_MODE_STREAMING);	sizeAsset = AAsset_getLength(asset);	gVertexShader = (char*) malloc (sizeof(char)*sizeAsset + 1);	AAsset_read (asset,gVertexShader,sizeAsset);	gVertexShader[sizeAsset] = 0;	AAsset_close(asset);	asset = AAssetManager_open(assetMgr, "Shaders/triangle.frag", AASSET_MODE_STREAMING);	sizeAsset = AAsset_getLength(asset);	gFragmentShader = (char*) malloc (sizeof(char)*sizeAsset + 1);	AAsset_read (asset,gFragmentShader,sizeAsset);	gFragmentShader[sizeAsset] = 0;	AAsset_close(asset);	asset = AAssetManager_open(assetMgr, "Shaders/line.vert", AASSET_MODE_STREAMING);	sizeAsset = AAsset_getLength(asset);	gLineVertexShader = (char*) malloc (sizeof(char)*sizeAsset + 1);	AAsset_read (asset,gLineVertexShader,sizeAsset);	gLineVertexShader[sizeAsset] = 0;	LOGE("%s/n",gLineVertexShader);	AAsset_close(asset);	asset = AAssetManager_open(assetMgr, "Shaders/line.frag", AASSET_MODE_STREAMING);	sizeAsset = AAsset_getLength(asset);	gFragmentLineShader = (char*) malloc (sizeof(char)*sizeAsset + 1);	AAsset_read (asset,gFragmentLineShader,sizeAsset);	gFragmentLineShader[sizeAsset] = 0;	LOGE("%s/n",gFragmentLineShader);	AAsset_close(asset);}

/** * Get shader program according to type. */GLuint ShaderProgramFactory::CreateShaderProgram(AAssetManager* assetManager, ShaderType type) {    if (mShaderPrograms[type] != INVALID_PROGRAM) {        // Already created.        return mShaderPrograms[type];    }    TRACE_LOG("Create new ShaderProgram.");    // Get vertex/fragment shader src file path.    const char* vertexShaderSrcFile = getShaderSrcFileName(GL_VERTEX_SHADER, type);    const char* fragmentShaderSrcFile = getShaderSrcFileName(GL_FRAGMENT_SHADER, type);    if (vertexShaderSrcFile == NULL || fragmentShaderSrcFile == NULL) {        LOGE("Unexpected ShaderType.");        return INVALID_PROGRAM;    }    // Vertex.    // Open assets.    AAsset* vertexSrcAsset = AAssetManager_open(                                 assetManager,                                 vertexShaderSrcFile,                                 AASSET_MODE_RANDOM);    GLsizei vertSrcLen = AAsset_getLength(vertexSrcAsset);    // Src codes.    GLchar vertSrc[vertSrcLen + 1];    // Read.    AAsset_seek(vertexSrcAsset, 0, 0);    AAsset_read(vertexSrcAsset, vertSrc, vertSrcLen);    vertSrc[vertSrcLen] = NULL; // Terminal.    // Close assets.    AAsset_close(vertexSrcAsset);    // Fragment.    // Open assets.    AAsset* fragmentSrcAsset = AAssetManager_open(                                   assetManager,                                   fragmentShaderSrcFile,                                   AASSET_MODE_RANDOM);    GLsizei fragSrcLen = AAsset_getLength(fragmentSrcAsset);    // Src codes.    GLchar fragSrc[fragSrcLen + 1];    // Read.    AAsset_seek(fragmentSrcAsset, 0, 0);    AAsset_read(fragmentSrcAsset, fragSrc, fragSrcLen);    fragSrc[fragSrcLen] = NULL; // Terminal.    // Close assets.    AAsset_close(fragmentSrcAsset);    // Create program.    mShaderPrograms[type] = createProgram(vertSrc, vertSrcLen + 1, fragSrc, fragSrcLen + 1);    return mShaderPrograms[type];}

ByteArray AndroidGetAssetBytes(const char *inResource){   AAsset *asset = AndroidGetAsset(inResource);      if (asset)   {      long size = AAsset_getLength(asset);      ByteArray result(size);      AAsset_read(asset, result.Bytes(), size);      AAsset_close(asset);      return result;   }      return 0;      /*JNIEnv *env = GetEnv();      jclass cls = FindClass("org/haxe/nme/GameActivity");   jmethodID mid = env->GetStaticMethodID(cls, "getResource", "(Ljava/lang/String;)[B");   if (mid == 0)      return 0;      jstring str = env->NewStringUTF( inResource );   jbyteArray bytes = (jbyteArray)env->CallStaticObjectMethod(cls, mid, str);   env->DeleteLocalRef(str);   if (bytes==0)   {      return 0;   }      jint len = env->GetArrayLength(bytes);   ByteArray result(len);   env->GetByteArrayRegion(bytes, (jint)0, (jint)len, (jbyte*)result.Bytes());   return result;*/}

shared_ptr<Scene> Scene::loadColladaFromAsset(    shared_ptr<EngineContext> engineContext,    const string &assetFile) {    AAssetManager *assetManager = engineContext->getAssetManager();    assert(assetManager != NULL);    AAsset* asset = AAssetManager_open(assetManager,        assetFile.c_str(), AASSET_MODE_BUFFER);    if (!asset) {        ALOGE("Failed to open asset: %s", assetFile.c_str());        return nullptr;    }    off_t length = AAsset_getLength(asset);    unique_ptr<char[]> buffer(new char[length]);    size_t sz = AAsset_read(asset, buffer.get(), length);    AAsset_close(asset);    if (sz != length) {        ALOGE("Partial read %d bytes", sz);        return nullptr;    }    return loadColladaFromMemory(buffer.get(), length, assetFile);}

    void test_assets() {        AAsset* a = AAssetManager_open( g_asset_mgr, "raw/test.jpg", AASSET_MODE_RANDOM );        assert( a != 0 );                off_t len = AAsset_getLength(a);                const char *buf = (const char *)AAsset_getBuffer(a);        LOGI( "asset: %p %d/n", a, len );                for( size_t i = 0; i < len; ++i ) {            LOGI( "x: %c/n", buf[i] );        }//         AAssetDir *dir = AAssetManager_openDir(g_asset_mgr, "assets" );//         //         while( true ) {//             const char *name = AAssetDir_getNextFileName(dir);//             //             if( name == 0 ) {//                 break;//             }//             //             LOGI( "asset: %s/n", name );//         }    }

JNIEXPORT jlong JNICALLJava_org_gearvrf_NativeImporter_readFileFromAssets(JNIEnv * env,        jobject obj, jobject asset_manager, jstring filename) {    const char* native_string = env->GetStringUTFChars(filename, 0);    AAssetManager* mgr = AAssetManager_fromJava(env, asset_manager);    AAsset* asset = AAssetManager_open(mgr, native_string, AASSET_MODE_UNKNOWN);    if (NULL == asset) {        LOGE("_ASSET_NOT_FOUND_");        return JNI_FALSE;    }    long size = AAsset_getLength(asset);    char* buffer = (char*) malloc(sizeof(char) * size);    AAsset_read(asset, buffer, size);    AssimpImporter* assimp_scene = Importer::readFileFromAssets(            buffer, size);    AAsset_close(asset);    free(buffer);    env->ReleaseStringUTFChars(filename, native_string);    return reinterpret_cast<jlong>(assimp_scene);}

// Read the contents of the give file return the content and the file size.// The calling function is responsible for free the memory allocated for Content.void ReadFile( const char* pFileName, char** ppContent, unsigned int* pSize ){      assert( g_pManager );        // Open files    AAsset* pFile = AAssetManager_open( g_pManager, pFileName, AASSET_MODE_UNKNOWN );    if( pFile != NULL )    {        // Determine file size        off_t fileSize = AAsset_getLength( pFile );        // Read data        char* pData = new char[fileSize];        AAsset_read( pFile, pData, fileSize );            // Allocate space for the file content        *ppContent = new char[fileSize];            // Copy the content        memcpy( *ppContent, pData, fileSize );        *pSize = fileSize;        Log("File length %d",*pSize);        delete pData;                // Close the file        AAsset_close( pFile );    }}

void Renderer::LoadTexture(const string* filePath, TextureID* id){#ifdef PLATFORM_WINDOWS	string nPath = Renderer::GetInstance()->ASSET_PATH + *filePath;	id->name = *filePath;	id->id = SOIL_load_OGL_texture(nPath.c_str(), SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID,			SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_NTSC_SAFE_RGB);#else	AAssetManager* mgr = System::GetInstance()->GetEngineData()->app->activity->assetManager;	AAsset* textureAsset = AAssetManager_open(mgr, filePath->c_str(), AASSET_MODE_UNKNOWN);	unsigned int length = AAsset_getLength(textureAsset);	unsigned char * bitmap = new unsigned char[length];	AAsset_read(textureAsset, (void*)bitmap, length);	id->name = *filePath;	id->id = SOIL_load_OGL_texture_from_memory(bitmap, length, SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID,		SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_NTSC_SAFE_RGB);	++length;#endif}

void OSLOgg::load(char* filename) {	strcpy(this->filename, filename);//	LOGD("filename = %s, this->filename = %s",filename, this->filename);	// if set Player Buffer, than load audio data to PCM buffer	if(playerType == BUFFER){		AAsset* f = openFile(filename);		if (!f) {				LOGE("no file %s",filename);				throw "no file %s";		}		buf = 0;		off_t length = AAsset_getLength(f);		buf = (char*) malloc(length);		if (buf) {			if (AAsset_read(f,buf, length)) {			} else {				free(buf);				AAsset_close(f);				LOGE("smthng wrong with %s",filename);				throw "smthng wrong while reading file";	//			return;			}		}//		LOGD("length = %d", length);		this->buf =  (char *) ConvertOggToPCM(length, buf);		if(f)			AAsset_close(f);	}}

char* OSLSound::readWAVFull(AAssetManager *mgr, BasicWAVEHeader* header) {    char* buffer = 0;    AAsset * file = openFile(filename);    if (!file) {        LOGE("no file %s in readWAV",filename);        return 0;    }    char extra[2];    int res = AAsset_read (file,header,sizeof(BasicWAVEHeader));    if(!strstr(header->data, "data")) {        AAsset_read (file,extra,2);        header->dataSize = AAsset_getLength(file) - sizeof(BasicWAVEHeader)-2;    }    if(res) {        buffer = (char*)malloc(header->dataSize);        if (buffer) {            res = AAsset_read (file,buffer,header->dataSize);            if(res) {                AAsset_close(file);                return buffer;            }            free(buffer);        }    }    AAsset_close(file);    return 0;}

	FileInfoListPtr APKFileSystemArchive::findFileInfo(const String& pattern, bool recursive, bool dirs)	{		FileInfoListPtr files(new FileInfoList);		std::map<String, std::vector< String > >::iterator iter = mFiles.find( mName );		std::vector< String > fileList = iter->second;		for( size_t i = 0; i < fileList.size(); i++ ) 		{			if(StringUtil::match(fileList[i], pattern)) 			{				AAsset* asset = AAssetManager_open(mAssetMgr, (mPathPreFix + fileList[i]).c_str(), AASSET_MODE_UNKNOWN);				if(asset) {					FileInfo info;					info.archive = this;					info.filename = fileList[i];					info.path = mName;					info.basename = fileList[i];					info.compressedSize = AAsset_getLength(asset);					info.uncompressedSize = info.compressedSize;					files->push_back(info);					AAsset_close(asset);				}			}		}		return files;	}

AssetFileCache::AssetFileCache ( AAsset* asset ) : asset ( asset ){    fileSize = AAsset_getLength ( asset );    pageSize = 1024 * 1024;    nbrPageData = 8;    pos = 0;    uint32_t totalPages = fileSize / pageSize;    if ( fileSize % pageSize != 0 )    {        totalPages++;    }    this->totalPages = totalPages;    if ( totalPages < nbrPageData )    {        nbrPageData = totalPages;    }    for ( int32_t n = 0; n < totalPages; n++ )    {        pages.push_back ( new Page() );    }    for ( int32_t n = 0; n < nbrPageData; n++ )    {        pageData.push_back ( new PageData ( pageSize ) );    }    LOGI ( "Created, asset = %p, fileSize = %d, totalPages = %d, nbrPageData = %d", asset, fileSize, totalPages, nbrPageData );}

	int ReadAPKFile(void ** data, const char * filename)	{		assert (gAssetManager != NULL);		AAsset * pAsset = AAssetManager_open(gAssetManager, filename, AASSET_MODE_UNKNOWN);		if (pAsset == NULL)			return -1;		size_t size = AAsset_getLength(pAsset);		if (size > 0 && data != NULL)		{			unsigned char * pd = new unsigned char[size];			int read_count = AAsset_read(pAsset, pd, size);			if(read_count <= 0)			{				n_log("?: Read APK File '%s'.", filename);				delete[] pd;				pd = NULL;				size = 0;			}			*data = pd;		}		AAsset_close(pAsset);				return size;	}

void GetAsset(char* path, GLchar *text, GLuint *length){	AAsset* asset = AAssetManager_open(Manager, path, AASSET_MODE_STREAMING);	*length = AAsset_getLength(asset);	AAsset_read(asset, text, length);	AAsset_close(asset);}

void androidRead(const char* pFileName, char** ppContent, unsigned int* pSize) {	assert( gActivity->assetManager );	AAsset* pFile = AAssetManager_open(gActivity->assetManager, pFileName,	                                   AASSET_MODE_STREAMING);	if (pFile != NULL) {		off_t fileSize = AAsset_getLength(pFile);		std::string path = androidGetPath(pFileName);		char* pData = new char[fileSize];		AAsset_read(pFile, pData, fileSize);		*ppContent = new char[fileSize];		memcpy(*ppContent, pData, fileSize);		*pSize = fileSize;		FLOG_DEBUG("File %s length %d", pFileName, *pSize);		delete pData;		AAsset_close(pFile);	}}

const char* AndroidPlatformAdapter::loadAsset(const char* filename,		size_t* size) {	LOGD("loadAsset %s", filename);	AAsset* asset = AAssetManager_open(m_AssetManager, filename, AASSET_MODE_UNKNOWN);	if (NULL == asset) {		LOGE("_ASSET_NOT_FOUND_ %s", filename);		return 0;	}	size_t filesize = AAsset_getLength(asset);	char* data;	if(size) {		*size = filesize;		data = new char[filesize];	} else {		data = new char[filesize + 1];	}	AAsset_read (asset,data,filesize);	AAsset_close(asset);	if(!size) {		data[filesize] = 0;	}	return data;}

void LoaderAndroid::loadAsset(const char* filename, std::stringstream& stream) {	//auto del = AAsset_close();	std::unique_ptr<AAsset, void (*)(AAsset*)> asset(AAssetManager_open(assetManager, filename, AASSET_MODE_BUFFER), AAsset_close);	//std::unique_ptr<AAsset> asset(AAssetManager_open(assetManager, filename, AASSET_MODE_BUFFER));	//asset.get_deleter()	//AAsset* asset = AAssetManager_open(assetManager, filename, AASSET_MODE_BUFFER);	if(asset){		//std::string content;		//content.resize(AAsset_getLength( asset ));		std::vector<char> buffer;		buffer.resize(AAsset_getLength( asset.get() ));		//AAsset_read(asset, (void *)content.data(), content.size()); // ToDo: ugly hack		AAsset_read( asset.get(), (void *)buffer.data(), buffer.size());		//stream << content;		stream.write(buffer.data(), buffer.size());	} else{		LOG(WARNING) << "Asset %s not found";	}	// ToDo: I want to return a stringstream object, but gnu_std doesn't support move constructor for stringstreams}

veFileData* veFileAndroid::readFileToBuffer(const std::string &filePath) {    if (!veFileAndroid::ASSET_MANAGER)        return nullptr;    std::string fullPath = getFullFilePath(filePath);    if (!isFileExist(fullPath))        return nullptr;    auto fileIter = _fileDataCache.find(fullPath);    if (fileIter != _fileDataCache.end())        return fileIter->second;    const char* str = fullPath.c_str() + strlen("assets/");    AAsset* asset = AAssetManager_open(veFileAndroid::ASSET_MANAGER, str, AASSET_MODE_UNKNOWN);    if (asset) {        off_t fileSize = AAsset_getLength(asset);        char *buffer = new char[fileSize + 1];        buffer[fileSize] = '/0';        int bytesread = AAsset_read(asset, (void*)buffer, fileSize);        auto fileData = new veFileData();        fileData->buffer = buffer;        fileData->size = fileSize + 1;        //veLog("filebuffer: %s, size: %d", buffer, fileSize);        _fileDataCache[fullPath] = fileData;        AAsset_close(asset);        return fileData;    }    return nullptr;}

	// Android shaders are stored as assets in the apk	// So they need to be loaded via the asset manager	VkShaderModule loadShader(AAssetManager* assetManager, const char *fileName, VkDevice device, VkShaderStageFlagBits stage)	{		// Load shader from compressed asset		AAsset* asset = AAssetManager_open(assetManager, fileName, AASSET_MODE_STREAMING);		assert(asset);		size_t size = AAsset_getLength(asset);		assert(size > 0);		char *shaderCode = new char[size];		AAsset_read(asset, shaderCode, size);		AAsset_close(asset);		VkShaderModule shaderModule;		VkShaderModuleCreateInfo moduleCreateInfo;		moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;		moduleCreateInfo.pNext = NULL;		moduleCreateInfo.codeSize = size;		moduleCreateInfo.pCode = (uint32_t*)shaderCode;		moduleCreateInfo.flags = 0;		VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule));		delete[] shaderCode;		return shaderModule;	}

	FileInfoListPtr APKFileSystemArchive::listFileInfo(bool recursive, bool dirs)	{		FileInfoListPtr files(new FileInfoList);		AAssetDir* dir = AAssetManager_openDir(mAssetMgr, mName.c_str());		const char* fileName = NULL;		while((fileName = AAssetDir_getNextFileName(dir)) != NULL)		{			AAsset* asset = AAssetManager_open(mAssetMgr, (mPathPreFix + String(fileName)).c_str(), AASSET_MODE_UNKNOWN);			if(asset)			{				FileInfo info;				info.archive = this;				info.filename = fileName;				info.path = mName;				info.basename = fileName;				info.compressedSize = AAsset_getLength(asset);				info.uncompressedSize = info.compressedSize;				files->push_back(info);				AAsset_close(asset);			}		}		AAssetDir_close(dir);		return files;	}

long int AssetFileSystem_ftell( AssetFileSystem_FILE * stream ){	off_t total = AAsset_getLength( stream );	off_t remain = AAsset_getRemainingLength( stream );	off_t offset = total - remain;	return (offset >= 0 && offset <= total) ? offset : -1L;}

std::string read_file(const std::string& fname){	AAssetManager* assetManager = GetJavaAssetManager();	AAsset* asset;	std::string name(fname);	if(name[0] == '.' && name[1] == '/') {		name = name.substr(2);	}	asset = AAssetManager_open(assetManager, name.c_str(), AASSET_MODE_RANDOM);	if(asset != 0) {		int len = AAsset_getLength(asset);		std::vector<char> v;		v.resize(len);		if(AAsset_read(asset,&v[0],len)>0) {			std::string s(v.begin(),v.end());			AAsset_close(asset);			return s;		}    	AAsset_close(asset);		return 0;	}	// Couldn't find the file as an asset, try the standard filesystem	std::string filename = find_file(fname);	std::ifstream file(filename.c_str(),std::ios_base::binary);	std::stringstream ss;	ss << file.rdbuf();	return ss.str();}

aasset_buffer_t::aasset_buffer_t(AAsset* asset)        : _asset(asset),          _position(0),          _data(nullptr){    _size = AAsset_getLength(_asset);}

unsigned char* bytesFromAssetManager(const char* _path, unsigned int* _size) {    unsigned char* data = nullptr;    AAsset* asset = AAssetManager_open(assetManager, _path, AASSET_MODE_UNKNOWN);    if (asset == nullptr) {        logMsg("Failed to open asset at path: %s/n", _path);        *_size = 0;        return data;    }    *_size = AAsset_getLength(asset);    data = (unsigned char*) malloc(sizeof(unsigned char) * (*_size));    int read = AAsset_read(asset, data, *_size);    if (read <= 0) {        logMsg("Failed to read asset at path: %s/n", _path);    }    AAsset_close(asset);    return data;}

std::string stringFromResource(const char* _path) {    std::string out;    // Open asset    AAsset* asset = AAssetManager_open(assetManager, _path, AASSET_MODE_STREAMING);    if (asset == nullptr) {        logMsg("Failed to open asset at path: %s/n", _path);        return out;    }    // Allocate string    int length = AAsset_getLength(asset);    out.resize(length);    // Read data    int read = AAsset_read(asset, &out.front(), length);    // Clean up    AAsset_close(asset);    if (read <= 0) {        logMsg("Failed to read asset at path: %s/n", _path);    }    return out;}

		int Asset::GetLength()		{			if(!mAsset)			{				LOGE("Asset::GetLength() error: asset is not opened");				return 0;			}			return AAsset_getLength(mAsset);		}

tImage *LoadJPG(const char *strFileName){	tImage *pImageData = NULL;    struct jpeg_decompress_struct cinfo;    jpeg_error_mgr jerr;		pImageData = (tImage*)malloc(sizeof(tImage));    cinfo.err = jpeg_std_error(&jerr);    jpeg_create_decompress(&cinfo);		AAsset* pAsset = AAssetManager_open(g_amgr, strFileName, AASSET_MODE_UNKNOWN);    if (!pAsset)	{		free(pImageData);		LOGE("Error opening jpeg %s", strFileName);		return NULL;	}	unsigned char* ucharRawData = (unsigned char*)AAsset_getBuffer(pAsset);    long myAssetLength = (long)AAsset_getLength(pAsset);		// the jpeg_stdio_src alternative func, which is also included in IJG's lib.    jpeg_mem_src(&cinfo, ucharRawData, myAssetLength);    jpeg_read_header(&cinfo, TRUE);    jpeg_start_decompress(&cinfo);    pImageData->channels = cinfo.num_components;    pImageData->sizeX    = cinfo.image_width;    pImageData->sizeY    = cinfo.image_height;    int rowSpan = cinfo.image_width * cinfo.num_components;    pImageData->data = ((unsigned char*)malloc(sizeof(unsigned char)*rowSpan*pImageData->sizeY));    unsigned char** rowPtr = new unsigned char*[pImageData->sizeY];    for (int i = 0; i < pImageData->sizeY; i++)        rowPtr[i] = &(pImageData->data[i * rowSpan]);    int rowsRead = 0;    while (cinfo.output_scanline < cinfo.output_height)        rowsRead += jpeg_read_scanlines(&cinfo, &rowPtr[rowsRead], cinfo.output_height - rowsRead);    delete [] rowPtr;    jpeg_finish_decompress(&cinfo);    jpeg_destroy_decompress(&cinfo);    	AAsset_close(pAsset);    return pImageData;}

my::buffer art::asset::retrieve(my::string request, my::string path) { DEBUG_SCOPE;  my::buffer data;    DEBUG_TRACE << "Attempting to find resource: " << request << my::endl;  AAsset* asset = AAssetManager_open((AAssetManager*)manager_instance, request, AASSET_MODE_STREAMING);  //m_ptr = asset;  if(asset) {    DEBUG_TRACE << "Found resource " << (int)AAsset_getLength(asset) << " bytes" << my::endl;//    DEBUG_TRACE << "Contents: " << (char *)AAsset_getBuffer(asset) << my::endl;//    DEBUG_TRACE << "Contents length: " << strlen((char *)AAsset_getBuffer(asset)) << my::endl;    data.write((unsigned char *)AAsset_getBuffer(asset), AAsset_getLength(asset));  }  else {    DEBUG_TRACE << "Failure to load resource" << my::endl;  }    return(data);}

static long apk_size(struct stream_t* stream){   if (stream == NULL)   {      return -1;   }   struct io_stream_apk_t* s = (struct io_stream_apk_t*)stream;   return AAsset_getLength(s->f);}

bool BaseFile::at_end(){    if (flags & ANDROID_ASSET) {        return AAsset_getLength((AAsset*)handle) == 0;    } else {        FILE * fp = (FILE*)handle;        int c = getc(fp);        ungetc(c, fp);        return c == EOF;    }}