public override void ExitPragma([NotNull] XSharpParser.PragmaContext context)
{
ErrorCode error = ErrorCode.Unknown;
var tokens = context._Tokens;
IToken i1 = null;
IToken i2 = null;
var numbers = new List <IToken>();
Pragmastate state = Pragmastate.Default;
IToken errortoken = null;
bool isWarning = false;
if (tokens.Count > 0)
{
i1 = tokens[0];
if (tokens.Count > 1)
{
i2 = tokens[1];
// 0 1 2 3 4 5
// #pragma warnings ( 123 , off )
// #pragma warnings ( pop )
if (i2.Type == XSharpParser.LPAREN)
{
if (tokens.Count >= 6 && tokens[3].Type == XSharpParser.COMMA && tokens[5].Type == XSharpParser.RPAREN)
{
i2 = tokens[4];
numbers.Add(tokens[2]);
}
else if (tokens.Count >= 4 && tokens[3].Type == XSharpParser.RPAREN)
{
i2 = tokens[2];
}
}
else
{
// 0 1 2 3 4 5 6
// #pragma warnings disable 1 , 2 , 3
if (tokens.Count > 2)
{
for (int i = 2; i < context._Tokens.Count; i++)
{
if (tokens[i].Type != XSharpParser.COMMA)
{
numbers.Add(tokens[i]);
}
}
}
}
}
}
if (i1 == null)
{
error = ErrorCode.WRN_IllegalPragma;
errortoken = context.P;
}
if (error == ErrorCode.Unknown)
{
switch (i1.Text.ToLower())
{
case "options":
isWarning = false;
break;
case "warning":
case "warnings":
isWarning = true;
break;
default:
error = ErrorCode.WRN_IllegalPragma;
errortoken = i1;
break;
}
}
if (error == ErrorCode.Unknown)
{
if (i2 != null)
{
switch (i2.Text.ToLower())
{
case "on":
state = Pragmastate.On;
break;
case "disable":
case "off":
state = Pragmastate.Off;
break;
case "restore":
case "default":
case "pop":
state = Pragmastate.Default;
break;
default:
error = ErrorCode.WRN_IllegalPPWarning;
errortoken = i2;
break;
}
}
else
{
error = ErrorCode.WRN_IllegalPPWarning;
errortoken = i1;
}
}
if (error == ErrorCode.Unknown)
{
if (isWarning)
{
context.Pragma = new PragmaWarning(context, state, numbers, i1, i2);
}
else if (numbers.Count == 0)
{
// options pop
if (i2.Text.ToLower() == "pop")
{
context.Pragma = new PragmaOption(context, Pragmastate.Default, CompilerOption.All);
}
else
{
error = ErrorCode.WRN_IllegalPPWarning;
errortoken = i2;
}
}
else
{
var token = numbers[0];
var opt = token.Text.ToLower();
if (token.Type == XSharpParser.STRING_CONST && opt.StartsWith("\"") && opt.EndsWith("\"") && opt.Length > 2)
{
opt = opt.Substring(1, opt.Length - 2);
switch (opt)
{
case "az":
case "initlocals":
case "lb":
case "memvar":
case "memvars":
case "undeclared":
case "vo2": // Initialize string variables with empty strings
case "vo4": // SignedUnsignedConversion
case "vo5": // Implicit Clipper Calling convention
case "vo6": // ResolveTypedFunctionPointersToPtr
case "vo7": // Implicit Casts and Conversions
case "vo9": // Allow missing return statements or missing return values
case "vo10": // Compatible IIF
case "vo11": // ArithmeticConversions
case "vo12": // Clipper Integer divisions
case "vo13": // StringComparisons
case "vo14": // Embed real constants as float
context.Pragma = new PragmaOption(context, state, CompilerOptionDecoder.Decode(opt));
break;
default:
error = ErrorCode.WRN_IllegalPPOption;
errortoken = numbers[0];
break;
}
}
}
}
// C# does not validate the error codes, so we will not do that either.
if (error != ErrorCode.Unknown)
{
var errdata = new ParseErrorData(errortoken, error, errortoken.Text);
_parseErrors.Add(errdata);
}
}
public PragmaOption(ParserRuleContext context, Pragmastate state, CompilerOption option) : base(context, state)
{
Option = option;
}
public PragmaWarning(ParserRuleContext context, Pragmastate state, IList <IToken> tokens, IToken warning, IToken switch_) : base(context, state)
{
Numbers = tokens;
Warning = warning;
Switch = switch_;
}
public PragmaBase(ParserRuleContext context, Pragmastate state)
{
Context = context;
State = state;
}
