JBLToken.C

Go to the documentation of this file.

#include "jbltools/sfh/JBLToken.h"

#include <iostream>             
#include <sstream>

// #ifdef DEBUG
// #undef DEBUG
// #endif
// #define DEBUG 2

using namespace std;


static const char *ident="@(#)$Id: JBLToken.C,v 1.8 2005/07/08 15:01:34 blist Exp $";

JBLToken::JBLToken() 
{}

bool JBLToken::isoperator (char c) {
  return (c=='=' || c=='+' || c=='-' || c=='*' || c=='/' ||
          c=='<' || c=='>' || c=='!' || c=='^' ||
          c=='|' || c=='&' || c=='~'); 
}

bool JBLToken::issimpleoperator (char c) {
  return (c==','); 
}

bool JBLToken::isparanthesis (char c) {
//   return (c=='(' || c==')' || c=='[' || c==']' || c=='{' || c=='}'); 
  return (c=='(' || c==')' || c=='{' || c=='}'); 
}

bool JBLToken::input(istream& is) {
  type = EMPTY;
  stringvalue = "";
  char c;
  // eat leading whitespace
  while (isblank(is.peek())) is.get();
  
  c = is.peek();
  if (c == EOF) return false;
  if (isalpha(c)) {
    type = IDENTIFIER;
//    while (isalnum(c) || c=='_' || c=='.' || c==':') {
    while (isalnum(c) || c=='_' || c=='[' || c==']' || c=='.' || c==':') {
      stringvalue+=is.get();
      c = is.peek();
    }
    if (stringvalue == "true") {
      type = BOOL;
      boolvalue = true;
    } else if (stringvalue == "false") {
      type = BOOL;
      boolvalue = false;
    }
  } 
  else if (isdigit(c) || c=='.') {
    type = INT;
    bool pointallowed = true;
    bool signallowed = false;
    bool expallowed = true;
    while (isdigit(c) || 
          (pointallowed && c=='.') || 
          (expallowed && (c=='e' || c=='E')) ||
          (signallowed && (c=='+' || c=='-'))) {
      if (!isdigit(c)) type = FLOAT;
      if (c=='.') pointallowed = false;
      if (c=='e' || c=='E') 
        {expallowed = false; signallowed = true;}
      else 
        {signallowed = false;}
      stringvalue+=is.get();
      c = is.peek();
    }  
    if ((type == INT) && (1 == sscanf (stringvalue.c_str(), "%d", &intvalue))) {
      floatvalue = intvalue;
      // cout << "JBLToken::input: '" << stringvalue << "' is an INT\n";
    }
    else  if (1 == sscanf (stringvalue.c_str(), "%f", &floatvalue)) {
      type = FLOAT;
      // cout << "JBLToken::input: '" << stringvalue << "' is a FLOAT\n";
    }
    else {
      type = UNKNOWN;
      cerr << "JBLToken::input: '" << stringvalue << "' is an ill-formatted number!\n";
    }
  }
  else if (issimpleoperator(c))  {
    type = OPERATOR;
    stringvalue+=is.get();
  }
  else if (isoperator(c))  {
    type = OPERATOR;
    while (isoperator(c)) {
      stringvalue+=is.get();
      c = is.peek();
    }
  }
  else if (isparanthesis(c)) {
    type = PARANTHESIS;
    stringvalue = is.get(); 
  }
  else {
    type = UNKNOWN;
    stringvalue = is.get();
    cerr <<  "token.input: illegal character '" << stringvalue << "'!\n";
  }
  // cout << "token.input: stringvalue='" << stringvalue << "', type=" << type << endl;
#if DEBUG>0
  cout << "JBLToken::input: " << *this << endl;
#endif  
  return stringvalue != "";
}

std::ostream& JBLToken::print(std::ostream& os) const {
  if      (isEmpty())       os << "EMPTY";
  else if (isUnknown())     os << "UNKNOWN";
  else if (isIdentifier())  os << "IDENTIFIER '"  << getStringValue() << "'";
  else if (isInt())         os << "INT "          << getIntValue();
  else if (isFloat())       os << "FLOAT "        << getFloatValue();
  else if (isBool())        os << "BOOL "         << (getBoolValue() ? "true" : "false");
  else if (isOperator())    os << "IDENTIFIER '"  << getStringValue() << "'";
  else if (isParanthesis()) os << "PARANTHESIS '" << getStringValue() << "'";

  return os;
}

istream& operator>> (istream& is, JBLToken& token) {
  token.input (is);
  return is;
}

ostream& operator<< (ostream& os, const JBLToken& token) {
  return token.print (os);
}

---