/*---------------------------------------------------------------------------------------------------------------------- | Called when an error is encountered in a NEXUS file. Allows program to give user details of the error as well as | the precise location of the error. */ void GarliReader::NexusError( NxsString msg, /* the error message */ file_pos , /* the point in the NEXUS file where the error occurred */ long line, /* the line in the NEXUS file where the error occurred */ long col, /* the column in the NEXUS file where the error occurred */ bool throwExcept /*=true*/) /* whether to throw an actual exception or just output the error message */ { message = "\n"; message += msg; PrintMessage(); if (1) { message = "Line: "; message += line; PrintMessage(); message = "Column: "; message += col; PrintMessage(); } if(throwExcept) throw ErrorException("NCL encountered a problem reading the dataset."); }
void AminoacidData::CreateMatrixFromNCL(GarliReader &reader){ NxsCharactersBlock *charblock; int num=0, numNuc = -1; do{ charblock = reader.GetCharactersBlock(num); if(charblock->GetDataType() == NxsCharactersBlock::protein){ if(numNuc < 0) numNuc = num; else{ throw ErrorException("Multiple characters/data blocks containing protein data found in Nexus datafile!\n\tEither combine the blocks or comment one out."); } } else outman.UserMessage("Ignoring non-protein characters block from Nexus datafile"); num++; }while(num < reader.NumCharBlocks()); if(numNuc < 0) throw ErrorException("No characters/data blocks containing protein data found in Nexus datafile!"); charblock = reader.GetCharactersBlock(numNuc); if(charblock->GetNumActiveChar() < charblock->GetNChar()){ outman.UserMessageNoCR("Excluded characters:\n\t"); for(int c=0;c<charblock->GetNCharTotal();c++) if(charblock->IsExcluded(c)) outman.UserMessageNoCR("%d ", c+1); outman.UserMessage(""); } // vector<unsigned> reducedToOrigCharMap = charblock->GetOrigIndexVector(); NxsTaxaBlock *taxablock = reader.GetTaxaBlock(); int numOrigTaxa = charblock->GetNTax(); int numActiveTaxa = charblock->GetNumActiveTaxa(); int numOrigChar = charblock->GetNChar(); int numActiveChar = charblock->GetNumActiveChar(); //int num_chars = reducedToOrigCharMap.size(); //cout << num_chars << endl; NewMatrix( numActiveTaxa, numActiveChar ); // read in the data, including taxon names int i=0; for( int origTaxIndex = 0; origTaxIndex < numOrigTaxa; origTaxIndex++ ) { if(charblock->IsActiveTaxon(origTaxIndex)){ //internally, blanks in taxon names will be stored as underscores NxsString tlabel = taxablock->GetTaxonLabel(origTaxIndex); tlabel.BlanksToUnderscores(); SetTaxonLabel( i, tlabel.c_str()); int j = 0; bool firstAmbig = true; for( int origIndex = 0; origIndex < numOrigChar; origIndex++ ) { if(charblock->IsActiveChar(origIndex)){ unsigned char datum = '\0'; if(charblock->IsGapState(origTaxIndex, origIndex) == true) datum = 20; else if(charblock->IsMissingState(origTaxIndex, origIndex) == true) datum = 20; else{ int nstates = charblock->GetNumStates(origTaxIndex, origIndex); //assert(nstates == 1); //need to deal with the possibility of multiple states represented in matrix //just convert to full ambiguity if(nstates == 1) datum = CharToDatum(charblock->GetState(origTaxIndex, origIndex, 0)); else{ if(firstAmbig){ outman.UserMessageNoCR("Partially ambiguous characters of taxon %s converted to full ambiguity:\n\t", TaxonLabel(origTaxIndex)); firstAmbig = false; } outman.UserMessageNoCR("%d ", origIndex+1); datum = CharToDatum('?'); } } SetMatrix( i, j++, datum ); } } if(firstAmbig == false) outman.UserMessage(""); i++; } } }
void Globals::Globals_Init() { if (SDL_Init(SDL_INIT_EVERYTHING) < 0) { throw ErrorException(SDL_GetError()); } screen = SDL_SetVideoMode(800, 600, 32, SDL_SWSURFACE | SDL_DOUBLEBUF); }
bool DisjunctiveCombinationProcessor::next() { if (index < 0) { init(); index = 0; } size_t size = inputs.size(); if (!dimCount || !size) { return false; } bool hasNext = false; while (index < (int)size) { if (pos[index] == (int32_t)dimCount) { if (first[index]) { hasNext = true; first[index] = false; } else { hasNext = inputs[index]->next(); if (!hasNext) { throw ErrorException(ErrorException::ERROR_INTERNAL, "internal error in DisjunctiveCombinationProcessor::next!"); } } pos[index]--; break; } int32_t iDim; for (iDim = (int32_t)dimCount - 1; iDim >= 0; iDim--) { counter[index][iDim]++; if (counter[index][iDim] < setSize[iDim]) { break; } } pos[index] = iDim; if (iDim < 0) { // all keys from this stream are already returned index++; } else { if (index >= (int)firstDiff.size() || iDim > (int)firstDiff[index]) { // there is a set after firstDiff -> go back, if it is possible, otherwise continue with the same stream int i; for (i = index; i >= 0; i--) { if (index >= (int)firstDiff.size()) { if (pos[i] == -1) { break; } else if (i && pos[i] > pos[i - 1]) { // continue with the same stream i--; break; } } else { if (pos[i] < (int32_t)firstDiff[index]) { break; } else if (i && pos[i] > pos[i - 1]) { // continue with the same stream i--; break; } } } for (int j = i + 1; j <= index; j++) { for (size_t k = pos[j] + 1; k < dimCount; k++) { counter[j][k] = 0; } pos[j] = (int32_t)dimCount; } index = i + 1; } else { // there is a set before firstDiff -> check the next stream index++; } } } return hasNext; }
bool FileUtils::copyFile(const std::string& fromFile, const std::string &toFile) { throw ErrorException(ErrorException::ERROR_COPY_FAILED, "file copy not implemented"); // return true; }
//DJZ this is my function, replacing an old one that appeared in funcs.cpp //simpler now, since it uses NxsMultiFormatReader bool GarliReader::ReadData(const char* filename, const ModelSpecification &modspec){ //first use a few of my crappy functions to try to diagnose the type of file and data //then call the NxsMultiFormatReader functions to process it if (!FileExists(filename)) { throw ErrorException("data file not found: %s!", filename); } //if it is Nexus, don't need to specify anything else in advance if(FileIsNexus(filename)){ outman.UserMessage("Attempting to read data file in Nexus format (using NCL):\n\t%s ...", filename); ReadFilepath(filename, NEXUS_FORMAT); } else{//if this isn't nexus we'll try a bunch of formats to see if we can get something to work //the idea here is that we create an ordered list of formats to try, then we try them typedef pair<MultiFormatReader::DataFormatType, NxsString> FormatPair; list<FormatPair> formatsToTry; NxsString name; if(FileIsFasta(filename)){ if(modspec.IsAminoAcid()){ formatsToTry.push_back(FormatPair(FASTA_AA_FORMAT, "Fasta amino acid")); } else{ if(modSpec.IsRna() == false) formatsToTry.push_back(FormatPair(FASTA_DNA_FORMAT, "Fasta DNA")); formatsToTry.push_back(FormatPair(FASTA_RNA_FORMAT, "Fasta RNA")); } } else{//otherwise assume phylip format if(modSpec.IsAminoAcid()){ formatsToTry.push_back(FormatPair(RELAXED_PHYLIP_AA_FORMAT, "relaxed Phylip amino acid")); formatsToTry.push_back(FormatPair(INTERLEAVED_RELAXED_PHYLIP_AA_FORMAT, "interleaved relaxed Phylip amino acid")); formatsToTry.push_back(FormatPair(PHYLIP_AA_FORMAT, "strict Phylip amino acid")); formatsToTry.push_back(FormatPair(INTERLEAVED_PHYLIP_AA_FORMAT, "interleaved strict Phylip amino acid")); } else{ if(modSpec.IsRna() == false){ formatsToTry.push_back(FormatPair(RELAXED_PHYLIP_DNA_FORMAT, "relaxed Phylip DNA")); formatsToTry.push_back(FormatPair(INTERLEAVED_RELAXED_PHYLIP_DNA_FORMAT, "interleaved relaxed Phylip DNA")); formatsToTry.push_back(FormatPair(PHYLIP_DNA_FORMAT, "strict Phylip DNA")); formatsToTry.push_back(FormatPair(INTERLEAVED_PHYLIP_DNA_FORMAT, "interleaved strict Phylip DNA")); } formatsToTry.push_back(FormatPair(RELAXED_PHYLIP_RNA_FORMAT, "relaxed Phylip RNA")); formatsToTry.push_back(FormatPair(INTERLEAVED_RELAXED_PHYLIP_RNA_FORMAT, "interleaved relaxed Phylip RNA")); formatsToTry.push_back(FormatPair(PHYLIP_RNA_FORMAT, "strict Phylip RNA")); formatsToTry.push_back(FormatPair(INTERLEAVED_PHYLIP_RNA_FORMAT, "interleaved strict Phylip RNA")); } } //now start trying formats bool success; for(list<FormatPair>::iterator formIt = formatsToTry.begin();formIt != formatsToTry.end();formIt++){ success = true; try{ outman.UserMessage("Attempting to read data file %s as\n\t%s format (using NCL) ...", filename, (*formIt).second.c_str()); ReadFilepath(filename, (*formIt).first); }catch(NxsException err){ NexusError(err.msg, err.pos, err.line, err.col, false); outman.UserMessage("Problem reading data file as %s format...\n", (*formIt).second.c_str()); success = false; } if(success) break; } if(success == false) throw ErrorException("\nUnable to read data file %s in any format.\n", filename); else outman.UserMessage("\nData read successfully."); } return true; }
SEM::TypeInstance* AddTypeInstance(Context& context, const AST::Node<AST::TypeInstance>& astTypeInstanceNode, const SEM::ModuleScope& moduleScope) { const auto parentNamespace = context.scopeStack().back().nameSpace(); const auto& typeInstanceName = astTypeInstanceNode->name; const Name fullTypeName = parentNamespace->name() + typeInstanceName; // Check if there's anything with the same name. const auto iterator = parentNamespace->items().find(typeInstanceName); if (iterator != parentNamespace->items().end()) { const auto& existingTypeInstance = iterator->second.typeInstance(); const auto& debugInfo = *(existingTypeInstance.debugInfo()); throw ErrorException(makeString("Type instance name '%s', at position %s, clashes with existing name, at position %s.", fullTypeName.toString().c_str(), astTypeInstanceNode.location().toString().c_str(), debugInfo.location.toString().c_str())); } const auto typeInstanceKind = ConvertTypeInstanceKind(astTypeInstanceNode->kind); // Create a placeholder type instance. std::unique_ptr<SEM::TypeInstance> semTypeInstance(new SEM::TypeInstance(context.semContext(), fullTypeName.copy(), typeInstanceKind, moduleScope.copy())); if (semTypeInstance->isPrimitive()) { semTypeInstance->setPrimitiveID(context.sharedMaps().primitiveIDMap().getPrimitiveID(typeInstanceName)); } switch (moduleScope.kind()) { case SEM::ModuleScope::INTERNAL: { if (semTypeInstance->isClassDecl()) { throw ErrorException(makeString("Definition required for internal class '%s', at location %s.", fullTypeName.toString().c_str(), astTypeInstanceNode.location().toString().c_str())); } break; } case SEM::ModuleScope::IMPORT: { if (semTypeInstance->isClassDef()) { throw ErrorException(makeString("Implementation not allowed of imported class '%s', at location %s.", fullTypeName.toString().c_str(), astTypeInstanceNode.location().toString().c_str())); } break; } case SEM::ModuleScope::EXPORT: { if (semTypeInstance->isClassDecl()) { throw ErrorException(makeString("Definition required for exported class '%s', at location %s.", fullTypeName.toString().c_str(), astTypeInstanceNode.location().toString().c_str())); } break; } } semTypeInstance->setDebugInfo(Debug::TypeInstanceInfo(astTypeInstanceNode.location())); // Add template variables. size_t templateVarIndex = 0; for (const auto& astTemplateVarNode: *(astTypeInstanceNode->templateVariables)) { const auto& templateVarName = astTemplateVarNode->name; // TODO! const bool isVirtual = (typeInstanceName == "__ref"); const auto semTemplateVar = new SEM::TemplateVar(context.semContext(), fullTypeName + templateVarName, templateVarIndex++, isVirtual); const auto templateVarIterator = semTypeInstance->namedTemplateVariables().find(templateVarName); if (templateVarIterator != semTypeInstance->namedTemplateVariables().end()) { throw ErrorException(makeString("More than one template variable shares name '%s' in type '%s', at location %s.", templateVarName.c_str(), fullTypeName.toString().c_str(), astTemplateVarNode.location().toString().c_str())); } semTemplateVar->setDebugInfo(makeTemplateVarInfo(astTemplateVarNode)); semTypeInstance->templateVariables().push_back(semTemplateVar); semTypeInstance->namedTemplateVariables().insert(std::make_pair(templateVarName, semTemplateVar)); } if (semTypeInstance->isUnionDatatype()) { for (auto& astVariantNode: *(astTypeInstanceNode->variants)) { const auto variantTypeInstance = AddTypeInstance(context, astVariantNode, moduleScope); variantTypeInstance->setParent(semTypeInstance.get()); variantTypeInstance->templateVariables() = semTypeInstance->templateVariables().copy(); variantTypeInstance->namedTemplateVariables() = semTypeInstance->namedTemplateVariables().copy(); semTypeInstance->variants().push_back(variantTypeInstance); } } if (!astTypeInstanceNode->noTagSet.isNull()) { SEM::TemplateVarArray noTagSet; for (const auto& astNoTagName: *(astTypeInstanceNode->noTagSet)) { const auto templateVarIterator = semTypeInstance->namedTemplateVariables().find(astNoTagName); if (templateVarIterator == semTypeInstance->namedTemplateVariables().end()) { throw ErrorException(makeString("Can't find template variable '%s' in notag() set in type '%s', at location %s.", astNoTagName.c_str(), fullTypeName.toString().c_str(), astTypeInstanceNode->noTagSet.location().toString().c_str())); } noTagSet.push_back(templateVarIterator->second); } semTypeInstance->setNoTagSet(std::move(noTagSet)); } const auto typeInstancePtr = semTypeInstance.get(); parentNamespace->items().insert(std::make_pair(typeInstanceName, SEM::NamespaceItem::TypeInstance(std::move(semTypeInstance)))); return typeInstancePtr; }
void error(std::string msg) { throw ErrorException(msg); }
void LegacyRule::reset() { vkey.clear(); throw ErrorException(ErrorException::ERROR_INTERNAL, "No reset for LegacyRule!"); }
void LegacyRule::setValue(const CellValue &value) { throw ErrorException(ErrorException::ERROR_INTERNAL, "No setValue for LegacyRule"); }
void Error(const char* text) { mprintf(("\n%s\n", text)); if (Cmdline_noninteractive) { abort(); return; } if (running_unittests) { throw ErrorException(text); } SCP_stringstream messageStream; messageStream << text << "\n"; messageStream << dump_stacktrace(); SCP_string fullText = messageStream.str(); set_clipboard_text(fullText.c_str()); fullText = truncateLines(messageStream, Messagebox_lines); fullText += "\n[ This info is in the clipboard so you can paste it somewhere now ]\n"; fullText += "\n\nUse Debug to break into Debugger, Exit will close the application.\n"; const SDL_MessageBoxButtonData buttons[] = { { SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 1, "Exit" }, { /* .flags, .buttonid, .text */ 0, 0, "Debug" }, }; SDL_MessageBoxData boxData; memset(&boxData, 0, sizeof(boxData)); boxData.buttons = buttons; boxData.numbuttons = 2; boxData.colorScheme = nullptr; boxData.flags = SDL_MESSAGEBOX_ERROR; boxData.message = text; boxData.title = "Error!"; boxData.window = os::getSDLMainWindow(); gr_activate(0); int buttonId; if (SDL_ShowMessageBox(&boxData, &buttonId) < 0) { // Call failed exit(1); } switch (buttonId) { case 1: exit(1); default: Int3(); break; } gr_activate(1); }
const GpuBinPath &SessionInfoProcessor::getBinKey() const { throw ErrorException(ErrorException::ERROR_INTERNAL, "SessionInfoProcessor::getBinKey not implemented"); }
void SessionInfoProcessor::setValue(const CellValue &value) { throw ErrorException(ErrorException::ERROR_INTERNAL, "SessionInfoProcessor::setValue not implemented"); }
double SessionInfoProcessor::getDouble() { throw ErrorException(ErrorException::ERROR_INTERNAL, "SessionInfoProcessor::getDouble not implemented"); }
void error(std::string str) { throw ErrorException(str); }
SEM::Value GetTemplatedMethodWithoutResolution(Context& context, SEM::Value value, const SEM::Type* const type, const String& methodName, SEM::ValueArray templateArguments, const Debug::SourceLocation& location) { assert(value.type()->isRef() && value.type()->isBuiltInReference()); if (!type->isObjectOrTemplateVar()) { throw ErrorException(makeString("Cannot get method '%s' for non-object type '%s' at position %s.", methodName.c_str(), type->toString().c_str(), location.toString().c_str())); } const auto methodSet = getTypeMethodSet(context, type); const auto& objectConstPredicate = methodSet->constPredicate(); const auto canonicalMethodName = CanonicalizeMethodName(methodName); const auto methodIterator = methodSet->find(canonicalMethodName); if (methodIterator == methodSet->end()) { throw ErrorException(makeString("Cannot find method '%s' for type '%s' at position %s.", methodName.c_str(), type->toString().c_str(), location.toString().c_str())); } const auto& methodElement = methodIterator->second; if (methodElement.isStatic()) { throw ErrorException(makeString("Cannot access static method '%s' for value of type '%s' at position %s.", methodName.c_str(), type->toString().c_str(), location.toString().c_str())); } auto templateVariableAssignments = type->generateTemplateVarMap(); const auto function = type->isObject() ? type->getObjectType()->functions().at(canonicalMethodName).get() : nullptr; if (function != nullptr) { const auto& templateVariables = function->templateVariables(); if (templateVariables.size() != templateArguments.size()) { // Try to apply some basic deduction... if (templateVariables.size() == 1 && templateArguments.size() == 0 && function->constPredicate().isVariable() && function->constPredicate().variableTemplateVar() == templateVariables[0] ) { const auto boolType = getBuiltInType(context, context.getCString("bool"), {}); templateArguments.push_back(SEM::Value::PredicateExpr(objectConstPredicate.copy(), boolType)); } else { throw ErrorException(makeString("Incorrect number of template " "arguments provided for method '%s'; %llu were required, " "but %llu were provided at position %s.", function->name().toString().c_str(), (unsigned long long) templateVariables.size(), (unsigned long long) templateArguments.size(), location.toString().c_str())); } } // Add function template variable => argument mapping. for (size_t i = 0; i < templateArguments.size(); i++) { const auto templateVariable = templateVariables.at(i); const auto& templateValue = templateArguments.at(i); if (templateValue.isTypeRef()) { const auto templateTypeValue = templateValue.typeRefType()->resolveAliases(); if (!templateTypeValue->isObjectOrTemplateVar() || templateTypeValue->isInterface()) { throw ErrorException(makeString("Invalid type '%s' passed " "as template parameter '%s' for method '%s' at position %s.", templateTypeValue->toString().c_str(), templateVariable->name().toString().c_str(), function->name().toString().c_str(), location.toString().c_str())); } templateVariableAssignments.insert(std::make_pair(templateVariable, SEM::Value::TypeRef(templateTypeValue, templateValue.type()))); } else { templateVariableAssignments.insert(std::make_pair(templateVariable, templateValue.copy())); } } } else { assert(templateArguments.empty()); } const auto methodConstPredicate = methodElement.constPredicate().substitute(templateVariableAssignments); if (!objectConstPredicate.implies(methodConstPredicate)) { throw ErrorException(makeString("Cannot refer to mutator method '%s' from const object of type '%s' at position %s.", methodName.c_str(), type->toString().c_str(), location.toString().c_str())); } // Now check the template arguments satisfy the requires predicate. const auto& requirePredicate = methodElement.requirePredicate(); // Conservatively assume require predicate is not satisified if result is undetermined. const bool satisfiesRequireDefault = false; if (!evaluatePredicateWithDefault(context, requirePredicate, templateVariableAssignments, satisfiesRequireDefault)) { throw ErrorException(makeString("Template arguments do not satisfy " "require predicate '%s' of method '%s' at position %s.", requirePredicate.substitute(templateVariableAssignments).toString().c_str(), methodName.c_str(), location.toString().c_str())); } if (function != nullptr) { const auto functionType = simplifyFunctionType(context, function->type().substitute(templateVariableAssignments)); const auto functionRefType = createFunctionPointerType(context, functionType); auto functionRef = addDebugInfo(SEM::Value::FunctionRef(type, function, std::move(templateArguments), functionRefType), location); if (type->isInterface()) { const auto interfaceMethodType = createInterfaceMethodType(context, functionType); return addDebugInfo(SEM::Value::InterfaceMethodObject(std::move(functionRef), std::move(value), interfaceMethodType), location); } else { const auto methodType = createMethodType(context, functionType); return addDebugInfo(SEM::Value::MethodObject(std::move(functionRef), std::move(value), methodType), location); } } else { const bool isTemplated = true; const auto functionType = methodElement.createFunctionType(isTemplated); const auto functionRefType = createFunctionPointerType(context, functionType); auto functionRef = addDebugInfo(SEM::Value::TemplateFunctionRef(type, methodName, functionRefType), location); const auto methodType = createMethodType(context, functionType); return addDebugInfo(SEM::Value::MethodObject(std::move(functionRef), std::move(value), methodType), location); } }
int MPIMain(int argc, char** argv) { MPI_Init(&argc, &argv); int rank, nprocs; MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); bool poo=true; //if(rank==0) while (poo) ; try{ if (rank == 0) { MasterGamlConfig conf; int err=conf.Read("garli.conf", true); if(err != 0){ throw ErrorException("Error in config file (Master)...aborting."); } LogConfig(conf); // Create the data object HKYData data; ReadData(conf.datafname.c_str(), &data); // start the remote nodes going... StartProcs(conf, data); // start yourself! MasterMaster(conf, data); } else { // rank != 0 int from, tag, size; char* buf; HKYData data; GeneralGamlConfig conf; if (conf.Read("garli.conf") < 0) { throw ErrorException("Error in config file (Remote)...aborting."); } //no longer sending the conf, just letting the remote read it from file // for (int i = 0; i < 2; ++i) { RecvMPIMessage(&buf, &size, &from, &tag, true); assert(from == 0); // sanity check if (tag == TAG_DATA) { data.Deserialize(buf, size); debug_mpi("receieved data from %d", from); } /* else if (tag == TAG_CONFIG) { conf.Deserialize(buf, size); debug_mpi("received conf from %d", from); } */ else { debug_mpi("ERROR: received unexpected message from %d with tag %d", from, tag); debug_mpi("aborting from MPIMain()"); } delete [] buf; // } // LogConfig(conf); RemoteMaster(conf, data); } }catch(ErrorException err){ err.Print(cout); } // time to kill some global vars delete [] node_results; MPI_Finalize(); return 0; }
int StackValue::integerValue() const { if (_type != Type::INTEGER) throw ErrorException(std::string("StackValue::integerValue() - stack value is not integer, it is ") + typeName(_type)); return _intValue; }
void AddNamespaceData(Context& context, const AST::Node<AST::NamespaceData>& astNamespaceDataNode, const SEM::ModuleScope& moduleScope) { const auto semNamespace = context.scopeStack().back().nameSpace(); for (const auto& astChildNamespaceNode: astNamespaceDataNode->namespaces) { const auto& childNamespaceName = astChildNamespaceNode->name; SEM::Namespace* semChildNamespace = nullptr; const auto iterator = semNamespace->items().find(childNamespaceName); if (iterator == semNamespace->items().end()) { std::unique_ptr<SEM::Namespace> childNamespace(new SEM::Namespace(semNamespace->name() + childNamespaceName, *semNamespace)); semChildNamespace = childNamespace.get(); semNamespace->items().insert(std::make_pair(childNamespaceName, SEM::NamespaceItem::Namespace(std::move(childNamespace)))); } else { semChildNamespace = &(iterator->second.nameSpace()); } PushScopeElement pushScopeElement(context.scopeStack(), ScopeElement::Namespace(semChildNamespace)); AddNamespaceData(context, astChildNamespaceNode->data, moduleScope); } for (const auto& astModuleScopeNode: astNamespaceDataNode->moduleScopes) { if (!moduleScope.isInternal()) { throw ErrorException(makeString("Cannot nest module scopes, at position %s.", astModuleScopeNode.location().toString().c_str())); } AddNamespaceData(context, astModuleScopeNode->data, ConvertModuleScope(astModuleScopeNode)); } for (const auto& astAliasNode: astNamespaceDataNode->aliases) { const auto& aliasName = astAliasNode->name; const auto fullTypeName = semNamespace->name() + aliasName; const auto iterator = semNamespace->items().find(aliasName); if (iterator != semNamespace->items().end()) { throw ErrorException(makeString("Type alias name '%s' clashes with existing name, at position %s.", fullTypeName.toString().c_str(), astAliasNode.location().toString().c_str())); } std::unique_ptr<SEM::Alias> semAlias(new SEM::Alias(context.semContext(), *semNamespace, fullTypeName.copy())); // Add template variables. size_t templateVarIndex = 0; for (auto astTemplateVarNode: *(astAliasNode->templateVariables)) { const auto& templateVarName = astTemplateVarNode->name; // TODO! const bool isVirtual = false; const auto semTemplateVar = new SEM::TemplateVar(context.semContext(), fullTypeName + templateVarName, templateVarIndex++, isVirtual); const auto templateVarIterator = semAlias->namedTemplateVariables().find(templateVarName); if (templateVarIterator != semAlias->namedTemplateVariables().end()) { throw TemplateVariableClashException(fullTypeName.copy(), templateVarName); } semAlias->templateVariables().push_back(semTemplateVar); semAlias->namedTemplateVariables().insert(std::make_pair(templateVarName, semTemplateVar)); } PushScopeElement pushScopeElement(context.scopeStack(), ScopeElement::Alias(semAlias.get())); context.aliasTypeResolver().addAlias(*semAlias, astAliasNode->value, context.scopeStack().copy()); semNamespace->items().insert(std::make_pair(aliasName, SEM::NamespaceItem::Alias(std::move(semAlias)))); } for (const auto& astTypeInstanceNode: astNamespaceDataNode->typeInstances) { (void) AddTypeInstance(context, astTypeInstanceNode, moduleScope); } }
float StackValue::floatValue() const { if (_type != Type::FLOAT) throw ErrorException(std::string("StackValue::floatValue() - stack value is not float, it is ") + typeName(_type)); return _floatValue; }
std::string StackValue::stringValue() const { if (_type != Type::STRING) throw ErrorException(std::string("StackValue::stringValue() - stack value is not string, it is ") + typeName(_type)); return _stringValue; }
void AminoacidData::CalcEmpiricalFreqs(){ empStateFreqs=new FLOAT_TYPE[maxNumStates];//this is a member of the class, and where the final freqs will be stored for(int i=0;i<maxNumStates;i++) empStateFreqs[i] = 0.0; FLOAT_TYPE total = 0.0; //for codons and aminoacids this will assume no ambiguity for( int i = 0; i < NTax(); i++ ) { for( int j = 0; j < nChar; j++ ) { char thischar= matrix[i][j]; if(thischar != maxNumStates){ assert(thischar > -1); empStateFreqs[thischar] += (FLOAT_TYPE) Count(j); total += (FLOAT_TYPE) Count(j); } } } //check whether this might be nucleotide data in disguise if((empStateFreqs[0]+empStateFreqs[1]+empStateFreqs[5]+empStateFreqs[16])/total > 0.90) throw ErrorException("Model specified as aminoacid, but nucleotide data found!"); FLOAT_TYPE freqTot = 0.0; bool allPresent = true; for(int j=0;j<maxNumStates;j++) if(empStateFreqs[j] == ZERO_POINT_ZERO) allPresent = false; if(!allPresent){ outman.UserMessage("WARNING: Not all amino acids were observed in this dataset.\n\tOne pseudo-count will be added to each amino acid for calculation of the\n\tempirical frequencies. You should probably use\n\ta statefrequencies setting other than emprical.\n"); for(int j=0;j<maxNumStates;j++) empStateFreqs[j] += ONE_POINT_ZERO; total += (FLOAT_TYPE) maxNumStates; } for(int j=0;j<maxNumStates;j++){ empStateFreqs[j] /= total; freqTot += empStateFreqs[j]; } assert(fabs(freqTot - 1.0) < 1e-5); }
//verifies that we got the right number/type of blocks and returns the Characters block to be used const NxsCharactersBlock *GarliReader::CheckBlocksAndGetCorrectCharblock(const ModelSpecification &) const{ const int numTaxaBlocks = GetNumTaxaBlocks(); if(numTaxaBlocks > 1) throw ErrorException("Either more than one taxa block was found in the data file\n\tor multiple blocks had different taxon sets."); else if(numTaxaBlocks == 0) throw ErrorException("No taxa information was provided by NCL.\n\tThere may have been a problem reading the data file.\n\tCheck output above."); const NxsTaxaBlock *taxablock = GetTaxaBlock(0); const int numCharBlocks = GetNumCharactersBlocks(taxablock); outman.UserMessageNoCR(""); if(numCharBlocks == 0) throw ErrorException("No character data was provided by NCL. There may have been a problem reading\n\tthe data file, or the data was of the wrong type. Check output above."); //now check that we only have one of the charblock types that we want int correctIndex = -1; for(unsigned c = 0;c < GetNumCharactersBlocks(taxablock);c++){ const NxsCharactersBlock *charblock = GetCharactersBlock(taxablock, c); if((charblock->GetDataType() == NxsCharactersBlock::dna || charblock->GetDataType() == NxsCharactersBlock::nucleotide) && (modSpec.IsNucleotide() || modSpec.IsCodon() || modSpec.IsCodonAminoAcid())){ if(correctIndex > -1) throw ErrorException("More than one block containing nucleotide data was found."); else correctIndex = c; } //rna data is not allowed as input for codon or codon-aminoacid analyses else if(charblock->GetDataType() == NxsCharactersBlock::rna && (modSpec.IsNucleotide() || modSpec.IsRna())){ if(correctIndex > -1) throw ErrorException("More than one block containing nucleotide data was found."); else correctIndex = c; } else if(charblock->GetDataType() == NxsCharactersBlock::protein && (modSpec.IsAminoAcid())){ if(correctIndex > -1) throw ErrorException("More than one block containing amino acid (protein) data was found."); else correctIndex = c; } } if(correctIndex == -1){ if(modSpec.IsNucleotide()) throw ErrorException("A data file was read, but no nucleotide data was found."); else if(modSpec.IsRna()) throw ErrorException("A data file was read, but no RNA data was found."); else if(modSpec.IsAminoAcid()) throw ErrorException("A data file was read, but no amino acid (protein) data was found."); else if(modSpec.IsCodon()) throw ErrorException("DNA data is required as input for codon models.\n\tA data file was read, but none was found."); else if(modSpec.IsCodonAminoAcid()) throw ErrorException("DNA data is required as input for codon translated amino acid models.\n\tA data file was read, but none was found."); } return GetCharactersBlock(taxablock, correctIndex); }
void CodonData::FillCodonMatrixFromDNA(const NucleotideData *dnaData){ //first we need to convert the nucleotide data to codons numbered 0-60 or 61 and assign them back to the terminals //codons are ordered AAA, AAC, AAG, AAT, ACA, ... TTT short pos1, pos2, pos3; nChar = dnaData->NChar()/3; nTax = dnaData->NTax(); if(dnaData->NChar() % 3 != 0) throw ErrorException("Codon datatype specified, but number of nucleotides not divisible by 3!"); NewMatrix(nTax, nChar); //this will just map from the bitwise format to the index format (A, C, G, T = 0, 1, 2, 3) //partial ambiguity is mapped to total ambiguity currently short bitwiseToIndexFormat[16] = {15,0,1,15,2,15,15,15,3,15,15,15,15,15,15,15}; //keep track of the empirical base freqs at the codon positions, for possible use //in the F1x4 or F3x4 methods of calculating the equilibrium codon freqs empBaseFreqsPos1[0]=empBaseFreqsPos1[1]=empBaseFreqsPos1[2]=empBaseFreqsPos1[3]=ZERO_POINT_ZERO; empBaseFreqsPos2[0]=empBaseFreqsPos2[1]=empBaseFreqsPos2[2]=empBaseFreqsPos2[3]=ZERO_POINT_ZERO; empBaseFreqsPos3[0]=empBaseFreqsPos3[1]=empBaseFreqsPos3[2]=empBaseFreqsPos3[3]=ZERO_POINT_ZERO; FLOAT_TYPE total = ZERO_POINT_ZERO; int tax=0, thisCodonNum; for(int tax=0;tax<NTax();tax++){ bool firstAmbig = true; for(int cod=0;cod<nChar;cod++){ short p1 = dnaData->Matrix(tax, cod*3); short p2 = dnaData->Matrix(tax, cod*3+1); short p3 = dnaData->Matrix(tax, cod*3+2); pos1 = bitwiseToIndexFormat[p1]; pos2 = bitwiseToIndexFormat[p2]; pos3 = bitwiseToIndexFormat[p3]; thisCodonNum=(pos1)*16 + (pos2)*4 + pos3; if(pos1==15||pos2==15||pos3==15){//check for gaps or ambiguity if(pos1+pos2+pos3 != 45){ //warn about gaps or ambiguity in codons if(firstAmbig){ outman.UserMessageNoCR("Gaps or ambiguity codes found within codon for taxon %s.\n\tCodons coded as missing for that taxon: ", dnaData->TaxonLabel(tax)); firstAmbig = false; } outman.UserMessageNoCR("%d ", cod+1); } thisCodonNum=64; } else{ empBaseFreqsPos1[pos1] += ONE_POINT_ZERO; empBaseFreqsPos2[pos2] += ONE_POINT_ZERO; empBaseFreqsPos3[pos3] += ONE_POINT_ZERO; total += ONE_POINT_ZERO; } char prot; //note that a return code of 20 from the codon lookup indicates a stop codon, but a protein code of 20 generally means total ambiguity if(thisCodonNum != 64){ prot = code.CodonLookup(thisCodonNum); if(prot == 20){ string c; char b[4]={'A','C','G','T'}; c += b[pos1]; c += b[pos2]; c += b[pos3]; throw ErrorException("stop codon %s found at codon site %d (nuc site %d) in taxon %s. Bailing out.", c.c_str(), cod+1, cod*3+1, dnaData->TaxonLabel(tax)); } } if(thisCodonNum == 64)//missing or ambiguous matrix[tax][cod] = maxNumStates; else matrix[tax][cod] = code.Map64stateToNonStops(thisCodonNum); } if(firstAmbig == false) outman.UserMessage(""); } for(int b=0;b<4;b++){ empBaseFreqsAllPos[b] = (empBaseFreqsPos1[b] + empBaseFreqsPos2[b] + empBaseFreqsPos3[b]) / (3.0 * total); empBaseFreqsPos1[b] /= total; empBaseFreqsPos2[b] /= total; empBaseFreqsPos3[b] /= total; } }
SEM::Var* ConvertVar(Context& context, const Debug::VarInfo::Kind varKind, const AST::Node<AST::TypeVar>& astTypeVarNode) { const auto& location = astTypeVarNode.location(); switch (astTypeVarNode->kind()) { case AST::TypeVar::ANYVAR: { throw ErrorException("'Any' vars not yet implemented for uninitialised variables."); } case AST::TypeVar::NAMEDVAR: { const auto& varName = astTypeVarNode->name(); // Search all scopes outside of the current scope. const auto searchStartPosition = 1; if (varKind != Debug::VarInfo::VAR_MEMBER && !performSearch(context, Name::Relative() + varName, searchStartPosition).isNone()) { throw ErrorException(makeString("Variable '%s' shadows existing object at position %s.", varName.c_str(), location.toString().c_str())); } const auto varType = ConvertType(context, astTypeVarNode->namedType()); // 'final' keyword uses a different lval type (which doesn't support // moving or re-assignment). const bool isFinalLval = astTypeVarNode->isFinal(); const auto lvalType = makeLvalType(context, isFinalLval, varType); const auto var = SEM::Var::Basic(varType, lvalType); var->setMarkedUnused(astTypeVarNode->isUnused()); var->setOverrideConst(astTypeVarNode->isOverrideConst()); attachVar(context, varName, astTypeVarNode, var, varKind); return var; } case AST::TypeVar::PATTERNVAR: { const auto varType = ConvertType(context, astTypeVarNode->patternType())->resolveAliases(); if (!varType->isDatatype()) { throw ErrorException(makeString("Can't pattern match for non-datatype '%s' at position %s.", varType->toString().c_str(), location.toString().c_str())); } const auto& astChildTypeVars = astTypeVarNode->typeVarList(); const auto& typeChildVars = varType->getObjectType()->variables(); if (astChildTypeVars->size() != typeChildVars.size()) { throw ErrorException(makeString("%llu pattern match children specified; %llu expected (for type '%s') at position %s.", (unsigned long long) astChildTypeVars->size(), (unsigned long long) typeChildVars.size(), varType->toString().c_str(), location.toString().c_str())); } const auto templateVarMap = varType->generateTemplateVarMap(); std::vector<SEM::Var*> children; for (size_t i = 0; i < typeChildVars.size(); i++) { const auto& astVar = astChildTypeVars->at(i); children.push_back(ConvertVar(context, varKind, astVar)); } return SEM::Var::Composite(varType, children); } } std::terminate(); }
void NucleotideData::CreateMatrixFromNCL(GarliReader &reader){ NxsCharactersBlock *charblock; int num=0, numNuc = -1; do{ charblock = reader.GetCharactersBlock(num); if(charblock->GetDataType() == NxsCharactersBlock::nucleotide || charblock->GetDataType() == NxsCharactersBlock::dna || charblock->GetDataType() == NxsCharactersBlock::rna){ if(numNuc < 0) numNuc = num; else{ throw ErrorException("Multiple characters/data blocks containing nucleotide data found in Nexus datafile!\n\tEither combine the blocks or comment one out."); } } else outman.UserMessage("Ignoring non-nucleotide characters block from Nexus datafile"); num++; }while(num < reader.NumCharBlocks()); if(numNuc < 0) throw ErrorException("No characters/data blocks containing nucleotide data found in Nexus datafile!"); charblock = reader.GetCharactersBlock(numNuc); if(charblock->GetNumActiveChar() < charblock->GetNChar()){ outman.UserMessageNoCR("Excluded characters:\n\t"); for(int c=0;c<charblock->GetNCharTotal();c++) if(charblock->IsExcluded(c)) outman.UserMessageNoCR("%d ", c+1); outman.UserMessage(""); } // vector<unsigned> reducedToOrigCharMap = charblock->GetOrigIndexVector(); NxsTaxaBlock *taxablock = reader.GetTaxaBlock(); int numOrigTaxa = charblock->GetNTax(); int numActiveTaxa = charblock->GetNumActiveTaxa(); int numOrigChar = charblock->GetNChar(); int numActiveChar = charblock->GetNumActiveChar(); //int num_chars = reducedToOrigCharMap.size(); //cout << num_chars << endl; NewMatrix( numActiveTaxa, numActiveChar ); // read in the data, including taxon names int i=0; for( int origTaxIndex = 0; origTaxIndex < numOrigTaxa; origTaxIndex++ ) { if(charblock->IsActiveTaxon(origTaxIndex)){ //internally, blanks in taxon names will be stored as underscores NxsString tlabel = taxablock->GetTaxonLabel(origTaxIndex); tlabel.BlanksToUnderscores(); SetTaxonLabel( i, tlabel.c_str()); int j = 0; for( int origIndex = 0; origIndex < numOrigChar; origIndex++ ) { if(charblock->IsActiveChar(origIndex)){ unsigned char datum = '\0'; if(charblock->IsGapState(origTaxIndex, origIndex) == true) datum = 15; else if(charblock->IsMissingState(origTaxIndex, origIndex) == true) datum = 15; else{ int nstates = charblock->GetNumStates(origTaxIndex, origIndex); for(int s=0;s<nstates;s++){ datum += CharToBitwiseRepresentation(charblock->GetState(origTaxIndex, origIndex, s)); } } SetMatrix( i, j++, datum ); } } i++; } } }
void CaseManager::updateCaseStatus(int faceId, double percentageMatch) { string randomIdentifier = ""; srand (time(NULL) + faceId); for (int i = 0; i < 10; i++) { char c; int j = rand() % 4; if (j == 0) { c = (rand() % 10) + 48; } else if (j == 1) { c = (rand() % 26) + 65; } else { c = (rand() % 26) + 97; } randomIdentifier += c; } stringstream ss; ss << faceId; string strFaceId; ss >> strFaceId; randomIdentifier += strFaceId; if (databaseConnection->getDatabase().open()) { QSqlQuery query; query.prepare("INSERT INTO case_results " "(face_id, case_id, percentage_match, random_identifier) " "VALUES (:faceId, :caseId, :percentageMatch, :randomIdentifier)"); query.bindValue(":faceId", faceId); query.bindValue(":caseId", caseId); query.bindValue(":percentageMatch", percentageMatch); QString qRandomIdentifier(randomIdentifier.c_str()); query.bindValue(":randomIdentifier", qRandomIdentifier); if(!query.exec()) { QString error("inserting case result."); throw ErrorException(error, 0); } QSqlQuery updateQuery; updateQuery.prepare("UPDATE cases " "SET num_results = num_results +1 " "WHERE id = :caseId"); updateQuery.bindValue(":caseId", caseId); if(!updateQuery.exec()) { QString error("updating case result."); throw ErrorException(error, 1); } } else { QString error("database closed."); throw ErrorException(error, 3); } }
void OpcodeHandler::_error(const std::string& message) { throw ErrorException(message); }