Class: TPPlus::Parser

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

Defined Under Namespace

Classes: ParseError

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",
"ACC",
"TERM",
"OFFSET",
"SKIP",
"GROUP",
"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",
"SET_SKIP_CONDITION",
"NAMESPACE",
"CASE",
"WHEN",
"INDIRECT",
"POSITION",
"EVAL",
"TIMER",
"TIMER_METHOD",
"RAISE",
"ABORT",
"POSITION_DATA",
"TRUE_FALSE",
"RUN",
"TP_HEADER",
"PAUSE",
"LPAREN",
"RPAREN",
"COLON",
"COMMA",
"LBRACK",
"RBRACK",
"LBRACE",
"RBRACE",
"LABEL",
"ADDRESS",
"false",
"$start",
"program",
"statements",
"statement",
"terminator",
"block",
"optional_newline",
"comment",
"definition",
"namespace",
"motion_statement",
"label_definition",
"address",
"conditional",
"inline_conditional",
"forloop",
"while_loop",
"use_statement",
"set_skip_statement",
"wait_statement",
"case_statement",
"fanuc_eval",
"timer_method",
"position_data",
"raise",
"tp_header_definition",
"empty_stmt",
"tp_header_value",
"var_or_indirect",
"indirectable",
"expression",
"wait_modifier",
"timeout_modifier",
"after_modifier",
"swallow_newlines",
"label",
"program_call",
"args",
"arg",
"number",
"var",
"string",
"io_method",
"indirect_thing",
"jump",
"else_block",
"int_or_var",
"integer",
"case_conditions",
"case_else",
"case_condition",
"case_allowed_condition",
"case_allowed_statement",
"inlineable",
"assignment",
"motion_modifiers",
"motion_modifier",
"speed",
"valid_terminations",
"time",
"time_seg_actions",
"optional_lpos_arg",
"definable",
"var_without_namespaces",
"var_with_namespaces",
"var_method_modifiers",
"namespaces",
"var_method_modifier",
"ns",
"unary_expression",
"binary_expression",
"factor",
"operator",
"signed_number",
"paren_expr",
"sign",
"numreg",
"output",
"input",
"posreg",
"position",
"vreg",
"argument",
"timer",
"ualm",
"sreg",
"sn",
"hash",
"hash_attributes",
"hash_attribute",
"hash_value",
"array",
"optional_sign",
"array_values",
"array_value" ]
Racc_debug_parser = 
true

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_1(val, _values, result) ⇒ Object

reduce 0 omitted



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

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

#_reduce_101(val, _values, result) ⇒ Object

reduce 100 omitted

Raises:

  • (Racc::ParseError) 


1249
1250
1251
1252
1253
1254
1255
 
# File 'lib/tp_plus/parser.rb', line 1249

def _reduce_101(val, _values, result)
                                         raise Racc::ParseError, sprintf("\ninvalid termination type: (%s)", val[1]) if val[1] != 1

                                         result = DigitNode.new(val[1].to_i * -1)
                                       
    result
end

#_reduce_102(val, _values, result) ⇒ Object 



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

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

#_reduce_110(val, _values, result) ⇒ Object

reduce 109 omitted



1276
1277
1278
1279
 
# File 'lib/tp_plus/parser.rb', line 1276

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

#_reduce_111(val, _values, result) ⇒ Object 



1281
1282
1283
1284
 
# File 'lib/tp_plus/parser.rb', line 1281

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

#_reduce_112(val, _values, result) ⇒ Object 



1286
1287
1288
1289
 
# File 'lib/tp_plus/parser.rb', line 1286

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

#_reduce_113(val, _values, result) ⇒ Object 



1291
1292
1293
1294
 
# File 'lib/tp_plus/parser.rb', line 1291

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

#_reduce_114(val, _values, result) ⇒ Object 



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

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

#_reduce_115(val, _values, result) ⇒ Object 



1301
1302
1303
1304
1305
1306
1307
1308
 
# File 'lib/tp_plus/parser.rb', line 1301

def _reduce_115(val, _values, result)
 result = AssignmentNode.new(
                                           val[0],
                                           ExpressionNode.new(val[0],"+",val[3])
                                         )
                                       
    result
end

#_reduce_116(val, _values, result) ⇒ Object 



1310
1311
1312
1313
1314
1315
1316
1317
 
# File 'lib/tp_plus/parser.rb', line 1310

