Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===--- OptParser.td - Common Option Parsing Interfaces ------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This file defines the common interfaces used by the option parsing TableGen

//  backend.

//

//===----------------------------------------------------------------------===//

// Define the kinds of options.

class OptionKind<string name, int precedence = 0, bit sentinel = false> {

  string Name = name;

  // The kind precedence, kinds with lower precedence are matched first.

  int Precedence = precedence;

  // Indicate a sentinel option.

  bit Sentinel = sentinel;

}

// An option group.

def KIND_GROUP : OptionKind<"Group">;

// The input option kind.

def KIND_INPUT : OptionKind<"Input", 1, true>;

// The unknown option kind.

def KIND_UNKNOWN : OptionKind<"Unknown", 2, true>;

// A flag with no values.

def KIND_FLAG : OptionKind<"Flag">;

// An option which prefixes its (single) value.

def KIND_JOINED : OptionKind<"Joined", 1>;

// An option which is followed by its value.

def KIND_SEPARATE : OptionKind<"Separate">;

// An option followed by its values, which are separated by commas.

def KIND_COMMAJOINED : OptionKind<"CommaJoined">;

// An option which is which takes multiple (separate) arguments.

def KIND_MULTIARG : OptionKind<"MultiArg">;

// An option which is either joined to its (non-empty) value, or followed by its

// value.

def KIND_JOINED_OR_SEPARATE : OptionKind<"JoinedOrSeparate">;

// An option which is both joined to its (first) value, and followed by its

// (second) value.

def KIND_JOINED_AND_SEPARATE : OptionKind<"JoinedAndSeparate">;

// An option which consumes all remaining arguments if there are any.

def KIND_REMAINING_ARGS : OptionKind<"RemainingArgs">;

// An option which consumes an optional joined argument and any other remaining

// arguments.

def KIND_REMAINING_ARGS_JOINED : OptionKind<"RemainingArgsJoined">;

// Define the option flags.

class OptionFlag {}

// HelpHidden - The option should not be displayed in --help, even if it has

// help text. Clients *can* use this in conjunction with the OptTable::PrintHelp

// arguments to implement hidden help groups.

def HelpHidden : OptionFlag;

// RenderAsInput - The option should not render the name when rendered as an

// input (i.e., the option is rendered as values).

def RenderAsInput : OptionFlag;

// RenderJoined - The option should be rendered joined, even if separate (only

// sensible on single value separate options).

def RenderJoined : OptionFlag;

// RenderSeparate - The option should be rendered separately, even if joined

// (only sensible on joined options).

def RenderSeparate : OptionFlag;

// Define the option group class.

class OptionGroup<string name> {

  string EnumName = ?; // Uses the def name if undefined.

  string Name = name;

  string HelpText = ?;

  OptionGroup Group = ?;

  list<OptionFlag> Flags = [];

}

// Define the option class.

class Option<list<string> prefixes, string name, OptionKind kind> {

  string EnumName = ?; // Uses the def name if undefined.

  list<string> Prefixes = prefixes;

  string Name = name;

  OptionKind Kind = kind;

  // Used by MultiArg option kind.

  int NumArgs = 0;

  string HelpText = ?;

  string MetaVarName = ?;

  string Values = ?;

  code ValuesCode = ?;

  list<OptionFlag> Flags = [];

  OptionGroup Group = ?;

  Option Alias = ?;

  list<string> AliasArgs = [];

  code MacroPrefix = "";

  code KeyPath = ?;

  code DefaultValue = ?;

  code ImpliedValue = ?;

  code ImpliedCheck = "false";

  code ShouldParse = "true";

  bit ShouldAlwaysEmit = false;

  code NormalizerRetTy = ?;

  code NormalizedValuesScope = "";

  code Normalizer = "";

  code Denormalizer = "";

  code ValueMerger = "mergeForwardValue";

  code ValueExtractor = "extractForwardValue";

  list<code> NormalizedValues = ?;

}

// Helpers for defining options.

class Flag<list<string> prefixes, string name>

  : Option<prefixes, name, KIND_FLAG>;

class Joined<list<string> prefixes, string name>

  : Option<prefixes, name, KIND_JOINED>;

class Separate<list<string> prefixes, string name>

  : Option<prefixes, name, KIND_SEPARATE>;

class CommaJoined<list<string> prefixes, string name>

  : Option<prefixes, name, KIND_COMMAJOINED>;

class MultiArg<list<string> prefixes, string name, int numargs>

  : Option<prefixes, name, KIND_MULTIARG> {

  int NumArgs = numargs;

}

class JoinedOrSeparate<list<string> prefixes, string name>

  : Option<prefixes, name, KIND_JOINED_OR_SEPARATE>;

class JoinedAndSeparate<list<string> prefixes, string name>

  : Option<prefixes, name, KIND_JOINED_AND_SEPARATE>;

// Mix-ins for adding optional attributes.

class Alias<Option alias> { Option Alias = alias; }

class AliasArgs<list<string> aliasargs> { list<string> AliasArgs = aliasargs; }

class EnumName<string name> { string EnumName = name; }

class Flags<list<OptionFlag> flags> { list<OptionFlag> Flags = flags; }

