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
141
142
143
144
145
146
147
148
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#pragma once
#include "glsl.h"
#include "glslmemorypool.h"
#include "glsltypes.h"
#include <qstring.h>
#include <functional>
#include <set>
#include <unordered_set>
namespace GLSL {
class GLSL_EXPORT DiagnosticMessage
{
public:
enum Kind {
Warning,
Error
};
struct GLSL_EXPORT Location
{
int line = -1;
int position = -1;
int length = -1;
bool operator==(const Location &rhs) const
{
return line == rhs.line && position == rhs.position && length == rhs.length;
}
};
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);
void setLocation(const Location &location);
Location location() const;
QString message() const;
void setMessage(const QString &message);
private:
QString _fileName;
QString _message;
Kind _kind;
Location _location;
int _line;
};
inline size_t qHash(const DiagnosticMessage::Location &location, size_t seed)
{
return ::qHashMulti(seed, location.line, location.position, location.length);
}
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 GLSL_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 ImageType *imageType(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);
InterfaceBlock *newInterfaceBlock(Scope *scope = nullptr);
SubroutineType *newSubroutineType(Scope *scope);
MemoryPool *pool();
bool blockDiagnosticMessages(bool block);
QList<DiagnosticMessage> diagnosticMessages() const;
void clearDiagnosticMessages();
void addDiagnosticMessage(const DiagnosticMessage &m);
void warning(const DiagnosticMessage::Location &location, const QString &message);
void error(const DiagnosticMessage::Location &location, 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;
TypeTable<ImageType> _imageTypes;
MemoryPool _pool;
QList<DiagnosticMessage> _diagnosticMessages;
QList<Symbol *> _symbols;
bool _blockDiagnosticMessages;
};
} // namespace GLSL
|
