Merge pull request #39 from sodabrew/commandline_warnings

Commandline warnings

3 files changed, 90 insertions, 75 deletions

diff --git a/commandline/Makefile b/commandline/Makefile
index af9a9ee..b5bea87 100644
--- a/commandline/Makefile
+++ b/commandline/Makefile
@@ -1,17 +1,17 @@
 # Makefile initially writen for Little-Wire by Omer Kilic <omerkilic@gmail.com>
-# Later on modified by ihsan Kehribar <ihsan@kehribar.me> for Micronucleus bootloader application. 
+# Later on modified by ihsan Kehribar <ihsan@kehribar.me> for Micronucleus bootloader application.
 
 CC=gcc
 
 # FIXME: Need to add OSX stuff
 ifeq ($(shell uname), Linux)
-	USBFLAGS = `libusb-config --cflags`
-	USBLIBS = `libusb-config --libs`
+	USBFLAGS=$(shell libusb-config --cflags)
+	USBLIBS=$(shell libusb-config --libs)
 	EXE_SUFFIX =
 	OSFLAG = -D LINUX
 else ifeq ($(shell uname), Darwin)
-	USBFLAGS = `libusb-config --cflags`
-	USBLIBS = `libusb-config --libs`
+	USBFLAGS=$(shell libusb-config --cflags || libusb-legacy-config --cflags)
+	USBLIBS=$(shell libusb-config --libs || libusb-legacy-config --libs)
 	EXE_SUFFIX =
 	OSFLAG = -D MAC_OS
 else
@@ -36,7 +36,7 @@ library: $(LWLIBS)
 
 $(LWLIBS):
 	@echo Building library: $@...
-	$(CC) $(CFLAGS) -c library/$@.c 
+	$(CC) $(CFLAGS) -c library/$@.c
 
 $(EXAMPLES): $(addsuffix .o, $(LWLIBS))
 	@echo Building example: $@...
diff --git a/commandline/examples/micronucleus.c b/commandline/examples/micronucleus.c
index 46fbe67..0f2000c 100644
--- a/commandline/examples/micronucleus.c
+++ b/commandline/examples/micronucleus.c
@@ -1,7 +1,7 @@
 /*
   Created: September 2012
   by ihsan Kehribar <ihsan@kehribar.me>
-  
+
   Permission is hereby granted, free of charge, to any person obtaining a copy of
   this software and associated documentation files (the "Software"), to deal in
   the Software without restriction, including without limitation the rights to
@@ -18,13 +18,14 @@
   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.  
+  SOFTWARE.
 */
 
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
+#include <time.h>
 #include "micronucleus_lib.h"
 #include "littleWire_util.h"
 
@@ -33,7 +34,7 @@
 #define CONNECT_WAIT 250 /* milliseconds to wait after detecting device on usb bus - probably excessive */
 
 /******************************************************************************
-* Global definitions 
+* Global definitions
 ******************************************************************************/
 unsigned char dataBuffer[65536 + 256];    /* buffer for file data */
 /*****************************************************************************/
@@ -41,8 +42,8 @@ unsigned char dataBuffer[65536 + 256];    /* buffer for file data */
 /******************************************************************************
 * Function prototypes
 ******************************************************************************/
-static int parseRaw(char *hexfile, char* buffer, int *startAddr, int *endAddr);
-static int parseIntelHex(char *hexfile, char* buffer, int *startAddr, int *endAddr); /* taken from bootloadHID example from obdev */
+static int parseRaw(char *hexfile, unsigned char *buffer, int *startAddr, int *endAddr);
+static int parseIntelHex(char *hexfile, unsigned char *buffer, int *startAddr, int *endAddr); /* taken from bootloadHID example from obdev */
 static int parseUntilColon(FILE *fp); /* taken from bootloadHID example from obdev */
 static int parseHex(FILE *fp, int numDigits); /* taken from bootloadHID example from obdev */
 static void printProgress(float progress);
@@ -53,7 +54,7 @@ static char* progress_friendly_name; // name of progress section
 static int dump_progress = 0; // output computer friendly progress info
 static int use_ansi = 0; // output ansi control character stuff
 static int erase_only = 0; // only erase, dont't write file
