Free uppercase software for linux

QPBPManager is a PBP File manager for Linux. The software is intended to use as a user friendly GUI to the known tedious pack and unpack processes of the PSP PBP files, directory generation and further copy into the PSP, in order to execute those binary files in PSPs with firmware 1.50.
QPSPManager automates this process to make it a simple task to the end user, who will only have to select a PBP file and the PSP directory, leaving all other tasks to the program. It also provides some other cool features such as selecting custom PNG, PMF and AT3 files to use as an icon or background in the PSP menu.
QPBPManager also allows the user to backup the savegames to the computer and copy those savegames later to the PSP.
Main features:
- Unpacks PBP files and selects automatically the icon and background files from the source file.
- Extracts the program name included in the PBP file and sets it as default output directory.
- Extracts the ELF of the PBP file and packs a fake PBP file without the ELF for showing in the menu of the PSP.
- Allows to select custom icon and background files to use in the menu.
- Allows to select custom video and music files to use in the menu.
- Allows to select the output directory on the PSP and the actual PSP directory, which is saved as an option for further usages, so you only have to configure it once (as long as the PSP directory does not change).
- Provides support for backup the savegames on the PSP to the computer and viceversa.
Although QPSPManager was mainly designed only to transfer PBP files into the PSP so they can be executed through the memory stick menu, Im thinking about new features in future versions non related to PBP file management. Some of those features:
- Conversion and transfering of any kind of video file. It will allow to convert all kind of video files into the PSP format and transfer the files to the PSP to allow viewing them on the console.
- Conversion and transfering of any kind of audio file. It will allow to convert all kind of audio files into the PSP format (mp3) and transfer the files to the PSP to allow hearing them on the console.
Enhancements:
- Added ISO/CISO compression/decompression and transfer support.
- Fixed bug where you couldnt rename a directory in the PSP.
- Changed renaming policy for kxploit.
- Copy file routine changed.
- Support for different linux distributions where mount options change the filenames of the mounted PSP to uppercase.

Password Creator is a great tool to generate passwords with criteria like uppercase letters, numbers or even specified characters.
It has virtually no limitation on the pasword length and the password quantity or the characters to use.
Enhancements:
- Fixed the excellent rating bug when one character length.
- Fixed pronoucable passwords to not start with two vowels.

