source/astexpr.cc

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #include <cmath>
  20
  21 #include "astexprs.h"
  22 #include "shapesexceptions.h"
  23 #include "lighttypes.h"
  24
  25 using namespace Shapes;
  26 using namespace std;
  27
  28
  29 Ast::UnaryExpr::UnaryExpr( const Ast::SourceLocation & _loc )
  30         : Ast::Expression( _loc )
  31 { }
  32 Ast::UnaryExpr::~UnaryExpr( )
  33 { }
  34
  35 DEFAULTUNARYOPIMPL( UnaryExpr );
  36
  37
  38 Kernel::UnaryCont_1::UnaryCont_1( const Ast::UnaryExpr * op, const Kernel::PassedDyn & dyn, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
  39         : Kernel::Continuation( traceLoc ), op_( op ), dyn_( dyn ), cont_( cont )
  40 { }
  41
  42 Kernel::UnaryCont_1::~UnaryCont_1( )
  43 { }
  44
  45 void
  46 Kernel::UnaryCont_1::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
  47 {
  48         cont_->takeValue( val->unaryDispatch( val, dyn_, op_ ), evalState );
  49 }
  50
  51 Kernel::ContRef
  52 Kernel::UnaryCont_1::up( ) const
  53 {
  54         return cont_;
  55 }
  56
  57 RefCountPtr< const char >
  58 Kernel::UnaryCont_1::description( ) const
  59 {
  60         return strrefdup( "unary's only" );
  61 }
  62
  63 void
  64 Kernel::UnaryCont_1::gcMark( Kernel::GCMarkedSet & marked )
  65 {
  66         cont_->gcMark( marked );
  67 }
  68
  69
  70 Ast::UnaryPrefixExpr::UnaryPrefixExpr( const Ast::SourceLocation & loc, const Ast::SourceLocation & opLoc, Ast::Expression * expr )
  71         : Ast::UnaryExpr( loc ), opLoc_( opLoc ), expr_( expr )
  72 { }
  73
  74 Ast::UnaryPrefixExpr::UnaryPrefixExpr( const Ast::SourceLocation & opLoc, Ast::Expression * expr )
  75         : Ast::UnaryExpr( Ast::SourceLocation( opLoc, expr->loc( ) ) ), opLoc_( opLoc ), expr_( expr )
  76 { }
  77
  78 Ast::UnaryPrefixExpr::~UnaryPrefixExpr( )
  79 {
  80         delete expr_;
  81 }
  82
  83 void
  84 Ast::UnaryPrefixExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
  85 {
  86         expr_->analyze( this, env, freeStatesDst );
  87 }
  88
  89 void
  90 Ast::UnaryPrefixExpr::eval( Kernel::EvalState * evalState ) const
  91 {
  92         evalState->expr_ = expr_;
  93         evalState->cont_ = Kernel::ContRef( new Kernel::UnaryCont_1( this, evalState->dyn_, evalState->cont_, expr_->loc( ) ) );
  94 }
  95
  96 RefCountPtr< const Lang::Value >
  97 Ast::UnaryPrefixExpr::throwNotApplicable( const Lang::Value * arg ) const
  98 {
  99         throw Exceptions::UnaryPrefixNotApplicable( opLoc_, expr_, arg->getTypeName( ) );
 100 }
 101
 102
 103
 104
 105 Ast::UnaryPostfixExpr::UnaryPostfixExpr( const Ast::SourceLocation & opLoc, Ast::Expression * expr )
 106         : Ast::UnaryExpr( Ast::SourceLocation( expr->loc( ), opLoc ) ), opLoc_( opLoc ), expr_( expr )
 107 { }
 108
 109 Ast::UnaryPostfixExpr::~UnaryPostfixExpr( )
 110 {
 111         delete expr_;
 112 }
 113
 114 void
 115 Ast::UnaryPostfixExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
 116 {
 117         expr_->analyze( this, env, freeStatesDst );
 118 }
 119
 120 void
 121 Ast::UnaryPostfixExpr::eval( Kernel::EvalState * evalState ) const
 122 {
 123         evalState->expr_ = expr_;
 124         evalState->cont_ = Kernel::ContRef( new Kernel::UnaryCont_1( this, evalState->dyn_, evalState->cont_, expr_->loc( ) ) );
 125 }
 126
 127 RefCountPtr< const Lang::Value >
 128 Ast::UnaryPostfixExpr::throwNotApplicable( const Lang::Value * arg ) const
 129 {
 130         throw Exceptions::UnaryPostfixNotApplicable( opLoc_, expr_, arg->getTypeName( ) );
 131 }
 132
 133
 134 Kernel::BinaryInfixCont_2::BinaryInfixCont_2( const Ast::BinaryInfixExpr * op, const Kernel::ValueRef & val1, const Kernel::PassedDyn & dyn, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 135         : Kernel::Continuation( traceLoc ), op_( op ), val1_( val1 ), dyn_( dyn ), cont_( cont )
 136 { }
 137
 138 Kernel::BinaryInfixCont_2::~BinaryInfixCont_2( )
 139 { }
 140
 141 void
 142 Kernel::BinaryInfixCont_2::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 143 {
 144         cont_->takeValue( val1_->binaryDispatch1( val1_, val, dyn_, op_ ), evalState );
 145 }
 146
 147 Kernel::ContRef
 148 Kernel::BinaryInfixCont_2::up( ) const
 149 {
 150         return cont_;
 151 }
 152
 153 RefCountPtr< const char >
 154 Kernel::BinaryInfixCont_2::description( ) const
 155 {
 156         return strrefdup( "binary infix's second" );
 157 }
 158
 159 void
 160 Kernel::BinaryInfixCont_2::gcMark( Kernel::GCMarkedSet & marked )
 161 {
 162         const_cast< Lang::Value * >( val1_.getPtr( ) )->gcMark( marked );
 163         cont_->gcMark( marked );
 164 }
 165
 166
 167 Kernel::BinaryInfixCont_1::BinaryInfixCont_1( const Ast::BinaryInfixExpr * op, Kernel::EvalState & evalState, const Ast::SourceLocation & traceLoc )
 168         : Kernel::Continuation( traceLoc ), op_( op ), env_( evalState.env_ ), dyn_( evalState.dyn_ ), cont_( evalState.cont_ )
 169 { }
 170
 171 Kernel::BinaryInfixCont_1::~BinaryInfixCont_1( )
 172 { }
 173
 174 void
 175 Kernel::BinaryInfixCont_1::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 176 {
 177         evalState->expr_ = const_cast< Ast::Expression * >( op_->get_expr2( ) );
 178         evalState->env_ = env_;
 179         evalState->dyn_ = dyn_;
 180         evalState->cont_ = Kernel::ContRef( new Kernel::BinaryInfixCont_2( op_, val, dyn_, cont_, evalState->expr_->loc( ) ) );
 181 }
 182
 183 Kernel::ContRef
 184 Kernel::BinaryInfixCont_1::up( ) const
 185 {
 186         return cont_;
 187 }
 188
 189 RefCountPtr< const char >
 190 Kernel::BinaryInfixCont_1::description( ) const
 191 {
 192         return strrefdup( "binary infix's first" );
 193 }
 194
 195 void
 196 Kernel::BinaryInfixCont_1::gcMark( Kernel::GCMarkedSet & marked )
 197 {
 198         env_->gcMark( marked );
 199         cont_->gcMark( marked );
 200 }
 201
 202
 203 Ast::BinaryInfixExpr::BinaryInfixExpr( const Ast::SourceLocation & opLoc, Ast::Expression * expr1, Ast::Expression * expr2 )
 204         : Ast::Expression( Ast::SourceLocation( expr1->loc( ), expr2->loc( ) ) ), opLoc_( opLoc ), expr1_( expr1 ), expr2_( expr2 )
 205 { }
 206
 207 Ast::BinaryInfixExpr::~BinaryInfixExpr( )
 208 {
 209         delete expr1_;
 210         delete expr2_;
 211 }
 212
 213 void
 214 Ast::BinaryInfixExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
 215 {
 216         expr1_->analyze( this, env, freeStatesDst );
 217         expr2_->analyze( this, env, freeStatesDst );
 218 }
 219
 220 void
 221 Ast::BinaryInfixExpr::eval( Kernel::EvalState * evalState ) const
 222 {
 223         evalState->expr_ = expr1_;
 224         evalState->cont_ = Kernel::ContRef( new Kernel::BinaryInfixCont_1( this, *evalState, expr1_->loc( ) ) );
 225 }
 226
 227 RefCountPtr< const Lang::Value >
 228 Ast::BinaryInfixExpr::throwNotApplicable( const Lang::Value * arg1, const Lang::Value * arg2 ) const
 229 {
 230         throw Exceptions::BinaryInfixNotApplicable( opLoc_, expr1_, arg1->getTypeName( ), expr2_, arg2->getTypeName( ) );
 231 }
 232
 233 DEFAULTBINARYOPIMPL;