-static int timeout = 0; // 
+static int timeout = 0;
 /*****************************************************************************/
 
 /******************************************************************************
@@ -63,7 +64,7 @@ int main(int argc, char **argv) {
   int res;
   char *file = NULL;
   micronucleus *my_device = NULL;
-  
+
   // parse arguments
   int run = 0;
   int file_type = FILE_TYPE_INTEL_HEX;
@@ -79,7 +80,7 @@ int main(int argc, char **argv) {
   //#else
     use_ansi = 1;
   //#endif
-  
+
   while (arg_pointer < argc) {
     if (strcmp(argv[arg_pointer], "--run") == 0) {
       run = 1;
@@ -127,41 +128,41 @@ int main(int argc, char **argv) {
     } else {
       file = argv[arg_pointer];
     }
-    
+
     arg_pointer += 1;
   }
-  
+
   if (argc < 2) {
     puts(usage);
     return EXIT_FAILURE;
   }
-  
+
   setProgressData("waiting", 1);
   if (dump_progress) printProgress(0.5);
   printf("> Please plug in the device ... \n");
   printf("> Press CTRL+C to terminate the program.\n");
-  
-  
+
+
   time_t start_time, current_time;
   time(&start_time);
-  
+
   while (my_device == NULL) {
     delay(100);
     my_device = micronucleus_connect();
-    
+
     time(&current_time);
     if (timeout && start_time + timeout < current_time) {
       break;
     }
   }
-  
+
   if (my_device == NULL) {
     printf("> Device search timed out\n");
     return EXIT_FAILURE;
   }
-  
+
   printf("> Device is found!\n");
-  
+
   // wait for CONNECT_WAIT milliseconds with progress output
   float wait = 0.0f;
   setProgressData("connecting", 2);
@@ -170,10 +171,10 @@ int main(int argc, char **argv) {
     wait += 50.0f;
     delay(50);
   }
-  
+
   //my_device = micronucleus_connect();
   printProgress(1.0);
-    
+
   // if (my_device->page_size == 64) {
   //   printf("> Device looks like ATtiny85!\n");
   // } else if (my_device->page_size == 32)  {
@@ -182,12 +183,12 @@ int main(int argc, char **argv) {
   //   printf("> Unsupported device!\n");
   //   return EXIT_FAILURE;
   // }
-  
+
   printf("> Available space for user application: %d bytes\n", my_device->flash_size);
   printf("> Suggested sleep time between sending pages: %ums\n", my_device->write_sleep);
   printf("> Whole page count: %d\n", my_device->pages);
   printf("> Erase function sleep duration: %dms\n", my_device->erase_sleep);
-  
+
   int startAddress = 1, endAddress = 0;
 
   if (!erase_only)
@@ -195,7 +196,7 @@ int main(int argc, char **argv) {
     setProgressData("parsing", 3);
     printProgress(0.0);
     memset(dataBuffer, 0xFF, sizeof(dataBuffer));
-    
+
     if (file_type == FILE_TYPE_INTEL_HEX) {
       if (parseIntelHex(file, dataBuffer, &startAddress, &endAddress)) {
         printf("> Error loading or parsing hex file.\n");
@@ -207,52 +208,64 @@ int main(int argc, char **argv) {
         return EXIT_FAILURE;
       }
     }
-    
+
     printProgress(1.0);
 
     if (startAddress >= endAddress) {
       printf("> No data in input file, exiting.\n");
       return EXIT_FAILURE;
     }
-          
+
     if (endAddress > my_device->flash_size) {
       printf("> Program file is %d bytes too big for the bootloader!\n", endAddress - my_device->flash_size);
       return EXIT_FAILURE;
     }
-  } 
-  
+  }
+
+  printProgress(1.0);
+
+  if (startAddress >= endAddress) {
+    printf("> No data in input file, exiting.\n");
+    return EXIT_FAILURE;
+  }
+
+  if (endAddress > my_device->flash_size) {
+    printf("> Program file is %d bytes too big for the bootloader!\n", endAddress - my_device->flash_size);
+    return EXIT_FAILURE;
+  }
+
   setProgressData("erasing", 4);
   printf("> Erasing the memory ...\n");
   res = micronucleus_eraseFlash(my_device, printProgress);
-  
+
   if (res == 1) { // erase disconnection bug workaround
     printf(">> Eep! Connection to device lost during erase! Not to worry\n");
     printf(">> This happens on some computers - reconnecting...\n");
     my_device = NULL;
-    
+
     delay(CONNECT_WAIT);
-    
+
     int deciseconds_till_reconnect_notice = 50; // notice after 5 seconds
     while (my_device == NULL) {
       delay(100);
       my_device = micronucleus_connect();
       deciseconds_till_reconnect_notice -= 1;
-      
+
       if (deciseconds_till_reconnect_notice == 0) {
         printf(">> (!) Automatic reconnection not working. Unplug and reconnect\n");
         printf("   device usb connector, or reset it some other way to continue.\n");
       }
     }
-    
+
     printf(">> Reconnected! Continuing upload sequence...\n");
-    
+
   } else if (res != 0) {
     printf(">> Flash erase error %d has occured ...\n", res);
     printf(">> Please unplug the device and restart the program.\n");
     return EXIT_FAILURE;
   }
   printProgress(1.0);
-  
+
   if (!erase_only)
   {
     printf("> Starting to upload ...\n");
@@ -264,26 +277,26 @@ int main(int argc, char **argv) {
       return EXIT_FAILURE;
     }
   }
-  
+
   if (run) {
-    
+
     printf("> Starting the user app ...\n");
     setProgressData("running", 6);
     printProgress(0.0);
-    
+
     res = micronucleus_startApp(my_device);
-    
+
     if (res != 0) {
       printf(">> Run error %d has occured ...\n", res);
       printf(">> Please unplug the device and restart the program. \n");
       return EXIT_FAILURE;
     }
-    
+
     printProgress(1.0);
   }
-  
+
   printf(">> Micronucleus done. Thank you!\n");
-  
+
   return EXIT_SUCCESS;
 }
 /******************************************************************************/
