Version abc80130

Makefile

@@ -6,20 +6,12 @@ CP   := cp
 
 PROG := abc
 
-MODULES := src/base/abc src/base/abci src/base/cmd \
-	src/base/io src/base/main src/base/ver \
-	src/bdd/cudd src/bdd/dsd src/bdd/epd src/bdd/mtr \
-	src/bdd/parse src/bdd/reo src/bdd/cas \
-	src/map/fpga src/map/mapper src/map/mio src/map/super src/map/if \
-	src/misc/extra src/misc/mvc src/misc/st src/misc/util \
-	src/misc/espresso src/misc/nm src/misc/vec src/misc/hash \
-	src/opt/cut src/opt/dec src/opt/fxu src/opt/rwr \
-	src/opt/sim src/opt/ret src/opt/res src/opt/lpk src/opt/fret \
-	src/sat/bsat src/sat/csat src/sat/msat src/sat/fraig \
-	src/aig/ivy src/aig/hop src/aig/rwt src/aig/deco \
-	src/aig/mem src/aig/dar src/aig/fra src/aig/cnf \
-	src/aig/csw src/aig/ioa src/aig/aig src/aig/kit \
-	src/aig/bdc src/aig/bar src/aig/ntl src/aig/tim
+MODULES := src/base/abc src/base/abci src/base/abcs src/base/cmd src/base/io src/base/main \
+           src/bdd/cudd src/bdd/dsd src/bdd/epd src/bdd/mtr src/bdd/parse src/bdd/reo \
+           src/map/fpga src/map/mapper src/map/mio src/map/super \
+           src/misc/extra src/misc/mvc src/misc/st src/misc/util src/misc/vec \
+	   src/opt/cut src/opt/dec src/opt/fxu src/opt/rwr src/opt/sim \
+           src/sat/asat src/sat/csat src/sat/msat src/sat/fraig
 
 default: $(PROG)
 
@@ -29,7 +21,7 @@ OPTFLAGS  := -DNDEBUG -O3
 CFLAGS   += -Wall -Wno-unused-function $(OPTFLAGS) $(patsubst %, -I%, $(MODULES)) 
 CXXFLAGS += $(CFLAGS) 
 
-LIBS := -ldl -rdynamic -lreadline -ltermcap
+LIBS := 
 SRC  := 
 GARBAGE := core core.* *.stackdump ./tags $(PROG)
 
@@ -67,10 +59,6 @@ tags:
 $(PROG): $(OBJ)
 	$(LD) -o $@ $^ $(LIBS)
 
-lib$(PROG).a: $(OBJ)
-	ar rv $@ $?
-	ranlib $@
-
 docs:
 	doxygen doxygen.conf
 

abc.rc

 # global parameters
-set check         # checks intermediate networks
+#set check         # checks intermediate networks
 #set checkfio      # prints warnings when fanins/fanouts are duplicated
 set checkread     # checks new networks after reading from file
 set backup        # saves backup networks retrived by "undo" and "recall"
 set savesteps 1   # sets the maximum number of backup networks to save
-set progressbar   # display the progress bar
 
 # program names for internal calls
 set dotwin dot.exe
@@ -15,10 +14,6 @@ set siswin sis.exe
 set sisunix sis
 set mvsiswin mvsis.exe
 set mvsisunix mvsis
-set capowin MetaPl-Capo10.1-Win32.exe
-set capounix MetaPl-Capo10.1
-set gnuplotwin wgnuplot.exe
-set gnuplotunix gnuplot
 
 # standard aliases
 alias b balance
@@ -27,102 +22,48 @@ alias clp collapse
 alias esd ext_seq_dcs
 alias f fraig
 alias fs fraig_sweep
-alias fsto fraig_store
-alias fres fraig_restore
 alias ft fraig_trust
-alias lp lutpack
-alias pd print_dsd
-alias pex print_exdc -d
+alias mu renode -m
 alias pf print_factor
 alias pfan print_fanio
 alias pl print_level
 alias pio print_io
-alias pk print_kmap
 alias ps print_stats 
 alias psu print_supp
 alias psy print_symm
-alias pun print_unate
 alias q quit
 alias r read
-alias r3 retime -M 3
-alias r3f retime -M 3 -f
-alias r3b retime -M 3 -b
 alias ren renode
-alias rh read_hie
 alias rl read_blif
 alias rb read_bench
-alias ret retime
-alias dret dretime
 alias rp read_pla
-alias rt read_truth
 alias rv read_verilog
-alias rvl read_verlib
 alias rsup read_super mcnc5_old.super
 alias rlib read_library
-alias rlibc read_library cadence.genlib
 alias rw rewrite
 alias rwz rewrite -z
 alias rf refactor
 alias rfz refactor -z
-alias re restructure
-alias rez restructure -z
-alias rs resub
-alias rsz resub -z
 alias sa set autoexec ps
-alias scl scleanup
-alias sif if -s
 alias so source -x
 alias st strash
 alias sw sweep
-alias ssw ssweep
-alias tr0 trace_start
-alias tr1 trace_check
-alias trt "r c.blif; st; tr0; b; tr1"
 alias u undo
-alias w write
-alias wa write_aiger
-alias wb write_bench
-alias wc write_cnf
-alias wh write_hie
+alias wb write_blif
 alias wl write_blif
 alias wp write_pla
-alias wv write_verilog
 
 # standard scripts
+alias cnf      "st; ren -c; write_cnf"
+alias prove    "st; ren -c; sat"
+alias opt      "b; ren; b"
+alias share    "b; ren; fx; b"
+alias sharem   "b; ren -m; fx; b"
+alias sharedsd "b; ren; dsd -g; sw; fx; b"
 alias resyn    "b; rw; rwz; b; rwz; b"
 alias resyn2   "b; rw; rf; b; rw; rwz; b; rfz; rwz; b"
-alias resyn2a     "b; rw; b; rw; rwz; b; rwz; b"
-alias resyn3      "b; rs; rs -K 6; b; rsz; rsz -K 6; b; rsz -K 5; b"
-alias compress    "b -l; rw -l; rwz -l; b -l; rwz -l; b -l"
-alias compress2   "b -l; rw -l; rf -l; b -l; rw -l; rwz -l; b -l; rfz -l; rwz -l; b -l"
 alias choice   "fraig_store; resyn; fraig_store; resyn2; fraig_store; fraig_restore"
