r - walk.go

     1  // Package walk provides a R type walker.
     2  package walk
     3  
     4  import "vimagination.zapto.org/r"
     5  
     6  // Handler is used to process R types.
     7  type Handler interface {
     8  	Handle(r.Type) error
     9  }
    10  
    11  // HandlerFunc wraps a func to implement Handler interface.
    12  type HandlerFunc func(r.Type) error
    13  
    14  // Handle implements the Handler interface.
    15  func (h HandlerFunc) Handle(t r.Type) error {
    16  	return h(t)
    17  }
    18  
    19  // Walk calls the Handle function on the given interface for each non-nil, non-Token field of the given R type.
    20  func Walk(t r.Type, fn Handler) error {
    21  	switch t := t.(type) {
    22  	case r.AdditionExpression:
    23  		return walkAdditionExpression(&t, fn)
    24  	case *r.AdditionExpression:
    25  		return walkAdditionExpression(t, fn)
    26  	case r.AndExpression:
    27  		return walkAndExpression(&t, fn)
    28  	case *r.AndExpression:
    29  		return walkAndExpression(t, fn)
    30  	case r.Arg:
    31  		return walkArg(&t, fn)
    32  	case *r.Arg:
    33  		return walkArg(t, fn)
    34  	case r.ArgList:
    35  		return walkArgList(&t, fn)
    36  	case *r.ArgList:
    37  		return walkArgList(t, fn)
    38  	case r.Argument:
    39  		return walkArgument(&t, fn)
    40  	case *r.Argument:
    41  		return walkArgument(t, fn)
    42  	case r.AssignmentExpression:
    43  		return walkAssignmentExpression(&t, fn)
    44  	case *r.AssignmentExpression:
    45  		return walkAssignmentExpression(t, fn)
    46  	case r.Call:
    47  		return walkCall(&t, fn)
    48  	case *r.Call:
    49  		return walkCall(t, fn)
    50  	case r.CompoundExpression:
    51  		return walkCompoundExpression(&t, fn)
    52  	case *r.CompoundExpression:
    53  		return walkCompoundExpression(t, fn)
    54  	case r.ExponentiationExpression:
    55  		return walkExponentiationExpression(&t, fn)
    56  	case *r.ExponentiationExpression:
    57  		return walkExponentiationExpression(t, fn)
    58  	case r.Expression:
    59  		return walkExpression(&t, fn)
    60  	case *r.Expression:
    61  		return walkExpression(t, fn)
    62  	case r.File:
    63  		return walkFile(&t, fn)
    64  	case *r.File:
    65  		return walkFile(t, fn)
    66  	case r.FlowControl:
    67  		return walkFlowControl(&t, fn)
    68  	case *r.FlowControl:
    69  		return walkFlowControl(t, fn)
    70  	case r.ForControl:
    71  		return walkForControl(&t, fn)
    72  	case *r.ForControl:
    73  		return walkForControl(t, fn)
    74  	case r.FormulaeExpression:
    75  		return walkFormulaeExpression(&t, fn)
    76  	case *r.FormulaeExpression:
    77  		return walkFormulaeExpression(t, fn)
    78  	case r.FunctionDefinition:
    79  		return walkFunctionDefinition(&t, fn)
    80  	case *r.FunctionDefinition:
    81  		return walkFunctionDefinition(t, fn)
    82  	case r.IfControl:
    83  		return walkIfControl(&t, fn)
    84  	case *r.IfControl:
    85  		return walkIfControl(t, fn)
    86  	case r.Index:
    87  		return walkIndex(&t, fn)
    88  	case *r.Index:
    89  		return walkIndex(t, fn)
    90  	case r.IndexExpression:
    91  		return walkIndexExpression(&t, fn)
    92  	case *r.IndexExpression:
    93  		return walkIndexExpression(t, fn)
    94  	case r.IndexOrCallExpression:
    95  		return walkIndexOrCallExpression(&t, fn)
    96  	case *r.IndexOrCallExpression:
    97  		return walkIndexOrCallExpression(t, fn)
    98  	case r.MultiplicationExpression:
    99  		return walkMultiplicationExpression(&t, fn)
   100  	case *r.MultiplicationExpression:
   101  		return walkMultiplicationExpression(t, fn)
   102  	case r.NotExpression:
   103  		return walkNotExpression(&t, fn)
   104  	case *r.NotExpression:
   105  		return walkNotExpression(t, fn)
   106  	case r.OrExpression:
   107  		return walkOrExpression(&t, fn)
   108  	case *r.OrExpression:
   109  		return walkOrExpression(t, fn)
   110  	case r.ParenthesizedExpression:
   111  		return walkParenthesizedExpression(&t, fn)
   112  	case *r.ParenthesizedExpression:
   113  		return walkParenthesizedExpression(t, fn)
   114  	case r.PipeOrSpecialExpression:
   115  		return walkPipeOrSpecialExpression(&t, fn)
   116  	case *r.PipeOrSpecialExpression:
   117  		return walkPipeOrSpecialExpression(t, fn)
   118  	case r.QueryExpression:
   119  		return walkQueryExpression(&t, fn)
   120  	case *r.QueryExpression:
   121  		return walkQueryExpression(t, fn)
   122  	}
   123  
   124  	return nil
   125  }
   126  
   127  func walkAdditionExpression(t *r.AdditionExpression, fn Handler) error {
   128  	if err := fn.Handle(&t.MultiplicationExpression); err != nil {
   129  		return err
   130  	}
   131  
   132  	if t.AdditionExpression != nil {
   133  		return fn.Handle(t.AdditionExpression)
   134  	}
   135  
   136  	return nil
   137  }
   138  
   139  func walkAndExpression(t *r.AndExpression, fn Handler) error {
   140  	if err := fn.Handle(&t.NotExpression); err != nil {
   141  		return err
   142  	}
   143  
   144  	if t.AndExpression != nil {
   145  		return fn.Handle(t.AndExpression)
   146  	}
   147  
   148  	return nil
   149  }
   150  
   151  func walkArg(t *r.Arg, fn Handler) error {
   152  	if t.QueryExpression != nil {
   153  		return fn.Handle(t.QueryExpression)
   154  	}
   155  
   156  	return nil
   157  }
   158  
   159  func walkArgList(t *r.ArgList, fn Handler) error {
   160  	for n := range t.Args {
   161  		if err := fn.Handle(&t.Args[n]); err != nil {
   162  			return err
   163  		}
   164  	}
   165  
   166  	return nil
   167  }
   168  
   169  func walkArgument(t *r.Argument, fn Handler) error {
   170  	if t.Default != nil {
   171  		return fn.Handle(t.Default)
   172  	}
   173  
   174  	return nil
   175  }
   176  
   177  func walkAssignmentExpression(t *r.AssignmentExpression, fn Handler) error {
   178  	if err := fn.Handle(&t.FormulaeExpression); err != nil {
   179  		return err
   180  	}
   181  
   182  	if t.AssignmentExpression != nil {
   183  		return fn.Handle(t.AssignmentExpression)
   184  	}
   185  
   186  	return nil
   187  }
   188  
   189  func walkCall(t *r.Call, fn Handler) error {
   190  	for n := range t.Args {
   191  		if err := fn.Handle(t.Args[n]); err != nil {
   192  			return err
   193  		}
   194  	}
   195  
   196  	return nil
   197  }
   198  
   199  func walkCompoundExpression(t *r.CompoundExpression, fn Handler) error {
   200  	for n := range t.Expressions {
   201  		if err := fn.Handle(&t.Expressions[n]); err != nil {
   202  			return err
   203  		}
   204  	}
   205  
   206  	return nil
   207  }
   208  
   209  func walkExponentiationExpression(t *r.ExponentiationExpression, fn Handler) error {
   210  	if err := fn.Handle(&t.SubsetExpression); err != nil {
   211  		return err
   212  	}
   213  
   214  	if t.ExponentiationExpression != nil {
   215  		return fn.Handle(t.ExponentiationExpression)
   216  	}
   217  
   218  	return nil
   219  }
   220  
   221  func walkExpression(t *r.Expression, fn Handler) error {
   222  	if t.FlowControl != nil {
   223  		return fn.Handle(t.FlowControl)
   224  	} else if t.FunctionDefinition != nil {
   225  		return fn.Handle(t.FunctionDefinition)
   226  	} else if t.QueryExpression != nil {
   227  		return fn.Handle(t.QueryExpression)
   228  	}
   229  
   230  	return nil
   231  }
   232  
   233  func walkFile(t *r.File, fn Handler) error {
   234  	for n := range t.Statements {
   235  		if err := fn.Handle(&t.Statements[n]); err != nil {
   236  			return err
   237  		}
   238  	}
   239  
   240  	return nil
   241  }
   242  
   243  func walkFlowControl(t *r.FlowControl, fn Handler) error {
   244  	if t.IfControl != nil {
   245  		return fn.Handle(t.IfControl)
   246  	} else if t.WhileControl != nil {
   247  		return fn.Handle(t.WhileControl)
   248  	} else if t.RepeatControl != nil {
   249  		return fn.Handle(t.RepeatControl)
   250  	} else if t.ForControl != nil {
   251  		return fn.Handle(t.ForControl)
   252  	}
   253  
   254  	return nil
   255  }
   256  
   257  func walkForControl(t *r.ForControl, fn Handler) error {
   258  	if err := fn.Handle(&t.List); err != nil {
   259  		return err
   260  	}
   261  
   262  	if err := fn.Handle(&t.Expr); err != nil {
   263  		return err
   264  	}
   265  
   266  	return nil
   267  }
   268  
   269  func walkFormulaeExpression(t *r.FormulaeExpression, fn Handler) error {
   270  	if t.OrExpression != nil {
   271  		if err := fn.Handle(t.OrExpression); err != nil {
   272  			return err
   273  		}
   274  	}
   275  
   276  	if t.FormulaeExpression != nil {
   277  		return fn.Handle(t.FormulaeExpression)
   278  	}
   279  
   280  	return nil
   281  }
   282  
   283  func walkFunctionDefinition(t *r.FunctionDefinition, fn Handler) error {
   284  	if err := fn.Handle(&t.ArgList); err != nil {
   285  		return err
   286  	}
   287  
   288  	return fn.Handle(&t.Body)
   289  }
   290  
   291  func walkIfControl(t *r.IfControl, fn Handler) error {
   292  	if err := fn.Handle(&t.Cond); err != nil {
   293  		return err
   294  	}
   295  
   296  	if err := fn.Handle(&t.Expr); err != nil {
   297  		return err
   298  	}
   299  
   300  	if t.Else != nil {
   301  		return fn.Handle(t.Else)
   302  	}
   303  
   304  	return nil
   305  }
   306  
   307  func walkIndex(t *r.Index, fn Handler) error {
   308  	for n := range t.Args {
   309  		if err := fn.Handle(&t.Args[n]); err != nil {
   310  			return err
   311  		}
   312  	}
   313  
   314  	return nil
   315  }
   316  
   317  func walkIndexExpression(t *r.IndexExpression, fn Handler) error {
   318  	return fn.Handle(&t.QueryExpression)
   319  }
   320  
   321  func walkIndexOrCallExpression(t *r.IndexOrCallExpression, fn Handler) error {
   322  	if t.SimpleExpression != nil {
   323  		return fn.Handle(t.SimpleExpression)
   324  	} else if t.IndexOrCallExpression != nil {
   325  		if err := fn.Handle(t.IndexOrCallExpression); err != nil {
   326  			return err
   327  		}
   328  
   329  		if t.Index != nil {
   330  			return fn.Handle(t.Index)
   331  		} else if t.Call != nil {
   332  			return fn.Handle(t.Call)
   333  		}
   334  	}
   335  	return nil
   336  }
   337  
   338  func walkMultiplicationExpression(t *r.MultiplicationExpression, fn Handler) error {
   339  	if err := fn.Handle(&t.PipeOrSpecialExpression); err != nil {
   340  		return err
   341  	}
   342  
   343  	if t.MultiplicationExpression != nil {
   344  		return fn.Handle(t.MultiplicationExpression)
   345  	}
   346  
   347  	return nil
   348  }
   349  
   350  func walkNotExpression(t *r.NotExpression, fn Handler) error {
   351  	return fn.Handle(&t.RelationalExpression)
   352  }
   353  
   354  func walkOrExpression(t *r.OrExpression, fn Handler) error {
   355  	if err := fn.Handle(&t.AndExpression); err != nil {
   356  		return err
   357  	}
   358  
   359  	if t.OrExpression != nil {
   360  		return fn.Handle(t.OrExpression)
   361  	}
   362  
   363  	return nil
   364  }
   365  
   366  func walkParenthesizedExpression(t *r.ParenthesizedExpression, fn Handler) error {
   367  	return fn.Handle(&t.Expression)
   368  }
   369  
   370  func walkPipeOrSpecialExpression(t *r.PipeOrSpecialExpression, fn Handler) error {
   371  	if err := fn.Handle(&t.SequenceExpression); err != nil {
   372  		return err
   373  	}
   374  
   375  	if t.PipeOrSpecialExpression != nil {
   376  		return fn.Handle(t.PipeOrSpecialExpression)
   377  	}
   378  
   379  	return nil
   380  }
   381  
   382  func walkQueryExpression(t *r.QueryExpression, fn Handler) error {
   383  	if t.AssignmentExpression != nil {
   384  		if err := fn.Handle(t.AssignmentExpression); err != nil {
   385  			return err
   386  		}
   387  	}
   388  
   389  	if t.QueryExpression != nil {
   390  		return fn.Handle(t.QueryExpression)
   391  	}
   392  
   393  	return nil
   394  }
   395