gEDA-user: Gdatabase and datadraw available for download

[Bill Cox <bill@viasic.com>]

Hi.

I've put together a modern EDA netlist database I'm calling gdatabase 
for now.  It's built using a CASE tool designed specifically for EDA 
database support, called DataDraw.  Gdatabase is released under the GPL, 
while DataDraw is under the library version of the GPL.

For now, they are available at:

www.viasic.com/download

I recommend taking a look at the hand-written code.  Don't worry about 
the generated code, which is in files of the form <prefix>ddr.c and 
<prefix>ddr.h.  I'd also ignore the output of flex and bison in the cir 
directory.

In particular, take a look at the cirmain.c file in the cir directory. 
This is the spice netlister, except for some parsing of device 
configuration data.  There isn't any code specific to any device, except 
for sub-circuits.

To run the spice netlister, you'd type something like:

gdatabase <myschem>.sch

It' generates <myschem>.cir.  It does not yet have a flattening 
capability, but it will soon.  It also doesn't know how to search any 
library paths for your symbols and schems, so they'll have to be present 
in the current directory.

Feel free to check out DataDraw.exe under wine.  If you can figure out 
how to do it, check out all the different schemas, such as the 
Spicenetlist schema, as well as the main netlist database schema.  There 
is also a linux-based command line generator for datadraw called mkddr 
in the bin directory.  I'm using the 'New C' generator.  On the command 
line, you'd type:

mkddr -new_c db.ddr

This generates all the boiler-plate code for supporting the data structures.

Feel free to work with the code if you wish.  In the short term I need 
to do a couple things:

-- Write flattener
-- Write path search code, or integrate such code from libgeda
-- Integrate scripting tool

The gEDA code base uses guile.  The other obvious choice is TCL.  Other 
than being compatible with gEDA, is there a good reason to base the code 
on guile?  FPGA designers generally will be willing to use TCL for 
timing constraints and all kinds of design specific things, but they get 
lost in Scheme.  The more advanced ASIC guys who are capable of writing 
netlisters are willing to use Scheme, but they'd also use TCL.  I'm not 
guessing about this, it's based on strong experience.  I could do both, 
but I'm not sure that makes sense.

Finally, a word about the motivation for this project:

No module in a modern EDA system is more important than the central 
netlist data structures, or the "netlist database".  It's coding style 
is often propagated throughout the system.  It's data structures 
facilitate or hinder tool development to a very high degree.  Building 
this module well is the single most important step in setting up an EDA 
project to succeed.  I've seen the impact these modules have had in many 
companies.

Gnetlist a good start on a modern EDA netlist database.  I've seen 
enough of these systems to know that this one is good.

To get started with this system, I'd recommend doing something small. 
For example, write another netlist writer and/or reader.  Then try 
something more advanced, like automation of transistor sizing for speed 
and power.  Or, perhaps we could write a schematic generator, or 
hierarchical viewer, or both.

Bill