Browse Source

code cleanup

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/vbnet@6046 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61
pull/1/head
Siegfried Pammer 16 years ago
parent
commit
f5e798c77d
  1. 12
      src/Libraries/NRefactory/NRefactory.sln
  2. 21
      src/Libraries/NRefactory/Project/NRefactory.csproj
  3. 2
      src/Libraries/NRefactory/Project/Src/Lexer/AbstractLexer.cs
  4. 5
      src/Libraries/NRefactory/Project/Src/Lexer/LATextReader.cs
  5. 0
      src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.atg
  6. 3
      src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.cs
  7. 3
      src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Lexer.cs
  8. 2
      src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Parser.cs
  9. 0
      src/Libraries/NRefactory/Project/Src/Lexer/VBNet/PushParser.frame
  10. 161
      src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Parser.frame
  11. 363
      src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Scanner.frame
  12. 40
      src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/Program.cs
  13. 31
      src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/Properties/AssemblyInfo.cs
  14. 65
      src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/VBParserExperiment.csproj
  15. 4
      src/Libraries/NRefactory/Test/Lexer/LATextReaderTests.cs
  16. 2
      src/Libraries/NRefactory/Test/Lexer/VBNet/ImplicitLineContinuationTests.cs
  17. 11
      src/Libraries/NRefactory/Test/Lexer/VBNet/LexerContextTests.cs
  18. 2
      src/Libraries/NRefactory/Test/Lexer/VBNet/TokenTests.cs
  19. 2
      src/Libraries/NRefactory/Test/Lexer/VBNet/XmlModeLexerTests.cs
  20. 9
      src/Libraries/NRefactory/Test/NRefactoryTests.csproj

12
src/Libraries/NRefactory/NRefactory.sln

@ -1,7 +1,7 @@
 
Microsoft Visual Studio Solution File, Format Version 11.00 Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010 # Visual Studio 2010
# SharpDevelop 4.0.0.5897 # SharpDevelop 4.0.0.5967
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}"
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryTests", "Test\NRefactoryTests.csproj", "{870115DD-960A-4406-A6B9-600BCDC36A03}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryTests", "Test\NRefactoryTests.csproj", "{870115DD-960A-4406-A6B9-600BCDC36A03}"
@ -10,8 +10,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryASTGenerator", "N
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryDemo", "..\..\..\samples\NRefactoryDemo\NRefactoryDemo.csproj", "{63199047-9D5D-474C-B3CC-62ABBB071B67}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryDemo", "..\..\..\samples\NRefactoryDemo\NRefactoryDemo.csproj", "{63199047-9D5D-474C-B3CC-62ABBB071B67}"
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VBParserExperiment", "Project\Src\Parser\VBNet\Experimental\Test\VBParserExperiment.csproj", "{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}"
EndProject
Global Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU Debug|Any CPU = Debug|Any CPU
@ -36,14 +34,6 @@ Global
{63199047-9D5D-474C-B3CC-62ABBB071B67}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {63199047-9D5D-474C-B3CC-62ABBB071B67}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{63199047-9D5D-474C-B3CC-62ABBB071B67}.Release|Any CPU.Build.0 = Release|Any CPU {63199047-9D5D-474C-B3CC-62ABBB071B67}.Release|Any CPU.Build.0 = Release|Any CPU
{63199047-9D5D-474C-B3CC-62ABBB071B67}.Release|Any CPU.ActiveCfg = Release|Any CPU {63199047-9D5D-474C-B3CC-62ABBB071B67}.Release|Any CPU.ActiveCfg = Release|Any CPU
{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}.Debug|Any CPU.Build.0 = Debug|x86
{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}.Debug|Any CPU.ActiveCfg = Debug|x86
{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}.Debug|x86.Build.0 = Debug|x86
{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}.Debug|x86.ActiveCfg = Debug|x86
{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}.Release|Any CPU.Build.0 = Release|x86
{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}.Release|Any CPU.ActiveCfg = Release|x86
{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}.Release|x86.Build.0 = Release|x86
{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}.Release|x86.ActiveCfg = Release|x86
EndGlobalSection EndGlobalSection
GlobalSection(SolutionProperties) = preSolution GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE HideSolutionNode = FALSE

