source: src/CodeGen/OperatorTable.cc @ b54ad9c

ADTarm-ehast-experimentalcleanup-dtorsenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since b54ad9c was 3d2b7bc, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

Check for operator-as-object errors
  • Property mode set to 100644
File size: 5.6 KB
RevLine 
[51587aa]1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
[6943f051]7// OperatorTable.cc --
[51587aa]8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
[58dd019]11// Last Modified By : Peter A. Buhr
[e5f2a67]12// Last Modified On : Sat Jul 15 17:12:22 2017
13// Update Count     : 15
[51587aa]14//
[51b7345]15
[bff227f]16#include <algorithm>  // for any_of
17#include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
18#include <utility>    // for pair
[bf2438c]19
[51b7345]20#include "OperatorTable.h"
[bc3127d]21#include "Common/utility.h"
[51b7345]22
23namespace CodeGen {
[51587aa]24        namespace {
25                const OperatorInfo tableValues[] = {
[de62360d]26                        {       "?[?]",         "",             "_operator_index",                              OT_INDEX                        },
[58dd019]27                        {       "?{}",          "=",    "_constructor",                                 OT_CTOR                         },
[6943f051]28                        {       "^?{}",         "",             "_destructor",                                  OT_DTOR                         },
[de62360d]29                        {       "?()",          "",             "_operator_call",                               OT_CALL                         },
30                        {       "?++",          "++",   "_operator_postincr",                   OT_POSTFIXASSIGN        },
31                        {       "?--",          "--",   "_operator_postdecr",                   OT_POSTFIXASSIGN        },
32                        {       "*?",           "*",    "_operator_deref",                              OT_PREFIX                       },
33                        {       "+?",           "+",    "_operator_unaryplus",                  OT_PREFIX                       },
34                        {       "-?",           "-",    "_operator_unaryminus",                 OT_PREFIX                       },
35                        {       "~?",           "~",    "_operator_bitnot",                             OT_PREFIX                       },
36                        {       "!?",           "!",    "_operator_lognot",                             OT_PREFIX                       },
37                        {       "++?",          "++",   "_operator_preincr",                    OT_PREFIXASSIGN         },
38                        {       "--?",          "--",   "_operator_predecr",                    OT_PREFIXASSIGN         },
[e5f2a67]39                        {       "?\\?",         "\\",   "_operator_exponential",                OT_INFIX                        },
[de62360d]40                        {       "?*?",          "*",    "_operator_multiply",                   OT_INFIX                        },
41                        {       "?/?",          "/",    "_operator_divide",                             OT_INFIX                        },
42                        {       "?%?",          "%",    "_operator_modulus",                    OT_INFIX                        },
43                        {       "?+?",          "+",    "_operator_add",                                OT_INFIX                        },
44                        {       "?-?",          "-",    "_operator_subtract",                   OT_INFIX                        },
45                        {       "?<<?",         "<<",   "_operator_shiftleft",                  OT_INFIX                        },
46                        {       "?>>?",         ">>",   "_operator_shiftright",                 OT_INFIX                        },
47                        {       "?<?",          "<",    "_operator_less",                               OT_INFIX                        },
48                        {       "?>?",          ">",    "_operator_greater",                    OT_INFIX                        },
49                        {       "?<=?",         "<=",   "_operator_lessequal",                  OT_INFIX                        },
50                        {       "?>=?",         ">=",   "_operator_greaterequal",               OT_INFIX                        },
51                        {       "?==?",         "==",   "_operator_equal",                              OT_INFIX                        },
52                        {       "?!=?",         "!=",   "_operator_notequal",                   OT_INFIX                        },
53                        {       "?&?",          "&",    "_operator_bitand",                             OT_INFIX                        },
54                        {       "?^?",          "^",    "_operator_bitxor",                             OT_INFIX                        },
55                        {       "?|?",          "|",    "_operator_bitor",                              OT_INFIX                        },
56                        {       "?=?",          "=",    "_operator_assign",                             OT_INFIXASSIGN          },
[e5f2a67]57                        {       "?\\=?",        "\\=",  "_operator_expassign",                  OT_INFIXASSIGN          },
[de62360d]58                        {       "?*=?",         "*=",   "_operator_multassign",                 OT_INFIXASSIGN          },
59                        {       "?/=?",         "/=",   "_operator_divassign",                  OT_INFIXASSIGN          },
60                        {       "?%=?",         "%=",   "_operator_modassign",                  OT_INFIXASSIGN          },
61                        {       "?+=?",         "+=",   "_operator_addassign",                  OT_INFIXASSIGN          },
62                        {       "?-=?",         "-=",   "_operator_subassign",                  OT_INFIXASSIGN          },
[51587aa]63                        {       "?<<=?",        "<<=",  "_operator_shiftleftassign",    OT_INFIXASSIGN          },
64                        {       "?>>=?",        ">>=",  "_operator_shiftrightassign",   OT_INFIXASSIGN          },
[de62360d]65                        {       "?&=?",         "&=",   "_operator_bitandassign",               OT_INFIXASSIGN          },
66                        {       "?^=?",         "^=",   "_operator_bitxorassign",               OT_INFIXASSIGN          },
67                        {       "?|=?",         "|=",   "_operator_bitorassign",                OT_INFIXASSIGN          },
[51587aa]68                };
[51b7345]69
[51587aa]70                const int numOps = sizeof( tableValues ) / sizeof( OperatorInfo );
[51b7345]71
[51587aa]72                std::map< std::string, OperatorInfo > table;
[51b7345]73
[51587aa]74                void initialize() {
75                        for ( int i = 0; i < numOps; ++i ) {
76                                table[ tableValues[i].inputName ] = tableValues[i];
77                        } // for
78                }
79        } // namespace
[51b7345]80
[3d2b7bc]81        bool operatorLookup( const std::string & funcName, OperatorInfo & info ) {
[51587aa]82                static bool init = false;
83                if ( ! init ) {
84                        initialize();
85                } // if
[bc3127d]86
[51587aa]87                std::map< std::string, OperatorInfo >::const_iterator i = table.find( funcName );
88                if ( i == table.end() ) {
[bc3127d]89                        if ( isPrefix( funcName, "?`" ) ) {
90                                // handle literal suffixes, which are user-defined postfix operators
91                                info.inputName = funcName;
92                                info.symbol = funcName.substr(2);
93                                info.outputName = toString( "__operator_literal_", info.symbol );
94                                info.type = OT_POSTFIX;
95                                return true;
96                        }
[51587aa]97                        return false;
98                } else {
99                        info = i->second;
100                        return true;
101                } // if
102        }
[bff227f]103
[3d2b7bc]104        bool isOperator( const std::string & funcName ) {
105                OperatorInfo info;
106                return operatorLookup( funcName, info );
107        }
108
[bff227f]109        /// determines if a given function name is one of the operator types between [begin, end)
110        template<typename Iterator>
111        bool isOperatorType( const std::string & funcName, Iterator begin, Iterator end ) {
112                OperatorInfo info;
113                if ( operatorLookup( funcName, info ) ) {
114                        return std::find( begin, end, info.type ) != end;
115                }
116                return false;
117        }
118
119        bool isConstructor( const std::string & funcName ) {
120                static OperatorType types[] = { OT_CTOR };
121                return isOperatorType( funcName, std::begin(types), std::end(types) );
122        }
123
124        bool isDestructor( const std::string & funcName ) {
125                static OperatorType types[] = { OT_DTOR };
126                return isOperatorType( funcName, std::begin(types), std::end(types) );
127        }
128
129        bool isAssignment( const std::string & funcName ) {
130                static OperatorType types[] = { OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
131                return isOperatorType( funcName, std::begin(types), std::end(types) );
132        }
133
134        bool isCtorDtor( const std::string & funcName ) {
135                static OperatorType types[] = { OT_CTOR, OT_DTOR };
136                return isOperatorType( funcName, std::begin(types), std::end(types) );
137        }
138
139        bool isCtorDtorAssign( const std::string & funcName ) {
140                static OperatorType types[] = { OT_CTOR, OT_DTOR, OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
141                return isOperatorType( funcName, std::begin(types), std::end(types) );
142        }
[51b7345]143} // namespace CodeGen
[51587aa]144
145// Local Variables: //
146// tab-width: 4 //
147// mode: c++ //
148// compile-command: "make install" //
149// End: //
Note: See TracBrowser for help on using the repository browser.