/usr/local/share/cint/cint/include

export CINTSYSDIR=/usr/local/share/cint

mapping eth0
   script guessnet-ifupdown
   map default: default
   map timeout: 10
   map verbose: true
   map autofilter: true
iface eth0-home inet static
   test peer address router-IP mac router-MAC source own-IP
   static network settings
   ...
iface default inet dhcp

#include <pthread.h>
#include <iostream>

/* Declaration of the function which will serve as an argument function for all the threads.*/
void* functionA (void*);

/* Declaration of the global variable which will get incremented by each of the threads in the common function `functionA`.*/
int counter = 0;

/* Declaration and initialization of the mutex variable which will protect the shared global variable `counter`.*/
pthread_mutex_t mutexA = PTHREAD_MUTEX_INITIALIZER;

int main ()
{
	/* Declaring an array for 10 threads.*/
	pthread_t thread_id [10];

	/* Creating 10 threads with default attributes and the common function namely `functionA` for execution.*/
	for (int i = 0; i < 10; i++)
	{
		pthread_create (&thread_id [i], NULL, functionA, NULL);
	}

	std :: cout << "Final counter value: " << counter << "\n";
	return 0;
}

void* functionA (void* arg)
{
	/* `pthread_self ()` prints the thread ID of the currently calling thread.*/
	std :: cout << "Thread number: " << pthread_self () << "\n";
		
	pthread_mutex_lock (&mutexA);
	/* Each time this function gets called, the counter is incremented by the calling thread.*/
	counter++;
	pthread_mutex_unlock (&mutexA);

	return 0;
} 

anisha@linux-y3pi:~/> g++ joinA.cpp -lpthread -Wall
anisha@linux-y3pi:~/> ./a.out 

Final counter value: 0

anisha@linux-y3pi:~/>

int pthread_join (pthread_t threadID,
	  	        void*     *retval);

#include <pthread.h>
#include <iostream>

/* Declaration of the function which will serve as an argument function for all the threads.*/
void* functionA (void*);

/* Declaration of the global variable which will get incremented by each of the threads in the common function `functionA`.*/
int counter = 0;

/* Declaration and initialization of the mutex variable which will protect the shared global variable `counter`.*/
pthread_mutex_t mutexA = PTHREAD_MUTEX_INITIALIZER;

int main ()
{
	/* Declaring an array for 10 threads.*/
	pthread_t thread_id [10];

	/* Creating 10 threads with default attributes and the common function namely `functionA` for execution.*/
	for (int i = 0; i < 10; i++)
	{
		pthread_create (&thread_id [i], NULL, functionA, NULL);
	}

	/* Telling the main thread to wait for the task completion of all its spawned threads.*/
	for (int j = 0; j < 10; j++)
	 {
		pthread_join (thread_id [j], NULL);
	 }

	std :: cout << "\n\nFinal counter value: " << counter << "\n";
	return 0;
}

void* functionA (void* arg)
{
	/* `pthread_self ()` prints the thread ID of the currently calling thread.*/
	std :: cout << "Thread number: " << pthread_self () << "\n";
		
	pthread_mutex_lock (&mutexA);
	/* Each time this function gets called, the counter is incremented by the calling thread.*/
	counter++;
	pthread_mutex_unlock (&mutexA);

	return 0;
}

anisha@linux-y3pi:~/> g++ joinB.cpp -lpthread -Wall
anisha@linux-y3pi:~/> ./a.out 
Thread number: 140546115806992
Thread number: 140546107414288
Thread number: 140546099021584
Thread number: 140546090628880
Thread number: 140546082236176
Thread number: 140546073843472
Thread number: 140546065450768
Thread number: 140546124199696
Thread number: 140546132592400
Thread number: 140546140985104
	
Final counter value: 10
	
anisha@linux-y3pi:~/>

qemu-kvm -hda debian.img -m 512 -redir tcp:5555:22

sshfs me@localhost:/home/me /remote/cmhoward/guests/vdebian-i386 -p 5555

oCell.setPropertyValue( "RotateAngle", 9000 )

oCell.setPropertyValue( "RotateAngle", 90 )

#!/bin/bash
#
# weather.bash
#
# 2012 - Snark1994 (J. Hunt) - snark1994@gmail.com
#
# Free to use, distribute and alter, with the exception of the API key - you
# need to register your own one with worldweatheronline.com
#
key=ABCDEFGHIJLMNOP #obtain your own API key from worldweatheronline.com
postcode="$@"
postcode=$(echo $postcode | sed 's/ /+/g')
url="http://free.worldweatheronline.com/feed/weather.ashx?q=CF38+1GD&format=csv&num_of_days=5&key=$key"

if [ $(/usr/bin/stat -c %Y "/tmp/weather") -lt $(( $(date +%s) - 3600 )) ]; then
    echo "/tmp/weather out of date!"
    echo "Fetching $url"
    wget -q -O "/tmp/weather" $url
fi

awk 'BEGIN { FS=","; ORS=""; print "5-day forecast:\n"; "date +%u" | getline day; days[1]="Mon  "; days[2]="Tue  "; days[3]="Wed  "; days[4]=    "Thur "; days[5]="Fri  "; days[6]="Sat  "; days[7]="Sun  "; days[day]="Today" }
     NR >= 10 { gsub(/\r/, ""); print days[(day+NR-11)%7+1] "\tTemp (°C): " $4 "=>" $2 " \tWind (kmph) " $7 "  \tRain (mm) " $13 "\t\t" $12 "    \n" }' /tmp/weather

exit 0

EXT_OBJ = \
  new-target \
  ... 
  ########### end of list

LDFLAGS =  "" # must be cleared explicitly for ar
LIB =      "" # must be cleared explicitly for ar

LDFLAGS =     # must be cleared explicitly for ar
LIB =         # must be cleared explicitly for ar

mc2 -fetch static-32
<edit> mc2.def # and make changes shown above
mc2 -save static-32 # and press [y]es

// signal-handler.h

#ifndef signal_handler_h
#define signal_handler_h

// signal-handler.h

///////////////////////////////////////////////////////////
// catch segfaults and continue
#include <signal.h>  // segfault handling
#include <setjmp.h>  // reset eflags 0x100 (trap) flag
#include <sys/ucontext.h> // register names

#define BITS 32
// #define BITS 64

#ifdef __cplusplus
// intercept throw-catch errors too.
#include <exception>
extern std::terminate_handler old_term_handler;

// used only once in main()
#define BEGIN_MAIN_HANDLER() \
    pvt_init_sighandler(pvt_exception_mediator); \
    std::set_terminate(pvt_handler_throw)

// done once at the end of main() before returning.
#define END_MAIN_HANDLER() \
  std::set_terminate(old_term_handler)
#else

#define BEGIN_MAIN_HANDLER() \
    pvt_init_sighandler(pvt_exception_mediator)

#define END_MAIN_HANDLER()

#endif // __cplusplus

// begins a handled block and may include a {handler function} 
// that may reset the throw_code variable if the problem is handled.
#define PUSH_HANDLER() \
  { \
    throw_code = handler_code = 0; \
    handler_link_ptr  cont_next; \
    pvt_push_handler(&cont_next); \
    if(!setjmp(handler_link->jb) && ! handler_code) \
    {

// followed by { what to try } which may include try-catch 
// expressions. if cont is false, will pop_handler prior to 
// a 'return' or (more typically) a 'throw(int code) function
// to balance push/pops.
#define HANDLE(cont) }else{ if(!cont) pvt_pop_handler();

// ends a handler block
#define POP_HANDLER() \
    } \
  } \
  pvt_pop_handler()

typedef struct
{
  void* prev;
  jmp_buf jb;
}handler_link_ptr;

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

// Used in C++ for the signal number to translate trapped signals to 
// throw and catch.  Signal number 11 is segfault.  These can often be 
// non-fatal errors though the linux os prefers to unload the binary and 
// return to the shell when these happen.
extern int throw_code;

// used in to simulate throw-catch through handlers in C using HANDLER_THROW(code)
// See HANDLER_THROW() below.
extern int handler_code;

// Used mainly in C, similar to try-catch throw function.  This will call
// the HANDLER currently pushed, so some care is required to avoid recursion 
// or other problems.  It's generally best to throw to the caller after 
// setting a flag in the HANDLER section.
void HANDLER_THROW(int code);

// global handler linked list (points to current)
extern handler_link_ptr *handler_link;

// used internally by PUSH/POP macros
void pvt_push_handler(handler_link_ptr* o);
void pvt_pop_handler();

// used to call c/c++ exception handlers from trapped signals
void pvt_exception_mediator(int);

// used in BEGIN_MAIN_HANDLER() to trap all signals in the 
// range 1-15 for handling and/or conversion to throw-catch
void pvt_init_sighandler(void (*fn)(int));

// used internally to call handler(s) with current throw_code
void pvt_handler_throw();

#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus

#endif // signal_handler_h

// signal-handler.c

#include <signal-handler.h>
#include <stdio.h> // fprintf()
#include <stdlib.h> // exit()

// used to untrap and begin throw-catch
int throw_code;

#ifdef __cplusplus
std::terminate_handler old_term_handler;
extern "C" {
#endif // __cplusplus
  
int handler_code;

// used mainly in C, similar to try-catch throw function
void HANDLER_THROW(int code)
{
  if(!code) 
  {
    fprintf(stderr, "Can't HANDLER_THROW( zero ), aborting...\n");
    exit(1);
  }
  handler_code = code;
  pvt_handler_throw();
}

  
static handler_link_ptr _handler_link;
handler_link_ptr *handler_link = &_handler_link;

void pvt_push_handler(handler_link_ptr* o) 
{
  handler_link_ptr* save = handler_link;
  handler_link = o;
  handler_link->prev = save;
}

void pvt_pop_handler() 
{ 
  handler_link = (handler_link_ptr*)handler_link->prev; 
}


void pvt_handler_throw()
{
  longjmp(handler_link->jb, throw_code);
}

void handle(int err)
{
  throw_code = err;
  pvt_handler_throw();
}


#if BITS == 32

  // returns ebp from cpu
  static void** get_ebp()
  {
    asm(
        "mov %ebp, %esp;\n"
        "popl %ebp;\n"
        "mov %ebp, %eax;\n"
        "ret;\n"
       );
    return 0; // not used
  }
#else 
#if BITS == 64
  // returns rdx from cpu
  static void** get_rdx()
  {
    asm(
        "mov %rbp, %rsp;\n"
        "popl %rbp;\n"
        "mov %rdx, %rax;\n"
        "ret;\n"
       );
    return 0; // not used
  }
#else
#warning BITS must be defined (either 32 or 64)
#endif // 64
#endif // 32
  
  static struct sigaction new_action;
  
  void pvt_init_sighandler(void (*fn)(int))
  { 
    new_action.sa_handler = fn;
    sigemptyset (&new_action.sa_mask);
    new_action.sa_flags = SA_SIGINFO;
/// *****************************************
/// THIS COULD POTENTIALLY HANG YOUR CPU
// If all you want to trap is segfaults,
// replace this with 
// sigaction(11, &new_action, 0);
// and repeat for other signals you want to 
// catch.  This may not be a problem in C++
// but it is in C, so be aware of this potential
// problem.

    for(int i = 0; i < 16; i++)
      sigaction( i, &new_action, 0);
  }

  // a pointer we can get at in asm
  void** psig_context; 

  typedef struct
  {
    const char c;
  }ERRSTRING;
    

  void pvt_exception_mediator(int signum)
  {
    throw_code = signum;
    
#if BITS == 32
// see /usr/include/sys/ucontext.h
    
#define CTX_TRAPNO 12
#define CTX_EIP 14
    void** p = get_ebp();
    p += 2; // &signum
    p = (void**)p[2];                     // pointers
    p += 5;                               // psig_context
    psig_context = (void**)p;
  
  // get context
    void*** context = (void***)psig_context;

    // turn off trap flag
    context[CTX_TRAPNO] = (void**)0;
    // set new eip as though it were a call
    context[CTX_EIP] = (void**)&pvt_handler_throw;

#else
#if BITS == 64
// see /usr/include/sys/ucontext.h
#define CTX_TRAPNO 20
#define CTX_RIP 16

    void**p;
    
    p = (void**)get_rdx();
    p+=5;
    psig_context = p;
    void***context = (void***)psig_context;
    context[REG_RIP] = (void**)&handler_throw;

#else
#warning BITS must be defined (either 32 or 64)
#endif // 64
#endif // 32
  }

#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus

COMPILE = g++ -m32 -c -o # COMPILE <output_file> ...
CFLAGS = -Wall -g3 --save-temps
# or CFLAGS = -Wall -O2 # optimized
INCLUDE = -I $(SRCDIR) -I$(PREFIX)/include 

LINK = g++ -m32 -o # LINK <output_file> ...
LDFLAGS = # $(GCCDIR)/libgcc_eh.a
LIB = -L/usr/lib -L/opt/gcc-dbg/lib

COMPILE = gcc -m32 -c -o # COMPILE <output_file> ...
CFLAGS = -Wall -g3 -std=gnu99 # --save-temps
# or CFLAGS = -Wall -O2 -std=gnu99 # optimized
INCLUDE = -I $(SRCDIR)

LINK = gcc -m32 -o # LINK <output_file> ...
LDFLAGS = # $(GCCDIR)/libgcc_eh.a
LIB = -L/usr/lib # -L$(PREFIX)/lib -L/opt/gcc-dbg/lib/

// generic C++ source template created by new.main

#include <stdio.h>  // printf(), FILE*, etc.
#include <malloc.h> // malloc(), free()
#include <string.h> // strcpy(), memcpy(), etc.
#include <stdlib.h> // exit()

#include "signal-handler.h"

void dbg(){}

// seg fault corrected
void test_handled()
{
  printf("Test 1 (handled segfault):\n");
  try
  {
    PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
    {
      char* s = 0;
      s += 9;
      int c = *s;
      c = c; // use it
    }
    HANDLE(true);       // handle signals and flag = continue normally
    POP_HANDLER();      // end HANDLER block to continue execution
    
    if(throw_code == 11)
    {
      // do segfault cleanup if any
      printf("%s: handling segfault\n", __func__);
    }
    else // abort
    {
      printf("%s: can't handle signal (%d)\n", __func__, throw_code);
      exit(throw_code);
    }
  }
  catch(int err)
  {
    if(err)
      throw(err);
  }
}

// seg fault uncorrected (fatal)
void test_unhandled()
{
  printf("Test 2 (unhandled segfault):\n");
  try
  {
    PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
    {
      char* s = 0;
      int c = *s;
      c = c; // use it
    }
    HANDLE(false)        // handle signals and flag = not continuing
    {
      printf("%s: not handling segfault\n", __func__);
      printf("%s: throwing code (1)\n", __func__);
      throw(1);
    }
    POP_HANDLER();      // end HANDLER block to continue execution
  }
  catch(int err)
  {
    if(err)
      throw(err);
  }
}

void tester()
{
  printf("%s: testing translating handled and unhandled signals to throw-catch\n", __func__);
  int caught = 0;
  try
  {
    PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
    {
      test_handled();
    }
    HANDLE(false)        // handle signals and flag = not continuing
    {
      printf("test_handled screwed up, supposed handle errors\n");
      printf("%s: HANDLE throwing code (4)\n", __func__);
      throw(4);
    }
    POP_HANDLER();      // end HANDLER block to continue execution
  }
  catch(int err)
  {
    caught = err;
  }
  // caught...
  try
  {
    PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
    {
      test_unhandled();
    }
    
    // this time we want to know if the signal was handled or not
    HANDLE(false)        // handle signals and flag = not continuing
    {
      printf("%s: can't handle throw_code = %d\n", __func__, throw_code);
      printf("%s: HANDLE throwing code (2)\n", __func__);
      throw(2);
    }
    POP_HANDLER();      // end HANDLER block to continue execution
  }
  catch(int err)
  {
    caught += 2;
  }
  if(caught)
  {
    printf("%s: caught cumulative error code(s) (%d)\n", __func__, caught);
    printf("%s: rethrowing throw_code (%d) from handler funcs\n", __func__, throw_code);
    if(caught)
      throw(throw_code);
  }
}

int main(int argc, char** argv)
{
  dbg();
  // done only once in main();
  BEGIN_MAIN_HANDLER(); // init system
  try
  {
    PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
    {
      tester();
    }
    HANDLE(false)        // handle signals and flag = not continuing
    {
      throw(1);
    }    
    POP_HANDLER();      // end HANDLER block to continue execution
  }
  catch(int err)
  {
    if(err)
    {
      printf("main: caught code (%d)\n", err);
    }
  }
  // done only once in main();
  END_MAIN_HANDLER(); // reset terminate function for throw-catch
    
  printf("Exiting main() normally after testing\n");
  return 0;
}

// main.c sig-handler test

/* 
  In the C version to avoid adding an additional PUSH_HANDLER/POP_HANDLER
  pair around the individual tests, we don't HANDLER_THROW() anything until 
  we leave the block, reading the handler_code to determine whether to throw 
  or not.
  
  As a result the HANDLE() functions set the continuing flag to true and 
  'catch' is simulated by reading the handler_code flag.  
  
*/

#include <stdio.h>  // printf(), FILE*, etc.
#include <malloc.h> // malloc(), free()
#include <string.h> // strcpy(), memcpy(), etc.

#include "signal-handler.h"

// these macros help show what the param in HANDLE(param)
// is doing.  It's only a flag for whether to unnest the 
// handlers or not within a HANDLE block.  True = continue
// i.e., NOT to unnest the HANDLER
#ifndef true
#define true 1
#endif
#ifndef false
#define false 0
#endif


void dbg(){}

void noop() {}

// seg fault corrected
void test_handled()
{
  printf("Test 1 (handled segfault):\n");
    PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
    {
      char* s = 0;
      s += 9;
      int c = *s;
      c = c; // use it
    }
    HANDLE(true);       // handle signals and flag = continue normally
    POP_HANDLER();      // end HANDLER block to continue execution
    
    if(throw_code == 11)
    {
      // do segfault cleanup if any
      printf("%s: handling segfault\n", __func__);
    }
    else // abort
    {
      printf("%s: can't handle signal (%d)\n", __func__, throw_code);
      exit(throw_code);
    }
    if(handler_code)
      HANDLER_THROW(handler_code);
    else
      noop();
}

// seg fault uncorrected (fatal)
void test_unhandled()
{
  printf("Test 2 (unhandled segfault):\n");
    PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
    {
      char* s = 0;
      int c = *s;
      c = c; // use it
    }
    HANDLE(true)        // handle signals and flag = continuing
    {
      printf("%s: not handling segfault\n", __func__);
      printf("%s: throwing code (1)\n", __func__);
      handler_code = 1;
    }
    POP_HANDLER();      // end HANDLER block to continue execution
    if(handler_code)
      HANDLER_THROW(handler_code);
}

void tester()
{
  printf("%s: testing translating handled and unhandled signals to throw-catch\n", __func__);
  int caught = 0;
  PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
  {
    test_handled();
  }
  HANDLE(true)        // handle signals and flag = continuing
  {
    printf("test_handled screwed up, supposed handle errors\n");
    printf("%s: HANDLE throwing code (4)\n", __func__);
    handler_code = 4;
  }
  POP_HANDLER();      // end HANDLER block to continue execution
  if(handler_code)
    caught = handler_code;
    
  PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
  {
    test_unhandled();
  }
    
    // this time we want to know if the signal was handled or not
  HANDLE(true)        // handle signals and flag = continuing
  {
    printf("%s: can't handle throw_code = %d\n", __func__, throw_code);
    printf("%s: HANDLE throwing code (2)\n", __func__);
    handler_code = 2;
  }
  POP_HANDLER();      // end HANDLER block to continue execution
  
  if(handler_code)
    caught += handler_code;
  
  if(caught)
  {
    printf("%s: caught cumulative error code(s) (%d)\n", __func__, caught);
    printf("%s: rethrowing throw_code (%d) from handler funcs\n", __func__, throw_code);
    HANDLER_THROW(throw_code);
  }
}

int main(int argc, char** argv)
{
  dbg();
  // done only once in main();
  BEGIN_MAIN_HANDLER(); // init system
  PUSH_HANDLER()      // set up HANDLE(flg) as the signal hander
  {
    tester();
  }
  HANDLE(true)        // handle signals and flag = continuing
    handler_code = 1;
  POP_HANDLER();      // end HANDLER block to continue execution
  
  // done only once in main();
  END_MAIN_HANDLER(); // reset terminate function for throw-catch
    
  printf("Exiting main() normally after testing\n");
  return 0;
}

./configure \
  --prefix=$DBGPREFIX \
  <other config stuff> \
  ##########

// main.cpp for segv catch test

#include <stdio.h>  // printf() 
#include <signal.h> // signal()

#define BITS 32

void dbg(){}


extern "C"
{

#if BITS == 32
void** get_ebp()
{
  asm(
      "mov %ebp, %esp;\n"
      "popl %ebp;\n"
      "mov %ebp, %eax;\n"
      "ret;\n"
     );
  return 0; // not used
}
#else 
#if BITS == 64
void** get_edx()
{
  asm(
      "mov %rbp, %rsp;\n"
      "popl %rbp;\n"
      "mov %rdx, %rax;\n"
      "ret;\n"
     );
  return 0; // not used
}
#else
#warning BITS must be defined (either 32 or 64)
#endif // 64
#endif // 32

static void exception_mediator(int signum);

int mem_test_var;

static struct sigaction new_action;

static void init_sighandler(void (*fn)(int))
{
  new_action.sa_handler = fn;
  sigemptyset (&new_action.sa_mask);
  new_action.sa_flags = SA_SIGINFO;
  sigaction(11, &new_action, 0); // sigsegv only
}

void** psig_context; // a pointer we can get at in asm
int test_flag;

void throw_test()
{
  test_flag++;
  throw("Segment violation\nContinuing...\n\n");
}
    

static void exception_mediator(int signum)
{
  
#if BITS == 32
#define CTX_EIP 14
  void** p = get_ebp();
  p += 2; // &signum
  p = (void**)p[2];                     // pointers
  p += 5;                               // psig_context
  psig_context = (void**)p;
  
  // get context
  void*** context = (void***)psig_context;
  
  // set new eip as though it were a call
  context[CTX_EIP] = (void**)&throw_test;
// } not close brace here -rs

#else
#if BITS == 64
#define CTX_RIP 16

    void**p;
    
    p = (void**)get_rdx();
    p+=5;
    psig_context = p;
    void***context = (void***)psig_context;
    context[CTX_RIP] = (void**)&throw_test;
    
#else
#warning BITS must be defined (either 32 or 64)
#endif // 64
#endif // 32
} // add close brace here -rs

} // extern "C"

int main(int argc, char** argv)
{
  dbg();  
  init_sighandler(exception_mediator);
  printf("Press ENTER 4 times to test and exit normally\n");  
  for(int i = 0; i < 4; i++)
  {
    getchar();
    try
    {
      char* s = 0;
      printf("%s\n", s);
    }
    catch(const char* s)
    {
      if(test_flag)
        printf("%s", s);
      test_flag = 0;
    }
  }
  printf("\nExiting normally\n");  
  return 0;
}

list all classes:
  find all headers in /usr/include/Qt that contain "Q_<*>_EXPORT" and 
  extract the class name.
  display the list.

void classes_x_listAll(int argc, char** argv)
{
  // implementation details
}

 : argc | function_address [ | param1 | param2 ... ] ;

void quit(int argc, char** argv)
{
  // implementation details
}

////////////////////////////////////////////////////////////////////////
// This is a list of name/value pairs for loading constant error tokens
////////////////////////////////////////////////////////////////////////
// User defines LOAD_NV to either set the first or the second parameter
// in the enum or the string array.

LOAD_NV(ERROR_VERSION, "NO VERSION, JUST FOR TEST"),
LOAD_NV(ERROR_ARGC, "Wrong number of args"),
LOAD_NV(ERROR_ENDLIST, 0)

);
  if(helpstr)
    fprintf(stderr, "%s\n", helpstr);
  exit(code);
}

