Example #1
0
static void CAL_SetupAudioFile()
{
	int handle;
	long length;
	char fname[13];
	int i;
	
	strcpy(fname, aheadname);
	strcat(fname, extension);

	handle = OpenRead(fname);
	if (handle == -1)
		CA_CannotOpen(fname);
	
	length = ReadLength(handle);
	
	MM_GetPtr((memptr)&audiostarts, length);
	
	for (i = 0; i < (length/4); i++)
		audiostarts[i] = ReadInt32(handle);

	CloseRead(handle);	

/* open the data file */

	strcpy(fname, afilename);
	strcat(fname, extension);

	audiohandle = OpenRead(fname);
	if (audiohandle == -1)
		CA_CannotOpen(fname);
}
void loadCalibrationData()
{
  TFileHandle hFileHandle;
  TFileIOResult nIoResult;
  short nFileSize=sizeof(baseHeading);
  OpenRead(hFileHandle, nIoResult, BASEDATADAT, nFileSize);
  ReadFloat(hFileHandle, nIoResult, baseHeading);
  Close(hFileHandle, nIoResult);



  nFileSize=sizeof(result);
  OpenRead(hFileHandle, nIoResult, COMPASSADJUSTMENTSDAT, nFileSize);
  for (int i=0; i<360; i++)
  {
    ReadFloat(hFileHandle, nIoResult, result[i]);
  }
  Close(hFileHandle, nIoResult);


  /*nFileSize=22*sizeof(BPgm1one);
  OpenRead(hFileHandle, nIoResult, FIELD, nFileSize);

  ReadFloat(hFileHandle, nIoResult, BPgm1one);
  ReadFloat(hFileHandle, nIoResult, BPgm1two);
  ReadFloat(hFileHandle, nIoResult, BPgm1three);
  ReadFloat(hFileHandle, nIoResult, BPgm1four);
  ReadFloat(hFileHandle, nIoResult, BPgm1five);
  ReadFloat(hFileHandle, nIoResult, BPgm1six);

  ReadFloat(hFileHandle, nIoResult, BPgm2one);

  ReadFloat(hFileHandle, nIoResult, BPgm3one);

  ReadFloat(hFileHandle, nIoResult, BPgm4one);
  ReadFloat(hFileHandle, nIoResult, BPgm4two);
  ReadFloat(hFileHandle, nIoResult, BPgm4three);

  ReadFloat(hFileHandle, nIoResult, RPgm1one);
  ReadFloat(hFileHandle, nIoResult, RPgm1two);
  ReadFloat(hFileHandle, nIoResult, RPgm1three);
  ReadFloat(hFileHandle, nIoResult, RPgm1four);
  ReadFloat(hFileHandle, nIoResult, RPgm1five);
  ReadFloat(hFileHandle, nIoResult, RPgm1six);

  ReadFloat(hFileHandle, nIoResult, RPgm2one);

  ReadFloat(hFileHandle, nIoResult, RPgm3one);

  ReadFloat(hFileHandle, nIoResult, RPgm4one);
  ReadFloat(hFileHandle, nIoResult, RPgm4two);
  ReadFloat(hFileHandle, nIoResult, RPgm4three);

  Close(hFileHandle, nIoResult);*/

}
Example #3
0
task main()
{
	Task_Kill(displayDiagnostics);
	Display_Clear();
	initializeGlobalVariables(); // Defined in "initialize.h", this intializes all struct members.

	const int finish_delay = 4*1000; // MAGIC_NUM: milliseconds to delay when program ends. // TODO: Figure out why the delay is nowhere near this.
	TFileHandle IO_handle;
	TFileIOResult IO_result;
	const string filename = "_reset_pods.txt";
	const string filename_temp = "_reset_pods_tmp.txt"; // temp makes the filename too long??
	int file_size = 0;
	short rotation[POD_NUM] = {0,0,0,0};


	// Read in all the values of the pods from a text file.
	OpenRead(IO_handle, IO_result, filename, file_size); // TODO: Add more error handling.
	if (IO_result==ioRsltSuccess) {
		nxtDisplayTextLine(0, "Read from file");
		nxtDisplayTextLine(1, "\"_reset_pods.txt\"");
	} else if (IO_result==ioRsltFileNotFound) {
		OpenRead(IO_handle, IO_result, filename_temp, file_size); // TODO: Add more error handling.
		if (IO_result==ioRsltSuccess) {
			nxtDisplayTextLine(0, "Read from file");
			nxtDisplayTextLine(1, "\"_pods_tmp.txt\"");
		} else if (	(IO_result==ioRsltFileNotFound)	||
					(IO_result==ioRsltNoSpace)		||
					(IO_result==ioRsltNoMoreFiles)	) {
			nxtDisplayTextLine(2, "No data file.");
			nxtDisplayTextLine(3, "Terminating.");
			Time_Wait(finish_delay);
			return; // The only way to break out of this function?
		}
	} else if ((IO_result==ioRsltNoSpace)||(IO_result==ioRsltNoMoreFiles)) {
		nxtDisplayTextLine(2, "No data file.");
		nxtDisplayTextLine(3, "Terminating.");
		Time_Wait(finish_delay);
		return; // The only way to break out of this function?
	}
	for (int i=POD_FR; i<(int)POD_NUM; i++) {
		ReadShort(IO_handle, IO_result, rotation[i]);
	}
	Close(IO_handle, IO_result);

	nxtDisplayTextLine(3, "FL:%5d FR:%5d", rotation[POD_FL], rotation[POD_FR]);
	nxtDisplayTextLine(4, "BL:%5d BR:%5d", rotation[POD_BL], rotation[POD_BR]);

	nxtDisplayCenteredTextLine(6, "Press [ENTER] to");
	nxtDisplayCenteredTextLine(7, "end program.");
	do {
		Buttons_UpdateData();
		Time_Wait(100); // MAGIC_NUM: Arbitrary LCD refresh delay.
	} while (Buttons_Released(NXT_BUTTON_YES)==false);
}
Example #4
0
	InputStreamPtr Directory::OpenRead(const String& fileName) {
		String path;
		if (paths.length()) {
			MultiStringHelper pathsL(paths);
			MultiStringHelper::Iterator it = pathsL.Iterate();
			while (it.HasNext(path)) {
				InputStreamPtr ptr = OpenRead(path, fileName);
				if (ptr)
					return ptr;
			}
		}
		else
			return OpenRead("", fileName);
		return InputStreamPtr();
	}
