Free xmlencode c software for linux

More for C++ is a class library that provides some features usually not common for C++

More for C++ includes a mark-sweep garbage collector, platform-independent classes for threading, sockets, and I/O, unit tests, and a few other utility classes.

First of all, there is a garbage collector for automatic memory management. When an object has been referenced by a special smart pointer and should not be used any more, it will be destroyed by the librarys garbage collector.

Next, there are platform independent packages for file operations, networking and multithreading. At the time being, concrete implementations exist for Win32 and GNU/Linux.

Additionally, the library has some utility classes like containers, observers and (of course the inevitable class "String" (which - like any other class provided by and used with this library - will also be managed by the garbage collector).
One of the most recent packages is called "servlet". It offers the possibility to write loadable modules for the popular Apache web server, serving dynamic content with C++.

Last but not least, "More for C++" comes with its own framework for writing unit tests. This package has been inspired by the fabulous JUnit by Kent Beck and Erich Gamma.

By using this library, you are able to combine the performance of C++ with the elegance and ease of use of Java and Python. A native garbage collector in combination with the smart pointer class helps you to avoid common programming errors like dangling pointers or memory leaks. Besides this, the platform independence helps you to easily port your programs to the most important operating systems.

C/Invoke is a library for connecting to C libraries at runtime. This differs from the typical method of interfacing with C, which involves writing static definitions which are then compiled to a machine-dependant format. C/Invoke provides a runtime facility to build descriptions of C functions and to call them, passing them appropriate data and retrieving results.
C/Invoke provides a central repository of code to handle the platform-dependant details of marshaling C parameters and return values. Currently C/Invoke has been ported to GCC (GNU/Linux, *BSD) on the x86 and amd64 architectures, Microsoft Windows on x86, and Mac OS X on PowerPC. The development team is interested in adding more ports as they gain access to more diverse hardware.
Audience
The main audience of C/Invoke are users of high-level programming languages who wish to interface with C. At the moment, most languages can be extended with C libraries only by authoring modules in C using language-specific APIs. There are many problems with this approach; writing extension modules requires knowledge of the C language instead of the language the application is being written in, the APIs needed to implement the modules are often involved and complex, and the resulting libraries must be built and maintained on many different platforms.
However, once C/Invoke is integrated into a language, the situation changes dramatically; users of Lua (for example) can interface to C by writing Lua code alone. This means that the advantages of Lua (or other high-level languages) such as portability and ease of use can be combined with the low-level power of C. To call a C function, one merely declares a C prototype in the high-level code, similar to the P/Invoke functionality of Microsofts .NET Framework. A subroutine is then created in the high-level environment which hooks into a proxy generated to correctly call the given C function.
There are two ways to integrate C/Invoke into a language. One is to use the existing extension module interface of the language in the normal manner. This is the preferred method to integrate with a language which is already established and which would be hard to modify, such as Perl, Python, Ruby, Tcl, etc. The other way would be to link C/Invoke directly into the language runtime and make the declarative C services part of the syntax of the language.
The C/Invoke developers are always looking for volunteers to integrate with an existing language, or programming language authors who are interested in using C/Invoke directly.
Enhancements:
- Support for the SPARC architecure was added, and many bugs were fixed in the Lua language binding.

mod_lock.c Apache module allows to conditionaly lock a part of a web server by just creating a file in a predefined location. This feature is useful for system maintenance on multi VirtualHosted systems.
Configuration:
Integrating into Apache - compiling and linking
To link the lock module with Apache, you must rebuild Apache from its sources with adding mod_lock in the configuration file:
- Copy mod_lock.c in Apache sources directory
- Edit Configuration file according your installation
- Run the Configure script to rebuild the makefile
- Build Apache by typing make
- Install the brand new httpd program
- Edit the web server configuration files (typically httpd.conf and access.conf)
- Restart the web daemon
- Example of a Configuration file
...
Module mime_module mod_mime.o
Module access_module mod_access.o
Module auth_module mod_auth.o
Module negotiation_module mod_negotiation.o
Module includes_module mod_include.o
Module dir_module mod_dir.o
Module cgi_module mod_cgi.o
...
#
# Miscellaneous modules
#
Module lock_module mod_lock.o
httpd.conf Directives
SetLockFile filename default value: none context: Directory or Location effect: Enables the conditional lock for a location. The web server will check for the existence of the file each time it will access the concerned documents. If it finds it, it will return a 503 (Service unavailable) HTTP status code. remarks: if filename is a null string (""), conditional lock will be disabled for this class of documents. LockBypass host1 host2 ... default value: none context: Directory or Location effect: Allows access from an host, even if locked. remarks: hostnames can be either real hostnames (www.hp.com) or domain names (.hp.com).
Known bugs:
wrong access rights can confuse the test of the lock file (access denied is equivalent to not found).
webuser (the user who runs the web daemon) should have read access to the lock file to avoid this behaviour.

AspeCt-oriented C project implements an aspect-oriented extension to C and offers one possible language design for an aspect-oriented C language.
Main features:
- an aspect-oriented extension to C, aspect-oriented software development for C, and an ACC language design option
- full ANSI-C compliance and gcc source-compatibility;
- compiler and generated code portability;
- seamless Linux, Solaris and Windows support;
- simple integration in existing builds and code transparency through source-to-source transformations;
- an open source license and compiler.
AspeCt-oriented C enables:
- modularization of crosscutting concerns for C-based software;
- research on concern separation tailored to C and imperative programming;
- research on aspect-orientation on C-based systems;
- development of highly customizable and easily configurable software in C;
- development of feature-rich software product lines in C.
Enhancements:
- set()/get() join point and pointcut support was added for global variables, and compiler options were added for manipulating join points.

JXTA-C/C++ project is an open source cross-platform C/C++ implementation of the JXTA platform.
The community is committed to a quarterly release cycle. For each release, it is currently built and tested on Solaris/Linux/Windows, MacOS X and BSD are reported to work.
The JXTA platform is an open network computing platform designed for peer-to-peer (P2P) computing. The JXTA platform standardizes the manner in which peers:
- Advertise and discover resources (Peer, PeerGroup, Service and Pipe Advertisements)
- Communicate with each other (Pipes)
- Cooperate with each other to dynamically form peer groups
Enhancements:
- Thread pool support for lower resource usage.
- The jxta_log_callback function prototype has been changed.
- JPR is built as a static library as an integral part of libjxta on Unix platforms.