cpp
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 111
cpphs 1.0
cpphs is a Haskell re-implementation of cpp, the C pre-processor. more>>
cpphs is a liberalised re-implementation of cpp, the C pre-processor, in Haskell.
Why re-implement cpp? Rightly or wrongly, the C pre-processor is widely used in Haskell source code. It enables conditional compilation for different compilers, different versions of the same compiler, and different OS platforms.
It is also occasionally used for its macro language, which can enable certain forms of platform-specific detail-filling, such as the tedious boilerplate generation of instance definitions and FFI declarations. However, there are two problems with cpp, aside from the obvious aesthetic ones:
- For some Haskell systems, notably Hugs on Windows, a true cpp is not available by default. * Even for the other Haskell systems, the common cpp provided by the gcc 3.x series is changing subtly in ways that are incompatible with Haskells syntax. There have always been problems with, for instance, string gaps, and prime characters in identifiers. These problems are only going to get worse.
So, it seemed right to provide an alternative to cpp, both more compatible with Haskell, and itself written in Haskell so that it can be distributed with compilers.
This version of the C pre-processor is pretty-much feature-complete, and compatible with the -traditional style. It has two main modes:
- conditional compilation only (--nomacro),
- and full macro-expansion (default).
In --nomacro mode, cpphs performs only conditional compilation actions, namely #includes, #ifs, and #ifdefs are processed according to text-replacement definitions (both command-line and internal), but no parameterised macro expansion is performed. In full compatibility mode (the default), textual replacements and macro expansions are also processed in the remaining body of non-cpp text.
Working features:
#ifdef simple conditional compilation
#if the full boolean language of defined(), &&, ||, ==, etc.
#elif chained conditionals
#define in-line definitions (text replacements and macros)
#undef in-line revocation of definitions
#include file inclusion
#line line number directives
line continuations within all # directives
/**/ token catenation within a macro definition
## ANSI-style token catenation
# ANSI-style token stringisation
__FILE__ special text replacement for DIY error messages
__LINE__ special text replacement for DIY error messages
__DATE__ special text replacement
__TIME__ special text replacement
Macro expansion is recursive. Redefinition of a macro name does not generate a warning. Macros can be defined on the command-line with -D just like textual replacements. Macro names are permitted to be Haskell identifiers e.g. with the prime and backtick ` characters, which is slightly looser than in C, but they still may not include operator symbols.
Numbering of lines in the output is preserved so that any later processor can give meaningful error messages. When a file is #included, cpphs inserts #line directives for the same reason. Numbering should be correct even in the presence of line continuations. If you dont want #line directives in the final output, use the --noline option.
Any syntax errors in cpp directives gives a message to stderr and halts the program. Failure to find a #included file produces a warning to stderr, but processing continues.
Differences from cpp:
In general, cpphs is based on the -traditional behaviour, not ANSI C, and has the following main differences from the standard cpp.
General
- The # that introduces any cpp directive must be in the first column of a line (whereas ANSI permits whitespace before the #).
- Generates the #line n "filename" syntax, not the # n "filename" variant.
- C comments are only removed from within cpp directives. They are not stripped from other text. Consider for instance that in Haskell, all of the following are valid operator symbols: /* */ */* However, you can turn on C-comment removal with the --strip option.
- Macros are never expanded within Haskell comments, strings, or character constants, unless you give the --text option to disable lexing the input as Haskell.
- Macros are always expanded recursively, unlike ANSI, which detects and prevents self-recursion. For instance, #define foo x:foo expands foo once only to x:foo in ANSI, but in cpphs it becomes an infinite list x:x:x:x:..., i.e. cpphs does not terminate.
Macro definition language
- Accepts /**/ for token-pasting in a macro definition. However, /* */ (with any text between the open/close comment) inserts whitespace.
- The ANSI ## token-pasting operator is available with the --hashes flag. This is to avoid misinterpreting any valid Haskell operator of the same name.
- Replaces a macro formal parameter with the actual, even inside a string (double or single quoted). This is -traditional behaviour, not supported in ANSI.
- Recognises the # stringisation operator in a macro definition only if you use the --hashes option. (It is an ANSI addition, only needed because quoted stringisation (above) is prohibited by ANSI.)
- Preserves whitespace within a textual replacement definition exactly (modulo newlines), but leading and trailing space is eliminated.
- Preserves whitespace within a macro definition (and trailing it) exactly (modulo newlines), but leading space is eliminated.
- Preserves whitespace within macro call arguments exactly (including newlines), but leading and trailing space is eliminated.
- With the --layout option, line continuations in a textual replacement or macro definition are preserved as line-breaks in the macro call. (Useful for layout-sensitive code in Haskell.)
Enhancements:
- This release now includes a compatibility script for command line arguments to match the original cpp.
- There are several minor bugfixes, e.g. quotes around replacements for special macros like __FILE__, etc.
- Interaction with preprocessors like hsc2hs is also improved: if they allow non-cpp directives like #def, these are now passed through to the output with a warning to stderr, rather than halting with an error.
- Likewise, a #! line in a shell script is now ignored.
<<lessWhy re-implement cpp? Rightly or wrongly, the C pre-processor is widely used in Haskell source code. It enables conditional compilation for different compilers, different versions of the same compiler, and different OS platforms.
It is also occasionally used for its macro language, which can enable certain forms of platform-specific detail-filling, such as the tedious boilerplate generation of instance definitions and FFI declarations. However, there are two problems with cpp, aside from the obvious aesthetic ones:
- For some Haskell systems, notably Hugs on Windows, a true cpp is not available by default. * Even for the other Haskell systems, the common cpp provided by the gcc 3.x series is changing subtly in ways that are incompatible with Haskells syntax. There have always been problems with, for instance, string gaps, and prime characters in identifiers. These problems are only going to get worse.
So, it seemed right to provide an alternative to cpp, both more compatible with Haskell, and itself written in Haskell so that it can be distributed with compilers.
This version of the C pre-processor is pretty-much feature-complete, and compatible with the -traditional style. It has two main modes:
- conditional compilation only (--nomacro),
- and full macro-expansion (default).
In --nomacro mode, cpphs performs only conditional compilation actions, namely #includes, #ifs, and #ifdefs are processed according to text-replacement definitions (both command-line and internal), but no parameterised macro expansion is performed. In full compatibility mode (the default), textual replacements and macro expansions are also processed in the remaining body of non-cpp text.
Working features:
#ifdef simple conditional compilation
#if the full boolean language of defined(), &&, ||, ==, etc.
#elif chained conditionals
#define in-line definitions (text replacements and macros)
#undef in-line revocation of definitions
#include file inclusion
#line line number directives
line continuations within all # directives
/**/ token catenation within a macro definition
## ANSI-style token catenation
# ANSI-style token stringisation
__FILE__ special text replacement for DIY error messages
__LINE__ special text replacement for DIY error messages
__DATE__ special text replacement
__TIME__ special text replacement
Macro expansion is recursive. Redefinition of a macro name does not generate a warning. Macros can be defined on the command-line with -D just like textual replacements. Macro names are permitted to be Haskell identifiers e.g. with the prime and backtick ` characters, which is slightly looser than in C, but they still may not include operator symbols.
Numbering of lines in the output is preserved so that any later processor can give meaningful error messages. When a file is #included, cpphs inserts #line directives for the same reason. Numbering should be correct even in the presence of line continuations. If you dont want #line directives in the final output, use the --noline option.
Any syntax errors in cpp directives gives a message to stderr and halts the program. Failure to find a #included file produces a warning to stderr, but processing continues.
Differences from cpp:
In general, cpphs is based on the -traditional behaviour, not ANSI C, and has the following main differences from the standard cpp.
General
- The # that introduces any cpp directive must be in the first column of a line (whereas ANSI permits whitespace before the #).
- Generates the #line n "filename" syntax, not the # n "filename" variant.
- C comments are only removed from within cpp directives. They are not stripped from other text. Consider for instance that in Haskell, all of the following are valid operator symbols: /* */ */* However, you can turn on C-comment removal with the --strip option.
- Macros are never expanded within Haskell comments, strings, or character constants, unless you give the --text option to disable lexing the input as Haskell.
- Macros are always expanded recursively, unlike ANSI, which detects and prevents self-recursion. For instance, #define foo x:foo expands foo once only to x:foo in ANSI, but in cpphs it becomes an infinite list x:x:x:x:..., i.e. cpphs does not terminate.
Macro definition language
- Accepts /**/ for token-pasting in a macro definition. However, /* */ (with any text between the open/close comment) inserts whitespace.
- The ANSI ## token-pasting operator is available with the --hashes flag. This is to avoid misinterpreting any valid Haskell operator of the same name.
- Replaces a macro formal parameter with the actual, even inside a string (double or single quoted). This is -traditional behaviour, not supported in ANSI.
- Recognises the # stringisation operator in a macro definition only if you use the --hashes option. (It is an ANSI addition, only needed because quoted stringisation (above) is prohibited by ANSI.)
- Preserves whitespace within a textual replacement definition exactly (modulo newlines), but leading and trailing space is eliminated.
- Preserves whitespace within a macro definition (and trailing it) exactly (modulo newlines), but leading space is eliminated.
- Preserves whitespace within macro call arguments exactly (including newlines), but leading and trailing space is eliminated.
- With the --layout option, line continuations in a textual replacement or macro definition are preserved as line-breaks in the macro call. (Useful for layout-sensitive code in Haskell.)
Enhancements:
- This release now includes a compatibility script for command line arguments to match the original cpp.
- There are several minor bugfixes, e.g. quotes around replacements for special macros like __FILE__, etc.
- Interaction with preprocessors like hsc2hs is also improved: if they allow non-cpp directives like #def, these are now passed through to the output with a warning to stderr, rather than halting with an error.
- Likewise, a #! line in a shell script is now ignored.
Download (0.039MB)
Added: 2005-10-18 License: LGPL (GNU Lesser General Public License) Price:
1467 downloads
Cppmake 0.5
Cppmake is a front-end to make that builds C++ programs with less effort than writing makefiles manually. more>>
Cppmake application is a front-end to make that builds C++ programs with less effort than writing makefiles manually.
Building a C++ program with cppmake is similar to compiling a Java program. The idea is that you specify a classpath and cppmake will automatically find all the classes needed by your program. Once found, all of the classes are compiled and linked into an executable or library.
The benefits of using cppmake to build C++ programs include
- You dont have to write a makefile when you start a new project
- You dont have to maintain a makefile as your project evolves
- Header file dependencies are automatically kept up to date
- You can switch from one implementation of a group of classes to another on the fly by simply changing the classpath
Lets begin with an example. Suppose you want to build a program called joe and the main function is in joe.cpp. Your programs classes live in the current directory, ../../common, and /usr/src/base. The only thing you need to do is set the classpath (just like a java program) to ".:../../common:/usr/src/base" (unix/cygwin) or ".;....common;C:usrsrcbase" (windows). This tells cppmake to first search for classes in the current directory, then in ../../common and finally in /usr/src/base. You simply run cppmake on joe.cpp to build the executable.
$ cppmake --classpath ".:../../common:/usr/src/base" joe.cpp
The result of this command is an executable called joe. Cppmake figures out which classes on the classpath need to be included in the executable and defers the work of actually compiling and linking the executable to the make command. Therefore the next time you run cppmake, only files that need to be recompiled are recompiled.
Now lets do a more complicated example. Suppose you want to build the same program as in the previous example, but this time you want more control over the build. You want to explicitly name the executable joe.exe, you want output files to go in a directory called build, you want to specify the compiler as g++, you want to pass the -Wall -g compiler flags, and you want to link with the pthread library.
$ cppmake --classpath ".:../../common:/usr/src/base" -o joe.exe -d build -x g++ -f "-Wall -g" -l "-lpthread" joe.cpp
Most of these options can be given through environment variables as well as the command line. The following is equivalent to the previous example using bash.
$ export CLASSPATH=".:../../common:/usr/src/base"
$ export OUTPUT=joe.exe
$ export DIRECTORY=build
$ export CXX=g++
$ export CXXFLAGS="-Wall -g"
$ export LDFLAGS="-lpthread"
$ export CPPFILES="joe.cpp"
$ cppmake
When an option is given by both an environment variable and the command line, the command line option takes precedence. One exception to this rule is that C++ files can be given with the CPPFILES environment variable and the command line at the same time.
Cppmake can also be used to build libraries. The difference between building a library and an executable is that when building an executable you only want classes that are needed by the executable, but when you build a library you want all the C++ files on the classpath.
The --library option tells cppmake to include every C++ file found on the classpath in the build. You also have to pass your compiler specific linker options to build a library, cppmake will not know to give those options automatically because they are compiler specific. The following example creates a library on linux assuming CLASSPATH has already been set as in the previous example.
$ cppmake --library -o libjoe.so.1.1.1 -l"-shared -Wl-soname,libjoe.so.1"
The --clean option tells cppmake to remove all the object files and the output. The --help option prints a summary of all the options and exits.
<<lessBuilding a C++ program with cppmake is similar to compiling a Java program. The idea is that you specify a classpath and cppmake will automatically find all the classes needed by your program. Once found, all of the classes are compiled and linked into an executable or library.
The benefits of using cppmake to build C++ programs include
- You dont have to write a makefile when you start a new project
- You dont have to maintain a makefile as your project evolves
- Header file dependencies are automatically kept up to date
- You can switch from one implementation of a group of classes to another on the fly by simply changing the classpath
Lets begin with an example. Suppose you want to build a program called joe and the main function is in joe.cpp. Your programs classes live in the current directory, ../../common, and /usr/src/base. The only thing you need to do is set the classpath (just like a java program) to ".:../../common:/usr/src/base" (unix/cygwin) or ".;....common;C:usrsrcbase" (windows). This tells cppmake to first search for classes in the current directory, then in ../../common and finally in /usr/src/base. You simply run cppmake on joe.cpp to build the executable.
$ cppmake --classpath ".:../../common:/usr/src/base" joe.cpp
The result of this command is an executable called joe. Cppmake figures out which classes on the classpath need to be included in the executable and defers the work of actually compiling and linking the executable to the make command. Therefore the next time you run cppmake, only files that need to be recompiled are recompiled.
Now lets do a more complicated example. Suppose you want to build the same program as in the previous example, but this time you want more control over the build. You want to explicitly name the executable joe.exe, you want output files to go in a directory called build, you want to specify the compiler as g++, you want to pass the -Wall -g compiler flags, and you want to link with the pthread library.
$ cppmake --classpath ".:../../common:/usr/src/base" -o joe.exe -d build -x g++ -f "-Wall -g" -l "-lpthread" joe.cpp
Most of these options can be given through environment variables as well as the command line. The following is equivalent to the previous example using bash.
$ export CLASSPATH=".:../../common:/usr/src/base"
$ export OUTPUT=joe.exe
$ export DIRECTORY=build
$ export CXX=g++
$ export CXXFLAGS="-Wall -g"
$ export LDFLAGS="-lpthread"
$ export CPPFILES="joe.cpp"
$ cppmake
When an option is given by both an environment variable and the command line, the command line option takes precedence. One exception to this rule is that C++ files can be given with the CPPFILES environment variable and the command line at the same time.
Cppmake can also be used to build libraries. The difference between building a library and an executable is that when building an executable you only want classes that are needed by the executable, but when you build a library you want all the C++ files on the classpath.
The --library option tells cppmake to include every C++ file found on the classpath in the build. You also have to pass your compiler specific linker options to build a library, cppmake will not know to give those options automatically because they are compiler specific. The following example creates a library on linux assuming CLASSPATH has already been set as in the previous example.
$ cppmake --library -o libjoe.so.1.1.1 -l"-shared -Wl-soname,libjoe.so.1"
The --clean option tells cppmake to remove all the object files and the output. The --help option prints a summary of all the options and exits.
Download (0.013MB)
Added: 2006-11-05 License: GPL (GNU General Public License) Price:
1084 downloads
mod_cpp 0.1
mod_cpp easily write an Apache modules in C++. more>>
mod_cpp easily write an Apache modules in C++.
The way this thing works is that there is a class "Module", with virtual functions for all Apache request processing API hooks. What one needs to do in order to get it rolling is:
- Download the header, and include it in your own C++ source file.
- Derive own class from module
- Override needed virtual functions
- Create static variable of your class
- Assign pointer to this variable to "theModule"
- Put THE_MODULE(mymodule) in the beginning of .cpp file
Of course this thing is far from complete. Its even far from being useful, Id say. There is no nice support for Apache configuration directives or action handlers yet, but I think it might provide as a good starting point. I will be adding features to it as I do my own development in this area, but any suggestions / comments / code are welcome as always.
<<lessThe way this thing works is that there is a class "Module", with virtual functions for all Apache request processing API hooks. What one needs to do in order to get it rolling is:
- Download the header, and include it in your own C++ source file.
- Derive own class from module
- Override needed virtual functions
- Create static variable of your class
- Assign pointer to this variable to "theModule"
- Put THE_MODULE(mymodule) in the beginning of .cpp file
Of course this thing is far from complete. Its even far from being useful, Id say. There is no nice support for Apache configuration directives or action handlers yet, but I think it might provide as a good starting point. I will be adding features to it as I do my own development in this area, but any suggestions / comments / code are welcome as always.
Download (0.005MB)
Added: 2006-05-22 License: Freeware Price:
1255 downloads
Text::CPP 0.12
Text::CPP is a full C Preprocessor in XS. more>>
Text::CPP is a full C Preprocessor in XS.
SYNOPSIS
use Text::CPP;
my $reader = new Text::CPP(
Language => CLK_GNUC99,
Options => {
...
},
Builtins => {
foo => this,
bar => that,
},
);
$reader->read("file.c");
while (my $token = $reader->token) {
print "Token: $tokenn";
}
$reader->data->{MyKey} = $MyData;
A fast C preprocessor in XS. This does not require an external C preprocessor, and will not fork() or exec() any external process.
USAGE
The following methods have been implemented, allowing the use of this module as a pure C preprocessor, or as a lexer for a C, C++ or Assembler-like language.
new Text::CPP(...)
Takes a hash or hashref with the following possible keys:
Language
Defines the source language to preprocess and/or tokenise. It may be any of:
CLK_GNUC89 - GNU C89
CLK_GNUC99 - GNU C99
CLK_STDC89 - Standard C89
CLK_STDC94 - Standard C94
CLK_STDC99 - Standard C99
CLK_GNUCXX - GNU C++
CLK_CXX98 - Standard C++ 98
CLK_ASM - Assembler
Options
A hashref of options for the preprocessor. Valid entries are given with alternative forms (from GNU cpp) in brackets.
Define (-D): array of strings or hash
Strings should be of the form NAME=VALUE.
Undef (-U): array of strings
DiscardComments (-C): boolean
DiscardCommentsInMacroExp (-CC): boolean
PrintIncludeNames (-H): boolean
NoLineCommands (-P): boolean
WarnComments (-Wcomment -Wcomments): boolean
WarnDeprecated (-Wdeprecated): boolean
WarningsAreErrors (-Werror): boolean
WarnImport (-Wimport): boolean
WarnMultichar (-Wmultichar): boolean
WarnSystemHeaders (-Wsystem-headers): boolean
Ignore errors in system header files.
WarnTraditional (-Wtraditional): boolean
WarnTrigraphs (-Wtrigraphs): boolean
WarnUnusedMacros (-Wunused-macros): boolean
Pedantic (-pedantic): boolean
PedanticErrors (-pedantic-errors): boolean
Implies, and overrides, Pedantic.
Remap (-remap): boolean
Deal with some brokennesses of MSDOS. Untested.
Trigraphs (-trigraphs): boolean
Traditional (-traditional): boolean
NoWarnings (-w): boolean
IncludePrefix (-iprefix): string
SystemRoot (-isysroot): string
Include (-include): array of strings
Include the specified files before reading the main file to be processed.
IncludeMacros (-imacros): array of strings
Include the specified files before reading the main file to be processed. Output from preprocessing these files is discarded. Files specified by IncludeMacros are processed before files specified by Include.
IncludePath (-I): array of strings
This include path is searched first.
SystemIncludePath (-isystem): array of strings
Specify the standard system include path, searched second.
AfterIncludePath (-idirafter): array of strings
This include path is searched after the system include path.
Builtins
A hashref of predefined macros. The values must be strings or integers. Macros in this hash will be defined before preprocessing starts. These correspond to true "builtin" macros. You should probably prefer to use the Define option.
$text = $reader->token
($text, $type, $flags) = $reader->token
Return the next available preprocessed token. Some tokens are not stringifiable. These include tokens of type CPP_MACRO_ARG, CPP_PADDING and CPP_EOF. Text::CPP returns a dummy string in the text field for these tokens. Tokens of type CPP_EOF should never actually be returned.
@tokens = $reader->tokens
Preprocess and return a list of tokens. This is approximately equivalent to:
push(@tokens, $_) while ($_ = $reader->token);
$reader->type($type)
Return a human readable name for a token type, as returned by $reader->token.
$reader->data
Returns a hashref in which user data may be stored by subclasses. This hashref is created with a new Text::CPP object, and is ignored for all functional purposes. The user may do with it as he wishes.
$reader->errors
In scalar context, returns the fatal error count. In list context, returns a list of warnings and errors encountered by the preprocessor. Thus scalar(@errors) >= $errors, since @errors will also contain the warnings.
<<lessSYNOPSIS
use Text::CPP;
my $reader = new Text::CPP(
Language => CLK_GNUC99,
Options => {
...
},
Builtins => {
foo => this,
bar => that,
},
);
$reader->read("file.c");
while (my $token = $reader->token) {
print "Token: $tokenn";
}
$reader->data->{MyKey} = $MyData;
A fast C preprocessor in XS. This does not require an external C preprocessor, and will not fork() or exec() any external process.
USAGE
The following methods have been implemented, allowing the use of this module as a pure C preprocessor, or as a lexer for a C, C++ or Assembler-like language.
new Text::CPP(...)
Takes a hash or hashref with the following possible keys:
Language
Defines the source language to preprocess and/or tokenise. It may be any of:
CLK_GNUC89 - GNU C89
CLK_GNUC99 - GNU C99
CLK_STDC89 - Standard C89
CLK_STDC94 - Standard C94
CLK_STDC99 - Standard C99
CLK_GNUCXX - GNU C++
CLK_CXX98 - Standard C++ 98
CLK_ASM - Assembler
Options
A hashref of options for the preprocessor. Valid entries are given with alternative forms (from GNU cpp) in brackets.
Define (-D): array of strings or hash
Strings should be of the form NAME=VALUE.
Undef (-U): array of strings
DiscardComments (-C): boolean
DiscardCommentsInMacroExp (-CC): boolean
PrintIncludeNames (-H): boolean
NoLineCommands (-P): boolean
WarnComments (-Wcomment -Wcomments): boolean
WarnDeprecated (-Wdeprecated): boolean
WarningsAreErrors (-Werror): boolean
WarnImport (-Wimport): boolean
WarnMultichar (-Wmultichar): boolean
WarnSystemHeaders (-Wsystem-headers): boolean
Ignore errors in system header files.
WarnTraditional (-Wtraditional): boolean
WarnTrigraphs (-Wtrigraphs): boolean
WarnUnusedMacros (-Wunused-macros): boolean
Pedantic (-pedantic): boolean
PedanticErrors (-pedantic-errors): boolean
Implies, and overrides, Pedantic.
Remap (-remap): boolean
Deal with some brokennesses of MSDOS. Untested.
Trigraphs (-trigraphs): boolean
Traditional (-traditional): boolean
NoWarnings (-w): boolean
IncludePrefix (-iprefix): string
SystemRoot (-isysroot): string
Include (-include): array of strings
Include the specified files before reading the main file to be processed.
IncludeMacros (-imacros): array of strings
Include the specified files before reading the main file to be processed. Output from preprocessing these files is discarded. Files specified by IncludeMacros are processed before files specified by Include.
IncludePath (-I): array of strings
This include path is searched first.
SystemIncludePath (-isystem): array of strings
Specify the standard system include path, searched second.
AfterIncludePath (-idirafter): array of strings
This include path is searched after the system include path.
Builtins
A hashref of predefined macros. The values must be strings or integers. Macros in this hash will be defined before preprocessing starts. These correspond to true "builtin" macros. You should probably prefer to use the Define option.
$text = $reader->token
($text, $type, $flags) = $reader->token
Return the next available preprocessed token. Some tokens are not stringifiable. These include tokens of type CPP_MACRO_ARG, CPP_PADDING and CPP_EOF. Text::CPP returns a dummy string in the text field for these tokens. Tokens of type CPP_EOF should never actually be returned.
@tokens = $reader->tokens
Preprocess and return a list of tokens. This is approximately equivalent to:
push(@tokens, $_) while ($_ = $reader->token);
$reader->type($type)
Return a human readable name for a token type, as returned by $reader->token.
$reader->data
Returns a hashref in which user data may be stored by subclasses. This hashref is created with a new Text::CPP object, and is ignored for all functional purposes. The user may do with it as he wishes.
$reader->errors
In scalar context, returns the fatal error count. In list context, returns a list of warnings and errors encountered by the preprocessor. Thus scalar(@errors) >= $errors, since @errors will also contain the warnings.
Download (0.17MB)
Added: 2007-05-29 License: Perl Artistic License Price:
878 downloads
idl2cpp 0.21
idl2cpp is a IDL compiler to language C++ mapping. more>>
idl2cpp is a IDL compiler to language C++ mapping.
SYNOPSIS
idl2cpp [options] spec.idl
OPTIONS
All options are forwarded to C preprocessor, except -h -i -v -x.
With the GNU C Compatible Compiler Processor, useful options are :
-D name
-D name=definition
-I directory
-I-
-nostdinc
Specific options :
-h
Display help.
-i directory
Specify a path for import (only for IDL version 3.0).
-v
Display version.
-x
Enable export (only for IDL version 3.0).
idl2cpp parses the given input file (IDL) and generates a include file following the language C mapping rules.
idl2cpp is a Perl OO application what uses the visitor design pattern. The parser is generated by Parse::Yapp.
idl2cpp needs Math::BigInt and CORBA::Fixed modules.
idl2cpp needs a cpp executable.
<<lessSYNOPSIS
idl2cpp [options] spec.idl
OPTIONS
All options are forwarded to C preprocessor, except -h -i -v -x.
With the GNU C Compatible Compiler Processor, useful options are :
-D name
-D name=definition
-I directory
-I-
-nostdinc
Specific options :
-h
Display help.
-i directory
Specify a path for import (only for IDL version 3.0).
-v
Display version.
-x
Enable export (only for IDL version 3.0).
idl2cpp parses the given input file (IDL) and generates a include file following the language C mapping rules.
idl2cpp is a Perl OO application what uses the visitor design pattern. The parser is generated by Parse::Yapp.
idl2cpp needs Math::BigInt and CORBA::Fixed modules.
idl2cpp needs a cpp executable.
Download (0.011MB)
Added: 2007-05-31 License: Perl Artistic License Price:
538 downloads
Inline::CPP 0.25
Inline::CPP is a Perl module that can write Perl subroutines and classes in C++. more>>
Inline::CPP is a Perl module that can write Perl subroutines and classes in C++.
SYNOPSIS
use Inline CPP;
print "9 + 16 = ", add(9, 16), "n";
print "9 - 16 = ", subtract(9, 16), "n";
__END__
__CPP__
int add(int x, int y) {
return x + y;
}
int subtract(int x, int y) {
return x - y;
}
The Inline::CPP module allows you to put C++ source code directly "inline" in a Perl script or module. You code classes or functions in C++, and you can use them as if they were written in Perl.
<<lessSYNOPSIS
use Inline CPP;
print "9 + 16 = ", add(9, 16), "n";
print "9 - 16 = ", subtract(9, 16), "n";
__END__
__CPP__
int add(int x, int y) {
return x + y;
}
int subtract(int x, int y) {
return x - y;
}
The Inline::CPP module allows you to put C++ source code directly "inline" in a Perl script or module. You code classes or functions in C++, and you can use them as if they were written in Perl.
Download (0.024MB)
Added: 2006-07-06 License: Perl Artistic License Price:
1205 downloads
Filter::cpp 1.33
Filter::cpp is a cpp source filter. more>>
Filter::cpp is a cpp source filter.
SYNOPSIS
use Filter::cpp ;
This source filter pipes the current source file through the C pre-processor (cpp) if it is available.
As with all source filters its scope is limited to the current source file only. Every file you want to be processed by the filter must have a
use Filter::cpp ;
near the top.
Here is an example script which uses the filter:
use Filter::cpp ;
#define FRED 1
$a = 2 + FRED ;
print "a = $an" ;
#ifdef FRED
print "Hello FREDn" ;
#else
print "Where is FREDn" ;
#endif
And here is what it will output:
a = 3
Hello FRED
This example below, provided by Michael G Schwern, shows a clever way to get Perl to use a C pre-processor macro when the Filter::cpp module is available, or to use a Perl sub when it is not.
# use Filter::cpp if we can.
BEGIN { eval use Filter::cpp }
sub PRINT {
my($string) = shift;
#define PRINT($string)
(print $string."n")
}
PRINT("Mu");
Look at Michaels Tie::VecArray module for a practical use.
<<lessSYNOPSIS
use Filter::cpp ;
This source filter pipes the current source file through the C pre-processor (cpp) if it is available.
As with all source filters its scope is limited to the current source file only. Every file you want to be processed by the filter must have a
use Filter::cpp ;
near the top.
Here is an example script which uses the filter:
use Filter::cpp ;
#define FRED 1
$a = 2 + FRED ;
print "a = $an" ;
#ifdef FRED
print "Hello FREDn" ;
#else
print "Where is FREDn" ;
#endif
And here is what it will output:
a = 3
Hello FRED
This example below, provided by Michael G Schwern, shows a clever way to get Perl to use a C pre-processor macro when the Filter::cpp module is available, or to use a Perl sub when it is not.
# use Filter::cpp if we can.
BEGIN { eval use Filter::cpp }
sub PRINT {
my($string) = shift;
#define PRINT($string)
(print $string."n")
}
PRINT("Mu");
Look at Michaels Tie::VecArray module for a practical use.
Download (0.040MB)
Added: 2007-05-29 License: Perl Artistic License Price:
882 downloads
cpp xstream 0.0.3
cpp xstream is a collection of several streambuf and iostream classes. more>>
cpp xstream is a C++ flexible stream library.
cpp xstream is a collection of several streambuf and iostream classes that allow a programmer to compress and decompress data transparently with gzip or bzip2, to serialize composite types to xdr, to encode or decode with base64, and to tee output from one channel to several others. These streams can be stacked on each other.
Main features:
- Compressing and decompressing data using zlib and bzlib
- Encode and decode base64 data
- Serialize and deserialize structures to XDR
- Calculate digests of data
- Fork data written to a stream to several others
- Use file descriptors using a iostream interface (where available)
<<lesscpp xstream is a collection of several streambuf and iostream classes that allow a programmer to compress and decompress data transparently with gzip or bzip2, to serialize composite types to xdr, to encode or decode with base64, and to tee output from one channel to several others. These streams can be stacked on each other.
Main features:
- Compressing and decompressing data using zlib and bzlib
- Encode and decode base64 data
- Serialize and deserialize structures to XDR
- Calculate digests of data
- Fork data written to a stream to several others
- Use file descriptors using a iostream interface (where available)
Download (0.11MB)
Added: 2006-03-07 License: GPL (GNU General Public License) Price:
1329 downloads
Devel::Depend::Cpp 0.08
Devel::Depend::Cpp is a Perl module that can extract dependency trees from c files. more>>
Devel::Depend::Cpp is a Perl module that can extract dependency trees from c files.
SYNOPSIS
use Devel::Depend::Cpp;
my ($success, $includ_levels, $included_files)
= Devel::Depend::Cpp::Depend
(
undef, # use default cpp command
/usr/include/stdio.h,
, # switches to cpp
0, # include system includes
0, # dump cpp output in terminal
) ;
OUTPUT
include levels for /usr/include/stdio.h:
|- 1
| |- /usr/include/bits/stdio_lim.h
| |- /usr/include/bits/sys_errlist.h
| |- /usr/include/bits/types.h
| |- /usr/include/features.h
| |- /usr/include/libio.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
|- 2
| |- /usr/include/_G_config.h
| |- /usr/include/bits/typesizes.h
| |- /usr/include/bits/wordsize.h
| |- /usr/include/gnu/stubs.h
| |- /usr/include/sys/cdefs.h
| |- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stdarg.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
|- 3
| |- /usr/include/gconv.h
| |- /usr/include/wchar.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
|- 4
| |- /usr/include/bits/wchar.h
| |- /usr/include/wchar.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
`- 5
`- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
/usr/include/stdio.h included files:
|- /usr/include/_G_config.h
|- /usr/include/bits/stdio_lim.h
|- /usr/include/bits/sys_errlist.h
|- /usr/include/bits/types.h
|- /usr/include/bits/typesizes.h
|- /usr/include/bits/wchar.h
|- /usr/include/bits/wordsize.h
|- /usr/include/features.h
|- /usr/include/gconv.h
|- /usr/include/gnu/stubs.h
|- /usr/include/libio.h
|- /usr/include/sys/cdefs.h
|- /usr/include/wchar.h
|- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stdarg.h
`- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
/usr/include/stdio.h included files tree:
|- /usr/include/bits/stdio_lim.h
|- /usr/include/bits/sys_errlist.h
|- /usr/include/bits/types.h
| |- /usr/include/bits/typesizes.h
| |- /usr/include/bits/wordsize.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
|- /usr/include/features.h
| |- /usr/include/gnu/stubs.h
| `- /usr/include/sys/cdefs.h
|- /usr/include/libio.h
| |- /usr/include/_G_config.h
| | |- /usr/include/gconv.h
| | | |- /usr/include/wchar.h
| | | | |- /usr/include/bits/wchar.h
| | | | `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
| | | `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
| | |- /usr/include/wchar.h
| | `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stdarg.h
`- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
<<lessSYNOPSIS
use Devel::Depend::Cpp;
my ($success, $includ_levels, $included_files)
= Devel::Depend::Cpp::Depend
(
undef, # use default cpp command
/usr/include/stdio.h,
, # switches to cpp
0, # include system includes
0, # dump cpp output in terminal
) ;
OUTPUT
include levels for /usr/include/stdio.h:
|- 1
| |- /usr/include/bits/stdio_lim.h
| |- /usr/include/bits/sys_errlist.h
| |- /usr/include/bits/types.h
| |- /usr/include/features.h
| |- /usr/include/libio.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
|- 2
| |- /usr/include/_G_config.h
| |- /usr/include/bits/typesizes.h
| |- /usr/include/bits/wordsize.h
| |- /usr/include/gnu/stubs.h
| |- /usr/include/sys/cdefs.h
| |- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stdarg.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
|- 3
| |- /usr/include/gconv.h
| |- /usr/include/wchar.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
|- 4
| |- /usr/include/bits/wchar.h
| |- /usr/include/wchar.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
`- 5
`- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
/usr/include/stdio.h included files:
|- /usr/include/_G_config.h
|- /usr/include/bits/stdio_lim.h
|- /usr/include/bits/sys_errlist.h
|- /usr/include/bits/types.h
|- /usr/include/bits/typesizes.h
|- /usr/include/bits/wchar.h
|- /usr/include/bits/wordsize.h
|- /usr/include/features.h
|- /usr/include/gconv.h
|- /usr/include/gnu/stubs.h
|- /usr/include/libio.h
|- /usr/include/sys/cdefs.h
|- /usr/include/wchar.h
|- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stdarg.h
`- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
/usr/include/stdio.h included files tree:
|- /usr/include/bits/stdio_lim.h
|- /usr/include/bits/sys_errlist.h
|- /usr/include/bits/types.h
| |- /usr/include/bits/typesizes.h
| |- /usr/include/bits/wordsize.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
|- /usr/include/features.h
| |- /usr/include/gnu/stubs.h
| `- /usr/include/sys/cdefs.h
|- /usr/include/libio.h
| |- /usr/include/_G_config.h
| | |- /usr/include/gconv.h
| | | |- /usr/include/wchar.h
| | | | |- /usr/include/bits/wchar.h
| | | | `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
| | | `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
| | |- /usr/include/wchar.h
| | `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
| `- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stdarg.h
`- /usr/lib/gcc/i686-pc-linux-gnu/3.4.5/include/stddef.h
Download (0.020MB)
Added: 2007-05-29 License: Perl Artistic License Price:
879 downloads
Inline::CPP2XS 0.08
Inline::CPP2XS is capable of parsing correctly only that CPP code that is suitable for inclusion in an Inline::CPP script. more>>
The Inline::CPP2XS Perl module is deprecated. Please install the latest version of InlineX::CPP2XS.
SYNOPSIS
use Inline::CPP2XS qw(cpp2xs);
my $module_name = MY::XS_MOD;
my $package_name = MY::XS_MOD;
# $build_dir is an optional third arg
my $build_dir = /some/where/else;
# $config_opts is an optional fourth arg (hash reference)
my $config_opts = {AUTOWRAP => 1,
AUTO_INCLUDE => my_header.h,
TYPEMAPS => [my_typemap],
INC => -Imy/includes/dir,
};
# Create /some/where/else/XS_MOD.xs from ./src/XS_MOD.cpp
# Will also create the typemap file /some/where/else/CPP.map
# if that file is going to be needed to build the module:
cpp2xs($module_name, $package_name, $build_dir);
# Or create XS_MOD.xs (and CPP.map, if needed) in the cwd:
cpp2xs($module_name, $package_name);
The optional fourth arg (a reference to a hash) is to enable the writing of XS files using Inline::CPPs autowrap capability. It currently only accommodates 4 hash keys - AUTOWRAP, INC, AUTO_INCLUDE, and TYPEMAPS - though other keys may be added in in the future to accommodate additional functionality.
# Create XS_MOD.xs in the cwd, using the AUTOWRAP feature:
cpp2xs($module_name, $package_name, ., $config_opts);
Dont feed an actual Inline::CPP script to this module - it wont be able to parse it. It is capable of parsing correctly only that CPP code that is suitable for inclusion in an Inline::CPP script.
For example, here is a simple Inline::CPP script:
use warnings;
use Inline CPP => Config =>
BUILD_NOISY => 1,
CLEAN_AFTER_BUILD => 0;
use Inline CPP =><<less
SYNOPSIS
use Inline::CPP2XS qw(cpp2xs);
my $module_name = MY::XS_MOD;
my $package_name = MY::XS_MOD;
# $build_dir is an optional third arg
my $build_dir = /some/where/else;
# $config_opts is an optional fourth arg (hash reference)
my $config_opts = {AUTOWRAP => 1,
AUTO_INCLUDE => my_header.h,
TYPEMAPS => [my_typemap],
INC => -Imy/includes/dir,
};
# Create /some/where/else/XS_MOD.xs from ./src/XS_MOD.cpp
# Will also create the typemap file /some/where/else/CPP.map
# if that file is going to be needed to build the module:
cpp2xs($module_name, $package_name, $build_dir);
# Or create XS_MOD.xs (and CPP.map, if needed) in the cwd:
cpp2xs($module_name, $package_name);
The optional fourth arg (a reference to a hash) is to enable the writing of XS files using Inline::CPPs autowrap capability. It currently only accommodates 4 hash keys - AUTOWRAP, INC, AUTO_INCLUDE, and TYPEMAPS - though other keys may be added in in the future to accommodate additional functionality.
# Create XS_MOD.xs in the cwd, using the AUTOWRAP feature:
cpp2xs($module_name, $package_name, ., $config_opts);
Dont feed an actual Inline::CPP script to this module - it wont be able to parse it. It is capable of parsing correctly only that CPP code that is suitable for inclusion in an Inline::CPP script.
For example, here is a simple Inline::CPP script:
use warnings;
use Inline CPP => Config =>
BUILD_NOISY => 1,
CLEAN_AFTER_BUILD => 0;
use Inline CPP =><<less
Download (0.007MB)
Added: 2007-05-30 License: Perl Artistic License Price:
877 downloads
Autodia::Handler::Cpp 2.03
Autodia::Handler::Cpp Perl module is an AutoDia handler for C++. more>>
Autodia::Handler::Cpp Perl module is an AutoDia handler for C++.
This module parses files into a Diagram Object, which all handlers use. The role of the handler is to parse through the file extracting information such as Class names, attributes, methods and properties.
HandlerPerl parses files using simple perl rules. A possible alternative would be to write HandlerCPerl to handle C style perl or HandleHairyPerl to handle hairy perl.
HandlerPerl is registered in the Autodia.pm module, which contains a hash of language names and the name of their respective language - in this case:
%language_handlers = { .. , cpp => "Autodia::Handler::Cpp", .. };
CONSTRUCTION METHOD
use Autodia::Handler::Cpp;
my $handler = Autodia::Handler::Cpp->New(%Config);
This creates a new handler using the Configuration hash to provide rules selected at the command line.
ACCESS METHODS
This parses the named file and returns 1 if successful or 0 if the file could not be opened.
$handler->output_xml(); # interpolates values into an xml or html template
$handler->output_graphviz(); # generates a gif file via graphviz
<<lessThis module parses files into a Diagram Object, which all handlers use. The role of the handler is to parse through the file extracting information such as Class names, attributes, methods and properties.
HandlerPerl parses files using simple perl rules. A possible alternative would be to write HandlerCPerl to handle C style perl or HandleHairyPerl to handle hairy perl.
HandlerPerl is registered in the Autodia.pm module, which contains a hash of language names and the name of their respective language - in this case:
%language_handlers = { .. , cpp => "Autodia::Handler::Cpp", .. };
CONSTRUCTION METHOD
use Autodia::Handler::Cpp;
my $handler = Autodia::Handler::Cpp->New(%Config);
This creates a new handler using the Configuration hash to provide rules selected at the command line.
ACCESS METHODS
This parses the named file and returns 1 if successful or 0 if the file could not be opened.
$handler->output_xml(); # interpolates values into an xml or html template
$handler->output_graphviz(); # generates a gif file via graphviz
Download (0.060MB)
Added: 2007-05-29 License: Perl Artistic License Price:
880 downloads
CPP Socket library 0.8.4
CPP Socket library is a small Classlibrary for C++ that supports a easy usage of socket-programming for networking-software. more>>
CPP Socket library is a small Classlibrary for C++ that supports a easy usage of socket-programming for networking-software.
It provides a simple object-oriented interface to the classic C library calls.
With CPPSocket supports the following network protocols:
- TCP (transmission control protocol; needs an established connection from one host to another)
- UDP (user datagram protocol; packets can be sent without an established connection)
- IPv4 (internet protocol version 4; uses 32-bit network addresses)
These protocols are what may also be called TCP/IP.
The library provides two layers of abstraction:
- Low-Level
This is a simple oo interface of the classic socket calls. But it provides some (optional) abstractions for addressing and buffering.
Usefull for more experienced programmers, that have already worked with classic sockets.
- High-Level
This provides somewhat more abstraction and ignores some functionality of the full blown sockets.
But nevertheless it is quite usefull and makes programming of networking software very easy.
So its intended to be used by novice programmers or those who dont want the maximum complexity/flexibility but an easy to use network-interface.
<<lessIt provides a simple object-oriented interface to the classic C library calls.
With CPPSocket supports the following network protocols:
- TCP (transmission control protocol; needs an established connection from one host to another)
- UDP (user datagram protocol; packets can be sent without an established connection)
- IPv4 (internet protocol version 4; uses 32-bit network addresses)
These protocols are what may also be called TCP/IP.
The library provides two layers of abstraction:
- Low-Level
This is a simple oo interface of the classic socket calls. But it provides some (optional) abstractions for addressing and buffering.
Usefull for more experienced programmers, that have already worked with classic sockets.
- High-Level
This provides somewhat more abstraction and ignores some functionality of the full blown sockets.
But nevertheless it is quite usefull and makes programming of networking software very easy.
So its intended to be used by novice programmers or those who dont want the maximum complexity/flexibility but an easy to use network-interface.
Download (MB)
Added: 2006-09-07 License: GPL (GNU General Public License) Price:
678 downloads
GPP 2.24
GPP is a generic preprocessor with customizable syntax. more>>
GPP is a general-purpose preprocessor with customizable syntax, suitable for a wide range of preprocessing tasks. Its independence from any programming language makes it much more versatile than cpp, while its syntax is lighter and more flexible than that of m4.
GPP is targeted at all common preprocessing tasks where cpp is not suitable and where no very sophisticated features are needed. In order to be able to process equally efficiently text files or source code in a variety of languages, the syntax used by GPP is fully customizable. The handling of comments and strings is especially advanced.
Initially, GPP only understands a minimal set of built-in macros, called meta-macros. These meta-macros allow the definition of user macros as well as some basic operations forming the core of the preprocessing system, including conditional tests, arithmetic evaluation, wildcard matching (globbing), and syntax specification.
All user macro definitions are globali.e., they remain valid until explicitly removed; meta-macros cannot be redefined. With each user macro definition GPP keeps track of the corresponding syntax specification so that a macro can be safely invoked regardless of any subsequent change in operating mode.
In addition to macros, GPP understands comments and strings, whose syntax and behavior can be widely customized to fit any particular purpose. Internally comments and strings are the same construction, so everything that applies to comments applies to strings as well.
Syntax
gpp [-{o|O} outfile] [-I/include/path] [-Dname=val ...]
[-z|+z] [-x] [-m] [-C|-T|-H|-X|-P|-U ... [-M ...]]
[-n|+n] [+c str1 str2] [+s str1 str2 c]
[-c str1] [--nostdinc] [--nocurinc]
[--curdirinclast] [--warninglevel n]
[--includemarker str] [--include file]
[infile]
gpp --help
gpp --version
<<lessGPP is targeted at all common preprocessing tasks where cpp is not suitable and where no very sophisticated features are needed. In order to be able to process equally efficiently text files or source code in a variety of languages, the syntax used by GPP is fully customizable. The handling of comments and strings is especially advanced.
Initially, GPP only understands a minimal set of built-in macros, called meta-macros. These meta-macros allow the definition of user macros as well as some basic operations forming the core of the preprocessing system, including conditional tests, arithmetic evaluation, wildcard matching (globbing), and syntax specification.
All user macro definitions are globali.e., they remain valid until explicitly removed; meta-macros cannot be redefined. With each user macro definition GPP keeps track of the corresponding syntax specification so that a macro can be safely invoked regardless of any subsequent change in operating mode.
In addition to macros, GPP understands comments and strings, whose syntax and behavior can be widely customized to fit any particular purpose. Internally comments and strings are the same construction, so everything that applies to comments applies to strings as well.
Syntax
gpp [-{o|O} outfile] [-I/include/path] [-Dname=val ...]
[-z|+z] [-x] [-m] [-C|-T|-H|-X|-P|-U ... [-M ...]]
[-n|+n] [+c str1 str2] [+s str1 str2 c]
[-c str1] [--nostdinc] [--nocurinc]
[--curdirinclast] [--warninglevel n]
[--includemarker str] [--include file]
[infile]
gpp --help
gpp --version
Download (0.059MB)
Added: 2005-04-13 License: LGPL (GNU Lesser General Public License) Price:
1669 downloads
sqlpp 0.06
sqlpp Perl package is a SQL preprocessor. more>>
sqlpp Perl package is a SQL preprocessor.
sqlpp is a conventional cpp-alike preprocessor taught to understand SQL ( PgSQL, in particular) syntax specificities. In addition to the standard #define/#ifdef/#else/#endif cohort, provides also #perldef for calling arbitrary perl code.
SYNOPSIS
sqlpp [options] filename
options:
-I path - include path
-D var[=value] - define variable
-o output - output to file ( default to stdout )
-h,--help - display this text
-hh - display man page
SYNTAX
#define TAG
Identical to cpp
#define TAG([PARAMETERS]) MACRO
Not fully identical to cpp, the behavior is slightly different. Concatenation ( a ## b ) and stringification ( # a ) behave similar to as in cpp.
The multiline macro can be declared either tranditionally via CPP backslash line continuation, or a perls heredoc style. In the latter case, TAG must be prepended with<<less
sqlpp is a conventional cpp-alike preprocessor taught to understand SQL ( PgSQL, in particular) syntax specificities. In addition to the standard #define/#ifdef/#else/#endif cohort, provides also #perldef for calling arbitrary perl code.
SYNOPSIS
sqlpp [options] filename
options:
-I path - include path
-D var[=value] - define variable
-o output - output to file ( default to stdout )
-h,--help - display this text
-hh - display man page
SYNTAX
#define TAG
Identical to cpp
#define TAG([PARAMETERS]) MACRO
Not fully identical to cpp, the behavior is slightly different. Concatenation ( a ## b ) and stringification ( # a ) behave similar to as in cpp.
The multiline macro can be declared either tranditionally via CPP backslash line continuation, or a perls heredoc style. In the latter case, TAG must be prepended with<<less
Download (0.010MB)
Added: 2007-05-30 License: Perl Artistic License Price:
877 downloads
HappyHTTP 0.1
HappyHTTP is a simple C++ library for issuing HTTP requests and processing responses. more>>
HappyHTTP is a simple C++ library for issuing HTTP requests and processing responses.
Main features:
- Simple to integrate - just drop in the .h and .cpp files
- Easy-to-use interface (example)
- Non-blocking operation, suitable for use in game update loops
- Supports pipelining. You can issue multiple requests without waiting for responses.
- Licensed under the zlib/libpng license.
- Cross-platform (Linux, OSX, Windows, at least)
Usage:
The interface is based loosely on Pythons httplib. Ive kept the same terminology where possible.
All HappyHTTP code is kept within the happyhttp namespace
To issue and process a HTTP request, the basic steps are:
- Create a connection object
- Set up callbacks for handling responses
- Issue request(s)
- pump the connection at regular intervals. As responses are received, the callbacks will be invoked.
<<lessMain features:
- Simple to integrate - just drop in the .h and .cpp files
- Easy-to-use interface (example)
- Non-blocking operation, suitable for use in game update loops
- Supports pipelining. You can issue multiple requests without waiting for responses.
- Licensed under the zlib/libpng license.
- Cross-platform (Linux, OSX, Windows, at least)
Usage:
The interface is based loosely on Pythons httplib. Ive kept the same terminology where possible.
All HappyHTTP code is kept within the happyhttp namespace
To issue and process a HTTP request, the basic steps are:
- Create a connection object
- Set up callbacks for handling responses
- Issue request(s)
- pump the connection at regular intervals. As responses are received, the callbacks will be invoked.
Download (0.013MB)
Added: 2006-05-10 License: zlib/libpng License Price:
1262 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above cpp search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
Contact Us | Submit Software | Advertise with us | Terms and Conditions | Privacy Policy | Publisher List | Browse Categories | Blog | Discussion Board
Copyright (c)2005-2009 WareSeeker.com. All rights reserved.
Copyright (c)2005-2009 WareSeeker.com. All rights reserved.