---

semantics.cc

Go to the documentation of this file.

// Semantics implementation -*- C++ -*-

// Copyright (C) 2001-2003 Hermann Schichl
//
// This file is part of the COCONUT API.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#include <semantics.h>
  
void convex_e::read(char *c)
{
  switch(c[0])
  {
    case 'V':
      e = c_concave;
      break;
    case 'X':
      e = c_convex;
      break;
    case 'L':
      e = c_linear;
      break;
    case 'M':
      e = c_maybe;
      break;
    default:
      throw "malformed convexity info: wrong type";
  }
  unsigned int t;
  if(sscanf(c+1,"%u",&t) != 1)
    throw "malformed convexity info: tested is not an integer";
  tested = (uint16_t)t;
}

const char* semantics::print_tristate(const tristate& x) const
{
  if(x == t_true) return "T";
  if(x == t_false) return "F";
  return "M";
}

tristate semantics::read_tristate(char c) const
{
  if(c == 'T') return t_true;
  if(c == 'F') return t_false;
  return t_maybe;
}

const char* semantics::print_type_annotation(const type_annotation& x) const
{
  switch(x)
  {
    case v_exists:
      return "E";
    case v_forall:
      return "A";
    case v_free:
      return "F";
    case v_stochastic:
      return "S";
  }
  // we must not get here
  return "";
}

type_annotation semantics::read_type_annotation(char c) const
{
  switch(c)
  {
    case 'A':
      return v_forall;
    case 'F':
      return v_free;
    case 'S':
      return v_stochastic;
  }
  return v_exists;
}

const char* semantics::print_activity_descr(const activity_descr& x) const
{
  switch(x)
  {
    case a_redundant:
      return "R";
    case a_active_lo:
      return "l";
    case a_active_lo_red:
      return "L";
    case a_active_hi:
      return "h";
    case a_active_hi_red:
      return "H";
    case a_active:
      return "a";
    case a_active_red:
      return "A";
  }
  // we must not get here
  return "";
}

activity_descr semantics::read_activity_descr(char c) const
{
  switch(c)
  {
    case 'A':
      return a_active_red;
    case 'H':
      return a_active_hi_red;
    case 'L':
      return a_active_lo_red;
    case 'R':
      return a_redundant;
    case 'a':
      return a_active;
    case 'h':
      return a_active_hi;
    case 'l':
      return a_active_lo;
  }
  return a_active;
}

void semantics::read(char *c)
{
  try
  {
    for(; c;)
    {
      char *ct;

      ct = strsep(&c, ",");
      ct += strspn(ct, " \t");
      switch(ct[0])
      {
        case 'C':
          if(ct[1] != '=')
            throw "malformed semantics C expression: `=' missing";
          property_flags.c_info.read(ct+2);
          break;
        case 'P':
          if(ct[1] != '=')
            throw "malformed semantics P expression: `=' missing";
          property_flags.separable = read_tristate(ct[2]);
          property_flags.act = read_activity_descr(ct[3]);
          property_flags.is_at_any_bound = (ct[4] == 'T' ? true : false);
          break;
        case 'N':
          if(ct[1] != '=')
            throw "malformed semantics N expression: `=' missing";
          annotation_flags.kj = (ct[2] == 'T' ? true : false);
          annotation_flags.integer = (ct[3] == 'T' ? true : false);
          annotation_flags.hard = (ct[4] == 'T' ? true : false);
          annotation_flags.type = read_type_annotation(ct[5]);
          break;
        case 'I':
          if(ct[1] != '=')
            throw "malformed semantics I expression: `=' missing";
          info_flags.has_0chnbase = read_tristate(ct[3]);
          break;
        case 'A':
          if(ct[1] != '=')
            throw "malformed semantics A expression: `=' missing";
          if(sscanf(ct+2, "%d", &addinfo) != 1)
            throw "malformed semantics A expression: no integer";
          break;
        case 'B':
          if(ct[1] != '=')
            throw "malformed semantics B expression: `=' missing";
          if(sscanf(ct+2, "%u", &_0chnbase) != 1)
            throw "malformed semantics B expression: no integer";
          break;
        case 'G':
          if(ct[1] != '=')
            throw "malformed semantics G expression: `=' missing";
          if(sscanf(ct+2, "%d", &degree) != 1)
            throw "malformed semantics G expression: no integer";
          break;
        case 'D':
          if(ct[1] != '=')
            throw "malformed semantics D expression: `=' missing";
          if(sscanf(ct+2, "%d", &dim) != 1)
            throw "malformed semantics D expression: no integer";
          break;
        case 'S':
          if(ct[1] != '=')
            throw "malformed semantics S expression: `=' missing";
          if(sscanf(ct+2, "%d", &stage) != 1)
            throw "malformed semantics S expression: no integer";
          break;
        default:
          throw "malformed semantics expression: wrong type";
          break;
      }
    }
  }
  catch(char *str)
  {
    std::cerr << "Error: " << str << std::endl;
    std::terminate();
  }
}

std::ostream& operator<< (std::ostream& o, const semantics& __s)
{
  o << "C=";
  o << __s.property_flags.c_info;
  o << ",P=";
  o << __s.print_tristate(__s.property_flags.separable);
  o << __s.print_activity_descr(__s.property_flags.act);
  o << (__s.property_flags.is_at_any_bound ? "T" : "F");
  o << ",N=";
  o << (__s.annotation_flags.kj ? "T" : "F");
  o << (__s.annotation_flags.integer ? "T" : "F");
  o << (__s.annotation_flags.hard ? "T" : "F");
  o << __s.print_type_annotation(__s.annotation_flags.type);
  o << ",I=";
  o << __s.print_tristate(__s.info_flags.has_0chnbase);
  o << ",A=" << __s.addinfo;
  o << ",B=" << __s._0chnbase;
  o << ",G=" << __s.degree;
  o << ",D=" << __s.dim;
  o << ",S=" << __s.stage;
  return o;
}

---