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, 2014 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
  33 Ast::UnaryExpr::UnaryExpr( const Ast::SourceLocation & firstLoc, const Ast::SourceLocation & lastLoc )
  34         : Ast::Expression( firstLoc, lastLoc )
  35 { }
  36
  37 Ast::UnaryExpr::~UnaryExpr( )
  38 { }
  39
  40 DEFAULTUNARYOPIMPL( UnaryExpr );
  41
  42
  43 Kernel::UnaryCont_1::UnaryCont_1( const Ast::UnaryExpr * op, const Kernel::PassedDyn & dyn, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
  44         : Kernel::Continuation( traceLoc ), op_( op ), dyn_( dyn ), cont_( cont )
  45 { }
  46
  47 Kernel::UnaryCont_1::~UnaryCont_1( )
  48 { }
  49
  50 void
  51 Kernel::UnaryCont_1::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
  52 {
  53         cont_->takeValue( val->unaryDispatch( val, dyn_, op_ ), evalState );
  54 }
  55
  56 Kernel::ContRef
  57 Kernel::UnaryCont_1::up( ) const
  58 {
  59         return cont_;
  60 }
  61
  62 RefCountPtr< const char >
  63 Kernel::UnaryCont_1::description( ) const
  64 {
  65         return strrefdup( "unary's only" );
  66 }
  67
  68 void
  69 Kernel::UnaryCont_1::gcMark( Kernel::GCMarkedSet & marked )
  70 {
  71         cont_->gcMark( marked );
  72 }
  73
  74
  75 Ast::UnaryPrefixExpr::UnaryPrefixExpr( const Ast::SourceLocation & loc, const Ast::SourceLocation & opLoc, Ast::Expression * expr )
  76         : Ast::UnaryExpr( loc ), opLoc_( opLoc, bool( ) ), expr_( expr )
  77 { }
  78
  79 Ast::UnaryPrefixExpr::UnaryPrefixExpr( const Ast::SourceLocation & opLoc, Ast::Expression * expr )
  80         : Ast::UnaryExpr( opLoc, expr->loc( ) ), opLoc_( opLoc, bool ( ) ), expr_( expr )
  81 { }
  82
  83 Ast::UnaryPrefixExpr::~UnaryPrefixExpr( )
  84 {
  85         delete expr_;
  86 }
  87
  88 void
  89 Ast::UnaryPrefixExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
  90 {
  91         expr_->analyze( this, env, freeStatesDst );
  92 }
  93
  94 void
  95 Ast::UnaryPrefixExpr::eval( Kernel::EvalState * evalState ) const
  96 {
  97         evalState->expr_ = expr_;
  98         evalState->cont_ = Kernel::ContRef( new Kernel::UnaryCont_1( this, evalState->dyn_, evalState->cont_, expr_->loc( ) ) );
  99 }
 100
 101 RefCountPtr< const Lang::Value >
 102 Ast::UnaryPrefixExpr::throwNotApplicable( const Lang::Value * arg ) const
 103 {
 104         throw Exceptions::UnaryPrefixNotApplicable( opLoc_, expr_, arg->getTypeName( ) );
 105 }
 106
 107
 108
 109
 110 Ast::UnaryPostfixExpr::UnaryPostfixExpr( const Ast::SourceLocation & opLoc, Ast::Expression * expr )
 111         : Ast::UnaryExpr( expr->loc( ), opLoc ), opLoc_( opLoc, bool( ) ), expr_( expr )
 112 { }
 113
 114 Ast::UnaryPostfixExpr::~UnaryPostfixExpr( )
 115 {
 116         delete expr_;
 117 }
 118
 119 void
 120 Ast::UnaryPostfixExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
 121 {
 122         expr_->analyze( this, env, freeStatesDst );
 123 }
 124
 125 void
 126 Ast::UnaryPostfixExpr::eval( Kernel::EvalState * evalState ) const
 127 {
 128         evalState->expr_ = expr_;
 129         evalState->cont_ = Kernel::ContRef( new Kernel::UnaryCont_1( this, evalState->dyn_, evalState->cont_, expr_->loc( ) ) );
 130 }
 131
 132 RefCountPtr< const Lang::Value >
 133 Ast::UnaryPostfixExpr::throwNotApplicable( const Lang::Value * arg ) const
 134 {
 135         throw Exceptions::UnaryPostfixNotApplicable( opLoc_, expr_, arg->getTypeName( ) );
 136 }
 137
 138
 139 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 )
 140         : Kernel::Continuation( traceLoc ), op_( op ), val1_( val1 ), dyn_( dyn ), cont_( cont )
 141 { }
 142
 143 Kernel::BinaryInfixCont_2::~BinaryInfixCont_2( )
 144 { }
 145
 146 void
 147 Kernel::BinaryInfixCont_2::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 148 {
 149         cont_->takeValue( val1_->binaryDispatch1( val1_, val, dyn_, op_ ), evalState );
 150 }
 151
 152 Kernel::ContRef
 153 Kernel::BinaryInfixCont_2::up( ) const
 154 {
 155         return cont_;
 156 }
 157
 158 RefCountPtr< const char >
 159 Kernel::BinaryInfixCont_2::description( ) const
 160 {
 161         return strrefdup( "binary infix's second" );
 162 }
 163
 164 void
 165 Kernel::BinaryInfixCont_2::gcMark( Kernel::GCMarkedSet & marked )
 166 {
 167         const_cast< Lang::Value * >( val1_.getPtr( ) )->gcMark( marked );
 168         cont_->gcMark( marked );
 169 }
 170
 171
 172 Kernel::BinaryInfixCont_1::BinaryInfixCont_1( const Ast::BinaryInfixExpr * op, Kernel::EvalState & evalState, const Ast::SourceLocation & traceLoc )
 173         : Kernel::Continuation( traceLoc ), op_( op ), env_( evalState.env_ ), dyn_( evalState.dyn_ ), cont_( evalState.cont_ )
 174 { }
 175
 176 Kernel::BinaryInfixCont_1::~BinaryInfixCont_1( )
 177 { }
 178
 179 void
 180 Kernel::BinaryInfixCont_1::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 181 {
 182         evalState->expr_ = const_cast< Ast::Expression * >( op_->get_expr2( ) );
 183         evalState->env_ = env_;
 184         evalState->dyn_ = dyn_;
 185         evalState->cont_ = Kernel::ContRef( new Kernel::BinaryInfixCont_2( op_, val, dyn_, cont_, evalState->expr_->loc( ) ) );
 186 }
 187
 188 Kernel::ContRef
 189 Kernel::BinaryInfixCont_1::up( ) const
 190 {
 191         return cont_;
 192 }
 193
 194 RefCountPtr< const char >
 195 Kernel::BinaryInfixCont_1::description( ) const
 196 {
 197         return strrefdup( "binary infix's first" );
 198 }
 199
 200 void
 201 Kernel::BinaryInfixCont_1::gcMark( Kernel::GCMarkedSet & marked )
 202 {
 203         env_->gcMark( marked );
 204         cont_->gcMark( marked );
 205 }
 206
 207
 208 Ast::BinaryInfixExpr::BinaryInfixExpr( const Ast::SourceLocation & opLoc, Ast::Expression * expr1, Ast::Expression * expr2 )
 209         : Ast::Expression( expr1->loc( ), expr2->loc( ) ), opLoc_( opLoc, bool( ) ), expr1_( expr1 ), expr2_( expr2 )
 210 { }
 211
 212 Ast::BinaryInfixExpr::~BinaryInfixExpr( )
 213 {
 214         delete expr1_;
 215         delete expr2_;
 216 }
 217
 218 void
 219 Ast::BinaryInfixExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
 220 {
 221         expr1_->analyze( this, env, freeStatesDst );
 222         expr2_->analyze( this, env, freeStatesDst );
 223 }
 224
 225 void
 226 Ast::BinaryInfixExpr::eval( Kernel::EvalState * evalState ) const
 227 {
 228         evalState->expr_ = expr1_;
 229         evalState->cont_ = Kernel::ContRef( new Kernel::BinaryInfixCont_1( this, *evalState, expr1_->loc( ) ) );
 230 }
 231
 232 RefCountPtr< const Lang::Value >
 233 Ast::BinaryInfixExpr::throwNotApplicable( const Lang::Value * arg1, const Lang::Value * arg2 ) const
 234 {
 235         throw Exceptions::BinaryInfixNotApplicable( opLoc_, expr1_, arg1->getTypeName( ), expr2_, arg2->getTypeName( ) );
 236 }
 237
 238 DEFAULTBINARYOPIMPL;