void parse_classnames(char*** pclassnames, char**filelist);

// subroutines are private and may have non-std parameter lists and 
// return values.  The pvt_ prefix isn't necessary, but don't use 
// _x_ anywhere in the name.  We may need that to generate jump addresses
// and name linkage later.

void pvt_listAll(char*** plist)
{
  slist_pipeRead(plist, "ls /usr/include/Qt/*.h 2>/dev/null");
}

void pvt_parse_classnames(char*** pclassnames, char** filelist);
    
void classes_x_listAll(int argc, char** argv)
{
  // implementation details
  if(argc != 1)
    syntax_error(argv, ERROR_ARGC, "Needs 0 args");
  // get list of headers in /usr/include/Qt and create list of 
  // find class strings
  char** filelist = slist_new();
  char** classnames = slist_new();
  pvt_listAll(&filelist);
  // for(char** ps = filelist; *ps; ps++) printf("%s\n", *ps);
  if(slist_count(filelist)) 
  {
    pvt_parse_classnames(&classnames, filelist);
    for(int i = 0; i < slist_count(classnames); i++)
      printf("%s\n", classnames[i]);
  }
  slist_delete(&filelist);
  slist_delete(&classnames);
}

static void pvt_parse_one_classname(char*** pclassnames, const char* filename)
{
  FILE* fp = fopen(filename, "r");
  char ibuf[256];
  char obuf[256];
  // simple parse for text 
  // class Q_GUI_EXPORT %{ClassName}% ... 

  const char* ip;
  char* op;
  if(!fp) return;
  while(!feof(fp))
  {
    *ibuf = 0;
    fgets(ibuf, 256, fp);
    if(*ibuf)
    {
      // simple parse job, let's do it inline
      do
      {
        ip = ibuf;
        op = obuf;
        
        // skip [whitespaces]
        while(*ip == ' ') ip++;
        
        // skip "class"
        if(strncmp(ip, "class", 5)) break;
        ip += 5;
        
        // skip [whitespaces]
        while(*ip == ' ') ip++;
        
        // skip "Q_"<*>_EXPORT"
        {
          bool state = false;
          do
          {
            if(strncmp(ip, "Q_", 2)) break;
            ip += 2;
            for(; *ip > ' '; ip++)
            {
              if(strncmp(ip, "_EXPORT", 7) == 0) 
              {
                ip += 7;
                state = true; 
                break;
              }
            }
          }while(0);
          if(!state)
            break;
        } // end "Q_"<*>_EXPORT"

        // skip [whitespaces]
        while(*ip == ' ') ip++;
        
        // copy classname
        while((*ip > ' ') && (*ip != ':'))
          *op++ = *ip++;
      }while(0);
      *op = 0;
      if(*obuf)
        slist_append(pclassnames, obuf);
    }
  }
  fclose(fp);
}

void pvt_parse_classnames(char*** pclassnames, char** filelist)
{
  int nfiles = slist_count(filelist);
  const char* filename;
  for(int i = 0; i < nfiles; i++)
  {
    filename = filelist[i];
    pvt_parse_one_classname(pclassnames, filename);
  }
}

#if TESTING_LISTALL
int main(int argc, char** argv)
{
  dbg();  
  classes_x_listAll(argc, argv);
  return 0;
}
#endif // TESTING_LISTALL

PREFIX = $(HOME)/usr32
INCLUDE = -I $(SRCDIR) -I$(PREFIX)/include -I /usr/include 
LINK = g++ -m32 -o # LINK <output_file> ...
LDFLAGS = -lLQ
LIB = -L/usr/lib -L$(PREFIX)/lib

Q3Accel
Q3Action
Q3ActionGroup
  <snipping 905 class names>
QXmlSchema
QXmlSchemaValidator
QXmlSerializer

mc2 -fetch qt4                         # makefile template for qt4
mc2 -create qt4-files src/click_id.ui  # generate initial fileset

# edit click_id.ui and change class from QWidget to QDialog
mc2 -run qt4-ui src                    # get ui: target and paste into mc2.def
mc2 -init                              # generate a self-updating makefile

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>click_id</class>
 <widget class="QDialog" name="click_id">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>400</width>
    <height>300</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Form</string>
  </property>
  <widget class="QPushButton" name="btnGetName">
   <property name="geometry">
    <rect>
     <x>280</x>
     <y>10</y>
     <width>102</width>
     <height>27</height>
    </rect>
   </property>
   <property name="text">
    <string>Get &amp;Name</string>
   </property>
  </widget>
  <widget class="QPushButton" name="btnQuit_1">
   <property name="geometry">
    <rect>
     <x>30</x>
     <y>220</y>
     <width>102</width>
     <height>27</height>
    </rect>
   </property>
   <property name="text">
    <string>Quit &amp;1</string>
   </property>
  </widget>
  <widget class="QPushButton" name="btnQuit_2">
   <property name="geometry">
    <rect>
     <x>150</x>
     <y>220</y>
     <width>102</width>
     <height>27</height>
    </rect>
   </property>
   <property name="text">
    <string>Quit &amp;2</string>
   </property>
  </widget>
  <widget class="QPushButton" name="btnQuit_3">
   <property name="geometry">
    <rect>
     <x>270</x>
     <y>220</y>
     <width>102</width>
     <height>27</height>
    </rect>
   </property>
   <property name="text">
    <string>Quit &amp;3</string>
   </property>
  </widget>
 </widget>
 <resources/>
 <connections>
  <connection>
   <sender>btnQuit_1</sender>
   <signal>clicked()</signal>
   <receiver>click_id</receiver>
   <slot>close()</slot>
  </connection>
  <connection>
   <sender>btnQuit_2</sender>
   <signal>clicked()</signal>
   <receiver>click_id</receiver>
   <slot>close()</slot>
  </connection>
  <connection>
   <sender>btnQuit_3</sender>
   <signal>clicked()</signal>
   <receiver>click_id</receiver>
   <slot>close()</slot>
  </connection>
  <connection>
   <sender>btnGetName</sender>
   <signal>clicked()</signal>
   <receiver>click_id</receiver>
   <slot>onGetID()</slot>
  </connection>
 </connections>
 <slots>
  <slot>onGetID()</slot>
 </slots>
</ui>

#include <stdio.h>
#include <QtGui/QApplication>
#include "click_id.h"
#include "lqapp.h"

int main(int argc, char *argv[])
{
    LQApp a(argc, argv);
    click_id w;
    w.show();
    LQApp::watch = &w;
    return a.exec();
}

//////////////////////////////////////////////////////////////
// filling out LQApp

extern bool getting_id;

// user defined virtual function
bool LQApp::eventHandler(QObject* receiver, QEvent* event)
{
  if(event->type() == QEvent::MouseButtonPress)
  {
    if(getting_id)
    {
      // 1. find widget under mouse... well, that will be the intended 
      // receiver of the current event if getting_id is true.
      //
      // 2. get property of widget on mouse click and do NOT process 
      // this event.
      
      int indx;
      QVariant anytype;
      indx = receiver->metaObject()->indexOfProperty("objectName");
      if(indx < 0)
        printf("This baby has no 'objectName' property\n");
      else
      {
        const char* s;
        anytype = receiver->property("objectName");
        printf("objectName: %s\n", s = anytype.toByteArray());
      }
      indx = receiver->metaObject()->indexOfProperty("text");
      if(indx < 0)
        printf("This baby has no 'text' property\n");
      else
      {
        const char* s;
        anytype = receiver->property("text");
        printf("text: %s\n", s = anytype.toByteArray());
      }
      printf("\n");
      getting_id = false;
      return true; // consumed
    }
  }
  return QApplication::notify(receiver, event);
}

public slots:
  void onGetID();

bool getting_id;

void click_id::onGetID()
{
  getting_id = true;
}

// lqapp.cpp - preemptive event handling in subclass of QApplication

#include "lqapp.h"


// today the world, tomorrow the stars...
bool LQApp::notify(QObject *receiver, QEvent *event)
{ 
  // printf("receiver: %s0x%lX: eventType: %d\n", 
  //         receiver == watch ? "TARGET -> " : "", 
  //         (long)receiver, e->type());
  return eventHandler(receiver, event); // user defined virtual
}

LQApp::LQApp(int &argc, char **argv)
: QApplication(argc, argv)
{
  // additional setup
}

LQApp::~LQApp()
{
  // delete additional setup as req'd
}

QObject* LQApp::watch; // static, globally accessible

// lqapp.h

#ifndef lqapp_h
#define lqapp_h

#include <QApplication>     // parent class
#include <qevent.h>           // always used

class LQApp : public QApplication
{
public:
  LQApp(int &argc, char **argv);
  ~LQApp();
  bool notify(QObject *receiver, QEvent *e);                // preemptive event handler
  virtual bool eventHandler(QObject *receiver, QEvent *e);  // let's try this approach
  static QObject* watch;                                    // ...
};

#endif // lqapp_h

make ui
make

$> main
objectName: btnQuit_2
text: Quit &2

objectName: click_id
This baby has no 'text' property

objectName: btnGetName
text: Get &Name

// utils.h

#ifndef utils_h
#define utils_h

#include <QObject>

// See explanation in utils.cpp
int lq_hash32(const char* name);

// See explanation in utils.cpp
typedef struct 
{
  int hashid; // computed once
  const char* name;
  uint value;
}HASH_ENTRY;

extern HASH_ENTRY lq_key_name_tbl[];

const char* qkey2name(uint value);
char* qmodkeys2name(uint value);  // returns a temp static string
uint qname2key(const char* name); // key value for name or 0x01ffffff ("Key_unknown")

bool handle_return_key(QObject* p);

#endif // utils_h

#include <QApplication>   // app
#include <QTextEdit>      // editor
#include <QKeyEvent>      // QKeyEvent
#include "utils.h"        // qkey2name(), handle_return_key(QTextEditor*), etc.
#include "lib/utils.cpp"  // for type MULTI mc2 compilation, include, not link
#include <stdio.h>        // printf()

#define OLD_SCHOOL 1 /* change this to 0 to compare old to new */

void dbg(){}

////////////////////////////////////////////////////////
// LQApp class declaration

// type used to set the event handler aka 'notify'
typedef bool (*handler_func_t)(QObject* target, QObject* object, QEvent* ev);


