/// <summary>
/// Writes a character to the underlying writer
/// </summary>
/// <param name="value">the char to write</param>
/// <remarks>
/// <para>
/// Writes a character to the underlying writer
/// </para>
/// </remarks>
public override void Write(char value)
{
try
{
base.Write(value);
}
catch (Exception e)
{
m_errorHandler.Error("Failed to write [" + value.ToString() + "].", e, ErrorCode.WriteFailure);
}
}
private void Declare(Token name)
{
if (m_Scopes.Count == 0)
{
return;
}
Scope scope = m_Scopes.Peek();
if (scope.ContainsKey(name.lexeme))
{
m_ErrorHandler.Error(name, "Variable with this name already declared in this scope.");
}
scope[name.lexeme] = false;
}
public void ActivateOptions()
{
if (string.IsNullOrEmpty(Name) || string.IsNullOrEmpty(FileName))
{
_errorHandler.Error("Template name or fileName is empty!");
}
if (!File.Exists(FileName))
{
_errorHandler.Error(string.Format("Could not find template file: {0}", FileName));
}
IsValid = true;
}
private bool DoEndTag(string ident, SymbolScanner scanner)
{
bool ret = false;
Trace.WriteLine("End Tag:" + ident);
scanner.SkipSpaces();
if (scanner.NextSymbol == SymbolScanner.SymbolCloseTag)
{
scanner.SkipSymbol();
scanner.SkipSpaces();
}
char ch = scanner.GetSymbol();
if (ch != '>')
{
_errorHandler.Error($"Expected '>' symbol but become:'{ch}'", scanner);
}
else
{
ret = true;
}
return(ret);
}
public virtual void Error(ParseError error)
{
if (errorHandler != null)
{
errorHandler.Error(error);
}
}
public static void Log(string data, string host, string indexName, string userName, string password, int port = 8089, IErrorHandler errorHandler = null, bool useFreshSession = false,
int sessionTimeout = 55)
{
try
{
indexName = indexName.ToLowerInvariant();
var service = CreateSplunkService(host, indexName, userName, password, port, useFreshSession, sessionTimeout);
var receiver = service.GetReceiver();
var args = new ReceiverSubmitArgs()
{
Index = indexName,
Source = "SplunkAppender",
SourceType = "bigjson",
Host = Environment.MachineName
};
receiver.Submit(args, data);
}
catch (Exception ex)
{
if (errorHandler != null)
{
errorHandler.Error("Splunk Appender Log Exception.", ex);
}
}
}
public virtual void Error(SAXParseException e)
{
if (_errorHandler != null)
{
_errorHandler.Error(e);
}
}
/// <summary>
/// Resolve a variable expression
/// </summary>
/// <param name="expr">The expression</param>
public object Visit(Expr.Variable expr)
{
if (!_scopes.IsEmpty() && _scopes.Peek().Get(expr.Name.Lexeme) == false)
{
_error_handler.Error(expr.Name, "Cannot read local variable in its own initializer.");
}
ResolveLocal(expr, expr.Name);
return(null);
}
#pragma warning disable RECS0165 // Asynchronous methods should return a Task instead of void
public static async void FireAndForgetSafeAsync(this Task task, IErrorHandler handler = null)
#pragma warning restore RECS0165 // Asynchronous methods should return a Task instead of void
{
try
{
await task;
}
catch (Exception ex)
{
handler?.Error(ex.Message);
}
}
/// <summary>
/// Interpret statements
/// </summary>
/// <param name="statements">The statements</param>
public void Interpret(List <Stmt> statements)
{
try
{
foreach (Stmt statement in statements)
{
Execute(statement);
}
}
catch (RuntimeErrorException ex)
{
_error_handler.Error(ex);
}
}
public static async Task LogAsync(string data, string host, string indexName, string userName, string password, int port = 8089, IErrorHandler errorHandler = null, bool useFreshSession = false,
int sessionTimeout = 55)
{
var t = new Task(() =>
{
try
{
Log(data, host, indexName, userName, password, port, errorHandler, useFreshSession, sessionTimeout);
}
catch (Exception ex)
{
if (errorHandler != null)
{
errorHandler.Error("Splunk Appender Log Exception.", ex);
}
}
});
t.Start();
await t;
}
/// <summary>
/// Takes our current string and checks for the next token.
/// </summary>
private void ScanToken()
{
// Get our next char
char nextChar = Read();
// Switch on it
switch (nextChar)
{
// Braces
case '(': AddToken(TokenType.LeftParen); break;
case ')': AddToken(TokenType.RightParen); break;
case '{': AddToken(TokenType.LeftBrace); break;
case '}': AddToken(TokenType.RightBrace); break;
case '[': AddToken(TokenType.LeftBracket); break;
case ']': AddToken(TokenType.RightBracket); break;
// Syntax
case ',': AddToken(TokenType.Comma); break;
case '.': AddToken(TokenType.Dot); break;
case '?': AddToken(TokenType.Question); break;
case ':': AddToken(TokenType.Colon); break;
// Math
case '%': AddToken(TokenType.Modulus); break;
case '-': AddToken(Match('-') ? TokenType.MinusMinus : TokenType.Minus); break;
case '+': AddToken(Match('+') ? TokenType.PlusPlus : TokenType.Plus); break;
case ';': AddToken(TokenType.Semicolon); break;
case '*': AddToken(TokenType.Star); break;
case '!': AddToken(Match('=') ? TokenType.BangEqual : TokenType.Bang); break;
case '=': AddToken(Match('=') ? TokenType.EqualEqual : TokenType.Equal); break;
case '<': AddToken(Match('=') ? TokenType.LessEqual : TokenType.Less); break;
case '>': AddToken(Match('=') ? TokenType.GreaterEqual : TokenType.Greater); break;
// Long Literals
case '"': ParseStringToken(); break;
// Whitespace
case ' ':
case '\r':
case '\t':
break;
case '\n':
m_Line++;
break;
case '/':
if (Match('/'))
{
// A comment goes to the end of a line
while (Peek() != '\n' && !isAtEnd)
{
// Move to the next char
Read();
}
}
else if (Match('*'))
{
ParseMulitLineComment();
}
else
{
AddToken(TokenType.Slash);
}
break;
default:
// Handle all numbers
if (char.IsDigit(nextChar))
{
ParseNumberToken();
}
else if (IsAlpha(nextChar))
{
ParseIdentifier();
}
else
{
m_ErrorHandler.Error(m_Line, string.Format("Unexpected character '{0}'", nextChar));
}
break;
}
}
// We can safely report a few validity errors that
// make layered Sax2 Dtd validation more conformant
internal void verror(string message)
{
errorHandler.Error(new ParseErrorImpl(message, this, ""));
}
private ParserException Error(Token token, string message)
{
m_ErrorHandler.Error(token, message);
return(new ParserException());
}
bool Initialize(JobSettings settings, IErrorHandler errorHandler)
{
this.settings = settings;
var auditColumns = settings.AuditColumns.AuditColumnNames().Select(c => c.ToLowerInvariant()).ToList();
if (settings.UseAuditColumnsOnImport ?? false)
{
foreach (var field in Fields)
{
if (auditColumns.Contains(field.CanonicalName))
{
field.IsAuditingColumn = true;
}
}
}
if (!Fields.Any())
{
errorHandler.Error($"Could not find any information for table {Name}. Make sure it exists in the target database");
return(false);
}
var data = Fields.Select(f => f.Name.ToLowerInvariant());
if (PrimaryKey == null)
{
var primaryKeys = Fields.Where(f => f.IsPrimaryKey).ToList();
if (primaryKeys.Count == 0)
{
//errorHandler.Warning($"No primary key set for table {Name}, trying to infer from name");
primaryKeys = Fields.Where(f => f.Name.ToLowerInvariant() == "id" || f.Name.ToLowerInvariant() == BasicName.ToLowerInvariant() + "id").ToList();
}
if (primaryKeys.Count > 1)
{
errorHandler.Error($"Multiple primary keys found for table {Name} ({string.Join(", ", primaryKeys.Select(pk => pk.Name))}). Please specify one manually.");
return(false);
}
if (!primaryKeys.Any())
{
errorHandler.Error($"No primary key could be found for table {Name}. Please specify one manually");
return(false);
}
PrimaryKey = primaryKeys.Single().Name;
}
PrimaryKey = PrimaryKey.ToLowerInvariant();
data = data.Where(f => f != PrimaryKey);
if (settings.UseAuditColumnsOnImport ?? false)
{
data = data.Where(f => !settings.AuditColumns.AuditColumnNames().Select(a => a.ToLowerInvariant()).Contains(f));
}
if (IsEnvironmentSpecific)
{
data = data.Where(f => f != "isenvironmentspecific");
}
DataFields = data.ToList();
return(true);
}
/// <summary>
/// Scan for a new token
/// </summary>
private void ScanToken()
{
char c = Advance();
switch (c)
{
// 1 char lexemes
case '(': AddToken(TokenType.LEFT_PAREN); break;
case ')': AddToken(TokenType.RIGHT_PAREN); break;
case '{': AddToken(TokenType.LEFT_BRACE); break;
case '}': AddToken(TokenType.RIGHT_BRACE); break;
case ',': AddToken(TokenType.COMMA); break;
case '.': AddToken(TokenType.DOT); break;
case '-': AddToken(TokenType.MINUS); break;
case '+': AddToken(TokenType.PLUS); break;
case ';': AddToken(TokenType.SEMICOLON); break;
case '*': AddToken(TokenType.STAR); break;
// 2 char lexemes
case '!': AddToken(Match('=') ? TokenType.BANG_EQUAL : TokenType.BANG); break;
case '=': AddToken(Match('=') ? TokenType.EQUAL_EQUAL : TokenType.EQUAL); break;
case '<': AddToken(Match('=') ? TokenType.LESS_EQUAL : TokenType.LESS); break;
case '>': AddToken(Match('=') ? TokenType.GREATER_EQUAL : TokenType.GREATER); break;
// Slash could be a comment
case '/':
if (Match('/'))
{
// A comment continues to the end of the line
while (Peek() != '\n' && !IsAtEnd())
{
Advance();
}
}
else
{
AddToken(TokenType.SLASH);
}
break;
// Whitespace (fall-through)
case ' ':
case '\r':
case '\t':
// Ignore
break;
// New Line
case '\n':
_line++;
break;
// String
case '"': String(); break;
default:
if (IsDigit(c))
{
Number();
}
else if (IsAlpha(c))
{
Identifier();
}
else
{
_error_handler.Error(_line, $"Unexpected character: '{c}'.");
}
break;
}
}
public XamlMainObjectNode Parse(StreamReader fileStream)
{
if (fileStream == null)
{
throw new ArgumentNullException(nameof(fileStream));
}
Stack <XamlObjectNode> objStack = new Stack <XamlObjectNode>();
XamlObjectNode currentNode = null;
XamlMainObjectNode mainObject = null;
SymbolScanner scanner = new SymbolScanner(fileStream);
int lineNumberStart = 0;
int linePositionStart = 0;
//long newLineStreamPosition = fileStream.BaseStream.Position;
string ident;
//bool tagBracketClosed = false;
while (!fileStream.EndOfStream)
{
scanner.SkipSpaces();
char ch = scanner.GetSymbol();
if (ch == '\0')
{
break;
}
if (ch == SymbolScanner.SymbolStartTag)
{
//tagBracketClosed = false;
lineNumberStart = scanner.LineNumber;
//open tag symbol must be start not the next symbol
linePositionStart = scanner.CharPosition - 1;
char chNext = scanner.NextSymbol;
if (chNext == SymbolScanner.SymbolCloseTag)
{
scanner.SkipSymbol();
ident = scanner.GetName();
if (DoEndTag(ident, scanner))
{
CloseTag(ident, scanner, objStack);
}
}
else if (chNext == SymbolScanner.SymbolStartComment)
{
string comment = scanner.ReadComment();
Trace.WriteLine($"{lineNumberStart + 1}:{linePositionStart + 1} Comment:{comment}");
XamlCommentNode commentNode = new XamlCommentNode
{
LineNumberStart = lineNumberStart + 1,
LinePositionStart = linePositionStart + 1,
Comment = comment
};
commentNode.LineNumberEnd = scanner.LineNumber + 1;
//end position is outside comment tag
commentNode.LinePositionEnd = scanner.CharPosition;
objStack.Push(commentNode);
}
else
{
char breakSymbol;
ident = scanner.GetName();
breakSymbol = scanner.NextSymbol;
//ident = GetIdent(fileStream, out breakSymbol);
Trace.WriteLine($"{lineNumberStart + 1}:{linePositionStart + 1} Start Tag:{ident}");
if (mainObject == null)
{
mainObject = new XamlMainObjectNode {
LineNumberStart = lineNumberStart + 1, LinePositionStart = linePositionStart + 1
};
mainObject.Name = ident;
currentNode = mainObject;
//root.MainObject = mainObject;
objStack.Push(mainObject);
}
else
{
currentNode = new XamlObjectNode {
LineNumberStart = lineNumberStart + 1, LinePositionStart = linePositionStart + 1
};
currentNode.Name = ident;
objStack.Push(currentNode);
}
if (breakSymbol != SymbolScanner.SymbolEndTag)
{
scanner.SkipSpaces();
breakSymbol = scanner.NextSymbol;
}
if (breakSymbol == SymbolScanner.SymbolCloseTag)
{
//end of tag
if (DoEndTag(ident, scanner))
{
CloseTag(ident, scanner, objStack);
}
}
else if (breakSymbol != SymbolScanner.SymbolEndTag)
{
XamlObjectNode objectNode = null;
if (objStack.Count > 0)
{
objectNode = objStack.Peek();
}
bool isClosed = ReadAttributes(objectNode, scanner, breakSymbol);
if (isClosed)
{
//tagBracketClosed = true;
if (objectNode != null)
{
objectNode.SetState(XamlNodeBase.EState.EndTagPresent);
//objectNode.IsTagBracketClosed = true;
}
Trace.WriteLine("Tag end symbol for:" + ident);
}
if (scanner.NextSymbol == SymbolScanner.SymbolCloseTag)
{
//end of tag
if (DoEndTag(ident, scanner))
{
CloseTag(ident, scanner, objStack);
}
}
}
else
{
// skip '>'
scanner.SkipSymbol();
XamlObjectNode objectNode = objStack.Peek();
objectNode.SetState(XamlNodeBase.EState.EndTagPresent);
Trace.WriteLine("Tag end symbol for:" + ident);
}
//chNext = scanner.NextSymbol;
}
}
else
{
if (objStack.Count > 0)
{
XamlObjectNode objectNode = objStack.Peek();
if (objectNode.IsState(XamlNodeBase.EState.EndTagPresent))
{
lineNumberStart = scanner.LineNumber;
//text symbol must be current not the next symbol
linePositionStart = scanner.CharPosition - 1;
string text = scanner.ReadText(ch);
Trace.WriteLine("Text node:" + text);
XamlTextNode textNode = new XamlTextNode(text)
{
LineNumberStart = lineNumberStart + 1, LinePositionStart = linePositionStart + 1
};
textNode.LineNumberEnd = scanner.LastTextLineNumberEnd + 1;
// it must be the next symbol
textNode.LinePositionEnd = scanner.LastTextCharPositionEnd;
objectNode.SetState(XamlNodeBase.EState.TextNodePresent);
objectNode.AddChild(textNode);
}
else
{
//Trace.Write(ch);
_errorHandler?.Error($"Not expected symbol :'{ch}'", scanner);
}
}
else
{
//Trace.Write(ch);
_errorHandler?.Error($"Not expected symbol, no tag found :'{ch}'", scanner);
}
}
char chNext1 = scanner.CheckEndOfLine(scanner.NextSymbol);
}
if (objStack.Count > 0)
{
//ignore exception by non closed main state. Temporary
if (mainObject != null && objStack.Count == 1)
{
if (!mainObject.IsState(XamlNodeBase.EState.Closed))
{
return(mainObject);
}
}
_errorHandler?.Error($"unused {objStack.Count} nodes", scanner);
}
return(mainObject);
}
public virtual void Parse(TextReader text)
{
Stack nsstack = new Stack();
Locator locator = new Locator();
SAXParseException saxException = new SAXParseException();
Attributes atts = new Attributes();
XmlTextReader reader = null;
try
{
reader = new XmlTextReader(text);
object nsuri = reader.NameTable.Add(
"http://www.w3.org/2000/xmlns/");
handler.StartDocument();
while (reader.Read())
{
string prefix = "";
locator.LineNumber = reader.LineNumber;
locator.ColumnNumber = reader.LinePosition;
handler.SetDocumentLocator(locator);
switch (reader.NodeType)
{
case XmlNodeType.Element:
nsstack.Push(null); //marker
atts = new Attributes();
while (reader.MoveToNextAttribute())
{
if (reader.NamespaceURI.Equals(nsuri))
{
prefix = "";
if (reader.Prefix == "xmlns")
{
prefix = reader.LocalName;
}
nsstack.Push(prefix);
handler.StartPrefixMapping(prefix, reader.Value);
}
else
{
atts.AddAttribute(reader.NamespaceURI, reader.Name, reader.Name, reader.GetType().ToString(), reader.Value);
}
}
reader.MoveToElement();
Handler.StartElement(reader.NamespaceURI, reader.LocalName, reader.Name, atts);
if (reader.IsEmptyElement)
{
handler.EndElement(reader.NamespaceURI, reader.LocalName, reader.Name);
}
break;
case XmlNodeType.EndElement:
handler.EndElement(reader.NamespaceURI, reader.LocalName, reader.Name);
while (prefix != null)
{
handler.EndPrefixMapping(prefix);
prefix = (string)nsstack.Pop();
}
break;
case XmlNodeType.Text:
handler.Characters(reader.Value.ToCharArray(), 0, reader.Value.Length);
break;
case XmlNodeType.ProcessingInstruction:
handler.ProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Whitespace:
char[] whiteSpace = reader.Value.ToCharArray();
handler.IgnorableWhitespace(whiteSpace, 0, 1);
break;
case XmlNodeType.Entity:
handler.SkippedEntity(reader.Name);
break;
}
} //While
handler.EndDocument();
} //try
catch (Exception exception)
{
saxException.LineNumber = reader.LineNumber;
saxException.SystemID = "";
saxException.setMessage(exception.GetBaseException().ToString());
errorHandler.Error(saxException);
}
finally
{
if (reader.ReadState != ReadState.Closed)
{
reader.Close();
}
}
} //parse()
public virtual void Attribute(string aname, string value, bool isSpecified)
{
// Code changed by MHK 16 April 2001.
// The only safe thing to do is to process all the namespace declarations
// first, then process the ordinary attributes. So if this is a namespace
// declaration, we deal with it now, otherwise we save it till we get the
// startElement call.
if (_attributeCount++ == 0)
{
if (_namespaces)
{
_prefixStack.PushContext();
}
}
// set nsTemp [0] == namespace URI (or empty)
// set nsTemp [1] == local name (or empty)
if (value == null)
{
// MHK: I think this can only happen on an error recovery path
// MHK: I was wrong: AElfred was notifying null values of attribute
// declared in the DTD as #IMPLIED. But I've now changed it so it doesn't.
return;
}
if (_namespaces && aname.StartsWith("xmlns"))
{
if (aname.Length == 5)
{
_prefixStack.DeclarePrefix("", value);
//System.err.println("Declare default prefix = "+value);
_contentHandler.StartPrefixMapping("", value);
}
else if (aname[5] == ':' && !aname.Equals("xmlns:xml"))
{
if (aname.Length == 6)
{
_errorHandler.Error(new SAXParseException("Missing namespace prefix in namespace declaration: " + aname,
this));
return;
}
string prefix = aname.Substring(6);
if (value.Length == 0)
{
_errorHandler.Error(new SAXParseException("Missing URI in namespace declaration: " + aname, this));
return;
}
_prefixStack.DeclarePrefix(prefix, value);
//System.err.println("Declare prefix " +prefix+"="+value);
_contentHandler.StartPrefixMapping(prefix, value);
}
if (!_xmlNames)
{
// if xmlNames option wasn't selected,
// we don't report xmlns:* declarations as attributes
return;
}
}
_attributeNames.Add(aname);
_attributeValues.Add(value);
}
