ppopsdef.h

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C头文件 代码 · 共 811 行 · 第 1/2 页

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


// PPOPSDEF.H -- define operators
//
// PPOPCG -- defines code-generation requirements
// PPOPAN -- defines table for ANALYSE.C
// PPOPCD -- defines an operator code
// PPOPIM -- defines impossible entry for ANALYSE.C
//           -- can be deleted with a table re-arrangement
// PPOPNAME -- defines start of CO_NAME_...
// PPOPNM -- define CO_NAME...
// PPOPOP -- define mangled version of operator name
//
// This file is never directly #included. Use the following:
//
//  * PPOPS.H       -- enumerate CO_...
//  * PPOPSAN.H     -- generate internal table in ANALYSE.C
//  * PPOPSFLG.H    -- generate the flags column
//  * PPOPSCOP.H    -- generate the CGOP column
//  * PPOPSNAM.H    -- generate names for the CGOP column (debug only)
//  * PPOPSLNM.H    -- generate long names for the CGOP column
//  * PPOPFNAM.H    -- generate names for the Internal Names column
//
// 91/06/25 -- J.W.Welch        -- defined
// 91/10/25 -- J.W.Welch        -- added internal names
// 91/12/04 -- J.W.Welch        -- introduced PPOP.. macros
// 92/01/29 -- J.W.Welch        -- introduced OPCNV_... bits
// 92/12/18 -- Greg Bentz       -- added PPOPSLNM.H
// 93/01/18 -- Greg Bentz       -- added PPOPOP
// 93/09/29 -- A.F.Scian        -- added delete [] and new []
// 95/02/16 -- A.F.Scian        -- moved non-null PPOPOP operators up so that
//                                 CppLookupName doesn't have to sift through
//                                 impossible operator names to lookup valid
//                                 operator names

// define null macros as required

#ifndef PPOPCD
    #define PPOPCD( a )
#endif

#ifndef PPOPOP
    #define PPOPOP( a, sa )
#endif

#ifndef PPOPCG
    #define PPOPCG( a, b, c )
#endif

#ifndef PPOPIM
    #define PPOPIM
#endif

#ifndef PPOPAN
    // ptr op ptr, ptr op arith, arith op ptr, arith op arith, other
    #define PPOPAN( a, b, c, d, e )
#endif

#ifndef PPOPNMS
    #define PPOPNMS
#endif

#ifndef PPOPNM
    #define PPOPNM( a )
#endif

#ifndef PPOPEND
    #define PPOPEND
#endif


#ifndef ONLY_INTRINSIC

#define delim

PPOPCD( PLUS )
PPOPOP( "oj", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_PLUS, O_PLUS, "+" )
PPOPAN( ER__BOTH_PTR, LVALUE_BEXPR, SW_LV_EXPR, BIN_ARITH, ER__ONLY_AP )//o+o

#undef  delim
#define delim ,

PPOPCD( MINUS )
PPOPOP( "oi", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_MINUS, O_MINUS, "-" )
PPOPAN( MINUS_PP, LVALUE_BEXPR, ER__SUB_AP, BIN_ARITH, ER__ONLY_AP )//o-o

PPOPCD( TIMES )
PPOPOP( "of", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_TWO_AR, O_TIMES, "*" )
PPOPAN( ER__ONLY_AR, ER__ONLY_AR, ER__ONLY_AR, BIN_ARITH, ER__ONLY_AR )//o*o

PPOPCD( DIVIDE )
PPOPOP( "om", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_TWO_AR, O_DIV, "/" )
PPOPAN( ER__ONLY_AR, ER__ONLY_AR, ER__ONLY_AR, BIN_ARITH, ER__ONLY_AR )//o/o

PPOPCD( PERCENT )
PPOPOP( "on", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_TWO_INT, O_MOD, "%" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, BIN_ARITH_I, ER__ONLY_IN )//o%o

