public override object VisitFunctionAssignment_Ex([NotNull] ClepsParser.FunctionAssignmentContext context) { VariableManager variableManager = new VariableManager(); VariableManagers.Add(variableManager); ClepsType returnType = VoidType.GetVoidType(); if(context.FunctionReturnType != null) { returnType = Visit(context.FunctionReturnType) as ClepsType; } List<ClepsType> parameterTypes = context._FunctionParameterTypes.Select(t => Visit(context.FunctionReturnType) as ClepsType).ToList(); FunctionClepsType functionType = new FunctionClepsType(parameterTypes, returnType); IMethodRegister methodRegister = CodeGenerator.GetMethodRegister(FullyQualifiedClassName, CurrMemberIsStatic, CurrMemberType, CurrMemberName); var formalParameterNames = context._FormalParameters.Select(p => Visit(p) as string).ToList(); methodRegister.SetFormalParameterNames(formalParameterNames); formalParameterNames.Zip(parameterTypes, (name, clepsType) => new ClepsVariable(name, clepsType)) .ToList().ForEach(variable => { variableManager.AddLocalVariable(variable, methodRegister.GetFormalParameterRegister(variable.VariableName)); }); Visit(context.statementBlock()); VariableManagers.RemoveAt(VariableManagers.Count - 1); return functionType; }
public void Output(string directoryName, string fileNameWithoutExtension, CompileStatus status) { StringBuilder output = new StringBuilder(); InitializeOutput(output); foreach(var nativeCodeSnippet in GlobalNativeCodeSnippets) { output.AppendLine(nativeCodeSnippet); } foreach (var clepsClass in ClassesLoaded) { GenerateClass(output, clepsClass.Value); } output.AppendLine(GlobalInitializer.GetMethodBodyWithoutDeclaration()); FunctionClepsType voidFuncType = new FunctionClepsType(new List<ClepsType>(), VoidClepsType.GetVoidType()); foreach (var clepsType in CompilerConstants.SystemSupportedTypes) { output.AppendFormat("{0}.{1}.{2}();\n", JavaScriptCodeParameters.TOPLEVELNAMESPACE, clepsType.GetClepsTypeString(), JavaScriptCodeParameters.GetMangledFunctionName("classStaticInitializer", voidFuncType)); } if (!String.IsNullOrWhiteSpace(EntryPointClass) && !String.IsNullOrWhiteSpace(EntryPointFunctionName)) { output.AppendFormat("{0}.{1}.{2}();\n", JavaScriptCodeParameters.TOPLEVELNAMESPACE, EntryPointClass, JavaScriptCodeParameters.GetMangledFunctionName("classStaticInitializer", voidFuncType)); output.AppendFormat("{0}.{1}.{2}();\n", JavaScriptCodeParameters.TOPLEVELNAMESPACE, EntryPointClass, JavaScriptCodeParameters.GetMangledFunctionName(EntryPointFunctionName, voidFuncType)); } var outputFileName = Path.Combine(directoryName, fileNameWithoutExtension + ".js"); File.WriteAllText(outputFileName, output.ToString()); }
public override IMethodValue VisitFunctionAssignment_Ex([NotNull] ClepsParser.FunctionAssignmentContext context) { var oldCurrMethodRegister = CurrMethodGenerator; VariableManager variableManager = new VariableManager(); VariableManagers.Add(variableManager); ClepsType returnType = VoidClepsType.GetVoidType(); if (context.FunctionReturnType != null) { returnType = Visit(context.FunctionReturnType) as ClepsType; } List<ClepsVariable> functionParameters = context._FunctionParameters.Select(p => Visit(p) as ClepsVariable).ToList(); FunctionClepsType functionType = new FunctionClepsType(functionParameters.Select(p => p.VariableType).ToList(), returnType); var newMethod = CodeGenerator.CreateNewMethod(functionType); CurrMethodGenerator = newMethod; CurrMethodGenerator.SetFormalParameterNames(functionParameters.Select(p => p.VariableName).ToList()); functionParameters.ForEach(variable => { variableManager.AddLocalVariable(variable, CurrMethodGenerator.GetFormalParameterRegister(variable.VariableName)); }); Visit(context.statementBlock()); VariableManagers.RemoveAt(VariableManagers.Count - 1); CurrMethodGenerator = oldCurrMethodRegister; return newMethod; }
public override bool NotNullObjectEquals(ClepsType obj) { if (obj.GetType() != typeof(FunctionClepsType)) { return(false); } FunctionClepsType objToCompare = obj as FunctionClepsType; return(ReturnType == objToCompare.ReturnType && ParameterTypes.SequenceEqual(objToCompare.ParameterTypes)); }
public static string GetMangledFunctionName(string currentFunctionName, FunctionClepsType functionType) { string ret = String.Format("{0} {1}", currentFunctionName, functionType.GetClepsTypeString()); foreach(var kvp in CHARACTERSUBSTITUTIONS) { ret = ret.Replace(kvp.Key, kvp.Value); } return ret; }
public void Initiate() { FunctionClepsType voidFuncType = new FunctionClepsType(new List<ClepsType>(), VoidClepsType.GetVoidType()); ClassesLoaded = new Dictionary<string, ClepsClass>(); ClassInitializers = new Dictionary<string, JavaScriptMethod>(); ClassStaticInitializers = new Dictionary<string, JavaScriptMethod>(); GlobalInitializer = new JavaScriptMethod(voidFuncType); EntryPointClass = null; EntryPointFunctionName = null; GlobalNativeCodeSnippets = new List<string>(); }
private void GenerateClass(StringBuilder output, ClepsClass clepsClass) { FunctionClepsType voidFuncType = new FunctionClepsType(new List<ClepsType>(), VoidClepsType.GetVoidType()); EnsureNamespaceExists(output, clepsClass); output.AppendLine(JavaScriptCodeParameters.TOPLEVELNAMESPACE + "." + clepsClass.FullyQualifiedName + " = function() {"); { clepsClass.MemberVariables.ToList().ForEach(kvp => output.AppendFormat("\tthis.{0} = undefined;\n", kvp.Key)); output.AppendFormat("\tthis.{0}();\n", JavaScriptCodeParameters.GetMangledFunctionName("classInitializer", voidFuncType)); output.AppendFormat("\t{0}.{1}.{2}();\n", JavaScriptCodeParameters.TOPLEVELNAMESPACE, clepsClass.FullyQualifiedName, JavaScriptCodeParameters.GetMangledFunctionName("classStaticInitializer", voidFuncType)); } output.AppendLine("};"); GenerateMethodWithBody(output, clepsClass.FullyQualifiedName, "classInitializer", voidFuncType, false, ClassInitializers[clepsClass.FullyQualifiedName]); GenerateMethodWithBody(output, clepsClass.FullyQualifiedName, "classStaticInitializer", voidFuncType, true, ClassStaticInitializers[clepsClass.FullyQualifiedName]); }
public JavaScriptMethod(FunctionClepsType methodType) : base("", methodType) { }
public IMethodValue CreateNewMethod(FunctionClepsType functionType) { var methodRegister = new JavaScriptMethod(functionType); return methodRegister; }
public IValue GetFunctionCallReturnValue(IValue target, BasicClepsType targetType, string targetFunctionName, FunctionClepsType clepsType, List<IValue> parameters) { string code; if (CompilerConstants.SystemSupportedTypes.Contains(targetType) && target != null) { string fullFunctionName = String.Format("{0}.{1}.prototype.{2}", JavaScriptCodeParameters.TOPLEVELNAMESPACE, targetType.GetClepsTypeString(), JavaScriptCodeParameters.GetMangledFunctionName(targetFunctionName, clepsType)); string functionTarget = target != null ? (target as JavaScriptValue).Expression : String.Format("{0}.{1}", JavaScriptCodeParameters.TOPLEVELNAMESPACE, targetType.GetClepsTypeString()); string parameterString = String.Join("", parameters.Select(v => ", " + (v as JavaScriptValue).Expression).ToList()); code = String.Format("{0}.call({1}{2})", fullFunctionName, functionTarget, parameterString); } else { string functionTarget = target != null ? (target as JavaScriptValue).Expression : String.Format("{0}.{1}", JavaScriptCodeParameters.TOPLEVELNAMESPACE, targetType.GetClepsTypeString()); string fullFunctionName = String.Format("{0}.{1}", functionTarget, JavaScriptCodeParameters.GetMangledFunctionName(targetFunctionName, clepsType)); string parameterString = String.Join(", ", parameters.Select(v => (v as JavaScriptValue).Expression).ToList()); code = String.Format("{0}({1})", fullFunctionName, parameterString); } JavaScriptValue ret = new JavaScriptValue(code, clepsType.ReturnType); return ret; }
public IValue GetFunctionCallReturnValue(string fullyQualifiedClassName, string targetFunctionName, FunctionClepsType clepsType, List<IValue> parameters) { throw new NotImplementedException(); }
private void GenerateMethodWithBody(StringBuilder output, string fullyQualifiedClassName, string methodName, FunctionClepsType methodType, bool isStatic, JavaScriptMethod method) { string fullFunctionName = String.Format("{0}.{1}.{2}{3}", JavaScriptCodeParameters.TOPLEVELNAMESPACE, fullyQualifiedClassName, isStatic ? "" : "prototype.", JavaScriptCodeParameters.GetMangledFunctionName(methodName, methodType) ); output.AppendFormat("{0} = {1};\n", fullFunctionName, method.GetMethodText() ); }
public JavaScriptMethod(FunctionClepsType methodType) { MethodType = methodType; }
public IValue GetFunctionCallReturnValue(string fullyQualifiedClassName, string targetFunctionName, FunctionClepsType clepsType, List<IValue> parameters) { string parameterString = String.Join(", ", parameters.Select(v => (v as JavaScriptValue).Expression).ToList()); string code = String.Format("{0}.{1}.{2}({3})", TOPLEVELNAMESPACE, fullyQualifiedClassName, targetFunctionName, parameterString); JavaScriptValue ret = new JavaScriptValue(code, clepsType.ReturnType); return ret; }
public void SetMethodType(FunctionClepsType methodType) { throw new NotImplementedException(); }
public static bool MatchingFunctionTypeExists(List<FunctionClepsType> functionOverloads, FunctionClepsType typeToFind) { FunctionClepsType matchingTypeIfExists = functionOverloads.Where(o => o == typeToFind).FirstOrDefault(); return matchingTypeIfExists != null; }