class LQApp : public QApplication
{
  public:
    LQApp(int &argc, char **argv);
    ~LQApp();
    bool notify(QObject *receiver, QEvent *ev);
    void setHandler(QObject* target, handler_func_t handler);
    void getTargetHandler(QObject** pobj, handler_func_t* pfunc);

    // globally accessible funcs and vars
    static bool (*handler)(QObject* target, QObject* object, QEvent* ev);
    static bool defaultHandler(QObject* target, QObject* object, QEvent* ev);
    QObject* target;
    static LQApp* self;
    
};

////////////////////////////////////////////////////////
// LQApp class implementation

// these are globally accessible for now so our handler
// functions can get at them through LQApp::self (aka 
// a static 'this') ->

// a 'this' pointer
LQApp* LQApp::self;

// the currently effective event handler
bool (*LQApp::handler)(QObject* target, QObject* object, QEvent* ev);

// the default handler, usually not called by user
bool LQApp::defaultHandler(QObject* notused, QObject* receiver, QEvent* ev)
{
  notused = 0; // not used, just something to 'reference' the variable  
  return self->QApplication::notify(receiver, ev);
}

// these need the object in order to call them ->
bool LQApp::notify(QObject *receiver, QEvent *ev) 
{
  handler(target, receiver, ev);
  return true;
}

// sets new target object and handler func.
void LQApp::setHandler(QObject* new_target, handler_func_t new_handler)
{
  target = new_target;
  handler = new_handler;
}

// Saves previous target and handler in user supplied var ptrs.
// Used to generate a chain of handlers, call with the address of 
// an object and a function that can be used by the new handler 
// to call prev_handler(prev_target, object, event);
void LQApp::getTargetHandler(QObject** prev_targ, handler_func_t* prev_func)
{
  LQApp* This = LQApp::self;
  *prev_targ = This->target;
  *prev_func = This->handler;
}

// App contructor
LQApp::LQApp(int &argc, char **argv)
  : QApplication(argc, argv) 
{
  // additional setup
  self = this;
  handler = defaultHandler;
}

// App destructor
LQApp::~LQApp()
{
  // delete additional setup as req'd
}


//////////////////////////////////////////////////////
// Usage example

static QObject* prev_target;
static handler_func_t prev_handler;

bool editor_handler(QObject* target, QObject* receiver, QEvent* event)
{
  // return true; // preempt everything - testing
  // screen for our receiver
  if(receiver == target)
  {
    // screen by event types
    switch(event->type())
    {
      // screen by event types
      case QEvent::KeyRelease:
      case QEvent::KeyPress:
      {
        // this is funky...
        // This 'firsttime' flag just blocks recursion.
        // QT or some error in my program runs this loop twice
        // and I don't yet know why it does this. -rs ->
        
//        static int firsttime;
//        firsttime = !firsttime;
//        if(!firsttime)
//          return true; // consumed
        // <- rs Try commenting this out and see what happens.
        // We might want to explore the blocking or using timestamps for 
        // the event, or even the "accept()" flag in the event.  At least
        // at this level.
        
        // cast the QEvent to the right type
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        uint keyval = keyEvent->key();
        // screen by key value
        switch(keyval)
        {
          case Qt::Key_Return:
#if OLD_SCHOOL
            // explain in great detail what was received
            printf("\n<ching-smash-grind-BAM>\n"); 
            fflush(stdout);
#else
            // less less old school, but perhaps still somewhat informative. ;-)
            printf("Key: %-20s  Flags: %s\n", qkey2name(keyval), qmodkeys2name(keyval));
#endif             
            ((QTextEdit*)receiver)->append(""); // newline
            return true; // consumed
          default:

#if OLD_SCHOOL
            // explain in great detail what was received
            printf("<tappity>"); 
            fflush(stdout);
#else
            // less less old school, but perhaps still somewhat informative. ;-)
            printf("Key: %-20s  Flags: %s\n", qkey2name(keyval), qmodkeys2name(keyval));
#endif             
                goto CONTINUE;
            ; // or just fall through
        } // end switch key
      } // end case keypress
          default:
            goto CONTINUE;   // or just fall through
    } // end switch event type 
    // fall through, do not preempt
  }
CONTINUE:
  return prev_handler(prev_target, receiver, event);
}

////////////////////////////////////////////////////
// standard-ish main except that it adds a TextEdit 
// set to all the defaults.
int main(int argc, char *argv[])
{
  dbg();
  LQApp app(argc, argv);
  QTextEdit editor;
  
  // save the previous pointers if we need to use or restore them.
  app.getTargetHandler(&prev_target, &prev_handler);
  
  app.setHandler(&editor, editor_handler);
  editor.show();
  return app.exec();
}

// lookup-test.cpp
#include <stdio.h>


#include "utils.h"

#define LOOKUP_TEST 1
#include "lib/utils.cpp" // for type MULTI mc2 build
#undef LOOKUP_TEST

int main()
{
  for(HASH_ENTRY* p = lq_key_name_tbl; p->name != 0; p++)
  {
    const char* keyname = p->name;
    uint keyval = qname2key(keyname);
    printf("keyval: Ox%-10X keyname: %s\n", keyval, keyname);
  }
  // defined in lib/utils.cpp
  // int hash_false_hits = 0;
  // int hash_lookups = 0;
  printf("Total lookups = %d\n", hash_lookups);
  printf("Total string comparisons = %d\n", string_comparisons);
  printf("Total false hits = %d\n", hash_false_hits);
  return 0;
}

uint qname2key(const char* name)

// precomputing the hash value takes a little time, so this is for longish lists
// where the hash32 call and return and the iteration over the entire string to 
// generate the id vanish due to the simplicity of the hash matching below.

jmp loop_start:

// increment i and exit if *i == 0
next_i:
80495e8: add    $0xc,%ebx         
80495eb: mov    0x4(%ebx),%edx
80495ee: test   %edx,%edx
80495f0: je     not_found;

loop_start:
80495f2: cmp    %esi,(%ebx)
80495f4: jne    80495e8 next_i;
// this is the bottom of the loop except when doing strcmp

80495f6: mov    %edi,0x4(%esp)
80495fa: mov    %edx,(%esp)
80495fd: call   8048f2c <strcmp@plt>
8049602: test   %eax,%eax
8049604: jne    next_i;
// this only loops back if the string comparison fails which is almost never

// usually falls through from successful strcmp to return i

... (and then at the end of the dump) ...
keyval: Ox1100020    keyname: Key_Camera
keyval: Ox1100021    keyname: Key_CameraFocus
keyval: Ox1FFFFFF    keyname: Key_unknown
Total lookups = 365
Total string comparisons = 66795
Total false hits = 0

// utils.cpp

#include <QTextEdit>
#include <stdio.h>
#include "utils.h" 

/*
  lq_hash32() is very similar to the ghash algorithm used to look up 
  names in shared objects except that it always sets the high 
  bit so no '0' value can be computed.
  
  While it could be argued that hashing is an extra step and it doesn't 
  result in unique ids in all cases, the fact that we can compare ids
  in a for() loop without calling strcmp() except to do a double check 
  saves quite a bit of time for large lists.
  
  If the lists to look through are super-long more time can be saved 
  by creating 'buckets' or 'threads' (where I come from) computed from 
  the hash id.
  
  In the following example there's just one 'thread' and it's a fixed size.
  Obviously, if you need them to 'grow' you need to allocate and reallocate 
  memory for these or use linked lists;
  
*/

int lq_hash32(const char* name)
{
  const char *p = name;
  if(!p) return 0;  // returns 0 if null pointer
  int h = *p;
  if (h) {
    for (p += 1; *p != 0; p++)
      h = ((h << 5) - h) + *p;
  }
  // return h < 0 ? h : -h;
  // corrected per ntubski's observations -rs
  return h < 0 ? h : ~h;
}