PPOPCD( AND )
PPOPOP( "ok", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_TWO_INT, O_AND, "&" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, BIN_ARITH_I, ER__ONLY_IN )//o&o

PPOPCD( OR )
PPOPOP( "os", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_TWO_INT, O_OR, "|" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, BIN_ARITH_I, ER__ONLY_IN )//o|o

PPOPCD( XOR )
PPOPOP( "or", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_TWO_INT, O_XOR, "^" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, BIN_ARITH_I, ER__ONLY_IN )//o^o

PPOPCD( RSHIFT )
PPOPOP( "oa", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_SHIFT, O_RSHIFT, ">>" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, SHIFT_OP, ER__ONLY_IN )//o>>o

PPOPCD( LSHIFT )
PPOPOP( "ob", INVALID )
PPOPCG( PTO_BIN_ARITH | OPCNV_SHIFT, O_LSHIFT, "<<" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, SHIFT_OP, ER__ONLY_IN )//o<<o

PPOPCD( UMINUS )
PPOPOP( "oi", MINUS )
PPOPCG( PTO_UN_ARITH | OPCNV_ONE_AR, O_UMINUS, "-" )
PPOPAN( ER__ONLY_AR, IMPOSSIBLE, IMPOSSIBLE, UN_ARITH, ER__ONLY_IN )//-o

PPOPCD( TILDE )
PPOPOP( "oq", INVALID )
PPOPCG( PTO_UN_ARITH | OPCNV_ONE_INT, O_COMPLEMENT, "~" )
PPOPAN( ER__ONLY_IN, IMPOSSIBLE, IMPOSSIBLE, UN_ARITH_I, ER__ONLY_IN )//~o

PPOPCD( ADDR_OF )
PPOPOP( "ok", AND )
PPOPCG( PTO_ADDR_OPER, 0, "&" )
PPOPAN( ADDR_OF, IMPOSSIBLE, IMPOSSIBLE, ADDR_OF, ADDR_OF )//&o

PPOPCD( EQUAL )
PPOPOP( "aa", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQUALS | PTO_ASSIGN_SAME, O_GETS, "=" )
PPOPAN( EQUAL_PP, EQUAL_PZ, EQUAL_AP, EQUAL_AA, EQUAL_OTHER )//o=o

PPOPCD( EQ )
PPOPOP( "ra", INVALID )
PPOPCG( PTO_COMPARES | OPCNV_RELEQ, O_EQ, "==" )
PPOPAN( CMP_PP, CMP_PTR_ZERO, CMP_ZERO_PTR, CMP_AA, CMP_MP )//o==o

PPOPCD( NE )
PPOPOP( "rb", INVALID )
PPOPCG( PTO_COMPARES | OPCNV_RELEQ, O_NE, "!=" )
PPOPAN( CMP_PP, CMP_PTR_ZERO, CMP_ZERO_PTR, CMP_AA, CMP_MP )//o!=o

PPOPCD( GT )
PPOPOP( "re", INVALID )
PPOPCG( PTO_COMPARES | OPCNV_RELN, O_GT, ">" )
PPOPAN( CMP_PP, CMP_PTR_ZERO, CMP_ZERO_PTR, CMP_AA, ER__ONLY_AP )//o>o

PPOPCD( LE )
PPOPOP( "rd", INVALID )
PPOPCG( PTO_COMPARES | OPCNV_RELN, O_LE, "<=" )
PPOPAN( CMP_PP, CMP_PTR_ZERO, CMP_ZERO_PTR, CMP_AA, ER__ONLY_AP )//o<=o

PPOPCD( LT )
PPOPOP( "rc", INVALID )
PPOPCG( PTO_COMPARES | OPCNV_RELN, O_LT, "<" )
PPOPAN( CMP_PP, CMP_PTR_ZERO, CMP_ZERO_PTR, CMP_AA, ER__ONLY_AP )//o<o

