// Copyright (c) 2012-2022 The ANTLR Project. All rights reserved.

// Use of this file is governed by the BSD 3-clause license that

// can be found in the LICENSE.txt file in the project root.

package antlr

import (

"bytes"

"fmt"

)

//

// Useful for rewriting out a buffered input token stream after doing some

// augmentation or other manipulations on it.

// <p>

// You can insert stuff, replace, and delete chunks. Note that the operations

// are done lazily--only if you convert the buffer to a {@link String} with

// {@link TokenStream#getText()}. This is very efficient because you are not

// moving data around all the time. As the buffer of tokens is converted to

// strings, the {@link #getText()} method(s) scan the input token stream and

// check to see if there is an operation at the current index. If so, the

// operation is done and then normal {@link String} rendering continues on the

// buffer. This is like having multiple Turing machine instruction streams

// (programs) operating on a single input tape. :)</p>

// <p>

// This rewriter makes no modifications to the token stream. It does not ask the

// stream to fill itself up nor does it advance the input cursor. The token

// stream {@link TokenStream#index()} will return the same value before and

// after any {@link #getText()} call.</p>

// <p>

// The rewriter only works on tokens that you have in the buffer and ignores the

// current input cursor. If you are buffering tokens on-demand, calling

// {@link #getText()} halfway through the input will only do rewrites for those

// tokens in the first half of the file.</p>

// <p>

// Since the operations are done lazily at {@link #getText}-time, operations do

// not screw up the token index values. That is, an insert operation at token

// index {@code i} does not change the index values for tokens

// {@code i}+1..n-1.</p>

// <p>

// Because operations never actually alter the buffer, you may always get the

// original token stream back without undoing anything. Since the instructions

// are queued up, you can easily simulate transactions and roll back any changes

// if there is an error just by removing instructions. For example,</p>

// <pre>

// CharStream input = new ANTLRFileStream("input");

// TLexer lex = new TLexer(input);

// CommonTokenStream tokens = new CommonTokenStream(lex);

// T parser = new T(tokens);

// TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);

// parser.startRule();

// </pre>

// <p>

// Then in the rules, you can execute (assuming rewriter is visible):</p>

// <pre>

// Token t,u;

// ...

// rewriter.insertAfter(t, "text to put after t");}

// rewriter.insertAfter(u, "text after u");}

// System.out.println(rewriter.getText());

// </pre>

// <p>

// You can also have multiple "instruction streams" and get multiple rewrites

// from a single pass over the input. Just name the instruction streams and use

// that name again when printing the buffer. This could be useful for generating

// a C file and also its header file--all from the same buffer:</p>

// <pre>

// rewriter.insertAfter("pass1", t, "text to put after t");}

// rewriter.insertAfter("pass2", u, "text after u");}

// System.out.println(rewriter.getText("pass1"));

// System.out.println(rewriter.getText("pass2"));

// </pre>

// <p>

// If you don't use named rewrite streams, a "default" stream is used as the

// first example shows.</p>

const (

DefaultProgramName = "default"

ProgramInitSize = 100

MinTokenIndex = 0

)

// Define the rewrite operation hierarchy

type RewriteOperation interface {

}

type BaseRewriteOperation struct {

}

func (op *BaseRewriteOperation) GetInstructionIndex() int {

return op.instructionIndex

}

func (op *BaseRewriteOperation) GetIndex() int {

return op.index

}

func (op *BaseRewriteOperation) GetText() string {

return op.text

}

func (op *BaseRewriteOperation) GetOpName() string {

return op.opName

}

func (op *BaseRewriteOperation) GetTokens() TokenStream {

return op.tokens

}

func (op *BaseRewriteOperation) SetInstructionIndex(val int) {

op.instructionIndex = val

}

func (op *BaseRewriteOperation) SetIndex(val int) {

op.index = val

}

func (op *BaseRewriteOperation) SetText(val string) {

op.text = val

}

func (op *BaseRewriteOperation) SetOpName(val string) {

op.opName = val

}

func (op *BaseRewriteOperation) SetTokens(val TokenStream) {

op.tokens = val

}

func (op *BaseRewriteOperation) Execute(_ *bytes.Buffer) int {

return op.index

}

