Revision control
Copy as Markdown
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "glslengine_p.h"
#include "glslsymbols_p.h"
#include "glsltypes_p.h"
#include "glslparser_p.h"
QT_BEGIN_NAMESPACE
using namespace GLSL;
DiagnosticMessage::DiagnosticMessage()
: _kind(Error), _line(0)
{
}
DiagnosticMessage::Kind DiagnosticMessage::kind() const
{
return _kind;
}
void DiagnosticMessage::setKind(Kind kind)
{
_kind = kind;
}
QString DiagnosticMessage::fileName() const
{
return _fileName;
}
void DiagnosticMessage::setFileName(const QString &fileName)
{
_fileName = fileName;
}
int DiagnosticMessage::line() const
{
return _line;
}
void DiagnosticMessage::setLine(int line)
{
_line = line;
}
QString DiagnosticMessage::message() const
{
return _message;
}
void DiagnosticMessage::setMessage(const QString &message)
{
_message = message;
}
Engine::Engine()
: _blockDiagnosticMessages(false)
{
}
Engine::~Engine()
{
qDeleteAll(_symbols);
}
const QString *Engine::identifier(const QString &s)
{
return &(*_identifiers.insert(s).first);
}
const QString *Engine::identifier(const char *s, int n)
{
return &(*_identifiers.insert(QString::fromLatin1(s, n)).first);
}
std::unordered_set<QString> Engine::identifiers() const
{
return _identifiers;
}
const QString *Engine::number(const QString &s)
{
return &(*_numbers.insert(s).first);
}
const QString *Engine::number(const char *s, int n)
{
return &(*_numbers.insert(QString::fromLatin1(s, n)).first);
}
std::unordered_set<QString> Engine::numbers() const
{
return _numbers;
}
MemoryPool *Engine::pool()
{
return &_pool;
}
const UndefinedType *Engine::undefinedType()
{
static UndefinedType t;
return &t;
}
const VoidType *Engine::voidType()
{
static VoidType t;
return &t;
}
const BoolType *Engine::boolType()
{
static BoolType t;
return &t;
}
const IntType *Engine::intType()
{
static IntType t;
return &t;
}
const UIntType *Engine::uintType()
{
static UIntType t;
return &t;
}
const FloatType *Engine::floatType()
{
static FloatType t;
return &t;
}
const DoubleType *Engine::doubleType()
{
static DoubleType t;
return &t;
}
const SamplerType *Engine::samplerType(int kind)
{
return _samplerTypes.intern(SamplerType(kind));
}
const VectorType *Engine::vectorType(const Type *elementType, int dimension)
{
VectorType *type = const_cast<VectorType *>
(_vectorTypes.intern(VectorType(elementType, dimension)));
type->populateMembers(this);
return type;
}
const MatrixType *Engine::matrixType(const Type *elementType, int columns, int rows)
{
return _matrixTypes.intern(MatrixType(elementType, columns, rows,
vectorType(elementType, rows)));
}
const ArrayType *Engine::arrayType(const Type *elementType)
{
return _arrayTypes.intern(ArrayType(elementType));
}
QList<DiagnosticMessage> Engine::diagnosticMessages() const
{
return _diagnosticMessages;
}
void Engine::clearDiagnosticMessages()
{
_diagnosticMessages.clear();
}
void Engine::addDiagnosticMessage(const DiagnosticMessage &m)
{
if (! _blockDiagnosticMessages)
_diagnosticMessages.append(m);
}
void Engine::warning(int line, const QString &message)
{
DiagnosticMessage m;
m.setKind(DiagnosticMessage::Warning);
m.setLine(line);
m.setMessage(message);
addDiagnosticMessage(m);
}
void Engine::error(int line, const QString &message)
{
DiagnosticMessage m;
m.setKind(DiagnosticMessage::Error);
m.setLine(line);
m.setMessage(message);
addDiagnosticMessage(m);
}
bool DiagnosticMessage::isError() const
{
return _kind == Error;
}
bool DiagnosticMessage::isWarning() const
{
return _kind == Warning;
}
Namespace *Engine::newNamespace()
{
Namespace *s = new Namespace();
_symbols.append(s);
return s;
}
Struct *Engine::newStruct(Scope *scope)
{
Struct *s = new Struct(scope);
_symbols.append(s);
return s;
}
Block *Engine::newBlock(Scope *scope)
{
Block *s = new Block(scope);
_symbols.append(s);
return s;
}
Function *Engine::newFunction(Scope *scope)
{
Function *s = new Function(scope);
_symbols.append(s);
return s;
}
Argument *Engine::newArgument(Function *function, const QString &name, const Type *type)
{
Argument *a = new Argument(function);
a->setName(name);
a->setType(type);
_symbols.append(a);
return a;
}
Variable *Engine::newVariable(Scope *scope, const QString &name, const Type *type, int qualifiers)
{
Variable *var = new Variable(scope);
var->setName(name);
var->setType(type);
var->setQualifiers(qualifiers);
_symbols.append(var);
return var;
}
bool Engine::blockDiagnosticMessages(bool block)
{
bool previous = _blockDiagnosticMessages;
_blockDiagnosticMessages = block;
return previous;
}
QT_END_NAMESPACE