riscv
/
alliance
mirror of https://gitlab.lip6.fr/vlsi-eda/alliance.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Importing RDSCIF sources into the new CVS tree

This commit is contained in:
Frederic Petrot 2002-03-13 13:38:17 +00:00
parent 3663f0049a
commit 969d5ffc21
14 changed files with 5511 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
alliance/src/rdscif/Makefile.am Normal file
View File

@ -0,0 +1 @@
SUBDIRS = src

318
alliance/src/rdscif/Makefile.in Normal file
View File

@ -0,0 +1,318 @@
# Makefile.in generated automatically by automake 1.4 from Makefile.am
# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
SHELL = @SHELL@
srcdir = @srcdir@
top_srcdir = @top_srcdir@
VPATH = @srcdir@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
sbindir = @sbindir@
libexecdir = @libexecdir@
datadir = @datadir@
sysconfdir = @sysconfdir@
sharedstatedir = @sharedstatedir@
localstatedir = @localstatedir@
libdir = @libdir@
infodir = @infodir@
mandir = @mandir@
includedir = @includedir@
oldincludedir = /usr/include
DESTDIR =
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
top_builddir = .
ACLOCAL = @ACLOCAL@
AUTOCONF = @AUTOCONF@
AUTOMAKE = @AUTOMAKE@
AUTOHEADER = @AUTOHEADER@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
INSTALL_DATA = @INSTALL_DATA@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
transform = @program_transform_name@
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
CC = @CC@
INCLUDES = @INCLUDES@
LDFLAGS = @LDFLAGS@
RANLIB = @RANLIB@
SUBDIRS = src
mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs
CONFIG_CLEAN_FILES =
DIST_COMMON = Makefile.am Makefile.in configure configure.in
PACKAGE = @PACKAGE@
VERSION = @VERSION@
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = gtar
GZIP_ENV = --best
all: all-redirect
.SUFFIXES:
$(srcdir)/Makefile.in: Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4)
cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES)
cd $(top_builddir) \
&& CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status
config.status: $(srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
$(SHELL) ./config.status --recheck
$(srcdir)/configure: $(srcdir)/configure.in $(ACLOCAL_M4) $(CONFIGURE_DEPENDENCIES)
cd $(srcdir) && $(AUTOCONF)
# This directory's subdirectories are mostly independent; you can cd
# into them and run `make' without going through this Makefile.
# To change the values of `make' variables: instead of editing Makefiles,
# (1) if the variable is set in `config.status', edit `config.status'
# (which will cause the Makefiles to be regenerated when you run `make');
# (2) otherwise, pass the desired values on the `make' command line.
@SET_MAKE@
all-recursive install-data-recursive install-exec-recursive \
installdirs-recursive install-recursive uninstall-recursive \
check-recursive installcheck-recursive info-recursive dvi-recursive:
@set fnord $(MAKEFLAGS); amf=$$2; \
dot_seen=no; \
target=`echo $@ | sed s/-recursive//`; \
list='$(SUBDIRS)'; for subdir in $$list; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
dot_seen=yes; \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \
done; \
if test "$$dot_seen" = "no"; then \
$(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
fi; test -z "$$fail"
mostlyclean-recursive clean-recursive distclean-recursive \
maintainer-clean-recursive:
@set fnord $(MAKEFLAGS); amf=$$2; \
dot_seen=no; \
rev=''; list='$(SUBDIRS)'; for subdir in $$list; do \
rev="$$subdir $$rev"; \
test "$$subdir" = "." && dot_seen=yes; \
done; \
test "$$dot_seen" = "no" && rev=". $$rev"; \
target=`echo $@ | sed s/-recursive//`; \
for subdir in $$rev; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \
done && test -z "$$fail"
tags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
done
tags: TAGS
ID: $(HEADERS) $(SOURCES) $(LISP)
list='$(SOURCES) $(HEADERS)'; \
unique=`for i in $$list; do echo $$i; done | \
awk ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
here=`pwd` && cd $(srcdir) \
&& mkid -f$$here/ID $$unique $(LISP)
TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test -f $$subdir/TAGS && tags="$$tags -i $$here/$$subdir/TAGS"; \
fi; \
done; \
list='$(SOURCES) $(HEADERS)'; \
unique=`for i in $$list; do echo $$i; done | \
awk ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
|| (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS)
mostlyclean-tags:
clean-tags:
distclean-tags:
-rm -f TAGS ID
maintainer-clean-tags:
distdir = $(PACKAGE)-$(VERSION)
top_distdir = $(distdir)
# This target untars the dist file and tries a VPATH configuration. Then
# it guarantees that the distribution is self-contained by making another
# tarfile.
distcheck: dist
-rm -rf $(distdir)
GZIP=$(GZIP_ENV) $(TAR) zxf $(distdir).tar.gz
mkdir $(distdir)/=build
mkdir $(distdir)/=inst
dc_install_base=`cd $(distdir)/=inst && pwd`; \
cd $(distdir)/=build \
&& ../configure --srcdir=.. --prefix=$$dc_install_base \
&& $(MAKE) $(AM_MAKEFLAGS) \
&& $(MAKE) $(AM_MAKEFLAGS) dvi \
&& $(MAKE) $(AM_MAKEFLAGS) check \
&& $(MAKE) $(AM_MAKEFLAGS) install \
&& $(MAKE) $(AM_MAKEFLAGS) installcheck \
&& $(MAKE) $(AM_MAKEFLAGS) dist
-rm -rf $(distdir)
@banner="$(distdir).tar.gz is ready for distribution"; \
dashes=`echo "$$banner" | sed s/./=/g`; \
echo "$$dashes"; \
echo "$$banner"; \
echo "$$dashes"
dist: distdir
-chmod -R a+r $(distdir)
GZIP=$(GZIP_ENV) $(TAR) chozf $(distdir).tar.gz $(distdir)
-rm -rf $(distdir)
dist-all: distdir
-chmod -R a+r $(distdir)
GZIP=$(GZIP_ENV) $(TAR) chozf $(distdir).tar.gz $(distdir)
-rm -rf $(distdir)
distdir: $(DISTFILES)
-rm -rf $(distdir)
mkdir $(distdir)
-chmod 777 $(distdir)
here=`cd $(top_builddir) && pwd`; \
top_distdir=`cd $(distdir) && pwd`; \
distdir=`cd $(distdir) && pwd`; \
cd $(top_srcdir) \
&& $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --foreign Makefile
@for file in $(DISTFILES); do \
d=$(srcdir); \
if test -d $$d/$$file; then \
cp -pr $$/$$file $(distdir)/$$file; \
else \
test -f $(distdir)/$$file \
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \
|| cp -p $$d/$$file $(distdir)/$$file || :; \
fi; \
done
for subdir in $(SUBDIRS); do \
if test "$$subdir" = .; then :; else \
test -d $(distdir)/$$subdir \
|| mkdir $(distdir)/$$subdir \
|| exit 1; \
chmod 777 $(distdir)/$$subdir; \
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir=../$(distdir) distdir=../$(distdir)/$$subdir distdir) \
|| exit 1; \
fi; \
done
info-am:
info: info-recursive
dvi-am:
dvi: dvi-recursive
check-am: all-am
check: check-recursive
installcheck-am:
installcheck: installcheck-recursive
install-exec-am:
install-exec: install-exec-recursive
install-data-am:
install-data: install-data-recursive
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
install: install-recursive
uninstall-am:
uninstall: uninstall-recursive
all-am: Makefile
all-redirect: all-recursive
install-strip:
$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
installdirs: installdirs-recursive
installdirs-am:
mostlyclean-generic:
clean-generic:
distclean-generic:
-rm -f Makefile $(CONFIG_CLEAN_FILES)
-rm -f config.cache config.log stamp-h stamp-h[0-9]*
maintainer-clean-generic:
mostlyclean-am: mostlyclean-tags mostlyclean-generic
mostlyclean: mostlyclean-recursive
clean-am: clean-tags clean-generic mostlyclean-am
clean: clean-recursive
distclean-am: distclean-tags distclean-generic clean-am
distclean: distclean-recursive
-rm -f config.status
maintainer-clean-am: maintainer-clean-tags maintainer-clean-generic \
distclean-am
@echo "This command is intended for maintainers to use;"
@echo "it deletes files that may require special tools to rebuild."
maintainer-clean: maintainer-clean-recursive
-rm -f config.status
.PHONY: install-data-recursive uninstall-data-recursive \
install-exec-recursive uninstall-exec-recursive installdirs-recursive \
uninstalldirs-recursive all-recursive check-recursive \
installcheck-recursive info-recursive dvi-recursive \
mostlyclean-recursive distclean-recursive clean-recursive \
maintainer-clean-recursive tags tags-recursive mostlyclean-tags \
distclean-tags clean-tags maintainer-clean-tags distdir info-am info \
dvi-am dvi check check-am installcheck-am installcheck install-exec-am \
install-exec install-data-am install-data install-am install \
uninstall-am uninstall all-redirect all-am all installdirs-am \
installdirs mostlyclean-generic distclean-generic clean-generic \
maintainer-clean-generic clean mostlyclean distclean maintainer-clean
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

1634
alliance/src/rdscif/configure vendored Executable file
View File

File diff suppressed because it is too large Load Diff

51
alliance/src/rdscif/configure.in Normal file
View File

@ -0,0 +1,51 @@
dnl
dnl This file is part of the Alliance CAD System
dnl Copyright (C) Laboratoire LIP6 - Département ASIM
dnl Universite Pierre et Marie Curie
dnl
dnl Home page : http://www-asim.lip6.fr/alliance/
dnl E-mail support : mailto:alliance-support@asim.lip6.fr
dnl
dnl This library is free software; you can redistribute it and/or modify it
dnl under the terms of the GNU Library General Public License as published
dnl by the Free Software Foundation; either version 2 of the License, or (at
dnl your option) any later version.
dnl
dnl Alliance VLSI CAD System is distributed in the hope that it will be
dnl useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
dnl Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License along
dnl with the GNU C Library; see the file COPYING. If not, write to the Free
dnl Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
dnl
dnl Purpose : Auto stuffing Alliance
dnl Almost ten years since I wrote this stuff, I just can't
dnl believe it
dnl Date : 01/02/2002
dnl Author : Frederic Petrot <Frederic.Petrot@lip6.fr>
dnl $Id: configure.in,v 1.1 2002/03/13 13:38:16 fred Exp $
dnl
dnl
AC_INIT(src/cif_drive.c)
AM_INIT_AUTOMAKE(rdscif, 2.1)
AC_PROG_INSTALL
AC_PROG_CC
AC_HEADER_STDC
AC_C_CONST
AC_PROG_RANLIB
changequote(,)dnl
INCLUDES=-I${ALLIANCE_TOP}/include
LDFLAGS=-L${ALLIANCE_TOP}/lib
changequote([,])dnl
AC_SUBST(INCLUDES)
AC_SUBST(LDFLAGS)
AC_OUTPUT([
Makefile
src/Makefile
])

2
alliance/src/rdscif/src/Makefile.am Normal file
View File

@ -0,0 +1,2 @@
lib_LIBRARIES = libRcf.a
libRcf_a_SOURCES = cif_drive.c cif_error.c cif_parse.c rcf.h cif.h cif_drive.h cif_error.h cif_parse.h

317
alliance/src/rdscif/src/Makefile.in Normal file
View File

@ -0,0 +1,317 @@
# Makefile.in generated automatically by automake 1.4 from Makefile.am
# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
SHELL = @SHELL@
srcdir = @srcdir@
top_srcdir = @top_srcdir@
VPATH = @srcdir@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
sbindir = @sbindir@
libexecdir = @libexecdir@
datadir = @datadir@
sysconfdir = @sysconfdir@
sharedstatedir = @sharedstatedir@
localstatedir = @localstatedir@
libdir = @libdir@
infodir = @infodir@
mandir = @mandir@
includedir = @includedir@
oldincludedir = /usr/include
DESTDIR =
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
top_builddir = ..
ACLOCAL = @ACLOCAL@
AUTOCONF = @AUTOCONF@
AUTOMAKE = @AUTOMAKE@
AUTOHEADER = @AUTOHEADER@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
INSTALL_DATA = @INSTALL_DATA@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
transform = @program_transform_name@
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
CC = @CC@
INCLUDES = @INCLUDES@
LDFLAGS = @LDFLAGS@
RANLIB = @RANLIB@
lib_LIBRARIES = libRcf.a
libRcf_a_SOURCES = cif_drive.c cif_error.c cif_parse.c rcf.h cif.h cif_drive.h cif_error.h cif_parse.h
mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs
CONFIG_CLEAN_FILES =
LIBRARIES = $(lib_LIBRARIES)
DEFS = @DEFS@ -I. -I$(srcdir)
CPPFLAGS = @CPPFLAGS@
LIBS = @LIBS@
libRcf_a_LIBADD =
libRcf_a_OBJECTS = cif_drive.o cif_error.o cif_parse.o
AR = ar
CFLAGS = @CFLAGS@
COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@
DIST_COMMON = Makefile.am Makefile.in
PACKAGE = @PACKAGE@
VERSION = @VERSION@
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = gtar
GZIP_ENV = --best
DEP_FILES = .deps/cif_drive.P .deps/cif_error.P .deps/cif_parse.P
SOURCES = $(libRcf_a_SOURCES)
OBJECTS = $(libRcf_a_OBJECTS)
all: all-redirect
.SUFFIXES:
.SUFFIXES: .S .c .o .s
$(srcdir)/Makefile.in: Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4)
cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES)
cd $(top_builddir) \
&& CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
mostlyclean-libLIBRARIES:
clean-libLIBRARIES:
-test -z "$(lib_LIBRARIES)" || rm -f $(lib_LIBRARIES)
distclean-libLIBRARIES:
maintainer-clean-libLIBRARIES:
install-libLIBRARIES: $(lib_LIBRARIES)
@$(NORMAL_INSTALL)
$(mkinstalldirs) $(DESTDIR)$(libdir)
@list='$(lib_LIBRARIES)'; for p in $$list; do \
if test -f $$p; then \
echo " $(INSTALL_DATA) $$p $(DESTDIR)$(libdir)/$$p"; \
$(INSTALL_DATA) $$p $(DESTDIR)$(libdir)/$$p; \
else :; fi; \
done
@$(POST_INSTALL)
@list='$(lib_LIBRARIES)'; for p in $$list; do \
if test -f $$p; then \
echo " $(RANLIB) $(DESTDIR)$(libdir)/$$p"; \
$(RANLIB) $(DESTDIR)$(libdir)/$$p; \
else :; fi; \
done
uninstall-libLIBRARIES:
@$(NORMAL_UNINSTALL)
list='$(lib_LIBRARIES)'; for p in $$list; do \
rm -f $(DESTDIR)$(libdir)/$$p; \
done
.s.o:
$(COMPILE) -c $<
.S.o:
$(COMPILE) -c $<
mostlyclean-compile:
-rm -f *.o core *.core
clean-compile:
distclean-compile:
-rm -f *.tab.c
maintainer-clean-compile:
libRcf.a: $(libRcf_a_OBJECTS) $(libRcf_a_DEPENDENCIES)
-rm -f libRcf.a
$(AR) cru libRcf.a $(libRcf_a_OBJECTS) $(libRcf_a_LIBADD)
$(RANLIB) libRcf.a
tags: TAGS
ID: $(HEADERS) $(SOURCES) $(LISP)
list='$(SOURCES) $(HEADERS)'; \
unique=`for i in $$list; do echo $$i; done | \
awk ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
here=`pwd` && cd $(srcdir) \
&& mkid -f$$here/ID $$unique $(LISP)
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS)'; \
unique=`for i in $$list; do echo $$i; done | \
awk ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
|| (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS)
mostlyclean-tags:
clean-tags:
distclean-tags:
-rm -f TAGS ID
maintainer-clean-tags:
distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)
subdir = src
distdir: $(DISTFILES)
here=`cd $(top_builddir) && pwd`; \
top_distdir=`cd $(top_distdir) && pwd`; \
distdir=`cd $(distdir) && pwd`; \
cd $(top_srcdir) \
&& $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --foreign src/Makefile
@for file in $(DISTFILES); do \
d=$(srcdir); \
if test -d $$d/$$file; then \
cp -pr $$/$$file $(distdir)/$$file; \
else \
test -f $(distdir)/$$file \
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \
|| cp -p $$d/$$file $(distdir)/$$file || :; \
fi; \
done
DEPS_MAGIC := $(shell mkdir .deps > /dev/null 2>&1 || :)
-include $(DEP_FILES)
mostlyclean-depend:
clean-depend:
distclean-depend:
-rm -rf .deps
maintainer-clean-depend:
%.o: %.c
@echo '$(COMPILE) -c $<'; \
$(COMPILE) -Wp,-MD,.deps/$(*F).pp -c $<
@-cp .deps/$(*F).pp .deps/$(*F).P; \
tr ' ' '\012' < .deps/$(*F).pp \
| sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \
>> .deps/$(*F).P; \
rm .deps/$(*F).pp
%.lo: %.c
@echo '$(LTCOMPILE) -c $<'; \
$(LTCOMPILE) -Wp,-MD,.deps/$(*F).pp -c $<
@-sed -e 's/^\([^:]*\)\.o[ ]*:/\1.lo \1.o :/' \
< .deps/$(*F).pp > .deps/$(*F).P; \
tr ' ' '\012' < .deps/$(*F).pp \
| sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \
>> .deps/$(*F).P; \
rm -f .deps/$(*F).pp
info-am:
info: info-am
dvi-am:
dvi: dvi-am
check-am: all-am
check: check-am
installcheck-am:
installcheck: installcheck-am
install-exec-am: install-libLIBRARIES
install-exec: install-exec-am
install-data-am:
install-data: install-data-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
install: install-am
uninstall-am: uninstall-libLIBRARIES
uninstall: uninstall-am
all-am: Makefile $(LIBRARIES)
all-redirect: all-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
installdirs:
$(mkinstalldirs) $(DESTDIR)$(libdir)
mostlyclean-generic:
clean-generic:
distclean-generic:
-rm -f Makefile $(CONFIG_CLEAN_FILES)
-rm -f config.cache config.log stamp-h stamp-h[0-9]*
maintainer-clean-generic:
mostlyclean-am: mostlyclean-libLIBRARIES mostlyclean-compile \
mostlyclean-tags mostlyclean-depend mostlyclean-generic
mostlyclean: mostlyclean-am
clean-am: clean-libLIBRARIES clean-compile clean-tags clean-depend \
clean-generic mostlyclean-am
clean: clean-am
distclean-am: distclean-libLIBRARIES distclean-compile distclean-tags \
distclean-depend distclean-generic clean-am
distclean: distclean-am
maintainer-clean-am: maintainer-clean-libLIBRARIES \
maintainer-clean-compile maintainer-clean-tags \
maintainer-clean-depend maintainer-clean-generic \
distclean-am
@echo "This command is intended for maintainers to use;"
@echo "it deletes files that may require special tools to rebuild."
maintainer-clean: maintainer-clean-am
.PHONY: mostlyclean-libLIBRARIES distclean-libLIBRARIES \
clean-libLIBRARIES maintainer-clean-libLIBRARIES uninstall-libLIBRARIES \
install-libLIBRARIES mostlyclean-compile distclean-compile \
clean-compile maintainer-clean-compile tags mostlyclean-tags \
distclean-tags clean-tags maintainer-clean-tags distdir \
mostlyclean-depend distclean-depend clean-depend \
maintainer-clean-depend info-am info dvi-am dvi check check-am \
installcheck-am installcheck install-exec-am install-exec \
install-data-am install-data install-am install uninstall-am uninstall \
all-redirect all-am all installdirs mostlyclean-generic \
distclean-generic clean-generic maintainer-clean-generic clean \
mostlyclean distclean maintainer-clean
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