def _reduce_116(val, _values, result)
 result = AssignmentNode.new(
                                           val[0],
                                           ExpressionNode.new(val[0],"-",val[3])
                                         )
                                       
    result
end

#_reduce_119(val, _values, result) ⇒ Object

reduce 118 omitted



1323
1324
1325
1326
 
# File 'lib/tp_plus/parser.rb', line 1323

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

#_reduce_120(val, _values, result) ⇒ Object 



1328
1329
1330
1331
 
# File 'lib/tp_plus/parser.rb', line 1328

def _reduce_120(val, _values, result)
 result = VarMethodNode.new(val[0],val[1]) 
    result
end

#_reduce_121(val, _values, result) ⇒ Object 



1333
1334
1335
1336
 
# File 'lib/tp_plus/parser.rb', line 1333

def _reduce_121(val, _values, result)
 result = NamespacedVarNode.new(val[0],val[1]) 
    result
end

#_reduce_122(val, _values, result) ⇒ Object 



1338
1339
1340
1341
 
# File 'lib/tp_plus/parser.rb', line 1338

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

#_reduce_123(val, _values, result) ⇒ Object 



1343
1344
1345
1346
 
# File 'lib/tp_plus/parser.rb', line 1343

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

#_reduce_124(val, _values, result) ⇒ Object 



1348
1349
1350
1351
 
# File 'lib/tp_plus/parser.rb', line 1348

def _reduce_124(val, _values, result)
 result = { method: val[2] } 
    result
end

#_reduce_125(val, _values, result) ⇒ Object 



1353
1354
1355
1356
 
# File 'lib/tp_plus/parser.rb', line 1353

def _reduce_125(val, _values, result)
 result = { group: val[4] } 
    result
end

#_reduce_126(val, _values, result) ⇒ Object 



1358
1359
1360
1361
 
# File 'lib/tp_plus/parser.rb', line 1358

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

#_reduce_127(val, _values, result) ⇒ Object 



1363
1364
1365
1366
 
# File 'lib/tp_plus/parser.rb', line 1363

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

#_reduce_128(val, _values, result) ⇒ Object 



1368
1369
1370
1371
 
# File 'lib/tp_plus/parser.rb', line 1368

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

#_reduce_131(val, _values, result) ⇒ Object

reduce 130 omitted



1377
1378
1379
1380
 
# File 'lib/tp_plus/parser.rb', line 1377

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

#_reduce_133(val, _values, result) ⇒ Object

reduce 132 omitted



1384
1385
1386
1387
 
# File 'lib/tp_plus/parser.rb', line 1384

def _reduce_133(val, _values, result)
 result = ExpressionNode.new(val[1], "!", nil) 
    result
end

#_reduce_134(val, _values, result) ⇒ Object 



1389
1390
1391
1392
 
# File 'lib/tp_plus/parser.rb', line 1389

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

#_reduce_135(val, _values, result) ⇒ Object 



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

def _reduce_135(val, _values, result)
 result = "==" 
    result
end

#_reduce_136(val, _values, result) ⇒ Object 



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

def _reduce_136(val, _values, result)
 result = "<>" 
    result
end

#_reduce_137(val, _values, result) ⇒ Object 



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

def _reduce_137(val, _values, result)
 result = "<" 
    result
end

#_reduce_138(val, _values, result) ⇒ Object 



1409
1410
1411
1412
 
# File 'lib/tp_plus/parser.rb', line 1409

def _reduce_138(val, _values, result)
 result = ">" 
    result
end

#_reduce_139(val, _values, result) ⇒ Object 



1414
1415
1416
1417
 
# File 'lib/tp_plus/parser.rb', line 1414

def _reduce_139(val, _values, result)
 result = ">=" 
    result
end

#_reduce_140(val, _values, result) ⇒ Object 



1419
1420
1421
1422
 
# File 'lib/tp_plus/parser.rb', line 1419

def _reduce_140(val, _values, result)
 result = "<=" 
    result
end

#_reduce_141(val, _values, result) ⇒ Object 



1424
1425
1426
1427
 
# File 'lib/tp_plus/parser.rb', line 1424

def _reduce_141(val, _values, result)
 result = "+" 
    result
end

#_reduce_142(val, _values, result) ⇒ Object 



1429
1430
1431
1432
 
# File 'lib/tp_plus/parser.rb', line 1429

def _reduce_142(val, _values, result)
 result = "-" 
    result
end

#_reduce_143(val, _values, result) ⇒ Object 



