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",
"RETURN",
"POSITION_DATA",
"TRUE_FALSE",
"RUN",
"TP_HEADER",
"PAUSE",
"LPAREN",
"RPAREN",
"COLON",
"COMMA",
"LBRACK",
"RBRACK",
"LBRACE",
"RBRACE",
"LABEL",
"ADDRESS",
"LPOS",
"JPOS",
"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",
"lpos_or_jpos",
"empty_stmt",
"var",
"tp_header_value",
"var_or_indirect",
"indirectable",
"expression",
"wait_modifier",
"timeout_modifier",
"after_modifier",
"swallow_newlines",
"label",
"program_call",
"args",
"arg",
"number",
"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",
"signed_var",
"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



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

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

#_reduce_100(val, _values, result) ⇒ Object 



1271
1272
1273
1274
 
# File 'lib/tp_plus/parser.rb', line 1271

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

#_reduce_101(val, _values, result) ⇒ Object 



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

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

#_reduce_102(val, _values, result) ⇒ Object 



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

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

#_reduce_105(val, _values, result) ⇒ Object

reduce 104 omitted

Raises:

  • (Racc::ParseError) 


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

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



1298
1299
1300
1301
 
# File 'lib/tp_plus/parser.rb', line 1298

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

#_reduce_114(val, _values, result) ⇒ Object

reduce 113 omitted



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

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

#_reduce_115(val, _values, result) ⇒ Object 



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

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

#_reduce_116(val, _values, result) ⇒ Object 



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

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

#_reduce_117(val, _values, result) ⇒ Object 



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

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

#_reduce_118(val, _values, result) ⇒ Object 



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

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

#_reduce_119(val, _values, result) ⇒ Object 



1342
1343
1344
1345
1346
1347
1348
1349
 
# File 'lib/tp_plus/parser.rb', line 1342

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

#_reduce_120(val, _values, result) ⇒ Object 



1351
1352
1353
1354
1355
1356
1357
1358
 
# File 'lib/tp_plus/parser.rb', line 1351

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

#_reduce_123(val, _values, result) ⇒ Object

reduce 122 omitted



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

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

#_reduce_124(val, _values, result) ⇒ Object 



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

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

#_reduce_125(val, _values, result) ⇒ Object 



1374
1375
1376
1377
 
# File 'lib/tp_plus/parser.rb', line 1374

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

#_reduce_126(val, _values, result) ⇒ Object 



1379
1380
1381
1382
 
# File 'lib/tp_plus/parser.rb', line 1379

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

#_reduce_127(val, _values, result) ⇒ Object 



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

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

#_reduce_128(val, _values, result) ⇒ Object 



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

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

#_reduce_129(val, _values, result) ⇒ Object 



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

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

#_reduce_130(val, _values, result) ⇒ Object 



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

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

#_reduce_131(val, _values, result) ⇒ Object 



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

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

#_reduce_132(val, _values, result) ⇒ Object 



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

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

#_reduce_135(val, _values, result) ⇒ Object

reduce 134 omitted



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

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

#_reduce_137(val, _values, result) ⇒ Object

reduce 136 omitted



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

def _reduce_137(val, _values, result)
 result = UnaryExpressionNode.new("!",val[1]) 
    result
end

#_reduce_138(val, _values, result) ⇒ Object 



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

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

#_reduce_139(val, _values, result) ⇒ Object 



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

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

#_reduce_140(val, _values, result) ⇒ Object 



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

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

#_reduce_141(val, _values, result) ⇒ Object 



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

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

#_reduce_142(val, _values, result) ⇒ Object 



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

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

#_reduce_143(val, _values, result) ⇒ Object 



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

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

#_reduce_144(val, _values, result) ⇒ Object 



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

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

#_reduce_145(val, _values, result) ⇒ Object 



1465
1466
1467
1468
 
# File 'lib/tp_plus/parser.rb', line 1465

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

#_reduce_146(val, _values, result) ⇒ Object 



1470
1471
1472
1473
 
