/*------------------------------------------------------------\ | | | This file is part of the Alliance CAD System Copyright | | (C) Laboratoire LIP6 - Département ASIM Universite P&M Curie| | | | Home page : http://www-asim.lip6.fr/alliance/ | | E-mail : mailto:alliance-users@asim.lip6.fr | | | | This progam is free software; you can redistribute it | | and/or modify it under the terms of the GNU Library General| | Public License as published by the Free Software Foundation | | either version 2 of the License, or (at your option) any | | later version. | | | | Alliance VLSI CAD System is distributed in the hope that | | it will be useful, but WITHOUT ANY WARRANTY; | | without even the implied warranty of MERCHANTABILITY or | | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General | | Public License for more details. | | | | You should have received a copy of the GNU General Public | | License along with the GNU C Library; see the file COPYING. | | If not, write to the Free Software Foundation, Inc., | | 675 Mass Ave, Cambridge, MA 02139, USA. | | | \------------------------------------------------------------*/ /*------------------------------------------------------\ | | | Title : Structures and fonctions for VEX | | | | Date : 04.02.97 | | | | Author : Jacomme Ludovic | | | \------------------------------------------------------*/ # ifndef VEX_103_H # define VEX_103_H /*------------------------------------------------------\ | | | Constants | | | \------------------------------------------------------*/ # ifndef __P # if defined(__STDC__) || defined(__GNUC__) # define __P(x) x # else # define __P(x) () # endif # endif /*------------------------------------------------------\ | | | View Mode | | | \------------------------------------------------------*/ # define VEX_VIEW_VHDL 0 # define VEX_VIEW_VERILOG 1 /*------------------------------------------------------\ | | | Node Type | | | \------------------------------------------------------*/ # define VEX_NODE_ATOM_MASK (unsigned short)(0x1000) # define VEX_NODE_OPER_MASK (unsigned short)(0x2000) # define VEX_NODE_FUNC_MASK (unsigned short)(0x4000) # define VEX_NODE_TYPE_MASK (unsigned short)(0x7000) # define VEX_NODE_TAG_MASK (unsigned short)(0x8000) # define VEX_ATOM_LITERAL_MASK (unsigned short)(0x0100) /*Literal Name */ # define VEX_NODE_SIGNED_MASK (unsigned short)(0x0200) /*Signed Unsigned */ # define VEX_NODE_BIT_MASK (unsigned short)(0x0400) /*Bit Vector */ # define VEX_NODE_DOWN_MASK (unsigned short)(0x0800) /*Down Up */ # define VEX_NODE_VAR_WIDTH_MASK (unsigned short)(0x0080) /*Variable Width */ # define VEX_NODE_USER1_MASK (unsigned short)(0x0020) # define VEX_NODE_USER2_MASK (unsigned short)(0x0040) # define VEX_NODE_VHDL_TYPE_MASK (unsigned short)(0x001f) /*------------------------------------------------------\ | | | Macro Node Type | | | \------------------------------------------------------*/ # define IsVexNodeAtom( N ) ( (N)->TYPE & VEX_NODE_ATOM_MASK ) # define SetVexNodeAtom( N ) ( (N)->TYPE = ((N)->TYPE & ~VEX_NODE_TYPE_MASK )\ | VEX_NODE_ATOM_MASK ) # define IsVexNodeOper( N ) ( (N)->TYPE & VEX_NODE_OPER_MASK ) # define SetVexNodeOper( N ) ( (N)->TYPE = ((N)->TYPE & ~VEX_NODE_TYPE_MASK )\ | VEX_NODE_OPER_MASK ) # define IsVexNodeFunc( N ) ( (N)->TYPE & VEX_NODE_FUNC_MASK ) # define SetVexNodeFunc( N ) ( (N)->TYPE = ((N)->TYPE & ~VEX_NODE_TYPE_MASK )\ | VEX_NODE_FUNC_MASK ) /*------------------------------------------------------\ | | | Macro Node Width | | | \------------------------------------------------------*/ # define IsVexNodeVarWidth( N ) ( (N)->TYPE & VEX_NODE_VAR_WIDTH_MASK ) # define SetVexNodeVarWidth( N ) ( (N)->TYPE |= VEX_NODE_VAR_WIDTH_MASK ) # define ClearVexNodeVarWidth( N ) ( (N)->TYPE &= ~VEX_NODE_VAR_WIDTH_MASK ) /*------------------------------------------------------\ | | | Macro Node Signed | | | \------------------------------------------------------*/ # define IsVexNodeSigned( N ) ( (N)->TYPE & VEX_NODE_SIGNED_MASK ) # define SetVexNodeSigned( N ) ( (N)->TYPE |= VEX_NODE_SIGNED_MASK ) # define ClearVexNodeSigned( N ) ( (N)->TYPE &= ~VEX_NODE_SIGNED_MASK ) /*------------------------------------------------------\ | | | Macro Node Bit | | | \------------------------------------------------------*/ # define IsVexNodeBit( N ) ( (N)->TYPE & VEX_NODE_BIT_MASK ) # define SetVexNodeBit( N ) ( (N)->TYPE |= VEX_NODE_BIT_MASK ) # define ClearVexNodeBit( N ) ( (N)->TYPE &= ~VEX_NODE_BIT_MASK ) /*------------------------------------------------------\ | | | Macro Node Direction | | | \------------------------------------------------------*/ # define IsVexNodeDown( N ) ( (N)->TYPE & VEX_NODE_DOWN_MASK ) # define SetVexNodeDown( N ) ( (N)->TYPE |= VEX_NODE_DOWN_MASK ) # define ClearVexNodeDown( N ) ( (N)->TYPE &= ~VEX_NODE_DOWN_MASK ) /*------------------------------------------------------\ | | | Macro Node Tag | | | \------------------------------------------------------*/ # define IsVexNodeTag( N ) ( (N)->TYPE & VEX_NODE_TAG_MASK ) # define SetVexNodeTag( N ) ( (N)->TYPE |= VEX_NODE_TAG_MASK ) # define ClearVexNodeTag( N ) ( (N)->TYPE &= ~VEX_NODE_TAG_MASK ) /*------------------------------------------------------\ | | | Macro Atom | | | \------------------------------------------------------*/ # define IsVexAtomLiteral( N ) ( (N)->TYPE & VEX_ATOM_LITERAL_MASK ) # define SetVexAtomLiteral( N ) ( (N)->TYPE |= VEX_ATOM_LITERAL_MASK ) # define ClearVexAtomLiteral( N ) ( (N)->TYPE &= ~VEX_ATOM_LITERAL_MASK ) # define IsVexAtomVarWidth( N ) ( IsVexNodeVarWidth( N ) ) # define SetVexAtomVarWidth( N ) ( SetVexNodeVarWidth( N ) ) # define IsVexAtomStaWidth( N ) ( ! IsVexNodeVarWidth( N ) ) # define SetVexAtomStaWidth( N ) ( ClearVexNodeVarWidth( N ) ) # define IsVexAtomBit( N ) ( IsVexNodeBit( N ) ) # define SetVexAtomBit( N ) ( SetVexNodeBit( N ) ) # define IsVexAtomVector( N ) ( ! IsVexNodeBit( N ) ) # define SetVexAtomVector( N ) ( ClearVexNodeBit( N ) ) # define IsVexAtomSigned( N ) ( IsVexNodeSigned( N ) ) # define SetVexAtomSigned( N ) ( SetVexNodeSigned( N ) ) # define IsVexAtomUnsigned( N ) ( ! IsVexNodeSigned( N ) ) # define SetVexAtomUnsigned( N ) ( ClearVexNodeSigned( N ) ) # define IsVexAtomDown( N ) ( IsVexNodeDown( N ) ) # define SetVexAtomDown( N ) ( SetVexNodeDown( N ) ) # define IsVexAtomUp( N ) ( ! IsVexNodeDown( N ) ) # define SetVexAtomUp( N ) ( ClearVexNodeDown( N ) ) /*------------------------------------------------------\ | | | Macro Oper | | | \------------------------------------------------------*/ # define IsVexOperVarWidth( N ) ( IsVexNodeVarWidth( N ) ) # define SetVexOperVarWidth( N ) ( SetVexNodeVarWidth( N ) ) # define IsVexOperStaWidth( N ) ( ! IsVexNodeVarWidth( N ) ) # define SetVexOperStaWidth( N ) ( ClearVexNodeVarWidth( N ) ) # define IsVexOperBit( N ) ( IsVexNodeBit( N ) ) # define SetVexOperBit( N ) ( SetVexNodeBit( N ) ) # define IsVexOperVector( N ) ( ! IsVexNodeBit( N ) ) # define SetVexOperVector( N ) ( ClearVexNodeBit( N ) ) # define IsVexOperSigned( N ) ( IsVexNodeSigned( N ) ) # define SetVexOperSigned( N ) ( SetVexNodeSigned( N ) ) # define IsVexOperUnsigned( N ) ( ! IsVexNodeSigned( N ) ) # define SetVexOperUnsigned( N ) ( ClearVexNodeSigned( N ) ) # define IsVexOperDown( N ) ( IsVexNodeDown( N ) ) # define SetVexOperDown( N ) ( SetVexNodeDown( N ) ) # define IsVexOperUp( N ) ( ! IsVexNodeDown( N ) ) # define SetVexOperUp( N ) ( ClearVexNodeDown( N ) ) /*------------------------------------------------------\ | | | Macro Func | | | \------------------------------------------------------*/ # define IsVexFuncVarWidth( N ) ( IsVexNodeVarWidth( N ) ) # define SetVexFuncVarWidth( N ) ( SetVexNodeVarWidth( N ) ) # define IsVexFuncStaWidth( N ) ( ! IsVexNodeVarWidth( N ) ) # define SetVexFuncStaWidth( N ) ( ClearVexNodeVarWidth( N ) ) # define IsVexFuncBit( N ) ( IsVexNodeBit( N ) ) # define SetVexFuncBit( N ) ( SetVexNodeBit( N ) ) # define IsVexFuncVector( N ) ( ! IsVexNodeBit( N ) ) # define SetVexFuncVector( N ) ( ClearVexNodeBit( N ) ) # define IsVexFuncSigned( N ) ( IsVexNodeSigned( N ) ) # define SetVexFuncSigned( N ) ( SetVexNodeSigned( N ) ) # define IsVexFuncUnsigned( N ) ( ! IsVexNodeSigned( N ) ) # define SetVexFuncUnsigned( N ) ( ClearVexNodeSigned( N ) ) # define IsVexFuncDown( N ) ( IsVexNodeDown( N ) ) # define SetVexFuncDown( N ) ( SetVexNodeDown( N ) ) # define IsVexFuncUp( N ) ( ! IsVexNodeDown( N ) ) # define SetVexFuncUp( N ) ( ClearVexNodeDown( N ) ) /*------------------------------------------------------\ | | | Macro Type | | | \------------------------------------------------------*/ # define SetVexVhdlType( N, T ) ((N)->TYPE = ((N)->TYPE & ~VEX_NODE_VHDL_TYPE_MASK)|(T)) # define GetVexVhdlType( N ) ((N)->TYPE & VEX_NODE_VHDL_TYPE_MASK) /*------------------------------------------------------\ | | | Operators | | | \------------------------------------------------------*/ # define VEX_CONCAT 0 # define VEX_NOT 1 # define VEX_NEG 2 # define VEX_EVENT 3 # define VEX_OR 4 # define VEX_AND 5 # define VEX_XOR 6 # define VEX_NOR 7 # define VEX_NAND 8 # define VEX_NXOR 9 # define VEX_EQ 10 # define VEX_NE 11 # define VEX_LT 12 # define VEX_LE 13 # define VEX_GT 14 # define VEX_GE 15 # define VEX_ADD 16 # define VEX_SUB 17 # define VEX_MUL 18 # define VEX_DIV 19 # define VEX_EXP 20 # define VEX_MOD 21 # define VEX_REM 22 # define VEX_TO 23 # define VEX_DOWNTO 24 # define VEX_INDEX 25 # define VEX_LEFT 26 # define VEX_RIGHT 27 # define VEX_LOW 28 # define VEX_HIGH 29 # define VEX_LENGTH 30 # define VEX_RANGE 31 # define VEX_REV_RANGE 32 # define VEX_DRIVER 33 # define VEX_IFT 34 # define VEX_ARRAY 35 # define VEX_INDEX_N 36 # define VEX_OTHERS 37 # define VEX_NUM_BIT 38 # define VEX_ABS 39 # define VEX_AF 40 # define VEX_AG 41 # define VEX_AX 42 # define VEX_AU 43 # define VEX_EF 44 # define VEX_EG 45 # define VEX_EX 46 # define VEX_EU 47 # define VEX_EQUIV 48 # define VEX_IMPLY 49 # define VEX_MAX_OPERATOR 50 /*------------------------------------------------------\ | | | Vhdl Type | | | \------------------------------------------------------*/ # define VEX_TYPE_SEVERITY 0 # define VEX_TYPE_BOOLEAN 1 # define VEX_TYPE_CHARACTER 2 # define VEX_TYPE_STRING 3 # define VEX_TYPE_BIT 4 # define VEX_TYPE_INTEGER 5 # define VEX_TYPE_NATURAL 6 # define VEX_TYPE_BIT_VECTOR 7 # define VEX_TYPE_STD_ULOGIC 8 # define VEX_TYPE_STD_LOGIC 9 # define VEX_TYPE_STD_ULOGIC_VECTOR 10 # define VEX_TYPE_STD_LOGIC_VECTOR 11 # define VEX_TYPE_X01 12 # define VEX_TYPE_X01Z 13 # define VEX_TYPE_UX01 14 # define VEX_TYPE_UX01Z 15 # define VEX_TYPE_UNSIGNED 16 # define VEX_TYPE_SIGNED 17 # define VEX_TYPE_SMALL_INT 18 # define VEX_TYPE_REG_BIT 19 # define VEX_TYPE_REG_VECTOR 20 # define VEX_TYPE_MUX_BIT 21 # define VEX_TYPE_MUX_VECTOR 22 # define VEX_TYPE_WOR_BIT 23 # define VEX_TYPE_WOR_VECTOR 24 # define VEX_TYPE_ENUMERATE 25 # define VEX_TYPE_ARRAY 26 # define VEX_MAX_TYPE 27 /*------------------------------------------------------\ | | | Std Function | | | \------------------------------------------------------*/ # define VEX_STD_TO_BIT 0 # define VEX_STD_TO_BITVECTOR 1 # define VEX_STD_TO_STDULOGIC 2 # define VEX_STD_TO_STDLOGICVECTOR 3 # define VEX_STD_TO_STDULOGICVECTOR 4 # define VEX_STD_TO_X01 5 # define VEX_STD_TO_X01Z 6 # define VEX_STD_TO_UX01 7 # define VEX_STD_RISING_EDGE 8 # define VEX_STD_FALLING_EDGE 9 # define VEX_STD_IS_X 10 # define VEX_STD_ABS 11 # define VEX_STD_SHL 12 # define VEX_STD_SHR 13 # define VEX_STD_CONV_INTEGER 14 # define VEX_STD_CONV_UNSIGNED 15 # define VEX_STD_CONV_SIGNED 16 # define VEX_STD_CONV_STD_LOGIC_VECTOR 17 # define VEX_STD_EXT 18 # define VEX_STD_SXT 19 # define VEX_STD_SHIFT_LEFT 20 # define VEX_STD_SHIFT_RIGHT 21 # define VEX_STD_ROTATE_LEFT 22 # define VEX_STD_ROTATE_RIGHT 23 # define VEX_STD_RESIZE 24 # define VEX_STD_TO_INTEGER 25 # define VEX_STD_TO_UNSIGNED 26 # define VEX_STD_TO_SIGNED 27 # define VEX_STD_STD_LOGIC_VECTOR 28 # define VEX_STD_STD_ULOGIC_VECTOR 29 # define VEX_STD_SIGNED 30 # define VEX_STD_UNSIGNED 31 # define VEX_MAX_STD_FUNC 32 /*------------------------------------------------------\ | | | Literals 9 | | | \------------------------------------------------------*/ # define VEX_UNINIT_ID 0 /* Uninitialized */ # define VEX_UNKNOWN_ID 1 /* Forcing Unknown */ # define VEX_ZERO_ID 2 /* Forcing 0 */ # define VEX_ONE_ID 3 /* Forcing 1 */ # define VEX_TRISTATE_ID 4 /* High Impedance */ # define VEX_WEAK_UNKNOWN_ID 5 /* Weak Unknown */ # define VEX_WEAK_ZERO_ID 6 /* Weak 0 */ # define VEX_WEAK_ONE_ID 7 /* Weak 1 */ # define VEX_DC_ID 8 /* Don't care */ # define VEX_MAX_ID 9 /*------------------------------------------------------\ | | | Macro Literals 9 | | | \------------------------------------------------------*/ # define VEX_UNINIT VEX_LITERAL_BY_ID[ VEX_UNINIT_ID ] # define VEX_UNKNOWN VEX_LITERAL_BY_ID[ VEX_UNKNOWN_ID ] # define VEX_ZERO VEX_LITERAL_BY_ID[ VEX_ZERO_ID ] # define VEX_ONE VEX_LITERAL_BY_ID[ VEX_ONE_ID ] # define VEX_TRISTATE VEX_LITERAL_BY_ID[ VEX_TRISTATE_ID ] # define VEX_WEAK_UNKNOWN VEX_LITERAL_BY_ID[ VEX_WEAK_UNKNOWN_ID ] # define VEX_WEAK_ZERO VEX_LITERAL_BY_ID[ VEX_WEAK_ZERO_ID ] # define VEX_WEAK_ONE VEX_LITERAL_BY_ID[ VEX_WEAK_ONE_ID ] # define VEX_DC VEX_LITERAL_BY_ID[ VEX_DC_ID ] /*------------------------------------------------------\ | | | Macro Atom Literals 9 | | | \------------------------------------------------------*/ # define VEX_ATOM_UNINIT VEX_ATOM_BY_ID[ VEX_UNINIT_ID ] # define VEX_ATOM_UNKNOWN VEX_ATOM_BY_ID[ VEX_UNKNOWN_ID ] # define VEX_ATOM_ZERO VEX_ATOM_BY_ID[ VEX_ZERO_ID ] # define VEX_ATOM_ONE VEX_ATOM_BY_ID[ VEX_ONE_ID ] # define VEX_ATOM_TRISTATE VEX_ATOM_BY_ID[ VEX_TRISTATE_ID ] # define VEX_ATOM_WEAK_UNKNOWN VEX_ATOM_BY_ID[ VEX_WEAK_UNKNOWN_ID ] # define VEX_ATOM_WEAK_ZERO VEX_ATOM_BY_ID[ VEX_WEAK_ZERO_ID ] # define VEX_ATOM_WEAK_ONE VEX_ATOM_BY_ID[ VEX_WEAK_ONE_ID ] # define VEX_ATOM_DC VEX_ATOM_BY_ID[ VEX_DC_ID ] /*------------------------------------------------------\ | | | Macro Oper Types | | | \------------------------------------------------------*/ # define GetVexFuncValue( N ) ( (char *)(N)->VALUE ) # define SetVexFuncValue( N, F ) ( (N)->VALUE = (void *)(F) ) # define GetVexOperValue( N ) ( (long )(N)->VALUE ) # define SetVexOperValue( N, O ) ( (N)->VALUE = (void *)(O) ) # define GetVexAtomValue( N ) ( (char *)(N)->VALUE ) # define SetVexAtomValue( N, A ) ( (N)->VALUE = (void *)(A) ) # define GetVexOperand( C ) ( (vexexpr *)(C)->DATA ) # define GetVexOperandL( C ) ( (C)->DATA ) # define SetVexOperand( C, O ) ( (C)->DATA = (void *)(O) ) /*------------------------------------------------------\ | | | Type | | | \------------------------------------------------------*/ typedef struct vexexpr { chain_list *OPERAND; void *VALUE; short TYPE; short LEFT; short RIGHT; short WIDTH; } vexexpr; /*------------------------------------------------------\ | | | Global Variable | | | \------------------------------------------------------*/ extern char *VEX_OPER_NAME[ VEX_MAX_OPERATOR ]; extern char *VEX_OPER_UPPER_NAME[ VEX_MAX_OPERATOR ]; extern char *VEX_OPER_VERILOG_NAME[ VEX_MAX_OPERATOR ]; extern char *VEX_TYPE_NAME[ VEX_MAX_TYPE ]; extern long VEX_OPER_NOT[ VEX_MAX_OPERATOR ]; extern char VEX_LITERAL_BY_ID[ VEX_MAX_ID ]; extern char *VEX_ATOM_BY_ID[ VEX_MAX_ID ]; extern char *VEX_STD_FUNC_NAME[ VEX_MAX_STD_FUNC ]; extern char *VEX_STD_FUNC_UPPER_NAME[ VEX_MAX_STD_FUNC ]; /*------------------------------------------------------\ | | | Functions | | | \------------------------------------------------------*/ /*------------------------------------------------------\ | | | Initialize Functions | | | \------------------------------------------------------*/ extern void vexenv __P(()); /*------------------------------------------------------\ | | | Node Functions | | | \------------------------------------------------------*/ extern vexexpr *allocvexnode __P(()); extern vexexpr *dupvexnode __P((vexexpr *Node)); extern vexexpr *copyvexnode __P((vexexpr *Target, vexexpr *Source)); extern void freevexnode __P((vexexpr *Node)); /*------------------------------------------------------\ | | | Create Functions | | | \------------------------------------------------------*/ extern vexexpr *createvexatombit __P((char *Name)); extern vexexpr *createvexatomvec __P((char *Name, short Left, short Right)); extern vexexpr *createvexatomlit __P((char *Name)); extern vexexpr *createvexatomveclit __P((unsigned char Literal, short Width)); extern vexexpr *createvexatomlong __P((long Integer, short Width, short Signed)); extern vexexpr *createvexatomlongarray __P((long *Array, short Size, short Width, short Signed)); extern vexexpr *createvexoper __P((long Oper, short Width)); extern vexexpr *createvexbinexpr __P((long Oper, short Width, vexexpr *Expr1, vexexpr *Expr2)); extern vexexpr *createvexternaryexpr __P((long Oper, short Width, \ vexexpr *Expr1, vexexpr *Expr2, vexexpr *Expr3)); extern vexexpr *createvexunaryexpr __P((long Oper, short Width, vexexpr *Expr)); extern vexexpr *createvexfunc __P((char *Func, short Width)); /*------------------------------------------------------\ | | | Simplify Functions | | | \------------------------------------------------------*/ extern vexexpr *simpvexexpr __P((vexexpr *Expr)); extern vexexpr *simpvexexpreq __P((vexexpr *Expr)); extern vexexpr *simpvexexprothers __P((vexexpr *Expr, short Width )); /*------------------------------------------------------\ | | | Optimize Functions | | | \------------------------------------------------------*/ extern vexexpr *optimvexnotexpr __P((vexexpr *Expr)); extern vexexpr *optimvexbinexpr __P((long Oper, short Width, vexexpr *Expr1, vexexpr *Expr2)); /*------------------------------------------------------\ | | | Add Functions | | | \------------------------------------------------------*/ extern void addvexqexpr __P((vexexpr *Expr1, vexexpr *Expr2)); extern void addvexhexpr __P((vexexpr *Expr1, vexexpr *Expr2)); /*------------------------------------------------------\ | | | Duplicate Functions | | | \------------------------------------------------------*/ extern vexexpr *dupvexexpr __P((vexexpr *Expr)); /*------------------------------------------------------\ | | | Del Functions | | | \------------------------------------------------------*/ extern void delvexexpr __P((vexexpr *Expr)); extern void delvexexprnum __P((vexexpr *Expr, int Number)); /*------------------------------------------------------\ | | | Free Functions | | | \------------------------------------------------------*/ extern void freevexexpr __P((vexexpr *Expr)); /*------------------------------------------------------\ | | | Is Functions | | | \------------------------------------------------------*/ extern int isvexunaryoper __P((long Oper)); extern int isvexbinaryoper __P((long Oper)); extern int isvexternaryoper __P((long Oper)); extern int isvexoperinexpr __P((vexexpr *Expr, long Oper)); extern int isvexarithoperinexpr __P((vexexpr *Expr)); extern int isvexnameinexpr __P((vexexpr *Expr, char *Name)); extern int isvexpositiveoper __P((long Oper)); extern int isvexnegativeoper __P((long Oper)); extern int isvexequalexpr __P((vexexpr *Expr1, vexexpr *Expr2)); extern int isvextypedivisible __P((int Type)); extern int isvextypevector __P((int Type)); /*------------------------------------------------------\ | | | Get Functions | | | \------------------------------------------------------*/ extern char *getvexvectorname __P((char *Vector, long *Index)); extern char *getvexopername __P((long Oper)); extern char *getvexatomname __P((vexexpr *Expr)); extern char *getvexoperuppername __P((long Oper)); extern char *getvexoperverilogname __P((long Oper)); extern long getvexoperbyname __P((char *Name)); extern long getvexnotoper __P((long Oper)); extern char *getvexarrayname __P((vexexpr *Atom)); extern vexexpr *getvexarrayatom __P((vexexpr *Expr)); extern chain_list *getvexatombitname __P((vexexpr *Expr)); extern chain_list *getvexexprsupport __P((vexexpr *Expr)); extern chain_list *unionvexexprsupport __P((chain_list *Support, vexexpr *Expr)); extern ptype_list *getvexatombitnameptype __P((vexexpr *Expr)); extern ptype_list *getvexexprsupportptype __P((vexexpr *Expr)); extern ptype_list *unionvexexprsupportptype __P((ptype_list *Support, vexexpr *Expr)); extern chain_list *getvexexprallname __P((vexexpr *Expr)); extern chain_list *unionvexexprallname __P((chain_list *AllName, vexexpr *Expr)); extern int getvextypescalar __P((int Type)); extern long getvexexprdepth __P((vexexpr *Expr)); extern long getvexexprnumnode __P((vexexpr *Expr)); extern int getvexliteralid __P((char Literal)); extern int getvexstdfuncid __P((char *FuncName)); extern int getvexvectorpos __P((vexexpr *Vector, short Index)); extern int getvexvectorindex __P((vexexpr *Atom, short Position)); extern int getvexvectormin __P((vexexpr *Expr)); extern int getvexvectormax __P((vexexpr *Expr)); extern int getvexintnumbit __P((long Size)); extern int getvexintervalnumbit __P((long Left, long Right)); /*------------------------------------------------------\ | | | Eval Functions | | | \------------------------------------------------------*/ extern int evalvexatomlong __P((vexexpr *Expr, long *PLong)); extern int evalvexnotliteral __P((char Literal, char *PChar)); extern int evalvexandliteral __P((char Literal1, char Literal2, char *PChar)); extern int evalvexorliteral __P((char Literal1, char Literal2, char *PChar)); extern int evalvexxorliteral __P((char Literal1, char Literal2, char *PChar)); /*------------------------------------------------------\ | | | Extend Sign Functions | | | \------------------------------------------------------*/ extern vexexpr *extendvexatomsign __P((vexexpr *Expr, short Width)); /*------------------------------------------------------\ | | | Shift Functions | | | \------------------------------------------------------*/ extern vexexpr *shiftvexatomleft __P((vexexpr *Expr, short Count )); extern vexexpr *shiftvexatomright __P((vexexpr *Expr, short Count )); /*------------------------------------------------------\ | | | Slice Functions | | | \------------------------------------------------------*/ extern vexexpr *slicevexatomvec __P((vexexpr *Expr, short Left, short Right)); /*------------------------------------------------------\ | | | Unflat Functions | | | \------------------------------------------------------*/ extern vexexpr *unflatvexexpr __P((vexexpr *Expr)); /*------------------------------------------------------\ | | | View Functions | | | \------------------------------------------------------*/ extern void viewvexexprfile __P((FILE *VexFile, vexexpr *Expr)); extern void viewvexexpr __P((vexexpr *Expr)); extern void viewvexexprln __P((vexexpr *Expr)); extern void viewvexexprbound __P((vexexpr *Expr)); extern void viewvexexprboundln __P((vexexpr *Expr)); extern char *viewvexexprstr __P((vexexpr *Expr)); extern char *viewvexexprstrbound __P((vexexpr *Expr)); extern int getvexviewmode __P(()); extern void setvexviewmode __P((int Mode)); # endif