DynamicArray::DynamicArray(TypeSystem& typesys, DataType& elemType)
    : BaseType(make_name(typesys, elemType), typesys.word_size() * 2)
    , elemType_(&elemType)
    , wordSize_(typesys.word_size())
{
    typesys.manage(this);
}

void registerFunction(const string& name, RetT(*f)(ArgT0, ArgT1))
{
    TypeSystem* ts = TypeSystem::instance();
    IType *retT = CType2ScriptType<RetT>::get(ts);
    vector<IType*> argT = {CType2ScriptType<ArgT0>::get(ts), CType2ScriptType<ArgT1>::get(ts)};
    IType *ftype = ts->getFunc(retT, argT);
    SymbolTableManager::instance()->global()->addSymbol(name, ftype);
    CodeManager::instance()->registerFunction(name, FunctionPtr(new CFunction2<RetT, ArgT0, ArgT1>(f)));
}

void registerVarLengFunction(const string& name, CVarlengFunction::FuncT f)
{
    TypeSystem* ts = TypeSystem::instance();
    IType *retT = CType2ScriptType<int>::get(ts);
    vector<IType*> argT = {CType2ScriptType<const char*>::get(ts)};
    IType *ftype = ts->getFunc(retT, argT);
    dynamic_cast<FunctionType*>(ftype)->isVarLengOfArg = true;
    SymbolTableManager::instance()->global()->addSymbol(name, ftype);
    CodeManager::instance()->registerFunction(name, FunctionPtr(new CVarlengFunction(f)));
}

  TyErrorId typeSystemInit(TypeSystem const & crTypeSystem) {
    cout << "SofaExampleAnnotator::typeSystemInit()" << endl;

    // get Type and Feature objects for use in process()
    annot  = crTypeSystem.getType("uima.tcas.Annotation");
    cross  = crTypeSystem.getType("sofa.test.CrossAnnotation");
    other = cross.getFeatureByBaseName("otherAnnotation");
    if (!(annot.isValid() && cross.isValid() && other.isValid())) {
      cout << "SofaExampleAnnotator::typeSystemInit() - Error getting Type or Feature objects" << endl;
      return (TyErrorId)UIMA_ERR_RESMGR_INVALID_RESOURCE;
    }
    return(TyErrorId)UIMA_ERR_NONE;
  }

// === EDIT ===
// Edit type
void MainWindow::editType(){
    QVector<int> ids = utilities::getSelectedTableViewIds(ui->typesTable);

    // No rows or more than 1
    if (ids.size() != 1) {
        return;
    }

    // An empty person
    TypeSystem ts;
    // Set person ID to the ID of the row
    ts.setId(ids[0]);

    // Get the person info by ID
    if(!servicesLayer.getTypeSystem(ts, 1, error)){
        checkError();
        return;
    }

    // Edit dialog
    EditTypeSystemDialog editDialog;
    // Forward person to edit dialog
    editDialog.setName(ts.getName());
    // Set the fields
    editDialog.setFields();
    // Set title
    editDialog.setTitle("Edit Type");

    // If saved
    if (editDialog.exec()) {

        ts.setName(editDialog.getName());

        // If error, show error, else update table
        if (!servicesLayer.editTypeSystem(ts, 1, error)) {
            checkError();
            return;
        }
        else{
            checkTypeSearch();
            displayMachinesTable();
            displayConnectionsTable();
        }

        // Set status bar message
        ui->statusBar->showMessage(ts.getName() + " edited", constants::STATUSBAR_MESSAGE_TIME);

        // Disable Person edit and delete buttons
        disableEditDeleteTypeButtons();
    }
}

/**
 * Derive the name of the array type from the elements' type
 */
static RefPtr<SharedString>
make_name(TypeSystem& typesys, DataType& elemType)
{
    ostringstream buf;

    buf << elemType.name()->c_str() << "[]";
    return typesys.get_string(buf.str().c_str(), buf.str().length());
}

RetT callFromC(IFunction *func, RuntimeEnv* env)
{
    TypeSystem* ts = TypeSystem::instance();
    IType *retT = CType2ScriptType<RetT>::get(ts);
    vector<IType*> argT = {};
    IType *ftype = ts->getFunc(retT, argT);

    int retSize = retT->getSize();
    int retArgSize = retSize;
    env->pushValue(RetT());

    env->pushFrame(retArgSize);
    func->call(env);
    env->popFrame(retSize);

    RetT r;
    env->popValue(r);
    return r;
}