# File 'lib/tp_plus/parser.rb', line 1470

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

#_reduce_147(val, _values, result) ⇒ Object 



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

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

#_reduce_148(val, _values, result) ⇒ Object 



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

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

#_reduce_149(val, _values, result) ⇒ Object 



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

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

#_reduce_150(val, _values, result) ⇒ Object 



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

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

#_reduce_151(val, _values, result) ⇒ Object 



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

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

#_reduce_152(val, _values, result) ⇒ Object 



1500
1501
1502
1503
 
# File 'lib/tp_plus/parser.rb', line 1500

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

#_reduce_159(val, _values, result) ⇒ Object

reduce 158 omitted



1517
1518
1519
1520
 
# File 'lib/tp_plus/parser.rb', line 1517

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

#_reduce_160(val, _values, result) ⇒ Object 



1522
1523
1524
1525
 
# File 'lib/tp_plus/parser.rb', line 1522

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

#_reduce_161(val, _values, result) ⇒ Object 



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

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

#_reduce_162(val, _values, result) ⇒ Object 



1534
1535
1536
1537
 
# File 'lib/tp_plus/parser.rb', line 1534

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

#_reduce_163(val, _values, result) ⇒ Object 



1539
1540
1541
1542
1543
1544
1545
1546
 
# File 'lib/tp_plus/parser.rb', line 1539

def _reduce_163(val, _values, result)
 result = ExpressionNode.new(
                                          val[1],
                                          "*",
                                          DigitNode.new(-1)
                                        ) 
    result
end

#_reduce_164(val, _values, result) ⇒ Object 



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

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

#_reduce_166(val, _values, result) ⇒ Object

reduce 165 omitted



1555
1556
1557
1558
 
# File 'lib/tp_plus/parser.rb', line 1555

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

#_reduce_167(val, _values, result) ⇒ Object 



1560
1561
1562
1563
 
# File 'lib/tp_plus/parser.rb', line 1560

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

#_reduce_180(val, _values, result) ⇒ Object

reduce 179 omitted



1589
1590
1591
1592
 
# File 'lib/tp_plus/parser.rb', line 1589

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

#_reduce_181(val, _values, result) ⇒ Object 



1594
1595
1596
1597
 
# File 'lib/tp_plus/parser.rb', line 1594

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

#_reduce_182(val, _values, result) ⇒ Object 



1599
1600
1601
1602
 
# File 'lib/tp_plus/parser.rb', line 1599

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

#_reduce_183(val, _values, result) ⇒ Object 



1604
1605
1606
1607
 
# File 'lib/tp_plus/parser.rb', line 1604

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

#_reduce_184(val, _values, result) ⇒ Object 



1609
1610
1611
1612
 
# File 'lib/tp_plus/parser.rb', line 1609

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

#_reduce_185(val, _values, result) ⇒ Object 



1614
1615
1616
1617
 
# File 'lib/tp_plus/parser.rb', line 1614

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

#_reduce_186(val, _values, result) ⇒ Object 



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

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

#_reduce_187(val, _values, result) ⇒ Object 



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

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

#_reduce_188(val, _values, result) ⇒ Object 



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

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

#_reduce_189(val, _values, result) ⇒ Object 



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

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

#_reduce_190(val, _values, result) ⇒ Object 



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

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

#_reduce_191(val, _values, result) ⇒ Object 



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

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

#_reduce_192(val, _values, result) ⇒ Object 



1649
1650
1651
1652
 
# File 'lib/tp_plus/parser.rb', line 1649

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

#_reduce_193(val, _values, result) ⇒ Object 



1654
1655
1656
1657
 
# File 'lib/tp_plus/parser.rb', line 1654

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

#_reduce_196(val, _values, result) ⇒ Object

reduce 195 omitted



1663
1664
1665
1666
 
# File 'lib/tp_plus/parser.rb', line 1663

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

#_reduce_198(val, _values, result) ⇒ Object

reduce 197 omitted



1670
1671
1672
1673
 
# File 'lib/tp_plus/parser.rb', line 1670

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

