2002-11-01 21:27:31 +00:00
|
|
|
/*****************************************************************************/
|
|
|
|
/* */
|
|
|
|
/* exprdesc.h */
|
|
|
|
/* */
|
|
|
|
/* Expression descriptor structure */
|
|
|
|
/* */
|
|
|
|
/* */
|
|
|
|
/* */
|
2010-03-20 18:51:59 +00:00
|
|
|
/* (C) 2002-2010, Ullrich von Bassewitz */
|
2009-08-29 21:20:13 +00:00
|
|
|
/* Roemerstrasse 52 */
|
|
|
|
/* D-70794 Filderstadt */
|
|
|
|
/* EMail: uz@cc65.org */
|
2002-11-01 21:27:31 +00:00
|
|
|
/* */
|
|
|
|
/* */
|
|
|
|
/* This software is provided 'as-is', without any expressed or implied */
|
|
|
|
/* warranty. In no event will the authors be held liable for any damages */
|
|
|
|
/* arising from the use of this software. */
|
|
|
|
/* */
|
|
|
|
/* Permission is granted to anyone to use this software for any purpose, */
|
|
|
|
/* including commercial applications, and to alter it and redistribute it */
|
|
|
|
/* freely, subject to the following restrictions: */
|
|
|
|
/* */
|
|
|
|
/* 1. The origin of this software must not be misrepresented; you must not */
|
|
|
|
/* claim that you wrote the original software. If you use this software */
|
|
|
|
/* in a product, an acknowledgment in the product documentation would be */
|
|
|
|
/* appreciated but is not required. */
|
|
|
|
/* 2. Altered source versions must be plainly marked as such, and must not */
|
|
|
|
/* be misrepresented as being the original software. */
|
|
|
|
/* 3. This notice may not be removed or altered from any source */
|
|
|
|
/* distribution. */
|
|
|
|
/* */
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef EXPRDESC_H
|
|
|
|
#define EXPRDESC_H
|
|
|
|
|
|
|
|
|
2002-11-14 22:51:59 +00:00
|
|
|
|
2002-12-12 17:40:58 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
/* common */
|
2008-08-11 17:51:00 +00:00
|
|
|
#include "fp.h"
|
2002-12-12 17:40:58 +00:00
|
|
|
#include "inline.h"
|
|
|
|
|
2002-11-01 21:27:31 +00:00
|
|
|
/* cc65 */
|
2009-09-08 19:48:22 +00:00
|
|
|
#include "asmcode.h"
|
2002-11-01 21:27:31 +00:00
|
|
|
#include "datatype.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
2013-05-09 11:56:54 +00:00
|
|
|
/* Data */
|
2002-11-01 21:27:31 +00:00
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Defines for the flags field of the expression descriptor */
|
2004-05-31 15:27:33 +00:00
|
|
|
enum {
|
|
|
|
/* Location: Where is the value we're talking about? */
|
|
|
|
E_MASK_LOC = 0x00FF,
|
|
|
|
E_LOC_ABS = 0x0001, /* Absolute: numeric address or const */
|
|
|
|
E_LOC_GLOBAL = 0x0002, /* Global variable */
|
|
|
|
E_LOC_STATIC = 0x0004, /* Static variable */
|
|
|
|
E_LOC_REGISTER = 0x0008, /* Register variable */
|
|
|
|
E_LOC_STACK = 0x0010, /* Value on the stack */
|
|
|
|
E_LOC_PRIMARY = 0x0020, /* The primary register */
|
|
|
|
E_LOC_EXPR = 0x0040, /* An expression in the primary register */
|
|
|
|
E_LOC_LITERAL = 0x0080, /* Literal in the literal pool */
|
|
|
|
|
|
|
|
/* Constant location of some sort (only if rval) */
|
|
|
|
E_LOC_CONST = E_LOC_ABS | E_LOC_GLOBAL | E_LOC_STATIC |
|
|
|
|
E_LOC_REGISTER | E_LOC_LITERAL,
|
|
|
|
|
|
|
|
/* Reference? */
|
2004-06-05 20:29:47 +00:00
|
|
|
E_MASK_RTYPE = 0x0100,
|
2004-05-31 15:27:33 +00:00
|
|
|
E_RTYPE_RVAL = 0x0000,
|
2004-06-05 20:29:47 +00:00
|
|
|
E_RTYPE_LVAL = 0x0100,
|
2004-05-25 20:59:38 +00:00
|
|
|
|
2009-08-29 21:20:13 +00:00
|
|
|
/* Bit-field? */
|
|
|
|
E_BITFIELD = 0x0200,
|
|
|
|
|
2004-06-05 20:29:47 +00:00
|
|
|
/* Test */
|
2009-08-29 21:20:13 +00:00
|
|
|
E_NEED_TEST = 0x0400, /* Expression needs a test to set cc */
|
2009-09-08 19:48:22 +00:00
|
|
|
E_CC_SET = 0x0800, /* Condition codes are set */
|
|
|
|
|
|
|
|
E_HAVE_MARKS = 0x1000, /* Code marks are valid */
|
|
|
|
|
2004-06-05 20:29:47 +00:00
|
|
|
};
|
2002-11-01 21:27:31 +00:00
|
|
|
|
2010-03-20 18:51:59 +00:00
|
|
|
/* Forward */
|
|
|
|
struct Literal;
|
|
|
|
|
2002-11-01 21:27:31 +00:00
|
|
|
/* Describe the result of an expression */
|
|
|
|
typedef struct ExprDesc ExprDesc;
|
|
|
|
struct ExprDesc {
|
2013-05-09 11:56:54 +00:00
|
|
|
struct SymEntry* Sym; /* Symbol table entry if known */
|
|
|
|
Type* Type; /* Type array of expression */
|
2004-06-06 14:48:59 +00:00
|
|
|
unsigned Flags;
|
2013-05-09 11:56:54 +00:00
|
|
|
unsigned long Name; /* Name or label number */
|
|
|
|
long IVal; /* Integer value if expression constant */
|
2009-08-29 21:20:13 +00:00
|
|
|
Double FVal; /* Floating point value */
|
2010-03-20 18:51:59 +00:00
|
|
|
struct Literal* LVal; /* Literal value */
|
2009-08-29 21:20:13 +00:00
|
|
|
|
2009-09-08 19:48:22 +00:00
|
|
|
/* Bit field stuff */
|
2009-08-29 21:20:13 +00:00
|
|
|
unsigned BitOffs; /* Bit offset for bit fields */
|
|
|
|
unsigned BitWidth; /* Bit width for bit fields */
|
2009-09-08 19:48:22 +00:00
|
|
|
|
|
|
|
/* Start and end of generated code */
|
|
|
|
CodeMark Start;
|
|
|
|
CodeMark End;
|
2002-11-01 21:27:31 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
2013-05-09 11:56:54 +00:00
|
|
|
/* Code */
|
2002-11-01 21:27:31 +00:00
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
2004-05-31 15:27:33 +00:00
|
|
|
ExprDesc* ED_Init (ExprDesc* Expr);
|
2002-12-12 17:40:58 +00:00
|
|
|
/* Initialize an ExprDesc */
|
2004-05-31 15:27:33 +00:00
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_GetLoc (const ExprDesc* Expr)
|
|
|
|
/* Return the location flags from the expression */
|
2002-12-12 17:40:58 +00:00
|
|
|
{
|
2004-05-31 15:27:33 +00:00
|
|
|
return (Expr->Flags & E_MASK_LOC);
|
2002-12-12 17:40:58 +00:00
|
|
|
}
|
|
|
|
#else
|
2004-05-31 15:27:33 +00:00
|
|
|
# define ED_GetLoc(Expr) ((Expr)->Flags & E_MASK_LOC)
|
2002-12-12 17:40:58 +00:00
|
|
|
#endif
|
|
|
|
|
2004-05-25 20:59:38 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
2004-05-31 15:27:33 +00:00
|
|
|
INLINE int ED_IsLocAbs (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is an absolute value */
|
2004-05-25 20:59:38 +00:00
|
|
|
{
|
2004-05-31 15:27:33 +00:00
|
|
|
return (Expr->Flags & E_MASK_LOC) == E_LOC_ABS;
|
2004-05-25 20:59:38 +00:00
|
|
|
}
|
|
|
|
#else
|
2004-05-31 15:27:33 +00:00
|
|
|
# define ED_IsLocAbs(Expr) (((Expr)->Flags & E_MASK_LOC) == E_LOC_ABS)
|
2004-05-25 20:59:38 +00:00
|
|
|
#endif
|
|
|
|
|
2004-06-02 21:33:35 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsLocRegister (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is located in a register */
|
|
|
|
{
|
|
|
|
return (Expr->Flags & E_MASK_LOC) == E_LOC_REGISTER;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_IsLocRegister(Expr) (((Expr)->Flags & E_MASK_LOC) == E_LOC_REGISTER)
|
|
|
|
#endif
|
|
|
|
|
2004-05-25 20:59:38 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
2004-05-31 15:27:33 +00:00
|
|
|
INLINE int ED_IsLocStack (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is located on the stack */
|
|
|
|
{
|
|
|
|
return (Expr->Flags & E_MASK_LOC) == E_LOC_STACK;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_IsLocStack(Expr) (((Expr)->Flags & E_MASK_LOC) == E_LOC_STACK)
|
|
|
|
#endif
|
|
|
|
|
2004-06-02 21:33:35 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsLocPrimary (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is an expression in the register pseudo variable */
|
|
|
|
{
|
|
|
|
return (Expr->Flags & E_MASK_LOC) == E_LOC_PRIMARY;
|
|
|
|
}
|
|
|
|
#else
|
2004-06-04 17:00:48 +00:00
|
|
|
# define ED_IsLocPrimary(Expr) (((Expr)->Flags & E_MASK_LOC) == E_LOC_PRIMARY)
|
2004-06-02 21:33:35 +00:00
|
|
|
#endif
|
|
|
|
|
2004-05-31 15:27:33 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsLocExpr (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is an expression in the primary */
|
|
|
|
{
|
|
|
|
return (Expr->Flags & E_MASK_LOC) == E_LOC_EXPR;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_IsLocExpr(Expr) (((Expr)->Flags & E_MASK_LOC) == E_LOC_EXPR)
|
|
|
|
#endif
|
|
|
|
|
2004-06-02 21:33:35 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsLocLiteral (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is a string from the literal pool */
|
2010-03-20 18:51:59 +00:00
|
|
|
{
|
2004-06-02 21:33:35 +00:00
|
|
|
return (Expr->Flags & E_MASK_LOC) == E_LOC_LITERAL;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_IsLocLiteral(Expr) (((Expr)->Flags & E_MASK_LOC) == E_LOC_LITERAL)
|
|
|
|
#endif
|
|
|
|
|
2004-05-31 15:27:33 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsLocConst (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is a constant location of some sort */
|
|
|
|
{
|
|
|
|
return (Expr->Flags & E_LOC_CONST) != 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_IsLocConst(Expr) (((Expr)->Flags & E_LOC_CONST) != 0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsLVal (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is a reference */
|
2004-05-25 20:59:38 +00:00
|
|
|
{
|
2004-05-31 15:27:33 +00:00
|
|
|
return (Expr->Flags & E_MASK_RTYPE) == E_RTYPE_LVAL;
|
2004-05-25 20:59:38 +00:00
|
|
|
}
|
|
|
|
#else
|
2004-05-31 15:27:33 +00:00
|
|
|
# define ED_IsLVal(Expr) (((Expr)->Flags & E_MASK_RTYPE) == E_RTYPE_LVAL)
|
2004-05-25 20:59:38 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
2004-05-31 15:27:33 +00:00
|
|
|
INLINE int ED_IsRVal (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is a rvalue */
|
2004-05-25 20:59:38 +00:00
|
|
|
{
|
2004-05-31 15:27:33 +00:00
|
|
|
return (Expr->Flags & E_MASK_RTYPE) == E_RTYPE_RVAL;
|
2004-05-25 20:59:38 +00:00
|
|
|
}
|
|
|
|
#else
|
2004-05-31 15:27:33 +00:00
|
|
|
# define ED_IsRVal(Expr) (((Expr)->Flags & E_MASK_RTYPE) == E_RTYPE_RVAL)
|
2004-05-25 20:59:38 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
2004-05-31 15:27:33 +00:00
|
|
|
INLINE void ED_MakeLVal (ExprDesc* Expr)
|
|
|
|
/* Make the expression a lvalue. */
|
2004-05-25 20:59:38 +00:00
|
|
|
{
|
2004-05-31 15:27:33 +00:00
|
|
|
Expr->Flags |= E_RTYPE_LVAL;
|
2004-05-25 20:59:38 +00:00
|
|
|
}
|
|
|
|
#else
|
2004-06-05 20:29:47 +00:00
|
|
|
# define ED_MakeLVal(Expr) do { (Expr)->Flags |= E_RTYPE_LVAL; } while (0)
|
2004-05-25 20:59:38 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
2004-05-31 15:27:33 +00:00
|
|
|
INLINE void ED_MakeRVal (ExprDesc* Expr)
|
|
|
|
/* Make the expression a rvalue. */
|
2004-05-25 20:59:38 +00:00
|
|
|
{
|
2004-05-31 15:27:33 +00:00
|
|
|
Expr->Flags &= ~E_RTYPE_LVAL;
|
2004-05-25 20:59:38 +00:00
|
|
|
}
|
|
|
|
#else
|
2004-06-05 20:29:47 +00:00
|
|
|
# define ED_MakeRVal(Expr) do { (Expr)->Flags &= ~E_RTYPE_LVAL; } while (0)
|
|
|
|
#endif
|
|
|
|
|
2009-08-29 21:20:13 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsBitField (const ExprDesc* Expr)
|
|
|
|
/* Return true if the expression is a bit field */
|
|
|
|
{
|
|
|
|
return (Expr->Flags & E_BITFIELD) != 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_IsBitField(Expr) (((Expr)->Flags & E_BITFIELD) != 0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void ED_MakeBitField (ExprDesc* Expr, unsigned BitOffs, unsigned BitWidth);
|
|
|
|
/* Make this expression a bit field expression */
|
|
|
|
|
2004-06-05 20:29:47 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE void ED_MarkForTest (ExprDesc* Expr)
|
|
|
|
/* Mark the expression for a test. */
|
|
|
|
{
|
|
|
|
Expr->Flags |= E_NEED_TEST;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_MarkForTest(Expr) do { (Expr)->Flags |= E_NEED_TEST; } while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_NeedsTest (const ExprDesc* Expr)
|
|
|
|
/* Check if the expression needs a test. */
|
|
|
|
{
|
|
|
|
return (Expr->Flags & E_NEED_TEST) != 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_NeedsTest(Expr) (((Expr)->Flags & E_NEED_TEST) != 0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE void ED_TestDone (ExprDesc* Expr)
|
|
|
|
/* Mark the expression as tested and condition codes set. */
|
|
|
|
{
|
|
|
|
Expr->Flags = (Expr->Flags & ~E_NEED_TEST) | E_CC_SET;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_TestDone(Expr) \
|
|
|
|
do { (Expr)->Flags = ((Expr)->Flags & ~E_NEED_TEST) | E_CC_SET; } while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsTested (const ExprDesc* Expr)
|
|
|
|
/* Check if the expression has set the condition codes. */
|
|
|
|
{
|
|
|
|
return (Expr->Flags & E_CC_SET) != 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_IsTested(Expr) (((Expr)->Flags & E_CC_SET) != 0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE void ED_MarkAsUntested (ExprDesc* Expr)
|
|
|
|
/* Mark the expression as not tested (condition codes not set). */
|
|
|
|
{
|
|
|
|
Expr->Flags &= ~E_CC_SET;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_MarkAsUntested(Expr) do { (Expr)->Flags &= ~E_CC_SET; } while (0)
|
2004-05-25 20:59:38 +00:00
|
|
|
#endif
|
|
|
|
|
2009-09-08 19:48:22 +00:00
|
|
|
void ED_SetCodeRange (ExprDesc* Expr, const CodeMark* Start, const CodeMark* End);
|
|
|
|
/* Set the code range for this expression */
|
|
|
|
|
|
|
|
int ED_CodeRangeIsEmpty (const ExprDesc* Expr);
|
|
|
|
/* Return true if no code was output for this expression */
|
|
|
|
|
2004-06-02 21:33:35 +00:00
|
|
|
const char* ED_GetLabelName (const ExprDesc* Expr, long Offs);
|
|
|
|
/* Return the assembler label name of the given expression. Beware: This
|
2014-06-30 09:10:35 +00:00
|
|
|
** function may use a static buffer, so the name may get "lost" on the second
|
|
|
|
** call to the function.
|
|
|
|
*/
|
2004-06-02 21:33:35 +00:00
|
|
|
|
2004-06-05 11:35:53 +00:00
|
|
|
int ED_GetStackOffs (const ExprDesc* Expr, int Offs);
|
|
|
|
/* Get the stack offset of an address on the stack in Expr taking into account
|
2014-06-30 09:10:35 +00:00
|
|
|
** an additional offset in Offs.
|
|
|
|
*/
|
2004-06-05 11:35:53 +00:00
|
|
|
|
2006-02-19 12:29:37 +00:00
|
|
|
ExprDesc* ED_MakeConstAbs (ExprDesc* Expr, long Value, Type* Type);
|
2004-05-31 15:27:33 +00:00
|
|
|
/* Make Expr an absolute const with the given value and type. */
|
|
|
|
|
|
|
|
ExprDesc* ED_MakeConstAbsInt (ExprDesc* Expr, long Value);
|
2002-11-01 21:27:31 +00:00
|
|
|
/* Make Expr a constant integer expression with the given value */
|
|
|
|
|
2004-05-31 15:27:33 +00:00
|
|
|
ExprDesc* ED_MakeRValExpr (ExprDesc* Expr);
|
|
|
|
/* Convert Expr into a rvalue which is in the primary register without an
|
2014-06-30 09:10:35 +00:00
|
|
|
** offset.
|
|
|
|
*/
|
2004-05-31 15:27:33 +00:00
|
|
|
|
|
|
|
ExprDesc* ED_MakeLValExpr (ExprDesc* Expr);
|
|
|
|
/* Convert Expr into a lvalue which is in the primary register without an
|
2014-06-30 09:10:35 +00:00
|
|
|
** offset.
|
|
|
|
*/
|
2004-05-31 15:27:33 +00:00
|
|
|
|
|
|
|
int ED_IsConst (const ExprDesc* Expr);
|
|
|
|
/* Return true if the expression denotes a constant of some sort. This can be a
|
2014-06-30 09:10:35 +00:00
|
|
|
** numeric constant, the address of a global variable (maybe with offset) or
|
|
|
|
** similar.
|
|
|
|
*/
|
2004-05-31 15:27:33 +00:00
|
|
|
|
2004-06-29 20:26:27 +00:00
|
|
|
#if defined(HAVE_INLINE)
|
|
|
|
INLINE int ED_IsConstAbs (const ExprDesc* Expr)
|
2004-05-31 15:27:33 +00:00
|
|
|
/* Return true if the expression denotes a constant absolute value. This can be
|
2014-06-30 09:10:35 +00:00
|
|
|
** a numeric constant, cast to any type.
|
|
|
|
*/
|
2004-06-29 20:26:27 +00:00
|
|
|
{
|
|
|
|
return (Expr->Flags & (E_MASK_LOC|E_MASK_RTYPE)) == (E_LOC_ABS|E_RTYPE_RVAL);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define ED_IsConstAbs(E) \
|
|
|
|
(((E)->Flags & (E_MASK_LOC|E_MASK_RTYPE)) == (E_LOC_ABS|E_RTYPE_RVAL))
|
|
|
|
#endif
|
2004-05-31 15:27:33 +00:00
|
|
|
|
|
|
|
int ED_IsConstAbsInt (const ExprDesc* Expr);
|
|
|
|
/* Return true if the expression is a constant (numeric) integer. */
|
|
|
|
|
|
|
|
int ED_IsNullPtr (const ExprDesc* Expr);
|
|
|
|
/* Return true if the given expression is a NULL pointer constant */
|
|
|
|
|
|
|
|
int ED_IsBool (const ExprDesc* Expr);
|
|
|
|
/* Return true of the expression can be treated as a boolean, that is, it can
|
2014-06-30 09:10:35 +00:00
|
|
|
** be an operand to a compare operation.
|
|
|
|
*/
|
2004-05-31 15:27:33 +00:00
|
|
|
|
2002-11-01 21:27:31 +00:00
|
|
|
void PrintExprDesc (FILE* F, ExprDesc* Expr);
|
|
|
|
/* Print an ExprDesc */
|
|
|
|
|
2006-02-19 12:29:37 +00:00
|
|
|
Type* ReplaceType (ExprDesc* Expr, const Type* NewType);
|
2002-11-14 22:51:59 +00:00
|
|
|
/* Replace the type of Expr by a copy of Newtype and return the old type string */
|
|
|
|
|
2002-11-01 21:27:31 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* End of exprdesc.h */
|
|
|
|
|
2014-03-04 00:11:19 +00:00
|
|
|
#endif
|