protected Symbol(SymbolType type, string name, Symbol parent)
 {
     _type = type;
     _name = name;
     _parent = parent;
     _transformAllowed = true;
 }

 /// <summary>
 /// Constructor for parameter symbol
 /// </summary>
 /// <param name="name"></param>
 /// <param name="symbolType"></param>
 /// <param name="parameter"></param>
 public ParameterSymbol(string name,SymbolType symbolType, Parameter parameter,
     VariableType variableType)
     : base(name,symbolType)
 {
     base.variableType = variableType;
     this.parameter = parameter;
 }

 public Symbol(char _symbol, SymbolType _type, Interpreter _interpreter, string _interpreterMethod)
 {
     symbol = _symbol;
     type = _type;
     interpreter = _interpreter;
     interpreterMethod = _interpreterMethod;
 }

 public GrammarNodeDExistsVisitor(String nameIn, SymbolType symbolTypeIn)
 {
     name = nameIn;
     symbolType = symbolTypeIn;
     rulesVisited = new List<NonterminalHeadD>();
     found = false;
 }

        private static XamlShapes.Shape CreateSymbolFromVectorStyle(VectorStyle style, double opacity = 1, SymbolType symbolType = SymbolType.Ellipse, double width = SymbolStyle.DefaultWidth, double height = SymbolStyle.DefaultHeight)
        {
            var path = new XamlShapes.Path { StrokeThickness = 0 };  //The SL StrokeThickness default is 1 which causes blurry bitmaps

            if (style.Fill != null && (style.Fill.Color != null || style.Fill.BitmapId != -1))
                path.Fill = style.Fill.ToXaml();
            else
                path.Fill = new XamlMedia.SolidColorBrush(XamlColors.Transparent);

            if (style.Outline != null)
            {
                path.Stroke = new XamlMedia.SolidColorBrush(style.Outline.Color.ToXaml());
                path.StrokeThickness = style.Outline.Width;
                path.StrokeDashArray = style.Outline.PenStyle.ToXaml();
            }

            if (symbolType == SymbolType.Ellipse)
                path.Data = CreateEllipse(width, height);
            else
                path.Data = CreateRectangle(width, height);

            path.Opacity = opacity;

            return path;
        }

        public void AddCurve(GraphPane pane, string name, string measure, Color color, SymbolType sType, int capacity)
        {
            _dataPointList = new RollingPointPairList(capacity);

            // Добавим кривую пока еще без каких-либо точек
            _myCurve = pane.AddCurve(string.Format("{0} ({1})",name,measure), _dataPointList, color, sType);
        }

 /// <summary>
 /// Constuctor for function symbol
 /// </summary>
 /// <param name="name"></param>
 /// <param name="symbolType"></param>
 /// <param name="label"></param>
 /// <param name="paramList"></param>
 /// <param name="returnVar"></param>
 public FunctionSymbol(string name,SymbolType symbolType,string label,
     List<Parameter> paramList,VariableType returnVar)
     : base(name,symbolType,label,paramList)
 {
     this.returnVar = returnVar;
     this.variableType = returnVar;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Label"/> class
 /// that defines a symbol with the specified type and identifier.
 /// </summary>
 /// <param name="identifier">The identifier of the defined symbol.</param>
 /// <param name="symbolType">The type of symbol defined.</param>
 /// <remarks>
 /// The <see cref="DefinedSymbol"/> property holds the symbol that is defined.
 /// </remarks>
 public Label(string identifier, SymbolType symbolType)
     : this(new Symbol(symbolType, identifier))
 {
     #region Contract
     Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(SymbolType), symbolType));
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Symbol"/> class.
 /// </summary>
 /// <param name="symbolType">The type of symbol.</param>
 public Symbol(SymbolType symbolType)
     : this(symbolType, null)
 {
     #region Contract
     Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(SymbolType), symbolType));
     #endregion
 }

 protected ClassSymbol(SymbolType type, string name, NamespaceSymbol parent)
     : base(type, name, parent)
 {
     _inheritanceDepth = -1;
     _minimizationDepth = -1;
     _transformationCookie = -1;
 }

 public static Symbol create(SymbolType type)
 {
     Transform t = null;
     switch (type) {
         case SymbolType.Resistor:
             t = Instantiate(parent.resistorSym.transform) as Transform;
             break;
         case SymbolType.Lamp:
             t = Instantiate(parent.lampSym.transform) as Transform;
             break;
         case SymbolType.Switch:
             t = Instantiate(parent.switchSym.transform) as Transform;
             break;
         case SymbolType.Battery:
             t = Instantiate(parent.batterySym.transform) as Transform;
             break;
         case SymbolType.And:
             t = Instantiate(parent.andSym.transform) as Transform;
             break;
         case SymbolType.Or:
             t = Instantiate(parent.orSym.transform) as Transform;
             break;
         case SymbolType.Not:
             t = Instantiate(parent.notSym.transform) as Transform;
             break;
         default:
             return null;
     }
     return t.GetComponent(typeof(Symbol)) as Symbol;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="text"></param>
 /// <param name="color"></param>
 /// <param name="width"></param>
 /// <param name="symbol"></param>
 public LineHelper(string text, Color color, int width, SymbolType symbol)
 {
     this.Text = text;
     this.Color = color;
     this.LineWidth = width;
     this.SymbolType = symbol;
 }

 /// <summary>
 /// Constructor for Procedure Symbol
 /// </summary>
 /// <param name="name"></param>
 /// <param name="symbolType"></param>
 /// <param name="label"></param>
 /// <param name="paramList"></param>
 public ProcedureSymbol(string name, SymbolType symbolType,string label,
     List<Parameter> paramList)
     : base(name, symbolType)
 {
     this.label = label;
     this.paramList = paramList;
 }

        protected TypeSymbol(SymbolType type, string name, NamespaceSymbol parent)
            : base(type, name, parent) {
            Debug.Assert(parent != null);

            _memberTable = new Dictionary<string, MemberSymbol>();
            _members = new List<MemberSymbol>();
            _applicationType = true;
        }

 /// <summary>
 /// コンストラクタ
 /// </summary>
 public Symbol(SpriteUV sprite, SymbolType type)
 {
     sprite.Scale = new Sce.PlayStation.Core.Vector2(1.0f);
     sprite.Quad.S = sprite.TextureInfo.TextureSizef;
     sprite.CenterSprite();
     Image = sprite;
     Type = type;
 }

 /// <summary>
 /// Constructor for Variable Symbol
 /// </summary>
 /// <param name="name"></param>
 /// <param name="size"></param>
 /// <param name="offset"></param>
 public VariableSymbol( string name, SymbolType symbolType, VariableType var,int size, 
     int offset)
     : base(name,symbolType)
 {
     this.size = size;
     this.offset = offset;
     this.variableType = var;
 }

 public Line(string label, DataPointList points)
 {
     mVisible = true;
     mLabel = label;
     mPoints = points;
     mColor = Color.Black;
     mWidth = 1;
     mSymbolType = SymbolType.None;
 }

 /// <summary>
 /// Gets the index of the specified symbol type in the match list, or -1 if not found
 /// </summary>
 /// <param name="symbol"></param>
 /// <param name="offset"></param>
 /// <returns></returns>
 public int IndexOfMatchSymbol(SymbolType symbol, int offset = 0)
 {
     for (int i = offset; i < MatchSymbols.Length; i++)
     {
         if (MatchSymbols[i] == symbol)
             return i;
     }
     return -1;
 }

        /// <summary>
        /// Initializes a new instance of the Symbol class.
        /// </summary>
        /// <param name="text">
        /// The item text.
        /// </param>
        /// <param name="symbolType">
        /// The symbol type.
        /// </param>
        /// <param name="location">
        /// The location of the token within the code document.
        /// </param>
        internal Symbol(string text, SymbolType symbolType, CodeLocation location)
        {
            Param.AssertValidString(text, "text");
            Param.Ignore(symbolType);
            Param.AssertNotNull(location, "location");

            this.text = text;
            this.symbolType = symbolType;
            this.location = location;
        }

 public Symbol(SymbolType symt, string name, uint val)
 {
     this.type = symt;
     this.name = name;
     this.val = val;
     this.sectType = SectionType.Null;
     this.exported = false;
     this.index = 0;
     this.strindex = 0;
 }