private object Expect(CTokenType expected, CToken actualToken)
{
if (actualToken.Type != expected)
{
throw new FormatException(string.Format("Expected '{0}' but got '{1}'.", expected, actualToken.Type));
}
return(actualToken.Value);
}
private CToken ReadToken()
{
if (this.tokenPrev.Type == CTokenType.None)
{
return(lexer.Read());
}
var token = this.tokenPrev;
this.tokenPrev = new CToken();
return(token);
}
public CToken Read()
{
var state = State.Start;
Debug.Assert(sb.Length == 0);
for (; ;)
{
var token = ReadToken();
switch (state)
{
case State.Start:
if (token.Type != CTokenType.StringLiteral)
{
return(token);
}
this.tokenString = token;
state = State.FirstString;
break;
case State.FirstString:
if (token.Type != CTokenType.StringLiteral)
{
this.tokenPrev = token;
return(tokenString);
}
sb.Append((string)tokenString.Value !);
sb.Append((string)token.Value !);
state = State.NextString;
break;
case State.NextString:
if (token.Type != CTokenType.StringLiteral)
{
this.tokenPrev = token;
var concToken = new CToken(this.tokenString.Type, sb.ToString());
sb.Clear();
return(concToken);
}
sb.Append((string)token.Value !);
break;
}
}
}
public CToken Read()
{
if (tokenPrev.Type != CTokenType.EOF)
{
var t = tokenPrev;
tokenPrev = new CToken(CTokenType.EOF);
return(t);
}
var token = lexer.Read();
string lastString = null;
var state = State.Start;
StringBuilder sb = null;
for (; ;)
{
switch (state)
{
case State.Start:
switch (token.Type)
{
case CTokenType.LineDirective:
Expect(CTokenType.NumericLiteral);
Expect(CTokenType.StringLiteral);
token = lexer.Read();
break;
case CTokenType.PragmaDirective:
token = ReadPragma((string)lexer.Read().Value);
break;
case CTokenType.__Pragma:
Expect(CTokenType.LParen);
ReadPragma((string)lexer.Read().Value);
token = lexer.Read();
break;
case CTokenType.StringLiteral:
state = State.Strings;
lastString = (string)token.Value;
break;
default:
return(token);
}
break;
case State.Strings:
if (token.Type == CTokenType.StringLiteral)
{
if (lastString != null)
{
sb = new StringBuilder(lastString);
lastString = null;
}
else
{
sb.Append(token.Value);
}
token = lexer.Read();
}
else
{
tokenPrev = token;
if (lastString != null)
{
var tok = new CToken(CTokenType.StringLiteral, lastString);
return(tok);
}
else
{
return(new CToken(CTokenType.StringLiteral, sb.ToString()));
}
}
break;
}
}
}
public CDirectiveLexer(ParserState state, CLexer lexer)
{
this.state = state;
this.lexer = lexer;
this.tokenPrev = new CToken(CTokenType.EOF);
}
public bool IsTypeName(CToken x)
{
if (x.Type != CTokenType.Id)
return false;
return ParserState.Typedefs.Contains((string)x.Value);
}
private Exception Unexpected(CToken unexpected)
{
return new CParserException(
string.Format("Unexpected token '{0}' ({1}) on line {2}.",
unexpected.Type,
unexpected.Value ?? unexpected.Type, lexer.LineNumber));
}
public StringConcatenator(CDirectiveLexer lexer)
{
this.lexer = lexer;
this.sb = new StringBuilder();
this.tokenPrev = new CToken(CTokenType.None);
}
public CToken Read()
{
if (tokenPrev.Type != CTokenType.EOF)
{
var t = tokenPrev;
tokenPrev = new CToken(CTokenType.EOF);
return t;
}
var token = lexer.Read();
string lastString = null;
var state = State.Start;
StringBuilder sb = null;
for (; ; )
{
switch (state)
{
case State.Start:
if (token.Type == CTokenType.LineDirective)
{
Expect(CTokenType.NumericLiteral);
Expect(CTokenType.StringLiteral);
token = lexer.Read();
}
else if (token.Type == CTokenType.PragmaDirective)
{
token = ReadPragma((string) lexer.Read().Value);
}
else if (token.Type == CTokenType.__Pragma)
{
Expect(CTokenType.LParen);
token = ReadPragma((string) lexer.Read().Value);
token = lexer.Read();
}
else if (token.Type == CTokenType.StringLiteral)
{
state = State.Strings;
lastString = (string) token.Value;
}
else
{
return token;
}
break;
case State.Strings:
if (token.Type == CTokenType.StringLiteral)
{
if (lastString != null)
{
sb = new StringBuilder(lastString);
lastString = null;
}
else
{
sb.Append(token.Value);
}
token = lexer.Read();
}
else
{
tokenPrev = token;
if (lastString != null)
{
var tok = new CToken(CTokenType.StringLiteral, lastString);
lastString = null;
return tok;
}
else
{
return new CToken(CTokenType.StringLiteral, sb.ToString());
}
}
break;
}
}
}
public CDirectiveLexer(ParserState state, CLexer lexer)
{
this.state = state;
this.lexer = lexer;
this.tokenPrev = new CToken( CTokenType.EOF);
}
private object Expect(CTokenType expected, CToken actualToken)
{
if (actualToken.Type != expected)
throw new FormatException(string.Format("Expected '{0}' but got '{1}'.", expected, actualToken.Type));
return actualToken.Value;
}