1434
1435
1436
1437
 
# File 'lib/tp_plus/parser.rb', line 1434

def _reduce_143(val, _values, result)
 result = "||" 
    result
end

#_reduce_144(val, _values, result) ⇒ Object 



1439
1440
1441
1442
 
# File 'lib/tp_plus/parser.rb', line 1439

def _reduce_144(val, _values, result)
 result = "*" 
    result
end

#_reduce_145(val, _values, result) ⇒ Object 



1444
1445
1446
1447
 
# File 'lib/tp_plus/parser.rb', line 1444

def _reduce_145(val, _values, result)
 result = "/" 
    result
end

#_reduce_146(val, _values, result) ⇒ Object 



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

def _reduce_146(val, _values, result)
 result = "DIV" 
    result
end

#_reduce_147(val, _values, result) ⇒ Object 



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

def _reduce_147(val, _values, result)
 result = "%" 
    result
end

#_reduce_148(val, _values, result) ⇒ Object 



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

def _reduce_148(val, _values, result)
 result = "&&" 
    result
end

#_reduce_154(val, _values, result) ⇒ Object

reduce 153 omitted



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

def _reduce_154(val, _values, result)
 result = ParenExpressionNode.new(val[1]) 
    result
end

#_reduce_155(val, _values, result) ⇒ Object 



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

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

#_reduce_156(val, _values, result) ⇒ Object 



1484
1485
1486
1487
1488
1489
 
# File 'lib/tp_plus/parser.rb', line 1484

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

#_reduce_157(val, _values, result) ⇒ Object 



1491
1492
1493
1494
 
# File 'lib/tp_plus/parser.rb', line 1491

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

#_reduce_158(val, _values, result) ⇒ Object 



1496
1497
1498
1499
 
# File 'lib/tp_plus/parser.rb', line 1496

def _reduce_158(val, _values, result)
 result = "-" 
    result
end

#_reduce_160(val, _values, result) ⇒ Object

reduce 159 omitted



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

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

#_reduce_161(val, _values, result) ⇒ Object 



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

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

#_reduce_174(val, _values, result) ⇒ Object

reduce 173 omitted



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

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

#_reduce_175(val, _values, result) ⇒ Object 



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

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

#_reduce_176(val, _values, result) ⇒ Object 



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

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

#_reduce_177(val, _values, result) ⇒ Object 



1552
1553
1554
1555
 
# File 'lib/tp_plus/parser.rb', line 1552

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

#_reduce_178(val, _values, result) ⇒ Object 



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

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

#_reduce_179(val, _values, result) ⇒ Object 



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

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

#_reduce_180(val, _values, result) ⇒ Object 



1567
1568
1569
1570
 
# File 'lib/tp_plus/parser.rb', line 1567

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

#_reduce_181(val, _values, result) ⇒ Object 



1572
1573
1574
1575
 
# File 'lib/tp_plus/parser.rb', line 1572

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

#_reduce_182(val, _values, result) ⇒ Object 



1577
1578
1579
1580
 
# File 'lib/tp_plus/parser.rb', line 1577

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

#_reduce_183(val, _values, result) ⇒ Object 



1582
1583
1584
1585
 
# File 'lib/tp_plus/parser.rb', line 1582

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

#_reduce_184(val, _values, result) ⇒ Object 



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

def _reduce_184(val, _values, result)
 result = AddressNode.new(val[0]) 
    result
end

#_reduce_185(val, _values, result) ⇒ Object 



1592
1593
1594
1595
 
# File 'lib/tp_plus/parser.rb', line 1592

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

#_reduce_186(val, _values, result) ⇒ Object 



1597
1598
1599
1600
 
# File 'lib/tp_plus/parser.rb', line 1597

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

#_reduce_187(val, _values, result) ⇒ Object 



1602
1603
1604
1605
 
# File 'lib/tp_plus/parser.rb', line 1602

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

#_reduce_190(val, _values, result) ⇒ Object

reduce 189 omitted



1611
1612
1613
1614
 
# File 'lib/tp_plus/parser.rb', line 1611

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

#_reduce_192(val, _values, result) ⇒ Object

reduce 191 omitted



1618
1619
1620
1621
 
# File 'lib/tp_plus/parser.rb', line 1618

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

#_reduce_194(val, _values, result) ⇒ Object

reduce 193 omitted



1625
1626
1627
1628
 
# File 'lib/tp_plus/parser.rb', line 1625

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