PPOPCD( GE )
PPOPOP( "rf", INVALID )
PPOPCG( PTO_COMPARES | OPCNV_RELN, O_GE, ">=" )
PPOPAN( CMP_PP, CMP_PTR_ZERO, CMP_ZERO_PTR, CMP_AA, ER__ONLY_AP )//o>=o

PPOPCD( AND_AND )
PPOPOP( "ot", INVALID )
PPOPCG( PTO_FLOW_BINARY | OPCNV_LOG2, O_FLOW_AND, "&&" )
PPOPAN( BIN_LOG_PP, BIN_LOG_PA, BIN_LOG_AP, BIN_LOG_AA, BIN_LOG_MP )//o&&o

PPOPCD( OR_OR )
PPOPOP( "ou", INVALID )
PPOPCG( PTO_FLOW_BINARY | OPCNV_LOG2, O_FLOW_OR, "||" )
PPOPAN( BIN_LOG_PP, BIN_LOG_PA, BIN_LOG_AP, BIN_LOG_AA, BIN_LOG_MP )//o&&o

PPOPCD( EXCLAMATION )
PPOPOP( "oc", INVALID )
PPOPCG( PTO_FLOW_UNARY | OPCNV_LOG1, O_FLOW_NOT, "!" )
PPOPAN( UN_LOG_P, UN_LOG_P, UN_LOG, UN_LOG, UN_LOG_MP )//!o

PPOPCD( ARROW )
PPOPOP( "oe", INVALID )
PPOPCG( PTO_POINTS_TO | OPCNV_ARROW, O_PLUS, "->" )
PPOPIM

PPOPCD( INDEX )
PPOPOP( "od", INVALID )
PPOPCG( PTO_INDEX | OPCNV_SUBSCR, 0, "[]" )
PPOPAN( ER__PP_INDEX, INDEX_PA, INDEX_AP, ER__INDEX, ER__INDEX )//o[o]

PPOPCD( PLUS_EQUAL )
PPOPOP( "ac", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQAP | PTO_ASSIGN_SAME, O_PLUS, "+=" )
PPOPAN( ER__BOTH_PTR, OPEQ_PTR, ER__AP_ASSN, OPEQ_ARITH, ER__ONLY_AP )//o+=o

PPOPCD( MINUS_EQUAL )
PPOPOP( "ad", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQAP | PTO_ASSIGN_SAME, O_MINUS, "-=" )
PPOPAN( ER__BOTH_PTR, OPEQ_PTR, ER__AP_ASSN, OPEQ_ARITH, ER__ONLY_AP )//o-=o

PPOPCD( TIMES_EQUAL )
PPOPOP( "ab", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQAR, O_TIMES, "*=" )
PPOPAN( ER__ONLY_AR, ER__ONLY_AR, ER__ONLY_AR, OPEQ_ARITH, ER__ONLY_AR )//o*=o

PPOPCD( DIVIDE_EQUAL )
PPOPOP( "ae", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQAR, O_DIV, "/=" )
PPOPAN( ER__ONLY_AR, ER__ONLY_AR, ER__ONLY_AR, OPEQ_ARITH, ER__ONLY_AR )//o/=o

PPOPCD( PERCENT_EQUAL )
PPOPOP( "af", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQINT, O_MOD, "%=" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, OPEQ_INT, ER__ONLY_IN )//o%=o

PPOPCD( AND_EQUAL )
PPOPOP( "ai", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQINT | PTO_ASSIGN_SAME, O_AND, "&=" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, OPEQ_INT, ER__ONLY_IN )//o&=o

PPOPCD( OR_EQUAL )
PPOPOP( "aj", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQINT | PTO_ASSIGN_SAME, O_OR, "|=" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, OPEQ_INT, ER__ONLY_IN )//o|=o

PPOPCD( XOR_EQUAL )
PPOPOP( "ak", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQINT | PTO_ASSIGN_SAME, O_XOR, "^=" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, OPEQ_INT, ER__ONLY_IN )//o^=o