bool RemoveInterfacePass::is_leaf(const TypeSystem& type_system,
                                  const DexType* intf) {
  auto intf_children = type_system.get_interface_children(intf);
  size_t num_removed = 0;
  for (const auto child : intf_children) {
    if (m_removed_interfaces.count(child) > 0) {
      ++num_removed;
    }
  }
  return num_removed == intf_children.size();
}

		/*!
		* Initializes the typesystem types and features
		*/
		TyErrorId AnnotatorPerformanceAnnotation::initializeTypeSystem(TypeSystem const& crTypeSystem)
		{
			tAnnotatorPerformanceAnnotation = crTypeSystem.getType("org.gramlab.kwaga.unitex_uima.general.tcas.AnnotatorPerformanceAnnotation");
			if (!tAnnotatorPerformanceAnnotation.isValid())
				return (TyErrorId) UIMA_ERR_RESMGR_INVALID_RESOURCE;

			fComponentName = tAnnotatorPerformanceAnnotation.getFeatureByBaseName("componentName");
			fElapsedTime = tAnnotatorPerformanceAnnotation.getFeatureByBaseName("elapsedTime");

			return (TyErrorId) UIMA_ERR_NONE;
		}

		/*!
		 * Initializes the typesystem types and features
		 */
		TyErrorId SentenceAnnotation::initializeTypeSystem(TypeSystem const& crTypeSystem)
		{
			if (ContextAreaAnnotation::initializeTypeSystem(crTypeSystem) != UIMA_ERR_NONE)
				return (TyErrorId) UIMA_ERR_RESMGR_INVALID_RESOURCE;

			tSentenceAnnotation = crTypeSystem.getType("org.gramlab.kwaga.unitex_uima.unitex.tcas.SentenceAnnotation");
			if (!tSentenceAnnotation.isValid())
				return (TyErrorId) UIMA_ERR_RESMGR_INVALID_RESOURCE;

			fParagraph = tSentenceAnnotation.getFeatureByBaseName("paragraph");

			return (TyErrorId) UIMA_ERR_NONE;
		}

TypeSet RemoveInterfacePass::remove_leaf_interfaces(
    const Scope& scope,
    const DexType* root,
    const TypeSet& interfaces,
    const TypeSystem& type_system) {
  TypeSet leaf_interfaces;
  for (const auto intf : interfaces) {
    if (is_leaf(type_system, intf)) {
      leaf_interfaces.insert(intf);
    }
  }

  std::unordered_map<DexMethod*, DexMethod*> intf_meth_to_dispatch;
  for (const auto intf : leaf_interfaces) {
    TRACE(RM_INTF, 5, "Found leaf interface %s\n", SHOW(intf));
    auto implementors = type_system.get_implementors(intf);
    auto intf_methods = type_class(intf)->get_vmethods();
    for (const auto meth : intf_methods) {
      TRACE(RM_INTF, 5, "Finding virt scope for %s\n", SHOW(meth));
      auto intf_scope = type_system.find_interface_scope(meth);
      MethodOrderedSet found_targets =
          find_dispatch_targets(type_system, intf_scope, implementors);
      std::vector<DexMethod*> dispatch_targets(found_targets.begin(),
                                               found_targets.end());
      auto replacement_type = get_replacement_type(type_system, intf, root);
      auto dispatch =
          generate_dispatch(replacement_type, dispatch_targets, meth,
                            m_keep_debug_info, m_interface_dispatch_anno);
      m_dispatch_stats[dispatch_targets.size()]++;
      intf_meth_to_dispatch[meth] = dispatch;
    }
  }
  update_interface_calls(scope, intf_meth_to_dispatch);
  remove_inheritance(scope, type_system, leaf_interfaces);
  m_num_interface_removed += leaf_interfaces.size();
  return leaf_interfaces;
}

void RemoveInterfacePass::remove_inheritance(const Scope& scope,
                                             const TypeSystem& type_system,
                                             const TypeSet& interfaces) {
  for (const auto intf : interfaces) {
    always_assert(is_leaf(type_system, intf));
    auto impls = type_system.get_implementors(intf);
    for (const auto impl : impls) {
      TRACE(RM_INTF, 5, "Remove inheritance for %s on %s\n", SHOW(intf),
            SHOW(impl));
      auto new_impl_list = get_new_impl_list(impl, intf);
      type_class(impl)->set_interfaces(new_impl_list);
    }
    type_class(intf)->set_interfaces(DexTypeList::make_type_list({}));
  }
}