#_reduce_195(val, _values, result) ⇒ Object 



1630
1631
1632
1633
 
# File 'lib/tp_plus/parser.rb', line 1630

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

#_reduce_196(val, _values, result) ⇒ Object 



1635
1636
1637
1638
 
# File 'lib/tp_plus/parser.rb', line 1635

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

#_reduce_197(val, _values, result) ⇒ Object 



1640
1641
1642
1643
 
# File 'lib/tp_plus/parser.rb', line 1640

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

#_reduce_198(val, _values, result) ⇒ Object 



1645
1646
1647
1648
 
# File 'lib/tp_plus/parser.rb', line 1645

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

#_reduce_202(val, _values, result) ⇒ Object

reduce 201 omitted



1656
1657
1658
1659
 
# File 'lib/tp_plus/parser.rb', line 1656

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

#_reduce_203(val, _values, result) ⇒ Object 



1661
1662
1663
1664
 
# File 'lib/tp_plus/parser.rb', line 1661

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

#_reduce_204(val, _values, result) ⇒ Object 



1666
1667
1668
1669
 
# File 'lib/tp_plus/parser.rb', line 1666

def _reduce_204(val, _values, result)
 result = val[0] == "true" 
    result
end

#_reduce_207(val, _values, result) ⇒ Object

reduce 206 omitted



1675
1676
1677
1678
 
# File 'lib/tp_plus/parser.rb', line 1675

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

#_reduce_208(val, _values, result) ⇒ Object 



1680
1681
1682
1683
 
# File 'lib/tp_plus/parser.rb', line 1680

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

#_reduce_209(val, _values, result) ⇒ Object 



1685
1686
1687
1688
 
# File 'lib/tp_plus/parser.rb', line 1685

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

#_reduce_28(val, _values, result) ⇒ Object

reduce 27 omitted



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

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

#_reduce_29(val, _values, result) ⇒ Object 



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

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

#_reduce_3(val, _values, result) ⇒ Object

reduce 2 omitted



893
894
895
896
897
898
 
# File 'lib/tp_plus/parser.rb', line 893

def _reduce_3(val, _values, result)
                                          result = [val[0]]
                                          result << val[1] unless val[1].nil?
                                        
    result
end

#_reduce_30(val, _values, result) ⇒ Object 



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

def _reduce_30(val, _values, result)
 result = EmptyStmtNode.new() 
    result
end

#_reduce_31(val, _values, result) ⇒ Object 



971
972
973
974
 
# File 'lib/tp_plus/parser.rb', line 971

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

#_reduce_34(val, _values, result) ⇒ Object

reduce 33 omitted



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

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

#_reduce_35(val, _values, result) ⇒ Object 



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

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

#_reduce_36(val, _values, result) ⇒ Object 



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

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

#_reduce_37(val, _values, result) ⇒ Object 



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

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

#_reduce_38(val, _values, result) ⇒ Object 



1000
1001
1002
1003
 
# File 'lib/tp_plus/parser.rb', line 1000

def _reduce_38(val, _values, result)
 result = WaitUntilNode.new(val[2], nil) 
    result
end

#_reduce_39(val, _values, result) ⇒ Object 



1005
1006
1007
1008
 
# File 'lib/tp_plus/parser.rb', line 1005

def _reduce_39(val, _values, result)
 result = WaitUntilNode.new(val[2],val[5]) 
    result
end

#_reduce_4(val, _values, result) ⇒ Object 



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

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

#_reduce_40(val, _values, result) ⇒ Object 



1010
1011
1012
1013
 
# File 'lib/tp_plus/parser.rb', line 1010

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

#_reduce_43(val, _values, result) ⇒ Object

reduce 42 omitted



1019
1020
1021
1022
 
# File 'lib/tp_plus/parser.rb', line 1019

def _reduce_43(val, _values, result)
 result = { label: val[3] } 
    result
end

#_reduce_44(val, _values, result) ⇒ Object 



1024
1025
1026
1027
 
# File 'lib/tp_plus/parser.rb', line 1024

def _reduce_44(val, _values, result)
 result = { timeout: [val[3],val[5]] } 
    result
end

#_reduce_45(val, _values, result) ⇒ Object 



1029
1030
1031
1032
 
# File 'lib/tp_plus/parser.rb', line 1029

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

#_reduce_46(val, _values, result) ⇒ Object 



1034
1035
1036
1037
 
# File 'lib/tp_plus/parser.rb', line 1034

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