// a temp definition to help convert from header data to a struct definition
#define COMPILE_HASH_ENTRY(name, value) \
  {0, #name, value}

HASH_ENTRY lq_key_name_tbl[] =
{
  // misc keys
  COMPILE_HASH_ENTRY(Key_Escape, 0x01000000),
  COMPILE_HASH_ENTRY(Key_Tab, 0x01000001),
  COMPILE_HASH_ENTRY(Key_Backtab, 0x01000002),
  COMPILE_HASH_ENTRY(Key_Backspace, 0x01000003),
  COMPILE_HASH_ENTRY(Key_Return, 0x01000004),
  COMPILE_HASH_ENTRY(Key_Enter, 0x01000005),
  COMPILE_HASH_ENTRY(Key_Insert, 0x01000006),
  COMPILE_HASH_ENTRY(Key_Delete, 0x01000007),
  COMPILE_HASH_ENTRY(Key_Pause, 0x01000008),
  COMPILE_HASH_ENTRY(Key_Print, 0x01000009),
  COMPILE_HASH_ENTRY(Key_SysReq, 0x0100000a),
  COMPILE_HASH_ENTRY(Key_Clear, 0x0100000b),
          
  // cursor movement
  COMPILE_HASH_ENTRY(Key_Home, 0x01000010),
  COMPILE_HASH_ENTRY(Key_End, 0x01000011),
  COMPILE_HASH_ENTRY(Key_Left, 0x01000012),
  COMPILE_HASH_ENTRY(Key_Up, 0x01000013),
  COMPILE_HASH_ENTRY(Key_Right, 0x01000014),
  COMPILE_HASH_ENTRY(Key_Down, 0x01000015),
  COMPILE_HASH_ENTRY(Key_PageUp, 0x01000016),
  COMPILE_HASH_ENTRY(Key_PageDown, 0x01000017),
          
  // modifiers
  COMPILE_HASH_ENTRY(Key_Shift, 0x01000020),
  COMPILE_HASH_ENTRY(Key_Control, 0x01000021),
  COMPILE_HASH_ENTRY(Key_Meta, 0x01000022),
  COMPILE_HASH_ENTRY(Key_Alt, 0x01000023),
  COMPILE_HASH_ENTRY(Key_CapsLock, 0x01000024),
  COMPILE_HASH_ENTRY(Key_NumLock, 0x01000025),
  COMPILE_HASH_ENTRY(Key_ScrollLock, 0x01000026),
          
  // function keys
  COMPILE_HASH_ENTRY(Key_F1, 0x01000030),
  COMPILE_HASH_ENTRY(Key_F2, 0x01000031),
  COMPILE_HASH_ENTRY(Key_F3, 0x01000032),
  COMPILE_HASH_ENTRY(Key_F4, 0x01000033),
  COMPILE_HASH_ENTRY(Key_F5, 0x01000034),
  COMPILE_HASH_ENTRY(Key_F6, 0x01000035),
  COMPILE_HASH_ENTRY(Key_F7, 0x01000036),
  COMPILE_HASH_ENTRY(Key_F8, 0x01000037),
  COMPILE_HASH_ENTRY(Key_F9, 0x01000038),
  COMPILE_HASH_ENTRY(Key_F10, 0x01000039),
  COMPILE_HASH_ENTRY(Key_F11, 0x0100003a),
  COMPILE_HASH_ENTRY(Key_F12, 0x0100003b),
  COMPILE_HASH_ENTRY(Key_F13, 0x0100003c),
  COMPILE_HASH_ENTRY(Key_F14, 0x0100003d),
  COMPILE_HASH_ENTRY(Key_F15, 0x0100003e),
  COMPILE_HASH_ENTRY(Key_F16, 0x0100003f),
  COMPILE_HASH_ENTRY(Key_F17, 0x01000040),
  COMPILE_HASH_ENTRY(Key_F18, 0x01000041),
  COMPILE_HASH_ENTRY(Key_F19, 0x01000042),
  COMPILE_HASH_ENTRY(Key_F20, 0x01000043),
  COMPILE_HASH_ENTRY(Key_F21, 0x01000044),
  COMPILE_HASH_ENTRY(Key_F22, 0x01000045),
  COMPILE_HASH_ENTRY(Key_F23, 0x01000046),
  COMPILE_HASH_ENTRY(Key_F24, 0x01000047),
  // F25 .. F35 only on X11
  COMPILE_HASH_ENTRY(Key_F25, 0x01000048),
  COMPILE_HASH_ENTRY(Key_F26, 0x01000049),
  COMPILE_HASH_ENTRY(Key_F27, 0x0100004a),
  COMPILE_HASH_ENTRY(Key_F28, 0x0100004b),
  COMPILE_HASH_ENTRY(Key_F29, 0x0100004c),
  COMPILE_HASH_ENTRY(Key_F30, 0x0100004d),
  COMPILE_HASH_ENTRY(Key_F31, 0x0100004e),
  COMPILE_HASH_ENTRY(Key_F32, 0x0100004f),
  COMPILE_HASH_ENTRY(Key_F33, 0x01000050),
  COMPILE_HASH_ENTRY(Key_F34, 0x01000051),
  COMPILE_HASH_ENTRY(Key_F35, 0x01000052),
  // extra keys
  COMPILE_HASH_ENTRY(Key_Super_L, 0x01000053),
  COMPILE_HASH_ENTRY(Key_Super_R, 0x01000054),
  COMPILE_HASH_ENTRY(Key_Menu, 0x01000055),
  COMPILE_HASH_ENTRY(Key_Hyper_L, 0x01000056),
  COMPILE_HASH_ENTRY(Key_Hyper_R, 0x01000057),
  COMPILE_HASH_ENTRY(Key_Help, 0x01000058),
  COMPILE_HASH_ENTRY(Key_Direction_L, 0x01000059),
  COMPILE_HASH_ENTRY(Key_Direction_R, 0x01000060),          
  // 7 bit printable ASCII
  COMPILE_HASH_ENTRY(Key_Space, 0x20),
  COMPILE_HASH_ENTRY(Key_Any, Qt::Key_Space),
  COMPILE_HASH_ENTRY(Key_Exclam, 0x21),
  COMPILE_HASH_ENTRY(Key_QuoteDbl, 0x22),
  COMPILE_HASH_ENTRY(Key_NumberSign, 0x23),
  COMPILE_HASH_ENTRY(Key_Dollar, 0x24),
  COMPILE_HASH_ENTRY(Key_Percent, 0x25),
  COMPILE_HASH_ENTRY(Key_Ampersand, 0x26),
  COMPILE_HASH_ENTRY(Key_Apostrophe, 0x27),
  COMPILE_HASH_ENTRY(Key_ParenLeft, 0x28),
  COMPILE_HASH_ENTRY(Key_ParenRight, 0x29),
  COMPILE_HASH_ENTRY(Key_Asterisk, 0x2a),
  COMPILE_HASH_ENTRY(Key_Plus, 0x2b),
  COMPILE_HASH_ENTRY(Key_Comma, 0x2c),
  COMPILE_HASH_ENTRY(Key_Minus, 0x2d),
  COMPILE_HASH_ENTRY(Key_Period, 0x2e),
  COMPILE_HASH_ENTRY(Key_Slash, 0x2f),
  COMPILE_HASH_ENTRY(Key_0, 0x30),
  COMPILE_HASH_ENTRY(Key_1, 0x31),
  COMPILE_HASH_ENTRY(Key_2, 0x32),
  COMPILE_HASH_ENTRY(Key_3, 0x33),
  COMPILE_HASH_ENTRY(Key_4, 0x34),
  COMPILE_HASH_ENTRY(Key_5, 0x35),
  COMPILE_HASH_ENTRY(Key_6, 0x36),
  COMPILE_HASH_ENTRY(Key_7, 0x37),
  COMPILE_HASH_ENTRY(Key_8, 0x38),
  COMPILE_HASH_ENTRY(Key_9, 0x39),
  COMPILE_HASH_ENTRY(Key_Colon, 0x3a),
  COMPILE_HASH_ENTRY(Key_Semicolon, 0x3b),
  COMPILE_HASH_ENTRY(Key_Less, 0x3c),
  COMPILE_HASH_ENTRY(Key_Equal, 0x3d),
  COMPILE_HASH_ENTRY(Key_Greater, 0x3e),
  COMPILE_HASH_ENTRY(Key_Question, 0x3f),
  COMPILE_HASH_ENTRY(Key_At, 0x40),
  COMPILE_HASH_ENTRY(Key_A, 0x41),
  COMPILE_HASH_ENTRY(Key_B, 0x42),
  COMPILE_HASH_ENTRY(Key_C, 0x43),
  COMPILE_HASH_ENTRY(Key_D, 0x44),
  COMPILE_HASH_ENTRY(Key_E, 0x45),
  COMPILE_HASH_ENTRY(Key_F, 0x46),
  COMPILE_HASH_ENTRY(Key_G, 0x47),
  COMPILE_HASH_ENTRY(Key_H, 0x48),
  COMPILE_HASH_ENTRY(Key_I, 0x49),
  COMPILE_HASH_ENTRY(Key_J, 0x4a),
  COMPILE_HASH_ENTRY(Key_K, 0x4b),
  COMPILE_HASH_ENTRY(Key_L, 0x4c),
  COMPILE_HASH_ENTRY(Key_M, 0x4d),
  COMPILE_HASH_ENTRY(Key_N, 0x4e),
  COMPILE_HASH_ENTRY(Key_O, 0x4f),
  COMPILE_HASH_ENTRY(Key_P, 0x50),
  COMPILE_HASH_ENTRY(Key_Q, 0x51),
  COMPILE_HASH_ENTRY(Key_R, 0x52),
  COMPILE_HASH_ENTRY(Key_S, 0x53),
  COMPILE_HASH_ENTRY(Key_T, 0x54),
  COMPILE_HASH_ENTRY(Key_U, 0x55),
  COMPILE_HASH_ENTRY(Key_V, 0x56),
  COMPILE_HASH_ENTRY(Key_W, 0x57),
  COMPILE_HASH_ENTRY(Key_X, 0x58),
  COMPILE_HASH_ENTRY(Key_Y, 0x59),
  COMPILE_HASH_ENTRY(Key_Z, 0x5a),
  COMPILE_HASH_ENTRY(Key_BracketLeft, 0x5b),
  COMPILE_HASH_ENTRY(Key_Backslash, 0x5c),
  COMPILE_HASH_ENTRY(Key_BracketRight, 0x5d),
  COMPILE_HASH_ENTRY(Key_AsciiCircum, 0x5e),
  COMPILE_HASH_ENTRY(Key_Underscore, 0x5f),
  COMPILE_HASH_ENTRY(Key_QuoteLeft, 0x60),
  COMPILE_HASH_ENTRY(Key_BraceLeft, 0x7b),
  COMPILE_HASH_ENTRY(Key_Bar, 0x7c),
  COMPILE_HASH_ENTRY(Key_BraceRight, 0x7d),
  COMPILE_HASH_ENTRY(Key_AsciiTilde, 0x7e),
  COMPILE_HASH_ENTRY(Key_nobreakspace, 0x0a0),
  COMPILE_HASH_ENTRY(Key_exclamdown, 0x0a1),
  COMPILE_HASH_ENTRY(Key_cent, 0x0a2),
  COMPILE_HASH_ENTRY(Key_sterling, 0x0a3),
  COMPILE_HASH_ENTRY(Key_currency, 0x0a4),
  COMPILE_HASH_ENTRY(Key_yen, 0x0a5),
  COMPILE_HASH_ENTRY(Key_brokenbar, 0x0a6),
  COMPILE_HASH_ENTRY(Key_section, 0x0a7),
  COMPILE_HASH_ENTRY(Key_diaeresis, 0x0a8),
  COMPILE_HASH_ENTRY(Key_copyright, 0x0a9),
  COMPILE_HASH_ENTRY(Key_ordfeminine, 0x0aa),
  COMPILE_HASH_ENTRY(Key_guillemotleft, 0x0ab),
  COMPILE_HASH_ENTRY(Key_notsign, 0x0ac),
  COMPILE_HASH_ENTRY(Key_hyphen, 0x0ad),
  COMPILE_HASH_ENTRY(Key_registered, 0x0ae),
  COMPILE_HASH_ENTRY(Key_macron, 0x0af),
  COMPILE_HASH_ENTRY(Key_degree, 0x0b0),
  COMPILE_HASH_ENTRY(Key_plusminus, 0x0b1),
  COMPILE_HASH_ENTRY(Key_twosuperior, 0x0b2),
  COMPILE_HASH_ENTRY(Key_threesuperior, 0x0b3),
  COMPILE_HASH_ENTRY(Key_acute, 0x0b4),
  COMPILE_HASH_ENTRY(Key_mu, 0x0b5),
  COMPILE_HASH_ENTRY(Key_paragraph, 0x0b6),
  COMPILE_HASH_ENTRY(Key_periodcentered, 0x0b7),
  COMPILE_HASH_ENTRY(Key_cedilla, 0x0b8),
  COMPILE_HASH_ENTRY(Key_onesuperior, 0x0b9),
  COMPILE_HASH_ENTRY(Key_masculine, 0x0ba),
  COMPILE_HASH_ENTRY(Key_guillemotright, 0x0bb),
  COMPILE_HASH_ENTRY(Key_onequarter, 0x0bc),
  COMPILE_HASH_ENTRY(Key_onehalf, 0x0bd),
  COMPILE_HASH_ENTRY(Key_threequarters, 0x0be),
  COMPILE_HASH_ENTRY(Key_questiondown, 0x0bf),
  COMPILE_HASH_ENTRY(Key_Agrave, 0x0c0),
  COMPILE_HASH_ENTRY(Key_Aacute, 0x0c1),
  COMPILE_HASH_ENTRY(Key_Acircumflex, 0x0c2),
  COMPILE_HASH_ENTRY(Key_Atilde, 0x0c3),
  COMPILE_HASH_ENTRY(Key_Adiaeresis, 0x0c4),
  COMPILE_HASH_ENTRY(Key_Aring, 0x0c5),
  COMPILE_HASH_ENTRY(Key_AE, 0x0c6),
  COMPILE_HASH_ENTRY(Key_Ccedilla, 0x0c7),
  COMPILE_HASH_ENTRY(Key_Egrave, 0x0c8),
  COMPILE_HASH_ENTRY(Key_Eacute, 0x0c9),
  COMPILE_HASH_ENTRY(Key_Ecircumflex, 0x0ca),
  COMPILE_HASH_ENTRY(Key_Ediaeresis, 0x0cb),
  COMPILE_HASH_ENTRY(Key_Igrave, 0x0cc),
  COMPILE_HASH_ENTRY(Key_Iacute, 0x0cd),
  COMPILE_HASH_ENTRY(Key_Icircumflex, 0x0ce),
  COMPILE_HASH_ENTRY(Key_Idiaeresis, 0x0cf),
  COMPILE_HASH_ENTRY(Key_ETH, 0x0d0),
  COMPILE_HASH_ENTRY(Key_Ntilde, 0x0d1),
  COMPILE_HASH_ENTRY(Key_Ograve, 0x0d2),
  COMPILE_HASH_ENTRY(Key_Oacute, 0x0d3),
  COMPILE_HASH_ENTRY(Key_Ocircumflex, 0x0d4),
  COMPILE_HASH_ENTRY(Key_Otilde, 0x0d5),
  COMPILE_HASH_ENTRY(Key_Odiaeresis, 0x0d6),
  COMPILE_HASH_ENTRY(Key_multiply, 0x0d7),
  COMPILE_HASH_ENTRY(Key_Ooblique, 0x0d8),
  COMPILE_HASH_ENTRY(Key_Ugrave, 0x0d9),
  COMPILE_HASH_ENTRY(Key_Uacute, 0x0da),
  COMPILE_HASH_ENTRY(Key_Ucircumflex, 0x0db),
  COMPILE_HASH_ENTRY(Key_Udiaeresis, 0x0dc),
  COMPILE_HASH_ENTRY(Key_Yacute, 0x0dd),
  COMPILE_HASH_ENTRY(Key_THORN, 0x0de),
  COMPILE_HASH_ENTRY(Key_ssharp, 0x0df),
  COMPILE_HASH_ENTRY(Key_division, 0x0f7),
  COMPILE_HASH_ENTRY(Key_ydiaeresis, 0x0ff),  
  // see the headers if you need international and multi-key char composition.
  // multimedia/internet keys - ignored by default.
  COMPILE_HASH_ENTRY(Key_Back , 0x01000061),
  COMPILE_HASH_ENTRY(Key_Forward , 0x01000062),
  COMPILE_HASH_ENTRY(Key_Stop , 0x01000063),
  COMPILE_HASH_ENTRY(Key_Refresh , 0x01000064),
  COMPILE_HASH_ENTRY(Key_VolumeDown, 0x01000070),
  COMPILE_HASH_ENTRY(Key_VolumeMute , 0x01000071),
  COMPILE_HASH_ENTRY(Key_VolumeUp, 0x01000072),
  COMPILE_HASH_ENTRY(Key_BassBoost, 0x01000073),
  COMPILE_HASH_ENTRY(Key_BassUp, 0x01000074),
  COMPILE_HASH_ENTRY(Key_BassDown, 0x01000075),
  COMPILE_HASH_ENTRY(Key_TrebleUp, 0x01000076),
  COMPILE_HASH_ENTRY(Key_TrebleDown, 0x01000077),
  COMPILE_HASH_ENTRY(Key_MediaPlay , 0x01000080),
  COMPILE_HASH_ENTRY(Key_MediaStop , 0x01000081),
  COMPILE_HASH_ENTRY(Key_MediaPrevious , 0x01000082),
  COMPILE_HASH_ENTRY(Key_MediaNext , 0x01000083),
  COMPILE_HASH_ENTRY(Key_MediaRecord, 0x01000084),
  COMPILE_HASH_ENTRY(Key_MediaPause, 0x1000085),
  COMPILE_HASH_ENTRY(Key_MediaTogglePlayPause, 0x1000086),
  COMPILE_HASH_ENTRY(Key_HomePage , 0x01000090),
  COMPILE_HASH_ENTRY(Key_Favorites , 0x01000091),
  COMPILE_HASH_ENTRY(Key_Search , 0x01000092),
  COMPILE_HASH_ENTRY(Key_Standby, 0x01000093),
  COMPILE_HASH_ENTRY(Key_OpenUrl, 0x01000094),
  COMPILE_HASH_ENTRY(Key_LaunchMail , 0x010000a0),
  COMPILE_HASH_ENTRY(Key_LaunchMedia, 0x010000a1),
  COMPILE_HASH_ENTRY(Key_Launch0 , 0x010000a2),
  COMPILE_HASH_ENTRY(Key_Launch1 , 0x010000a3),
  COMPILE_HASH_ENTRY(Key_Launch2 , 0x010000a4),
  COMPILE_HASH_ENTRY(Key_Launch3 , 0x010000a5),
  COMPILE_HASH_ENTRY(Key_Launch4 , 0x010000a6),
  COMPILE_HASH_ENTRY(Key_Launch5 , 0x010000a7),
  COMPILE_HASH_ENTRY(Key_Launch6 , 0x010000a8),
  COMPILE_HASH_ENTRY(Key_Launch7 , 0x010000a9),
  COMPILE_HASH_ENTRY(Key_Launch8 , 0x010000aa),
  COMPILE_HASH_ENTRY(Key_Launch9 , 0x010000ab),
  COMPILE_HASH_ENTRY(Key_LaunchA , 0x010000ac),
  COMPILE_HASH_ENTRY(Key_LaunchB , 0x010000ad),
  COMPILE_HASH_ENTRY(Key_LaunchC , 0x010000ae),
  COMPILE_HASH_ENTRY(Key_LaunchD , 0x010000af),
  COMPILE_HASH_ENTRY(Key_LaunchE , 0x010000b0),
  COMPILE_HASH_ENTRY(Key_LaunchF , 0x010000b1),
  COMPILE_HASH_ENTRY(Key_MonBrightnessUp, 0x010000b2),
  COMPILE_HASH_ENTRY(Key_MonBrightnessDown, 0x010000b3),
  COMPILE_HASH_ENTRY(Key_KeyboardLightOnOff, 0x010000b4),
  COMPILE_HASH_ENTRY(Key_KeyboardBrightnessUp, 0x010000b5),
  COMPILE_HASH_ENTRY(Key_KeyboardBrightnessDown, 0x010000b6),
  COMPILE_HASH_ENTRY(Key_PowerOff, 0x010000b7),
  COMPILE_HASH_ENTRY(Key_WakeUp, 0x010000b8),
  COMPILE_HASH_ENTRY(Key_Eject, 0x010000b9),
  COMPILE_HASH_ENTRY(Key_ScreenSaver, 0x010000ba),
  COMPILE_HASH_ENTRY(Key_WWW, 0x010000bb),
  COMPILE_HASH_ENTRY(Key_Memo, 0x010000bc),
  COMPILE_HASH_ENTRY(Key_LightBulb, 0x010000bd),
  COMPILE_HASH_ENTRY(Key_Shop, 0x010000be),
  COMPILE_HASH_ENTRY(Key_History, 0x010000bf),
  COMPILE_HASH_ENTRY(Key_AddFavorite, 0x010000c0),
  COMPILE_HASH_ENTRY(Key_HotLinks, 0x010000c1),
  COMPILE_HASH_ENTRY(Key_BrightnessAdjust, 0x010000c2),
  COMPILE_HASH_ENTRY(Key_Finance, 0x010000c3),
  COMPILE_HASH_ENTRY(Key_Community, 0x010000c4),
  COMPILE_HASH_ENTRY(Key_AudioRewind, 0x010000c5),
  COMPILE_HASH_ENTRY(Key_BackForward, 0x010000c6),
  COMPILE_HASH_ENTRY(Key_ApplicationLeft, 0x010000c7),
  COMPILE_HASH_ENTRY(Key_ApplicationRight, 0x010000c8),
  COMPILE_HASH_ENTRY(Key_Book, 0x010000c9),
  COMPILE_HASH_ENTRY(Key_CD, 0x010000ca),
  COMPILE_HASH_ENTRY(Key_Calculator, 0x010000cb),
  COMPILE_HASH_ENTRY(Key_ToDoList, 0x010000cc),
  COMPILE_HASH_ENTRY(Key_ClearGrab, 0x010000cd),
  COMPILE_HASH_ENTRY(Key_Close, 0x010000ce),
  COMPILE_HASH_ENTRY(Key_Copy, 0x010000cf),
  COMPILE_HASH_ENTRY(Key_Cut, 0x010000d0),
  COMPILE_HASH_ENTRY(Key_Display, 0x010000d1),
  COMPILE_HASH_ENTRY(Key_DOS, 0x010000d2),
  COMPILE_HASH_ENTRY(Key_Documents, 0x010000d3),
  COMPILE_HASH_ENTRY(Key_Excel, 0x010000d4),
  COMPILE_HASH_ENTRY(Key_Explorer, 0x010000d5),
  COMPILE_HASH_ENTRY(Key_Game, 0x010000d6),
  COMPILE_HASH_ENTRY(Key_Go, 0x010000d7),
  COMPILE_HASH_ENTRY(Key_iTouch, 0x010000d8),
  COMPILE_HASH_ENTRY(Key_LogOff, 0x010000d9),
  COMPILE_HASH_ENTRY(Key_Market, 0x010000da),
  COMPILE_HASH_ENTRY(Key_Meeting, 0x010000db),
  COMPILE_HASH_ENTRY(Key_MenuKB, 0x010000dc),
  COMPILE_HASH_ENTRY(Key_MenuPB, 0x010000dd),
  COMPILE_HASH_ENTRY(Key_MySites, 0x010000de),
  COMPILE_HASH_ENTRY(Key_News, 0x010000df),
  COMPILE_HASH_ENTRY(Key_OfficeHome, 0x010000e0),
  COMPILE_HASH_ENTRY(Key_Option, 0x010000e1),
  COMPILE_HASH_ENTRY(Key_Paste, 0x010000e2),
  COMPILE_HASH_ENTRY(Key_Phone, 0x010000e3),
  COMPILE_HASH_ENTRY(Key_Calendar, 0x010000e4),
  COMPILE_HASH_ENTRY(Key_Reply, 0x010000e5),
  COMPILE_HASH_ENTRY(Key_Reload, 0x010000e6),
  COMPILE_HASH_ENTRY(Key_RotateWindows, 0x010000e7),
  COMPILE_HASH_ENTRY(Key_RotationPB, 0x010000e8),
  COMPILE_HASH_ENTRY(Key_RotationKB, 0x010000e9),
  COMPILE_HASH_ENTRY(Key_Save, 0x010000ea),
  COMPILE_HASH_ENTRY(Key_Send, 0x010000eb),
  COMPILE_HASH_ENTRY(Key_Spell, 0x010000ec),
  COMPILE_HASH_ENTRY(Key_SplitScreen, 0x010000ed),
  COMPILE_HASH_ENTRY(Key_Support, 0x010000ee),
  COMPILE_HASH_ENTRY(Key_TaskPane, 0x010000ef),
  COMPILE_HASH_ENTRY(Key_Terminal, 0x010000f0),
  COMPILE_HASH_ENTRY(Key_Tools, 0x010000f1),
  COMPILE_HASH_ENTRY(Key_Travel, 0x010000f2),
  COMPILE_HASH_ENTRY(Key_Video, 0x010000f3),
  COMPILE_HASH_ENTRY(Key_Word, 0x010000f4),
  COMPILE_HASH_ENTRY(Key_Xfer, 0x010000f5),
  COMPILE_HASH_ENTRY(Key_ZoomIn, 0x010000f6),
  COMPILE_HASH_ENTRY(Key_ZoomOut, 0x010000f7),
  COMPILE_HASH_ENTRY(Key_Away, 0x010000f8),
  COMPILE_HASH_ENTRY(Key_Messenger, 0x010000f9),
  COMPILE_HASH_ENTRY(Key_WebCam, 0x010000fa),
  COMPILE_HASH_ENTRY(Key_MailForward, 0x010000fb),
  COMPILE_HASH_ENTRY(Key_Pictures, 0x010000fc),
  COMPILE_HASH_ENTRY(Key_Music, 0x010000fd),
  COMPILE_HASH_ENTRY(Key_Battery, 0x010000fe),
  COMPILE_HASH_ENTRY(Key_Bluetooth, 0x010000ff),
  COMPILE_HASH_ENTRY(Key_WLAN, 0x01000100),
  COMPILE_HASH_ENTRY(Key_UWB, 0x01000101),
  COMPILE_HASH_ENTRY(Key_AudioForward, 0x01000102),
  COMPILE_HASH_ENTRY(Key_AudioRepeat, 0x01000103),
  COMPILE_HASH_ENTRY(Key_AudioRandomPlay, 0x01000104),
  COMPILE_HASH_ENTRY(Key_Subtitle, 0x01000105),
  COMPILE_HASH_ENTRY(Key_AudioCycleTrack, 0x01000106),
  COMPILE_HASH_ENTRY(Key_Time, 0x01000107),
  COMPILE_HASH_ENTRY(Key_Hibernate, 0x01000108),
  COMPILE_HASH_ENTRY(Key_View, 0x01000109),
  COMPILE_HASH_ENTRY(Key_TopMenu, 0x0100010a),
  COMPILE_HASH_ENTRY(Key_PowerDown, 0x0100010b),
  COMPILE_HASH_ENTRY(Key_Suspend, 0x0100010c),
  COMPILE_HASH_ENTRY(Key_ContrastAdjust, 0x0100010d),
  COMPILE_HASH_ENTRY(Key_LaunchG , 0x0100010e),
  COMPILE_HASH_ENTRY(Key_LaunchH , 0x0100010f),
  COMPILE_HASH_ENTRY(Key_MediaLast, 0x0100ffff),
  
  // Keypad navigation keys
  COMPILE_HASH_ENTRY(Key_Select, 0x01010000),
  COMPILE_HASH_ENTRY(Key_Yes, 0x01010001),
  COMPILE_HASH_ENTRY(Key_No, 0x01010002),
  
  // Newer misc keys
  COMPILE_HASH_ENTRY(Key_Cancel , 0x01020001),
  COMPILE_HASH_ENTRY(Key_Printer, 0x01020002),
  COMPILE_HASH_ENTRY(Key_Execute, 0x01020003),
  COMPILE_HASH_ENTRY(Key_Sleep  , 0x01020004),
  COMPILE_HASH_ENTRY(Key_Play   , 0x01020005),
  COMPILE_HASH_ENTRY(Key_Zoom   , 0x01020006),
                     
  // Device keys
  COMPILE_HASH_ENTRY(Key_Context1, 0x01100000),
  COMPILE_HASH_ENTRY(Key_Context2, 0x01100001),
  COMPILE_HASH_ENTRY(Key_Context3, 0x01100002),
  COMPILE_HASH_ENTRY(Key_Context4, 0x01100003),
  COMPILE_HASH_ENTRY(Key_Call, 0x01100004),
  COMPILE_HASH_ENTRY(Key_Hangup, 0x01100005),
  COMPILE_HASH_ENTRY(Key_Flip, 0x01100006),
  COMPILE_HASH_ENTRY(Key_ToggleCallHangup, 0x01100007),
  COMPILE_HASH_ENTRY(Key_VoiceDial, 0x01100008),
  COMPILE_HASH_ENTRY(Key_LastNumberRedial, 0x01100009),
  COMPILE_HASH_ENTRY(Key_Camera, 0x01100020),
  COMPILE_HASH_ENTRY(Key_CameraFocus, 0x01100021),
  COMPILE_HASH_ENTRY(Key_unknown, 0x01ffffff),
        
  {0, 0, 0},
};
#undef COMPILE_HASH_ENTRY

int lq_key_name_tbl_hash_inited = 0;

void init_lq_key_pairs()
{
  for(HASH_ENTRY* p = lq_key_name_tbl;p->name != 0; p++)
    p->hashid = lq_hash32(p->name);
  
  lq_key_name_tbl_hash_inited++;
}

const char* qkey2name(uint value)
{
  for(HASH_ENTRY* p = lq_key_name_tbl;p->name != 0; p++)
  {
    if(p->value == value)
      return p->name;
  }
  return "Key_unknown";
}


#ifdef LOOKUP_TEST
int hash_false_hits = 0;
int hash_lookups = 0;
int string_comparisons = 0;
#endif

uint qname2key(const char* name)
{
  // only need hashes for names.
  if(!lq_key_name_tbl_hash_inited)
    init_lq_key_pairs();
  int hashid = lq_hash32(name);

// normal
#ifndef LOOKUP_TEST
  for(HASH_ENTRY* p = lq_key_name_tbl;p->name != 0; p++)
  {
    if((p->hashid == hashid) && (strcmp(p->name, name) == 0))
      return p->value;
  }

// test
#else
int ctr = 0;
hash_lookups ++;
for(HASH_ENTRY* p = lq_key_name_tbl;p->name != 0; p++)
{
  string_comparisons++;
  if(p->hashid == hashid) 
  { 
    ctr++; // id's match
    if (strcmp(p->name, name) == 0)
    {
      if(ctr > 1)
      {
        hash_false_hits += ctr -1;
      }
      return p->value;
    } // if
  } // if
}
#endif // LOOKUP_TEST

  return 0x01ffffff; // "Key_unknown";
}

char* qmodkeys2name(uint value)
{
  static char tmp[256];
  *tmp = 0;
  
  if(value & 0x40000000) strcat(tmp, "Qt::GroupSwitchModifier | ");
  if(value & 0x20000000) strcat(tmp, "Qt::KeypadModifier | ");
  if(value & 0x10000000) strcat(tmp, "Qt::MetaModifier | ");
  if(value & 0x08000000) strcat(tmp, "Qt::AltModifier | ");
  if(value & 0x04000000) strcat(tmp, "Qt::ControlModifier | ");
  if(value & 0x02000000) strcat(tmp, "Qt::ShiftModifier | ");

  if(*tmp)
    strrchr(tmp, '|')[-1] = 0;
  else
    strcpy(tmp, "NONE");
  return tmp;
}

//////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////
// Here's a method extender for QTextEdit.  These method 
// extenders don't contain any additional data, just 
// methods, so they don't have constructors or destructors
// and everything is public so the original class functions
// can be obtained through them and funcs or vars not 
// available publicly can be made accessible through this 
// interface by reimplimenting them as public.
class LQTextEdit : public QTextEdit
{
public:
  int count();                // slist style, not implemented
  const char* get(int idx);   // slist style, not implemented
  int position() { return QTextEdit::textCursor().position();}
};

bool handle_return_key(QObject* p)
{
  LQTextEdit* te = static_cast<LQTextEdit*>(p);
  QTextCursor tc = te->textCursor();
  printf("Position: %d\n", te->position());
  te->append("\n");
  return true; // stop processing, this key is preempted
}

#include <QApplication> // app
#include <QTextEdit>    // editor
#include <QKeyEvent>    // QKeyEvent
// #include "utils.h"      // qkey2name(), handle_return_key(QTextEditor*), etc.
#include <stdio.h>      // printf()

QObject* target;

void dbg(){}
class LQApplication : public QApplication
{
public:
  LQApplication(int &argc, char **argv);
  ~LQApplication();
  bool notify(QObject *receiver, QEvent *e)
  { 
    printf("receiver: %s0x%lX: eventType: %d\n", 
           receiver == target ? "TARGET -> " : "", 
           (long)receiver, e->type());
    return QApplication::notify(receiver, e);
  }
};

LQApplication::LQApplication(int &argc, char **argv)
: QApplication(argc, argv)
{
  // additional setup
}

LQApplication::~LQApplication()
{
  // delete additional setup as req'd
}

////////////////////////////////////////////////////
// standard-ish main except that it adds a TextEdit 
// set to all the defaults.
int main(int argc, char *argv[])
{
  dbg();
  LQApplication app(argc, argv);
  QTextEdit editor;
  target = &editor;
  editor.show();
  return app.exec();
}

receiver: 0x81524C0: eventType: 18
receiver: TARGET -> 0xBFFE30F4: eventType: 27
receiver: 0xBFFE3108: eventType: 20
receiver: TARGET -> 0xBFFE30F4: eventType: 77
receiver: 0x80F6F50: eventType: 71
receiver: 0x80FE278: eventType: 16
receiver: 0x80F6E68: eventType: 71
receiver: 0x80FAC18: eventType: 16
receiver: 0x80F6E68: eventType: 16
receiver: 0x80FDFA8: eventType: 71
receiver: 0x80FB4F0: eventType: 16
receiver: 0x80FDFA8: eventType: 16
receiver: 0x8141E18: eventType: 16
receiver: 0x8145120: eventType: 16
receiver: 0x8147A18: eventType: 16
receiver: 0x81524C0: eventType: 16
receiver: TARGET -> 0xBFFE30F4: eventType: 16

// file: qt4-props.cpp - lists all properties for (in this case)
// a QPushButton class.

#include <QApplication>
#include <QtCore/qmetaobject.h>
#include <QPushButton>
#include <stdio.h>

int main(int argc, char **argv)
{
  QApplication app(argc, argv);
  
  QPushButton *t = new QPushButton();
  
  const QMetaObject* m;
  m = t->metaObject();
  int cnt = m->propertyCount();
  // int cnt = m->methodCount();
  
  while(m)
  {
    QStringList properties;
    QStringList types;
    
    printf("\nFrom class: %s\n", m->d.stringdata);
    printf("---------------------------\n");
    
    for(int i = m->propertyOffset(); i < m->propertyCount(); i++)
      // for(int i = m->methodOffset(); i < m->methodCount(); i++)
    {
      QMetaProperty a = m->property(i);
      // QMetaMethod a = m->method(i);
      
      properties << QString::fromLatin1(m->property(i).name());
      properties << QString::fromLatin1(m->property(i).typeName());
      // properties << QString::fromLatin1(m->method(i).signature());
    }
    
    int odd = 0;
    foreach(QString s, properties)
    {
      const char* str = s.toAscii();
      if(!odd)
        printf("%s : ", str);
      else
        printf("%s\n", str);
      odd = !odd;
    }
    cnt = m->propertyOffset();      
    //    cnt = m->methodOffset();      
    m = m->d.superdata;
  }
  return 0;
}

/*
 # file: m*c2.def - type 'mc2 -i' or 'mc2 -u' to init a new makefile
 
 OUTNAME = qt4-props
 BINDIR = .
 SRCDIR = src
 OBJDIR = o
 COMPILE = g++ -c 
 CFLAGS = $(DEFINES) -Wall -W -O2 
 INCLUDE = -I ~/usr32/include -I$(SRCDIR) -I/usr/include -I/usr/include/Qt -I/usr/include/QtGui -I /usr/include/QtCore 
 
 # add these as needed to the includes above.  
 # -I /usr/include/Qt             -I /usr/include/QtHelp         -I /usr/include/QtSvg
 # -I /usr/include/Qt3Support     -I /usr/include/QtMultimedia   -I /usr/include/QtTest
 # -I /usr/include/QtCore         -I /usr/include/QtNetwork      -I /usr/include/QtUiTools
 # -I /usr/include/QtDBus         -I /usr/include/QtOpenGL       -I /usr/include/QtWebKit
 # -I /usr/include/QtDeclarative  -I /usr/include/QtScript       -I /usr/include/QtXml
 # -I /usr/include/QtDesigner     -I /usr/include/QtScriptTools  -I /usr/include/QtXmlPatterns
 # -I /usr/include/QtGui          -I /usr/include/QtSql
 
 LINK = g++ 
 LDFLAGS = -lLQ -lQtGui -lQtCore 
 
 # add as needed. see notes for DEFINES and INCLUDES above if you need to split lines
 # -lQt3Support              -lQtNetwork               -lQtCLucene
 # -lQtOpenGL                -lQtCore                  -lQtScript
 # -lQtDBus                  -lQtScriptTools           -lQtDeclarative
 # -lQtSql                   -lQtDesignerComponents    -lQtSvg
 # -lQtDesigner              -lQtTest                  -lQtGui 
 # -lQtWebKit                -lQtHelp                  -lQtXmlPatterns
 # -lQtMultimedia            -lQtXml
 
 
 # adjust the LIB paths for your system.  Try 'locate libQtGui'
 # to find the right path for your system.
 LIB = -L ~/usr32/lib -L/usr/lib 
 
 ################################################################
 ## User Defined Targets
 
 clean: 
 @rm -f $(MAIN)
 @rm -f $(OBJ)
 @rm -f `find . -name *~ -o -name *.*~`
 
*/

$> qt4-props

From class: QPushButton
---------------------------
autoDefault : bool
default : bool
flat : bool

From class: QAbstractButton
---------------------------
text : QString
icon : QIcon
iconSize : QSize
shortcut : QKeySequence
checkable : bool
checked : bool
autoRepeat : bool
autoExclusive : bool
autoRepeatDelay : int
autoRepeatInterval : int
down : bool

From class: QWidget
---------------------------
modal : bool
windowModality : Qt::WindowModality
enabled : bool
geometry : QRect
frameGeometry : QRect
normalGeometry : QRect
x : int
y : int
pos : QPoint
frameSize : QSize
size : QSize
width : int
height : int
rect : QRect
childrenRect : QRect
childrenRegion : QRegion
sizePolicy : QSizePolicy
minimumSize : QSize
maximumSize : QSize
minimumWidth : int
minimumHeight : int
maximumWidth : int
maximumHeight : int
sizeIncrement : QSize
baseSize : QSize
palette : QPalette
font : QFont
cursor : QCursor
mouseTracking : bool
isActiveWindow : bool
focusPolicy : Qt::FocusPolicy
focus : bool
contextMenuPolicy : Qt::ContextMenuPolicy
updatesEnabled : bool
visible : bool
minimized : bool
maximized : bool
fullScreen : bool
sizeHint : QSize
minimumSizeHint : QSize
acceptDrops : bool
windowTitle : QString
windowIcon : QIcon
windowIconText : QString
windowOpacity : double
windowModified : bool
toolTip : QString
statusTip : QString
whatsThis : QString
accessibleName : QString
accessibleDescription : QString
layoutDirection : Qt::LayoutDirection
autoFillBackground : bool
styleSheet : QString
locale : QLocale
windowFilePath : QString
inputMethodHints : Qt::InputMethodHints

From class: QObject
---------------------------
objectName : QString

base64 -d << _eof | gunzip > qt4-methods.cpp
H4sICKssnk8AA3F0NC1wcm9wcy5jcHAApVZbU+M2FH7XrziF3cEJ2GnZPgW6LSRA3XUS2MDQh31Y
YSuJdmXJSDIM0ym/vUe2k9iJw7TTPGSsc/nO7dOxez2YccH68Gh/9lNmFyoxQZxl4IPgxhqgQkAl
h5nS4HEJdsENxNSwDun1gMLNdW4W57m1SkIsqDEBIftcxiJPGJzenGWZ4DG1XMmPdbkdKM16j4hO
1cM3Fttg0dCvUetiYxOunCXh0kJKufTcA9Xz+AjiBdXQ7eLhqUP+IgD14ECzzCvtCoMT1DuTWvZd
C7+AZM91obc0jJU0Fm5GmO+kyLcLqVOl6GP9j+lKXnq4rGLpANNCiS0cqFzaFd7zAjvvpR18dKli
JlOruZxH2HjItMqYtpyZky2dfcmW4uIvQ42deXtf5KVWaTmCPrw3X+TekQueBKZwTqilnZOGi7/7
h96dWhAcftFoXi9oMpsZ5ipC8el2ncAPDzuFd1kglN0bFUZInBqSx6tgVTiodQBOT5f19/szLDHC
ecqfvLpzYPhcUptr5nVWSP8RwvV1TNM1wt/1jFzxKkkw6R9Plh1hNF54FS6Yo1rAZtkldRw7u4Cz
QAwTWHVmYs69VbZ85v2AATrVcT2k9wb6gKNEz5UxE4a1GBYj7xYhME/4FfaeFE/20L/uXJbhgtXr
3CDrerbrHuB1/3eGaWmAzMuxIY54LpKLoxkOSboe4on0umS/2kBpfBwkbIabx80BDvAMPj8AXDrl
c34AVuEYON724pKm9DtzvoRM7m7HZ6MLDOr2mJuCIefheBh+RlFApp8H5aPRMZmc/1EeFBlMRtdh
5Nzmh4fgx0AGl9HZ1RQF77zhxWU4vph2wL93S9C/B39yDCQcD6K7ofPxQ3jt5UZ/OO4tt5MfvvPK
YOgWOmVNVT/2buy25CrnDnRD6rYk4EIFilOzC2YYUIP1s4QlriEogsoa1/WDemIBDmG/BQnqv231
70xkb6inT/NW1A/TPMuUtjvcRrmwPGUJp63qW2ZsK2xR9u5sxsw+K/19l/qO3yolTCvy8Dw3byBP
Miavop3qe/bwibenPGS4ejUulifW2sBY88zuBP4zFTtQ3WpjetdYCtSi2h2o19RapmV7Mxzn3hr6
oyAkCsefqjtCouHyhvgiusG/irZig6grigZgGAOpLCs/IKprBVQmUN2laUlbXIDwovLCzxHb4Jvb
4meIZEXqYoNq66zFBh0amkGUx0yyCqEx3KZdnW8NTdnhCqBBnhazahANTY0XFQq2dRuksi2nPVBp
piST1qzwy/snNhjR8Ha3qR3XDalyLxncZtTYAA3NBo3Exr3etCUlDb7l7msF91MUnkNG7aKkAA5Z
g3kxlqW4qm71CxwIhd9oDIf9UKR6gO7IgBmXxcoDzecLWyBsARCHjWyMVssYQfBYENk9Yir/84cA
cGew30N83Ugk5y1+PzJrCIkFo7LvXnm/6RT8Gb42RmfhuFMX4Pumdv5a1BSAL/FDA7qv4Kvlc9B9
/UpIt/cPquplspQLAAA=
_eof

#!/bin/sh

if [ "$1" == "" ]; then
  name=form1
else
  name=$1
fi

cat << _EOF > $name.ui
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>Form</class>
 <widget class="QWidget" name="Form">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>400</width>
    <height>300</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Form</string>
  </property>
 </widget>
 <resources/>
 <connections/>
</ui>
_EOF

--- install_logwatch.sh.orig	2012-03-24 11:35:34.000000000 +0000
+++ install_logwatch.sh	2012-03-24 11:35:35.000000000 +0000
@@ -72,11 +72,11 @@
 
 #All these can be set via user input
 #Defaults
-BASEDIR="/usr/share/logwatch"
-CONFIGDIR="/etc/logwatch"
-TEMPDIR="/var/cache/logwatch"
+BASEDIR="/tmp/logwatch_portable"
+CONFIGDIR="${BASEDIR}/etc"
+TEMPDIR="${BASEDIR}/tmp"
 PERLEXE="/usr/bin/perl"
-MANDIR="/usr/share/man"
+MANDIR="${BASEDIR}/man"
 
 #Command line options section
 #Currently only prefix is supported but now that the door is open other options should follow. -mgt
@@ -237,7 +237,7 @@
 #The install would destory the perms on /tmp
 if [ ! -d $TEMPDIR ]; then
    #Should this be 0700 -d $TEMPDIR ??
-   install -m 0755 -d $TEMPDIR
+   install -m 0750 -d $TEMPDIR
 fi
 
 #This can create duplicates need to grep first -mgt
@@ -271,22 +271,22 @@
    install -m 0644 postfix-logwatch.1 $MANDIR/man1
    install -m 0644 amavis-logwatch.1 $MANDIR/man1
    #OpenBSD no -s
-   if [ $OS = "OpenBSD" ]; then
-      makewhatis -u $MANDIR/man5 $MANDIR/man8 $MANDIR/man1
-   else
-      #FreeBSD and NetBSD no -s no -u
-      if [ $OS = "FreeBSD" ] || [ $OS = "NetBSD" ]; then
-         makewhatis $MANDIR/man5 $MANDIR/man8 $MANDIR/man1
-      else
-         #MacOS X aka Darwin no -u [even thought the manpage says]
-         if [ $OS = "Darwin" ]; then
-            makewhatis -s "1 5 8" $MANDIR
-         else
-         #Linux
-            makewhatis -u -s "1 5 8" $MANDIR
-         fi
-      fi
-   fi
+# DONT:   if [ $OS = "OpenBSD" ]; then
+# DONT:      makewhatis -u $MANDIR/man5 $MANDIR/man8 $MANDIR/man1
+# DONT:   else
+# DONT:      #FreeBSD and NetBSD no -s no -u
+# DONT:      if [ $OS = "FreeBSD" ] || [ $OS = "NetBSD" ]; then
+# DONT:         makewhatis $MANDIR/man5 $MANDIR/man8 $MANDIR/man1
+# DONT:      else
+# DONT:         #MacOS X aka Darwin no -u [even thought the manpage says]
+# DONT:         if [ $OS = "Darwin" ]; then
+# DONT:            makewhatis -s "1 5 8" $MANDIR
+# DONT:         else
+# DONT:         #Linux
+# DONT:            makewhatis -u -s "1 5 8" $MANDIR
+# DONT:         fi
+# DONT:      fi
+# DONT:   fi
 else
    if [ $OS = "SunOS" ]; then
       #Go for the safe install rather then editing man.cf
@@ -317,21 +317,115 @@
 fi
 
 #Symlink
-ln -f -s $BASEDIR/scripts/logwatch.pl /usr/sbin/logwatch
-printf "Created symlink for /usr/sbin/logwatch \n"
+# FIX_STATIC_PATH: ln -f -s $BASEDIR/scripts/logwatch.pl /usr/sbin/logwatch
+# FIX_STATIC_PATH: printf "Created symlink for /usr/sbin/logwatch \n"
 
 #Cron
-if [ -d /etc/cron.daily ]; then
-   rm -f /etc/cron.daily/0logwatch
-   install -m 0755 logwatch.cron /etc/cron.daily/0logwatch
-   printf "Created /etc/cron.daily/0logwatch \n" 
-else
-   install -m 0744 logwatch.cron $CONFIGDIR/logwatch.cron
-   printf "################ README ####################.\n"
-   printf "You need to setup your cron job for logwatch.\n"
-   printf "A sample script is included see $CONFIGDIR/logwatch.cron. \n"
-   printf "2 0 * * * $CONFIGDIR/logwatch.cron >/dev/null 2>&1 \n"
-fi
+# FIX_STATIC_PATH: if [ -d /etc/cron.daily ]; then
+# FIX_STATIC_PATH:    rm -f /etc/cron.daily/0logwatch
+# FIX_STATIC_PATH:    install -m 0755 logwatch.cron /etc/cron.daily/0logwatch
+# FIX_STATIC_PATH:    printf "Created /etc/cron.daily/0logwatch \n" 
+# FIX_STATIC_PATH: else
+# FIX_STATIC_PATH:    install -m 0744 logwatch.cron $CONFIGDIR/logwatch.cron
+# FIX_STATIC_PATH:    printf "################ README ####################.\n"
+# FIX_STATIC_PATH:    printf "You need to setup your cron job for logwatch.\n"
+# FIX_STATIC_PATH:    printf "A sample script is included see $CONFIGDIR/logwatch.cron. \n"
+# FIX_STATIC_PATH:    printf "2 0 * * * $CONFIGDIR/logwatch.cron >/dev/null 2>&1 \n"
+# FIX_STATIC_PATH: fi
+
+# Create dir for log files and report:
+install -m 0700 -d $BASEDIR/logs
+install -m 0700 -d $BASEDIR/report
+# Just let the user recursively copy /var into $BASEDIR/logs
+# mkdir -p ${BASEDIR}/logs/var/{adm,cron,log,log/mysql,spool,spool/MailScanner/incoming,tmp,run,mail,lib/rpm,spool/up2date}
+
+# Fix other static paths:
+find /tmp/logwatch_portable/ -type f -print0 | xargs -0 -iX sed -i "s|/usr/share/logwatch|/tmp/logwatch_portable|g" 'X'
+find /tmp/logwatch_portable/ -type f -print0 | xargs -0 -iX sed -i "s|/etc/logwatch|/tmp/logwatch_portable/etc|g" 'X'
+find /tmp/logwatch_portable/ -type f -print0 | xargs -0 -iX sed -i "s|/usr/local/etc|/tmp/logwatch_portable/etc|g" 'X'
+find /tmp/logwatch_portable/ -type f -print0 | xargs -0 -iX sed -i "s|/var/cache/logwatch|/tmp/logwatch_portable/tmp|g" 'X'
+find /tmp/logwatch_portable/ -type f -not -name http -print0 | xargs -0 -iX sed -i "s|/var|/tmp/logwatch_portable/logs/var|g" 'X'
+
+# Patch scripts/services/http
+cat > http.diff << EOP
+--- http.orig 2012-03-28 00:00:01.000000000 +0000
++++ http      2012-03-28 00:00:02.000000000 +0000
+@@ -334,6 +334,64 @@
+    'shtml\.exe',
+    'win\.ini',
+    'xxxxxxxxxxxxxxxxxxxxxx',
++   '%20/tmp',
++   '%20/var',
++   '7z%20',
++   'apt-get%20',
++   'cat%20',
++   'cc%20',
++   'cd%20',
++   'crontab%20',
++   'curl%20',
++   'cvs%20',
++   'echo%20',
++   'elinks%20',
++   'emerge%20',
++   'ftp%20',
++   'GET%20',
++   'gcc%20',
++   'gzip%20',
++   'gunzip%20',
++   'HEAD%20',
++   'id%20',
++   'kill%20',
++   'killall%20',
++   'links%20',
++   'ls%20',
++   'lwp-download%20',
++   'lwp-request%20',
++   'lwp-mirror%20',
++   'lwp-rget%20',
++   'lynx%20',
++   'mail%20',
++   'mailx%20',
++   'mkdir%20',
++   'nc%20',
++   'ncftp%20',
++   'netcat%20',
++   'netstat%20',
++   'POST%20',
++   'perl%20',
++   'ps%20',
++   'python%20',
++   'rar%20',
++   'rexec%20',
++   'rm%20',
++   'rpm%20',
++   'ruby%20',
++   'scp%20',
++   'sh%20',
++   'smbclient%20',
++   'ssh%20',
++   'svn%20',
++   'tar%20',
++   'telnet%20',
++   'tftp%20',
++   'wget%20',
++   'uname%20',
++   'wget%20',
++   'whoami%20',
++   'yum%20',
+ );
+ 
+ #
+EOP
+
+cat http.diff | patch -F 3 /tmp/logwatch_portable/scripts/services/http
+
+cat > /tmp/logwatch_portable/scripts/logwatch.sh << EOP
+#!/bin/bash ---
+/tmp/logwatch_portable/scripts/logwatch.pl --detail High --logdir /tmp/logwatch_portable/logs --output file --format text --archives --filename /tmp/logwatch_portable/report/logwatch.log --range All --numeric --debug Med --hostformat split 2>&1 | tee /tmp/logwatch_portable/report/logwatch.tee
+exit 0 
+EOP
+
+echo "Run /tmp/logwatch_portable/scripts/logwatch.sh now."
 
 exit
 # vi: shiftwidth=3 tabstop=3 et