Example #5
0
boolean CA_LoadFile(const char *filename, memptr *ptr)
{
	int handle;
	ssize_t l;
	long size;

	if ((handle = OpenRead(filename)) == -1)
		return false;

	size = ReadLength(handle);
	MM_GetPtr(ptr, size);
	
	l = ReadBytes(handle, (byte *)(*ptr), size);
	
	if (l == -1) {
		perror("CA_FarRead");
		return false;
	} else if (l == 0) { 
		fprintf(stderr, "CA_FarRead hit EOF?\n");
		return false;
	} else if (l != size) {
		fprintf(stderr, "CA_FarRead only read %d out of %ld\n", l, size);
		return false;
	}
	
	CloseRead(handle);
	
	return true;
}
bool IPlatformFile::CopyFile(const TCHAR* To, const TCHAR* From)
{
	const int64 MaxBufferSize = 1024*1024;

	TAutoPtr<IFileHandle> FromFile(OpenRead(From));
	if (!FromFile.IsValid())
	{
		return false;
	}
	TAutoPtr<IFileHandle> ToFile(OpenWrite(To));
	if (!ToFile.IsValid())
	{
		return false;
	}
	int64 Size = FromFile->Size();
	if (Size < 1)
	{
		check(Size == 0);
		return true;
	}
	int64 AllocSize = FMath::Min<int64>(MaxBufferSize, Size);
	check(AllocSize);
	uint8* Buffer = (uint8*)FMemory::Malloc(int32(AllocSize));
	check(Buffer);
	while (Size)
	{
		int64 ThisSize = FMath::Min<int64>(AllocSize, Size);
		FromFile->Read(Buffer, ThisSize);
		ToFile->Write(Buffer, ThisSize);
		Size -= ThisSize;
		check(Size >= 0);
	}
	FMemory::Free(Buffer);
	return true;
}
Example #7
0
//----handles the storage of data----//
void swapFiles()
{
	OpenWrite(hFileHandle2,nIoResultRead,sFileName2,nFileSize2);
	OpenRead(hFileHandle,nIoResult,sFileName1,nFileSize);
	float tempVar;
	char tempX, tempY, tempTheta, z;
  while(nIoResult != ioRsltEndOfFile)
  {
  	for(z = 0; z<numNeuralUnits; z++)
  	{
      ReadFloat(hFileHandle,nIoResult,tempVar);
      if(nIoResult == ioRsltEndOfFile) {break;}
      WriteFloat(hFileHandle2,nIoResultRead,tempVar);
    }
    if(nIoResult == ioRsltEndOfFile) {break;}
    ReadByte(hFileHandle, nIoResult, tempX);
    ReadByte(hFileHandle, nIoResult, tempY);
    ReadByte(hFileHandle, nIoResult, tempTheta);
    WriteByte(hFileHandle2,nIoResultRead,tempX);
    WriteByte(hFileHandle2,nIoResultRead,tempY);
    WriteByte(hFileHandle2,nIoResultRead,tempTheta);
  }
	char x;
  for(x = 0; x<numNeuralUnits; x++)
  {
    WriteFloat(hFileHandle2, nIoResult, localTemp.localArray[x]);
  }
  WriteByte(hFileHandle2, nIoResult, poseWorld.maxActivatedCell.x);
  WriteByte(hFileHandle2, nIoResult, poseWorld.maxActivatedCell.y);
  WriteByte(hFileHandle2, nIoResult, poseWorld.maxActivatedCell.theta);
  Close(hFileHandle2,nIoResultRead);
  Close(hFileHandle,nIoResult);
  Delete(sFileName1,nIoResult);
  Rename(sFileName1,nIoResult,sFileName2);
}
Example #8
0
Surface *Surface::Load(const OSChar *inFilename)
{
   FILE *file = OpenRead(inFilename);
   if (!file)
   {
      #ifdef ANDROID
      ByteArray bytes = AndroidGetAssetBytes(inFilename);
      if (bytes.Ok())
      {
         Surface *result = LoadFromBytes(bytes.Bytes(), bytes.Size());
         return result;
      }

      #endif
      return 0;
   }

   Surface *result = TryJPEG(file,0,0);
   if (!result)
   {
      rewind(file);
      result = TryPNG(file,0,0);
   }

   fclose(file);
   return result;
}
void initializeRobot()
{
	CloseAllHandles(nIoResult);												// make sure everything is closed
	wait1Msec(100);
	OpenRead(hFileHandle, nIoResult, sFileName , nFileSize);  // open the existing file
	ReadFloat(hFileHandle, nIoResult, drift);					// read a single float value from it
	ReadFloat(hFileHandle, nIoResult, Driver_Cal);		// read a single float value from it
	Close(hFileHandle, nIoResult);										// and close the file
	HTGYROsetCal(HTGYRO, Driver_Cal);									// force the GYRO driver calibration to the value from Autonomous

	disableDiagnosticsDisplay();
	StartTask(display);
	StartTask(buttons);
	StartTask(gyro);
	StartTask(Lifter);
	StartTask(lightFun);
	//StartTask(sensors);
	StartTask(grabbers);
	RequestedScreen=S_GYRO;										// default the screen display to the GYRO information
	calibrate=1;
	grabbers_state = grabbersMid;
	servo[shoulder] = SHOULDER_DOWN;
	getJoystickSettings(joystick);
	motor[lightMotor] = 50;															// reset light sensor into UP position for safety
	wait1Msec(500);
	motor[lightMotor] = 0;
	wait1Msec(400);
	return;
}
Example #10
0
void getUserControlProgram(string& sFileName)
{
    byte   nParmToReadByte[2];
    int    nFileSize;
    TFileIOResult nIoResult;
    TFileHandle hFileHandle;

    sFileName = "";
    nParmToReadByte[1] = 0;
    hFileHandle = 0;
    OpenRead(hFileHandle, nIoResult, kConfigName, nFileSize);
    if (nIoResult == ioRsltSuccess)
    {
        for (int index = 0; index < nFileSize; ++index)
        {
            ReadByte(hFileHandle, nIoResult,  nParmToReadByte[0]);
            strcat(sFileName, nParmToReadByte);
        }

        //
        // Delete the ".rxe" file extension
        //
        int nFileExtPosition;

        nFileExtPosition = strlen(sFileName) - 4;
        if (nFileExtPosition > 0)
            StringDelete(sFileName, nFileExtPosition, 4);
    }
    Close(hFileHandle, nIoResult);
    return;
}
Example #11
0
void TabularFile::ReadFromFile(const std::string & filename,
                               size_t              first_data_line,
                               size_t              n_columns,
                               bool                read_last_line)
{
  std::ifstream in_file;
  OpenRead(in_file, filename);
  std::string line;

  columns_.resize(n_columns);
  std::vector<double> data(n_columns);

  // First line in file is line number 1. Read and discard up to first_data_line
  for (size_t i = 1; i < first_data_line; ++i) {
    std::getline(in_file, line);
  }
  std::string this_line, next_line;
  std::getline(in_file, this_line);
  while(std::getline(in_file, next_line)) {
    ParseAsciiArrayFast(this_line, data.begin(), n_columns);
    for (size_t i = 0; i < n_columns; ++i) {
      columns_[i].push_back(data[i]);
    }
    this_line = next_line;
  }
  // Reading last line
  if(read_last_line) {
    ParseAsciiArrayFast(this_line, data.begin(), n_columns);
    for (size_t i = 0; i < n_columns; ++i) {
      columns_[i].push_back(data[i]);
    }
  }
}
Example #12
0
/**Creates file instance linked to filename. \sa Open.*/
File::File( const string& filename, bool writable ):
	fp(NULL), contentSize(0), validName("")
{
	if( writable )
		OpenWrite( filename );
	else
		OpenRead( filename );
}
Example #13
0
void NRLib::ReadStormBinarySurf(const std::string & filename,
                                RegularSurface<A> & surface)
{
    std::ifstream file;
    OpenRead(file, filename.c_str(), std::ios::in | std::ios::binary);

    int line = 0;

    // Header
    try {
        std::string token = ReadNext<std::string>(file, line);
        if (token != "STORMGRID_BINARY") {
            throw FileFormatError("Error reading " + filename + ", file is not "
                                  "in STORM binary format.");
        }

        int ni       = ReadNext<int>(file, line);
        int nj       = ReadNext<int>(file, line);
        double dx    = ReadNext<double>(file, line);
        double dy    = ReadNext<double>(file, line);
        double x_min = ReadNext<double>(file, line);
        double x_max = ReadNext<double>(file, line);
        double y_min = ReadNext<double>(file, line);
        double y_max = ReadNext<double>(file, line);

        double lx = x_max - x_min;
        double ly = y_max - y_min;

        if (!NRLibPrivate::Equal(lx/(ni-1), dx)) {
            throw FileFormatError("Inconsistent data in file. dx != lx/(nx-1).");
        }
        if (!NRLibPrivate::Equal(ly/(nj-1), dy)) {
            throw FileFormatError("Inconsistent data in file. dy != ly/(ny-1).");
        }

        surface.Resize(ni, nj);
        surface.SetDimensions(x_min, y_min, lx, ly);

        DiscardRestOfLine(file, line, true);
        ReadBinaryDoubleArray(file, surface.begin(), surface.GetN());

        surface.SetMissingValue(static_cast<A>(STORM_MISSING));

        if (!CheckEndOfFile(file)) {
            throw FileFormatError("File too long.");
        }

        surface.SetName(GetStem(filename));
    }
    catch (EndOfFile& ) {
        throw FileFormatError("Unexcpected end of file found while parsing "
                              " \"" + filename + "\"");
    }
    catch (Exception& e) {
        throw FileFormatError("Error parsing \"" + filename + "\" as a "
                              "STORM surface file at line " + ToString(line) + ":" + e.what() + "\n");
    }
}
bool FStreamingNetworkPlatformFile::InitializeInternal(IPlatformFile* Inner, const TCHAR* HostIP)
{
	// look for the commandline that will read files from over the network
	if (HostIP == nullptr)
	{
		UE_LOG(LogStreamingPlatformFile, Error, TEXT("No Host IP specified in the commandline."));
		bIsUsable = false;

		return false;
	}

	// optionally get the port from the command line
	int32 OverridePort;
	if (FParse::Value(FCommandLine::Get(), TEXT("fileserverport="), OverridePort))
	{
		UE_LOG(LogStreamingPlatformFile, Display, TEXT("Overriding file server port: %d"), OverridePort);
		FileServerPort = OverridePort;
	}

	// Send the filenames and timestamps to the server.
	FNetworkFileArchive Payload(NFS_Messages::GetFileList);
	FillGetFileList(Payload, true);

	// Send the directories over, and wait for a response.
	FArrayReader Response;

	if(SendPayloadAndReceiveResponse(Payload,Response))
	{
		// Receive the cooked version information.
		int32 ServerPackageVersion = 0;
		int32 ServerPackageLicenseeVersion = 0;
		ProcessServerInitialResponse(Response, ServerPackageVersion, ServerPackageLicenseeVersion);

		// Make sure we can sync a file.
		FString TestSyncFile = FPaths::Combine(*(FPaths::EngineDir()), TEXT("Config/BaseEngine.ini"));
		IFileHandle* TestFileHandle = OpenRead(*TestSyncFile);
		if (TestFileHandle != nullptr)
		{
			uint8* FileContents = (uint8*)FMemory::Malloc(TestFileHandle->Size());
			if (!TestFileHandle->Read(FileContents, TestFileHandle->Size()))
			{
				UE_LOG(LogStreamingPlatformFile, Fatal, TEXT("Could not read test file %s."), *TestSyncFile);
			}
			FMemory::Free(FileContents);
			delete TestFileHandle;
		}
		else
		{
			UE_LOG(LogStreamingPlatformFile, Fatal, TEXT("Could not open test file %s."), *TestSyncFile);
		}

		FCommandLine::AddToSubprocessCommandline( *FString::Printf( TEXT("-StreamingHostIP=%s"), HostIP ) );

		return true; 
	}

	return false; 
}
Example #15
0
bool TabularFile::CheckFile(const std::string & filename,
                            size_t            & first_data_line,
                            size_t            & n_columns,
                            bool              & read_last_line,
                            std::string       & last_line)
{
  // Check if the last line of the file consists of data
  // and make initial guess if the last line shoud be read (not reading when equal to 0 or -999)
  std::ifstream in_file0;
  OpenRead(in_file0, filename);
  last_line = FindLastNonEmptyLine(in_file0);
  std::vector<std::string> tokens = GetTokens(last_line);
  read_last_line = true;
  if (!IsType<double>(tokens[0])) {
    read_last_line = false;
  }
  else {
    for (size_t i = 0; i < tokens.size(); ++i) {
      if (!IsType<double>(tokens[i]))
        read_last_line = false;
      else {
        if(atof(tokens[i].c_str()) == 0.0 || atof(tokens[i].c_str()) == -999.0)
          read_last_line = false;
      }
    }
  }
  std::ifstream in_file;
  OpenRead(in_file, filename);

  int line_number = 0;
  std::string line;
  while (GetNextNonEmptyLine(in_file, line_number, line)) {
    std::vector<std::string> tokens = GetTokens(line);
    if (IsType<double>(tokens[0])) {
      first_data_line = line_number;
      n_columns = tokens.size();
      for (size_t i = 0; i < n_columns; ++i) {
        if (!IsType<double>(tokens[i]))
          return false;
      }
      return true;
    }
  }
  return false;
}
static
void FetchGiantStep(ZZ_pEX& g, long gs, const ZZ_pEXModulus& F)
{
   if (use_files) {
      ifstream s;
      OpenRead(s, FileName("giant", gs));
      NTL_INPUT_CHECK_ERR(s >> g);
   }
   else
Example #17
0
////////////////////////////////////////////////////////////
/// Restart the sound from the beginning
////////////////////////////////////////////////////////////
bool SoundFile::Restart()
{
    if (myData)
    {
        // Reopen from memory
        return OpenRead(myData, mySize, myNbSamples, myChannelsCount, mySampleRate);
    }
    else if (myFilename != L"")
    {
        // Reopen from file
        return OpenRead(myFilename, myNbSamples, myChannelsCount, mySampleRate);
    }
    else
    {
        // Trying to reopen a file opened in write mode... error
        std::wcerr << L"Warning : trying to restart a sound opened in write mode, which is not allowed" << std::endl;
        return false;
    }
}
float readTeleopForwards()
{
  TFileHandle hFileHandle;
  TFileIOResult nIoResult;
  float result=0;
  short nFileSize=sizeof(baseHeading);
  OpenRead(hFileHandle, nIoResult, TELEOPFORWARDSDAT, nFileSize);
  ReadFloat(hFileHandle, nIoResult, result);
  Close(hFileHandle, nIoResult);
  return result;
}
Example #19
0
static
void FetchGiantStep(ZZ_pX& g, long gs, const ZZ_pXModulus& F)
{
   if (use_files) {
      ifstream s;
   
      OpenRead(s, FileName(ZZ_pX_stem, "giant", gs));
   
      s >> g;
      s.close();
   }
   else
Example #20
0
bool Connection::StreamForPath(const util::http::Request *rq,
				   util::http::Response *rs)
{
    unsigned int generation, fid;
    if (sscanf(rq->path.c_str(), "/empeg/%u/%u", &generation, &fid) == 2
	&& generation == m_generation)
    {
	rs->body_source = OpenRead(fid);
	return true;
    }
    return false; 
}
Example #21
0
/** Read file corresponding to index (e.g., if index is 1,
    read file will be loc_01.dat), and store its signature
    into ls. ASSUMES FILE EXISTS! */
void read_signature_from_file(loc_sig& ls, short index)
{
  ASSERT(index >= 0 && index < NO_LOCS);
  TFileIOResult nIoResult;
  TFileHandle hFileHandle;
  int read_size;

  string sFileName = file_names[index];
  OpenRead(hFileHandle, nIoResult, sFileName, read_size);
  for ( short i=0; i<NO_BINS; ++i )
    ReadShort(hFileHandle, nIoResult, ls.sig[i]);

  Close(hFileHandle, nIoResult);
}
Example #22
0
/* This function reads 'threshold' and 'k' from background calibration
 * file "libCalib.dat" and wheel calibration file "compassCalib.dat" */
bool readCalib(){
  //read the max and min from file "libCalib.dat"
  TFileIOResult nIoResult;
  short filehandle;
  const string filename1 = "libCalib.dat";
  short filesize = 1000;
  OpenRead(filehandle, nIoResult, filename1, filesize);
  short min, max;
  ReadShort(filehandle, nIoResult, min);
  ReadShort(filehandle, nIoResult, max);

  //if file not existed, beep!
  if(nIoResult){
    nxtDisplayStringAt(0,31,"Please run background calibration program.");
    PlayTone(1175,15);
    wait1Msec(2000);
    return false;
  }
  Close(filehandle, nIoResult);
  threshold = (min + max) / 2; //threshold is a global variable

  //read k from file "compassCalib.dat"
  const string filename2 = "compassCalib.dat";
  OpenRead(filehandle, nIoResult, filename2, filesize);
  ReadFloat(filehandle, nIoResult, k); //k is a global variable

  //if file not existed, beep!
  if(nIoResult){
    nxtDisplayStringAt(0,31,"Please run compass calibration program.");
    PlayTone(1175,15);
    wait1Msec(2000);
    return false;
  }
  Close(filehandle,nIoResult);

  return true;
}
Example #23
0
/// Delete all loc_%%.dat files
void delete_loc_files()
{
  for ( short n=0; n<NO_LOCS; n++ )
    {
      TFileIOResult nIoResult;
      TFileHandle hFileHandle;
      int read_size;

      OpenRead(hFileHandle, nIoResult, file_names[n], read_size);
      bool exists = (nIoResult == 0);
      Close(hFileHandle, nIoResult);
      if ( exists )
	Delete(file_names[n], nIoResult);
    }
    writeDebugStreamLine("DELETING LOC FILES");
}
Example #24
0
//reads gyro position from a file written in autonomous?
int getOffset()
{
	TFileHandle hFileHandle;
	TFileIOResult nIoResult;
	int length = 3;
	string name = "data.txt";
	OpenRead(hFileHandle, nIoResult, name, length);
	if (nIoResult != 0)
		return 0;

	long offset;
	ReadLong(hFileHandle, nIoResult, offset);

	Close(hFileHandle, nIoResult);

	return offset;
}
Example #25
0
/**
 * A convenience for {@link #openRead()} that also reads all of the
 * file contents into a byte array which is returned.
 */
ECode CAtomicFile::ReadFully(
    /* [out] */ ArrayOf<Byte>** result)
{
    VALIDATE_NOT_NULL(result);
    *result = NULL;

    AutoPtr<IFileInputStream> stream;
    FAIL_RETURN(OpenRead((IFileInputStream**)&stream));

    //try {
    Int32 pos = 0;
    Int32 avail, amt;
    IInputStream::Probe(stream)->Available(&avail);
    AutoPtr<ArrayOf<Byte> > data = ArrayOf<Byte>::Alloc(avail);

    AutoPtr<ArrayOf<Byte> > newData;
    while (TRUE) {
        IInputStream::Probe(stream)->Read(data, pos,data->GetLength() - pos, &amt);
        //Log.i("foo", "Read " + amt + " bytes at " + pos
        //        + " of avail " + data.length);
        if (amt <= 0) {
            //Log.i("foo", "**** FINISHED READING: pos=" + pos
            //        + " len=" + data.length);
            goto _EXIT_;
        }

        pos += amt;
        IInputStream::Probe(stream)->Available(&avail);
        if (avail > data->GetLength() - pos) {
            newData = ArrayOf<Byte>::Alloc(pos + avail);
            newData->Copy(data, 0, pos);
            data = newData;
        }
    }

    *result = data;
    REFCOUNT_ADD(*result);
_EXIT_:
    //} finally {
        ICloseable::Probe(stream)->Close();
    //}
    return NOERROR;
}
Example #26
0
static void PML_OpenPageFile()
{
	int i;
	PageListStruct *page;
	char fname[13];

	strcpy(fname, pfilename);

	if (w0 == true || w1 == true || s0 == true || s1 == true){
		strcat(fname, extension);
	} else {
		strcat(fname, extension2);
	}

	PageFile = OpenRead(fname);
	if (PageFile == -1)
		Quit("PML_OpenPageFile: Unable to open page file");

	/* Read in header variables */
	ChunksInFile = ReadInt16(PageFile);
	PMSpriteStart = ReadInt16(PageFile);
	PMSoundStart = ReadInt16(PageFile);

	/* Allocate and clear the page list */
	MM_GetPtr((memptr)&PMPages, sizeof(PageListStruct) * ChunksInFile);
	MM_SetLock((memptr)&PMPages, true);
	
	memset(PMPages, 0, sizeof(PageListStruct) * ChunksInFile);

	/* Read in the chunk offsets */
	for (i = 0, page = PMPages; i < ChunksInFile; i++, page++) {
		page->offset = ReadInt32(PageFile);
	}
		
	/* Read in the chunk lengths */
	for (i = 0, page = PMPages; i < ChunksInFile; i++, page++) {	
		page->length = ReadInt16(PageFile);
	}
}
Example #27
0
/** Given that some location files have been stored, and given
    that at most NO_LOCS are going to be learned, what is the
    next location index that is expected to be written? For instance,
    if 2 locations out of 3 have already been recorded in files
    loc_00.dat and loc_01.dat, then, the next "free" index for
    naming a file would be 2, and the corresponding file would be
    loc_02.dat */
short find_next_loc_index()
{
  short n = 0;
  while ( n<NO_LOCS )
    {
      TFileIOResult nIoResult;
      TFileHandle hFileHandle;
      int read_size;

      OpenRead(hFileHandle, nIoResult, file_names[n], read_size);
      bool exists = (nIoResult == 0);
      Close(hFileHandle, nIoResult);
      if ( !exists )
	{
	  Delete(file_names[n], nIoResult);
	  break;
	}
      else
	n++;
    }

  return n;
}
Example #28
0
task main()
{
	CloseAllHandles(nIoResult);																// make sure everything is closed
	wait1Msec(500);
	OpenRead(hFileHandle, nIoResult, sFileName , nFileSize);  // open the existing file
	ReadFloat(hFileHandle, nIoResult, fParmToReadFloat);			// read a single float value from it
	Close(hFileHandle, nIoResult);														// and close the file

	while(nNxtButtonPressed!=3)   // continue in editor until enter button is pressed
	{if (nNxtButtonPressed==1)
		{
			while(nNxtButtonPressed==1){};  // right arrow increases value
			fParmToReadFloat+=1;
		}
		if (nNxtButtonPressed==2)
		{
			while(nNxtButtonPressed==2){};  // left arrow decreases value
			fParmToReadFloat-=1;
		}
		nxtDisplayCenteredBigTextLine(6, "%3.1f", fParmToReadFloat); // update the display
	}

	Delete(sFileName, nIoResult);							// delete pre-existing file (if any)
	nxtDisplayBigTextLine(0, "Deleted");
	wait1Msec(2000);
	nFileSize = 100;
	OpenWrite(  hFileHandle, nIoResult, sFileName, nFileSize); // create new file
	nxtDisplayBigTextLine(2, "Opened");
	wait1Msec(2000);
	WriteFloat( hFileHandle, nIoResult, fParmToReadFloat);  // write our value
	nxtDisplayBigTextLine(4, "Written");
	wait1Msec(2000);
	Close(hFileHandle, nIoResult);				// and close the file
	nxtDisplayBigTextLine(6, "Closed");
	wait1Msec(2000);
}
Example #29
0
//----Checks if there is a match, add activities, else creates a new association----//
void checkLocalCell()
{
	//uses a normalised version of the localTemp.  The comparison local cells are stored as normalised when 1st created
	char z;
	char breakSymbol =0;
	signed char cellCount = 0;
	char match = 0;
	float dotTempValue = 0;
	float tempAngle = 0;
	if(nextEmptyCell == 0)
	{
	  //first localCellView
		writeLocal();
    nextEmptyCell++;
    PlaySound(soundFastUpwardTones);
    while(bSoundActive) {}
	}
  else {
  OpenRead(hFileHandle3,nIoResultRead,sFileName1,nFileSize);
  while(nIoResultRead != ioRsltEndOfFile)
    {
    	//search for a previous local cell that matches the current view to a certain degree
    	for(z = 0; z<numNeuralUnits; z++)
    	{
    		ReadFloat(hFileHandle3,nIoResultRead,localComparison.localArray[z]);
    		if(nIoResultRead == ioRsltEndOfFile) {breakSymbol = 1;break;}
    	}
    	if(breakSymbol == 1) {break;}
      ReadByte(hFileHandle3, nIoResultRead, injectX);
      ReadByte(hFileHandle3, nIoResultRead, injectY);
      ReadByte(hFileHandle3, nIoResultRead, injectTheta);

      dotTempValue = dotMultiply();
      tempAngle = acos(dotTempValue);
      if(tempAngle<0.17)//0.17 //if difference less than 10 degrees between vectors
      {
      	match = 1;
      	Close(hFileHandle3,nIoResultRead);
      	break; //save cycles break out
      }
      cellCount++;
    }
    if(match == 0)
    {//no match found - create a new local view cell
      Close(hFileHandle3,nIoResultRead);
      swapFiles();
    	nextEmptyCell++;
      PlaySound(soundFastUpwardTones);
      while(bSoundActive) {}
    }
    else if(match == 1)
    {
    	injectEnergy(stepSize, injectX, injectY, injectTheta);
    	nxtDisplayStringAt(64,30,"x: %2d",injectX);
	    nxtDisplayStringAt(64,20,"y: %2d",injectY);
	    nxtDisplayStringAt(64,10,"T: %1d",injectTheta);
      PlaySound(soundBeepBeep);
      while(bSoundActive) {}
    }
  }
}
Example #30
0
FILE *OpenRead(const char *inUtf8Name)
{
   WString wide = UTF8ToWide(inUtf8Name);
   return OpenRead( wide.c_str() );
}