github.com/hoop33/elvish@v0.0.0-20160801152013-6d25485beab4/eval/boilerplate.go (about)

     1  package eval
     2  
     3  import "github.com/elves/elvish/parse"
     4  
     5  func (cp *compiler) chunkOp(n *parse.Chunk) Op {
     6  	return Op{cp.chunk(n), n.Begin(), n.End()}
     7  }
     8  
     9  func (cp *compiler) chunkOps(ns []*parse.Chunk) []Op {
    10  	ops := make([]Op, len(ns))
    11  	for i, n := range ns {
    12  		ops[i] = cp.chunkOp(n)
    13  	}
    14  	return ops
    15  }
    16  
    17  func (cp *compiler) pipelineOp(n *parse.Pipeline) Op {
    18  	return Op{cp.pipeline(n), n.Begin(), n.End()}
    19  }
    20  
    21  func (cp *compiler) pipelineOps(ns []*parse.Pipeline) []Op {
    22  	ops := make([]Op, len(ns))
    23  	for i, n := range ns {
    24  		ops[i] = cp.pipelineOp(n)
    25  	}
    26  	return ops
    27  }
    28  
    29  func (cp *compiler) formOp(n *parse.Form) Op {
    30  	return Op{cp.form(n), n.Begin(), n.End()}
    31  }
    32  
    33  func (cp *compiler) formOps(ns []*parse.Form) []Op {
    34  	ops := make([]Op, len(ns))
    35  	for i, n := range ns {
    36  		ops[i] = cp.formOp(n)
    37  	}
    38  	return ops
    39  }
    40  
    41  func (cp *compiler) controlOp(n *parse.Control) Op {
    42  	return Op{cp.control(n), n.Begin(), n.End()}
    43  }
    44  
    45  func (cp *compiler) controlOps(ns []*parse.Control) []Op {
    46  	ops := make([]Op, len(ns))
    47  	for i, n := range ns {
    48  		ops[i] = cp.controlOp(n)
    49  	}
    50  	return ops
    51  }
    52  
    53  func (cp *compiler) assignmentOp(n *parse.Assignment) Op {
    54  	return Op{cp.assignment(n), n.Begin(), n.End()}
    55  }
    56  
    57  func (cp *compiler) assignmentOps(ns []*parse.Assignment) []Op {
    58  	ops := make([]Op, len(ns))
    59  	for i, n := range ns {
    60  		ops[i] = cp.assignmentOp(n)
    61  	}
    62  	return ops
    63  }
    64  
    65  func (cp *compiler) redirOp(n *parse.Redir) Op {
    66  	return Op{cp.redir(n), n.Begin(), n.End()}
    67  }
    68  
    69  func (cp *compiler) redirOps(ns []*parse.Redir) []Op {
    70  	ops := make([]Op, len(ns))
    71  	for i, n := range ns {
    72  		ops[i] = cp.redirOp(n)
    73  	}
    74  	return ops
    75  }
    76  
    77  func (cp *compiler) compoundOp(n *parse.Compound) ValuesOp {
    78  	return ValuesOp{cp.compound(n), n.Begin(), n.End()}
    79  }
    80  
    81  func (cp *compiler) compoundOps(ns []*parse.Compound) []ValuesOp {
    82  	ops := make([]ValuesOp, len(ns))
    83  	for i, n := range ns {
    84  		ops[i] = cp.compoundOp(n)
    85  	}
    86  	return ops
    87  }
    88  
    89  func (cp *compiler) arrayOp(n *parse.Array) ValuesOp {
    90  	return ValuesOp{cp.array(n), n.Begin(), n.End()}
    91  }
    92  
    93  func (cp *compiler) arrayOps(ns []*parse.Array) []ValuesOp {
    94  	ops := make([]ValuesOp, len(ns))
    95  	for i, n := range ns {
    96  		ops[i] = cp.arrayOp(n)
    97  	}
    98  	return ops
    99  }
   100  
   101  func (cp *compiler) indexingOp(n *parse.Indexing) ValuesOp {
   102  	return ValuesOp{cp.indexing(n), n.Begin(), n.End()}
   103  }
   104  
   105  func (cp *compiler) indexingOps(ns []*parse.Indexing) []ValuesOp {
   106  	ops := make([]ValuesOp, len(ns))
   107  	for i, n := range ns {
   108  		ops[i] = cp.indexingOp(n)
   109  	}
   110  	return ops
   111  }
   112  
   113  func (cp *compiler) primaryOp(n *parse.Primary) ValuesOp {
   114  	return ValuesOp{cp.primary(n), n.Begin(), n.End()}
   115  }
   116  
   117  func (cp *compiler) primaryOps(ns []*parse.Primary) []ValuesOp {
   118  	ops := make([]ValuesOp, len(ns))
   119  	for i, n := range ns {
   120  		ops[i] = cp.primaryOp(n)
   121  	}
   122  	return ops
   123  }
   124  
   125  func (cp *compiler) listOp(n *parse.Array) ValuesOp {
   126  	return ValuesOp{cp.list(n), n.Begin(), n.End()}
   127  }
   128  
   129  func (cp *compiler) listOps(ns []*parse.Array) []ValuesOp {
   130  	ops := make([]ValuesOp, len(ns))
   131  	for i, n := range ns {
   132  		ops[i] = cp.listOp(n)
   133  	}
   134  	return ops
   135  }
   136  
   137  func (cp *compiler) errorCaptureOp(n *parse.Chunk) ValuesOp {
   138  	return ValuesOp{cp.errorCapture(n), n.Begin(), n.End()}
   139  }
   140  
   141  func (cp *compiler) errorCaptureOps(ns []*parse.Chunk) []ValuesOp {
   142  	ops := make([]ValuesOp, len(ns))
   143  	for i, n := range ns {
   144  		ops[i] = cp.errorCaptureOp(n)
   145  	}
   146  	return ops
   147  }
   148  
   149  func (cp *compiler) outputCaptureOp(n *parse.Primary) ValuesOp {
   150  	return ValuesOp{cp.outputCapture(n), n.Begin(), n.End()}
   151  }
   152  
   153  func (cp *compiler) outputCaptureOps(ns []*parse.Primary) []ValuesOp {
   154  	ops := make([]ValuesOp, len(ns))
   155  	for i, n := range ns {
   156  		ops[i] = cp.outputCaptureOp(n)
   157  	}
   158  	return ops
   159  }
   160  
   161  func (cp *compiler) lambdaOp(n *parse.Primary) ValuesOp {
   162  	return ValuesOp{cp.lambda(n), n.Begin(), n.End()}
   163  }
   164  
   165  func (cp *compiler) lambdaOps(ns []*parse.Primary) []ValuesOp {
   166  	ops := make([]ValuesOp, len(ns))
   167  	for i, n := range ns {
   168  		ops[i] = cp.lambdaOp(n)
   169  	}
   170  	return ops
   171  }
   172  
   173  func (cp *compiler) map_Op(n *parse.Primary) ValuesOp {
   174  	return ValuesOp{cp.map_(n), n.Begin(), n.End()}
   175  }
   176  
   177  func (cp *compiler) map_Ops(ns []*parse.Primary) []ValuesOp {
   178  	ops := make([]ValuesOp, len(ns))
   179  	for i, n := range ns {
   180  		ops[i] = cp.map_Op(n)
   181  	}
   182  	return ops
   183  }
   184  
   185  func (cp *compiler) bracedOp(n *parse.Primary) ValuesOp {
   186  	return ValuesOp{cp.braced(n), n.Begin(), n.End()}
   187  }
   188  
   189  func (cp *compiler) bracedOps(ns []*parse.Primary) []ValuesOp {
   190  	ops := make([]ValuesOp, len(ns))
   191  	for i, n := range ns {
   192  		ops[i] = cp.bracedOp(n)
   193  	}
   194  	return ops
   195  }