public Data Parse(string source, string content)
{
if (string.IsNullOrEmpty(content) || content == DataConvertorConsts.NullStr)
{
return(null);
}
Stack <Data> dataStack = new Stack <Data>();
Data lastData = null;
PartialData partialData = new PartialData();
partialData.ValueType = DataType.Data;
partialData.Key = "";
Word lastWord = new Word(source, 0, 0, DataConvertorConsts.ValueBegin);
WordSplitter.Split(source, content, DataConvertorConsts.WordChars, (Word word) => {
ProcessWord(dataStack, ref lastData, partialData, lastWord, word);
lastWord = word;
});
if (dataStack.Count == 0 && lastData != null)
{
return(lastData);
}
else
{
throw new WordException(lastWord, "Data Stack Error: {0}, {1}", dataStack.Count, lastData);
}
}
private void ProcessValue(Stack <Data> dataStack, ref Data lastData,
PartialData partialData,
Word lastWord, Word word)
{
Data data = dataStack.Count > 0 ? dataStack.Peek() : null;
if (DataConvertorConsts.IsWordChar(word.Value))
{
if (word.Value == DataConvertorConsts.DataBegin)
{
Data subData = new Data();
dataStack.Push(subData);
if (data != null)
{
data.SetData(partialData.Key, subData);
}
partialData.Clear();
}
else if (word.Value == DataConvertorConsts.DataEnd)
{
if (partialData.ValueType == DataType.String)
{
SetSimpleDataValue(data, partialData, new Word(word.Caret, ""));
PopDataFromStack(dataStack, ref lastData, word);
}
else
{
throw new WordException(word, "Missing Value");
}
}
else if (lastWord.Value == DataConvertorConsts.ValueBegin ||
word.Value != DataConvertorConsts.ValueBegin)
{
throw new WordException(word, "Syntax Error");
}
}
else if (lastWord.Value == DataConvertorConsts.ValueBegin)
{
SetSimpleDataValue(data, partialData, word);
}
else
{
throw new WordException(word, "Syntax Error");
}
}
private void SetSimpleDataValue(Data data, PartialData partialData, Word word)
{
if (data == null)
{
throw new WordException(word, "Syntax Error");
}
bool ok = false;
switch (partialData.ValueType)
{
case DataType.Bool:
ok = data.SetBool(partialData.Key, Convertor.BoolConvertor.Parse(word.Value));
break;
case DataType.Int:
ok = data.SetInt(partialData.Key, Convertor.IntConvertor.Parse(word.Value));
break;
case DataType.Long:
ok = data.SetLong(partialData.Key, Convertor.LongConvertor.Parse(word.Value));
break;
case DataType.Float:
ok = data.SetFloat(partialData.Key, Convertor.FloatConvertor.Parse(word.Value));
break;
case DataType.Double:
ok = data.SetDouble(partialData.Key, Convertor.DoubleConvertor.Parse(word.Value));
break;
case DataType.String:
ok = data.SetString(partialData.Key, Convertor.StringConvertor.Parse(word.Value));
break;
}
if (ok)
{
partialData.Clear();
}
else
{
throw new WordException(word, "Syntax Error");
}
}
private void ProcessKey(Stack <Data> dataStack, ref Data lastData,
PartialData partialData,
Word lastWord, Word word)
{
if (DataConvertorConsts.IsWordChar(word.Value))
{
if (lastWord.Value == DataConvertorConsts.KeyBegin ||
word.Value != DataConvertorConsts.KeyBegin)
{
throw new WordException(word, "Syntax Error");
}
}
else if (lastWord.Value == DataConvertorConsts.KeyBegin)
{
partialData.Key = word.Value;
}
else
{
throw new WordException(word, "Syntax Error");
}
}
private void ProcessWord(Stack <Data> dataStack, ref Data lastData,
PartialData partialData,
Word lastWord, Word word)
{
bool isWordChar = DataConvertorConsts.IsWordChar(word.Value);
switch (partialData.GetExpectKind())
{
case PartialData.ExpectKind.Type:
ProcessType(dataStack, ref lastData, partialData, lastWord, word);
break;
case PartialData.ExpectKind.Key:
ProcessKey(dataStack, ref lastData, partialData, lastWord, word);
break;
case PartialData.ExpectKind.Value:
ProcessValue(dataStack, ref lastData, partialData, lastWord, word);
break;
}
}
private void ProcessType(Stack <Data> dataStack, ref Data lastData,
PartialData partialData,
Word lastWord, Word word)
{
if (DataConvertorConsts.IsWordChar(word.Value))
{
if (word.Value == DataConvertorConsts.DataEnd)
{
PopDataFromStack(dataStack, ref lastData, word);
}
else
{
throw new WordException(word, "Expecting DataType");
}
}
else
{
partialData.ValueType = Convertor.DataTypeConvertor.Parse(word.Value);
if (partialData.ValueType == DataType.Invalid)
{
throw new WordException(word, "Invalid DataType");
}
}
}