@@ -292,7 +305,7 @@ int main(int argc, char **argv) {
 static void printProgress(float progress) {
   static int last_step;
   static int last_integer_total_progress;
-  
+
   if (dump_progress) {
     printf("{status:\"%s\",step:%d,steps:%d,progress:%f}\n", progress_friendly_name, progress_step, progress_total_steps, progress);
   } else {
@@ -303,17 +316,17 @@ static void printProgress(float progress) {
         printf("\r"); // return carriage to start of line so we can type over existing text
       #endif
     }
-    
+
     float total_progress = ((float) progress_step - 1.0f) / (float) progress_total_steps;
     total_progress += progress / (float) progress_total_steps;
     int integer_total_progress = total_progress * 100.0f;
-    
+
     if (use_ansi || integer_total_progress >= last_integer_total_progress + 5) {
       printf("%s: %d%% complete\n", progress_friendly_name, integer_total_progress);
       last_integer_total_progress = integer_total_progress;
     }
   }
-  
+
   last_step = progress_step;
 }
 
@@ -326,11 +339,11 @@ static void setProgressData(char* friendly, int step) {
 /******************************************************************************/
 static int parseUntilColon(FILE *file_pointer) {
   int character;
-  
+
   do {
     character = getc(file_pointer);
   } while(character != ':' && character != EOF);
-  
+
   return character;
 }
 /******************************************************************************/
@@ -344,22 +357,22 @@ static int parseHex(FILE *file_pointer, int num_digits) {
     temp[iter] = getc(file_pointer);
   }
   temp[iter] = 0;
-  
+
   return strtol(temp, NULL, 16);
 }
 /******************************************************************************/
 
 /******************************************************************************/
-static int parseIntelHex(char *hexfile, char* buffer, int *startAddr, int *endAddr) {
+static int parseIntelHex(char *hexfile, unsigned char *buffer, int *startAddr, int *endAddr) {
   int address, base, d, segment, i, lineLen, sum;
   FILE *input;
-  
+
   input = strcmp(hexfile, "-") == 0 ? stdin : fopen(hexfile, "r");
   if (input == NULL) {
     printf("> Error opening %s: %s\n", hexfile, strerror(errno));
     return 1;
   }
-  
+
   while (parseUntilColon(input) == ':') {
     sum = 0;
     sum += lineLen = parseHex(input, 2);
@@ -370,18 +383,18 @@ static int parseIntelHex(char *hexfile, char* buffer, int *startAddr, int *endAd
     if (segment != 0) {   /* ignore lines where this byte is not 0 */
       continue;
     }
-    
+
     for (i = 0; i < lineLen; i++) {
       d = parseHex(input, 2);
       buffer[address++] = d;
       sum += d;
     }
-    
+
     sum += parseHex(input, 2);
     if ((sum & 0xff) != 0) {
       printf("> Warning: Checksum error between address 0x%x and 0x%x\n", base, address);
     }
-    
+
     if(*startAddr > base) {
       *startAddr = base;
     }
@@ -389,37 +402,37 @@ static int parseIntelHex(char *hexfile, char* buffer, int *startAddr, int *endAd
       *endAddr = address;
     }
   }
-  
+
   fclose(input);
   return 0;
 }
 /******************************************************************************/
 
 /******************************************************************************/
-static int parseRaw(char *filename, char* data_buffer, int *start_address, int *end_address) {
+static int parseRaw(char *filename, unsigned char *data_buffer, int *start_address, int *end_address) {
   FILE *input;
-  
+
   input = strcmp(filename, "-") == 0 ? stdin : fopen(filename, "r");
-  
+
   if (input == NULL) {
     printf("> Error reading %s: %s\n", filename, strerror(errno));
     return 1;
   }
-  
+
   *start_address = 0;
   *end_address = 0;
-  
+
   // read in bytes from file
   int byte = 0;
   while (1) {
     byte = getc(input);
     if (byte == EOF) break;
-    
+
     *data_buffer = byte;
     data_buffer += 1;
     *end_address += 1;
   }
-  
+
   fclose(input);
   return 0;
 }
diff --git a/commandline/library/micronucleus_lib.c b/commandline/library/micronucleus_lib.c
index 6bbf04c..b9bceb2 100644
--- a/commandline/library/micronucleus_lib.c
+++ b/commandline/library/micronucleus_lib.c
@@ -50,17 +50,19 @@ micronucleus* micronucleus_connect() {
         nucleus->version.minor = dev->descriptor.bcdDevice & 0xFF;
 
         if (nucleus->version.major > MICRONUCLEUS_MAX_MAJOR_VERSION) {
-	        fprintf(stderr, "Warning: device with unknown new version of Micronucleus detected.\n");
-	        fprintf(stderr, "This tool doesn't know how to upload to this new device. Updates may be available.\n");
-	        fprintf(stderr, "Device reports version as: %d.%d\n", nucleus->version.major, nucleus->version.minor);
-	        return NULL;
+          fprintf(stderr,
+                  "Warning: device with unknown new version of Micronucleus detected.\n"
+                  "This tool doesn't know how to upload to this new device. Updates may be available.\n"
+                  "Device reports version as: %d.%d\n",
+                  nucleus->version.major, nucleus->version.minor);
+          return NULL;
         }
 
         nucleus->device = usb_open(dev);
 
         // get nucleus info
         unsigned char buffer[4];
-        int res = usb_control_msg(nucleus->device, 0xC0, 0, 0, 0, buffer, 4, MICRONUCLEUS_USB_TIMEOUT);
+        int res = usb_control_msg(nucleus->device, 0xC0, 0, 0, 0, (char *)buffer, 4, MICRONUCLEUS_USB_TIMEOUT);
         assert(res >= 4);
 
         nucleus->flash_size = (buffer[0]<<8) + buffer[1];
@@ -102,7 +104,7 @@ int micronucleus_eraseFlash(micronucleus* deviceHandle, micronucleus_callback pr
    Assertion failed: (res >= 4), function micronucleus_connect, file library/micronucleus_lib.c, line 63.
   */
   if (res == -5 || res == -34 || res == -84) {
-    if (res = -34) {
+    if (res == -34) {
       usb_close(deviceHandle->device);
       deviceHandle->device = NULL;
     }
@@ -149,7 +151,7 @@ int micronucleus_writeFlash(micronucleus* deviceHandle, unsigned int program_siz
 
     // give microcontroller enough time to write this page and come back online
     delay(deviceHandle->write_sleep);
-    
+
     if (res != page_length) return -1;
   }