func (op *BaseRewriteOperation) String() string {

}

type InsertBeforeOp struct {

BaseRewriteOperation

}

func NewInsertBeforeOp(index int, text string, stream TokenStream) *InsertBeforeOp {

}

func (op *InsertBeforeOp) Execute(buffer *bytes.Buffer) int {

}

func (op *InsertBeforeOp) String() string {

return op.BaseRewriteOperation.String()

}

// InsertAfterOp distinguishes between insert after/before to do the "insert after" instructions

// first and then the "insert before" instructions at same index. Implementation

// of "insert after" is "insert before index+1".

type InsertAfterOp struct {

BaseRewriteOperation

}

func NewInsertAfterOp(index int, text string, stream TokenStream) *InsertAfterOp {

}

func (op *InsertAfterOp) Execute(buffer *bytes.Buffer) int {

}

func (op *InsertAfterOp) String() string {

return op.BaseRewriteOperation.String()

}

// ReplaceOp tries to replace range from x..y with (y-x)+1 ReplaceOp

// instructions.

type ReplaceOp struct {

BaseRewriteOperation

LastIndex int

}

func NewReplaceOp(from, to int, text string, stream TokenStream) *ReplaceOp {

}

func (op *ReplaceOp) Execute(buffer *bytes.Buffer) int {

}

func (op *ReplaceOp) String() string {

}

type TokenStreamRewriter struct {

}

func NewTokenStreamRewriter(tokens TokenStream) *TokenStreamRewriter {

}

func (tsr *TokenStreamRewriter) GetTokenStream() TokenStream {

return tsr.tokens

}

// Rollback the instruction stream for a program so that

// the indicated instruction (via instructionIndex) is no

// longer in the stream. UNTESTED!

func (tsr *TokenStreamRewriter) Rollback(programName string, instructionIndex int) {

}

func (tsr *TokenStreamRewriter) RollbackDefault(instructionIndex int) {

tsr.Rollback(DefaultProgramName, instructionIndex)

}

// DeleteProgram Reset the program so that no instructions exist

func (tsr *TokenStreamRewriter) DeleteProgram(programName string) {

tsr.Rollback(programName, MinTokenIndex) //TODO: double test on that cause lower bound is not included

}

func (tsr *TokenStreamRewriter) DeleteProgramDefault() {

tsr.DeleteProgram(DefaultProgramName)

}

func (tsr *TokenStreamRewriter) InsertAfter(programName string, index int, text string) {

}

func (tsr *TokenStreamRewriter) InsertAfterDefault(index int, text string) {

tsr.InsertAfter(DefaultProgramName, index, text)

}

func (tsr *TokenStreamRewriter) InsertAfterToken(programName string, token Token, text string) {

tsr.InsertAfter(programName, token.GetTokenIndex(), text)

}

func (tsr *TokenStreamRewriter) InsertBefore(programName string, index int, text string) {

}

func (tsr *TokenStreamRewriter) InsertBeforeDefault(index int, text string) {

tsr.InsertBefore(DefaultProgramName, index, text)

}

func (tsr *TokenStreamRewriter) InsertBeforeToken(programName string, token Token, text string) {

tsr.InsertBefore(programName, token.GetTokenIndex(), text)

}

func (tsr *TokenStreamRewriter) Replace(programName string, from, to int, text string) {

}

func (tsr *TokenStreamRewriter) ReplaceDefault(from, to int, text string) {

tsr.Replace(DefaultProgramName, from, to, text)

}

func (tsr *TokenStreamRewriter) ReplaceDefaultPos(index int, text string) {

tsr.ReplaceDefault(index, index, text)

}

func (tsr *TokenStreamRewriter) ReplaceToken(programName string, from, to Token, text string) {

tsr.Replace(programName, from.GetTokenIndex(), to.GetTokenIndex(), text)

}

func (tsr *TokenStreamRewriter) ReplaceTokenDefault(from, to Token, text string) {

tsr.ReplaceToken(DefaultProgramName, from, to, text)

}

func (tsr *TokenStreamRewriter) ReplaceTokenDefaultPos(index Token, text string) {

tsr.ReplaceTokenDefault(index, index, text)

}