#_reduce_47(val, _values, result) ⇒ Object 



1039
1040
1041
1042
 
# File 'lib/tp_plus/parser.rb', line 1039

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

#_reduce_48(val, _values, result) ⇒ Object 



1044
1045
1046
1047
 
# File 'lib/tp_plus/parser.rb', line 1044

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

#_reduce_49(val, _values, result) ⇒ Object 



1049
1050
1051
1052
 
# File 'lib/tp_plus/parser.rb', line 1049

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

#_reduce_5(val, _values, result) ⇒ Object 



907
908
909
910
 
# File 'lib/tp_plus/parser.rb', line 907

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

#_reduce_50(val, _values, result) ⇒ Object 



1054
1055
1056
1057
 
# File 'lib/tp_plus/parser.rb', line 1054

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

#_reduce_51(val, _values, result) ⇒ Object 



1059
1060
1061
1062
 
# File 'lib/tp_plus/parser.rb', line 1059

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

#_reduce_52(val, _values, result) ⇒ Object 



1064
1065
1066
1067
 
# File 'lib/tp_plus/parser.rb', line 1064

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

#_reduce_57(val, _values, result) ⇒ Object

reduce 56 omitted



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

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

#_reduce_58(val, _values, result) ⇒ Object 



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

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

#_reduce_59(val, _values, result) ⇒ Object 



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

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

#_reduce_60(val, _values, result) ⇒ Object 



1092
1093
1094
1095
 
# File 'lib/tp_plus/parser.rb', line 1092

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

#_reduce_63(val, _values, result) ⇒ Object

reduce 62 omitted



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

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

#_reduce_64(val, _values, result) ⇒ Object 



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

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

#_reduce_65(val, _values, result) ⇒ Object 



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

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

#_reduce_66(val, _values, result) ⇒ Object 



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

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

#_reduce_67(val, _values, result) ⇒ Object 



1121
1122
1123
1124
 
# File 'lib/tp_plus/parser.rb', line 1121

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

#_reduce_70(val, _values, result) ⇒ Object

reduce 69 omitted



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

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

#_reduce_71(val, _values, result) ⇒ Object 



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

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

#_reduce_72(val, _values, result) ⇒ Object 



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

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

#_reduce_73(val, _values, result) ⇒ Object 



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

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

#_reduce_74(val, _values, result) ⇒ Object 



1150
1151
1152
1153
 
# File 'lib/tp_plus/parser.rb', line 1150

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

#_reduce_77(val, _values, result) ⇒ Object

reduce 76 omitted



1159
1160
1161
1162
 
# File 'lib/tp_plus/parser.rb', line 1159

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

#_reduce_82(val, _values, result) ⇒ Object

reduce 81 omitted



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

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

#_reduce_83(val, _values, result) ⇒ Object 



1177
1178
1179
1180
 
# File 'lib/tp_plus/parser.rb', line 1177

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

#_reduce_88(val, _values, result) ⇒ Object

reduce 87 omitted



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

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

#_reduce_89(val, _values, result) ⇒ Object 



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

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

#_reduce_90(val, _values, result) ⇒ Object 



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

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

#_reduce_91(val, _values, result) ⇒ Object 



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

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

#_reduce_92(val, _values, result) ⇒ Object 



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

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

#_reduce_93(val, _values, result) ⇒ Object 



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

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

#_reduce_94(val, _values, result) ⇒ Object 



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

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

#_reduce_95(val, _values, result) ⇒ Object 



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

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

#_reduce_96(val, _values, result) ⇒ Object 



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

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

#_reduce_97(val, _values, result) ⇒ Object 



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

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

#_reduce_98(val, _values, result) ⇒ Object 



1240
1241
1242
1243
 
# File 'lib/tp_plus/parser.rb', line 1240

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

#_reduce_none(val, _values, result) ⇒ Object

reduce 210 omitted



1692
1693
1694
 
# File 'lib/tp_plus/parser.rb', line 1692

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

#on_error(t, val, vstack) ⇒ Object

Raises:



36
37
38
39
 
# File 'lib/tp_plus/parser.rb', line 36

def on_error(t, val, vstack)
  raise ParseError, sprintf("Parse error on line #{@scanner.tok_line} column #{@scanner.tok_col}: %s (%s)",
                              val.inspect, token_to_str(t) || '?')
end

#parse ⇒ Object 



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

def parse
  #@yydebug =true

  do_parse
  @interpreter
end