bash - walk.go

     1  package walk
     2  
     3  import "vimagination.zapto.org/bash"
     4  
     5  type Handler interface {
     6  	Handle(bash.Type) error
     7  }
     8  
     9  type HandlerFunc func(bash.Type) error
    10  
    11  func (h HandlerFunc) Handle(t bash.Type) error {
    12  	return h(t)
    13  }
    14  
    15  func Walk(t bash.Type, fn Handler) error {
    16  	switch t := t.(type) {
    17  	case bash.ArithmeticExpansion:
    18  		return walkArithmeticExpansion(&t, fn)
    19  	case *bash.ArithmeticExpansion:
    20  		return walkArithmeticExpansion(t, fn)
    21  	case bash.ArrayWord:
    22  		return walkArrayWord(&t, fn)
    23  	case *bash.ArrayWord:
    24  		return walkArrayWord(t, fn)
    25  	case bash.Assignment:
    26  		return walkAssignment(&t, fn)
    27  	case *bash.Assignment:
    28  		return walkAssignment(t, fn)
    29  	case bash.AssignmentOrWord:
    30  		return walkAssignmentOrWord(&t, fn)
    31  	case *bash.AssignmentOrWord:
    32  		return walkAssignmentOrWord(t, fn)
    33  	case bash.BraceExpansion:
    34  		return walkBraceExpansion(&t, fn)
    35  	case *bash.BraceExpansion:
    36  		return walkBraceExpansion(t, fn)
    37  	case bash.BraceWord:
    38  		return walkBraceWord(&t, fn)
    39  	case *bash.BraceWord:
    40  		return walkBraceWord(t, fn)
    41  	case bash.CaseCompound:
    42  		return walkCaseCompound(&t, fn)
    43  	case *bash.CaseCompound:
    44  		return walkCaseCompound(t, fn)
    45  	case bash.Command:
    46  		return walkCommand(&t, fn)
    47  	case *bash.Command:
    48  		return walkCommand(t, fn)
    49  	case bash.CommandOrCompound:
    50  		return walkCommandOrCompound(&t, fn)
    51  	case *bash.CommandOrCompound:
    52  		return walkCommandOrCompound(t, fn)
    53  	case bash.CommandSubstitution:
    54  		return walkCommandSubstitution(&t, fn)
    55  	case *bash.CommandSubstitution:
    56  		return walkCommandSubstitution(t, fn)
    57  	case bash.Compound:
    58  		return walkCompound(&t, fn)
    59  	case *bash.Compound:
    60  		return walkCompound(t, fn)
    61  	case bash.File:
    62  		return walkFile(&t, fn)
    63  	case *bash.File:
    64  		return walkFile(t, fn)
    65  	case bash.ForCompound:
    66  		return walkForCompound(&t, fn)
    67  	case *bash.ForCompound:
    68  		return walkForCompound(t, fn)
    69  	case bash.FunctionCompound:
    70  		return walkFunctionCompound(&t, fn)
    71  	case *bash.FunctionCompound:
    72  		return walkFunctionCompound(t, fn)
    73  	case bash.GroupingCompound:
    74  		return walkGroupingCompound(&t, fn)
    75  	case *bash.GroupingCompound:
    76  		return walkGroupingCompound(t, fn)
    77  	case bash.Heredoc:
    78  		return walkHeredoc(&t, fn)
    79  	case *bash.Heredoc:
    80  		return walkHeredoc(t, fn)
    81  	case bash.HeredocPartOrWord:
    82  		return walkHeredocPartOrWord(&t, fn)
    83  	case *bash.HeredocPartOrWord:
    84  		return walkHeredocPartOrWord(t, fn)
    85  	case bash.IfCompound:
    86  		return walkIfCompound(&t, fn)
    87  	case *bash.IfCompound:
    88  		return walkIfCompound(t, fn)
    89  	case bash.Line:
    90  		return walkLine(&t, fn)
    91  	case *bash.Line:
    92  		return walkLine(t, fn)
    93  	case bash.LoopCompound:
    94  		return walkLoopCompound(&t, fn)
    95  	case *bash.LoopCompound:
    96  		return walkLoopCompound(t, fn)
    97  	case bash.Parameter:
    98  		return walkParameter(&t, fn)
    99  	case *bash.Parameter:
   100  		return walkParameter(t, fn)
   101  	case bash.ParameterAssign:
   102  		return walkParameterAssign(&t, fn)
   103  	case *bash.ParameterAssign:
   104  		return walkParameterAssign(t, fn)
   105  	case bash.ParameterExpansion:
   106  		return walkParameterExpansion(&t, fn)
   107  	case *bash.ParameterExpansion:
   108  		return walkParameterExpansion(t, fn)
   109  	case bash.Pattern:
   110  		return walkPattern(&t, fn)
   111  	case *bash.Pattern:
   112  		return walkPattern(t, fn)
   113  	case bash.PatternLines:
   114  		return walkPatternLines(&t, fn)
   115  	case *bash.PatternLines:
   116  		return walkPatternLines(t, fn)
   117  	case bash.Pipeline:
   118  		return walkPipeline(&t, fn)
   119  	case *bash.Pipeline:
   120  		return walkPipeline(t, fn)
   121  	case bash.Redirection:
   122  		return walkRedirection(&t, fn)
   123  	case *bash.Redirection:
   124  		return walkRedirection(t, fn)
   125  	case bash.SelectCompound:
   126  		return walkSelectCompound(&t, fn)
   127  	case *bash.SelectCompound:
   128  		return walkSelectCompound(t, fn)
   129  	case bash.Statement:
   130  		return walkStatement(&t, fn)
   131  	case *bash.Statement:
   132  		return walkStatement(t, fn)
   133  	case bash.String:
   134  		return walkString(&t, fn)
   135  	case *bash.String:
   136  		return walkString(t, fn)
   137  	case bash.TestCompound:
   138  		return walkTestCompound(&t, fn)
   139  	case *bash.TestCompound:
   140  		return walkTestCompound(t, fn)
   141  	case bash.TestConsequence:
   142  		return walkTestConsequence(&t, fn)
   143  	case *bash.TestConsequence:
   144  		return walkTestConsequence(t, fn)
   145  	case bash.Tests:
   146  		return walkTests(&t, fn)
   147  	case *bash.Tests:
   148  		return walkTests(t, fn)
   149  	case bash.Value:
   150  		return walkValue(&t, fn)
   151  	case *bash.Value:
   152  		return walkValue(t, fn)
   153  	case bash.Word:
   154  		return walkWord(&t, fn)
   155  	case *bash.Word:
   156  		return walkWord(t, fn)
   157  	case bash.WordOrOperator:
   158  		return walkWordOrOperator(&t, fn)
   159  	case *bash.WordOrOperator:
   160  		return walkWordOrOperator(t, fn)
   161  	case bash.WordOrToken:
   162  		return walkWordOrToken(&t, fn)
   163  	case *bash.WordOrToken:
   164  		return walkWordOrToken(t, fn)
   165  	case bash.WordPart:
   166  		return walkWordPart(&t, fn)
   167  	case *bash.WordPart:
   168  		return walkWordPart(t, fn)
   169  	}
   170  
   171  	return nil
   172  }
   173  
   174  func walkArithmeticExpansion(t *bash.ArithmeticExpansion, fn Handler) error {
   175  	for n := range t.WordsAndOperators {
   176  		if err := fn.Handle(&t.WordsAndOperators[n]); err != nil {
   177  			return err
   178  		}
   179  	}
   180  
   181  	return nil
   182  }
   183  
   184  func walkArrayWord(t *bash.ArrayWord, fn Handler) error {
   185  	return fn.Handle(&t.Word)
   186  }
   187  
   188  func walkAssignment(t *bash.Assignment, fn Handler) error {
   189  	if err := fn.Handle(&t.Identifier); err != nil {
   190  		return err
   191  	}
   192  
   193  	for n := range t.Expression {
   194  		if err := fn.Handle(&t.Expression[n]); err != nil {
   195  			return err
   196  		}
   197  	}
   198  
   199  	if t.Value != nil {
   200  		return fn.Handle(t.Value)
   201  	}
   202  
   203  	return nil
   204  }
   205  
   206  func walkAssignmentOrWord(t *bash.AssignmentOrWord, fn Handler) error {
   207  	if t.Assignment != nil {
   208  		return fn.Handle(t.Assignment)
   209  	}
   210  
   211  	if t.Word != nil {
   212  		return fn.Handle(t.Word)
   213  	}
   214  
   215  	return nil
   216  }
   217  
   218  func walkBraceExpansion(t *bash.BraceExpansion, fn Handler) error {
   219  	for n := range t.Words {
   220  		if err := fn.Handle(&t.Words[n]); err != nil {
   221  			return err
   222  		}
   223  	}
   224  
   225  	return nil
   226  }
   227  
   228  func walkBraceWord(t *bash.BraceWord, fn Handler) error {
   229  	for n := range t.Parts {
   230  		if err := fn.Handle(&t.Parts[n]); err != nil {
   231  			return err
   232  		}
   233  	}
   234  
   235  	return nil
   236  }
   237  
   238  func walkCaseCompound(t *bash.CaseCompound, fn Handler) error {
   239  	if err := fn.Handle(&t.Word); err != nil {
   240  		return err
   241  	}
   242  
   243  	for n := range t.Matches {
   244  		if err := fn.Handle(&t.Matches[n]); err != nil {
   245  			return err
   246  		}
   247  	}
   248  
   249  	return nil
   250  }
   251  
   252  func walkCommand(t *bash.Command, fn Handler) error {
   253  	for n := range t.Vars {
   254  		if err := fn.Handle(&t.Vars[n]); err != nil {
   255  			return err
   256  		}
   257  	}
   258  
   259  	for n := range t.AssignmentsOrWords {
   260  		if err := fn.Handle(&t.AssignmentsOrWords[n]); err != nil {
   261  			return err
   262  		}
   263  	}
   264  
   265  	for n := range t.Redirections {
   266  		if err := fn.Handle(&t.Redirections[n]); err != nil {
   267  			return err
   268  		}
   269  	}
   270  
   271  	return nil
   272  }
   273  
   274  func walkCommandOrCompound(t *bash.CommandOrCompound, fn Handler) error {
   275  	if t.Command != nil {
   276  		return fn.Handle(t.Command)
   277  	}
   278  
   279  	if t.Compound != nil {
   280  		return fn.Handle(t.Compound)
   281  	}
   282  
   283  	return nil
   284  }
   285  
   286  func walkCommandSubstitution(t *bash.CommandSubstitution, fn Handler) error {
   287  	return fn.Handle(&t.Command)
   288  }
   289  
   290  func walkCompound(t *bash.Compound, fn Handler) error {
   291  	return nil
   292  }
   293  
   294  func walkFile(t *bash.File, fn Handler) error {
   295  	return nil
   296  }
   297  
   298  func walkForCompound(t *bash.ForCompound, fn Handler) error {
   299  	return nil
   300  }
   301  
   302  func walkFunctionCompound(t *bash.FunctionCompound, fn Handler) error {
   303  	return nil
   304  }
   305  
   306  func walkGroupingCompound(t *bash.GroupingCompound, fn Handler) error {
   307  	return nil
   308  }
   309  
   310  func walkHeredoc(t *bash.Heredoc, fn Handler) error {
   311  	return nil
   312  }
   313  
   314  func walkHeredocPartOrWord(t *bash.HeredocPartOrWord, fn Handler) error {
   315  	return nil
   316  }
   317  
   318  func walkIfCompound(t *bash.IfCompound, fn Handler) error {
   319  	return nil
   320  }
   321  
   322  func walkLine(t *bash.Line, fn Handler) error {
   323  	return nil
   324  }
   325  
   326  func walkLoopCompound(t *bash.LoopCompound, fn Handler) error {
   327  	return nil
   328  }
   329  
   330  func walkParameter(t *bash.Parameter, fn Handler) error {
   331  	return nil
   332  }
   333  
   334  func walkParameterAssign(t *bash.ParameterAssign, fn Handler) error {
   335  	return nil
   336  }
   337  
   338  func walkParameterExpansion(t *bash.ParameterExpansion, fn Handler) error {
   339  	return nil
   340  }
   341  
   342  func walkPattern(t *bash.Pattern, fn Handler) error {
   343  	return nil
   344  }
   345  
   346  func walkPatternLines(t *bash.PatternLines, fn Handler) error {
   347  	return nil
   348  }
   349  
   350  func walkPipeline(t *bash.Pipeline, fn Handler) error {
   351  	return nil
   352  }
   353  
   354  func walkRedirection(t *bash.Redirection, fn Handler) error {
   355  	return nil
   356  }
   357  
   358  func walkSelectCompound(t *bash.SelectCompound, fn Handler) error {
   359  	return nil
   360  }
   361  
   362  func walkStatement(t *bash.Statement, fn Handler) error {
   363  	return nil
   364  }
   365  
   366  func walkString(t *bash.String, fn Handler) error {
   367  	return nil
   368  }
   369  
   370  func walkTestCompound(t *bash.TestCompound, fn Handler) error {
   371  	return nil
   372  }
   373  
   374  func walkTestConsequence(t *bash.TestConsequence, fn Handler) error {
   375  	return nil
   376  }
   377  
   378  func walkTests(t *bash.Tests, fn Handler) error {
   379  	return nil
   380  }
   381  
   382  func walkValue(t *bash.Value, fn Handler) error {
   383  	return nil
   384  }
   385  
   386  func walkWord(t *bash.Word, fn Handler) error {
   387  	return nil
   388  }
   389  
   390  func walkWordOrOperator(t *bash.WordOrOperator, fn Handler) error {
   391  	return nil
   392  }
   393  
   394  func walkWordOrToken(t *bash.WordOrToken, fn Handler) error {
   395  	return nil
   396  }
   397  
   398  func walkWordPart(t *bash.WordPart, fn Handler) error {
   399  	return nil
   400  }
   401