You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
628 lines
27 KiB
628 lines
27 KiB
/*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef ANDROID_RS_API_GENERATOR_SPECIFICATION_H
|
|
#define ANDROID_RS_API_GENERATOR_SPECIFICATION_H
|
|
|
|
// See Generator.cpp for documentation of the .spec file format.
|
|
|
|
#include <climits>
|
|
#include <fstream>
|
|
#include <list>
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
class Constant;
|
|
class ConstantSpecification;
|
|
class Function;
|
|
class FunctionPermutation;
|
|
class FunctionSpecification;
|
|
class SpecFile;
|
|
class Specification;
|
|
class Scanner;
|
|
class SystemSpecification;
|
|
class Type;
|
|
class TypeSpecification;
|
|
|
|
enum NumberKind { SIGNED_INTEGER, UNSIGNED_INTEGER, FLOATING_POINT };
|
|
|
|
// Table of type equivalences.
|
|
struct NumericalType {
|
|
const char* specType; // Name found in the .spec file
|
|
const char* rsDataType; // RS data type
|
|
const char* cType; // Type in a C file
|
|
const char* javaType; // Type in a Java file
|
|
NumberKind kind;
|
|
/* For integers, number of bits of the number, excluding the sign bit.
|
|
* For floats, number of implied bits of the mantissa.
|
|
*/
|
|
int significantBits;
|
|
// For floats, number of bits of the exponent. 0 for integer types.
|
|
int exponentBits;
|
|
};
|
|
|
|
/* Corresponds to one parameter line in a .spec file. These will be parsed when
|
|
* we instantiate the FunctionPermutation(s) that correspond to one FunctionSpecification.
|
|
*/
|
|
struct ParameterEntry {
|
|
std::string type;
|
|
std::string name;
|
|
/* Optional information on how to generate test values for this parameter. Can be:
|
|
* - range(low, high): Generates values between these two limits only.
|
|
* - above(other_parameter): The values must be greater than those of the named parameter.
|
|
* Used for clamp.
|
|
* - compatible(type): The values must also be fully representable in the specified type.
|
|
* - conditional: Don't verify this value the function return NaN.
|
|
*/
|
|
std::string testOption;
|
|
std::string documentation;
|
|
int lineNumber;
|
|
};
|
|
|
|
/* Information about a parameter to a function. The values of all the fields should only be set by
|
|
* parseParameterDefinition.
|
|
*/
|
|
struct ParameterDefinition {
|
|
std::string rsType; // The Renderscript type, e.g. "uint3"
|
|
std::string rsBaseType; // As above but without the number, e.g. "uint"
|
|
std::string javaBaseType; // The type we need to declare in Java, e.g. "unsigned int"
|
|
std::string specType; // The type found in the spec, e.g. "f16"
|
|
bool isFloatType; // True if it's a floating point value
|
|
/* The number of entries in the vector. It should be either "1", "2", "3", or "4". It's also
|
|
* "1" for scalars.
|
|
*/
|
|
std::string mVectorSize;
|
|
/* The space the vector takes in an array. It's the same as the vector size, except for size
|
|
* "3", where the width is "4".
|
|
*/
|
|
std::string vectorWidth;
|
|
|
|
std::string specName; // e.g. x, as found in the spec file
|
|
std::string variableName; // e.g. inX, used both in .rs and .java
|
|
std::string rsAllocName; // e.g. gAllocInX
|
|
std::string javaAllocName; // e.g. inX
|
|
std::string javaArrayName; // e.g. arrayInX
|
|
std::string doubleVariableName; // e.g. inXDouble, used in .java for storing Float16 parameters
|
|
// in double.
|
|
|
|
// If non empty, the mininum and maximum values to be used when generating the test data.
|
|
std::string minValue;
|
|
std::string maxValue;
|
|
/* If non empty, contains the name of another parameter that should be smaller or equal to this
|
|
* parameter, i.e. value(smallerParameter) <= value(this). This is used when testing clamp.
|
|
*/
|
|
std::string smallerParameter;
|
|
|
|
bool isOutParameter; // True if this parameter returns data from the script.
|
|
bool undefinedIfOutIsNan; // If true, we don't validate if 'out' is NaN.
|
|
|
|
int typeIndex; // Index in the TYPES array. Negative if not found in the array.
|
|
int compatibleTypeIndex; // Index in TYPES for which the test data must also fit.
|
|
|
|
/* Fill this object from the type, name, and testOption.
|
|
* isReturn is true if we're processing the "return:"
|
|
*/
|
|
void parseParameterDefinition(const std::string& type, const std::string& name,
|
|
const std::string& testOption, int lineNumber, bool isReturn,
|
|
Scanner* scanner);
|
|
|
|
bool isFloat16Parameter() const { return specType.compare("f16") == 0; }
|
|
};
|
|
|
|
struct VersionInfo {
|
|
/* The range of versions a specification applies to. Zero if there's no restriction,
|
|
* so an API that became available at 12 and is still valid would have min:12 max:0.
|
|
* If non zero, both versions should be at least 9, the API level that introduced
|
|
* RenderScript.
|
|
*/
|
|
unsigned int minVersion;
|
|
unsigned int maxVersion;
|
|
// Either 0, 32 or 64. If 0, this definition is valid for both 32 and 64 bits.
|
|
int intSize;
|
|
|
|
VersionInfo() : minVersion(0), maxVersion(0), intSize(0) {}
|
|
/* Scan the version info from the spec file. maxApiLevel specifies the maximum level
|
|
* we are interested in. This may alter maxVersion. This method returns false if the
|
|
* minVersion is greater than the maxApiLevel.
|
|
*/
|
|
bool scan(Scanner* scanner, unsigned int maxApiLevel);
|
|
/* Return true if the target can be found whitin the range. */
|
|
bool includesVersion(unsigned int target) const {
|
|
return (minVersion == 0 || target >= minVersion) &&
|
|
(maxVersion == 0 || target <= maxVersion);
|
|
}
|
|
|
|
static constexpr unsigned int kUnreleasedVersion = UINT_MAX;
|
|
};
|
|
|
|
// We have three type of definitions
|
|
class Definition {
|
|
protected:
|
|
std::string mName;
|
|
/* If greater than 0, this definition is deprecated. It's the API level at which
|
|
* we added the deprecation warning.
|
|
*/
|
|
int mDeprecatedApiLevel;
|
|
std::string mDeprecatedMessage; // Optional specific warning if the API is deprecated
|
|
bool mHidden; // True if it should not be documented
|
|
std::string mSummary; // A one-line description
|
|
std::vector<std::string> mDescription; // The comments to be included in the header
|
|
std::string mUrl; // The URL of the detailed documentation
|
|
int mFinalVersion; // API level at which this API was removed, 0 if API is still valid
|
|
|
|
public:
|
|
Definition(const std::string& name);
|
|
|
|
std::string getName() const { return mName; }
|
|
bool deprecated() const { return mDeprecatedApiLevel > 0; }
|
|
int getDeprecatedApiLevel() const { return mDeprecatedApiLevel; }
|
|
std::string getDeprecatedMessage() const { return mDeprecatedMessage; }
|
|
bool hidden() const { return mHidden; }
|
|
std::string getSummary() const { return mSummary; }
|
|
const std::vector<std::string>& getDescription() const { return mDescription; }
|
|
std::string getUrl() const { return mUrl; }
|
|
int getFinalVersion() const { return mFinalVersion; }
|
|
|
|
void scanDocumentationTags(Scanner* scanner, bool firstOccurence, const SpecFile* specFile);
|
|
// Keep track of the final version of this API, if any.
|
|
void updateFinalVersion(const VersionInfo& info);
|
|
};
|
|
|
|
/* Represents a constant, like M_PI. This is a grouping of the version specific specifications.
|
|
* We'll only have one instance of Constant for each name.
|
|
*/
|
|
class Constant : public Definition {
|
|
private:
|
|
std::vector<ConstantSpecification*> mSpecifications; // Owned
|
|
|
|
public:
|
|
Constant(const std::string& name) : Definition(name) {}
|
|
~Constant();
|
|
|
|
const std::vector<ConstantSpecification*> getSpecifications() const { return mSpecifications; }
|
|
// This method should only be called by the scanning code.
|
|
void addSpecification(ConstantSpecification* spec) { mSpecifications.push_back(spec); }
|
|
};
|
|
|
|
/* Represents a type, like "float4". This is a grouping of the version specific specifications.
|
|
* We'll only have one instance of Type for each name.
|
|
*/
|
|
class Type : public Definition {
|
|
private:
|
|
std::vector<TypeSpecification*> mSpecifications; // Owned
|
|
|
|
public:
|
|
Type(const std::string& name) : Definition(name) {}
|
|
~Type();
|
|
|
|
const std::vector<TypeSpecification*> getSpecifications() const { return mSpecifications; }
|
|
// This method should only be called by the scanning code.
|
|
void addSpecification(TypeSpecification* spec) { mSpecifications.push_back(spec); }
|
|
};
|
|
|
|
/* Represents a function, like "clamp". Even though the spec file contains many entries for clamp,
|
|
* we'll only have one clamp instance.
|
|
*/
|
|
class Function : public Definition {
|
|
private:
|
|
// mName in the base class contains the lower case name, e.g. native_log
|
|
std::string mCapitalizedName; // The capitalized name, e.g. NativeLog
|
|
|
|
// The unique parameters between all the specifications. NOT OWNED.
|
|
std::vector<ParameterEntry*> mParameters;
|
|
std::string mReturnDocumentation;
|
|
|
|
std::vector<FunctionSpecification*> mSpecifications; // Owned
|
|
|
|
public:
|
|
Function(const std::string& name);
|
|
~Function();
|
|
|
|
std::string getCapitalizedName() const { return mCapitalizedName; }
|
|
const std::vector<ParameterEntry*>& getParameters() const { return mParameters; }
|
|
std::string getReturnDocumentation() const { return mReturnDocumentation; }
|
|
const std::vector<FunctionSpecification*> getSpecifications() const { return mSpecifications; }
|
|
|
|
bool someParametersAreDocumented() const;
|
|
|
|
// The following methods should only be called by the scanning code.
|
|
void addParameter(ParameterEntry* entry, Scanner* scanner);
|
|
void addReturn(ParameterEntry* entry, Scanner* scanner);
|
|
void addSpecification(FunctionSpecification* spec) { mSpecifications.push_back(spec); }
|
|
};
|
|
|
|
/* Base class for TypeSpecification, ConstantSpecification, and FunctionSpecification.
|
|
* A specification can be specific to a range of RenderScript version or 32bits vs 64 bits.
|
|
* This base class contains code to parse and store this version information.
|
|
*/
|
|
class Specification {
|
|
protected:
|
|
VersionInfo mVersionInfo;
|
|
void scanVersionInfo(Scanner* scanner);
|
|
|
|
public:
|
|
VersionInfo getVersionInfo() const { return mVersionInfo; }
|
|
};
|
|
|
|
/* Defines one of the many variations of a constant. There's a one to one correspondence between
|
|
* ConstantSpecification objects and entries in the spec file.
|
|
*/
|
|
class ConstantSpecification : public Specification {
|
|
private:
|
|
Constant* mConstant; // Not owned
|
|
|
|
std::string mValue; // E.g. "3.1415"
|
|
std::string mType; // E.g. "float"
|
|
public:
|
|
ConstantSpecification(Constant* constant) : mConstant(constant) {}
|
|
|
|
Constant* getConstant() const { return mConstant; }
|
|
std::string getValue() const { return mValue; }
|
|
std::string getType() const { return mType; }
|
|
|
|
// Parse a constant specification and add it to specFile.
|
|
static void scanConstantSpecification(Scanner* scanner, SpecFile* specFile, unsigned int maxApiLevel);
|
|
};
|
|
|
|
enum TypeKind {
|
|
SIMPLE,
|
|
RS_OBJECT,
|
|
STRUCT,
|
|
ENUM,
|
|
};
|
|
|
|
/* Defines one of the many variations of a type. There's a one to one correspondence between
|
|
* TypeSpecification objects and entries in the spec file.
|
|
*/
|
|
class TypeSpecification : public Specification {
|
|
private:
|
|
Type* mType; // Not owned
|
|
|
|
TypeKind mKind; // The kind of type specification
|
|
|
|
// If mKind is SIMPLE:
|
|
std::string mSimpleType; // The definition of the type
|
|
|
|
// If mKind is STRUCT:
|
|
std::string mStructName; // The name found after the struct keyword
|
|
std::vector<std::string> mFields; // One entry per struct field
|
|
std::vector<std::string> mFieldComments; // One entry per struct field
|
|
std::string mAttribute; // Some structures may have attributes
|
|
|
|
// If mKind is ENUM:
|
|
std::string mEnumName; // The name found after the enum keyword
|
|
std::vector<std::string> mValues; // One entry per enum value
|
|
std::vector<std::string> mValueComments; // One entry per enum value
|
|
public:
|
|
TypeSpecification(Type* type) : mType(type) {}
|
|
|
|
Type* getType() const { return mType; }
|
|
TypeKind getKind() const { return mKind; }
|
|
std::string getSimpleType() const { return mSimpleType; }
|
|
std::string getStructName() const { return mStructName; }
|
|
const std::vector<std::string>& getFields() const { return mFields; }
|
|
const std::vector<std::string>& getFieldComments() const { return mFieldComments; }
|
|
std::string getAttribute() const { return mAttribute; }
|
|
std::string getEnumName() const { return mEnumName; }
|
|
const std::vector<std::string>& getValues() const { return mValues; }
|
|
const std::vector<std::string>& getValueComments() const { return mValueComments; }
|
|
|
|
// Parse a type specification and add it to specFile.
|
|
static void scanTypeSpecification(Scanner* scanner, SpecFile* specFile, unsigned int maxApiLevel);
|
|
};
|
|
|
|
// Maximum number of placeholders (like #1, #2) in function specifications.
|
|
const int MAX_REPLACEABLES = 4;
|
|
|
|
/* Defines one of the many variations of the function. There's a one to one correspondence between
|
|
* FunctionSpecification objects and entries in the spec file. Some of the strings that are parts
|
|
* of a FunctionSpecification can include placeholders, which are "#1", "#2", "#3", and "#4". We'll
|
|
* replace these by values before generating the files.
|
|
*/
|
|
class FunctionSpecification : public Specification {
|
|
private:
|
|
Function* mFunction; // Not owned
|
|
|
|
/* How to test. One of:
|
|
* "scalar": Generate test code that checks entries of each vector indepently. E.g. for
|
|
* sin(float3), the test code will call the CoreMathVerfier.computeSin 3 times.
|
|
* "limited": Like "scalar" but we don't generate extreme values. This is not currently
|
|
* enabled as we were generating to many errors.
|
|
* "custom": Like "scalar" but instead of calling CoreMathVerifier.computeXXX() to compute
|
|
* the expected value, we call instead CoreMathVerifier.verifyXXX(). This method
|
|
* returns a string that contains the error message, null if there's no error.
|
|
* "vector": Generate test code that calls the CoreMathVerifier only once for each vector.
|
|
* This is useful for APIs like dot() or length().
|
|
* "noverify": Generate test code that calls the API but don't verify the returned value.
|
|
* This can discover unresolved references.
|
|
* "": Don't test. This is the default.
|
|
*/
|
|
std::string mTest;
|
|
bool mInternal; // Internal. Not visible to users. (Default: false)
|
|
bool mIntrinsic; // Compiler intrinsic that is lowered to an internal API.
|
|
// (Default: false)
|
|
std::string mAttribute; // Function attributes.
|
|
std::string mPrecisionLimit; // Maximum precision required when checking output of this
|
|
// function.
|
|
|
|
// The vectors of values with which we'll replace #1, #2, ...
|
|
std::vector<std::vector<std::string> > mReplaceables;
|
|
|
|
// i-th entry is true if each entry in mReplaceables[i] has an equivalent
|
|
// RS numerical type (i.e. present in TYPES global)
|
|
std::vector<bool> mIsRSTAllowed;
|
|
|
|
/* The collection of permutations for this specification, i.e. this class instantianted
|
|
* for specific values of #1, #2, etc. Owned.
|
|
*/
|
|
std::vector<FunctionPermutation*> mPermutations;
|
|
|
|
// The following fields may contain placeholders that will be replaced using the mReplaceables.
|
|
|
|
/* As of this writing, convert_... is the only function with #1 in its name.
|
|
* The related Function object contains the name of the function without #n, e.g. convert.
|
|
* This is the name with the #, e.g. convert_#1_#2
|
|
*/
|
|
std::string mUnexpandedName;
|
|
ParameterEntry* mReturn; // The return type. The name should be empty. Owned.
|
|
std::vector<ParameterEntry*> mParameters; // The parameters. Owned.
|
|
std::vector<std::string> mInline; // The inline code to be included in the header
|
|
|
|
/* Substitute the placeholders in the strings (e.g. #1, #2, ...) by the
|
|
* corresponding entries in mReplaceables. Substitute placeholders for RS
|
|
* types (#RST_1, #RST_2, ...) by the RS Data type strings (UNSIGNED_8,
|
|
* FLOAT_32 etc.) of the corresponding types in mReplaceables.
|
|
* indexOfReplaceable1 selects with value to use for #1, same for 2, 3, and
|
|
* 4.
|
|
*/
|
|
std::string expandString(std::string s, int indexOfReplaceable[MAX_REPLACEABLES]) const;
|
|
void expandStringVector(const std::vector<std::string>& in,
|
|
int replacementIndexes[MAX_REPLACEABLES],
|
|
std::vector<std::string>* out) const;
|
|
|
|
// Helper function used by expandString to perform #RST_* substitution
|
|
std::string expandRSTypeInString(const std::string &s,
|
|
const std::string &pattern,
|
|
const std::string &cTypeStr) const;
|
|
|
|
// Fill the mPermutations field.
|
|
void createPermutations(Function* function, Scanner* scanner);
|
|
|
|
public:
|
|
FunctionSpecification(Function* function) : mFunction(function), mInternal(false),
|
|
mIntrinsic(false), mReturn(nullptr) {}
|
|
~FunctionSpecification();
|
|
|
|
Function* getFunction() const { return mFunction; }
|
|
bool isInternal() const { return mInternal; }
|
|
bool isIntrinsic() const { return mIntrinsic; }
|
|
std::string getAttribute() const { return mAttribute; }
|
|
std::string getTest() const { return mTest; }
|
|
std::string getPrecisionLimit() const { return mPrecisionLimit; }
|
|
|
|
const std::vector<FunctionPermutation*>& getPermutations() const { return mPermutations; }
|
|
|
|
std::string getName(int replacementIndexes[MAX_REPLACEABLES]) const;
|
|
void getReturn(int replacementIndexes[MAX_REPLACEABLES], std::string* retType,
|
|
int* lineNumber) const;
|
|
size_t getNumberOfParams() const { return mParameters.size(); }
|
|
void getParam(size_t index, int replacementIndexes[MAX_REPLACEABLES], std::string* type,
|
|
std::string* name, std::string* testOption, int* lineNumber) const;
|
|
void getInlines(int replacementIndexes[MAX_REPLACEABLES],
|
|
std::vector<std::string>* inlines) const;
|
|
|
|
// Parse the "test:" line.
|
|
void parseTest(Scanner* scanner);
|
|
|
|
// Return true if we need to generate tests for this function.
|
|
bool hasTests(unsigned int versionOfTestFiles) const;
|
|
|
|
bool hasInline() const { return mInline.size() > 0; }
|
|
|
|
/* Return true if this function can be overloaded. This is added by default to all
|
|
* specifications, so except for the very few exceptions that start the attributes
|
|
* with an '=' to avoid this, we'll return true.
|
|
*/
|
|
bool isOverloadable() const {
|
|
return mAttribute.empty() || mAttribute[0] != '=';
|
|
}
|
|
|
|
/* Check if RST_i is present in 's' and report an error if 'allow' is false
|
|
* or the i-th replacement list is not a valid candidate for RST_i
|
|
* replacement
|
|
*/
|
|
void checkRSTPatternValidity(const std::string &s, bool allow, Scanner *scanner);
|
|
|
|
// Parse a function specification and add it to specFile.
|
|
static void scanFunctionSpecification(Scanner* scanner, SpecFile* specFile, unsigned int maxApiLevel);
|
|
};
|
|
|
|
/* A concrete version of a function specification, where all placeholders have been replaced by
|
|
* actual values.
|
|
*/
|
|
class FunctionPermutation {
|
|
private:
|
|
// These are the expanded version of those found on FunctionSpecification
|
|
std::string mName;
|
|
std::string mNameTrunk; // The name without any expansion, e.g. convert
|
|
std::string mTest; // How to test. One of "scalar", "vector", "noverify", "limited", and
|
|
// "none".
|
|
std::string mPrecisionLimit; // Maximum precision required when checking output of this
|
|
// function.
|
|
|
|
// The parameters of the function. This does not include the return type. Owned.
|
|
std::vector<ParameterDefinition*> mParams;
|
|
// The return type. nullptr if a void function. Owned.
|
|
ParameterDefinition* mReturn;
|
|
|
|
// The number of input and output parameters. mOutputCount counts the return type.
|
|
int mInputCount;
|
|
int mOutputCount;
|
|
|
|
// Whether one of the output parameters is a float.
|
|
bool mHasFloatAnswers;
|
|
|
|
// The inline code that implements this function. Will be empty if not an inline.
|
|
std::vector<std::string> mInline;
|
|
|
|
public:
|
|
FunctionPermutation(Function* function, FunctionSpecification* specification,
|
|
int replacementIndexes[MAX_REPLACEABLES], Scanner* scanner);
|
|
~FunctionPermutation();
|
|
|
|
std::string getName() const { return mName; }
|
|
std::string getNameTrunk() const { return mNameTrunk; }
|
|
std::string getTest() const { return mTest; }
|
|
std::string getPrecisionLimit() const { return mPrecisionLimit; }
|
|
|
|
const std::vector<std::string>& getInline() const { return mInline; }
|
|
const ParameterDefinition* getReturn() const { return mReturn; }
|
|
int getInputCount() const { return mInputCount; }
|
|
int getOutputCount() const { return mOutputCount; }
|
|
bool hasFloatAnswers() const { return mHasFloatAnswers; }
|
|
|
|
const std::vector<ParameterDefinition*> getParams() const { return mParams; }
|
|
};
|
|
|
|
// An entire spec file and the methods to process it.
|
|
class SpecFile {
|
|
private:
|
|
std::string mSpecFileName;
|
|
std::string mHeaderFileName;
|
|
std::string mDetailedDocumentationUrl;
|
|
std::string mBriefDescription;
|
|
std::vector<std::string> mFullDescription;
|
|
// Text to insert as-is in the generated header.
|
|
std::vector<std::string> mVerbatimInclude;
|
|
|
|
/* The constants, types, and functions specifications declared in this
|
|
* file, in the order they are found in the file. This matters for
|
|
* header generation, as some types and inline functions depend
|
|
* on each other. Pointers not owned.
|
|
*/
|
|
std::list<ConstantSpecification*> mConstantSpecificationsList;
|
|
std::list<TypeSpecification*> mTypeSpecificationsList;
|
|
std::list<FunctionSpecification*> mFunctionSpecificationsList;
|
|
|
|
/* The constants, types, and functions that are documented in this file.
|
|
* In very rare cases, specifications for an API are split across multiple
|
|
* files, e.g. currently for ClearObject(). The documentation for
|
|
* that function must be found in the first spec file encountered, so the
|
|
* order of the files on the command line matters.
|
|
*/
|
|
std::map<std::string, Constant*> mDocumentedConstants;
|
|
std::map<std::string, Type*> mDocumentedTypes;
|
|
std::map<std::string, Function*> mDocumentedFunctions;
|
|
|
|
public:
|
|
explicit SpecFile(const std::string& specFileName);
|
|
|
|
std::string getSpecFileName() const { return mSpecFileName; }
|
|
std::string getHeaderFileName() const { return mHeaderFileName; }
|
|
std::string getDetailedDocumentationUrl() const { return mDetailedDocumentationUrl; }
|
|
const std::string getBriefDescription() const { return mBriefDescription; }
|
|
const std::vector<std::string>& getFullDescription() const { return mFullDescription; }
|
|
const std::vector<std::string>& getVerbatimInclude() const { return mVerbatimInclude; }
|
|
|
|
const std::list<ConstantSpecification*>& getConstantSpecifications() const {
|
|
return mConstantSpecificationsList;
|
|
}
|
|
const std::list<TypeSpecification*>& getTypeSpecifications() const {
|
|
return mTypeSpecificationsList;
|
|
}
|
|
const std::list<FunctionSpecification*>& getFunctionSpecifications() const {
|
|
return mFunctionSpecificationsList;
|
|
}
|
|
const std::map<std::string, Constant*>& getDocumentedConstants() const {
|
|
return mDocumentedConstants;
|
|
}
|
|
const std::map<std::string, Type*>& getDocumentedTypes() const { return mDocumentedTypes; }
|
|
const std::map<std::string, Function*>& getDocumentedFunctions() const {
|
|
return mDocumentedFunctions;
|
|
}
|
|
|
|
bool hasSpecifications() const {
|
|
return !mDocumentedConstants.empty() || !mDocumentedTypes.empty() ||
|
|
!mDocumentedFunctions.empty();
|
|
}
|
|
|
|
bool readSpecFile(unsigned int maxApiLevel);
|
|
|
|
/* These are called by the parser to keep track of the specifications defined in this file.
|
|
* hasDocumentation is true if this specification containes the documentation.
|
|
*/
|
|
void addConstantSpecification(ConstantSpecification* spec, bool hasDocumentation);
|
|
void addTypeSpecification(TypeSpecification* spec, bool hasDocumentation);
|
|
void addFunctionSpecification(FunctionSpecification* spec, bool hasDocumentation);
|
|
};
|
|
|
|
// The collection of all the spec files.
|
|
class SystemSpecification {
|
|
private:
|
|
std::vector<SpecFile*> mSpecFiles;
|
|
|
|
/* Entries in the table of contents. We accumulate them in a map to sort them.
|
|
* Pointers are owned.
|
|
*/
|
|
std::map<std::string, Constant*> mConstants;
|
|
std::map<std::string, Type*> mTypes;
|
|
std::map<std::string, Function*> mFunctions;
|
|
|
|
public:
|
|
~SystemSpecification();
|
|
|
|
/* These are called the parser to create unique instances per name. Set *created to true
|
|
* if the named specification did not already exist.
|
|
*/
|
|
Constant* findOrCreateConstant(const std::string& name, bool* created);
|
|
Type* findOrCreateType(const std::string& name, bool* created);
|
|
Function* findOrCreateFunction(const std::string& name, bool* created);
|
|
|
|
/* Parse the spec file and create the object hierarchy, adding a pointer to mSpecFiles.
|
|
* We won't include information passed the specified level.
|
|
*/
|
|
bool readSpecFile(const std::string& fileName, unsigned int maxApiLevel);
|
|
// Generate all the files.
|
|
bool generateFiles(unsigned int maxApiLevel) const;
|
|
|
|
const std::vector<SpecFile*>& getSpecFiles() const { return mSpecFiles; }
|
|
const std::map<std::string, Constant*>& getConstants() const { return mConstants; }
|
|
const std::map<std::string, Type*>& getTypes() const { return mTypes; }
|
|
const std::map<std::string, Function*>& getFunctions() const { return mFunctions; }
|
|
|
|
// Returns "<a href='...'> for the named specification, or empty if not found.
|
|
std::string getHtmlAnchor(const std::string& name) const;
|
|
|
|
// Returns the maximum API level specified in any spec file.
|
|
unsigned int getMaximumApiLevel();
|
|
};
|
|
|
|
// Singleton that represents the collection of all the specs we're processing.
|
|
extern SystemSpecification systemSpecification;
|
|
|
|
// Table of equivalences of numerical types.
|
|
extern const NumericalType TYPES[];
|
|
extern const int NUM_TYPES;
|
|
|
|
/* Given a renderscript type (string) calculate the vector size and base type. If the type
|
|
* is not a vector the vector size is 1 and baseType is just the type itself.
|
|
*/
|
|
void getVectorSizeAndBaseType(const std::string& type, std::string& vectorSize,
|
|
std::string& baseType);
|
|
|
|
#endif // ANDROID_RS_API_GENERATOR_SPECIFICATION_H
|