public YuSymbolTableRow(ESymbolType stype, YuToken token)
{
this.SymbolType = stype;
this.SymbolToken = token;
this.ProcTree = null;
this.AbsoluteAddr = -1;
}
public YuSymbolTableRow(ESymbolType stype, YuToken token, YuTreeNode tree)
{
this.SymbolType = stype;
this.SymbolToken = token;
this.ProcTree = tree;
this.AbsoluteAddr = -1;
}
private int GetSymbolTypePrecedence(ESymbolType type)
{
if (type == ESymbolType.ESYMBOLTYPE_ZERO_INTEGER || type == ESymbolType.ESYMBOLTYPE_ZERO_FLOAT)
{
return(1);
}
else if (type == ESymbolType.ESYMBOLTYPE_INTEGER || type == ESymbolType.ESYMBOLTYPE_FLOAT || type == ESymbolType.ESYMBOLTYPE_STRING || type == ESymbolType.ESYMBOLTYPE_STRUCTURE)
{
return(6);
}
else if (type == ESymbolType.ESYMBOLTYPE_INTEGER_ONE_BYTE)
{
return(2);
}
else if (type == ESymbolType.ESYMBOLTYPE_UNSIGNED_INTEGER_ONE_BYTE)
{
return(3);
}
else if (type == ESymbolType.ESYMBOLTYPE_INTEGER_TWO_BYTES)
{
return(4);
}
else if (type == ESymbolType.ESYMBOLTYPE_UNSIGNED_INTEGER_TWO_BYTES)
{
return(5);
}
return(0);
}
public List <SymbolEntry> ReadBuffer()
{
List <SymbolEntry> objects = new List <SymbolEntry>();
while (true)
{
int skipSize;
ESymbolType symbol = GetNextSymbol(out skipSize);
ESymbolType?subType;
if ((ESymbolType)symbol == ESymbolType.ESYMBOLTYPE_NONE)
{
break;
}
System.UInt32 checksum = GetNextChecksum(skipSize);
object value = GetSymbolValue(symbol, out subType);
SymbolEntry entry = new SymbolEntry();
entry.name = checksum;
entry.value = value;
entry.type = symbol;
entry.subType = subType;
if (skipSize != 4)
{
entry.compressedByteSize = skipSize;
}
objects.Add(entry);
}
return(objects);
}
private Symbol GetFirstOfType(ESymbolType type)
{
foreach (var symbol in m_tables.Symbols)
{
if (symbol.Type == type)
{
return(symbol);
}
}
return(null);
}
public SymbolData(string sSymbol, int iStartLine, ESymbolType eType)
{
Symbol = sSymbol;
StartLine = iStartLine;
Type = eType;
}
private SymbolEntry ReadSymbolEntry(JsonReader reader, string propertyName)
{
SymbolEntry result = new SymbolEntry();
result.name = propertyName;
if (System.Int64.TryParse(propertyName, out System.Int64 checksum))
{
result.name = checksum;
}
result.compressedByteSize = null;
result.type = GetSymbolTypeFromToken(reader);
result.subType = ESymbolType.ESYMBOLTYPE_NONE;
int depth = reader.Depth;
if (result.type == ESymbolType.ESYMBOLTYPE_ARRAY)
{
var list = new List <object>();
int lastPrecedence = 0;
do
{
reader.Read();
if (reader.TokenType == JsonToken.StartObject)
{
var symbolList = ReadSymbolList(reader, reader.Depth);
list.Add(symbolList);
result.subType = ESymbolType.ESYMBOLTYPE_STRUCTURE;
lastPrecedence = 4;
}
else if (reader.TokenType != JsonToken.EndArray)
{
list.Add(reader.Value);
ESymbolType type = GetSymbolTypeFromToken(reader, false, false);
int precedence = GetSymbolTypePrecedence(type);
if (precedence > lastPrecedence)
{
result.subType = type;
lastPrecedence = precedence;
}
}
} while(reader.TokenType != JsonToken.EndArray || reader.Depth > depth);
result.value = list;
}
else if (result.type == ESymbolType.ESYMBOLTYPE_STRUCTURE)
{
result.value = ReadSymbolList(reader, depth);
}
else if (result.type == ESymbolType.ESYMBOLTYPE_NAME && reader.ValueType == typeof(bool))
{
result.value = result.name;
result.name = (System.Int64) 0;
}
else
{
result.value = reader.Value;
}
return(result);
}
private ESymbolType GetSymbolTypeFromToken(JsonReader reader, bool zeroes = true, bool optimize = true)
{
ESymbolType result = ESymbolType.ESYMBOLTYPE_NONE;
switch (reader.TokenType)
{
case JsonToken.Boolean:
result = ESymbolType.ESYMBOLTYPE_NAME;
break;
case JsonToken.String:
result = ESymbolType.ESYMBOLTYPE_STRING;
break;
case JsonToken.Integer:
result = ESymbolType.ESYMBOLTYPE_INTEGER;
if (optimize)
{
long v = (long)reader.Value;
if (v > -127 && v < 127)
{
result = ESymbolType.ESYMBOLTYPE_INTEGER_ONE_BYTE;
}
else if (v > 255 && v > -32767 && v < 32767)
{
result = ESymbolType.ESYMBOLTYPE_INTEGER_TWO_BYTES;
}
if (result == ESymbolType.ESYMBOLTYPE_INTEGER_ONE_BYTE || result == ESymbolType.ESYMBOLTYPE_INTEGER)
{
if (v > 127 && v < 255)
{
result = ESymbolType.ESYMBOLTYPE_UNSIGNED_INTEGER_ONE_BYTE;
}
}
if (result == ESymbolType.ESYMBOLTYPE_INTEGER_TWO_BYTES || result == ESymbolType.ESYMBOLTYPE_INTEGER)
{
if (v > 255 && v < 65535)
{
result = ESymbolType.ESYMBOLTYPE_UNSIGNED_INTEGER_TWO_BYTES;
}
}
if (zeroes && (long)v == 0)
{
result = ESymbolType.ESYMBOLTYPE_ZERO_INTEGER;
}
}
break;
case JsonToken.Float:
result = ESymbolType.ESYMBOLTYPE_FLOAT;
if (zeroes && (double)reader.Value == 0.0)
{
result = ESymbolType.ESYMBOLTYPE_ZERO_FLOAT;
}
break;
case JsonToken.EndObject:
break;
case JsonToken.StartObject:
result = ESymbolType.ESYMBOLTYPE_STRUCTURE;
break;
case JsonToken.StartArray:
result = ESymbolType.ESYMBOLTYPE_ARRAY;
break;
case JsonToken.Null:
result = ESymbolType.ESYMBOLTYPE_NONE;
break;
default:
throw new NotImplementedException();
}
return(result);
}
private object GetSymbolValue(ESymbolType type, out ESymbolType?subType)
{
subType = null;
var float_list = new List <float>();
switch (type)
{
case ESymbolType.ESYMBOLTYPE_ZERO_INTEGER:
return((System.Int32)(0));
case ESymbolType.ESYMBOLTYPE_ZERO_FLOAT:
return(0.0f);
case ESymbolType.ESYMBOLTYPE_INTEGER_ONE_BYTE:
return((System.Int32)_bs.ReadByte());
case ESymbolType.ESYMBOLTYPE_INTEGER_TWO_BYTES:
return((short)_bs.ReadInt16());
case ESymbolType.ESYMBOLTYPE_UNSIGNED_INTEGER_ONE_BYTE:
return((System.UInt32)(_bs.ReadByte()));
case ESymbolType.ESYMBOLTYPE_UNSIGNED_INTEGER_TWO_BYTES:
return((System.UInt16)(_bs.ReadUInt16()));
case ESymbolType.ESYMBOLTYPE_FLOAT:
return((float)_bs.ReadSingle());
case ESymbolType.ESYMBOLTYPE_INTEGER:
return(_bs.ReadInt32());
case ESymbolType.ESYMBOLTYPE_NONE:
return(ESymbolType.ESYMBOLTYPE_NONE);
case ESymbolType.ESYMBOLTYPE_NAME:
return(_bs.ReadUInt32());
case ESymbolType.ESYMBOLTYPE_ARRAY:
return(ReadArray(out subType));
case ESymbolType.ESYMBOLTYPE_STRUCTURE:
SymbolBufferReader reader = new SymbolBufferReader(_bs);
return(reader.ReadBuffer());
case ESymbolType.ESYMBOLTYPE_PAIR:
float_list.Add(_bs.ReadSingle());
float_list.Add(_bs.ReadSingle());
return(float_list);
case ESymbolType.ESYMBOLTYPE_VECTOR:
float_list.Add(_bs.ReadSingle());
float_list.Add(_bs.ReadSingle());
float_list.Add(_bs.ReadSingle());
return(float_list);
case ESymbolType.ESYMBOLTYPE_LOCALSTRING:
case ESymbolType.ESYMBOLTYPE_STRING:
return(readString());
default:
throw new ArgumentException("Got unhandled symbol", type.ToString());
}
}
public SymbolData(string sSymbol, int iStartLine, ESymbolType eType)
{
Symbol = sSymbol;
StartLine = iStartLine;
Type = eType;
}
