C++ (Cpp) Diagnostic::Report Examples

Example #1

int ArgList::getLastArgIntValue(OptSpecifier Id, int Default,
                                clang::Diagnostic &Diags) const {
  int Res = Default;

  if (Arg *A = getLastArg(Id)) {
    if (llvm::StringRef(A->getValue(*this)).getAsInteger(10, Res))
      Diags.Report(diag::err_drv_invalid_int_value)
        << A->getAsString(*this) << A->getValue(*this);
  }

  return Res;
}

Example #2

File: llvm-rs-cc.cpp Project: rhcp011235/frameworks_compile_slang

// ParseArguments -
static void ParseArguments(llvm::SmallVectorImpl<const char*> &ArgVector,
                           llvm::SmallVectorImpl<const char*> &Inputs,
                           RSCCOptions &Opts,
                           clang::Diagnostic &Diags) {
    if (ArgVector.size() > 1) {
        const char **ArgBegin = ArgVector.data() + 1;
        const char **ArgEnd = ArgVector.data() + ArgVector.size();
        unsigned MissingArgIndex, MissingArgCount;
        llvm::OwningPtr<OptTable> OptParser(createRSCCOptTable());
        llvm::OwningPtr<InputArgList> Args(
            OptParser->ParseArgs(ArgBegin, ArgEnd, MissingArgIndex, MissingArgCount));

        // Check for missing argument error.
        if (MissingArgCount)
            Diags.Report(clang::diag::err_drv_missing_argument)
                    << Args->getArgString(MissingArgIndex) << MissingArgCount;

        // Issue errors on unknown arguments.
        for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN),
                ie = Args->filtered_end(); it != ie; ++it)
            Diags.Report(clang::diag::err_drv_unknown_argument)
                    << (*it)->getAsString(*Args);

        for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
                it != ie; ++it) {
            const Arg *A = *it;
            if (A->getOption().getKind() == Option::InputClass)
                Inputs.push_back(A->getValue(*Args));
        }

        Opts.mIncludePaths = Args->getAllArgValues(OPT_I);

        Opts.mOutputDir = Args->getLastArgValue(OPT_o);

        if (const Arg *A = Args->getLastArg(OPT_M_Group)) {
            switch (A->getOption().getID()) {
            case OPT_M: {
                Opts.mOutputDep = 1;
                Opts.mOutputType = slang::Slang::OT_Dependency;
                break;
            }
            case OPT_MD: {
                Opts.mOutputDep = 1;
                Opts.mOutputType = slang::Slang::OT_Bitcode;
                break;
            }
            default: {
                slangAssert(false && "Invalid option in M group!");
            }
            }
        }

        if (const Arg *A = Args->getLastArg(OPT_Output_Type_Group)) {
            switch (A->getOption().getID()) {
            case OPT_emit_asm: {
                Opts.mOutputType = slang::Slang::OT_Assembly;
                break;
            }
            case OPT_emit_llvm: {
                Opts.mOutputType = slang::Slang::OT_LLVMAssembly;
                break;
            }
            case OPT_emit_bc: {
                Opts.mOutputType = slang::Slang::OT_Bitcode;
                break;
            }
            case OPT_emit_nothing: {
                Opts.mOutputType = slang::Slang::OT_Nothing;
                break;
            }
            default: {
                slangAssert(false && "Invalid option in output type group!");
            }
            }
        }

        if (Opts.mOutputDep &&
                ((Opts.mOutputType != slang::Slang::OT_Bitcode) &&
                 (Opts.mOutputType != slang::Slang::OT_Dependency)))
            Diags.Report(clang::diag::err_drv_argument_not_allowed_with)
                    << Args->getLastArg(OPT_M_Group)->getAsString(*Args)
                    << Args->getLastArg(OPT_Output_Type_Group)->getAsString(*Args);

        Opts.mAllowRSPrefix = Args->hasArg(OPT_allow_rs_prefix);

        Opts.mJavaReflectionPathBase =
            Args->getLastArgValue(OPT_java_reflection_path_base);
        Opts.mJavaReflectionPackageName =
            Args->getLastArgValue(OPT_java_reflection_package_name);

        llvm::StringRef BitcodeStorageValue =
            Args->getLastArgValue(OPT_bitcode_storage);
        if (BitcodeStorageValue == "ar")
            Opts.mBitcodeStorage = slang::BCST_APK_RESOURCE;
        else if (BitcodeStorageValue == "jc")
            Opts.mBitcodeStorage = slang::BCST_JAVA_CODE;
        else if (!BitcodeStorageValue.empty())
            Diags.Report(clang::diag::err_drv_invalid_value)
                    << OptParser->getOptionName(OPT_bitcode_storage)
                    << BitcodeStorageValue;

        Opts.mOutputDepDir =
            Args->getLastArgValue(OPT_output_dep_dir, Opts.mOutputDir);
        Opts.mAdditionalDepTargets =
            Args->getAllArgValues(OPT_additional_dep_target);

        Opts.mShowHelp = Args->hasArg(OPT_help);
        Opts.mShowVersion = Args->hasArg(OPT_version);

        Opts.mTargetAPI = Args->getLastArgIntValue(OPT_target_api,
                          RS_VERSION,
                          Diags);
    }

    return;
}