56
alliance/src/rdscif/src/cif.h Normal file
View File

@ -0,0 +1,56 @@
#ifndef __P
# if defined(__STDC__) || defined(__GNUC__)
# define __P(x) x
# else
# define __P(x) ()
# endif
#endif
/*------------------------------------------------------------\
| |
| Tool : RDSCIF |
| |
| File : cif.h |
| |
| Authors : Petrot Frederic & Jacomme Ludovic |
| --------- |
| Date : The king ^ 04/07/93 |
| |
\------------------------------------------------------------*/
# ifndef RDSCIF_CIF
# define RDSCIF_CIF
/*------------------------------------------------------------\
| |
| Constants |
| |
\------------------------------------------------------------*/
/* Fred the king, has written this line !!!! */
# define CIF_UNIT 100
/* You can't beleive it ?, but it's true !! */
/*------------------------------------------------------------\
| |
| Macro |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Types |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Variables |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Functions |
| |
\------------------------------------------------------------*/
# endif

718
alliance/src/rdscif/src/cif_drive.c Normal file
View File

@ -0,0 +1,718 @@
/*------------------------------------------------------------\
| |
| Tool : RDSCIF |
| |
| File : cif_drive.c |
| |
| Authors : Petrot Frederic & Jacomme Ludovic |
| --------- --------- |
| Date : The king ^ 04/07/93 ^ The slave |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Include Files |
| |
\------------------------------------------------------------*/
# include <stdlib.h>
# include <stdio.h>
# include <time.h>
# include <mut.h>
# include <mph.h>
# include <rds.h>
# include <rpr.h>
# include <rfm.h>
# include <rwi.h>
# include <rut.h>
# include <rtl.h>
# include "cif.h"
# include "cif_error.h"
# include "cif_drive.h"
/*------------------------------------------------------------\
| |
| Constants |
| |
\------------------------------------------------------------*/
static char CifBuffer[ 256 ];
static long CIF_DS_A = 0;
static long CIF_DS_B = 0;
static ptype_list *HEAD_CIF_MODEL = (ptype_list *)NULL;
static long CifModelIndex = 0;
static int RDS_CIF_BERKLEY_DRIVER = 0;
/*------------------------------------------------------------\
| |
| Types |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Variables |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Functions |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| rdstocifname |
| |
\------------------------------------------------------------*/
char *rdstocifname( Name )
char *Name;
{
char *Source;
char *Target;
char One;
if ( Name == (char *)NULL )
{
return( (char *)NULL );
}
One = 1;
Source = Name;
Target = CifBuffer;
while ( *Source != '\0' )
{
if ( *Source == ' ' )
{
if ( One )
{
*Target++ = '[';
Source++;
One = 0;
}
else
{
*Target++ = ']';
*Target++ = '[';
Source++;
}
}
if ( ( *Source == SEPAR ) && ( ! One ) )
{
*Target++ = ']';
One = 1;
}
*Target++ = *Source++;
}
if ( ! One )
{
*Target++ = ']';
}
*Target = '\0';
return ( CifBuffer );
}
/*------------------------------------------------------------\
| |
| r_cif_model_list |
| |
\------------------------------------------------------------*/
static ptype_list *r_cif_model_list( Figure )
rdsfig_list *Figure;
{
rdsins_list *Instance;
rdsfig_list *Model;
ptype_list *List;
for ( Instance = Figure->INSTANCE;
Instance != (rdsins_list *)NULL;
Instance = Instance->NEXT )
{
for ( List = HEAD_CIF_MODEL;
List != (ptype_list *)NULL;
List = List->NEXT )
{
if (((rdsfig_list *)List->DATA)->NAME == Instance->FIGNAME )
{
break;
}
}
if ( List == (ptype_list *)NULL )
{
for ( Model = HEAD_RDSFIG;
Model != (rdsfig_list *)NULL;
Model = Model->NEXT )
{
if ( Model->NAME == Instance->FIGNAME ) break;
}
if ( Model == (rdsfig_list *)NULL )
{
ciferror( CIF_ERROR_MODEL, Instance->FIGNAME, 0 );
}
(void)r_cif_model_list( Model );
}
}
HEAD_CIF_MODEL = addptype( HEAD_CIF_MODEL,
++CifModelIndex, (char *)Figure );
return( HEAD_CIF_MODEL );
}
/*------------------------------------------------------------\
| |
| cif_model_list |
| |
\------------------------------------------------------------*/
ptype_list *cif_model_list( Figure )
rdsfig_list *Figure;
{
CifModelIndex = 0;
if ( HEAD_CIF_MODEL != (ptype_list *)NULL )
{
freeptype( HEAD_CIF_MODEL);
}
HEAD_CIF_MODEL = NULL;
return( r_cif_model_list( Figure ) );
}
/*------------------------------------------------------------\
| |
| write_figure |
| |
\------------------------------------------------------------*/
void write_figure( File, Model )
FILE *File;
long Model;
{
(void)fprintf( File, "C%ld;\n", Model );
}
/*------------------------------------------------------------\
| |
| write_instance |
| |
\------------------------------------------------------------*/
void write_instance( File, Name, Model, X, Y, Trans )
FILE *File;
char *Name;
long Model;
long X;
long Y;
long Trans;
{
char Buffer[ 100 ];
long Xcif;
long Ycif;
Xcif = RDS_TO_CIF_UNIT( X );
Ycif = RDS_TO_CIF_UNIT( Y );
switch ( Trans )
{
case RDS_NOSYM :
(void)sprintf( Buffer, "T%ld, %ld", Xcif, Ycif );
break;
case RDS_SYM_X :
(void)sprintf( Buffer, "MX T%ld, %ld", Xcif, Ycif );
break;
case RDS_SYM_Y :
(void)sprintf( Buffer, "MY T%ld, %ld", Xcif, Ycif );
break;
case RDS_SYMXY :
(void)sprintf( Buffer, "R-1, 0 T%ld, %ld", Xcif, Ycif );
break;
case RDS_ROT_P :
(void)sprintf( Buffer, "R0, 1 T%ld, %ld", Xcif, Ycif );
break;
case RDS_ROT_M :
(void)sprintf( Buffer, "R0, -1 T%ld, %ld", Xcif, Ycif );
break;
case RDS_SY_RP :
(void)sprintf( Buffer, "MX R0, -1 T%ld, %ld", Xcif, Ycif );
break;
case RDS_SY_RM :
(void)sprintf( Buffer, "MX R0, 1 T%ld, %ld", Xcif, Ycif );
break;
default :
ciferror( CIF_ERROR_BAD_TRANS, Name, 0 );
}
if ( ! RDS_CIF_BERKLEY_DRIVER )
{
(void)fprintf( File, "4I %s;", Name);
}
else
{
(void)fprintf( File, "91 %s;", Name);
}
(void)fprintf( File, "C%ld %s;\n", Model, Buffer );
}
/*------------------------------------------------------------\
| |
| write_connector |
| |
\------------------------------------------------------------*/
void write_connector( File, Name, Index, Width, X, Y, Dx, Dy, Layer, WriteLayer )
FILE *File;
char *Name;
long Index;
long Width;
long X;
long Y;
long Dx;
long Dy;
char *Layer;
char WriteLayer;
{
if ( Name == (char *)NULL )
{
ciferror( CIF_ERROR_CONNECTOR_NAME, (char *)X, Y );
}
if ( WriteLayer )
{
(void)fprintf( File, "L%s;\n", Layer );
}
Name = rdstocifname( Name );
if ( ! RDS_CIF_BERKLEY_DRIVER )
{
(void)fprintf( File, "4X %s %ld %ld %ld %ld %s;\n",
Name, Index,
RDS_TO_CIF_UNIT( X ) + RDS_TO_CIF_UNIT( Dx ) / 2,
RDS_TO_CIF_UNIT( Y ) + RDS_TO_CIF_UNIT( Dy ) / 2,
RDS_TO_CIF_UNIT( Width ), Name );
}
else
{
(void)fprintf( File, "94 %s %ld %ld %s;\n",
Name,
RDS_TO_CIF_UNIT( X ) + RDS_TO_CIF_UNIT( Dx ) / 2,
RDS_TO_CIF_UNIT( Y ) + RDS_TO_CIF_UNIT( Dy ) / 2,
Layer );
}
}
/*------------------------------------------------------------\
| |
| write_rectangle |
| |
\------------------------------------------------------------*/
void write_rectangle( File, Name, X, Y, Dx, Dy, Layer, WriteLayer )
FILE *File;
char *Name;
long X;
long Y;
long Dx;
long Dy;
char *Layer;
char WriteLayer;
{
if ( WriteLayer )
{
(void)fprintf( File, "L%s;\n", Layer );
}
if ( ( Name != (char *)NULL ) &&
( *Name != '*' ) &&
( *Name != '\0' ) )
{
if ( ! RDS_CIF_BERKLEY_DRIVER )
{
(void)fprintf( File, "4N %s %ld %ld;\n",
rdstocifname( Name ),
RDS_TO_CIF_UNIT( X ) + RDS_TO_CIF_UNIT( Dx ) / 2,
RDS_TO_CIF_UNIT( Y ) + RDS_TO_CIF_UNIT( Dy ) / 2);
}
else
{
(void)fprintf( File, "95 %s %ld %ld %ld %ld %s;\n",
rdstocifname( Name ),
RDS_TO_CIF_UNIT( Dx ), RDS_TO_CIF_UNIT( Dy ),
RDS_TO_CIF_UNIT( X ) + RDS_TO_CIF_UNIT( Dx ) / 2,
RDS_TO_CIF_UNIT( Y ) + RDS_TO_CIF_UNIT( Dy ) / 2,
Layer );
}
}
(void)fprintf( File, "B%ld %ld %ld %ld;\n",
RDS_TO_CIF_UNIT( ABSOLUTE( Dx ) ),
RDS_TO_CIF_UNIT( ABSOLUTE( Dy ) ),
RDS_TO_CIF_UNIT( X ) + RDS_TO_CIF_UNIT( Dx ) / 2,
RDS_TO_CIF_UNIT( Y ) + RDS_TO_CIF_UNIT( Dy ) / 2);
}
/*------------------------------------------------------------\
| |
| write_header |
| |
\------------------------------------------------------------*/
void write_header( File, Name )
FILE *File;
char *Name;
{
long Counter;
(void)time( &Counter );
(void)fprintf( File, "(rds to CIF driver cvs version $Revision: 1.1 $\n");
(void)fprintf( File, "technology %s\n", RDS_TECHNO_NAME );
(void)fprintf( File, "%s" , ctime( &Counter ) );
(void)fprintf( File, "%s\n", Name );
(void)fprintf( File, "%s);\n\n", mbkgetenv("USER") );
}
/*------------------------------------------------------------\
| |
| write_header |
| |
\------------------------------------------------------------*/
void write_tail( File, X, Y, Dx, Dy )
FILE *File;
long X;
long Y;
long Dx;
long Dy;
{
(void)fprintf( File, "(AB : %.2f, %.2f %.2f, %.2f in micron); \n",
(float)X / RDS_UNIT,
(float)Y / RDS_UNIT,
(float)(X + Dx) / RDS_UNIT,
(float)(Y + Dy) / RDS_UNIT );
}
/*------------------------------------------------------------\
| |
| write_model_header |
| |
\------------------------------------------------------------*/
void write_model_header( File, ModelName, ModelNum )
FILE *File;
char *ModelName;
long ModelNum;
{
(void)fprintf( File, "DS%ld %ld %ld;\n", ModelNum, CIF_DS_A, CIF_DS_B * 2 );
(void)fprintf( File, "9 %s;\n", ModelName );
}
/*------------------------------------------------------------\
| |
| write_model_abox |
| |
\------------------------------------------------------------*/
void write_model_abox( File, X, Y, Dx, Dy )
FILE *File;
long X;
long Y;
long Dx;
long Dy;
{
(void)fprintf( File, "(AB : %.2f, %.2f %.2f, %.2f in micron);\n",
(float)X / RDS_UNIT,
(float)Y / RDS_UNIT,
(float)(X + Dx) / RDS_UNIT,
(float)(Y + Dy) / RDS_UNIT);
if ( ! RDS_CIF_BERKLEY_DRIVER )
{
(void)fprintf( File, "4A %ld %ld %ld %ld; \n",
RDS_TO_CIF_UNIT( X ),
RDS_TO_CIF_UNIT( Y ),
RDS_TO_CIF_UNIT( X + Dx ),
RDS_TO_CIF_UNIT( Y + Dy ) );
}
}
/*------------------------------------------------------------\
| |
| write_model_tail |
| |
\------------------------------------------------------------*/
void write_model_tail( File )
FILE *File;
{
(void)fprintf( File, "DF;\n\n" );
}
/*------------------------------------------------------------\
| |
| getcifmodel |
| |
\------------------------------------------------------------*/
long getcifmodel( Head, Name )
ptype_list *Head;
char *Name;
{
ptype_list *Scan;
for ( Scan = Head;
Scan != (ptype_list *)NULL;
Scan = Scan->NEXT )
{
if (((rdsfig_list *)Scan->DATA)->NAME == Name )
{
return( Scan->TYPE );
}
}
return( 0 );
}
/*------------------------------------------------------------\
| |
| compute_cif_unit |
| |
\------------------------------------------------------------*/
void compute_cif_unit()
{
/* why CIF_DS_A, CIF_DS_B ?
the simple of driving CIF would be to take both as 1, and have on
each coordinate a (x * CIF_UNIT)/rds_unit).
The interest here is to shorten the lenght of the numbers in the
CIF output, and to be able to express a precision better that a
centh of a micron.
CIF_DS_A and CIF_DS_B are defined as follow :
(CIF_DS_A / CIF_DS_B) * rds_unit = CIF_UNIT
see CIF documentation for details.
the coodinates for CIF will be computed like
(x * CIF_DS_B) / (CIF_DS_A * rds_unit).
The computation algorithm is equivalent to the one given in the
function RprComputeRdsUnit, so take a look there for details.
Friendly, The king ... */
/* why 2 * CIF_UNIT ?
because all the rectangles in the CIF file are written like
BOXES, ie dx and dy must be even since we drive dx/2 dy/2
and we don't want to lose any information! */
int cif_unit = 2 * CIF_UNIT;
if ( RDS_UNIT < cif_unit )
{
for ( CIF_DS_A = 1, CIF_DS_B = 1;
( CIF_DS_A * RDS_UNIT ) != ( cif_unit * CIF_DS_B );
CIF_DS_B++ )
{
for ( CIF_DS_A--;
( CIF_DS_A * RDS_UNIT ) < ( cif_unit * CIF_DS_B );
(CIF_DS_A)++ );
if ( ( CIF_DS_A * RDS_UNIT ) == ( cif_unit * CIF_DS_B ) ) break;
}
}
else
{
for ( CIF_DS_A = 1, CIF_DS_B = 1;
( CIF_DS_A * RDS_UNIT ) != ( cif_unit * CIF_DS_B );
CIF_DS_A++ )
{
for ( CIF_DS_B--;
( CIF_DS_A * RDS_UNIT ) > ( cif_unit * CIF_DS_B );
CIF_DS_B++ );
if ( ( CIF_DS_A * RDS_UNIT ) == ( cif_unit * CIF_DS_B ) ) break;
}
}
}
/*------------------------------------------------------------\
| |
| drive_model |
| |
\------------------------------------------------------------*/
void drive_model( File, Model, Figure )
FILE *File;
ptype_list *Model;
rdsfig_list *Figure;
{
rdsrec_list *Rectangle;
rdsins_list *Instance;
int Layer;
int WriteLayer;
long Index;
char *CifLayer;
Index = 0;
for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
{
if ( Layer == RDS_ABOX ) continue;
CifLayer = GET_CIF_LAYER( Layer );
if ( CifLayer == RDS_CIF_LAYER_EMPTY ) continue;
WriteLayer = 1;
for ( Rectangle = Figure->LAYERTAB[ Layer ];
Rectangle != (rdsrec_list *)NULL;
Rectangle = Rectangle->NEXT )
{
/* drive connector :
put the connector name in vti cif dialect.
if the rds doesn't come from mbk, the type may be set but the
mbk pointer may be null. */
if ( ( ( IsRdsConExter( Rectangle ) ) ||
( IsRdsRefCon ( Rectangle ) ) ) &&
! IsRdsVia( Rectangle )
)
{
write_connector( File,
Rectangle->NAME, ++Index,
( Rectangle->DX > Rectangle->DY ) ?
Rectangle->DX : Rectangle->DY,
Rectangle->X , Rectangle->Y,
Rectangle->DX , Rectangle->DY,
CifLayer, WriteLayer );
}
write_rectangle( File,
Rectangle->NAME,
Rectangle->X , Rectangle->Y,
Rectangle->DX, Rectangle->DY,
CifLayer, WriteLayer );
/* layer choice :
the layer is driven only once, since in cif when a layer is defined,
all further objects are build with this layer. This is close of the
rds representation, so the writting functions print a layer when the
parameter is not NULL, nothing if it is. The king ... */
WriteLayer = 0;
}
}
for ( Instance = Figure->INSTANCE;
Instance != (rdsins_list *)NULL;
Instance = Instance->NEXT )
{
write_instance( File, Instance->INSNAME,
getcifmodel( Model, Instance->FIGNAME ),
Instance->X, Instance->Y,
(long)Instance->TRANSF );
}
}
/*------------------------------------------------------------\
| |
| cifsaverdsfig |
| |
\------------------------------------------------------------*/
void cifsaverdsfig( Figure )
rdsfig_list *Figure;
{
FILE *File;
ptype_list *Model;
ptype_list *List;
rdsrec_list *Abox;
if ( mbkgetenv( "RDS_CIF_BERKLEY_DRIVER" ) != (char *)0 )
{
RDS_CIF_BERKLEY_DRIVER = 1;
}
else
{
RDS_CIF_BERKLEY_DRIVER = 0;
}
compute_cif_unit();
List = Model = (ptype_list *)reverse((chain_list *)cif_model_list( Figure ) );
if ( ( File = mbkfopen( Figure->NAME, "cif", "w" ) ) == NULL )
{
ciferror( CIF_ERROR_FILE_OPEN, Figure->NAME, 0 );
}
write_header( File, Figure->NAME );
while ( Model != (ptype_list *)NULL )
{
write_model_header( File, ((rdsfig_list *)Model->DATA)->NAME,
Model->TYPE );
Abox = ((rdsfig_list *)Model->DATA)->LAYERTAB[ RDS_ABOX ];
if ( Abox != (rdsrec_list *)NULL )
{
write_model_abox( File, Abox->X, Abox->Y,
Abox->DX, Abox->DY );
}
drive_model( File, List, ((rdsfig_list *)Model->DATA) );
write_model_tail( File );
Model = Model->NEXT;
}
write_figure( File, getcifmodel( List, Figure->NAME ) );
Abox = Figure->LAYERTAB[ RDS_ABOX ];
if ( Abox != (rdsrec_list *)NULL )
{
write_tail( File, Abox->X, Abox->Y, Abox->DX, Abox->DY );
}
(void)fprintf( File, "E \n");
if ( fclose( File ) )
{
ciferror( CIF_ERROR_FILE_CLOSE, Figure->NAME, 0 );
}
}