#_reduce_200(val, _values, result) ⇒ Object

reduce 199 omitted



1677
1678
1679
1680
 
# File 'lib/tp_plus/parser.rb', line 1677

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

#_reduce_201(val, _values, result) ⇒ Object 



1682
1683
1684
1685
 
# File 'lib/tp_plus/parser.rb', line 1682

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

#_reduce_202(val, _values, result) ⇒ Object 



1687
1688
1689
1690
 
# File 'lib/tp_plus/parser.rb', line 1687

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

#_reduce_203(val, _values, result) ⇒ Object 



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

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

#_reduce_204(val, _values, result) ⇒ Object 



1697
1698
1699
1700
 
# File 'lib/tp_plus/parser.rb', line 1697

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

#_reduce_208(val, _values, result) ⇒ Object

reduce 207 omitted



1708
1709
1710
1711
 
# File 'lib/tp_plus/parser.rb', line 1708

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

#_reduce_209(val, _values, result) ⇒ Object 



1713
1714
1715
1716
 
# File 'lib/tp_plus/parser.rb', line 1713

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

#_reduce_210(val, _values, result) ⇒ Object 



1718
1719
1720
1721
 
# File 'lib/tp_plus/parser.rb', line 1718

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

#_reduce_213(val, _values, result) ⇒ Object

reduce 212 omitted



1727
1728
1729
1730
 
# File 'lib/tp_plus/parser.rb', line 1727

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

#_reduce_214(val, _values, result) ⇒ Object 



1732
1733
1734
1735
 
# File 'lib/tp_plus/parser.rb', line 1732

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

#_reduce_215(val, _values, result) ⇒ Object 



1737
1738
1739
1740
 
# File 'lib/tp_plus/parser.rb', line 1737

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

#_reduce_29(val, _values, result) ⇒ Object

reduce 28 omitted



982
983
984
985
 
# File 'lib/tp_plus/parser.rb', line 982

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

#_reduce_3(val, _values, result) ⇒ Object

reduce 2 omitted



917
918
919
920
921
922
 
# File 'lib/tp_plus/parser.rb', line 917

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

#_reduce_30(val, _values, result) ⇒ Object 



987
988
989
990
 
# File 'lib/tp_plus/parser.rb', line 987

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

#_reduce_31(val, _values, result) ⇒ Object 



992
993
994
995
 
# File 'lib/tp_plus/parser.rb', line 992

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

#_reduce_32(val, _values, result) ⇒ Object 



997
998
999
1000
 
# File 'lib/tp_plus/parser.rb', line 997

def _reduce_32(val, _values, result)
 result = LPOSNode.new(val[2]) 
    result
end

#_reduce_33(val, _values, result) ⇒ Object 



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

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

#_reduce_34(val, _values, result) ⇒ Object 



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

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

#_reduce_35(val, _values, result) ⇒ Object 



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

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

#_reduce_38(val, _values, result) ⇒ Object

reduce 37 omitted



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

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

#_reduce_39(val, _values, result) ⇒ Object 



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

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

#_reduce_4(val, _values, result) ⇒ Object 



924
925
926
927
928
929
 
# File 'lib/tp_plus/parser.rb', line 924

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 



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

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

#_reduce_41(val, _values, result) ⇒ Object 



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

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

#_reduce_42(val, _values, result) ⇒ Object 



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

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

#_reduce_43(val, _values, result) ⇒ Object 



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

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

#_reduce_44(val, _values, result) ⇒ Object 



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

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

#_reduce_47(val, _values, result) ⇒ Object

reduce 46 omitted



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

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

#_reduce_48(val, _values, result) ⇒ Object 



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

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

#_reduce_49(val, _values, result) ⇒ Object 



1070
1071
1072
1073
 
# File 'lib/tp_plus/parser.rb', line 1070

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

#_reduce_5(val, _values, result) ⇒ Object 



931
932
933
934
 
# File 'lib/tp_plus/parser.rb', line 931

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

