Free html code generators software for linux

MyDBO is a powerful object-oriented code generator for PHP/MySQL Web application developers.
It is designed to remove the hassle of implementing familiar database operations (select, update, insert, etc) over and over again when creating Web applications. MyDBO Code Generator creates code for accessing your database tables without you having to worry about connections or SQL queries.
It also allows you to approach your database in an object-oriented fashion, thus giving you real flexibility. It uses templates to generate code, so it is also possible to create your own templates.
Main features:
- Forget about accessing your database with SQL queries.
- Use the far more flexible object-oriented approach.
- Create logic foreign key links between your tables and navigate between your objects.
- Map the default MySQL date type to whatever you want.
- Create your own templates for unlimited possibilities.
- Fast and reliable.
- Should your database structure change, just re-generate the code.
- Easy to generate with the generation wizard.
- The generated code has standard comments for each class and functions.
- Free for personal and commercial use (GNU), Open source.
- Clean and tested code.
Enhancements:
- Boolean return values were added in API methods.
- A LIMIT argument was added in the tableCollector of the businessAPI plugin.
- The number of queries to execute when using Collector was reduced to 1.
- The use of database connections was optimized, and $DB is now a global variable.
- Memory is allowed increased to 16M.
- The ADOdb installation was customized to be minimal.
- instantAdmin was updated with a new API.
- Collector classes can now return the number of results only.

phpCodeGenerator is a free database driven website code generator. This application reads the database and generates a website with the ability to Create, List, Edit, Update, Delete and Search Records.

QOF Generator is a project that generates C object source code from HTML/PHP or Perl/XML.

Generating new objects for the Query Object Framework is repetitive, tedious, and time consuming.

Qof Generator automates this process in PHP to build a working test program linked against QOF.

Objects are created from an HTML form using a temporary MySQL cache and exported with Makefile, ./autogen.sh, ChangeLog, README, C source code, and doxygen mark-up comments in a tarball built by the PHP code.

phpCodeGenie (PCG) is a code generator for database driven applications. PCG can generate entire working basic database driven applications for you. PCG can generate code from different databases.

The database servers it can talk to via ADODB are :- MySQL, PostgreSQL, Interbase, Firebird, Informix, Oracle, MS SQL, Foxpro, Access, Sybase, FrontBase, DB2, SAP DB, SQLite and Netezza. While the core version generates mostly PHP Code, phpCodeGenie can be modified to generate code in any programming language - Perl, Java, C#, ASP etc..

phpCodeGenie attempts to generate these CRUD code so that programmers have a base they can work on. The core database access code and scripts are usually the same for most applications.

Rather than spending a lot of time doing these common code, we can spend our time on the business logic of our applications and let PCG do the boring code for you. phpCodeGenie can generate simple code for beginners where everything is done in the same PHP script or structure Object Oriented PHP Code that follows the PCG framework.

phpCodeGenie requires you to design your tables and then the genie can generate code for reading and writing to the database, the html forms to enter or edit data in the database, scripts to list data, scripts to delete data, search forms, search scripts among others.

phpCodeGenie can interact and generate code from many database servers - MySQL, PostgreSQL, Interbase, Firebird, Informix, Oracle, MS SQL, Foxpro, Access, Sybase, FrontBase, DB2, SAP DB, SQLite, Netezza, LDAP, and generic ODBC, ODBTP, through the ADODB Database Abstraction Library.

phpCodeGenie uses a plugin mechanism for the different code that it generates. While most the core plugins are plugins for PHP Code Generation, one can write plugins for any language, be it Perl, Java, C#, Visual Basic, ASP etc.. Basically, code generation is String manipulation. So it is very easy to make a new PCG plugin. Feel free to write your own PCG plugins and it would be nice if you could share it back with the PCG community.

HTML::CGIChecker is a Perl module to detect dangerous HTML code.

SYNOPSIS

use HTML::CGIChecker;

$feedback =
< TABLE CELLPADDING="2" >< TR >< TD >One column< /TD >< /TR >< /TABLE >< BR >
" Arrays & variables "

Dough > Hi, how are you ?

And now some Perl code:
< PRE >
print "< HTML >< BODY >< /BODY >< /HTML >";
< /PRE >
;

# create the $checker object

$checker = new HTML::CGIChecker (
mode => allow,
allowclasses => [ qw( tables images ) ],
allowtags => [ qw ( B I A U STRONG BR HR ) ],
jscript => 0,
html => 0,
pre => 1,
debug => 0,
err_tag => Tag {tag} is not allowed in {element}.
);

