public void TestObjectParsing()
{
var sourceList = new List <string> {
ObjectContent
};
var streamer = TokenStreamer.CreateFromList(sourceList);
// Read object id
var currentToken = Token.EOL;
while (currentToken.Type != TokenType.Id)
{
currentToken = streamer.GetNextToken();
}
Assert.Equal("obj", currentToken.Value as string);
// Read attribute dict
var attribParser = new ObjectParser(streamer);
var parsedAttribs = attribParser.ReadSingleObject() as PdfDictionary;
Assert.Equal(804, (int)(parsedAttribs["Length"] as PdfAtom).AsNumber());
// Read body stream start token
var streamStartToken = streamer.GetNextToken();
Assert.Equal("stream", streamStartToken.Value as string);
}
private void ParseConversionTables(IList <string> objContents)
{
var parser = new ObjectParser(TokenStreamer.CreateFromList(objContents));
PdfAtom command;
var paramList = new List <IPdfTerm>();
do
{
command = parser.ReadNextCommand(paramList);
switch (command?.AsString())
{
case CodeSpaceSectionEnd:
CheckSidSize(paramList);
break;
case BfCharSectionEnd:
FillSidToCharMap(paramList);
break;
case BfRangeSectionEnd:
FillSidToCharMapFromRanges(paramList);
break;
}
paramList.Clear();
}while(command != null);
}
public void TestObjectWithComplexStringParsing()
{
var sourceList = new List <string> {
ObjectWithComplexString
};
var parser = new ObjectParser(TokenStreamer.CreateFromList(sourceList));
var parsedObj = parser.ReadSingleObject() as PdfArray;
Assert.Equal(4, parsedObj.Count);
}
public void TestParseComplexAttribs()
{
using var linesReader = CreateStringReader(ComplexString);
var streamer = TokenStreamer.CreateFromReader(linesReader);
var attribParser = new ObjectParser(streamer);
var attribDict = attribParser.ReadSingleObject();
Assert.IsType <PdfDictionary>(attribDict);
var nextTerm = attribParser.ReadSingleObject();
Assert.Null(nextTerm);
}
public void TestObjectTermsParsing()
{
var sourceList = new List <string>(ComplexObjectContent.Split("\r\n"));
var streamer = TokenStreamer.CreateFromList(sourceList);
var parser = new ObjectParser(streamer);
IPdfTerm term = parser.ReadSingleObject();
Assert.IsType <PdfArray>(term);
var firstArrayElement = (term as PdfArray)[0];
Assert.IsType <PdfDictionary>(firstArrayElement);
}
public void TestParseBasicAttribs()
{
const string CompressionAttrib = "Filter";
using var linesReader = CreateStringReader(BasicString);
var streamer = TokenStreamer.CreateFromReader(linesReader);
var attribParser = new ObjectParser(streamer);
var attribs = attribParser.ReadSingleObject() as PdfDictionary;
Assert.Contains(CompressionAttrib, attribs.Keys);
var nextToken = attribParser.ReadSingleObject();
Assert.Null(nextToken);
}
public void TestContinuousParsing()
{
const int NumTokensInTestString = 35;
using var contentReader = CreateStringReader(ObjectContent);
var streamer = TokenStreamer.CreateFromReader(contentReader);
Token currentToken;
int numTokensRead = 0;
do
{
currentToken = streamer.GetNextToken();
numTokensRead++;
}while(currentToken.Type != TokenType.End);
Assert.True(streamer.AtEndOfStream);
Assert.Equal(NumTokensInTestString, numTokensRead - 1);
}
private void ExtractTextFromPage(PdfPage page)
{
var streamer = TokenStreamer.CreateFromList(page.RawContent);
var parser = new ObjectParser(streamer);
PdfAtom command;
var paramList = new List <IPdfTerm>();
do
{
command = parser.ReadNextCommand(paramList);
if (command != null)
{
InterpretPdfCommand(command.AsString(), paramList);
}
paramList.Clear();
}while(command != null);
}
public void TestAllTermsParsing()
{
var sourceList = new List <string> {
ObjectContent
};
var streamer = TokenStreamer.CreateFromList(sourceList);
var parser = new ObjectParser(streamer);
var allTerms = new List <IPdfTerm>();
IPdfTerm parsedTerm;
do
{
parsedTerm = parser.ReadSingleObject();
if (parsedTerm != null)
{
allTerms.Add(parsedTerm);
}
}while(parsedTerm != null);
Assert.Null(parsedTerm);
Assert.Equal(5, allTerms.Count);
}
private async Task InsideRun()
{
bool NotExit = true;
//Thread safe Heap ??
//EDIT: Maybe it is an 'Object pool"!
var Pool = new ObjectPool();
var binderService = new BinderService();
#region Eval Loop
while (NotExit && !ForceGlobalExit)
{
var line = reader();
if (!string.IsNullOrEmpty(line))
{
var input = TokenStreamer.MakeTokenInput(line);
var stream = input.GetStream();
//check logger
//stream.GetStringsRepresentation().Project(sr => string.Format("check: {0}", sr)).Project(writer);
if (!input.IsCommandInput)
{
writer("Command inexistent");
}
else
{
switch (input.Command)
{
//Review this functionality, now it writes the result but doesnt handle very good the arguments !
case Command.Call:
#region Call Implementation
var com2 = new CallCommandable(stream, 1);
try
{
var result = await binderService.DynamicGenInvokeFunc(com2.LookUpName, com2.Arguments);
writer(result);
}
catch (Exception ex)
{
writer(string.Format("Exception when called: ", com2.LookUpName));
writer(ex.ToString());
}
break;
#endregion
case Command.Seq:
#region Seq Implementation
var seqCom = new SeqComandable(stream);
var runners = seqCom.PipeCommandables.Select(pc => new PipeRunner()
{
Pipe = pc, Binder = new BinderService()
});
var tasks = runners.Select(r => r.Run(Pool.GetAllocated));
await Task.WhenAll(tasks);
break;
#endregion
case Command.Pipe:
#region Pipe Implementation
var pipe = new PipeCommandable(stream);
var runner = new PipeRunner()
{
Pipe = pipe,
Binder = binderService,
OnException = (ex, lookup) => writer(string.Format("Action {0} failed with {1}", lookup, ex.ToString()))
};
await runner.Run(Pool.GetAllocated);
break;
#endregion
case Command.Types:
#region DEPRECATED
//TODO: ENHANCE THE TO TYPE FOR A DYNAMIC WAY
//var callCom = new CallCommandable(stream, 0);
//var comodin = callCom.IsComodin();
//var invoc = Invocables.Value.Where(inv => comodin || callCom.Arguments.Contains(inv.Name.ToLower())).ToList();
//Action<Invocable> writer = i => new[] { "", i.ToString(), i.Binder.TypesToString() }.Enumerates(Console.WriteLine);
//invoc.ForEach(writer);
#endregion
break;
case Command.Var:
#region Var Implementation
var varCom = new VarCommandable(stream.PlainTokens);
var name = varCom.Name;
if (!varCom.IsVarNameConvention)
{
writer(string.Format("var name should start with: {0}", TokenConfigs.VarNameStart));
break;
}
if (Pool.IsAny(name))
{
writer(string.Format("'{0}' already defined", name));
break;
}
;
var pipesAssign = new PipeCommandable(varCom.Statement);
var runnerVar = new PipeRunner()
{
Pipe = pipesAssign,
Binder = binderService,
OnException = (lookup, ex) => writer(string.Format("Action {0} failed with {1}", lookup, ex.ToString())),
OnValue = val => Pool.TryAdd(name, val)
};
await runnerVar.Run(Pool.GetAllocated);
break;
#endregion
case Command.Heap:
#region Heap Implementation
var heapCom = new HeapCommandable(stream.PlainTokens);
switch (heapCom.Operator.ToLower())
{
case "clear":
Pool.Clear();
writer("Heap cleared");
break;
case "remove":
dynamic outVar;
var dic = new Dictionary <string, bool>();
heapCom.Arguments.Enumerates(obj => {
if (Pool.IsAny(obj))
{
dic.Add(obj, Pool.TryRemove(obj, out outVar));
}
else
{
writer(string.Format("'{0}' not defined", obj));
}
});
dic.Enumerates(e => e.Value ? writer(string.Format("{0} removed", e.Key)) : writer(string.Format("error removing: {0} ", e.Key)));
break;
default:
if (Pool.IsAny())
{
Pool.GetVars().Enumerates(k => writer(k.ToString()));
}
else
{
writer("Heap is empty");
}
break;
}
break;
#endregion
case Command.Commands:
#region Commands Implementation
MyUtils.GetEnums <Command>().Select(e => e.ToString()).Enumerates(writer);
break;
#endregion
case Command.Clear:
//PENDING DEFINITION
Console.Clear();
break;
case Command.Exit:
#region Exit Command
writer("Press Y to exit");
if (reader().ToLower() == "y")
{
NotExit = false;
}
break;
#endregion
case Command.Invocables:
#region Implementation
var arg = stream.PlainTokens
.Skip(1)
.Where(t => !t.IsEmpty)
.FirstOrDefault();
var filter = MyUtils.MakeFunc((string s) => true);
if (arg != null)
{
filter = s => s.IndexOf(arg.Value, StringComparison.InvariantCultureIgnoreCase) >= 0;
}
Reflector.GetAttributesInAssembly <InvokerAttributes.Invoker>()
.OrderBy(a => a.Name)
.Where(a => filter(a.Name))
.Aggregate(new StringBuilder(), (builder, a) => builder.AppendLine(string.Format(a.Description != null ? "{0}: {1}" : "{0}", a.Name, a.Description)))
.ToString()
.Project(writer);
#endregion
break;
default:
#region Default
var first = stream.PlainTokens.First();
//IsReserved word ?
//Is Var instance
if (Pool.IsCreated)
{
var reference = Pool.GetAllocated(first.Value);
if (Pool.IsAny(first.Value.ToLower()))
{
writer(MyExtensions.ToNullString(reference)); //val.Value
}
else
{
writer(string.Format("'{0}' is not defined", first.Value));
}
}
break;
#endregion
}
}
}
ForceGlobalExit = _force;
}
#endregion
}
