+
+ if ( env )
+ {
+ wxString name,
+ value;
+ while ( *env )
+ {
+ const wxString var(*env);
+
+ name = var.BeforeFirst(wxS('='), &value);
+
+ (*map)[name] = value;
+
+ env++;
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+// ----------------------------------------------------------------------------
+// wxExecute
+// ----------------------------------------------------------------------------
+
+// wxDoExecuteWithCapture() helper: reads an entire stream into one array if
+// the stream is non-NULL (it doesn't do anything if it's NULL).
+//
+// returns true if ok, false if error
+#if wxUSE_STREAMS
+static bool ReadAll(wxInputStream *is, wxArrayString& output)
+{
+ if ( !is )
+ return true;
+
+ // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
+ is->Reset();
+
+ wxTextInputStream tis(*is);
+
+ for ( ;; )
+ {
+ wxString line = tis.ReadLine();
+
+ // check for EOF before other errors as it's not really an error
+ if ( is->Eof() )
+ {
+ // add the last, possibly incomplete, line
+ if ( !line.empty() )
+ output.Add(line);
+ break;
+ }
+
+ // any other error is fatal
+ if ( !*is )
+ return false;
+
+ output.Add(line);
+ }
+
+ return true;
+}
+#endif // wxUSE_STREAMS
+
+// this is a private function because it hasn't a clean interface: the first
+// array is passed by reference, the second by pointer - instead we have 2
+// public versions of wxExecute() below
+static long wxDoExecuteWithCapture(const wxString& command,
+ wxArrayString& output,
+ wxArrayString* error,
+ int flags,
+ const wxExecuteEnv *env)
+{
+ // create a wxProcess which will capture the output
+ wxProcess *process = new wxProcess;
+ process->Redirect();
+
+ long rc = wxExecute(command, wxEXEC_SYNC | flags, process, env);
+
+#if wxUSE_STREAMS
+ // Notice that while -1 indicates an error exit code for us, a program
+ // exiting with this code could still have written something to its stdout
+ // and, especially, stderr, so we still need to read from them.
+ if ( !ReadAll(process->GetInputStream(), output) )
+ rc = -1;
+
+ if ( error )
+ {
+ if ( !ReadAll(process->GetErrorStream(), *error) )
+ rc = -1;
+ }
+#else
+ wxUnusedVar(output);
+ wxUnusedVar(error);
+#endif // wxUSE_STREAMS/!wxUSE_STREAMS
+
+ delete process;
+
+ return rc;
+}
+
+long wxExecute(const wxString& command, wxArrayString& output, int flags,
+ const wxExecuteEnv *env)
+{
+ return wxDoExecuteWithCapture(command, output, NULL, flags, env);
+}
+
+long wxExecute(const wxString& command,
+ wxArrayString& output,
+ wxArrayString& error,
+ int flags,
+ const wxExecuteEnv *env)
+{
+ return wxDoExecuteWithCapture(command, output, &error, flags, env);
+}
+
+// ----------------------------------------------------------------------------
+// Id functions
+// ----------------------------------------------------------------------------
+
+// Id generation
+static long wxCurrentId = 100;
+
+long wxNewId()
+{
+ // skip the part of IDs space that contains hard-coded values:
+ if (wxCurrentId == wxID_LOWEST)
+ wxCurrentId = wxID_HIGHEST + 1;
+
+ return wxCurrentId++;
+}
+
+long
+wxGetCurrentId(void) { return wxCurrentId; }
+
+void
+wxRegisterId (long id)
+{
+ if (id >= wxCurrentId)
+ wxCurrentId = id + 1;
+}
+
+// ----------------------------------------------------------------------------
+// wxQsort, adapted by RR to allow user_data
+// ----------------------------------------------------------------------------
+
+/* This file is part of the GNU C Library.
+ Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
+
+ Douglas Schmidt kindly gave permission to relicence the
+ code under the wxWindows licence:
+
+From: "Douglas C. Schmidt" <schmidt@dre.vanderbilt.edu>
+To: Robert Roebling <robert.roebling@uni-ulm.de>
+Subject: Re: qsort licence
+Date: Mon, 23 Jul 2007 03:44:25 -0500
+Sender: schmidt@dre.vanderbilt.edu
+Message-Id: <20070723084426.64F511000A8@tango.dre.vanderbilt.edu>
+
+Hi Robert,
+
+> [...] I'm asking if you'd be willing to relicence your code
+> under the wxWindows licence. [...]
+
+That's fine with me [...]
+
+Thanks,
+
+ Doug */
+
+
+/* Byte-wise swap two items of size SIZE. */
+#define SWAP(a, b, size) \
+ do \
+ { \
+ register size_t __size = (size); \
+ register char *__a = (a), *__b = (b); \
+ do \
+ { \
+ char __tmp = *__a; \
+ *__a++ = *__b; \
+ *__b++ = __tmp; \
+ } while (--__size > 0); \
+ } while (0)
+
+/* Discontinue quicksort algorithm when partition gets below this size.
+ This particular magic number was chosen to work best on a Sun 4/260. */
+#define MAX_THRESH 4
+
+/* Stack node declarations used to store unfulfilled partition obligations. */
+typedef struct
+ {
+ char *lo;
+ char *hi;
+ } stack_node;
+
+/* The next 4 #defines implement a very fast in-line stack abstraction. */
+#define STACK_SIZE (8 * sizeof(unsigned long int))
+#define PUSH(low, high) ((void) ((top->lo = (low)), (top->hi = (high)), ++top))
+#define POP(low, high) ((void) (--top, (low = top->lo), (high = top->hi)))
+#define STACK_NOT_EMPTY (stack < top)
+
+
+/* Order size using quicksort. This implementation incorporates
+ four optimizations discussed in Sedgewick:
+
+ 1. Non-recursive, using an explicit stack of pointer that store the
+ next array partition to sort. To save time, this maximum amount
+ of space required to store an array of MAX_INT is allocated on the
+ stack. Assuming a 32-bit integer, this needs only 32 *
+ sizeof(stack_node) == 136 bits. Pretty cheap, actually.
+
+ 2. Chose the pivot element using a median-of-three decision tree.
+ This reduces the probability of selecting a bad pivot value and
+ eliminates certain extraneous comparisons.
+
+ 3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving
+ insertion sort to order the MAX_THRESH items within each partition.
+ This is a big win, since insertion sort is faster for small, mostly
+ sorted array segments.
+
+ 4. The larger of the two sub-partitions is always pushed onto the
+ stack first, with the algorithm then concentrating on the
+ smaller partition. This *guarantees* no more than log (n)
+ stack size is needed (actually O(1) in this case)! */
+
+void wxQsort(void* pbase, size_t total_elems,
+ size_t size, wxSortCallback cmp, const void* user_data)
+{
+ register char *base_ptr = (char *) pbase;
+ const size_t max_thresh = MAX_THRESH * size;
+
+ if (total_elems == 0)
+ /* Avoid lossage with unsigned arithmetic below. */
+ return;
+
+ if (total_elems > MAX_THRESH)
+ {
+ char *lo = base_ptr;
+ char *hi = &lo[size * (total_elems - 1)];
+ stack_node stack[STACK_SIZE];
+ stack_node *top = stack;
+
+ PUSH (NULL, NULL);
+
+ while (STACK_NOT_EMPTY)
+ {
+ char *left_ptr;
+ char *right_ptr;
+
+ /* Select median value from among LO, MID, and HI. Rearrange
+ LO and HI so the three values are sorted. This lowers the
+ probability of picking a pathological pivot value and
+ skips a comparison for both the LEFT_PTR and RIGHT_PTR. */
+
+ char *mid = lo + size * ((hi - lo) / size >> 1);
+
+ if ((*cmp) ((void *) mid, (void *) lo, user_data) < 0)
+ SWAP (mid, lo, size);
+ if ((*cmp) ((void *) hi, (void *) mid, user_data) < 0)
+ SWAP (mid, hi, size);
+ else
+ goto jump_over;
+ if ((*cmp) ((void *) mid, (void *) lo, user_data) < 0)
+ SWAP (mid, lo, size);
+ jump_over:;
+ left_ptr = lo + size;
+ right_ptr = hi - size;
+
+ /* Here's the famous ``collapse the walls'' section of quicksort.
+ Gotta like those tight inner loops! They are the main reason
+ that this algorithm runs much faster than others. */
+ do
+ {
+ while ((*cmp) ((void *) left_ptr, (void *) mid, user_data) < 0)
+ left_ptr += size;
+
+ while ((*cmp) ((void *) mid, (void *) right_ptr, user_data) < 0)
+ right_ptr -= size;
+
+ if (left_ptr < right_ptr)
+ {
+ SWAP (left_ptr, right_ptr, size);
+ if (mid == left_ptr)
+ mid = right_ptr;
+ else if (mid == right_ptr)
+ mid = left_ptr;
+ left_ptr += size;
+ right_ptr -= size;
+ }
+ else if (left_ptr == right_ptr)
+ {
+ left_ptr += size;
+ right_ptr -= size;
+ break;
+ }
+ }
+ while (left_ptr <= right_ptr);
+
+ /* Set up pointers for next iteration. First determine whether
+ left and right partitions are below the threshold size. If so,
+ ignore one or both. Otherwise, push the larger partition's
+ bounds on the stack and continue sorting the smaller one. */
+
+ if ((size_t) (right_ptr - lo) <= max_thresh)
+ {
+ if ((size_t) (hi - left_ptr) <= max_thresh)
+ /* Ignore both small partitions. */
+ POP (lo, hi);
+ else
+ /* Ignore small left partition. */
+ lo = left_ptr;
projects / wxWidgets.git / blobdiff