-alias choice2     "fraig_store; balance; fraig_store; resyn; fraig_store; resyn2; fraig_store; resyn2; fraig_store; fraig_restore"
-alias rwsat       "st; rw -l; b -l; rw -l; rf -l"
-alias rwsat2      "st; rw -l; b -l; rw -l; rf -l; fraig; rw -l; b -l; rw -l; rf -l"
-alias shake       "st; ps; sat -C 5000; rw -l; ps; sat -C 5000; b -l; rf -l; ps; sat -C 5000; rfz -l; ps; sat -C 5000; rwz -l; ps; sat -C 5000; rfz -l; ps; sat -C 5000"
-alias share       "st; multi -m; fx; resyn2"
-
-# resubstitution scripts for the IWLS paper
-alias src_rw      "st; rw -l; rwz -l; rwz -l" 
-alias src_rs      "st; rs -K 6 -N 2 -l; rs -K 9 -N 2 -l; rs -K 12 -N 2 -l" 
-alias src_rws     "st; rw -l; rs -K 6 -N 2 -l; rwz -l; rs -K 9 -N 2 -l; rwz -l; rs -K 12 -N 2 -l" 
-alias resyn2rs    "b; rs -K 6; rw; rs -K 6 -N 2; rf; rs -K 8; b; rs -K 8 -N 2; rw; rs -K 10; rwz; rs -K 10 -N 2; b; rs -K 12; rfz; rs -K 12 -N 2; rwz; b"
-alias compress2rs "b -l; rs -K 6 -l; rw -l; rs -K 6 -N 2 -l; rf -l; rs -K 8 -l; b -l; rs -K 8 -N 2 -l; rw -l; rs -K 10 -l; rwz -l; rs -K 10 -N 2 -l; b -l; rs -K 12 -l; rfz -l; rs -K 12 -N 2 -l; rwz -l; b -l"
-
-# experimental implementation of don't-cares
-alias resyn2rsdc    "b; rs -K 6 -F 2; rw; rs -K 6 -N 2 -F 2; rf; rs -K 8 -F 2; b; rs -K 8 -N 2 -F 2; rw; rs -K 10 -F 2; rwz; rs -K 10 -N 2 -F 2; b; rs -K 12 -F 2; rfz; rs -K 12 -N 2 -F 2; rwz; b"
-alias compress2rsdc "b -l; rs -K 6 -F 2 -l; rw -l; rs -K 6 -N 2 -F 2 -l; rf -l; rs -K 8 -F 2 -l; b -l; rs -K 8 -N 2 -F 2 -l; rw -l; rs -K 10 -F 2 -l; rwz -l; rs -K 10 -N 2 -F 2 -l; b -l; rs -K 12 -F 2 -l; rfz -l; rs -K 12 -N 2 -F 2 -l; rwz -l; b -l"
 
-# temporaries
-alias reach    "st; ps; compress2; ps; qrel; ps; compress2; ps; qreach -v; ps"
-alias chnew    "st; haig_start; resyn2; haig_use"
-alias chnewrs  "st; haig_start; resyn2rs; haig_use"
-alias stdsd    "r test/6in.blif; st; ps; u; bdd; dsd -g; st; ps"
-alias trec     "rec_start; r c.blif; st; rec_add; rec_use"
-alias trec4    "rec_start -K 4; r i10.blif; st; rec_add; rec_use"
-alias bmc2     "frames -i -F 10; orpos; iprove"
-
-alias t0       "r test/mc1.blif; st; test"
-alias t1       "r s27mc2.blif; st; test"
-alias t2       "r i/intel_001.aig; ps; indcut -v"
+alias scl      scleanup
+alias ssw      ssweep
 

abclib.dsw

-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "abclib"=.\abclib.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-

abctestlib.dsp

-# Microsoft Developer Studio Project File - Name="abctestlib" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=abctestlib - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "abctestlib.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "abctestlib.mak" CFG="abctestlib - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "abctestlib - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "abctestlib - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "abctestlib - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib C:\_projects\abc\abclib\abclib_release.lib /nologo /subsystem:console /machine:I386 /out:"_TEST/abctestlib.exe"
-
-!ELSEIF  "$(CFG)" == "abctestlib - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib C:\_projects\abc\abclib\abclib_debug.lib /nologo /subsystem:console /debug /machine:I386 /out:"_TEST/abctestlib.exe" /pdbtype:sept
-
-!ENDIF 
-
-# Begin Target
-
-# Name "abctestlib - Win32 Release"
-# Name "abctestlib - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=.\demo.c
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# End Target
-# End Project

abctestlib.dsw

-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "abctestlib"=.\abctestlib.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-

copyright.txt

-Copyright (c) The Regents of the University of California. All rights reserved.
-
-Permission is hereby granted, without written agreement and without license or
-royalty fees, to use, copy, modify, and distribute this software and its
-documentation for any purpose, provided that the above copyright notice and
-the following two paragraphs appear in all copies of this software.
-
-IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
-DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
-THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
-CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,
-AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
-SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-

demo.c