PPOPCD( RSHIFT_EQUAL )
PPOPOP( "ag", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQINT, O_RSHIFT, ">>=" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, OPEQ_SHIFT, ER__ONLY_IN )//o>>=o

PPOPCD( LSHIFT_EQUAL )
PPOPOP( "ah", INVALID )
PPOPCG( PTO_BIN_ASSIGN | OPCNV_EQINT, O_LSHIFT, "<<=" )
PPOPAN( ER__ONLY_IN, ER__ONLY_IN, ER__ONLY_IN, OPEQ_SHIFT, ER__ONLY_IN )//o<<=o

PPOPCD( UPLUS )
PPOPOP( "oj", PLUS )
PPOPCG( PTO_UN_ARITH | OPCNV_ONE_AR, 0, "+" )
PPOPAN( UN_PLUS_PTR, IMPOSSIBLE, IMPOSSIBLE, UN_ARITH, ER__ONLY_AR )//+o

// these four operators must be in the same order as their BPRE/BPOST equivalents

PPOPCD( PRE_PLUS_PLUS )
PPOPOP( "og", INVALID )
PPOPCG( PTO_UN_ASSIGN | OPCNV_ONE_RAP, 0, "++" )
PPOPAN( LINCDEC_PTR, IMPOSSIBLE, IMPOSSIBLE, LINCDEC_ARITH, ER__ONLY_AP )//++o

PPOPCD( PRE_MINUS_MINUS )
PPOPOP( "oh", INVALID )
PPOPCG( PTO_UN_ASSIGN | OPCNV_ONE_RAP, 0, "--" )
PPOPAN( LINCDEC_PTR, IMPOSSIBLE, IMPOSSIBLE, LINCDEC_ARITH, ER__ONLY_AP )//--o

PPOPCD( POST_PLUS_PLUS )
PPOPOP( "og", PRE_PLUS_PLUS )
PPOPCG( PTO_UN_ASSIGN | OPCNV_POST_OP, 0, "++" )
PPOPAN( INCDEC_PTR, IMPOSSIBLE, IMPOSSIBLE, INCDEC_ARITH, ER__ONLY_AP )//o++

PPOPCD( POST_MINUS_MINUS )
PPOPOP( "oh", PRE_MINUS_MINUS )
PPOPCG( PTO_UN_ASSIGN | OPCNV_POST_OP, 0, "--" )
PPOPAN( INCDEC_PTR, IMPOSSIBLE, IMPOSSIBLE, INCDEC_ARITH, ER__ONLY_AP )//o--

PPOPCD( INDIRECT )
PPOPOP( "of", TIMES )
PPOPCG( PTO_ADDR_OPER | OPCNV_PTR, O_POINTS, "*" )
PPOPAN( INDIRECT, IMPOSSIBLE, IMPOSSIBLE, ER__NO_PTR, ER__NO_PTR )//*o

PPOPCD( COMMA )
PPOPOP( "oo", INVALID )
PPOPCG( PTO_BINARY_OVLD, O_COMMA, "," )
PPOPAN( COMMA, COMMA, COMMA, COMMA, COMMA )//o, o

PPOPCD( ARROW_STAR )
PPOPOP( "ol", INVALID )
PPOPCG( PTO_BINARY_OVLD | OPCNV_ARROW_STAR, 0, "->*" )
PPOPAN( ARROW_STAR, ARROW_STAR, ARROW_STAR, ARROW_STAR, ARROW_STAR )//o->*o

PPOPCD( CALL )
PPOPOP( "op", INVALID )
PPOPCG( PTO_FUNCALL | OPCNV_FUNCTION, 0, "()" )
PPOPAN( CALL, CALL, ER__NOT_FUN, ER__NOT_FUN, CALL )//o(o)

PPOPCD( CONVERT )
PPOPOP( "cv", INVALID )
PPOPCG( PTO_BINARY_NO_OVLD, O_CONVERT, "CONV" )
PPOPAN( CAST, CAST, CAST, CAST, CAST )//convert

