]> git.zerfleddert.de Git - proxmark3-svn/commitdiff
Merge branch 'master' into master
authorgrauerfuchs <42082416+grauerfuchs@users.noreply.github.com>
Fri, 14 Sep 2018 01:30:24 +0000 (21:30 -0400)
committerGitHub <noreply@github.com>
Fri, 14 Sep 2018 01:30:24 +0000 (21:30 -0400)
19 files changed:
CHANGELOG.md
CI/.travis.yml
armsrc/Makefile
armsrc/appmain.c
armsrc/legicrf.c
armsrc/legicrf.h
armsrc/legicrfsim.c [new file with mode: 0644]
armsrc/legicrfsim.h [new file with mode: 0644]
client/Makefile
client/cliparser/README.md [new file with mode: 0644]
client/cliparser/argtable3.c [new file with mode: 0644]
client/cliparser/argtable3.h [new file with mode: 0644]
client/cliparser/cliparser.c [new file with mode: 0644]
client/cliparser/cliparser.h [new file with mode: 0644]
client/cmdhf14a.c
client/cmdhflegic.c
client/obj/cliparser/.dummy [new file with mode: 0644]
fpga/fpga_hf.bit
fpga/hi_simulate.v

index 3b454f64f8c99b07cfc5780aa1b29f558e7082c0..f10ef4e24f6f79a824839ed8e58e165090fdecae 100644 (file)
@@ -18,6 +18,7 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac
 - Changed `hf 14a raw` - works with LED's and some exchange logic (Merlok)
 - Changed TLV parser messages to more convenient (Merlok)
 - Rewritten Legic Prime reader (`hf legic reader`, `write` and `fill`) - it is using xcorrelation now (AntiCat)
+- `hf 14a` commands works via argtable3 commandline parsing library (Merlok)
 - HID LF operations on firmware updated for complete native support of long (>37 bit) HID tags (grauerfuchs)
 
 ### Fixed
index 8e9289b1908d18294cd52edec231d0be711043dd..f5fed7a62b9e67718d3811645466e719af660bb2 100644 (file)
@@ -12,9 +12,9 @@ matrix:
     - os: osx
       osx_image: xcode8.3   # OS X 10.12
     - os: osx
-      osx_image: xcode9     # OS X 10.12
+      osx_image: xcode9.4   # OS X 10.13
     - os: osx
-      osx_image: xcode9.2   # OS X 10.12
+      osx_image: xcode10    # OS X 10.13
     - os: linux
       dist: trusty
       sudo: required
index d4b13c6bf59066a1a122d13237fb2653292fa3d8..046ad1bc17da8df991c2e2ea960bf33e90389cdf 100644 (file)
@@ -59,11 +59,12 @@ THUMBSRC = start.c \
 # These are to be compiled in ARM mode
 ARMSRC = fpgaloader.c \
        legicrf.c \
+       legicrfsim.c \
+       legic_prng.c \
        $(SRC_ISO14443a) \
        $(SRC_ISO14443b) \
        $(SRC_CRAPTO1) \
        $(SRC_CRC) \
-       legic_prng.c \
        iclass.c \
        BigBuf.c \
        optimized_cipher.c \
index 5995df6472eaf24df509f6c03e459e8f7ea43ffe..e6d40abceb7e580ec4453b0a45a1c9509967c6d6 100644 (file)
@@ -21,6 +21,7 @@
 #include "printf.h"
 #include "string.h"
 #include "legicrf.h"
+#include "legicrfsim.h"
 #include "hitag2.h"
 #include "hitagS.h"
 #include "lfsampling.h"
@@ -1103,7 +1104,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
 
 #ifdef WITH_LEGICRF
                case CMD_SIMULATE_TAG_LEGIC_RF:
-                       LegicRfSimulate(c->arg[0], c->arg[1], c->arg[2]);
+                       LegicRfSimulate(c->arg[0]);
                        break;
 
                case CMD_WRITER_LEGIC_RF:
index 2a236b6ff9e04ad0d6373560a4f20aea08ccf5b5..c8a4829f7d51c8b4abf658a9839d9c200211bb56 100644 (file)
@@ -1,7 +1,7 @@
 //-----------------------------------------------------------------------------
 // (c) 2009 Henryk Plötz <henryk@ploetzli.ch>
 //     2016 Iceman
-//     2018 AntiCat (rwd rewritten)
+//     2018 AntiCat
 //
 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
 // at your option, any later version. See the LICENSE.txt file for the text of
 #include "legic.h"
 #include "crc.h"
 
-static struct legic_frame {
-       int bits;
-       uint32_t data;
-} current_frame;
-
-static enum {
-  STATE_DISCON,
-  STATE_IV,
-  STATE_CON,
-} legic_state;
-
-static crc_t    legic_crc;
-static int      legic_read_count;
-static uint32_t legic_prng_bc;
-static uint32_t legic_prng_iv;
-
-static int      legic_phase_drift;
-static int      legic_frame_drift;
-static int      legic_reqresp_drift;
-
-AT91PS_TC timer;
-AT91PS_TC prng_timer;
-
 static legic_card_select_t card;/* metadata of currently selected card */
+static crc_t legic_crc;
 
 //-----------------------------------------------------------------------------
 // Frame timing and pseudorandom number generator
@@ -71,11 +49,6 @@ static uint32_t last_frame_end; /* ts of last bit of previews rx or tx frame */
 #define TAG_BIT_PERIOD      150 /* 100us */
 #define TAG_WRITE_TIMEOUT    60 /* 40 * 100us (write should take at most 3.6ms) */
 
-#define SIM_DIVISOR         586 /* prng_time/DIV count prng needs to be forwared */
-#define SIM_SHIFT           900 /* prng_time+SHIFT shift of delayed start */
-#define RWD_TIME_FUZZ        20 /* rather generous 13us, since the peak detector
-                                /+ hysteresis fuzz quite a bit */
-
 #define LEGIC_READ         0x01 /* Read Command */
 #define LEGIC_WRITE        0x00 /* Write Command */
 
@@ -86,8 +59,6 @@ static uint32_t last_frame_end; /* ts of last bit of previews rx or tx frame */
 #define INPUT_THRESHOLD       8 /* heuristically determined, lower values */
                                 /* lead to detecting false ack during write */
 
-#define FUZZ_EQUAL(value, target, fuzz) ((value) > ((target)-(fuzz)) && (value) < ((target)+(fuzz)))
-
 //-----------------------------------------------------------------------------
 // I/O interface abstraction (FPGA -> ARM)
 //-----------------------------------------------------------------------------