ProGuard is a free Java class file shrinker, optimizer, and obfuscator. ProGuard project can detect and remove unused classes, fields, methods, and attributes. It can then optimize bytecode and remove unused instructions.
Finally, it can rename the remaining classes, fields, and methods using short meaningless names. The resulting jars are smaller and harder to reverse-engineer.
More compact jar files also means smaller storage requirements, faster transfer of applications across networks, faster loading, and smaller memory footprints.
ProGuards main advantage compared to other Java obfuscators is probably its compact template-based configuration. A few intuitive command line options or a simple configuration file are usually sufficient. For instance, the following configuration option preserves all applets in a jar:
-keep public class * extends java.applet.Applet
The user manual explains all available options and shows more examples of this powerful configuration style.
ProGuard is fast. It only takes seconds to process programs and libraries of several megabytes. The results section presents actual figures for a number of applications.
ProGuard is a command-line tool with an optional graphical user interface. It also comes with plugins for Ant and for the J2ME Wireless Toolkit.
ProGuard is a Java class file shrinker, optimizer, and obfuscator. The shrinking step detects and removes unused classes, fields, methods, and attributes. The optimization step analyzes and optimizes the bytecode of the methods. The obfuscation step renames the remaining classes, fields, and methods using short meaningless names. The resulting jars are smaller and harder to reverse-engineer.
ProGuard can also be used to list unused fields and methods in an application, and to print out the internal structure of class files.
ProGuard typically reads the input jars (or wars, ears, zips, or directories). It then shrinks, optimizes, and obfuscates them. It then writes the results to one or more output jars (or wars, ears, zips, or directories). The input jars can optionally contain resource files. ProGuard copies all non-class resource files from the input jars to the output jars. Their names and contents remain unchanged.
ProGuard requires the library jars (or wars, ears, zips, or directories) of the input jars to be specified. It can then reconstruct class hierarchies and other class dependencies, which are necessary for proper shrinking, optimization, and obfuscation. The library jars themselves always remain unchanged. You should still put them in the class path of your final application.
In order to determine which code has to be preserved and which code can be discarded or obfuscated, you have to specify one or more entry points to your code. These entry points are typically classes with main methods, applets, midlets, etc.
- In the shrinking step, ProGuard starts from these seeds and recursively determines which classes and class members are used. All other classes and class members are discarded.
- In the optimization step, ProGuard further optimizes the code. Among other optimizations, classes and methods that are not entry points can be made final, and some methods may be inlined.
- In the obfuscation step, ProGuard renames classes and class members that are not entry points. In this entire process, keeping the entry points ensures that they can still be accessed by their original names.
Any classes or class members of your code that are created or invoked dynamically (that is, by name) have to be specified as entry points too. It is generally impossible to determine these cases automatically, but ProGuard will offer some suggestions if keeping some classes or class members appears necessary. For proper results, you should at least be somewhat familiar with the code that you are processing.
ProGuard does handle Class.forName("SomeClass") and SomeClass.class constructs automatically. The referenced classes are preserved in the shrinking phase, and the string arguments are properly replaced in the obfuscation phase. With variable string arguments, it is generally impossible to determine their possible values (they might be read from a configuration file, for instance).
However, as mentioned, ProGuard will note constructs like "(SomeClass)Class.forName(variable).newInstance()". These might be an indication that the class or interface SomeClass and/or its implementations may need to be preserved. You can then adapt your configuration accordingly.
Whats New in 3.9 Stable Release:
- This release fixes a number of bugs.
- Notably, ".class" constructs compiled in Java 6 are now handled correctly.
- The optimization step now avoids a possible division by 0 and correctly processes local variables with indices larger than 255.
- The documentation and examples have been updated.
Whats New in 4.0 Beta Development Release:
- Added preverifier for Java 6 and Java Micro Edition, with new option -dontpreverify.
- Added new option -target to modify java version of processed class files.
- Made -keep options more orthogonal and flexible, with option modifiers allowshrinking, allowoptimization, and allowobfuscation.
- Added support for configuration by means of annotations.
- Improved shrinking of unused annotations.
- Added check on modification times of input and output, to avoid unnecessary processing, with new option -forceprocessing.
- Added new options -flattenpackagehierarchy and -repackageclasses (replacing -defaultpackage) to control obfuscation of packages names.
- Added new options -adaptresourcefilenames and -adaptresourcefilecontents, with file filters, to update resource files corresponding to obfuscated class names.
- Now respecting naming rule for nested class names (EnclosingClass$InnerClass) in obfuscation step, if InnerClasses attributes or EnclosingMethod attributes are being kept.
- Added new inter-procedural optimizations: method inlining and propagation of constant fields, constant arguments, and constant return values.
- Added optimized local variable allocation.
- Added over 250 new peephole optimizations.
- Improved making classes and class members public or protected.
- Now printing notes on suspiciously unkept classes in parameters of specified methods.
- Now printing notes for class names that dont seem to be fully qualified.
- Added support for uppercase filename extensions.
- Rewritten class file I/O code.
- Updated documentation and examples.

EasyTAG is an utility for viewing and editing tags for MP3, MP2, FLAC, Ogg Vorbis, MusePack and Monkeys Audio files. EasyTAG is simple and nice GTK+ interface makes tagging easier under GNU/Linux.
The program exists for the both versions of the GTK library 1.2 and 2.4.
The GTK 1.2 version wouldnt change a lot (may be some bugs fixes), as all new developments will be concentrated on the new GTK 2.4 version.
Main features:
- View, edit, write tags of MP3, MP2 files (ID3 tag with pictures), FLAC files (FLAC Vorbis tag), Ogg Vorbis files (Ogg Vorbis tag), and MusePack, Monkeys Audio files (APE tag),
- Can edit more tag fields : Title, Artist, Album, Year, Track Number, Genre, Comment, Composer, Original Artist/Performer, Copyright, URL and Encoder name,
- Auto tagging: parse filename and directory to complete automatically the fields (using masks),
- Ability to rename files from the tag (using masks) or by loading a text file,
- Process selected files of the selected directory,
- Ability to browse subdirectories,
- Recursion for tagging, removing, renaming, saving...,
- Can set a field (artist, title,...) to all other files,
- Read file header informations (bitrate, time, ...) and display them,
- Auto completion of the date if a partial is entered,
- Undo and redo last changes,
- Ability to process fields of tag and file name (convert letters into uppercase, downcase, ...),
- Ability to open a directory or a file with an external program,
- CDDB support using Freedb.org servers (manual and automatic search),
- A tree based browser or a view by Artist & Album,
- A list to select files,
- A playlist generator window,
- A file searching window,
- Simple and explicit interface!,
- French, German, Russian, Dutch, Hungarian, Swedish, Italian, Japanese, Ukrainian, Czech, Spanish, Polish Romanian and Danish translation languages,
- Written in C and uses GTK+ 2.4 for the GUI
Enhancements:
- This release adds autoscroll in log view and the ability to change the modification time of the parent directory of a file when updating a tag (which is useful with Amarok).
- A problem with displaying the title in the cddb window and a mistake in the configure script were fixed.
- Swedish documentation was added.
- The French, German, Polish, Brazilian Portuguese, and Swedish translations were updated.

