Free int software for linux

Inline::C is a Perl module that can Write Perl Subroutines in C.

Inline::C is a module that allows you to write Perl subroutines in C. Since version 0.30 the Inline module supports multiple programming languages and each language has its own support module. This document describes how to use Inline with the C programming language. It also goes a bit into Perl C internals.

If you want to start working with programming examples right away, check out Inline::C-Cookbook. For more information on Inline in general, see Inline.

Usage

You never actually use Inline::C directly. It is just a support module for using Inline.pm with C. So the usage is always:
use Inline C => ...;
or
bind Inline C => ...;

Function Definitions

The Inline grammar for C recognizes certain function definitions (or signatures) in your C code. If a signature is recognized by Inline, then it will be available in Perl-space. That is, Inline will generate the "glue" necessary to call that function as if it were a Perl subroutine. If the signature is not recognized, Inline will simply ignore it, with no complaints. It will not be available from Perl-space, although it will be available from C-space.

Inline looks for ANSI/prototype style function definitions. They must be of the form:

return-type function-name ( type-name-pairs ) { ... }

The most common types are: int, long, double, char*, and SV*. But you can use any type for which Inline can find a typemap. Inline uses the typemap file distributed with Perl as the default. You can specify more typemaps with the TYPEMAPS configuration option.

A return type of void may also be used. The following are examples of valid function definitions.

int Foo(double num, char* str) {
void Foo(double num, char* str) {
SV* Foo() {
void Foo(SV*, ...) {
long Foo(int i, int j, ...) {

The following definitions would not be recognized:

Foo(int i) { # no return type
int Foo(float f) { # no (default) typemap for float
int Foo(num, str) double num; char* str; {
void Foo(void) { # void only valid for return type

Notice that Inline only looks for function definitions, not function prototypes. Definitions are the syntax directly preceeding a function body. Also Inline does not scan external files, like headers. Only the code passed to Inline is used to create bindings; although other libraries can linked in, and called from C-space.

passwd_info is a simple program that can query the /etc/passwd file for current user or specified user.

USAGE: passwd_info [username]

Sample:

#include < unistd.h >
#include < stdlib.h >
#include < stdio.h >
#include < sys/types.h >
#include < pwd.h >
#include < string.h >

struct passwd *pw;

void print_usage(void);

int main( int argc, char *argv[] )
{
if ( argc > 2 ) {
print_usage();
exit(1);
}

char *name;
uid_t uid;
gid_t gid;
char *gecos;
char *dir;
char *shell;

char *user_arg;

if ( argv[1] != NULL ) {
user_arg=(char *)malloc(strlen(argv[1]));
strcpy( user_arg, argv[1] );
if ( (pw = getpwnam(user_arg) ) == NULL ) {
fprintf( stderr, "Error: user %s does not existn", user_arg );
exit(1);
}
uid = pw->pw_uid;
free(user_arg);
}
else /* get for current user */
{
uid = getuid();
pw = getpwuid(uid);
}

name = pw->pw_name;
gid = pw->pw_gid;
gecos = pw->pw_gecos;
dir = pw->pw_dir;
shell = pw->pw_shell;

printf( "/etc/passwd file information for %sn", name );
printf( "Username = %stUID = %dtGID = %dn", name, (int)uid, (int)gid );
printf( "GECOS = %snHome = %stShell = %sn", gecos, dir, shell );

exit(0);
}

void print_usage( void )
{
fprintf( stderr, "USAGE: passwd_info [username]n" );
}

hcritsec is a C++ class for Critical Sections in programs.
hcritsec can be used to define a critical section in a program. It can be used in a recursive way. So functions that are nested can call the enter and leave functions recursively (see section Synopsys).
A critical section class is typically shared between threads, or is part of an object or variable that is shared between threads.
It can be used to gain exclusive access to shared resources or variables.
Synopsys
(...)
void thread_class::calc(int *t)
{
S->enter();
*t+=1;
S->leave();
}
void thread_class::run(void)
{
for(i=0;ienter();
calc(t);
S->leave();
}
}
(...)
int main()
{
hcrisec S;
int t=0;
thread_class t1(&S,&t),t2(&s,&t)
t1.start();
t2.start();
thread_class::join(t1,t2);
return 0;
}
Restrictions
- You may not copy an object of class critsec. Allways use a pointer to share the object between threads.
- If hcritsec throws a fatal error, this will allways be of type std::string.

Inline::CPR is C Perl Run. Embed Perl in C, ala Inline

SYNOPSIS

#!/usr/local/bin/cpr

int main(void) {

printf("Hello World, Im running under Perl version %sn",
CPR_eval("use Config; $Config{version}")
);

return 0;
}

Is it C? Is it Perl? Its neither, its both. Its CPR!

CPR (C Perl Run) is a "new language" that looks like C. You dont need to compile it. You just run it, much like Perl. As an added bonus, youll get access to the full internals of Perl via the CPR API.

The idea is that you just put a CPR hashbang at the top of your C program and run it like a script. The CPR interpreter will run your C code under Perl.

If your hash doesnt bang, you can run your program like this:

cpr synopsis.cpr

The GBrainFuck interpreter (gbf for short) is an interpreter for this language. It is more memory-effective than processor-effective, and it has room for optimization (especially on the code dealing with "[" and "]").

The interpreter is very like a Turing machine: it has an infinite tape, divided in cells that contain the value 0, which can move forward and backward; also, it has a controller unit, that reads, writes and moves the tape. Data in the cells are the size an int in the host machine (usually 32- or 64-bit)

Along with the interpreter, I put various BrainFuck sample programs, of which one of the most intersting is the BrainFuck interpreter in BrainFuck. I hope you enjoy.