58
alliance/src/rdscif/src/cif_drive.h Normal file
View File

@ -0,0 +1,58 @@
#ifndef __P
# if defined(__STDC__) || defined(__GNUC__)
# define __P(x) x
# else
# define __P(x) ()
# endif
#endif
/*------------------------------------------------------------\
| |
| Tool : RDSCIF |
| |
| File : cif_drive.h |
| |
| Authors : Petrot Frederic & Jacomme Ludovic |
| --------- |
| Date : The king ^ 04/07/93 |
| |
\------------------------------------------------------------*/
# ifndef RDSCIF_DRIVE
# define RDSCIF_DRIVE
/*------------------------------------------------------------\
| |
| Constants |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Macro |
| |
\------------------------------------------------------------*/
/* See the comment in CifComputUnit for the 2 * CIF_UNIT here */
# define RDS_TO_CIF_UNIT( X ) \
\
( ( ( ( X ) * 2 * CIF_UNIT / RDS_UNIT) * CIF_DS_B ) / CIF_DS_A )
# define ABSOLUTE( X ) \
\
( ( ( X ) > 0 ) ? ( X ) : -( X ) )
/*------------------------------------------------------------\
| |
| Types |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Variables |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Functions |
| |
\------------------------------------------------------------*/
# endif

315
alliance/src/rdscif/src/cif_error.c Normal file
View File