-/**CFile****************************************************************
-
-  FileName    [demo.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [ABC as a static library.]
-
-  Synopsis    [A demo program illustrating the use of ABC as a static library.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: demo.c,v 1.00 2005/11/14 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include <stdio.h>
-#include <time.h>
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-// procedures to start and stop the ABC framework
-// (should be called before and after the ABC procedures are called)
-extern void   Abc_Start();
-extern void   Abc_Stop();
-
-// procedures to get the ABC framework and execute commands in it
-extern void * Abc_FrameGetGlobalFrame();
-extern int    Cmd_CommandExecute( void * pAbc, char * sCommand );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [The main() procedure.]
-
-  Description [This procedure compiles into a stand-alone program for 
-  DAG-aware rewriting of the AIGs. A BLIF or PLA file to be considered
-  for rewriting should be given as a command-line argument. Implementation 
-  of the rewriting is inspired by the paper: Per Bjesse, Arne Boralv, 
-  "DAG-aware circuit compression for formal verification", Proc. ICCAD 2004.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int main( int argc, char * argv[] )
-{
-    // parameters
-    int fUseResyn2  = 0;
-    int fPrintStats = 1;
-    int fVerify     = 1;
-    // variables
-    void * pAbc;
-    char * pFileName;
-    char Command[1000];
-    int clkRead, clkResyn, clkVer, clk;
-
-    //////////////////////////////////////////////////////////////////////////
-    // get the input file name
-    if ( argc != 2 )
-    {
-        printf( "Wrong number of command-line arguments.\n" );
-        return 1;
-    }
-    pFileName = argv[1];
-
-    //////////////////////////////////////////////////////////////////////////
-    // start the ABC framework
-    Abc_Start();
-    pAbc = Abc_FrameGetGlobalFrame();
-
-clk = clock();
-    //////////////////////////////////////////////////////////////////////////
-    // read the file
-    sprintf( Command, "read %s", pFileName );
-    if ( Cmd_CommandExecute( pAbc, Command ) )
-    {
-        fprintf( stdout, "Cannot execute command \"%s\".\n", Command );
-        return 1;
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // balance
-    sprintf( Command, "balance" );
-    if ( Cmd_CommandExecute( pAbc, Command ) )
-    {
-        fprintf( stdout, "Cannot execute command \"%s\".\n", Command );
-        return 1;
-    }
-clkRead = clock() - clk;
-
-    //////////////////////////////////////////////////////////////////////////
-    // print stats
-    if ( fPrintStats )
-    {
-        sprintf( Command, "print_stats" );
-        if ( Cmd_CommandExecute( pAbc, Command ) )
-        {
-            fprintf( stdout, "Cannot execute command \"%s\".\n", Command );
-            return 1;
-        }
-    }
-
-clk = clock();
-    //////////////////////////////////////////////////////////////////////////
-    // synthesize
-    if ( fUseResyn2 )
-    {
-        sprintf( Command, "balance; rewrite -l; refactor -l; balance; rewrite -l; rewrite -lz; balance; refactor -lz; rewrite -lz; balance" );
-        if ( Cmd_CommandExecute( pAbc, Command ) )
-        {
-            fprintf( stdout, "Cannot execute command \"%s\".\n", Command );
-            return 1;
-        }
-    }
-    else
-    {
-        sprintf( Command, "balance; rewrite -l; rewrite -lz; balance; rewrite -lz; balance" );
-        if ( Cmd_CommandExecute( pAbc, Command ) )
-        {
-            fprintf( stdout, "Cannot execute command \"%s\".\n", Command );
-            return 1;
-        }
-    }
-clkResyn = clock() - clk;
-
-    //////////////////////////////////////////////////////////////////////////
-    // print stats
-    if ( fPrintStats )
-    {
-        sprintf( Command, "print_stats" );
-        if ( Cmd_CommandExecute( pAbc, Command ) )
-        {
-            fprintf( stdout, "Cannot execute command \"%s\".\n", Command );
-            return 1;
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // write the result in blif
-    sprintf( Command, "write_blif result.blif" );
-    if ( Cmd_CommandExecute( pAbc, Command ) )
-    {
-        fprintf( stdout, "Cannot execute command \"%s\".\n", Command );
-        return 1;
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // perform verification
-clk = clock();
-    if ( fVerify )
-    {
-        sprintf( Command, "cec %s result.blif", pFileName );
-        if ( Cmd_CommandExecute( pAbc, Command ) )
-        {
-            fprintf( stdout, "Cannot execute command \"%s\".\n", Command );
-            return 1;
-        }
-    }
-clkVer = clock() - clk;
-
-    printf( "Reading = %6.2f sec   ",     (float)(clkRead)/(float)(CLOCKS_PER_SEC) );
-    printf( "Rewriting = %6.2f sec   ",   (float)(clkResyn)/(float)(CLOCKS_PER_SEC) );
-    printf( "Verification = %6.2f sec\n", (float)(clkVer)/(float)(CLOCKS_PER_SEC) );
-
-    //////////////////////////////////////////////////////////////////////////
-    // stop the ABC framework
-    Abc_Stop();
-    return 0;
-}
-

readme

-Often the code comes directly from a Windows computer.
-The following steps may be needed to compile it on UNIX:
-
->> dos2unix Makefile Makefile
->> dos2unix depends.sh depends.sh
->> chmod 755 depends.sh
->> make  // on Solaris, try "gmake"
-
-If compiling as a static library, it is necessary to uncomment
-#define _LIB in "src/abc/main/main.c"
-
-Several things to try if it does not compile on your platform:
-- Try running all code (not only Makefile and depends.sh) through dos2unix
-- Try the following actions:
-  (a) Remove flags from the libs line (LIBS :=) in Makefile
-  (b) Remove "src\base\main\libSupport.c" from "src\base\main\module.make"
-  (c) Comment calls to Libs_Init() and Libs_End() in "src\base\main\mainInit.c"
-- Try linking with gcc (rather than g++)
-  For this replace "LD   := g++" with "LD   := gcc -lm" in Makefile
-- If your Linux distributin does not have "readline", you may have problems 
-  compiling ABC with gcc. Please try installing this library from
-  http://tiswww.case.edu/php/chet/readline/rltop.html
-
-
-Finally, run regression test:
-abc>>> so regtest.script

regtest.script

-r examples/apex4.pla;    resyn; if; cec; ps; clp; resyn; map; cec; ps
-r examples/C2670.blif;   st; w 1.aig; cec 1.aig
-r examples/C2670.blif;   st; short_names; w 1.bench; cec 1.bench
-r examples/C2670.blif;   st; short_names; ren -s; w 1.eqn; cec 1.eqn
-r examples/C2670.blif;   resyn2; if -K 8; cec; ps; u; map; cec; ps
-r examples/frg2.blif;    dsd; muxes; cec; ps; clp; share; resyn; map; cec; ps
-r examples/frg2.blif;    bdd; muxes; cec; ps; clp; st; ren -b; muxes; cec; ps
-r examples/i10.blif;     resyn2; fpga; cec; ps;  u; map; cec; ps
-r examples/i10.blif;     choice; fpga; cec; ps;  u; map; cec; ps
-r examples/pj1.blif;     st; if; cec; ps;   u; map; cec; ps
-r examples/s38417.blif;  comb; w 1.blif; resyn; if; cec 1.blif; ps
-r examples/s38417.blif;  resyn; if; cec; ps;   u; map; cec; ps
-r examples/s38584.bench; resyn; ren -s; fx; if; cec; ps;   u; map; cec; ps
-r examples/s444.blif;    b; esd -v; print_exdc; dsd; cec; ps
-r examples/s444.blif;    double; frames -F 5; w 1.blif; ffpga -K 8; cec 1.blif
-r examples/s5378.blif;   frames -F 5; cycle; w 1.blif; ps; ret; ps; sec 1.blif
-r examples/s6669.blif;   cycle; w 1.blif; ps; ret -M 3; resyn; ps; sec 1.blif
+r examples/apex4.pla
+resyn
+sharem
+fpga
+cec
+ps
+
+clp
+share
+resyn
+map
+cec
+ps
+
+r examples/C2670.blif
+resyn
+fpga
+cec
+ps
+
+u
+map
+cec
+ps
+
+r examples/frg2.blif
+dsd
+muxes
+cec
+clp
+share
+resyn
+map
+cec
+ps
+
+r examples/pj1.blif
+resyn
+fpga
+cec
+ps
+
+u
+map
+cec
+ps
+
+r examples/s38584.bench
+resyn
+fpga
+cec
+ps
+
+u
+map
+cec
+ps
+
+r examples/ac.v
+resyn
+fpga
+cec
+ps
+
+u
+map
+cec
+ps
+
+r examples/s444.blif
+b
+esd -v
+dsd
+cec
+ps
+
+r examples/i10.blif
+fpga
+cec
+ps
+u
+map
+cec
+ps
+
+r examples/i10.blif
+b
+fraig_store
+resyn
+fraig_store
+resyn2
+fraig_store
+fraig_restore
+fpga
+cec
+ps
+
+u
+map
+cec
+ps
+
 time

src/aig/aig/aig.h → src/abc8/aig/aig.h

@@ -35,7 +35,7 @@ extern "C" {
 #include <assert.h>
 #include <time.h>
 
-#include "vec.h"
+#include "vec2.h"
 
 ////////////////////////////////////////////////////////////////////////
 ///                         PARAMETERS                               ///

src/aig/aig/aigMan.c → src/abc8/aig/aigMan.c

@@ -19,7 +19,7 @@
 ***********************************************************************/
 
 #include "aig.h"