/usr/lib/qt4/examples

ls /usr/lib/qt4/examples      # if there's nothing there
ls /usr/share/qt4/examples    # AND if there is something there
# then...
cd /usr/lib/qt4
sudo ln -s /usr/share/qt4/examples .

added qt4 mc2.def template to build qt4 apps from any file set.
added 'mc2 -create qt4-files' to generate a basic fileset for new *.ui file.
added 'mc2 -run qt4-ui' function to write ui: tag for moc, uic, and qrc files.

"-quiet\0RemoteControl"
// instead of
"-enableRemoteControl"

$> diff a.txt b.txt
20955c20955
< 00052210  65 6e 74 00 2d 65 6e 61  62 6c 65 52 65 6d 6f 74  |ent.-enableRemot|
---
> 00052210  65 6e 74 00 2d 71 75 69  65 74 00 52 65 6d 6f 74  |ent.-quiet.Remot|

int main(int argc, char** argv)
{
  return 0;
}

mc2 -t c++ dummy

OUTNAME = dummy
SRCDIR = .
<...>
LDFLAGS =  $(LIBSLIST) $(LIBSLIST_FULLPATH)

# list of development libs (*.so)
LIBSLIST = \
  -lQtGui \
  -lQtCore \
  -lQtDeclarative \
  -lQtScript \
  -lQtSvg \
  -lQtSql \
  -lQtXmlPatterns \
  -lQtNetwork \
  -lpthread \
  -lQtMultimedia \
  -lstdc++ \
  -lm \
  -lgcc_s \
  -lc \
  -lglib-2.0 \
  -lpng14 \
  -lz \
  -lfreetype \
  -lgobject-2.0 \
  -lSM \
  -lICE \
  -lXi \
  -lXrender \
  -lXrandr \
  -lXfixes \
  -lXcursor \
  -lXinerama \
  -lfontconfig \
  -lXext \
  -lX11 \
  -ldl \
  -lgthread-2.0 \
  -lrt \
  -lasound \
  -lpcre \
  -luuid \
  -lxcb \
  -lXau \
  ###############