@ -0,0 +1,315 @@
/*------------------------------------------------------------\
| |
| Tool : RDSCIF |
| |
| File : cif_error.c |
| |
| Authors : Petrot Frederic & Jacomme Ludovic |
| --------- |
| Date : The king ^ 04/07/93 |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Include Files |
| |
\------------------------------------------------------------*/
# include <stdio.h>
# include <mut.h>
# include "cif_error.h"
/*------------------------------------------------------------\
| |
| Constants |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Types |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Variables |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Functions |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| ciferror |
| |
\------------------------------------------------------------*/
void ciferror( Error, Text, Value )
char Error;
char *Text;
long Value;
{
switch( Error )
{
case CIF_ERROR_BAD_TRANS :
(void)fprintf( stderr,
"cif109: Unknown instance transformation on `%s'\n",
Text );
break;
case CIF_ERROR_CONNECTOR_NAME :
(void)fprintf( stderr,
"cif109: Rds connector (%ld, %ld) has no name !\n",
(long)Text, Value );
break;
case CIF_ERROR_FILE_OPEN :
(void)fprintf( stderr,
"cif109: Could not open file `%s'\n",
Text );
break;
case CIF_ERROR_FILE_CLOSE :
(void)fprintf( stderr,
"cif109: Could not close file `%s'\n",
Text );
break;
case CIF_ERROR_MODEL :
(void)fprintf( stderr,
"cif109: Could not find model `%s'\n",
Text );
break;
case CIF_ERROR_EXPECTED_SEMI :
(void)fprintf( stderr,
"cif109: Missing ';' line %ld\n",
Value );
break;
case CIF_ERROR_EXPECTED_SPACE :
(void)fprintf( stderr,
"cif109: Missing space, line %ld\n",
Value );
break;
case CIF_ERROR_EXPECTED_NAME :
(void)fprintf( stderr,
"cif109: Missing name, line %ld\n",
Value );
break;
case CIF_ERROR_EXPECTED_UNSIGNED :
(void)fprintf( stderr,
"cif109: Missing unsigned integer, line %ld\n",
Value );
break;
case CIF_ERROR_EXPECTED_SIGNED :
(void)fprintf( stderr,
"cif109: Missing signed integer, line %ld\n",
Value );
break;
case CIF_ERROR_EXPECTED_LAYER :
(void)fprintf( stderr,
"cif109: Missing layer name, line %ld\n",
Value );
break;
case CIF_ERROR_EXPECTED_MANHATTAN :
(void)fprintf( stderr,
"cif109: Expected manhattan distance, line %ld\n",
Value );
break;
case CIF_ERROR_EXPECTED_EOF :
(void)fprintf( stderr,
"cif109: End of file expected, line %ld\n",
Value );
break;
case CIF_ERROR_UNEXPECTED_EOF :
(void)fprintf( stderr,
"cif109: Unexpected end of file, line %ld\n",
Value );
break;
case CIF_ERROR_UNSIGNED_OVERFLOW :
(void)fprintf( stderr,
"cif109: Unsigned integer overflow, line %ld\n",
Value );
break;
case CIF_ERROR_SIGNED_OVERFLOW :
(void)fprintf( stderr,
"cif109: Signed integer overflow, line %ld\n",
Value );
break;
case CIF_ERROR_LAYER_UNKNOWN :
(void)fprintf( stderr,
"cif109: Layer unknown, line %ld\n",
Value );
break;
case CIF_ERROR_POLYGON_EMPTY :
(void)fprintf( stderr,
"cif109: Polygon empty, line %ld\n",
Value );
break;
case CIF_ERROR_POLYGON_OVERFLOW :
(void)fprintf( stderr,
"cif109: Polygon overflow, line %ld\n",
Value );
break;
case CIF_ERROR_POLYGON_NOT_REC :
(void)fprintf( stderr,
"cif109: Polygon not rectangular, line %ld\n",
Value );
break;
case CIF_ERROR_SYMBOL_STARTED :
(void)fprintf( stderr,
"cif109: Symbol has already started, line %ld\n",
Value );
break;
case CIF_ERROR_SYMBOL_NOT_STARTED :
(void)fprintf( stderr,
"cif109: Symbol hasn't started, line %ld\n",
Value );
break;
case CIF_ERROR_BAD_DEFINE :
(void)fprintf( stderr,
"cif109: Bad define, line %ld\n",
Value );
break;
case CIF_ERROR_BAD_COMMAND :
(void)fprintf( stderr,
"cif109: Bad command, line %ld\n",
Value );
break;
case CIF_ERROR_BAD_COMMENT :
(void)fprintf( stderr,
"cif109: Bad comment, line %ld\n",
Value );
break;
case CIF_ERROR_BAD_CONNECTOR :
(void)fprintf( stderr,
"cif109: Bad connector specification, line %ld\n",
Value );
break;
case CIF_ERROR_BAD_SYMBOL :
(void)fprintf( stderr,
"cif109: Bad symbol specification, line %ld\n",
Value );
break;
case CIF_ERROR_SYMBOL_NOT_DEFINE :
(void)fprintf( stderr,
"cif109: Symbol number %ld not define\n",
Value );
break;
case CIF_ERROR_BAD_MIRROR :
(void)fprintf( stderr,
"cif109: Bad mirror specification, line %ld\n",
Value );
break;
case CIF_ERROR_NO_TOP_MODEL :
(void)fprintf( stderr,
"cif109: there is no top model !\n"
);
break;
}
EXIT( 1 );
}
/*------------------------------------------------------------\
| |
| cifwarning |
| |
\------------------------------------------------------------*/
void cifwarning( Warning, Text, Value )
char Warning;
char *Text;
long Value;
{
switch( Warning )
{
case CIF_WARNING_PHYSICAL_GRID :
(void)fprintf( stderr,
"cif109: Rectangle not aligned on the physical grid !\n"
);
break;
case CIF_WARNING_UNCONNECTED_NODE :
(void)fprintf( stderr,
"cif109: Node %s is not connected, in model %s !\n",
Text, (char *)Value
);
break;
case CIF_WARNING_ROUND_FLASH :
(void)fprintf( stderr,
"cif109: Command round flash ignored, line %ld !\n",
Value
);
break;
case CIF_WARNING_USER_COMMAND :
(void)fprintf( stderr,
"cif109: User command ignored, line %ld !\n",
Value
);
break;
}
}

