char * filename = "testFile";
char readBuffer[128];

void testLongs()
{
   writeDebugStreamLine("Testing Longs");

   long fileHandle;

   long writeValue = 0x11DD0000;
   long readValue;

   fileHandle = fileOpenWrite(filename);
   for (int i = 0; i < 10; i++)
   {
      fileWriteLong(fileHandle, writeValue++);
   }
   writeDebugStreamLine("fileHandle: %d", fileHandle);
   fileClose(fileHandle);

   fileHandle = fileOpenRead(filename);
   while (fileReadLong(fileHandle, &readValue))
   {
      writeDebugStreamLine("Read: 0x%X", readValue);
   }
   fileClose(fileHandle);
}

void testFloats()
{
   writeDebugStreamLine("Testing Floats");


   long fileHandle;

   float writeValue = 8.167;
   float readValue;

   fileHandle = fileOpenWrite(filename);
   for (int i = 0; i < 10; i++)
   {
      fileWriteFloat(fileHandle, writeValue);
      writeValue*=5;
   }
   writeDebugStreamLine("fileHandle: %d", fileHandle);
   fileClose(fileHandle);

   fileHandle = fileOpenRead(filename);
   while (fileReadFloat(fileHandle, &readValue))
   {
      writeDebugStreamLine("Read: %f", readValue);
   }
   fileClose(fileHandle);
}

void testShorts()
{
   writeDebugStreamLine("Testing Shorts");


   long fileHandle;

   short writeValue = 2;
   short readValue;

   fileHandle = fileOpenWrite(filename);
   for (int i = 0; i < 10; i++)
   {
      fileWriteShort(fileHandle, writeValue);
      writeValue*=2;
   }
   writeDebugStreamLine("fileHandle: %d", fileHandle);
   fileClose(fileHandle);

   fileHandle = fileOpenRead(filename);
   while (fileReadShort(fileHandle, &readValue))
   {
      writeDebugStreamLine("Read: %d", readValue);
   }
   fileClose(fileHandle);
}

void testChars()
{
   writeDebugStreamLine("Testing Chars");


   long fileHandle;

   char writeValue = 1;
   char readValue;

   fileHandle = fileOpenWrite(filename);
   for (int i = 0; i < 10; i++)
   {
      fileWriteChar(fileHandle, writeValue);
      writeValue+=5;
   }
   writeDebugStreamLine("fileHandle: %d", fileHandle);
   fileClose(fileHandle);

   fileHandle = fileOpenRead(filename);
   while (fileReadChar(fileHandle, &readValue))
   {
      writeDebugStreamLine("Read: %d", readValue);
   }
   fileClose(fileHandle);
}

void testData()
{
   writeDebugStreamLine("Testing Data");

   long fileHandle;

   char * string1 = "I like peanutbutter";
   int strlen1 = strlen(string1);

   char * string2 = "ROBOTC is cool";
   int strlen2 = strlen(string2);

   fileHandle = fileOpenWrite(filename);
   writeDebugStreamLine("fileHandle: %d", fileHandle);

   writeDebugStreamLine("strlen1: %d", strlen1);
   fileWriteData(fileHandle, string1, strlen1 + 1); // gets the 0 terminator as well
   fileWriteData(fileHandle, string2, strlen2 + 1); // gets the 0 terminator as well

   fileClose(fileHandle);

   fileHandle = fileOpenRead(filename);
   memset(readBuffer, 0, 128);
   fileReadData(fileHandle, readBuffer, strlen1 + 1);
   writeDebugStreamLine(readBuffer);
   fileReadData(fileHandle, readBuffer, strlen2 + 1);
   writeDebugStreamLine(readBuffer);

   fileClose(fileHandle);
}


task main()
{
   testLongs();
   testFloats();
   testShorts();
   testChars();
   testData();
}

// Open a file for reading (really a define that calls _OpenFile() with the right ev3FileFlags)
// File name can contain a path, but this will be ignored.  All ROBOTC data files like this
// reside under /home/root/lms2012/prjs/rc-data.  This cannot be changed and sub folders
// are not supported.
// Returns a file descriptor, which is used for writing and subsequently closing the file
#define fileOpenWrite(X) _OpenFile(X, fileFlagWriteOnly|fileFlagCreate|fileFlagTruncate)

// Open a file writing (really a define that calls _OpenFile() with the right ev3FileFlags)
// File name can contain a path, but this will be ignored.  All ROBOTC data files like this
// reside under /home/root/lms2012/prjs/rc-data.  This cannot be changed and sub folders
// are not supported.
// Returns a file descriptor, which is used for reading and subsequently closing the file
#define fileOpenRead(X)    _OpenFile(X, fileFlagReadOnly)