-#include "tim.h"
+//#include "tim.h"
 
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
@@ -277,8 +277,8 @@ void Aig_ManStop( Aig_Man_t * p )
     if ( p->time1 ) { PRT( "time1", p->time1 ); }
     if ( p->time2 ) { PRT( "time2", p->time2 ); }
     // delete timing
-    if ( p->pManTime )
-        Tim_ManStop( p->pManTime );
+//    if ( p->pManTime )
+//        Tim_ManStop( p->pManTime );
     // delete fanout
     if ( p->pFanData ) 
         Aig_ManFanoutStop( p );

src/aig/aig/module.make → src/abc8/aig/module.make

@@ -3,7 +3,6 @@ SRC +=    src/aig/aig/aigCheck.c \
     src/aig/aig/aigFanout.c \
     src/aig/aig/aigFrames.c \
     src/aig/aig/aigHaig.c \
-    src/aig/aig/aigInter.c \
     src/aig/aig/aigMan.c \
     src/aig/aig/aigMem.c \
     src/aig/aig/aigMffc.c \
@@ -16,7 +15,6 @@ SRC +=    src/aig/aig/aigCheck.c \
     src/aig/aig/aigRetF.c \
     src/aig/aig/aigScl.c \
     src/aig/aig/aigSeq.c \
-    src/aig/aig/aigShow.c \
     src/aig/aig/aigTable.c \
     src/aig/aig/aigTiming.c \
     src/aig/aig/aigTruth.c \

src/sat/bsat/module.make → src/abc8/bsat/module.make

 SRC +=  src/sat/bsat/satMem.c \
     src/sat/bsat/satInter.c \
-    src/sat/bsat/satInterA.c \
     src/sat/bsat/satSolver.c \
     src/sat/bsat/satStore.c \
     src/sat/bsat/satTrace.c \

src/abc8/bsat/satMem.h