filepp is a generic file preprocessor. It is designed to allow the functionality provided by the C preprocessor to be used with any file type. This project supports the following keywords, all of which have their usual C preprocessor meanings and usage:
- #include
- #define
- #if
- #elif
- #ifdef
- #ifndef
- #else
- #endif
- #undef
- #error
- #warning
However, filepp is much more than a rewrite of the C preprocessor, it features the following enhancements:
- An extended #if keyword which includes string and regular expression parsing.
- It works with all character sets including international characters, not just ASCII characters.
- The prefix to the keyword (normally #) and the line continuation character (normally ) can be set to any character, string or regular expression.
- Keywords can be added, removed or modified.
- Macro expansion can work on whole or part words (the C preprocessors macro expansion only works on whole words).
- Macros can have multiple arguments.
- Filepp has a debugging mode to help when things go wrong.
- Environment variables can be automatically defined as macros.
- Blank lines originating from include files can be suppressed.
- Filepp can be customised on the fly using the #pragma keyword which allows any of filepps internal functions to be called.
- Modules can be written (in Perl) to modify or extend the behaviour of filepp.
These are just some of the enhancements filepp has over the normal C preprocessor. Its main advantage is the ability to write modules to extend and modify its behaviour. Filepp is written in Perl and allows anyone who knows how to program in Perl to easily write modules. Filepp comes with a set of modules which do the following:
- for module: Implements the #for keyword. The allows loops to be generated, the behaviour is similar to Perl and C loops.
- foreach module: Implements the #foreach keyword. The allows loops to be generated for a list of strings, the behaviour is similar to Perl and csh foreach loops.
- c-comment module: Removes C and C++ style comments from a file.
- hash-comment module: Remove # style comments (as used in Perl and shell scripts) from a file.
- function module: Allows macros to be written which directly call Perl functions. This allows macros to give dynamic output.
- maths module: Implements basic maths functions including add, subtract, multiply, divide, sine, cosine, exponential, random etc.
- format module: Provides a list of functions for formatting text including a C/Perl style printf function and the Perl substr function.
- literal module: This module prevents macros appearing in strings being replaced.
- toupper module: Converts all lowercase letters in a file to uppercase.
- tolower module: Converts all uppercase letters in a file to lowercase.
- bigdef module: Enables multi-line macros to be defined without needing to put a line continuation character at the end of each line - makes large macros much more readable.
- bigfunc module: Same as bigdef, only difference is any keywords embedded in the macro are evaluated when the macro is replaced rather than when the macro is defined.
- defplus module: Enables existing macros to be appened to.
- blc module: Enables automatic line continuation if a closing bracket is on a line below the opening bracket.
- cmacro module: Makes certain macros more "C" like by putting quotes around their values.
- cpp module: Makes filepp behave as a basic C preprocessor.
- regexp module: Implements Perl style regular expression search and replacement, which allows regular expressions to be searched for and replaced with other strings.
- grab module: Used to grab input before any processing is done on it.
Enhancements:
- This release includes a rewrite of the processing chain so macros within macros behave correctly.
- Several other bugfixes and minor enhancements were made.

ustring is a C++ library to implement the complete Unicode 3.0 standard. It gives an easy access to the properties of each of the 10600 characters defined by the Unicode 3.0 standard, including the uppercase and lowercase mapping, category and subcategory, character name, and bidirectional category.

ustring C++ Unicode library provides a wide string class which fits with STL, implementing a full Unicode normalizer, uppercase and lowercase transformation, and diacritical mark removal. A Unicode level-1 regular expression class is also provided.

SmartTemplate is a Template Engine that was designed to support large scale, web based applications.
Whats so special about it?
Common template engines work like the following: Your PHP script specifies an HTML template and assigns some dynamic content to display. The template parser replaces all placeholders within the template with the assigned content and displays it to the user. This means a lot of string processing and regular expression work each time you want to display some content.
SmartTemplate works like a template compiler that converts templates into executable PHP code and stores it for later reuse. The first time a new template is processed, all placeholders in the template are replaced by small PHP code elements that print the assigned content. The HTML template fragment < H3 >{TITLE}< /H3 >, for example, is converted into something like < H3 >< ?php echo $TITLE; ? >< /H3 >. If you have assigned your content to the right variables, there is no need for any template parsing anymore. The only thing that has to be done is to include and execute the compiled template. This usually increases the execution time of the template engine dramatically.
SmartTemplate supports:
- Simple Scalar Substitution (Strings, etc.)
- Block Iterations (nested Arrays / BEGIN..END)
- Basic Control Structures (IF..ELSEIF..ELSE)
- Custom Extension (Output filters, uppercase, sprintf, etc.)
- Template Compilation (HTML templates are converted to executable PHP Code)
- SubTemplate System (HTML templates can be included on other templates)
- Output Caching (Accelerates your applications by reusing page output)