func (tsr *TokenStreamRewriter) Delete(programName string, from, to int) {

tsr.Replace(programName, from, to, "")

}

func (tsr *TokenStreamRewriter) DeleteDefault(from, to int) {

tsr.Delete(DefaultProgramName, from, to)

}

func (tsr *TokenStreamRewriter) DeleteDefaultPos(index int) {

tsr.DeleteDefault(index, index)

}

func (tsr *TokenStreamRewriter) DeleteToken(programName string, from, to Token) {

tsr.ReplaceToken(programName, from, to, "")

}

func (tsr *TokenStreamRewriter) DeleteTokenDefault(from, to Token) {

tsr.DeleteToken(DefaultProgramName, from, to)

}

func (tsr *TokenStreamRewriter) GetLastRewriteTokenIndex(programName string) int {

}

func (tsr *TokenStreamRewriter) GetLastRewriteTokenIndexDefault() int {

return tsr.GetLastRewriteTokenIndex(DefaultProgramName)

}

func (tsr *TokenStreamRewriter) SetLastRewriteTokenIndex(programName string, i int) {

tsr.lastRewriteTokenIndexes[programName] = i

}

func (tsr *TokenStreamRewriter) InitializeProgram(name string) []RewriteOperation {

}

func (tsr *TokenStreamRewriter) AddToProgram(name string, op RewriteOperation) {

}

func (tsr *TokenStreamRewriter) GetProgram(name string) []RewriteOperation {

}

// GetTextDefault returns the text from the original tokens altered per the

// instructions given to this rewriter.

func (tsr *TokenStreamRewriter) GetTextDefault() string {

}

// GetText returns the text from the original tokens altered per the

// instructions given to this rewriter.

func (tsr *TokenStreamRewriter) GetText(programName string, interval Interval) string {

}

// reduceToSingleOperationPerIndex combines operations and report invalid operations (like

// overlapping replaces that are not completed nested). Inserts to

// same index need to be combined etc...

//

// Here are the cases:

//

// I.i.u I.j.v leave alone, non-overlapping

// I.i.u I.i.v combine: Iivu

//

// R.i-j.u R.x-y.v | i-j in x-y delete first R

// R.i-j.u R.i-j.v delete first R

// R.i-j.u R.x-y.v | x-y in i-j ERROR

// R.i-j.u R.x-y.v | boundaries overlap ERROR

//

// Delete special case of replace (text==null):

// D.i-j.u D.x-y.v | boundaries overlap combine to max(min)..max(right)

//

// I.i.u R.x-y.v | i in (x+1)-y delete I (since insert before

// we're not deleting i)

// I.i.u R.x-y.v | i not in (x+1)-y leave alone, non-overlapping

// R.x-y.v I.i.u | i in x-y ERROR

// R.x-y.v I.x.u R.x-y.uv (combine, delete I)

// R.x-y.v I.i.u | i not in x-y leave alone, non-overlapping

//

// I.i.u = insert u before op @ index i

// R.x-y.u = replace x-y indexed tokens with u

//

// First we need to examine replaces. For any replace op:

//

// 1. wipe out any insertions before op within that range.

// 2. Drop any replace op before that is contained completely within

// that range.

// 3. Throw exception upon boundary overlap with any previous replace.

//

// Then we can deal with inserts:

//

// 1. for any inserts to same index, combine even if not adjacent.

// 2. for any prior replace with same left boundary, combine this

// insert with replace and delete this 'replace'.

// 3. throw exception if index in same range as previous replace

//

// Don't actually delete; make op null in list. Easier to walk list.

// Later we can throw as we add to index &rarr; op map.

//

// Note that I.2 R.2-2 will wipe out I.2 even though, technically, the

// inserted stuff would be before the 'replace' range. But, if you

// add tokens in front of a method body '{' and then delete the method

// body, I think the stuff before the '{' you added should disappear too.

//

// The func returns a map from token index to operation.

func reduceToSingleOperationPerIndex(rewrites []RewriteOperation) map[int]RewriteOperation {

}

/*

Quick fixing Go lack of overloads

*/

func max(a, b int) int {

}

func min(a, b int) int {

}