Free cc software for linux

B::CC is Perl compilers optimized C translation backend.

SYNOPSIS

perl -MO=CC[,OPTIONS] foo.pl

This compiler backend takes Perl source and generates C source code corresponding to the flow of your program. In other words, this backend is somewhat a "real" compiler in the sense that many people think about compilers. Note however that, currently, it is a very poor compiler in that although it generates (mostly, or at least sometimes) correct code, it performs relatively few optimisations. This will change as the compiler develops. The result is that running an executable compiled with this backend may start up more quickly than running the original Perl program (a feature shared by the C compiler backend--see B::C) and may also execute slightly faster. This is by no means a good optimising compiler--yet.

OPTIONS

If there are any non-option arguments, they are taken to be names of objects to be saved (probably doesnt work properly yet). Without extra arguments, it saves the main program.

-ofilename

Output to filename instead of STDOUT

-v

Verbose compilation (currently gives a few compilation statistics).

--

Force end of options

-uPackname

Force apparently unused subs from package Packname to be compiled. This allows programs to use eval "foo()" even when sub foo is never seen to be used at compile time. The down side is that any subs which really are never used also have code generated. This option is necessary, for example, if you have a signal handler foo which you initialise with $SIG{BAR} = "foo". A better fix, though, is just to change it to $SIG{BAR} = &foo. You can have multiple -u options. The compiler tries to figure out which packages may possibly have subs in which need compiling but the current version doesnt do it very well. In particular, it is confused by nested packages (i.e. of the form A::B) where package A does not contain any subs.

-mModulename

Instead of generating source for a runnable executable, generate source for an XSUB module. The boot_Modulename function (which DynaLoader can look for) does the appropriate initialisation and runs the main part of the Perl source that is being compiled.

-D

Debug options (concatenated or separate flags like perl -D).

-Dr

Writes debugging output to STDERR just as its about to write to the programs runtime (otherwise writes debugging info as comments in its C output).

-DO

Outputs each OP as its compiled

-Ds

Outputs the contents of the shadow stack at each OP

-Dp

Outputs the contents of the shadow pad of lexicals as its loaded for each sub or the main program.

-Dq

Outputs the name of each fake PP function in the queue as its about to process it.

-Dl

Output the filename and line number of each original line of Perl code as its processed (pp_nextstate).

-Dt

Outputs timing information of compilation stages.

-f

Force optimisations on or off one at a time.

-ffreetmps-each-bblock

Delays FREETMPS from the end of each statement to the end of the each basic block.

-ffreetmps-each-loop

Delays FREETMPS from the end of each statement to the end of the group of basic blocks forming a loop. At most one of the freetmps-each-* options can be used.

-fomit-taint

Omits generating code for handling perls tainting mechanism.

-On

Optimisation level (n = 0, 1, 2, ...). -O means -O1. Currently, -O1 sets -ffreetmps-each-bblock and -O2 sets -ffreetmps-each-loop.