# Now you can use it to check any string using its checkHTML()
# method. It "remembers" its configuration, so you can reuse it.

($checked_feedback, $Warnings) =
$checker->checkHTML ($feedback);

# Process the results ...

if ($checked_feedback) {
# save $checked_feedback to the database ....
}
else {
# print the warnings ...
print join ("n", @{$Warnings});
}

The example above produces no warning messages and returns $feedback checked and properly HTML escaped. The only HTML "error" - the unescaped ">" bracket on the fourth line - is autocorrected. One warning message was overriden by a customized version. Potential warnings would not be HTML formatted and HTML safe, because the html parameter is not true.

HTML::Clean module cleans up HTML code for web browsers, not humans.

SYNOPSIS

use HTML::Clean;
$h = new HTML::Clean($filename); # or..
$h = new HTML::Clean($htmlcode);

$h->compat();
$h->strip();
$data = $h->data();
print $$data;

The HTML::Clean module encapsulates a number of common techniques for minimizing the size of HTML files. You can typically save between 10% and 50% of the size of a HTML file using these methods. It provides the following features:

Remove unneeded whitespace (begining of line, etc)
Remove unneeded META elements.
Remove HTML comments (except for styles, javascript and SSI)
Replace tags with equivilant shorter tags (< strong > --> < b >)
etc.

The entire proces is configurable, so you can pick and choose what you want to clean.

Verilog::CodeGen module is a Verilog code generator.

SYNOPSIS

use Verilog::CodeGen;

mkdir DeviceLibs/Objects/YourDesign, 0755;
chdir DeviceLibs/Objects/YourDesign;

# if the directory YourDesign exists, the second argument can be omitted
# create YourModule.pl in YourDesign
&create_template_file(YourModule,YourDesign);

# create a device library for testing in DeviceLibs/Objects/DeviceLibs
&make_module(YourModule,YourDesign);

# create the final device library in DeviceLibs (once YourModule code is clean)
&make_module(,YourDesign);

Pod::HTML2Pod Perl module can translate HTML into POD.

SYNOPSIS

# Use the program html2pod that comes in this dist, or:
use Pod::HTML2Pod;
print Pod::HTML2Pod::convert(
file => my_stuff.html, # input file
a_href => 1, # try converting links
);

Larry Wall once said (1999-08-27, on the pod-people list, I do believe): "The whole point of pod is to get people to document stuff they wouldnt document in any other form."

To that end, I wrote this module so that people who are unpracticed with POD but in a hurry to simply document their programs or modules, could write their documentation in simple HTML, and convert that to POD. Thats what this module does.

Specifically, this module bends over backwards to try to turn even vaguely plausable HTML into POD -- and when in doubt, it simply ignores things that it doesnt know about, or cant render.

FUNCTIONS

This module provides one documented function, which it does not export:
Pod::HTML2Pod::convert( ...options... )

This returns a single scalar value containing the converted POD text, with some comments after the end.

This function takes options:

file => FILENAME,

Specifies that the HTML code is to be read from the filename given.

handle => *HANDLE,

Specifies that the HTML code is to be read from the open filehandle given (e.g., $fh_obj, *HANDLE, *HANDLE{IO}, etc.) If you specify this, but fail to specify an actual handle object, inscrutible errors may result.

content => STRING,

Specifies that the HTML code is in the string given. (Alternately, pass a reference to the scalar: content => $stuff.)

tree => OBJ,

Specifies that the HTML document is contained in the given HTML::TreeBuilder object (or HTML::Element object, at least).

a_name => BOOLEAN,

Specifies whether you want to try converting < a name="..." > elements. By default this is off -- i.e., such elements are ignored.

a_href => BOOLEAN,

Specifies whether you want to try converting < a href="..." > elements. By default this is off -- i.e., such elements are ignored. If on, bear in mind that relative URLs cannot be properly converted to POD -- any relative URLs will be complained about in comments after the end of the document. Normal absolute URLs will be treated as best they can be. Note that URLs beginning "pod:..." will be turned into POD links to whatever follows; that is, "pod:Getopt::Std" is turned into L< Getopt::Std >

debug => INTEGER,

Puts Pod::HTML2Pod into verbose debug mode for the duration of processing this this HTML document. INTEGER can be 0 for no debug output, 1 for a moderate amount that will cause the HTML syntax tree to be be dumped at the start of the conversion, and 2 for that plus a dump of the intermediate POD doctree, plus a few more inscrutible diagnostic messages. Looking at the trees dumped might be helpful in making sense of error messages that refer to a particular node in the parse tree.