[Mono-list] A new 'mcs' driver that automatically find available parsers in the assembly
A Rafael D Teixeira
rafaelteixeirabr@hotmail.com
Tue, 25 Sep 2001 18:59:53 -0300
This is a multi-part message in MIME format.
------=_NextPart_000_3f50_4bae_5570
Content-Type: text/plain; format=flowed
The attached mcs.diff reflect the changes in GenericParser.cs, Driver.cs, to
allow the automatic finding of parsers.
It also has changes to cs-parser.jay and cs-tokenizer.cs to better conform
with GenericParser.
The tokenizer was moved to namespace Mono.Languages.CSharp as planned, but
the parser not yet, because at least two other classes are still explicitly
referencing it by name.
Location.cs was created from that small class of the same name, originally
present in cs-tokenizer.cs, because it is used by lots of other classes and
is reused by mbas-tokenizer.cs as well.
The makefile has now a target 'mbas' that adds the MonoBasic files, the
resulting file accepts .vb files correctly but the jay file was stripped to
keep it from being a problem for you, as I will restart the grammar effort.
If you do:
make
./compiler assign.cs
youŽll get
[DEBUG] CIR.CSharpParser parses '.cs' files
assign.cs(23,16): Error CS1520: Class, struct, or interface method must have
a return type
If you do:
make mbas
./compiler assign.cs
youŽll get
[DEBUG] CIR.CSharpParser parses '.cs' files
[DEBUG] Mono.Languages.MonoBASIC.MonoBASICParser parses '.vb' files
assign.cs(23,16): Error CS1520: Class, struct, or interface method must have
a return type
That isnŽt possible with Microsoft Tools: the mixing of languages IN THE
SAME ASSEMBLY/MODULE.
Within MS .NET you have to compile a vb dll with vbc, reference it in the
csharp project, that then has to be compiled with csc.
Rafael Teixeira
Brazilian Developer
_________________________________________________________________
Get your FREE download of MSN Explorer at http://explorer.msn.com/intl.asp
------=_NextPart_000_3f50_4bae_5570
Content-Type: application/octet-stream; name="mbas-parser.jay"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="mbas-parser.jay"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------=_NextPart_000_3f50_4bae_5570
Content-Type: text/plain; name="location.cs"; format=flowed
Content-Transfer-Encoding: 8bit
Content-Disposition: attachment; filename="location.cs"
using System;
namespace CIR
{
public class Location {
public readonly string Name;
public readonly int Col;
public readonly int Row;
public Location (string name, int col, int row)
{
Name = name;
Col = col;
Row = row;
}
}
}
------=_NextPart_000_3f50_4bae_5570
Content-Type: text/plain; name="mbas-tokenizer.cs"; format=flowed
Content-Transfer-Encoding: 8bit
Content-Disposition: attachment; filename="mbas-tokenizer.cs"
//
// mbas-tokenizer.cs: The Tokenizer for the MonoBASIC compiler
//
// Author: A Rafael D Teixeira (rafaelteixeirabr@hotmail.com)
//
// Based on cs-tokenizer.cs by Miguel de Icaza (miguel@gnu.org)
//
// Licensed under the terms of the GNU GPL
//
// Copyright (C) 2001 A Rafael D Teixeira
//
/*
Todo:
EVERYTHING
*/
namespace Mono.Languages.MonoBASIC
{
using System;
using System.Text;
using System.Collections;
using System.IO;
using System.Globalization;
using Mono.Languages.MonoBASIC;
/// <summary>
/// Tokenizer for MonoBASIC source code.
/// </summary>
public class Tokenizer : yyParser.yyInput
{
TextReader reader;
public string ref_name;
public int ref_line = 1;
public int line = 1;
public int col = 1;
public int current_token;
bool handle_get_set = false;
public string location {
get {
string det;
if (current_token == Token.ERROR)
det = "detail: " + error_details;
else
det = "";
return "Line: "+line+" Col: "+col + "\n" +
"VirtLine: "+ref_line +
" Token: "+current_token + " " + det;
}
}
public bool properties {
get {
return handle_get_set;
}
set {
handle_get_set = value;
}
}
//
// Class variables
//
static Hashtable keywords;
static NumberStyles styles;
static NumberFormatInfo csharp_format_info;
//
// Values for the associated token returned
//
System.Text.StringBuilder number;
int putback_char;
Object val;
//
// Details about the error encoutered by the tokenizer
//
string error_details;
public string error {
get {
return error_details;
}
}
public int Line {
get {
return line;
}
}
public int Col {
get {
return col;
}
}
static void initTokens ()
{
keywords = new Hashtable ();
keywords.Add ("addhandler", Token.ADDHANDLER);
keywords.Add ("addressof", Token.ADDRESSOF);
keywords.Add ("alias", Token.ALIAS);
keywords.Add ("and", Token.AND);
keywords.Add ("andalso", Token.ANDALSO);
keywords.Add ("ansi", Token.ANSI);
keywords.Add ("as", Token.AS);
keywords.Add ("assembly", Token.ASSEMBLY);
keywords.Add ("auto", Token.AUTO);
keywords.Add ("boolean", Token.BOOLEAN);
keywords.Add ("byref", Token.BYREF);
keywords.Add ("byte", Token.BYTE);
keywords.Add ("byval", Token.BYVAL);
keywords.Add ("call", Token.CALL);
keywords.Add ("case", Token.CASE);
keywords.Add ("catch", Token.CATCH);
keywords.Add ("cbool", Token.CBOOL);
keywords.Add ("cbyte", Token.CBYTE);
keywords.Add ("cchar", Token.CCHAR);
keywords.Add ("cdate", Token.CDATE);
keywords.Add ("cdec", Token.CDEC);
keywords.Add ("cdbl", Token.CDBL);
keywords.Add ("char", Token.CHAR);
keywords.Add ("cint", Token.CINT);
keywords.Add ("class", Token.CLASS);
keywords.Add ("clng", Token.CLNG);
keywords.Add ("cobj", Token.COBJ);
//keywords.Add ("compare", Token.COMPARE);
keywords.Add ("const", Token.CONST);
keywords.Add ("cshort", Token.CSHORT);
keywords.Add ("csng", Token.CSNG);
keywords.Add ("cstr", Token.CSTR);
keywords.Add ("ctype", Token.CTYPE);
keywords.Add ("date", Token.DATE);
keywords.Add ("decimal", Token.DECIMAL);
keywords.Add ("declare", Token.DECLARE);
keywords.Add ("default", Token.DEFAULT);
keywords.Add ("delegate", Token.DELEGATE);
keywords.Add ("dim", Token.DIM);
keywords.Add ("do", Token.DO);
keywords.Add ("double", Token.DOUBLE);
keywords.Add ("each", Token.EACH);
keywords.Add ("else", Token.ELSE);
keywords.Add ("elseif", Token.ELSEIF);
keywords.Add ("end", Token.END);
keywords.Add ("enum", Token.ENUM);
keywords.Add ("erase", Token.ERASE);
keywords.Add ("error", Token.ERROR);
keywords.Add ("event", Token.EVENT);
keywords.Add ("exit", Token.EXIT);
//keywords.Add ("explicit", Token.EXPLICIT);
keywords.Add ("false", Token.FALSE);
keywords.Add ("finally", Token.FINALLY);
keywords.Add ("for", Token.FOR);
keywords.Add ("friend", Token.FRIEND);
keywords.Add ("function", Token.FUNCTION);
keywords.Add ("get", Token.GET);
keywords.Add ("gettype", Token.GETTYPE);
keywords.Add ("goto", Token.GOTO);
keywords.Add ("handles", Token.HANDLES);
keywords.Add ("if", Token.IF);
keywords.Add ("implements", Token.IMPLEMENTS);
keywords.Add ("imports", Token.IMPORTS);
keywords.Add ("in", Token.IN);
keywords.Add ("inherits", Token.INHERITS);
keywords.Add ("integer", Token.INTEGER);
keywords.Add ("interface", Token.INTERFACE);
keywords.Add ("is", Token.IS);
keywords.Add ("let ", Token.LET );
keywords.Add ("lib ", Token.LIB );
keywords.Add ("like ", Token.LIKE );
keywords.Add ("long", Token.LONG);
keywords.Add ("loop", Token.LOOP);
keywords.Add ("me", Token.ME);
keywords.Add ("mod", Token.MOD);
keywords.Add ("module", Token.MODULE);
keywords.Add ("mustinherit", Token.MUSTINHERIT);
keywords.Add ("mustoverride", Token.MUSTOVERRIDE);
keywords.Add ("mybase", Token.MYBASE);
keywords.Add ("myclass", Token.MYCLASS);
keywords.Add ("namespace", Token.NAMESPACE);
keywords.Add ("new", Token.NEW);
keywords.Add ("next", Token.NEXT);
keywords.Add ("not", Token.NOT);
keywords.Add ("nothing", Token.NOTHING);
keywords.Add ("notinheritable", Token.NOTINHERITABLE);
keywords.Add ("notoverridable", Token.NOTOVERRIDABLE);
keywords.Add ("object", Token.OBJECT);
keywords.Add ("on", Token.ON);
keywords.Add ("option", Token.OPTION);
keywords.Add ("optional", Token.OPTIONAL);
keywords.Add ("or", Token.OR);
keywords.Add ("orelse", Token.ORELSE);
keywords.Add ("overloads", Token.OVERLOADS);
keywords.Add ("overridable", Token.OVERRIDABLE);
keywords.Add ("overrides", Token.OVERRIDES);
keywords.Add ("paramarray", Token.PARAM_ARRAY);
keywords.Add ("preserve", Token.PRESERVE);
keywords.Add ("private", Token.PRIVATE);
keywords.Add ("property", Token.PROPERTY);
keywords.Add ("protected", Token.PROTECTED);
keywords.Add ("public", Token.PUBLIC);
keywords.Add ("raiseevent", Token.RAISEEVENT);
keywords.Add ("readonly", Token.READONLY);
keywords.Add ("redim", Token.REDIM);
keywords.Add ("rem", Token.REM);
keywords.Add ("removehandler", Token.REMOVEHANDLER);
keywords.Add ("resume", Token.RESUME);
keywords.Add ("return", Token.RETURN);
keywords.Add ("select", Token.SELECT);
keywords.Add ("set", Token.SET);
keywords.Add ("shadows", Token.SHADOWS);
keywords.Add ("shared", Token.SHARED);
keywords.Add ("short", Token.SHORT);
keywords.Add ("single", Token.SINGLE);
keywords.Add ("sizeof", Token.SIZEOF);
keywords.Add ("static", Token.STATIC);
keywords.Add ("step", Token.STEP);
keywords.Add ("stop", Token.STOP);
keywords.Add ("string", Token.STRING);
keywords.Add ("structure", Token.STRUCTURE);
keywords.Add ("sub", Token.SUB);
keywords.Add ("synclock", Token.SYNCLOCK);
keywords.Add ("then", Token.THEN);
keywords.Add ("throw", Token.THROW);
keywords.Add ("to", Token.TO);
keywords.Add ("true", Token.TRUE);
keywords.Add ("try", Token.TRY);
keywords.Add ("typeof", Token.TYPEOF);
keywords.Add ("unicode", Token.UNICODE);
keywords.Add ("until", Token.UNTIL);
keywords.Add ("variant", Token.VARIANT);
keywords.Add ("when", Token.WHEN);
keywords.Add ("while", Token.WHILE);
keywords.Add ("with", Token.WITH);
keywords.Add ("withevents", Token.WITHEVENTS);
keywords.Add ("writeonly", Token.WRITEONLY);
keywords.Add ("xor", Token.XOR);
}
//
// Class initializer
//
static Tokenizer ()
{
initTokens ();
csharp_format_info = new NumberFormatInfo ();
csharp_format_info.CurrencyDecimalSeparator = ".";
styles = NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint;
}
bool is_keyword (string name)
{
bool res;
res = keywords.Contains(name.ToLower());
if ((name == "get" || name == "set") && handle_get_set == false)
return false;
return res;
}
int getKeyword (string name)
{
return (int) (keywords [name.ToLower()]);
}
public Tokenizer (System.IO.TextReader input, string fname)
{
this.ref_name = fname;
reader = input;
putback_char = -1;
}
bool is_identifier_start_character (char c)
{
return Char.IsLetter (c) || c == '_' ;
}
bool is_identifier_part_character (char c)
{
return (Char.IsLetter (c) || Char.IsDigit (c) || c == '_');
}
int is_punct (char c, ref bool doread)
{
int idx = "{}[](),:;~+-*/%&|^!=<>?".IndexOf (c);
int d;
int t;
doread = false;
switch (c){
case '{':
return Token.OPEN_BRACE;
case '}':
return Token.CLOSE_BRACE;
case '[':
return Token.OPEN_BRACKET;
case ']':
return Token.CLOSE_BRACKET;
case '(':
return Token.OPEN_PARENS;
case ')':
return Token.CLOSE_PARENS;
case ',':
return Token.COMMA;
case ':':
return Token.COLON;
case ';':
return Token.SEMICOLON;
case '~':
return Token.TILDE;
case '?':
return Token.INTERR;
}
d = peekChar ();
if (c == '+'){
if (d == '+')
t = Token.OP_INC;
else if (d == '=')
t = Token.OP_ADD_ASSIGN;
else
return Token.PLUS;
doread = true;
return t;
}
if (c == '-'){
if (d == '=')
t = Token.OP_SUB_ASSIGN;
else
return Token.MINUS;
doread = true;
return t;
}
if (c == '='){
/*if (d == '='){
doread = true;
return Token.OP_EQ;
}*/
return Token.ASSIGN;
}
if (c == '*'){
if (d == '='){
doread = true;
return Token.OP_MULT_ASSIGN;
}
return Token.STAR;
}
if (c == '/'){
if (d == '='){
doread = true;
return Token.OP_DIV_ASSIGN;
}
return Token.DIV;
}
if (c == '\\'){
if (d == '='){
doread = true;
return Token.OP_IDIV_ASSIGN;
}
return Token.OP_IDIV;
}
if (c == '^'){
if (d == '='){
doread = true;
return Token.OP_EXP_ASSIGN;
}
return Token.OP_EXP;
}
if (c == '<'){
if (d == '>')
{
doread = true;
return Token.OP_NE;
}
if (d == '='){
doread = true;
return Token.OP_LE;
}
return Token.OP_LT;
}
if (c == '>'){
if (d == '='){
doread = true;
return Token.OP_GE;
}
return Token.OP_GT;
}
return Token.ERROR;
}
bool decimal_digits (int c)
{
int d;
bool seen_digits = false;
if (c != -1)
number.Append ((char) c);
while ((d = peekChar ()) != -1){
if (Char.IsDigit ((char)d)){
number.Append ((char) d);
getChar ();
seen_digits = true;
} else
break;
}
return seen_digits;
}
void hex_digits (int c)
{
int d;
if (c != -1)
number.Append ((char) c);
while ((d = peekChar ()) != -1){
char e = Char.ToUpper ((char) d);
if (Char.IsDigit (e) ||
(e >= 'A' && e <= 'F')){
number.Append ((char) e);
getChar ();
} else
break;
}
}
int real_type_suffix (int c)
{
int t;
switch (c){
case 'F': case 'f':
t = Token.LITERAL_SINGLE;
break;
case 'D': case 'd':
t = Token.LITERAL_DOUBLE;
break;
case 'M': case 'm':
t= Token.LITERAL_DECIMAL;
break;
default:
return Token.NONE;
}
getChar ();
return t;
}
int integer_type_suffix (int c)
{
// FIXME: Handle U and L suffixes.
// We also need to see in which kind of
// Int the thing fits better according to the spec.
return Token.LITERAL_INTEGER;
}
void adjust_int (int t)
{
val = new System.Int32();
val = System.Int32.Parse (number.ToString (), 0);
}
int adjust_real (int t)
{
string s = number.ToString ();
Console.WriteLine (s);
switch (t){
case Token.LITERAL_DECIMAL:
val = new System.Decimal ();
val = System.Decimal.Parse (
s, styles, csharp_format_info);
break;
case Token.LITERAL_DOUBLE:
val = new System.Double ();
val = System.Double.Parse (
s, styles, csharp_format_info);
break;
case Token.LITERAL_SINGLE:
val = new System.Double ();
val = (float) System.Double.Parse (
s, styles, csharp_format_info);
break;
case Token.NONE:
val = new System.Double ();
val = System.Double.Parse (
s, styles, csharp_format_info);
t = Token.LITERAL_DOUBLE;
break;
}
return t;
}
//
// Invoked if we know we have .digits or digits
//
int is_number (int c)
{
bool is_real = false;
number = new System.Text.StringBuilder ();
int type;
number.Length = 0;
if (Char.IsDigit ((char)c)){
if (c == '0' && peekChar () == 'x' || peekChar () == 'X'){
getChar ();
hex_digits (-1);
val = new System.Int32 ();
val = System.Int32.Parse (number.ToString (), NumberStyles.HexNumber);
return integer_type_suffix (peekChar ());
}
decimal_digits (c);
c = getChar ();
}
//
// We need to handle the case of
// "1.1" vs "1.string" (LITERAL_SINGLE vs NUMBER DOT IDENTIFIER)
//
if (c == '.'){
if (decimal_digits ('.')){
is_real = true;
c = peekChar ();
} else {
putback ('.');
number.Length -= 1;
adjust_int (Token.LITERAL_INTEGER);
return Token.LITERAL_INTEGER;
}
}
if (c == 'e' || c == 'E'){
is_real = true;
number.Append ("e");
getChar ();
c = peekChar ();
if (c == '+'){
number.Append ((char) c);
getChar ();
c = peekChar ();
} else if (c == '-'){
number.Append ((char) c);
getChar ();
c = peekChar ();
}
decimal_digits (-1);
c = peekChar ();
}
type = real_type_suffix (c);
if (type == Token.NONE && !is_real){
type = integer_type_suffix (c);
adjust_int (type);
putback (c);
return type;
} else
is_real = true;
if (is_real)
return adjust_real (type);
Console.WriteLine ("This should not be reached");
throw new Exception ("Is Number should never reach this point");
}
int escape (int c)
{
int d;
int v;
d = peekChar ();
if (c != '\\')
return c;
switch (d){
case 'a':
v = '\a'; break;
case 'b':
v = '\b'; break;
case 'n':
v = '\n'; break;
case 't':
v = '\t'; break;
case 'v':
v = '\v'; break;
case 'r':
v = 'c'; break;
case '\\':
v = '\\'; break;
case 'f':
v = '\f'; break;
case '0':
v = 0; break;
case '"':
v = '"'; break;
case '\'':
v = '\''; break;
default:
error_details = "cs1009: Unrecognized escape sequence " + (char)d;
return -1;
}
getChar ();
return v;
}
int getChar ()
{
if (putback_char != -1){
int x = putback_char;
putback_char = -1;
return x;
}
return reader.Read ();
}
int peekChar ()
{
if (putback_char != -1)
return putback_char;
return reader.Peek ();
}
void putback (int c)
{
if (putback_char != -1)
throw new Exception ("This should not happen putback on putback");
putback_char = c;
}
public bool advance ()
{
return current_token != Token.EOF ;
}
public Object Value {
get {
return val;
}
}
public Object value ()
{
return val;
}
public int token ()
{
current_token = xtoken ();
if (current_token == 0)
return Token.EOF;
return current_token;
}
public int xtoken ()
{
int t;
bool allow_keyword_as_ident = false;
bool doread = false;
int c;
val = null;
for (;(c = getChar ()) != -1; col++) {
if (c == '\n')
{
line++;
ref_line++;
col = 0;
return Token.EOL;
}
if (is_identifier_start_character ((char) c)){
System.Text.StringBuilder id = new System.Text.StringBuilder ();
string ids;
id.Append ((char) c);
while ((c = peekChar ()) != -1) {
if (is_identifier_part_character ((char) c)){
id.Append ((char)getChar ());
col++;
} else
break;
}
ids = id.ToString ();
if (!is_keyword (ids) || allow_keyword_as_ident) {
val = ids;
return Token.IDENTIFIER;
}
// true, false and null are in the hash anyway.
return getKeyword (ids);
}
if (c == '.'){
if (Char.IsDigit ((char) peekChar ()))
return is_number (c);
return Token.DOT;
}
if (Char.IsDigit ((char) c))
return is_number (c);
// Handle line comments.
if (c == '\''){
int d = getChar ();
while ((d = getChar ()) != -1 && (d != '\n'))
col++;
line++;
ref_line++;
col = 0;
return Token.EOL;
}
/* For now, ignore pre-processor commands */
if (col == 1 && c == '#'){
System.Text.StringBuilder s = new System.Text.StringBuilder ();
while ((c = getChar ()) != -1 && (c != '\n')){
s.Append ((char) c);
}
if (String.Compare (s.ToString (), 0, "line", 0, 4) == 0){
string arg = s.ToString ().Substring (5);
int pos;
if ((pos = arg.IndexOf (' ')) != -1 && pos != 0){
ref_line = System.Int32.Parse (arg.Substring (0, pos));
pos++;
char [] quotes = { '\"' };
ref_name = arg.Substring (pos);
ref_name.TrimStart (quotes);
ref_name.TrimEnd (quotes);
} else
ref_line = System.Int32.Parse (arg);
}
line++;
ref_line++;
continue;
}
if ((t = is_punct ((char)c, ref doread)) != Token.ERROR){
if (doread){
getChar ();
col++;
}
return t;
}
if (c == '"'){
System.Text.StringBuilder s = new System.Text.StringBuilder ();
while ((c = getChar ()) != -1){
if (c == '"'){
val = s.ToString ();
return Token.LITERAL_STRING;
}
c = escape (c);
if (c == -1)
return Token.ERROR;
s.Append ((char) c);
}
}
if (c == '\''){
c = getChar ();
if (c == '\''){
error_details = "CS1011: Empty character literal";
return Token.ERROR;
}
c = escape (c);
if (c == -1)
return Token.ERROR;
val = new System.Char ();
val = (char) c;
c = getChar ();
if (c != '\''){
error_details = "CS1012: Too many characters in character literal";
// Try to recover, read until newline or next "'"
while ((c = getChar ()) != -1){
if (c == '\n' || c == '\'')
break;
}
return Token.ERROR;
}
return Token.LITERAL_CHARACTER;
}
// white space
if (c == ' ' || c == '\t' || c == '\f' || c == '\v' || c == '\r'){
if (c == '\t')
col = (((col + 8) / 8) * 8) - 1;
continue;
}
if (c == '@'){
allow_keyword_as_ident = true;
continue;
}
error_details = ((char)c).ToString ();
return Token.ERROR;
}
return Token.EOF;
}
}
}
------=_NextPart_000_3f50_4bae_5570
Content-Type: application/octet-stream; name="mcs.diff"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="mcs.diff"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------=_NextPart_000_3f50_4bae_5570--