+/**CFile****************************************************************
+
+  FileName    [satMem.h]
+
+  PackageName [SAT solver.]
+
+  Synopsis    [Memory management.]
+
+  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - January 1, 2004.]
+
+  Revision    [$Id: satMem.h,v 1.0 2004/01/01 1:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef __SAT_MEM_H__
+#define __SAT_MEM_H__
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+//#include "leaks.h"       
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    STRUCTURE DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Sat_MmFixed_t_ Sat_MmFixed_t;
+typedef struct Sat_MmFlex_t_  Sat_MmFlex_t;
+typedef struct Sat_MmStep_t_  Sat_MmStep_t;
+
+////////////////////////////////////////////////////////////////////////
+///                       GLOBAL VARIABLES                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                       MACRO DEFINITIONS                          ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DECLARATIONS                        ///
+////////////////////////////////////////////////////////////////////////
+
+// fixed-size-block memory manager
+extern Sat_MmFixed_t *     Sat_MmFixedStart( int nEntrySize );
+extern void                Sat_MmFixedStop( Sat_MmFixed_t * p, int fVerbose );
+extern char *              Sat_MmFixedEntryFetch( Sat_MmFixed_t * p );
+extern void                Sat_MmFixedEntryRecycle( Sat_MmFixed_t * p, char * pEntry );
+extern void                Sat_MmFixedRestart( Sat_MmFixed_t * p );
+extern int                 Sat_MmFixedReadMemUsage( Sat_MmFixed_t * p );
+// flexible-size-block memory manager
+extern Sat_MmFlex_t *      Sat_MmFlexStart();
+extern void                Sat_MmFlexStop( Sat_MmFlex_t * p, int fVerbose );
+extern char *              Sat_MmFlexEntryFetch( Sat_MmFlex_t * p, int nBytes );
+extern int                 Sat_MmFlexReadMemUsage( Sat_MmFlex_t * p );
+// hierarchical memory manager
+extern Sat_MmStep_t *      Sat_MmStepStart( int nSteps );
+extern void                Sat_MmStepStop( Sat_MmStep_t * p, int fVerbose );
+extern char *              Sat_MmStepEntryFetch( Sat_MmStep_t * p, int nBytes );
+extern void                Sat_MmStepEntryRecycle( Sat_MmStep_t * p, char * pEntry, int nBytes );
+extern int                 Sat_MmStepReadMemUsage( Sat_MmStep_t * p );
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+

src/abc8/bsat/satSolver.h

+/**************************************************************************************************
+MiniSat -- Copyright (c) 2005, Niklas Sorensson
+http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
+
+#ifndef satSolver_h
+#define satSolver_h
+
+#ifdef _WIN32
+#define inline __inline // compatible with MS VS 6.0
+#endif
+
+#include "satVec.h"
+#include "satMem.h"
+
+//=================================================================================================
+// Simple types:
+
+// does not work for c++
+//typedef int                   bool;
+#ifndef __cplusplus
+#ifndef bool
+#define bool int
+#endif
+#endif
+
+static const bool  true      = 1;
+static const bool  false     = 0;
+
+typedef int                lit;
+typedef char               lbool;
+
+#ifndef SINT64
+#define SINT64
+
+#ifdef _WIN32
+typedef signed __int64     sint64;   // compatible with MS VS 6.0
+#else
+typedef long long          sint64;
+#endif
+
+#endif
+
+static const int   var_Undef = -1;
+static const lit   lit_Undef = -2;
+
+static const lbool l_Undef   =  0;
+static const lbool l_True    =  1;
+static const lbool l_False   = -1;
+
+static inline lit  toLit    (int v)        { return v + v; }
+static inline lit  toLitCond(int v, int c) { return v + v + (c != 0); }
+static inline lit  lit_neg  (lit l)        { return l ^ 1; }
+static inline int  lit_var  (lit l)        { return l >> 1; }
+static inline int  lit_sign (lit l)        { return l & 1; }
+static inline int  lit_print(lit l)        { return lit_sign(l)? -lit_var(l)-1 : lit_var(l)+1; }
+static inline lit  lit_read (int s)        { return s > 0 ? toLit(s-1) : lit_neg(toLit(-s-1)); }
+static inline int  lit_check(lit l, int n) { return l >= 0 && lit_var(l) < n;                  }
+
+
+//=================================================================================================
+// Public interface:
+
+struct sat_solver_t;
+typedef struct sat_solver_t sat_solver;
+
+extern sat_solver* sat_solver_new(void);
+extern void        sat_solver_delete(sat_solver* s);
+
+extern bool        sat_solver_addclause(sat_solver* s, lit* begin, lit* end);
+extern bool        sat_solver_simplify(sat_solver* s);
+extern int         sat_solver_solve(sat_solver* s, lit* begin, lit* end, sint64 nConfLimit, sint64 nInsLimit, sint64 nConfLimitGlobal, sint64 nInsLimitGlobal);
+
+extern int         sat_solver_nvars(sat_solver* s);
+extern int         sat_solver_nclauses(sat_solver* s);
+extern int         sat_solver_nconflicts(sat_solver* s);
+
+extern void        sat_solver_setnvars(sat_solver* s,int n);
+
+struct stats_t
+{
+    sint64   starts, decisions, propagations, inspects, conflicts;
+    sint64   clauses, clauses_literals, learnts, learnts_literals, max_literals, tot_literals;
+};
+typedef struct stats_t stats;
+
+extern void        Sat_SolverWriteDimacs( sat_solver * p, char * pFileName, lit* assumptionsBegin, lit* assumptionsEnd, int incrementVars );
+extern void        Sat_SolverPrintStats( FILE * pFile, sat_solver * p );
+extern int *       Sat_SolverGetModel( sat_solver * p, int * pVars, int nVars );
+extern void        Sat_SolverDoubleClauses( sat_solver * p, int iVar );
+
+// trace recording
+extern void        Sat_SolverTraceStart( sat_solver * pSat, char * pName );
+extern void        Sat_SolverTraceStop( sat_solver * pSat );
+extern void        Sat_SolverTraceWrite( sat_solver * pSat, int * pBeg, int * pEnd, int fRoot );
+
+// clause storage
+extern void        sat_solver_store_alloc( sat_solver * s );
+extern void        sat_solver_store_write( sat_solver * s, char * pFileName );
+extern void        sat_solver_store_free( sat_solver * s );
+extern void        sat_solver_store_mark_roots( sat_solver * s );
+extern void        sat_solver_store_mark_clauses_a( sat_solver * s );
+extern void *      sat_solver_store_release( sat_solver * s ); 
+
+//=================================================================================================
+// Solver representation:
+
+struct clause_t;
+typedef struct clause_t clause;
+
+struct sat_solver_t
+{
+    int      size;          // nof variables
+    int      cap;           // size of varmaps
+    int      qhead;         // Head index of queue.
+    int      qtail;         // Tail index of queue.
+
+    // clauses
+    vecp     clauses;       // List of problem constraints. (contains: clause*)
+    vecp     learnts;       // List of learnt clauses. (contains: clause*)
+
+    // activities
+    double   var_inc;       // Amount to bump next variable with.
+    double   var_decay;     // INVERSE decay factor for variable activity: stores 1/decay. 
+    float    cla_inc;       // Amount to bump next clause with.
+    float    cla_decay;     // INVERSE decay factor for clause activity: stores 1/decay.
+
+    vecp*    wlists;        // 
+    double*  activity;      // A heuristic measurement of the activity of a variable.
+    lbool*   assigns;       // Current values of variables.
+    int*     orderpos;      // Index in variable order.
+    clause** reasons;       //
+    int*     levels;        //
+    lit*     trail;
+
+    clause*  binary;        // A temporary binary clause
+    lbool*   tags;          //
+    veci     tagged;        // (contains: var)
+    veci     stack;         // (contains: var)
+
+    veci     order;         // Variable order. (heap) (contains: var)
+    veci     trail_lim;     // Separator indices for different decision levels in 'trail'. (contains: int)
+    veci     model;         // If problem is solved, this vector contains the model (contains: lbool).
+
+    int      root_level;    // Level of first proper decision.
+    int      simpdb_assigns;// Number of top-level assignments at last 'simplifyDB()'.
+    int      simpdb_props;  // Number of propagations before next 'simplifyDB()'.
+    double   random_seed;
+    double   progress_estimate;
+    int      verbosity;     // Verbosity level. 0=silent, 1=some progress report, 2=everything
+
+    stats    stats;
+
+    sint64   nConfLimit;    // external limit on the number of conflicts
+    sint64   nInsLimit;     // external limit on the number of implications
+
+    veci     act_vars;      // variables whose activity has changed
+    double*  factors;       // the activity factors
+    int      nRestarts;     // the number of local restarts
+    int      nCalls;        // the number of local restarts
+    int      nCalls2;        // the number of local restarts
+ 
+    Sat_MmStep_t * pMem;
+
+    int      fSkipSimplify; // set to one to skip simplification of the clause database
+
+    // clause store
+    void *   pStore;
+
+    // trace recording
+    FILE *   pFile;
+    int      nClauses;
+    int      nRoots;
+};
+
+static int sat_solver_var_value( sat_solver* s, int v ) 
+{
+    assert( s->model.ptr != NULL && v < s->size );
+    return (int)(s->model.ptr[v] == l_True);
+}
+static int sat_solver_var_literal( sat_solver* s, int v ) 
+{
+    assert( s->model.ptr != NULL && v < s->size );
+    return toLitCond( v, s->model.ptr[v] != l_True );
+}
+static void sat_solver_act_var_clear(sat_solver* s) 
+{
+    int i;
+    for (i = 0; i < s->size; i++)
+        s->activity[i] = 0.0;
+    s->var_inc = 1.0;
+}
+
+#endif

src/abc8/bsat/satStore.h

+/**CFile****************************************************************
+
+  FileName    [satStore.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Proof recording.]
+
+  Synopsis    [External declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: pr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef __SAT_STORE_H__
+#define __SAT_STORE_H__
+
+#include "satSolver.h"
+
+/*
+    The trace of SAT solving contains the original clauses of the problem
+    along with the learned clauses derived during SAT solving.
+    The first line of the resulting file contains 3 numbers instead of 2:
+    c <num_vars> <num_all_clauses> <num_root_clauses>
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#define inline __inline // compatible with MS VS 6.0
+#endif
+
+#ifndef PRT
+#define PRT(a,t)  printf("%s = ", (a)); printf("%6.2f sec\n", (float)(t)/(float)(CLOCKS_PER_SEC))
+#endif
+
+#define STO_MAX(a,b)  ((a) > (b) ? (a) : (b))
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+/*
+typedef unsigned lit;
+// variable/literal conversions (taken from MiniSat)
+static inline lit   toLit    (int v)        { return v + v;  }
+static inline lit   toLitCond(int v, int c) { return v + v + (c != 0); }
+static inline lit   lit_neg  (lit l)        { return l ^ 1;  }
+static inline int   lit_var  (lit l)        { return l >> 1; }
+static inline int   lit_sign (lit l)        { return l & 1;  }
+static inline int   lit_print(lit l)        { return lit_sign(l)? -lit_var(l)-1 : lit_var(l)+1; }
+static inline lit   lit_read (int s)        { return s > 0 ? toLit(s-1) : lit_neg(toLit(-s-1)); }
+static inline int   lit_check(lit l, int n) { return l >= 0 && lit_var(l) < n;                  }
+*/
+
+typedef struct Sto_Cls_t_ Sto_Cls_t;
+struct Sto_Cls_t_
+{
+    Sto_Cls_t *     pNext;        // the next clause
+    Sto_Cls_t *     pNext0;       // the next 0-watch
+    Sto_Cls_t *     pNext1;       // the next 0-watch
+    int             Id;           // the clause ID
+    unsigned        fA     :  1;  // belongs to A
+    unsigned        fRoot  :  1;  // original clause
+    unsigned        fVisit :  1;  // visited clause
+    unsigned        nLits  : 24;  // the number of literals
+    lit             pLits[0];     // literals of this clause
+};
+
+typedef struct Sto_Man_t_ Sto_Man_t;
+struct Sto_Man_t_
+{
+    // general data
+    int             nVars;        // the number of variables
+    int             nRoots;       // the number of root clauses
+    int             nClauses;     // the number of all clauses
+    int             nClausesA;    // the number of clauses of A 
+    Sto_Cls_t *     pHead;        // the head clause
+    Sto_Cls_t *     pTail;        // the tail clause
+    Sto_Cls_t *     pEmpty;       // the empty clause
+    // memory management
+    int             nChunkSize;   // the number of bytes in a chunk
+    int             nChunkUsed;   // the number of bytes used in the last chunk
+    char *          pChunkLast;   // the last memory chunk
+};
+
+// iterators through the clauses
+#define Sto_ManForEachClause( p, pCls )      for( pCls = p->pHead; pCls; pCls = pCls->pNext )
+#define Sto_ManForEachClauseRoot( p, pCls )  for( pCls = p->pHead; pCls && pCls->fRoot; pCls = pCls->pNext )
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/*=== satStore.c ==========================================================*/
+extern Sto_Man_t *  Sto_ManAlloc();
+extern void         Sto_ManFree( Sto_Man_t * p );
+extern int          Sto_ManAddClause( Sto_Man_t * p, lit * pBeg, lit * pEnd );
+extern int          Sto_ManMemoryReport( Sto_Man_t * p );
+extern void         Sto_ManMarkRoots( Sto_Man_t * p );
+extern void         Sto_ManMarkClausesA( Sto_Man_t * p );
+extern void         Sto_ManDumpClauses( Sto_Man_t * p, char * pFileName );
+extern Sto_Man_t *  Sto_ManLoadClauses( char * pFileName );
+
+/*=== satInter.c ==========================================================*/
+typedef struct Int_Man_t_ Int_Man_t;
+extern Int_Man_t *  Int_ManAlloc();
+extern void         Int_ManFree( Int_Man_t * p );
+extern int          Int_ManInterpolate( Int_Man_t * p, Sto_Man_t * pCnf, int fVerbose, unsigned ** ppResult );
+
+/*=== satInterA.c ==========================================================*/
+typedef struct Inta_Man_t_ Inta_Man_t;
+extern Inta_Man_t * Inta_ManAlloc();
+extern void         Inta_ManFree( Inta_Man_t * p );
+extern void *       Inta_ManInterpolate( Inta_Man_t * p, Sto_Man_t * pCnf, void * vVarsAB, int fVerbose );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+

