public override char_value createchar_value()
{
char_value retVal = new CharValue();
_defaultValueSetter.SetDefaultValue(retVal);
return(retVal);
}
public void CreateCharacteristicValue(CharValueDTO dto)
{
var newCharValue = new CharValue();
newCharValue.CharacteristicId = dto.CharacteristicId;
newCharValue.Id = Guid.NewGuid();
newCharValue.IntVal = dto.IntVal;
newCharValue.FloatVal = dto.FloatVal;
newCharValue.StrVal = dto.StrVal;
_characteristicValueRepository.Create(newCharValue);
}
/// <summary>
/// Iterates over a string of characters.
/// </summary>
/// <param name="vm">The environment in which to execute the for loop's body.</param>
/// <param name="str"><see cref="StringValue"/> to iterate over.</param>
private void IterateOverString(VM vm, StringValue str)
{
char[] chars = str.String.ToCharArray();
for (int count = 0; count < chars.Length; count++)
{
Value it = new CharValue(chars[count]);
VM @new = new VM(vm, vm.Global);
if (DoExecution(@new, it, count))
{
break;
}
chars[count] = @new.Variables[iter].Char;
}
str.ReplaceString(new string(chars));
}
public void SaveCharacteristicValue(CharValue characteristicValue, Product product)
{
var characteristic = context.Characteristics.Find(characteristicValue.Characteristic.Id);
characteristicValue.Characteristic = characteristic;
if (characteristicValue.Id == 0)
{
characteristicValue.Product = product;
context.CharValues.Add(characteristicValue);
}
else
{
var dbEntry = context.CharValues.Find(characteristicValue.Id);
dbEntry.Characteristic = characteristicValue.Characteristic;
dbEntry.numValue = characteristicValue.numValue;
dbEntry.strValue = characteristicValue.strValue;
//dbEntry.Product = product;
}
context.SaveChanges();
}
public override int GetHashCode()
{
unchecked
{
var hashCode = CharValue.GetHashCode();
hashCode = (hashCode * 397) ^ ByteValue.GetHashCode();
hashCode = (hashCode * 397) ^ SByteValue.GetHashCode();
hashCode = (hashCode * 397) ^ ShortValue.GetHashCode();
hashCode = (hashCode * 397) ^ UShortValue.GetHashCode();
hashCode = (hashCode * 397) ^ IntValue;
hashCode = (hashCode * 397) ^ (int)UIntValue;
hashCode = (hashCode * 397) ^ LongValue.GetHashCode();
hashCode = (hashCode * 397) ^ ULongValue.GetHashCode();
hashCode = (hashCode * 397) ^ FloatValue.GetHashCode();
hashCode = (hashCode * 397) ^ DoubleValue.GetHashCode();
hashCode = (hashCode * 397) ^ DecimalValue.GetHashCode();
hashCode = (hashCode * 397) ^ DateTimeValue.GetHashCode();
hashCode = (hashCode * 397) ^ GuidValue.GetHashCode();
hashCode = (hashCode * 397) ^ StringValue.GetHashCode();
return(hashCode);
}
}
/// <summary>
/// Processes the source code assuming that it represents a char literal.
/// </summary>
/// <returns>A character token if success or an error token if not.</returns>
private Token ProcessCharacter()
{
// skip ' character
tokenStart++;
while (CurrentChar != '\'' && CurrentChar != '\0')
{
tokenLength++;
}
if (tokenLength != 1 || CurrentChar != '\'')
{
return(Token.Error(TokenString, currentIndentation));
}
string charString = TokenString;
Value charVal = new CharValue(charString[0]);
Token token = new Token(Token.Kind.LiteralChar, currentIndentation, charString, charVal);
// skip last ' character
tokenLength++;
return(token);
}
/// <summary>
/// Replaces the escape sequences in the given piece of text by their value
/// </summary>
/// <param name="value">A string</param>
/// <returns>The string with the escape sequences replaced by their value</returns>
public static string ReplaceEscapees(string value)
{
if (!value.Contains("\\"))
{
return(value);
}
StringBuilder builder = new StringBuilder();
for (int i = 0; i != value.Length;)
{
CharValue cv = GetCharValue(value, i);
if (cv.chars.Length == 2 && cv.chars[0] == '\\')
{
builder.Append(cv.chars[1]);
}
else
{
builder.Append(cv.chars);
}
i += cv.length;
}
return(builder.ToString());
}
/// <summary>
/// Iterates over a range of values.
/// </summary>
/// <param name="vm">The environment in which to execute the for loop's body.</param>
/// <param name="range">The range to iterate over.</param>
private void IterateOverRange(VM vm, RangeValue range)
{
Value it = range.Start;
Value end = range.End;
int count = 0;
while (true)
{
switch (it.Type)
{
case Value.ValueType.Number:
{
bool @break;
if (range.Inclusive)
{
@break = it.Number > end.Number;
}
else
{
@break = it.Number >= end.Number;
}
if (@break)
{
return;
}
break;
}
case Value.ValueType.Char:
{
bool @break;
if (range.Inclusive)
{
@break = it.Char > end.Char;
}
else
{
@break = it.Char >= end.Char;
}
if (@break)
{
return;
}
break;
}
default:
throw new Exception(string.Format("Internal Error: Range<{0}>.", it.Type));
}
VM @new = new VM(vm, vm.Global);
if (DoExecution(@new, it, count))
{
break;
}
count++;
switch (it.Type)
{
case Value.ValueType.Number:
it = new NumberValue(it.Number + 1);
break;
case Value.ValueType.Char:
it = new CharValue((char)(it.Char + 1));
break;
default:
throw new Exception(string.Format("Internal Error: Range<{0}>.", it.Type));
}
}
}
public override char_value createchar_value()
{
char_value retVal = new CharValue();
_defaultValueSetter.SetDefaultValue(retVal);
return retVal;
}
public override char?MapChar(CharValue value)
{
return(value.Value());
}
/// <summary>
/// Hash code
/// </summary>
public override int GetHashCode()
{
return(CharValue.GetHashCode());
}
/// <summary>
/// Equality with another char
/// </summary>
public bool Equals(CharInfo c)
{
return(CharValue.Equals(c.CharValue));
}
/// <summary>
/// Appends the corresponding type to the name space
/// </summary>
/// <param name="nameSpace">The namespace in which the type must be added</param>
/// <param name="name">the name of the type</param>
/// <param name="type">the type to convert</param>
private DataDictionary.Types.Type AppendType(DataDictionary.Types.NameSpace nameSpace, string name, ErtmsSolutions.CodecNT.Type type)
{
DataDictionary.Types.Type retVal = null;
if (EFSType(type) == null)
{
if (type.value is UiValue)
{
UiValue uiValue = type.value as UiValue;
List <DataDictionary.Constants.EnumValue> values = getSpecialValues(uiValue.special_or_reserved_values);
Decimal maxValue = twoPow(type.length) - 1;
if (IsEnumeration(values, maxValue))
{
DataDictionary.Types.Enum enumeration = (DataDictionary.Types.Enum)DataDictionary.Generated.acceptor.getFactory().createEnum();
enumeration.Name = type.id;
enumeration.Default = values[0].Name;
foreach (DataDictionary.Constants.EnumValue value in values)
{
enumeration.appendValues(value);
}
nameSpace.appendEnumerations(enumeration);
retVal = enumeration;
}
else
{
DataDictionary.Types.Range range = (DataDictionary.Types.Range)DataDictionary.Generated.acceptor.getFactory().createRange();
range.Name = type.id;
double factor = 1.0;
System.Globalization.CultureInfo info = System.Globalization.CultureInfo.InvariantCulture;
ResolutionFormula resolutionFormula = uiValue.resolution_formula;
if (resolutionFormula != null && resolutionFormula.Value != null)
{
factor = double.Parse(resolutionFormula.Value, info);
// In that case the precision is integer
range.setPrecision(DataDictionary.Generated.acceptor.PrecisionEnum.aIntegerPrecision);
range.MinValue = "0";
range.MaxValue = "" + maxValue;
range.Default = "0";
}
else
{
if (Math.Round(factor) == factor)
{
// Integer precision
range.setPrecision(DataDictionary.Generated.acceptor.PrecisionEnum.aIntegerPrecision);
range.MinValue = "0";
range.MaxValue = "" + maxValue * new Decimal(factor);
range.Default = "0";
}
else
{
// Double precision
range.setPrecision(DataDictionary.Generated.acceptor.PrecisionEnum.aDoublePrecision);
range.MinValue = "0.0";
range.MaxValue = (maxValue * new Decimal(factor)).ToString(info);
range.Default = "0.0";
}
}
foreach (DataDictionary.Constants.EnumValue value in values)
{
range.appendSpecialValues(value);
}
nameSpace.appendRanges(range);
retVal = range;
}
}
else if (type.value is CharValue)
{
CharValue charValue = type.value as CharValue;
// Nothing to do : translated into string
}
else if (type.value is BcdValue)
{
BcdValue bcdValue = type.value as BcdValue;
DataDictionary.Types.Range range = (DataDictionary.Types.Range)DataDictionary.Generated.acceptor.getFactory().createRange();
range.Name = type.id;
range.MinValue = "0";
range.MaxValue = "" + (twoPow(type.length) - 1);
range.Default = "0";
nameSpace.appendRanges(range);
retVal = range;
}
if (retVal != null)
{
retVal.Comment = type.short_description;
if (type.description != null)
{
retVal.Comment = retVal.Comment + "\n" + type.description;
}
}
}
return(retVal);
}
public override string ToString()
{
return("Results of " + CharValue.ToString());
}
/// <summary>
/// Builds a NFA from a character class
/// </summary>
/// <param name="node">An AST node representing a NFA</param>
/// <returns>The equivalent NFA</returns>
private NFA BuildNFAFromClass(ASTNode node)
{
// extract the value
string value = node.Value;
value = value.Substring(1, value.Length - 2);
bool positive = true;
if (value.Length > 0 && value[0] == '^')
{
value = value.Substring(1);
positive = false;
}
// build the character spans
List <CharSpan> spans = new List <CharSpan>();
for (int i = 0; i != value.Length;)
{
// read the first full unicode character
CharValue b = GetCharValue(value, i);
i += b.length;
if (b.chars[0] >= 0xD800 && b.chars[0] <= 0xDFFF)
{
OnError(node.Position, "Unsupported non-plane 0 Unicode character ({0}) in character class", new String(b.chars));
return(BuildEpsilonNFA());
}
if ((i <= value.Length - 2) && (value[i] == '-'))
{
// this is a range, match the '-'
i++;
CharValue e = GetCharValue(value, i);
i += e.length;
if (e.chars[0] >= 0xD800 && e.chars[0] <= 0xDFFF)
{
OnError(node.Position, "Unsupported non-plane 0 Unicode character ({0}) in character class", new String(e.chars));
return(BuildEpsilonNFA());
}
char begin = b.chars.Length == 1 ? b.chars[0] : b.chars[1];
char end = e.chars.Length == 1 ? e.chars[0] : e.chars[1];
if (begin < 0xD800 && end > 0xDFFF)
{
// oooh you ...
spans.Add(new CharSpan(begin, (char)0xD7FF));
spans.Add(new CharSpan((char)0xE000, end));
}
else
{
spans.Add(new CharSpan(begin, end));
}
}
else
{
// this is a normal character
char begin = b.chars.Length == 1 ? b.chars[0] : b.chars[1];
spans.Add(new CharSpan(begin, begin));
}
}
// build the result
NFA automata = NFA.NewMinimal();
if (positive)
{
foreach (CharSpan span in spans)
{
automata.StateEntry.AddTransition(span, automata.StateExit);
}
}
else
{
spans.Sort(new System.Comparison <CharSpan>(CharSpan.Compare));
// TODO: Check for span intersections and overflow of b (when a span ends on 0xFFFF)
char b = (char)0;
for (int i = 0; i != spans.Count; i++)
{
if (spans[i].Begin > b)
{
automata.StateEntry.AddTransition(new CharSpan(b, (char)(spans[i].Begin - 1)), automata.StateExit);
}
b = (char)(spans[i].End + 1);
// skip the surrogate encoding points
if (b >= 0xD800 && b <= 0xDFFF)
{
b = (char)0xE000;
}
}
if (b <= 0xD7FF)
{
automata.StateEntry.AddTransition(new CharSpan(b, (char)0xD7FF), automata.StateExit);
automata.StateEntry.AddTransition(new CharSpan((char)0xE000, (char)0xFFFF), automata.StateExit);
}
else if (b != 0xFFFF)
{
// here b >= 0xE000
automata.StateEntry.AddTransition(new CharSpan(b, (char)0xFFFF), automata.StateExit);
}
// surrogate pairs
NFAState intermediate = automata.AddNewState();
automata.StateEntry.AddTransition(new CharSpan((char)0xD800, (char)0xDBFF), intermediate);
intermediate.AddTransition(new CharSpan((char)0xDC00, (char)0xDFFF), automata.StateExit);
}
return(automata);
}