#_reduce_50(val, _values, result) ⇒ Object 



1075
1076
1077
1078
 
# File 'lib/tp_plus/parser.rb', line 1075

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

#_reduce_51(val, _values, result) ⇒ Object 



1080
1081
1082
1083
 
# File 'lib/tp_plus/parser.rb', line 1080

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

#_reduce_52(val, _values, result) ⇒ Object 



1085
1086
1087
1088
 
# File 'lib/tp_plus/parser.rb', line 1085

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

#_reduce_53(val, _values, result) ⇒ Object 



1090
1091
1092
1093
 
# File 'lib/tp_plus/parser.rb', line 1090

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

#_reduce_54(val, _values, result) ⇒ Object 



1095
1096
1097
1098
 
# File 'lib/tp_plus/parser.rb', line 1095

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

#_reduce_55(val, _values, result) ⇒ Object 



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

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

#_reduce_56(val, _values, result) ⇒ Object 



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

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

#_reduce_61(val, _values, result) ⇒ Object

reduce 60 omitted



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

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

#_reduce_62(val, _values, result) ⇒ Object 



1123
1124
1125
1126
 
# File 'lib/tp_plus/parser.rb', line 1123

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

#_reduce_63(val, _values, result) ⇒ Object 



1128
1129
1130
1131
 
# File 'lib/tp_plus/parser.rb', line 1128

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

#_reduce_64(val, _values, result) ⇒ Object 



1133
1134
1135
1136
 
# File 'lib/tp_plus/parser.rb', line 1133

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

#_reduce_67(val, _values, result) ⇒ Object

reduce 66 omitted



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

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

#_reduce_68(val, _values, result) ⇒ Object 



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

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

#_reduce_69(val, _values, result) ⇒ Object 



1152
1153
1154
1155
 
# File 'lib/tp_plus/parser.rb', line 1152

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

#_reduce_70(val, _values, result) ⇒ Object 



1157
1158
1159
1160
 
# File 'lib/tp_plus/parser.rb', line 1157

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

#_reduce_71(val, _values, result) ⇒ Object 



1162
1163
1164
1165
 
# File 'lib/tp_plus/parser.rb', line 1162

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

#_reduce_74(val, _values, result) ⇒ Object

reduce 73 omitted



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

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

#_reduce_75(val, _values, result) ⇒ Object 



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

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

#_reduce_76(val, _values, result) ⇒ Object 



1181
1182
1183
1184
 
# File 'lib/tp_plus/parser.rb', line 1181

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

#_reduce_77(val, _values, result) ⇒ Object 



1186
1187
1188
1189
 
# File 'lib/tp_plus/parser.rb', line 1186

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

#_reduce_78(val, _values, result) ⇒ Object 



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

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

#_reduce_81(val, _values, result) ⇒ Object

reduce 80 omitted



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

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

#_reduce_86(val, _values, result) ⇒ Object

reduce 85 omitted



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

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

#_reduce_87(val, _values, result) ⇒ Object 



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

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

#_reduce_92(val, _values, result) ⇒ Object

reduce 91 omitted



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

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

#_reduce_93(val, _values, result) ⇒ Object 



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

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

#_reduce_94(val, _values, result) ⇒ Object 



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

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

#_reduce_95(val, _values, result) ⇒ Object 



1246
1247
1248
1249
 
# File 'lib/tp_plus/parser.rb', line 1246

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

#_reduce_96(val, _values, result) ⇒ Object 



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

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

#_reduce_97(val, _values, result) ⇒ Object 



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

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

#_reduce_98(val, _values, result) ⇒ Object 



1261
1262
1263
1264
 
# File 'lib/tp_plus/parser.rb', line 1261

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

#_reduce_99(val, _values, result) ⇒ Object 



1266
1267
1268
1269
 
# File 'lib/tp_plus/parser.rb', line 1266

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

#_reduce_none(val, _values, result) ⇒ Object

reduce 216 omitted



1744
1745
1746
 
# File 'lib/tp_plus/parser.rb', line 1744

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