mumukit-content-type 1.11.1 → 1.12.0

data/vendor/bundle/ruby/2.6.0/gems/racc-1.5.2/test/assets/tp_plus.y

@@ -1,622 +0,0 @@
-# Released under an MIT License (http://www.opensource.org/licenses/MIT)
-# By Jay Strybis (https://github.com/unreal)
-
-class TPPlus::Parser
-token ASSIGN AT_SYM COMMENT JUMP IO_METHOD INPUT OUTPUT
-token NUMREG POSREG VREG SREG TIME_SEGMENT ARG UALM
-token MOVE DOT TO AT TERM OFFSET SKIP GROUP
-token SEMICOLON NEWLINE STRING
-token REAL DIGIT WORD EQUAL
-token EEQUAL NOTEQUAL GTE LTE LT GT BANG
-token PLUS MINUS STAR SLASH DIV AND OR MOD
-token IF ELSE END UNLESS FOR IN WHILE
-token WAIT_FOR WAIT_UNTIL TIMEOUT AFTER
-token FANUC_USE SET_SKIP_CONDITION NAMESPACE
-token CASE WHEN INDIRECT POSITION
-token EVAL TIMER TIMER_METHOD RAISE ABORT
-token POSITION_DATA TRUE_FALSE RUN TP_HEADER PAUSE
-token LPAREN RPAREN COLON COMMA LBRACK RBRACK LBRACE RBRACE
-token LABEL ADDRESS
-token false
-
-prechigh
-  right BANG
-  left STAR SLASH DIV MOD
-  left PLUS MINUS
-  left GT GTE LT LTE
-  left EEQUAL NOTEQUAL
-  left AND
-  left OR
-  right EQUAL
-preclow
-
-rule
-  program
-    #: statements                        { @interpreter.nodes = val[0].flatten }
-    : statements { @interpreter.nodes = val[0] }
-    |
-    ;
-
-
-  statements
-    : statement terminator              {
-                                          result = [val[0]]
-                                          result << val[1] unless val[1].nil?
-                                        }
-    | statements statement terminator   {
-                                          result = val[0] << val[1]
-                                          result << val[2] unless val[2].nil?
-                                        }
-    ;
-
-  block
-    : NEWLINE statements      { result = val[1] }
-    ;
-
-  optional_newline
-    : NEWLINE
-    |
-    ;
-
-  statement
-    : comment
-    | definition
-    | namespace
-    #| assignment
-    | motion_statement
-    #| jump
-    #| io_method
-    | label_definition
-    | address
-    | conditional
-    | inline_conditional
-    | forloop
-    | while_loop
-    #| program_call
-    | use_statement
-    | set_skip_statement
-    | wait_statement
-    | case_statement
-    | fanuc_eval
-    | timer_method
-    | position_data
-    | raise
-    | tp_header_definition
-    | empty_stmt
-    | PAUSE                           { result = PauseNode.new }
-    | ABORT                           { result = AbortNode.new }
-    ;
-
-  empty_stmt
-    : NEWLINE                         { result = EmptyStmtNode.new() }
-    ;
-
-  tp_header_definition
-    : TP_HEADER EQUAL tp_header_value { result = HeaderNode.new(val[0],val[2]) }
-    ;
-
-  tp_header_value
-    : STRING
-    | TRUE_FALSE
-    ;
-
-  raise
-    : RAISE var_or_indirect            { result = RaiseNode.new(val[1]) }
-    ;
-
-  timer_method
-    : TIMER_METHOD var_or_indirect     { result = TimerMethodNode.new(val[0],val[1]) }
-    ;
-
-  fanuc_eval
-    : EVAL STRING                      { result = EvalNode.new(val[1]) }
-    ;
-
-  wait_statement
-    : WAIT_FOR LPAREN indirectable COMMA STRING RPAREN
-                                       { result = WaitForNode.new(val[2], val[4]) }
-    | WAIT_UNTIL LPAREN expression RPAREN
-                                       { result = WaitUntilNode.new(val[2], nil) }
-    | WAIT_UNTIL LPAREN expression RPAREN DOT wait_modifier
-                                       { result = WaitUntilNode.new(val[2],val[5]) }
-    | WAIT_UNTIL LPAREN expression RPAREN DOT wait_modifier DOT wait_modifier
-                                       { result = WaitUntilNode.new(val[2],val[5].merge(val[7])) }
-    ;
-
-  wait_modifier
-    : timeout_modifier
-    | after_modifier
-    ;
-
-  timeout_modifier
-    : swallow_newlines TIMEOUT LPAREN label RPAREN
-                                       { result = { label: val[3] } }
-    ;
-
-  after_modifier
-    : swallow_newlines AFTER LPAREN indirectable COMMA STRING RPAREN
-                                       { result = { timeout: [val[3],val[5]] } }
-    ;
-
-  label
-    : LABEL { result = val[0] }
-    ;
-
-  use_statement
-    : FANUC_USE indirectable           { result = UseNode.new(val[0],val[1]) }
-    ;
-
-  # set_skip_condition x
-  set_skip_statement
-    : SET_SKIP_CONDITION expression             { result = SetSkipNode.new(val[1]) }
-    ;
-
-  program_call
-    : WORD LPAREN args RPAREN                { result = CallNode.new(val[0],val[2]) }
-    | RUN WORD LPAREN args RPAREN            { result = CallNode.new(val[1],val[3],async: true) }
-    ;
-
-  args
-    : arg                              { result = [val[0]] }
-    | args COMMA arg                     { result = val[0] << val[2] }
-    |                                  { result = [] }
-    ;
-
-  arg
-    : number
-    | var
-    | string
-    | address
-    ;
-
-  string
-    : STRING                           { result = StringNode.new(val[0]) }
-    ;
-
-  io_method
-    : IO_METHOD var_or_indirect        { result = IOMethodNode.new(val[0],val[1]) }
-    | IO_METHOD LPAREN var_or_indirect RPAREN
-                                       { result = IOMethodNode.new(val[0],val[2]) }
-    | IO_METHOD LPAREN var_or_indirect COMMA number COMMA STRING RPAREN
-                                       { result = IOMethodNode.new(val[0],val[2],{ pulse_time: val[4], pulse_units: val[6] }) }
-    ;
-
-  var_or_indirect
-    : var
-    | indirect_thing
-    ;
-
-
-  jump
-    : JUMP label                       { result = JumpNode.new(val[1]) }
-    ;
-
-  conditional
-    : IF expression block else_block END
-                                       { result = ConditionalNode.new("if",val[1],val[2],val[3]) }
-    | UNLESS expression block else_block END
-                                       { result = ConditionalNode.new("unless",val[1],val[2],val[3]) }
-    ;
-
-  forloop
-    : FOR var IN LPAREN minmax_val TO minmax_val RPAREN block END
-                                       { result = ForNode.new(val[1],val[4],val[6],val[8]) }
-    ;
-
-  while_loop
-    : WHILE expression block END       { result = WhileNode.new(val[1],val[2]) }
-    ;
-
-  minmax_val
-    : integer
-    | var
-    ;
-
-  namespace
-    : NAMESPACE WORD block END         { result = NamespaceNode.new(val[1],val[2]) }
-    ;
-
-  case_statement
-    : CASE var swallow_newlines
-        case_conditions
-        case_else
-      END                               { result = CaseNode.new(val[1],val[3],val[4]) }
-    ;
-
-  case_conditions
-    : case_condition                    { result = val }
-    | case_conditions case_condition
-                                        { result = val[0] << val[1] << val[2] }
-    ;
-
-  case_condition
-    : WHEN case_allowed_condition swallow_newlines case_allowed_statement
-        terminator                      { result = CaseConditionNode.new(val[1],val[3]) }
-    ;
-
-  case_allowed_condition
-    : number
-    | var
-    ;
-
-  case_else
-    : ELSE swallow_newlines case_allowed_statement terminator
-                                        { result = CaseConditionNode.new(nil,val[2]) }
-    |
-    ;
-
-  case_allowed_statement
-    : program_call
-    | jump
-    ;
-
-  inline_conditional
-    : inlineable
-    | inlineable IF expression     { result = InlineConditionalNode.new(val[1], val[2], val[0]) }
-    | inlineable UNLESS expression { result = InlineConditionalNode.new(val[1], val[2], val[0]) }
-    ;
-
-  inlineable
-    : jump
-    | assignment
-    | io_method
-    | program_call
-    ;
-
-  else_block
-    : ELSE block                       { result = val[1] }
-    |                                  { result = [] }
-    ;
-
-  motion_statement
-    : MOVE DOT swallow_newlines TO LPAREN var RPAREN motion_modifiers
-                                       { result = MotionNode.new(val[0],val[5],val[7]) }
-    ;
-
-  motion_modifiers
-    : motion_modifier                  { result = val }
-    | motion_modifiers motion_modifier
-                                       { result = val[0] << val[1] }
-    ;
-
-  motion_modifier
-    : DOT swallow_newlines AT LPAREN speed RPAREN
-                                       { result = SpeedNode.new(val[4]) }
-    | DOT swallow_newlines TERM LPAREN valid_terminations RPAREN
-                                       { result = TerminationNode.new(val[4]) }
-    | DOT swallow_newlines OFFSET LPAREN var RPAREN
-                                       { result = OffsetNode.new(val[2],val[4]) }
-    | DOT swallow_newlines TIME_SEGMENT LPAREN time COMMA time_seg_actions RPAREN
-                                       { result = TimeNode.new(val[2],val[4],val[6]) }
-    | DOT swallow_newlines SKIP LPAREN label optional_lpos_arg RPAREN
-                                       { result = SkipNode.new(val[4],val[5]) }
-    ;
-
-  valid_terminations
-    : integer
-    | var
-    | MINUS DIGIT                      {
-                                         raise Racc::ParseError, sprintf("\ninvalid termination type: (%s)", val[1]) if val[1] != 1
-
-                                         result = DigitNode.new(val[1].to_i * -1)
-                                       }
-    ;
-
-  optional_lpos_arg
-    : COMMA var                          { result = val[1] }
-    |
-    ;
-
-  indirectable
-    : number
-    | var
-    ;
-
-  time_seg_actions
-    : program_call
-    | io_method
-    ;
-
-  time
-    : var
-    | number
-    ;
-
-  speed
-    : indirectable COMMA STRING          { result = { speed: val[0], units: val[2] } }
-    | STRING                           { result = { speed: val[0], units: nil } }
-    ;
-
-  label_definition
-    : label                            { result = LabelDefinitionNode.new(val[0]) }#@interpreter.add_label(val[1]) }
-    ;
-
-  definition
-    : WORD ASSIGN definable            { result = DefinitionNode.new(val[0],val[2]) }
-    ;
-
-  assignment
-    : var_or_indirect EQUAL expression            { result = AssignmentNode.new(val[0],val[2]) }
-    | var_or_indirect PLUS EQUAL expression       { result = AssignmentNode.new(
-                                           val[0],
-                                           ExpressionNode.new(val[0],"+",val[3])
-                                         )
-                                       }
-    | var_or_indirect MINUS EQUAL expression       { result = AssignmentNode.new(
-                                           val[0],
-                                           ExpressionNode.new(val[0],"-",val[3])
-                                         )
-                                       }
-    ;
-
-  var
-    : var_without_namespaces
-    | var_with_namespaces
-    ;
-
-  var_without_namespaces
-    : WORD                             { result = VarNode.new(val[0]) }
-    | WORD var_method_modifiers        { result = VarMethodNode.new(val[0],val[1]) }
-    ;
-
-  var_with_namespaces
-    : namespaces var_without_namespaces
-                                       { result = NamespacedVarNode.new(val[0],val[1]) }
-    ;
-
-  var_method_modifiers
-    : var_method_modifier              { result = val[0] }
-    | var_method_modifiers var_method_modifier
-                                       { result = val[0].merge(val[1]) }
-    ;
-
-  var_method_modifier
-    : DOT swallow_newlines WORD        { result = { method: val[2] } }
-    | DOT swallow_newlines GROUP LPAREN integer RPAREN
-                                       { result = { group: val[4] } }
-    ;
-
-  namespaces
-    : ns                               { result = [val[0]] }
-    | namespaces ns                    { result = val[0] << val[1] }
-    ;
-
-  ns
-    : WORD COLON COLON                 { result = val[0] }
-    ;
-
-
-  expression
-    : unary_expression
-    | binary_expression
-    ;
-
-  unary_expression
-    : factor                           { result = val[0] }
-    | address
-    | BANG factor                      { result = ExpressionNode.new(val[1], "!", nil) }
-    ;
-
-  binary_expression
-    : expression operator expression
-                                       { result = ExpressionNode.new(val[0], val[1], val[2]) }
-    ;
-
-  operator
-    : EEQUAL { result = "==" }
-    | NOTEQUAL { result = "<>" }
-    | LT { result = "<" }
-    | GT { result = ">" }
-    | GTE { result = ">=" }
-    | LTE { result = "<=" }
-    | PLUS { result = "+" }
-    | MINUS { result = "-" }
-    | OR { result = "||" }
-    | STAR { result = "*" }
-    | SLASH { result = "/" }
-    | DIV { result = "DIV" }
-    | MOD { result = "%" }
-    | AND { result = "&&" }
-    ;
-
-  factor
-    : number
-    | signed_number
-    | var
-    | indirect_thing
-    | paren_expr
-    ;
-
-  paren_expr
-    : LPAREN expression RPAREN        { result = ParenExpressionNode.new(val[1]) }
-    ;
-
-  indirect_thing
-    : INDIRECT LPAREN STRING COMMA indirectable RPAREN
-                                      { result = IndirectNode.new(val[2].to_sym, val[4]) }
-    ;
-
-  signed_number
-    : sign DIGIT                      {
-                                          val[1] = val[1].to_i * -1 if val[0] == "-"
-                                          result = DigitNode.new(val[1])
-                                      }
-    | sign REAL                       { val[1] = val[1].to_f * -1 if val[0] == "-"; result = RealNode.new(val[1]) }
-    ;
-
-  sign
-    : MINUS { result = "-" }
-    ;
-
-  number
-    : integer
-    | REAL                             { result = RealNode.new(val[0]) }
-    ;
-
-  integer
-    : DIGIT                            { result = DigitNode.new(val[0]) }
-    ;
-
-  definable
-    : numreg
-    | output
-    | input
-    | posreg
-    | position
-    | vreg
-    | number
-    | signed_number
-    | argument
-    | timer
-    | ualm
-    | sreg
-    ;
-
-
-  sreg
-    : SREG LBRACK DIGIT RBRACK               { result = StringRegisterNode.new(val[2].to_i) }
-    ;
-
-  ualm
-    : UALM LBRACK DIGIT RBRACK               { result = UserAlarmNode.new(val[2].to_i) }
-    ;
-
-  timer
-    : TIMER LBRACK DIGIT RBRACK              { result = TimerNode.new(val[2].to_i) }
-    ;
-
-  argument
-    : ARG LBRACK DIGIT RBRACK                { result = ArgumentNode.new(val[2].to_i) }
-    ;
-
-  vreg
-    : VREG LBRACK DIGIT RBRACK               { result = VisionRegisterNode.new(val[2].to_i) }
-    ;
-
-  position
-    : POSITION LBRACK DIGIT RBRACK           { result = PositionNode.new(val[2].to_i) }
-    ;
-
-  numreg
-    : NUMREG LBRACK DIGIT RBRACK             { result = NumregNode.new(val[2].to_i) }
-    ;
-
-  posreg
-    : POSREG LBRACK DIGIT RBRACK             { result = PosregNode.new(val[2].to_i) }
-    ;
-
-  output
-    : OUTPUT LBRACK DIGIT RBRACK             { result = IONode.new(val[0], val[2].to_i) }
-    ;
-
-  input
-    : INPUT LBRACK DIGIT RBRACK              { result = IONode.new(val[0], val[2].to_i) }
-    ;
-
-  address
-    : ADDRESS                            { result = AddressNode.new(val[0]) }
-    ;
-
-  comment
-    : COMMENT                                { result = CommentNode.new(val[0]) }
-    ;
-
-  terminator
-    : NEWLINE                          { result = TerminatorNode.new }
-    | comment optional_newline         { result = val[0] }
-              # ^-- consume newlines or else we will get an extra space from EmptyStmt in the output
-    | false
-    |
-    ;
-
-  swallow_newlines
-    : NEWLINE                          { result = TerminatorNode.new }
-    |
-    ;
-
-  position_data
-    : POSITION_DATA sn hash sn END
-                                       { result = PositionDataNode.new(val[2]) }
-    ;
-
-  sn
-    : swallow_newlines
-    ;
-
-  hash
-    : LBRACE sn hash_attributes sn RBRACE    { result = val[2] }
-    | LBRACE sn RBRACE                       { result = {} }
-    ;
-
-  hash_attributes
-    : hash_attribute                   { result = val[0] }
-    | hash_attributes COMMA sn hash_attribute
-                                       { result = val[0].merge(val[3]) }
-    ;
-
-  hash_attribute
-    : STRING COLON hash_value              { result = { val[0].to_sym => val[2] } }
-    ;
-
-  hash_value
-    : STRING
-    | hash
-    | array
-    | optional_sign DIGIT              { val[1] = val[1].to_i * -1 if val[0] == "-"; result = val[1] }
-    | optional_sign REAL               { val[1] = val[1].to_f * -1 if val[0] == "-"; result = val[1] }
-    | TRUE_FALSE                       { result = val[0] == "true" }
-    ;
-
-  optional_sign
-    : sign
-    |
-    ;
-
-  array
-    : LBRACK sn array_values sn RBRACK       { result = val[2] }
-    ;
-
-  array_values
-    : array_value                      { result = val }
-    | array_values COMMA sn array_value  { result = val[0] << val[3] }
-    ;
-
-  array_value
-    : hash_value
-    ;
-
-
-end
-
----- inner
-
-  include TPPlus::Nodes
-
-  attr_reader :interpreter
-  def initialize(scanner, interpreter = TPPlus::Interpreter.new)
-    @scanner       = scanner
-    @interpreter   = interpreter
-    super()
-  end
-
-  def next_token
-    t = @scanner.next_token
-    @interpreter.line_count += 1 if t && t[0] == :NEWLINE
-
-    #puts t.inspect
-    t
-  end
-
-  def parse
-    #@yydebug =true
-
-    do_parse
-    @interpreter
-  end
-
-  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
-
-  class ParseError < StandardError ; end