# list of non-development libs or where more than one lib
# may exist (*.so.ver) requiring the full path
LIBSLIST_FULLPATH = \
  /lib/libexpat.so.1 \
  ###############

mc2 -init   # or mc2 -update if the -init switch isn't implemented 
            # in your version mc2, it does the same thing
make

void QMetaObject::removeGuard(QObject **ptr)
{
  if (!*ptr) // when the object at ptr is null it exits cleanly 
    return;  // but sometimes it has an object pointer and then 
             // it segfaults.  This occurs when it tries to cleanup 
             // the main app.
  ....
}

#include <QtGui/QApplication>
#include "guitartuner.h"

void dbg(){}

int main(int argc, char *argv[])
{
  static QApplication* a = new QApplication(argc, argv);
  GuitarTuner w;
  w.setOrientation(GuitarTuner::LockPortrait);
  
  #ifdef Q_OS_SYMBIAN
  w.showFullScreen();
  #elif defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6)
  w.showMaximized();
  #else
  w.show();
  #endif
  
  int err = a->exec();
  printf("Looking for segfault -rs\n");
  dbg();
  return err;
}

  // run
  // disable remote control -rs
  // QStringList args(QLatin1String("-enableRemoteControl"));
  QStringList args(QLatin1String("-quiet"));

DAY=$(date +"%m%d%y%H%M%S")
# picfn="pic$DAY.png"
# echo $picfn
wget http://radar.weather.gov/ridge/Thumbs/FWS.png -O fws$DAY.png

for g  in fws*.png
do
echo $g
img2txt -W 80 -f utf8 img2txt -W  80 -H 25 utf8 $g > $g.txt
done

for g  in fws*.txt
do
tput cup 0 0
 cat $g
done

vgdisplay -v

dd if=/dev/zero of=/app/loop bs=1 count=1 seek=10737418240
losetup -f /app/loop
losetup -a

pvcreate /dev/loop0
vgextend vg_echo360 /dev/loop0

lvcreate -s -n echo_snapshot1 /dev/vg_echo360/lv_echo360 -L 9.9G
lvs

mkdir /mnt/snapshot_recovery
mount /dev/vg_echo360/echo_snapshot1 /mnt/snapshot_recovery

lvremove /dev/vg_echo360/echo_snapshot1

pvchange -xn /dev/loop0

vgdisplay -v

vgreduce vg_echo360 /dev/loop0

vgdisplay -v

losetup -a

losetup -d /dev/loop0
rm /app/loop

vgreduce --removemissing vg_echo360

find . -mtime +120 -type f -name '*.h264' -o -mtime +120 -type f -name '*.aac' | tr '\n' ' ' > /tmp/rawfiles

du -shc $(cat /tmp/rawfiles)

find . -mtime +120 -type f -name '*.h264' -exec rm {} \; -o -mtime +120 -type f -name '*.aac' -exec rm {} \;

