public ASLGrammar()
: base(true)
{
var string_lit = TerminalFactory.CreateCSharpString("string");
var number = TerminalFactory.CreateCSharpNumber("number");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var code = new CustomTerminal("code", MatchCodeTerminal);
var single_line_comment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimited_comment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(single_line_comment);
NonGrammarTerminals.Add(delimited_comment);
var state = new KeyTerm("state", "state");
var init = new KeyTerm("init", "init");
var exit = new KeyTerm("exit", "exit");
var update = new KeyTerm("update", "update");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var startup = new KeyTerm("startup", "startup");
var shutdown = new KeyTerm("shutdown", "shutdown");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var state_def = new NonTerminal("stateDef");
var version = new NonTerminal("version");
var state_list = new NonTerminal("stateList");
var method_list = new NonTerminal("methodList");
var var_list = new NonTerminal("varList");
var var = new NonTerminal("var");
var module = new NonTerminal("module");
var method = new NonTerminal("method");
var offset_list = new NonTerminal("offsetList");
var offset = new NonTerminal("offset");
var method_type = new NonTerminal("methodType");
root.Rule = state_list + method_list;
version.Rule = (comma + string_lit) | Empty;
state_def.Rule = state + "(" + string_lit + version + ")" + "{" + var_list + "}";
state_list.Rule = MakeStarRule(state_list, state_def);
method_list.Rule = MakeStarRule(method_list, method);
var_list.Rule = MakeStarRule(var_list, semi, var);
module.Rule = (string_lit + comma) | Empty;
var.Rule = (identifier + identifier + ":" + module + offset_list) | Empty;
method.Rule = (method_type + "{" + code + "}") | Empty;
offset_list.Rule = MakePlusRule(offset_list, comma, offset);
offset.Rule = number;
method_type.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown;
Root = root;
MarkTransient(var_list, method_list, offset, method_type);
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public ASLGrammar()
: base(true)
{
var stringLit = TerminalFactory.CreateCSharpString("string");
var number = TerminalFactory.CreateCSharpNumber("number");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var code = new CustomTerminal("code", MatchCodeTerminal);
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(delimitedComment);
var state = new KeyTerm("state", "state");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var stateDef = new NonTerminal("stateDef");
var methodList = new NonTerminal("methodList");
var varList = new NonTerminal("varList");
var var = new NonTerminal("var");
var method = new NonTerminal("method");
var offsetList = new NonTerminal("offsetList");
var offset = new NonTerminal("offset");
var methodType = new NonTerminal("methodType");
root.Rule = stateDef + methodList;
stateDef.Rule = state + "(" + stringLit + ")" + "{" + varList + "}";
methodList.Rule = MakeStarRule(methodList, method);
varList.Rule = MakeStarRule(varList, semi, var);
var.Rule = (identifier + identifier + ":" + stringLit + comma + offsetList) | Empty;
method.Rule = (methodType + "{" + code + "}") | Empty;
offsetList.Rule = MakePlusRule(offsetList, comma, offset);
offset.Rule = number;
methodType.Rule = start | split | isLoading | gameTime | reset;
this.Root = root;
MarkTransient(varList, methodList, offset, methodType);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public FunctionGrammer()
{
//Terminals
var StringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
var CharLiteral = TerminalFactory.CreateCSharpChar("CharLiteral");
var Number = TerminalFactory.CreateCSharpNumber("Number");
var identifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
//var guid_part_8 = new FixedLengthLiteral("guid_part_8", 8, TypeCode.String);
//var guid_part_4 = new FixedLengthLiteral("guid_part_4", 4, TypeCode.String);
//var guid_part_12 = new FixedLengthLiteral("guid_part_12", 12, TypeCode.String);
var guid_variable = new CustomTerminal("guid_variable", delegate(Terminal terminal, ParsingContext context, ISourceStream source)
{
var start = source.PreviewPosition;
if (source.PreviewChar == '@'
&& source.NextPreviewChar == '{'
&& source.Text.Length - start >= 39) // There are enough characters left to make a guid + @ symbol
{
Guid parsed_guid;
var guid_candidate = source.Text.Substring(start + 1, 38);
if (TryStrToGuid(guid_candidate, out parsed_guid))
{
source.PreviewPosition = source.PreviewPosition + 39;
return source.CreateToken(terminal, source.Text.Substring(start, 39));
}
}
return null;
});
//Symbols
KeyTerm colon = ToTerm(":", "colon");
KeyTerm semi = ToTerm(";", "semi");
KeyTerm comma = ToTerm(",", "comma");
KeyTerm Lbr = ToTerm("{");
KeyTerm Rbr = ToTerm("}");
KeyTerm Lpar = ToTerm("(");
KeyTerm Rpar = ToTerm(")");
KeyTerm qmark = ToTerm("?", "qmark");
KeyTerm at = ToTerm("@", "At");
KeyTerm hyphen = ToTerm("-");
//Nonterminals
var argument_list = new NonTerminal("argument_list");
var argument_list_opt = new NonTerminal("argument_list_opt");
var argument_list_par = new NonTerminal("argument_list_par");
var argument_list_par_opt = new NonTerminal("argument_list_par_opt");
var bin_op = new NonTerminal("bin_op", "operator symbol");
var bin_op_expression = new NonTerminal("bin_op_expression");
//var conditional_expression = new NonTerminal("conditional_expression");
var expression = new NonTerminal("expression");
var function_expression = new NonTerminal("function_expression");
//var guid = new NonTerminal("guid");
//var guid_variable = new NonTerminal("guid_variable");
var literal = new NonTerminal("literal");
var parenthesized_expression = new NonTerminal("parenthesized_expression");
var primary_expression = new NonTerminal("primary_expression");
//var typecast_expression = new NonTerminal("typecast_expression");
var unary_expression = new NonTerminal("unary_expression");
var unary_operator = new NonTerminal("unary_operator");
var qual_name_with_targs = new NonTerminal("qual_name_with_targs");
#region From CSharpGrammer
#region operators, punctuation and delimiters
RegisterOperators(1, "||");
RegisterOperators(2, "&&");
RegisterOperators(3, "|");
RegisterOperators(4, "^");
RegisterOperators(5, "&");
RegisterOperators(6, "==", "!=");
RegisterOperators(7, "<", ">", "<=", ">=", "is", "as");
RegisterOperators(8, "<<", ">>");
RegisterOperators(9, "+", "-");
RegisterOperators(10, "*", "/", "%");
//RegisterOperators(11, ".");
// RegisterOperators(12, "++", "--");
//The following makes sense, if you think about "?" in context of operator precedence.
// What we say here is that "?" has the lowest priority among arithm operators.
// Therefore, the parser should prefer reduce over shift when input symbol is "?".
// For ex., when seeing ? in expression "a + b?...", the parser will perform Reduce:
// (a + b)->expr
// and not shift the "?" symbol.
// Same goes for ?? symbol
RegisterOperators(-3, "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
RegisterOperators(-2, "?");
RegisterOperators(-1, "??");
this.Delimiters = "{}[](),:;+-*/%&|^!~<>=";
this.MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":");
this.MarkTransient(expression, literal, bin_op, primary_expression, expression);
this.AddTermsReportGroup("assignment", "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
this.AddTermsReportGroup("typename", "bool", "decimal", "float", "double", "string", "object", "sbyte", "byte", "short", "ushort", "int", "uint", "long", "ulong", "char");
this.AddTermsReportGroup("statement", "if", "switch", "do", "while", "for", "foreach", "continue", "goto", "return", "try", "yield", "break", "throw", "unchecked", "using");
this.AddTermsReportGroup("type declaration", "public", "private", "protected", "static", "internal", "sealed", "abstract", "partial", "class", "struct", "delegate", "interface", "enum");
this.AddTermsReportGroup("member declaration", "virtual", "override", "readonly", "volatile", "extern");
this.AddTermsReportGroup("constant", Number, StringLiteral, CharLiteral);
this.AddTermsReportGroup("constant", "true", "false", "null");
this.AddTermsReportGroup("unary operator", "+", "-", "!", "~");
this.AddToNoReportGroup(comma, semi);
this.AddToNoReportGroup("var", "const", "new", "++", "--", "this", "base", "checked", "lock", "typeof", "default", "{", "}", "[");
#endregion
#endregion
//Rules
//guid.Rule = guid_part_8 + hyphen + guid_part_4 + hyphen + guid_part_4 + hyphen + guid_part_4 + hyphen + guid_part_12;
//guid_variable.Rule = at + Lbr + guid + Rbr;
bin_op.Rule = ToTerm("<") | "||" | "&&" | "|" | "&" | "==" | "!=" | ">" | "<=" | ">=" | "+" | "-" | "*" | "/" | "%";
argument_list.Rule = MakePlusRule(argument_list, comma, expression);
argument_list_opt.Rule = Empty | argument_list;
argument_list_par.Rule = Lpar + argument_list_opt + Rpar;
argument_list_par_opt.Rule = Empty | argument_list_par;
bin_op_expression.Rule = expression + bin_op + expression;
parenthesized_expression.Rule = Lpar + expression + Rpar;
//typecast_expression.Rule = parenthesized_expression + primary_expression;
primary_expression.Rule = literal | unary_expression | parenthesized_expression;
//conditional_expression.Rule = expression + PreferShiftHere() + qmark + expression + colon + expression;// + ReduceThis();
unary_expression.Rule = unary_operator + primary_expression;
expression.Rule = bin_op_expression
| primary_expression
| function_expression
| guid_variable;
//| typecast_expression
//| conditional_expression;
literal.Rule = Number | StringLiteral | CharLiteral | "true" | "false" | "True" | "False" | "null";
unary_operator.Rule = ToTerm("-") | "!"; //ToTerm("+") | "-" | "!" | "~" | "*";
function_expression.Rule = identifier + argument_list_par;
//Set grammar root
this.Root = function_expression;
}
public ClarionGrammar() : base(false) { //case insensitive
base.GrammarComments = "Clarion grammar for parsing Clarion sources.";
//Terminals
var comment = new CommentTerminal("comment", "!", "\n");
this.NonGrammarTerminals.Add(comment);
_comment = comment;
var identifier = new IdentifierTerminal("identifier", ":", string.Empty);
var label = new IdentifierTerminal("label", ":", string.Empty);
label.ValidateToken += label_ValidateToken;
label.Priority = TerminalPriority.High;
//Clarion uses suffixes for identifying number base (bin, octal, hex) - unlike Irony's NumberLiteral which supports suffixes.
// We treat all numbers as hexadecimal with optional prefixes that don't mean anything. We "fix" the value in ValidateToken handler
var number = new NumberLiteral("number");
number.Options = NumberOptions.Hex | NumberOptions.DisableQuickParse;
number.AddSuffix("b", TypeCode.Int64);
number.AddSuffix("o", TypeCode.Int64);
number.AddSuffix("h", TypeCode.Int64);
number.ValidateToken += number_ValidateToken;
var string_lit = new StringLiteral("string_lit", "'", StringOptions.AllowsDoubledQuote | StringOptions.NoEscapes);
var comma = ToTerm(",");
var not = ToTerm("NOT");
//Non-terminals
var source_file = new NonTerminal("source_file");
var main_file = new NonTerminal("main_file");
//whitespace - NewLine, Empty line, line with compiler directive, or line with end-tag of Compile(..) directive
var wspace = new NonTerminal("wspace");
var ws_lines = new NonTerminal("ws_lines");
var ws_line = new NonTerminal("ws_line");
var compiler_dir = new NonTerminal("compiler_dir");
var compiler_dir_line = new NonTerminal("compiler_dir_line");
var cdir_compile_end_tag = new CustomTerminal("compile_end_tag", Match_compile_end_tag);
var cdir_include = new NonTerminal("cdir_include");
var cdir_equate = new NonTerminal("cdir_equate");
var cdir_compile_omit = new NonTerminal("cdir_compile_omit");
var compile_or_omit = new NonTerminal("compile_or_omit");
var cdir_section = new NonTerminal("cdir_section");
var once_opt = new NonTerminal("once_opt");
var const_value = new NonTerminal("const_value");
var comma_expr_opt = new NonTerminal("comma_expr_opt");
var comma_string_lit_opt = new NonTerminal("comma_string_lit_opt");
var member_file = new NonTerminal("member_file");
var file_hearder = new NonTerminal("file_header");
var map = new NonTerminal("map");
var map_opt = new NonTerminal("map_opt");
var map_elem = new NonTerminal("map_elem");
var map_elem_list = new NonTerminal("map_elem_list");
var proc_decl_list = new NonTerminal("proc_decl_list");
var proc_decl = new NonTerminal("proc_decl");
var proc_impl_list = new NonTerminal("proc_impl_list");
var proc_impl = new NonTerminal("proc_impl");
var data_decl_list = new NonTerminal("data_decl_list");
var data_decl_list_opt = new NonTerminal("data_decl_list_opt");
var data_decl = new NonTerminal("data_decl");
var stmt_list = new NonTerminal("stmt_list");
var stmt_line = new NonTerminal("stmt_line");
var stmt = new NonTerminal("stmt");
var assign_stmt = new NonTerminal("assign_stmt");
var expr = new NonTerminal("expr");
var expr_opt = new NonTerminal("expr_opt");
var bin_expr = new NonTerminal("bin_expr");
var bin_op = new NonTerminal("bin_op");
var fun_call = new NonTerminal("fun_call");
var par_expr = new NonTerminal("par_expr");
var expr_list = new NonTerminal("expr_list");
var term = new NonTerminal("term");
var module_decl = new NonTerminal("module_decl");
var module_header = new NonTerminal("module_ref");
var data_type = new NonTerminal("data_type");
var param_init_opt = new NonTerminal("param_init_opt");
var type_args_opt = new NonTerminal("type_args_opt");
var type_arg_list = new NonTerminal("type_arg_list");
var type_arg = new NonTerminal("type_arg");
var label_opt = new NonTerminal("label_opt");
var param_list = new NonTerminal("param_list");
var param = new NonTerminal("param");
var param_list_par_opt = new NonTerminal("param_list_par_opt");
var attr_list_tail_opt = new NonTerminal("attr_list_tail_opt");
var attr_list = new NonTerminal("attr_list");
var attr_def = new NonTerminal("attr_def");
var return_line_opt = new NonTerminal("return_line_opt");
var end_line = new NonTerminal("end_line");
//Rules
base.Root = source_file;
source_file.Rule = main_file | member_file;
//whitespace - includes compiler directives
wspace.Rule = NewLine + ws_lines;// +ReduceHere();
ws_lines.Rule = MakeStarRule(ws_lines, ws_line);
ws_line.Rule = compiler_dir | PreferShiftHere() + NewLine + ReduceHere();
//compiler_dir_line.Rule = compiler_dir;
compiler_dir.Rule = cdir_include | cdir_equate | cdir_compile_omit | cdir_section | cdir_compile_end_tag;
cdir_include.Rule = ToTerm("INCLUDE") + "(" + string_lit + comma_string_lit_opt + ")" + once_opt;
comma_string_lit_opt.Rule = Empty | comma + string_lit;
once_opt.Rule = comma + "ONCE" | Empty;
cdir_equate.Rule = //ShiftIf("EQUATE").ComesBefore(NewLine) +
label + "EQUATE" + "(" + const_value + ")";
const_value.Rule = number | string_lit;
cdir_compile_omit.Rule = compile_or_omit + "(" + string_lit + comma_expr_opt + ")";
comma_expr_opt.Rule = Empty | comma + expr;
cdir_section.Rule = ToTerm("SECTION") + "(" + string_lit + ")";
compile_or_omit.Rule = ToTerm("COMPILE") | "OMIT";
//File structure
main_file.Rule = "PROGRAM" + wspace + map + data_decl_list_opt + wspace +
"CODE" + wspace + stmt_list + return_line_opt + proc_impl_list;
member_file.Rule = "MEMBER" + wspace + map_opt + data_decl_list + proc_impl_list;
//map
map_opt.Rule = map | Empty;
map.Rule = "MAP" + wspace + map_elem_list + end_line;
map_elem_list.Rule = MakeStarRule(map_elem_list, wspace, map_elem);
map_elem.Rule = proc_decl | module_header;
module_decl.Rule = module_header + proc_decl_list + end_line;
module_header.Rule = ToTerm("MODULE") + "(" + string_lit + ")" + wspace;
proc_decl_list.Rule = MakePlusRule(proc_decl_list, proc_decl);
proc_decl.Rule = label + "PROCEDURE" + param_list_par_opt + attr_list_tail_opt + wspace;
param_list_par_opt.Rule = Empty | "(" + param_list + ")";
param_list.Rule = MakePlusRule(param_list, comma, param);
param.Rule = data_type + identifier + param_init_opt;
param_init_opt.Rule = Empty | "=" + number;
data_type.Rule = identifier + type_args_opt;
type_args_opt.Rule = Empty | "(" + type_arg_list + ")";
type_arg_list.Rule = MakePlusRule(type_arg_list, comma, type_arg);
type_arg.Rule = number | identifier;
attr_list_tail_opt.Rule = Empty | comma + attr_list;
attr_list.Rule = MakePlusRule(attr_list, comma, attr_def);
attr_def.Rule = identifier + param_list_par_opt;
data_decl_list.Rule = MakePlusRule(data_decl_list, data_decl);
data_decl_list_opt.Rule = data_decl_list | Empty;
data_decl.Rule = identifier + data_type + wspace;
proc_impl_list.Rule = MakeStarRule(proc_impl_list, proc_impl);
proc_impl.Rule = proc_decl + data_decl_list + "CODE" + wspace + stmt_list + return_line_opt + wspace;
stmt_list.Rule = MakeStarRule(stmt_list, stmt_line);
stmt_line.Rule = stmt + wspace;
stmt.Rule = assign_stmt | fun_call;
assign_stmt.Rule = identifier + "=" + expr;
expr.Rule = fun_call | par_expr | bin_expr | term;
par_expr.Rule = "(" + expr + ")";
bin_expr.Rule = expr + bin_op + expr;
bin_op.Rule = ToTerm("+") | "-" | "*" | "/" | "^" | "%"
| "&"
| "=" | "<" | ">" | "~=" | "~<" | "~>" | not + "=" | not + "<" | not + ">"
| "<>" | "<=" | "=<" | ">=" | "=>"
| "~" | not | "AND" | "OR" | "XOR";
fun_call.Rule = identifier + "(" + expr_list + ")";
expr_list.Rule = MakeStarRule(expr_list, comma, expr);
expr_opt.Rule = expr | Empty;
term.Rule = identifier | number | string_lit;
return_line_opt.Rule = "RETURN" + expr_opt | Empty;
end_line.Rule = "END" + NewLine | "." + NewLine;
//operator precedence
RegisterOperators(10, "OR", "XOR");
RegisterOperators(20, "AND");
RegisterOperators(50, "=", "<", ">", "~=", "~<", "~>", "<>", "<=", "=<", ">=", "=>");
RegisterOperators(100, "+", "-");
RegisterOperators(110, "*", "/", "%", "&");
RegisterOperators(120, Associativity.Right, "^");
RegisterOperators(130, not);
RegisterOperators(130, "~");
//punctuation, brace pairs, transient nodes
MarkPunctuation("(", ")", ",");
RegisterBracePair("(", ")");
//Reserved words and special words
var resWordList = "ACCEPT AND BEGIN BREAK BY CASE CHOOSE COMPILE CYCLE DO ELSE ELSIF END EXECUTE EXIT FUNCTION GOTO IF INCLUDE LOOP" +
" MEMBER NEW NOT NULL OF OMIT OR OROF PARENT PROCEDURE PROGRAM RETURN ROUTINE SECTION SELF THEN TIMES TO UNTIL WHILE XOR";
this.MarkReservedWords(resWordList.Split(' '));
var specialWordsList = "APPLICATION CLASS CODE DATA DETAIL FILE FOOTER FORM GROUP HEADER ITEM ITEMIZE JOIN MAP MENU MENUBAR" +
" MODULE OLECONTROL OPTION QUEUE RECORD REPORT ROW SHEET TAB TABLE TOOLBAR VIEW WINDOW";
//Initialize special words list (words that cannot be used as proc names); we'll later use them for verifying proc names
SpecialWords = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
SpecialWords.UnionWith(specialWordsList.Split(' '));
}
