예제 #1
0
파일: Translator.cs 프로젝트: nrnoble/h5
        public string GenerateSourceMap(string fileName, string content, Action<SourceMapBuilder> before = null)
        {
            if (AssemblyInfo.SourceMap.Enabled)
            {
                var projectPath = Path.GetDirectoryName(Location);

                SourceMapGenerator.Generate(fileName, projectPath, ref content,
                    before,
                    (sourceRelativePath) =>
                    {
                        string path = null;
                        ParsedSourceFile sourceFile = null;

                        try
                        {
                            path = Path.Combine(projectPath, sourceRelativePath);
                            sourceFile = ParsedSourceFiles.First(pf => pf.ParsedFile.FileName == path);

                            return sourceFile.SyntaxTree.TextSource ?? sourceFile.SyntaxTree.ToString(GetFormatter());
                        }
                        catch (Exception ex)
                        {
                            throw (TranslatorException)TranslatorException.Create(
                                "Could not get ParsedSourceFile for SourceMap. Exception: {0}; projectPath: {1}; sourceRelativePath: {2}; path: {3}.",
                                ex.ToString(), projectPath, sourceRelativePath, path);
                        }

                    },
                    new string[0], SourceFiles, AssemblyInfo.SourceMap.Eol
                );
            }

            return content;
        }
예제 #2
0
        public virtual List <TranslatorOutputItem> Emit()
        {
            using (new Measure(Logger, "Emitting JavaScript code"))
            {
                var blocks = GetBlocks();
                foreach (var block in blocks)
                {
                    CancellationToken.ThrowIfCancellationRequested();

                    JsDoc.Init();

                    Logger.ZLogTrace("Emitting block {0}", block.GetType());

                    block.Emit();
                }

                if (AutoStartupMethods.Count > 1)
                {
                    var autoMethods = string.Join(", ", AutoStartupMethods);

                    Logger.LogError("Program has more than one entry point defined - {0}", autoMethods);

                    throw (TranslatorException)TranslatorException.Create("Program has more than one entry point defined - {0}", autoMethods);
                }

                return(TransformOutputs());
            }
        }
예제 #3
0
        protected virtual void EnsureAssemblyName(Project project)
        {
            if (ProjectProperties.AssemblyName == null && _shouldReadProjectFile)
            {
                var property = (from n in project.AllEvaluatedProperties
                                where n.Name == ProjectPropertyNames.ASSEMBLY_NAME_PROP
                                select n).LastOrDefault();

                if (property != null)
                {
                    ProjectProperties.AssemblyName = property.EvaluatedValue;
                }
            }

            if (string.IsNullOrWhiteSpace(ProjectProperties.AssemblyName))
            {
                TranslatorException.Throw("Unable to determine assembly name");
            }
        }
예제 #4
0
        private string ReadProperty(Project doc, string name, bool fineIfMissing, Contract.ConfigHelper configHelper)
        {
            var node = (from n in doc.AllEvaluatedProperties
                        where string.Compare(n.Name, name, true) == 0
                        select n).LastOrDefault();

            if (node is null)
            {
                if (fineIfMissing)
                {
                    return(null);
                }

                TranslatorException.Throw("Unable to determine " + name + " in the project file with conditions " + EvaluationConditionsAsString());
            }

            var value = node.EvaluatedValue;

            value = configHelper.ConvertPath(value);

            return(value);
        }
예제 #5
0
        public virtual HashSet <string> GetParentTypes(IDictionary <string, TypeDefinition> allTypes)
        {
            var result = new HashSet <string>();

            foreach (var type in allTypes.Values)
            {
                if (type.BaseType != null)
                {
                    string parentName = type.BaseType.FullName.LeftOf('<').Replace('`', JS.Vars.D);

                    if (!allTypes.ContainsKey(parentName))
                    {
                        TranslatorException.Throw("Unknown type {0}", parentName);
                    }

                    if (!result.Contains(parentName))
                    {
                        result.Add(parentName);
                    }
                }
            }
            return(result);
        }
