diff -r 86ebf18a029f -r 2c3ccdde3919 tool/CommandRegWrite.cpp
--- a/tool/CommandRegWrite.cpp	Wed Nov 14 22:08:32 2012 +0100
+++ b/tool/CommandRegWrite.cpp	Wed Nov 14 22:12:57 2012 +0100
@@ -2,7 +2,7 @@
  *
  *  $Id$
  *
- *  Copyright (C) 2006-2009  Florian Pose, Ingenieurgemeinschaft IgH
+ *  Copyright (C) 2006-2012  Florian Pose, Ingenieurgemeinschaft IgH
  *
  *  This file is part of the IgH EtherCAT Master.
  *
@@ -57,7 +57,7 @@
         << "This command requires a single slave to be selected." << endl
         << endl
         << "Arguments:" << endl
-        << "  OFFSET  is the register address to write to." << endl
+        << "  ADDRESS is the register address to write to." << endl
         << "  DATA    depends on whether a datatype was specified" << endl
         << "          with the --type option: If not, DATA must be" << endl
         << "          either a path to a file with data to write," << endl
@@ -83,7 +83,7 @@
 void CommandRegWrite::execute(const StringVector &args)
 {
     stringstream strOffset, err;
-    ec_ioctl_slave_reg_t data;
+    ec_ioctl_slave_reg_t io;
     ifstream file;
     SlaveList slaves;
 
@@ -95,22 +95,22 @@
     strOffset << args[0];
     strOffset
         >> resetiosflags(ios::basefield) // guess base from prefix
-        >> data.offset;
+        >> io.address;
     if (strOffset.fail()) {
-        err << "Invalid offset '" << args[0] << "'!";
+        err << "Invalid address '" << args[0] << "'!";
         throwInvalidUsageException(err);
     }
 
     if (getDataType().empty()) {
         if (args[1] == "-") {
-            loadRegData(&data, cin);
+            loadRegData(&io, cin);
         } else {
             file.open(args[1].c_str(), ifstream::in | ifstream::binary);
             if (file.fail()) {
                 err << "Failed to open '" << args[1] << "'!";
                 throwCommandException(err);
             }
-            loadRegData(&data, file);
+            loadRegData(&io, file);
             file.close();
         }
     } else {
@@ -123,30 +123,30 @@
         }
 
         if (dataType->byteSize) {
-            data.length = dataType->byteSize;
+            io.size = dataType->byteSize;
         } else {
-            data.length = 1024; // FIXME
-        }
-
-        data.data = new uint8_t[data.length];
+            io.size = 1024; // FIXME
+        }
+
+        io.data = new uint8_t[io.size];
 
         try {
-            data.length = interpretAsType(
-                    dataType, args[1], data.data, data.length);
+            io.size = interpretAsType(
+                    dataType, args[1], io.data, io.size);
         } catch (SizeException &e) {
-            delete [] data.data;
+            delete [] io.data;
             throwCommandException(e.what());
         } catch (ios::failure &e) {
-            delete [] data.data;
+            delete [] io.data;
             err << "Invalid value argument '" << args[1]
                 << "' for type '" << dataType->name << "'!";
             throwInvalidUsageException(err);
         }
     }
 
-    if ((uint32_t) data.offset + data.length > 0xffff) {
-        err << "Offset and length exceeding 64k!";
-        delete [] data.data;
+    if ((uint32_t) io.address + io.size > 0xffff) {
+        err << "Address and size exceeding 64k!";
+        delete [] io.data;
         throwInvalidUsageException(err);
     }
 
@@ -154,22 +154,22 @@
     try {
         m.open(MasterDevice::ReadWrite);
     } catch (MasterDeviceException &e) {
-        delete [] data.data;
+        delete [] io.data;
         throw e;
     }
 
     slaves = selectedSlaves(m);
     if (slaves.size() != 1) {
-        delete [] data.data;
+        delete [] io.data;
         throwSingleSlaveRequired(slaves.size());
     }
-    data.slave_position = slaves.front().position;
+    io.slave_position = slaves.front().position;
 
     // send data to master
     try {
-        m.writeReg(&data);
+        m.writeReg(&io);
     } catch (MasterDeviceException &e) {
-        delete [] data.data;
+        delete [] io.data;
         throw e;
     }
 
@@ -177,13 +177,13 @@
         cerr << "Register writing finished." << endl;
     }
 
-    delete [] data.data;
+    delete [] io.data;
 }
 
 /*****************************************************************************/
 
 void CommandRegWrite::loadRegData(
-        ec_ioctl_slave_reg_t *data,
+        ec_ioctl_slave_reg_t *io,
         const istream &in
         )
 {
@@ -201,11 +201,11 @@
         err << "Invalid data size " << contents.size() << "!";
         throwInvalidUsageException(err);
     }
-    data->length = contents.size();
+    io->size = contents.size();
 
     // allocate buffer and read file into buffer
-    data->data = new uint8_t[data->length];
-    contents.copy((char *) data->data, contents.size());
-}
-
-/*****************************************************************************/
+    io->data = new uint8_t[io->size];
+    contents.copy((char *) io->data, contents.size());
+}
+
+/*****************************************************************************/