90
alliance/src/rdscif/src/cif_error.h Normal file
View File

@ -0,0 +1,90 @@
#ifndef __P
# if defined(__STDC__) || defined(__GNUC__)
# define __P(x) x
# else
# define __P(x) ()
# endif
#endif
/*------------------------------------------------------------\
| |
| Tool : RDSCIF |
| |
| File : cif_error.h |
| |
| Authors : Petrot Frederic & Jacomme Ludovic |
| --------- |
| Date : The king ^ 04/07/93 |
| |
\------------------------------------------------------------*/
# ifndef RDSCIF_ERROR
# define RDSCIF_ERROR
/*------------------------------------------------------------\
| |
| Constants |
| |
\------------------------------------------------------------*/
# define CIF_ERROR_BAD_TRANS 0
# define CIF_ERROR_CONNECTOR_NAME 1
# define CIF_ERROR_FILE_OPEN 2
# define CIF_ERROR_FILE_CLOSE 3
# define CIF_ERROR_MODEL 4
# define CIF_ERROR_EXPECTED_SEMI 5
# define CIF_ERROR_EXPECTED_SPACE 6
# define CIF_ERROR_EXPECTED_NAME 7
# define CIF_ERROR_EXPECTED_SIGNED 8
# define CIF_ERROR_EXPECTED_UNSIGNED 9
# define CIF_ERROR_EXPECTED_LAYER 10
# define CIF_ERROR_EXPECTED_MANHATTAN 11
# define CIF_ERROR_EXPECTED_EOF 12
# define CIF_ERROR_UNEXPECTED_EOF 13
# define CIF_ERROR_SIGNED_OVERFLOW 14
# define CIF_ERROR_UNSIGNED_OVERFLOW 15
# define CIF_ERROR_LAYER_UNKNOWN 16
# define CIF_ERROR_POLYGON_EMPTY 17
# define CIF_ERROR_POLYGON_OVERFLOW 18
# define CIF_ERROR_POLYGON_NOT_REC 19
# define CIF_ERROR_SYMBOL_STARTED 20
# define CIF_ERROR_SYMBOL_NOT_STARTED 21
# define CIF_ERROR_BAD_DEFINE 22
# define CIF_ERROR_BAD_COMMAND 23
# define CIF_ERROR_BAD_COMMENT 24
# define CIF_ERROR_BAD_CONNECTOR 25
# define CIF_ERROR_BAD_SYMBOL 26
# define CIF_ERROR_SYMBOL_NOT_DEFINE 27
# define CIF_ERROR_BAD_MIRROR 28
# define CIF_ERROR_NO_TOP_MODEL 29
# define CIF_WARNING_PHYSICAL_GRID 0
# define CIF_WARNING_UNCONNECTED_NODE 1
# define CIF_WARNING_ROUND_FLASH 2
# define CIF_WARNING_USER_COMMAND 3
/*------------------------------------------------------------\
| |
| Macro |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Types |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Variables |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Functions |
| |
\------------------------------------------------------------*/
extern void ciferror __P((char Error, char *Text, long Value));
extern void cifwarning __P((char Warning, char *Text, long Value));
# endif

