-
What are "Windows (Embedded) CE", "Windows Mobile", "Handheld PC", "Pocket PC",
"SmartPhone" and "Portable Media Center"?
See
Wikipedia
articles about the
Windows CE
and the
Windows Mobile.
See the
History & Overview of Windows CE
and the
Determining the Windows CE / H/PC version
from the
HPC:Factor CESD,
the
Windows CE / Windows Mobile Versions
table from the
Pocket PC FAQ,
and the
Learn Windows Mobile
from the
Windows Mobile Developer Center.
In practice, all this means that, different WinCE driven devices come with
different sets of implemented functions in the system provided default
DLLs, and even with partially different sets of system provided default DLLs.
This in turn means that, a utility (or a DLL), which runs on one variation of WinCE,
may refuse to start on another one (even when their kernel versions match), just because
some required functions are missing in some system DLLs, or even some required system DLLs are missing at all.
Note also that, while compiling your source code, you may need to
define the "_WIN32_IE" and the "_WIN32_WCE" macros
,
in order to tell the compiler which version of WinCE you're using.
Table of Contents
-
How can I transfer files between my PC and my WinCE device?
Several possibilities exist.
-
If you use PC Windows (x86/x64), you may need to use the
"standard" native tool provided by the system.
WE WILL ALWAYS REFERENCE TO IT AS TO THE
ActiveSync
(USB, Infrared, Serial, Bluetooth, WiFi/LAN/Dial-up TCP/IP - support depends on the version),
while in fact ...
-
On Windows XP SP2 and earlier, you need the "real"
ActiveSync.
If you want to connect to a WinCE 6.0 based device, you will definitely need the
ActiveSync 4.5, or newer
(WinCE 3.0 and newer supported).
On the other hand, starting with this release, Microsoft Office
Outlook 2000 is no longer supported (you need Outlook 2003 or newer).
Hence, if your device is WinCE 5.0 based, you can use the
ActiveSync 4.2
(WinCE 3.0 and newer supported, see also
here).
For yet older WinCE based devices, try the
ActiveSync 3.8
(from WinCE 2.0 to WinCE 4.2.1, maybe also WinCE 5.0).
Getting this really big s..t working may often be very, if not
"extremely", difficult.
The best idea, which solves all these problems (and many, many, many more), is
to delete PC Windows and install Linux.
If you, however, still insist on running PC Windows, some advices are
here,
here,
here,
here,
here,
here,
here,
here,
here,
and here.
See also the
Handheld PC Desktop Synchronisation Software
article from the
HPC:Factor CESD,
and the
Pocket PC ActiveSync FAQ Wiki.
-
On Windows Vista (and newer), you need the "new tool" called
Windows Mobile Device Center
(WinCE 4.2 based devices and newer supported).
Problems? Install Linux! Otherwise, see
here,
here,
and here.
Note, on top of these tools, you can also use the
Xda RAPI Utilities.
-
If you use Linux
(or another UNIX like system with USB, Bluetooth, WiFi/LAN), see the
SynCE
and the
OpenSync
projects, for example (note: many contemporary distributions come
with such packages built-in, i.e. ready to use). And, if you (accidentally) do not use Linux (yet), think it through!
-
If your WinCE device has any
flash memory card
reader (SD, CF, ...), you can use these cards.
-
If your WinCE device has any Internet connectivity (Ethernet, Wi-Fi, or Bluetooth), you can use it.
Table of Contents
-
Can I debug/test my DLL/EXE entirely on the PC itself (without any risk to make any harm to my WinCE device)?
If you use a contemporary PC Windows (x86/x64) system, then you can
use the free
Microsoft Device Emulator 2.0 -- Standalone Release.
-
It runs code compiled for ARM processors. In most cases, you can run the same binaries on the emulator as you do on the device.
-
You can connect a runnning Device Emulator to a directory on your PC as if the directory were a drive mounted on the Device Emulator. In the file system for the Device Emulator, the connected directory appears at the root level as Storage Card (you can connect the Device Emulator to only one directory, with all its subdirectories, at a time).
-
It supports synchronizing with
ActiveSync.
This feature allows you to debug applications that are syncing, or be able to use real synchronized data from within the Device Emulator.
Use the Device Emulator Manager (DEM) to start, connect to, and manage Device Emulator instances on your PC. Using the DEM menu commands, you can connect to the emulator, cradle and uncradle it, shut it down, reset it, bring it to the front, clear saved states, refresh images, and perform other tasks.
When a device is cradled, it can communicate using ActiveSync (synchronizing contents of email, calendar, application installations, and so on). The Device Emulator by itself has no equivalent functionality and cannot work with ActiveSync unless it is cradled. A common scenario is to launch the Device Emulator, cradle it using the DEM, and then establish an ActiveSync (set "File -> Connection Settings... -> Allow connections to one of the following: DMA") partnership with it.
In order to use it, you just need to:
-
(well, if you haven't done it yet, then download and install an appropriate, for
your PC Windows system release, version of the free
ActiveSync software)
-
download and install the free
Virtual PC 2007,
-
download and install the free
Microsoft Device Emulator 2.0 -- Standalone Release,
-
download and install the free ARM CPU Emulator Images (you need at least one, you can
install as many of them as you like):
The installation will create shortcuts on your start menu from where you can launch the various configurations of the Windows Mobile 5.0/6 MSFP (ARM CPU). You will also see a shortcut for the Device Emulator Manager (DEM) using which you can launch any of the installed images.
Note again that, you do NOT need any non-free tools (in particular, you do NOT need the
Microsoft Visual Studio,
for example).
For the time being, I do not know if this software can be used on
Linux
with the Wine), sorry.
Table of Contents
-
I hate to use the command-line driven "gdb"! Doesn't there exist any debugger with a graphical front-end?
Well, you can use the free
GNU Data Display Debugger (DDD).
It's a graphical front-end for several command-line debuggers, including the
gdb.
Besides "usual" front-end features, such as viewing source texts,
DDD
has become famous through its interactive graphical data display,
where data structures are displayed as graphs.
When invoking
DDD,
you simply need to specify the name under which the inferior debugger is to be invoked:
-
ddd --debugger "arm-wince-[cegcc/mingw32ce]-gdb" MyProgram.exe
Note however, from time to time, you will still need to interact with the
gdb, via its command-line console window
(integrated in DDD).
For more informations see the
DDD Manual.
See also this answer, if you're debugging a GUI application.
Table of Contents
-
I get "Unable to start remote stub '\gdb\wince-stub.exe'. Windows CE error 126." when I try to debug MyProgram with the "arm-wince-cegcc-gdb".
The arm-wince-cegcc compiled binaries (including the "arm-wince-cegcc-stub.exe") require at least the "cegcc.dll" to be present on your WinCE device.
You can copy
the "/opt/cegcc/arm-wince-cegcc/lib/device/cegcc.dll" to the "\gdb" subdirectory, or to the "\Windows" subdirectory, or to any subdirectory that is present in the registry subkey "SystemPath", in the "HKEY_LOCAL_MACHINE\Loader" registry entry, on your WinCE device (any change to the "SystemPath" subkey itself does not take effect until the WinCE device is reset).
You should not get this error when you try to use the "arm-wince-mingw32ce-gdb" (arm-wince-mingw32ce binaries NEVER need the "cegcc.dll", so also the "arm-wince-mingw32ce-stub.exe" does not need it), unless you are trying to debug an arm-wince-cegcc binary (the arm-wince-cegcc generated binary DLL/EXE will need it, of course), but in this case you should switch back to the "arm-wince-cegcc-gdb".
See Beware! need to install CeGCC DLL's first, and
How can I find/trace any missing "DLL imports"?.
Note, the magic error "126", hexadecimal "0x7e", known also as "ERROR_MOD_NOT_FOUND" and "The specified module could not be found", is defined in the "winerror.h".
Table of Contents
-
I get "Error creating process \gdb\MyProgram.exe, (error 126)." when I try to debug MyProgram.
Your DLL/EXE could not be loaded/started.
This usually means that, one (or more) DLLs, required by your DLL/EXE, are missing on your WinCE device
(or, if all DLLs exist, one or more functions, which your program needs, are missing in some of them).
You need to copy
the required DLLs to the "\gdb" subdirectory, or to the "\Windows" subdirectory, or to any subdirectory that is present in the registry subkey "SystemPath", in the "HKEY_LOCAL_MACHINE\Loader" registry entry, on your WinCE device (any change to the "SystemPath" subkey itself does not take effect until the WinCE device is reset).
See Beware! need to install CeGCC DLL's first,
I get "GetLastError returns c1" when I try to use my DLL/EXE.,
and
How can I find/trace any missing "DLL imports"?.
Note, the magic error "126", hexadecimal "0x7e", known also as "ERROR_MOD_NOT_FOUND" and "The specified module could not be found", is defined in the "winerror.h".
Table of Contents
-
I get "Error while mapping shared library sections: coredll.dll: No such file or directory." when I try to debug MyProgram.
So what? Does it really bother you THAT much? Haven't you got any more serious problems in your life?
Table of Contents
-
I get "No line number known for MyProcedure", or "(no debugging symbols found)", or "No symbol table is loaded. Use the 'file' command.", when I try to debug MyProgram.
-
The error "No line number known for MyProcedure" means that the debugging symbols are not present in your binary DLL/EXE. It seems, you've forgotten to use the "-g" compiler flag (when compiling your source code).
-
The errors "(no debugging symbols found)" and "No symbol table is loaded. Use the 'file' command." mean that symbol table and relocation information have been removed from your binary DLL/EXE. Either you've been using the "-s" compiler flag (when compiling your source code), or you've run "arm-wince-[cegcc/mingw32ce]-strip MyProgram.[dll/exe]" later.
The best idea is to recompile your source code (with "-g" and without "-s" compiler flags), and then try to debug it once again.
Table of Contents
-
I get "/cygdrive/e/pedro/cegcc/0.50/src/mingw/crt3.c: No such file or directory.", or "Function 'main' not defined.", when I try to "list" the source code in the debugger (and who's that mysterious Don Pedro anyhow?).
You get this error message because, the debugger tries to "list" the source code for the "program entry point routine", which it apparently cannot locate in your source code.
Most probably, you're trying to debug an application which is a WinCE GUI (Graphical User Interface) application.
The normal user's startup routine for such an application is called "WinMain".
However, the "standard" entry point, for C/C++ language programs, is the "main".
So, CeGCC implements a special glue module which automatically defines the "main" function for you, which then calls your "WinMain" routine.
The solution is simple, just ask the debugger to "list WinMain", and you should immediately see your source code, unless you have forgotten to provide the debugging symbols.
Note also that, when you compile a program that has the "main" routine of its own, then the automatic CeGCC "main" module is simply not used. In this case, you should never get such an error message, unless you have forgotten to provide the debugging symbols (try to "list main"), of course.
See Startup and termination of WinCE programs.
Last, but not least, that mysterious Don Pedro is the one whoem you own a big tribute, for the possiblility to run your CeGCC binary distribution. He's the one who prepared it for you.
Table of Contents
-
Why is my "arm-wince-mingw32ce-g++" compiled DLL/EXE so large?
First, let me explain, why I am taking about the "arm-wince-mingw32ce-g++" compiler only, and not about the "arm-wince-cegcc-g++".
The reason is simple. The "arm-wince-mingw32ce" target ALWAYS STATICALLY LINKS the
stdc++ library
into your every DLL/EXE binary.
This may cause some really LARGE PARTS of this library to be INCLUDED in EACH of your DLL/EXE. You aks why? So do I! Apparently, it is the conseqence of the fact that, this target comes from the MinGW project, and
that's how they do it.
The "arm-wince-cegcc" target, on the other hand, uses DYNAMICALLY LINKED
stdc++ library,
by default (of course,
Beware! need to install CeGCC DLL's first).
So, let us now try to get the lowest possible size of your "arm-wince-mingw32ce-g++" compiled binaries. Let us create a very dumb "MyProgram.cpp", which contains just "int main(void) { return 0; }".
-
If you do not need to debug your DLL/EXE any more, get rid of all symbol table and relocation information from it. Either remove them using "arm-wince-[cegcc/mingw32ce]-strip MyProgram.[dll/exe]", or recompile your source code WITHOUT the "-g" and WITH the "-s" compiler flags.
The example "MyProgram.cpp" compiled WITH "-g" is 203 kB long (for "arm-wince-cegcc-g++" it is just 18 kB long), but stripped, it is just 40 kB long (for "arm-wince-cegcc-g++", it is just 3 kB long, when stripped).
-
If you do not need the
exception handling
(i.e.
"try/catch/throw")
in your source code, compile it adding the "-fno-exceptions" compiler flag.
The exception handling
generates extra code needed to propagate exceptions, which then triggers some
stdc++ library
("/opt/mingw32ce/arm-wince-mingw32ce/lib/libstdc++.a") functions
to be statically linked into your DLL/EXE.
Note that, if you do not specify this option, GNU CC will enable
exception handling
by default for languages like C++ which normally require it,
and disable it for languages like C that do not
normally require it. However, you may need to enable this option
when compiling C code (adding the "-fexceptions" compiler flag)
that needs to interoperate properly with exception handlers written in C++.
The example "MyProgram.cpp" compiled WITH "-fexceptions" (the default), and stripped, is 40 kB long, but compiled WITH "-fno-exceptions", and stripped, is just 4.5 kB long (for "arm-wince-cegcc-g++", it doesn't really matter, it's always about 3 kB long, when stripped).
-
Avoid using any
Standard Template Library
elements, especially in your DLL libraries, no matter what the cost!
C++ programs (and shared libraries) using the
Standard Template Library
(e.g. which "#include <iostream>" or any close "relative") cause a really large part of the
stdc++ library
("/opt/mingw32ce/arm-wince-mingw32ce/lib/libstdc++.a") to be statically linked into the binary.
If the only functions from "libstdc++.a" which you need are language support functions (those listed in
the Clause 18 of the C++ Standard,
e.g. "new" and "delete"), then try linking against "libsupc++.a" (using gcc instead of g++ and explicitly linking in "-lsupc++" for the final link step should do it). This library contains only those support routines, one per object file. But if you are using anything from the rest of the library, such as "IOStreams" or "Vectors", then you'll still need pieces from "libstdc++.a".
Let us now extend the "MyProgram.cpp" example. Let us add a line in form "#include <iostream>", before our "main" routine (we will NOT use any "IOStreams", it is sufficient to just include this file). The extended example "MyProgram.cpp" compiled WITH "-g" is almost 4 MB long (for "arm-wince-cegcc-g++", it is just 49 kB long). Stripped, it is still 544 kB long (for "arm-wince-cegcc-g++", it is just 3.5 kB long, when stripped). The "-fno-exceptions" compiler flag has no impact on the size now (the
stdc++ library
exception handling
code is always linked in anyhow, because it's used by the
Standard Template Library
routines, I believe).
Last, but not least, you can, of course, use the above advices to minimize the size of your "arm-wince-mingw32ce-gcc" generated DLL/EXE binaries, too (i.e. when you compile any C source code, except for the
Standard Template Library
advice, which is C++ specific).
Table of Contents
-
The arm-wince-mingw32ce compiler complains about undeclared identifier 'SOME_WIN_CE_IDENTIFIER'.
First, make sure that you
properly define the "_WIN32_IE" and the "_WIN32_WCE" macros
,
while compiling your source code (in order to tell the compiler which version of WinCE you're using).
If you do, then it's quite possible that you've hit a CeGCC bug.
Indeed, we don't have all the macros we should have. Our include files ("/opt/mingw32ce/arm-wince-mingw32ce/include/*")
are inherited from other projects (e.g. MinGW).
They're very good, but they tend to lack some WinCE specific stuff (well, WinCE is not their focus).
A patch for our include files would be very welcome.
The good sources for this information are (in this order):
-
reliable documentation, such as
MSDN,
-
publicly avaiable programming examples.
A bad source for such information is a copy of a Microsoft include file - that's copyrighted.
In any case, please, do inform us about the missing identifier
(regardless whether you were able to fix it, or not), using either the
CeGCC Tracker
system, and/or the
cegcc-devel
mailing list.
Table of Contents
-
The arm-wince-mingw32ce linker complains about undefined reference to 'SomeWinCeFunctionW' (and what's that "W" suffix appended to the function's name?).
First, make sure that you
properly define the "_WIN32_IE" and the "_WIN32_WCE" macros
,
while compiling your source code (in order to tell the compiler which version of WinCE you're using).
If you do, then it's quite possible that you've hit a CeGCC bug.
In general, because the
Microsoft Windows System comes in so many flavours,
there exist two mysterious suffixes, "A" and "W", which may get appended to function names.
They directly correspond to the "ASCII" and the "Wide-Character" versions of the Windows API.
The system include files are meant to automatically map a function name into a function with
an added "A" or "W" to its name, depending on whether the "UNICODE" macro is defined, or not.
For WinCE, however, the "UNICODE" should always be defined, as WinCE supports only that part of the API.
Hence, there is no need to append the "W" suffix in this case (and it should not be present).
Our include files ("/opt/mingw32ce/arm-wince-mingw32ce/include/*") are inherited from other projects (e.g. MinGW).
They're very good, but they tend to lack some WinCE specific stuff (well, WinCE is not their focus).
By running "arm-wince-mingw32ce-strings" on the right library file ("/opt/mingw32ce/arm-wince-mingw32ce/lib/*.a"), you can check whether the "SomeWinCeFunction" is present in there.
If it is not there, then
we need to implement this function.
If it is present, however, then it usually requires just some slight modifications of one of our include files
(you should then immediately be able to use this function, no further steps required).
The fix is to "#ifdef" the function's prototype, in the appropriate header file, with "_WIN32_WCE",
so that this function is always declared as "SomeWinCeFunction",
instead of the non-WinCE "SomeWinCeFunctionA" + "SomeWinCeFunctionW" pair
(which also depends on the "UNICODE" macro).
See, for example, any other function, which is present in the same header file as
"SomeWinCeFunction", in order to learn what needs to be done.
A patch for our include files would be very welcome.
In any case, please, do inform us about this problem
(regardless whether you were able to fix it, or not), using either the
CeGCC Tracker
system, and/or the
cegcc-devel
mailing list.
Table of Contents
-
How can I find/trace any missing "DLL imports"?
Different variations of
Windows CE
based systems come with different sets of functions implemented
in the system provided default DLLs, and with partially different
sets of system provided default DLLs (even when their kernel versions match).
Hence, it sometimes happens that a user added DLL / EXE will not
run on the user's system, just because it misses a specific
function to be imported from some specific system default DLL,
or even the required DLL itself does not exist at all on the user's system.
How can one find/trace any missing "DLL imports"?
You can find the ultimate answer below!
-
Get the free PC Windows (x86/x64) utility called
Dependency Walker.
Although it is a PC Windows (x86/x64) utility
(on Linux,
you can try to run it with the Wine),
it can also "scan" WinCE (ARM) libraries
and executables. What one needs to do is to open the "Options ->
Configure Module Search Order" window, remove all "standard PC Windows
subdirectories" from there, and add one's own (which hold WinCE DLLs).
Then, one can "Save..." these settings, in order to easily run the
Dependency Walker
later, giving it the "saved module search order" as
a command line parameter. See the question "Will Dependency Walker
work with Windows CE modules?" in the
Dependency Walker Frequently Asked Questions (FAQ),
and read about its
Module Search Order
and its
Command Line Options.
Note that, in order to "resolve" all dependencies, you will need to
have a copy of the WinCE DLLs, provided by YOUR OWN WinCE device in the
"\Windows" subdirectory, in the PC. However, as these libraries reside in ROM,
they cannot be simply copied to the PC, you cannot
even copy them entirely inside of the WinCE system (using its file manager).
-
Get the free WinCE utility called
ROM Extractor.
This utility can "extract" DLL / EXE / CPL / ... modules from ROM (files
which have the "FILE_ATTRIBUTE_ROMMODULE" set, i.e. files which cannot be copied by using a
file manager nor by the
ActiveSync).
Copy these "extracted" files into the PC
(preserving their original names), put them into a separate subdirectory, and use the
"Add Directory" button in the "Options -> Configure Module Search
Order" window (of the
Dependency Walker
), in order to add this
subdirectory to the "Current Search Order".
There are two things, I need to mention here. Although my CPU is an
"ARM", the "extracted modules" are marked as "Thumb". This fools the
Dependency Walker
a bit - it will mark all of them in red, to notify
the user that the CPU types do not match. I do not know if this
"Thumb" signature is really put in my ROM, or is it just the
ROM Extractor
which does it. The solution, however, is very simple. Just
take any tool that can edit binary files (I use the free
GNU Midnight Commander)
and change one byte, or two, in each DLL (the bytes which define the
CPU type). Very close to the beginning of the DLL file (usually inside of the first 256 bytes),
you should find a sequence of bytes in form:
"0x50 0x45 0x00 0x00 0xC2 0x01" ("0x50 0x45" = "PE").
The sequence "0xC2 0x01" means "Thumb" CPU, so we need to change it
into "0xC0 0x01", which means "ARM" CPU (just one, single byte to be changed):
"0x50 0x45 0x00 0x00 0xC0 0x01".
The second thing to mention is related to the usage of the
ROM Extractor.
On my WinCE system, it keeps closing the "Input Panel"
(i.e. the "Keyboard"), so that I cannot enter the "Save to:" output
file. The solution is to manually open the "Input Panel" BEFORE
starting the
ROM Extractor
executable (then the "Keyboard" remains available all the time).
And voilà, you can use the
Dependency Walker
to trace your problems!
There is still one thing, I need to mention here. As of today, Sun, Nov 11, 2007,
the Dependency Walker has some problems
with binaries (DLL/EXE) generated by the CeGCC-0.50 release (and earlier, I believe).
The problem is related to the DLL names "encoded" inside of the CeGCC generated DLL/EXE files.
All these names miss the ".dll" file name extension. As a result, the
Dependency Walker seeks for files
named "DllName" (which do NOT exist) instead of "DllName.dll" (which, hopefully, DO exist).
A temporary solution is to keep a copy of every "DllName.dll" file as a "DllName" file
(note, you do NOT need these copies on your WinCE device, just on the PC).
For the completeness of this description, let me add the following.
-
There exists a simple free, "command line" driven, WinCE utility called
Executability Check,
which can be helpful (it checks which libraries are needed and it can
"rewrite" both, the library name and it's version), but using it is a
pain. Moreover, as this utility is NOT able to read system DLLs, it
will not tell you which function is missing (if any), nor it will tell
you which functions are provided by the system default DLLs.
Note, this is really a "command line" driven utility. It NEEDS to get
the name of the DLL/EXE file (to be "inspected") in the command line
(as a parameter). It will not start without this parameter.
-
There exists a more advanced free WinCE tool called
PEInfo.
It will provide you with many informations about your DLL/EXE,
including the list of imported functions. However, as this utility is
NOT able to read system DLLs, it will not tell you which function is
missing (if any). Moreover, it does NOT even check whether the required function (to be
imported) is actually exported by the system DLL. As soon as it finds
the required DLL, it will simply happily assume that all required
functions are really provided by it.
Table of Contents
-
I get "GetLastError returns c1" when
I try to use my DLL/EXE.
Your DLL/EXE could not be loaded/started.
Are you mistakenly trying to run a PC Windows (x86/x64) DLL/EXE on your WinCE device?
If not (i.e. you are sure this is really a WinCE ARM binary), then
this usually means that one or more functions, which your
program needs, are missing in some system DLLs, or even that
one or more required DLLs are missing at all
(well, you might have also forgotten to copy some DLLs, that came
with your program, to your WinCE device, for example).
In such case, one gets a mysterious message "'MyProgram' is not a
valid Windows CE application", often bundled with a mysterious
error message "GetLastError returns c1". The "0xc1", decimal
"193", error is called "ERROR_BAD_EXE_FORMAT". It is defined in
the "winerror.h" file.
See How can I find/trace any missing "DLL imports"?
Table of Contents
-
I get "ERROR_BAD_EXE_FORMAT" when I try to use my DLL/EXE.
That is just another form of the message
"GetLastError returns c1".
Table of Contents
-
I get "'MyProgram' is not a valid Windows CE application" when
I try to run MyProgram.
That is just another form of the message
"GetLastError returns c1".
Table of Contents
-
Need More Informations?
See the CeGCC Documentation.
Table of Contents
-
DLL doesn't work with Windows Mobile 6.1
Memory management changes in Windows Mobile 6.1 cause some DLLs not to load.
It has been suggested (see
this blog
that the underlying problem is a writable code section in the DLL,
other reports suggest that the DLL size may be an issue.
The workaround or solution (I'm not sure what to call it) that we have
is to restrict this DLL to Slot 0 by adding the following registry key:
[HKEY_LOCAL_MACHINE\System\Loader\LoadModuleLow] "MyDll.dll"=dword:1
Obviously you need to change "MyDll" into the name of the DLL that causes the problem.
Please note that using the this approach will force your entire DLL into Slot 0 and,
it may prevent other modules from loading in that slot.
Therefore, the above registry setting should be used with caution.
Table of Contents
-
Who's to be plead guilty for all that crap that I had to read in here?
Well, many sources contributed, but, the main blame
(at least, for the time being) should definitely be put on
Jacek M. Holeczek,
who got them (in here) together.
Table of Contents