du -shc $(cat /tmp/rawfiles) 2> /dev/null

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>digital_delay</class>
 <widget class="QWidget" name="digital_delay">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>362</width>
    <height>166</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>MAd sCIeNcE - Digital Delay</string>
  </property>
  <widget class="QPushButton" name="btn_Clock">
   <property name="geometry">
    <rect>
     <x>260</x>
     <y>10</y>
     <width>66</width>
     <height>25</height>
    </rect>
   </property>
   <property name="text">
    <string>Clock</string>
   </property>
  </widget>
  <widget class="QPushButton" name="Quit">
   <property name="geometry">
    <rect>
     <x>260</x>
     <y>120</y>
     <width>75</width>
     <height>26</height>
    </rect>
   </property>
   <property name="text">
    <string>Yow</string>
   </property>
  </widget>
  <widget class="QFrame" name="frame">
   <property name="geometry">
    <rect>
     <x>20</x>
     <y>10</y>
     <width>201</width>
     <height>131</height>
    </rect>
   </property>
   <property name="palette">
    <palette>
     <active>
      <colorrole role="Button">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>96</red>
         <green>0</green>
         <blue>0</blue>
        </color>
       </brush>
      </colorrole>
      <colorrole role="Base">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>255</red>
         <green>255</green>
         <blue>255</blue>
        </color>
       </brush>
      </colorrole>
      <colorrole role="Window">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>0</red>
         <green>0</green>
         <blue>0</blue>
        </color>
       </brush>
      </colorrole>
     </active>
     <inactive>
      <colorrole role="Button">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>96</red>
         <green>0</green>
         <blue>0</blue>
        </color>
       </brush>
      </colorrole>
      <colorrole role="Base">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>255</red>
         <green>255</green>
         <blue>255</blue>
        </color>
       </brush>
      </colorrole>
      <colorrole role="Window">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>0</red>
         <green>0</green>
         <blue>0</blue>
        </color>
       </brush>
      </colorrole>
     </inactive>
     <disabled>
      <colorrole role="Button">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>96</red>
         <green>0</green>
         <blue>0</blue>
        </color>
       </brush>
      </colorrole>
      <colorrole role="Base">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>0</red>
         <green>0</green>
         <blue>0</blue>
        </color>
       </brush>
      </colorrole>
      <colorrole role="Window">
       <brush brushstyle="SolidPattern">
        <color alpha="255">
         <red>0</red>
         <green>0</green>
         <blue>0</blue>
        </color>
       </brush>
      </colorrole>
     </disabled>
    </palette>
   </property>
   <property name="autoFillBackground">
    <bool>true</bool>
   </property>
   <property name="frameShape">
    <enum>QFrame::StyledPanel</enum>
   </property>
   <property name="frameShadow">
    <enum>QFrame::Raised</enum>
   </property>
   <widget class="KLed" name="led_2">
    <property name="geometry">
     <rect>
      <x>70</x>
      <y>70</y>
      <width>25</width>
      <height>25</height>
     </rect>
    </property>
    <property name="state">
     <enum>KLed::Off</enum>
    </property>
   </widget>
   <widget class="KLed" name="led_3">
    <property name="geometry">
     <rect>
      <x>30</x>
      <y>70</y>
      <width>25</width>
      <height>25</height>
     </rect>
    </property>
    <property name="state">
     <enum>KLed::Off</enum>
    </property>
   </widget>
   <widget class="QRadioButton" name="bit_2">
    <property name="geometry">
     <rect>
      <x>73</x>
      <y>23</y>
      <width>25</width>
      <height>21</height>
     </rect>
    </property>
    <property name="text">
     <string/>
    </property>
   </widget>
   <widget class="QRadioButton" name="bit_3">
    <property name="geometry">
     <rect>
      <x>34</x>
      <y>23</y>
      <width>25</width>
      <height>21</height>
     </rect>
    </property>
    <property name="text">
     <string/>
    </property>
   </widget>
   <widget class="KLed" name="led_1">
    <property name="geometry">
     <rect>
      <x>110</x>
      <y>70</y>
      <width>25</width>
      <height>25</height>
     </rect>
    </property>
    <property name="state">
     <enum>KLed::Off</enum>
    </property>
   </widget>
   <widget class="QRadioButton" name="bit_1">
    <property name="geometry">
     <rect>
      <x>114</x>
      <y>23</y>
      <width>25</width>
      <height>21</height>
     </rect>
    </property>
    <property name="text">
     <string/>
    </property>
   </widget>
   <widget class="QRadioButton" name="bit_0">
    <property name="geometry">
     <rect>
      <x>153</x>
      <y>23</y>
      <width>25</width>
      <height>21</height>
     </rect>
    </property>
    <property name="text">
     <string/>
    </property>
   </widget>
   <widget class="KLed" name="led_0">
    <property name="geometry">
     <rect>
      <x>150</x>
      <y>70</y>
      <width>25</width>
      <height>25</height>
     </rect>
    </property>
    <property name="state">
     <enum>KLed::Off</enum>
    </property>
   </widget>
  </widget>
  <widget class="QGroupBox" name="enable_2">
   <property name="geometry">
    <rect>
     <x>250</x>
     <y>40</y>
     <width>91</width>
     <height>61</height>
    </rect>
   </property>
   <property name="font">
    <font>
     <weight>50</weight>
     <bold>false</bold>
    </font>
   </property>
   <property name="title">
    <string>enable</string>
   </property>
   <property name="flat">
    <bool>true</bool>
   </property>
   <property name="checkable">
    <bool>true</bool>
   </property>
   <property name="checked">
    <bool>false</bool>
   </property>
   <widget class="QRadioButton" name="run">
    <property name="geometry">
     <rect>
      <x>30</x>
      <y>30</y>
      <width>50</width>
      <height>19</height>
     </rect>
    </property>
    <property name="text">
     <string>run</string>
    </property>
   </widget>
  </widget>
 </widget>
 <layoutdefault spacing="6" margin="11"/>
 <pixmapfunction>qPixmapFromMimeSource</pixmapfunction>
 <customwidgets>
  <customwidget>
   <class>KLed</class>
   <extends>QWidget</extends>
   <header>kled.h</header>
  </customwidget>
 </customwidgets>
 <includes>
  <include location="local">kled.h</include>
  <include location="local">kled.h</include>
  <include location="local">kled.h</include>
  <include location="local">kled.h</include>
 </includes>
 <resources/>
 <connections>
  <connection>
   <sender>bit_0</sender>
   <signal>released()</signal>
   <receiver>bit_1</receiver>
   <slot>animateClick()</slot>
  </connection>
  <connection>
   <sender>bit_1</sender>
   <signal>released()</signal>
   <receiver>bit_2</receiver>
   <slot>animateClick()</slot>
  </connection>
  <connection>
   <sender>bit_2</sender>
   <signal>released()</signal>
   <receiver>bit_3</receiver>
   <slot>animateClick()</slot>
  </connection>
  <connection>
   <sender>btn_Clock</sender>
   <signal>released()</signal>
   <receiver>bit_0</receiver>
   <slot>animateClick()</slot>
  </connection>
  <connection>
   <sender>run</sender>
   <signal>clicked()</signal>
   <receiver>btn_Clock</receiver>
   <slot>animateClick()</slot>
  </connection>
  <connection>
   <sender>bit_3</sender>
   <signal>released()</signal>
   <receiver>run</receiver>
   <slot>animateClick()</slot>
  </connection>
  <connection>
   <sender>bit_0</sender>
   <signal>toggled(bool)</signal>
   <receiver>led_0</receiver>
   <slot>toggle()</slot>
  </connection>
  <connection>
   <sender>bit_1</sender>
   <signal>toggled(bool)</signal>
   <receiver>led_1</receiver>
   <slot>toggle()</slot>
  </connection>
  <connection>
   <sender>bit_2</sender>
   <signal>toggled(bool)</signal>
   <receiver>led_2</receiver>
   <slot>toggle()</slot>
  </connection>
  <connection>
   <sender>bit_3</sender>
   <signal>toggled(bool)</signal>
   <receiver>led_3</receiver>
   <slot>toggle()</slot>
  </connection>
  <connection>
   <sender>Quit</sender>
   <signal>clicked()</signal>
   <receiver>digital_delay</receiver>
   <slot>close()</slot>
  </connection>
  <connection>
   <sender>Quit</sender>
   <signal>clicked()</signal>
   <receiver>digital_delay</receiver>
   <slot>close()</slot>
  </connection>
 </connections>
</ui>

mc2 -create qt4-files src/digital_delay.ui
mc2 -fetch qt4
# edit mc2.def and change OUTNAME if you like and add -lkdeui
# to the link like so:
LDFLAGS = -lQtGui -lQtCore -lkdeui 
mc2 -u
make clean; make

bool result = g_main_context_iteration(d->mainContext, canWait);

gboolean g_main_context_iteration (GMainContext *context, gboolean may_block)
{
  gboolean retval;
  
  if (!context)
    context = g_main_context_default();
  
  LOCK_CONTEXT (context);
  retval = g_main_context_iterate (context, may_block, TRUE, G_THREAD_SELF);
  UNLOCK_CONTEXT (context);
  
  return retval;
}

Report bugs to <http://bugzilla.gnome.org/enter_bug.cgi?product=glib>.

int Screenshot::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
  _id = QWidget::qt_metacall(_c, _id, _a);
  if (_id < 0)
    return _id;
  if (_c == QMetaObject::InvokeMetaMethod) {
    switch (_id) {
      case 0: newScreenshot(); break;
      case 1: saveScreenshot(); break;
      case 2: shootScreen(); break;
      case 3: updateCheckBox(); break;
      default: ;
    }
    _id -= 4;
  }
  return _id;
}

           Unit 1
Income     5000
Expenses   2000

           Unit 2
Income     45000
Expenses   46000

           Unit 3
Income     18000
Expenses   18000

# Get data from unit files and create .CUT files.
for f in unit?
do
    newfile="$f.CUT"
    cut -c 12-25 $f > $newfile
done

# create tmpfile.
touch cutfile
rm cutfile
touch cutfile

#create Labels for the file.
echo " " > cutitfile
echo Income >> cutitfile
echo Expenses >> cutitfile

# put it all together.
for g  in unit?.CUT
do
   paste --d , cutitfile  $g >> cutfile
   mv cutfile cutitfile
done

# uncomment the next line if you want to use sc
# psc -d , < cutitfile > Units.sc

sc 7.16:  Type '?' for help.
Reading file "Units.sc"
        A       B       C       D        E         F         G         H     
  0            Unit 1  Unit 2  Unit 3
  1   Income     5000   45000   18000
  2  Expenses    2000   46000   18000
  3
  4
  5
  6

#include <QApplication>

#include "screenshot.h"

int main(int argc, char *argv[])
{
  // Certain standard args like --help may be processed here.  If they are, the 
  // function won't return.  -rs
  
  QApplication app(argc, argv); 
  
  // This creates the widget.  It is not explicitly linked to the parent, 
  // class which should be 'app' so we may want to trace this and see how it 
  // gets connected. -rs
  
  Screenshot screenshot;
  
  // This either sets flags or actually fills in variables. (Turns out in QT it
  // does both) -rs
  screenshot.show();
  
  // app.exec() returns 0 if there are no errors.  It runs the main loop. 
  return app.exec();
}

## The output file name not including path
OUTNAME = screenshot

## use default dirs

## What COMPILE should do.
COMPILE = g++ -c                # making no assumption about register width here
CFLAGS = -g3                    # debuggable
INCLUDE = -I/usr/include  -I/usr/include/Qt -I/usr/include/QtGui
# as needed add:
# /usr/include/Qt             /usr/include/QtHelp         /usr/include/QtSvg
# /usr/include/Qt3Support     /usr/include/QtMultimedia   /usr/include/QtTest
# /usr/include/QtCore         /usr/include/QtNetwork      /usr/include/QtUiTools
# /usr/include/QtDBus         /usr/include/QtOpenGL       /usr/include/QtWebKit
# /usr/include/QtDeclarative  /usr/include/QtScript       /usr/include/QtXml
# /usr/include/QtDesigner     /usr/include/QtScriptTools  /usr/include/QtXmlPatterns
# /usr/include/QtGui          /usr/include/QtSql


## What LINK should do.
LINK = g++                      # making no assumption about register width here
LDFLAGS = -lQtGui -lQtCore      # must be symlinks named <name>.so
# as needed add: libQtCore -lQt3Support -lQtDeclarative.so -lQtGui.so -lQtNetwork.so
# -lQtOpenGL.so -lQtSql.so -lQtSvg.so , etc...
# Note, however, that if you list a lib it WILL be considered a dependency and
# the app will abort at runtime if the lib is missing from the user's system 
# even it's not really needed.  Therefor, as a rule, do not list libs that aren't 
# really needed.  An exception might be for MULTI types of mc2 builds, where a 
# shotgun spread of libs is usually ok.

# adjust this path for your own system.  Use 'locate libQtGui.so, for example, and 
# copy that path if you need to.
LIB = -L/usr/lib

################################################################
## User Defined Targets