// this is an "internal" function and should not be used directly, returns a file descriptor
// The flags are one or more of the ones in ev3FileFlags, OR'd together.
intrinsic long _OpenFile(const char *pzFileName, ev3FileFlags nFlags);

// Close the file. Returns true if the close() went off without an issue, false if it didn't.
intrinsic bool fileClose(long nFileDescriptor);

// Write a signed long value to the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileWriteLong(long nFileDescriptor, long data);

// Read a signed long value from the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileReadLong(long nFileDescriptor, long *pData);

// Write a float value to the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileWriteFloat(long nFileDescriptor, float data);

// Read a float value from the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileReadFloat(long nFileDescriptor, float *pData);

// Write a signed 2 byte (short) value to the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileWriteShort(long nFileDescriptor, short data);

// Read a signed 2 byte (short) value from the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileReadShort(long nFileDescriptor, short *pData);

// Write an unsigned single byte value to the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileWriteChar(long nFileDescriptor, char data);

// Read an unsigned single byte value from the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileReadChar(long nFileDescriptor, char *pData);

// Write arbitrary data to the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic bool fileWriteData(long nFileDescriptor, char *pData, long nWriteLen);

// Read arbitrary data from the file descriptor
// Returns true if action did not cause an error, false if it did
intrinsic long fileReadData(long nFileDescriptor, char *pData, long nReadLen);

// Open a datalog file for writing to. Datalog files are named datalog-<datalogIndex>.txt
// The file has a comma separated values (CSV) format with the specified number of columns.
// If the append flag is set to false or omitted, an existing log file will be truncated and overwritten.
// Please note that if the old datalog file contains a different number of columns and the append
// flag is set to "true", the resulting CSV file may become useless.
// All ROBOTC data files like this reside under /home/root/lms2012/prjs/rc-data.
// This cannot be changed and sub folders are not supported.
// Returns true if action did not cause an error, false if it did
intrinsic bool datalogOpen(long nDatalogIndex, long nColumns, bool bAppend = false)
      asm(opcdEV3_ROBOTC, ev3Fcn_DatalogOpen, variable(nDatalogIndex), variable(nColumns), variable(bAppend), functionReturn);

// Flush the buffers and close the datalog file
// Returns true if action did not cause an error, false if it did
intrinsic bool datalogClose()
      asm(opcdEV3_ROBOTC, ev3Fcn_DatalogClose, functionReturn);

// Flush the buffers to the datalog file.  Useful if the program has a bug and
// crashes or exits before the datalogClose(); could be called.  Reduces the chance
// of partial writes to the log file.
// Returns true if action did not cause an error, false if it did
intrinsic bool datalogFlush()
      asm(opcdEV3_ROBOTC, ev3Fcn_DatalogFlush, functionReturn);

// Add a signed, unsingle byte value to the datalog on the specified column.
// Columns are numbered from 0
// Returns true if action did not cause an error, false if it did
intrinsic bool datalogAddChar(long nIndex, char data)
      asm(opcdEV3_ROBOTC, ev3Fcn_DatalogAddChar, variable(nIndex), variable(data), functionReturn);

// Add a signed,2-byte (short) value to the datalog on the specified column.
// Columns are numbered from 0
// Returns true if action did not cause an error, false if it did
intrinsic bool datalogAddShort(long nIndex, short data)
      asm(opcdEV3_ROBOTC, ev3Fcn_DatalogAddShort, variable(nIndex), variable(data), functionReturn);

// Add a signed, 4-byte (long) value to the datalog on the specified column.
// Columns are numbered from 0
// Returns true if action did not cause an error, false if it did
intrinsic bool datalogAddLong(long nIndex, long data)
      asm(opcdEV3_ROBOTC, ev3Fcn_DatalogAddLong, variable(nIndex), variable(data), functionReturn);

// Add a float value to the datalog on the specified column.
// Columns are numbered from 0
// Returns true if action did not cause an error, false if it did
intrinsic bool datalogAddFloat(long nIndex, float data)
      asm(opcdEV3_ROBOTC, ev3Fcn_DatalogAddFloat, variable(nIndex), variable(data), functionReturn);

task main()
{
   // The first argument is a datalog index number.
   // The filename will be saved in the rc-data folder as
   // datalog-<INDEX>.txt
   // The format is a comma separated value file.
   // The 2nd argument is the number of columns you wish to have in the file
   // The 3rd argument specifies if you wish to append to the datalog, if it
   // exists.
   if (!datalogOpen(0, 4, false))
      writeDebugStreamLine("Unable to open datalog");

   // You can add an entry at the specified column number
   for (int i = 0;i < 2; i++)
   {
      datalogAddChar(0, 1 + i);
      datalogAddShort(1, 9000 + i);
      datalogAddLong(2, 2388738 + i);
      datalogAddFloat(3, 678.98 / i);
   }

   // Make sure you close the file properly
   datalogClose();
}