Home | History | Annotate | Download | only in kati 
      1 // Copyright 2015 Google Inc. All rights reserved
      2 //
      3 // Licensed under the Apache License, Version 2.0 (the "License");
      4 // you may not use this file except in compliance with the License.
      5 // You may obtain a copy of the License at
      6 //
      7 //      http://www.apache.org/licenses/LICENSE-2.0
      8 //
      9 // Unless required by applicable law or agreed to in writing, software
     10 // distributed under the License is distributed on an "AS IS" BASIS,
     11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     12 // See the License for the specific language governing permissions and
     13 // limitations under the License.
     14 
     15 // +build ignore
     16 
     17 #include "stmt.h"
     18 
     19 #include "eval.h"
     20 #include "expr.h"
     21 #include "stringprintf.h"
     22 #include "strutil.h"
     23 
     24 Stmt::Stmt() {}
     25 
     26 Stmt::~Stmt() {}
     27 
     28 string RuleStmt::DebugString() const {
     29   return StringPrintf("RuleStmt(expr=%s term=%d after_term=%s loc=%s:%d)",
     30                       expr->DebugString().c_str(),
     31                       term,
     32                       after_term->DebugString().c_str(),
     33                       LOCF(loc()));
     34 }
     35 
     36 string AssignStmt::DebugString() const {
     37   const char* opstr = "???";
     38   switch (op) {
     39     case AssignOp::EQ: opstr = "EQ"; break;
     40     case AssignOp::COLON_EQ: opstr = "COLON_EQ"; break;
     41     case AssignOp::PLUS_EQ: opstr = "PLUS_EQ"; break;
     42     case AssignOp::QUESTION_EQ: opstr = "QUESTION_EQ"; break;
     43   }
     44   const char* dirstr = "???";
     45   switch (directive) {
     46     case AssignDirective::NONE: dirstr = ""; break;
     47     case AssignDirective::OVERRIDE: dirstr = "override"; break;
     48     case AssignDirective::EXPORT: dirstr = "export"; break;
     49   }
     50   return StringPrintf("AssignStmt(lhs=%s rhs=%s (%s) "
     51                       "opstr=%s dir=%s loc=%s:%d)",
     52                       lhs->DebugString().c_str(),
     53                       rhs->DebugString().c_str(),
     54                       NoLineBreak(orig_rhs.as_string()).c_str(),
     55                       opstr, dirstr, LOCF(loc()));
     56 }
     57 
     58 Symbol AssignStmt::GetLhsSymbol(Evaluator* ev) const {
     59   if (!lhs->IsLiteral()) {
     60     string buf;
     61     lhs->Eval(ev, &buf);
     62     return Intern(buf);
     63   }
     64 
     65   if (!lhs_sym_cache_.IsValid()) {
     66     lhs_sym_cache_ = Intern(lhs->GetLiteralValueUnsafe());
     67   }
     68   return lhs_sym_cache_;
     69 }
     70 
     71 string CommandStmt::DebugString() const {
     72   return StringPrintf("CommandStmt(%s, loc=%s:%d)",
     73                       expr->DebugString().c_str(), LOCF(loc()));
     74 }
     75 
     76 string IfStmt::DebugString() const {
     77   const char* opstr = "???";
     78   switch (op) {
     79     case CondOp::IFEQ: opstr = "ifeq"; break;
     80     case CondOp::IFNEQ: opstr = "ifneq"; break;
     81     case CondOp::IFDEF: opstr = "ifdef"; break;
     82     case CondOp::IFNDEF: opstr = "ifndef"; break;
     83   }
     84   return StringPrintf("IfStmt(op=%s, lhs=%s, rhs=%s t=%zu f=%zu loc=%s:%d)",
     85                       opstr,
     86                       lhs->DebugString().c_str(),
     87                       rhs->DebugString().c_str(),
     88                       true_stmts.size(),
     89                       false_stmts.size(),
     90                       LOCF(loc()));
     91 }
     92 
     93 string IncludeStmt::DebugString() const {
     94   return StringPrintf("IncludeStmt(%s, loc=%s:%d)",
     95                       expr->DebugString().c_str(), LOCF(loc()));
     96 }
     97 
     98 string ExportStmt::DebugString() const {
     99   return StringPrintf("ExportStmt(%s, %d, loc=%s:%d)",
    100                       expr->DebugString().c_str(),
    101                       is_export,
    102                       LOCF(loc()));
    103 }
    104 
    105 string ParseErrorStmt::DebugString() const {
    106   return StringPrintf("ParseErrorStmt(%s, loc=%s:%d)",
    107                       msg.c_str(),
    108                       LOCF(loc()));
    109 }
    110 
    111 RuleStmt::~RuleStmt() {
    112   delete expr;
    113   delete after_term;
    114 }
    115 
    116 void RuleStmt::Eval(Evaluator* ev) const {
    117   ev->EvalRule(this);
    118 }
    119 
    120 AssignStmt::~AssignStmt() {
    121   delete lhs;
    122   delete rhs;
    123 }
    124 
    125 void AssignStmt::Eval(Evaluator* ev) const {
    126   ev->EvalAssign(this);
    127 }
    128 
    129 CommandStmt::~CommandStmt() {
    130   delete expr;
    131 }
    132 
    133 void CommandStmt::Eval(Evaluator* ev) const {
    134   ev->EvalCommand(this);
    135 }
    136 
    137 IfStmt::~IfStmt() {
    138   delete lhs;
    139   delete rhs;
    140 }
    141 
    142 void IfStmt::Eval(Evaluator* ev) const {
    143   ev->EvalIf(this);
    144 }
    145 
    146 IncludeStmt::~IncludeStmt() {
    147   delete expr;
    148 }
    149 
    150 void IncludeStmt::Eval(Evaluator* ev) const {
    151   ev->EvalInclude(this);
    152 }
    153 
    154 ExportStmt::~ExportStmt() {
    155   delete expr;
    156 }
    157 
    158 void ExportStmt::Eval(Evaluator* ev) const {
    159   ev->EvalExport(this);
    160 }
    161 
    162 ParseErrorStmt::~ParseErrorStmt() {
    163 }
    164 
    165 void ParseErrorStmt::Eval(Evaluator* ev) const {
    166   ev->set_loc(loc());
    167   ev->Error(msg);
    168 }
    169