PPOPCD( NEW )
PPOPOP( "nw", INVALID )
PPOPCG( PTO_BINARY_NO_OVLD, 0, "new" )
PPOPAN( NEW, NEW, NEW, NEW, NEW )//new

PPOPCD( NEW_ARRAY )
PPOPOP( "na", INVALID )
PPOPCG( PTO_BINARY_NO_OVLD, 0, "new[]" )
PPOPAN( NEW, NEW, NEW, NEW, NEW )//new

PPOPCD( DELETE )
PPOPOP( "dl", INVALID )
PPOPCG( PTO_UNARY_NO_OVLD, 0, "delete" )
PPOPAN( DLT, DLT, DLT, DLT, DLT )//delete

PPOPCD( DELETE_ARRAY )
PPOPOP( "da", INVALID )
PPOPCG( PTO_UNARY_NO_OVLD, 0, "delete[]" )
PPOPAN( DLT, DLT, DLT, DLT, DLT )//delete_array

PPOPCD( DTOR )
PPOPOP( "dt", INVALID )
PPOPCG( PTO_BINARY_CPP, 0, "DTOR" )
PPOPIM

PPOPCD( CTOR )
PPOPOP( "ct", INVALID )
PPOPCG( PTO_BINARY_CPP, 0, "CTOR" )
PPOPAN( CTOR, CTOR, CTOR, CTOR, CTOR )//ctor

//---
PPOPCD( DOT )
PPOPCG( PTO_DOT, O_PLUS, "." )
PPOPIM

PPOPCD( QUESTION )
PPOPCG( PTO_BINARY_NO_OVLD | OPCNV_QUESTION, 0, "" )
PPOPAN( QUESTMRK, QUESTMRK, QUESTMRK, QUESTMRK, QUESTMRK )//o?o

PPOPCD( COLON )
//PPOPCG( PTO_BINARY_NO_OVLD | OPCNV_COLON, 0, "" )
PPOPCG( PTO_BINARY_NO_OVLD , 0, "" )
PPOPAN( COLON_PP, COLON_PA, COLON_AP, COLON_AA, COLON_OTHER )//o:o

PPOPCD( LIST )
PPOPCG( PTO_BINARY_NO_OVLD, 0, "" )
PPOPAN( PARAMETER_P, PARAMETER, PARAMETER_P, PARAMETER, PARAMETER_P )//list

PPOPCD( DOT_STAR )
PPOPCG( PTO_DOT, 0, ".*" )
PPOPAN( DOT_STAR, DOT_STAR, DOT_STAR, DOT_STAR, DOT_STAR )//o.*o

PPOPCD( CONVERT_INT )
PPOPCG( PTO_UNARY_CPP | OPCNV_ONE_INT, O_NOP, "" )
PPOPAN( ER__ONLY_IN, IMPOSSIBLE, IMPOSSIBLE, CONVERT_INT, CONVERT_INT )

PPOPCD( SIZEOF_TYPE )
PPOPCG( PTO_UNARY_NO_OVLD, 0, "" )
PPOPAN( OP_SIZEOF, IMPOSSIBLE, IMPOSSIBLE, OP_SIZEOF, OP_SIZEOF )//sizeof-type

PPOPCD( SIZEOF_EXPR )
PPOPCG( PTO_UNARY_NO_OVLD, 0, "" )
PPOPAN( OP_SIZEOF, IMPOSSIBLE, IMPOSSIBLE, OP_SIZEOF, OP_SIZEOF )//sizeof-expr

PPOPCD( OFFSETOF )
PPOPCG( PTO_BINARY_NO_OVLD, 0, "" )
PPOPAN( IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE, DO_NOTHING )

PPOPCD( STORAGE )
PPOPCG( PTO_BINARY_NO_OVLD, 0, "storage" )
PPOPAN( IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE, DO_NOTHING )