protected Symbol(SymbolType type, string name, Symbol parent)
{
_type = type;
_name = name;
_parent = parent;
_transformAllowed = true;
}
/// <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
}
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);
}
protected ClassSymbol(SymbolType type, string name, NamespaceSymbol parent)
: base(type, name, parent)
{
_inheritanceDepth = -1;
_minimizationDepth = -1;
_transformationCookie = -1;
}
public Symbol(char _symbol, SymbolType _type, Interpreter _interpreter, string _interpreterMethod)
{
symbol = _symbol;
type = _type;
interpreter = _interpreter;
interpreterMethod = _interpreterMethod;
}
/// <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;
}
public GrammarNodeDExistsVisitor(String nameIn, SymbolType symbolTypeIn)
{
name = nameIn;
symbolType = symbolTypeIn;
rulesVisited = new List<NonterminalHeadD>();
found = false;
}
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>
/// 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;
}
/// <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;
}
/// <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>
/// 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>
/// コンストラクタ
/// </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;
}
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>
/// 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;
}
/// <summary>
/// Initializes a new instance of the <see cref="Symbol"/> class.
/// </summary>
/// <param name="symbolType">The type of symbol.</param>
/// <param name="identifier">The identifier of the symbol; or <see langword="null"/>.</param>
public Symbol(SymbolType symbolType, string identifier)
{
#region Contract
Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(SymbolType), symbolType));
#endregion
this.symbolType = symbolType;
this.identifier = identifier;
}
/// <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;
}
public Line()
{
mVisible = true;
mLabel = "";
mPoints = new DataPointList();
mColor = Color.Black;
mWidth = 1;
mSymbolType = SymbolType.None;
}
public Line(string label, DataPointList points)
{
mVisible = true;
mLabel = label;
mPoints = points;
mColor = Color.Black;
mWidth = 1;
mSymbolType = SymbolType.None;
}
/// <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;
}
public static void CreateChartForInt(ZedGraphControl zgc ,int[] data,
string titleName ,string lblName,
Color color,SymbolType symType )
{
double[] res = new double[data.Length ] ;
for (int i = 0 ; i <data.Length ; i ++)
{
res [i ] = (double )data [i ] ;
}
CreateChartForDouble(zgc ,res , titleName ,lblName ,color ,symType ) ;
}
public static SymbolType getGreatestType(SymbolType leftType, SymbolType rightType)
{
if (!isEquivalentType(leftType, rightType))
throw new Exception("Incomparable types");
else
{
if (leftType == rightType)
return leftType;
else
return SymbolType.Tint;
}
}
public void AddCurve(string label, double[] xData, double[] yData,
Color color, SymbolType symbolType, bool isLineVisible)
{
CurveProperties item = new CurveProperties();
item.label = label;
item.xData = xData;
item.yData = yData;
item.color = color;
item.simbolType = symbolType;
item.isLineVisible = isLineVisible;
this.curveItems.Add(item);
}
public Symbol Add(string name, SymbolType type, object syntaxObject, object codeObject)
{
string prefix = PrefixFromType(type);
if (m_Hashtable.Contains(prefix + name))
throw new Exception("Symbol already exists in symbol table.");
Symbol symbol = new Symbol(name, type, syntaxObject, codeObject);
m_Hashtable.Add(prefix + name, symbol);
return symbol;
}
/// <summary>
/// Create a new <see cref="FilledLineItem"/> using the specified properties.
/// </summary>
/// <param name="label">The _label that will appear in the legend.</param>
/// <param name="upperPoints">A <see cref="IPointList"/> of double precision value pairs that define
/// the X and upper Y values for this curve</param>
/// <param name="lowerPoints">A <see cref="IPointList"/> of double precision value pairs that define
/// the X and lower Y values for this curve</param>
/// <param name="color">A <see cref="System.Drawing.Color"/> value that will be applied to
/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
/// </param>
/// <param name="symbolType">A <see cref="SymbolType"/> enum specifying the
/// type of symbol to use for this <see cref="LineItem"/>. Use <see cref="SymbolType.None"/>
/// to hide the symbols.</param>
/// <param name="lineWidth">The width (in points) to be used for the <see cref="Line"/>. This
/// width is scaled based on <see cref="PaneBase.CalcScaleFactor"/>. Use a value of zero to
/// hide the line (see <see cref="ZedGraph.LineBase.IsVisible"/>).</param>
public FilledLineItem( string label, IPointList upperPoints, IPointList lowerPoints, System.Drawing.Color color, SymbolType symbolType, float lineWidth )
: base(label)
{
Points = upperPoints ?? new PointPairList();
LowerPoints = lowerPoints ?? new PointPairList();
_line = new FilledLine( color );
if ( lineWidth == 0 )
_line.IsVisible = false;
else
_line.Width = lineWidth;
_symbol = new Symbol( symbolType, color );
}
/// <summary>
/// Constructs and instance of a SymbolReference
/// </summary>
/// <param name="symbolType">The higher level type of the symbol</param>
/// <param name="scriptExtent">The script extent of the symbol</param>
/// <param name="filePath">The file path of the symbol</param>
/// <param name="sourceLine">The line contents of the given symbol (defaults to empty string)</param>
public SymbolReference(SymbolType symbolType, IScriptExtent scriptExtent, string filePath = "", string sourceLine = "")
{
// TODO: Verify params
this.SymbolType = symbolType;
this.SymbolName = scriptExtent.Text;
this.ScriptRegion = ScriptRegion.Create(scriptExtent);
this.FilePath = filePath;
this.SourceLine = sourceLine;
// TODO: Make sure end column number usage is correct
// Build the display string
//this.DisplayString =
// string.Format(
// "{0} {1}")
}
private void AnalizeLecsicalSymbolType()
{
for (_counter = 0; _counter < _line.Length; _counter++)
{
if (_error)
break;
_symbol = _line[_counter];
if (_symbol == '(')
{
_lecsicalSymbolType = SymbolType.left_parenthesis;
Console.WriteLine("{0}: {1}", _lecsicalSymbolType, _symbol);
}
else if (_symbol == ')')
{
_lecsicalSymbolType = SymbolType.right_parenthesis;
Console.WriteLine("{0}: {1}", _lecsicalSymbolType, _symbol);
}
else if (_symbol == '*' || _symbol == '+' || _symbol == '/' || _symbol == '-')
{
_lecsicalSymbolType = SymbolType.operation;
Console.WriteLine("{0}: {1}", _lecsicalSymbolType, _symbol);
}
else if (char.IsDigit(_symbol))
{
_lecsicalSymbolType = SymbolType.integer;
GetNumber();
}
else if (char.IsLetter(_symbol))
{
_lecsicalSymbolType = SymbolType.identifier;
GetWord();
}
else if (char.IsWhiteSpace(_symbol))
{
continue;
}
else
{
Console.WriteLine("Symbol not recognized, canceling translation");
break;
}
}
}
public int DefineVariable(string name, SymbolType type)
{
RegisterScopeIfNeeded();
try
{
int varIdx;
if (type == SymbolType.Variable)
varIdx = _currentContext.DefineVariable(name).CodeIndex;
else
varIdx = _currentContext.DefineProperty(name).CodeIndex;
_predefinedVariables.Add(varIdx);
return varIdx;
}
catch
{
_currentContext.PopScope();
_scope = null;
throw;
}
}
protected virtual void AddCurvetoGraph(PointPairList list, string DataName, Color linecolor, SymbolType type, int symbolsize, DashStyle style, bool isSmoothed, string tag)
{
LineItem myCurve = m_cMyPane.AddCurve(DataName, list, linecolor, type);
myCurve.Symbol.Fill = new Fill(Color.DeepSkyBlue, Color.Red);
myCurve.Symbol.Fill.Type = FillType.GradientByZ;
myCurve.Symbol.Fill.RangeMin = 0;
myCurve.Symbol.Fill.RangeMax = 1;
myCurve.Symbol.Size = symbolsize;
myCurve.Line.Style = style;
myCurve.Line.IsAntiAlias = true;
myCurve.Tag = tag;
myCurve.Line.IsSmooth = isSmoothed;
}
/// <summary>
/// Create a new <see cref="LineItem"/> using the specified properties.
/// </summary>
/// <param name="label">The _label that will appear in the legend.</param>
/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
/// the X and Y values for this curve</param>
/// <param name="color">A <see cref="Color"/> value that will be applied to
/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
/// </param>
/// <param name="symbolType">A <see cref="SymbolType"/> enum specifying the
/// type of symbol to use for this <see cref="LineItem"/>. Use <see cref="SymbolType.None"/>
/// to hide the symbols.</param>
public LineItem(string label, IPointList points, Color color, SymbolType symbolType)
: this(label, points, color, symbolType, ZedGraph.LineBase.Default.Width)
{
}
protected MemberSymbol(SymbolType type, string name, TypeSymbol parent, TypeSymbol associatedType)
: base(type, name, parent)
{
AssociatedType = associatedType;
}
public bool IsArgumentTypeCompatible(SymbolType parameterType, Data argument)
{
switch (parameterType)
{
case SymbolType.Int:
if (argument.Type == SymbolType.Int || argument.Type == SymbolType.Instance)
{
// TODO think about giving warning if somebody passes instance to int argument
return(true);
}
break;
case SymbolType.Float:
if (argument.Type == SymbolType.Int && argument.Category == DataCategory.Literal)
{
return(true);
}
if (argument.Type == SymbolType.Float)
{
if (argument.Category == DataCategory.Literal || argument.Category == DataCategory.Variable)
{
return(true);
}
}
break;
case SymbolType.String:
if (argument.Type == SymbolType.String)
{
return(true);
}
break;
case SymbolType.Instance:
if (argument.Type == SymbolType.Instance && argument.Category == DataCategory.Variable)
{
return(true);
}
break;
case SymbolType.Func:
if (argument.Type == SymbolType.Func && argument.Category == DataCategory.Variable)
{
return(true);
}
if (argument.Type == SymbolType.Instance && argument.Category == DataCategory.Variable)
{
return(true);
}
break;
}
return(false);
}
private static void DrawPointWithVectorStyle(SKCanvas canvas, VectorStyle vectorStyle,
Point destination, float opacity, SymbolType symbolType = SymbolType.Ellipse)
{
canvas.Save();
canvas.Translate((float)destination.X, (float)destination.Y);
DrawPointWithVectorStyle(canvas, vectorStyle, opacity, symbolType);
canvas.Restore();
}
private bool AreEqulSymbolTypes(SymbolType type)
{
return(type == currentSymbolType);
}
/// <summary>
/// Initializes a new instance of the <see cref="Iodine.Compiler.Symbol"/> class.
/// </summary>
/// <param name="type">Type of symbol.</param>
/// <param name="name">Name of the symbol.</param>
/// <param name="index">Symbol index.</param>
public Symbol(SymbolType type, string name, int index)
{
Name = name;
Index = index;
Type = type;
}
/* constructor */
/// Creates a new Symbol object.
internal Symbol(int p_index, String p_name, SymbolType p_kind)
{
m_tableIndex = p_index;
m_name = p_name;
m_kind = p_kind;
}
public LabelInfo(SymbolType type = SymbolType.Undefined, int address = 0)
: this()
{
Type = type;
Address = address;
}
protected LocalSymbol(SymbolType type, string name, MemberSymbol parent, TypeSymbol valueType)
: base(type, name, parent)
{
ValueType = valueType;
}
///
internal protected void CopyData(Symbol p_symbol)
{
m_name = p_symbol.Name;
m_kind = p_symbol.Kind;
m_tableIndex = p_symbol.TableIndex;
}
protected PropertySymbol(SymbolType type, string name, TypeSymbol parent, TypeSymbol propertyType)
: base(type, name, parent, propertyType)
{
}
protected Function(SymbolType returnType)
{
ReturnType = returnType;
}
protected virtual void AddCurvetoGraph(PointPairList list, PointPairList elist, string DataName, Color linecolor, SymbolType type, int symbolsize, string tag)
{
LineItem myCurve = m_cMyPane.AddCurve(DataName, list, linecolor, type);
myCurve.Symbol.Fill = new Fill(Color.DeepSkyBlue, Color.Red);
myCurve.Symbol.Fill.Type = FillType.GradientByZ;
myCurve.Symbol.Fill.RangeMin = 0;
myCurve.Symbol.Fill.RangeMax = 1;
myCurve.Symbol.Size = symbolsize;
myCurve.Line.IsAntiAlias = true;
myCurve.Line.IsSmooth = true;
myCurve.Tag = tag;
if (elist != null)
{
ErrorBarItem myECurve;
myECurve = m_cMyPane.AddErrorBar("", elist, Color.Black);
myECurve.Bar.PenWidth = 1f;
// Use the HDash symbol so that the error bars look like I-beams
myECurve.Bar.Symbol.Type = SymbolType.HDash;
/// myECurve.Bar.Symbol.Border.Width = .1f;
myECurve.Bar.Symbol.IsVisible = true;
myECurve.Bar.Symbol.Size = 2;
}
}
/// <summary>
/// Inserts a new symbol with defined parameters into the lookup structure.
/// </summary>
/// <param name="name">Name.</param>
/// <param name="start">Start.</param>
/// <param name="size">Size.</param>
/// <param name="type">SymbolType.</param>
/// <param name="binding">Symbol binding</param>
/// <param name="isThumb">If set to <c>true</c>, symbol is marked as a thumb symbol.</param>
public void InsertSymbol(string name, SymbolAddress start, SymbolAddress size, SymbolType type = SymbolType.NotSpecified, SymbolBinding binding = SymbolBinding.Global, bool isThumb = false)
{
var symbol = new Symbol(start, start + size, name, type, binding, isThumb);
InsertSymbol(symbol);
}
public virtual bool Visit(SymbolType symbolType)
{
return(true);
}
public Symbol GetSymbolByType(SymbolType type)
{
int idx = GetSymbolIdxByType(type);
return((idx == -1) ? null : Symbols[idx]);
}
public VisualMap ItemSymbol(SymbolType itemSymbol)
{
this.itemSymbol = itemSymbol;
return(this);
}
private Symbol()
{
this.Type = SymbolType.Token;
this.ID = "$";
this.Tag = null;
}
public void WriteResultToFile(SymbolType type)
{
fileWriter.WriteLine(type.ToString());
}
public Compability GetAssignmentCompability(SymbolType lValueType, Data rValue)
{
switch (lValueType)
{
case SymbolType.Int:
if (rValue.Type == SymbolType.Int)
{
return(Compability.Full);
}
if (rValue.Type == SymbolType.Instance && rValue.Category == DataCategory.Variable)
{
// TODO, check if this is worth supporting
return(Compability.Full);
}
break;
case SymbolType.Float:
if (rValue.Type == SymbolType.Int && rValue.Category == DataCategory.Literal)
{
// var float x;
// x = 2; // 2 can be counted as IntegerLiteral or FloatLiteral
return(Compability.Full);
}
if (rValue.Type == SymbolType.Float)
{
if (rValue.Category == DataCategory.Literal || rValue.Category == DataCategory.FunctionInvocation)
{
return(Compability.Full);
}
}
break;
case SymbolType.String:
if (rValue.Type == SymbolType.String)
{
return(Compability.Full);
}
break;
case SymbolType.Instance:
if (rValue.Type == SymbolType.Instance && rValue.Category == DataCategory.FunctionInvocation)
{
return(Compability.Full);
}
break;
case SymbolType.Func:
if (rValue.Type == SymbolType.Func && rValue.Category == DataCategory.Variable)
{
return(Compability.Full);
}
if (rValue.Type == SymbolType.Instance && rValue.Category == DataCategory.Variable)
{
return(Compability.Full);
}
break;
}
return(Compability.None);
}
public BadgeSymbol(SymbolType type, BadgeColor color, BadgePosition position)
{
Type = type;
Color = color;
Position = position;
}
public SymbolToken(SymbolType type) =>
/// <summary>
/// Creates DatSymbol from Symbol
/// </summary>
public DatSymbol(Symbol symbol)
{
IsFunction = symbol is FunctionSymbol;
IsAddressable = symbol is BlockSymbol;
Index = symbol.Index;
Name = symbol.Path;
switch (symbol)
{
case FunctionSymbol functionSymbol:
OffClsRet = (uint)functionSymbol.BuiltinType;
break;
case AttributeSymbol attributeSymbol:
OffClsRet = (uint)attributeSymbol.Offset;
break;
case ClassSymbol classSymbol:
OffClsRet = (uint)classSymbol.Size;
break;
default:
OffClsRet = 0;
break;
}
switch (symbol)
{
case FunctionSymbol functionSymbol:
Count = (uint)functionSymbol.ParametersCount;
break;
case ClassSymbol classSymbol:
Count = (uint)classSymbol.AttributesCount;
break;
case IArraySymbol arraySymbol:
Count = (uint)arraySymbol.Size;
break;
case ExternalParameterSymbol _:
Count = 0;
break;
case PrototypeSymbol _:
Count = 0;
break;
case InstanceSymbol _:
Count = 0;
break;
default:
Count = 1;
break;
}
BuiltinType = IsFunction ? SymbolType.Func : symbol.BuiltinType;
if (symbol is ConstSymbol && symbol.BuiltinType == SymbolType.Func)
{
BuiltinType = SymbolType.Int;
}
Flags = symbol.Flags;
if (!symbol.Path.StartsWith(".")) // .HELPER_INSTANCE symbol (used for nested attributes) is automatically created
{
FileIndex = (uint)symbol.Node.Location.FileIndex;
Line = (uint)symbol.Node.Location.Line;
LinesCount = (uint)symbol.Node.Location.LinesCount;
Column = (uint)symbol.Node.Location.Column;
CharsCount = (uint)symbol.Node.Location.CharsCount;
}
switch (symbol)
{
case ClassSymbol classSymbol:
Content = new object[] { classSymbol.Offset };
break;
case BlockSymbol blockSymbol:
Content = new object[] { blockSymbol.FirstTokenAddress };
break;
case AttributeSymbol _:
Content = new object[] {};
break;
case StringConstSymbol stringConstSymbol:
Content = stringConstSymbol.Content;
break;
case ConstSymbol constSymbol:
Content = constSymbol.Content;
break;
case VarSymbol _:
Content = new object[Count];
for (int i = 0; i < Count; ++i)
{
switch (BuiltinType)
{
case SymbolType.String:
Content[i] = "";
break;
case SymbolType.Float:
Content[i] = 0.0f;
break;
default:
Content[i] = 0;
break;
}
}
break;
case ExternalParameterSymbol externalParameterSymbol:
if (externalParameterSymbol.BuiltinType == SymbolType.Instance || externalParameterSymbol.BuiltinType == SymbolType.Func)
{
Content = new object[] { 0 };
}
else
{
Content = new object[] {};
}
break;
case ParameterSymbol _:
switch (BuiltinType)
{
case SymbolType.String:
Content = new object[] { "" };
break;
case SymbolType.Float:
Content = new object[] { 0.0f };
break;
default:
Content = new object[] { 0 };
break;
}
break;
default:
Content = new object[] {};
break;
}
ParentIndex = -1;
switch (symbol)
{
case SubclassSymbol subclassSymbol:
if (subclassSymbol.Path.StartsWith(".")) // .HELPER_INSTANCE symbol (used for nested attributes) is automatically created
{
ParentIndex = -1;
}
else
{
ParentIndex = subclassSymbol.InheritanceParentSymbol.Index;
}
break;
case AttributeSymbol attributeSymbol:
ParentIndex = attributeSymbol.ParentBlockSymbol.Index;
break;
case VarSymbol varSymbol:
if (varSymbol.ComplexType is ClassSymbol classSymbol)
{
ParentIndex = classSymbol.Index;
}
break;
case ParameterSymbol parameterSymbol:
if (parameterSymbol.ComplexType is ClassSymbol classSymbol2)
{
ParentIndex = classSymbol2.Index;
}
break;
}
}
private static void DrawPointWithSymbolStyle(SKCanvas canvas, SymbolStyle style,
Point destination, float opacity, SymbolType symbolType, float mapRotation)
{
canvas.Save();
canvas.Translate((float)destination.X, (float)destination.Y);
canvas.Scale((float)style.SymbolScale, (float)style.SymbolScale);
if (style.SymbolOffset.IsRelative)
{
canvas.Translate((float)(SymbolStyle.DefaultWidth * style.SymbolOffset.X), (float)(-SymbolStyle.DefaultWidth * style.SymbolOffset.Y));
}
else
{
canvas.Translate((float)style.SymbolOffset.X, (float)-style.SymbolOffset.Y);
}
if (style.SymbolRotation != 0)
{
var rotation = (float)style.SymbolRotation;
if (style.RotateWithMap)
{
rotation += mapRotation;
}
canvas.RotateDegrees(rotation);
}
DrawPointWithVectorStyle(canvas, style, opacity, symbolType);
canvas.Restore();
}
/// <summary>
/// Creates DatSymbol from binary (DAT formatted) stream
/// </summary>
public DatSymbol(DatBinaryReader reader)
{
var hasName = Convert.ToBoolean(reader.ReadUInt32());
if (hasName) // TODO is it even possible for symbol to not have name?
{
Name = reader.ReadString();
}
OffClsRet = reader.ReadUInt32();
uint bitField = reader.ReadUInt32();
Count = bitField & 0xFFF;
BuiltinType = (SymbolType)((bitField & 0xF000) >> 12);
Flags = (SymbolFlag)((bitField & 0x3F0000) >> 16);
FileIndex = reader.ReadUInt32();
Line = reader.ReadUInt32();
LinesCount = reader.ReadUInt32();
Column = reader.ReadUInt32();
CharsCount = reader.ReadUInt32();
Content = new object[] {};
if (!Flags.HasFlag(SymbolFlag.ClassVar))
{
switch (BuiltinType)
{
case SymbolType.Class:
case SymbolType.Func:
case SymbolType.Instance:
case SymbolType.Prototype:
Content = new object[] { reader.ReadInt32() };
break;
default:
Content = new object[Count];
for (int i = 0; i < Count; ++i)
{
switch (BuiltinType)
{
case SymbolType.String:
Content[i] = reader.ReadString();
break;
case SymbolType.Float:
Content[i] = reader.ReadSingle();
break;
default:
Content[i] = reader.ReadInt32();
break;
}
}
break;
}
}
ParentIndex = reader.ReadInt32();
}
/// <summary>
/// Create a new <see cref="LineItem"/> using the specified properties.
/// </summary>
/// <param name="label">The _label that will appear in the legend.</param>
/// <param name="x">An array of double precision values that define
/// the independent (X axis) values for this curve</param>
/// <param name="y">An array of double precision values that define
/// the dependent (Y axis) values for this curve</param>
/// <param name="color">A <see cref="Color"/> value that will be applied to
/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
/// </param>
/// <param name="symbolType">A <see cref="SymbolType"/> enum specifying the
/// type of symbol to use for this <see cref="LineItem"/>. Use <see cref="SymbolType.None"/>
/// to hide the symbols.</param>
public LineItem(string label, double[] x, double[] y, Color color, SymbolType symbolType)
: this(label, new PointPairList(x, y), color, symbolType)
{
}
private void Resolve(ITypedSymbol typedSymbol)
{
Symbol symbol = (Symbol)typedSymbol;
SymbolType symbolBuiltinType = symbol.BuiltinType;
DeclarationNode typedSymbolNode = (DeclarationNode)symbol.Node;
CustomTypeDeclarationNode customTypeDeclarationNode = (CustomTypeDeclarationNode)typedSymbolNode;
if (symbolBuiltinType == SymbolType.Uninitialized) // if symbolBuiltinType isn't one of the simple builtin types
{
// TODO think of: differentiate NotAClassError and UnknownTypeNameError
if (_symbolTable.ContainsKey(typedSymbol.TypeName))
{
Symbol typeSymbol = _symbolTable[typedSymbol.TypeName];
if (typeSymbol is ClassSymbol)
{
typedSymbol.ComplexType = typeSymbol;
symbol.BuiltinType = SymbolType.Instance;
symbolBuiltinType = SymbolType.Instance;
DeclarationNode declarationNode = (DeclarationNode)typeSymbol.Node;
declarationNode.Usages.Add(customTypeDeclarationNode.TypeNameNode);
}
else
{
typedSymbolNode.Annotations.Add(new UnknownTypeNameError(customTypeDeclarationNode.TypeNameNode.Value, customTypeDeclarationNode.TypeNameNode.Location));
return;
}
}
else
{
typedSymbolNode.Annotations.Add(new UnknownTypeNameError(customTypeDeclarationNode.TypeNameNode.Value, customTypeDeclarationNode.TypeNameNode.Location));
return;
}
}
switch (typedSymbol)
{
case FunctionSymbol _:
switch (symbolBuiltinType)
{
case SymbolType.Class:
case SymbolType.Prototype:
case SymbolType.Func:
symbol.BuiltinType = SymbolType.Uninitialized;
typedSymbolNode.Annotations.Add(new UnsupportedFunctionTypeError(customTypeDeclarationNode.TypeNameNode.Location));
return;
}
break;
case IArraySymbol _:
switch (symbolBuiltinType)
{
case SymbolType.Int:
case SymbolType.String:
case SymbolType.Func:
case SymbolType.Float: // very limited type
break;
default:
symbol.BuiltinType = SymbolType.Uninitialized;
typedSymbolNode.Annotations.Add(new UnsupportedArrayTypeError(customTypeDeclarationNode.TypeNameNode.Location));
return;
}
break;
case NestableSymbol _:
switch (symbolBuiltinType)
{
case SymbolType.Class:
case SymbolType.Prototype:
case SymbolType.Void:
symbol.BuiltinType = SymbolType.Uninitialized;
typedSymbolNode.Annotations.Add(new UnsupportedTypeError(customTypeDeclarationNode.TypeNameNode.Location));
return;
}
break;
}
}
public virtual void LoadfromArray(string name, double[] X, double[] Y, Color color, SymbolType symbol, int symbolsize, bool isSmoothed, string tag)
{
PointPairList list = new PointPairList(X, Y);
AddCurvetoGraph(list, name, color, symbol, symbolsize, isSmoothed, tag);
m_alDatainGraph.Add(name);
}
protected MethodSymbol(SymbolType type, string name, TypeSymbol parent, TypeSymbol returnType)
: base(type, name, parent, returnType)
{
}
