private void SetSymbolRuleMarkers(PredefinedSymbolCollection customSymbols)
{
int bucketCount = base.GetBucketCount();
MapMarkerRule mapMarkerRule = (MapMarkerRule)base.m_mapRule;
MapMarkerCollection mapMarkers = mapMarkerRule.MapMarkers;
int count = mapMarkers.Count;
MapBucketCollection mapBuckets = base.m_mapRule.MapBuckets;
bool flag = base.GetDistributionType() == MapRuleDistributionType.Custom;
for (int i = 0; i < bucketCount; i++)
{
PredefinedSymbol predefinedSymbol = new PredefinedSymbol();
if (i < count)
{
this.RenderMarker(predefinedSymbol, ((ReportElementCollectionBase <MapMarker>)mapMarkers)[i]);
}
else
{
predefinedSymbol.MarkerStyle = MarkerStyle.None;
}
if (flag)
{
MapBucket bucket = ((ReportElementCollectionBase <MapBucket>)mapBuckets)[i];
predefinedSymbol.FromValue = base.GetFromValue(bucket);
predefinedSymbol.ToValue = base.GetToValue(bucket);
}
customSymbols.Add(predefinedSymbol);
}
}
private void SetSymbolRuleSizes(PredefinedSymbolCollection customSymbols)
{
int bucketCount = GetBucketCount();
if (bucketCount == 0)
{
return;
}
double startSize = GetStartSize();
double num = (GetEndSize() - startSize) / (double)bucketCount;
MapBucketCollection mapBuckets = m_mapRule.MapBuckets;
bool flag = GetDistributionType() == MapRuleDistributionType.Custom;
for (int i = 0; i < bucketCount; i++)
{
PredefinedSymbol predefinedSymbol = new PredefinedSymbol();
float num4 = predefinedSymbol.Width = (predefinedSymbol.Height = (int)Math.Round(startSize + (double)i * num));
if (flag)
{
MapBucket bucket = mapBuckets[i];
predefinedSymbol.FromValue = GetFromValue(bucket);
predefinedSymbol.ToValue = GetToValue(bucket);
}
customSymbols.Add(predefinedSymbol);
}
}
private void SetSymbolRuleSizes(PredefinedSymbolCollection customSymbols)
{
int bucketCount = base.GetBucketCount();
if (bucketCount != 0)
{
double startSize = this.GetStartSize();
double num = (this.GetEndSize() - startSize) / (double)bucketCount;
MapBucketCollection mapBuckets = base.m_mapRule.MapBuckets;
bool flag = base.GetDistributionType() == MapRuleDistributionType.Custom;
for (int i = 0; i < bucketCount; i++)
{
PredefinedSymbol predefinedSymbol = new PredefinedSymbol();
PredefinedSymbol predefinedSymbol2 = predefinedSymbol;
PredefinedSymbol predefinedSymbol3 = predefinedSymbol;
float num4 = predefinedSymbol2.Width = (predefinedSymbol3.Height = (float)(int)Math.Round(startSize + (double)i * num));
if (flag)
{
MapBucket bucket = ((ReportElementCollectionBase <MapBucket>)mapBuckets)[i];
predefinedSymbol.FromValue = base.GetFromValue(bucket);
predefinedSymbol.ToValue = base.GetToValue(bucket);
}
customSymbols.Add(predefinedSymbol);
}
}
}
private void SetSymbolRuleColors(Color[] colorRange, PredefinedSymbolCollection customSymbols)
{
MapBucketCollection mapBuckets = m_mapRule.MapBuckets;
bool flag = GetDistributionType() == MapRuleDistributionType.Custom;
int bucketCount = GetBucketCount();
for (int i = 0; i < bucketCount; i++)
{
PredefinedSymbol predefinedSymbol = new PredefinedSymbol();
if (i < colorRange.Length)
{
predefinedSymbol.Color = colorRange[i];
}
else
{
predefinedSymbol.Color = Color.Empty;
}
if (flag)
{
MapBucket bucket = mapBuckets[i];
predefinedSymbol.FromValue = GetFromValue(bucket);
predefinedSymbol.ToValue = GetToValue(bucket);
}
customSymbols.Add(predefinedSymbol);
}
}
private void SetSymbolRuleMarkers(PredefinedSymbolCollection customSymbols)
{
int bucketCount = GetBucketCount();
MapMarkerCollection mapMarkers = ((MapMarkerRule)m_mapRule).MapMarkers;
int count = mapMarkers.Count;
MapBucketCollection mapBuckets = m_mapRule.MapBuckets;
bool flag = GetDistributionType() == MapRuleDistributionType.Custom;
for (int i = 0; i < bucketCount; i++)
{
PredefinedSymbol predefinedSymbol = new PredefinedSymbol();
if (i < count)
{
RenderMarker(predefinedSymbol, mapMarkers[i]);
}
else
{
predefinedSymbol.MarkerStyle = MarkerStyle.None;
}
if (flag)
{
MapBucket bucket = mapBuckets[i];
predefinedSymbol.FromValue = GetFromValue(bucket);
predefinedSymbol.ToValue = GetToValue(bucket);
}
customSymbols.Add(predefinedSymbol);
}
}
private void ProcessKeyword(KeywordToken keywordToken)
{
PredefinedSymbol keyword = keywordToken.SymbolType;
if (keyword == PredefinedSymbol.If)
{
_source.ExpectKeyword(PredefinedSymbol.OpenParenthesis);
Expression condition = ReadExpression(true, PredefinedSymbol.CloseParenthesis);
GenerateCodeForExpression(condition);
ProcessCodeBlock();
if (_source.NextIsKeyword(PredefinedSymbol.Else))
{
ProcessCodeBlock();
}
}
else if (keyword == PredefinedSymbol.While)
{
_source.ExpectKeyword(PredefinedSymbol.OpenParenthesis);
Expression condition = ReadExpression(true, PredefinedSymbol.CloseParenthesis);
GenerateCodeForExpression(condition);
ProcessCodeBlock();
}
else if (keyword == PredefinedSymbol.For)
{
// TODO: Handle for loops
}
else if (keyword == PredefinedSymbol.Break)
{
// TODO: Handle break
}
else if (keyword == PredefinedSymbol.Continue)
{
// TODO: Handle continue
}
else if (keyword == PredefinedSymbol.Return)
{
Expression resultToReturn = ReadExpression(true, PredefinedSymbol.Semicolon);
GenerateCodeForExpression(resultToReturn);
// TODO: Generate code to return and release local vars
FreeAllLocalVariablesButLeaveValid();
}
else
{
throw new CompilerMessage(ErrorCode.InvalidUseOfKeyword, "Keyword '" + keywordToken.Name + "' is not valid here");
}
}
public bool IsModifierPresent(PredefinedSymbol symbol)
{
foreach (ModifierToken token in _nextTokenModifiers)
{
if (token.Symbol == symbol)
{
return(true);
}
}
return(false);
}
public bool IsModifierPresent(PredefinedSymbol symbol)
{
foreach (ModifierToken token in _nextTokenModifiers)
{
if (token.Symbol == symbol)
{
return true;
}
}
return false;
}
protected void InitializePredefinedSymbols(PredefinedSymbol predefinedSymbol, PointTemplateMapper symbolTemplateMapper)
{
predefinedSymbol.BorderColor = symbolTemplateMapper.GetBorderColor(hasScope: false);
predefinedSymbol.BorderStyle = symbolTemplateMapper.GetBorderStyle(hasScope: false);
predefinedSymbol.BorderWidth = symbolTemplateMapper.GetBorderWidth(hasScope: false);
predefinedSymbol.Font = symbolTemplateMapper.GetFont(hasScope: false);
predefinedSymbol.GradientType = symbolTemplateMapper.GetGradientType(hasScope: false);
predefinedSymbol.HatchStyle = symbolTemplateMapper.GetHatchStyle(hasScope: false);
predefinedSymbol.SecondaryColor = symbolTemplateMapper.GetBackGradientEndColor(hasScope: false);
predefinedSymbol.ShadowOffset = symbolTemplateMapper.GetShadowOffset(hasScope: false);
predefinedSymbol.TextColor = symbolTemplateMapper.GetTextColor(hasScope: false);
predefinedSymbol.LegendText = "";
predefinedSymbol.Text = "";
}
private void ProcessTokenAtTopLevel(Token thisToken)
{
if (thisToken is ModifierToken)
{
_state.NextTokenModifiers.Add((ModifierToken)thisToken);
}
else if (thisToken.IsVariableType)
{
bool wasFunction = false;
do
{
wasFunction = ParseAndAddGlobalVariableOrFunction(thisToken);
}while ((!wasFunction) && (_source.NextIsKeyword(PredefinedSymbol.Comma)));
if (!wasFunction)
{
_source.ExpectKeyword(PredefinedSymbol.Semicolon);
}
_state.NextTokenModifiers.Clear();
}
else if (thisToken is KeywordToken)
{
PredefinedSymbol keyword = ((KeywordToken)thisToken).SymbolType;
if (keyword == PredefinedSymbol.StructDefinition)
{
_output.AddStruct(ProcessStructDeclaration());
}
else if (keyword == PredefinedSymbol.Enum)
{
ProcessEnumDeclaration();
}
else if (keyword == PredefinedSymbol.Export)
{
ProcessExportCommand();
}
else
{
RecordError(ErrorCode.InvalidUseOfKeyword, "Invalid use of '" + thisToken.Name + "'");
}
}
else if (thisToken.Name.StartsWith(Constants.NEW_SCRIPT_MARKER))
{
_scriptName = thisToken.Name.Substring(Constants.NEW_SCRIPT_MARKER.Length, thisToken.Name.Length - Constants.NEW_SCRIPT_MARKER.Length - 1);
}
else
{
RecordError(ErrorCode.UnexpectedToken, "Unexpected '" + thisToken.Name + "'");
}
}
private void InitializePredefinedSymbols(PredefinedSymbolCollection predefinedSymbols, PointTemplateMapper spatialElementTemplateMapper, Color?color, int?size)
{
foreach (PredefinedSymbol predefinedSymbol4 in predefinedSymbols)
{
if (color.HasValue)
{
predefinedSymbol4.Color = color.Value;
}
if (size.HasValue)
{
PredefinedSymbol predefinedSymbol2 = predefinedSymbol4;
PredefinedSymbol predefinedSymbol3 = predefinedSymbol4;
float num3 = predefinedSymbol2.Width = (predefinedSymbol3.Height = (float)size.Value);
}
base.InitializePredefinedSymbols(predefinedSymbol4, spatialElementTemplateMapper);
}
}
private void InitializePredefinedSymbols(PredefinedSymbolCollection predefinedSymbols, PointTemplateMapper symbolTemplateMapper, int?size, MarkerStyle?markerStyle)
{
foreach (PredefinedSymbol predefinedSymbol4 in predefinedSymbols)
{
if (size.HasValue)
{
PredefinedSymbol predefinedSymbol2 = predefinedSymbol4;
PredefinedSymbol predefinedSymbol3 = predefinedSymbol4;
float num3 = predefinedSymbol2.Width = (predefinedSymbol3.Height = (float)size.Value);
}
if (markerStyle.HasValue)
{
predefinedSymbol4.MarkerStyle = markerStyle.Value;
}
base.InitializePredefinedSymbols(predefinedSymbol4, symbolTemplateMapper);
}
}
/// <summary>Gets the <see cref="T:ComparisonOperator"/> that matches the specified <see cref="T:PredefinedSymbol"/>.</summary>
/// <param name="symbol">The <see cref="T:PredefinedSymbol"/> to match.</param>
/// <returns>The matched <see cref="T:ComparisonOperator"/>.</returns>
public static ComparisonOperator GetOperator(PredefinedSymbol symbol)
{
switch (symbol)
{
case PredefinedSymbol.Equal: return(ComparisonOperator.Equal);
case PredefinedSymbol.NotEqual: return(ComparisonOperator.NotEqual);
case PredefinedSymbol.LessThan: return(ComparisonOperator.LessThan);
case PredefinedSymbol.GreaterThan: return(ComparisonOperator.GreaterThan);
case PredefinedSymbol.LessThanOrEqual: return(ComparisonOperator.LessThanOrEqual);
case PredefinedSymbol.GreaterThanOrEqual: return(ComparisonOperator.GreaterThanOrEqual);
default: return(ComparisonOperator.None);
}
}
private void RenderMarker(PredefinedSymbol customSymbol, MapMarker mapMarker)
{
MapMarkerStyle markerStyle = MapMapper.GetMarkerStyle(mapMarker, hasScope: true);
if (markerStyle != MapMarkerStyle.Image)
{
customSymbol.MarkerStyle = MapMapper.GetMarkerStyle(markerStyle);
return;
}
MapMarkerImage mapMarkerImage = mapMarker.MapMarkerImage;
if (mapMarkerImage == null)
{
throw new RenderingObjectModelException(RPRes.rsMapLayerMissingProperty(RPRes.rsObjectTypeMap, m_mapRule.MapDef.Name, m_mapVectorLayer.Name, "MapMarkerImage"));
}
customSymbol.Image = m_mapMapper.AddImage(mapMarkerImage);
customSymbol.ImageResizeMode = m_mapMapper.GetImageResizeMode(mapMarkerImage);
customSymbol.ImageTransColor = m_mapMapper.GetImageTransColor(mapMarkerImage);
}
private bool NextIsKeyword(PredefinedSymbol[] symbolTypes, bool throwIfNot, bool peekOnly, string customErrorMessage)
{
int lineNumberOfNext, readIndexOfNext;
Token nextToken = PeekNextToken(out lineNumberOfNext, out readIndexOfNext);
if (nextToken is KeywordToken)
{
foreach (PredefinedSymbol symbolType in symbolTypes)
{
if (((KeywordToken)nextToken).SymbolType == symbolType)
{
if (!peekOnly)
{
_currentLineNumber = lineNumberOfNext;
_readIndex = readIndexOfNext;
}
return true;
}
}
}
if (throwIfNot)
{
string errorMessage;
if (customErrorMessage != null)
{
errorMessage = customErrorMessage;
}
else
{
errorMessage = "Unexpected '" + nextToken.Name + "'; was expecting one of ";
foreach (PredefinedSymbol symbolType in symbolTypes)
{
errorMessage += "'" + symbolType.ToString() + "'; ";
}
}
throw new CompilerMessage(ErrorCode.UnexpectedToken, errorMessage);
}
return false;
}
public static bool AdjustBracketLevelIfTokenIsBracket(Token token, ref int bracketLevel)
{
if (token is KeywordToken)
{
PredefinedSymbol symbol = ((KeywordToken)token).SymbolType;
if ((symbol == PredefinedSymbol.OpenBrace) ||
(symbol == PredefinedSymbol.OpenParenthesis) ||
(symbol == PredefinedSymbol.OpenSquareBracket))
{
bracketLevel++;
return(true);
}
else if ((symbol == PredefinedSymbol.CloseBrace) ||
(symbol == PredefinedSymbol.CloseParenthesis) ||
(symbol == PredefinedSymbol.CloseSquareBracket))
{
bracketLevel--;
return(true);
}
}
return(false);
}
public KeywordToken(string name, PredefinedSymbol symbolType)
: this(name, symbolType, false)
{
}
/// <summary>
/// Determines if the next token is the specified keyword token. Behaviour
/// depends on parameters.
/// </summary>
/// <param name="peekOnly">do not advance the stream if the symbol is found</param>
/// <returns></returns>
public bool NextIsKeyword(PredefinedSymbol symbolType, bool peekOnly)
{
return(NextIsKeyword(new PredefinedSymbol[1] {
symbolType
}, false, peekOnly, null));
}
internal ModifierToken(string name, PredefinedSymbol type, ModifierTargets targets)
: base(name, true)
{
_targets = targets;
_type = type;
}
/// <summary>
/// Reads the next token, and expects it to be the passed in type.
/// If it isn't, throws an exception with the specified message.
/// </summary>
public void ExpectKeyword(PredefinedSymbol symbolTypes, string errorMessage)
{
NextIsKeyword(new PredefinedSymbol[] { symbolTypes }, true, false, errorMessage);
}
/// <summary>
/// Determines if the next token is the specified keyword token. If it
/// is, reads it from the stream. If not, leaves the stream as-is.
/// </summary>
public bool NextIsKeyword(PredefinedSymbol symbolType)
{
return(NextIsKeyword(symbolType, false));
}
public KeywordToken(string name, PredefinedSymbol symbolType)
: this(name, symbolType, false)
{
}
Token ReadPredefinedSymbolOrSingleLineComment()
{
PredefinedSymbol symbol = PredefinedSymbol.None;
switch (currentChar)
{
case '+': symbol = PredefinedSymbol.Plus; break;
case '*': symbol = PredefinedSymbol.Asterisk; break;
case '/': symbol = PredefinedSymbol.Slash; break;
case '^': symbol = PredefinedSymbol.Caret; break;
case '&': symbol = PredefinedSymbol.Ampersand; break;
case '(': symbol = PredefinedSymbol.OpenParenthesis; break;
case ')': symbol = PredefinedSymbol.ClosedParenthesis; break;
case ',': symbol = PredefinedSymbol.Comma; break;
case ':':
if (reader.Peek() == '=')
{
ReadChar(); symbol = PredefinedSymbol.Assignment;
}
else
{
symbol = PredefinedSymbol.Colon;
}
break;
case '=': ReadChar(); CheckForExpectedChar('='); symbol = PredefinedSymbol.Equal; break;
case '<':
switch (reader.Peek())
{
case '>': ReadChar(); symbol = PredefinedSymbol.NotEqual; break;
case '=': ReadChar(); symbol = PredefinedSymbol.LessThanOrEqual; break;
default: symbol = PredefinedSymbol.LessThan; break;
}
break;
case '>':
if (reader.Peek() == '=')
{
ReadChar(); symbol = PredefinedSymbol.GreaterThanOrEqual;
}
else
{
symbol = PredefinedSymbol.GreaterThan;
}
break;
case '-':
if (reader.Peek() == '-')
{
return(ReadSingleLineComment());
}
else
{
symbol = PredefinedSymbol.Minus;
}
break;
}
if (symbol != PredefinedSymbol.None)
{
ReadChar();
return(new PredefinedSymbolToken(symbol, startPosition, previousPosition));
}
else
{
ThrowException("Invalid character.", currentPosition);
}
return(null);
}
internal ModifierToken(string name, PredefinedSymbol type, ModifierTargets targets)
: base(name, true)
{
_targets = targets;
_type = type;
}
public KeywordToken(string name, PredefinedSymbol symbolType, bool isModificationOperator)
: base(name, true)
{
_symbolType = symbolType;
_isModificationOperator = isModificationOperator;
}
/// <summary>Initializes a new instance of the <see cref="PredefinedSymbolToken"/> class.</summary>
/// <param name="symbol">The symbol.</param>
/// <param name="startPosition">The start position.</param>
/// <param name="endPosition">The end position.</param>
internal PredefinedSymbolToken(PredefinedSymbol symbol, TextPosition startPosition, TextPosition endPosition)
: base(TokenType.Symbol, startPosition, endPosition)
{
this.symbol = symbol;
}
/// <summary>Checks whether this token is the specified predefined symbol token.</summary>
/// <param name="symbol">The predefined symbol to check.</param>
/// <returns>If this token equals the specified symbol, true; otherwise, false.</returns>
public override bool Equals(PredefinedSymbol symbol)
{
return(this.symbol == symbol);
}
/// <summary>
/// Determines if the next token is the specified keyword token. Behaviour
/// depends on parameters.
/// </summary>
/// <param name="peekOnly">do not advance the stream if the symbol is found</param>
/// <returns></returns>
public bool NextIsKeyword(PredefinedSymbol symbolType, bool peekOnly)
{
return NextIsKeyword(new PredefinedSymbol[1] { symbolType }, false, peekOnly, null);
}
/// <summary>
/// Determines if the next token is the specified keyword token. If it
/// is, reads it from the stream. If not, leaves the stream as-is.
/// </summary>
public bool NextIsKeyword(PredefinedSymbol symbolType)
{
return NextIsKeyword(symbolType, false);
}
/// <summary>
/// Reads the next token, and expects it to be the passed in type.
/// If it isn't, throws an exception with the specified message.
/// </summary>
public void ExpectKeyword(PredefinedSymbol symbolTypes, string errorMessage)
{
NextIsKeyword(new PredefinedSymbol[] { symbolTypes }, true, false, errorMessage);
}
/// <summary>Checks whether this token is the specified predefined symbol token.</summary>
/// <param name="symbol">The predefined symbol to check.</param>
/// <returns>If this token equals the specified symbol, true; otherwise, false.</returns>
public virtual bool Equals(PredefinedSymbol symbol)
{
return(false);
}
public KeywordToken(string name, PredefinedSymbol symbolType, bool isModificationOperator)
: base(name, true)
{
_symbolType = symbolType;
_isModificationOperator = isModificationOperator;
}
