529 lines
11 KiB
C#
529 lines
11 KiB
C#
/******************************************************************************
|
|
* The MIT License
|
|
* Copyright (c) 2003 Novell Inc. www.novell.com
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the Software), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*******************************************************************************/
|
|
//
|
|
// Novell.Directory.Ldap.Utilclass.SchemaTokenCreator.cs
|
|
//
|
|
// Author:
|
|
// Sunil Kumar (Sunilk@novell.com)
|
|
//
|
|
// (C) 2003 Novell, Inc (http://www.novell.com)
|
|
//
|
|
|
|
using System;
|
|
|
|
namespace Novell.Directory.Ldap.Utilclass
|
|
{
|
|
|
|
public class SchemaTokenCreator
|
|
{
|
|
private string basestring;
|
|
private bool cppcomments=false; // C++ style comments enabled
|
|
private bool ccomments=false; // C style comments enabled
|
|
private bool iseolsig=false;
|
|
private bool cidtolower;
|
|
private bool pushedback;
|
|
private int peekchar;
|
|
private sbyte[] ctype;
|
|
private int linenumber=1;
|
|
private int ichar=1;
|
|
private char[] buf;
|
|
|
|
private System.IO.StreamReader reader = null;
|
|
private System.IO.StringReader sreader = null;
|
|
private System.IO.Stream input = null;
|
|
|
|
public System.String StringValue;
|
|
public double NumberValue;
|
|
public int lastttype;
|
|
|
|
private void Initialise()
|
|
{
|
|
ctype = new sbyte[256];
|
|
buf = new char[20];
|
|
peekchar=System.Int32.MaxValue;
|
|
WordCharacters('a', 'z');
|
|
WordCharacters('A', 'Z');
|
|
WordCharacters(128 + 32, 255);
|
|
WhitespaceCharacters(0, ' ');
|
|
CommentCharacter('/');
|
|
QuoteCharacter('"');
|
|
QuoteCharacter('\'');
|
|
parseNumbers();
|
|
}
|
|
|
|
public SchemaTokenCreator(System.IO.Stream instream)
|
|
{
|
|
Initialise();
|
|
if (instream == null)
|
|
{
|
|
throw new System.NullReferenceException();
|
|
}
|
|
input = instream;
|
|
}
|
|
|
|
public SchemaTokenCreator(System.IO.StreamReader r)
|
|
{
|
|
Initialise();
|
|
if (r == null)
|
|
{
|
|
throw new System.NullReferenceException();
|
|
}
|
|
reader = r;
|
|
}
|
|
|
|
public SchemaTokenCreator(System.IO.StringReader r)
|
|
{
|
|
Initialise();
|
|
if (r == null)
|
|
{
|
|
throw new System.NullReferenceException();
|
|
}
|
|
sreader = r;
|
|
}
|
|
|
|
public void pushBack()
|
|
{
|
|
pushedback = true;
|
|
}
|
|
|
|
public int CurrentLine
|
|
{
|
|
get
|
|
{
|
|
return linenumber;
|
|
}
|
|
}
|
|
|
|
public System.String ToStringValue()
|
|
{
|
|
System.String strval;
|
|
switch (lastttype)
|
|
{
|
|
|
|
case (int)TokenTypes.EOF:
|
|
strval = "EOF";
|
|
break;
|
|
|
|
case (int) TokenTypes.EOL:
|
|
strval = "EOL";
|
|
break;
|
|
|
|
case (int) TokenTypes.WORD:
|
|
strval = StringValue;
|
|
break;
|
|
|
|
case (int) TokenTypes.STRING:
|
|
strval = StringValue;
|
|
break;
|
|
|
|
case (int) TokenTypes.NUMBER:
|
|
case (int) TokenTypes.REAL:
|
|
strval = "n=" + NumberValue;
|
|
break;
|
|
|
|
default:
|
|
{
|
|
if (lastttype < 256 && ((ctype[lastttype] & (sbyte)CharacterTypes.STRINGQUOTE) != 0))
|
|
{
|
|
strval = StringValue;
|
|
break;
|
|
}
|
|
|
|
char[] s = new char[3];
|
|
s[0] = s[2] = '\'';
|
|
s[1] = (char) lastttype;
|
|
strval = new System.String(s);
|
|
break;
|
|
}
|
|
|
|
}
|
|
return strval;
|
|
}
|
|
|
|
public void WordCharacters(int min, int max)
|
|
{
|
|
if (min < 0)
|
|
min = 0;
|
|
if (max >= ctype.Length)
|
|
max = ctype.Length - 1;
|
|
while (min <= max)
|
|
ctype[min++] |= (sbyte)CharacterTypes.ALPHABETIC;
|
|
}
|
|
|
|
public void WhitespaceCharacters(int min, int max)
|
|
{
|
|
if (min < 0)
|
|
min = 0;
|
|
if (max >= ctype.Length)
|
|
max = ctype.Length - 1;
|
|
while (min <= max)
|
|
ctype[min++] = (sbyte)CharacterTypes.WHITESPACE;
|
|
}
|
|
|
|
public void OrdinaryCharacters(int min, int max)
|
|
{
|
|
if (min < 0)
|
|
min = 0;
|
|
if (max >= ctype.Length)
|
|
max = ctype.Length - 1;
|
|
while (min <= max)
|
|
ctype[min++] = 0;
|
|
}
|
|
|
|
public void OrdinaryCharacter(int ch)
|
|
{
|
|
if (ch >= 0 && ch < ctype.Length)
|
|
ctype[ch] = 0;
|
|
}
|
|
|
|
public void CommentCharacter(int ch)
|
|
{
|
|
if (ch >= 0 && ch < ctype.Length)
|
|
ctype[ch] = (sbyte)CharacterTypes.COMMENTCHAR;
|
|
}
|
|
|
|
public void InitTable()
|
|
{
|
|
for (int i = ctype.Length; --i >= 0; )
|
|
ctype[i] = 0;
|
|
}
|
|
|
|
public void QuoteCharacter(int ch)
|
|
{
|
|
if (ch >= 0 && ch < ctype.Length)
|
|
ctype[ch] = (sbyte)CharacterTypes.STRINGQUOTE;
|
|
}
|
|
|
|
public void parseNumbers()
|
|
{
|
|
for (int i = '0'; i <= '9'; i++)
|
|
ctype[i] |= (sbyte)CharacterTypes.NUMERIC;
|
|
ctype['.'] |= (sbyte)CharacterTypes.NUMERIC;
|
|
ctype['-'] |= (sbyte)CharacterTypes.NUMERIC;
|
|
}
|
|
|
|
private int read()
|
|
{
|
|
if (sreader !=null )
|
|
{
|
|
return sreader.Read();
|
|
}
|
|
else if (reader != null)
|
|
{
|
|
return reader.Read();
|
|
}
|
|
else if (input != null)
|
|
return input.ReadByte();
|
|
else
|
|
throw new System.SystemException();
|
|
}
|
|
|
|
public int nextToken()
|
|
{
|
|
if (pushedback)
|
|
{
|
|
pushedback = false;
|
|
return lastttype;
|
|
}
|
|
|
|
StringValue = null;
|
|
|
|
int curc = peekchar;
|
|
if (curc < 0)
|
|
curc = System.Int32.MaxValue;
|
|
if (curc == (System.Int32.MaxValue - 1))
|
|
{
|
|
curc = read();
|
|
if (curc < 0)
|
|
return lastttype = (int) TokenTypes.EOF;
|
|
if (curc == '\n')
|
|
curc = System.Int32.MaxValue;
|
|
}
|
|
if (curc == System.Int32.MaxValue)
|
|
{
|
|
curc = read();
|
|
if (curc < 0)
|
|
return lastttype = (int) TokenTypes.EOF;
|
|
}
|
|
lastttype = curc;
|
|
peekchar = System.Int32.MaxValue;
|
|
|
|
int ctype = curc < 256?this.ctype[curc]:(sbyte)CharacterTypes.ALPHABETIC;
|
|
while ((ctype & (sbyte)CharacterTypes.WHITESPACE) != 0)
|
|
{
|
|
if (curc == '\r')
|
|
{
|
|
linenumber++;
|
|
if (iseolsig)
|
|
{
|
|
peekchar = (System.Int32.MaxValue - 1);
|
|
return lastttype = (int) TokenTypes.EOL;
|
|
}
|
|
curc = read();
|
|
if (curc == '\n')
|
|
curc = read();
|
|
}
|
|
else
|
|
{
|
|
if (curc == '\n')
|
|
{
|
|
linenumber++;
|
|
if (iseolsig)
|
|
{
|
|
return lastttype = (int) TokenTypes.EOL;
|
|
}
|
|
}
|
|
curc = read();
|
|
}
|
|
if (curc < 0)
|
|
return lastttype = (int) TokenTypes.EOF;
|
|
ctype = curc < 256?this.ctype[curc]:(sbyte)CharacterTypes.ALPHABETIC;
|
|
}
|
|
|
|
if ((ctype & (sbyte)CharacterTypes.NUMERIC) != 0)
|
|
{
|
|
bool checkb = false;
|
|
if (curc == '-')
|
|
{
|
|
curc = read();
|
|
if (curc != '.' && (curc < '0' || curc > '9'))
|
|
{
|
|
peekchar = curc;
|
|
return lastttype = '-';
|
|
}
|
|
checkb = true;
|
|
}
|
|
double dvar = 0;
|
|
int tempvar = 0;
|
|
int checkdec = 0;
|
|
while (true)
|
|
{
|
|
if (curc == '.' && checkdec == 0)
|
|
checkdec = 1;
|
|
else if ('0' <= curc && curc <= '9')
|
|
{
|
|
dvar = dvar * 10 + (curc - '0');
|
|
tempvar += checkdec;
|
|
}
|
|
else
|
|
break;
|
|
curc = read();
|
|
}
|
|
peekchar = curc;
|
|
if (tempvar != 0)
|
|
{
|
|
double divby = 10;
|
|
tempvar--;
|
|
while (tempvar > 0)
|
|
{
|
|
divby *= 10;
|
|
tempvar--;
|
|
}
|
|
dvar = dvar / divby;
|
|
}
|
|
NumberValue = checkb?- dvar:dvar;
|
|
return lastttype = (int) TokenTypes.NUMBER;
|
|
}
|
|
|
|
if ((ctype & (sbyte)CharacterTypes.ALPHABETIC) != 0)
|
|
{
|
|
int i = 0;
|
|
do
|
|
{
|
|
if (i >= buf.Length)
|
|
{
|
|
char[] nb = new char[buf.Length * 2];
|
|
Array.Copy((System.Array) buf, 0, (System.Array) nb, 0, buf.Length);
|
|
buf = nb;
|
|
}
|
|
buf[i++] = (char) curc;
|
|
curc = read();
|
|
ctype = curc < 0?(sbyte)CharacterTypes.WHITESPACE:curc < 256?this.ctype[curc]:(sbyte)CharacterTypes.ALPHABETIC;
|
|
}
|
|
while ((ctype & ((sbyte)CharacterTypes.ALPHABETIC | (sbyte)CharacterTypes.NUMERIC)) != 0);
|
|
peekchar = curc;
|
|
StringValue = new String(buf, 0, i);
|
|
if (cidtolower)
|
|
StringValue = StringValue.ToLower();
|
|
return lastttype = (int) TokenTypes.WORD;
|
|
}
|
|
|
|
if ((ctype & (sbyte)CharacterTypes.STRINGQUOTE) != 0)
|
|
{
|
|
lastttype = curc;
|
|
int i = 0;
|
|
int rc = read();
|
|
while (rc >= 0 && rc != lastttype && rc != '\n' && rc != '\r')
|
|
{
|
|
if (rc == '\\')
|
|
{
|
|
curc = read();
|
|
int first = curc;
|
|
if (curc >= '0' && curc <= '7')
|
|
{
|
|
curc = curc - '0';
|
|
int loopchar = read();
|
|
if ('0' <= loopchar && loopchar <= '7')
|
|
{
|
|
curc = (curc << 3) + (loopchar - '0');
|
|
loopchar = read();
|
|
if ('0' <= loopchar && loopchar <= '7' && first <= '3')
|
|
{
|
|
curc = (curc << 3) + (loopchar - '0');
|
|
rc = read();
|
|
}
|
|
else
|
|
rc = loopchar;
|
|
}
|
|
else
|
|
rc = loopchar;
|
|
}
|
|
else
|
|
{
|
|
switch (curc)
|
|
{
|
|
|
|
case 'f':
|
|
curc = 0xC;
|
|
break;
|
|
|
|
case 'a':
|
|
curc = 0x7;
|
|
break;
|
|
|
|
case 'b':
|
|
curc = '\b';
|
|
break;
|
|
|
|
case 'v':
|
|
curc = 0xB;
|
|
break;
|
|
|
|
case 'n':
|
|
curc = '\n';
|
|
break;
|
|
|
|
case 'r':
|
|
curc = '\r';
|
|
break;
|
|
|
|
case 't':
|
|
curc = '\t';
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
rc = read();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
curc = rc;
|
|
rc = read();
|
|
}
|
|
if (i >= buf.Length)
|
|
{
|
|
char[] nb = new char[buf.Length * 2];
|
|
Array.Copy((System.Array) buf, 0, (System.Array) nb, 0, buf.Length);
|
|
buf = nb;
|
|
}
|
|
buf[i++] = (char) curc;
|
|
}
|
|
|
|
peekchar = (rc == lastttype)?System.Int32.MaxValue:rc;
|
|
|
|
StringValue = new String(buf, 0, i);
|
|
return lastttype;
|
|
}
|
|
|
|
if (curc == '/' && (cppcomments || ccomments))
|
|
{
|
|
curc = read();
|
|
if (curc == '*' && ccomments)
|
|
{
|
|
int prevc = 0;
|
|
while ((curc = read()) != '/' || prevc != '*')
|
|
{
|
|
if (curc == '\r')
|
|
{
|
|
linenumber++;
|
|
curc = read();
|
|
if (curc == '\n')
|
|
{
|
|
curc = read();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (curc == '\n')
|
|
{
|
|
linenumber++;
|
|
curc = read();
|
|
}
|
|
}
|
|
if (curc < 0)
|
|
return lastttype = (int) TokenTypes.EOF;
|
|
prevc = curc;
|
|
}
|
|
return nextToken();
|
|
}
|
|
else if (curc == '/' && cppcomments)
|
|
{
|
|
while ((curc = read()) != '\n' && curc != '\r' && curc >= 0)
|
|
;
|
|
peekchar = curc;
|
|
return nextToken();
|
|
}
|
|
else
|
|
{
|
|
if ((this.ctype['/'] & (sbyte)CharacterTypes.COMMENTCHAR) != 0)
|
|
{
|
|
while ((curc = read()) != '\n' && curc != '\r' && curc >= 0)
|
|
;
|
|
peekchar = curc;
|
|
return nextToken();
|
|
}
|
|
else
|
|
{
|
|
peekchar = curc;
|
|
return lastttype = '/';
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((ctype & (sbyte)CharacterTypes.COMMENTCHAR) != 0)
|
|
{
|
|
while ((curc = read()) != '\n' && curc != '\r' && curc >= 0)
|
|
;
|
|
peekchar = curc;
|
|
return nextToken();
|
|
}
|
|
|
|
return lastttype = curc;
|
|
}
|
|
|
|
}
|
|
}
|