21
src/Libraries/NRefactory/Project/NRefactory.csproj

@ -60,9 +60,9 @@
</Reference> </Reference>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="Src\Parser\VBNet\Experimental\ExpressionFinder.cs" /> <Compile Include="Src\Lexer\LATextReader.cs" />
<Compile Include="Src\Parser\VBNet\Experimental\LATextReader.cs" /> <Compile Include="Src\Lexer\VBNet\ExpressionFinder.cs" />
<Compile Include="Src\Parser\VBNet\Experimental\Parser.cs"> <Compile Include="Src\Lexer\VBNet\Parser.cs">
<DependentUpon>ExpressionFinder.atg</DependentUpon> <DependentUpon>ExpressionFinder.atg</DependentUpon>
</Compile> </Compile>
<None Include="Resources\ICSharpCode.NRefactory.snk" /> <None Include="Resources\ICSharpCode.NRefactory.snk" />
@ -143,20 +143,14 @@
<Compile Include="Src\Ast\TypeReference.cs" /> <Compile Include="Src\Ast\TypeReference.cs" />
<Compile Include="Src\Parser\VBNet\ParamModifierList.cs" /> <Compile Include="Src\Parser\VBNet\ParamModifierList.cs" />
<Compile Include="Src\Visitors\NodeTrackingAstVisitor.cs" /> <Compile Include="Src\Visitors\NodeTrackingAstVisitor.cs" />
<None Include="Src\Parser\Frames\Parser.frame" /> <None Include="Src\Lexer\VBNet\ExpressionFinder.atg">
<None Include="Src\Parser\VBNet\Experimental\ExpressionFinder.atg">
<Generator>CocoParserGenerator</Generator> <Generator>CocoParserGenerator</Generator>
<CustomToolNamespace>ICSharpCode.NRefactory.Parser.VBNet.Experimental</CustomToolNamespace> <CustomToolNamespace>ICSharpCode.NRefactory.Parser.VB</CustomToolNamespace>
</None>
<None Include="Src\Parser\VBNet\Experimental\Parser.frame">
<DependentUpon>ExpressionFinder.atg</DependentUpon>
</None>
<None Include="Src\Parser\VBNet\Experimental\PushParser.frame">
<DependentUpon>ExpressionFinder.atg</DependentUpon>
</None> </None>
<None Include="Src\Parser\VBNet\Experimental\Scanner.frame"> <None Include="Src\Lexer\VBNet\PushParser.frame">
<DependentUpon>ExpressionFinder.atg</DependentUpon> <DependentUpon>ExpressionFinder.atg</DependentUpon>
</None> </None>
<None Include="Src\Parser\Frames\Parser.frame" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Content Include="Src\Lexer\CSharp\KeywordList.txt" /> <Content Include="Src\Lexer\CSharp\KeywordList.txt" />
@ -174,7 +168,6 @@
<CustomToolNamespace>ICSharpCode.NRefactory.Parser.VB</CustomToolNamespace> <CustomToolNamespace>ICSharpCode.NRefactory.Parser.VB</CustomToolNamespace>
</None> </None>
<Content Include="Src\Parser\gen.bat" /> <Content Include="Src\Parser\gen.bat" />
<Folder Include="Src\Parser\VBNet\Experimental" />
<Folder Include="Src\PrettyPrinter" /> <Folder Include="Src\PrettyPrinter" />
<Folder Include="Src\PrettyPrinter\CSharp" /> <Folder Include="Src\PrettyPrinter\CSharp" />
<Folder Include="Src\PrettyPrinter\VBNet" /> <Folder Include="Src\PrettyPrinter\VBNet" />

2
src/Libraries/NRefactory/Project/Src/Lexer/AbstractLexer.cs