src/abc8/bsat/satTrace.c

+/**CFile****************************************************************
+
+  FileName    [satTrace.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT sat_solver.]
+
+  Synopsis    [Records the trace of SAT solving in the CNF form.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: satTrace.c,v 1.4 2005/09/16 22:55:03 casem Exp $]
+
+***********************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+#include "satSolver.h"
+
+/*
+    The trace of SAT solving contains the original clause of the problem
+    along with the learned clauses derived during SAT solving.
+    The first line of the resulting file contains 3 numbers instead of 2:
+    c <num_vars> <num_all_clauses> <num_root_clauses>
+*/
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Start the trace recording.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sat_SolverTraceStart( sat_solver * pSat, char * pName )
+{
+    assert( pSat->pFile == NULL );
+    pSat->pFile = fopen( pName, "w" );
+    fprintf( pSat->pFile, "                                        \n" );
+    pSat->nClauses = 0;
+    pSat->nRoots = 0;
+}   
+
+/**Function*************************************************************
+
+  Synopsis    [Stops the trace recording.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sat_SolverTraceStop( sat_solver * pSat )
+{
+    if ( pSat->pFile == NULL )
+        return;
+    rewind( pSat->pFile );
+    fprintf( pSat->pFile, "p %d %d %d", sat_solver_nvars(pSat), pSat->nClauses, pSat->nRoots );
+    fclose( pSat->pFile );
+    pSat->pFile = NULL;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Writes one clause into the trace file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sat_SolverTraceWrite( sat_solver * pSat, int * pBeg, int * pEnd, int fRoot )
+{
+    if ( pSat->pFile == NULL )
+        return;
+    pSat->nClauses++;
+    pSat->nRoots += fRoot;
+    for ( ; pBeg < pEnd ; pBeg++ )
+        fprintf( pSat->pFile, " %d", lit_print(*pBeg) );
+    fprintf( pSat->pFile, " 0\n" );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/abc8/bsat/satUtil.c

+/**CFile****************************************************************
+
+  FileName    [satUtil.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [C-language MiniSat solver.]
+
+  Synopsis    [Additional SAT solver procedures.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: satUtil.c,v 1.4 2005/09/16 22:55:03 casem Exp $]
+
+***********************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+#include "satSolver.h"
+#include "vec.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+struct clause_t
+{
+    int size_learnt;
+    lit lits[0];
+};
+
+static inline int  clause_size( clause* c )  { return c->size_learnt >> 1; }
+static inline lit* clause_begin( clause* c ) { return c->lits;             }
+
+static void Sat_SolverClauseWriteDimacs( FILE * pFile, clause * pC, bool fIncrement );
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Write the clauses in the solver into a file in DIMACS format.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sat_SolverWriteDimacs( sat_solver * p, char * pFileName, lit* assumptionsBegin, lit* assumptionsEnd, int incrementVars )
+{
+    FILE * pFile;
+    void ** pClauses;
+    int nClauses, i;
+
+    // count the number of clauses
+    nClauses = p->clauses.size + p->learnts.size;
+    for ( i = 0; i < p->size; i++ )
+        if ( p->levels[i] == 0 && p->assigns[i] != l_Undef )
+            nClauses++;
+
+    // start the file
+    pFile = fopen( pFileName, "wb" );
+    if ( pFile == NULL )
+    {
+        printf( "Sat_SolverWriteDimacs(): Cannot open the ouput file.\n" );
+        return;
+    }
+//    fprintf( pFile, "c CNF generated by ABC on %s\n", Extra_TimeStamp() );
+    fprintf( pFile, "p cnf %d %d\n", p->size, nClauses );
+
+    // write the original clauses
+    nClauses = p->clauses.size;
+    pClauses = p->clauses.ptr;
+    for ( i = 0; i < nClauses; i++ )
+        Sat_SolverClauseWriteDimacs( pFile, pClauses[i], incrementVars );
+
+    // write the learned clauses
+    nClauses = p->learnts.size;
+    pClauses = p->learnts.ptr;
+    for ( i = 0; i < nClauses; i++ )
+        Sat_SolverClauseWriteDimacs( pFile, pClauses[i], incrementVars );
+
+    // write zero-level assertions
+    for ( i = 0; i < p->size; i++ )
+        if ( p->levels[i] == 0 && p->assigns[i] != l_Undef )
+            fprintf( pFile, "%s%d%s\n",
+                     (p->assigns[i] == l_False)? "-": "",
+                     i + (int)(incrementVars>0),
+                     (incrementVars) ? " 0" : "");
+
+    // write the assumptions
+    if (assumptionsBegin) {
+        for (; assumptionsBegin != assumptionsEnd; assumptionsBegin++) {
+            fprintf( pFile, "%s%d%s\n",
+                     lit_sign(*assumptionsBegin)? "-": "",
+                     lit_var(*assumptionsBegin) + (int)(incrementVars>0),
+                     (incrementVars) ? " 0" : "");
+        }
+    }
+
+    fprintf( pFile, "\n" );
+    fclose( pFile );
+}   
+
+/**Function*************************************************************
+
+  Synopsis    [Writes the given clause in a file in DIMACS format.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sat_SolverClauseWriteDimacs( FILE * pFile, clause * pC, bool fIncrement )
+{
+    lit * pLits = clause_begin(pC);
+    int nLits = clause_size(pC);
+    int i;
+
+    for ( i = 0; i < nLits; i++ )
+        fprintf( pFile, "%s%d ", (lit_sign(pLits[i])? "-": ""),  lit_var(pLits[i]) + (int)(fIncrement>0) );
+    if ( fIncrement )
+        fprintf( pFile, "0" );
+    fprintf( pFile, "\n" );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes the given clause in a file in DIMACS format.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sat_SolverPrintStats( FILE * pFile, sat_solver * p )
+{
+//    printf( "calls         : %8d (%d)\n", (int)p->nCalls, (int)p->nCalls2 );
+    printf( "starts        : %8d\n", (int)p->stats.starts );
+    printf( "conflicts     : %8d\n", (int)p->stats.conflicts );
+    printf( "decisions     : %8d\n", (int)p->stats.decisions );
+    printf( "propagations  : %8d\n", (int)p->stats.propagations );
+    printf( "inspects      : %8d\n", (int)p->stats.inspects );
+//    printf( "inspects2     : %8d\n", (int)p->stats.inspects2 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns a counter-example.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int * Sat_SolverGetModel( sat_solver * p, int * pVars, int nVars )
+{
+    int * pModel;
+    int i;
+    pModel = ALLOC( int, nVars );
+    for ( i = 0; i < nVars; i++ )
+    {
+        assert( pVars[i] >= 0 && pVars[i] < p->size );
+        pModel[i] = (int)(p->model.ptr[pVars[i]] == l_True);
+    }
+    return pModel;    
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Duplicates all clauses, complements unit clause of the given var.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sat_SolverDoubleClauses( sat_solver * p, int iVar )
+{
+    clause * pClause;
+    lit Lit, * pLits;
+    int RetValue, nClauses, nVarsOld, nLitsOld, nLits, c, v;
+    // get the number of variables
+    nVarsOld = p->size;
+    nLitsOld = 2 * p->size;
+    // extend the solver to depend on two sets of variables
+    sat_solver_setnvars( p, 2 * p->size );
+    // duplicate implications
+    for ( v = 0; v < nVarsOld; v++ )
+        if ( p->assigns[v] != l_Undef )
+        {
+            Lit = nLitsOld + toLitCond( v, p->assigns[v]==l_False );
+            if ( v == iVar )
+                Lit = lit_neg(Lit);
+            RetValue = sat_solver_addclause( p, &Lit, &Lit + 1 );
+            assert( RetValue );
+        }
+    // duplicate clauses
+    nClauses = vecp_size(&p->clauses);
+    for ( c = 0; c < nClauses; c++ )
+    {
+        pClause = p->clauses.ptr[c];
+        nLits = clause_size(pClause);
+        pLits = clause_begin(pClause);
+        for ( v = 0; v < nLits; v++ )
+            pLits[v] += nLitsOld;
+        RetValue = sat_solver_addclause( p, pLits, pLits + nLits );
+        assert( RetValue );
+        for ( v = 0; v < nLits; v++ )
+            pLits[v] -= nLitsOld;
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/abc8/bsat/satVec.h

+/**************************************************************************************************
+MiniSat -- Copyright (c) 2005, Niklas Sorensson
+http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
+
+#ifndef satVec_h
+#define satVec_h
+
+#include <stdlib.h>
+
+// vector of 32-bit intergers (added for 64-bit portability)
+struct veci_t {
+    int    size;
+    int    cap;
+    int*   ptr;
+};
+typedef struct veci_t veci;
+
+static inline void veci_new (veci* v) {
+    v->size = 0;
+    v->cap  = 4;
+    v->ptr  = (int*)malloc(sizeof(int)*v->cap);
+}
+
+static inline void   veci_delete (veci* v)          { free(v->ptr);   }
+static inline int*   veci_begin  (veci* v)          { return v->ptr;  }
+static inline int    veci_size   (veci* v)          { return v->size; }
+static inline void   veci_resize (veci* v, int k)   { v->size = k;    } // only safe to shrink !!
+static inline void   veci_push   (veci* v, int e)
+{
+    if (v->size == v->cap) {
+        int newsize = v->cap * 2;//+1;
+        v->ptr = (int*)realloc(v->ptr,sizeof(int)*newsize);
+        v->cap = newsize; }
+    v->ptr[v->size++] = e;
+}
+
+
+// vector of 32- or 64-bit pointers
+struct vecp_t {
+    int    size;
+    int    cap;
+    void** ptr;
+};
+typedef struct vecp_t vecp;
+
+static inline void vecp_new (vecp* v) {
+    v->size = 0;
+    v->cap  = 4;
+    v->ptr  = (void**)malloc(sizeof(void*)*v->cap);
+}
+
+static inline void   vecp_delete (vecp* v)          { free(v->ptr);   }
+static inline void** vecp_begin  (vecp* v)          { return v->ptr;  }
+static inline int    vecp_size   (vecp* v)          { return v->size; }
+static inline void   vecp_resize (vecp* v, int   k) { v->size = k;    } // only safe to shrink !!
+static inline void   vecp_push   (vecp* v, void* e)
+{
+    if (v->size == v->cap) {
+        int newsize = v->cap * 2;//+1;
+        v->ptr = (void**)realloc(v->ptr,sizeof(void*)*newsize);
+        v->cap = newsize; }
+    v->ptr[v->size++] = e;
+}
+
+
+#endif

src/aig/cnf/cnf.h → src/abc8/cnf/cnf.h

@@ -35,7 +35,7 @@ extern "C" {
 #include <assert.h>
 #include <time.h>
 
-#include "vec.h"
+#include "vec2.h"
 #include "aig.h"
 #include "darInt.h"
 

src/aig/cnf/cnfWrite.c → src/abc8/cnf/cnfWrite.c

@@ -361,8 +361,10 @@ Cnf_Dat_t * Cnf_DeriveSimple( Aig_Man_t * p, int nOutputs )
     Number = 1;
     if ( nOutputs )
     {
-        assert( nOutputs == Aig_ManRegNum(p) );
-        Aig_ManForEachLiSeq( p, pObj, i )
+//        assert( nOutputs == Aig_ManRegNum(p) );
+//        Aig_ManForEachLiSeq( p, pObj, i )
+//            pCnf->pVarNums[pObj->Id] = Number++;
+        Aig_ManForEachPo( p, pObj, i )
             pCnf->pVarNums[pObj->Id] = Number++;
     }
     // assign variables to the internal nodes

src/aig/dar/darInt.h → src/abc8/dar/darInt.h

@@ -36,7 +36,7 @@ extern "C" {
 #include <time.h>
 
 //#include "bar.h"
-#include "vec.h"
+#include "vec2.h"
 #include "aig.h"
 #include "dar.h"
 

src/aig/dar/darRefact.c → src/abc8/dar/darRefact.c

@@ -18,8 +18,8 @@
 
 ***********************************************************************/
 
-#include "darInt.h"
 #include "kit.h"
+#include "darInt.h"
 
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///

src/aig/fra/fra.h → src/abc8/fra/fra.h

@@ -35,7 +35,7 @@ extern "C" {
 #include <assert.h>
 #include <time.h>
 
-#include "vec.h"
+#include "vec2.h"
 #include "aig.h"
 #include "dar.h"
 #include "satSolver.h"

src/aig/ioa/ioa.h → src/abc8/ioa/ioa.h

@@ -35,7 +35,7 @@ extern "C" {
 #include <assert.h>
 #include <time.h>
 
-#include "vec.h"
+#include "vec2.h"
 //#include "bar.h"
 #include "aig.h"