@@ -125,8 +96,8 @@ static inline uint8_t rx_byte_from_fpga() {
 // also.
 //
 // The demedulated should be alligned to the bit periode by the caller. This is
-// done in rx_bit_as_reader and rx_ack_as_reader.
-static inline bool rx_bit_as_reader() {
+// done in rx_bit and rx_ack.
+static inline bool rx_bit() {
   int32_t cq = 0;
   int32_t ci = 0;
 
@@ -158,7 +129,7 @@ static inline bool rx_bit_as_reader() {
 // be circumvented, but the adventage over bitbang would be little.
 //-----------------------------------------------------------------------------
 
-static inline void tx_bit_as_reader(bool bit) {
+static inline void tx_bit(bool bit) {
   // insert pause
   LOW(GPIO_SSC_DOUT);
   last_frame_end += RWD_TIME_PAUSE;
@@ -180,7 +151,7 @@ static inline void tx_bit_as_reader(bool bit) {
 // present.
 //-----------------------------------------------------------------------------
 
-static void tx_frame_as_reader(uint32_t frame, uint8_t len) {
+static void tx_frame(uint32_t frame, uint8_t len) {
   FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_TX);
 
   // wait for next tx timeslot
@@ -190,7 +161,7 @@ static void tx_frame_as_reader(uint32_t frame, uint8_t len) {
   // transmit frame, MSB first
   for(uint8_t i = 0; i < len; ++i) {
     bool bit = (frame >> i) & 0x01;
-    tx_bit_as_reader(bit ^ legic_prng_get_bit());
+    tx_bit(bit ^ legic_prng_get_bit());
     legic_prng_forward(1);
   };
 
@@ -201,7 +172,7 @@ static void tx_frame_as_reader(uint32_t frame, uint8_t len) {
   HIGH(GPIO_SSC_DOUT);
 }
 
-static uint32_t rx_frame_as_reader(uint8_t len) {
+static uint32_t rx_frame(uint8_t len) {
   FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR
                   | FPGA_HF_READER_RX_XCORR_848_KHZ
                   | FPGA_HF_READER_RX_XCORR_QUARTER_FREQ);
@@ -211,11 +182,11 @@ static uint32_t rx_frame_as_reader(uint8_t len) {
   while(GET_TICKS < last_frame_end) { };
 
   uint32_t frame = 0;
-  for(uint8_t i = 0; i < len; i++) {
-    frame |= (rx_bit_as_reader() ^ legic_prng_get_bit()) << i;
+  for(uint8_t i = 0; i < len; ++i) {
+    frame |= (rx_bit() ^ legic_prng_get_bit()) << i;
     legic_prng_forward(1);
 
-    // rx_bit_as_reader runs only 95us, resync to TAG_BIT_PERIOD
+    // rx_bit runs only 95us, resync to TAG_BIT_PERIOD
     last_frame_end += TAG_BIT_PERIOD;
     while(GET_TICKS < last_frame_end) { };
   }
@@ -223,7 +194,7 @@ static uint32_t rx_frame_as_reader(uint8_t len) {
   return frame;
 }
 
-static bool rx_ack_as_reader() {
+static bool rx_ack() {
   // change fpga into rx mode
   FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR
                   | FPGA_HF_READER_RX_XCORR_848_KHZ
@@ -236,10 +207,10 @@ static bool rx_ack_as_reader() {
   uint32_t ack = 0;
   for(uint8_t i = 0; i < TAG_WRITE_TIMEOUT; ++i) {
     // sample bit
-    ack = rx_bit_as_reader();
+    ack = rx_bit();
     legic_prng_forward(1);
 
-    // rx_bit_as_reader runs only 95us, resync to TAG_BIT_PERIOD
+    // rx_bit runs only 95us, resync to TAG_BIT_PERIOD
     last_frame_end += TAG_BIT_PERIOD;
     while(GET_TICKS < last_frame_end) { };
 
@@ -256,7 +227,7 @@ static bool rx_ack_as_reader() {
 // Legic Reader
 //-----------------------------------------------------------------------------
 
-int init_card(uint8_t cardtype, legic_card_select_t *p_card) {
+static int init_card(uint8_t cardtype, legic_card_select_t *p_card) {
   p_card->tagtype = cardtype;
 
   switch(p_card->tagtype) {
@@ -313,8 +284,8 @@ static void init_reader(bool clear_mem) {
 // The setup consists of a three way handshake:
 //  - Transmit initialisation vector 7 bits
 //  - Receive card type 6 bits
-//  - Acknowledge frame 6 bits
-static uint32_t setup_phase_reader(uint8_t iv) {
+//  - Transmit Acknowledge 6 bits
+static uint32_t setup_phase(uint8_t iv) {
   // init coordination timestamp
   last_frame_end = GET_TICKS;
 
@@ -323,24 +294,24 @@ static uint32_t setup_phase_reader(uint8_t iv) {
   while(GET_TICKS < last_frame_end) { };
 
   legic_prng_init(0);
-  tx_frame_as_reader(iv, 7);
+  tx_frame(iv, 7);
 
-  // configure iv
+  // configure prng
   legic_prng_init(iv);
   legic_prng_forward(2);
 
   // receive card type
-  int32_t card_type = rx_frame_as_reader(6);
+  int32_t card_type = rx_frame(6);
   legic_prng_forward(3);
 
   // send obsfuscated acknowledgment frame
   switch (card_type) {
     case 0x0D:
-      tx_frame_as_reader(0x19, 6); // MIM22 | READCMD = 0x18 | 0x01
+      tx_frame(0x19, 6); // MIM22 | READCMD = 0x18 | 0x01
       break;
     case 0x1D:
     case 0x3D:
-      tx_frame_as_reader(0x39, 6); // MIM256 | READCMD = 0x38 | 0x01
+      tx_frame(0x39, 6); // MIM256 | READCMD = 0x38 | 0x01
       break;
   }
 
@@ -359,9 +330,9 @@ static int16_t read_byte(uint16_t index, uint8_t cmd_sz) {
   // read one byte
   LED_B_ON();
   legic_prng_forward(2);
-  tx_frame_as_reader(cmd, cmd_sz);
+  tx_frame(cmd, cmd_sz);
   legic_prng_forward(2);
-  uint32_t frame = rx_frame_as_reader(12);
+  uint32_t frame = rx_frame(12);
   LED_B_OFF();
 
   // split frame into data and crc
@@ -391,12 +362,12 @@ bool write_byte(uint16_t index, uint8_t byte, uint8_t addr_sz) {
   // send write command
   LED_C_ON();
   legic_prng_forward(2);
-  tx_frame_as_reader(cmd, addr_sz + 1 + 8 + 4); // sz = addr_sz + cmd + data + crc
+  tx_frame(cmd, addr_sz + 1 + 8 + 4); // sz = addr_sz + cmd + data + crc
   legic_prng_forward(3);
   LED_C_OFF();
 
   // wait for ack
-  return rx_ack_as_reader();
+  return rx_ack();
 }
 
 //-----------------------------------------------------------------------------
@@ -413,7 +384,7 @@ void LegicRfReader(int offset, int bytes) {
 
   // establish shared secret and detect card type
   DbpString("Reading card ...");
-  uint8_t card_type = setup_phase_reader(SESSION_IV);
+  uint8_t card_type = setup_phase(SESSION_IV);
   if(init_card(card_type, &card) != 0) {
     Dbprintf("No or unknown card found, aborting");
     goto OUT;
@@ -463,7 +434,7 @@ void LegicRfWriter(int bytes, int offset) {
 
   // establish shared secret and detect card type
   Dbprintf("Writing 0x%02.2x - 0x%02.2x ...", offset, offset+bytes);
-  uint8_t card_type = setup_phase_reader(SESSION_IV);
+  uint8_t card_type = setup_phase(SESSION_IV);
   if(init_card(card_type, &card) != 0) {
     Dbprintf("No or unknown card found, aborting");
     goto OUT;
@@ -492,345 +463,3 @@ OUT:
   LED_D_OFF();
   StopTicks();
 }
-
-//-----------------------------------------------------------------------------
-// Legic Simulator
-//-----------------------------------------------------------------------------
-
-static void setup_timer(void)
-{
-       /* Set up Timer 1 to use for measuring time between pulses. Since we're bit-banging
-        * this it won't be terribly accurate but should be good enough.
-        */
-       AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC1);
-       timer = AT91C_BASE_TC1;
-       timer->TC_CCR = AT91C_TC_CLKDIS;
-       timer->TC_CMR = AT91C_TC_CLKS_TIMER_DIV3_CLOCK;
-       timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
-
-       /* 
-     * Set up Timer 2 to use for measuring time between frames in 
-     * tag simulation mode. Runs 4x faster as Timer 1
-        */
-    AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC2);
-    prng_timer = AT91C_BASE_TC2;
-    prng_timer->TC_CCR = AT91C_TC_CLKDIS;
-       prng_timer->TC_CMR = AT91C_TC_CLKS_TIMER_DIV2_CLOCK;
-    prng_timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
-}
-
-/* Generate Keystream */
-static uint32_t get_key_stream(int skip, int count)
-{
-  uint32_t key=0; int i;
-
-  /* Use int to enlarge timer tc to 32bit */
-  legic_prng_bc += prng_timer->TC_CV;
-  prng_timer->TC_CCR = AT91C_TC_SWTRG;
-
-  /* If skip == -1, forward prng time based */
-  if(skip == -1) {
-     i  = (legic_prng_bc+SIM_SHIFT)/SIM_DIVISOR; /* Calculate Cycles based on timer */
-     i -= legic_prng_count(); /* substract cycles of finished frames */
-     i -= count; /* substract current frame length, rewidn to bedinning */
-     legic_prng_forward(i);
-  } else {
-     legic_prng_forward(skip);
-  }
-
-  /* Write Time Data into LOG */
-  uint8_t *BigBuf = BigBuf_get_addr();
-  if(count == 6) { i = -1; } else { i = legic_read_count; }
-  BigBuf[OFFSET_LOG+128+i] = legic_prng_count();
-  BigBuf[OFFSET_LOG+256+i*4]   = (legic_prng_bc >> 0) & 0xff;
-  BigBuf[OFFSET_LOG+256+i*4+1] = (legic_prng_bc >> 8) & 0xff;
-  BigBuf[OFFSET_LOG+256+i*4+2] = (legic_prng_bc >>16) & 0xff;
-  BigBuf[OFFSET_LOG+256+i*4+3] = (legic_prng_bc >>24) & 0xff;
-  BigBuf[OFFSET_LOG+384+i] = count;
-
-  /* Generate KeyStream */
-  for(i=0; i<count; i++) {
-    key |= legic_prng_get_bit() << i;
-    legic_prng_forward(1);
-  }
-  return key;
-}
-
-/* Send a frame in tag mode, the FPGA must have been set up by
- * LegicRfSimulate
- */
-static void frame_send_tag(uint16_t response, int bits, int crypt)
-{
-   /* Bitbang the response */
-   AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
-   AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
-   AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT;
-        
-   /* Use time to crypt frame */
-   if(crypt) {
-      legic_prng_forward(2); /* TAG_TIME_WAIT -> shift by 2 */
-      int i; int key = 0;
-      for(i=0; i<bits; i++) {
-         key |= legic_prng_get_bit() << i;
-         legic_prng_forward(1);
-      }
-      //Dbprintf("key = 0x%x", key);
-      response = response ^ key;
-   }
-
-   /* Wait for the frame start */
-   while(timer->TC_CV < (TAG_FRAME_WAIT - 30)) ;
-       
-   int i;
-   for(i=0; i<bits; i++) {
-      int nextbit = timer->TC_CV + TAG_BIT_PERIOD;
-      int bit = response & 1;
-      response = response >> 1;
-      if(bit) {
-         AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;
-      } else {
-         AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
-      }
-      while(timer->TC_CV < nextbit) ;
-   }
-   AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
-}
-
-static void frame_append_bit(struct legic_frame * const f, int bit)
-{
-   if(f->bits >= 31) {
-       return; /* Overflow, won't happen */
-   }
-   f->data |= (bit<<f->bits);
-   f->bits++;
-}
-
-static void frame_clean(struct legic_frame * const f)
-{
-       f->data = 0;
-       f->bits = 0;
-}
-
-/* Handle (whether to respond) a frame in tag mode */
-static void frame_handle_tag(struct legic_frame const * const f)
-{
-       uint8_t *BigBuf = BigBuf_get_addr();
-
-   /* First Part of Handshake (IV) */
-   if(f->bits == 7) {
-     if(f->data == SESSION_IV) {
-        LED_C_ON();
-        prng_timer->TC_CCR = AT91C_TC_SWTRG;
-        legic_prng_init(f->data);
-        frame_send_tag(0x3d, 6, 1); /* 0x3d^0x26 = 0x1b */
-        legic_state = STATE_IV;
-        legic_read_count = 0;
-        legic_prng_bc = 0;
-        legic_prng_iv = f->data;
-        /* TIMEOUT */
-        timer->TC_CCR = AT91C_TC_SWTRG;
-        while(timer->TC_CV > 1);
-        while(timer->TC_CV < 280);
-        return;
-      } else if((prng_timer->TC_CV % 50) > 40) {
-        legic_prng_init(f->data);
-        frame_send_tag(0x3d, 6, 1);
-        SpinDelay(20);
-        return;
-     }
-   }
-
-   /* 0x19==??? */
-   if(legic_state == STATE_IV) {
-      if((f->bits == 6) && (f->data == (0x19 ^ get_key_stream(1, 6)))) {
-         legic_state = STATE_CON;
-
-         /* TIMEOUT */
-         timer->TC_CCR = AT91C_TC_SWTRG;
-         while(timer->TC_CV > 1);
-         while(timer->TC_CV < 200);
-         return;
-      } else {
-         legic_state = STATE_DISCON;
-         LED_C_OFF();
-         Dbprintf("0x19 - Frame: %03.3x", f->data);
-         return;
-      }
-   }
-
-   /* Read */
-   if(f->bits == 11) {
-      if(legic_state == STATE_CON) {
-         int key   = get_key_stream(-1, 11); //legic_phase_drift, 11);
-         int addr  = f->data ^ key; addr = addr >> 1;
-         int data = BigBuf[addr];
-         int hash = calc_crc4(addr, data, 11) << 8;
-         BigBuf[OFFSET_LOG+legic_read_count] = (uint8_t)addr;
-         legic_read_count++;
-
-         //Dbprintf("Data:%03.3x, key:%03.3x, addr: %03.3x, read_c:%u", f->data, key, addr, read_c);
-         legic_prng_forward(legic_reqresp_drift);
-
-         frame_send_tag(hash | data, 12, 1);
-
-         /* SHORT TIMEOUT */
-         timer->TC_CCR = AT91C_TC_SWTRG;
-         while(timer->TC_CV > 1);
-         legic_prng_forward(legic_frame_drift);
-         while(timer->TC_CV < 180);
-         return;
-      }
-   }
-
-   /* Write */
-   if(f->bits == 23) {
-      int key   = get_key_stream(-1, 23); //legic_frame_drift, 23);
-      int addr  = f->data ^ key; addr = addr >> 1; addr = addr & 0x3ff;
-      int data  = f->data ^ key; data = data >> 11; data = data & 0xff;
-
-      /* write command */
-      legic_state = STATE_DISCON;
-      LED_C_OFF();
-      Dbprintf("write - addr: %x, data: %x", addr, data);
-      return;
-   }
-
-   if(legic_state != STATE_DISCON) {
-      Dbprintf("Unexpected: sz:%u, Data:%03.3x, State:%u, Count:%u", f->bits, f->data, legic_state, legic_read_count);
-      int i;
-      Dbprintf("IV: %03.3x", legic_prng_iv);
-      for(i = 0; i<legic_read_count; i++) {
-         Dbprintf("Read Nb: %u, Addr: %u", i, BigBuf[OFFSET_LOG+i]);
-      }
-
-      for(i = -1; i<legic_read_count; i++) {
-         uint32_t t;
-         t  = BigBuf[OFFSET_LOG+256+i*4];
-         t |= BigBuf[OFFSET_LOG+256+i*4+1] << 8;
-         t |= BigBuf[OFFSET_LOG+256+i*4+2] <<16;
-         t |= BigBuf[OFFSET_LOG+256+i*4+3] <<24;
-
-         Dbprintf("Cycles: %u, Frame Length: %u, Time: %u", 
-            BigBuf[OFFSET_LOG+128+i],
-            BigBuf[OFFSET_LOG+384+i],
-            t);
-      }
-   }
-   legic_state = STATE_DISCON; 
-   legic_read_count = 0;
-   SpinDelay(10);
-   LED_C_OFF();
-   return; 
-}
-
-/* Read bit by bit untill full frame is received
- * Call to process frame end answer
- */
-static void emit(int bit)
-{
-  if(bit == -1) {
-     if(current_frame.bits <= 4) {
-        frame_clean(&current_frame);
-     } else {
-        frame_handle_tag(&current_frame);
-        frame_clean(&current_frame);
-     }
-     WDT_HIT();
-  } else if(bit == 0) {
-    frame_append_bit(&current_frame, 0);
-  } else if(bit == 1) {
-    frame_append_bit(&current_frame, 1);
-  }
-}
-
-void LegicRfSimulate(int phase, int frame, int reqresp)
-{
-  /* ADC path high-frequency peak detector, FPGA in high-frequency simulator mode, 
-   * modulation mode set to 212kHz subcarrier. We are getting the incoming raw
-   * envelope waveform on DIN and should send our response on DOUT.
-   *
-   * The LEGIC RF protocol is pulse-pause-encoding from reader to card, so we'll
-   * measure the time between two rising edges on DIN, and no encoding on the
-   * subcarrier from card to reader, so we'll just shift out our verbatim data
-   * on DOUT, 1 bit is 100us. The time from reader to card frame is still unclear,
-   * seems to be 300us-ish.
-   */
-
-   if(phase < 0) {
-      int i;
-      for(i=0; i<=reqresp; i++) {
-         legic_prng_init(SESSION_IV);
-         Dbprintf("i=%u, key 0x%3.3x", i, get_key_stream(i, frame));
-      }
-      return;
-   }
-
-   legic_phase_drift = phase;
-   legic_frame_drift = frame;
-   legic_reqresp_drift = reqresp;
-
-   FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
-   SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
-   FpgaSetupSsc();
-   FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_SIMULATOR | FPGA_HF_SIMULATOR_MODULATE_212K);
-   
-   /* Bitbang the receiver */
-   AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
-   AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;
-   
-   setup_timer();
-   crc_init(&legic_crc, 4, 0x19 >> 1, 0x5, 0);
-   
-   int old_level = 0;
-   int active = 0;
-   legic_state = STATE_DISCON;
-
-   LED_B_ON();
-   DbpString("Starting Legic emulator, press button to end");
-   while(!BUTTON_PRESS()) {
-      int level = !!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_DIN);
-      int time = timer->TC_CV;
-                
-      if(level != old_level) {
-         if(level == 1) {
-            timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
-            if(FUZZ_EQUAL(time, RWD_TIME_1, RWD_TIME_FUZZ)) {
-               /* 1 bit */
-               emit(1);
-               active = 1;
-               LED_A_ON();
-            } else if(FUZZ_EQUAL(time, RWD_TIME_0, RWD_TIME_FUZZ)) {
-               /* 0 bit */
-               emit(0);
-               active = 1;
-               LED_A_ON();
-            } else if(active) {
-               /* invalid */
-               emit(-1);
-               active = 0;
-               LED_A_OFF();
-            }
-         }
-      }
-
-      if(time >= (RWD_TIME_1+RWD_TIME_FUZZ) && active) {
-         /* Frame end */
-         emit(-1);
-         active = 0;
-         LED_A_OFF();
-      }
-                
-      if(time >= (20*RWD_TIME_1) && (timer->TC_SR & AT91C_TC_CLKSTA)) {
-         timer->TC_CCR = AT91C_TC_CLKDIS;
-      }
-                
-      old_level = level;
-      WDT_HIT();
-   }
-   DbpString("Stopped");
-   LED_B_OFF();
-   LED_A_OFF();
-   LED_C_OFF();
-}
-
index 464598566b4b1546b0e89de8cde033c338b4ea80..9f8cf457eee3554de170ab9765687eb01b251960 100644 (file)
@@ -1,5 +1,6 @@
 //-----------------------------------------------------------------------------
 // (c) 2009 Henryk Plötz <henryk@ploetzli.ch>
+//     2018 AntiCat
 //
 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
 // at your option, any later version. See the LICENSE.txt file for the text of
@@ -11,7 +12,6 @@
 #ifndef __LEGICRF_H
 #define __LEGICRF_H
 
-extern void LegicRfSimulate(int phase, int frame, int reqresp);
 extern void LegicRfReader(int bytes, int offset);
 extern void LegicRfWriter(int bytes, int offset);
 
diff --git a/armsrc/legicrfsim.c b/armsrc/legicrfsim.c
new file mode 100644 (file)
index 0000000..34633f3
--- /dev/null
@@ -0,0 +1,469 @@
+//-----------------------------------------------------------------------------
+// (c) 2009 Henryk Plötz <henryk@ploetzli.ch>
+//     2016 Iceman
+//     2018 AntiCat
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// LEGIC RF simulation code
+//-----------------------------------------------------------------------------
+
+#include "proxmark3.h"
+#include "apps.h"
+#include "util.h"
+#include "string.h"
+
+#include "legicrfsim.h"
+#include "legic_prng.h"
+#include "legic.h"
+#include "crc.h"
+#include "usb_cdc.h"  // for usb_poll_validate_length
+
+static uint8_t* legic_mem;      /* card memory, used for sim */
+static legic_card_select_t card;/* metadata of currently selected card */
+static crc_t legic_crc;
+
+//-----------------------------------------------------------------------------
+// Frame timing and pseudorandom number generator
+//
+// The Prng is forwarded every 99.1us (TAG_BIT_PERIOD), except when the reader is
+// transmitting. In that case the prng has to be forwarded every bit transmitted:
+//  - 31.3us for a 0 (RWD_TIME_0)
+//  - 99.1us for a 1 (RWD_TIME_1)
+//
+// The data dependent timing makes writing comprehensible code significantly
+// harder. The current aproach forwards the prng data based if there is data on
+// air and time based, using GetCountSspClk(), during computational and wait
+// periodes. SSP Clock is clocked by the FPGA at 212 kHz (subcarrier frequency).
+//
+// To not have the necessity to calculate/guess exection time dependend timeouts
+// tx_frame and rx_frame use a shared timestamp to coordinate tx and rx timeslots.
+//-----------------------------------------------------------------------------
+
+static uint32_t last_frame_end; /* ts of last bit of previews rx or tx frame */
+
+#define TAG_FRAME_WAIT       70 /* 330us from READER frame end to TAG frame start */
+#define TAG_ACK_WAIT        758 /* 3.57ms from READER frame end to TAG write ACK */
+#define TAG_BIT_PERIOD       21 /* 99.1us */
+
+#define RWD_TIME_PAUSE        4 /* 18.9us */
+#define RWD_TIME_1           21 /* RWD_TIME_PAUSE 18.9us off + 80.2us on = 99.1us */
+#define RWD_TIME_0           13 /* RWD_TIME_PAUSE 18.9us off + 42.4us on = 61.3us */
+#define RWD_CMD_TIMEOUT      40 /* 40 * 99.1us (arbitrary value) */
+#define RWD_MIN_FRAME_LEN     6 /* Shortest frame is 6 bits */
+#define RWD_MAX_FRAME_LEN    23 /* Longest frame is 23 bits */
+
+#define RWD_PULSE             1 /* Pulse is signaled with GPIO_SSC_DIN high */
+#define RWD_PAUSE             0 /* Pause is signaled with GPIO_SSC_DIN low */
+
+//-----------------------------------------------------------------------------
+// Demodulation
+//-----------------------------------------------------------------------------
+
+// Returns true if a pulse/pause is received within timeout
+static inline bool wait_for(bool value, const uint32_t timeout) {
+  while((bool)(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_DIN) != value) {
+    if(GetCountSspClk() > timeout) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Returns a demedulated bit or -1 on code violation
+//
+// rx_bit decodes bits using a thresholds. rx_bit has to be called by as soon as
+// a frame starts (first pause is received). rx_bit checks for a pause up to
+// 18.9us followed by a pulse of 80.2us or 42.4us:
+//  - A bit length <18.9us is a code violation
+//  - A bit length >80.2us is a 1
+//  - A bit length <80.2us is a 0
+//  - A bit length >148.6us is a code violation
+static inline int8_t rx_bit() {
+  // backup ts for threshold calculation
+  uint32_t bit_start = last_frame_end;
+
+  // wait for pause to end
+  if(!wait_for(RWD_PULSE, bit_start + RWD_TIME_1*3/2)) {
+    return -1;
+  }
+
+  // wait for next pause
+  if(!wait_for(RWD_PAUSE, bit_start + RWD_TIME_1*3/2)) {
+    return -1;
+  }
+
+  // update bit and frame end
+  last_frame_end = GetCountSspClk();
+
+  // check for code violation (bit to short)
+  if(last_frame_end - bit_start < RWD_TIME_PAUSE) {
+    return -1;
+  }
+
+  // apply threshold (average of RWD_TIME_0 and )
+  return (last_frame_end - bit_start > (RWD_TIME_0 + RWD_TIME_1) / 2);
+}
+
+//-----------------------------------------------------------------------------
+// Modulation
+//
+// LEGIC RF uses a very basic load modulation from card to reader:
+//  - Subcarrier on for a 1
+//  - Subcarrier off for for a 0
+//
+// The 212kHz subcarrier is generated by the FPGA as well as a mathcing ssp clk.
+// Each bit is transfered in a 99.1us slot and the first timeslot starts 330us
+// after the final 20us pause generated by the reader.
+//-----------------------------------------------------------------------------
+
+// Transmits a bit
+//
+// Note: The Subcarrier is not disabled during bits to prevent glitches. This is
+//       not mandatory but results in a cleaner signal. tx_frame will disable
+//       the subcarrier when the frame is done.
+static inline void tx_bit(bool bit) {
+  LED_C_ON();
+
+  if(bit) {
+    // modulate subcarrier
+    HIGH(GPIO_SSC_DOUT);
+  } else {
+    // do not modulate subcarrier
+    LOW(GPIO_SSC_DOUT);
+  }
+
+  // wait for tx timeslot to end
+  last_frame_end += TAG_BIT_PERIOD;
+  while(GetCountSspClk() < last_frame_end) { };
+  LED_C_OFF();
+}
+
+//-----------------------------------------------------------------------------
+// Frame Handling
+//
+// The LEGIC RF protocol from reader to card does not include explicit frame
+// start/stop information or length information. The tag detects end of frame
+// trough an extended pulse (>99.1us) without a pause.
+// In reverse direction (card to reader) the number of bites is well known
+// and depends only the command received (IV, ACK, READ or WRITE).
+//-----------------------------------------------------------------------------
+
+static void tx_frame(uint32_t frame, uint8_t len) {
+  // wait for next tx timeslot
+  last_frame_end += TAG_FRAME_WAIT;
+  legic_prng_forward(TAG_FRAME_WAIT/TAG_BIT_PERIOD - 1);
+  while(GetCountSspClk() < last_frame_end) { };
+
+  // transmit frame, MSB first
+  for(uint8_t i = 0; i < len; ++i) {
+    bool bit = (frame >> i) & 0x01;
+    tx_bit(bit ^ legic_prng_get_bit());
+    legic_prng_forward(1);
+  };
+
+  // disable subcarrier
+  LOW(GPIO_SSC_DOUT);
+}
+
+static void tx_ack() {
+  // wait for ack timeslot
+  last_frame_end += TAG_ACK_WAIT;
+  legic_prng_forward(TAG_ACK_WAIT/TAG_BIT_PERIOD - 1);
+  while(GetCountSspClk() < last_frame_end) { };
+
+  // transmit ack (ack is not encrypted)
+  tx_bit(true);
+  legic_prng_forward(1);
+
+  // disable subcarrier
+  LOW(GPIO_SSC_DOUT);
+}
+
+// Returns a demedulated frame or -1 on code violation
+//
+// Since TX to RX delay is arbitrary rx_frame has to:
+//  - detect start of frame (first pause)
+//  - forward prng based on ts/TAG_BIT_PERIOD
+//  - receive the frame
+//  - detect end of frame (last pause)
+static int32_t rx_frame(uint8_t *len) {
+  int32_t frame = 0;
+
+  // add 2 SSP clock cycles (1 for tx and 1 for rx pipeline delay)
+  // those will be substracted at the end of the rx phase
+  last_frame_end -= 2;
+
+  // wait for first pause (start of frame)
+  for(uint8_t i = 0; true; ++i) {
+    // increment prng every TAG_BIT_PERIOD
+    last_frame_end += TAG_BIT_PERIOD;
+    legic_prng_forward(1);
+
+    // if start of frame was received exit delay loop
+    if(wait_for(RWD_PAUSE, last_frame_end)) {
+      last_frame_end = GetCountSspClk();
+      break;
+    }
+
+    // check for code violation
+    if(i > RWD_CMD_TIMEOUT) {
+      return -1;
+    }
+  }
+
+  // receive frame
+  for(*len = 0; true; ++(*len)) {
+    // receive next bit
+    LED_D_ON();
+    int8_t bit = rx_bit();
+    LED_D_OFF();
+
+    // check for code violation and to short / long frame
+    if((bit < 0) && ((*len < RWD_MIN_FRAME_LEN) || (*len > RWD_MAX_FRAME_LEN))) {
+      return -1;
+    }
+
+    // check for code violation caused by end of frame
+    if(bit < 0) {
+      break;
+    }
+
+    // append bit
+    frame |= (bit ^ legic_prng_get_bit()) << (*len);
+    legic_prng_forward(1);
+  }
+
+  // rx_bit sets coordination timestamp to start of pause, append pause duration
+  // and substract 2 SSP clock cycles (1 for rx and 1 for tx pipeline delay) to
+  // obtain exact end of frame.
+  last_frame_end += RWD_TIME_PAUSE - 2;
+
+  return frame;
+}
+
+//-----------------------------------------------------------------------------
+// Legic Simulator
+//-----------------------------------------------------------------------------
+
+static int32_t init_card(uint8_t cardtype, legic_card_select_t *p_card) {
+  p_card->tagtype = cardtype;
+
+  switch(p_card->tagtype) {
+    case 0:
+      p_card->cmdsize = 6;
+      p_card->addrsize = 5;
+      p_card->cardsize = 22;
+      break;
+    case 1:
+      p_card->cmdsize = 9;
+      p_card->addrsize = 8;
+      p_card->cardsize = 256;
+      break;
+    case 2:
+      p_card->cmdsize = 11;
+      p_card->addrsize = 10;
+      p_card->cardsize = 1024;
+      break;
+    default:
+      p_card->cmdsize = 0;
+      p_card->addrsize = 0;
+      p_card->cardsize = 0;
+      return 2;
+  }
+  return 0;
+}
+
+static void init_tag() {
+  // configure FPGA
+  FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
+  FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_SIMULATOR
+                  | FPGA_HF_SIMULATOR_MODULATE_212K);
+  SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
+
+  // configure SSC with defaults
+  FpgaSetupSsc();
+
+  // first pull output to low to prevent glitches then re-claim GPIO_SSC_DOUT
+  LOW(GPIO_SSC_DOUT);
+  AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
+  AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT;
+
+  // reserve a cardmem, meaning we can use the tracelog function in bigbuff easier.
+  legic_mem = BigBuf_get_addr();
+
+  // init crc calculator
+  crc_init(&legic_crc, 4, 0x19 >> 1, 0x05, 0);
+
+  // start 212kHz timer (running from SSP Clock)
+  StartCountSspClk();
+}
+
+// Setup reader to card connection
+//
+// The setup consists of a three way handshake:
+//  - Receive initialisation vector 7 bits
+//  - Transmit card type 6 bits
+//  - Receive Acknowledge 6 bits
+static int32_t setup_phase(legic_card_select_t *p_card) {
+  uint8_t len = 0;
+
+  // init coordination timestamp
+  last_frame_end = GetCountSspClk();
+
+  // reset prng
+  legic_prng_init(0);
+
+  // wait for iv
+  int32_t iv = rx_frame(&len);
+  if((len != 7) || (iv < 0)) {
+    return -1;
+  }
+
+  // configure prng
+  legic_prng_init(iv);
+
+  // reply with card type
+  switch(p_card->tagtype) {
+    case 0:
+      tx_frame(0x0D, 6);
+      break;
+    case 1:
+      tx_frame(0x1D, 6);
+      break;
+    case 2:
+      tx_frame(0x3D, 6);
+      break;
+  }
+
+  // wait for ack
+  int32_t ack = rx_frame(&len);
+  if((len != 6) || (ack < 0)) {
+    return -1;
+  }
+
+  // validate data
+  switch(p_card->tagtype) {
+    case 0:
+      if(ack != 0x19) return -1;
+      break;
+    case 1:
+      if(ack != 0x39) return -1;
+      break;
+    case 2:
+      if(ack != 0x39) return -1;
+      break;
+  }
+
+  // During rx the prng is clocked using the variable reader period.
+  // Since rx_frame detects end of frame by detecting a code violation,
+  // the prng is off by one bit period after each rx phase. Hence, tx
+  // code advances the prng by (TAG_FRAME_WAIT/TAG_BIT_PERIOD - 1).
+  // This is not possible for back to back rx, so this quirk reduces
+  // the gap by one period.
+  last_frame_end += TAG_BIT_PERIOD;
+
+  return 0;
+}
+
+static uint8_t calc_crc4(uint16_t cmd, uint8_t cmd_sz, uint8_t value) {
+  crc_clear(&legic_crc);
+  crc_update(&legic_crc, (value << cmd_sz) | cmd, 8 + cmd_sz);
+  return crc_finish(&legic_crc);
+}
+
+static int32_t connected_phase(legic_card_select_t *p_card) {
+  uint8_t len = 0;
+
+  // wait for command
+  int32_t cmd = rx_frame(&len);
+  if(cmd < 0) {
+    return -1;
+  }
+
+  // check if command is LEGIC_READ
+  if(len == p_card->cmdsize) {
+    // prepare data
+    uint8_t byte = legic_mem[cmd >> 1];
+    uint8_t crc = calc_crc4(cmd, p_card->cmdsize, byte);
+
+    // transmit data
+    tx_frame((crc << 8) | byte, 12);
+
+    return 0;
+  }
+
+  // check if command is LEGIC_WRITE
+  if(len == p_card->cmdsize + 8 + 4) {
+    // decode data
+    uint16_t mask = (1 << p_card->addrsize) - 1;
+    uint16_t addr = (cmd >> 1) & mask;
+    uint8_t  byte = (cmd >> p_card->cmdsize) & 0xff;
+    uint8_t  crc  = (cmd >> (p_card->cmdsize + 8)) & 0xf;
+
+    // check received against calculated crc
+    uint8_t calc_crc = calc_crc4(addr << 1, p_card->cmdsize, byte);
+    if(calc_crc != crc) {
+      Dbprintf("!!! crc mismatch: %x != %x !!!",  calc_crc, crc);
+      return -1;
+    }
+
+    // store data
+    legic_mem[addr] = byte;
+
+    // transmit ack
+    tx_ack();
+
+    return 0;
+  }
+
+  return -1;
+}
+
+//-----------------------------------------------------------------------------
+// Command Line Interface
+//
+// Only this function is public / called from appmain.c
+//-----------------------------------------------------------------------------
+
+void LegicRfSimulate(uint8_t cardtype) {
+  // configure ARM and FPGA
+  init_tag();
+
+  // verify command line input
+  if(init_card(cardtype, &card) != 0) {
+    DbpString("Unknown tagtype.");
+    goto OUT;
+  }
+
+  LED_A_ON();
+  DbpString("Starting Legic emulator, press button to end");
+  while(!BUTTON_PRESS() && !usb_poll_validate_length()) {
+    WDT_HIT();
+
+    // wait for carrier, restart after timeout
+    if(!wait_for(RWD_PULSE, GetCountSspClk() + TAG_BIT_PERIOD)) {
+      continue;
+    }
+
+    // wait for connection, restart on error
+    if(setup_phase(&card)) {
+      continue;
+    }
+
+    // conection is established, process commands until one fails
+    while(!connected_phase(&card)) {
+      WDT_HIT();
+    }
+  }
+
+OUT:
+  DbpString("Stopped");
+  FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
+  LED_A_OFF();
+  LED_C_OFF();
+  LED_D_OFF();
+  StopTicks();
+}
diff --git a/armsrc/legicrfsim.h b/armsrc/legicrfsim.h
new file mode 100644 (file)
index 0000000..c1c8a86
--- /dev/null
@@ -0,0 +1,19 @@
+//-----------------------------------------------------------------------------
+// (c) 2009 Henryk Plötz <henryk@ploetzli.ch>
+//     2018 AntiCat
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// LEGIC RF emulation public interface
+//-----------------------------------------------------------------------------
+
+#ifndef __LEGICRFSIM_H
+#define __LEGICRFSIM_H
+
+#include "proxmark3.h"
+
+extern void LegicRfSimulate(uint8_t tagtype);
+
+#endif /* __LEGICRFSIM_H */
index 7c79b63b7053b554aefae2b2d246aedc46107365..e2f3e99219a92d0d41fb5f8304ef191bf54e7381 100644 (file)
@@ -106,6 +106,8 @@ CMDSRCS =   $(SRC_SMARTCARD) \
                        polarssl/bignum.c\
                        polarssl/rsa.c\
                        polarssl/sha1.c\
+                       cliparser/argtable3.c\
+                       cliparser/cliparser.c\
                        mfkey.c\
                        loclass/cipher.c \
                        loclass/cipherutils.c \
diff --git a/client/cliparser/README.md b/client/cliparser/README.md
new file mode 100644 (file)
index 0000000..2b32194
--- /dev/null
@@ -0,0 +1,13 @@
+# Command line parser
+
+cliparser - librari for proxmark with command line parsing high level functions.
+
+## External libraries:
+
+### argtable
+
+Argtable3 is a single-file, ANSI C, command-line parsing library that parses GNU-style command-line options.
+
+You can download argtable3 from this repository https://github.com/argtable/argtable3
+
+[argtable3 license](https://github.com/argtable/argtable3/blob/master/LICENSE)
diff --git a/client/cliparser/argtable3.c b/client/cliparser/argtable3.c
new file mode 100644 (file)
index 0000000..f70f68c
--- /dev/null
@@ -0,0 +1,5005 @@
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include "argtable3.h"
+
+// On Windows isspace crashes app in case of using Unicode character set and string to be above ASCII
+// so you have to use _istspace instead of space
+#ifdef UNICODE
+#include <tchar.h>
+    #define ISSPACE _istspace
+#else
+    #define ISSPACE isspace
+#endif
+
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 2013 Tom G. Huang
+ * <tomghuang@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#ifndef ARG_UTILS_H
+#define ARG_UTILS_H
+
+#define ARG_ENABLE_TRACE 0
+#define ARG_ENABLE_LOG 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum
+{
+    EMINCOUNT = 1,
+    EMAXCOUNT,
+    EBADINT,
+    // The same name define EOVERFLOW in errno.h on windows platform
+#ifdef __STDC_WANT_SECURE_LIB__
+    EOVERFLOW_,
+#else
+    EOVERFLOW,
+#endif
+    EBADDOUBLE,
+    EBADDATE,
+    EREGNOMATCH
+};
+
+
+#if defined(_MSC_VER)
+#define ARG_TRACE(x) \
+    __pragma(warning(push)) \
+    __pragma(warning(disable:4127)) \
+    do { if (ARG_ENABLE_TRACE) dbg_printf x; } while (0) \
+    __pragma(warning(pop))
+
+#define ARG_LOG(x) \
+    __pragma(warning(push)) \
+    __pragma(warning(disable:4127)) \
+    do { if (ARG_ENABLE_LOG) dbg_printf x; } while (0) \
+    __pragma(warning(pop))
+#else
+#define ARG_TRACE(x) \
+    do { if (ARG_ENABLE_TRACE) dbg_printf x; } while (0)
+
+#define ARG_LOG(x) \
+    do { if (ARG_ENABLE_LOG) dbg_printf x; } while (0)
+#endif 
+
+extern void dbg_printf(const char *fmt, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdarg.h>
+#include <stdio.h>
+
+
+void dbg_printf(const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    vfprintf(stderr, fmt, args);
+    va_end(args);
+}
+
+/*     $NetBSD: getopt.h,v 1.4 2000/07/07 10:43:54 ad Exp $    */
+/*     $FreeBSD$ */
+
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _GETOPT_H_
+#define _GETOPT_H_
+
+#include <sys/cdefs.h>
+
+/*
+ * GNU-like getopt_long()/getopt_long_only() with 4.4BSD optreset extension.
+ * getopt() is declared here too for GNU programs.
+ */
+#define no_argument        0
+#define required_argument  1
+#define optional_argument  2
+
+struct option {
+       /* name of long option */
+       const char *name;
+       /*
+        * one of no_argument, required_argument, and optional_argument:
+        * whether option takes an argument
+        */
+       int has_arg;
+       /* if not NULL, set *flag to val when option found */
+       int *flag;
+       /* if flag not NULL, value to set *flag to; else return value */
+       int val;
+};
+
+__BEGIN_DECLS
+int    getopt_long(int, char * const *, const char *,
+       const struct option *, int *);
+int    getopt_long_only(int, char * const *, const char *,
+       const struct option *, int *);
+#ifndef _GETOPT_DECLARED
+#define        _GETOPT_DECLARED
+int     getopt(int, char * const [], const char *);
+
+extern char *optarg;                   /* getopt(3) external variables */
+extern int optind, opterr, optopt;
+#endif
+#ifndef _OPTRESET_DECLARED
+#define        _OPTRESET_DECLARED
+extern int optreset;                   /* getopt(3) external variable */
+#endif
+__END_DECLS
+#endif /* !_GETOPT_H_ */
+/*     $Id: getopt_long.c,v 1.1 2009/10/16 19:50:28 rodney Exp rodney $        */
+/*     $OpenBSD: getopt_long.c,v 1.23 2007/10/31 12:34:57 chl Exp $    */
+/*     $NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $      */
+
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F39502-99-1-0512.
+ */
+
+// $Id: getopt_long.c,v 1.1 2009/10/16 19:50:28 rodney Exp rodney $"
+
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if 0
+#include <err.h>
+#endif
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+#define        REPLACE_GETOPT          /* use this getopt as the system getopt(3) */
+
+#ifdef REPLACE_GETOPT
+int    opterr = 1;             /* if error message should be printed */
+int    optind = 1;             /* index into parent argv vector */
+int    optopt = '?';           /* character checked for validity */
+int    optreset;               /* reset getopt */
+char    *optarg;               /* argument associated with option */
+#endif
+
+#define PRINT_ERROR    ((opterr) && (*options != ':'))
+
+#define FLAG_PERMUTE   0x01    /* permute non-options to the end of argv */
+#define FLAG_ALLARGS   0x02    /* treat non-options as args to option "-1" */
+#define FLAG_LONGONLY  0x04    /* operate as getopt_long_only */
+
+/* return values */
+#define        BADCH           (int)'?'
+#define        BADARG          ((*options == ':') ? (int)':' : (int)'?')
+#define        INORDER         (int)1
+
+#define        EMSG            ""
+
+static int getopt_internal(int, char * const *, const char *,
+                          const struct option *, int *, int);
+static int parse_long_options(char * const *, const char *,
+                             const struct option *, int *, int);
+static int gcd(int, int);
+static void permute_args(int, int, int, char * const *);
+
+static char *place = EMSG; /* option letter processing */
+
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+
+
+#ifdef _WIN32
+
+/* Windows needs warnx().  We change the definition though:
+ *  1. (another) global is defined, opterrmsg, which holds the error message
+ *  2. errors are always printed out on stderr w/o the program name
+ * Note that opterrmsg always gets set no matter what opterr is set to.  The
+ * error message will not be printed if opterr is 0 as usual.
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#define MAX_OPTER_MSG_SIZE 128
+
+extern char opterrmsg[MAX_OPTER_MSG_SIZE];
+char opterrmsg[MAX_OPTER_MSG_SIZE]; /* buffer for the last error message */
+
+static void warnx(const char *fmt, ...)
+{
+       va_list ap;
+       va_start(ap, fmt);
+    /*
+    Make sure opterrmsg is always zero-terminated despite the _vsnprintf()
+    implementation specifics and manually suppress the warning.
+    */
+    memset(opterrmsg, 0, sizeof opterrmsg);
+       if (fmt != NULL)
+#ifdef __STDC_WANT_SECURE_LIB__
+        _vsnprintf_s(opterrmsg, MAX_OPTER_MSG_SIZE, sizeof(opterrmsg) - 1, fmt, ap);
+#else
+        _vsnprintf(opterrmsg, sizeof(opterrmsg) - 1, fmt, ap);
+#endif
+       va_end(ap);
+
+#pragma warning(suppress: 6053)
+       fprintf(stderr, "%s\n", opterrmsg);
+}
+
+#else
+#include <err.h>
+#endif /*_WIN32*/
+
+
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(int a, int b)
+{
+       int c;
+
+       c = a % b;
+       while (c != 0) {
+               a = b;
+               b = c;
+               c = a % b;
+       }
+
+       return (b);
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(int panonopt_start, int panonopt_end, int opt_end,
+       char * const *nargv)
+{
+       int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+       char *swap;
+
+       /*
+        * compute lengths of blocks and number and size of cycles
+        */
+       nnonopts = panonopt_end - panonopt_start;
+       nopts = opt_end - panonopt_end;
+       ncycle = gcd(nnonopts, nopts);
+       cyclelen = (opt_end - panonopt_start) / ncycle;
+
+       for (i = 0; i < ncycle; i++) {
+               cstart = panonopt_end+i;
+               pos = cstart;
+               for (j = 0; j < cyclelen; j++) {
+                       if (pos >= panonopt_end)
+                               pos -= nnonopts;
+                       else
+                               pos += nopts;
+                       swap = nargv[pos];
+                       /* LINTED const cast */
+                       ((char **) nargv)[pos] = nargv[cstart];
+                       /* LINTED const cast */
+                       ((char **)nargv)[cstart] = swap;
+               }
+       }
+}
+
+/*
+ * parse_long_options --
+ *     Parse long options in argc/argv argument vector.
+ * Returns -1 if short_too is set and the option does not match long_options.
+ */
+static int
+parse_long_options(char * const *nargv, const char *options,
+       const struct option *long_options, int *idx, int short_too)
+{
+       char *current_argv, *has_equal;
+       size_t current_argv_len;
+       int i, match;
+
+       current_argv = place;
+       match = -1;
+
+       optind++;
+
+       if ((has_equal = strchr(current_argv, '=')) != NULL) {
+               /* argument found (--option=arg) */
+               current_argv_len = has_equal - current_argv;
+               has_equal++;
+       } else
+               current_argv_len = strlen(current_argv);
+
+       for (i = 0; long_options[i].name; i++) {
+               /* find matching long option */
+               if (strncmp(current_argv, long_options[i].name,
+                   current_argv_len))
+                       continue;
+
+               if (strlen(long_options[i].name) == current_argv_len) {
+                       /* exact match */
+                       match = i;
+                       break;
+               }
+               /*
+                * If this is a known short option, don't allow
+                * a partial match of a single character.
+                */
+               if (short_too && current_argv_len == 1)
+                       continue;
+
+               if (match == -1)        /* partial match */
+                       match = i;
+               else {
+                       /* ambiguous abbreviation */
+                       if (PRINT_ERROR)
+                               warnx(ambig, (int)current_argv_len,
+                                    current_argv);
+                       optopt = 0;
+                       return (BADCH);
+               }
+       }
+       if (match != -1) {              /* option found */
+               if (long_options[match].has_arg == no_argument
+                   && has_equal) {
+                       if (PRINT_ERROR)
+                               warnx(noarg, (int)current_argv_len,
+                                    current_argv);
+                       /*
+                        * XXX: GNU sets optopt to val regardless of flag
+                        */
+                       if (long_options[match].flag == NULL)
+                               optopt = long_options[match].val;
+                       else
+                               optopt = 0;
+                       return (BADARG);
+               }
+               if (long_options[match].has_arg == required_argument ||
+                   long_options[match].has_arg == optional_argument) {
+                       if (has_equal)
+                               optarg = has_equal;
+                       else if (long_options[match].has_arg ==
+                           required_argument) {
+                               /*
+                                * optional argument doesn't use next nargv
+                                */
+                               optarg = nargv[optind++];
+                       }
+               }
+               if ((long_options[match].has_arg == required_argument)
+                   && (optarg == NULL)) {
+                       /*
+                        * Missing argument; leading ':' indicates no error
+                        * should be generated.
+                        */
+                       if (PRINT_ERROR)
+                               warnx(recargstring,
+                                   current_argv);
+                       /*
+                        * XXX: GNU sets optopt to val regardless of flag
+                        */
+                       if (long_options[match].flag == NULL)
+                               optopt = long_options[match].val;
+                       else
+                               optopt = 0;
+                       --optind;
+                       return (BADARG);
+               }
+       } else {                        /* unknown option */
+               if (short_too) {
+                       --optind;
+                       return (-1);
+               }
+               if (PRINT_ERROR)
+                       warnx(illoptstring, current_argv);
+               optopt = 0;
+               return (BADCH);
+       }
+       if (idx)
+               *idx = match;
+       if (long_options[match].flag) {
+               *long_options[match].flag = long_options[match].val;
+               return (0);
+       } else
+               return (long_options[match].val);
+}
+
+/*
+ * getopt_internal --
+ *     Parse argc/argv argument vector.  Called by user level routines.
+ */
+static int
+getopt_internal(int nargc, char * const *nargv, const char *options,
+       const struct option *long_options, int *idx, int flags)
+{
+       char *oli;                              /* option letter list index */
+       int optchar, short_too;
+       static int posixly_correct = -1;
+#ifdef __STDC_WANT_SECURE_LIB__
+    char* buffer = NULL;
+    size_t buffer_size = 0;
+    errno_t err = 0;
+#endif
+
+       if (options == NULL)
+               return (-1);
+
+       /*
+        * Disable GNU extensions if POSIXLY_CORRECT is set or options
+        * string begins with a '+'.
+        */
+
+#ifdef __STDC_WANT_SECURE_LIB__
+    if (posixly_correct == -1) {
+        err = _dupenv_s(&buffer, &buffer_size, "POSIXLY_CORRECT") == 0;
+        posixly_correct = buffer != NULL;
+        if(buffer != NULL && err == 0) {
+            free(buffer);
+        }
+    }
+#else
+    if (posixly_correct == -1)
+        posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+#endif
+       if (posixly_correct || *options == '+')
+               flags &= ~FLAG_PERMUTE;
+       else if (*options == '-')
+               flags |= FLAG_ALLARGS;
+       if (*options == '+' || *options == '-')
+               options++;
+
+       /*
+        * XXX Some GNU programs (like cvs) set optind to 0 instead of
+        * XXX using optreset.  Work around this braindamage.
+        */
+       if (optind == 0)
+               optind = optreset = 1;
+
+       optarg = NULL;
+       if (optreset)
+               nonopt_start = nonopt_end = -1;
+start:
+       if (optreset || !*place) {              /* update scanning pointer */
+               optreset = 0;
+               if (optind >= nargc) {          /* end of argument vector */
+                       place = EMSG;
+                       if (nonopt_end != -1) {
+                               /* do permutation, if we have to */
+                               permute_args(nonopt_start, nonopt_end,
+                                   optind, nargv);
+                               optind -= nonopt_end - nonopt_start;
+                       }
+                       else if (nonopt_start != -1) {
+                               /*
+                                * If we skipped non-options, set optind
+                                * to the first of them.
+                                */
+                               optind = nonopt_start;
+                       }
+                       nonopt_start = nonopt_end = -1;
+                       return (-1);
+               }
+               if (*(place = nargv[optind]) != '-' ||
+                   (place[1] == '\0' && strchr(options, '-') == NULL)) {
+                       place = EMSG;           /* found non-option */
+                       if (flags & FLAG_ALLARGS) {
+                               /*
+                                * GNU extension:
+                                * return non-option as argument to option 1
+                                */
+                               optarg = nargv[optind++];
+                               return (INORDER);
+                       }
+                       if (!(flags & FLAG_PERMUTE)) {
+                               /*
+                                * If no permutation wanted, stop parsing
+                                * at first non-option.
+                                */
+                               return (-1);
+                       }
+                       /* do permutation */
+                       if (nonopt_start == -1)
+                               nonopt_start = optind;
+                       else if (nonopt_end != -1) {
+                               permute_args(nonopt_start, nonopt_end,
+                                   optind, nargv);
+                               nonopt_start = optind -
+                                   (nonopt_end - nonopt_start);
+                               nonopt_end = -1;
+                       }
+                       optind++;
+                       /* process next argument */
+                       goto start;
+               }
+               if (nonopt_start != -1 && nonopt_end == -1)
+                       nonopt_end = optind;
+
+               /*
+                * If we have "-" do nothing, if "--" we are done.
+                */
+               if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
+                       optind++;
+                       place = EMSG;
+                       /*
+                        * We found an option (--), so if we skipped
+                        * non-options, we have to permute.
+                        */
+                       if (nonopt_end != -1) {
+                               permute_args(nonopt_start, nonopt_end,
+                                   optind, nargv);
+                               optind -= nonopt_end - nonopt_start;
+                       }
+                       nonopt_start = nonopt_end = -1;
+                       return (-1);
+               }
+       }
+
+       /*
+        * Check long options if:
+        *  1) we were passed some
+        *  2) the arg is not just "-"
+        *  3) either the arg starts with -- we are getopt_long_only()
+        */
+       if (long_options != NULL && place != nargv[optind] &&
+           (*place == '-' || (flags & FLAG_LONGONLY))) {
+               short_too = 0;
+               if (*place == '-')
+                       place++;                /* --foo long option */
+               else if (*place != ':' && strchr(options, *place) != NULL)
+                       short_too = 1;          /* could be short option too */
+
+               optchar = parse_long_options(nargv, options, long_options,
+                   idx, short_too);
+               if (optchar != -1) {
+                       place = EMSG;
+                       return (optchar);
+               }
+       }
+
+       if ((optchar = (int)*place++) == (int)':' ||
+           (optchar == (int)'-' && *place != '\0') ||
+           (oli = strchr(options, optchar)) == NULL) {
+               /*
+                * If the user specified "-" and  '-' isn't listed in
+                * options, return -1 (non-option) as per POSIX.
+                * Otherwise, it is an unknown option character (or ':').
+                */
+               if (optchar == (int)'-' && *place == '\0')
+                       return (-1);
+               if (!*place)
+                       ++optind;
+               if (PRINT_ERROR)
+                       warnx(illoptchar, optchar);
+               optopt = optchar;
+               return (BADCH);
+       }
+       if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
+               /* -W long-option */
+               if (*place)                     /* no space */
+                       /* NOTHING */;
+               else if (++optind >= nargc) {   /* no arg */
+                       place = EMSG;
+                       if (PRINT_ERROR)
+                               warnx(recargchar, optchar);
+                       optopt = optchar;
+                       return (BADARG);
+               } else                          /* white space */
+                       place = nargv[optind];
+               optchar = parse_long_options(nargv, options, long_options,
+                   idx, 0);
+               place = EMSG;
+               return (optchar);
+       }
+       if (*++oli != ':') {                    /* doesn't take argument */
+               if (!*place)
+                       ++optind;
+       } else {                                /* takes (optional) argument */
+               optarg = NULL;
+               if (*place)                     /* no white space */
+                       optarg = place;
+               else if (oli[1] != ':') {       /* arg not optional */
+                       if (++optind >= nargc) {        /* no arg */
+                               place = EMSG;
+                               if (PRINT_ERROR)
+                                       warnx(recargchar, optchar);
+                               optopt = optchar;
+                               return (BADARG);
+                       } else
+                               optarg = nargv[optind];
+               }
+               place = EMSG;
+               ++optind;
+       }
+       /* dump back option letter */
+       return (optchar);
+}
+
+#ifdef REPLACE_GETOPT
+/*
+ * getopt --
+ *     Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the BSD getopt]
+ */
+int
+getopt(int nargc, char * const *nargv, const char *options)
+{
+
+       /*
+        * We don't pass FLAG_PERMUTE to getopt_internal() since
+        * the BSD getopt(3) (unlike GNU) has never done this.
+        *
+        * Furthermore, since many privileged programs call getopt()
+        * before dropping privileges it makes sense to keep things
+        * as simple (and bug-free) as possible.
+        */
+       return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
+}
+#endif /* REPLACE_GETOPT */
+
+/*
+ * getopt_long --
+ *     Parse argc/argv argument vector.
+ */
+int
+getopt_long(int nargc, char * const *nargv, const char *options,
+    const struct option *long_options, int *idx)
+{
+
+       return (getopt_internal(nargc, nargv, options, long_options, idx,
+           FLAG_PERMUTE));
+}
+
+/*
+ * getopt_long_only --
+ *     Parse argc/argv argument vector.
+ */
+int
+getopt_long_only(int nargc, char * const *nargv, const char *options,
+    const struct option *long_options, int *idx)
+{
+
+       return (getopt_internal(nargc, nargv, options, long_options, idx,
+           FLAG_PERMUTE|FLAG_LONGONLY));
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "argtable3.h"
+
+
+char * arg_strptime(const char *buf, const char *fmt, struct tm *tm);
+
+
+static void arg_date_resetfn(struct arg_date *parent)
+{
+    ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+    parent->count = 0;
+}
+
+
+static int arg_date_scanfn(struct arg_date *parent, const char *argval)
+{
+    int errorcode = 0;
+
+    if (parent->count == parent->hdr.maxcount)
+    {
+        errorcode = EMAXCOUNT;
+    }
+    else if (!argval)
+    {
+        /* no argument value was given, leave parent->tmval[] unaltered but still count it */
+        parent->count++;
+    }
+    else
+    {
+        const char *pend;
+        struct tm tm = parent->tmval[parent->count];
+
+        /* parse the given argument value, store result in parent->tmval[] */
+        pend = arg_strptime(argval, parent->format, &tm);
+        if (pend && pend[0] == '\0')
+            parent->tmval[parent->count++] = tm;
+        else
+            errorcode = EBADDATE;
+    }
+
+    ARG_TRACE(("%s:scanfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static int arg_date_checkfn(struct arg_date *parent)
+{
+    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
+
+    ARG_TRACE(("%s:checkfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static void arg_date_errorfn(
+    struct arg_date *parent,
+    FILE *fp,
+    int errorcode,
+    const char *argval,
+    const char *progname)
+{
+    const char *shortopts = parent->hdr.shortopts;
+    const char *longopts  = parent->hdr.longopts;
+    const char *datatype  = parent->hdr.datatype;
+
+    /* make argval NULL safe */
+    argval = argval ? argval : "";
+
+    fprintf(fp, "%s: ", progname);
+    switch(errorcode)
+    {
+    case EMINCOUNT:
+        fputs("missing option ", fp);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+
+    case EMAXCOUNT:
+        fputs("excess option ", fp);
+        arg_print_option(fp, shortopts, longopts, argval, "\n");
+        break;
+
+    case EBADDATE:
+    {
+        struct tm tm;
+        char buff[200];
+
+        fprintf(fp, "illegal timestamp format \"%s\"\n", argval);
+        memset(&tm, 0, sizeof(tm));
+        arg_strptime("1999-12-31 23:59:59", "%F %H:%M:%S", &tm);
+        strftime(buff, sizeof(buff), parent->format, &tm);
+        printf("correct format is \"%s\"\n", buff);
+        break;
+    }
+    }
+}
+
+
+struct arg_date * arg_date0(
+    const char * shortopts,
+    const char * longopts,
+    const char * format,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_daten(shortopts, longopts, format, datatype, 0, 1, glossary);
+}
+
+
+struct arg_date * arg_date1(
+    const char * shortopts,
+    const char * longopts,
+    const char * format,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_daten(shortopts, longopts, format, datatype, 1, 1, glossary);
+}
+
+
+struct arg_date * arg_daten(
+    const char * shortopts,
+    const char * longopts,
+    const char * format,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary)
+{
+    size_t nbytes;
+    struct arg_date *result;
+
+    /* foolproof things by ensuring maxcount is not less than mincount */
+    maxcount = (maxcount < mincount) ? mincount : maxcount;
+
+    /* default time format is the national date format for the locale */
+    if (!format)
+        format = "%x";
+
+    nbytes = sizeof(struct arg_date)         /* storage for struct arg_date */
+        + maxcount * sizeof(struct tm);    /* storage for tmval[maxcount] array */
+
+    /* allocate storage for the arg_date struct + tmval[] array.    */
+    /* we use calloc because we want the tmval[] array zero filled. */
+    result = (struct arg_date *)calloc(1, nbytes);
+    if (result)
+    {
+        /* init the arg_hdr struct */
+        result->hdr.flag      = ARG_HASVALUE;
+        result->hdr.shortopts = shortopts;
+        result->hdr.longopts  = longopts;
+        result->hdr.datatype  = datatype ? datatype : format;
+        result->hdr.glossary  = glossary;
+        result->hdr.mincount  = mincount;
+        result->hdr.maxcount  = maxcount;
+        result->hdr.parent    = result;
+        result->hdr.resetfn   = (arg_resetfn *)arg_date_resetfn;
+        result->hdr.scanfn    = (arg_scanfn *)arg_date_scanfn;
+        result->hdr.checkfn   = (arg_checkfn *)arg_date_checkfn;
+        result->hdr.errorfn   = (arg_errorfn *)arg_date_errorfn;
+
+        /* store the tmval[maxcount] array immediately after the arg_date struct */
+        result->tmval  = (struct tm *)(result + 1);
+
+        /* init the remaining arg_date member variables */
+        result->count = 0;
+        result->format = format;
+    }
+
+    ARG_TRACE(("arg_daten() returns %p\n", result));
+    return result;
+}
+
+
+/*-
+ * Copyright (c) 1997, 1998, 2005, 2008 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code was contributed to The NetBSD Foundation by Klaus Klein.
+ * Heavily optimised by David Laight
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <ctype.h>
+#include <string.h>
+#include <time.h>
+
+/*
+ * We do not implement alternate representations. However, we always
+ * check whether a given modifier is allowed for a certain conversion.
+ */
+#define ALT_E                   0x01
+#define ALT_O                   0x02
+#define LEGAL_ALT(x)            { if (alt_format & ~(x)) return (0); }
+#define TM_YEAR_BASE   (1900)
+
+static int conv_num(const char * *, int *, int, int);
+
+static const char *day[7] = {
+    "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
+    "Friday", "Saturday"
+};
+
+static const char *abday[7] = {
+    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+};
+
+static const char *mon[12] = {
+    "January", "February", "March", "April", "May", "June", "July",
+    "August", "September", "October", "November", "December"
+};
+
+static const char *abmon[12] = {
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+
+static const char *am_pm[2] = {
+    "AM", "PM"
+};
+
+
+static int arg_strcasecmp(const char *s1, const char *s2)
+{
+    const unsigned char *us1 = (const unsigned char *)s1;
+    const unsigned char *us2 = (const unsigned char *)s2;
+    while (tolower(*us1) == tolower(*us2++))
+        if (*us1++ == '\0')
+            return 0;
+
+    return tolower(*us1) - tolower(*--us2);
+}
+
+
+static int arg_strncasecmp(const char *s1, const char *s2, size_t n)
+{
+    if (n != 0)
+    {
+        const unsigned char *us1 = (const unsigned char *)s1;
+        const unsigned char *us2 = (const unsigned char *)s2;
+        do
+        {
+            if (tolower(*us1) != tolower(*us2++))
+                return tolower(*us1) - tolower(*--us2);
+
+            if (*us1++ == '\0')
+                break;
+        } while (--n != 0);
+    }
+
+    return 0;
+}
+
+
+char * arg_strptime(const char *buf, const char *fmt, struct tm *tm)
+{
+    char c;
+    const char *bp;
+    size_t len = 0;
+    int alt_format, i, split_year = 0;
+
+    bp = buf;
+
+    while ((c = *fmt) != '\0') {
+        /* Clear `alternate' modifier prior to new conversion. */
+        alt_format = 0;
+
+        /* Eat up white-space. */
+        if (ISSPACE(c)) {
+            while (ISSPACE(*bp))
+                bp++;
+
+            fmt++;
+            continue;
+        }
+
+        if ((c = *fmt++) != '%')
+            goto literal;
+
+
+again:
+        switch (c = *fmt++)
+        {
+        case '%': /* "%%" is converted to "%". */
+literal:
+            if (c != *bp++)
+                return (0);
+            break;
+
+        /*
+         * "Alternative" modifiers. Just set the appropriate flag
+         * and start over again.
+         */
+        case 'E': /* "%E?" alternative conversion modifier. */
+            LEGAL_ALT(0);
+            alt_format |= ALT_E;
+            goto again;
+
+        case 'O': /* "%O?" alternative conversion modifier. */
+            LEGAL_ALT(0);
+            alt_format |= ALT_O;
+            goto again;
+
+        /*
+         * "Complex" conversion rules, implemented through recursion.
+         */
+        case 'c': /* Date and time, using the locale's format. */
+            LEGAL_ALT(ALT_E);
+            bp = arg_strptime(bp, "%x %X", tm);
+            if (!bp)
+                return (0);
+            break;
+
+        case 'D': /* The date as "%m/%d/%y". */
+            LEGAL_ALT(0);
+            bp = arg_strptime(bp, "%m/%d/%y", tm);
+            if (!bp)
+                return (0);
+            break;
+
+        case 'R': /* The time as "%H:%M". */
+            LEGAL_ALT(0);
+            bp = arg_strptime(bp, "%H:%M", tm);
+            if (!bp)
+                return (0);
+            break;
+
+        case 'r': /* The time in 12-hour clock representation. */
+            LEGAL_ALT(0);
+            bp = arg_strptime(bp, "%I:%M:%S %p", tm);
+            if (!bp)
+                return (0);
+            break;
+
+        case 'T': /* The time as "%H:%M:%S". */
+            LEGAL_ALT(0);
+            bp = arg_strptime(bp, "%H:%M:%S", tm);
+            if (!bp)
+                return (0);
+            break;
+
+        case 'X': /* The time, using the locale's format. */
+            LEGAL_ALT(ALT_E);
+            bp = arg_strptime(bp, "%H:%M:%S", tm);
+            if (!bp)
+                return (0);
+            break;
+
+        case 'x': /* The date, using the locale's format. */
+            LEGAL_ALT(ALT_E);
+            bp = arg_strptime(bp, "%m/%d/%y", tm);
+            if (!bp)
+                return (0);
+            break;
+
+        /*
+         * "Elementary" conversion rules.
+         */
+        case 'A': /* The day of week, using the locale's form. */
+        case 'a':
+            LEGAL_ALT(0);
+            for (i = 0; i < 7; i++) {
+                /* Full name. */
+                len = strlen(day[i]);
+                if (arg_strncasecmp(day[i], bp, len) == 0)
+                    break;
+
+                /* Abbreviated name. */
+                len = strlen(abday[i]);
+                if (arg_strncasecmp(abday[i], bp, len) == 0)
+                    break;
+            }
+
+            /* Nothing matched. */
+            if (i == 7)
+                return (0);
+
+            tm->tm_wday = i;
+            bp += len;
+            break;
+
+        case 'B': /* The month, using the locale's form. */
+        case 'b':
+        case 'h':
+            LEGAL_ALT(0);
+            for (i = 0; i < 12; i++) {
+                /* Full name. */
+                len = strlen(mon[i]);
+                if (arg_strncasecmp(mon[i], bp, len) == 0)
+                    break;
+
+                /* Abbreviated name. */
+                len = strlen(abmon[i]);
+                if (arg_strncasecmp(abmon[i], bp, len) == 0)
+                    break;
+            }
+
+            /* Nothing matched. */
+            if (i == 12)
+                return (0);
+
+            tm->tm_mon = i;
+            bp += len;
+            break;
+
+        case 'C': /* The century number. */
+            LEGAL_ALT(ALT_E);
+            if (!(conv_num(&bp, &i, 0, 99)))
+                return (0);
+
+            if (split_year) {
+                tm->tm_year = (tm->tm_year % 100) + (i * 100);
+            } else {
+                tm->tm_year = i * 100;
+                split_year = 1;
+            }
+            break;
+
+        case 'd': /* The day of month. */
+        case 'e':
+            LEGAL_ALT(ALT_O);
+            if (!(conv_num(&bp, &tm->tm_mday, 1, 31)))
+                return (0);
+            break;
+
+        case 'k': /* The hour (24-hour clock representation). */
+            LEGAL_ALT(0);
+        /* FALLTHROUGH */
+        case 'H':
+            LEGAL_ALT(ALT_O);
+            if (!(conv_num(&bp, &tm->tm_hour, 0, 23)))
+                return (0);
+            break;
+
+        case 'l': /* The hour (12-hour clock representation). */
+            LEGAL_ALT(0);
+        /* FALLTHROUGH */
+        case 'I':
+            LEGAL_ALT(ALT_O);
+            if (!(conv_num(&bp, &tm->tm_hour, 1, 12)))
+                return (0);
+            if (tm->tm_hour == 12)
+                tm->tm_hour = 0;
+            break;
+
+        case 'j': /* The day of year. */
+            LEGAL_ALT(0);
+            if (!(conv_num(&bp, &i, 1, 366)))
+                return (0);
+            tm->tm_yday = i - 1;
+            break;
+
+        case 'M': /* The minute. */
+            LEGAL_ALT(ALT_O);
+            if (!(conv_num(&bp, &tm->tm_min, 0, 59)))
+                return (0);
+            break;
+
+        case 'm': /* The month. */
+            LEGAL_ALT(ALT_O);
+            if (!(conv_num(&bp, &i, 1, 12)))
+                return (0);
+            tm->tm_mon = i - 1;
+            break;
+
+        case 'p': /* The locale's equivalent of AM/PM. */
+            LEGAL_ALT(0);
+            /* AM? */
+            if (arg_strcasecmp(am_pm[0], bp) == 0) {
+                if (tm->tm_hour > 11)
+                    return (0);
+
+                bp += strlen(am_pm[0]);
+                break;
+            }
+            /* PM? */
+            else if (arg_strcasecmp(am_pm[1], bp) == 0) {
+                if (tm->tm_hour > 11)
+                    return (0);
+
+                tm->tm_hour += 12;
+                bp += strlen(am_pm[1]);
+                break;
+            }
+
+            /* Nothing matched. */
+            return (0);
+
+        case 'S': /* The seconds. */
+            LEGAL_ALT(ALT_O);
+            if (!(conv_num(&bp, &tm->tm_sec, 0, 61)))
+                return (0);
+            break;
+
+        case 'U': /* The week of year, beginning on sunday. */
+        case 'W': /* The week of year, beginning on monday. */
+            LEGAL_ALT(ALT_O);
+            /*
+             * XXX This is bogus, as we can not assume any valid
+             * information present in the tm structure at this
+             * point to calculate a real value, so just check the
+             * range for now.
+             */
+            if (!(conv_num(&bp, &i, 0, 53)))
+                return (0);
+            break;
+
+        case 'w': /* The day of week, beginning on sunday. */
+            LEGAL_ALT(ALT_O);
+            if (!(conv_num(&bp, &tm->tm_wday, 0, 6)))
+                return (0);
+            break;
+
+        case 'Y': /* The year. */
+            LEGAL_ALT(ALT_E);
+            if (!(conv_num(&bp, &i, 0, 9999)))
+                return (0);
+
+            tm->tm_year = i - TM_YEAR_BASE;
+            break;
+
+        case 'y': /* The year within 100 years of the epoch. */
+            LEGAL_ALT(ALT_E | ALT_O);
+            if (!(conv_num(&bp, &i, 0, 99)))
+                return (0);
+
+            if (split_year) {
+                tm->tm_year = ((tm->tm_year / 100) * 100) + i;
+                break;
+            }
+            split_year = 1;
+            if (i <= 68)
+                tm->tm_year = i + 2000 - TM_YEAR_BASE;
+            else
+                tm->tm_year = i + 1900 - TM_YEAR_BASE;
+            break;
+
+        /*
+         * Miscellaneous conversions.
+         */
+        case 'n': /* Any kind of white-space. */
+        case 't':
+            LEGAL_ALT(0);
+            while (ISSPACE(*bp))
+                bp++;
+            break;
+
+
+        default: /* Unknown/unsupported conversion. */
+            return (0);
+        }
+
+
+    }
+
+    /* LINTED functional specification */
+    return ((char *)bp);
+}
+
+
+static int conv_num(const char * *buf, int *dest, int llim, int ulim)
+{
+    int result = 0;
+
+    /* The limit also determines the number of valid digits. */
+    int rulim = ulim;
+
+    if (**buf < '0' || **buf > '9')
+        return (0);
+
+    do {
+        result *= 10;
+        result += *(*buf)++ - '0';
+        rulim /= 10;
+    } while ((result * 10 <= ulim) && rulim && **buf >= '0' && **buf <= '9');
+
+    if (result < llim || result > ulim)
+        return (0);
+
+    *dest = result;
+    return (1);
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+
+#include "argtable3.h"
+
+
+static void arg_dbl_resetfn(struct arg_dbl *parent)
+{
+    ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+    parent->count = 0;
+}
+
+
+static int arg_dbl_scanfn(struct arg_dbl *parent, const char *argval)
+{
+    int errorcode = 0;
+
+    if (parent->count == parent->hdr.maxcount)
+    {
+        /* maximum number of arguments exceeded */
+        errorcode = EMAXCOUNT;
+    }
+    else if (!argval)
+    {
+        /* a valid argument with no argument value was given. */
+        /* This happens when an optional argument value was invoked. */
+        /* leave parent argument value unaltered but still count the argument. */
+        parent->count++;
+    }
+    else
+    {
+        double val;
+        char *end;
+
+        /* extract double from argval into val */
+        val = strtod(argval, &end);
+
+        /* if success then store result in parent->dval[] array otherwise return error*/
+        if (*end == 0)
+            parent->dval[parent->count++] = val;
+        else
+            errorcode = EBADDOUBLE;
+    }
+
+    ARG_TRACE(("%s:scanfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static int arg_dbl_checkfn(struct arg_dbl *parent)
+{
+    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
+    
+    ARG_TRACE(("%s:checkfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static void arg_dbl_errorfn(
+    struct arg_dbl *parent,
+    FILE *fp,
+    int errorcode,
+    const char *argval,
+    const char *progname)
+{
+    const char *shortopts = parent->hdr.shortopts;
+    const char *longopts  = parent->hdr.longopts;
+    const char *datatype  = parent->hdr.datatype;
+
+    /* make argval NULL safe */
+    argval = argval ? argval : "";
+
+    fprintf(fp, "%s: ", progname);
+    switch(errorcode)
+    {
+    case EMINCOUNT:
+        fputs("missing option ", fp);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+
+    case EMAXCOUNT:
+        fputs("excess option ", fp);
+        arg_print_option(fp, shortopts, longopts, argval, "\n");
+        break;
+
+    case EBADDOUBLE:
+        fprintf(fp, "invalid argument \"%s\" to option ", argval);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+    }
+}
+
+
+struct arg_dbl * arg_dbl0(
+    const char * shortopts,
+    const char * longopts,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_dbln(shortopts, longopts, datatype, 0, 1, glossary);
+}
+
+
+struct arg_dbl * arg_dbl1(
+    const char * shortopts,
+    const char * longopts,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_dbln(shortopts, longopts, datatype, 1, 1, glossary);
+}
+
+
+struct arg_dbl * arg_dbln(
+    const char * shortopts,
+    const char * longopts,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary)
+{
+    size_t nbytes;
+    struct arg_dbl *result;
+
+    /* foolproof things by ensuring maxcount is not less than mincount */
+    maxcount = (maxcount < mincount) ? mincount : maxcount;
+
+    nbytes = sizeof(struct arg_dbl)     /* storage for struct arg_dbl */
+             + (maxcount + 1) * sizeof(double); /* storage for dval[maxcount] array plus one extra for padding to memory boundary */
+
+    result = (struct arg_dbl *)malloc(nbytes);
+    if (result)
+    {
+        size_t addr;
+        size_t rem;
+
+        /* init the arg_hdr struct */
+        result->hdr.flag      = ARG_HASVALUE;
+        result->hdr.shortopts = shortopts;
+        result->hdr.longopts  = longopts;
+        result->hdr.datatype  = datatype ? datatype : "<double>";
+        result->hdr.glossary  = glossary;
+        result->hdr.mincount  = mincount;
+        result->hdr.maxcount  = maxcount;
+        result->hdr.parent    = result;
+        result->hdr.resetfn   = (arg_resetfn *)arg_dbl_resetfn;
+        result->hdr.scanfn    = (arg_scanfn *)arg_dbl_scanfn;
+        result->hdr.checkfn   = (arg_checkfn *)arg_dbl_checkfn;
+        result->hdr.errorfn   = (arg_errorfn *)arg_dbl_errorfn;
+
+        /* Store the dval[maxcount] array on the first double boundary that
+         * immediately follows the arg_dbl struct. We do the memory alignment
+         * purely for SPARC and Motorola systems. They require floats and
+         * doubles to be aligned on natural boundaries.
+         */
+        addr = (size_t)(result + 1);
+        rem  = addr % sizeof(double);
+        result->dval  = (double *)(addr + sizeof(double) - rem);
+        ARG_TRACE(("addr=%p, dval=%p, sizeof(double)=%d rem=%d\n", addr, result->dval, (int)sizeof(double), (int)rem));
+
+        result->count = 0;
+    }
+    
+    ARG_TRACE(("arg_dbln() returns %p\n", result));
+    return result;
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+
+#include "argtable3.h"
+
+
+static void arg_end_resetfn(struct arg_end *parent)
+{
+    ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+    parent->count = 0;
+}
+
+static void arg_end_errorfn(
+    void *parent,
+    FILE *fp,
+    int error,
+    const char *argval,
+    const char *progname)
+{
+    /* suppress unreferenced formal parameter warning */
+    (void)parent;
+
+    progname = progname ? progname : "";
+    argval = argval ? argval : "";
+
+    fprintf(fp, "%s: ", progname);
+    switch(error)
+    {
+    case ARG_ELIMIT:
+        fputs("too many errors to display", fp);
+        break;
+    case ARG_EMALLOC:
+        fputs("insufficent memory", fp);
+        break;
+    case ARG_ENOMATCH:
+        fprintf(fp, "unexpected argument \"%s\"", argval);
+        break;
+    case ARG_EMISSARG:
+        fprintf(fp, "option \"%s\" requires an argument", argval);
+        break;
+    case ARG_ELONGOPT:
+        fprintf(fp, "invalid option \"%s\"", argval);
+        break;
+    default:
+        fprintf(fp, "invalid option \"-%c\"", error);
+        break;
+    }
+    
+    fputc('\n', fp);
+}
+
+
+struct arg_end * arg_end(int maxcount)
+{
+    size_t nbytes;
+    struct arg_end *result;
+
+    nbytes = sizeof(struct arg_end)
+             + maxcount * sizeof(int)     /* storage for int error[maxcount] array*/
+             + maxcount * sizeof(void *)  /* storage for void* parent[maxcount] array */
+             + maxcount * sizeof(char *); /* storage for char* argval[maxcount] array */
+
+    result = (struct arg_end *)malloc(nbytes);
+    if (result)
+    {
+        /* init the arg_hdr struct */
+        result->hdr.flag      = ARG_TERMINATOR;
+        result->hdr.shortopts = NULL;
+        result->hdr.longopts  = NULL;
+        result->hdr.datatype  = NULL;
+        result->hdr.glossary  = NULL;
+        result->hdr.mincount  = 1;
+        result->hdr.maxcount  = maxcount;
+        result->hdr.parent    = result;
+        result->hdr.resetfn   = (arg_resetfn *)arg_end_resetfn;
+        result->hdr.scanfn    = NULL;
+        result->hdr.checkfn   = NULL;
+        result->hdr.errorfn   = (arg_errorfn *)arg_end_errorfn;
+
+        /* store error[maxcount] array immediately after struct arg_end */
+        result->error = (int *)(result + 1);
+
+        /* store parent[maxcount] array immediately after error[] array */
+        result->parent = (void * *)(result->error + maxcount );
+
+        /* store argval[maxcount] array immediately after parent[] array */
+        result->argval = (const char * *)(result->parent + maxcount );
+    }
+
+    ARG_TRACE(("arg_end(%d) returns %p\n", maxcount, result));
+    return result;
+}
+
+
+void arg_print_errors(FILE * fp, struct arg_end * end, const char * progname)
+{
+    int i;
+    ARG_TRACE(("arg_errors()\n"));
+    for (i = 0; i < end->count; i++)
+    {
+        struct arg_hdr *errorparent = (struct arg_hdr *)(end->parent[i]);
+        if (errorparent->errorfn)
+            errorparent->errorfn(end->parent[i],
+                                 fp,
+                                 end->error[i],
+                                 end->argval[i],
+                                 progname);
+    }
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "argtable3.h"
+
+#ifdef WIN32
+# define FILESEPARATOR1 '\\'
+# define FILESEPARATOR2 '/'
+#else
+# define FILESEPARATOR1 '/'
+# define FILESEPARATOR2 '/'
+#endif
+
+
+static void arg_file_resetfn(struct arg_file *parent)
+{
+    ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+    parent->count = 0;
+}
+
+
+/* Returns ptr to the base filename within *filename */
+static const char * arg_basename(const char *filename)
+{
+    const char *result = NULL, *result1, *result2;
+
+    /* Find the last occurrence of eother file separator character. */
+    /* Two alternative file separator chars are supported as legal  */
+    /* file separators but not both together in the same filename.  */
+    result1 = (filename ? strrchr(filename, FILESEPARATOR1) : NULL);
+    result2 = (filename ? strrchr(filename, FILESEPARATOR2) : NULL);
+
+    if (result2)
+        result = result2 + 1;  /* using FILESEPARATOR2 (the alternative file separator) */
+
+    if (result1)
+        result = result1 + 1;  /* using FILESEPARATOR1 (the preferred file separator) */
+
+    if (!result)
+        result = filename;  /* neither file separator was found so basename is the whole filename */
+
+    /* special cases of "." and ".." are not considered basenames */
+    if (result && ( strcmp(".", result) == 0 || strcmp("..", result) == 0 ))
+        result = filename + strlen(filename);
+
+    return result;
+}
+
+
+/* Returns ptr to the file extension within *basename */
+static const char * arg_extension(const char *basename)
+{
+    /* find the last occurrence of '.' in basename */
+    const char *result = (basename ? strrchr(basename, '.') : NULL);
+
+    /* if no '.' was found then return pointer to end of basename */
+    if (basename && !result)
+        result = basename + strlen(basename);
+
+    /* special case: basenames with a single leading dot (eg ".foo") are not considered as true extensions */
+    if (basename && result == basename)
+        result = basename + strlen(basename);
+
+    /* special case: empty extensions (eg "foo.","foo..") are not considered as true extensions */
+    if (basename && result && result[1] == '\0')
+        result = basename + strlen(basename);
+
+    return result;
+}
+
+
+static int arg_file_scanfn(struct arg_file *parent, const char *argval)
+{
+    int errorcode = 0;
+
+    if (parent->count == parent->hdr.maxcount)
+    {
+        /* maximum number of arguments exceeded */
+        errorcode = EMAXCOUNT;
+    }
+    else if (!argval)
+    {
+        /* a valid argument with no argument value was given. */
+        /* This happens when an optional argument value was invoked. */
+        /* leave parent arguiment value unaltered but still count the argument. */
+        parent->count++;
+    }
+    else
+    {
+        parent->filename[parent->count]  = argval;
+        parent->basename[parent->count]  = arg_basename(argval);
+        parent->extension[parent->count] =
+            arg_extension(parent->basename[parent->count]);                                /* only seek extensions within the basename (not the file path)*/
+        parent->count++;
+    }
+
+    ARG_TRACE(("%s4:scanfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static int arg_file_checkfn(struct arg_file *parent)
+{
+    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
+    
+    ARG_TRACE(("%s:checkfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static void arg_file_errorfn(
+    struct arg_file *parent,
+    FILE *fp,
+    int errorcode,
+    const char *argval,
+    const char *progname)
+{
+    const char *shortopts = parent->hdr.shortopts;
+    const char *longopts  = parent->hdr.longopts;
+    const char *datatype  = parent->hdr.datatype;
+
+    /* make argval NULL safe */
+    argval = argval ? argval : "";
+
+    fprintf(fp, "%s: ", progname);
+    switch(errorcode)
+    {
+    case EMINCOUNT:
+        fputs("missing option ", fp);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+
+    case EMAXCOUNT:
+        fputs("excess option ", fp);
+        arg_print_option(fp, shortopts, longopts, argval, "\n");
+        break;
+
+    default:
+        fprintf(fp, "unknown error at \"%s\"\n", argval);
+    }
+}
+
+
+struct arg_file * arg_file0(
+    const char * shortopts,
+    const char * longopts,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_filen(shortopts, longopts, datatype, 0, 1, glossary);
+}
+
+
+struct arg_file * arg_file1(
+    const char * shortopts,
+    const char * longopts,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_filen(shortopts, longopts, datatype, 1, 1, glossary);
+}
+
+
+struct arg_file * arg_filen(
+    const char * shortopts,
+    const char * longopts,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary)
+{
+    size_t nbytes;
+    struct arg_file *result;
+
+    /* foolproof things by ensuring maxcount is not less than mincount */
+    maxcount = (maxcount < mincount) ? mincount : maxcount;
+
+    nbytes = sizeof(struct arg_file)      /* storage for struct arg_file */
+             + sizeof(char *) * maxcount  /* storage for filename[maxcount] array */
+             + sizeof(char *) * maxcount  /* storage for basename[maxcount] array */
+             + sizeof(char *) * maxcount; /* storage for extension[maxcount] array */
+
+    result = (struct arg_file *)malloc(nbytes);
+    if (result)
+    {
+        int i;
+
+        /* init the arg_hdr struct */
+        result->hdr.flag      = ARG_HASVALUE;
+        result->hdr.shortopts = shortopts;
+        result->hdr.longopts  = longopts;
+        result->hdr.glossary  = glossary;
+        result->hdr.datatype  = datatype ? datatype : "<file>";
+        result->hdr.mincount  = mincount;
+        result->hdr.maxcount  = maxcount;
+        result->hdr.parent    = result;
+        result->hdr.resetfn   = (arg_resetfn *)arg_file_resetfn;
+        result->hdr.scanfn    = (arg_scanfn *)arg_file_scanfn;
+        result->hdr.checkfn   = (arg_checkfn *)arg_file_checkfn;
+        result->hdr.errorfn   = (arg_errorfn *)arg_file_errorfn;
+
+        /* store the filename,basename,extension arrays immediately after the arg_file struct */
+        result->filename  = (const char * *)(result + 1);
+        result->basename  = result->filename + maxcount;
+        result->extension = result->basename + maxcount;
+        result->count = 0;
+
+        /* foolproof the string pointers by initialising them with empty strings */
+        for (i = 0; i < maxcount; i++)
+        {
+            result->filename[i] = "";
+            result->basename[i] = "";
+            result->extension[i] = "";
+        }
+    }
+    
+    ARG_TRACE(("arg_filen() returns %p\n", result));
+    return result;
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <limits.h>
+#include <ctype.h>
+
+#include "argtable3.h"
+
+
+static void arg_int_resetfn(struct arg_int *parent)
+{
+    ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+    parent->count = 0;
+}
+
+
+/* strtol0x() is like strtol() except that the numeric string is    */
+/* expected to be prefixed by "0X" where X is a user supplied char. */
+/* The string may optionally be prefixed by white space and + or -  */
+/* as in +0X123 or -0X123.                                          */
+/* Once the prefix has been scanned, the remainder of the numeric   */
+/* string is converted using strtol() with the given base.          */
+/* eg: to parse hex str="-0X12324", specify X='X' and base=16.      */
+/* eg: to parse oct str="+0o12324", specify X='O' and base=8.       */
+/* eg: to parse bin str="-0B01010", specify X='B' and base=2.       */
+/* Failure of conversion is indicated by result where *endptr==str. */
+static long int strtol0X(const char * str,
+                         const char * *endptr,
+                         char X,
+                         int base)
+{
+    long int val;               /* stores result */
+    int s = 1;                    /* sign is +1 or -1 */
+    const char *ptr = str;        /* ptr to current position in str */
+
+    /* skip leading whitespace */
+    while (ISSPACE(*ptr))
+        ptr++;
+    /* printf("1) %s\n",ptr); */
+
+    /* scan optional sign character */
+    switch (*ptr)
+    {
+    case '+':
+        ptr++;
+        s = 1;
+        break;
+    case '-':
+        ptr++;
+        s = -1;
+        break;
+    default:
+        s = 1;
+        break;
+    }
+    /* printf("2) %s\n",ptr); */
+
+    /* '0X' prefix */
+    if ((*ptr++) != '0')
+    {
+        /* printf("failed to detect '0'\n"); */
+        *endptr = str;
+        return 0;
+    }
+    /* printf("3) %s\n",ptr); */
+    if (toupper(*ptr++) != toupper(X))
+    {
+        /* printf("failed to detect '%c'\n",X); */
+        *endptr = str;
+        return 0;
+    }
+    /* printf("4) %s\n",ptr); */
+
+    /* attempt conversion on remainder of string using strtol() */
+    val = strtol(ptr, (char * *)endptr, base);
+    if (*endptr == ptr)
+    {
+        /* conversion failed */
+        *endptr = str;
+        return 0;
+    }
+
+    /* success */
+    return s * val;
+}
+
+
+/* Returns 1 if str matches suffix (case insensitive).    */
+/* Str may contain trailing whitespace, but nothing else. */
+static int detectsuffix(const char *str, const char *suffix)
+{
+    /* scan pairwise through strings until mismatch detected */
+    while( toupper(*str) == toupper(*suffix) )
+    {
+        /* printf("'%c' '%c'\n", *str, *suffix); */
+
+        /* return 1 (success) if match persists until the string terminator */
+        if (*str == '\0')
+            return 1;
+
+        /* next chars */
+        str++;
+        suffix++;
+    }
+    /* printf("'%c' '%c' mismatch\n", *str, *suffix); */
+
+    /* return 0 (fail) if the matching did not consume the entire suffix */
+    if (*suffix != 0)
+        return 0;   /* failed to consume entire suffix */
+
+    /* skip any remaining whitespace in str */
+    while (ISSPACE(*str))
+        str++;
+
+    /* return 1 (success) if we have reached end of str else return 0 (fail) */
+    return (*str == '\0') ? 1 : 0;
+}
+
+
+static int arg_int_scanfn(struct arg_int *parent, const char *argval)
+{
+    int errorcode = 0;
+
+    if (parent->count == parent->hdr.maxcount)
+    {
+        /* maximum number of arguments exceeded */
+        errorcode = EMAXCOUNT;
+    }
+    else if (!argval)
+    {
+        /* a valid argument with no argument value was given. */
+        /* This happens when an optional argument value was invoked. */
+        /* leave parent arguiment value unaltered but still count the argument. */
+        parent->count++;
+    }
+    else
+    {
+        long int val;
+        const char *end;
+
+        /* attempt to extract hex integer (eg: +0x123) from argval into val conversion */
+        val = strtol0X(argval, &end, 'X', 16);
+        if (end == argval)
+        {
+            /* hex failed, attempt octal conversion (eg +0o123) */
+            val = strtol0X(argval, &end, 'O', 8);
+            if (end == argval)
+            {
+                /* octal failed, attempt binary conversion (eg +0B101) */
+                val = strtol0X(argval, &end, 'B', 2);
+                if (end == argval)
+                {
+                    /* binary failed, attempt decimal conversion with no prefix (eg 1234) */
+                    val = strtol(argval, (char * *)&end, 10);
+                    if (end == argval)
+                    {
+                        /* all supported number formats failed */
+                        return EBADINT;
+                    }
+                }
+            }
+        }
+
+        /* Safety check for integer overflow. WARNING: this check    */
+        /* achieves nothing on machines where size(int)==size(long). */
+        if ( val > INT_MAX || val < INT_MIN )
+#ifdef __STDC_WANT_SECURE_LIB__
+            errorcode = EOVERFLOW_;
+#else
+            errorcode = EOVERFLOW;
+#endif
+
+        /* Detect any suffixes (KB,MB,GB) and multiply argument value appropriately. */
+        /* We need to be mindful of integer overflows when using such big numbers.   */
+        if (detectsuffix(end, "KB"))             /* kilobytes */
+        {
+            if ( val > (INT_MAX / 1024) || val < (INT_MIN / 1024) )
+#ifdef __STDC_WANT_SECURE_LIB__
+                errorcode = EOVERFLOW_;          /* Overflow would occur if we proceed */
+#else
+                errorcode = EOVERFLOW;          /* Overflow would occur if we proceed */
+#endif
+            else
+                val *= 1024;                    /* 1KB = 1024 */
+        }
+        else if (detectsuffix(end, "MB"))        /* megabytes */
+        {
+            if ( val > (INT_MAX / 1048576) || val < (INT_MIN / 1048576) )
+#ifdef __STDC_WANT_SECURE_LIB__
+                errorcode = EOVERFLOW_;          /* Overflow would occur if we proceed */
+#else
+                errorcode = EOVERFLOW;          /* Overflow would occur if we proceed */
+#endif
+            else
+                val *= 1048576;                 /* 1MB = 1024*1024 */
+        }
+        else if (detectsuffix(end, "GB"))        /* gigabytes */
+        {
+            if ( val > (INT_MAX / 1073741824) || val < (INT_MIN / 1073741824) )
+#ifdef __STDC_WANT_SECURE_LIB__
+                errorcode = EOVERFLOW_;          /* Overflow would occur if we proceed */
+#else
+                errorcode = EOVERFLOW;          /* Overflow would occur if we proceed */
+#endif
+            else
+                val *= 1073741824;              /* 1GB = 1024*1024*1024 */
+        }
+        else if (!detectsuffix(end, ""))
+            errorcode = EBADINT;                /* invalid suffix detected */
+
+        /* if success then store result in parent->ival[] array */
+        if (errorcode == 0)
+            parent->ival[parent->count++] = val;
+    }
+
+    /* printf("%s:scanfn(%p,%p) returns %d\n",__FILE__,parent,argval,errorcode); */
+    return errorcode;
+}
+
+
+static int arg_int_checkfn(struct arg_int *parent)
+{
+    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
+    /*printf("%s:checkfn(%p) returns %d\n",__FILE__,parent,errorcode);*/
+    return errorcode;
+}
+
+
+static void arg_int_errorfn(
+    struct arg_int *parent,
+    FILE *fp,
+    int errorcode,
+    const char *argval,
+    const char *progname)
+{
+    const char *shortopts = parent->hdr.shortopts;
+    const char *longopts  = parent->hdr.longopts;
+    const char *datatype  = parent->hdr.datatype;
+
+    /* make argval NULL safe */
+    argval = argval ? argval : "";
+
+    fprintf(fp, "%s: ", progname);
+    switch(errorcode)
+    {
+    case EMINCOUNT:
+        fputs("missing option ", fp);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+
+    case EMAXCOUNT:
+        fputs("excess option ", fp);
+        arg_print_option(fp, shortopts, longopts, argval, "\n");
+        break;
+
+    case EBADINT:
+        fprintf(fp, "invalid argument \"%s\" to option ", argval);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+
+#ifdef __STDC_WANT_SECURE_LIB__
+    case EOVERFLOW_:
+#else
+    case EOVERFLOW:
+#endif
+        fputs("integer overflow at option ", fp);
+        arg_print_option(fp, shortopts, longopts, datatype, " ");
+        fprintf(fp, "(%s is too large)\n", argval);
+        break;
+    }
+}
+
+
+struct arg_int * arg_int0(
+    const char *shortopts,
+    const char *longopts,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_intn(shortopts, longopts, datatype, 0, 1, glossary);
+}
+
+
+struct arg_int * arg_int1(
+    const char *shortopts,
+    const char *longopts,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_intn(shortopts, longopts, datatype, 1, 1, glossary);
+}
+
+
+struct arg_int * arg_intn(
+    const char *shortopts,
+    const char *longopts,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary)
+{
+    size_t nbytes;
+    struct arg_int *result;
+
+    /* foolproof things by ensuring maxcount is not less than mincount */
+    maxcount = (maxcount < mincount) ? mincount : maxcount;
+
+    nbytes = sizeof(struct arg_int)    /* storage for struct arg_int */
+             + maxcount * sizeof(int); /* storage for ival[maxcount] array */
+
+    result = (struct arg_int *)malloc(nbytes);
+    if (result)
+    {
+        /* init the arg_hdr struct */
+        result->hdr.flag      = ARG_HASVALUE;
+        result->hdr.shortopts = shortopts;
+        result->hdr.longopts  = longopts;
+        result->hdr.datatype  = datatype ? datatype : "<int>";
+        result->hdr.glossary  = glossary;
+        result->hdr.mincount  = mincount;
+        result->hdr.maxcount  = maxcount;
+        result->hdr.parent    = result;
+        result->hdr.resetfn   = (arg_resetfn *)arg_int_resetfn;
+        result->hdr.scanfn    = (arg_scanfn *)arg_int_scanfn;
+        result->hdr.checkfn   = (arg_checkfn *)arg_int_checkfn;
+        result->hdr.errorfn   = (arg_errorfn *)arg_int_errorfn;
+
+        /* store the ival[maxcount] array immediately after the arg_int struct */
+        result->ival  = (int *)(result + 1);
+        result->count = 0;
+    }
+    
+    ARG_TRACE(("arg_intn() returns %p\n", result));
+    return result;
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+
+#include "argtable3.h"
+
+
+static void arg_lit_resetfn(struct arg_lit *parent)
+{
+    ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+    parent->count = 0;
+}
+
+
+static int arg_lit_scanfn(struct arg_lit *parent, const char *argval)
+{
+    int errorcode = 0;
+    if (parent->count < parent->hdr.maxcount )
+        parent->count++;
+    else
+        errorcode = EMAXCOUNT;
+
+    ARG_TRACE(("%s:scanfn(%p,%s) returns %d\n", __FILE__, parent, argval,
+               errorcode));
+    return errorcode;
+}
+
+
+static int arg_lit_checkfn(struct arg_lit *parent)
+{
+    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
+    ARG_TRACE(("%s:checkfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static void arg_lit_errorfn(
+    struct arg_lit *parent,
+    FILE *fp,
+    int errorcode,
+    const char *argval,
+    const char *progname)
+{
+    const char *shortopts = parent->hdr.shortopts;
+    const char *longopts  = parent->hdr.longopts;
+    const char *datatype  = parent->hdr.datatype;
+
+    switch(errorcode)
+    {
+    case EMINCOUNT:
+        fprintf(fp, "%s: missing option ", progname);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        fprintf(fp, "\n");
+        break;
+
+    case EMAXCOUNT:
+        fprintf(fp, "%s: extraneous option ", progname);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+    }
+
+    ARG_TRACE(("%s:errorfn(%p, %p, %d, %s, %s)\n", __FILE__, parent, fp,
+               errorcode, argval, progname));
+}
+
+
+struct arg_lit * arg_lit0(
+    const char * shortopts,
+    const char * longopts,
+    const char * glossary)
+{
+    return arg_litn(shortopts, longopts, 0, 1, glossary);
+}
+
+
+struct arg_lit * arg_lit1(
+    const char *shortopts,
+    const char *longopts,
+    const char *glossary)
+{
+    return arg_litn(shortopts, longopts, 1, 1, glossary);
+}
+
+
+struct arg_lit * arg_litn(
+    const char *shortopts,
+    const char *longopts,
+    int mincount,
+    int maxcount,
+    const char *glossary)
+{
+    struct arg_lit *result;
+
+    /* foolproof things by ensuring maxcount is not less than mincount */
+    maxcount = (maxcount < mincount) ? mincount : maxcount;
+
+    result = (struct arg_lit *)malloc(sizeof(struct arg_lit));
+    if (result)
+    {
+        /* init the arg_hdr struct */
+        result->hdr.flag      = 0;
+        result->hdr.shortopts = shortopts;
+        result->hdr.longopts  = longopts;
+        result->hdr.datatype  = NULL;
+        result->hdr.glossary  = glossary;
+        result->hdr.mincount  = mincount;
+        result->hdr.maxcount  = maxcount;
+        result->hdr.parent    = result;
+        result->hdr.resetfn   = (arg_resetfn *)arg_lit_resetfn;
+        result->hdr.scanfn    = (arg_scanfn *)arg_lit_scanfn;
+        result->hdr.checkfn   = (arg_checkfn *)arg_lit_checkfn;
+        result->hdr.errorfn   = (arg_errorfn *)arg_lit_errorfn;
+
+        /* init local variables */
+        result->count = 0;
+    }
+    
+    ARG_TRACE(("arg_litn() returns %p\n", result));
+    return result;
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+
+#include "argtable3.h"
+
+struct arg_rem *arg_rem(const char *datatype, const char *glossary)
+{
+    struct arg_rem *result = (struct arg_rem *)malloc(sizeof(struct arg_rem));
+    if (result)
+    {
+        result->hdr.flag = 0;
+        result->hdr.shortopts = NULL;
+        result->hdr.longopts = NULL;
+        result->hdr.datatype = datatype;
+        result->hdr.glossary = glossary;
+        result->hdr.mincount = 1;
+        result->hdr.maxcount = 1;
+        result->hdr.parent = result;
+        result->hdr.resetfn = NULL;
+        result->hdr.scanfn = NULL;
+        result->hdr.checkfn = NULL;
+        result->hdr.errorfn = NULL;
+    }
+
+    ARG_TRACE(("arg_rem() returns %p\n", result));
+    return result;
+}
+
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "argtable3.h"
+
+
+#ifndef _TREX_H_
+#define _TREX_H_
+/***************************************************************
+       T-Rex a tiny regular expression library
+
+       Copyright (C) 2003-2006 Alberto Demichelis
+
+       This software is provided 'as-is', without any express
+       or implied warranty. In no event will the authors be held
+       liable for any damages arising from the use of this software.
+
+       Permission is granted to anyone to use this software for
+       any purpose, including commercial applications, and to alter
+       it and redistribute it freely, subject to the following restrictions:
+
+               1. The origin of this software must not be misrepresented;
+               you must not claim that you wrote the original software.
+               If you use this software in a product, an acknowledgment
+               in the product documentation would be appreciated but
+               is not required.
+
+               2. Altered source versions must be plainly marked as such,
+               and must not be misrepresented as being the original software.
+
+               3. This notice may not be removed or altered from any
+               source distribution.
+
+****************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _UNICODE
+#define TRexChar unsigned short
+#define MAX_CHAR 0xFFFF
+#define _TREXC(c) L##c
+#define trex_strlen wcslen
+#define trex_printf wprintf
+#else
+#define TRexChar char
+#define MAX_CHAR 0xFF
+#define _TREXC(c) (c)
+#define trex_strlen strlen
+#define trex_printf printf
+#endif
+
+#ifndef TREX_API
+#define TREX_API extern
+#endif
+
+#define TRex_True 1
+#define TRex_False 0
+
+#define TREX_ICASE ARG_REX_ICASE
+
+typedef unsigned int TRexBool;
+typedef struct TRex TRex;
+
+typedef struct {
+       const TRexChar *begin;
+       int len;
+} TRexMatch;
+
+TREX_API TRex *trex_compile(const TRexChar *pattern, const TRexChar **error, int flags);
+TREX_API void trex_free(TRex *exp);
+TREX_API TRexBool trex_match(TRex* exp, const TRexChar* text);
+TREX_API TRexBool trex_search(TRex* exp, const TRexChar* text, const TRexChar** out_begin, const TRexChar** out_end);
+TREX_API TRexBool trex_searchrange(TRex* exp, const TRexChar* text_begin, const TRexChar* text_end, const TRexChar** out_begin, const TRexChar** out_end);
+TREX_API int trex_getsubexpcount(TRex* exp);
+TREX_API TRexBool trex_getsubexp(TRex* exp, int n, TRexMatch *subexp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+
+struct privhdr
+{
+    const char *pattern;
+    int flags;
+};
+
+
+static void arg_rex_resetfn(struct arg_rex *parent)
+{
+    ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+    parent->count = 0;
+}
+
+static int arg_rex_scanfn(struct arg_rex *parent, const char *argval)
+{
+    int errorcode = 0;
+    const TRexChar *error = NULL;
+    TRex *rex = NULL;
+    TRexBool is_match = TRex_False;
+
+    if (parent->count == parent->hdr.maxcount )
+    {
+        /* maximum number of arguments exceeded */
+        errorcode = EMAXCOUNT;
+    }
+    else if (!argval)
+    {
+        /* a valid argument with no argument value was given. */
+        /* This happens when an optional argument value was invoked. */
+        /* leave parent argument value unaltered but still count the argument. */
+        parent->count++;
+    }
+    else
+    {
+        struct privhdr *priv = (struct privhdr *)parent->hdr.priv;
+
+        /* test the current argument value for a match with the regular expression */
+        /* if a match is detected, record the argument value in the arg_rex struct */
+
+        rex = trex_compile(priv->pattern, &error, priv->flags);
+        is_match = trex_match(rex, argval);
+        if (!is_match)
+            errorcode = EREGNOMATCH;
+        else
+            parent->sval[parent->count++] = argval;
+
+        trex_free(rex);
+    }
+
+    ARG_TRACE(("%s:scanfn(%p) returns %d\n",__FILE__,parent,errorcode));
+    return errorcode;
+}
+
+static int arg_rex_checkfn(struct arg_rex *parent)
+{
+    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
+    //struct privhdr *priv = (struct privhdr*)parent->hdr.priv;
+
+    /* free the regex "program" we constructed in resetfn */
+    //regfree(&(priv->regex));
+
+    /*printf("%s:checkfn(%p) returns %d\n",__FILE__,parent,errorcode);*/
+    return errorcode;
+}
+
+static void arg_rex_errorfn(struct arg_rex *parent,
+                    FILE *fp,
+                    int errorcode,
+                    const char *argval,
+                    const char *progname)
+{
+    const char *shortopts = parent->hdr.shortopts;
+    const char *longopts  = parent->hdr.longopts;
+    const char *datatype  = parent->hdr.datatype;
+
+    /* make argval NULL safe */
+    argval = argval ? argval : "";
+
+    fprintf(fp, "%s: ", progname);
+    switch(errorcode)
+    {
+    case EMINCOUNT:
+        fputs("missing option ", fp);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+
+    case EMAXCOUNT:
+        fputs("excess option ", fp);
+        arg_print_option(fp, shortopts, longopts, argval, "\n");
+        break;
+
+    case EREGNOMATCH:
+        fputs("illegal value  ", fp);
+        arg_print_option(fp, shortopts, longopts, argval, "\n");
+        break;
+
+    default:
+    {
+        //char errbuff[256];
+        //regerror(errorcode, NULL, errbuff, sizeof(errbuff));
+        //printf("%s\n", errbuff);
+    }
+    break;
+    }
+}
+
+
+struct arg_rex * arg_rex0(const char * shortopts,
+                          const char * longopts,
+                          const char * pattern,
+                          const char *datatype,
+                          int flags,
+                          const char *glossary)
+{
+    return arg_rexn(shortopts,
+                    longopts,
+                    pattern,
+                    datatype,
+                    0,
+                    1,
+                    flags,
+                    glossary);
+}
+
+struct arg_rex * arg_rex1(const char * shortopts,
+                          const char * longopts,
+                          const char * pattern,
+                          const char *datatype,
+                          int flags,
+                          const char *glossary)
+{
+    return arg_rexn(shortopts,
+                    longopts,
+                    pattern,
+                    datatype,
+                    1,
+                    1,
+                    flags,
+                    glossary);
+}
+
+
+struct arg_rex * arg_rexn(const char * shortopts,
+                          const char * longopts,
+                          const char * pattern,
+                          const char *datatype,
+                          int mincount,
+                          int maxcount,
+                          int flags,
+                          const char *glossary)
+{
+    size_t nbytes;
+    struct arg_rex *result;
+    struct privhdr *priv;
+    int i;
+    const TRexChar *error = NULL;
+    TRex *rex = NULL;
+
+    if (!pattern)
+    {
+        printf(
+            "argtable: ERROR - illegal regular expression pattern \"(NULL)\"\n");
+        printf("argtable: Bad argument table.\n");
+        return NULL;
+    }
+
+    /* foolproof things by ensuring maxcount is not less than mincount */
+    maxcount = (maxcount < mincount) ? mincount : maxcount;
+
+    nbytes = sizeof(struct arg_rex)       /* storage for struct arg_rex */
+             + sizeof(struct privhdr)     /* storage for private arg_rex data */
+             + maxcount * sizeof(char *);  /* storage for sval[maxcount] array */
+
+    result = (struct arg_rex *)malloc(nbytes);
+    if (result == NULL)
+        return result;
+
+    /* init the arg_hdr struct */
+    result->hdr.flag      = ARG_HASVALUE;
+    result->hdr.shortopts = shortopts;
+    result->hdr.longopts  = longopts;
+    result->hdr.datatype  = datatype ? datatype : pattern;
+    result->hdr.glossary  = glossary;
+    result->hdr.mincount  = mincount;
+    result->hdr.maxcount  = maxcount;
+    result->hdr.parent    = result;
+    result->hdr.resetfn   = (arg_resetfn *)arg_rex_resetfn;
+    result->hdr.scanfn    = (arg_scanfn *)arg_rex_scanfn;
+    result->hdr.checkfn   = (arg_checkfn *)arg_rex_checkfn;
+    result->hdr.errorfn   = (arg_errorfn *)arg_rex_errorfn;
+
+    /* store the arg_rex_priv struct immediately after the arg_rex struct */
+    result->hdr.priv  = result + 1;
+    priv = (struct privhdr *)(result->hdr.priv);
+    priv->pattern = pattern;
+    priv->flags = flags;
+
+    /* store the sval[maxcount] array immediately after the arg_rex_priv struct */
+    result->sval  = (const char * *)(priv + 1);
+    result->count = 0;
+
+    /* foolproof the string pointers by initializing them to reference empty strings */
+    for (i = 0; i < maxcount; i++)
+        result->sval[i] = "";
+
+    /* here we construct and destroy a regex representation of the regular
+     * expression for no other reason than to force any regex errors to be
+     * trapped now rather than later. If we don't, then errors may go undetected
+     * until an argument is actually parsed.
+     */
+
+    rex = trex_compile(priv->pattern, &error, priv->flags);
+    if (rex == NULL)
+    {
+        ARG_LOG(("argtable: %s \"%s\"\n", error ? error : _TREXC("undefined"), priv->pattern));
+        ARG_LOG(("argtable: Bad argument table.\n"));
+    }
+
+    trex_free(rex);
+
+    ARG_TRACE(("arg_rexn() returns %p\n", result));
+    return result;
+}
+
+
+
+/* see copyright notice in trex.h */
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <setjmp.h>
+
+#ifdef _UINCODE
+#define scisprint iswprint
+#define scstrlen wcslen
+#define scprintf wprintf
+#define _SC(x) L(x)
+#else
+#define scisprint isprint
+#define scstrlen strlen
+#define scprintf printf
+#define _SC(x) (x)
+#endif
+
+#ifdef _DEBUG
+#include <stdio.h>
+
+static const TRexChar *g_nnames[] =
+{
+       _SC("NONE"),_SC("OP_GREEDY"),   _SC("OP_OR"),
+       _SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"),       _SC("OP_CLASS"),
+       _SC("OP_CCLASS"),_SC("OP_NCLASS"),_SC("OP_RANGE"),_SC("OP_CHAR"),
+       _SC("OP_EOL"),_SC("OP_BOL"),_SC("OP_WB")
+};
+
+#endif
+#define OP_GREEDY              (MAX_CHAR+1) // * + ? {n}
+#define OP_OR                  (MAX_CHAR+2)
+#define OP_EXPR                        (MAX_CHAR+3) //parentesis ()
+#define OP_NOCAPEXPR   (MAX_CHAR+4) //parentesis (?:)
+#define OP_DOT                 (MAX_CHAR+5)
+#define OP_CLASS               (MAX_CHAR+6)
+#define OP_CCLASS              (MAX_CHAR+7)
+#define OP_NCLASS              (MAX_CHAR+8) //negates class the [^
+#define OP_RANGE               (MAX_CHAR+9)
+#define OP_CHAR                        (MAX_CHAR+10)
+#define OP_EOL                 (MAX_CHAR+11)
+#define OP_BOL                 (MAX_CHAR+12)
+#define OP_WB                  (MAX_CHAR+13)
+
+#define TREX_SYMBOL_ANY_CHAR ('.')
+#define TREX_SYMBOL_GREEDY_ONE_OR_MORE ('+')
+#define TREX_SYMBOL_GREEDY_ZERO_OR_MORE ('*')
+#define TREX_SYMBOL_GREEDY_ZERO_OR_ONE ('?')
+#define TREX_SYMBOL_BRANCH ('|')
+#define TREX_SYMBOL_END_OF_STRING ('$')
+#define TREX_SYMBOL_BEGINNING_OF_STRING ('^')
+#define TREX_SYMBOL_ESCAPE_CHAR ('\\')
+
+
+typedef int TRexNodeType;
+
+typedef struct tagTRexNode{
+       TRexNodeType type;
+       int left;
+       int right;
+       int next;
+}TRexNode;
+
+struct TRex{
+       const TRexChar *_eol;
+       const TRexChar *_bol;
+       const TRexChar *_p;
+       int _first;
+       int _op;
+       TRexNode *_nodes;
+       int _nallocated;
+       int _nsize;
+       int _nsubexpr;
+       TRexMatch *_matches;
+       int _currsubexp;
+       void *_jmpbuf;
+       const TRexChar **_error;
+       int _flags;
+};
+
+static int trex_list(TRex *exp);
+
+static int trex_newnode(TRex *exp, TRexNodeType type)
+{
+       TRexNode n;
+       int newid;
+       n.type = type;
+       n.next = n.right = n.left = -1;
+       if(type == OP_EXPR)
+               n.right = exp->_nsubexpr++;
+       if(exp->_nallocated < (exp->_nsize + 1)) {
+               exp->_nallocated *= 2;
+               exp->_nodes = (TRexNode *)realloc(exp->_nodes, exp->_nallocated * sizeof(TRexNode));
+       }
+       exp->_nodes[exp->_nsize++] = n;
+       newid = exp->_nsize - 1;
+       return (int)newid;
+}
+
+static void trex_error(TRex *exp,const TRexChar *error)
+{
+       if(exp->_error) *exp->_error = error;
+       longjmp(*((jmp_buf*)exp->_jmpbuf),-1);
+}
+
+static void trex_expect(TRex *exp, int n){
+       if((*exp->_p) != n)
+               trex_error(exp, _SC("expected paren"));
+       exp->_p++;
+}
+
+static TRexChar trex_escapechar(TRex *exp)
+{
+       if(*exp->_p == TREX_SYMBOL_ESCAPE_CHAR){
+               exp->_p++;
+               switch(*exp->_p) {
+               case 'v': exp->_p++; return '\v';
+               case 'n': exp->_p++; return '\n';
+               case 't': exp->_p++; return '\t';
+               case 'r': exp->_p++; return '\r';
+               case 'f': exp->_p++; return '\f';
+               default: return (*exp->_p++);
+               }
+       } else if(!scisprint(*exp->_p)) trex_error(exp,_SC("letter expected"));
+       return (*exp->_p++);
+}
+
+static int trex_charclass(TRex *exp,int classid)
+{
+       int n = trex_newnode(exp,OP_CCLASS);
+       exp->_nodes[n].left = classid;
+       return n;
+}
+
+static int trex_charnode(TRex *exp,TRexBool isclass)
+{
+       TRexChar t;
+       if(*exp->_p == TREX_SYMBOL_ESCAPE_CHAR) {
+               exp->_p++;
+               switch(*exp->_p) {
+                       case 'n': exp->_p++; return trex_newnode(exp,'\n');
+                       case 't': exp->_p++; return trex_newnode(exp,'\t');
+                       case 'r': exp->_p++; return trex_newnode(exp,'\r');
+                       case 'f': exp->_p++; return trex_newnode(exp,'\f');
+                       case 'v': exp->_p++; return trex_newnode(exp,'\v');
+                       case 'a': case 'A': case 'w': case 'W': case 's': case 'S':
+                       case 'd': case 'D': case 'x': case 'X': case 'c': case 'C':
+                       case 'p': case 'P': case 'l': case 'u':
+                               {
+                               t = *exp->_p; exp->_p++;
+                               return trex_charclass(exp,t);
+                               }
+                       case 'b':
+                       case 'B':
+                               if(!isclass) {
+                                       int node = trex_newnode(exp,OP_WB);
+                                       exp->_nodes[node].left = *exp->_p;
+                                       exp->_p++;
+                                       return node;
+                               } //else default
+                       default:
+                               t = *exp->_p; exp->_p++;
+                               return trex_newnode(exp,t);
+               }
+       }
+       else if(!scisprint(*exp->_p)) {
+
+               trex_error(exp,_SC("letter expected"));
+       }
+       t = *exp->_p; exp->_p++;
+       return trex_newnode(exp,t);
+}
+static int trex_class(TRex *exp)
+{
+       int ret = -1;
+       int first = -1,chain;
+       if(*exp->_p == TREX_SYMBOL_BEGINNING_OF_STRING){
+               ret = trex_newnode(exp,OP_NCLASS);
+               exp->_p++;
+       }else ret = trex_newnode(exp,OP_CLASS);
+
+       if(*exp->_p == ']') trex_error(exp,_SC("empty class"));
+       chain = ret;
+       while(*exp->_p != ']' && exp->_p != exp->_eol) {
+               if(*exp->_p == '-' && first != -1){
+                       int r,t;
+                       if(*exp->_p++ == ']') trex_error(exp,_SC("unfinished range"));
+                       r = trex_newnode(exp,OP_RANGE);
+                       if(first>*exp->_p) trex_error(exp,_SC("invalid range"));
+                       if(exp->_nodes[first].type == OP_CCLASS) trex_error(exp,_SC("cannot use character classes in ranges"));
+                       exp->_nodes[r].left = exp->_nodes[first].type;
+                       t = trex_escapechar(exp);
+                       exp->_nodes[r].right = t;
+            exp->_nodes[chain].next = r;
+                       chain = r;
+                       first = -1;
+               }
+               else{
+                       if(first!=-1){
+                               int c = first;
+                               exp->_nodes[chain].next = c;
+                               chain = c;
+                               first = trex_charnode(exp,TRex_True);
+                       }
+                       else{
+                               first = trex_charnode(exp,TRex_True);
+                       }
+               }
+       }
+       if(first!=-1){
+               int c = first;
+               exp->_nodes[chain].next = c;
+               chain = c;
+               first = -1;
+       }
+       /* hack? */
+       exp->_nodes[ret].left = exp->_nodes[ret].next;
+       exp->_nodes[ret].next = -1;
+       return ret;
+}
+
+static int trex_parsenumber(TRex *exp)
+{
+       int ret = *exp->_p-'0';
+       int positions = 10;
+       exp->_p++;
+       while(isdigit(*exp->_p)) {
+               ret = ret*10+(*exp->_p++-'0');
+               if(positions==1000000000) trex_error(exp,_SC("overflow in numeric constant"));
+               positions *= 10;
+       };
+       return ret;
+}
+
+static int trex_element(TRex *exp)
+{
+       int ret = -1;
+       switch(*exp->_p)
+       {
+       case '(': {
+               int expr,newn;
+               exp->_p++;
+
+
+               if(*exp->_p =='?') {
+                       exp->_p++;
+                       trex_expect(exp,':');
+                       expr = trex_newnode(exp,OP_NOCAPEXPR);
+               }
+               else
+                       expr = trex_newnode(exp,OP_EXPR);
+               newn = trex_list(exp);
+               exp->_nodes[expr].left = newn;
+               ret = expr;
+               trex_expect(exp,')');
+                         }
+                         break;
+       case '[':
+               exp->_p++;
+               ret = trex_class(exp);
+               trex_expect(exp,']');
+               break;
+       case TREX_SYMBOL_END_OF_STRING: exp->_p++; ret = trex_newnode(exp,OP_EOL);break;
+       case TREX_SYMBOL_ANY_CHAR: exp->_p++; ret = trex_newnode(exp,OP_DOT);break;
+       default:
+               ret = trex_charnode(exp,TRex_False);
+               break;
+       }
+
+       {
+               TRexBool isgreedy = TRex_False;
+               unsigned short p0 = 0, p1 = 0;
+               switch(*exp->_p){
+                       case TREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = TRex_True; break;
+                       case TREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; isgreedy = TRex_True; break;
+                       case TREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = TRex_True; break;
+                       case '{':
+                               exp->_p++;
+                               if(!isdigit(*exp->_p)) trex_error(exp,_SC("number expected"));
+                               p0 = (unsigned short)trex_parsenumber(exp);
+                               /*******************************/
+                               switch(*exp->_p) {
+                       case '}':
+                               p1 = p0; exp->_p++;
+                               break;
+                       case ',':
+                               exp->_p++;
+                               p1 = 0xFFFF;
+                               if(isdigit(*exp->_p)){
+                                       p1 = (unsigned short)trex_parsenumber(exp);
+                               }
+                               trex_expect(exp,'}');
+                               break;
+                       default:
+                               trex_error(exp,_SC(", or } expected"));
+               }
+               /*******************************/
+               isgreedy = TRex_True;
+               break;
+
+               }
+               if(isgreedy) {
+                       int nnode = trex_newnode(exp,OP_GREEDY);
+                       exp->_nodes[nnode].left = ret;
+                       exp->_nodes[nnode].right = ((p0)<<16)|p1;
+                       ret = nnode;
+               }
+       }
+       if((*exp->_p != TREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != TREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != TREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) {
+               int nnode = trex_element(exp);
+               exp->_nodes[ret].next = nnode;
+       }
+
+       return ret;
+}
+
+static int trex_list(TRex *exp)
+{
+       int ret=-1,e;
+       if(*exp->_p == TREX_SYMBOL_BEGINNING_OF_STRING) {
+               exp->_p++;
+               ret = trex_newnode(exp,OP_BOL);
+       }
+       e = trex_element(exp);
+       if(ret != -1) {
+               exp->_nodes[ret].next = e;
+       }
+       else ret = e;
+
+       if(*exp->_p == TREX_SYMBOL_BRANCH) {
+               int temp,tright;
+               exp->_p++;
+               temp = trex_newnode(exp,OP_OR);
+               exp->_nodes[temp].left = ret;
+               tright = trex_list(exp);
+               exp->_nodes[temp].right = tright;
+               ret = temp;
+       }
+       return ret;
+}
+
+static TRexBool trex_matchcclass(int cclass,TRexChar c)
+{
+       switch(cclass) {
+       case 'a': return isalpha(c)?TRex_True:TRex_False;
+       case 'A': return !isalpha(c)?TRex_True:TRex_False;
+       case 'w': return (isalnum(c) || c == '_')?TRex_True:TRex_False;
+       case 'W': return (!isalnum(c) && c != '_')?TRex_True:TRex_False;
+       case 's': return ISSPACE(c)?TRex_True:TRex_False;
+       case 'S': return !ISSPACE(c)?TRex_True:TRex_False;
+       case 'd': return isdigit(c)?TRex_True:TRex_False;
+       case 'D': return !isdigit(c)?TRex_True:TRex_False;
+       case 'x': return isxdigit(c)?TRex_True:TRex_False;
+       case 'X': return !isxdigit(c)?TRex_True:TRex_False;
+       case 'c': return iscntrl(c)?TRex_True:TRex_False;
+       case 'C': return !iscntrl(c)?TRex_True:TRex_False;
+       case 'p': return ispunct(c)?TRex_True:TRex_False;
+       case 'P': return !ispunct(c)?TRex_True:TRex_False;
+       case 'l': return islower(c)?TRex_True:TRex_False;
+       case 'u': return isupper(c)?TRex_True:TRex_False;
+       }
+       return TRex_False; /*cannot happen*/
+}
+
+static TRexBool trex_matchclass(TRex* exp,TRexNode *node,TRexChar c)
+{
+       do {
+               switch(node->type) {
+                       case OP_RANGE:
+                               if (exp->_flags & TREX_ICASE)
+                               {
+                                       if(c >= toupper(node->left) && c <= toupper(node->right)) return TRex_True;
+                                       if(c >= tolower(node->left) && c <= tolower(node->right)) return TRex_True;
+                               }
+                               else
+                               {
+                                       if(c >= node->left && c <= node->right) return TRex_True;
+                               }
+                               break;
+                       case OP_CCLASS:
+                               if(trex_matchcclass(node->left,c)) return TRex_True;
+                               break;
+                       default:
+                               if (exp->_flags & TREX_ICASE)
+                               {
+                                       if (c == tolower(node->type) || c == toupper(node->type)) return TRex_True;
+                               }
+                               else
+                               {
+                                       if(c == node->type)return TRex_True;
+                               }
+
+               }
+       } while((node->next != -1) && (node = &exp->_nodes[node->next]));
+       return TRex_False;
+}
+
+static const TRexChar *trex_matchnode(TRex* exp,TRexNode *node,const TRexChar *str,TRexNode *next)
+{
+
+       TRexNodeType type = node->type;
+       switch(type) {
+       case OP_GREEDY: {
+               //TRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL;
+               TRexNode *greedystop = NULL;
+               int p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0;
+               const TRexChar *s=str, *good = str;
+
+               if(node->next != -1) {
+                       greedystop = &exp->_nodes[node->next];
+               }
+               else {
+                       greedystop = next;
+               }
+
+               while((nmaches == 0xFFFF || nmaches < p1)) {
+
+                       const TRexChar *stop;
+                       if(!(s = trex_matchnode(exp,&exp->_nodes[node->left],s,greedystop)))
+                               break;
+                       nmaches++;
+                       good=s;
+                       if(greedystop) {
+                               //checks that 0 matches satisfy the expression(if so skips)
+                               //if not would always stop(for instance if is a '?')
+                               if(greedystop->type != OP_GREEDY ||
+                               (greedystop->type == OP_GREEDY && ((greedystop->right >> 16)&0x0000FFFF) != 0))
+                               {
+                                       TRexNode *gnext = NULL;
+                                       if(greedystop->next != -1) {
+                                               gnext = &exp->_nodes[greedystop->next];
+                                       }else if(next && next->next != -1){
+                                               gnext = &exp->_nodes[next->next];
+                                       }
+                                       stop = trex_matchnode(exp,greedystop,s,gnext);
+                                       if(stop) {
+                                               //if satisfied stop it
+                                               if(p0 == p1 && p0 == nmaches) break;
+                                               else if(nmaches >= p0 && p1 == 0xFFFF) break;
+                                               else if(nmaches >= p0 && nmaches <= p1) break;
+                                       }
+                               }
+                       }
+
+                       if(s >= exp->_eol)
+                               break;
+               }
+               if(p0 == p1 && p0 == nmaches) return good;
+               else if(nmaches >= p0 && p1 == 0xFFFF) return good;
+               else if(nmaches >= p0 && nmaches <= p1) return good;
+               return NULL;
+       }
+       case OP_OR: {
+                       const TRexChar *asd = str;
+                       TRexNode *temp=&exp->_nodes[node->left];
+                       while( (asd = trex_matchnode(exp,temp,asd,NULL)) ) {
+                               if(temp->next != -1)
+                                       temp = &exp->_nodes[temp->next];
+                               else
+                                       return asd;
+                       }
+                       asd = str;
+                       temp = &exp->_nodes[node->right];
+                       while( (asd = trex_matchnode(exp,temp,asd,NULL)) ) {
+                               if(temp->next != -1)
+                                       temp = &exp->_nodes[temp->next];
+                               else
+                                       return asd;
+                       }
+                       return NULL;
+                       break;
+       }
+       case OP_EXPR:
+       case OP_NOCAPEXPR:{
+                       TRexNode *n = &exp->_nodes[node->left];
+                       const TRexChar *cur = str;
+                       int capture = -1;
+                       if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
+                               capture = exp->_currsubexp;
+                               exp->_matches[capture].begin = cur;
+                               exp->_currsubexp++;
+                       }
+
+                       do {
+                               TRexNode *subnext = NULL;
+                               if(n->next != -1) {
+                                       subnext = &exp->_nodes[n->next];
+                               }else {
+                                       subnext = next;
+                               }
+                               if(!(cur = trex_matchnode(exp,n,cur,subnext))) {
+                                       if(capture != -1){
+                                               exp->_matches[capture].begin = 0;
+                                               exp->_matches[capture].len = 0;
+                                       }
+                                       return NULL;
+                               }
+                       } while((n->next != -1) && (n = &exp->_nodes[n->next]));
+
+                       if(capture != -1)
+                               exp->_matches[capture].len = (int)(cur - exp->_matches[capture].begin);
+                       return cur;
+       }
+       case OP_WB:
+               if((str == exp->_bol && !ISSPACE(*str))
+                || ((str == exp->_eol && !ISSPACE(*(str-1))))
+                || ((!ISSPACE(*str) && ISSPACE(*(str+1))))
+                || ((ISSPACE(*str) && !ISSPACE(*(str+1)))) ) {
+                       return (node->left == 'b')?str:NULL;
+               }
+               return (node->left == 'b')?NULL:str;
+       case OP_BOL:
+               if(str == exp->_bol) return str;
+               return NULL;
+       case OP_EOL:
+               if(str == exp->_eol) return str;
+               return NULL;
+       case OP_DOT:
+               str++;
+               return str;
+       case OP_NCLASS:
+       case OP_CLASS:
+               if(trex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?TRex_True:TRex_False):(type == OP_NCLASS?TRex_True:TRex_False)) {
+                        str++;
+                       return str;
+               }
+               return NULL;
+       case OP_CCLASS:
+               if(trex_matchcclass(node->left,*str)) {
+                        str++;
+                       return str;
+               }
+               return NULL;
+       default: /* char */
+               if (exp->_flags & TREX_ICASE)
+               {
+                       if(*str != tolower(node->type) && *str != toupper(node->type)) return NULL;
+               }
+               else
+               {
+                       if (*str != node->type) return NULL;
+               }
+               str++;
+               return str;
+       }
+       return NULL;
+}
+
+/* public api */
+TRex *trex_compile(const TRexChar *pattern,const TRexChar **error,int flags)
+{
+       TRex *exp = (TRex *)malloc(sizeof(TRex));
+       exp->_eol = exp->_bol = NULL;
+       exp->_p = pattern;
+       exp->_nallocated = (int)scstrlen(pattern) * sizeof(TRexChar);
+       exp->_nodes = (TRexNode *)malloc(exp->_nallocated * sizeof(TRexNode));
+       exp->_nsize = 0;
+       exp->_matches = 0;
+       exp->_nsubexpr = 0;
+       exp->_first = trex_newnode(exp,OP_EXPR);
+       exp->_error = error;
+       exp->_jmpbuf = malloc(sizeof(jmp_buf));
+       exp->_flags = flags;
+       if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) {
+               int res = trex_list(exp);
+               exp->_nodes[exp->_first].left = res;
+               if(*exp->_p!='\0')
+                       trex_error(exp,_SC("unexpected character"));
+#ifdef _DEBUG
+               {
+                       int nsize,i;
+                       TRexNode *t;
+                       nsize = exp->_nsize;
+                       t = &exp->_nodes[0];
+                       scprintf(_SC("\n"));
+                       for(i = 0;i < nsize; i++) {
+                               if(exp->_nodes[i].type>MAX_CHAR)
+                                       scprintf(_SC("[%02d] %10s "),i,g_nnames[exp->_nodes[i].type-MAX_CHAR]);
+                               else
+                                       scprintf(_SC("[%02d] %10c "),i,exp->_nodes[i].type);
+                               scprintf(_SC("left %02d right %02d next %02d\n"),exp->_nodes[i].left,exp->_nodes[i].right,exp->_nodes[i].next);
+                       }
+                       scprintf(_SC("\n"));
+               }
+#endif
+               exp->_matches = (TRexMatch *) malloc(exp->_nsubexpr * sizeof(TRexMatch));
+               memset(exp->_matches,0,exp->_nsubexpr * sizeof(TRexMatch));
+       }
+       else{
+               trex_free(exp);
+               return NULL;
+       }
+       return exp;
+}
+
+void trex_free(TRex *exp)
+{
+       if(exp) {
+               if(exp->_nodes) free(exp->_nodes);
+               if(exp->_jmpbuf) free(exp->_jmpbuf);
+               if(exp->_matches) free(exp->_matches);
+               free(exp);
+       }
+}
+
+TRexBool trex_match(TRex* exp,const TRexChar* text)
+{
+       const TRexChar* res = NULL;
+       exp->_bol = text;
+       exp->_eol = text + scstrlen(text);
+       exp->_currsubexp = 0;
+       res = trex_matchnode(exp,exp->_nodes,text,NULL);
+       if(res == NULL || res != exp->_eol)
+               return TRex_False;
+       return TRex_True;
+}
+
+TRexBool trex_searchrange(TRex* exp,const TRexChar* text_begin,const TRexChar* text_end,const TRexChar** out_begin, const TRexChar** out_end)
+{
+       const TRexChar *cur = NULL;
+       int node = exp->_first;
+       if(text_begin >= text_end) return TRex_False;
+       exp->_bol = text_begin;
+       exp->_eol = text_end;
+       do {
+               cur = text_begin;
+               while(node != -1) {
+                       exp->_currsubexp = 0;
+                       cur = trex_matchnode(exp,&exp->_nodes[node],cur,NULL);
+                       if(!cur)
+                               break;
+                       node = exp->_nodes[node].next;
+               }
+               text_begin++;
+       } while(cur == NULL && text_begin != text_end);
+
+       if(cur == NULL)
+               return TRex_False;
+
+       --text_begin;
+
+       if(out_begin) *out_begin = text_begin;
+       if(out_end) *out_end = cur;
+       return TRex_True;
+}
+
+TRexBool trex_search(TRex* exp,const TRexChar* text, const TRexChar** out_begin, const TRexChar** out_end)
+{
+       return trex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end);
+}
+
+int trex_getsubexpcount(TRex* exp)
+{
+       return exp->_nsubexpr;
+}
+
+TRexBool trex_getsubexp(TRex* exp, int n, TRexMatch *subexp)
+{
+       if( n<0 || n >= exp->_nsubexpr) return TRex_False;
+       *subexp = exp->_matches[n];
+       return TRex_True;
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+
+#include "argtable3.h"
+
+
+static void arg_str_resetfn(struct arg_str *parent)
+{
+    ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+    parent->count = 0;
+}
+
+
+static int arg_str_scanfn(struct arg_str *parent, const char *argval)
+{
+    int errorcode = 0;
+
+    if (parent->count == parent->hdr.maxcount)
+    {
+        /* maximum number of arguments exceeded */
+        errorcode = EMAXCOUNT;
+    }
+    else if (!argval)
+    {
+        /* a valid argument with no argument value was given. */
+        /* This happens when an optional argument value was invoked. */
+        /* leave parent arguiment value unaltered but still count the argument. */
+        parent->count++;
+    }
+    else
+    {
+        parent->sval[parent->count++] = argval;
+    }
+
+    ARG_TRACE(("%s:scanfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static int arg_str_checkfn(struct arg_str *parent)
+{
+    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
+    
+    ARG_TRACE(("%s:checkfn(%p) returns %d\n", __FILE__, parent, errorcode));
+    return errorcode;
+}
+
+
+static void arg_str_errorfn(
+    struct arg_str *parent,
+    FILE *fp,
+    int errorcode,
+    const char *argval,
+    const char *progname)
+{
+    const char *shortopts = parent->hdr.shortopts;
+    const char *longopts  = parent->hdr.longopts;
+    const char *datatype  = parent->hdr.datatype;
+
+    /* make argval NULL safe */
+    argval = argval ? argval : "";
+
+    fprintf(fp, "%s: ", progname);
+    switch(errorcode)
+    {
+    case EMINCOUNT:
+        fputs("missing option ", fp);
+        arg_print_option(fp, shortopts, longopts, datatype, "\n");
+        break;
+
+    case EMAXCOUNT:
+        fputs("excess option ", fp);
+        arg_print_option(fp, shortopts, longopts, argval, "\n");
+        break;
+    }
+}
+
+
+struct arg_str * arg_str0(
+    const char *shortopts,
+    const char *longopts,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_strn(shortopts, longopts, datatype, 0, 1, glossary);
+}
+
+
+struct arg_str * arg_str1(
+    const char *shortopts,
+    const char *longopts,
+    const char *datatype,
+    const char *glossary)
+{
+    return arg_strn(shortopts, longopts, datatype, 1, 1, glossary);
+}
+
+
+struct arg_str * arg_strn(
+    const char *shortopts,
+    const char *longopts,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary)
+{
+    size_t nbytes;
+    struct arg_str *result;
+
+    /* should not allow this stupid error */
+    /* we should return an error code warning this logic error */
+    /* foolproof things by ensuring maxcount is not less than mincount */
+    maxcount = (maxcount < mincount) ? mincount : maxcount;
+
+    nbytes = sizeof(struct arg_str)     /* storage for struct arg_str */
+             + maxcount * sizeof(char *); /* storage for sval[maxcount] array */
+
+    result = (struct arg_str *)malloc(nbytes);
+    if (result)
+    {
+        int i;
+
+        /* init the arg_hdr struct */
+        result->hdr.flag      = ARG_HASVALUE;
+        result->hdr.shortopts = shortopts;
+        result->hdr.longopts  = longopts;
+        result->hdr.datatype  = datatype ? datatype : "<string>";
+        result->hdr.glossary  = glossary;
+        result->hdr.mincount  = mincount;
+        result->hdr.maxcount  = maxcount;
+        result->hdr.parent    = result;
+        result->hdr.resetfn   = (arg_resetfn *)arg_str_resetfn;
+        result->hdr.scanfn    = (arg_scanfn *)arg_str_scanfn;
+        result->hdr.checkfn   = (arg_checkfn *)arg_str_checkfn;
+        result->hdr.errorfn   = (arg_errorfn *)arg_str_errorfn;
+
+        /* store the sval[maxcount] array immediately after the arg_str struct */
+        result->sval  = (const char * *)(result + 1);
+        result->count = 0;
+
+        /* foolproof the string pointers by initialising them to reference empty strings */
+        for (i = 0; i < maxcount; i++)
+            result->sval[i] = "";
+    }
+    
+    ARG_TRACE(("arg_strn() returns %p\n", result));
+    return result;
+}
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "argtable3.h"
+
+static
+void arg_register_error(struct arg_end *end,
+                        void *parent,
+                        int error,
+                        const char *argval)
+{
+    /* printf("arg_register_error(%p,%p,%d,%s)\n",end,parent,error,argval); */
+    if (end->count < end->hdr.maxcount)
+    {
+        end->error[end->count] = error;
+        end->parent[end->count] = parent;
+        end->argval[end->count] = argval;
+        end->count++;
+    }
+    else
+    {
+        end->error[end->hdr.maxcount - 1]  = ARG_ELIMIT;
+        end->parent[end->hdr.maxcount - 1] = end;
+        end->argval[end->hdr.maxcount - 1] = NULL;
+    }
+}
+
+
+/*
+ * Return index of first table entry with a matching short option
+ * or -1 if no match was found.
+ */
+static
+int find_shortoption(struct arg_hdr * *table, char shortopt)
+{
+    int tabindex;
+    for(tabindex = 0; !(table[tabindex]->flag & ARG_TERMINATOR); tabindex++)
+    {
+        if (table[tabindex]->shortopts &&
+            strchr(table[tabindex]->shortopts, shortopt))
+            return tabindex;
+    }
+    return -1;
+}
+
+
+struct longoptions
+{
+    int getoptval;
+    int noptions;
+    struct option *options;
+};
+
+#if 0
+static
+void dump_longoptions(struct longoptions * longoptions)
+{
+    int i;
+    printf("getoptval = %d\n", longoptions->getoptval);
+    printf("noptions  = %d\n", longoptions->noptions);
+    for (i = 0; i < longoptions->noptions; i++)
+    {
+        printf("options[%d].name    = \"%s\"\n",
+               i,
+               longoptions->options[i].name);
+        printf("options[%d].has_arg = %d\n", i, longoptions->options[i].has_arg);
+        printf("options[%d].flag    = %p\n", i, longoptions->options[i].flag);
+        printf("options[%d].val     = %d\n", i, longoptions->options[i].val);
+    }
+}
+#endif
+
+static
+struct longoptions * alloc_longoptions(struct arg_hdr * *table)
+{
+    struct longoptions *result;
+    size_t nbytes;
+    int noptions = 1;
+    size_t longoptlen = 0;
+    int tabindex;
+
+    /*
+     * Determine the total number of option structs required
+     * by counting the number of comma separated long options
+     * in all table entries and return the count in noptions.
+     * note: noptions starts at 1 not 0 because we getoptlong
+     * requires a NULL option entry to terminate the option array.
+     * While we are at it, count the number of chars required
+     * to store private copies of all the longoption strings
+     * and return that count in logoptlen.
+     */
+    tabindex = 0;
+    do
+    {
+        const char *longopts = table[tabindex]->longopts;
+        longoptlen += (longopts ? strlen(longopts) : 0) + 1;
+        while (longopts)
+        {
+            noptions++;
+            longopts = strchr(longopts + 1, ',');
+        }
+    } while(!(table[tabindex++]->flag & ARG_TERMINATOR));
+    /*printf("%d long options consuming %d chars in total\n",noptions,longoptlen);*/
+
+
+    /* allocate storage for return data structure as: */
+    /* (struct longoptions) + (struct options)[noptions] + char[longoptlen] */
+    nbytes = sizeof(struct longoptions)
+             + sizeof(struct option) * noptions
+             + longoptlen;
+    result = (struct longoptions *)malloc(nbytes);
+    if (result)
+    {
+        int option_index = 0;
+        char *store;
+
+        result->getoptval = 0;
+        result->noptions = noptions;
+        result->options = (struct option *)(result + 1);
+        store = (char *)(result->options + noptions);
+
+        for(tabindex = 0; !(table[tabindex]->flag & ARG_TERMINATOR); tabindex++)
+        {
+            const char *longopts = table[tabindex]->longopts;
+
+            while(longopts && *longopts)
+            {
+                char *storestart = store;
+
+                /* copy progressive longopt strings into the store */
+                while (*longopts != 0 && *longopts != ',')
+                    *store++ = *longopts++;
+                *store++ = 0;
+                if (*longopts == ',')
+                    longopts++;
+                /*fprintf(stderr,"storestart=\"%s\"\n",storestart);*/
+
+                result->options[option_index].name    = storestart;
+                result->options[option_index].flag    = &(result->getoptval);
+                result->options[option_index].val     = tabindex;
+                if (table[tabindex]->flag & ARG_HASOPTVALUE)
+                    result->options[option_index].has_arg = 2;
+                else if (table[tabindex]->flag & ARG_HASVALUE)
+                    result->options[option_index].has_arg = 1;
+                else
+                    result->options[option_index].has_arg = 0;
+
+                option_index++;
+            }
+        }
+        /* terminate the options array with a zero-filled entry */
+        result->options[option_index].name    = 0;
+        result->options[option_index].has_arg = 0;
+        result->options[option_index].flag    = 0;
+        result->options[option_index].val     = 0;
+    }
+
+    /*dump_longoptions(result);*/
+    return result;
+}
+
+static
+char * alloc_shortoptions(struct arg_hdr * *table)
+{
+    char *result;
+    size_t len = 2;
+    int tabindex;
+
+    /* determine the total number of option chars required */
+    for(tabindex = 0; !(table[tabindex]->flag & ARG_TERMINATOR); tabindex++)
+    {
+        struct arg_hdr *hdr = table[tabindex];
+        len += 3 * (hdr->shortopts ? strlen(hdr->shortopts) : 0);
+    }
+
+    result = malloc(len);
+    if (result)
+    {
+        char *res = result;
+
+        /* add a leading ':' so getopt return codes distinguish    */
+        /* unrecognised option and options missing argument values */
+        *res++ = ':';
+
+        for(tabindex = 0; !(table[tabindex]->flag & ARG_TERMINATOR); tabindex++)
+        {
+            struct arg_hdr *hdr = table[tabindex];
+            const char *shortopts = hdr->shortopts;
+            while(shortopts && *shortopts)
+            {
+                *res++ = *shortopts++;
+                if (hdr->flag & ARG_HASVALUE)
+                    *res++ = ':';
+                if (hdr->flag & ARG_HASOPTVALUE)
+                    *res++ = ':';
+            }
+        }
+        /* null terminate the string */
+        *res = 0;
+    }
+
+    /*printf("alloc_shortoptions() returns \"%s\"\n",(result?result:"NULL"));*/
+    return result;
+}
+
+
+/* return index of the table terminator entry */
+static
+int arg_endindex(struct arg_hdr * *table)
+{
+    int tabindex = 0;
+    while (!(table[tabindex]->flag & ARG_TERMINATOR))
+        tabindex++;
+    return tabindex;
+}
+
+
+static
+void arg_parse_tagged(int argc,
+                      char * *argv,
+                      struct arg_hdr * *table,
+                      struct arg_end *endtable)
+{
+    struct longoptions *longoptions;
+    char *shortoptions;
+    int copt;
+
+    /*printf("arg_parse_tagged(%d,%p,%p,%p)\n",argc,argv,table,endtable);*/
+
+    /* allocate short and long option arrays for the given opttable[].   */
+    /* if the allocs fail then put an error msg in the last table entry. */
+    longoptions  = alloc_longoptions(table);
+    shortoptions = alloc_shortoptions(table);
+    if (!longoptions || !shortoptions)
+    {
+        /* one or both memory allocs failed */
+        arg_register_error(endtable, endtable, ARG_EMALLOC, NULL);
+        /* free anything that was allocated (this is null safe) */
+        free(shortoptions);
+        free(longoptions);
+        return;
+    }
+
+    /*dump_longoptions(longoptions);*/
+
+    /* reset getopts internal option-index to zero, and disable error reporting */
+    optind = 0;
+    opterr = 0;
+
+    /* fetch and process args using getopt_long */
+    while( (copt =
+                getopt_long(argc, argv, shortoptions, longoptions->options,
+                            NULL)) != -1)
+    {
+        /*
+           printf("optarg='%s'\n",optarg);
+           printf("optind=%d\n",optind);
+           printf("copt=%c\n",(char)copt);
+           printf("optopt=%c (%d)\n",optopt, (int)(optopt));
+         */
+        switch(copt)
+        {
+        case 0:
+        {
+            int tabindex = longoptions->getoptval;
+            void *parent  = table[tabindex]->parent;
+            /*printf("long option detected from argtable[%d]\n", tabindex);*/
+            if (optarg && optarg[0] == 0 &&
+                (table[tabindex]->flag & ARG_HASVALUE))
+            {
+                /* printf(": long option %s requires an argument\n",argv[optind-1]); */
+                arg_register_error(endtable, endtable, ARG_EMISSARG,
+                                   argv[optind - 1]);
+                /* continue to scan the (empty) argument value to enforce argument count checking */
+            }
+            if (table[tabindex]->scanfn)
+            {
+                int errorcode = table[tabindex]->scanfn(parent, optarg);
+                if (errorcode != 0)
+                    arg_register_error(endtable, parent, errorcode, optarg);
+            }
+        }
+        break;
+
+        case '?':
+            /*
+             * getopt_long() found an unrecognised short option.
+             * if it was a short option its value is in optopt
+             * if it was a long option then optopt=0
+             */
+            switch (optopt)
+            {
+            case 0:
+                /*printf("?0 unrecognised long option %s\n",argv[optind-1]);*/
+                arg_register_error(endtable, endtable, ARG_ELONGOPT,
+                                   argv[optind - 1]);
+                break;
+            default:
+                /*printf("?* unrecognised short option '%c'\n",optopt);*/
+                arg_register_error(endtable, endtable, optopt, NULL);
+                break;
+            }
+            break;
+
+        case ':':
+            /*
+             * getopt_long() found an option with its argument missing.
+             */
+            /*printf(": option %s requires an argument\n",argv[optind-1]); */
+            arg_register_error(endtable, endtable, ARG_EMISSARG,
+                               argv[optind - 1]);
+            break;
+
+        default:
+        {
+            /* getopt_long() found a valid short option */
+            int tabindex = find_shortoption(table, (char)copt);
+            /*printf("short option detected from argtable[%d]\n", tabindex);*/
+            if (tabindex == -1)
+            {
+                /* should never get here - but handle it just in case */
+                /*printf("unrecognised short option %d\n",copt);*/
+                arg_register_error(endtable, endtable, copt, NULL);
+            }
+            else
+            {
+                if (table[tabindex]->scanfn)
+                {
+                    void *parent  = table[tabindex]->parent;
+                    int errorcode = table[tabindex]->scanfn(parent, optarg);
+                    if (errorcode != 0)
+                        arg_register_error(endtable, parent, errorcode, optarg);
+                }
+            }
+            break;
+        }
+        }
+    }
+
+    free(shortoptions);
+    free(longoptions);
+}
+
+
+static
+void arg_parse_untagged(int argc,
+                        char * *argv,
+                        struct arg_hdr * *table,
+                        struct arg_end *endtable)
+{
+    int tabindex = 0;
+    int errorlast = 0;
+    const char *optarglast = NULL;
+    void *parentlast = NULL;
+
+    /*printf("arg_parse_untagged(%d,%p,%p,%p)\n",argc,argv,table,endtable);*/
+    while (!(table[tabindex]->flag & ARG_TERMINATOR))
+    {
+        void *parent;
+        int errorcode;
+
+        /* if we have exhausted our argv[optind] entries then we have finished */
+        if (optind >= argc)
+        {
+            /*printf("arg_parse_untagged(): argv[] exhausted\n");*/
+            return;
+        }
+
+        /* skip table entries with non-null long or short options (they are not untagged entries) */
+        if (table[tabindex]->longopts || table[tabindex]->shortopts)
+        {
+            /*printf("arg_parse_untagged(): skipping argtable[%d] (tagged argument)\n",tabindex);*/
+            tabindex++;
+            continue;
+        }
+
+        /* skip table entries with NULL scanfn */
+        if (!(table[tabindex]->scanfn))
+        {
+            /*printf("arg_parse_untagged(): skipping argtable[%d] (NULL scanfn)\n",tabindex);*/
+            tabindex++;
+            continue;
+        }
+
+        /* attempt to scan the current argv[optind] with the current     */
+        /* table[tabindex] entry. If it succeeds then keep it, otherwise */
+        /* try again with the next table[] entry.                        */
+        parent = table[tabindex]->parent;
+        errorcode = table[tabindex]->scanfn(parent, argv[optind]);
+        if (errorcode == 0)
+        {
+            /* success, move onto next argv[optind] but stay with same table[tabindex] */
+            /*printf("arg_parse_untagged(): argtable[%d] successfully matched\n",tabindex);*/
+            optind++;
+
+            /* clear the last tentative error */
+            errorlast = 0;
+        }
+        else
+        {
+            /* failure, try same argv[optind] with next table[tabindex] entry */
+            /*printf("arg_parse_untagged(): argtable[%d] failed match\n",tabindex);*/
+            tabindex++;
+
+            /* remember this as a tentative error we may wish to reinstate later */
+            errorlast = errorcode;
+            optarglast = argv[optind];
+            parentlast = parent;
+        }
+
+    }
+
+    /* if a tenative error still remains at this point then register it as a proper error */
+    if (errorlast)
+    {
+        arg_register_error(endtable, parentlast, errorlast, optarglast);
+        optind++;
+    }
+
+    /* only get here when not all argv[] entries were consumed */
+    /* register an error for each unused argv[] entry */
+    while (optind < argc)
+    {
+        /*printf("arg_parse_untagged(): argv[%d]=\"%s\" not consumed\n",optind,argv[optind]);*/
+        arg_register_error(endtable, endtable, ARG_ENOMATCH, argv[optind++]);
+    }
+
+    return;
+}
+
+
+static
+void arg_parse_check(struct arg_hdr * *table, struct arg_end *endtable)
+{
+    int tabindex = 0;
+    /* printf("arg_parse_check()\n"); */
+    do
+    {
+        if (table[tabindex]->checkfn)
+        {
+            void *parent  = table[tabindex]->parent;
+            int errorcode = table[tabindex]->checkfn(parent);
+            if (errorcode != 0)
+                arg_register_error(endtable, parent, errorcode, NULL);
+        }
+    } while(!(table[tabindex++]->flag & ARG_TERMINATOR));
+}
+
+
+static
+void arg_reset(void * *argtable)
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    int tabindex = 0;
+    /*printf("arg_reset(%p)\n",argtable);*/
+    do
+    {
+        if (table[tabindex]->resetfn)
+            table[tabindex]->resetfn(table[tabindex]->parent);
+    } while(!(table[tabindex++]->flag & ARG_TERMINATOR));
+}
+
+
+int arg_parse(int argc, char * *argv, void * *argtable)
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    struct arg_end *endtable;
+    int endindex;
+    char * *argvcopy = NULL;
+
+    /*printf("arg_parse(%d,%p,%p)\n",argc,argv,argtable);*/
+
+    /* reset any argtable data from previous invocations */
+    arg_reset(argtable);
+
+    /* locate the first end-of-table marker within the array */
+    endindex = arg_endindex(table);
+    endtable = (struct arg_end *)table[endindex];
+
+    /* Special case of argc==0.  This can occur on Texas Instruments DSP. */
+    /* Failure to trap this case results in an unwanted NULL result from  */
+    /* the malloc for argvcopy (next code block).                         */
+    if (argc == 0)
+    {
+        /* We must still perform post-parse checks despite the absence of command line arguments */
+        arg_parse_check(table, endtable);
+
+        /* Now we are finished */
+        return endtable->count;
+    }
+
+    argvcopy = (char **)malloc(sizeof(char *) * (argc + 1));
+    if (argvcopy)
+    {
+        int i;
+
+        /*
+           Fill in the local copy of argv[]. We need a local copy
+           because getopt rearranges argv[] which adversely affects
+           susbsequent parsing attempts.
+         */
+        for (i = 0; i < argc; i++)
+            argvcopy[i] = argv[i];
+
+        argvcopy[argc] = NULL;
+        
+        /* parse the command line (local copy) for tagged options */
+        arg_parse_tagged(argc, argvcopy, table, endtable);
+
+        /* parse the command line (local copy) for untagged options */
+        arg_parse_untagged(argc, argvcopy, table, endtable);
+
+        /* if no errors so far then perform post-parse checks otherwise dont bother */
+        if (endtable->count == 0)
+            arg_parse_check(table, endtable);
+
+        /* release the local copt of argv[] */
+        free(argvcopy);
+    }
+    else
+    {
+        /* memory alloc failed */
+        arg_register_error(endtable, endtable, ARG_EMALLOC, NULL);
+    }
+
+    return endtable->count;
+}
+
+
+/*
+ * Concatenate contents of src[] string onto *pdest[] string.
+ * The *pdest pointer is altered to point to the end of the
+ * target string and *pndest is decremented by the same number
+ * of chars.
+ * Does not append more than *pndest chars into *pdest[]
+ * so as to prevent buffer overruns.
+ * Its something like strncat() but more efficient for repeated
+ * calls on the same destination string.
+ * Example of use:
+ *   char dest[30] = "good"
+ *   size_t ndest = sizeof(dest);
+ *   char *pdest = dest;
+ *   arg_char(&pdest,"bye ",&ndest);
+ *   arg_char(&pdest,"cruel ",&ndest);
+ *   arg_char(&pdest,"world!",&ndest);
+ * Results in:
+ *   dest[] == "goodbye cruel world!"
+ *   ndest  == 10
+ */
+static
+void arg_cat(char * *pdest, const char *src, size_t *pndest)
+{
+    char *dest = *pdest;
+    char *end  = dest + *pndest;
+
+    /*locate null terminator of dest string */
+    while(dest < end && *dest != 0)
+        dest++;
+
+    /* concat src string to dest string */
+    while(dest < end && *src != 0)
+        *dest++ = *src++;
+
+    /* null terminate dest string */
+    *dest = 0;
+
+    /* update *pdest and *pndest */
+    *pndest = end - dest;
+    *pdest  = dest;
+}
+
+
+static
+void arg_cat_option(char *dest,
+                    size_t ndest,
+                    const char *shortopts,
+                    const char *longopts,
+                    const char *datatype,
+                    int optvalue)
+{
+    if (shortopts)
+    {
+        char option[3];
+
+        /* note: option array[] is initialiazed dynamically here to satisfy   */
+        /* a deficiency in the watcom compiler wrt static array initializers. */
+        option[0] = '-';
+        option[1] = shortopts[0];
+        option[2] = 0;
+
+        arg_cat(&dest, option, &ndest);
+        if (datatype)
+        {
+            arg_cat(&dest, " ", &ndest);
+            if (optvalue)
+            {
+                arg_cat(&dest, "[", &ndest);
+                arg_cat(&dest, datatype, &ndest);
+                arg_cat(&dest, "]", &ndest);
+            }
+            else
+                arg_cat(&dest, datatype, &ndest);
+        }
+    }
+    else if (longopts)
+    {
+        size_t ncspn;
+
+        /* add "--" tag prefix */
+        arg_cat(&dest, "--", &ndest);
+
+        /* add comma separated option tag */
+        ncspn = strcspn(longopts, ",");
+#ifdef __STDC_WANT_SECURE_LIB__
+        strncat_s(dest, ndest, longopts, (ncspn < ndest) ? ncspn : ndest);
+#else
+        strncat(dest, longopts, (ncspn < ndest) ? ncspn : ndest);
+#endif
+
+        if (datatype)
+        {
+            arg_cat(&dest, "=", &ndest);
+            if (optvalue)
+            {
+                arg_cat(&dest, "[", &ndest);
+                arg_cat(&dest, datatype, &ndest);
+                arg_cat(&dest, "]", &ndest);
+            }
+            else
+                arg_cat(&dest, datatype, &ndest);
+        }
+    }
+    else if (datatype)
+    {
+        if (optvalue)
+        {
+            arg_cat(&dest, "[", &ndest);
+            arg_cat(&dest, datatype, &ndest);
+            arg_cat(&dest, "]", &ndest);
+        }
+        else
+            arg_cat(&dest, datatype, &ndest);
+    }
+}
+
+static
+void arg_cat_optionv(char *dest,
+                     size_t ndest,
+                     const char *shortopts,
+                     const char *longopts,
+                     const char *datatype,
+                     int optvalue,
+                     const char *separator)
+{
+    separator = separator ? separator : "";
+
+    if (shortopts)
+    {
+        const char *c = shortopts;
+        while(*c)
+        {
+            /* "-a|-b|-c" */
+            char shortopt[3];
+
+            /* note: shortopt array[] is initialiazed dynamically here to satisfy */
+            /* a deficiency in the watcom compiler wrt static array initializers. */
+            shortopt[0] = '-';
+            shortopt[1] = *c;
+            shortopt[2] = 0;
+
+            arg_cat(&dest, shortopt, &ndest);
+            if (*++c)
+                arg_cat(&dest, separator, &ndest);
+        }
+    }
+
+    /* put separator between long opts and short opts */
+    if (shortopts && longopts)
+        arg_cat(&dest, separator, &ndest);
+
+    if (longopts)
+    {
+        const char *c = longopts;
+        while(*c)
+        {
+            size_t ncspn;
+
+            /* add "--" tag prefix */
+            arg_cat(&dest, "--", &ndest);
+
+            /* add comma separated option tag */
+            ncspn = strcspn(c, ",");
+#ifdef __STDC_WANT_SECURE_LIB__
+            strncat_s(dest, ndest, c, (ncspn < ndest) ? ncspn : ndest);
+#else
+            strncat(dest, c, (ncspn < ndest) ? ncspn : ndest);
+#endif
+            c += ncspn;
+
+            /* add given separator in place of comma */
+            if (*c == ',')
+            {
+                arg_cat(&dest, separator, &ndest);
+                c++;
+            }
+        }
+    }
+
+    if (datatype)
+    {
+        if (longopts)
+            arg_cat(&dest, "=", &ndest);
+        else if (shortopts)
+            arg_cat(&dest, " ", &ndest);
+
+        if (optvalue)
+        {
+            arg_cat(&dest, "[", &ndest);
+            arg_cat(&dest, datatype, &ndest);
+            arg_cat(&dest, "]", &ndest);
+        }
+        else
+            arg_cat(&dest, datatype, &ndest);
+    }
+}
+
+
+/* this function should be deprecated because it doesnt consider optional argument values (ARG_HASOPTVALUE) */
+void arg_print_option(FILE *fp,
+                      const char *shortopts,
+                      const char *longopts,
+                      const char *datatype,
+                      const char *suffix)
+{
+    char syntax[200] = "";
+    suffix = suffix ? suffix : "";
+
+    /* there is no way of passing the proper optvalue for optional argument values here, so we must ignore it */
+    arg_cat_optionv(syntax,
+                    sizeof(syntax),
+                    shortopts,
+                    longopts,
+                    datatype,
+                    0,
+                    "|");
+
+    fputs(syntax, fp);
+    fputs(suffix, fp);
+}
+
+
+/*
+ * Print a GNU style [OPTION] string in which all short options that
+ * do not take argument values are presented in abbreviated form, as
+ * in: -xvfsd, or -xvf[sd], or [-xvsfd]
+ */
+static
+void arg_print_gnuswitch(FILE *fp, struct arg_hdr * *table)
+{
+    int tabindex;
+    char *format1 = " -%c";
+    char *format2 = " [-%c";
+    char *suffix = "";
+
+    /* print all mandatory switches that are without argument values */
+    for(tabindex = 0;
+        table[tabindex] && !(table[tabindex]->flag & ARG_TERMINATOR);
+        tabindex++)
+    {
+        /* skip optional options */
+        if (table[tabindex]->mincount < 1)
+            continue;
+
+        /* skip non-short options */
+        if (table[tabindex]->shortopts == NULL)
+            continue;
+
+        /* skip options that take argument values */
+        if (table[tabindex]->flag & ARG_HASVALUE)
+            continue;
+
+        /* print the short option (only the first short option char, ignore multiple choices)*/
+        fprintf(fp, format1, table[tabindex]->shortopts[0]);
+        format1 = "%c";
+        format2 = "[%c";
+    }
+
+    /* print all optional switches that are without argument values */
+    for(tabindex = 0;
+        table[tabindex] && !(table[tabindex]->flag & ARG_TERMINATOR);
+        tabindex++)
+    {
+        /* skip mandatory args */
+        if (table[tabindex]->mincount > 0)
+            continue;
+
+        /* skip args without short options */
+        if (table[tabindex]->shortopts == NULL)
+            continue;
+
+        /* skip args with values */
+        if (table[tabindex]->flag & ARG_HASVALUE)
+            continue;
+
+        /* print first short option */
+        fprintf(fp, format2, table[tabindex]->shortopts[0]);
+        format2 = "%c";
+        suffix = "]";
+    }
+
+    fprintf(fp, "%s", suffix);
+}
+
+
+void arg_print_syntax(FILE *fp, void * *argtable, const char *suffix)
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    int i, tabindex;
+
+    /* print GNU style [OPTION] string */
+    arg_print_gnuswitch(fp, table);
+
+    /* print remaining options in abbreviated style */
+    for(tabindex = 0;
+        table[tabindex] && !(table[tabindex]->flag & ARG_TERMINATOR);
+        tabindex++)
+    {
+        char syntax[200] = "";
+        const char *shortopts, *longopts, *datatype;
+
+        /* skip short options without arg values (they were printed by arg_print_gnu_switch) */
+        if (table[tabindex]->shortopts &&
+            !(table[tabindex]->flag & ARG_HASVALUE))
+            continue;
+
+        shortopts = table[tabindex]->shortopts;
+        longopts  = table[tabindex]->longopts;
+        datatype  = table[tabindex]->datatype;
+        arg_cat_option(syntax,
+                       sizeof(syntax),
+                       shortopts,
+                       longopts,
+                       datatype,
+                       table[tabindex]->flag & ARG_HASOPTVALUE);
+
+        if (strlen(syntax) > 0)
+        {
+            /* print mandatory instances of this option */
+            for (i = 0; i < table[tabindex]->mincount; i++)
+                fprintf(fp, " %s", syntax);
+
+            /* print optional instances enclosed in "[..]" */
+            switch ( table[tabindex]->maxcount - table[tabindex]->mincount )
+            {
+            case 0:
+                break;
+            case 1:
+                fprintf(fp, " [%s]", syntax);
+                break;
+            case 2:
+                fprintf(fp, " [%s] [%s]", syntax, syntax);
+                break;
+            default:
+                fprintf(fp, " [%s]...", syntax);
+                break;
+            }
+        }
+    }
+
+    if (suffix)
+        fprintf(fp, "%s", suffix);
+}
+
+
+void arg_print_syntaxv(FILE *fp, void * *argtable, const char *suffix)
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    int i, tabindex;
+
+    /* print remaining options in abbreviated style */
+    for(tabindex = 0;
+        table[tabindex] && !(table[tabindex]->flag & ARG_TERMINATOR);
+        tabindex++)
+    {
+        char syntax[200] = "";
+        const char *shortopts, *longopts, *datatype;
+
+        shortopts = table[tabindex]->shortopts;
+        longopts  = table[tabindex]->longopts;
+        datatype  = table[tabindex]->datatype;
+        arg_cat_optionv(syntax,
+                        sizeof(syntax),
+                        shortopts,
+                        longopts,
+                        datatype,
+                        table[tabindex]->flag & ARG_HASOPTVALUE,
+                        "|");
+
+        /* print mandatory options */
+        for (i = 0; i < table[tabindex]->mincount; i++)
+            fprintf(fp, " %s", syntax);
+
+        /* print optional args enclosed in "[..]" */
+        switch ( table[tabindex]->maxcount - table[tabindex]->mincount )
+        {
+        case 0:
+            break;
+        case 1:
+            fprintf(fp, " [%s]", syntax);
+            break;
+        case 2:
+            fprintf(fp, " [%s] [%s]", syntax, syntax);
+            break;
+        default:
+            fprintf(fp, " [%s]...", syntax);
+            break;
+        }
+    }
+
+    if (suffix)
+        fprintf(fp, "%s", suffix);
+}
+
+
+void arg_print_glossary(FILE *fp, void * *argtable, const char *format)
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    int tabindex;
+
+    format = format ? format : "  %-20s %s\n";
+    for (tabindex = 0; !(table[tabindex]->flag & ARG_TERMINATOR); tabindex++)
+    {
+        if (table[tabindex]->glossary)
+        {
+            char syntax[200] = "";
+            const char *shortopts = table[tabindex]->shortopts;
+            const char *longopts  = table[tabindex]->longopts;
+            const char *datatype  = table[tabindex]->datatype;
+            const char *glossary  = table[tabindex]->glossary;
+            arg_cat_optionv(syntax,
+                            sizeof(syntax),
+                            shortopts,
+                            longopts,
+                            datatype,
+                            table[tabindex]->flag & ARG_HASOPTVALUE,
+                            ", ");
+            fprintf(fp, format, syntax, glossary);
+        }
+    }
+}
+
+
+/**
+ * Print a piece of text formatted, which means in a column with a
+ * left and a right margin. The lines are wrapped at whitspaces next
+ * to right margin. The function does not indent the first line, but
+ * only the following ones.
+ *
+ * Example:
+ * arg_print_formatted( fp, 0, 5, "Some text that doesn't fit." )
+ * will result in the following output:
+ *
+ * Some
+ * text
+ * that
+ * doesn'
+ * t fit.
+ *
+ * Too long lines will be wrapped in the middle of a word.
+ *
+ * arg_print_formatted( fp, 2, 7, "Some text that doesn't fit." )
+ * will result in the following output:
+ *
+ * Some
+ *   text
+ *   that
+ *   doesn'
+ *   t fit.
+ *
+ * As you see, the first line is not indented. This enables output of
+ * lines, which start in a line where output already happened.
+ *
+ * Author: Uli Fouquet
+ */
+static
+void arg_print_formatted( FILE *fp,
+                          const unsigned lmargin,
+                          const unsigned rmargin,
+                          const char *text )
+{
+    const unsigned textlen = (unsigned)strlen( text );
+    unsigned line_start = 0;
+    unsigned line_end = textlen + 1;
+    const unsigned colwidth = (rmargin - lmargin) + 1;
+
+    /* Someone doesn't like us... */
+    if ( line_end < line_start )
+    { fprintf( fp, "%s\n", text ); }
+
+    while (line_end - 1 > line_start )
+    {
+        /* Eat leading whitespaces. This is essential because while
+           wrapping lines, there will often be a whitespace at beginning
+           of line */
+        while ( ISSPACE(*(text + line_start)) )
+        { line_start++; }
+
+        if ((line_end - line_start) > colwidth )
+        { line_end = line_start + colwidth; }
+
+        /* Find last whitespace, that fits into line */
+        while ( ( line_end > line_start )
+                && ( line_end - line_start > colwidth )
+                && !ISSPACE(*(text + line_end)))
+        { line_end--; }
+
+        /* Do not print trailing whitespace. If this text
+           has got only one line, line_end now points to the
+           last char due to initialization. */
+        line_end--;
+
+        /* Output line of text */
+        while ( line_start < line_end )
+        {
+            fputc(*(text + line_start), fp );
+            line_start++;
+        }
+        fputc( '\n', fp );
+
+        /* Initialize another line */
+        if ( line_end + 1 < textlen )
+        {
+            unsigned i;
+
+            for (i = 0; i < lmargin; i++ )
+            { fputc( ' ', fp ); }
+
+            line_end = textlen;
+        }
+
+        /* If we have to print another line, get also the last char. */
+        line_end++;
+
+    } /* lines of text */
+}
+
+/**
+ * Prints the glossary in strict GNU format.
+ * Differences to arg_print_glossary() are:
+ *   - wraps lines after 80 chars
+ *   - indents lines without shortops
+ *   - does not accept formatstrings
+ *
+ * Contributed by Uli Fouquet
+ */
+void arg_print_glossary_gnu(FILE *fp, void * *argtable )
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    int tabindex;
+
+    for(tabindex = 0; !(table[tabindex]->flag & ARG_TERMINATOR); tabindex++)
+    {
+        if (table[tabindex]->glossary)
+        {
+            char syntax[200] = "";
+            const char *shortopts = table[tabindex]->shortopts;
+            const char *longopts  = table[tabindex]->longopts;
+            const char *datatype  = table[tabindex]->datatype;
+            const char *glossary  = table[tabindex]->glossary;
+
+            if ( !shortopts && longopts )
+            {
+                /* Indent trailing line by 4 spaces... */
+                memset( syntax, ' ', 4 );
+                *(syntax + 4) = '\0';
+            }
+
+            arg_cat_optionv(syntax,
+                            sizeof(syntax),
+                            shortopts,
+                            longopts,
+                            datatype,
+                            table[tabindex]->flag & ARG_HASOPTVALUE,
+                            ", ");
+
+            /* If syntax fits not into column, print glossary in new line... */
+            if ( strlen(syntax) > 25 )
+            {
+                fprintf( fp, "  %-25s %s\n", syntax, "" );
+                *syntax = '\0';
+            }
+
+            fprintf( fp, "  %-25s ", syntax );
+            arg_print_formatted( fp, 28, 79, glossary );
+        }
+    } /* for each table entry */
+
+    fputc( '\n', fp );
+}
+
+
+/**
+ * Checks the argtable[] array for NULL entries and returns 1
+ * if any are found, zero otherwise.
+ */
+int arg_nullcheck(void * *argtable)
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    int tabindex;
+    /*printf("arg_nullcheck(%p)\n",argtable);*/
+
+    if (!table)
+        return 1;
+
+    tabindex = 0;
+    do
+    {
+        /*printf("argtable[%d]=%p\n",tabindex,argtable[tabindex]);*/
+        if (!table[tabindex])
+            return 1;
+    } while(!(table[tabindex++]->flag & ARG_TERMINATOR));
+
+    return 0;
+}
+
+
+/*
+ * arg_free() is deprecated in favour of arg_freetable() due to a flaw in its design.
+ * The flaw results in memory leak in the (very rare) case that an intermediate
+ * entry in the argtable array failed its memory allocation while others following
+ * that entry were still allocated ok. Those subsequent allocations will not be
+ * deallocated by arg_free().
+ * Despite the unlikeliness of the problem occurring, and the even unlikelier event
+ * that it has any deliterious effect, it is fixed regardless by replacing arg_free()
+ * with the newer arg_freetable() function.
+ * We still keep arg_free() for backwards compatibility.
+ */
+void arg_free(void * *argtable)
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    int tabindex = 0;
+    int flag;
+    /*printf("arg_free(%p)\n",argtable);*/
+    do
+    {
+        /*
+           if we encounter a NULL entry then somewhat incorrectly we presume
+           we have come to the end of the array. It isnt strictly true because
+           an intermediate entry could be NULL with other non-NULL entries to follow.
+           The subsequent argtable entries would then not be freed as they should.
+         */
+        if (table[tabindex] == NULL)
+            break;
+
+        flag = table[tabindex]->flag;
+        free(table[tabindex]);
+        table[tabindex++] = NULL;
+
+    } while(!(flag & ARG_TERMINATOR));
+}
+
+/* frees each non-NULL element of argtable[], where n is the size of the number of entries in the array */
+void arg_freetable(void * *argtable, size_t n)
+{
+    struct arg_hdr * *table = (struct arg_hdr * *)argtable;
+    size_t tabindex = 0;
+    /*printf("arg_freetable(%p)\n",argtable);*/
+    for (tabindex = 0; tabindex < n; tabindex++)
+    {
+        if (table[tabindex] == NULL)
+            continue;
+
+        free(table[tabindex]);
+        table[tabindex] = NULL;
+    };
+}
+
diff --git a/client/cliparser/argtable3.h b/client/cliparser/argtable3.h
new file mode 100644 (file)
index 0000000..1107de2
--- /dev/null
@@ -0,0 +1,305 @@
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#ifndef ARGTABLE3
+#define ARGTABLE3
+
+#include <stdio.h>      /* FILE */
+#include <time.h>       /* struct tm */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ARG_REX_ICASE 1
+    
+/* bit masks for arg_hdr.flag */
+enum
+{
+    ARG_TERMINATOR=0x1,
+    ARG_HASVALUE=0x2,
+    ARG_HASOPTVALUE=0x4
+};
+
+typedef void (arg_resetfn)(void *parent);
+typedef int  (arg_scanfn)(void *parent, const char *argval);
+typedef int  (arg_checkfn)(void *parent);
+typedef void (arg_errorfn)(void *parent, FILE *fp, int error, const char *argval, const char *progname);
+
+
+/*
+* The arg_hdr struct defines properties that are common to all arg_xxx structs.
+* The argtable library requires each arg_xxx struct to have an arg_hdr
+* struct as its first data member.
+* The argtable library functions then use this data to identify the
+* properties of the command line option, such as its option tags,
+* datatype string, and glossary strings, and so on.
+* Moreover, the arg_hdr struct contains pointers to custom functions that
+* are provided by each arg_xxx struct which perform the tasks of parsing
+* that particular arg_xxx arguments, performing post-parse checks, and
+* reporting errors.
+* These functions are private to the individual arg_xxx source code
+* and are the pointer to them are initiliased by that arg_xxx struct's
+* constructor function. The user could alter them after construction
+* if desired, but the original intention is for them to be set by the
+* constructor and left unaltered.
+*/
+struct arg_hdr
+{
+    char         flag;        /* Modifier flags: ARG_TERMINATOR, ARG_HASVALUE. */
+    const char  *shortopts;   /* String defining the short options */
+    const char  *longopts;    /* String defiing the long options */
+    const char  *datatype;    /* Description of the argument data type */
+    const char  *glossary;    /* Description of the option as shown by arg_print_glossary function */
+    int          mincount;    /* Minimum number of occurences of this option accepted */
+    int          maxcount;    /* Maximum number of occurences if this option accepted */
+    void        *parent;      /* Pointer to parent arg_xxx struct */
+    arg_resetfn *resetfn;     /* Pointer to parent arg_xxx reset function */
+    arg_scanfn  *scanfn;      /* Pointer to parent arg_xxx scan function */
+    arg_checkfn *checkfn;     /* Pointer to parent arg_xxx check function */
+    arg_errorfn *errorfn;     /* Pointer to parent arg_xxx error function */
+    void        *priv;        /* Pointer to private header data for use by arg_xxx functions */
+};
+
+struct arg_rem
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+};
+
+struct arg_lit
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+};
+
+struct arg_int
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+    int *ival;               /* Array of parsed argument values */
+};
+
+struct arg_dbl
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+    double *dval;            /* Array of parsed argument values */
+};
+
+struct arg_str
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+    const char **sval;       /* Array of parsed argument values */
+};
+
+struct arg_rex
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+    const char **sval;       /* Array of parsed argument values */
+};
+
+struct arg_file
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args*/
+    const char **filename;   /* Array of parsed filenames  (eg: /home/foo.bar) */
+    const char **basename;   /* Array of parsed basenames  (eg: foo.bar) */
+    const char **extension;  /* Array of parsed extensions (eg: .bar) */
+};
+
+struct arg_date
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    const char *format;      /* strptime format string used to parse the date */
+    int count;               /* Number of matching command line args */
+    struct tm *tmval;        /* Array of parsed time values */
+};
+
+enum {ARG_ELIMIT=1, ARG_EMALLOC, ARG_ENOMATCH, ARG_ELONGOPT, ARG_EMISSARG};
+struct arg_end
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of errors encountered */
+    int *error;              /* Array of error codes */
+    void **parent;           /* Array of pointers to offending arg_xxx struct */
+    const char **argval;     /* Array of pointers to offending argv[] string */
+};
+
+
+/**** arg_xxx constructor functions *********************************/
+
+struct arg_rem* arg_rem(const char* datatype, const char* glossary);
+
+struct arg_lit* arg_lit0(const char* shortopts,
+    const char* longopts,
+    const char* glossary);
+struct arg_lit* arg_lit1(const char* shortopts,
+    const char* longopts,
+    const char *glossary);
+struct arg_lit* arg_litn(const char* shortopts,
+    const char* longopts,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_key* arg_key0(const char* keyword,
+    int flags,
+    const char* glossary);
+struct arg_key* arg_key1(const char* keyword,
+    int flags,
+    const char* glossary);
+struct arg_key* arg_keyn(const char* keyword,
+    int flags,
+    int mincount,
+    int maxcount,
+    const char* glossary);
+
+struct arg_int* arg_int0(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char* glossary);
+struct arg_int* arg_int1(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char *glossary);
+struct arg_int* arg_intn(const char* shortopts,
+    const char* longopts,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_dbl* arg_dbl0(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char* glossary);
+struct arg_dbl* arg_dbl1(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char *glossary);
+struct arg_dbl* arg_dbln(const char* shortopts,
+    const char* longopts,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_str* arg_str0(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char* glossary);
+struct arg_str* arg_str1(const char* shortopts,
+    const char* longopts,                    
+    const char* datatype,
+    const char *glossary);
+struct arg_str* arg_strn(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_rex* arg_rex0(const char* shortopts,
+    const char* longopts,
+    const char* pattern,
+    const char* datatype,
+    int flags,
+    const char* glossary);
+struct arg_rex* arg_rex1(const char* shortopts,
+    const char* longopts,
+    const char* pattern,
+    const char* datatype,
+    int flags,
+    const char *glossary);
+struct arg_rex* arg_rexn(const char* shortopts,
+    const char* longopts,
+    const char* pattern,
+    const char* datatype,
+    int mincount,
+    int maxcount,
+    int flags,
+    const char *glossary);
+
+struct arg_file* arg_file0(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char* glossary);
+struct arg_file* arg_file1(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char *glossary);
+struct arg_file* arg_filen(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_date* arg_date0(const char* shortopts,
+    const char* longopts,
+    const char* format,
+    const char* datatype,
+    const char* glossary);
+struct arg_date* arg_date1(const char* shortopts,
+    const char* longopts,
+    const char* format,
+    const char* datatype,
+    const char *glossary);
+struct arg_date* arg_daten(const char* shortopts,
+    const char* longopts,
+    const char* format,
+    const char* datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_end* arg_end(int maxerrors);
+
+
+/**** other functions *******************************************/
+int arg_nullcheck(void **argtable);
+int arg_parse(int argc, char **argv, void **argtable);
+void arg_print_option(FILE *fp, const char *shortopts, const char *longopts, const char *datatype, const char *suffix);
+void arg_print_syntax(FILE *fp, void **argtable, const char *suffix);
+void arg_print_syntaxv(FILE *fp, void **argtable, const char *suffix);
+void arg_print_glossary(FILE *fp, void **argtable, const char *format);
+void arg_print_glossary_gnu(FILE *fp, void **argtable);
+void arg_print_errors(FILE* fp, struct arg_end* end, const char* progname);
+void arg_freetable(void **argtable, size_t n);
+
+/**** deprecated functions, for back-compatibility only ********/
+void arg_free(void **argtable);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/client/cliparser/cliparser.c b/client/cliparser/cliparser.c
new file mode 100644 (file)
index 0000000..0e70a63
--- /dev/null
@@ -0,0 +1,167 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2017 Merlok
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Command line parser core commands
+//-----------------------------------------------------------------------------
+
+#include "cliparser.h"
+#include <stdio.h>
+#include <string.h>
+
+void **argtable = NULL;
+size_t argtableLen = 0;
+char *programName = NULL;
+char *programHint = NULL;
+char *programHelp = NULL;
+char buf[500] = {0};
+
+int CLIParserInit(char *vprogramName, char *vprogramHint, char *vprogramHelp) {
+       argtable = NULL;
+       argtableLen = 0;
+       programName = vprogramName;
+       programHint = vprogramHint;
+       programHelp = vprogramHelp;
+       memset(buf, 0x00, 500);
+       
+       return 0;
+}
+
+int CLIParserParseArg(int argc, char **argv, void* vargtable[], size_t vargtableLen, bool allowEmptyExec) { 
+       int nerrors;
+       
+       argtable = vargtable;
+       argtableLen = vargtableLen;
+       
+       /* verify the argtable[] entries were allocated sucessfully */
+       if (arg_nullcheck(argtable) != 0) {
+               /* NULL entries were detected, some allocations must have failed */
+               printf("ERROR: Insufficient memory\n");
+               return 2;
+       }
+       /* Parse the command line as defined by argtable[] */
+       nerrors = arg_parse(argc, argv, argtable);
+       
+       /* special case: '--help' takes precedence over error reporting */
+       if ((argc < 2 && !allowEmptyExec) ||((struct arg_lit *)argtable[0])->count > 0) { // help must be the first record  
+               printf("Usage: %s", programName);
+               arg_print_syntaxv(stdout, argtable, "\n");
+               if (programHint)
+                       printf("%s\n\n", programHint);
+               arg_print_glossary(stdout, argtable, "    %-20s %s\n");
+               printf("\n");
+               if (programHelp)
+                       printf("%s \n", programHelp);
+               
+               return 1;
+       }
+
+       /* If the parser returned any errors then display them and exit */
+       if (nerrors > 0) {
+               /* Display the error details contained in the arg_end struct.*/
+               arg_print_errors(stdout, ((struct arg_end *)argtable[vargtableLen - 1]), programName);
+               printf("Try '%s --help' for more information.\n", programName);
+               
+               return 3;
+       }       
+       
+       return 0;
+}
+
+enum ParserState {
+       PS_FIRST,
+       PS_ARGUMENT,
+       PS_OPTION,
+};
+
+#define isSpace(c)(c == ' ' || c == '\t')
+
+int CLIParserParseString(const char* str, void* vargtable[], size_t vargtableLen, bool allowEmptyExec) {
+       int argc = 0;
+       char *argv[200] = {NULL};
+       
+       int len = strlen(str);
+       char *bufptr = buf;
+       char *spaceptr = NULL;
+       enum ParserState state = PS_FIRST;
+       
+       argv[argc++] = bufptr;  
+       // param0 = program name
+       memcpy(buf, programName, strlen(programName) + 1); // with 0x00
+       bufptr += strlen(programName) + 1;
+       if (len)
+               argv[argc++] = bufptr;  
+       
+       // parse params
+       for (int i = 0; i < len; i++) {
+               switch(state){
+                       case PS_FIRST: // first char
+                               if (str[i] == '-'){ // first char before space is '-' - next element - option
+                                       state = PS_OPTION;
+
+                                       if (spaceptr) {
+                                               bufptr = spaceptr;
+                                               *bufptr = 0x00;
+                                               bufptr++;
+                                               argv[argc++] = bufptr;  
+                                       }
+                               }
+                               spaceptr = NULL;
+                       case PS_ARGUMENT:
+                               if (state == PS_FIRST)
+                                       state = PS_ARGUMENT;
+                               if (isSpace(str[i])) {
+                                       spaceptr = bufptr;
+                                       state = PS_FIRST;
+                               }
+                               *bufptr = str[i];
+                               bufptr++;
+                               break;
+                       case PS_OPTION:
+                               if (isSpace(str[i])){
+                                       state = PS_FIRST;
+
+                                       *bufptr = 0x00;
+                                       bufptr++;
+                                       argv[argc++] = bufptr;  
+                                       break;
+                               }
+                               
+                               *bufptr = str[i];
+                               bufptr++;
+                               break;
+               }
+       }
+
+       return CLIParserParseArg(argc, argv, vargtable, vargtableLen, allowEmptyExec);
+}
+
+void CLIParserFree() {
+       arg_freetable(argtable, argtableLen);
+       argtable = NULL;
+       
+       return;
+}
+
+// convertors
+int CLIParamHexToBuf(struct arg_str *argstr, uint8_t *data, int maxdatalen, int *datalen) {
+       switch(param_gethex_to_eol(argstr->sval[0], 0, data, maxdatalen, datalen)) {
+       case 1:
+               printf("Parameter error: Invalid HEX value.\n");
+               return 1;
+       case 2:
+               printf("Parameter error: parameter too large.\n");
+               return 2;
+       case 3:
+               printf("Parameter error: Hex string must have even number of digits.\n");
+               return 3;
+       }
+       
+       return 0;
+}
+
+
+
diff --git a/client/cliparser/cliparser.h b/client/cliparser/cliparser.h
new file mode 100644 (file)
index 0000000..3f4fa4c
--- /dev/null
@@ -0,0 +1,32 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2017 Merlok
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Command line parser core commands
+//-----------------------------------------------------------------------------
+
+#include "argtable3.h"
+#include "util.h"
+#include <stdbool.h>
+
+#define arg_param_begin arg_lit0("hH",  "help",    "print this help and exit")
+#define arg_param_end arg_end(20)
+
+#define arg_getsize(a) (sizeof(a) / sizeof(a[0]))
+#define arg_get_lit(n)(((struct arg_lit*)argtable[n])->count)
+#define arg_get_int(n)(((struct arg_int*)argtable[n])->ival[0])
+#define arg_get_str(n)((struct arg_str*)argtable[n])
+
+#define CLIExecWithReturn(cmd, atbl, ifempty) if (CLIParserParseString(cmd, atbl, arg_getsize(atbl), ifempty)){CLIParserFree();return 0;}
+#define CLIGetStrBLessWithReturn(paramnum, data, datalen, delta) if (CLIParamHexToBuf(arg_get_str(paramnum), data, sizeof(data) - (delta), datalen)) {CLIParserFree();return 1;}
+#define CLIGetStrWithReturn(paramnum, data, datalen) if (CLIParamHexToBuf(arg_get_str(paramnum), data, sizeof(data), datalen)) {CLIParserFree();return 1;}
+
+extern int CLIParserInit(char *vprogramName, char *vprogramHint, char *vprogramHelp);
+extern int CLIParserParseString(const char* str, void* argtable[], size_t vargtableLen, bool allowEmptyExec);
+extern int CLIParserParseArg(int argc, char **argv, void* argtable[], size_t vargtableLen, bool allowEmptyExec);
+extern void CLIParserFree();
+
+extern int CLIParamHexToBuf(struct arg_str *argstr, uint8_t *data, int maxdatalen, int *datalen);
index 03ab0b5a69f8b3e83e725af73b99ed3b464f84fa..2d76f1098f69c7bf30b87f010d142fb4d08d6536 100644 (file)
@@ -28,6 +28,7 @@
 #include "mifare.h"
 #include "cmdhfmfu.h"
 #include "mifarehost.h"
+#include "cliparser/cliparser.h"
 #include "emv/apduinfo.h"
 #include "emv/emvcore.h"
 
@@ -137,38 +138,32 @@ int CmdHF14AList(const char *Cmd)
 
 int CmdHF14AReader(const char *Cmd) {
        uint32_t cm = ISO14A_CONNECT;
-       bool disconnectAfter = true;
+       bool leaveSignalON = false;
        
-       int cmdp = 0;
-       while(param_getchar(Cmd, cmdp) != 0x00) {
-               switch(param_getchar(Cmd, cmdp)) {
-               case 'h':
-               case 'H':
-                       PrintAndLog("Usage: hf 14a reader [k|x] [3]");
-                       PrintAndLog("       k    keep the field active after command executed");
-                       PrintAndLog("       x    just drop the signal field");
-                       PrintAndLog("       3    ISO14443-3 select only (skip RATS)");
-                       return 0;
-               case '3':
-                       cm |= ISO14A_NO_RATS; 
-                       break;
-               case 'k':
-               case 'K':
-                       disconnectAfter = false;
-                       break;
-               case 'x':
-               case 'X':
-                       cm &= ~ISO14A_CONNECT;
-                       break;
-               default:
-                       PrintAndLog("Unknown command.");
-                       return 1;
-               }       
-               
-               cmdp++;
+       CLIParserInit("hf 14a reader", "Executes ISO1443A anticollision-select group of commands.", NULL);
+       void* argtable[] = {
+               arg_param_begin,
+               arg_lit0("kK",  "keep",    "keep the field active after command executed"),
+               arg_lit0("xX",  "drop",    "just drop the signal field"),
+               arg_lit0("3",   NULL,      "ISO14443-3 select only (skip RATS)"),
+               arg_param_end
+       };
+       if (CLIParserParseString(Cmd, argtable, arg_getsize(argtable), true)){
+               CLIParserFree();
+               return 0;
        }
-
-       if (!disconnectAfter)
+       
+       leaveSignalON = arg_get_lit(1);
+       if (arg_get_lit(2)) {
+               cm = cm - ISO14A_CONNECT;
+       }
+       if (arg_get_lit(3)) {
+               cm |= ISO14A_NO_RATS;
+       }
+       
+       CLIParserFree();
+       
+       if (leaveSignalON)
                cm |= ISO14A_NO_DISCONNECT; 
        
        UsbCommand c = {CMD_READER_ISO_14443a, {cm, 0, 0}};
@@ -200,12 +195,12 @@ int CmdHF14AReader(const char *Cmd) {
                if(card.ats_len >= 3) {                 // a valid ATS consists of at least the length byte (TL) and 2 CRC bytes
                        PrintAndLog(" ATS : %s", sprint_hex(card.ats, card.ats_len));
                }
-               if (!disconnectAfter) {
+               if (leaveSignalON) {
                        PrintAndLog("Card is selected. You can now start sending commands");
                }
        }
 
-       if (disconnectAfter) {
+       if (!leaveSignalON) {
                PrintAndLog("Field dropped.");
        }
        
@@ -737,59 +732,30 @@ int CmdHF14AAPDU(const char *cmd) {
        bool activateField = false;
        bool leaveSignalON = false;
        bool decodeTLV = false;
+
+       CLIParserInit("hf 14a apdu", 
+               "Sends an ISO 7816-4 APDU via ISO 14443-4 block transmission protocol (T=CL)", 
+               "Sample:\n\thf 14a apdu -st 00A404000E325041592E5359532E444446303100\n");
+
+       void* argtable[] = {
+               arg_param_begin,
+               arg_lit0("sS",  "select",  "activate field and select card"),
+               arg_lit0("kK",  "keep",    "leave the signal field ON after receive response"),
+               arg_lit0("tT",  "tlv",     "executes TLV decoder if it possible"),
+               arg_str1(NULL,  NULL,      "<APDU (hex)>", NULL),
+               arg_param_end
+       };
+       CLIExecWithReturn(cmd, argtable, false);
        
-       if (strlen(cmd) < 2) {
-               PrintAndLog("Usage: hf 14a apdu [-s] [-k] [-t] <APDU (hex)>");
-               PrintAndLog("Command sends an ISO 7816-4 APDU via ISO 14443-4 block transmission protocol (T=CL)");
-               PrintAndLog("       -s    activate field and select card");
-               PrintAndLog("       -k    leave the signal field ON after receive response");
-               PrintAndLog("       -t    executes TLV decoder if it possible. TODO!!!!");
-               return 0;
-       }
+       activateField = arg_get_lit(1);
+       leaveSignalON = arg_get_lit(2);
+       decodeTLV = arg_get_lit(3);
+       // len = data + PCB(1b) + CRC(2b)
+       CLIGetStrBLessWithReturn(4, data, &datalen, 1 + 2);
 
-       int cmdp = 0;
-       while(param_getchar(cmd, cmdp) != 0x00) {
-               char c = param_getchar(cmd, cmdp);
-               if ((c == '-') && (param_getlength(cmd, cmdp) == 2))
-                       switch (param_getchar_indx(cmd, 1, cmdp)) {
-                               case 's':
-                               case 'S':
-                                       activateField = true;
-                                       break;
-                               case 'k':
-                               case 'K':
-                                       leaveSignalON = true;
-                                       break;
-                               case 't':
-                               case 'T':
-                                       decodeTLV = true;
-                                       break;
-                               default:
-                                       PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
-                                       return 1;
-                       }
-                       
-               if (isxdigit((unsigned char)c)) {
-                       // len = data + PCB(1b) + CRC(2b)
-                       switch(param_gethex_to_eol(cmd, cmdp, data, sizeof(data) - 1 - 2, &datalen)) {
-                       case 1:
-                               PrintAndLog("Invalid HEX value.");
-                               return 1;
-                       case 2:
-                               PrintAndLog("APDU too large.");
-                               return 1;
-                       case 3:
-                               PrintAndLog("Hex must have even number of digits.");
-                               return 1;
-                       }
-                       
-                       // we get all the hex to end of line with spaces
-                       break;
-               }
-               
-               cmdp++;
-       }
 
+       CLIParserFree();
+//     PrintAndLog("---str [%d] %s", arg_get_str(4)->count, arg_get_str(4)->sval[0]);
        PrintAndLog(">>>>[%s%s%s] %s", activateField ? "sel ": "", leaveSignalON ? "keep ": "", decodeTLV ? "TLV": "", sprint_hex(data, datalen));
        
        int res = ExchangeAPDU14a(data, datalen, activateField, leaveSignalON, data, USB_CMD_DATA_SIZE, &datalen);
@@ -821,102 +787,57 @@ int CmdHF14ACmdRaw(const char *cmd) {
        bool bTimeout = false;
        uint32_t timeout = 0;
        bool topazmode = false;
-       char buf[5]="";
-       int i = 0;
        uint8_t data[USB_CMD_DATA_SIZE];
-       uint16_t datalen = 0;
-       uint32_t temp;
-
-       if (strlen(cmd)<2) {
-               PrintAndLog("Usage: hf 14a raw [-r] [-c] [-p] [-f] [-b] [-t] <number of bits> <0A 0B 0C ... hex>");
-               PrintAndLog("       -r    do not read response");
-               PrintAndLog("       -c    calculate and append CRC");
-               PrintAndLog("       -p    leave the signal field ON after receive");
-               PrintAndLog("       -a    active signal field ON without select");
-               PrintAndLog("       -s    active signal field ON with select");
-               PrintAndLog("       -b    number of bits to send. Useful for send partial byte");
-               PrintAndLog("       -t    timeout in ms");
-               PrintAndLog("       -T    use Topaz protocol to send command");
-               PrintAndLog("       -3    ISO14443-3 select only (skip RATS)");
-               return 0;
-       }
-
+       int datalen = 0;
 
-       // strip
-       while (*cmd==' ' || *cmd=='\t') cmd++;
-
-       while (cmd[i]!='\0') {
-               if (cmd[i]==' ' || cmd[i]=='\t') { i++; continue; }
-               if (cmd[i]=='-') {
-                       switch (cmd[i+1]) {
-                               case 'r': 
-                                       reply = false;
-                                       break;
-                               case 'c':
-                                       crc = true;
-                                       break;
-                               case 'p':
-                                       power = true;
-                                       break;
-                               case 'a':
-                                       active = true;
-                                       break;
-                               case 's':
-                                       active_select = true;
-                                       break;
-                               case 'b': 
-                                       sscanf(cmd+i+2,"%d",&temp);
-                                       numbits = temp & 0xFFFF;
-                                       i+=3;
-                                       while(cmd[i]!=' ' && cmd[i]!='\0') { i++; }
-                                       i-=2;
-                                       break;
-                               case 't':
-                                       bTimeout = true;
-                                       sscanf(cmd+i+2,"%d",&temp);
-                                       timeout = temp;
-                                       i+=3;
-                                       while(cmd[i]!=' ' && cmd[i]!='\0') { i++; }
-                                       i-=2;
-                                       break;
-                               case 'T':
-                                       topazmode = true;
-                                       break;
-                               case '3':
-                                       no_rats = true;
-                                       break;
-                               default:
-                                       PrintAndLog("Invalid option");
-                                       return 0;
-                       }
-                       i+=2;
-                       continue;
-               }
-               if ((cmd[i]>='0' && cmd[i]<='9') ||
-                   (cmd[i]>='a' && cmd[i]<='f') ||
-                   (cmd[i]>='A' && cmd[i]<='F') ) {
-                       buf[strlen(buf)+1]=0;
-                       buf[strlen(buf)]=cmd[i];
-                       i++;
-
-                       if (strlen(buf)>=2) {
-                               sscanf(buf,"%x",&temp);
-                               data[datalen]=(uint8_t)(temp & 0xff);
-                               *buf=0;
-                               if (datalen > sizeof(data)-1) {
-                                       if (crc)
-                                               PrintAndLog("Buffer is full, we can't add CRC to your data");
-                                       break;
-                               } else {
-                                       datalen++;
-                               }
-                       }
-                       continue;
-               }
-               PrintAndLog("Invalid char on input");
+       // extract parameters
+       CLIParserInit("hf 14a raw", "Send raw hex data to tag", 
+               "Sample:\n"\
+               "\thf 14a raw -pa -b7 -t1000 52  -- execute WUPA\n"\
+               "\thf 14a raw -p 9320            -- anticollision\n"\
+               "\thf 14a raw -psc 60 00         -- select and mifare AUTH\n");
+       void* argtable[] = {
+               arg_param_begin,
+               arg_lit0("rR",  "nreply",  "do not read response"),
+               arg_lit0("cC",  "crc",     "calculate and append CRC"),
+               arg_lit0("pP",  "power",   "leave the signal field ON after receive"),
+               arg_lit0("aA",  "active",  "active signal field ON without select"),
+               arg_lit0("sS",  "actives", "active signal field ON with select"),
+               arg_int0("bB",  "bits",    NULL, "number of bits to send. Useful for send partial byte"),
+               arg_int0("t",   "timeout", NULL, "timeout in ms"),
+               arg_lit0("T",   "topaz",   "use Topaz protocol to send command"),
+               arg_lit0("3",   NULL,      "ISO14443-3 select only (skip RATS)"),
+               arg_str1(NULL,  NULL,      "<data (hex)>", NULL),
+               arg_param_end
+       };
+       // defaults
+       arg_get_int(6) = 0;
+       arg_get_int(7) = 0;
+       
+       if (CLIParserParseString(cmd, argtable, arg_getsize(argtable), false)){
+               CLIParserFree();
                return 0;
        }
-
+       
+       reply = !arg_get_lit(1);
+       crc = arg_get_lit(2);
+       power = arg_get_lit(3);
+       active = arg_get_lit(4);
+       active_select = arg_get_lit(5);
+       numbits = arg_get_int(6) & 0xFFFF;
+       timeout = arg_get_int(7);
+       bTimeout = (timeout > 0);       
+       topazmode = arg_get_lit(8);
+       no_rats = arg_get_lit(9);
+       // len = data + CRC(2b)
+       if (CLIParamHexToBuf(arg_get_str(10), data, sizeof(data) -2, &datalen)) {
+               CLIParserFree();
+               return 1;
+       }
+       
+       CLIParserFree();        
+       
+       // logic 
        if(crc && datalen>0 && datalen<sizeof(data)-2)
        {
                uint8_t first, second;
index 691e1978b0b1dacfaac9797a31bb3c74c0025b72..8fbd45782f341f4e7ba064e2fe7c57102fe9ce81 100644 (file)
@@ -28,7 +28,7 @@ static command_t CommandTable[] =
   {"reader",      CmdLegicRFRead, 0, "[offset [length]] -- read bytes from a LEGIC card"},
   {"save",        CmdLegicSave,   0, "<filename> [<length>] -- Store samples"},
   {"load",        CmdLegicLoad,   0, "<filename> -- Restore samples"},
-  {"sim",         CmdLegicRfSim,  0, "[phase drift [frame drift [req/resp drift]]] Start tag simulator (use after load or read)"},
+  {"sim",         CmdLegicRfSim,  0, "[tagtype, 0:MIM22, 1:MIM256, 2:MIM1024] Start tag simulator (use after load or read)"},
   {"write",       CmdLegicRfWrite,0, "<offset> <length> -- Write sample buffer (user after load or read)"},
   {"fill",        CmdLegicRfFill, 0, "<offset> <length> <value> -- Fill/Write tag with constant value"},
   {NULL, NULL, 0, NULL}
@@ -320,10 +320,8 @@ int CmdLegicSave(const char *Cmd)
 int CmdLegicRfSim(const char *Cmd)
 {
    UsbCommand c={CMD_SIMULATE_TAG_LEGIC_RF};
-   c.arg[0] = 6;
-   c.arg[1] = 3;
-   c.arg[2] = 0;
-   sscanf(Cmd, " %" SCNi64 " %" SCNi64 " %" SCNi64, &c.arg[0], &c.arg[1], &c.arg[2]);
+   c.arg[0] = 1;
+   sscanf(Cmd, " %" SCNi64, &c.arg[0]);
    SendCommand(&c);
    return 0;
 }
diff --git a/client/obj/cliparser/.dummy b/client/obj/cliparser/.dummy
new file mode 100644 (file)
index 0000000..e69de29
index 939ba93a54ce00e9425a1156d3900f1af58c4c8e..179e87eed22bc326f37e33f6925116916701c6bf 100644 (file)
Binary files a/fpga/fpga_hf.bit and b/fpga/fpga_hf.bit differ
index 0768c29de0dcd0204d0692acc9b23486a98d26a2..78650c4a9492c2f52f5db450219e97b3bd58eacc 100644 (file)
@@ -51,38 +51,29 @@ begin
 end
 
 
-// Divide 13.56 MHz by 32 to produce the SSP_CLK
-// The register is bigger to allow higher division factors of up to /128
+// Divide 13.56 MHz to produce various frequencies for SSP_CLK
+// and modulation. 11 bits allow for factors of up to /128.
 reg [10:0] ssp_clk_divider;
 
 always @(posedge adc_clk)
     ssp_clk_divider <= (ssp_clk_divider + 1);
 
 reg ssp_clk;
-reg ssp_frame;
+
 always @(negedge adc_clk)
 begin
-    //If we're in 101, we only need a new bit every 8th carrier bit (53Hz). Otherwise, get next bit at 424Khz
     if(mod_type == 3'b101)
-    begin
-       if(ssp_clk_divider[7:0] == 8'b00000000)
-           ssp_clk <= 1'b0;
-       if(ssp_clk_divider[7:0] == 8'b10000000)
-           ssp_clk <= 1'b1;
-
-    end
+      // Get bit every at 53KHz (every 8th carrier bit of 424kHz)
+      ssp_clk <= ssp_clk_divider[7];
+    else if(mod_type == 3'b010)
+      // Get next bit at 212kHz
+      ssp_clk <= ssp_clk_divider[5];
     else
-    begin
-       if(ssp_clk_divider[4:0] == 5'd0)//[4:0] == 5'b00000)
-           ssp_clk <= 1'b1;
-       if(ssp_clk_divider[4:0] == 5'd16) //[4:0] == 5'b10000)
-           ssp_clk <= 1'b0;
-    end
+      // Get next bit at 424Khz
+      ssp_clk <= ssp_clk_divider[4];
 end
 
 
-//assign ssp_clk = ssp_clk_divider[4];
-
 // Divide SSP_CLK by 8 to produce the byte framing signal; the phase of
 // this is arbitrary, because it's just a bitstream.
 // One nasty issue, though: I can't make it work with both rx and tx at
@@ -96,19 +87,19 @@ always @(negedge ssp_clk)
     ssp_frame_divider_from_arm <= (ssp_frame_divider_from_arm + 1);
 
 
-
+reg ssp_frame;
 always @(ssp_frame_divider_to_arm or ssp_frame_divider_from_arm or mod_type)
     if(mod_type == 3'b000) // not modulating, so listening, to ARM
         ssp_frame = (ssp_frame_divider_to_arm == 3'b000);
     else
-       ssp_frame = (ssp_frame_divider_from_arm == 3'b000);
+        ssp_frame = (ssp_frame_divider_from_arm == 3'b000);
 
 // Synchronize up the after-hysteresis signal, to produce DIN.
 reg ssp_din;
 always @(posedge ssp_clk)
     ssp_din = after_hysteresis;
 
-// Modulating carrier frequency is fc/16, reuse ssp_clk divider for that
+// Modulating carrier frequency is fc/64 (212kHz) to fc/16 (848kHz). Reuse ssp_clk divider for that.
 reg modulating_carrier;
 always @(mod_type or ssp_clk or ssp_dout)
     if(mod_type == 3'b000)
@@ -116,9 +107,9 @@ always @(mod_type or ssp_clk or ssp_dout)
     else if(mod_type == 3'b001)
         modulating_carrier <= ssp_dout ^ ssp_clk_divider[3]; // XOR means BPSK
     else if(mod_type == 3'b010)
-       modulating_carrier <= ssp_dout & ssp_clk_divider[5]; // switch 212kHz subcarrier on/off
+        modulating_carrier <= ssp_dout & ssp_clk_divider[5]; // switch 212kHz subcarrier on/off
     else if(mod_type == 3'b100 || mod_type == 3'b101)
-       modulating_carrier <= ssp_dout & ssp_clk_divider[4]; // switch 424kHz modulation on/off
+        modulating_carrier <= ssp_dout & ssp_clk_divider[4]; // switch 424kHz modulation on/off
     else
         modulating_carrier <= 1'b0;                           // yet unused
 
@@ -133,9 +124,6 @@ assign pwr_oe4 = modulating_carrier;
 // This one is always on, so that we can watch the carrier.
 assign pwr_oe3 = 1'b0;
 
-assign dbg = modulating_carrier;
-//reg dbg;
-//always @(ssp_dout)
-//    dbg <= ssp_dout;
+assign dbg = ssp_din;
 
 endmodule
Impressum, Datenschutz