@ -11,8 +11,6 @@ using System.Collections.Generic;
using System.IO; using System.IO;
using System.Text; using System.Text;
using ICSharpCode.NRefactory.Parser.VBNet.Experimental;
namespace ICSharpCode.NRefactory.Parser namespace ICSharpCode.NRefactory.Parser
{ {
/// <summary> /// <summary>

5
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/LATextReader.cs → src/Libraries/NRefactory/Project/Src/Lexer/LATextReader.cs

@ -9,11 +9,8 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
namespace ICSharpCode.NRefactory.Parser.VBNet.Experimental namespace ICSharpCode.NRefactory.Parser
{ {
/// <summary>
/// Description of LATextReader.
/// </summary>
public class LATextReader : TextReader public class LATextReader : TextReader
{ {
List<int> buffer; List<int> buffer;

0
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/ExpressionFinder.atg → src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.atg

3
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/ExpressionFinder.cs → src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.cs

@ -9,9 +9,8 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using ICSharpCode.NRefactory.Parser.VB;
namespace ICSharpCode.NRefactory.Parser.VBNet.Experimental namespace ICSharpCode.NRefactory.Parser.VB
{ {
public partial class ExpressionFinder public partial class ExpressionFinder
{ {

3
src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Lexer.cs

@ -14,9 +14,6 @@ using System.Linq;
using System.Text; using System.Text;
using System.Xml; using System.Xml;
using ICSharpCode.NRefactory.Ast;
using ICSharpCode.NRefactory.Parser.VBNet.Experimental;
namespace ICSharpCode.NRefactory.Parser.VB namespace ICSharpCode.NRefactory.Parser.VB
{ {
internal sealed class Lexer : AbstractLexer internal sealed class Lexer : AbstractLexer

2
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Parser.cs → src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Parser.cs

@ -9,7 +9,7 @@ using ASTAttribute = ICSharpCode.NRefactory.Ast.Attribute;
namespace ICSharpCode.NRefactory.Parser.VBNet.Experimental { namespace ICSharpCode.NRefactory.Parser.VB {

0
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/PushParser.frame → src/Libraries/NRefactory/Project/Src/Lexer/VBNet/PushParser.frame

161
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Parser.frame

@ -1,161 +0,0 @@
/*----------------------------------------------------------------------
Compiler Generator Coco/R,
Copyright (c) 1990, 2004 Hanspeter Moessenboeck, University of Linz
extended by M. Loeberbauer & A. Woess, Univ. of Linz
with improvements by Pat Terry, Rhodes University
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As an exception, it is allowed to write an extension of Coco/R that is
used as a plugin in non-free software.
If not otherwise stated, any source code generated by Coco/R (other than
Coco/R itself) does not fall under the GNU General Public License.
----------------------------------------------------------------------*/
-->begin
using System;
-->namespace
public partial class ExpressionFinder {
-->constants
const bool T = true;
const bool x = false;
const int minErrDist = 2;
public ILexer lexer;
public Errors errors;
public ExpressionFinder(ILexer lexer)
{
this.lexer = lexer;
this.errors = new Errors();
}
public Token t; // last recognized token
public Token la; // lookahead token
int errDist = minErrDist;
-->declarations
void SynErr (int n) {
if (errDist >= minErrDist) errors.SynErr(la.line, la.col, n);
errDist = 0;
}
public void SemErr (string msg) {
if (errDist >= minErrDist) errors.SemErr(t.line, t.col, msg);
errDist = 0;
}
void Get () {
for (;;) {
t = la;
la = lexer.NextToken();
if (la.kind <= maxT) { ++errDist; break; }
-->pragmas
la = t;
}
}
void Expect (int n) {
if (la.kind==n) Get(); else { SynErr(n); }
}
bool StartOf (int s) {
return set[s, la.kind];
}
void ExpectWeak (int n, int follow) {
if (la.kind == n) Get();
else {
SynErr(n);
while (!StartOf(follow)) Get();
}
}
bool WeakSeparator(int n, int syFol, int repFol) {
int kind = la.kind;
if (kind == n) {Get(); return true;}
else if (StartOf(repFol)) {return false;}
else {
SynErr(n);
while (!(set[syFol, kind] || set[repFol, kind] || set[0, kind])) {
Get();
kind = la.kind;
}
return StartOf(syFol);
}
}
-->productions
public void Parse() {
PushContext(Context.Global);
la = new Token(1, 1, 1);
Get();
-->parseRoot
Expect(0);
PopContext();
}
static readonly bool[,] set = {
-->initialization
};
} // end Parser
public class Errors {
public int count = 0; // number of errors detected
public System.IO.TextWriter errorStream = Console.Out; // error messages go to this stream
public string errMsgFormat = "-- line {0} col {1}: {2}"; // 0=line, 1=column, 2=text
public void SynErr (int line, int col, int n) {
string s;
switch (n) {
-->errors
default: s = "error " + n; break;
}
errorStream.WriteLine(errMsgFormat, line, col, s);
count++;
}
public void SemErr (int line, int col, string s) {
errorStream.WriteLine(errMsgFormat, line, col, s);
count++;
}
public void SemErr (string s) {
errorStream.WriteLine(s);
count++;
}
public void Warning (int line, int col, string s) {
errorStream.WriteLine(errMsgFormat, line, col, s);
}
public void Warning(string s) {
errorStream.WriteLine(s);
}
} // Errors
public class FatalError: Exception {
public FatalError(string m): base(m) {}
}
$$$

363
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Scanner.frame

@ -1,363 +0,0 @@
/*----------------------------------------------------------------------
Compiler Generator Coco/R,
Copyright (c) 1990, 2004 Hanspeter Moessenboeck, University of Linz
extended by M. Loeberbauer & A. Woess, Univ. of Linz
with improvements by Pat Terry, Rhodes University
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As an exception, it is allowed to write an extension of Coco/R that is
used as a plugin in non-free software.
If not otherwise stated, any source code generated by Coco/R (other than
Coco/R itself) does not fall under the GNU General Public License.
-----------------------------------------------------------------------*/
-->begin
using System;
using System.IO;
using System.Collections.Generic;
-->namespace
public class Token {
public int kind; // token kind
public int pos; // token position in the source text (starting at 0)
public int col; // token column (starting at 1)
public int line; // token line (starting at 1)
public string val; // token value
public Token next; // ML 2005-03-11 Tokens are kept in linked list
}
//-----------------------------------------------------------------------------------
// Buffer
//-----------------------------------------------------------------------------------
public class Buffer {
// This Buffer supports the following cases:
// 1) seekable stream (file)
// a) whole stream in buffer
// b) part of stream in buffer
// 2) non seekable stream (network, console)
public const int EOF = char.MaxValue + 1;
const int MIN_BUFFER_LENGTH = 1024; // 1KB
const int MAX_BUFFER_LENGTH = MIN_BUFFER_LENGTH * 64; // 64KB
byte[] buf; // input buffer
int bufStart; // position of first byte in buffer relative to input stream
int bufLen; // length of buffer
int fileLen; // length of input stream (may change if the stream is no file)
int bufPos; // current position in buffer
Stream stream; // input stream (seekable)
bool isUserStream; // was the stream opened by the user?
public Buffer (Stream s, bool isUserStream) {
stream = s; this.isUserStream = isUserStream;
if (stream.CanSeek) {
fileLen = (int) stream.Length;
bufLen = Math.Min(fileLen, MAX_BUFFER_LENGTH);
bufStart = Int32.MaxValue; // nothing in the buffer so far
} else {
fileLen = bufLen = bufStart = 0;
}
buf = new byte[(bufLen>0) ? bufLen : MIN_BUFFER_LENGTH];
if (fileLen > 0) Pos = 0; // setup buffer to position 0 (start)
else bufPos = 0; // index 0 is already after the file, thus Pos = 0 is invalid
if (bufLen == fileLen && stream.CanSeek) Close();
}
protected Buffer(Buffer b) { // called in UTF8Buffer constructor
buf = b.buf;
bufStart = b.bufStart;
bufLen = b.bufLen;
fileLen = b.fileLen;
bufPos = b.bufPos;
stream = b.stream;
// keep destructor from closing the stream
b.stream = null;
isUserStream = b.isUserStream;
}
~Buffer() { Close(); }
protected void Close() {
if (!isUserStream && stream != null) {
stream.Close();
stream = null;
}
}
public virtual int Read () {
if (bufPos < bufLen) {
return buf[bufPos++];
} else if (Pos < fileLen) {
Pos = Pos; // shift buffer start to Pos
return buf[bufPos++];
} else if (stream != null && !stream.CanSeek && ReadNextStreamChunk() > 0) {
return buf[bufPos++];
} else {
return EOF;
}
}
public int Peek () {
int curPos = Pos;
int ch = Read();
Pos = curPos;
return ch;
}
public string GetString (int beg, int end) {
int len = 0;
char[] buf = new char[end - beg];
int oldPos = Pos;
Pos = beg;
while (Pos < end) buf[len++] = (char) Read();
Pos = oldPos;
return new String(buf, 0, len);
}
public int Pos {
get { return bufPos + bufStart; }
set {
if (value >= fileLen && stream != null && !stream.CanSeek) {
// Wanted position is after buffer and the stream
// is not seek-able e.g. network or console,
// thus we have to read the stream manually till
// the wanted position is in sight.
while (value >= fileLen && ReadNextStreamChunk() > 0);
}
if (value < 0 || value > fileLen) {
throw new FatalError("buffer out of bounds access, position: " + value);
}
if (value >= bufStart && value < bufStart + bufLen) { // already in buffer
bufPos = value - bufStart;
} else if (stream != null) { // must be swapped in
stream.Seek(value, SeekOrigin.Begin);
bufLen = stream.Read(buf, 0, buf.Length);
bufStart = value; bufPos = 0;
} else {
// set the position to the end of the file, Pos will return fileLen.
bufPos = fileLen - bufStart;
}
}
}
// Read the next chunk of bytes from the stream, increases the buffer
// if needed and updates the fields fileLen and bufLen.
// Returns the number of bytes read.
private int ReadNextStreamChunk() {
int free = buf.Length - bufLen;
if (free == 0) {
// in the case of a growing input stream
// we can neither seek in the stream, nor can we
// foresee the maximum length, thus we must adapt
// the buffer size on demand.
byte[] newBuf = new byte[bufLen * 2];
Array.Copy(buf, newBuf, bufLen);
buf = newBuf;
free = bufLen;
}
int read = stream.Read(buf, bufLen, free);
if (read > 0) {
fileLen = bufLen = (bufLen + read);
return read;
}
// end of stream reached
return 0;
}
}
//-----------------------------------------------------------------------------------
// UTF8Buffer
//-----------------------------------------------------------------------------------
public class UTF8Buffer: Buffer {
public UTF8Buffer(Buffer b): base(b) {}
public override int Read() {
int ch;
do {
ch = base.Read();
// until we find a utf8 start (0xxxxxxx or 11xxxxxx)
} while ((ch >= 128) && ((ch & 0xC0) != 0xC0) && (ch != EOF));
if (ch < 128 || ch == EOF) {
// nothing to do, first 127 chars are the same in ascii and utf8
// 0xxxxxxx or end of file character
} else if ((ch & 0xF0) == 0xF0) {
// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
int c1 = ch & 0x07; ch = base.Read();
int c2 = ch & 0x3F; ch = base.Read();
int c3 = ch & 0x3F; ch = base.Read();
int c4 = ch & 0x3F;
ch = (((((c1 << 6) | c2) << 6) | c3) << 6) | c4;
} else if ((ch & 0xE0) == 0xE0) {
// 1110xxxx 10xxxxxx 10xxxxxx
int c1 = ch & 0x0F; ch = base.Read();
int c2 = ch & 0x3F; ch = base.Read();
int c3 = ch & 0x3F;
ch = (((c1 << 6) | c2) << 6) | c3;
} else if ((ch & 0xC0) == 0xC0) {
// 110xxxxx 10xxxxxx
int c1 = ch & 0x1F; ch = base.Read();
int c2 = ch & 0x3F;
ch = (c1 << 6) | c2;
}
return ch;
}
}
//-----------------------------------------------------------------------------------
// Scanner
//-----------------------------------------------------------------------------------
public class Scanner {
const char EOL = '\n';
const int eofSym = 0; /* pdt */
-->declarations
public Buffer buffer; // scanner buffer
Token t; // current token
int ch; // current input character
int pos; // byte position of current character
int col; // column number of current character
int line; // line number of current character
int oldEols; // EOLs that appeared in a comment;
static readonly Dictionary<int, int> start; // maps first token character to start state
Token tokens; // list of tokens already peeked (first token is a dummy)
Token pt; // current peek token
char[] tval = new char[128]; // text of current token
int tlen; // length of current token
static Scanner() {
start = new Dictionary<int, int>(128);
-->initialization
}
public Scanner (string fileName) {
try {
Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
buffer = new Buffer(stream, false);
Init();
} catch (IOException) {
throw new FatalError("Cannot open file " + fileName);
}
}
public Scanner (Stream s) {
buffer = new Buffer(s, true);
Init();
}
void Init() {
pos = -1; line = 1; col = 0;
oldEols = 0;
NextCh();
if (ch == 0xEF) { // check optional byte order mark for UTF-8
NextCh(); int ch1 = ch;
NextCh(); int ch2 = ch;
if (ch1 != 0xBB || ch2 != 0xBF) {
throw new FatalError(String.Format("illegal byte order mark: EF {0,2:X} {1,2:X}", ch1, ch2));
}
buffer = new UTF8Buffer(buffer); col = 0;
NextCh();
}
pt = tokens = new Token(); // first token is a dummy
}
void NextCh() {
if (oldEols > 0) { ch = EOL; oldEols--; }
else {
pos = buffer.Pos;
ch = buffer.Read(); col++;
// replace isolated '\r' by '\n' in order to make
// eol handling uniform across Windows, Unix and Mac
if (ch == '\r' && buffer.Peek() != '\n') ch = EOL;
if (ch == EOL) { line++; col = 0; }
}
-->casing1
}
void AddCh() {
if (tlen >= tval.Length) {
char[] newBuf = new char[2 * tval.Length];
Array.Copy(tval, 0, newBuf, 0, tval.Length);
tval = newBuf;
}
if (ch != Buffer.EOF) {
-->casing2
NextCh();
}
}
-->comments
void CheckLiteral() {
-->literals
}
Token NextToken() {
while (ch == ' ' ||
-->scan1
) NextCh();
-->scan2
t = new Token();
t.pos = pos; t.col = col; t.line = line;
int state;
if (!start.TryGetValue(ch, out state))
state = 0;
tlen = 0; AddCh();
switch (state) {
case -1: { t.kind = eofSym; break; } // NextCh already done
case 0: { t.kind = noSym; break; } // NextCh already done
-->scan3
}
t.val = new String(tval, 0, tlen);
return t;
}
// get the next token (possibly a token already seen during peeking)
public Token Scan () {
if (tokens.next == null) {
return NextToken();
} else {
pt = tokens = tokens.next;
return tokens;
}
}
// peek for the next token, ignore pragmas
public Token Peek () {
do {
if (pt.next == null) {
pt.next = NextToken();
}
pt = pt.next;
} while (pt.kind > maxT); // skip pragmas
return pt;
}
// make sure that peeking starts at the current scan position
public void ResetPeek () { pt = tokens; }
} // end Scanner
$$$

40
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/Program.cs

@ -1,40 +0,0 @@
// <file>
// <copyright see="prj:///doc/copyright.txt"/>
// <license see="prj:///doc/license.txt"/>
// <owner name="Siegfried Pammer" email="siegfriedpammer@gmail.com" />
// <version>$Revision$</version>
// </file>
using System;
using System.IO;
using ICSharpCode.NRefactory;
using ICSharpCode.NRefactory.Parser;
using VB = ICSharpCode.NRefactory.Parser.VB;
using ICSharpCode.NRefactory.Parser.VBNet.Experimental;
namespace VBParserExperiment
{
class Program
{
static string data = @"Class Test
Public Sub New()
Dim x = <a>
End Sub
End Class
";
public static void Main(string[] args)
{
ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, new StringReader(data));
ExpressionFinder p = new ExpressionFinder();
Token t;
do {
t = lexer.NextToken();
p.InformToken(t);
} while (t.Kind != VB.Tokens.EOF);
Console.ReadKey(true);
}
}
}

31
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/Properties/AssemblyInfo.cs

@ -1,31 +0,0 @@
#region Using directives
using System;
using System.Reflection;
using System.Runtime.InteropServices;
#endregion
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("VBParserExperiment")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("VBParserExperiment")]
[assembly: AssemblyCopyright("Copyright 2010")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// This sets the default COM visibility of types in the assembly to invisible.
// If you need to expose a type to COM, use [ComVisible(true)] on that type.
[assembly: ComVisible(false)]
// The assembly version has following format :
//
// Major.Minor.Build.Revision
//
// You can specify all the values or you can use the default the Revision and
// Build Numbers by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.*")]

65
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/VBParserExperiment.csproj

@ -1,65 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
<PropertyGroup>
<ProjectGuid>{A21BF46E-27BC-4DCA-AB11-462BE5B0B028}</ProjectGuid>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">x86</Platform>
<OutputType>Exe</OutputType>
<RootNamespace>VBParserExperiment</RootNamespace>
<AssemblyName>VBParserExperiment</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<AppDesignerFolder>Properties</AppDesignerFolder>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'x86' ">
<PlatformTarget>x86</PlatformTarget>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<OutputPath>bin\Debug\</OutputPath>
<DebugSymbols>True</DebugSymbols>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
<CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
<DefineConstants>DEBUG;TRACE</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<OutputPath>bin\Release\</OutputPath>
<DebugSymbols>False</DebugSymbols>
<DebugType>None</DebugType>
<Optimize>True</Optimize>
<CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
<DefineConstants>TRACE</DefineConstants>
</PropertyGroup>
<ItemGroup>
<Reference Include="nunit.framework">
<HintPath>..\..\..\..\..\..\..\..\Tools\NUnit\nunit.framework.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Data" />
<Reference Include="System.Data.DataSetExtensions">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Xml" />
<Reference Include="System.Xml.Linq">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
</ItemGroup>
<ItemGroup>
<Compile Include="ImplicitLineContinuationTests.cs" />
<Compile Include="LATextReaderTests.cs" />
<Compile Include="ParserTests.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="TokenTests.cs" />
<Compile Include="XmlModeLexerTests.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\..\..\NRefactory.csproj">
<Project>{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}</Project>
<Name>NRefactory</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
</Project>

4
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/LATextReaderTests.cs → src/Libraries/NRefactory/Test/Lexer/LATextReaderTests.cs

@ -8,10 +8,10 @@
using System; using System;
using System.IO; using System.IO;
using ICSharpCode.NRefactory.Parser.VBNet.Experimental; using ICSharpCode.NRefactory.Parser;
using NUnit.Framework; using NUnit.Framework;
namespace VBParserExperiment namespace ICSharpCode.NRefactory.Tests.Lexer
{ {
[TestFixture] [TestFixture]
public class LATextReaderTests public class LATextReaderTests

2
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/ImplicitLineContinuationTests.cs → src/Libraries/NRefactory/Test/Lexer/VBNet/ImplicitLineContinuationTests.cs

@ -12,7 +12,7 @@ using ICSharpCode.NRefactory.Parser;
using ICSharpCode.NRefactory.Parser.VB; using ICSharpCode.NRefactory.Parser.VB;
using NUnit.Framework; using NUnit.Framework;
namespace VBParserExperiment namespace ICSharpCode.NRefactory.Tests.Lexer.VB
{ {
[TestFixture] [TestFixture]
public class ImplicitLineContinuationTests public class ImplicitLineContinuationTests

11
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/ParserTests.cs → src/Libraries/NRefactory/Test/Lexer/VBNet/LexerContextTests.cs

@ -7,16 +7,15 @@
using System; using System;
using System.IO; using System.IO;
using ICSharpCode.NRefactory;
using ICSharpCode.NRefactory.Parser; using ICSharpCode.NRefactory.Parser;
using VB = ICSharpCode.NRefactory.Parser.VB; using ICSharpCode.NRefactory.Parser.VB;
using ICSharpCode.NRefactory.Parser.VBNet.Experimental;
using NUnit.Framework; using NUnit.Framework;
using VBParser = ICSharpCode.NRefactory.Parser.VB;
namespace VBParserExperiment namespace ICSharpCode.NRefactory.Tests.Lexer.VB
{ {
[TestFixture] [TestFixture]
public class ParserTests public class LexerContextTests
{ {
[Test] [Test]
public void SimpleGlobal() public void SimpleGlobal()
@ -299,7 +298,7 @@ exit Global
do { do {
t = lexer.NextToken(); t = lexer.NextToken();
p.InformToken(t); p.InformToken(t);
} while (t.Kind != VB.Tokens.EOF); } while (t.Kind != VBParser.Tokens.EOF);
Console.WriteLine(p.Output); Console.WriteLine(p.Output);

2
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/TokenTests.cs → src/Libraries/NRefactory/Test/Lexer/VBNet/TokenTests.cs

@ -10,7 +10,7 @@ using System;
using ICSharpCode.NRefactory.Parser; using ICSharpCode.NRefactory.Parser;
using NUnit.Framework; using NUnit.Framework;
namespace VBParserExperiment namespace ICSharpCode.NRefactory.Tests.Lexer.VB
{ {
[TestFixture] [TestFixture]
public class TokenTests public class TokenTests

2
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/XmlModeLexerTests.cs → src/Libraries/NRefactory/Test/Lexer/VBNet/XmlModeLexerTests.cs

@ -13,7 +13,7 @@ using ICSharpCode.NRefactory.Parser;
using ICSharpCode.NRefactory.Parser.VB; using ICSharpCode.NRefactory.Parser.VB;
using NUnit.Framework; using NUnit.Framework;
namespace VBParserExperiment namespace ICSharpCode.NRefactory.Tests.Lexer.VB
{ {
[TestFixture] [TestFixture]
public class XmlModeLexerTests public class XmlModeLexerTests

9
src/Libraries/NRefactory/Test/NRefactoryTests.csproj

@ -58,7 +58,12 @@
<Compile Include="Lexer\CSharp\LexerTests.cs" /> <Compile Include="Lexer\CSharp\LexerTests.cs" />
<Compile Include="General\UnitTest.cs" /> <Compile Include="General\UnitTest.cs" />
<Compile Include="Lexer\CSharp\PreprocessingTests.cs" /> <Compile Include="Lexer\CSharp\PreprocessingTests.cs" />
<Compile Include="Lexer\LATextReaderTests.cs" />
<Compile Include="Lexer\VBNet\CustomLexerTests.cs" /> <Compile Include="Lexer\VBNet\CustomLexerTests.cs" />
<Compile Include="Lexer\VBNet\ImplicitLineContinuationTests.cs" />
<Compile Include="Lexer\VBNet\LexerContextTests.cs" />
<Compile Include="Lexer\VBNet\TokenTests.cs" />
<Compile Include="Lexer\VBNet\XmlModeLexerTests.cs" />
<Compile Include="Output\CodeDOM\CodeDOMTypeReferenceTest.cs" /> <Compile Include="Output\CodeDOM\CodeDOMTypeReferenceTest.cs" />
<Compile Include="Parser\CheckParentVisitor.cs" /> <Compile Include="Parser\CheckParentVisitor.cs" />
<Compile Include="Parser\Expressions\AddressOfExpressionTests.cs" /> <Compile Include="Parser\Expressions\AddressOfExpressionTests.cs" />
@ -150,7 +155,9 @@
<Compile Include="Output\CodeDOM\CodeDOMParenthesizedExpressionTest.cs" /> <Compile Include="Output\CodeDOM\CodeDOMParenthesizedExpressionTest.cs" />
<Compile Include="Parser\Statements\YieldStatementTests.cs" /> <Compile Include="Parser\Statements\YieldStatementTests.cs" />
<Compile Include="Lexer\CSharp\NumberLexerTest.cs" /> <Compile Include="Lexer\CSharp\NumberLexerTest.cs" />
<Compile Include="Lexer\VBNet\LiteralsTests.cs" /> <Compile Include="Lexer\VBNet\LiteralsTests.cs">
<DependentUpon>LexerTests.cs</DependentUpon>
</Compile>
<Compile Include="Parser\SkipMethodBodiesTest.cs" /> <Compile Include="Parser\SkipMethodBodiesTest.cs" />
<Compile Include="Parser\Expressions\AnonymousMethodTests.cs" /> <Compile Include="Parser\Expressions\AnonymousMethodTests.cs" />
<Compile Include="Output\CodeDOM\InvocationExpressionTest.cs" /> <Compile Include="Output\CodeDOM\InvocationExpressionTest.cs" />

Loading…
Cancel
Save