void RemoveInterfacePass::remove_interfaces_for_root(
    const Scope& scope,
    const DexStoresVector& stores,
    const DexType* root,
    const TypeSystem& type_system) {
  TRACE(RM_INTF, 5, "Processing root %s\n", SHOW(root));
  TypeSet interfaces;
  type_system.get_all_interface_children(root, interfaces);
  include_parent_interfaces(root, interfaces);

  m_total_num_interface += interfaces.size();
  m_num_interface_excluded += exclude_unremovables(
      scope, stores, type_system, m_skip_multiple_targets_roots,
      m_include_primary_dex, interfaces);

  TRACE(RM_INTF, 5, "removable interfaces %ld\n", interfaces.size());
  TypeSet removed =
      remove_leaf_interfaces(scope, root, interfaces, type_system);

  while (removed.size() > 0) {
    for (const auto intf : removed) {
      interfaces.erase(intf);
      m_removed_interfaces.insert(intf);
    }
    TRACE(RM_INTF, 5, "non-leaf removable interfaces %ld\n", interfaces.size());
    removed = remove_leaf_interfaces(scope, root, interfaces, type_system);
  }

  // Update type reference to removed interfaces all at once.
  remove_interface_references(scope, type_system, root, m_removed_interfaces);

  if (traceEnabled(RM_INTF, 9)) {
    TypeSystem updated_ts(scope);
    for (const auto intf : interfaces) {
      TRACE(RM_INTF, 9, "unremoved interface %s\n", SHOW(intf));
      TypeSet children;
      updated_ts.get_all_interface_children(intf, children);
      for (const auto cintf : children) {
        TRACE(RM_INTF, 9, "  child %s\n", SHOW(cintf));
      }
    }
  }
}

 TyErrorId typeSystemInit(TypeSystem const & crTypeSystem) {
   cout << "SofaDataAnnotator: typeSystemInit()" << endl;
   annot  = crTypeSystem.getType("uima.tcas.Annotation");
   return(TyErrorId)UIMA_ERR_NONE;
 }

 /*static*/
 void
 CapabilityContainer::initTypeOrFeatures(
   TyMapLang2TypeOrFeatures & rMap, // output argument
   Capability::TyVecCapabilityTofs const & vecTofs,
   Capability::TyVecCapabilityLanguages const & vecLangs,
   TypeSystem const & typeSystem) {
   const int BUF_SIZE = 0x100;
   char  cBuf[BUF_SIZE];
   Capability::TyVecCapabilityLanguages::const_iterator itLang;
   for (itLang = vecLangs.begin(); itLang != vecLangs.end(); ++itLang) {
     // convert unicode lang string to single-byte lang string
     assert((*itLang).length() < BUF_SIZE);
     // Note: this conversion can be used only for invariant characters
     u_UCharsToChars((*itLang).getBuffer(), cBuf, (*itLang).length());
     // zero terminate single-byte buffer
     cBuf[(*itLang).length()] = '\0';
     // Special workaround code for the new way to specify the unspecified language
     if (strcasecmp(cBuf, "x-unspecified") == 0) {
       strcpy(cBuf, Language::UNSPECIFIED);
     }
     // create a language object based on single-byte lang string
     Language lang(cBuf);
     if (!lang.isValid()) {
       /* taph 06.02.2003: once we have more detailed information about
       the origin of the error we need to replace "unknown configuration file"
       with the filename of the XML file (and maybe line number?) */
       UIMA_EXC_THROW_NEW(uima::CapabilityException,          // exc-type
                          UIMA_ERR_ENGINE_LANGUAGE_INVALID,   // error code
                          ErrorMessage(UIMA_MSG_ID_EXC_INVALID_LANGUAGE, cBuf), // error message
                          ErrorMessage(UIMA_MSG_ID_EXCON_CHECKING_CAPABILITY_SPEC,"unknown configuration file"),  // error context message
                          ErrorInfo::recoverable);
     }
     // create a new empty vector in the map for this lang
     TySetTypeOrFeatures & setTofs = rMap[lang];
     // now fill the vector with tof objects created from tof strings
     Capability::TyVecCapabilityTofs::const_iterator itTof;
     for (itTof = vecTofs.begin(); itTof != vecTofs.end(); ++itTof) {
       TypeOrFeature tof;
       // the tof string may be a type...
       Type t = typeSystem.getType(*itTof);
       if (t.isValid()) {
         tof = TypeOrFeature(t);
       } else {
         // or the tof string may be a feature
         Feature f = typeSystem.getFeatureByFullName(*itTof);
         if (f.isValid()) {
           tof = TypeOrFeature(f);
         } else {
           /* taph 06.02.2003: once we have more detailed information about
           the origin of the error we need to replace "unknown configuration file"
           with the filename of the XML file (and maybe line number?) */
           if (tof.isType()) {
             UIMA_EXC_THROW_NEW(uima::CapabilityException,        // exc-type
                                UIMA_ERR_INVALID_FSTYPE_OBJECT,   // error code
                                ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_TYPE_NAME, *itTof), // error message
                                ErrorMessage(UIMA_MSG_ID_EXCON_CHECKING_CAPABILITY_SPEC, "unknown configuration file"),  // error context message
                                ErrorInfo::recoverable);
           } else {
             UIMA_EXC_THROW_NEW(uima::CapabilityException,        // exc-type
                                UIMA_ERR_INVALID_FSFEATURE_OBJECT,// error code
                                ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_FEATURE_NAME, *itTof), // error message
                                ErrorMessage(UIMA_MSG_ID_EXCON_CHECKING_CAPABILITY_SPEC, "unknown configuration file"),  // error context message
                                ErrorInfo::recoverable);
           }
         }
       }
       assert(tof.isValid());
       setTofs.insert(tof);
     } // for all tof strings
   } // for all lang strings
 }