source: src/Parser/ParseNode.cc @ 5d125e4

aaron-thesisarm-ehcleanup-dtorsctordeferred_resndemanglerjacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 5d125e4 was 5d125e4, checked in by Peter A. Buhr <pabuhr@…>, 6 years ago

start code allowing structures to no fields

  • Property mode set to 100644
File size: 7.5 KB
Line 
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//
7// ParseNode.cc --
8//
9// Author           : Rodolfo G. Esteves
10// Created On       : Sat May 16 13:26:29 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Fri Jul 15 18:49:25 2016
13// Update Count     : 62
14//
15
16#include <climits>
17#include "ParseNode.h"
18using namespace std;
19
20// Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
21//
22//              prefix action constant action suffix
23//
24// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
25//
26//              constant BEGIN CONT ...
27//              <CONT>(...)? BEGIN 0 ... // possible empty suffix
28//
29// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
30// type.
31
32static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
33static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
34static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
35static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
36static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
37static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
38
39BasicType::Kind literalType( ConstantNode::Type type, string &value ) {
40        BasicType::Kind btype;
41
42        // lexing divides constants into 4 kinds
43        switch ( type ) {
44          case ConstantNode::Integer:
45                {
46                        static const BasicType::Kind kind[2][3] = {
47                                { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
48                                { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
49                        };
50                        bool dec = true, Unsigned = false;                      // decimal, unsigned constant
51                        int size;                                                                       // 0 => int, 1 => long, 2 => long long
52                        unsigned long long v;                                           // converted integral value
53                        size_t last = value.length() - 1;                       // last character of constant
54
55                        if ( value[0] == '0' ) {                                        // octal/hex constant ?
56                                dec = false;
57                                if ( last != 0 && checkX( value[1] ) ) { // hex constant ?
58                                        sscanf( (char *)value.c_str(), "%llx", &v );
59                                        //printf( "%llx %llu\n", v, v );
60                                } else {                                                                // octal constant
61                                        sscanf( (char *)value.c_str(), "%llo", &v );
62                                        //printf( "%llo %llu\n", v, v );
63                                } // if
64                        } else {                                                                        // decimal constant ?
65                                sscanf( (char *)value.c_str(), "%llu", &v );
66                                //printf( "%llu %llu\n", v, v );
67                        } // if
68
69                        if ( v <= INT_MAX ) {                                           // signed int
70                                size = 0;
71                        } else if ( v <= UINT_MAX && ! dec ) {          // unsigned int
72                                size = 0;
73                                Unsigned = true;                                                // unsigned
74                        } else if ( v <= LONG_MAX ) {                           // signed long int
75                                size = 1;
76                        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
77                                size = 1;
78                                Unsigned = true;                                                // unsigned long int
79                        } else if ( v <= LLONG_MAX ) {                          // signed long long int
80                                size = 2;
81                        } else {                                                                        // unsigned long long int
82                                size = 2;
83                                Unsigned = true;                                                // unsigned long long int
84                        } // if
85
86                        if ( checkU( value[last] ) ) {                          // suffix 'u' ?
87                                Unsigned = true;
88                                if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'l' ?
89                                        size = 1;
90                                        if ( last > 1 && checkL( value[ last - 2 ] ) ) { // suffix 'll' ?
91                                                size = 2;
92                                        } // if
93                                } // if
94                        } else if ( checkL( value[ last ] ) ) {         // suffix 'l' ?
95                                size = 1;
96                                if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'll' ?
97                                        size = 2;
98                                        if ( last > 1 && checkU( value[ last - 2 ] ) ) { // suffix 'u' ?
99                                                Unsigned = true;
100                                        } // if
101                                } else {
102                                        if ( last > 0 && checkU( value[ last - 1 ] ) ) { // suffix 'u' ?
103                                                Unsigned = true;
104                                        } // if
105                                } // if
106                        } // if
107                        btype = kind[Unsigned][size];                           // lookup constant type
108                        break;
109                }
110          case ConstantNode::Float:
111                {
112                        //long double v;
113                        static const BasicType::Kind kind[2][3] = {
114                                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
115                                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
116                        };
117                        bool complx = false;                                            // real, complex
118                        int size = 1;                                                           // 0 => float, 1 => double (default), 2 => long double
119                        // floating-point constant has minimum of 2 characters: 1. or .1
120                        size_t last = value.length() - 1;
121
122                        if ( checkI( value[last] ) ) {                          // imaginary ?
123                                complx = true;
124                                last -= 1;                                                              // backup one character
125                        } // if
126
127                        //sscanf( (char *)value.c_str(), "%Lf", &v );
128                        //printf( "%s %24.22Lf %Lf\n", value.c_str(), v, v );
129
130                        if ( checkF( value[last] ) ) {                          // float ?
131                                size = 0;
132                        } else if ( checkD( value[last] ) ) {           // double ?
133                                size = 1;
134                        } else if ( checkL( value[last] ) ) {           // long double ?
135                                size = 2;
136                        } // if
137                        if ( ! complx && checkI( value[last - 1] ) ) { // imaginary ?
138                                complx = true;
139                        } // if
140                        btype = kind[complx][size];                                     // lookup constant type
141                        break;
142                }
143          case ConstantNode::Character:
144                btype = BasicType::Char;                                                // default
145                if ( string( "LUu" ).find( value[0] ) != string::npos ) {
146                        // ???
147                } // if
148                break;
149          case ConstantNode::String:
150                assert( false );
151                // array of char
152                if ( string( "LUu" ).find( value[0] ) != string::npos ) {
153                        if ( value[0] == 'u' && value[1] == '8' ) {
154                                // ???
155                        } else {
156                                // ???
157                        } // if
158                } // if
159                break;
160        } // switch
161        return btype;
162} // literalType
163
164
165ConstantNode *makeConstant( ConstantNode::Type type, std::string *str ) {
166        ::Type::Qualifiers emptyQualifiers;                                     // no qualifiers on constants
167        return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, literalType( type, *str ) ), *str ), nullptr ) );
168}
169
170ConstantNode *makeConstantStr( ConstantNode::Type type, std::string *str ) {
171        ::Type::Qualifiers emptyQualifiers;                                     // no qualifiers on constants
172        // string should probably be a primitive type
173        ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),
174                                                                   new ConstantExpr(
175                                                                           Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
176                                                                                                 toString( str->size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
177                                                                   false, false );
178        return new ConstantNode( new ConstantExpr( Constant( at, *str ), nullptr ) );
179}
180
181
182// Builder
183int ParseNode::indent_by = 4;
184
185ParseNode::ParseNode() : next( 0 ) {};
186ParseNode::ParseNode( const string *name ) : name( *name ), next( 0 ) { delete name; }
187ParseNode::ParseNode( const string &name ) : name( name ), next( 0 ) { }
188
189ParseNode::~ParseNode() {
190        delete next;
191};
192
193ParseNode *ParseNode::get_last() {
194        ParseNode *current = this;
195
196        while ( current->get_link() != 0 )
197        current = current->get_link();
198
199        return current;
200}
201
202ParseNode *ParseNode::set_link( ParseNode *next_ ) {
203        if ( next_ != 0 ) get_last()->next = next_;
204        return this;
205}
206
207void ParseNode::print( std::ostream &os, int indent ) const {}
208
209
210void ParseNode::printList( std::ostream &os, int indent ) const {
211        print( os, indent );
212
213        if ( next ) {
214                next->printList( os, indent );
215        } // if
216}
217
218ParseNode &ParseNode::operator,( ParseNode &p ) {
219        set_link( &p );
220
221        return *this;
222}
223
224ParseNode *mkList( ParseNode &pn ) {
225        // it just relies on `operator,' to take care of the "arguments" and provides a nice interface to an awful-looking
226        // address-of, rendering, for example (StatementNode *)(&(*$5 + *$7)) into (StatementNode *)mkList(($5, $7))
227        // (although "nice" is probably not the word)
228        return &pn;
229}
230
231// Local Variables: //
232// tab-width: 4 //
233// mode: c++ //
234// compile-command: "make install" //
235// End: //
Note: See TracBrowser for help on using the repository browser.