API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 13th, 2019
94
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.87 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. MIT License
  3.  
  4. Copyright (c) 2018 Computing and Engineering Department, Technical University of Varna
  5.  
  6. Permission is hereby granted, free of charge, to any person obtaining a copy
  7. of this software and associated documentation files (the "Software"), to deal
  8. in the Software without restriction, including without limitation the rights
  9. to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10. copies of the Software, and to permit persons to whom the Software is
  11. furnished to do so, subject to the following conditions:
  12.  
  13. The above copyright notice and this permission notice shall be included in all
  14. copies or substantial portions of the Software.
  15.  
  16. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17. IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18. FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19. AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20. LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21. OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22. SOFTWARE.
  23. */
  24.  
  25. package parser;
  26.  
  27. import bg.tu_varna.kst_sit.ci_ep.ast.*;
  28. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.ArrayInitNode;
  29. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.AssignableNode;
  30. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.CharacterLiteralNode;
  31. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.StringLiteralNode;
  32. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.*;
  33. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.binary_operators.additive_operators.AdditionNode;
  34. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.binary_operators.additive_operators.SubtractionNode;
  35. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.binary_operators.logical_operators.AndNode;
  36. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.binary_operators.logical_operators.OrNode;
  37. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.binary_operators.multiplicative_operators.DivisionNode;
  38. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.binary_operators.multiplicative_operators.ModNode;
  39. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.binary_operators.multiplicative_operators.MultiplicationNode;
  40. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.binary_operators.relational_operators.*;
  41. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.unary_operators.MinusNode;
  42. import bg.tu_varna.kst_sit.ci_ep.ast.assignable.expression.operators.unary_operators.NotNode;
  43. import bg.tu_varna.kst_sit.ci_ep.ast.global_definition.FunctionDefinitionNode;
  44. import bg.tu_varna.kst_sit.ci_ep.ast.global_definition.GlobalDefinitionNode;
  45. import bg.tu_varna.kst_sit.ci_ep.ast.global_definition.VariableDefinitionNode;
  46. import bg.tu_varna.kst_sit.ci_ep.ast.statement.*;
  47. import bg.tu_varna.kst_sit.ci_ep.ast.type.PrimitiveTypeNode;
  48. import bg.tu_varna.kst_sit.ci_ep.ast.type.TypeNode;
  49. import bg.tu_varna.kst_sit.ci_ep.ast.type.VoidTypeNode;
  50. import bg.tu_varna.kst_sit.ci_ep.exceptions.SyntaxException;
  51. import bg.tu_varna.kst_sit.ci_ep.lexer.Lexer;
  52. import bg.tu_varna.kst_sit.ci_ep.lexer.token.Token;
  53. import bg.tu_varna.kst_sit.ci_ep.parser.Parser;
  54. import bg.tu_varna.kst_sit.ci_ep.source.SourceImpl;
  55. import bg.tu_varna.kst_sit.ci_ep.utils.CompilerTestHelper;
  56. import lexer.LexerImpl;
  57. import token.TokenType;
  58.  
  59. import java.io.IOException;
  60. import java.util.ArrayList;
  61. import java.util.List;
  62.  
  63. public class ParserImpl extends Parser<TokenType, AST> {
  64.  
  65. public ParserImpl(Lexer<TokenType> lexer) {
  66. super(lexer);
  67. }
  68.  
  69. private void accept(TokenType tokenType) {
  70. if (currentToken.getTokenType() != tokenType) {
  71. throw new SyntaxException("Token doesn't match! Expected " +
  72. tokenType.value + ", Got " + currentToken.getTokenType().value, currentToken);
  73. }
  74. currentToken = lexer.nextToken();
  75. }
  76.  
  77. @Override
  78. public AST entryRule() {
  79. accept(TokenType.PROGRAM);
  80. accept(TokenType.LBRACKET);
  81. programBody();
  82. accept(TokenType.RBRACKET);
  83. return currentNode;
  84. }
  85.  
  86. void programBody() {
  87. List<GlobalDefinitionNode> globalDefinitions = new ArrayList<>();
  88. while(
  89. TokenType.isPrimitiveType(currentToken.getTokenType()) ||
  90. (currentToken.getTokenType() == TokenType.IDENTIFIER && !currentToken.getText().equals("main"))
  91. ) {
  92. if (currentToken.getTokenType() == TokenType.IDENTIFIER) {
  93. functionDefinition();
  94. } else {
  95. variableDefinition();
  96. accept(TokenType.SEMICOLON);
  97. }
  98. globalDefinitions.add((GlobalDefinitionNode) currentNode);
  99. }
  100. mainFunction();
  101. globalDefinitions.add((GlobalDefinitionNode) currentNode);
  102. currentNode = new ProgramBodyNode(null, globalDefinitions);
  103. }
  104.  
  105. void functionDefinition() {
  106. Token token = currentToken;
  107.  
  108. accept(TokenType.IDENTIFIER);
  109. accept(TokenType.LPAREN);
  110. FormalParameterNode formalParameters = null;
  111. if (TokenType.isPrimitiveType(currentToken.getTokenType())) {
  112. formalParameters();
  113. formalParameters = (FormalParameterNode) currentNode;
  114. }
  115. accept(TokenType.RPAREN);
  116. accept(TokenType.ARROW);
  117. /* ToDo handle symbol */
  118. /* ToDo handle symbol */
  119. TypeNode typeNode;
  120. if (currentToken.getTokenType() == TokenType.VOID) {
  121. typeNode = new VoidTypeNode(currentToken);
  122. /* ToDo handle symbol */
  123. accept(TokenType.VOID);
  124. } else {
  125. /* ToDo handle symbol */
  126. type();
  127. typeNode = (TypeNode) currentNode;
  128. }
  129. block();
  130. BlockNode blockNode = (BlockNode)currentNode;
  131. currentNode = new FunctionDefinitionNode(token, formalParameters, typeNode, blockNode);
  132. }
  133.  
  134. void functionCall() {
  135. /* ToDo handle symbol */
  136. accept(TokenType.AT);
  137. Token token = currentToken;
  138. /* ToDo handle symbol */
  139. /* ToDo handle symbol */
  140. accept(TokenType.IDENTIFIER);
  141. accept(TokenType.LPAREN);
  142. ActualParameterNode actualParameters = null;
  143. if (TokenType.isLiteralTerminal(currentToken.getTokenType())) {
  144. /* ToDo handle symbol */
  145. actualParameters();
  146. actualParameters = (ActualParameterNode) currentNode;
  147. }
  148. /* ToDo handle symbol */
  149. accept(TokenType.RPAREN);
  150. currentNode = new FunctionCall(token, actualParameters);
  151. }
  152.  
  153. void type() {
  154. Token token = currentToken;
  155. boolean isArray = false;
  156. if (TokenType.isPrimitiveType(currentToken.getTokenType())) {
  157. accept(currentToken.getTokenType());
  158. if (currentToken.getTokenType() == TokenType.LSQUARE) {
  159. isArray = true;
  160. /* ToDo handle symbol */
  161. /* ToDo handle symbol */
  162. accept(TokenType.LSQUARE);
  163. accept(TokenType.RSQUARE);
  164. }
  165. } else {
  166. throw new SyntaxException("Expected return type. Got " + currentToken.getTokenType().value, currentToken);
  167. }
  168. currentNode = new PrimitiveTypeNode(token, isArray);
  169. }
  170.  
  171. void formalParameters() {
  172. List<TypedVariableNode> formalParameters = new ArrayList<>();
  173. /* ToDo handle symbol */
  174. type();
  175. formalParameters.add(new TypedVariableNode(null, (TypeNode) currentNode, new VariableNode(currentToken, null)));
  176. /* ToDo handle symbol */
  177. accept(TokenType.IDENTIFIER);
  178. while (currentToken.getTokenType() == TokenType.COMMA) {
  179. /* ToDo handle symbol */
  180. /* ToDo handle symbol */
  181. accept(TokenType.COMMA);
  182. type();
  183. formalParameters.add(new TypedVariableNode(null, (TypeNode) currentNode, new VariableNode(currentToken, null)));
  184. /* ToDo handle symbol */
  185. accept(TokenType.IDENTIFIER);
  186. }
  187. currentNode = new FormalParameterNode(null, formalParameters);
  188. }
  189.  
  190. void actualParameters() {
  191. List<AssignableNode> params = new ArrayList<>();
  192. /* ToDo handle symbol */
  193. assignable();
  194. params.add((AssignableNode) currentNode);
  195. while(currentToken.getTokenType() == TokenType.COMMA) {
  196. /* ToDo handle symbol */
  197. /* ToDo handle symbol */
  198. accept(TokenType.COMMA);
  199. assignable();
  200. params.add((AssignableNode) currentNode);
  201. }
  202. currentNode = new ActualParameterNode(null, params);
  203. }
  204.  
  205. void variableDefinition() {
  206. /* ToDo handle symbol */
  207. type();
  208. TypeNode type = (TypeNode)currentNode;
  209. /* ToDo handle symbol */
  210. assignment();
  211. currentNode = new VariableDefinitionNode(null, type, (AssignmentNode) currentNode);
  212. }
  213.  
  214. void assignment() {
  215. /* ToDo handle symbol */
  216. variable();
  217. VariableNode variable = (VariableNode) currentNode;
  218. Token token = currentToken;
  219. /* ToDo handle symbol */
  220. accept(TokenType.BECOMES);
  221. if (TokenType.isPrimitiveType(currentToken.getTokenType())) {
  222. arrayInitialization();
  223. } else if (TokenType.CHAR_LITERAL == currentToken.getTokenType()) {
  224. characterLiteral();
  225. } else if (TokenType.STRING_LITERAL == currentToken.getTokenType()) {
  226. stringLiteral();
  227. } else {
  228. expression();
  229. }
  230. AssignableNode assignable = (AssignableNode) currentNode;
  231. currentNode = new AssignmentNode(token, variable, assignable);
  232. }
  233.  
  234. void arrayInitialization() {
  235. Token token = currentToken;
  236. ExpressionNode expression = null;
  237. if (TokenType.isPrimitiveType(currentToken.getTokenType())) {
  238. /* ToDo handle symbol currentToken (currentToken.getTokenType()) */
  239. /* ToDo handle symbol */
  240. /* ToDo handle symbol */
  241. accept(currentToken.getTokenType());
  242. accept(TokenType.LSQUARE);
  243. expression();
  244. expression = (ExpressionNode) currentNode;
  245. /* ToDo handle symbol */
  246. accept(TokenType.RSQUARE);
  247. } else {
  248. System.out.println("Expected array initialization. Got " + currentToken.getTokenType());
  249. }
  250. currentNode = new ArrayInitNode(token, expression);
  251. }
  252.  
  253. void block() {
  254. List<Statement> statements = new ArrayList<>();
  255. /* ToDo handle symbol */
  256. accept(TokenType.LBRACKET);
  257.  
  258. while (TokenType.isStatementTerminal(currentToken.getTokenType())) {
  259. /* ToDo handle symbol */
  260. statement();
  261. statements.add((Statement) currentNode);
  262. }
  263. /* ToDo handle symbol */
  264. accept(TokenType.RBRACKET);
  265. currentNode = new BlockNode(null, statements);
  266. }
  267.  
  268. void expression() {
  269. /* ToDo handle symbol */
  270. simpleExpression();
  271. Token<TokenType> token = currentToken;
  272. ExpressionNode left = (ExpressionNode) currentNode;
  273. //currentNode points to the simpleExpression no need to assign
  274. if (TokenType.isRelationalOperator(currentToken.getTokenType())) {
  275. ExpressionNode right;
  276. ExpressionNode relationalOperator = null;
  277. /* ToDo handle symbol currentToken (currentToken.getTokenType()) */
  278. /* ToDo handle symbol */
  279. accept(currentToken.getTokenType());
  280. simpleExpression();
  281. right = (ExpressionNode) currentNode;
  282. switch (token.getTokenType()) {
  283. case EQUALS: relationalOperator = new EqualsNode(token, left, right); break;
  284. case NOTEQUALS: relationalOperator = new NotEqualNode(token, left, right); break;
  285. case GREATER: relationalOperator = new GreaterNode(token, left, right); break;
  286. case GREATER_EQ: relationalOperator = new GreaterOrEqualNode(token, left, right); break;
  287. case LESS: relationalOperator = new LessNode(token, left, right); break;
  288. case LESS_EQ: relationalOperator = new LessOrEqualNode(token, left, right); break;
  289. }
  290. currentNode = relationalOperator;
  291. }
  292. }
  293.  
  294. void simpleExpression() {
  295. /* ToDo handle symbol */
  296. signedTerm();
  297. ExpressionNode left = (ExpressionNode) currentNode;
  298. //PLUS, MINUS, OR
  299. while (TokenType.isOperatorGroupOne(currentToken.getTokenType())) {
  300. Token<TokenType> token = currentToken;
  301. /* ToDo handle symbol currentToken (currentToken.getTokenType()) */
  302. /* ToDo handle symbol */
  303. accept(currentToken.getTokenType());
  304. signedTerm();
  305. ExpressionNode right = (ExpressionNode) currentNode;
  306. ExpressionNode additiveOperator = null;
  307. switch (token.getTokenType()) {
  308. case PLUS: additiveOperator = new AdditionNode(token, left, right); break;
  309. case MINUS: additiveOperator = new SubtractionNode(token, left, right); break;
  310. case OR: additiveOperator = new OrNode(token, left, right); break;
  311. }
  312. currentNode = left = additiveOperator;
  313. }
  314. }
  315.  
  316. void signedTerm() {
  317. Token<TokenType> token = null;
  318. if (TokenType.isUnaryOperator(currentToken.getTokenType())) {
  319. token = currentToken;
  320. /* ToDo handle symbol currentToken (currentToken.getTokenType()) */
  321. accept(currentToken.getTokenType());
  322. }
  323. /* ToDo handle symbol */
  324. term();
  325. ExpressionNode operand = (ExpressionNode) currentNode;
  326. if (token != null) {
  327. switch (token.getTokenType()) {
  328. case NOT: operand = new NotNode(token, operand); break;
  329. case MINUS: operand = new MinusNode(token, operand); break;
  330. }
  331. }
  332. currentNode = operand;
  333. }
  334.  
  335. void term() {
  336. /* ToDo handle symbol */
  337. factor();
  338. ExpressionNode left = (ExpressionNode) currentNode;
  339. //MUL, DIV, MOD, AND
  340. while (TokenType.isOperatorGroupTwo(currentToken.getTokenType())) {
  341. Token<TokenType> token = currentToken;
  342. /* ToDo handle symbol currentToken (currentToken.getTokenType()) */
  343. /* ToDo handle symbol */
  344. accept(currentToken.getTokenType());
  345. factor();
  346. ExpressionNode right = (ExpressionNode) currentNode;
  347. ExpressionNode multiplicativeOperator = null;
  348. switch (token.getTokenType()) {
  349. case MUL: multiplicativeOperator = new MultiplicationNode(token, left, right); break;
  350. case DIV: multiplicativeOperator = new DivisionNode(token, left, right); break;
  351. case MOD: multiplicativeOperator = new ModNode(token, left, right); break;
  352. case AND: multiplicativeOperator = new AndNode(token, left, right); break;
  353. }
  354. currentNode = left = multiplicativeOperator;
  355. }
  356. }
  357.  
  358. void factor() {
  359. switch(currentToken.getTokenType()) {
  360. case IDENTIFIER: variable();/* ToDo handle symbol */
  361. break;
  362. case NUMBER: currentNode = new IntegerNode(currentToken);
  363. accept(TokenType.NUMBER);/* ToDo handle symbol */
  364. break;
  365. case TRUE:
  366. case FALSE: currentNode = new BooleanNode(currentToken);
  367. accept(currentToken.getTokenType());/* ToDo handle symbol currentToken (currentToken.getTokenType()) */
  368. break;
  369. case LENGTH: arrayLength();/* ToDo handle symbol */
  370. break;
  371. case LPAREN: accept(TokenType.LPAREN);
  372. expression();
  373. accept(TokenType.RPAREN);
  374. /* ToDo handle symbol */
  375. /* ToDo handle symbol */
  376. /* ToDo handle symbol */
  377. break;
  378. case AT: functionCall();/* ToDo handle symbol */
  379. break;
  380. default: throw new SyntaxException("Expected factor. Got " + currentToken.getTokenType().value, currentToken);
  381. }
  382. }
  383.  
  384. void variable() {
  385. Token token = currentToken;
  386. accept(TokenType.IDENTIFIER);
  387. /* ToDo handle symbol */
  388. ExpressionNode expression = null;
  389. if (currentToken.getTokenType() == TokenType.LSQUARE) {
  390. accept(TokenType.LSQUARE);
  391. simpleExpression();
  392. /* ToDo handle symbol */
  393. /* ToDo handle symbol */
  394. expression = (ExpressionNode) currentNode;
  395. /* ToDo handle symbol */
  396. accept(TokenType.RSQUARE);
  397. }
  398. currentNode = new VariableNode(token, expression);
  399. }
  400.  
  401. void mainFunction() {
  402. Token token = currentToken;
  403. /* ToDo handle symbol */
  404. /* ToDo handle symbol */
  405. /* ToDo handle symbol */
  406. /* ToDo handle symbol */
  407. accept(TokenType.IDENTIFIER);
  408. accept(TokenType.LPAREN);
  409. accept(TokenType.RPAREN);
  410. accept(TokenType.ARROW);
  411.  
  412. TypeNode typeNode = new VoidTypeNode(currentToken);
  413. /* ToDo handle symbol */
  414. /* ToDo handle symbol */
  415. accept(TokenType.VOID);
  416. block();
  417. currentNode = new FunctionDefinitionNode(token, null, typeNode, (BlockNode) currentNode);
  418. }
  419.  
  420. void statement() {
  421. if (TokenType.isCompoundStatementTerminal(currentToken.getTokenType())) {
  422. /* ToDo handle symbol */
  423. compoundStatement();
  424. } else {
  425. /* ToDo handle symbol */
  426. /* ToDo handle symbol */
  427. simpleStatement();
  428. accept(TokenType.SEMICOLON);
  429. }
  430. }
  431.  
  432. void simpleStatement() {
  433. switch(currentToken.getTokenType()) {
  434. case INT:
  435. case CHAR:
  436. case BOOLEAN: variableDefinition();/* ToDo handle symbol */
  437. break;
  438. case IDENTIFIER: assignment();/* ToDo handle symbol */
  439. break;
  440. case AT: functionCall();/* ToDo handle symbol */
  441. break;
  442. case RETURN: returnStatement();/* ToDo handle symbol */
  443. break;
  444. case PRINT: printStatement();/* ToDo handle symbol */
  445. break;
  446. case READ: readStatement();/* ToDo handle symbol */
  447. break;
  448. default: throw new SyntaxException("Expected simpleStatement. Got " + currentToken.getTokenType().value, currentToken);
  449. }
  450. }
  451.  
  452. void compoundStatement() {
  453. if (currentToken.getTokenType() == TokenType.IF) {
  454. /* ToDo handle symbol */
  455. ifStatement();
  456. } else {
  457. /* ToDo handle symbol */
  458. whileStatement();
  459. }
  460. }
  461.  
  462. void ifStatement() {
  463. Token token = currentToken;
  464. /* ToDo handle symbol */
  465. /* ToDo handle symbol */
  466. /* ToDo handle symbol */
  467. accept(TokenType.IF);
  468. accept(TokenType.LPAREN);
  469. expression();
  470. ExpressionNode expressionNode = (ExpressionNode) currentNode;
  471. /* ToDo handle symbol */
  472. /* ToDo handle symbol */
  473. accept(TokenType.RPAREN);
  474. block();
  475. BlockNode ifStatement = (BlockNode) currentNode;
  476. BlockNode elseStatement = null;
  477. if (currentToken.getTokenType() == TokenType.ELSE) {
  478. /* ToDo handle symbol */
  479. /* ToDo handle symbol */
  480. accept(TokenType.ELSE);
  481. block();
  482. elseStatement = (BlockNode) currentNode;
  483. }
  484. currentNode = new IfStatementNode(token, expressionNode, ifStatement, elseStatement);
  485. }
  486.  
  487. void whileStatement() {
  488. Token token = currentToken;
  489. /* ToDo handle symbol */
  490. /* ToDo handle symbol */
  491. /* ToDo handle symbol */
  492. accept(TokenType.WHILE);
  493. accept(TokenType.LPAREN);
  494. expression();
  495. ExpressionNode expressionNode = (ExpressionNode) currentNode;
  496. /* ToDo handle symbol */
  497. /* ToDo handle symbol */
  498. accept(TokenType.RPAREN);
  499. block();
  500. BlockNode blockNode = (BlockNode) currentNode;
  501. currentNode = new WhileStatementNode(token, expressionNode, blockNode);
  502. }
  503.  
  504. void returnStatement() {
  505. Token token = currentToken;
  506. /* ToDo handle symbol */
  507. accept(TokenType.RETURN);
  508. AssignableNode assignable = null;
  509. if (TokenType.isLiteralTerminal(currentToken.getTokenType())) {
  510. /* ToDo handle symbol */
  511. assignable();
  512. assignable = (AssignableNode) currentNode;
  513. }
  514. currentNode = new ReturnStatementNode(token, assignable);
  515. }
  516.  
  517. void printStatement() {
  518. Token token = currentToken;
  519. /* ToDo handle symbol */
  520. /* ToDo handle symbol */
  521. /* ToDo handle symbol */
  522. accept(TokenType.PRINT);
  523. accept(TokenType.LPAREN);
  524. actualParameters();
  525. ActualParameterNode actualParameters = (ActualParameterNode) currentNode;
  526. /* ToDo handle symbol */
  527. accept(TokenType.RPAREN);
  528. currentNode = new PrintStatementNode(token, actualParameters);
  529. }
  530.  
  531. void readStatement() {
  532. Token token = currentToken;
  533. List<VariableNode> variables = new ArrayList<>();
  534. accept(TokenType.READ);
  535. accept(TokenType.LPAREN);
  536. while (currentToken.getTokenType() == TokenType.IDENTIFIER) {
  537. variable();
  538. variables.add((VariableNode) currentNode);
  539. }
  540. accept(TokenType.RPAREN);
  541. currentNode = new ReadStatementNode(token, variables);
  542. }
  543.  
  544. void assignable() {
  545. if (TokenType.isFactorTerminal(currentToken.getTokenType())) {
  546. expression();
  547. } else if (TokenType.isPrimitiveType(currentToken.getTokenType())) {
  548. arrayInitialization();
  549. } else if (TokenType.CHAR_LITERAL == currentToken.getTokenType()) {
  550. characterLiteral();
  551. } else {
  552. stringLiteral();
  553. }
  554. }
  555.  
  556. void characterLiteral() {
  557. currentNode = new CharacterLiteralNode(currentToken);
  558. accept(TokenType.CHAR_LITERAL);
  559. }
  560.  
  561. void stringLiteral() {
  562. currentNode = new StringLiteralNode(currentToken);
  563. accept(TokenType.STRING_LITERAL);
  564. }
  565.  
  566. void arrayLength() {
  567. Token token = currentToken;
  568. /* ToDo handle symbol */
  569. /* ToDo handle symbol */
  570. /* ToDo handle symbol */
  571. /* ToDo handle symbol */
  572. accept(TokenType.LENGTH);
  573. accept(TokenType.LPAREN);
  574. variable();
  575. accept(TokenType.RPAREN);
  576. currentNode = new ArrayLengthNode(token, (VariableNode) currentNode);
  577. }
  578.  
  579. public static void main(String[] args) throws IOException {
  580. Lexer<TokenType> lexer = new LexerImpl(new SourceImpl("resources/Fib.txt"));
  581. Parser<TokenType, AST> parser = new ParserImpl(lexer);
  582. System.out.println(CompilerTestHelper.getASTasString(parser));
  583. }
  584.  
  585.  
  586. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!