private bool DetermineContinuousness()
{
HashSet <int> integersUsed = new HashSet <int>();
bool first = true;
int min = 0;
int max = 0;
foreach (Chunk chunk in this.chunks)
{
if (chunk.Cases.Length != 1)
{
throw new Exception("This should have been filtered out by the largestSpane check earlier.");
}
IntegerConstant c = chunk.Cases[0] as IntegerConstant;
if (c == null)
{
throw new Exception("How did this happen?");
}
int num = c.Value;
integersUsed.Add(num);
if (first)
{
first = false;
min = num;
max = num;
}
else
{
if (num < min)
{
min = num;
}
if (num > max)
{
max = num;
}
}
}
int expectedTotal = max - min + 1;
return(expectedTotal == integersUsed.Count);
}
public ListSlice(Expression root, List <Expression> items, Token bracketToken, TopLevelConstruct owner)
: base(root.FirstToken, owner)
{
this.Root = root;
this.BracketToken = bracketToken;
if (items.Count == 2)
{
items.Add(new IntegerConstant(null, 1, owner));
}
if (items.Count != 3)
{
throw new Exception("Slices must have 2 or 3 components before passed into the constructor.");
}
if (items[2] == null)
{
items[2] = new IntegerConstant(null, 1, owner);
}
this.Items = items.ToArray();
}
public ListSlice(Expression root, List<Expression> items, Token bracketToken, Executable owner)
: base(root.FirstToken, owner)
{
this.Root = root;
this.BracketToken = bracketToken;
if (items.Count == 2)
{
items.Add(new IntegerConstant(null, 1, owner));
}
if (items.Count != 3)
{
throw new Exception("Slices must have 2 or 3 components before passed into the constructor.");
}
if (items[2] == null)
{
items[2] = new IntegerConstant(null, 1, owner);
}
this.Items = items.ToArray();
}
internal override IList <Executable> Resolve(Parser parser)
{
if (!parser.IsTranslateMode)
{
int resolutionState = parser.ConstantAndEnumResolutionState[this];
if (resolutionState == 2)
{
return(new Executable[0]);
}
if (resolutionState == 1)
{
throw new ParserException(this.FirstToken, "The resolution of this enum creates a cycle.");
}
parser.ConstantAndEnumResolutionState[this] = 1;
}
HashSet <int> consumed = new HashSet <int>();
for (int i = 0; i < this.Items.Length; ++i)
{
string itemName = this.Items[i].Value;
if (itemName == "length")
{
throw new ParserException(this.Items[i], "The name 'length' is not allowed as an enum value as it is a reserved field. In general, enum members should be in ALL CAPS anyway.");
}
if (this.IntValue.ContainsKey(itemName))
{
throw new ParserException(this.Items[i], "Duplicate item in same enum. ");
}
this.IntValue[itemName] = -1;
if (this.Values[i] != null)
{
IntegerConstant ic = this.Values[i].Resolve(parser) as IntegerConstant;
if (ic == null)
{
throw new ParserException(this.Values[i].FirstToken, "Enum values must be integers or left blank.");
}
this.Values[i] = ic;
if (consumed.Contains(ic.Value))
{
throw new ParserException(this.Values[i].FirstToken, "This integer value has already been used in the same enum.");
}
consumed.Add(ic.Value);
this.IntValue[itemName] = ic.Value;
}
}
parser.ConstantAndEnumResolutionState[this] = 2;
int next = 0;
for (int i = 0; i < this.Items.Length; ++i)
{
if (this.Values[i] == null)
{
while (consumed.Contains(next))
{
++next;
}
this.IntValue[this.Items[i].Value] = next;
consumed.Add(next);
}
}
parser.AddEnumDefinition(this);
return(Executable.EMPTY_ARRAY);
}
protected override void TranslateIntegerConstant(List<string> output, IntegerConstant intConstant)
{
int value = intConstant.Value;
if (value >= 0)
{
output.Add("" + value);
}
else
{
output.Add("(" + value + ")");
}
}
public SwitchStatementUnsafeBlotchy(SwitchStatement switchStatement, bool useExplicitMax, int explicitMax, Executable owner)
: base(switchStatement.FirstToken, owner)
{
this.OriginalSwitchStatement = switchStatement;
this.Condition = switchStatement.Condition;
this.UsesStrings = switchStatement.UsesStrings;
this.UseExplicitMax = useExplicitMax;
this.ExplicitMax = explicitMax;
if (this.UsesStrings)
{
this.StringUnsafeToSafeMapping = new Dictionary <string, int>();
}
else
{
this.IntegerUnsafeToSafeMapping = new Dictionary <int, int>();
}
this.codeMapping = new Dictionary <int, Executable[]>();
this.tokenMapping = new Dictionary <int, Token>();
this.max = switchStatement.Chunks.Length - 1;
for (int i = 0; i < switchStatement.Chunks.Length; ++i)
{
SwitchStatement.Chunk chunk = switchStatement.Chunks[i];
this.codeMapping[i] = chunk.Code;
this.tokenMapping[i] = chunk.CaseOrDefaultToken;
foreach (Expression expression in chunk.Cases)
{
if (expression == null)
{
this.DefaultCaseId = i;
}
else
{
IntegerConstant ic = expression as IntegerConstant;
StringConstant sc = expression as StringConstant;
if (ic == null && sc == null)
{
throw new Exception("This shouldn't happen.");
}
if (ic != null)
{
int c = ic.Value;
this.IntegerUnsafeToSafeMapping[c] = i;
}
else
{
string s = sc.Value;
this.StringUnsafeToSafeMapping[s] = i;
}
}
}
}
if (useExplicitMax)
{
if (this.UsesStrings)
{
throw new Exception("Cannot use explicit max on string switch statements.");
}
}
}
private void CompileIntegerConstant(Parser parser, ByteBuffer buffer, IntegerConstant intConst, bool outputUsed)
{
if (!outputUsed) throw new ParserException(intConst.FirstToken, "This expression does nothing.");
buffer.Add(intConst.FirstToken, OpCode.LITERAL, parser.GetIntConstant(intConst.Value));
}
protected abstract void TranslateIntegerConstant(List<string> output, IntegerConstant intConstant);