clean:
@rm -f $(MAIN)
@rm -f $(OBJ)
@rm -f *~ */*~ */*/*~ */*/*/*~

moc: force
cd src && moc screenshot.h > moc_screenshot.cpp

force:

mc2 -update         # create a new makefile after which 'make update' works

# We need to create the metaobject and we'll name it moc_screenshot.cpp
# This only needs to be done once unless the header file changes.
make moc            # create the missing cpp file

# now we can add the new file to the build
make update         # adds the new file
make                # and there you have it.

#!/bin/bash
set +f                  # Enable filename globbing
set -B                  # Enable brace expansion
shopt -s dotglob        # Include names that start with a dot
shopt -s nullglob       # No match expands to an empty string


# Create a safe temporary directory to put temporary files into,
# and make sure it is automatically deleted after this script exits.
# You can use any filename "$WORK/filename" as a temporary file.
# Omit this if you dont need it.
WORK="$(mktemp -d)" || exit $?
trap "rm -rf '$WORK'" EXIT


# Output usage to standard error, then exit.
# Exit status is optional (default 0), first parameter.
#
Usage () {
    exec >&2

    echo ""
    echo "Usage: $0 [-h|--help]"
    echo "       $0 [-t TYPE|--type=TYPE] FILES..."
    echo ""

    exit $[ $1-0 ]
}


# TYPE is stored in this parameter.
# You can also set a default value.
unset Type

# If you want no parameters to yield the usage,
# uncomment the next line:
# [ $# -gt 0 ] || Usage 0

# Parse command line arguments.
#
args=()
while [ $# -gt 0 ]; do

    # No options follow --
    if [ "$1" = "--" ]; then
        shift 1
        args=("${args[@]}" "$@")
        shift $#
        continue
    fi

    # Not an option?
    if [ "${1:0:1}" != "-" ]; then
        args[${#args[@]}]="$1"
        shift 1
        continue
    fi

    # A long option?
    if [ "${1:0:2}" == "--" ]; then

        # Skip the two dashes at start, and consume this one
        option="${1:2}"
        shift 1

        # --option=value or --option value
        value="${option#*=}"
        if [ "$value" = "$option" ]; then
            value="$1"
            valueshift=1
        else
            option="${option%%=*}"
            valueshift=0
        fi
        #
        # If $value is used, then do
        #   shift $valueshift

        # Long options:
        #
        case "$option" in

          help)
            Usage 0
            ;;

          type)
            Type="$value"
            shift $valueshift
            ;;

          *)
            echo "--$option: Unknown option." >&2
            exit 1
            ;;

        esac

    elif [ "$1" = "-" ]; then

        # A single dash is interpreted as "standard input".
        shift 1
        args[${#args[@]}]="/dev/stdin"

    else

        # Short option or multiple short options. Consume.
        options="${1:1}"
        shift 1

        # Handle each short option character separately.
        while [ ${#options} -gt 0 ]; do

            # Short options are handled character-by-character.
            option="${options:0:1}"
            options="${options:1}"

            # Short options:
            #
            case "$option" in

              h)
                Usage 0
                ;;

              t)
                Type="$1"
                shift 1
                ;;

              *)
                echo "-$option: Unknown option." >&2
                exit 1
                ;;

            esac
        done

    fi
done
# Set positional arguments "back".
set -- "${args[@]}"


#
# The actual script starts here.
#

if [ $# -gt 0 ]; then
    printf '%d command line parameters:\n' $#
    printf '\t\047%s\047\n' "$@"
else
    printf 'No command line parameters.\n'
fi

if test -v Type ; then
    printf 'TYPE was specified as \047%s\047.\n' "$Type"
else
    printf 'TYPE was not specified.\n'
fi

// UsR2usr.cpp

#include <stdio.h>        // printf, sprintf, etc.
#include <stdlib.h>       // exit()
#include <unistd.h>       // tons of stuff
#include <malloc.h>       // memory allocation
#include <string.h>       // strings and block comparisons and moves
#include <ctype.h>
#include "version.h"
#include <LQ/slist.h>

void dbg() {
}                // a breakpoint for kdbg.exec

// simplified syntax for comparing and moving str/mem
// case insensitive
#define streq(a, b) (strcasecmp(a, b) == 0)

// case sensitive
#define memeq(buf, str) \
(memcmp(buf, str, strlen(str)) == 0)

// move a string minus terminator
#define memstrcpy(buf, str) \
memcpy(buf, str, strlen(str))

enum {
  FILETYPE_ELF = 101,
  FILETYPE_TEXT,
  // others...
  FILETYPE_BINARY
};

static char errmsg[256];
typedef struct {
  char *buf;
  size_t buflen;
  bool armed_flag;      // = 0;
  bool etc_flag;        // = 0;
  bool elf_only_flag;     // = 0;
  bool pass_filter;
  int filetype;        // elf, text, other binary..
  int scan_number;      // = 0; // true if first file in scan
  const char *filename;
} VARS;

VARS *global_vars;
// #define obj (*global_vars)

VARS *vars_new() {
  VARS *vars = (VARS *) malloc(sizeof(VARS));
  memset(vars, 0, sizeof(VARS));
}

void vars_delete(VARS ** po) {
  // destructor
  if(*po)
    free(*po);
  *po = 0;
}

void obj_setPassFilter(VARS * o);
void obj_setFiletype(VARS * o);

// returns count of replacements proposed
int obj_scanAndReplace(VARS * o);

// returns 0 on success, else fatal
int obj_processFile(VARS * o, const char *filename);


const char *appname;

int usage(int errcode);
int show_version(int errcode);
int do_errmsg(int errcode, const char *msgfmt, const char *errvar);
int reorder_args(int argc, char **argv);

int main(int argc, char **argv) {
  dbg();

  appname = basename(argv[0]);
  int arg_offset = reorder_args(argc, argv);

  if(argc == 1)
    return usage(1);

  if(streq(argv[1], "--help"))
    return usage(0);

  VARS *o = vars_new();

  for(int i = 1; i <= arg_offset; i++) {
    if(streq(argv[i], "--armed"))
      o->armed_flag = 1;
    else if(streq(argv[i], "--etc"))
      o->etc_flag = 1;
    else if(memeq(argv[i], "--elf"))  // --elf | --elf-only
      o->elf_only_flag = 1;
    else if(streq(argv[i], "-v") || streq(argv[i], "--version"))
      return show_version(0);
    else {
      fprintf(stderr, "Unknown switch '%s'\n", argv[i]);
      exit(1);
    }
  }

  const char *dirname = argv[1 + arg_offset];

  // get list of files in dirname
  char tmpbuf[4096];
  char **filelist = slist_new();
  int numfiles;

  sprintf(tmpbuf, "find %s -type f", dirname);
  slist_pipeRead(&filelist, tmpbuf);

  numfiles = slist_count(filelist);

  // tell type of scan
  if(numfiles > 0) {
    printf("\n");
    sprintf(tmpbuf, "Scan type selected = [%s, %s]",
        o->armed_flag ? "ARMED" : "check",
        o->elf_only_flag ? "ELF only" : "all");
    printf("%s\n", tmpbuf);
    for(int i = 0; i < strlen(tmpbuf); i++)
      printf("-");
    printf("\n");
  } else {
    printf("%s: No files!\n", appname);
    return 1;
  }

  for(int i = 0; i < numfiles; i++) {
    const char *filename = filelist[i];
    int fatal = obj_processFile(o, filename);
    if(fatal)
      return 1;

  }
  vars_delete(&o);
  slist_delete(&filelist);
  return 0;
}

int show_version(int errcode) {
  printf("UsR2usr version %s", VERSION);
  return errcode;
}


int do_errmsg(int errcode, const char *msgfmt, const char *errvar) {
  if(errvar == 0)
    errvar = (char *)"";
  sprintf(errmsg, msgfmt, errvar);
  perror(errmsg);
  return errcode;
}


int usage(int errcode) {
#include "usage_str.dat"    // has one %s format for appname

  // test for presence of kdialog for the usage message
  char syscmd[4096];
  sprintf(syscmd, "kdialog -v >/dev/null 2>&1");
  int err = system(syscmd);

  if(err)
    printf(usage_str, appname);
  else {
    char msg[4096];
    sprintf(msg, usage_str, appname);
    sprintf(syscmd, "kdialog -msgbox \"%s\" -title \"Usage     \"",
        msg);
    err = system(syscmd);

    if(err)
      printf(usage_str, appname);
  }
  return errcode;
}

int reorder_args(int argc, char **argv) {
  // make literal copy of argv in temporary list
  char **tmp_args = (char **)malloc(argc * sizeof(char **));
  memcpy(tmp_args, argv, argc * sizeof(char **));

  int cnt = 1;        // current copy back number, app path is at [0] still
  int nswitches = 0;      // the value to return

  // copy switches back first
  for(int i = 1; i < argc; i++)
    if(tmp_args[i][0] == '-')
      argv[cnt++] = tmp_args[i];

  nswitches = cnt - 1;    // number of actual switches

  // copy non-switches back next
  for(int i = 1; i < argc; i++)
    if(tmp_args[i][0] != '-')
      argv[cnt++] = tmp_args[i];

  free(tmp_args);
  return nswitches;
}


void obj_setFiletype(VARS * o) {
  do {
    if(memeq(o->buf + 1, "ELF"))
      printf("");
    if(memeq(o->buf, "\177ELF"))
      printf("");
    if(o->buflen >= 4) {
      if(memeq(o->buf, "\177ELF")) {
        o->filetype = FILETYPE_ELF;
        break;
      }
    }
    int testlen = 32;
    int ascii_flag = 1;
    if(o->buflen < testlen)
      testlen = o->buflen;
    for(int i = 0; i < testlen; i++) {
      if(!isascii(o->buf[i])) {
        ascii_flag = 0;
        break;
      }
    }
    if(ascii_flag && (testlen > 0)) {
      o->filetype = FILETYPE_TEXT;
      break;
    }
    // other checks..
    // default
    o->filetype = FILETYPE_BINARY;
  } while(0);
}

// returns 0 on success, else fatal
int obj_processFile(VARS * o, const char *filename) {
  o->filename = filename;
  FILE *fp = fopen(filename, "rb+");
  if(!fp)
    return do_errmsg(1, "Can't open file '%s'", o->filename);

  fseek(fp, 0, SEEK_END);
  o->buflen = ftell(fp);
  fseek(fp, 0, SEEK_SET);

  o->buf = (char *)malloc(o->buflen);
  if(!o->buf)
    return do_errmsg(1, "Can't allocate memory", 0);

  fread(o->buf, 1, o->buflen, fp);

  // check file type and set accessible flag to indicate 
  // whether this is selected to be modified or not.
  obj_setFiletype(o);
  obj_setPassFilter(o);

  // scan for text /UsR or UsR/ and replace with 
  // /usr or usr/
  // save file only if not just checking and
  // filetype matches user selection
  if(o->pass_filter) {
    int count = obj_scanAndReplace(o);
    if(count < 0)
      return do_errmsg(1, "Can't scan file '%s'", o->filename);

    int nbytes;       // for debugger
    if(o->armed_flag) {
      //fseek(fp, 0, SEEK_SET);
      fseek(fp, 0, SEEK_SET);
      nbytes = fwrite(o->buf, 1, o->buflen, fp);
    }
  }
  fclose(fp);
  free(o->buf);
  return 0;
}

void obj_dumpContext(VARS * o, char *bufptr, bool change) {
  if(!o->scan_number)
    printf("\n");

  o->scan_number += 1;

  // hex dump 16 bytes of context

  unsigned char *cptr;
  int dumplen = 16;

  cptr = (unsigned char *)bufptr - 6;
  if((char *)cptr < o->buf)
    cptr = (unsigned char *)o->buf;

  char *bufend = o->buf + o->buflen;
  if(cptr > (unsigned char *)bufend)
    dumplen = (unsigned char *)bufend - cptr;

  if(!change)
    printf("NOT ");

  printf("To change in '%s' at offset 0x%0X:\n", o->filename,
       bufptr - o->buf);
  for(int i = 0; i < dumplen; i++) {
    printf("%0.2X ", cptr[i]);
  }
  printf(" %s\"...", change ? "CHG: \x1b[1;31m" : "---- \x1b[37m");
  for(int i = 0; i < dumplen; i++) {
    if(isprint(cptr[i]))
      printf("%c", cptr[i]);
    else
      printf(".");
  }
  printf("...\"\x1b[0;30m\n\n");
}


void obj_showStatus(VARS * o, char *bufptr, bool change) {
  if(o->armed_flag) {
    printf("Found 'UsR' in '%s' at 0x%X %s\n", o->filename,
         bufptr - o->buf, change ? "(CONVERTED)" : "(No Change)");
  } else {
    obj_dumpContext(o, bufptr, change);
  }
}


// returns number of changes made.
int obj_scanAndReplace(VARS * o) {
  int count = 0;
  char *ptr = o->buf;
  char *bufend = ptr + o->buflen;

  int found;
  found = 0;
  while(ptr < bufend) {
    found = 0;        // flag found in context
    const char *replstr = 0;  // flag and string to skip
    do {
      // UsR in correct context
      // check for any all at once
      if(strchr("/U\'\"", *ptr)) {
        if(*ptr == 'U') {
          static const char *this_str = "UsR/";
          if(memeq(ptr, this_str)) {
            found++;
            replstr = "usr/";
          } else if(memeq(ptr, "UsR")) {
            replstr = "UsR";
          }
        } else if(*ptr == '/') {
          static const char *this_str = "/UsR";
          if(memeq(ptr, this_str)) {
            found++;
            replstr = "/usr";
          }
        } else if(*ptr == '\'') {
          static const char *this_str = "\'UsR\'";
          if(memeq(ptr, this_str)) {
            found++;
            replstr = "\'usr\'";
          }
        } else if(*ptr == '\"') {
          static const char *this_str = "\"UsR\"";
          if(memeq(ptr, this_str)) {
            found++;
            replstr = "\"usr\"";
          }
        }
      }          // if(strchr

      //  found & show copy count steps
      //        | (replstr & steps | 1step)
      if(found) {
        obj_showStatus(o, ptr, true); // and show 'change'
        memstrcpy(ptr, replstr);
        ptr += strlen(replstr);
        count++;
      } else if(o->etc_flag) {
        // same thing but for EtC to etc
        if(strchr("/E\'\"", *ptr)) {
          if(*ptr == 'E') {
            static const char *this_str = "EtC/";
            if(memeq(ptr, this_str)) {
              found++;
              replstr = "etc/";
            } else if(memeq(ptr, "EtC")) {
              replstr = "etc";
            }
          } else if(*ptr == '/') {
            static const char *this_str = "/EtC";
            if(memeq(ptr, this_str)) {
              found++;
              replstr = "/etc";
            }
          } else if(*ptr == '\'') {
            static const char *this_str = "\'EtC\'";
            if(memeq(ptr, this_str)) {
              found++;
              replstr = "\'etc\'";
            }
          } else if(*ptr == '\"') {
            static const char *this_str = "\"EtC\"";
            if(memeq(ptr, this_str)) {
              found++;
              replstr = "\"etc\"";
            }
          }
        }        // if(strchr
        if(found) {
          obj_showStatus(o, ptr, true); // and show 'change'
          memstrcpy(ptr, replstr);
          ptr += strlen(replstr);
          count++;
        }
      }

      if(!found)      // not found
      {
        if(replstr) {
          obj_showStatus(o, ptr, false);  // show 'no change'
          ptr += strlen(replstr);
        } else
          ptr++;    // step 1
      }

    } while(0);       // do
  }              // while(bufptr...)
  return count;
}

void obj_setPassFilter(VARS * o) {
  // if filetype = elf or --all then true else false
  o->pass_filter = false;
  if(o->filetype == FILETYPE_ELF)
    o->pass_filter = true;
  else if(!o->elf_only_flag)
    o->pass_filter = true;
}

// created 
// #define VERSION "1.0"

// added '--check' option, tweeked help and more options and added version printout
// #define VERSION "1.1"

// minor changes.
// #define VERSION "1.2"

// Feb 2, 2012
// added  gui-based help if supported, made vars an 'object' for better
// debug view, etc.
// #define VERSION "1.3.0"

// Feb 9, 2012
// added /EtC to conversions for stuff like gtk+
// added warn if info/dir is present in share/info directory.
// #define VERSION "1.4.0"

// Apr 15, 2012 
// converted to use libLQ slist funcs
#define VERSION "1.5.0"

/* usage_str.txt converted with txt2cstr */
const char *usage_str =
  "Usage: %s [switches] dir\n"
  "\n"
  "  For use with 'configure' based installations to install into\n"
  "  prefix=/UsR and then converted to a binary installation into the\n"
  "  real /usr folder.\n"
  "\n"
  "  How: \n"
  "  This application scans and replaces the path UsR found in elf\n"
  "  binaries and other files allowing installation into /UsR and\n"
  "  then changing the path to a real system directory.\n"
  "\n"
  "  Several checks are performed on the text before committing to\n"
  "  a change and it can be first (without the --armed switch( which \n"
  "  you can verify in a hex viewers before creating the binary \n"
  "  installation.  \n"
  "\n"
  "  Is it fool proof?  Pretty close, but some caution is advised.\n"
  "  Keeping a backup of folders and doing a test installation on\n"
  "  your own system to see what changes is just good sense and as\n"
  "  usual, no warantees at this end.  Just best wishes and a bit\n"
  "  of optimism considering the alternatives which you might want\n"
  "  to check out if there are any.\n"
  "\n"
  "  Switches:\n"
  "    [none]          - prints file names and offsets where /UsR is\n"
  "                      found and set to be changed in an armed run.\n"
  "                      Shows a bit of context (hex/ascii dump) and\n"
  "                      can also be used to view in a hex editor.\n"
  "\n"
  "                      Includes text files and other other binaries\n"
  "                      in the scan in addition to elf binaries (the\n"
  "                      default).\n"
  "\n"
  "    --etc             Adds /EtC to /etc conversion for installations \n"
  "                      that need --infodir=/EtC to keep them from \n"
  "                      clobbering installed files.\n"
  "\n"
  "    --armed         - commit to changes reported in dry run (default).\n"
  "\n"
  "    --elf | --elf-only\n"
  "                    - Only change rpaths and other occurrances of \n"
  "                      UsR in a path context in elf binaries (libs\n"
  "                      and executables).\n"
  "\n"
  "  Tips: \n"
  "    * After intalling into prefix=/UsR, tar up the /UsR directory\n"
  "    where it is before moving the files to where you will build\n"
  "    your package to avoid broken links and missing files, etc.\n"
  "\n"
  "    * If after running with no switches and none of the non-elf files\n"
  "      need to be modified, you can add the '--elf' switch for the \n"
  "      armed run.\n"
  "\n"
  "    * For use as a non-root user, any directory tree is assumed to \n"
  "      have come from and is intended to be installed at root.  You \n"
  "      may run this before or after having moved the files.  Don't\n"
  "      run it in the source though. :-)\n"
  "\n"
  "  Note: The /UsR (prefix) folder you install into using the initial\n"
  "  compilation and installation must be located at the root of the\n"
  "  file system.  The number of letters in the path is critical to\n"
  "  this application's ability to accurately modify 'rpath' and other\n"
  "  text after you have installed into the /UsR dummy directory.\n"
  "\n"
  "    Copyright (C) 2012, Rainbow Sally\n"
  "\n" "    Released under the GPL license.\n" "\n";

uncmake -set ; ls /usr/bin/uncmake.*
uncmake -reset ; ls /usr/bin/uncmake.*

This is a precompiled binary installer/uninstaller using make.

It installs 'uncmake' and 'uncmakefile' utilities for demystifying
cmake and other opaque make system builds.

To install requires root permissions. It installs all the files 
into /usr/bin, where we presume gcc, g++, and ld are also.  The
files TREE is an image of what gets installed minus the PREFIX
defined in the Makefile.

To install, as superuser type 'make install'.

To uninstall, as superuser type 'make uninstall'.


------------------------------------------------------------------

Uncmake -set and -reset switch between uncmake mode and normal mode
for dumping cmake commands to a file initially named uncmake.txt in
the folder where you execute the 'cmake' command.

It requires root permissions in order to switch states.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       This is a DANGEROUS but very useful application
               when used with a little caution
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


HOW IT WORKS:

It will change the names of gcc, g++ and ld depending on the 
cmake.state (which is a file in /usr/bin that it creates) so that 
normal gcc, g++, and ld functions can be preempted by the uncmake 
utility when it is set.

Unless you update* while in cmake mode, the original files will be 
named /usr/bin/cmake.<name>.orig.  All of the files involved have
the "cmake." prefix.

-----------
* There is another potential problem besides updating while uncmake 
is -set as well.  See "NOTE" below.


DANGER:

What makes it dangerous is that uncmake may be in the wrong state 
if there's a power outage, or if you reboot while uncmake-ing.

It should be possible to 'uncmake -reset' after booting back up, but 
the output file will be corrupted by anthing that uses gcc, g++ or 
ld behind the scenes during the boot process.

uncmake doesn't depend on cmake.  It works with the files named above.

And things could get even worse if you upgrade your gcc, g++, or ld 
while uncmake-ing.  There's a good chance you'll have to reinstall 
them if you ever 'uncmake -reset' after this.  If it's already 
-reset when you upgrade there should be no problem since the files 
will all be restored to their original 'state' and cmake.state (the 
state flag file) will have been removed.

The best thing to do if this happens is to uninstall uncmake to 
remove junk files including 'uncmake.state' and reinstall it.  No 
guarantees.  That's untested but should probably work.

Gcc, g++, and ld are the only files affected.  You might want to back 
them up (whether they are symlinks or regular files) as an extra 
measure of safety.

NOTE that in addition to the above possible gotcha's some other 
utilities do the same thing to gcc, g++, and ld and these do not 
play well together.  For example, 'checkinstall' may cause problems 
with uncmake due to unsynchronized changing of these three critical 
files.  (This is unconfirmed but at one time, checkinstall backed up 
some pretty strange files shortly before a reinstall of gcc, g++, and 
ld became necessary.)

And while the scenarios described such as power outages and updating 
are fairly rare, this kind of issue with 'checkinstall' or other
similar apps could happen just as a matter of not knowing whose the 
boss in these situations at any time when both are working at the 
same time.

And one more issue to look out for is that ALL gcc, g++ and ld 
commands will get copied to the uncmake.txt file while uncmake 
is -set.  Even if another user executes commands that invoke these 
applications.  If it's a large file it could be quite time consuming 
to sift through and remove the unwanted portions of the dump.

Best used on a single user system.


USEFUL:

What makes this useful is that we can see the exact commands cmake 
and most other make systems are running.

And with uncmakefile (included in this package) the output file can 
be translated into convenient sub-parcels of make commands that can 
be imported into a makefile in order to work with just one or a small 
handfull of the files you normally can't get at even if you could 
find them nevermind edit, debug, or test.

For example, did you know that kdesu is created by simply linking 
kwrapper.o with the output name kdesu?  That is not at all obvious 
but we can see this in an uncmake dump file.  Once we know this we 
can see that kwrapper takes the name from argv[0] and prefixes that 
name with 'lib' and does the call.  Pretty nifty trick.

FUN:

There are some test<N>.in files in the uncmakefile-sources tarball if 
you want to see what it does.  

And there's a copy of the executable in the TREE folder you can copy 
for testing before committing to installation.

Uncmakefile does NOT require root permissions and is quite safe to play 
with.  :-)