FPge_expr::FPge_expr(Target* _target, int wE, int wF) :
         Operator(_target) {

      ostringstream name;

      name<<"FPge_expr_" <<wE<<"_"<<wF;
      setName(name.str());

      setCopyrightString("Fabrizio Ferrandi (2011-2017)");

      /* Set up the IO signals */

      addFPInput ("X", wE,wF);
      addFPInput ("Y", wE,wF);
      addOutput ("R", 1);

      /*	VHDL code description	*/
      manageCriticalPath(_target->localWireDelay() + _target->lutDelay());
      vhdl << tab << declare("nY",wE+wF+3) << "  <= Y"<< range(wE+wF+2,wE+wF+1) << " & not(Y"<< of(wE+wF) << ") & Y" << range(wE+wF-1,0) << ";" << endl;
      FPAdderSinglePath * value_difference = new FPAdderSinglePath(_target, wE, wF, wE, wF, wE, wF);
      value_difference->changeName(getName()+"value_difference");
      oplist.push_back(value_difference);
      inPortMap  (value_difference, "X", "X");
      inPortMap  (value_difference, "Y", "nY");
      outPortMap (value_difference, "R","valueDiff");
      vhdl << instance(value_difference, "value_difference");
      syncCycleFromSignal("valueDiff");
      setCriticalPath(value_difference->getOutputDelay("R"));

      manageCriticalPath(_target->localWireDelay() + _target->lutDelay());
      vhdl << tab << "R(0) <=   '1' when (valueDiff" << of(wE+wF) << "='0' or (valueDiff" << range(wE+wF+2,wE+wF+1) << " = \"00\")) else '0';" << endl;
   }

Decl&
Parser::on_type_template_parameter(Name& n)
{
  Decl& parm = build.make_type_parameter(n);
  declare(cxt, current_scope(), parm);
  return parm;
}

// Create a saved scope for the function body and add the parameters 
// to it. This will allow parameter names to be looked up during
// subsequent elaboration. Note that name hiding will also be diagnosed
// later.
static void
declare_parms(Context& cxt, Term& t, Decl_list& parms)
{
  Enter_scope scope(cxt, cxt.saved_scope(t));
  for (Decl& p : parms)
    declare(cxt, p);
}

DeclarationNode::DeclarationNode(DeclarationSpecifiersNode* declSpecifier , SymbolTable* _table)
	: declSpecifier(declSpecifier)
{

	declare(_table);

	nodeData = toOperations();
}

Decl&
Parser::on_class_declaration(Name& n, Type& t, Stmt& s)
{

  Decl& d = build.make_class_declaration(n, t, s);
  declare(cxt, current_scope(), d);
  return d;
}

// Add the declaration d to the given scope.
void
declare(Context& cxt, Scope& scope, Decl& decl)
{
  if (Overload_set* ovl = scope.lookup(decl.name()))
    declare(cxt, *ovl, decl);
  else
    scope.bind(decl);
}

// Called just prior to analyzing the definition, declare all of the
// parameters into the saved function scope.
Decl&
Parser::enter_function_declaration(Decl& d)
{
  Function_decl& fn = cast<Function_decl>(d);
  for (Decl& p : fn.parameters())
    declare(cxt, p);
  return d;
}

declist()
{
	extern peeksym, peekc, csym[], cval;
	auto o;

	while((o=symbol())==19 & cval<10)
		declare(cval);
	peeksym = o;
}

void
declare_functions(node_t* node){
    //The only possible child.
    node_t* functionlist = node->children[0];
    for(int i = 0;i < functionlist->n_children; i++){
        node_t* function = functionlist->children[i];
        declare(function->children[0],0,TRUE);
    }
}

ste *symboltable::lookup(lexid * name)
{
  ste *p = find(name);
  if (p == NULL) {
    Error.Error("%s undeclared.", name->getname());
    p = declare(name, errordecl);
  }
  return (p);
}

  void Interpreter::enableDynamicLookup(bool value /*=true*/) {
    m_DynamicLookupEnabled = value;

    if (isDynamicLookupEnabled()) {
     if (loadModuleForHeader("cling/Interpreter/DynamicLookupRuntimeUniverse.h")
         != kSuccess)
      declare("#include \"cling/Interpreter/DynamicLookupRuntimeUniverse.h\"");
    }
  }

