1916 lines
46 KiB
C#
1916 lines
46 KiB
C#
// Copyright (c) Ivan Bondarev, Stanislav Mihalkovich (for details please see \doc\copyright.txt)
|
||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
||
using System;
|
||
using System.Collections.Generic;
|
||
|
||
namespace PascalABCCompiler.TreeRealization
|
||
{
|
||
/// <summary>
|
||
/// Пустое выражение.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class empty_statement : statement_node
|
||
{
|
||
/// <summary>
|
||
/// Конструктор узла.
|
||
/// </summary>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public empty_statement(location loc) : base(loc)
|
||
{
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип выржения.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.empty_statement;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
}
|
||
|
||
[Serializable]
|
||
public class wrapped_statement : statement_node
|
||
{
|
||
/// <summary>
|
||
/// Конструктор узла.
|
||
/// </summary>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public wrapped_statement(location loc)
|
||
: base(loc)
|
||
{
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип выржения.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.wrapped_statement;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
public virtual statement_node restore()
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class runtime_statement : statement_node, SemanticTree.IRuntimeManagedMethodBody
|
||
{
|
||
private SemanticTree.runtime_statement_type _rts;
|
||
|
||
public runtime_statement(SemanticTree.runtime_statement_type rts,location loc) :base(loc)
|
||
{
|
||
_rts = rts;
|
||
}
|
||
|
||
public SemanticTree.runtime_statement_type runtime_statement_type
|
||
{
|
||
get
|
||
{
|
||
return _rts;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.runtime_statement;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
//TODO: Луше сделать специальный вид функции.
|
||
/// <summary>
|
||
/// Обращение к методу в неуправляемой dll.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class external_statement : statement_node, SemanticTree.IExternalStatementNode
|
||
{
|
||
/// <summary>
|
||
/// Имя dll.
|
||
/// </summary>
|
||
private string _module_name;
|
||
|
||
/// <summary>
|
||
/// Имя метода.
|
||
/// </summary>
|
||
private string _name;
|
||
|
||
/// <summary>
|
||
/// Конструктор узла.
|
||
/// </summary>
|
||
/// <param name="_module_name">Имя dll.</param>
|
||
/// <param name="_name">Имя метода.</param>
|
||
/// <param name="loc">Расположение выражения.</param>
|
||
public external_statement(string _module_name, string _name, location loc) : base(loc)
|
||
{
|
||
this._module_name = _module_name;
|
||
this._name = _name;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Имя dll.
|
||
/// </summary>
|
||
public string module_name
|
||
{
|
||
get
|
||
{
|
||
return _module_name;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Имя метода.
|
||
/// </summary>
|
||
public string name
|
||
{
|
||
get
|
||
{
|
||
return _name;
|
||
}
|
||
set
|
||
{
|
||
_name = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.external_statement_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class pinvoke_statement : statement_node, SemanticTree.IPInvokeStatementNode
|
||
{
|
||
public pinvoke_statement(location loc) : base(loc)
|
||
{
|
||
|
||
}
|
||
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.pinvoke_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Класс, представляющий узел if в программе.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class if_node : statement_node, SemanticTree.IIfNode
|
||
{
|
||
/// <summary>
|
||
/// Условие.
|
||
/// </summary>
|
||
private expression_node _condition;
|
||
|
||
/// <summary>
|
||
/// Тело then.
|
||
/// </summary>
|
||
private statement_node _then_body;
|
||
|
||
/// <summary>
|
||
/// Тело else.
|
||
/// </summary>
|
||
private statement_node _else_body;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="condition">Условие.</param>
|
||
/// <param name="then_body">Тело then.</param>
|
||
/// <param name="else_body">Тело else.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public if_node(expression_node condition,statement_node then_body,statement_node else_body,location loc) :
|
||
base(loc)
|
||
{
|
||
_condition=condition;
|
||
_then_body=then_body;
|
||
_else_body=else_body;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Условие.
|
||
/// </summary>
|
||
public expression_node condition
|
||
{
|
||
get
|
||
{
|
||
return _condition;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тело then.
|
||
/// </summary>
|
||
public statement_node then_body
|
||
{
|
||
get
|
||
{
|
||
return _then_body;
|
||
}
|
||
set
|
||
{
|
||
_then_body = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тело else. Если if без then это свойство = null.
|
||
/// </summary>
|
||
public statement_node else_body
|
||
{
|
||
get
|
||
{
|
||
return _else_body;
|
||
}
|
||
set
|
||
{
|
||
_else_body = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.if_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
SemanticTree.IStatementNode SemanticTree.IIfNode.else_body
|
||
{
|
||
get
|
||
{
|
||
return _else_body;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IExpressionNode SemanticTree.IIfNode.condition
|
||
{
|
||
get
|
||
{
|
||
return _condition;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IStatementNode SemanticTree.IIfNode.then_body
|
||
{
|
||
get
|
||
{
|
||
return _then_body;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Класс, представляющий узел while в программе.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class while_node : statement_node, SemanticTree.IWhileNode
|
||
{
|
||
/// <summary>
|
||
/// Условие цикла.
|
||
/// </summary>
|
||
private expression_node _condition;
|
||
|
||
/// <summary>
|
||
/// Тело цикла.
|
||
/// </summary>
|
||
private statement_node _body;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="condition">Условие цикла.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public while_node(expression_node condition, location loc)
|
||
: base(loc)
|
||
{
|
||
_condition = condition;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="condition">Условие цикла.</param>
|
||
/// <param name="body">Тело цикла.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public while_node(expression_node condition,statement_node body,location loc) : base(loc)
|
||
{
|
||
_condition=condition;
|
||
_body=body;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Условие цикла.
|
||
/// </summary>
|
||
public expression_node condition
|
||
{
|
||
get
|
||
{
|
||
return _condition;
|
||
}
|
||
}
|
||
|
||
//Тело while.
|
||
public statement_node body
|
||
{
|
||
get
|
||
{
|
||
return _body;
|
||
}
|
||
set
|
||
{
|
||
_body = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.while_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
SemanticTree.IExpressionNode SemanticTree.IWhileNode.condition
|
||
{
|
||
get
|
||
{
|
||
return _condition;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IStatementNode SemanticTree.IWhileNode.body
|
||
{
|
||
get
|
||
{
|
||
return _body;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Класс, представляющий узел repeat в программе.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class repeat_node : statement_node, SemanticTree.IRepeatNode
|
||
{
|
||
/// <summary>
|
||
/// Тело цикла.
|
||
/// </summary>
|
||
private statement_node _body;
|
||
|
||
/// <summary>
|
||
/// Условие цикла.
|
||
/// </summary>
|
||
private expression_node _condition;
|
||
|
||
/// <summary>
|
||
/// Конструктор узла.
|
||
/// </summary>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public repeat_node(location loc)
|
||
: base(loc)
|
||
{
|
||
}
|
||
|
||
/// <summary>
|
||
/// Конструктор узла.
|
||
/// </summary>
|
||
/// <param name="body">Тело цикла.</param>
|
||
/// <param name="condition">Условие.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public repeat_node(statement_node body,expression_node condition, location loc) : base(loc)
|
||
{
|
||
_body=body;
|
||
_condition=condition;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тело цикла.
|
||
/// </summary>
|
||
public statement_node body
|
||
{
|
||
get
|
||
{
|
||
return _body;
|
||
}
|
||
set
|
||
{
|
||
_body = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Условие цикла.
|
||
/// </summary>
|
||
public expression_node condition
|
||
{
|
||
get
|
||
{
|
||
return _condition;
|
||
}
|
||
set
|
||
{
|
||
_condition = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.repeat_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
SemanticTree.IExpressionNode SemanticTree.IRepeatNode.condition
|
||
{
|
||
get
|
||
{
|
||
return _condition;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IStatementNode SemanticTree.IRepeatNode.body
|
||
{
|
||
get
|
||
{
|
||
return _body;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Узел цикла for.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class for_node : statement_node, SemanticTree.IForNode
|
||
{
|
||
/// <summary>
|
||
/// Выражение инициализации переменной цикла.
|
||
/// </summary>
|
||
private statement_node _initialization_statement;
|
||
|
||
/// <summary>
|
||
/// Условие цикла
|
||
/// </summary>
|
||
private expression_node _while_expr;
|
||
|
||
private expression_node _init_while_expr;
|
||
|
||
/// <summary>
|
||
/// Выражение измененияя счетчика цикла.
|
||
/// </summary>
|
||
private statement_node _increment_statement;
|
||
|
||
/// <summary>
|
||
/// Тело цикла.
|
||
/// </summary>
|
||
private statement_node _body;
|
||
|
||
private bool _bool_cycle;
|
||
|
||
/// <summary>
|
||
/// Конструктор клааса.
|
||
/// </summary>
|
||
/// <param name="initialization_statement">Выражение инициализации переменной цикла.</param>
|
||
/// <param name="while_expr">Условие цикла.</param>
|
||
/// <param name="increment_statement">Выражение измененияя счетчика цикла.</param>
|
||
/// <param name="body">Тело цикла.</param>
|
||
public for_node(statement_node initialization_statement,expression_node while_expr, expression_node init_while_expr,
|
||
statement_node increment_statement,statement_node body, location loc) : base(loc)
|
||
{
|
||
_initialization_statement=initialization_statement;
|
||
_while_expr=while_expr;
|
||
_init_while_expr = init_while_expr;
|
||
_increment_statement=increment_statement;
|
||
_body=body;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Выражение инициализации переменной цикла.
|
||
/// </summary>
|
||
public statement_node initialization_statement
|
||
{
|
||
get
|
||
{
|
||
return _initialization_statement;
|
||
}
|
||
set
|
||
{
|
||
_increment_statement = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Условие продолжения цикла.
|
||
/// </summary>
|
||
public expression_node while_expr
|
||
{
|
||
get
|
||
{
|
||
return _while_expr;
|
||
}
|
||
set
|
||
{
|
||
_while_expr = value;
|
||
}
|
||
}
|
||
|
||
public expression_node init_while_expr
|
||
{
|
||
get
|
||
{
|
||
return _init_while_expr;
|
||
}
|
||
set
|
||
{
|
||
_init_while_expr = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Изменение счетчиков цикла.
|
||
/// </summary>
|
||
public statement_node increment_statement
|
||
{
|
||
get
|
||
{
|
||
return _increment_statement;
|
||
}
|
||
set
|
||
{
|
||
_increment_statement = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тело цикла.
|
||
/// </summary>
|
||
public statement_node body
|
||
{
|
||
get
|
||
{
|
||
return _body;
|
||
}
|
||
set
|
||
{
|
||
_body = value;
|
||
}
|
||
|
||
}
|
||
|
||
public bool bool_cycle
|
||
{
|
||
get
|
||
{
|
||
return _bool_cycle;
|
||
}
|
||
set
|
||
{
|
||
_bool_cycle = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.for_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
SemanticTree.IStatementNode SemanticTree.IForNode.initialization_statement
|
||
{
|
||
get
|
||
{
|
||
return _initialization_statement;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IStatementNode SemanticTree.IForNode.body
|
||
{
|
||
get
|
||
{
|
||
return _body;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IStatementNode SemanticTree.IForNode.increment_statement
|
||
{
|
||
get
|
||
{
|
||
return _increment_statement;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IExpressionNode SemanticTree.IForNode.while_expr
|
||
{
|
||
get
|
||
{
|
||
return _while_expr;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IExpressionNode SemanticTree.IForNode.init_while_expr
|
||
{
|
||
get
|
||
{
|
||
return _init_while_expr;
|
||
}
|
||
}
|
||
|
||
bool SemanticTree.IForNode.IsBoolCycle
|
||
{
|
||
get
|
||
{
|
||
return _bool_cycle;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Список выражений.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class statements_list : statement_node, SemanticTree.IStatementsListNode
|
||
{
|
||
/// <summary>
|
||
/// Список выражений.
|
||
/// </summary>
|
||
private statement_node_list _statements = new statement_node_list();
|
||
|
||
private location _llbl=null,_rlbl=null;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="loc">Расположение списка выражений.</param>
|
||
public statements_list(location loc) : base(loc)
|
||
{
|
||
}
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="loc">Расположение списка выражений.</param>
|
||
/// <param name="leftLogicalBracketLocation">Положение левой логической скобки</param>
|
||
/// <param name="rightLogicalBracketLocation">Положение правой логической скобки</param>
|
||
public statements_list(location loc, location leftLogicalBracketLocation, location rightLogicalBracketLocation)
|
||
: base(loc)
|
||
{
|
||
this._llbl = leftLogicalBracketLocation;
|
||
this._rlbl = rightLogicalBracketLocation;
|
||
}
|
||
|
||
|
||
|
||
private List<local_block_variable> _var_defs = new List<local_block_variable>();
|
||
|
||
/// <summary>
|
||
/// Массив переменных, определенных в блоке.
|
||
/// Используется при обходе дерева посетителем.
|
||
/// </summary>
|
||
SemanticTree.ILocalBlockVariableNode[] SemanticTree.IStatementsListNode.LocalVariables
|
||
{
|
||
get
|
||
{
|
||
return (_var_defs.ToArray());
|
||
}
|
||
}
|
||
|
||
public List<local_block_variable> local_variables
|
||
{
|
||
get
|
||
{
|
||
return _var_defs;
|
||
}
|
||
set
|
||
{
|
||
_var_defs = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Список statement-ов.
|
||
/// </summary>
|
||
public statement_node_list statements
|
||
{
|
||
get
|
||
{
|
||
return _statements;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Положение левой логической скобки
|
||
/// </summary>
|
||
public SemanticTree.ILocation LeftLogicalBracketLocation
|
||
{
|
||
get
|
||
{
|
||
return _llbl;
|
||
}
|
||
set
|
||
{
|
||
_llbl = (location)value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Положение правой логической скобки
|
||
/// </summary>
|
||
public SemanticTree.ILocation RightLogicalBracketLocation
|
||
{
|
||
get
|
||
{
|
||
return _rlbl;
|
||
}
|
||
set
|
||
{
|
||
_rlbl = (location)value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.statements_list;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
SemanticTree.IStatementNode[] SemanticTree.IStatementsListNode.statements
|
||
{
|
||
get
|
||
{
|
||
return (_statements.ToArray());
|
||
}
|
||
}
|
||
|
||
internal SymbolTable.Scope Scope = null;
|
||
}
|
||
|
||
//TODO: Неплохо-бы в следующих 3-х классах хранить ссылку на следующее за циклом выражение.
|
||
/// <summary>
|
||
/// Узел break в цикле while.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class while_break_node : expression_node, SemanticTree.IWhileBreakNode
|
||
{
|
||
/// <summary>
|
||
/// Узел while.
|
||
/// </summary>
|
||
private while_node _whnd;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="whnd">Узел while из которого ведет этот break.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public while_break_node(while_node whnd,location loc) :
|
||
base(null,loc)
|
||
{
|
||
_whnd=whnd;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.while_break_node;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IWhileNode while_node
|
||
{
|
||
get
|
||
{
|
||
return _whnd;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IWhileBreakNode)this);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Узел break в цикле repeat.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class repeat_break_node : expression_node, SemanticTree.IRepeatBreakNode
|
||
{
|
||
/// <summary>
|
||
/// Узел repeat, внутри которого расположен этот break.
|
||
/// </summary>
|
||
private repeat_node _rpnd;
|
||
|
||
/// <summary>
|
||
/// Конструктор касса.
|
||
/// </summary>
|
||
/// <param name="rn">Узел repeat, внутри которого расположен этот break.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public repeat_break_node(repeat_node rn,location loc) :
|
||
base(null,loc)
|
||
{
|
||
_rpnd=rn;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.repeat_break_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IRepeatBreakNode)this);
|
||
}
|
||
|
||
public SemanticTree.IRepeatNode repeat_node
|
||
{
|
||
get
|
||
{
|
||
return _rpnd;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Узел break в икле for.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class for_break_node : expression_node, SemanticTree.IForBreakNode
|
||
{
|
||
/// <summary>
|
||
/// Цикл for внутри которого расположен этот break.
|
||
/// </summary>
|
||
private for_node _frnd;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="fn">Цикл for внутри которого расположен этот break.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public for_break_node(for_node fn,location loc) :
|
||
base(null,loc)
|
||
{
|
||
_frnd=fn;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.for_break_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IForBreakNode)this);
|
||
}
|
||
|
||
public SemanticTree.IForNode for_node
|
||
{
|
||
get
|
||
{
|
||
return _frnd;
|
||
}
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class foreach_break_node : expression_node, SemanticTree.IForeachBreakNode
|
||
{
|
||
/// <summary>
|
||
/// Цикл for внутри которого расположен этот break.
|
||
/// </summary>
|
||
private foreach_node _frnd;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="fn">Цикл for внутри которого расположен этот break.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public foreach_break_node(foreach_node fn,location loc) :
|
||
base(null,loc)
|
||
{
|
||
_frnd=fn;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.foreach_break_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IForeachBreakNode)this);
|
||
}
|
||
|
||
public SemanticTree.IForeachNode foreach_node
|
||
{
|
||
get
|
||
{
|
||
return _frnd;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Узел exit где угодно
|
||
/// </summary>
|
||
[Serializable]
|
||
public class exit_procedure : expression_node, SemanticTree.IExitProcedure
|
||
{
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public exit_procedure(location loc)
|
||
:
|
||
base(null, loc)
|
||
{
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.exit_procedure;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IExitProcedure)this);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Узел, представляющий continue внутри цикла while.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class while_continue_node : expression_node, SemanticTree.IWhileContinueNode
|
||
{
|
||
/// <summary>
|
||
/// Цикл while внутри которого расположен этот continue.
|
||
/// </summary>
|
||
private while_node _whnd;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="whnd">Цикл while внутри которого расположен этот continue.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public while_continue_node(while_node whnd,location loc) :
|
||
base(null,loc)
|
||
{
|
||
_whnd=whnd;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.while_continue_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IWhileContinueNode)this);
|
||
}
|
||
|
||
public SemanticTree.IWhileNode while_node
|
||
{
|
||
get
|
||
{
|
||
return _whnd;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Узел continue в цикле repeat.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class repeat_continue_node : expression_node, SemanticTree.IRepeatContinueNode
|
||
{
|
||
/// <summary>
|
||
/// Цикл repeat, внутри которог расположен этот continue.
|
||
/// </summary>
|
||
private repeat_node _rpnd;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="rn">Цикл repeat, внутри которог расположен этот continue.</param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public repeat_continue_node(repeat_node rn, location loc) :
|
||
base(null,loc)
|
||
{
|
||
_rpnd=rn;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.repeat_continue_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IRepeatContinueNode)this);
|
||
}
|
||
|
||
public SemanticTree.IRepeatNode repeat_node
|
||
{
|
||
get
|
||
{
|
||
return _rpnd;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Узел continue внутри цикла for.
|
||
/// </summary>
|
||
[Serializable]
|
||
public class for_continue_node : expression_node, SemanticTree.IForContinueNode
|
||
{
|
||
/// <summary>
|
||
/// Цикл for, внутри которого расположен этот continue.
|
||
/// </summary>
|
||
private for_node _frnd;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="fn"></param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public for_continue_node(for_node fn,location loc):
|
||
base(null,loc)
|
||
{
|
||
_frnd=fn;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.for_continue_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IForContinueNode)this);
|
||
}
|
||
|
||
public SemanticTree.IForNode for_node
|
||
{
|
||
get
|
||
{
|
||
return _frnd;
|
||
}
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class foreach_continue_node : expression_node, SemanticTree.IForeachContinueNode
|
||
{
|
||
/// <summary>
|
||
/// Цикл for, внутри которого расположен этот continue.
|
||
/// </summary>
|
||
private foreach_node _frnd;
|
||
|
||
/// <summary>
|
||
/// Конструктор класса.
|
||
/// </summary>
|
||
/// <param name="fn"></param>
|
||
/// <param name="loc">Расположение узла.</param>
|
||
public foreach_continue_node(foreach_node fn,location loc):
|
||
base(null,loc)
|
||
{
|
||
_frnd=fn;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.foreach_continue_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit((SemanticTree.IForeachContinueNode)this);
|
||
}
|
||
|
||
public SemanticTree.IForeachNode foreach_node
|
||
{
|
||
get
|
||
{
|
||
return _frnd;
|
||
}
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class switch_node : statement_node, SemanticTree.ISwitchNode
|
||
{
|
||
private expression_node _condition;
|
||
private case_variant_node_list _case_variants = new case_variant_node_list();
|
||
private statement_node _default_statement;
|
||
|
||
public switch_node(location loc) : base(loc)
|
||
{
|
||
}
|
||
|
||
public case_variant_node_list case_variants
|
||
{
|
||
get
|
||
{
|
||
return _case_variants;
|
||
}
|
||
}
|
||
|
||
public expression_node condition
|
||
{
|
||
get
|
||
{
|
||
return _condition;
|
||
}
|
||
set
|
||
{
|
||
_condition = value;
|
||
}
|
||
}
|
||
|
||
public statement_node default_statement
|
||
{
|
||
get
|
||
{
|
||
return _default_statement;
|
||
}
|
||
set
|
||
{
|
||
_default_statement = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.switch_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
SemanticTree.ICaseVariantNode[] SemanticTree.ISwitchNode.case_variants
|
||
{
|
||
get
|
||
{
|
||
return _case_variants.ToArray();
|
||
}
|
||
}
|
||
|
||
SemanticTree.IStatementNode SemanticTree.ISwitchNode.default_statement
|
||
{
|
||
get
|
||
{
|
||
return _default_statement;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IExpressionNode case_expression
|
||
{
|
||
get
|
||
{
|
||
return _condition;
|
||
}
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class case_variant_node : statement_node, SemanticTree.ICaseVariantNode
|
||
{
|
||
private case_range_node_list _case_ranges = new case_range_node_list();
|
||
//private constant_node_list _case_constants = new constant_node_list();
|
||
private int_const_node_list _case_constants = new int_const_node_list();
|
||
private statement_node _case_statement;
|
||
|
||
public case_variant_node(location loc) : base(loc)
|
||
{
|
||
}
|
||
|
||
public case_range_node_list case_ranges
|
||
{
|
||
get
|
||
{
|
||
return _case_ranges;
|
||
}
|
||
}
|
||
|
||
public int_const_node_list case_constants
|
||
{
|
||
get
|
||
{
|
||
return _case_constants;
|
||
}
|
||
}
|
||
|
||
public statement_node case_statement
|
||
{
|
||
get
|
||
{
|
||
return _case_statement;
|
||
}
|
||
set
|
||
{
|
||
_case_statement = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.case_variant_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
public SemanticTree.IIntConstantNode[] elements
|
||
{
|
||
get
|
||
{
|
||
return _case_constants.ToArray();
|
||
}
|
||
}
|
||
|
||
public SemanticTree.ICaseRangeNode[] ranges
|
||
{
|
||
get
|
||
{
|
||
return _case_ranges.ToArray();
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IStatementNode statement_to_execute
|
||
{
|
||
get
|
||
{
|
||
return _case_statement;
|
||
}
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class case_range_node : statement_node, SemanticTree.ICaseRangeNode
|
||
{
|
||
private int_const_node _lower_bound;
|
||
private int_const_node _high_bound;
|
||
|
||
public case_range_node(int_const_node lower_bound, int_const_node high_bound, location loc) : base(loc)
|
||
{
|
||
_lower_bound = lower_bound;
|
||
_high_bound = high_bound;
|
||
}
|
||
|
||
public int_const_node lower_bound
|
||
{
|
||
get
|
||
{
|
||
return _lower_bound;
|
||
}
|
||
}
|
||
|
||
public int_const_node high_bound
|
||
{
|
||
get
|
||
{
|
||
return _high_bound;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.case_range_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
SemanticTree.IIntConstantNode SemanticTree.ICaseRangeNode.lower_bound
|
||
{
|
||
get
|
||
{
|
||
return _lower_bound;
|
||
}
|
||
}
|
||
|
||
SemanticTree.IIntConstantNode SemanticTree.ICaseRangeNode.high_bound
|
||
{
|
||
get
|
||
{
|
||
return _high_bound;
|
||
}
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class exception_filter : statement_node, SemanticTree.IExceptionFilterBlockNode
|
||
{
|
||
private type_node _filter_type;
|
||
private local_block_variable_reference _exception_var;
|
||
private statement_node _exception_handler;
|
||
|
||
public exception_filter(type_node filter_type, local_block_variable_reference exception_var,
|
||
statement_node exception_handler, location loc) : base(loc)
|
||
{
|
||
_filter_type = filter_type;
|
||
_exception_var = exception_var;
|
||
_exception_handler = exception_handler;
|
||
}
|
||
|
||
public type_node filter_type
|
||
{
|
||
get
|
||
{
|
||
return _filter_type;
|
||
}
|
||
set
|
||
{
|
||
_filter_type = value;
|
||
}
|
||
}
|
||
|
||
public local_block_variable_reference exception_var
|
||
{
|
||
get
|
||
{
|
||
return _exception_var;
|
||
}
|
||
set
|
||
{
|
||
_exception_var = value;
|
||
}
|
||
}
|
||
|
||
public statement_node exception_handler
|
||
{
|
||
get
|
||
{
|
||
return _exception_handler;
|
||
}
|
||
set
|
||
{
|
||
_exception_handler = value;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.ITypeNode ExceptionType
|
||
{
|
||
get
|
||
{
|
||
return _filter_type;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.ILocalBlockVariableReferenceNode ExceptionInstance
|
||
{
|
||
get
|
||
{
|
||
return _exception_var;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IStatementNode ExceptionHandler
|
||
{
|
||
get
|
||
{
|
||
return _exception_handler;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.exception_filter;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class try_block : statement_node, SemanticTree.ITryBlockNode
|
||
{
|
||
private statement_node _try_statements;
|
||
private statement_node _finally_statements;
|
||
private exception_filters_list _filters;
|
||
|
||
public try_block(statement_node try_statements, statement_node finally_statements,
|
||
exception_filters_list filters, location loc)
|
||
: base(loc)
|
||
{
|
||
_try_statements = try_statements;
|
||
_finally_statements = finally_statements;
|
||
_filters = filters;
|
||
}
|
||
|
||
public statement_node try_statements
|
||
{
|
||
get
|
||
{
|
||
return _try_statements;
|
||
}
|
||
}
|
||
|
||
public statement_node finally_statements
|
||
{
|
||
get
|
||
{
|
||
return _finally_statements;
|
||
}
|
||
}
|
||
|
||
public exception_filters_list filters
|
||
{
|
||
get
|
||
{
|
||
return _filters;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.try_block;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
|
||
public SemanticTree.IStatementNode TryStatements
|
||
{
|
||
get
|
||
{
|
||
return _try_statements;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IStatementNode FinallyStatements
|
||
{
|
||
get
|
||
{
|
||
return _finally_statements;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IExceptionFilterBlockNode[] ExceptionFilters
|
||
{
|
||
get
|
||
{
|
||
return _filters.ToArray();
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
[Serializable]
|
||
public class foreach_node : statement_node, SemanticTree.IForeachNode
|
||
{
|
||
private var_definition_node _ident;
|
||
private expression_node _in_what;
|
||
private statement_node _what_do;
|
||
|
||
public foreach_node(var_definition_node _ident, expression_node _in_what, statement_node _what_do, location loc):base(loc)
|
||
{
|
||
this._ident = _ident;
|
||
this._in_what = _in_what;
|
||
this._what_do = _what_do;
|
||
}
|
||
|
||
public var_definition_node ident
|
||
{
|
||
get
|
||
{
|
||
return _ident;
|
||
}
|
||
set
|
||
{
|
||
_ident = value;
|
||
}
|
||
}
|
||
|
||
public expression_node in_what
|
||
{
|
||
get
|
||
{
|
||
return _in_what;
|
||
}
|
||
set
|
||
{
|
||
_in_what = value;
|
||
}
|
||
}
|
||
|
||
public statement_node what_do
|
||
{
|
||
get
|
||
{
|
||
return _what_do;
|
||
}
|
||
set
|
||
{
|
||
_what_do = value;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IStatementNode Body
|
||
{
|
||
get
|
||
{
|
||
return _what_do;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IExpressionNode InWhatExpr
|
||
{
|
||
get
|
||
{
|
||
return _in_what;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IVAriableDefinitionNode VarIdent
|
||
{
|
||
get
|
||
{
|
||
return _ident;
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.foreach_node;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
}
|
||
|
||
|
||
[Serializable]
|
||
public class lock_statement : statement_node, SemanticTree.ILockStatement
|
||
{
|
||
private expression_node _lock_object;
|
||
private statement_node _body;
|
||
|
||
public lock_statement(expression_node _lock_object, statement_node _body, location loc)
|
||
: base(loc)
|
||
{
|
||
this._lock_object = _lock_object;
|
||
this._body = _body;
|
||
}
|
||
|
||
public expression_node lock_object
|
||
{
|
||
get
|
||
{
|
||
return _lock_object;
|
||
}
|
||
set
|
||
{
|
||
_lock_object = value;
|
||
}
|
||
}
|
||
|
||
public statement_node body
|
||
{
|
||
get
|
||
{
|
||
return _body;
|
||
}
|
||
set
|
||
{
|
||
_body = value;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IStatementNode Body
|
||
{
|
||
get
|
||
{
|
||
return _body;
|
||
}
|
||
}
|
||
|
||
public SemanticTree.IExpressionNode LockObject
|
||
{
|
||
get
|
||
{
|
||
return _lock_object;
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Тип узла.
|
||
/// </summary>
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.lock_statement;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Метод для обхода дерева посетителем.
|
||
/// </summary>
|
||
/// <param name="visitor">Класс - посетитель дерева.</param>
|
||
public override void visit(SemanticTree.ISemanticVisitor visitor)
|
||
{
|
||
visitor.visit(this);
|
||
}
|
||
}
|
||
}
|