mirror of https://github.com/procxx/kepka.git
137 lines
3.7 KiB
C++
137 lines
3.7 KiB
C++
/*
|
|
This file is part of Telegram Desktop,
|
|
the official desktop version of Telegram messaging app, see https://telegram.org
|
|
|
|
Telegram Desktop is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
It is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
In addition, as a special exception, the copyright holders give permission
|
|
to link the code of portions of this program with the OpenSSL library.
|
|
|
|
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
|
|
Copyright (c) 2014-2016 John Preston, https://desktop.telegram.org
|
|
*/
|
|
#include "codegen/style/tokenized_file.h"
|
|
|
|
#include <iostream>
|
|
#include <QtCore/QDir>
|
|
|
|
#include "codegen/common/basic_tokenized_file.h"
|
|
#include "codegen/common/logging.h"
|
|
|
|
using Token = codegen::style::TokenizedFile::Token;
|
|
using Type = Token::Type;
|
|
using BasicToken = codegen::common::BasicTokenizedFile::Token;
|
|
using BasicType = BasicToken::Type;
|
|
|
|
namespace codegen {
|
|
namespace style {
|
|
namespace {
|
|
|
|
QString plainValue(const BasicToken &token) {
|
|
return token.original.toStringUnchecked();
|
|
}
|
|
|
|
Token invalidToken() {
|
|
return { Type::Invalid, QString() };
|
|
}
|
|
|
|
} // namespace
|
|
|
|
TokenizedFile::TokenizedFile(const QString &filepath) : file_(filepath) {
|
|
}
|
|
|
|
bool TokenizedFile::putBack() {
|
|
if (currentToken_ > 0) {
|
|
--currentToken_;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Token TokenizedFile::getToken() {
|
|
if (currentToken_ >= tokens_.size()) {
|
|
if (readToken() == Type::Invalid) {
|
|
return invalidToken();
|
|
}
|
|
}
|
|
return tokens_.at(currentToken_++);
|
|
}
|
|
|
|
Type TokenizedFile::readToken() {
|
|
switch (state_) {
|
|
case State::Default: return readInDefault();
|
|
case State::StructStarted: return readInStructStarted();
|
|
case State::StructFieldName: return readInStructFieldName();
|
|
case State::Variable: return readInVariable();
|
|
case State::VariableParents: return readInVariableParents();
|
|
case State::VariableStarted: return readInVariableStarted();
|
|
case State::VariableChild: return readInVariableChild();
|
|
}
|
|
return Type::Invalid;
|
|
}
|
|
|
|
Type TokenizedFile::readInDefault() {
|
|
if (auto basicToken = file_.getToken(BasicType::Name)) {
|
|
if (plainValue(basicToken) == "using") {
|
|
if (auto usingFile = file_.getToken(BasicType::String)) {
|
|
if (file_.getToken(BasicType::Semicolon)) {
|
|
return saveToken(Type::Using, usingFile.value);
|
|
}
|
|
file_.logErrorUnexpectedToken("';'");
|
|
} else {
|
|
file_.logErrorUnexpectedToken("file path");
|
|
}
|
|
return Type::Invalid;
|
|
}
|
|
if (auto braceToken = file_.getToken(BasicType::LeftBrace)) {
|
|
state_ = State::StructStarted;
|
|
return saveToken(Type::DefineStruct, plainValue(basicToken));
|
|
} else if (auto colonToken = file_.getToken(BasicType::Colon)) {
|
|
state_ = State::Variable;
|
|
return saveToken(Type::DefineVariable, plainValue(basicToken));
|
|
}
|
|
file_.logErrorUnexpectedToken("using keyword, or struct definition, or variable definition");
|
|
}
|
|
return Type::Invalid;
|
|
}
|
|
|
|
Type TokenizedFile::readInStructStarted() {
|
|
return Type::Invalid;
|
|
}
|
|
|
|
Type TokenizedFile::readInStructFieldName() {
|
|
return Type::Invalid;
|
|
}
|
|
|
|
Type TokenizedFile::readInVariable() {
|
|
return Type::Invalid;
|
|
}
|
|
|
|
Type TokenizedFile::readInVariableParents() {
|
|
return Type::Invalid;
|
|
}
|
|
|
|
Type TokenizedFile::readInVariableStarted() {
|
|
return Type::Invalid;
|
|
}
|
|
|
|
Type TokenizedFile::readInVariableChild() {
|
|
return Type::Invalid;
|
|
}
|
|
|
|
Type TokenizedFile::saveToken(Type type, const QString &value) {
|
|
tokens_.push_back({ type, value });
|
|
return type;
|
|
}
|
|
|
|
} // namespace style
|
|
} // namespace codegen
|