예제 #6
0
        /// <summary>
        /// Validates project and namespace names against conflicts with H5 namespaces.
        /// </summary>
        /// <param name="project">XDocument reference of the .csproj file.</param>
        private void ValidateProject(Project project)
        {
            var valid         = true;
            var failList      = new HashSet <string>();
            var failNodeList  = new List <ProjectProperty>();
            var combined_tags = from x in project.AllEvaluatedProperties
                                where x.Name == ProjectPropertyNames.ROOT_NAMESPACE_PROP || x.Name == ProjectPropertyNames.ASSEMBLY_NAME_PROP
                                select x;

            if (!AssemblyInfo.Assembly.EnableReservedNamespaces)
            {
                foreach (var tag in combined_tags)
                {
                    if (tag.EvaluatedValue == CS.NS.H5)
                    {
                        valid = false;
                        if (!failList.Contains(tag.EvaluatedValue))
                        {
                            failList.Add(tag.EvaluatedValue);
                            failNodeList.Add(tag);
                        }
                    }
                }
            }

            if (!valid)
            {
                var offendingSettings = "";
                foreach (var tag in failNodeList)
                {
                    offendingSettings += "Line " + tag.Xml.Location.File + " (" + tag.Xml.Location.Line + "): <" + tag.Xml.Name + ">" +
                                         tag.UnevaluatedValue + "</" + tag.Xml.Name + ">\n";
                }

                throw new TranslatorException("'H5' name is reserved and may not " +
                                              "be used as project names or root namespaces.\n" +
                                              "Please verify your project settings and rename where it applies.\n" +
                                              "Project file: " + Location + "\n" +
                                              "Offending settings:\n" + offendingSettings
                                              );
            }

            var outputType = ProjectProperties.OutputType;

            if (outputType == null && _shouldReadProjectFile)
            {
                var projectType = (from n in project.AllEvaluatedProperties
                                   where n.Name == ProjectPropertyNames.OUTPUT_TYPE_PROP
                                   select n).LastOrDefault();

                if (projectType != null)
                {
                    outputType = projectType.EvaluatedValue;
                }
            }

            if (outputType != null && string.Compare(outputType, SupportedProjectType, true) != 0)
            {
                TranslatorException.Throw("Project type ({0}) is not supported, please use Library instead of {0}", outputType);
            }
        }
예제 #7
0
        public virtual void CheckObjectLiteral(TypeDefinition type, ITranslator translator)
        {
            if (!IsObjectLiteral(type))
            {
                return;
            }

            var objectCreateMode = GetObjectCreateMode(type);

            if (objectCreateMode == 0)
            {
                var ctors = type.GetConstructors();

                foreach (var ctor in ctors)
                {
                    foreach (var parameter in ctor.Parameters)
                    {
                        if (parameter.ParameterType.FullName == "H5.ObjectCreateMode")
                        {
                            TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_PLAIN_NO_CREATE_MODE_CUSTOM_CONSTRUCTOR, type);
                        }

                        if (parameter.ParameterType.FullName == "H5.ObjectInitializationMode")
                        {
                            continue;
                        }

                        TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_PLAIN_CUSTOM_CONSTRUCTOR, type);
                    }
                }
            }

            if (type.IsInterface)
            {
                if (type.HasMethods && type.Methods.GroupBy(m => m.Name).Any(g => g.Count() > 1))
                {
                    TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_INTERFACE_NO_OVERLOAD_METHODS, type);
                }

                if (type.HasEvents)
                {
                    TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_INTERFACE_NO_EVENTS, type);
                }
            }
            else
            {
                if (type.Methods.Any(m => !m.IsRuntimeSpecialName && m.Name.Contains(".") && !m.Name.Contains("<")) ||
                    type.Properties.Any(m => !m.IsRuntimeSpecialName && m.Name.Contains(".") && !m.Name.Contains("<")))
                {
                    TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_INTERFACE_NO_EXPLICIT_IMPLEMENTATION, type);
                }
            }

            if (type.BaseType != null)
            {
                TypeDefinition baseType = null;
                try
                {
                    baseType = type.BaseType.Resolve();
                }
                catch (Exception)
                {
                }

                if (objectCreateMode == 1 && baseType != null && baseType.FullName != "System.Object" && baseType.FullName != "System.ValueType" && GetObjectCreateMode(baseType) == 0)
                {
                    TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_CONSTRUCTOR_INHERITANCE, type);
                }

                if (objectCreateMode == 0 && baseType != null && GetObjectCreateMode(baseType) == 1)
                {
                    TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_PLAIN_INHERITANCE, type);
                }
            }

            if (type.Interfaces.Count > 0)
            {
                foreach (var @interface in type.Interfaces)
                {
                    TypeDefinition iDef = null;
                    try
                    {
                        iDef = @interface.InterfaceType.Resolve();
                    }
                    catch (Exception)
                    {
                    }

                    if (iDef != null && iDef.FullName != "System.Object" && !IsObjectLiteral(iDef))
                    {
                        TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_INTERFACE_INHERITANCE, type);
                    }
                }
            }

            if (objectCreateMode == 0)
            {
                var hasVirtualMethods = false;

                foreach (MethodDefinition method in type.Methods)
                {
                    if (AttributeHelper.HasCompilerGeneratedAttribute(method))
                    {
                        continue;
                    }

                    if (method.IsVirtual && !(method.IsSetter || method.IsGetter))
                    {
                        hasVirtualMethods = true;
                        break;
                    }
                }

                if (hasVirtualMethods)
                {
                    TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_NO_VIRTUAL_METHODS, type);
                }
            }
        }