Method processInput

src/EnergyPlus/InputProcessing/InputProcessor.cc:262–326

}

void InputProcessor::processInput(EnergyPlusData &state)
{
    if (!FileSystem::fileExists(state.dataStrGlobals->inputFilePath)) {
        ShowFatalError(state, EnergyPlus::format("Input file path {} not found", state.dataStrGlobals->inputFilePath.string()));
        return;
    }

    try {
        if (!state.dataGlobal->isEpJSON) {
            auto input_file = FileSystem::readFile(state.dataStrGlobals->inputFilePath); // (AUTO_OK_OBJ)

            bool success = true;
            epJSON = idf_parser->decode(input_file, schema(), success);

            if (state.dataGlobal->outputEpJSONConversion || state.dataGlobal->outputEpJSONConversionOnly) {
                json epJSONClean = epJSON;
                cleanEPJSON(epJSONClean);
                fs::path convertedIDF = FileSystem::makeNativePath(
                    FileSystem::replaceFileExtension(state.dataStrGlobals->outDirPath / state.dataStrGlobals->inputFilePathNameOnly, ".epJSON"));
                FileSystem::writeFile<FileSystem::FileTypes::EpJSON>(convertedIDF, epJSONClean);
            }
        } else {
            epJSON = FileSystem::readJSON(state.dataStrGlobals->inputFilePath);
        }
    } catch (const std::exception &e) {
        ShowSevereError(state, e.what());
        ShowFatalError(state, "Errors occurred on processing input file. Preceding condition(s) cause termination.");
    }

    bool is_valid = validation->validate(epJSON);
    bool hasErrors = processErrors(state);
    bool versionMatch = checkVersionMatch(state);
    bool unsupportedFound = checkForUnsupportedObjects(state);

    if (!is_valid || hasErrors || unsupportedFound) {
        ShowFatalError(state, "Errors occurred on processing input file. Preceding condition(s) cause termination.");
    }

    if (state.dataGlobal->isEpJSON && (state.dataGlobal->outputEpJSONConversion || state.dataGlobal->outputEpJSONConversionOnly)) {
        if (versionMatch) {
            std::string const encoded = idf_parser->encode(epJSON, schema());
            fs::path convertedEpJSON = FileSystem::makeNativePath(
                FileSystem::replaceFileExtension(state.dataStrGlobals->outDirPath / state.dataStrGlobals->inputFilePathNameOnly, ".idf"));
            FileSystem::writeFile<FileSystem::FileTypes::IDF>(convertedEpJSON, encoded);
        } else {
            ShowWarningError(state, "Skipping conversion of epJSON to IDF due to mismatched Version.");
        }
    }

    initializeMaps();

    int MaxArgs = 0;
    int MaxAlpha = 0;
    int MaxNumeric = 0;
    getMaxSchemaArgs(MaxArgs, MaxAlpha, MaxNumeric);

    state.dataIPShortCut->cAlphaFieldNames.allocate(MaxAlpha);
    state.dataIPShortCut->cAlphaArgs.allocate(MaxAlpha);