The ccbuild goal is to allow the developer to run only one command: ccbuild. ccbuild program will then find out what it should do on its own, and start updating any source connected to your current programs (by looking at #include statements).
Currently the program can do this using only the information from your source code and a file containing information about compilation parameters that are needed when a specific global include ("#include ") is used.
The main difference with other build tools is that, during the development phase, ccbuild should be able to find its own way: no part of the build should have to be scripted! This is also why ccbuild is very system specific and only runs on Linux (and hopfully any other platform that looks like it).
When developing C++ programs according to a standard of "a file per function, a directory per class" your filesystem will be in constant turmoil. When you use the GNU autotools you will have to edit your Makefile.am for every function and sometimes let the tools re-evaluate your whole system!
This, of course, will not do. So, I set out to create a tool to aid me in my development phase. Mind you, the autotools are great for portability and distribution, but during development they kept me from good coding ethics.
Main features:
- Fully automated building, with only one simple command.
- Automatic dependency resolution by reading the sourcecode.
- Automatic binary target resolution.
- Semi-automatic library and linking resolution (via a simple configuration file).
- Specific object file cleaning.
- Separation of object files an source by using an "o" directory for output.
- Monolithic makefile generation (without a clean rule at the moment).
- Header include graphs using the Graphviz DOT language (example).
- Support for ".cc" and ".cpp" extensions.
When run without any options ccbuild will issue the command "build". For every .cc file in the local directory: if it contains an "int main" function, it will be seen as a binary target. For every binary target, ccbuild will follow its includes to other directories and see all .cc files in those directories as objects (if they dont have an "int main" function). It will then compile the object, keeping any linker options back for the binary target. To know what linker options to use, see Resolution.
To be able to link the binary, the compiler needs to know what libraries to link to and of course what include paths need to be added. The ccbuild utility assumes that for every extra comipler argument, there is a global include that can indicate its needed.
When a global include is encountered ("#include ") it will try to resolve it by looking it up in its table, issueing a warning if it is not found in the resolution table or in "/usr/include" or in "/usr/include/g++-3/". The table of resolutions is loaded from tab saperated configuration files "ccResolutions" and "~/.ccbuild/ccResolutions" (in that order).
Currently this can only support options for either link OR compile time. (See TODO: "Propper...") Which means you cannot mix "-I" (include) and "-l" (library) options yet.
An example configuration file wich currently is useful is (notice the tab between "png.h" and "-lstdc++ -lpng -lz"):
png.h -lstdc++ -lpng -lz
sqlite3.h -lsqlite3
Version restrictions:
- Any source file that needs to be compiled into an executable must contain a main function returning an int.
- All code needed for a class must be contained in one directory (all .cc files are taken to be object targets for the main program including the header in the same directory).
- Currently source files need to have one of these extensions: .cc, .cpp, .h, .hh, .ih, .tcc. Any other extension is not seen or interpreted in the wrong way.

ccextractor project is a fast closed captions extractor for MPEG files.
ccextractor is mostly a mildly optimized C port of McPoodles excellent but painfully slow Perl script SCC_RIP. It lets you rip the raw closed captions (read: subtitles) data from a number of sources, such as DVD or replay TV.
As an added bonus compared to the original SCC_RIP, ccextractor can extract subtitles from the HDTV transport streams that are becoming more common.
At this point ccextractor extracts the line 21 captions (which must legally be present for a number of years until the transition to digital is complete). Note that in most .ts you can find, there will be subtitle data for both analog (EIA-608) decoders and digital (EIA-708). AFAIK there are not
freely available EIA-708 rippers.
Anyway, since line 21 captions will be available for some time, we have time to build a decent 708 ripper.
Basic Usage
For details on CC, please go to McPoodles page:
http://www.geocities.com/mcpoodle43/SCC_TOOLS/DOCS/SCC_TOOLS.HTML
You will need his tools to use ccextrators output.
The basic idea is that you get the raw closed caption dump from ccextractor.
Then you need other tools (which vary depending on what you want to do) to continue processing.
To get a transcript from a .ts file in .srt (I assume this will be the most common use) do this:
ccextractor -12 input_file
-12 means "extract both subtitle tracks" (actually technical names are fields but tracks is easier to understand). 1 is almost always English. 2 is Spanish in HBO (at least in the few samples Ive seen) but could be anything. Just extract both of them and check.
Example: cctractor -12 house315.ts
ccextractor will create two files, called house315_1.bin and _2.
Then use McPoodles RAW2SCC to create a temporary SCC file (means Scenerist, which is originally the native format for some program, its not important here).
raw2scc house315_1.bin
This creates house315_1.scc
From this .scc file, you can get the final .srt by using McPoodles CCASDI:
ccasdi -s house315_1.srt
Which looks like this (just 3 random lines shown).
514
00:24:07,400 --> 00:24:09,300
Theyve got another trial
going on at Duke.
515
00:24:09,367 --> 00:24:12,567
15% extend their lives
beyond five years.
516
00:24:12,634 --> 00:24:13,701
If youre positive
for protein PHF--
Enhancements:
- This release adds support for DVR-MS files.
- It improves the CC decoder.
- There are several bugfixes, a major speed boost (20%-40%), improved timing for non-TS files, improved format autodetection, and other minor improvements.

Google::Adwords::AccountService is a Perl module to interact with the Google Adwords AccountService API calls.

SYNOPSIS

use Google::Adwords::AccountService;
use Google::Adwords::AccountInfo;
use Google::Adwords::CoverageType;
use Google::Adwords::EmailPromotionsPreferences;
use Google::Adwords::CreditCard;
use Google::Adwords::Address;

my $service = Google::Adwords::AccountService->new();

# login to the Adwords server
$service->email($email)
->password($password)
->clientEmail($cemail)
->applicationToken($app_token)
->developerToken($dev_token);

# getAccountInfo
my $account = $service->getAccountInfo();
print "currencyCode : " . $account->currencyCode . "n";
print "descriptiveName : " . $account->descriptiveName . "n";

# getClientAccounts
my @emailaccounts = $service->getClientAccounts();
print "getClientAccounts : " . join(|, @emailaccounts) . "n";

# getCreditCard
my $creditcard = $service->getCreditCard();

# setLoginInfo
my $ret_setlogininfo= $service->setLoginInfo(email@example.com, toto);

# setLocalTimezone to brrr ...
my $ret_setlocaltimezone = $service->setLocalTimezone(America/Anchorage);

# setCreditCard
my $cc = Google::Adwords::CreditCard->new
->cardNumber(12345678912346)
->cardType(VISA)
->cardVerificationNumber(123)
->expirationMonth(1)
->expirationYear(2008);

my $addr = Google::Adwords::Address->new
->addressLine1(down the street)
->city(Paris)
->companyName(Up there)
->countryCode(FR)
->emailAddress(me@example.com)
->name(Up there)
->phoneNumber(+33112345678)
->postalCode(75020);

my $ret_setcreditcard = $service->setCreditCard($cc, $addr);

# createAdWordsAccount
my $emailPrefs = Google::Adwords::EmailPromotionsPreferences->new
->marketResearchEnabled(1)
->newsletterEnabled(1)
->promotionsEnabled(0);

my $covType = Google::Adwords::CoverageType->new
->optInContentNetwork(0)
->optInSearchNetwork(1);

my $ret = $service->createAdWordsAccount({
loginEmail => $loginEmail,
password => $password,
languagePreference => $lgPref,
emailPrefs => $emailPrefs,
currencyCode => $curCode,
cardInfo => $creditcard,
contactInfo => $address,
defaultAdsCoverage => $covType,
timeZoneId => $timeZoneId
});

# updateAccountInfo
$account->primaryBusinessCategory(Advertising, Marketing, SEO);
my $ret_updateaccountinfo = $service->updateAccountInfo($account);

This module provides an interface to the Google Adword AccountService API calls.

C# for Emacs is a derived mode implementing most of the C# rules.

After a good number of years, we noticed that there wasnt a "non-patched" version of a csharp-mode for Emacs.

There were a few, but most of them had comments that they were "in progress" or "about to merge", but then we noticed that those notices were there even after a couple of months.

Then, we saw a request for a csharp-mode on the cc-mode Emacs site, so we decided to follow the rules and create one that required no patching or modification to the core cc-mode engine (which is a good thing). So, this is the C# mode.
There was a 0.3.0 version, but it broke things more than it fixed, so we pulled it.

This is Comfortable FTP, a full screen ftp client.
Supported are FTP both with active and passive data connections,
IPv4 and IPv6, and SFTP (a file transfer protocol using SSH for
authorization and connection encryption).
SFTP support is somewhat preliminary: It requires SSH protocol
version 2 with a configured sftp subsystem on the server. It doesnt support resuming transfers.
For generic installation instructions, see file `INSTALL; for
documentation read the info file `cftp.info. For key bindings, see
the file `bindings.desc.
In cftp, press H for help.
The texinfo documentation is a mess; any help most welcome
(especially the outline of a good structure).
If you make a binary distribution, please include a pointer to the
distribution site:
ftp.giga.or.at /pub/nih/cftp
http://ftp.giga.or.at/pub/nih/cftp
The latest version can always be found there and on the backup site:
sunsite.univie.ac.at /pub/nih/cftp
http://sunsite.univie.ac.at/pub/nih/cftp
Enhancements:
- configure.in: step version number to 0.12.
- util.c (xdirname): rename and adapt callers, declare argument const.
- display.h, functions.h (struct function), list.c: fix missing prototype warnings from IRIX cc.
- mkbind.c: remove definition of global defined in functions.c.

THC-Flood Connect is a connection flooding tool which supports SSL, dumping + sending data, closing or keeping sessions etc.

Just a small release. Have fun.

Use allowed only for legal purposes.

To compile:

cc -o flood_connect -O2 flood_connect.c
openssl: cc -o flood_connect -O2 flood_connect.c -DOPENSSL -lssl -lcrypt

Options:

-S use SSL after TCP connect (not usuable with -u, sets port=443)
-u use UDP protocol (default: TCP) (not usable with -c)
-p port port to connect to (default: %d)
-f forks number of forks to additionally spawn (default: 0)
-i file data to send to the port (default: none)
-n connects maximum number of connects (default: unlimited)
-N delay delay between connects in ms (default: 0)
-c close after connect (and sending data, if used with -i)
use twice to shutdown SSL sessions hard (-S -c -c)
-C delay delay before closing the port (for use with -c) (default: 0)
-d dump data read from server
-D delay delay before trying to read+dump data from server (default: 0)
-e stop when no more connects possible (default: retry forever)
-k no keep-alive after finnishing with connects, terminate!
-v verbose mode
TARGET target to flood attack (ip or dns)

PDBCat can be used to manipulate and process PDB files using commonly available tools such as Perl, awk, etc.

Written by Andrew Dalke of the Theoretical Biophysics Group, Beckman Institute, University of Illinois. None of us are liable for any bugs, errors, or misconceptions. You may use this program freely and for free for non-comercial use. You may redistribute and modify the code as long as I am given credit for my part of the work.

Installation

1) uncompress and untar the source

% cat pdbcat_1.tar.Z | uncompress | tar -xf -

2) change to the pdbcat directory and run make

% cd pdbcat; make

3) If it complains about not finding CC, then youll have to edit the Makefile and set CC equal to your local C++ compilier, for instance, for gcc:

CC=gcc

4) If there is a problem with strcasecmp, uncomment the following line in the Makefile:

#DEF = -DNOSTRCASECMP

update the time stamp on the file Common.C

% touch Common.C

and run make again

Usage

pdbcat {-fields | -columns} [[-f] files]

Read any pdb file from stdin or list of files and convert the data to either a column based or field based pdb file. A # represents an empty field. This is useful for field based tools like awk. The default output is columns.