void SimilarShapeSegmentPage::apply() {
TDoubleParam *curve = getCurve();
if (!curve) return;
int kIndex = getViewer()->getSegmentIndex();
if (kIndex < 0) return;
std::string expressionText = m_expressionFld->getExpression();
TExpression expr;
expr.setGrammar(curve->getGrammar());
expr.setText(expressionText);
if (!expr.isValid()) {
DVGui::warning(
tr("There is a syntax error in the definition of the interpolation."));
return;
}
if (dependsOn(expr, curve)) {
DVGui::warning(
tr("There is a circular reference in the definition of the "
"interpolation."));
return;
}
KeyframeSetter setter(curve, kIndex);
setter.setSimilarShape(m_expressionFld->getExpression(),
m_offsetFld->text().toDouble());
}
void TLocalVar::AnalyzeSyntax(Lexer::ILexer* source) {
InitPos(source);
type->AnalyzeSyntax(source);
is_static = source->TestAndGet(TResWord::Static);
assert(parent->GetType()==TStatementType::Statements);
TStatements* statements = (TStatements*) parent;
TLocalVar* curr_var = this;
do {
if (curr_var != this) {
curr_var->type = type;
curr_var->is_static = is_static;
*(TTokenPos*) curr_var = *(TTokenPos*) this;
}
curr_var->name = source->NameId();
int identifier_token = source->GetCurrentToken();
source->SetCurrentToken(identifier_token + 1);
bool is_next_assign = source->Test(
TOperator::Assign);
source->SetCurrentToken(identifier_token);
if (is_next_assign)
{
//source->GetToken(TTokenType::Identifier);
//source->TestAndGet(TOperator::Assign);
curr_var->assign_expr.reset(new TExpression(owner, method, parent,
curr_var->stmt_id));
curr_var->assign_expr->AnalyzeSyntax(source);
} else {
source->GetToken();
if (source->TestAndGet(TTokenType::LParenth))
{
while (!source->Test(TTokenType::RParenth))
{
TExpression* expr = new TExpression(owner, method, parent,
curr_var->stmt_id);
expr->AnalyzeSyntax(source);
curr_var->params.push_back(std::unique_ptr<TExpression>(expr));
if (!source->TestAndGet(TTokenType::Comma))
break;
}
source->GetToken(TTokenType::RParenth);
}
}
if ((source->Test(TTokenType::Comma) || source->Test(TTokenType::Semicolon)) && (curr_var != this))
{
statements->AddVar(curr_var);
if (curr_var->assign_expr)
curr_var->assign_expr->SetStmtId(curr_var->stmt_id);
if (curr_var->params.size() > 0)
{
for (const std::unique_ptr<TExpression>& v : curr_var->params)
v->SetStmtId(curr_var->stmt_id);
}
}
if (source->Test(TTokenType::Comma))
{
curr_var = new TLocalVar(owner, method, statements, -1);
}
} while (source->TestAndGet(TTokenType::Comma));
}
void FunctionExpressionSegmentPage::apply() {
TDoubleParam *curve = getCurve();
if (!curve) return;
int kIndex = getViewer()->getSegmentIndex();
if (kIndex < 0) return;
std::string expressionText = m_expressionFld->getExpression();
TExpression expr;
expr.setGrammar(curve->getGrammar());
expr.setText(expressionText);
if (dependsOn(expr, curve)) {
DVGui::warning(
tr("There is a circular reference in the definition of the "
"interpolation."));
return;
}
std::string unitName = m_unitFld->text().toStdString();
KeyframeSetter setter(curve, kIndex);
setter.setExpression(m_expressionFld->getExpression());
setter.setUnitName(unitName);
/*
TDoubleKeyframe kf0 = curve->getKeyframeAt(getR0());
kf0.m_expressionText = m_expressionFld->getExpression();
kf0.m_unitName = m_unitFld->text().toStdString();
curve->setKeyframe(kf0);
wstring unitExtension = m_unitFld->text().toStdWString();
TMeasure *curveMeasure = curve->getMeasure();
if(curveMeasure)
{
TUnit *unit = curveMeasure->getUnit(unitExtension);
if(unit)
curveMeasure->setCurrentUnit(unit);
else
{
unitExtension = curveMeasure->getCurrentUnit()->getDefaultExtension();
m_unitFld->setText(QString::fromStdWString(unitExtension));
}
}
else
m_unitFld->setText("");
*/
}
/*! return false if a circular reference is occured
*/
bool FunctionExpressionSegmentPage::getGuiValues(std::string &expressionText,
std::string &unitName) {
expressionText = m_expressionFld->getExpression();
// checking a circular reference
TDoubleParam *curve = getCurve();
TExpression expr;
expr.setGrammar(curve->getGrammar());
expr.setText(expressionText);
if (dependsOn(expr, curve)) {
DVGui::warning(
tr("There is a circular reference in the definition of the "
"interpolation."));
return false;
}
unitName = m_unitFld->text().toStdString();
if (m_expressionFld->hasFocus()) m_expressionFld->clearFocus();
return true;
}
bool dependsOn(TExpression &expr, TDoubleParam *possiblyDependentParam) {
ParamDependencyFinder pdf(possiblyDependentParam);
expr.accept(pdf);
return pdf.found();
}
typename TExpression::adjoint_type adjoint(const TExpression& expression)
{
return expression.getAdjoint();
}
void TStatements::AnalyzeStatement(Lexer::ILexer* source, bool end_semicolon) {
switch (source->Type()) {
case TTokenType::LBrace: {
TStatements* s = new TStatements(owner, method, this,
statements.size());
Add(s);
s->AnalyzeSyntax(source);
return;
}
case TTokenType::ResWord: {
switch (source->Token()) {
case TResWord::Return: {
TReturn* t = new TReturn(owner, method, this, statements.size());
Add(t);
t->AnalyzeSyntax(source);
if (!end_semicolon)
source->Error("return можно использовать только как отдельную инструкцию!");
source->GetToken(TTokenType::Semicolon);
return;
}
case TResWord::If: {
TIf* t = new TIf(owner, method, this, statements.size());
Add(t);
t->AnalyzeSyntax(source);
return;
}
case TResWord::For: {
source->GetToken(TResWord::For);
source->GetToken(TTokenType::LParenth);
TStatements* for_stmt = new TStatements(owner, method, this,
statements.size());
Add(for_stmt);
TFor* t =
new TFor(owner, method, for_stmt, for_stmt->GetHigh()+1);
for_stmt->AnalyzeSyntax(source);
for_stmt->Add(t);
t->AnalyzeSyntax(source);
return;
}
case TResWord::While: {
TWhile* t = new TWhile(owner, method, this, statements.size());
Add(t);
t->AnalyzeSyntax(source);
return;
}
case TResWord::This: {
TExpression* t = new TExpression(owner, method, this,
statements.size());
Add(t);
t->AnalyzeSyntax(source);
if (end_semicolon)
source->GetToken(TTokenType::Semicolon);
return;
}
case TResWord::Bytecode: {
TBytecode* t = new TBytecode(owner, method, this,
statements.size());
Add(t);
t->AnalyzeSyntax(source);
if (end_semicolon)
source->GetToken(TTokenType::Semicolon);
return;
}
}
source->Error("Ожидался return,if,for,bytecode или this!");
}
default:
if (IsVarDecl(source)) {
TLocalVar* t = new TLocalVar(owner, method, this,
statements.size());
Add(t);
t->AnalyzeSyntax(source);
} else {
TExpression* t = new TExpression(owner, method, this,
statements.size());
Add(t);
t->AnalyzeSyntax(source);
}
if (end_semicolon)
source->GetToken(TTokenType::Semicolon);
return;
}
assert(false);//во всех switch должен быть return
}
