private void ClearParseData()
{
ApiDictionary1 = null;
ParseStatus1 = new ParseStatus();
ApiDictionary2 = null;
ParseStatus2 = new ParseStatus();
}
public ParseResult(ParseStatus theParseStatus, ParseTree theParseTree)
{
Errors = new List <string>();
Status = theParseStatus;
Tree = theParseTree;
Root = (T)theParseTree.Root.AstNode;
}
public zOSCMessage(byte[] sourceBuff, int startindex = 0)
{
UnityEngine.Debug.Log("Datratlen " + sourceBuff.Length);
data = sourceBuff;
timeStamp = DateTime.UtcNow.Ticks;
objects = null;
parseStatus = ParseStatus.raw;
payloadOffsets = null;
typetagOffset = 0;
payloadOffset = 0;
_addressSegments = null; // new List<string>();
UnityEngine.Debug.Log("soruce " + data.ByteArrayToStringAsHex());
OSCWordReader reader = new OSCWordReader();
_address = data.UnpackString(reader);
types = null;
// UnityEngine.Debug.Log("found address " + _address + " pos is now " + reader.readIndex);
UnityEngine.Debug.Log("after alignment " + reader.readIndex);
typetagOffset = reader.readIndex;
//
types = this.UnpackTypeTag(reader);
// reader.Align(data);
// payloadOffset = reader.readIndex;
UnityEngine.Debug.Log("found type count = " + typetagOffset + " payloadOffset= " + payloadOffset + " types.count=" + types.Count);
// //
// //FindAddressesAndTypeTagIndex();
}
// to build the roulette matrix
public List <double> ComputeRouletteMatrix(Session session)
{
ParseStatus current_parsestatus = session.parse_status;
List <double> transition_row = transition_matrix[parsestatus2int[current_parsestatus]];
foreach (var item in session.is_considerd)
{
if (item.Value)
{
ParseStatus reset_parsestatus = item.Key;
transition_row[parsestatus2int[reset_parsestatus]] = 0;
}
}
List <double> roulette_row = new List <double>();
double sum = 0;
for (int j = 0; j < transition_matrix.Count; j++)
{
sum += transition_row[j];
}
roulette_row.Add(transition_row[0] / sum);
for (int j = 1; j < transition_matrix.Count; j++)
{
roulette_row.Add(roulette_row[j - 1] + (transition_row[j] / sum));
}
return(roulette_row);
}
/// <summary>
/// EnsureExists_ParseStatus - we want to make sure our respective ParseStatus item exists, but NOT refresh it.
/// </summary>
/// <param name="targetFile"></param>
public static void EnsureExists(string targetFile)
{
lock (_synchronizationParseStatus)
{
if (!ParseStatus.ContainsKey(targetFile))
{
Init(targetFile);
}
}
}
ResumeParsing(XMLParser *parser, ReadBuffer read, out XMLError error)
{
ParseStatus parseStatus = ParseStatus.Finished;
if (!ResumeParsingBuffer(parser, ref parseStatus, out error))
{
parseStatus = Parse(parser, read, out error);
}
return(parseStatus);
}
/// <summary>
/// Either HTTPRequest contains the header AND some data, or it contains part or all of the header. Accumulate pieces
/// of the header in case it spans multiple reads.
/// </summary>
/// <param name="requestChunk"></param>
/// <returns></returns>
public ParseStatus Append(string requestChunk)
{
if (headerStatus == ParseStatus.COMPLETE_HEADER && this.ContentComplete)
{
// restart with empty header and see if it works
headerStatus = ParseStatus.UNINITIALIZED;
DataString = "";
headerSoFar = "";
headerFields.Clear();
}
if (headerStatus != ParseStatus.COMPLETE_HEADER)
{
int betweenHeaderAndData = requestChunk.IndexOf("\r\n\r\n"); // AKo: Fix this: Parsing has to be changed, packet could be split at newline boundaries.
if (betweenHeaderAndData > 0)
{
headerStatus = ParseStatus.COMPLETE_HEADER;
//found the boundary between header and data
headerSoFar += requestChunk.Substring(0, betweenHeaderAndData);
ParseHeader(headerSoFar);
//shorten the request so we can fall through
requestChunk = requestChunk.Substring(betweenHeaderAndData + 4);
if (ContentComplete)
{
return(headerStatus);
}
//
// FALL THROUGH to header complete case
//
}
else
{
headerSoFar += requestChunk;
headerStatus = ParseStatus.PARTIAL_HEADER;
ParseHeader(headerSoFar);
return(headerStatus);
}
}
if (headerStatus == ParseStatus.COMPLETE_HEADER)
{
DataString += requestChunk; // AKo: Fix this: remaining chunk is appended no matter if it is longer than the remaining content-length
if (ContentComplete)
{
logger.LogDebug("DONE READING CONTENT: {0}", DataString);
}
}
return(headerStatus);
}
ExternalEntityRefHandlerImpl(XMLParser *parser,
char *context,
char *baseUri,
char *systemId,
char *publicId)
{
int result = (int)XMLStatus.OK;
GCHandle parserHandle = (GCHandle)LibExpat.XMLGetUserData(parser);
X expatParser = (X)parserHandle.Target;
E newEntityContext = expatParser.freeEntityContext; // should always be != null
string encoding;
try {
if (!newEntityContext.Open(context, baseUri, systemId, publicId, out encoding))
{
return(result);
}
}
catch (Exception e) {
expatParser.error = e;
result = (int)XMLStatus.ERROR;
return(result);
}
expatParser.PushChildEntityParseContext(parser, context, encoding);
ParseStatus status = ExpatUtils.Parse(
newEntityContext.XmlParser, newEntityContext.Read, out newEntityContext.error);
switch (status)
{
case ParseStatus.Finished:
expatParser.PopChildEntityParseContext();
break;
case ParseStatus.Suspended:
// must suspend parent parser as well - don't check return value
LibExpat.XMLStopParser(parser, XMLBool.TRUE);
break;
case ParseStatus.FatalError:
result = (int)XMLStatus.ERROR;
break;
case ParseStatus.Aborted:
// must abort parent parser as well - don't check return value
LibExpat.XMLStopParser(parser, XMLBool.FALSE);
break;
}
return(result);
}
/// <summary>
/// Either HTTPRequest contains the header AND some data, or it contains part or all of the header. Accumulate pieces
/// of the header in case it spans multiple reads.
/// </summary>
/// <param name="HTTPRequest"></param>
/// <returns></returns>
public ParseStatus Append(string HTTPRequest)
{
if (headerStatus != ParseStatus.COMPLETE_HEADER)
{
int betweenHeaderAndData = HTTPRequest.IndexOf("\r\n\r\n");
if (betweenHeaderAndData > 0)
{
headerStatus = ParseStatus.COMPLETE_HEADER;
//found the boundary between header and data
headerSoFar += HTTPRequest.Substring(0, betweenHeaderAndData);
ParseHeader(headerSoFar);
//shorten the request so we can fall through
HTTPRequest = HTTPRequest.Substring(betweenHeaderAndData + 4);
//
// FALL THROUGH to header complete case
//
}
else
{
headerSoFar += HTTPRequest;
headerStatus = ParseStatus.PARTIAL_HEADER;
ParseHeader(headerSoFar);
return(headerStatus);
}
}
if (headerStatus == ParseStatus.COMPLETE_HEADER)
{
if (ContentComplete)
{
//this isn't right... restart with empty header and see if it works
headerStatus = ParseStatus.UNINITIALIZED;
Data = new byte[0];
DataString = "";
headerSoFar = "";
headerFields.Clear();
return(Append(HTTPRequest));
}
DataString += HTTPRequest;
if (ContentComplete)
{
Data = Encoding.ASCII.GetBytes(DataString);
logger.LogDebug("DONE READING CONTENT");
}
}
return(headerStatus);
}
/**
* Resets the Builder to match the provided IETF BCP 47
* language tag. Discards the existing state. Null and the
* empty string cause the builder to be reset, like {@link
* #clear}. Grandfathered tags (see {@link
* UCultureInfo.GetCultureInfoByIetfLanguageTag(string)}) are converted to their canonical
* form before being processed. Otherwise, the language tag
* must be well-formed (see {@link UCultureInfo}) or an exception is
* thrown (unlike <code>UCultureInfo.GetCultureInfoByIetfLanguageTag(string)</code>, which
* just discards ill-formed and following portions of the
* tag).
*
* @param languageTag the language tag
* @return This builder.
* @throws IllformedLocaleException if <code>languageTag</code> is ill-formed
* @see UCultureInfo.GetCultureInfoByIetfLanguageTag(string)
*
* @stable ICU 4.2
*/
public UCultureInfoBuilder SetLanguageTag(string languageTag)
{
ParseStatus sts = new ParseStatus();
LanguageTag tag = LanguageTag.Parse(languageTag, sts);
if (sts.IsError)
{
throw new IllformedLocaleException(sts.ErrorMessage, sts.ErrorIndex);
}
_locbld.SetLanguageTag(tag);
return(this);
}
public zOSCMessage(string address)
{
_address = address;
timeStamp = DateTime.UtcNow.Ticks;
parseStatus = ParseStatus.adressKnown;
_addressSegments = null; // new List<string>(address.Split('/'));
types = new List <System.Type>();
payloadOffsets = null;
objects = null;
data = null;
typetagOffset = 0;
payloadOffset = 0;
}
/// <summary>
/// Init - we want to make sure the ParseStatus for this file is freshly initialized (e.g. when opening / re-opening a file)
/// </summary>
/// <param name="targetFile"></param>
public static void Init(string targetFile)
{
lock (_synchronizationParseStatus)
{
if (!ParseStatus.ContainsKey(targetFile))
{
ParseStatus.Add(targetFile, new ParseAttribute());
}
else
{
ParseStatus[targetFile] = new ParseAttribute();
}
}
}
public static string StatusCode(ParseStatus status)
{
switch (status)
{
case ParseStatus.Error:
return("ERR");
case ParseStatus.Illegible:
return("ILL");
default:
return(string.Empty);
}
}
public static void ParseFailed(ParseStatus status)
{
switch (status)
{
case ParseStatus.NullInput:
throw new ArgumentNullException("input");
case ParseStatus.InvalidFormat:
throw new FormatException(
$"The value represented in the string is lower than {MinValue} or higher than {MaxValue}");
case ParseStatus.Overflow:
throw new OverflowException();
}
}
private static void TestTranstionStatus()
{
Session session = new Session();
DialogManager dm = new DialogManager();
session.is_considerd[ParseStatus.Artist] = true;
ParseStatus res = dm.GetTransitionStatus(session);
Console.WriteLine(res.ToString());
session = new Session();
dm = new DialogManager();
session.is_considerd[ParseStatus.PublishDate] = true;
res = dm.GetTransitionStatus(session);
Console.WriteLine(res.ToString());
}
public static Object Parse(byte[] buffer)
{
ParseStatus status = new ParseStatus();
status.data = buffer;
status.pos = 0;
object root = Parse(ref status);
if (status.error)
{
return(null);
}
else
{
return(root as MicroJson.Object);
}
}
ResumeParsingBuffer(XMLParser *parser, ref ParseStatus parseStatus, out XMLError error)
{
bool result = true;
XMLStatus status = LibExpat.XMLResumeParser(parser);
switch (status)
{
case XMLStatus.OK:
error = XMLError.NONE;
XMLParsingStatus pStatus;
LibExpat.XMLGetParsingStatus(parser, out pStatus);
if (pStatus.FinalBuffer == XMLBool.FALSE)
{
result = false;
}
else
{
parseStatus = ParseStatus.Finished;
}
break;
case XMLStatus.ERROR:
error = LibExpat.XMLGetErrorCode(parser);
if (error == XMLError.ABORTED)
{
parseStatus = ParseStatus.Aborted;
}
else
{
parseStatus = ParseStatus.FatalError;
}
break;
case XMLStatus.SUSPENDED:
error = XMLError.NONE;
parseStatus = ParseStatus.Suspended;
break;
default:
error = XMLError.NONE;
break;
}
return(result);
}
public static string AnswerIt(List <string> answer_entity, Session session, ParseStatus to)
{
int from_status = DialogManager.parsestatus2int[session.parse_status];
int to_status = DialogManager.parsestatus2int[to];
string entity_in_question = "";
switch (DialogManager.int2parsestatus[from_status])
{
case ParseStatus.All:
entity_in_question = string.Join("、 ", session.carried_artist.ToArray());
break;
case ParseStatus.Artist:
entity_in_question = string.Join("、 ", session.carried_artist.ToArray());
break;
case ParseStatus.Director:
entity_in_question = string.Join("、 ", session.carried_director.ToArray());
break;
case ParseStatus.Country:
entity_in_question = string.Join("、 ", session.carried_country.ToArray());
break;
case ParseStatus.Genre:
entity_in_question = string.Join("、 ", session.carried_genre.ToArray());
break;
case ParseStatus.PublishDate:
int carried_start_data = session.carried_publishdate.from;
int data_interface = int.Parse(DateTime.Now.AddMonths(-18).ToString("yyyyMMdd"));
entity_in_question = carried_start_data > data_interface ? "最近" : "过去";
break;
default:
Utils.WriteError("error turn status!");
break;
}
string answer = string.Format(relation_matrix[from_status, to_status], entity_in_question, string.Join("、 ", answer_entity.ToArray()));
return(answer);
}
private void Parse(string[] rawText)
{
Value = string.Empty;
Checksum = 0;
try
{
for (int i = 0; i < 25; i += 3)
{
var digitText = string.Empty;
for (int j = 0; j < 3; j++)
{
digitText = digitText + rawText[j].Substring(i, 3);
}
Value = Value + Digit.Parse(digitText);
}
if (Value.Contains("?"))
{
Status = ParseStatus.Illegible;
return;
}
Checksum = CalculateChecksum(Value);
if (Checksum != 0)
{
Status = ParseStatus.Error;
}
else
{
Status = ParseStatus.Success;
}
}
catch
{
Status = ParseStatus.Error;
}
}
public TokenizerArgument(string input, int index, ParseStatus status, StringCollection output)
{
if (input.IsNullOrWhiteSpace())
{
throw new ArgumentException(nameof(input));
}
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (output == null)
{
output = new StringCollection();
}
Input = input;
Index = index;
Status = status;
Output = output;
}
public ParseStatus Parse(IList<string> args, object argumentContainer)
{
if (args == null)
throw new ArgumentNullException("args");
if(argumentContainer == null)
throw new ArgumentNullException("argumentContainer");
ParseStatus result = new ParseStatus{ Succeeded = true };
try
{
// Get schema
// Validate schema
// Parse input
// Map input to schema
// Handle errors
// Return status
}
catch (SchemaException ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
}
catch (ParsingException ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
}
return result;
}
private void ParseData()
{
int byteCount = serialPort.BytesToRead;
uint val,payloadLength;
Byte tempByte;
points.Clear();
parseStep = ParseStatus.idle; //reset
while (byteCount > 0)
{
switch (parseStep)
{
case ParseStatus.idle:
try
{
tempByte = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
if (tempByte == 0xFF)
{
parseStep = ParseStatus.header2;
//debugText.Text += "Hi";
}
break;
case ParseStatus.header2:
try
{
tempByte = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
if (tempByte== 0xFE)
parseStep = ParseStatus.type;
else
parseStep = ParseStatus.idle; //reset
break;
/* case ParseStatus.length:
try
{
payloadLength = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
parseStep = ParseStatus.type;
break;
*/
case ParseStatus.type:
try
{
tempByte = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
switch (tempByte)
{
case 0x02:
//Alerts
//parseStep = ParseStatus.alert;
parseStep = ParseStatus.idle; //debug - no alerts
break;
case 0x03:
//Continious Data
//parseStep = ParseStatus.contData_subtype;
parseStep = ParseStatus.contDataPayload;
break;
case 0x04:
//one-shot data
parseStep = ParseStatus.singleData_subtype;
break;
default:
parseStep = ParseStatus.idle; //reset
break;
}
break;
case ParseStatus.alert:
//debugText.Text += "Alert!\n";
showFall();
parseStep = ParseStatus.idle; //reset
break;
case ParseStatus.contData_subtype:
parseStep = ParseStatus.idle; //reset
break;
case ParseStatus.contDataPayload:
try
{
val = (uint)serialPort.ReadByte();
val = val * 256 + (uint)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
points.Add(val); //add to PPG value list
try
{
AccelerometerData((double)((int)serialPort.ReadByte() - 128) / 64.0, (double)((int)serialPort.ReadByte() - 128) / 64.0, (double)((int)serialPort.ReadByte() - 128) / 64.0);
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount-=5;
//debugText.Text +=val +"\n";
parseStep = ParseStatus.idle; //reset
break;
case ParseStatus.singleData_subtype:
try
{
tempByte = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
switch (tempByte)
{
case 0x00:
try
{
tempByte = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
temperature = (int)tempByte; //set the temperature
break;
default:
parseStep = ParseStatus.idle;
break;
}
parseStep = ParseStatus.idle;
break;
default:
parseStep = ParseStatus.idle;
break;
}
}
}
private static string MakeErrorMsg(ParseStatus status, string errorStatement, string errorMsg)
{
return string.Format("Status {2} for {0} : {1}", errorStatement, errorMsg, status);
}
/// <summary>
/// Creates a new ParseException
/// </summary>
/// <param name="info">The System.Runtime.Serialization.SerializationInfo that holds the serialized object data about the exception being thrown.</param>
/// <param name="context"></param>
protected ParseException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
this.status = (ParseStatus)info.GetValue(StatusFieldName, typeof(ParseStatus));
this.errorStatement = info.GetString(ErrorStatementFieldName);
}
/// <summary>
/// This will tokenise the HTML input string.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
private StringCollection GetTokens(string input)
{
StringCollection tokens = new StringCollection();
int i = 0;
ParseStatus status = ParseStatus.ReadText;
while (i < input.Length)
{
if (status == ParseStatus.ReadText)
{
if (i + 2 < input.Length && input.Substring(i, 2).Equals("</"))
{
i += 2;
tokens.Add("</");
status = ParseStatus.ReadEndTag;
}
else if (input.Substring(i, 1).Equals("<"))
{
i++;
tokens.Add("<");
status = ParseStatus.ReadStartTag;
}
else
{
int next_index = input.IndexOf("<", i);
if (next_index == -1)
{
tokens.Add(input.Substring(i));
break;
}
else
{
tokens.Add(input.Substring(i, next_index - i));
i = next_index;
}
}
}
else if (status == ParseStatus.ReadStartTag)
{
// Skip leading whitespace in tag
while (i < input.Length && input.Substring(i, 1).IndexOfAny(WHITESPACE_CHARS) != -1)
{
i++;
}
// Read tag name
int tag_name_start = i;
while (i < input.Length && input.Substring(i, 1).IndexOfAny(" \r\n\t/>".ToCharArray()) == -1)
{
i++;
}
tokens.Add(input.Substring(tag_name_start, i - tag_name_start));
// Skip trailing whitespace in tag
while (i < input.Length && input.Substring(i, 1).IndexOfAny(WHITESPACE_CHARS) != -1)
{
i++;
}
if (i + 1 < input.Length && input.Substring(i, 1).Equals("/>"))
{
tokens.Add("/>");
status = ParseStatus.ReadText;
i += 2;
}
else if (i < input.Length && input.Substring(i, 1).Equals(">"))
{
tokens.Add(">");
status = ParseStatus.ReadText;
i++;
}
else
{
status = ParseStatus.ReadAttributeName;
}
}
else if (status == ParseStatus.ReadEndTag)
{
// Skip leading whitespace in tag
while (i < input.Length && input.Substring(i, 1).IndexOfAny(WHITESPACE_CHARS) != -1)
{
i++;
}
// Read tag name
int tag_name_start = i;
while (i < input.Length && input.Substring(i, 1).IndexOfAny(" \r\n\t>".ToCharArray()) == -1)
{
i++;
}
tokens.Add(input.Substring(tag_name_start, i - tag_name_start));
// Skip trailing whitespace in tag
while (i < input.Length && input.Substring(i, 1).IndexOfAny(WHITESPACE_CHARS) != -1)
{
i++;
}
if (i < input.Length && input.Substring(i, 1).Equals(">"))
{
tokens.Add(">");
status = ParseStatus.ReadText;
i++;
}
}
else if (status == ParseStatus.ReadAttributeName)
{
// Read attribute name
while (i < input.Length && input.Substring(i, 1).IndexOfAny(WHITESPACE_CHARS) != -1)
{
i++;
}
int attribute_name_start = i;
while (i < input.Length && input.Substring(i, 1).IndexOfAny(" \r\n\t/>=".ToCharArray()) == -1)
{
i++;
}
tokens.Add(input.Substring(attribute_name_start, i - attribute_name_start));
while (i < input.Length && input.Substring(i, 1).IndexOfAny(WHITESPACE_CHARS) != -1)
{
i++;
}
if (i + 1 < input.Length && input.Substring(i, 2).Equals("/>"))
{
tokens.Add("/>");
status = ParseStatus.ReadText;
i += 2;
}
else if (i < input.Length && input.Substring(i, 1).Equals(">"))
{
tokens.Add(">");
status = ParseStatus.ReadText;
i++;
}
else if (i < input.Length && input.Substring(i, 1).Equals("="))
{
tokens.Add("=");
i++;
status = ParseStatus.ReadAttributeValue;
}
else if (i < input.Length && input.Substring(i, 1).Equals("/"))
{
i++;
}
}
else if (status == ParseStatus.ReadAttributeValue)
{
// Read the attribute value
while (i < input.Length && input.Substring(i, 1).IndexOfAny(WHITESPACE_CHARS) != -1)
{
i++;
}
if (i < input.Length && input.Substring(i, 1).Equals("\""))
{
int value_start = i;
i++;
while (i < input.Length && !input.Substring(i, 1).Equals("\""))
{
i++;
}
if (i < input.Length && input.Substring(i, 1).Equals("\""))
{
i++;
}
tokens.Add(input.Substring(value_start + 1, i - value_start - 2));
status = ParseStatus.ReadAttributeName;
}
else if (i < input.Length && input.Substring(i, 1).Equals("\'"))
{
int value_start = i;
i++;
while (i < input.Length && !input.Substring(i, 1).Equals("\'"))
{
i++;
}
if (i < input.Length && input.Substring(i, 1).Equals("\'"))
{
i++;
}
tokens.Add(input.Substring(value_start + 1, i - value_start - 2));
status = ParseStatus.ReadAttributeName;
}
else
{
int value_start = i;
while (i < input.Length && input.Substring(i, 1).IndexOfAny(" \r\n\t/>".ToCharArray()) == -1)
{
i++;
}
tokens.Add(input.Substring(value_start, i - value_start));
while (i < input.Length && input.Substring(i, 1).IndexOfAny(WHITESPACE_CHARS) != -1)
{
i++;
}
status = ParseStatus.ReadAttributeName;
}
if (i + 1 < input.Length && input.Substring(i, 2).Equals("/>"))
{
tokens.Add("/>");
status = ParseStatus.ReadText;
i += 2;
}
else if (i < input.Length && input.Substring(i, 1).Equals(">"))
{
tokens.Add(">");
i++;
status = ParseStatus.ReadText;
}
// ANDY
}
}
return(tokens);
}
public static object Parse(ref ParseStatus status)
{
Parsing state = Parsing.NOTHING;
Object o = null;
Array a = null;
String name = null;
for (int i=status.pos;i<status.data.Length;i++)
{
byte b = status.data[i];
char c = (char)b;
switch (state)
{
case Parsing.NOTHING:
{
switch (c)
{
case '{': state = Parsing.OBJECT; o = new Object(); o.Data = new Dictionary<string, object>(); break;
case '[': state = Parsing.ARRAY; a = new Array(); a.Data = new List<object>(); break;
case ' ': case '\n': case '\t': break;
case '"': state = Parsing.QUOTED_VALUE; status.pos = i+1; break;
default: state = Parsing.VALUE; status.pos = i; break;
}
break;
}
case Parsing.QUOTED_VALUE:
{
if (c == '"')
{
String v = DecodeString(status.data, status.pos, i);
status.pos = i + 1;
return v;
}
break;
}
case Parsing.VALUE:
{
if (IsWhitespace(c) || c == ',' || c == ']' || c == '}' || c == ':')
{
String v = DecodeString(status.data, status.pos, i);
status.pos = i;
return v;
}
break;
}
case Parsing.OBJECT:
{
if (c == '}')
{
status.pos = i + 1;
return o;
}
if (IsWhitespace(c) || c == ',')
{
continue;
}
if (name == null)
{
status.pos = i;
name = Parse(ref status) as String;
if (name == null)
{
status.error = true;
return null;
}
i = status.pos - 1;
}
else
{
if (c == ':')
{
continue;
}
status.pos = i;
object val = Parse(ref status);
if (val == null)
{
status.error = true;
return null;
}
o.Data.Add(name, val);
i = status.pos - 1;
name = null;
}
break;
}
case Parsing.ARRAY:
{
if (c == ']')
{
status.pos = i + 1;
return a;
}
if (IsWhitespace(c) || c == ',')
{
continue;
}
status.pos = i;
object val = Parse(ref status);
if (val == null)
{
status.error = true;
return null;
}
a.Data.Add(val);
i = status.pos - 1;
break;
}
default:
break;
}
}
status.error = true;
return null;
}
public DetailedParseResult(ParseStatus status, string message)
: this(status, ASTNode.Empty, message)
{
return;
}
/// <summary>
/// Default constructor
/// </summary>
internal GXVerifyPacketEventArgs(byte[] data, GXPacket received)
{
State = ParseStatus.Complete;
Data = data;
Received = received;
}
private static string MakeErrorMsg(ParseStatus status, string errorStatement, string errorMsg)
{
return(string.Format("Status {2} for {0} : {1}", errorStatement, errorMsg, status));
}
/// <summary>
/// Creates a new instance with the specified error.
/// </summary>
/// <param name="status">The error status</param>
/// <param name="errorStatement">The statement that failed to be parsed</param>
/// <param name="errorMsg">The error message given by the native R engine</param>
public ParseException(ParseStatus status, string errorStatement, string errorMsg)
: base(MakeErrorMsg(status, errorStatement, errorMsg))
{
this.status = status;
this.errorStatement = errorStatement;
}
public void DialogFlow(string input)
{
// begin
session.parse_status = ParseStatus.All;
string query_str = "";
while (true)
{
Query query;
// get query. if it is the very beginning, then taking the parameter as input
if (session.parse_status == ParseStatus.All)
{
if (string.IsNullOrWhiteSpace(input))
{
query_str = Utils.ReadLine();
Utils.WriteQuery(query_str);
}
else
{
query_str = input;
input = null;
}
query = new Query(query_str);
parser.PosTagging(ref query);
// movie recommendation trigger
// don't need anymore due to Xiaoice API Connection
if (!parser.isAboutMovie(query))
{
Utils.WriteMachine(new string('=', 24));
Utils.WriteMachine("\n");
return;
}
}
else
{
query_str = Utils.ReadLine();
Utils.WriteQuery(query_str);
query = new Query(query_str);
Query query_kbqa = new Query(query_str);
parser.PosTagging(ref query_kbqa);
if (KBQA.DoKBQA(query_kbqa, parser))
{
continue;
}
parser.PosTagging(ref query);
}
// query parse according to parse status
switch (session.parse_status)
{
case ParseStatus.All:
parser.ParseAllTag(ref query);
break;
case ParseStatus.Movie:
parser.ParseMovieName(ref query);
break;
case ParseStatus.Artist:
parser.ParseArtistName(ref query);
break;
case ParseStatus.Director:
parser.ParseDirectorName(ref query);
break;
case ParseStatus.Country:
parser.ParseCountryName(ref query);
break;
case ParseStatus.Genre:
parser.ParseGenreName(ref query);
break;
case ParseStatus.PublishDate:
parser.ParsePublishDate(ref query);
break;
//case ParseStatus.Rating:
// parser.ParseRating(ref query);
// break;
//case ParseStatus.Duration:
// parser.ParseDuration(ref query);
// break;
default:
Utils.WriteError("error parse status!");
break;
}
// refresh session status using user query
session.RefreshSessionStatus(query);
ClarifyArtistDirector();
// refresh session movie candidate status
GetAllResult(ref session);
// is recommendation end or is user accept the kbqa answer
if (isRecommendationEnd(session) || parser.isAcceptCandidate(query))
{
if (parser.isAcceptCandidate(query))
{
Utils.WriteMachine("Have Fun~~~");
return;
}
if (session.is_considerd[ParseStatus.Movie] && session.candidate_movies.Count > 0)
{
Utils.WriteMachine("想看" + session.candidate_movies[0].name + "啊");
Utils.WriteMachine("眼光不错哦");
}
else
{
// if it is end, then show some movie candidate, let user confirm the result
ConfirmSession();
return;
}
}
else
{
// in this trun we asked some information, but user did not provide
if (session.parse_status == ParseStatus.Artist ||
session.parse_status == ParseStatus.Director ||
session.parse_status == ParseStatus.Country ||
session.parse_status == ParseStatus.Genre ||
session.parse_status == ParseStatus.PublishDate)
{
if (session.is_considerd[session.parse_status] != true)
{
Utils.WriteUnknow("Pardon me", query.raw_query);
continue;
}
}
if (session.parse_status == ParseStatus.All)
{
session.parse_status = MakeClearParseStatus(session);
}
// using current turn status(session.parse_status) to compute the Transition(next turn) status, a transition matrix requeried.
ParseStatus nextturn_status = GetTransitionStatus(session);
List <string> answer_entity_candidate = new List <string>();
// response according to the nextturn_status we just chosen.
switch (nextturn_status)
{
//case ParseStatus.All:
// answer_entity_candidate = AnalyseAll(session);
// break;
case ParseStatus.Artist:
answer_entity_candidate = AnalyseArtistName(session);
break;
case ParseStatus.Director:
answer_entity_candidate = AnalyseDirectorName(session);
break;
case ParseStatus.Country:
answer_entity_candidate = AnalyseCountryName(session);
break;
case ParseStatus.Genre:
answer_entity_candidate = AnalyseGenreName(session);
break;
case ParseStatus.PublishDate:
answer_entity_candidate = AnalysePublishDate(session);
break;
default:
Utils.WriteError("error turn status!");
break;
}
// answer and go to the next turn
Console.WriteLine("from {0} transite to {1}", session.parse_status.ToString(), nextturn_status.ToString());
string answer = AnswerGenerator.AnswerIt(answer_entity_candidate, session, nextturn_status);
Utils.WriteMachine(answer);
session.parse_status = nextturn_status;
}
}
}
public void ParseCompleted()
{
if (Error != null)
{
Status = ParseStatus.Failed;
return;
}
foreach (var source in _positionals.Where(p => p.IsOptional).ToList())
{
var value = source.DefaultValue ?? String.Empty;
if (!AcceptPositional(value, source))
{
Status = ParseStatus.Failed;
return;
}
}
if (_positionals.Any(UnusedPositional) && !_usedOptions.Any(o => o.IsShortCircuit))
{
Error = "Not enough parameters specified.";
Status = ParseStatus.Failed;
}
else
Status = ParseStatus.CompletedOk;
}
/// <summary>
/// Creates a new instance with the specified error.
/// </summary>
/// <param name="status">The error status</param>
/// <param name="errorStatement">The statement that failed to be parsed</param>
/// <param name="errorMsg">The error message given by the native R engine</param>
public ParseException(ParseStatus status, string errorStatement, string errorMsg)
: base(MakeErrorMsg(status, errorStatement, errorMsg))
{
this.status = status;
this.errorStatement = errorStatement;
}
private void ParseData()
{
int byteCount = serialPort.BytesToRead;
uint val1,val2,val3;
uint payloadLength;
Byte tempByte;
//points.Clear();
parseStep = ParseStatus.idle; //reset
while (byteCount > 0)
{
switch (parseStep)
{
case ParseStatus.idle:
try
{
tempByte = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
if (tempByte == 0xFF)
{
parseStep = ParseStatus.header2;
//HRPage.debugText.Text += "\nnew packet : FF ";
}
break;
case ParseStatus.header2:
try
{
tempByte = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
if (tempByte == 0xFE)
{
parseStep = ParseStatus.length;
//HRPage.debugText.Text += "FE ";
}
else
parseStep = ParseStatus.idle; //reset
break;
case ParseStatus.length:
try
{
payloadLength = (Byte)serialPort.ReadByte();
//HRPage.debugText.Text += payloadLength+" ";
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
parseStep = ParseStatus.type;
break;
case ParseStatus.type:
try
{
tempByte = (Byte)serialPort.ReadByte();
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
byteCount--;
switch (tempByte)
{
case 0x00:
//Control
parseStep = ParseStatus.control;
parseStep = ParseStatus.idle;
//HRPage.debugText.Text += "Control";
break;
case 0x01:
//Read
parseStep = ParseStatus.read;
parseStep = ParseStatus.idle;
//HRPage.debugText.Text += "read";
break;
case 0x02:
//Alerts
parseStep = ParseStatus.alert;
parseStep = ParseStatus.idle;
//HRPage.debugText.Text += "alerts";
break;
case 0x03:
//Continious Data
parseStep = ParseStatus.contDataPayload;
//parseStep = ParseStatus.idle;
//HRPage.debugText.Text += "payload";
break;
default:
parseStep = ParseStatus.idle; //reset
break;
}
break;
//case ParseStatus.alert:
// //debugText.Text += "Alert!\n";
// //showFall();
// parseStep = ParseStatus.idle; //reset
// break;
case ParseStatus.contDataPayload:
try
{
val1 = (uint)serialPort.ReadByte();
val1 = val1 + (uint)serialPort.ReadByte() * 256;
val3 = (uint)serialPort.ReadByte();
val3 = val3 + (uint)serialPort.ReadByte() * 256;
val2 = val1 + val3;
}
catch (Exception)
{
parseStep = ParseStatus.idle;
break;
}
HRPage.AddToChart(val1,val2,val3); //add to chart
byteCount -= 2;
parseStep = ParseStatus.idle; //reset
break;
default:
parseStep = ParseStatus.idle;
break;
}
}
}
/// <summary>
/// Creates a new ParseException
/// </summary>
/// <param name="info">The System.Runtime.Serialization.SerializationInfo that holds the serialised object data about the exception being thrown.</param>
/// <param name="context"></param>
protected ParseException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
this.status = (ParseStatus)info.GetValue(StatusFieldName, typeof(ParseStatus));
this.errorStatement = info.GetString(ErrorStatementFieldName);
}
private void ResetParser()
{
_status = ParseStatus.ParsingProtocol;
_i0 = 0;
_i = 0;
}
public DetailedParseResult(ParseStatus status, ASTNode node, string message)
{
Status = status;
Node = node;
Message = message;
}
private void ParseUrl(string url)
{
while (_i < url.Length)
{
switch (_status)
{
case ParseStatus.ParsingProtocol:
if (url[_i] == ':')
{
Protocol = url.Substring(_i0, _i - _i0);
if (_i + 2 >= url.Length)
{
throw new Exception(string.Format("Unexpected end of URL, while parsing protocol. \"{0}\"", url));
}
if (url[_i + 1] != '/' || url[_i + 2] != '/')
{
throw new Exception(string.Format("Unexpected end of URL, while parsing protocol. \"{0}\"", url));
}
_status = ParseStatus.ParsingHost;
_i0 = _i + 3;
_i = _i0;
}
break;
case ParseStatus.ParsingHost:
if (char.IsLetterOrDigit(url[_i]) == false && url[_i] != '.')
{
Host = url.Substring(_i0, _i - _i0);
_i0 = _i;
if (url[_i] == ':')
{
_status = ParseStatus.ParsingPort;
}
else
{
_status = ParseStatus.ParsingPath;
}
}
break;
case ParseStatus.ParsingPort:
if (char.IsDigit(url[_i]) == false)
{
Port = url.Substring(_i0, _i - _i0);
_i0 = _i;
_status = ParseStatus.ParsingPath;
}
break;
case ParseStatus.ParsingPath:
_i = url.Length - 1;
break;
}
_i++;
}
switch (_status)
{
case ParseStatus.ParsingProtocol:
Protocol = url.Substring(_i0, _i - _i0);
break;
case ParseStatus.ParsingHost:
Host = url.Substring(_i0, _i - _i0);
break;
case ParseStatus.ParsingPort:
Port = url.Substring(_i0, _i - _i0);
break;
case ParseStatus.ParsingPath:
Path = url.Substring(_i0, _i - _i0);
break;
}
}
public ParseTree(ParseStatus status, Token tree)
{
Status = status;
Tree = tree;
}
public static Object Parse(byte[] buffer)
{
ParseStatus status = new ParseStatus();
status.data = buffer;
status.pos = 0;
object root = Parse(ref status);
if (status.error)
{
return null;
}
else
{
return root as MicroJson.Object;
}
}
