• Home
• org.cassandraunit
• cassandra-unit-shaded
• 3.3.0.2
• source code
• Dbg.stg

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.cassandraunit.shaded.org.antlr.codegen.templates.CSharp2.Dbg.stg Maven / Gradle / Ivy

/*
 * [The "BSD license"]
 * Copyright (c) 2007-2008 Johannes Luber
 * Copyright (c) 2005-2007 Kunle Odutola
 * Copyright (c) 2011 Sam Harwell
 * Copyright (c) 2011 Terence Parr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/** Template overrides to add debugging to normal Java output;
 *  If ASTs are built, then you'll also get ASTDbg.stg loaded.
 */

@outputFile.debugPreprocessor() ::= "#define ANTLR_DEBUG"

@outputFile.imports() ::= <<
<@super.imports()>
using Antlr.Runtime.Debug;
using IOException = System.IO.IOException;
>>

@genericParser.members() ::= <<

public static readonly string[] ruleNames =
	new string[]
	{
		"invalidRule", "}; wrap="\n	", separator=", ">
	};<\n>


int ruleLevel = 0;
public virtual int RuleLevel { get { return ruleLevel; } }
public virtual void IncRuleLevel() { ruleLevel++; }
public virtual void DecRuleLevel() { ruleLevel--; }







public int RuleLevel { get { return }>.RuleLevel; } }
public void IncRuleLevel() { }>.IncRuleLevel(); }
public void DecRuleLevel() { }>.DecRuleLevel(); }



public override bool AlreadyParsedRule( IIntStream input, int ruleIndex )
{
	int stopIndex = GetRuleMemoization(ruleIndex, input.Index);
	((Profiler)dbg).ExamineRuleMemoization(input, ruleIndex, stopIndex, .ruleNames[ruleIndex]);
	return base.AlreadyParsedRule(input, ruleIndex);
}<\n>
public override void Memoize( IIntStream input, int ruleIndex, int ruleStartIndex )
{
	((Profiler)dbg).Memoize(input, ruleIndex, ruleStartIndex, .ruleNames[ruleIndex]);
	base.Memoize(input, ruleIndex, ruleStartIndex);
}<\n>

protected virtual bool EvalPredicate( bool result, string predicate )
{
	dbg.SemanticPredicate( result, predicate );
	return result;
}<\n>
>>

ctorForRootGrammar() ::= <<
 cut-n-paste instead !>

 (  input )
	: this( input, DebugEventSocketProxy.DefaultDebuggerPort, new RecognizerSharedState() )
{
}
 (  input, int port, RecognizerSharedState state )
	: base( input, state )
{
	
	 = new ( input, dbg, this.state, this}> );}; separator="\n">
	
	<@finally()>
}<\n>
>>

ctorForProfilingRootGrammar() ::= <<
 cut-n-paste instead !>
 (  input )
	: this( input, new Profiler(null), new RecognizerSharedState() )
{
}
 (  input, IDebugEventListener dbg, RecognizerSharedState state )
	: base( input, dbg, state )
{
	Profiler p = (Profiler)dbg;
	p.setParser(this);
	 = new ( input, dbg, this.state, this}> );}; separator="\n">
	
	<@finally()>
}
<\n>
>>

/** Basically we don't want to set any dbg listeners are root will have it. */
ctorForDelegateGrammar() ::= <<
 (  input, IDebugEventListener dbg, RecognizerSharedState state }> )
	: base( input, dbg, state )
{
	 = new ( input, this, this.state}> );}; separator="\n">
	
}<\n>
>>

ctorForPredefinedListener() ::= <<
 (  input, IDebugEventListener dbg )
	<@superClassRef>: base( input, dbg, new RecognizerSharedState() )<@end>
{

	Profiler p = (Profiler)dbg;
	p.setParser(this);

	 = new (input, dbg, this.state, this}>);}; separator="\n">
	
	<@finally()>
}<\n>
>>

createListenerAndHandshake() ::= <<

DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, input.TreeAdaptor );<\n>

DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, null );<\n>

DebugListener = proxy;
try
{
	proxy.Handshake();
}
catch ( IOException ioe )
{
	ReportError( ioe );
}
>>

@genericParser.superClassName() ::= "Debug<@super.superClassName()>"

/*
 * Many of the following rules were merged into CSharp2.stg.
 */

@rule.preamble() ::= <<
if (RuleLevel == 0)
	DebugListener.Commence();
IncRuleLevel();
>>
//@rule.preamble() ::= <<
//try
//{
//	dbg.EnterRule( GrammarFileName, "" );
//	if ( RuleLevel == 0 )
//	{
//		dbg.Commence();
//	}
//	IncRuleLevel();
//	dbg.Location( ,  );<\n>
//>>

@rule.postamble() ::= <<
DecRuleLevel();
if (RuleLevel == 0)
	DebugListener.Terminate();
>>
//@rule.postamble() ::= <<
//dbg.Location(, );<\n>
//}
//finally
//{
//	dbg.ExitRule( GrammarFileName, "" );
//	DecRuleLevel();
//	if ( RuleLevel == 0 )
//	{
//		dbg.Terminate();
//	}
//}<\n>
//>>

//@insertSynpreds.start() ::= "dbg.BeginBacktrack( state.backtracking );"
//@insertSynpreds.stop() ::= "dbg.EndBacktrack( state.backtracking, success );"

// Common debug event triggers used by region overrides below

//enterSubRule() ::= <<
//try
//{
//	dbg.EnterSubRule(  );<\n>
//>>

//exitSubRule() ::= <<
//}
//finally
//{
//	dbg.ExitSubRule(  );
//}<\n>
//>>

//enterDecision() ::= <<
//try
//{
//	dbg.EnterDecision(  );<\n>
//>>

//exitDecision() ::= <<
//}
//finally
//{
//	dbg.ExitDecision(  );
//}<\n>
//>>

//enterAlt(n) ::= "dbg.EnterAlt(  );<\n>"

// Region overrides that tell various constructs to add debugging triggers

//@block.predecision() ::= ""

//@block.postdecision() ::= ""

//@block.postbranch() ::= ""

//@ruleBlock.predecision() ::= ""

//@ruleBlock.postdecision() ::= ""

//@ruleBlockSingleAlt.prealt() ::= ""

//@blockSingleAlt.prealt() ::= ""

//@positiveClosureBlock.preloop() ::= ""

//@positiveClosureBlock.postloop() ::= ""

//@positiveClosureBlock.predecision() ::= ""

//@positiveClosureBlock.postdecision() ::= ""

//@positiveClosureBlock.earlyExitException() ::=
//	"dbg.RecognitionException( eee );<\n>"

//@closureBlock.preloop() ::= ""

//@closureBlock.postloop() ::= ""

//@closureBlock.predecision() ::= ""

//@closureBlock.postdecision() ::= ""

//@altSwitchCase.prealt() ::= ""

//@element.prematch() ::=
//	"dbg.Location( ,  );"

//@matchSet.mismatchedSetException() ::=
//	"dbg.RecognitionException( mse );"

//@dfaState.noViableAltException() ::= "dbg.RecognitionException( nvae );"

//@dfaStateSwitch.noViableAltException() ::= "dbg.RecognitionException( nvae );"

//dfaDecision(decisionNumber,description) ::= <<
//try
//{
//	isCyclicDecision = true;
//	
//}
//catch ( NoViableAltException nvae )
//{
//	dbg.RecognitionException( nvae );
//	throw nvae;
//}
//>>

//@cyclicDFA.errorMethod() ::= <<
//public override void Error( NoViableAltException nvae )
//{
//	((DebugParser)recognizer).dbg.RecognitionException( nvae );
//}
//>>

/** Force predicate validation to trigger an event */
evalPredicate(pred,description) ::= <<
EvalPredicate(, "")
>>