Class: TPPlus::Parser

Inherits:
Racc::Parser
  • Object
show all
Includes:
Nodes
Defined in:
lib/tp_plus/parser.rb

Constant Summary collapse

Racc_arg = 
[
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table = 
[
"$end",
"error",
"ASSIGN",
"AT_SYM",
"COMMENT",
"JUMP",
"IO_METHOD",
"INPUT",
"OUTPUT",
"NUMREG",
"POSREG",
"VREG",
"SREG",
"TIME_SEGMENT",
"ARG",
"UALM",
"MOVE",
"DOT",
"TO",
"AT",
"TERM",
"OFFSET",
"SKIP",
"SEMICOLON",
"NEWLINE",
"STRING",
"REAL",
"DIGIT",
"WORD",
"EQUAL",
"EEQUAL",
"NOTEQUAL",
"GTE",
"LTE",
"LT",
"GT",
"BANG",
"PLUS",
"MINUS",
"STAR",
"SLASH",
"DIV",
"AND",
"OR",
"MOD",
"IF",
"ELSE",
"END",
"UNLESS",
"FOR",
"IN",
"WHILE",
"WAIT_FOR",
"WAIT_UNTIL",
"TIMEOUT",
"AFTER",
"FANUC_USE",
"FANUC_SET",
"NAMESPACE",
"CASE",
"WHEN",
"INDIRECT",
"POSITION",
"EVAL",
"TIMER",
"TIMER_METHOD",
"RAISE",
"ABORT",
"POSITION_DATA",
"TRUE_FALSE",
"RUN",
"TP_HEADER",
"PAUSE",
"\"(\"",
"\",\"",
"\")\"",
"\":\"",
"\"[\"",
"\"]\"",
"\"{\"",
"\"}\"",
"$start",
"program",
"statements",
"statement",
"terminator",
"block",
"definition",
"namespace",
"assignment",
"motion_statement",
"jump",
"io_method",
"label_definition",
"conditional",
"inline_conditional",
"forloop",
"while_loop",
"program_call",
"use_statement",
"set_statement",
"wait_statement",
"case_statement",
"fanuc_eval",
"timer_method",
"position_data",
"raise",
"tp_header_definition",
"tp_header_value",
"var_or_indirect",
"indirectable",
"expression",
"wait_modifiers",
"wait_modifier",
"swallow_newlines",
"label",
"var",
"args",
"arg",
"number",
"string",
"indirect_thing",
"else_block",
"minmax_val",
"integer",
"case_conditions",
"case_else",
"case_condition",
"case_allowed_condition",
"case_allowed_statement",
"inlineable",
"motion_modifiers",
"motion_modifier",
"speed",
"time",
"time_seg_actions",
"optional_lpos_arg",
"definable",
"namespaces",
"factor",
"operator",
"relop",
"addop",
"mulop",
"signed_number",
"sign",
"numreg",
"output",
"input",
"posreg",
"position",
"vreg",
"argument",
"timer",
"ualm",
"sreg",
"comment",
"sn",
"hash",
"hash_attributes",
"hash_attribute",
"hash_value",
"array",
"array_values",
"array_value" ]
Racc_debug_parser = 
false

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(scanner, interpreter = TPPlus::Interpreter.new) ⇒ Parser

Returns a new instance of Parser.



15
16
17
18
19
 
# File 'lib/tp_plus/parser.rb', line 15

def initialize(scanner, interpreter = TPPlus::Interpreter.new)
  @scanner       = scanner
  @interpreter   = interpreter
  super()
end

Instance Attribute Details

#interpreter ⇒ Object (readonly)

Returns the value of attribute interpreter.



14
15
16
 
# File 'lib/tp_plus/parser.rb', line 14

def interpreter
  @interpreter
end

Instance Method Details

#_reduce_106(val, _values, result) ⇒ Object

reduce 105 omitted



1253
1254
1255
1256
 
# File 'lib/tp_plus/parser.rb', line 1253

def _reduce_106(val, _values, result)
 result = { speed: val[0], units: val[2] } 
    result
end

#_reduce_107(val, _values, result) ⇒ Object 



1258
1259
1260
1261
 
# File 'lib/tp_plus/parser.rb', line 1258

def _reduce_107(val, _values, result)
 result = { speed: val[0], units: nil } 
    result
end

#_reduce_108(val, _values, result) ⇒ Object 



1263
1264
1265
1266
 
# File 'lib/tp_plus/parser.rb', line 1263

def _reduce_108(val, _values, result)
 result = LabelDefinitionNode.new(val[0]) 
    result
end

#_reduce_109(val, _values, result) ⇒ Object 



1268
1269
1270
1271
 
# File 'lib/tp_plus/parser.rb', line 1268

def _reduce_109(val, _values, result)
 result = DefinitionNode.new(val[0],val[2]) 
    result
end

#_reduce_110(val, _values, result) ⇒ Object 



1273
1274
1275
1276
 
# File 'lib/tp_plus/parser.rb', line 1273

def _reduce_110(val, _values, result)
 result = AssignmentNode.new(val[0],val[2]) 
    result
end

#_reduce_111(val, _values, result) ⇒ Object 



1278
1279
1280
1281
1282
1283
1284
1285
 
# File 'lib/tp_plus/parser.rb', line 1278

def _reduce_111(val, _values, result)
 result = AssignmentNode.new(
                                           val[0],
                                           ExpressionNode.new(val[0],val[1],val[3])
                                         )
                                       
    result
end

#_reduce_112(val, _values, result) ⇒ Object 



1287
1288
1289
1290
1291
1292
1293
1294
 
# File 'lib/tp_plus/parser.rb', line 1287

def _reduce_112(val, _values, result)
 result = AssignmentNode.new(
                                           val[0],
                                           ExpressionNode.new(val[0],val[1],val[3])
                                         )
                                       
    result
end

#_reduce_113(val, _values, result) ⇒ Object 



1296
1297
1298
1299
 
# File 'lib/tp_plus/parser.rb', line 1296

def _reduce_113(val, _values, result)
 result = VarNode.new(val[0]) 
    result
end

#_reduce_114(val, _values, result) ⇒ Object 



1301
1302
1303
1304
 
# File 'lib/tp_plus/parser.rb', line 1301

def _reduce_114(val, _values, result)
 result = VarMethodNode.new(val[0],val[2]) 
    result
end

#_reduce_115(val, _values, result) ⇒ Object 



1306
1307
1308
1309
 
# File 'lib/tp_plus/parser.rb', line 1306

def _reduce_115(val, _values, result)
 result = NamespacedVarNode.new(val[0],val[3]) 
    result
end

#_reduce_116(val, _values, result) ⇒ Object 



1311
1312
1313
1314
 
# File 'lib/tp_plus/parser.rb', line 1311

def _reduce_116(val, _values, result)
 result = val 
    result
end

#_reduce_117(val, _values, result) ⇒ Object 



1316
1317
1318
1319
 
# File 'lib/tp_plus/parser.rb', line 1316

def _reduce_117(val, _values, result)
 result = val[0] << val[3] 
    result
end

#_reduce_118(val, _values, result) ⇒ Object 



1321
1322
1323
1324
 
# File 'lib/tp_plus/parser.rb', line 1321

def _reduce_118(val, _values, result)
 result = val[0] 
    result
end

#_reduce_119(val, _values, result) ⇒ Object 



1326
1327
1328
1329
 
# File 'lib/tp_plus/parser.rb', line 1326

def _reduce_119(val, _values, result)
 result = val[0] 
    result
end

#_reduce_120(val, _values, result) ⇒ Object 



1331
1332
1333
1334
 
# File 'lib/tp_plus/parser.rb', line 1331

def _reduce_120(val, _values, result)
 result = val[0] 
    result
end

#_reduce_121(val, _values, result) ⇒ Object 



1336
1337
1338
1339
 
# File 'lib/tp_plus/parser.rb', line 1336

def _reduce_121(val, _values, result)
 val[1].grouped = true; result = val[1] 
    result
end

#_reduce_122(val, _values, result) ⇒ Object 



1341
1342
1343
1344
 
# File 'lib/tp_plus/parser.rb', line 1341

def _reduce_122(val, _values, result)
 result = ExpressionNode.new(val[0],val[1],val[2]) 
    result
end

#_reduce_123(val, _values, result) ⇒ Object 



1346
1347
1348
1349
 
# File 'lib/tp_plus/parser.rb', line 1346

def _reduce_123(val, _values, result)
 result = ExpressionNode.new(val[0],val[1],val[2]) 
    result
end

#_reduce_124(val, _values, result) ⇒ Object 



1351
1352
1353
1354
 
# File 'lib/tp_plus/parser.rb', line 1351

def _reduce_124(val, _values, result)
 result = ExpressionNode.new(val[0],val[1],val[2]) 
    result
end

#_reduce_125(val, _values, result) ⇒ Object 



1356
1357
1358
1359
 
# File 'lib/tp_plus/parser.rb', line 1356

def _reduce_125(val, _values, result)
 result = ExpressionNode.new(val[1],val[0],nil) 
    result
end

#_reduce_143(val, _values, result) ⇒ Object

reduce 142 omitted



1395
1396
1397
1398
 
# File 'lib/tp_plus/parser.rb', line 1395

def _reduce_143(val, _values, result)
 result = IndirectNode.new(val[2].to_sym, val[4]) 
    result
end

#_reduce_144(val, _values, result) ⇒ Object 



1400
1401
1402
1403
 
# File 'lib/tp_plus/parser.rb', line 1400

def _reduce_144(val, _values, result)
 val[1] = val[1].to_i * -1 if val[0] == "-"; result = DigitNode.new(val[1]) 
    result
end

#_reduce_145(val, _values, result) ⇒ Object 



1405
1406
1407
1408
 
# File 'lib/tp_plus/parser.rb', line 1405

def _reduce_145(val, _values, result)
 val[1] = val[1].to_f * -1 if val[0] == "-"; result = RealNode.new(val[1]) 
    result
end

#_reduce_149(val, _values, result) ⇒ Object

reduce 148 omitted



1416
1417
1418
1419
 
# File 'lib/tp_plus/parser.rb', line 1416

def _reduce_149(val, _values, result)
 result = RealNode.new(val[0]) 
    result
end

#_reduce_150(val, _values, result) ⇒ Object 



1421
1422
1423
1424
 
# File 'lib/tp_plus/parser.rb', line 1421

def _reduce_150(val, _values, result)
 result = DigitNode.new(val[0]) 
    result
end

#_reduce_162(val, _values, result) ⇒ Object

reduce 161 omitted



1448
1449
1450
1451
 
# File 'lib/tp_plus/parser.rb', line 1448

def _reduce_162(val, _values, result)
 result = StringRegisterNode.new(val[2].to_i) 
    result
end

#_reduce_163(val, _values, result) ⇒ Object 



1453
1454
1455
1456
 
# File 'lib/tp_plus/parser.rb', line 1453

def _reduce_163(val, _values, result)
 result = UserAlarmNode.new(val[2].to_i) 
    result
end

#_reduce_164(val, _values, result) ⇒ Object 



1458
1459
1460
1461
 
# File 'lib/tp_plus/parser.rb', line 1458

def _reduce_164(val, _values, result)
 result = TimerNode.new(val[2].to_i) 
    result
end

#_reduce_165(val, _values, result) ⇒ Object 



1463
1464
1465
1466
 
# File 'lib/tp_plus/parser.rb', line 1463

def _reduce_165(val, _values, result)
 result = ArgumentNode.new(val[2].to_i) 
    result
end

#_reduce_166(val, _values, result) ⇒ Object 



1468
1469
1470
1471
 
# File 'lib/tp_plus/parser.rb', line 1468

def _reduce_166(val, _values, result)
 result = VisionRegisterNode.new(val[2].to_i) 
    result
end

#_reduce_167(val, _values, result) ⇒ Object 



1473
1474
1475
1476
 
# File 'lib/tp_plus/parser.rb', line 1473

def _reduce_167(val, _values, result)
 result = PositionNode.new(val[2].to_i) 
    result
end

#_reduce_168(val, _values, result) ⇒ Object 



1478
1479
1480
1481
 
# File 'lib/tp_plus/parser.rb', line 1478

def _reduce_168(val, _values, result)
 result = NumregNode.new(val[2].to_i) 
    result
end

#_reduce_169(val, _values, result) ⇒ Object 



1483
1484
1485
1486
 
# File 'lib/tp_plus/parser.rb', line 1483

def _reduce_169(val, _values, result)
 result = PosregNode.new(val[2].to_i) 
    result
end

#_reduce_170(val, _values, result) ⇒ Object 



1488
1489
1490
1491
 
# File 'lib/tp_plus/parser.rb', line 1488

def _reduce_170(val, _values, result)
 result = IONode.new(val[0], val[2].to_i) 
    result
end

#_reduce_171(val, _values, result) ⇒ Object 



1493
1494
1495
1496
 
# File 'lib/tp_plus/parser.rb', line 1493

def _reduce_171(val, _values, result)
 result = IONode.new(val[0], val[2].to_i) 
    result
end

#_reduce_172(val, _values, result) ⇒ Object 



1498
1499
1500
1501
 
# File 'lib/tp_plus/parser.rb', line 1498

def _reduce_172(val, _values, result)
 result = CommentNode.new(val[0]) 
    result
end

#_reduce_173(val, _values, result) ⇒ Object 



1503
1504
1505
1506
 
# File 'lib/tp_plus/parser.rb', line 1503

def _reduce_173(val, _values, result)
 result = TerminatorNode.new 
    result
end

#_reduce_174(val, _values, result) ⇒ Object 



1508
1509
1510
1511
 
# File 'lib/tp_plus/parser.rb', line 1508

def _reduce_174(val, _values, result)
 result = val[0] 
    result
end

#_reduce_175(val, _values, result) ⇒ Object 



1513
1514
1515
1516
 
# File 'lib/tp_plus/parser.rb', line 1513

def _reduce_175(val, _values, result)
 result = TerminatorNode.new 
    result
end

#_reduce_177(val, _values, result) ⇒ Object

reduce 176 omitted



1520
1521
1522
1523
 
# File 'lib/tp_plus/parser.rb', line 1520

def _reduce_177(val, _values, result)
 result = PositionDataNode.new(val[2]) 
    result
end

#_reduce_179(val, _values, result) ⇒ Object

reduce 178 omitted



1527
1528
1529
1530
 
# File 'lib/tp_plus/parser.rb', line 1527

def _reduce_179(val, _values, result)
 result = val[2] 
    result
end

#_reduce_180(val, _values, result) ⇒ Object 



1532
1533
1534
1535
 
# File 'lib/tp_plus/parser.rb', line 1532

def _reduce_180(val, _values, result)
 result = {} 
    result
end

#_reduce_181(val, _values, result) ⇒ Object 



1537
1538
1539
1540
 
# File 'lib/tp_plus/parser.rb', line 1537

def _reduce_181(val, _values, result)
 result = val[0] 
    result
end

#_reduce_182(val, _values, result) ⇒ Object 



1542
1543
1544
1545
 
# File 'lib/tp_plus/parser.rb', line 1542

def _reduce_182(val, _values, result)
 result = val[0].merge(val[3]) 
    result
end

#_reduce_183(val, _values, result) ⇒ Object 



1547
1548
1549
1550
 
# File 'lib/tp_plus/parser.rb', line 1547

def _reduce_183(val, _values, result)
 result = { val[0].to_sym => val[2] } 
    result
end

#_reduce_187(val, _values, result) ⇒ Object

reduce 186 omitted



1558
1559
1560
1561
 
# File 'lib/tp_plus/parser.rb', line 1558

def _reduce_187(val, _values, result)
 val[1] = val[1].to_i * -1 if val[0] == "-"; result = val[1] 
    result
end

#_reduce_188(val, _values, result) ⇒ Object 



1563
1564
1565
1566
 
# File 'lib/tp_plus/parser.rb', line 1563

def _reduce_188(val, _values, result)
 val[1] = val[1].to_f * -1 if val[0] == "-"; result = val[1] 
    result
end

#_reduce_190(val, _values, result) ⇒ Object

reduce 189 omitted



1570
1571
1572
1573
 
# File 'lib/tp_plus/parser.rb', line 1570

def _reduce_190(val, _values, result)
 result = val[2] 
    result
end

#_reduce_191(val, _values, result) ⇒ Object 



1575
1576
1577
1578
 
# File 'lib/tp_plus/parser.rb', line 1575

def _reduce_191(val, _values, result)
 result = val 
    result
end

#_reduce_192(val, _values, result) ⇒ Object 



1580
1581
1582
1583
 
# File 'lib/tp_plus/parser.rb', line 1580

def _reduce_192(val, _values, result)
 result = val[0] << val[3] 
    result
end

#_reduce_2(val, _values, result) ⇒ Object

reduce 1 omitted



877
878
879
880
 
# File 'lib/tp_plus/parser.rb', line 877

def _reduce_2(val, _values, result)
 @interpreter.nodes = val[0].flatten 
    result
end

#_reduce_3(val, _values, result) ⇒ Object 



882
883
884
885
 
# File 'lib/tp_plus/parser.rb', line 882

def _reduce_3(val, _values, result)
 result = val 
    result
end

#_reduce_31(val, _values, result) ⇒ Object

reduce 30 omitted



956
957
958
959
 
# File 'lib/tp_plus/parser.rb', line 956

def _reduce_31(val, _values, result)
 result = PauseNode.new 
    result
end

#_reduce_32(val, _values, result) ⇒ Object 



961
962
963
964
 
# File 'lib/tp_plus/parser.rb', line 961

def _reduce_32(val, _values, result)
 result = AbortNode.new 
    result
end

#_reduce_33(val, _values, result) ⇒ Object 



966
967
968
969
 
# File 'lib/tp_plus/parser.rb', line 966

def _reduce_33(val, _values, result)
 result = HeaderNode.new(val[0],val[2]) 
    result
end

#_reduce_36(val, _values, result) ⇒ Object

reduce 35 omitted



975
976
977
978
 
# File 'lib/tp_plus/parser.rb', line 975

def _reduce_36(val, _values, result)
 result = RaiseNode.new(val[1]) 
    result
end

#_reduce_37(val, _values, result) ⇒ Object 



980
981
982
983
 
# File 'lib/tp_plus/parser.rb', line 980

def _reduce_37(val, _values, result)
 result = TimerMethodNode.new(val[0],val[1]) 
    result
end

#_reduce_38(val, _values, result) ⇒ Object 



985
986
987
988
 
# File 'lib/tp_plus/parser.rb', line 985

def _reduce_38(val, _values, result)
 result = EvalNode.new(val[1]) 
    result
end

#_reduce_39(val, _values, result) ⇒ Object 



990
991
992
993
 
# File 'lib/tp_plus/parser.rb', line 990

def _reduce_39(val, _values, result)
 result = WaitForNode.new(val[2], val[4]) 
    result
end

#_reduce_4(val, _values, result) ⇒ Object 



887
888
889
890
 
# File 'lib/tp_plus/parser.rb', line 887

def _reduce_4(val, _values, result)
 result = val[0] << val[1] << val[2] 
    result
end

#_reduce_40(val, _values, result) ⇒ Object 



995
996
997
998
 
# File 'lib/tp_plus/parser.rb', line 995

def _reduce_40(val, _values, result)
 result = WaitUntilNode.new(val[2],val[4]) 
    result
end

#_reduce_42(val, _values, result) ⇒ Object

reduce 41 omitted



1002
1003
1004
1005
 
# File 'lib/tp_plus/parser.rb', line 1002

def _reduce_42(val, _values, result)
 result = val[0] 
    result
end

#_reduce_43(val, _values, result) ⇒ Object 



1007
1008
1009
1010
 
# File 'lib/tp_plus/parser.rb', line 1007

def _reduce_43(val, _values, result)
 result = val[0].merge(val[1]) 
    result
end

#_reduce_44(val, _values, result) ⇒ Object 



1012
1013
1014
1015
 
# File 'lib/tp_plus/parser.rb', line 1012

def _reduce_44(val, _values, result)
 result = { label: val[4] } 
    result
end

#_reduce_45(val, _values, result) ⇒ Object 



1017
1018
1019
1020
 
# File 'lib/tp_plus/parser.rb', line 1017

def _reduce_45(val, _values, result)
 result = { timeout: [val[4],val[6]] } 
    result
end

#_reduce_46(val, _values, result) ⇒ Object 



1022
1023
1024
1025
 
# File 'lib/tp_plus/parser.rb', line 1022

def _reduce_46(val, _values, result)
 result = val[1] 
    result
end

#_reduce_47(val, _values, result) ⇒ Object 



1027
1028
1029
1030
 
# File 'lib/tp_plus/parser.rb', line 1027

def _reduce_47(val, _values, result)
 result = UseNode.new(val[0],val[1]) 
    result
end

#_reduce_48(val, _values, result) ⇒ Object 



1032
1033
1034
1035
 
# File 'lib/tp_plus/parser.rb', line 1032

def _reduce_48(val, _values, result)
 result = SetNode.new(val[0],val[1],val[3]) 
    result
end

#_reduce_49(val, _values, result) ⇒ Object 



1037
1038
1039
1040
 
# File 'lib/tp_plus/parser.rb', line 1037

def _reduce_49(val, _values, result)
 result = SetNode.new(val[0],nil,val[1]) 
    result
end

#_reduce_5(val, _values, result) ⇒ Object 



892
893
894
895
 
# File 'lib/tp_plus/parser.rb', line 892

def _reduce_5(val, _values, result)
 result = val[0] << val[1] 
    result
end

#_reduce_50(val, _values, result) ⇒ Object 



1042
1043
1044
1045
 
# File 'lib/tp_plus/parser.rb', line 1042

def _reduce_50(val, _values, result)
 result = CallNode.new(val[0],val[2]) 
    result
end

#_reduce_51(val, _values, result) ⇒ Object 



1047
1048
1049
1050
 
# File 'lib/tp_plus/parser.rb', line 1047

def _reduce_51(val, _values, result)
 result = CallNode.new(val[1],val[3],async: true) 
    result
end

#_reduce_52(val, _values, result) ⇒ Object 



1052
1053
1054
1055
 
# File 'lib/tp_plus/parser.rb', line 1052

def _reduce_52(val, _values, result)
 result = [val[0]] 
    result
end

#_reduce_53(val, _values, result) ⇒ Object 



1057
1058
1059
1060
 
# File 'lib/tp_plus/parser.rb', line 1057

def _reduce_53(val, _values, result)
 result = val[0] << val[2] 
    result
end

#_reduce_54(val, _values, result) ⇒ Object 



1062
1063
1064
1065
 
# File 'lib/tp_plus/parser.rb', line 1062

def _reduce_54(val, _values, result)
 result = [] 
    result
end

#_reduce_58(val, _values, result) ⇒ Object

reduce 57 omitted



1073
1074
1075
1076
 
# File 'lib/tp_plus/parser.rb', line 1073

def _reduce_58(val, _values, result)
 result = StringNode.new(val[0]) 
    result
end

#_reduce_59(val, _values, result) ⇒ Object 



1078
1079
1080
1081
 
# File 'lib/tp_plus/parser.rb', line 1078

def _reduce_59(val, _values, result)
 result = IOMethodNode.new(val[0],val[1]) 
    result
end

#_reduce_6(val, _values, result) ⇒ Object 



897
898
899
900
 
# File 'lib/tp_plus/parser.rb', line 897

def _reduce_6(val, _values, result)
 result = [val[0]] << val[1] 
    result
end

#_reduce_60(val, _values, result) ⇒ Object 



1083
1084
1085
1086
 
# File 'lib/tp_plus/parser.rb', line 1083

def _reduce_60(val, _values, result)
 result = IOMethodNode.new(val[0],val[2]) 
    result
end

#_reduce_61(val, _values, result) ⇒ Object 



1088
1089
1090
1091
 
# File 'lib/tp_plus/parser.rb', line 1088

def _reduce_61(val, _values, result)
 result = IOMethodNode.new(val[0],val[2],{ pulse_time: val[4], pulse_units: val[6] }) 
    result
end

#_reduce_64(val, _values, result) ⇒ Object

reduce 63 omitted



1097
1098
1099
1100
 
# File 'lib/tp_plus/parser.rb', line 1097

def _reduce_64(val, _values, result)
 result = JumpNode.new(val[1]) 
    result
end

#_reduce_65(val, _values, result) ⇒ Object 



1102
1103
1104
1105
 
# File 'lib/tp_plus/parser.rb', line 1102

def _reduce_65(val, _values, result)
 result = ConditionalNode.new("if",val[1],val[2],val[3]) 
    result
end

#_reduce_66(val, _values, result) ⇒ Object 



1107
1108
1109
1110
 
# File 'lib/tp_plus/parser.rb', line 1107

def _reduce_66(val, _values, result)
 result = ConditionalNode.new("unless",val[1],val[2],val[3]) 
    result
end

#_reduce_67(val, _values, result) ⇒ Object 



1112
1113
1114
1115
 
# File 'lib/tp_plus/parser.rb', line 1112

def _reduce_67(val, _values, result)
 result = ForNode.new(val[1],val[4],val[6],val[8]) 
    result
end

#_reduce_68(val, _values, result) ⇒ Object 



1117
1118
1119
1120
 
# File 'lib/tp_plus/parser.rb', line 1117

def _reduce_68(val, _values, result)
 result = WhileNode.new(val[1],val[2]) 
    result
end

#_reduce_7(val, _values, result) ⇒ Object 



902
903
904
905
 
# File 'lib/tp_plus/parser.rb', line 902

def _reduce_7(val, _values, result)
 result = [val[0]] 
    result
end

#_reduce_71(val, _values, result) ⇒ Object

reduce 70 omitted



1126
1127
1128
1129
 
# File 'lib/tp_plus/parser.rb', line 1126

def _reduce_71(val, _values, result)
 result = NamespaceNode.new(val[1],val[2]) 
    result
end

#_reduce_72(val, _values, result) ⇒ Object 



1131
1132
1133
1134
 
# File 'lib/tp_plus/parser.rb', line 1131

def _reduce_72(val, _values, result)
 result = CaseNode.new(val[1],val[3],val[4]) 
    result
end

#_reduce_73(val, _values, result) ⇒ Object 



1136
1137
1138
1139
 
# File 'lib/tp_plus/parser.rb', line 1136

def _reduce_73(val, _values, result)
 result = val 
    result
end

#_reduce_74(val, _values, result) ⇒ Object 



1141
1142
1143
1144
 
# File 'lib/tp_plus/parser.rb', line 1141

def _reduce_74(val, _values, result)
 result = val[0] << val[1] << val[2] 
    result
end

#_reduce_75(val, _values, result) ⇒ Object 



1146
1147
1148
1149
 
# File 'lib/tp_plus/parser.rb', line 1146

def _reduce_75(val, _values, result)
 result = CaseConditionNode.new(val[1],val[3]) 
    result
end

#_reduce_78(val, _values, result) ⇒ Object

reduce 77 omitted



1155
1156
1157
1158
 
# File 'lib/tp_plus/parser.rb', line 1155

def _reduce_78(val, _values, result)
 result = CaseConditionNode.new(nil,val[2]) 
    result
end

#_reduce_82(val, _values, result) ⇒ Object

reduce 81 omitted



1166
1167
1168
1169
 
# File 'lib/tp_plus/parser.rb', line 1166

def _reduce_82(val, _values, result)
 result = InlineConditionalNode.new("if",val[2],val[0]) 
    result
end

#_reduce_83(val, _values, result) ⇒ Object 



1171
1172
1173
1174
 
# File 'lib/tp_plus/parser.rb', line 1171

def _reduce_83(val, _values, result)
 result = InlineConditionalNode.new("unless",val[2],val[0]) 
    result
end

#_reduce_88(val, _values, result) ⇒ Object

reduce 87 omitted



1184
1185
1186
1187
 
# File 'lib/tp_plus/parser.rb', line 1184

def _reduce_88(val, _values, result)
 result = val[1] 
    result
end

#_reduce_89(val, _values, result) ⇒ Object 



1189
1190
1191
1192
 
# File 'lib/tp_plus/parser.rb', line 1189

def _reduce_89(val, _values, result)
 result = [] 
    result
end

#_reduce_9(val, _values, result) ⇒ Object

reduce 8 omitted



909
910
911
912
 
# File 'lib/tp_plus/parser.rb', line 909

def _reduce_9(val, _values, result)
 result = val[0] 
    result
end

#_reduce_90(val, _values, result) ⇒ Object 



1194
1195
1196
1197
 
# File 'lib/tp_plus/parser.rb', line 1194

def _reduce_90(val, _values, result)
 result = MotionNode.new(val[0],val[5],val[7]) 
    result
end

#_reduce_91(val, _values, result) ⇒ Object 



1199
1200
1201
1202
 
# File 'lib/tp_plus/parser.rb', line 1199

def _reduce_91(val, _values, result)
 result = val 
    result
end

#_reduce_92(val, _values, result) ⇒ Object 



1204
1205
1206
1207
 
# File 'lib/tp_plus/parser.rb', line 1204

def _reduce_92(val, _values, result)
 result = val[0] << val[1] 
    result
end

#_reduce_93(val, _values, result) ⇒ Object 



1209
1210
1211
1212
 
# File 'lib/tp_plus/parser.rb', line 1209

def _reduce_93(val, _values, result)
 result = SpeedNode.new(val[4]) 
    result
end

#_reduce_94(val, _values, result) ⇒ Object 



1214
1215
1216
1217
 
# File 'lib/tp_plus/parser.rb', line 1214

def _reduce_94(val, _values, result)
 result = TerminationNode.new(val[4]) 
    result
end

#_reduce_95(val, _values, result) ⇒ Object 



1219
1220
1221
1222
 
# File 'lib/tp_plus/parser.rb', line 1219

def _reduce_95(val, _values, result)
 result = OffsetNode.new(val[2],val[4]) 
    result
end

#_reduce_96(val, _values, result) ⇒ Object 



1224
1225
1226
1227
 
# File 'lib/tp_plus/parser.rb', line 1224

def _reduce_96(val, _values, result)
 result = TimeNode.new(val[2],val[4],val[6]) 
    result
end

#_reduce_97(val, _values, result) ⇒ Object 



1229
1230
1231
1232
 
# File 'lib/tp_plus/parser.rb', line 1229

def _reduce_97(val, _values, result)
 result = SkipNode.new(val[4],val[5]) 
    result
end

#_reduce_98(val, _values, result) ⇒ Object 



1234
1235
1236
1237
 
# File 'lib/tp_plus/parser.rb', line 1234

def _reduce_98(val, _values, result)
 result = val[1] 
    result
end

#_reduce_none(val, _values, result) ⇒ Object

reduce 193 omitted



1587
1588
1589
 
# File 'lib/tp_plus/parser.rb', line 1587

def _reduce_none(val, _values, result)
  val[0]
end

#next_token ⇒ Object 



21
22
23
24
25
26
27
 
# File 'lib/tp_plus/parser.rb', line 21

def next_token
  t = @scanner.next_token
  @interpreter.line_count += 1 if t && t[0] == :NEWLINE

  #puts t.inspect

  t
end

#parse ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/tp_plus/parser.rb', line 29

def parse
  do_parse
  @interpreter
rescue Racc::ParseError => e
  raise "Parse error on line #{@interpreter.line_count+1}: #{e}"
end