class Group<OptionGroup group> { OptionGroup Group = group; }

class HelpText<string text> { string HelpText = text; }

class MetaVarName<string name> { string MetaVarName = name; }

class Values<string value> { string Values = value; }

class ValuesCode<code valuecode> { code ValuesCode = valuecode; }

// Helpers for defining marshalling information (typically used in Clang's -cc1

// frontend).

// The key path to the mapped field and the macro prefix for the resulting

// definition database.

class KeyPathAndMacro<string key_path_prefix, string key_path_base,

                      string macro_prefix = ""> {

  code KeyPath = !strconcat(key_path_prefix, key_path_base);

  code MacroPrefix = macro_prefix;

}

// Mixin that implies the specified value for the current option when any of the

// given key paths evaluates to true.

class ImpliedByAnyOf<list<string> key_paths, code value = "true"> {

  code ImpliedCheck = !foldl("false", key_paths, accumulator, key_path,

                             !strconcat(accumulator, " || ", key_path));

  code ImpliedValue = value;

}

// Parent class for marshalled options (typically used in Clang's -cc1 frontend).

class MarshallingInfo<KeyPathAndMacro kpm, code defaultvalue> {

  code KeyPath = kpm.KeyPath;

  code MacroPrefix = kpm.MacroPrefix;

  code DefaultValue = defaultvalue;

}

// Marshalled option accepting a string argument.

class MarshallingInfoString<KeyPathAndMacro kpm, code defaultvalue="std::string()">

  : MarshallingInfo<kpm, defaultvalue> {

  code Normalizer = "normalizeString";

  code Denormalizer = "denormalizeString";

}

// Marshalled option accepting an integer argument.

class MarshallingInfoInt<KeyPathAndMacro kpm, code defaultvalue="0", code type="unsigned">

  : MarshallingInfo<kpm, defaultvalue> {

  code Normalizer = "normalizeStringIntegral<"#type#">";

  code Denormalizer = "denormalizeString<"#type#">";

}

// Marshalled option accepting vector of strings.

class MarshallingInfoStringVector<KeyPathAndMacro kpm>

  : MarshallingInfo<kpm, "std::vector<std::string>({})"> {

  code Normalizer = "normalizeStringVector";

  code Denormalizer = "denormalizeStringVector";

}

// Marshalled option - single positive flag.

class MarshallingInfoFlag<KeyPathAndMacro kpm, code defaultvalue = "false">

  : MarshallingInfo<kpm, defaultvalue> {

  code Normalizer = "normalizeSimpleFlag";

  code Denormalizer = "denormalizeSimpleFlag";

}

// Marshalled option - single negative flag.

class MarshallingInfoNegativeFlag<KeyPathAndMacro kpm, code defaultvalue = "true">

  : MarshallingInfo<kpm, defaultvalue> {

  code Normalizer = "normalizeSimpleNegativeFlag";

  code Denormalizer = "denormalizeSimpleFlag";

}

// Marshalled option - single flag contributing to a bitfield.

class MarshallingInfoBitfieldFlag<KeyPathAndMacro kpm, code value>

  : MarshallingInfoFlag<kpm, "0u"> {

  code Normalizer = "makeFlagToValueNormalizer("#value#")";

  code ValueMerger = "mergeMaskValue";

  code ValueExtractor = "(extractMaskValue<unsigned, decltype("#value#"), "#value#">)";

}

// Implementation detail of BoolOption.

class MarshallingInfoBooleanFlag<KeyPathAndMacro kpm, code defaultvalue, code value,

                                 code other_value, code other_name>

  : MarshallingInfoFlag<kpm, defaultvalue> {

  code Normalizer = "makeBooleanOptionNormalizer("#value#", "#other_value#", OPT_"#other_name#")";

  code Denormalizer = "makeBooleanOptionDenormalizer("#value#")";

}

// Marshalled option accepting any of the specified enum values.

// Typically used with `Values`, `NormalizedValues` and `NormalizedValuesScope`.

class MarshallingInfoEnum<KeyPathAndMacro kpm, code defaultvalue>

  : MarshallingInfo<kpm, defaultvalue> {

  code Normalizer = "normalizeSimpleEnum";

  code Denormalizer = "denormalizeSimpleEnum";

}

// Mixins for additional marshalling attributes.

class ShouldParseIf<code condition> { code ShouldParse = condition; }

class AlwaysEmit { bit ShouldAlwaysEmit = true; }

class Normalizer<code normalizer> { code Normalizer = normalizer; }

class Denormalizer<code denormalizer> { code Denormalizer = denormalizer; }

class NormalizedValuesScope<code scope> { code NormalizedValuesScope = scope; }

class NormalizedValues<list<code> definitions> { list<code> NormalizedValues = definitions; } 

class ValueMerger<code merger> { code ValueMerger = merger; }

class ValueExtractor<code extractor> { code ValueExtractor = extractor; }

// Predefined options.

// FIXME: Have generator validate that these appear in correct position (and

// aren't duplicated).

def INPUT : Option<[], "<input>", KIND_INPUT>;

def UNKNOWN : Option<[], "<unknown>", KIND_UNKNOWN>;