1793
alliance/src/rdscif/src/cif_parse.c Normal file
View File

File diff suppressed because it is too large Load Diff

110
alliance/src/rdscif/src/cif_parse.h Normal file
View File

@ -0,0 +1,110 @@
#ifndef __P
# if defined(__STDC__) || defined(__GNUC__)
# define __P(x) x
# else
# define __P(x) ()
# endif
#endif
/*------------------------------------------------------------\
| |
| Tool : RDSCIF |
| |
| File : cif_parse.h |
| |
| Authors : Jacomme Ludovic |
| |
| Date : 23/08/93 |
| |
\------------------------------------------------------------*/
# ifndef RDSCIF_PARSE
# define RDSCIF_PARSE
/*------------------------------------------------------------\
| |
| Constants |
| |
\------------------------------------------------------------*/
# define CIF_MAX_BUFFER 512
# define CIF_MAX_SYMBOL_HEAD 16
# define CIF_MASK_SYMBOL (long)(0x0000F)
/*------------------------------------------------------------\
| |
| Commands |
| |
\------------------------------------------------------------*/
# define CIF_COMMAND_NULL 0
# define CIF_COMMAND_POLYGON 1
# define CIF_COMMAND_BOX 2
# define CIF_COMMAND_ROUNDFLASH 3
# define CIF_COMMAND_WIRE 4
# define CIF_COMMAND_LAYER 5
# define CIF_COMMAND_DEFSTART 6
# define CIF_COMMAND_DEFFINISH 7
# define CIF_COMMAND_DEFDELETE 8
# define CIF_COMMAND_CALL 9
# define CIF_COMMAND_COMMENT 10
# define CIF_COMMAND_END 11
# define CIF_COMMAND_EOF 12
/*------------------------------------------------------------\
| |
| Overflow |
| |
\------------------------------------------------------------*/
# define CIF_MAX_UNSIGNED ((unsigned int)((0XFFFFFFFF-9)/10))
# define CIF_MAX_SIGNED ((int )((0X7FFFFFFF-9)/10))
# define CIF_MAX_POINT 512
/*------------------------------------------------------------\
| |
| Macros |
| |
\------------------------------------------------------------*/
#define CIF_TO_RDS_UNIT( X ) \
\
( ( ( X )*CifScaleA*RDS_UNIT ) / ( CifScaleB*CIF_UNIT ) )
/*------------------------------------------------------------\
| |
| Types |
| |
\------------------------------------------------------------*/
typedef struct symbol_list
{
struct symbol_list *NEXT;
long NUMBER;
rdsfig_list *MODEL;
} symbol_list;
typedef struct node_list
{
struct node_list *NEXT;
char *NAME;
char LAYER;
long X;
long Y;
} node_list;
typedef struct connector_list
{
struct connector_list *NEXT;
char *NAME;
char LAYER;
long X;
long Y;
long WIDTH;
} connector_list;
# endif

48
alliance/src/rdscif/src/rcf.h Normal file
View File

@ -0,0 +1,48 @@
/*------------------------------------------------------------\
| |
| Tool : RCF |
| |
| File : rcf112.h |
| |
| Authors : Jacomme Ludovic |
| |
| Date : 27.06.95 |
| |
\------------------------------------------------------------*/
# ifndef RCF_112_H
# define RCF_112_H
#ifndef __P
# if defined(__STDC__) || defined(__GNUC__)
# define __P(x) x
# else
# define __P(x) ()
# endif
#endif
/*------------------------------------------------------------\
| |
| Constants |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Types |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Global Variables |
| |
\------------------------------------------------------------*/
/*------------------------------------------------------------\
| |
| Functions |
| |
\------------------------------------------------------------*/
extern rdsfig_list * cifloadrdsfig __P((rdsfig_list *Figure, char *Name, char Mode));
extern void cifsaverdsfig __P((rdsfig_list *Figure));
# endif