private bool P_RelationalOperator(out Token.Token op)
{
op = _curr;
_curr = _scanner.GetNextToken();
return(op.Type == TokenType.EqComp || op.Type == TokenType.Greater || op.Type == TokenType.Geq ||
op.Type == TokenType.Less || op.Type == TokenType.Leq || op.Type == TokenType.Neq);
}
public override List <Token.Token> ApplyEx(List <Token.Token> match, Token.Token left)
{
if (left != null)
{
if (left.TokenType == Token.Token.Type.Value)
{
return(null); // don't apply here
}
}
Debug.Assert(match.Count == 2);
if (match[0] is SingleCharToken signToken)
{
if (signToken.Symbol == '+')
{
return new List <Token.Token> {
match[1]
}
}
; // the value wont change
if (signToken.Symbol == '-')
{
return(new List <Token.Token>
{
new CombinedValueToken(new NumberToken(-1.0f),
new SingleCharToken(Token.Token.Type.Operation2, '*'), match[1])
});
}
}
throw new Exception("invalid token in Markov Rule RuleSign: " + match[0]);
}
}
public AstNode Parse(ExprParser parser, Token.Token token)
{
var expr = parser.Parse(0);
parser.Consume(Token.Token.TokenType.RightParen);
return(expr);
}
public JsonResult RefreshToken()
{
var userRefreshToken = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.NameIdentifier)
.Select(c => c.Value).SingleOrDefault();
var userLogin = UserLoginRepo.NewInstance.Filter.RefreshToken(userRefreshToken).Get.FirstOrDefault();
if (userLogin != null)/*&& user?.RefreshTokenEndDate > DateTime.Now*/
{
TokenHandler tokenHandler = new TokenHandler(configuration);
Token.Token token = tokenHandler.CreateAccessToken(userLogin);
userLogin.RefreshToken = token.RefreshToken;
userLogin.RefreshTokenEndDate = token.Expiration.AddMinutes(3);
var updateRefresh = UserLoginRepo.NewInstance.Do.Update(userLogin);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Sid, userLogin.UserId.ToString()),
new Claim(ClaimTypes.NameIdentifier, userLogin.RefreshToken),
new Claim(ClaimTypes.Name, userLogin.Name + " " + userLogin.Surname),
new Claim(ClaimTypes.Email, userLogin.Email),
};
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
var props = new AuthenticationProperties();
HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal, props);
return(Json(new { result = true }));
}
return(Json(new { result = false }));
}
public AstNode Parse(ExprParser parser, AstNode leftExpr, Token.Token token)
{
var truePart = parser.Parse(0);
parser.Consume(Token.Token.TokenType.Colon);
var falsePart = parser.Parse(0);
return(new TernaryNode(token, leftExpr, truePart, falsePart));
}
private bool CheckToken(TokenType tokenType)
{
if (_curr.Type != tokenType)
{
return(false);
}
_curr = _scanner.GetNextToken();
return(true);
}
public bool P_ForStatement(bool isProc)
{
if (P_For())
{
if (P_VarName(out var accumulator))
{
if (P_Eq())
{
PerformExpression(isProc, accumulator);
if (P_To())
{
_tmpCtr++;
var to = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
PerformExpression(isProc, to);
if (P_Step())
{
var tmp = new ArrayList();
_tmpCtr++;
var step = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
PerformExpression(isProc, step);
_loopCtr++;
tmp.Add($"_loop_start_{_loopCtr}:");
tmp.Add($"mov esi, DWORD[{FindAsmName(to.Lex)}]");
tmp.Add($"cmp DWORD[{FindAsmName(accumulator?.Lex)}], esi");
tmp.Add($"jg _loop_end_{_loopCtr}");
var origLoopCtr = _loopCtr;
if (P_Do())
{
if (P_LBrace())
{
if (P_Statement())
{
if (P_Rbrace())
{
tmp.Add($"mov edi, DWORD[{FindAsmName(step.Lex)}]");
tmp.Add($"add DWORD[{FindAsmName(accumulator?.Lex)}], edi");
tmp.Add($"jmp _loop_start_{origLoopCtr}");
tmp.Add($"_loop_end_{origLoopCtr}:");
AddToCorrectSection(isProc, tmp);
return(true);
}
}
}
}
}
}
}
}
LogError("Invalid syntax around for statement.");
return(false);
}
return(false);
}
private bool P_Alpha(bool isProc, out Token.Token?token)
{
if (!(P_StrConst(out token) || P_VarName(out token)))
{
_tmpCtr++;
var writeData = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
return(PerformExpression(isProc, writeData));
}
return(true);
}
private bool P_Ap(bool isProc, Token.Token?operand, out Token.Token?result)
{
if (P_LeftBracket())
{
var indices = new ArrayList();
for (;;)
{
_tmpCtr++;
var idx = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
if (PerformExpression(isProc, idx))
{
indices.Add(idx);
if (!P_Comma())
{
break;
}
}
else
{
break;
}
}
if (P_RightBracket())
{
var arr = _arrs.FirstOrDefault(x => x.Name == operand.Lex);
if (arr == null)
{
result = null;
return(false);
}
var tmp = new ArrayList();
tmp.AddRange(arr.GetRef(indices));
_tmpCtr++;
result = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
tmp.Add($"add eax, {FindAsmName(operand?.Lex)}");
tmp.Add($"mov eax, DWORD[eax]");
tmp.Add($"mov {DetermineAsmOperand(result.Lex)}, eax");
AddToCorrectSection(isProc, tmp);
return(true);
}
}
result = null;
return(false);
}
private bool P_ArrayAssignList(bool isProc, Token.Token?assignee, ArrayList indices)
{
if (P_Comma())
{
_tmpCtr++;
var idx = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
if (PerformExpression(isProc, idx))
{
indices.Add(idx);
return(P_ArrayAssignList(isProc, assignee, indices));
}
}
if (P_RightBracket())
{
if (P_Eq())
{
_tmpCtr++;
var val = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
if (PerformExpression(isProc, val))
{
var arr = _arrs.FirstOrDefault(x => x.Name == assignee.Lex);
if (arr == null)
{
return(false);
}
var tmp = new ArrayList();
tmp.AddRange(arr.GetRef(indices));
tmp.Add($"add eax, {FindAsmName(assignee?.Lex)}");
tmp.Add($"mov edi, {DetermineAsmOperand(val.Lex)}");
tmp.Add($"mov DWORD[eax], edi");
tmp.Add("xor edi, edi");
AddToCorrectSection(isProc, tmp);
return(P_Semicolon());
}
}
}
return(false);
}
public string?Parse(string fileName)
{
if (!_scanner.OpenFile(fileName))
{
Console.Error.WriteLine("Could not open file: " + fileName);
return(null);
}
_curr = _scanner.GetNextToken();
if (!P_Program())
{
return(null);
}
// LogError("File compiled successfully!");
return(_asmFileName);
}
public static List <Token.Token> Resolve(List <MarkovRule> rules, List <Token.Token> tokens)
{
var foundRules = true;
markovloop:
while (foundRules)
{
foreach (var markovRule in rules)
{
// find matching sequence
for (int i = 0; i < tokens.Count; ++i)
{
if (TokensMatch(markovRule, tokens, i))
{
// apply the rule
var middle = tokens.GetRange(i, markovRule.Tokens.Count);
Token.Token left = null;
if (i > 0)
{
left = tokens[i - 1];
}
middle = markovRule.ApplyEx(middle, left);
if (middle == null)
{
continue; // no match
}
tokens = Replace(tokens, i, markovRule.Tokens.Count, middle);
// and again
goto markovloop;
}
}
}
foundRules = false;
}
if (tokens.Count > 1)
{
throw new Exception("Could not resolve all tokens to an expression");
}
return(tokens);
}
private bool P_Condition(bool isProc, out Token.Token lhand, out Token.Token?rhand, out Token.Token?op)
{
rhand = null;
op = null;
_tmpCtr++;
lhand = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
PerformExpression(isProc, lhand);
if (!P_RelationalOperator(out op))
{
return(false);
}
_tmpCtr++;
rhand = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
PerformExpression(isProc, rhand);
return(true);
}
/// <summary>
/// CASE [EXP]:{[STATEMENT]} [CASE PART] | DEFAULT:{[STATEMENT]}
/// </summary>
/// <param name="switchArg"></param>
/// <returns></returns>
private bool P_CasePart(bool isProc, Token.Token?switchArg)
{
var tmp = new ArrayList();
if (P_Case())
{
_tmpCtr++;
var condition = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
PerformExpression(isProc, condition);
_ifCtr++;
tmp.Add($"mov edi, {DetermineAsmOperand(condition.Lex)}");
tmp.Add($"cmp {DetermineAsmOperand(switchArg.Lex)}, edi");
tmp.Add($"jnz _endif_{_ifCtr}");
var ifCtr = _ifCtr;
if (P_Colon() && P_LBrace())
{
if (P_Statement())
{
tmp.Add($"jmp _endswitch_{_switchCtr}");
tmp.Add($"_endif_{ifCtr}:");
AddToCorrectSection(isProc, tmp);
return(P_Rbrace() && P_CasePart(isProc, switchArg));
}
}
}
if (P_Default())
{
_elseCtr++;
tmp.RemoveAt(_text.Count - 1);
tmp.Add($"_endif_{_ifCtr}:");
AddToCorrectSection(isProc, tmp);
if (P_Colon() && P_LBrace())
{
if (P_Statement())
{
return(P_Rbrace());
}
}
}
return(false);
}
private bool P_ArrayAssignStmt(bool isProc, Token.Token?assignee)
{
if (P_LeftBracket())
{
_tmpCtr++;
var idx = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
if (PerformExpression(isProc, idx))
{
var indices = new ArrayList {
idx
};
return(P_ArrayAssignList(isProc, assignee, indices));
}
}
return(false);
}
public Parser()
{
_curr = new Token.Token(TokenType.Error, "", -1, -1);
_scanner = new Scanner.Scanner();
_bss = new HashSet <BssData>();
_data = new HashSet <PData>();
_arrs = new List <PArray>();
_text = new ArrayList();
_procs = new ArrayList();
_bssCtr = -1;
_dataCtr = -1;
_expCtr = -1;
_arrCtr = -1;
_tmpCtr = -1;
_loopCtr = -1;
_ifCtr = -1;
_elseCtr = -1;
_switchCtr = -1;
_strCtr = -1;
_copyCtr = -1;
_asmFileName = null;
}
private bool P_IntConst(out Token.Token?num)
{
if (_curr.Type != TokenType.IntConst)
{
if (_curr.Type == TokenType.Minus)
{
_curr = _scanner.GetNextToken();
if (_curr.Type == TokenType.IntConst)
{
num = new Token.Token(TokenType.IntConst, $"-{_curr.Lex}", _curr.Line, _curr.Col);
_curr = _scanner.GetNextToken();
return(true);
}
}
num = null;
return(false);
}
var part = _curr;
num = _curr;
_curr = _scanner.GetNextToken();
if (P_Dot())
{
if (_curr.Type == TokenType.IntConst)
{
num = new Token.Token(TokenType.FloatConst, $"{part?.Lex}.{_curr.Lex}", _curr.Line, _curr.Col);
_curr = _scanner.GetNextToken();
return(true);
}
}
return(true);
}
public JsonResult UserLogin(string username, string password)
{
var userLogin = UserLoginRepo.NewInstance.Filter.UserLogin(username, password).Get.FirstOrDefault();
if (userLogin == null || !BC.Verify(password, userLogin.Password))
{
return(Json(new { result = false }));
}
else
{
//Token üretiliyor.
TokenHandler tokenHandler = new TokenHandler(configuration);
Token.Token token = tokenHandler.CreateAccessToken(userLogin);
//Refresh token Users tablosuna işleniyor.
userLogin.RefreshToken = token.RefreshToken;
userLogin.RefreshTokenEndDate = token.Expiration.AddMinutes(3);
var updateRefresh = UserLoginRepo.NewInstance.Do.Update(userLogin);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Sid, userLogin.UserId.ToString()),
new Claim(ClaimTypes.NameIdentifier, userLogin.RefreshToken),
new Claim(ClaimTypes.Name, userLogin.Name + " " + userLogin.Surname),
new Claim(ClaimTypes.Email, userLogin.Email)
};
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
var props = new AuthenticationProperties();
HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal, props);
return(Json(new { result = true }));
}
}
public AstNode Parse(ExprParser parser, AstNode leftExpr, Token.Token token)
{
return(new BitwiseOperatorNode(token, leftExpr, parser.Parse(GetPrecedence())));
}
protected AstNode(NodeType type, Token.Token token)
{
Type = type;
Token = token;
}
public Token.Token NextToken()
{
SkipWhitespace();
Token.Token tok;
switch (_ch)
{
case '=':
if (PeekChar() == '=')
{
var ch = _ch.ToString();
ReadChar();
tok = new Token.Token(TokenType.EQ, ch + _ch);
}
else
{
tok = new Token.Token(TokenType.ASSIGN, _ch);
}
break;
case '+':
tok = new Token.Token(TokenType.PLUS, _ch);
break;
case '-':
tok = new Token.Token(TokenType.MINUS, _ch);
break;
case '!':
if (PeekChar() == '=')
{
var ch = _ch.ToString();
ReadChar();
tok = new Token.Token(TokenType.NOT_EQ, ch + _ch);
}
else
{
tok = new Token.Token(TokenType.BANG, _ch);
}
break;
case '/':
tok = new Token.Token(TokenType.SLASH, _ch);
break;
case '*':
tok = new Token.Token(TokenType.ASTERISK, _ch);
break;
case '<':
tok = new Token.Token(TokenType.LT, _ch);
break;
case '>':
tok = new Token.Token(TokenType.GT, _ch);
break;
case ';':
tok = new Token.Token(TokenType.SEMICOLON, _ch);
break;
case ',':
tok = new Token.Token(TokenType.COMMA, _ch);
break;
case '(':
tok = new Token.Token(TokenType.LPAREN, _ch);
break;
case ')':
tok = new Token.Token(TokenType.RPAREN, _ch);
break;
case '{':
tok = new Token.Token(TokenType.LBRACE, _ch);
break;
case '}':
tok = new Token.Token(TokenType.RBRACE, _ch);
break;
case '"':
tok = new Token.Token(TokenType.STRING, ReadString());
break;
case '[':
tok = new Token.Token(TokenType.LBRACKET, _ch);
break;
case ']':
tok = new Token.Token(TokenType.RBRACKET, _ch);
break;
case ':':
tok = new Token.Token(TokenType.COLON, _ch);
break;
case (char)0:
tok = new Token.Token(TokenType.EOF, "");
break;
default:
if (IsLetter(_ch))
{
tok = new Token.Token
{
Literal = ReadIdentifier()
};
tok.Type = tok.LookupIdentifier(tok.Literal);
return(tok);
}
if (char.IsDigit(_ch))
{
tok = new Token.Token(TokenType.INT, ReadNumber());
return(tok);
}
tok = new Token.Token(TokenType.ILLEGAL, _ch);
break;
}
ReadChar();
return(tok);
}
public BinaryOperatorNode(Token.Token token, AstNode left, AstNode right)
: base(NodeType.BinaryOperator, token)
{
Left = left;
Right = right;
}
public AstNode Parse(ExprParser parser, AstNode leftExpr, Token.Token token)
{
return(new AssignmentNode(token, leftExpr, parser.Parse(GetPrecedence() - 1))); // right associative
}
public AstNode Parse(ExprParser parser, AstNode leftExpr, Token.Token token)
{
return(new ComparisonNode(token, leftExpr, parser.Parse(GetPrecedence())));
}
public PrefixOperatorNode(Token.Token token, AstNode expr) : base(NodeType.UnaryOperator, token)
{
Expr = expr;
}
/// <summary>
/// program [variable name] ; begin [statement] end .
/// </summary>
/// <returns></returns>
private bool P_Program()
{
if (_curr.Type == TokenType.Program)
{
_curr = _scanner.GetNextToken();
if (_curr.Type == TokenType.VarName)
{
_asmFileName = $"{_curr.Lex.ToLower()}.asm";
_asmFile = new StreamWriter("C:\\Compiler\\" + _asmFileName);
_errFile = new StreamWriter("C:\\Compiler\\" + $"{_curr.Lex.ToLower()}.err");
_asmFile.WriteLine("extern _printf");
_asmFile.WriteLine("extern _scanf");
_asmFile.WriteLine("extern _ExitProcess@4");
_asmFile.WriteLine("global Start");
_curr = _scanner.GetNextToken();
if (P_Semicolon() && P_Begin() && P_Statement() && P_End() && P_Dot())
{
_text.Add("exit:");
_text.Add("push 0");
_text.Add("call _ExitProcess@4");
_asmFile.Write(BuildData());
_asmFile.Write(BuildBss());
_asmFile.WriteLine("section .text");
_asmFile.WriteLine("Start:");
if (_procs.Count > 0)
{
_asmFile.WriteLine("jmp afterProcedures");
_asmFile.Write(GenerateSection(_procs));
_asmFile.WriteLine("afterProcedures:");
}
_asmFile.Write(GenerateSection(_text));
_asmFile.Close();
_asmFile.Dispose();
_errFile.Close();
_errFile.Dispose();
return(true);
}
_asmFile.Close();
_asmFile.Dispose();
_errFile.Close();
_errFile.Dispose();
return(false);
}
Console.Error.WriteLine("Could not find an IDENT token. Exiting...");
}
else
{
Console.Error.WriteLine("Could not find a PROGRAM token. Exiting...");
}
return(false);
}
public LiteralNode(Token.Token token) : base(NodeType.Literal, token)
{
}
public Position(Token.Token token)
{
line = token.line;
}
private bool P_WriteStmt(bool isProc)
{
if (_curr.Type != TokenType.Write)
{
return(false);
}
_curr = _scanner.GetNextToken();
if (!P_Alpha(isProc, out var alpha))
{
return(false);
}
var tmp = new ArrayList();
if (alpha != null && alpha.Type == TokenType.StrConst)
{
tmp.Add($"push s{_dataCtr}");
tmp.Add("push stringPrinter");
}
else
{
if (P_LeftBracket())
{
var indices = new ArrayList();
for (;;)
{
_tmpCtr++;
var idx = new Token.Token(TokenType.VarName, $"_{_tmpCtr}_tmp", -1, -1);
_bss.Add(new BssData($"_{_tmpCtr}_tmp", $"_{_tmpCtr}_tmp", "resd", "1", AsmDataType.Num));
if (PerformExpression(isProc, idx))
{
indices.Add(idx);
if (!P_Comma())
{
break;
}
}
else
{
break;
}
}
if (P_RightBracket())
{
var arr = _arrs.FirstOrDefault(x => x.Name == alpha.Lex);
if (arr == null)
{
return(false);
}
tmp.AddRange(arr.GetRef(indices));
tmp.Add($"add eax, {FindAsmName(alpha.Lex)}");
tmp.Add("push DWORD[eax]");
tmp.Add("push numberPrinter");
tmp.Add("call _printf");
tmp.Add("add esp, 0x08");
AddToCorrectSection(isProc, tmp);
return(P_Semicolon());
}
}
if (GetTypeOfVar(alpha?.Lex) == AsmDataType.String)
{
tmp.Add($"push {FindAsmName(alpha?.Lex)}");
tmp.Add("push stringPrinter");
}
else if (GetTypeOfVar(alpha?.Lex) == AsmDataType.Float)
{
tmp.Add($"fld DWORD[{FindAsmName(alpha?.Lex)}]");
tmp.Add("fstp QWORD[esp]");
tmp.Add("push floatPrinter");
}
else
{
tmp.Add($"push DWORD[{FindAsmName(alpha.Lex)}]");
tmp.Add("push numberPrinter");
}
}
tmp.Add("call _printf");
tmp.Add("add esp, 0x08");
AddToCorrectSection(isProc, tmp);
return(P_Semicolon());
}
public AstNode Parse(ExprParser parser, AstNode leftExpr, Token.Token token)
{
return(new BinaryOperatorNode(token, leftExpr, parser.Parse(GetPrecedence() - (_rightAssociative ? 1 : 0))));
}