PUBLIC void init_type(void)
{
     void_type = prim_type("void");
     char_type = prim_type("char");
     int_type = prim_type("integer");
     bool_type = prim_type("boolean");
     scalar_type = prim_type("*scalar*");
     string_type = prim_type("*string*");
     text_type = prim_type("text");
     err_type = prim_type("*err_type*");

     def_const("true", bool_type, "TRUE");
     def_const("false", bool_type, "FALSE");
     dummy_def = def_const("*dummy*", err_type, "");

     _input_ = declare(VAR, enter("input", BUILTIN), text_type);
     _output_ = declare(VAR, enter("output", BUILTIN), text_type);
}

void ParseGlobalDeclarations()
{
	funcdecl = FALSE;
    for(;;) {
		switch(lastst) {
		case id:
		case kw_interrupt:
		case kw_pascal:
		case kw_nocall:
		case kw_oscall:
		case kw_typedef:
		case kw_byte: case kw_char: case kw_int: case kw_short: case kw_unsigned: case kw_signed:
        case kw_long: case kw_struct: case kw_union:
        case kw_enum: case kw_void:
        case kw_float: case kw_double:
                lc_static += declare(&gsyms,sc_global,lc_static,bt_struct);
				break;
		case kw_register:
				NextToken();
                error(ERR_ILLCLASS);
                lc_static += declare(&gsyms,sc_global,lc_static,bt_struct);
				break;
		case kw_private:
        case kw_static:
                NextToken();
				lc_static += declare(&gsyms,sc_static,lc_static,bt_struct);
                break;
        case kw_extern:
                NextToken();
				if (lastst==kw_pascal) {
					isPascal = TRUE;
					NextToken();
				}
				else if (lastst==kw_oscall || lastst==kw_interrupt || lastst==kw_nocall)
					NextToken();
                ++global_flag;
                declare(&gsyms,sc_external,0,bt_struct);
                --global_flag;
                break;
        default:
                return;
		}
	}
}

PRIVATE type prim_type(char *name)
{
     ident sym = enter(name, BUILTIN);
     type p = alloc_type();

     p->x_kind = PRIMTYPE;
     p->x_name = sym;
     declare(TYPE, sym, p);
     return p;
}     

 NodePtr elem()
 {
     NodePtr e = simpleelem();
     if (e != NULL) return e;
     if (e = comment()) return e;
     if (e = declare()) return e;
     if (e = text()) return e;
     if (e = fullelem()) return e;
     return e;
 }

void ParseStructMembers(TYP *tp, int ztype)
{
    int slc;

    slc = 0;
    tp->val_flag = 1;
//	tp->val_flag = FALSE;
    while( lastst != end) {
        if(ztype == bt_struct)
            slc += declare(&(tp->lst),sc_member,slc,ztype);
        else
            slc = imax(slc,declare(&tp->lst,sc_member,0,ztype));
    }
    bit_offset = 0;
    bit_next = 0;
    bit_width = -1;
    tp->size = tp->alignment ? tp->alignment : slc;
    NextToken();
}

/********************
  class symboltable
  ********************/
symboltable::symboltable()
{
  constdecl *temp;
  int i = 0;
  for (i = 0; i < MAXSCOPES; i++) {
    scopes[i] = 0;
    scopestack[i] = NULL;
  }
  curscope = 0;
  scopedepth = 0;

  /* enter useful stuff. */
  declare(ltable.enter("boolean"), booltype);
  temp = new constdecl(1, booltype);
  declare(ltable.enter("true"), temp);
  temp = new constdecl(0, booltype);
  declare(ltable.enter("false"), temp);
  ::offset = 0;
}

//Recursivly walk a tree looking for VARIABLE nodes
int32_t
declare_tree(node_t *node){
    if(node->type.index == VARIABLE){
        declare(node,next_stack_offset, FALSE);   
        next_stack_offset -= 4;
    }
    for(int i = 0; i < node->n_children; i++){
        node_t* child = node->children[i];
        declare_tree(child); 
    }
}

Decl&
Parser::on_variable_declaration(Name& n, Type& t, Def& d)
{
  Decl* ret;
  if (parsing_nonstatic_member())
    ret = &cxt.make_field_declaration(n, t, d);
  else
    ret = &cxt.make_variable_declaration(n, t, d);
  ret->spec_ = take_decl_specs();
  declare(cxt, *ret);
  return *ret;
}

CSMPrefs::State::State (const Files::ConfigurationManager& configurationManager)
: mConfigFile ("openmw-cs.cfg"), mConfigurationManager (configurationManager),
  mCurrentCategory (mCategories.end())
{
    if (sThis)
        throw std::logic_error ("An instance of CSMPRefs::State already exists");

    load();
    declare();

    sThis = this;
}