public static ScanResult Scan(string expression)
{
var scanner = new Scanner();
scanner.text = expression;
scanner.Scan();
return scanner.result;
}
public void CanParseSimpleFilename2()
{
var scanner = new Scanner("*.txt");
AssertToken(TokenKind.Wildcard, "*", scanner.Scan());
AssertToken(TokenKind.Identifier, ".txt", scanner.Scan());
AssertToken(TokenKind.EOT, "", scanner.Scan());
}
public void ReadInvalidRepeatedTagDirective()
{
using (var reader = new StreamReader(string.Format("TestData{0}example-6.17_invalid-repeated-tag-directive.yml", Path.DirectorySeparatorChar)))
{
var scanner = new Scanner(reader);
var tokens = scanner.ReadTokens().ToList();
Assert.That(tokens.Count, Is.EqualTo(9));
var directiveTokens = tokens.FindAll(t => t is DirectiveToken).Select(t => t as DirectiveToken).ToList();
Assert.AreEqual(2, directiveTokens.Count);
Assert.IsNotNull(directiveTokens[0]);
Assert.That(directiveTokens[0].Name, Is.EqualTo("TAG"));
Assert.IsNotNull(directiveTokens[1]);
Assert.That(directiveTokens[1].Name, Is.EqualTo("TAG"));
var directiveParameters0 = directiveTokens[0].Parameters.ToList();
Assert.That(directiveParameters0.Count, Is.EqualTo(2));
Assert.That(directiveParameters0[0], Is.EqualTo("!"));
Assert.That(directiveParameters0[1], Is.EqualTo("!foo"));
var directiveParameters1 = directiveTokens[1].Parameters.ToList();
Assert.That(directiveParameters1.Count, Is.EqualTo(2));
Assert.That(directiveParameters1[0], Is.EqualTo("!"));
Assert.That(directiveParameters1[1], Is.EqualTo("!foo"));
var documentContentToken = tokens.Find(t => t is DocumentContentToken) as DocumentContentToken;
Assert.IsNotNull(documentContentToken);
Assert.AreEqual("bar", documentContentToken.Content.TrimEnd());
}
}
void Run()
{
Scanner input = new Scanner(Console.In);
int A = input.NextInt();
int B = input.NextInt();
int D = input.NextInt();
bool[] sieve = new bool[B + 10];
sieve[0] = sieve[1] = true;
for (int i = 2; i * i <= B; ++i) {
if (!sieve[i]) {
for (int j = i * i; j <= B; j += i)
sieve[j] = true;
}
}
int res = 0;
for (int i = A; i <= B; ++i) {
if (!sieve[i]) {
int t = i;
while (t > 0) {
if (t % 10 == D) { res++; break; }
t /= 10;
}
}
}
Console.WriteLine(res);
}
void Run()
{
Scanner input = new Scanner(Console.In);
long A = input.NextInt();
long B = input.NextInt();
int N = input.NextInt();
Bignum a = new Bignum(0);
Bignum b = new Bignum(0);
Bignum one = new Bignum(1);
int last = 0;
for (int i = 0; i < N; i++) {
while (A % 2 == 0 && B % 2 == 0) { A /= 2; B /= 2; }
if (A > B || (A == B && last == 0)) {
B *= 2;
last = 0;
a.Add(a);
a.Add(one);
} else {
A *= 2;
last = 1;
b.Add(b);
b.Add(one);
}
}
a.Add(b);
Console.WriteLine(a);
}
//
#if !mono
public void runMain(Type mainType, object main, Scanner scanner, string ansExpected, object answerType)
{
var input = mainType.GetMethod("createInput").Invoke(main, new object[] { scanner });
//string ans = ( (InputFileConsumer<LostInput,string>) main).processInput(input);
var ans = mainType.GetMethod("processInput").Invoke(main, new object[] { input });
if ("double".Equals(answerType))
{
Logger.LogInfo("String [{}]", (string)ans);
try
{
double ans_d = double.Parse((string)ans, new CultureInfo("en-US"));
double expected_d = double.Parse(ansExpected, new CultureInfo("en-US"));
Assert.AreEqual(expected_d, ans_d, 0.00001);
}
catch (System.FormatException)
{
Logger.LogInfo("ERROR [{}] [{}]", (string)ans, ansExpected);
Assert.IsTrue(false);
}
}
else
{
Assert.AreEqual(ansExpected, ans);
}
}
public static IEnumerable<Token> Scan(string source)
{
var se = new SymbolsEnumerator(source);
var result = new Scanner(se).Scan();
se.Dispose();
return result;
}
private static bool TryGetCodePoint(Scanner scanner, out int codePoint)
{
codePoint = 0;
var validCodePoint = false;
var highSurrogate = scanner.ReadChar();
if (highSurrogate > 0 && char.IsHighSurrogate((char) highSurrogate))
{
var lowSurrogate = scanner.ReadChar();
if (lowSurrogate > 0 && char.IsLowSurrogate((char) lowSurrogate))
{
codePoint = char.ConvertToUtf32((char) highSurrogate, (char) lowSurrogate);
validCodePoint = true;
}
else
{
scanner.Position -= 2;
}
}
else
{
scanner.Position--;
}
return validCodePoint;
}
void Run()
{
Scanner input = new Scanner(Console.In);
long R = input.NextInt();
long xc = input.NextInt();
long yc = input.NextInt();
long x = input.NextInt() - xc;
long y = input.NextInt() - yc;
long dx = input.NextInt() - xc - x;
long dy = input.NextInt() - yc - y;
long a = dx * dx + dy * dy;
long b = 2 * x * dx + 2 * y * dy;
long c = x * x + y * y - R * R;
long det = b * b - 4 * a * c;
if (det == 0)
Console.WriteLine("0");
else if (det < 0)
Console.WriteLine("-1");
else {
double res = Math.Sqrt(det) / a * Math.Sqrt(dx * dx + dy * dy);
Console.WriteLine("{0:0.00000000}", res);
}
}
public static void Main(string[] arg)
{
Scanner scanner = new Scanner(arg[0]);
Parser parser = new Parser(scanner);
parser.Parse();
Console.Write(parser.errors.count + " errors detected");
}
void Run()
{
Scanner input = new Scanner(Console.In);
string[] a = new string[3];
for (int i = 0; i < 3; i++)
a[i] = input.Next();
int max = 0, min = 0, max_c = 1;
for (int i = 1; i < 3; i++) {
if (a[i].Length > a[max].Length ||
(a[i].Length == a[max].Length && a[i].CompareTo(a[max]) > 0)) {
max = i;
max_c = 1;
} else if (a[i] == a[max]) {
max_c++;
} else {
min = i;
}
}
string[] names = new string[] { "Mary", "Klaus", "Peter" };
if (max_c == 1)
Console.WriteLine(names[max]);
else if (max_c == 2)
Console.WriteLine(names[min]);
else
Console.WriteLine("Draw");
}
public void AssignmentAndColon()
{
var lexer = new Scanner(":");
Assert.That(lexer.NextToken(), Is.InstanceOf<TypeDeclaration>());
lexer = new Scanner(":=");
Assert.That(lexer.NextToken(), Is.InstanceOf<AssignmentToken>());
}
public void test_lex()
{
Scanner lex = new Scanner();
lex.src = "int main() { return 0; }";
lex.Lex();
String output = lex.ToString();
}
public EvoQLExpression(string query, IEnumerable<GetTypes> defaultTypes)
{
MemoryStream stream = new MemoryStream();
String errorString;
StreamWriter writer = new StreamWriter(stream);
writer.Write(query);
writer.Flush();
Scanner scanner = new Scanner(stream);
Parser parser = new Parser(scanner);
MemoryStream errorStream = new MemoryStream();
StreamWriter errorWriter = new StreamWriter(errorStream);
parser.errors.errorStream = errorWriter;
parser.Parse();
errorWriter.Flush();
errorStream.Seek(0, SeekOrigin.Begin);
errorString = new StreamReader(errorStream).ReadToEnd();
errorStream.Close();
stream.Close();
if (parser.errors.count > 0)
{
Errors = errorString.Split('\n');
HadErrors = true;
}
else
{
Tree = parser.RootTree;
}
}
public void Keywords(string keyword)
{
var lexer = new Scanner(keyword);
Token next = lexer.NextToken();
Assert.That(next, Is.InstanceOf<KeywordToken>());
Assert.That(((KeywordToken)next).Value, Is.EqualTo(keyword));
}
public void Run()
{
Scanner input = new Scanner(Console.In);
double height = input.NextDouble();
double[] x = new double[200];
double[] y = new double[200];
int n = input.NextInt() + 1;
for (int i = 0; i < n; i++)
{
x[i] = input.NextDouble();
y[i] = input.NextDouble();
}
int m = input.NextInt() + 1;
n += m;
for (int i = 1; i <= m; i++)
{
x[n - i] = input.NextDouble();
y[n - i] = input.NextDouble();
}
double area = 0;
for (int i = 0; i < n; i++)
{
int j = (i + 1) % n;
area += x[i] * y[j] - x[j] * y[i];
}
double volume = Math.Abs(area) / 2.0 * height;
Console.WriteLine("{0:0.00}", volume);
}
private void button2_Click(object sender, EventArgs e)
{
label2.ForeColor = Color.Cyan;
label2.Text = "Being Compiled.";
try
{
Scanner scanner = null;
using (TextReader input = File.OpenText(openFileDialog1.FileName))
{
scanner = new Scanner(input);
}
Parser parser = new Parser(scanner.Tokens);
CodeGen codeGen = new CodeGen(parser.Result, Path.GetFileNameWithoutExtension(openFileDialog1.FileName) + ".exe");
label2.ForeColor = Color.Lime;
label2.Text = "Compiled! Check the directory this program is in, or click 'Test File' and check the console.";
button3.Enabled = true;
}
catch (Exception ex)
{
textBox3.Show();
textBox3.Text = ex.Message;
label2.ForeColor = Color.Red;
label2.Text = "Error!";
button3.Enabled = false;
}
}
static void Main(string[] args)
{
string sampleText = @"<html>
<head>
<title>[% IF Title %][% EVAL Title %][% ELSE %] Some Stuff! [% END %]</title>
</head>
<body>
<h1>[% EVAL content %]</h1>
<ul>[% FOREACH Foos %]<li>[% Name %]</li>[% END %]</ul>
</body>
</html>";
Scanner s = new Scanner(sampleText);
Tokenizer t = new Tokenizer(s);
BlockParseNode bpn = new BlockParseNode(t);
Program p1 = new Program()
{
HasTitle = false,
Content = 3.1415,
Foos = Enumerable.Range(0, 10).Select(i => new Foo() { Name = i.ToString() }).ToList()
};
Program p2 = new Program()
{
HasTitle = true,
Title = "Example",
Foos = Enumerable.Range(10, 10).Select(i => new Foo() { Name = i.ToString() }).ToList()
};
Template template = new Template(new StringReader(sampleText));
template.Render(p1, Console.Out);
template.Render(p2, Console.Out);
Console.ReadKey();
}
// constructs a parser for a string in memory (used for test purposes)
// ts is the string to be parsed, source is a name to be used as the
// filename in any error messages.
public Parser( string source, string ts )
{
this.filename = source;
sc = new Scanner(source, ts);
DeclaredFunctionList = new List<Function>();
UsedFunctions = new List<Function>();
}
// constructs a parser for the contents of a file
public Parser( string filename )
{
this.filename = filename;
sc = new Scanner(filename);
DeclaredFunctionList = new List<Function>();
UsedFunctions = new List<Function>();
}
private void ActiveScanner(DeviceInfo selectedScanner)
{
if (selectedScanner != null && !selectedScanner.IsDeviceInfoOf(activeScanner))
{
DeactivateScanner();
UpdateEventHistory(string.Format("Activate Scanner:{0}", selectedScanner.ServiceObjectName));
try
{
activeScanner = (Scanner)explorer.CreateInstance(selectedScanner);
activeScanner.Open();
activeScanner.Claim(1000);
activeScanner.DeviceEnabled = true;
activeScanner.DataEvent += new DataEventHandler(activeScanner_DataEvent);
activeScanner.ErrorEvent += new DeviceErrorEventHandler(activeScanner_ErrorEvent);
activeScanner.DecodeData = true;
activeScanner.DataEventEnabled = true;
}
catch (PosControlException)
{
UpdateEventHistory(string.Format("Activation Failed:{0}", selectedScanner.ServiceObjectName));
activeScanner = null;
}
}
}
public static void Main(string[] args)
{
MemoryStream stream = new MemoryStream();
String saber = new String('c', 4);
StreamWriter writer = new StreamWriter(stream);
writer.Write(@"
GET lol, troll, bla WHERE asdsadas lol test FROM:(bla NOT:lol OR (NOT:lolo OR ""lolol lolol"")) asdasd OR asdasd TO:lala OR (FROM:bla TO:(lol OR (BLA AND NOT:bla)) AND (NOT Lol OR BLA))");
writer.Flush();
Scanner scanner = new Scanner(stream);
Parser parser = new Parser(scanner);
MemoryStream errorStream = new MemoryStream();
StreamWriter errorWriter = new StreamWriter(errorStream);
parser.errors.errorStream = errorWriter;
parser.Parse();
errorWriter.Flush();
errorStream.Seek(0, SeekOrigin.Begin);
saber = new StreamReader(errorStream).ReadToEnd();
errorStream.Close();
stream.Close();
if (parser.errors.count > 0)
{
Console.Out.WriteLine(saber);
}
else
{
PrintTree(parser.RootTree, 0);
}
Console.ReadLine();
}
public override Microsoft.VisualStudio.Package.AuthoringScope ParseSource(ParseRequest req)
{
Babel.Source source = (Babel.Source)this.GetSource(req.FileName);
bool yyparseResult = false;
// req.DirtySpan seems to be set even though no changes have occurred
// source.IsDirty also behaves strangely
// might be possible to use source.ChangeCount to sync instead
if (req.DirtySpan.iStartIndex != req.DirtySpan.iEndIndex
|| req.DirtySpan.iStartLine != req.DirtySpan.iEndLine) {
ErrorHandler handler = new ErrorHandler();
Scanner scanner = new Scanner(); // string interface
Parser parser = new Parser(); // use noarg constructor
parser.scanner = scanner;
scanner.Handler = handler;
parser.SetHandler(handler);
scanner.SetSource(req.Text, 0);
parser.MBWInit(req);
yyparseResult = parser.Parse();
// store the parse results
// source.ParseResult = aast;
source.ParseResult = null;
source.Braces = parser.Braces;
// for the time being, just pull errors back from the error handler
if (handler.ErrNum > 0) {
foreach (Babel.Parser.Error error in handler.SortedErrorList()) {
TextSpan span = new TextSpan();
span.iStartLine = span.iEndLine = error.line - 1;
span.iStartIndex = error.column;
span.iEndIndex = error.column + error.length;
req.Sink.AddError(req.FileName, error.message, span, Severity.Error);
}
}
}
switch (req.Reason) {
case ParseReason.Check:
case ParseReason.HighlightBraces:
case ParseReason.MatchBraces:
case ParseReason.MemberSelectAndHighlightBraces:
// send matches to sink
// this should (probably?) be filtered on req.Line / col
if (source.Braces != null) {
foreach (TextSpan[] brace in source.Braces) {
if (brace.Length == 2)
req.Sink.MatchPair(brace[0], brace[1], 1);
else if (brace.Length >= 3)
req.Sink.MatchTriple(brace[0], brace[1], brace[2], 1);
}
}
break;
default:
break;
}
return new AuthoringScope(req.Text);
}
void Run()
{
Scanner input = new Scanner(Console.In);
N = input.NextInt();
value = new int[N + 1];
for (int i = 1; i <= N; i++)
value[i] = input.NextInt();
kid = new int[N + 1];
sib = new int[N + 1];
parent = new int[N + 1];
for (int i = 1; i < N; i++) {
int x = input.NextInt();
int p = input.NextInt();
sib[x] = kid[p];
kid[p] = x;
parent[x] = p;
}
int root = 0;
for (int i = 1; i <= N; i++)
if (parent[i] == 0) root = i;
memo = new int[N + 1, 2];
got = new bool[N + 1, 2];
int res = Math.Max(vertCov(root, 0), vertCov(root, 1));
Console.WriteLine(res);
}
public void ReadBareDocuments()
{
using (var reader = new StreamReader(Path.Combine("TestData", "example-9.3_bare-documents.yml")))
{
var scanner = new Scanner(reader);
var tokens = scanner.ReadTokens().ToList();
Assert.That(tokens.Count, Is.EqualTo(12));
Assert.That(tokens[0], Is.InstanceOf(typeof(StreamStartToken)));
Assert.That(tokens[1], Is.InstanceOf(typeof(DirectivesStartToken)));
Assert.That(tokens[2], Is.InstanceOf(typeof(DirectivesEndToken)));
Assert.That(tokens[3], Is.InstanceOf(typeof(DocumentStartToken)));
Assert.That(tokens[4], Is.InstanceOf(typeof(DocumentContentToken)));
Assert.That(tokens[5], Is.InstanceOf(typeof(DocumentEndToken)));
Assert.That(tokens[6], Is.InstanceOf(typeof(DirectivesStartToken)));
Assert.That(tokens[7], Is.InstanceOf(typeof(DirectivesEndToken)));
Assert.That(tokens[8], Is.InstanceOf(typeof(DocumentStartToken)));
Assert.That(tokens[9], Is.InstanceOf(typeof(DocumentContentToken)));
Assert.That(tokens[10], Is.InstanceOf(typeof(DocumentEndToken)));
Assert.That(tokens[11], Is.InstanceOf(typeof(StreamEndToken)));
Assert.That(((DocumentContentToken)tokens[4]).Content, Is.Not.Empty);
Assert.That(((DocumentContentToken)tokens[9]).Content, Is.Not.Empty);
}
}
void Run()
{
Scanner input = new Scanner(Console.In);
N = input.NextInt();
mat = new int[N, N];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
mat[i, j] = input.NextInt();
int res = 0;
for (int y1 = 0; y1 < N; y1++) {
for (int x1 = 0; x1 < N; x1++) {
int c = mat[y1, x1];
for (int y2 = y1; y2 < N; y2++) {
for (int x2 = (y1 == y2 ? x1 + 1 : 0); x2 < N; x2++) {
if (mat[y2, x2] != c) continue;
int y3 = y2 + (x2 - x1);
int x3 = x2 + (y1 - y2);
if (y3 < 0 || y3 >= N || x3 < 0 || x3 >= N || mat[y3, x3] != c) continue;
int y4 = y1 + (x2 - x1);
int x4 = x1 + (y1 - y2);
if (y4 < 0 || y4 >= N || x4 < 0 || x4 >= N || mat[y4, x4] != c) continue;
res++;
}
}
}
}
Console.WriteLine(res/2);
}
public override object Evaluate(Frame environment)
{
if (environment == null)
{
throw new ArgumentNullException("Environment can not be null.");
}
string path = environment.FindBindingValue(Parameters[0]).ToString();
if (!File.Exists(path))
{
throw new Exception("Could not find file: " + path);
}
using (StreamReader codeReader = new StreamReader(File.Open(path, FileMode.Open)))
{
Scanner scanner = new Scanner(codeReader);
Expression expr = scanner.NextExpression;
string evaluation = string.Empty;
while (expr != null)
{
evaluation = environment.Evaluate(expr).ToString();
expr = scanner.NextExpression;
}
return evaluation;
}
}
public Parser(string exp, ICalcFunction calcFunc)
{
this.exp = exp;
tree = null;
scanner = new Scanner(exp);
this.icalcfunc = calcFunc;
}
void Run()
{
Scanner input = new Scanner(Console.In);
int N = input.NextInt();
if (N <= 4) {
string[] sol = new string[] { "1", "1 2", "1 3 2", "1 4 2 3" };
Console.WriteLine(sol[N]);
} else {
int[] a = new int[N + 10];
a[1] = 1;
a[2] = 4;
a[3] = 2;
a[4] = 3;
for (int K = 5; K <= N; K++) {
int p = (1 + K) / 2;
a[K] = a[p];
a[p] = K;
}
for (int i = 1; i <= N; i++)
Console.Write("{0} ", a[i]);
Console.WriteLine();
}
}
public static void Main(string[] arg)
{
if (arg.Length == 2)
{
Scanner scanner = new Scanner(arg[0]);
Parser parser = new Parser(scanner);
parser.Parse();
if (parser.errors.count != 0)
{
Console.WriteLine("*** " + parser.errors.count + " Parsing errors ***");
return;
}
parser.Write("output.ir");
IRStream tuples = parser.GetStream();
// Code Optimizations - 100% doesn't work yet
// tuples = SSA.DoSSAOptimizations(tuples);
// Register Allocation
List<IRTuple> tuples_out = Allocate.run(tuples);
// backenders should write ARM out to arg[1]
CodeGen.IRListToArmFile(tuples_out, arg[1]);
Console.Write("\n");
}
else Console.WriteLine("Usage: tcdscc <program.swift> <output.asm>");
}
public Program(TextReader input, TextWriter output)
{
_input = input;
_output = output;
_scanner = new Scanner(input);
}
public Parser(Scanner scanner)
{
this.scanner = scanner;
errors = new Errors();
}
private int GetPartyMemberDamage(int playerIndex)
{
Int64 DPSAddress = Scanner.READ_MULTILEVEL_PTR(Address.BASE + Address.DAMAGE_OFFSET, Address.Offsets.DamageOffsets);
return(Scanner.READ_INT(DPSAddress + (0x2A0 * playerIndex)));
}
private void GetParty()
{
Int64 address = Address.BASE + Address.PARTY_OFFSET;
Int64 PartyContainer = Scanner.READ_MULTILEVEL_PTR(address, Address.Offsets.PartyOffsets) - 0x22B7;
if (this.InPeaceZone)
{
PlayerParty.LobbySize = Scanner.READ_INT(PartyContainer - 0xA961);
}
else
{
int totalDamage = 0;
for (int i = 0; i < PlayerParty.MaxSize; i++)
{
totalDamage += GetPartyMemberDamage(i);
}
PlayerParty.TotalDamage = totalDamage;
GetQuestElapsedTime();
for (int i = 0; i < PlayerParty.MaxSize; i++)
{
string playerName = GetPartyMemberName(PartyContainer + (i * 0x1C0));
byte playerWeapon = playerName == this.Name ? this.WeaponID : Scanner.READ_BYTE(PartyContainer + (i * 0x1C0 + 0x33));
int playerDamage = GetPartyMemberDamage(i);
float playerDamagePercentage = 0;
if (totalDamage != 0)
{
playerDamagePercentage = playerDamage / (float)totalDamage;
}
PlayerParty[i].SetPlayerInfo(playerName, playerWeapon, playerDamage, playerDamagePercentage);
}
}
}
private void GetSecondaryMantleTimers()
{
Int64 SecondaryMantleTimerFixed = (SecondaryMantle.ID * 4) + Address.timerFixed;
Int64 SecondaryMantleTimer = (SecondaryMantle.ID * 4) + Address.timerDynamic;
Int64 SecondaryMantleCdFixed = (SecondaryMantle.ID * 4) + Address.cooldownFixed;
Int64 SecondaryMantleCdDynamic = (SecondaryMantle.ID * 4) + Address.cooldownDynamic;
SecondaryMantle.SetCooldown(Scanner.READ_FLOAT(EQUIPMENT_ADDRESS + SecondaryMantleCdDynamic), Scanner.READ_FLOAT(EQUIPMENT_ADDRESS + SecondaryMantleCdFixed));
SecondaryMantle.SetTimer(Scanner.READ_FLOAT(EQUIPMENT_ADDRESS + SecondaryMantleTimer), Scanner.READ_FLOAT(EQUIPMENT_ADDRESS + SecondaryMantleTimerFixed));
}
private void GetPlayerName()
{
Int64 Address = LEVEL_ADDRESS - 0x40;
Name = Scanner.READ_STRING(Address, 32);
}
private void GetPlayerMasterRank()
{
MasterRank = Scanner.READ_INT(LEVEL_ADDRESS + 0x44);
}
private void GetPlayerLevel()
{
Level = Scanner.READ_INT(LEVEL_ADDRESS);
}
public void Setup()
{
scanner = new Scanner();
parser = new Parser(scanner);
}
public Problem(bool isGCJ, Scanner scanner) : this(isGCJ, scanner, new Printer())
{
}
public void RunBeforeEachTest()
{
_scanner = new Scanner();
_parser = new Parser(_scanner);
}
static void Main(string[] args)
{
try
{
var scanner = new Scanner();
var parser = new Parser(scanner);
scanner.SetSource(File.OpenRead("test.lae"));
if (parser.Parse())
{
String files = String.Empty;
String init = String.Empty;
String s = String.Empty;
foreach (var item in parser.ParseTree)
{
String stateName = item.Target.Name;
String startCondition = item.Expression.Condition.Compile();
String beforeRun = String.Empty;
String afterRun = String.Empty;
bool before = true;
for (var i = 0; i < item.Expression.Iteration.Actors.Count; i++)
{
if (item.Expression.Iteration.Actors[i].GetType() == typeof(ExprCall))
{
before = false;
continue;
}
if (before)
{
beforeRun += item.Expression.Iteration.Actors[i].Compile() + ";\n";
}
else
{
afterRun += item.Expression.Iteration.Actors[i].Compile() + ";\n";
}
}
s = File.ReadAllText("..\\..\\Templates\\CommonState.cs");
s = s.Replace("##StateName##", stateName);
s = s.Replace("##StartCondition##", startCondition);
s = s.Replace("##BeforeRun##", beforeRun);
s = s.Replace("##AfterRun##", afterRun);
Directory.CreateDirectory("Solution");
File.WriteAllText("Solution\\" + stateName + ".cs", s);
files += "<Compile Include=\"" + stateName + ".cs\" />\n";
init += "var s" + number.ToString() + " = new " + stateName + "();\n";
number++;
}
s = File.ReadAllText("..\\..\\Templates\\Solution.csproj");
s = s.Replace("##Files##", files);
File.WriteAllText("Solution\\Solution.csproj", s);
s = File.ReadAllText("..\\..\\Templates\\Startup.cs");
s = s.Replace("##Init##", init);
File.WriteAllText("Solution\\Startup.cs", s);
File.Copy("..\\..\\Templates\\State.cs", "Solution\\State.cs", true);
File.Copy("..\\..\\Templates\\Solution.sln", "Solution\\Solution.sln", true);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
//Console.WriteLine("Press ENTER ...");
//Console.ReadLine();
}
public Parser(Scanner scanner,
IDictionary <string, CCompiler.Macro> macroMap)
: base(scanner)
{
m_macroMap = macroMap;
}
// Use this for initialization
void Start()
{
scan = GetComponent <Scanner>();
router = GetComponent <WalkOnRoute>();
mb = GetComponent <Mob>();
}
protected Transformer(Weapon weapon, Scanner scanner)
{
Weapon = weapon;
Scanner = scanner;
}
public Parser(Scanner scanner)
: base(scanner)
{
// Empty.
}
public override void FindEnemy()
{
Scanner.Scan();
}
public void UpdateRearSensor_Stats()
{
Scanner s = RadarObjs[2].GetComponent <Scanner>();
RearSensorStats.text = string.Format("Range: {0}\nFoV: {1}\nAngle: {2}", s.range, s.FieldOfView, RadarObjs[2].transform.parent.transform.localEulerAngles.y);
}
protected FlyingTransformer(Weapon weapon, Scanner scanner) : base(weapon, scanner)
{
}
public static Transformer CreateTransformer(TransformerType transformerType, Weapon weapon, Scanner scanner)
{
Transformer transformer = transformerType switch
{
TransformerType.OptimusPrime => new OptimusPrime(weapon, scanner),
TransformerType.AutoBotX5 => new AutoBotX5(weapon, scanner),
_ => throw new ArgumentOutOfRangeException($"No implementation for this type {transformerType}.")
};
return(transformer);
}
public static int Main()
{
cin = new Scanner();
new Myon().calc();
return(0);
}
public OptimusPrime(Weapon weapon, Scanner scanner) : base(weapon, scanner)
{
}
public static List <EditSpan> ReformatCode(IVsTextLines pBuffer, TextSpan span, int tabSize)
{
string filePath = FilePathUtilities.GetFilePath(pBuffer);
// Return dynamic scanner based on file extension
List <EditSpan> changeList = new List <EditSpan>();
string codeToFormat;
int endOfFirstLineIndex;
// Get 1st line and parse custom define
pBuffer.GetLengthOfLine(0, out endOfFirstLineIndex);
pBuffer.GetLineText(0, 0, 0, endOfFirstLineIndex, out codeToFormat);
Dictionary <string, string> defines = ParseDefineLine(codeToFormat);
AsmHighlighterScanner scanner = AsmHighlighterScannerFactory.GetScanner(filePath);
Scanner lexer = scanner.Lexer;
// Iterate on each line of the selection to format
for (int line = span.iStartLine; line <= span.iEndLine; line++)
{
int lineLength;
pBuffer.GetLengthOfLine(line, out lineLength);
pBuffer.GetLineText(line, 0, line, lineLength, out codeToFormat);
string codeToAssemble = ConvertToFasm(lexer, codeToFormat, defines);
lexer.SetSource(codeToFormat, 0);
int state = 0;
int start, end;
bool instructionFound = false, commentFound = false;
int commentStart = 0;
AsmHighlighterToken token = (AsmHighlighterToken)lexer.GetNext(ref state, out start, out end);
while (token != AsmHighlighterToken.EOF)
{
switch (token)
{
case AsmHighlighterToken.INSTRUCTION:
case AsmHighlighterToken.FPUPROCESSOR:
case AsmHighlighterToken.SIMDPROCESSOR:
instructionFound = true;
break;
case AsmHighlighterToken.COMMENT_LINE:
if (!commentFound)
{
commentFound = true;
commentStart = start;
}
break;
}
if (instructionFound && commentFound)
{
byte[] buffer = null;
try
{
buffer = ManagedFasm.Assemble(codeToAssemble);
}
catch (Exception ex)
{
// Unable to parse instruction... skip
}
if (buffer != null)
{
}
TextSpan editTextSpan = new TextSpan();
editTextSpan.iStartLine = line;
editTextSpan.iEndLine = line;
editTextSpan.iStartIndex = commentStart;
editTextSpan.iEndIndex = commentStart + 1;
if ((codeToFormat.Length - commentStart) > 2 && codeToFormat.Substring(commentStart, 2) == ";#")
{
editTextSpan.iEndIndex = editTextSpan.iEndIndex + 2;
}
string text = ";#" + ((buffer == null) ? "?" : string.Format("{0:X}", buffer.Length));
changeList.Add(new EditSpan(editTextSpan, text));
break;
}
token = (AsmHighlighterToken)lexer.GetNext(ref state, out start, out end);
}
}
return(changeList);
}
void calc()
{
cin = new Scanner();
}
//*************************************************************************************************************
private void toolScanner_Click(object sender, EventArgs e)
{
Scanner scanner = new Scanner();
scanner.Show(this);
}
// Use this for initialization
void Start()
{
_scanner = GameObject.FindGameObjectWithTag("Scanner").GetComponent <Scanner>();
}
private void GetAbnormality(string Type, Int64 AbnormalityAddress, int AbnormNumber, string AbnormInternalID, bool IsDebuff, bool HasConditions = false, int ConditionOffset = 0, bool IsInfinite = false, int DoubleBuffStack = 0, int ParentOffset = 0)
{
float Duration = Scanner.READ_FLOAT(AbnormalityAddress);
byte Stack;
// Palico and misc buffs don't stack
switch (Type)
{
case "HUNTINGHORN":
Stack = Scanner.READ_BYTE(AbnormalityAddress + (0x12C - (0x3 * ((ParentOffset - 0x38) / 4))));
break;
case "MISC":
if (HasConditions)
{
Stack = (byte)(Scanner.READ_BYTE(AbnormalityAddress + ConditionOffset));
if (Stack == (byte)0)
{
HasConditions = false;
}
}
else
{
Stack = 0;
}
break;
default:
Stack = 0;
break;
}
if ((int)Duration <= 0 && !HasConditions)
{
// Check if there's an abnormality with that ID
if (Abnormalities[AbnormInternalID] != null)
{
Abnormalities.Remove(AbnormInternalID);
}
else
{
return;
}
}
else
{
if ((int)Duration <= 0 && !IsInfinite)
{
if (Abnormalities[AbnormInternalID] != null)
{
Abnormalities.Remove(AbnormInternalID);
}
return;
}
if (Stack < DoubleBuffStack)
{
return;
}
// Check for existing abnormalities before making a new one
if (Abnormalities[AbnormInternalID] != null)
{
Abnormalities[AbnormInternalID].UpdateAbnormalityInfo(Type, AbnormInternalID, Duration, Stack, AbnormNumber, IsDebuff, IsInfinite, AbnormalityData.GetAbnormalityIconByID(Type, AbnormNumber));
}
else
{
Abnormality NewAbnorm = new Abnormality();
NewAbnorm.UpdateAbnormalityInfo(Type, AbnormInternalID, Duration, Stack, AbnormNumber, IsDebuff, IsInfinite, AbnormalityData.GetAbnormalityIconByID(Type, AbnormNumber));
Abnormalities.Add(AbnormInternalID, NewAbnorm);
}
}
}
/*
* public class X86TextSpan
* {
* public X86TextSpan(int start, int end)
* {
* Start = start;
* End = end;
* }
*
* public int Start { get; set; }
* public int End { get; set; }
* }
*
*
* public class X86Instruction : X86TextSpan
* {
* public X86Instruction(int start, int end, string name, AsmHighlighterToken type) : base(start, end)
* {
* Name = name;
* Type = type;
* }
*
* public string Name { get; set; }
* public AsmHighlighterToken Type { get; set; }
* }
*
* public class X86Code
* {
* public X86Instruction Instruction { get; set; }
*
* }
*
* public X86Code Parse(Scanner lexer, string codeToParse)
* {
* lexer.SetSource(codeToParse, 0);
* int state = 0;
* int start, end;
*
* AsmHighlighterToken token = (AsmHighlighterToken)lexer.GetNext(ref state, out start, out end);
* List<EditSpan> changes = new List<EditSpan>();
* while (token != AsmHighlighterToken.EOF)
* {
* bool isToStrip = false;
* string stripReplace = "";
* string tokenStr = codeToParse.Substring(start, end - start + 1).ToLower();
* switch (token)
* {
* case AsmHighlighterToken.INSTRUCTION:
* if (tokenStr == "call" || tokenStr.StartsWith("j"))
* {
* string restOfLine = codeToParse.Substring(end + 1, codeToParse.Length - (end + 1)).Trim();
* // Default call|jmp dword
* if (!restOfLine.StartsWith("dword") && !restOfLine.StartsWith("short"))
* {
* isToStrip = true;
* stripReplace = tokenStr + " dword";
* }
* }
* break;
* case AsmHighlighterToken.LEFT_SQUARE_BRACKET:
*
*
* break;
* case AsmHighlighterToken.RIGHT_SQUARE_BRACKET:
*
*
* break;
* case AsmHighlighterToken.REGISTER:
* if (tokenStr.StartsWith("st("))
* {
* tokenStr = tokenStr.Replace("(", "");
* tokenStr = tokenStr.Replace(")", "");
* isToStrip = true;
* stripReplace = tokenStr;
* }
* break;
* case AsmHighlighterToken.DIRECTIVE:
* // strip register
* if (tokenStr == "ptr")
* {
* isToStrip = true;
* stripReplace = "";
* }
* break;
*
* case AsmHighlighterToken.IDENTIFIER:
* // Convert all identifiers to 0 in order to be able to compile the code
* isToStrip = true;
* stripReplace = "125125";
* break;
* }
* if (isToStrip)
* {
* TextSpan editTextSpan = new TextSpan();
* editTextSpan.iStartLine = 0;
* editTextSpan.iEndLine = 0;
* editTextSpan.iStartIndex = start;
* editTextSpan.iEndIndex = end + 1;
*
* changes.Add(new EditSpan(editTextSpan, stripReplace));
* }
* token = (AsmHighlighterToken)lexer.GetNext(ref state, out start, out end);
* }
* return null;
* }
*/
public static string ConvertToFasm(Scanner lexer, string codeToFormat, Dictionary <string, string> defines)
{
lexer.SetSource(codeToFormat, 0);
int state = 0;
int start, end;
bool isInBracket = false;
int countRegisterInBracket = 0;
AsmHighlighterToken token = (AsmHighlighterToken)lexer.GetNext(ref state, out start, out end);
List <EditSpan> changes = new List <EditSpan>();
while (token != AsmHighlighterToken.EOF)
{
bool isToStrip = false;
string stripReplace = "";
string tokenStr = codeToFormat.Substring(start, end - start + 1).ToLower();
switch (token)
{
case AsmHighlighterToken.INSTRUCTION:
if (tokenStr == "call" || tokenStr.StartsWith("j"))
{
string restOfLine = codeToFormat.Substring(end + 1, codeToFormat.Length - (end + 1)).Trim();
// Set default call|jxx to dword
if (!restOfLine.StartsWith("dword") && !restOfLine.StartsWith("short") && !restOfLine.StartsWith("near") && !restOfLine.StartsWith("far"))
{
isToStrip = true;
stripReplace = tokenStr + " dword";
}
}
break;
case AsmHighlighterToken.LEFT_SQUARE_BRACKET:
isInBracket = true;
break;
case AsmHighlighterToken.RIGHT_SQUARE_BRACKET:
isInBracket = false;
countRegisterInBracket = 0;
break;
case AsmHighlighterToken.REGISTER:
case AsmHighlighterToken.REGISTER_FPU:
case AsmHighlighterToken.REGISTER_MMXSSE:
if (isInBracket)
{
countRegisterInBracket++;
}
// Convert st(#) register to st#
if (token == AsmHighlighterToken.REGISTER_FPU)
{
tokenStr = tokenStr.Replace("(", "");
tokenStr = tokenStr.Replace(")", "");
isToStrip = true;
stripReplace = tokenStr;
}
break;
case AsmHighlighterToken.DIRECTIVE:
// strip register
if (tokenStr == "ptr")
{
isToStrip = true;
stripReplace = "";
}
break;
case AsmHighlighterToken.IDENTIFIER:
isToStrip = true;
stripReplace = (defines.ContainsKey(tokenStr)) ? defines[tokenStr] : "4";
if (isInBracket)
{
if ((lexer.AsmHighlighterTokenProvider.GetTokenFromIdentifier(stripReplace) & AsmHighlighterToken.IS_REGISTER) != 0)
{
countRegisterInBracket++;
}
else if (stripReplace == "4")
{
// No register before 1st identifier
if (countRegisterInBracket == 0)
{
// Fake dword adress if we have mov [IDENTIFIER + ....]
stripReplace = "123123";
}
}
}
break;
}
if (isToStrip)
{
TextSpan editTextSpan = new TextSpan();
editTextSpan.iStartLine = 0;
editTextSpan.iEndLine = 0;
editTextSpan.iStartIndex = start;
editTextSpan.iEndIndex = end + 1;
changes.Add(new EditSpan(editTextSpan, stripReplace));
}
token = (AsmHighlighterToken)lexer.GetNext(ref state, out start, out end);
}
for (int i = changes.Count - 1; i >= 0; i--)
{
EditSpan editSpan = changes[i];
codeToFormat = codeToFormat.Substring(0, editSpan.Span.iStartIndex) + editSpan.Text +
codeToFormat.Substring(editSpan.Span.iEndIndex, codeToFormat.Length - editSpan.Span.iEndIndex);
}
// Force the FASM code to 32 bit
codeToFormat = "use32\r\n" + codeToFormat;
return(codeToFormat);
}
private string GetPartyMemberName(Int64 NameAddress)
{
string PartyMemberName = Scanner.READ_STRING(NameAddress, 32);
return(PartyMemberName ?? PartyMemberName.Trim('\x00'));
}
public override Node apply(Node args)
{
if (args == null)
{
return(null);
}
String symbolType = symbol.getName();
Node arg1 = args.getCar();
Node arg2 = args.getCdr();
if (arg1.isNull())
{
arg1 = Nil.getInstance();
}
if (arg2.isNull())
{
arg2 = Nil.getInstance();
}
else
{
arg2 = args.getCdr().getCar();
}
if (symbolType.Equals("b+"))
{
if (arg1.isNumber() & arg2.isNumber())
{
return(new IntLit(arg1.getValue() + arg2.getValue()));
}
else
{
return(new StringLit("Error: Both arguments must be numbers for b+"));
}
}
if (symbolType.Equals("b-"))
{
if (arg1.isNumber() & arg2.isNumber())
{
return(new IntLit(arg1.getValue() - arg2.getValue()));
}
else
{
return(new StringLit("Error: Both arguments must be numbers for b-"));
}
}
if (symbolType.Equals("b*"))
{
if (arg1.isNumber() & arg2.isNumber())
{
return(new IntLit(arg1.getValue() * arg2.getValue()));
}
else
{
return(new StringLit("Error: Both arguments must be numbers for b*"));
}
}
if (symbolType.Equals("b/"))
{
if (arg1.isNumber() & arg2.isNumber())
{
return(new IntLit(arg1.getValue() / arg2.getValue()));
}
else
{
return(new StringLit("Error: Both arguments must be numbers for b/"));
}
}
if (symbolType.Equals("b="))
{
if (arg1.isNumber() & arg2.isNumber())
{
return(new BoolLit(arg1.getValue() == arg2.getValue()));
}
else
{
return(new StringLit("Error: Both arguments must be numbers for b="));
}
}
if (symbolType.Equals("b<"))
{
if (arg1.isNumber() & arg2.isNumber())
{
return(new BoolLit(arg1.getValue() < arg2.getValue()));
}
else
{
return(new StringLit("Error: Both arguments must be numbers for b<"));
}
}
if (symbolType.Equals("null?"))
{
return(new BoolLit(arg1.isNull()));
}
if (symbolType.Equals("number?"))
{
return(new BoolLit(arg1.isNumber()));
}
if (symbolType.Equals("pair?"))
{
return(new BoolLit(arg1.isPair()));
}
if (symbolType.Equals("symbol?"))
{
return(new BoolLit(arg1.isSymbol()));
}
if (symbolType.Equals("procedure?"))
{
return(new BoolLit(arg1.isProcedure()));
}
if (symbolType.Equals("car"))
{
if (arg1.isNull())
{
return(arg1);
}
return(arg1.getCar());
}
if (symbolType.Equals("cdr"))
{
if (arg1.isNull())
{
return(arg1);
}
return(arg1.getCdr());
}
if (symbolType.Equals("set-car!"))
{
arg1.setCar(arg2);
return(arg1);
}
if (symbolType.Equals("set-cdr!"))
{
arg1.setCdr(arg2);
return(arg1);
}
if (symbolType.Equals("cons"))
{
return(new Cons(arg1, arg2));
}
if (symbolType.Equals("eq?"))
{
return(new BoolLit(arg1 == arg2));
}
if (symbolType.Equals("display"))
{
return(arg1);
}
if (symbolType.Equals("write"))
{
//write calls your pretting printer
arg1.print(0);
return(new StringLit(""));
}
if (symbolType.Equals("eval"))
{
//eval calls your C# eval() function
return(eval(arg1, env));
}
if (symbolType.Equals("apply"))
{
//apply calls your C# apply function
return(arg1.apply(arg2));
}
if (symbolType.Equals("newline"))
{
return(new StringLit(""));
}
if (symbolType.Equals("read"))
{
Scanner io = new Scanner(Console.In);
TreeBuilder tree = new TreeBuilder();
Parser parse = new Parser(io, tree);
Node theNode = (Node)parse.parseExp();
return(theNode);
}
if (symbolType.Equals("interaction-environment"))
{
env.print(0);
}
else
{
arg1.print(0);
return(Nil.getInstance());
}
return(Nil.getInstance());
}
