public override ScriptCode CompileSourceCode(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
{
try
{
switch (sourceUnit.Kind)
{
case SourceCodeKind.SingleStatement:
case SourceCodeKind.Expression:
case SourceCodeKind.AutoDetect:
case SourceCodeKind.InteractiveCode:
return new TotemScriptCode(
engine, engine.ParseExprToLambda(sourceUnit),
sourceUnit);
//case SourceCodeKind.Statements:
//case SourceCodeKind.File:
// return new TotemScriptCode(
// engine, engine.ParseFileToLambda(sourceUnit.Path, sourceUnit.GetCode()),
// sourceUnit);
default:
throw Assert.Unreachable;
}
}
catch (Exception e)
{
// Real language implementation would have a specific type
// of exception. Also, they would pass errorSink down into
// the parser and add messages while doing tighter error
// recovery and continuing to parse.
errorSink.Add(sourceUnit, e.Message, SourceSpan.None, 0,
Severity.FatalError);
return null;
}
}
public Tokenizer(ErrorSink errorSink) {
_errors = errorSink;
_verbatim = false;
_state = new State(null);
_dontImplyDedent = true;
_python26 = true;
}
public Tokenizer() {
_errors = ErrorSink.Null;
_verbatim = true;
_state = new State(null);
_dontImplyDedent = true;
_python26 = true;
}
public Tokenizer(ErrorSink errorSink, bool verbatim, bool dontImplyDedent) {
ContractUtils.RequiresNotNull(errorSink, "errorSink");
_errors = errorSink;
_verbatim = verbatim;
_state = new State(null);
_dontImplyDedent = dontImplyDedent;
}
public Tokenizer(ErrorSink errorSink, PythonCompilerOptions options) {
ContractUtils.RequiresNotNull(errorSink, "errorSink");
ContractUtils.RequiresNotNull(options, "options");
_errors = errorSink;
_verbatim = options.Verbatim;
_state = new State(null);
_dontImplyDedent = options.DontImplyDedent;
_printFunction = options.PrintFunction;
_python26 = options.Python26;
}
private Parser(Tokenizer tokenizer, ErrorSink errorSink, ParserSink parserSink, ModuleOptions languageFeatures) {
ContractUtils.RequiresNotNull(tokenizer, "tokenizer");
ContractUtils.RequiresNotNull(errorSink, "errorSink");
ContractUtils.RequiresNotNull(parserSink, "parserSink");
tokenizer.ErrorSink = new TokenizerErrorSink(this);
_tokenizer = tokenizer;
_errors = errorSink;
_sink = parserSink;
Reset(tokenizer.SourceUnit, languageFeatures);
}
public Parser(ILexer lexer, ErrorSink errorSink = null, LuaCompilerOptions options = null)
{
Contract.Requires(lexer != null);
_lexer = lexer;
_errors = errorSink ?? ErrorSink.Default;
_options = options ?? LuaCompilerOptions.Default;
// Debug: used to display the sequence of tokens that were read
//TokenSink = (t, s) => Debug.Print("{0,-12} {1,-10} {2,-10} {3}", t.Symbol, s.Start, s.End, t.Lexeme);
// initialise the token management variables
Current = GetNextToken();
Next = GetNextToken();
}
private Parser(CompilerContext context, Tokenizer tokenizer, ErrorSink errorSink, ParserSink parserSink, ModuleOptions languageFeatures) {
ContractUtils.RequiresNotNull(tokenizer, "tokenizer");
ContractUtils.RequiresNotNull(errorSink, "errorSink");
ContractUtils.RequiresNotNull(parserSink, "parserSink");
tokenizer.ErrorSink = new TokenizerErrorSink(this);
_tokenizer = tokenizer;
_errors = errorSink;
if (parserSink != ParserSink.Null) {
_sink = parserSink;
}
_context = context;
Reset(tokenizer.SourceUnit, languageFeatures);
}
private TotemParser(CompilerContext context, TotemTokenizer tokenizer, ErrorSink errorSink, ParserSink parserSink)
{
ContractUtils.RequiresNotNull(tokenizer, "tokenizer");
ContractUtils.RequiresNotNull(errorSink, "errorSink");
ContractUtils.RequiresNotNull(parserSink, "parserSink");
tokenizer.ErrorSink = new TokenizerErrorSink(this);
_tokenizer = tokenizer;
_errors = errorSink;
if (parserSink != ParserSink.Null)
_sink = parserSink;
_context = context;
Reset(tokenizer.SourceUnit);
}
public override ScriptCode CompileSourceCode(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
{
SilverLexer lexer = new SilverLexer("source", sourceUnit.GetCode());
CommonTokenStream stream = new CommonTokenStream(lexer.Queue);
SilverParser parser = new SilverParser(stream);
lexer.SetLines (parser);
parser.SourceUnit = sourceUnit;
var res = parser.program();
if (res != null) {
Expression mainBlock = AstExpression.Block (res);
return new SilverScriptCode(mainBlock, sourceUnit);
} else {
throw new SyntaxErrorException("Syntax error", sourceUnit, SourceSpan.None, 0, Severity.Error);
}
}
public ErrorCounter(ErrorSink /*!*/ sink)
{
ContractUtils.RequiresNotNull(sink, "sink");
_sink = sink;
}
public CompilerContext(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
: this(sourceUnit, options, errorSink, null)
{
}
public override ScriptCode CompileSourceCode(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
{
throw new NotImplementedException();
}
public JavascriptGenerator(SourceUnit src, ErrorSink sink)
: base()
{
this.src = src;
this.sink = sink;
}
/// <summary>
/// Compiles a list of source units into a single module.
/// <c>scope</c> can be <c>null</c>.
/// <c>options</c> can be <c>null</c>.
/// <c>errorSink</c> can be <c>null</c>.
/// </summary>
public ScriptModule CompileModule(string name, ScriptModuleKind kind, Scope scope, CompilerOptions options, ErrorSink errorSink,
params SourceUnit[] sourceUnits)
{
Contract.RequiresNotNull(name, "name");
Contract.RequiresNotNullItems(sourceUnits, "sourceUnits");
// TODO: Two phases: parse/compile?
// compiles all source units:
ScriptCode[] scriptCodes = new ScriptCode[sourceUnits.Length];
for (int i = 0; i < sourceUnits.Length; i++)
{
scriptCodes[i] = LanguageContext.FromEngine(sourceUnits[i].Engine).CompileSourceCode(sourceUnits[i], options, errorSink);
}
return(CreateModule(name, kind, scope, scriptCodes));
}
protected override Microsoft.Scripting.ScriptCode CompileSourceCode(Microsoft.Scripting.SourceUnit sourceUnit, Microsoft.Scripting.CompilerOptions options, Microsoft.Scripting.ErrorSink errorSink)
{
return(null);
// ClojureParser cp = new ClojureParser(sourceUnit);
// LambdaExpression ast;
// switch (sourceUnit.Kind)
// {
// case SourceCodeKind.InteractiveCode:
// {
// ScriptCodeParseResult result;
// object code = cp.ParseInteractiveStatement(out result);
// sourceUnit.CodeProperties = result;
// if (result != ScriptCodeParseResult.Complete)
// return null;
// //ast = Generator.Generate(code, true);
// ast = Compiler.GenerateLambda(code, true);
// }
// break;
// default:
// sourceUnit.CodeProperties = ScriptCodeParseResult.Complete;
// ast = Generator.Generate(cp.ParseFile(), sourceUnit);
// break;
// }
// //ast = new GlobalLookupRewriter().RewriteLambda(ast);
// //DEBUG!!!
// //Compiler.SaveContext();
// return new LegacyScriptCode(ast, sourceUnit);
}
public Tokenizer(ErrorSink errorSink)
: this(errorSink, false) {
}
public override ScriptCode CompileSourceCode(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
{
ScriptCode res = CompileTotemCode(sourceUnit, options, errorSink);
if (res != null)
{
Scope scope = res.CreateScope();
// if this is an optimized module we need to initialize the optimized totemCode.
// Optimized scopes come w/ extensions already attached so we use that to know
// if we're optimized or not.
TotemScopeExtension scopeExtension = (TotemScopeExtension)scope.GetExtension(ContextId);
if (scopeExtension != null)
{
InitializeModule(sourceUnit.Path, scopeExtension.ModuleContext, res, ModuleOptions.None);
}
}
return res;
}
/// <summary>
/// Executes in a new scope created by the language.
/// </summary>
public object Execute(ErrorSink errorSink)
{
return(Compile(errorSink).Run());
}
public Tokenizer(ErrorSink errorSink, bool verbatim)
: this(errorSink, verbatim, true) {
}
public override ScriptCode CompileSourceCode(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
{
Module module = Parser.ParseModule(sourceUnit, this);
#if WRITE_AST
module.WriteString(new AstWriter(Console.Out));
#endif
AstAnalyzer ctsg = new AstAnalyzer(this);
return ctsg.Analyze(module, sourceUnit);
}
public ErrorCounter(ErrorSink/*!*/ sink) {
ContractUtils.RequiresNotNull(sink, "sink");
_sink = sink;
}
internal static ScriptCode CompileTotemCode(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
{
var totemOptions = (TotemCompilerOptions)options;
if (sourceUnit.Kind == SourceCodeKind.File)
{
totemOptions.Module |= ModuleOptions.Initialize;
}
CompilerContext context = new CompilerContext(sourceUnit, options, errorSink);
TotemAst ast = ParseAndBindAst(context);
if (ast == null)
{
return null;
}
return ast.ToScriptCode();
}
public Tokenizer(bool verbatim, ILexicalVariableResolver/*!*/ localVariableResolver) {
ContractUtils.RequiresNotNull(localVariableResolver, "localVariableResolver");
_errorSink = ErrorSink.Null;
_localVariableResolver = localVariableResolver;
_verbatim = verbatim;
_encoding = RubyEncoding.Binary;
}
/// <summary>
/// Used to support legacy CreateParser API.
/// </summary>
internal Tokenizer(ErrorSink errorSink, PythonCompilerOptions options, bool verbatim)
: this(errorSink, options) {
_verbatim = verbatim || options.Verbatim;
}
public ScriptCode CompileSourceCode(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
{
Contract.RequiresNotNull(sourceUnit, "sourceUnit");
if (options == null)
{
options = GetCompilerOptions();
}
if (errorSink == null)
{
errorSink = Engine.GetCompilerErrorSink();
}
CompilerContext context = new CompilerContext(sourceUnit, options, errorSink);
CodeBlock block = ParseSourceCode(context);
if (block == null)
{
throw new SyntaxErrorException("invalid syntax|" + sourceUnit.GetCode().Trim());
}
//DumpBlock(block, sourceUnit.Id);
AnalyzeBlock(block);
DumpBlock(block, sourceUnit.Id);
// TODO: ParseSourceCode can update CompilerContext.Options
return(new ScriptCode(block, Engine.GetLanguageContext(context.Options), context));
}
public ScriptCode Compile(ErrorSink errorSink)
{
return(Compile(_language.GetCompilerOptions(), errorSink));
}
public Tokenizer(bool verbatim, ErrorSink/*!*/ errorSink) {
ContractUtils.RequiresNotNull(errorSink, "errorSink");
_bigIntParser = new BignumParser();
_errorSink = errorSink;
_sourceUnit = null;
_parser = null;
_verbatim = verbatim;
_compatibility = RubyCompatibility.Default;
// _buffer = null;
_initialLocation = SourceLocation.Invalid;
_tokenSpan = SourceSpan.Invalid;
_tokenValue = new TokenValue();
_bufferPos = 0;
// TODO:
_input = null;
}
/// <summary>
/// Executes in a new scope created by the language.
/// </summary>
public object Execute(CompilerOptions options, ErrorSink errorSink)
{
return(Compile(options, errorSink).Run());
}
public ErrorCollector(ErrorSink sourceErrors)
{
_sourceErrors = sourceErrors;
}
