1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#ifndef QSSG_GLSLENGINE_H
#define QSSG_GLSLENGINE_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtQuick3DGlslParser/private/glsl_p.h>
#include <QtQuick3DGlslParser/private/glslmemorypool_p.h>
#include <QtQuick3DGlslParser/private/glsltypes_p.h>
#include <qstring.h>
#include <functional>
#include <set>
#include <unordered_set>
QT_BEGIN_NAMESPACE
namespace GLSL {
class Q_QUICK3DGLSLPARSER_EXPORT DiagnosticMessage
{
public:
enum Kind {
Warning,
Error
};
DiagnosticMessage();
Kind kind() const;
void setKind(Kind kind);
bool isError() const;
bool isWarning() const;
QString fileName() const;
void setFileName(const QString &fileName);
int line() const;
void setLine(int line);
QString message() const;
void setMessage(const QString &message);
private:
QString _fileName;
QString _message;
Kind _kind;
int _line;
};
template <typename Type>
class TypeTable
{
public:
struct Compare {
bool operator()(const Type &value, const Type &other) const {
return value.isLessThan(&other);
}
};
const Type *intern(const Type &ty) { return &*_entries.insert(ty).first; }
private:
std::set<Type, Compare> _entries;
};
class Q_QUICK3DGLSLPARSER_EXPORT Engine
{
public:
Engine();
~Engine();
const QString *identifier(const QString &s);
const QString *identifier(const char *s, int n);
std::unordered_set<QString> identifiers() const;
const QString *number(const QString &s);
const QString *number(const char *s, int n);
std::unordered_set<QString> numbers() const;
// types
const UndefinedType *undefinedType();
const VoidType *voidType();
const BoolType *boolType();
const IntType *intType();
const UIntType *uintType();
const FloatType *floatType();
const DoubleType *doubleType();
const SamplerType *samplerType(int kind);
const VectorType *vectorType(const Type *elementType, int dimension);
const MatrixType *matrixType(const Type *elementType, int columns, int rows);
const ArrayType *arrayType(const Type *elementType);
// symbols
Namespace *newNamespace();
Struct *newStruct(Scope *scope = nullptr);
Block *newBlock(Scope *scope = nullptr);
Function *newFunction(Scope *scope = nullptr);
Argument *newArgument(Function *function, const QString &name, const Type *type);
Variable *newVariable(Scope *scope, const QString &name, const Type *type, int qualifiers = 0);
MemoryPool *pool();
bool blockDiagnosticMessages(bool block);
QList<DiagnosticMessage> diagnosticMessages() const;
void clearDiagnosticMessages();
void addDiagnosticMessage(const DiagnosticMessage &m);
void warning(int line, const QString &message);
void error(int line, const QString &message);
private:
std::unordered_set<QString> _identifiers;
std::unordered_set<QString> _numbers;
TypeTable<VectorType> _vectorTypes;
TypeTable<MatrixType> _matrixTypes;
TypeTable<ArrayType> _arrayTypes;
TypeTable<SamplerType> _samplerTypes;
MemoryPool _pool;
QList<DiagnosticMessage> _diagnosticMessages;
QList<Symbol *> _symbols;
bool _blockDiagnosticMessages;
};
} // namespace GLSL
QT_END_NAMESPACE
#endif // QSSG_GLSLENGINE_H
|
