/// <summary> /// Resolves the source path of a file. /// </summary> /// <param name="source">Original source value.</param> /// <param name="type">Optional type of source file being resolved.</param> /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param> /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param> /// <returns>Should return a valid path for the stream to be imported.</returns> public virtual string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage) { if (String.IsNullOrEmpty(source)) { throw new ArgumentNullException("source"); } if (BinderFileManager.CheckFileExists(source)) // if the file exists, we're good to go. { return(source); } else if (Path.IsPathRooted(source)) // path is rooted so bindpaths won't help, bail since the file apparently doesn't exist. { return(null); } else // not a rooted path so let's try applying all the different source resolution options. { const string bindPathOpenString = "!(bindpath."; string bindName = String.Empty; string path = source; string pathWithoutSourceDir = null; if (source.StartsWith(bindPathOpenString, StringComparison.Ordinal)) { int closeParen = source.IndexOf(')', bindPathOpenString.Length); if (-1 != closeParen) { bindName = source.Substring(bindPathOpenString.Length, closeParen - bindPathOpenString.Length); path = source.Substring(bindPathOpenString.Length + bindName.Length + 1); // +1 for the closing brace. path = path.TrimStart('\\'); // remove starting '\\' char so the path doesn't look rooted. } } else if (source.StartsWith("SourceDir\\", StringComparison.Ordinal) || source.StartsWith("SourceDir/", StringComparison.Ordinal)) { pathWithoutSourceDir = path.Substring(10); } var bindPaths = this.Core.GetBindPaths(bindStage, bindName); foreach (string bindPath in bindPaths) { string filePath; if (!String.IsNullOrEmpty(pathWithoutSourceDir)) { filePath = Path.Combine(bindPath, pathWithoutSourceDir); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } filePath = Path.Combine(bindPath, path); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } } // Didn't find the file. return(null); }
/// <summary> /// Creates a PayloadInfoRow row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this Media row belongs to and should get its column definitions from.</param> public PayloadInfoRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { }
/// <summary> /// Get the value of a variable. /// </summary> /// <param name="sourceLineNumbers">The source line information for the function.</param> /// <param name="prefix">The variable prefix.</param> /// <param name="name">The variable name.</param> /// <returns>The variable value or null if the variable is not set.</returns> public string GetVariableValue(SourceLineNumber sourceLineNumbers, string prefix, string name) { if (String.IsNullOrEmpty(prefix)) { throw new ArgumentNullException("prefix"); } if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException("name"); } switch (prefix) { case "env": return(Environment.GetEnvironmentVariable(name)); case "sys": switch (name) { case "CURRENTDIR": return(String.Concat(Directory.GetCurrentDirectory(), Path.DirectorySeparatorChar)); case "SOURCEFILEDIR": return(String.Concat(Path.GetDirectoryName(sourceLineNumbers.FileName), Path.DirectorySeparatorChar)); case "SOURCEFILEPATH": return(sourceLineNumbers.FileName); case "PLATFORM": this.OnMessage(WixWarnings.DeprecatedPreProcVariable(sourceLineNumbers, "$(sys.PLATFORM)", "$(sys.BUILDARCH)")); goto case "BUILDARCH"; case "BUILDARCH": switch (this.currentPlatform) { case Platform.X86: return("x86"); case Platform.X64: return("x64"); case Platform.IA64: return("ia64"); case Platform.ARM: return("arm"); default: throw new ArgumentException(WixStrings.EXP_UnknownPlatformEnum, this.currentPlatform.ToString()); } default: return(null); } case "var": string result = null; return(this.variables.TryGetValue(name, out result) ? result : null); default: PreprocessorExtension extension = (PreprocessorExtension)this.extensionsByPrefix[prefix]; if (null != extension) { try { return(extension.GetVariableValue(prefix, name)); } catch (Exception e) { throw new WixException(WixErrors.PreprocessorExtensionGetVariableValueFailed(sourceLineNumbers, prefix, name, e.Message)); } } else { return(null); } } }
/// <summary> /// Called at the end of the validation of a database file. /// </summary> /// <remarks> /// <para>The default implementation will nullify source lines.</para> /// <para><b>Notes to Inheritors:</b> When overriding /// <b>FinalizeValidator</b> in a derived class, be sure to call /// the base class's <b>FinalizeValidator</b> to thoroughly /// finalize the extension.</para> /// </remarks> public virtual void FinalizeValidator() { this.sourceLineNumbers = null; }
/// <summary> /// Parse a section from the xml. /// </summary> /// <param name="reader">XmlReader where the intermediate is persisted.</param> /// <param name="tableDefinitions">TableDefinitions to use in the intermediate.</param> /// <returns>The parsed Section.</returns> internal static Section Parse(XmlReader reader, TableDefinitionCollection tableDefinitions) { Debug.Assert("section" == reader.LocalName); int codepage = 0; bool empty = reader.IsEmptyElement; string id = null; Section section = null; SectionType type = SectionType.Unknown; while (reader.MoveToNextAttribute()) { switch (reader.Name) { case "codepage": codepage = Convert.ToInt32(reader.Value, CultureInfo.InvariantCulture); break; case "id": id = reader.Value; break; case "type": switch (reader.Value) { case "bundle": type = SectionType.Bundle; break; case "fragment": type = SectionType.Fragment; break; case "module": type = SectionType.Module; break; case "patchCreation": type = SectionType.PatchCreation; break; case "product": type = SectionType.Product; break; case "patch": type = SectionType.Patch; break; default: throw new WixException(WixErrors.IllegalAttributeValue(SourceLineNumber.CreateFromUri(reader.BaseURI), "section", reader.Name, reader.Value, "fragment", "module", "patchCreation", "product", "patch")); } break; default: if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal)) { throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumber.CreateFromUri(reader.BaseURI), "section", reader.Name)); } break; } } if (null == id && (SectionType.Unknown != type && SectionType.Fragment != type)) { throw new WixException(WixErrors.ExpectedAttribute(SourceLineNumber.CreateFromUri(reader.BaseURI), "section", "id", "type", type.ToString())); } if (SectionType.Unknown == type) { throw new WixException(WixErrors.ExpectedAttribute(SourceLineNumber.CreateFromUri(reader.BaseURI), "section", "type")); } section = new Section(id, type, codepage); section.sourceLineNumbers = SourceLineNumber.CreateFromUri(reader.BaseURI); if (!empty) { bool done = false; while (!done && reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: switch (reader.LocalName) { case "table": section.Tables.Add(Table.Parse(reader, section, tableDefinitions)); break; default: throw new WixException(WixErrors.UnexpectedElement(SourceLineNumber.CreateFromUri(reader.BaseURI), "section", reader.Name)); } break; case XmlNodeType.EndElement: done = true; break; } } if (!done) { throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumber.CreateFromUri(reader.BaseURI), "section")); } } return(section); }
/// <summary> /// Resolves the source path of a file. /// </summary> /// <param name="source">Original source value.</param> /// <param name="type">Optional type of source file being resolved.</param> /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param> /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param> /// <returns>Should return a valid path for the stream to be imported.</returns> public virtual string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage) { // the following new local variables are used for bind path and protect the changes to object field. StringCollection currentBindPaths = null; NameValueCollection currentNamedBindPaths = null; StringCollection currentSourcePaths = null; if (String.IsNullOrEmpty(source)) { throw new ArgumentNullException("source"); } // Call the original override function first. If it returns an answer then return that, // otherwise using the default resolving logic string filePath = this.ResolveFile(source, type, sourceLineNumbers); if (!String.IsNullOrEmpty(filePath)) { return(filePath); } // Assign the correct bind path to file manager currentSourcePaths = this.sourcePaths[bindStage]; currentNamedBindPaths = this.namedBindPaths[bindStage]; if (BindStage.Target != bindStage && BindStage.Updated != bindStage) { currentBindPaths = this.bindPaths[bindStage]; } else { currentBindPaths = this.sourcePaths[bindStage]; } // If the path is rooted, it better exist or we're not going to find it. if (Path.IsPathRooted(source)) { if (BinderFileManager.CheckFileExists(source)) { return(source); } } else // not a rooted path so let's try applying all the different source resolution options. { const string bindPathOpenString = "!(bindpath."; if (source.StartsWith(bindPathOpenString, StringComparison.Ordinal) && source.IndexOf(')') != -1) { int bindpathSignatureLength = bindPathOpenString.Length; string name = source.Substring(bindpathSignatureLength, source.IndexOf(')') - bindpathSignatureLength); string[] values = currentNamedBindPaths.GetValues(name); if (null != values) { foreach (string bindPath in values) { // Parse out '\\' chars that separate the "bindpath" variable and the next part of the path, // because Path.Combine() thinks that rooted second paths don't need the first path. string nameSection = string.Empty; int nameStart = bindpathSignatureLength + 1 + name.Length; // +1 for the closing bracket. nameSection = source.Substring(nameStart).TrimStart('\\'); filePath = Path.Combine(bindPath, nameSection); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } } } else if (source.StartsWith("SourceDir\\", StringComparison.Ordinal) || source.StartsWith("SourceDir/", StringComparison.Ordinal)) { foreach (string bindPath in currentBindPaths) { filePath = Path.Combine(bindPath, source.Substring(10)); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } } else if (BinderFileManager.CheckFileExists(source)) { return(source); } foreach (string path in currentSourcePaths) { filePath = Path.Combine(path, source); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } if (source.StartsWith("SourceDir\\", StringComparison.Ordinal) || source.StartsWith("SourceDir/", StringComparison.Ordinal)) { filePath = Path.Combine(path, source.Substring(10)); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } } } // Didn't find the file. throw new WixFileNotFoundException(sourceLineNumbers, source, type); }
/// <summary> /// Creates a WixFile row that does not belong to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="tableDef">TableDefinition this Media row belongs to and should get its column definitions from.</param> public WixFileRow(SourceLineNumber sourceLineNumbers, TableDefinition tableDef) : base(sourceLineNumbers, tableDef) { }
/// <summary> /// Creates a WixComplexReferenceRow row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this row belongs to and should get its column definitions from.</param> public WixComplexReferenceRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { }
/// <summary> /// Creates a Control row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this Control row belongs to and should get its column definitions from.</param> public BBControlRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { }
/// <summary> /// Creates a PatchTargetCodeRow row that does not belong to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="tableDef">TableDefinition this PatchTargetCode row belongs to and should get its column definitions from.</param> public WixBundlePatchTargetCodeRow(SourceLineNumber sourceLineNumbers, TableDefinition tableDef) : base(sourceLineNumbers, tableDef) { }
/// <summary> /// Creates a PatchTargetCodeRow row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this PatchTargetCode row belongs to and should get its column definitions from.</param> public WixBundlePatchTargetCodeRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { }
/// <summary> /// Creates an Upgrade row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this Upgrade row belongs to and should get its column definitions from.</param> public UpgradeRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { }
/// <summary> /// Creates a WixUpdateRegistrationRow row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this WixUpdateRegistrationRow row belongs to and should get its column definitions from.</param> public WixUpdateRegistrationRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { }
/// <summary> /// Creates a WixUpdateRegistrationRow row that does not belong to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="tableDef">TableDefinition this WixUpdateRegistrationRow row belongs to and should get its column definitions from.</param> public WixUpdateRegistrationRow(SourceLineNumber sourceLineNumbers, TableDefinition tableDef) : base(sourceLineNumbers, tableDef) { }
/// <summary> /// Gets a valid code page from the given web name or integer value. /// </summary> /// <param name="value">A code page web name or integer value as a string.</param> /// <param name="allowNoChange">Whether to allow -1 which does not change the database code pages. This may be the case with wxl files.</param> /// <param name="onlyAnsi">Whether to allow Unicode (UCS) or UTF code pages.</param> /// <param name="sourceLineNumbers">Source line information for the current authoring.</param> /// <returns>A valid code page number.</returns> /// <exception cref="ArgumentOutOfRangeException">The value is an integer less than 0 or greater than 65535.</exception> /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception> /// <exception cref="NotSupportedException">The value doesn't not represent a valid code page name or integer value.</exception> /// <exception cref="WixException">The code page is invalid for summary information.</exception> internal static int GetValidCodePage(string value, bool allowNoChange, bool onlyAnsi, SourceLineNumber sourceLineNumbers) { int codePage; Encoding enc; if (null == value) { throw new ArgumentNullException("value"); } try { // check if a integer as a string was passed if (int.TryParse(value, out codePage)) { if (0 == codePage) { // 0 represents a neutral database return(0); } else if (allowNoChange && -1 == codePage) { // -1 means no change to the database code page return(-1); } enc = Encoding.GetEncoding(codePage); } else { enc = Encoding.GetEncoding(value); } // Windows Installer parses some code page references // as unsigned shorts which fail to open the database. if (onlyAnsi) { codePage = enc.CodePage; if (0 > codePage || short.MaxValue < codePage) { throw new WixException(WixErrors.InvalidSummaryInfoCodePage(sourceLineNumbers, codePage)); } } return(enc.CodePage); } catch (ArgumentException ex) { // rethrow as NotSupportedException since either can be thrown // if the system does not support the specified code page throw new NotSupportedException(ex.Message, ex); } }
/// <summary> /// Parses table definition from xml reader. /// </summary> /// <param name="reader">Reader to get data from.</param> /// <returns>The TableDefintion represented by the Xml.</returns> internal static TableDefinition Parse(XmlReader reader) { Debug.Assert("tableDefinition" == reader.LocalName); bool empty = reader.IsEmptyElement; bool createSymbols = false; bool hasPrimaryKeyColumn = false; string name = null; bool unreal = false; bool bootstrapperApplicationData = false; while (reader.MoveToNextAttribute()) { switch (reader.LocalName) { case "createSymbols": createSymbols = Common.IsYes(SourceLineNumber.CreateFromUri(reader.BaseURI), "createSymbols", reader.Name, reader.Value); break; case "name": name = reader.Value; break; case "unreal": unreal = Common.IsYes(SourceLineNumber.CreateFromUri(reader.BaseURI), "tableDefinition", reader.Name, reader.Value); break; case "bootstrapperApplicationData": bootstrapperApplicationData = Common.IsYes(SourceLineNumber.CreateFromUri(reader.BaseURI), "tableDefinition", reader.Name, reader.Value); break; default: if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal)) { throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumber.CreateFromUri(reader.BaseURI), "tableDefinition", reader.Name)); } break; } } if (null == name) { throw new WixException(WixErrors.ExpectedAttribute(SourceLineNumber.CreateFromUri(reader.BaseURI), "tableDefinition", "name")); } TableDefinition tableDefinition = new TableDefinition(name, createSymbols, unreal, bootstrapperApplicationData); // parse the child elements if (!empty) { bool done = false; while (!done && reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: switch (reader.LocalName) { case "columnDefinition": ColumnDefinition columnDefinition = ColumnDefinition.Parse(reader); tableDefinition.columns.Add(columnDefinition); if (columnDefinition.IsLocalizable) { tableDefinition.localizable = true; } if (columnDefinition.IsPrimaryKey) { hasPrimaryKeyColumn = true; } break; default: throw new WixException(WixErrors.UnexpectedElement(SourceLineNumber.CreateFromUri(reader.BaseURI), "tableDefinition", reader.Name)); } break; case XmlNodeType.EndElement: done = true; break; } } if (!unreal && !bootstrapperApplicationData && !hasPrimaryKeyColumn) { throw new WixException(WixErrors.RealTableMissingPrimaryKeyColumn(SourceLineNumber.CreateFromUri(reader.BaseURI), name)); } if (!done) { throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumber.CreateFromUri(reader.BaseURI), "tableDefinition")); } } return(tableDefinition); }
/// <summary> /// Resolves the source path of a file. /// </summary> /// <param name="source">Original source value.</param> /// <param name="type">Optional type of source file being resolved.</param> /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param> /// <returns>Should return a valid path for the stream to be imported.</returns> public virtual string ResolveFile(string source, string type, SourceLineNumber sourceLineNumber) { return(ResolveFile(source)); }
/// <summary> /// Creates a new row in the table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <returns>Row created in table.</returns> public Row CreateRow(SourceLineNumber sourceLineNumbers) { return(this.CreateRow(sourceLineNumbers, true)); }
/// <summary> /// Resolves the source path of a file related to another file's source. /// </summary> /// <param name="source">Original source value.</param> /// <param name="relatedSource">Source related to original source.</param> /// <param name="type">Optional type of source file being resolved.</param> /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param> /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param> /// <returns>Should return a valid path for the stream to be imported.</returns> public virtual string ResolveRelatedFile(string source, string relatedSource, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage) { string resolvedSource = this.ResolveFile(source, type, sourceLineNumbers, bindStage); return(Path.Combine(Path.GetDirectoryName(resolvedSource), relatedSource)); }
/// <summary> /// Creates a new row in the table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="add">Specifies whether to only create the row or add it to the table automatically.</param> /// <returns>Row created in table.</returns> public Row CreateRow(SourceLineNumber sourceLineNumbers, bool add) { Row row; switch (this.Name) { case "BBControl": row = new BBControlRow(sourceLineNumbers, this); break; case "ChainMsiPackage": row = new ChainMsiPackageRow(sourceLineNumbers, this); break; case "Component": row = new ComponentRow(sourceLineNumbers, this); break; case "Control": row = new ControlRow(sourceLineNumbers, this); break; case "File": row = new FileRow(sourceLineNumbers, this); break; case "Media": row = new MediaRow(sourceLineNumbers, this); break; case "PayloadInfo": row = new PayloadInfoRow(sourceLineNumbers, this); break; case "Upgrade": row = new UpgradeRow(sourceLineNumbers, this); break; case "Variable": row = new VariableRow(sourceLineNumbers, this); break; case "WixAction": row = new WixActionRow(sourceLineNumbers, this); break; case "WixComplexReference": row = new WixComplexReferenceRow(sourceLineNumbers, this); break; case "WixFile": row = new WixFileRow(sourceLineNumbers, this); break; case "WixMedia": row = new WixMediaRow(sourceLineNumbers, this); break; case "WixMediaTemplate": row = new WixMediaTemplateRow(sourceLineNumbers, this); break; case "WixMerge": row = new WixMergeRow(sourceLineNumbers, this); break; case "WixProperty": row = new WixPropertyRow(sourceLineNumbers, this); break; case "WixBundle": row = new WixBundleRow(sourceLineNumbers, this); break; case "WixBundlePatchTargetCode": row = new WixBundlePatchTargetCodeRow(sourceLineNumbers, this); break; case "WixBundleUpdate": row = new WixBundleUpdateRow(sourceLineNumbers, this); break; case "WixUpdateRegistration": row = new WixUpdateRegistrationRow(sourceLineNumbers, this); break; case "WixSimpleReference": row = new WixSimpleReferenceRow(sourceLineNumbers, this); break; case "WixVariable": row = new WixVariableRow(sourceLineNumbers, this); break; default: row = new Row(sourceLineNumbers, this); break; } if (add) { this.rows.Add(row); } return(row); }
/// <summary> /// Creates a WixFile row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this File row belongs to and should get its column definitions from.</param> public WixFileRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { }
/// <summary> /// Parse a table from the xml. /// </summary> /// <param name="reader">XmlReader where the intermediate is persisted.</param> /// <param name="section">Section to populate with persisted data.</param> /// <param name="tableDefinitions">TableDefinitions to use in the intermediate.</param> /// <returns>The parsed table.</returns> internal static Table Parse(XmlReader reader, Section section, TableDefinitionCollection tableDefinitions) { Debug.Assert("table" == reader.LocalName); bool empty = reader.IsEmptyElement; TableOperation operation = TableOperation.None; string name = null; while (reader.MoveToNextAttribute()) { switch (reader.LocalName) { case "name": name = reader.Value; break; case "op": switch (reader.Value) { case "add": operation = TableOperation.Add; break; case "drop": operation = TableOperation.Drop; break; default: throw new WixException(WixErrors.IllegalAttributeValue(SourceLineNumber.CreateFromUri(reader.BaseURI), "table", reader.Name, reader.Value, "Add", "Drop")); } break; default: if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal)) { throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumber.CreateFromUri(reader.BaseURI), "table", reader.Name)); } break; } } if (null == name) { throw new WixException(WixErrors.ExpectedAttribute(SourceLineNumber.CreateFromUri(reader.BaseURI), "table", "name")); } TableDefinition tableDefinition = tableDefinitions[name]; Table table = new Table(section, tableDefinition); table.Operation = operation; if (!empty) { bool done = false; // loop through all the rows in a table while (!done && reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: switch (reader.LocalName) { case "row": Row.Parse(reader, table); break; default: throw new WixException(WixErrors.UnexpectedElement(SourceLineNumber.CreateFromUri(reader.BaseURI), "table", reader.Name)); } break; case XmlNodeType.EndElement: done = true; break; } } if (!done) { throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumber.CreateFromUri(reader.BaseURI), "table")); } } return(table); }
/// <summary> /// Creates a Media row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this Media row belongs to and should get its column definitions from.</param> public MediaRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { // default the compression level to mszip this.compressionLevel = Cab.CompressionLevel.Mszip; }
/// <summary> /// Instantiate a new WixFileNotFoundException. /// </summary> /// <param name="sourceLineNumbers">Source line information pertaining to the file that cannot be found.</param> /// <param name="file">The file that could not be found.</param> /// <param name="fileType">The type of file that cannot be found.</param> public WixFileNotFoundException(SourceLineNumber sourceLineNumbers, string file, string fileType) : base(WixErrors.FileNotFound(sourceLineNumbers, file, fileType)) { }
/// <summary> /// Creates a PayloadInfoRow row that does not belong to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="tableDef">TableDefinition this Media row belongs to and should get its column definitions from.</param> public PayloadInfoRow(SourceLineNumber sourceLineNumbers, TableDefinition tableDef) : base(sourceLineNumbers, tableDef) { }
/// <summary> /// Creates a properly formatted message string. /// </summary> /// <param name="messageLevel">Level of the message, as generated by MessageLevel(MessageEventArgs).</param> /// <param name="mea">Event arguments for the message.</param> /// <returns>String containing the formatted message.</returns> private string GenerateMessageString(MessageLevel messageLevel, MessageEventArgs mea) { if (MessageLevel.Nothing == messageLevel) { return(String.Empty); } if (MessageLevel.Error == messageLevel) { this.EncounteredError = true; } List <string> fileNames = new List <string>(); string errorFileName = this.longAppName ?? "WIX"; for (SourceLineNumber sln = mea.SourceLineNumbers; null != sln; sln = sln.Parent) { if (sln.LineNumber.HasValue) { if (0 == fileNames.Count) { errorFileName = String.Format(CultureInfo.CurrentUICulture, WixStrings.Format_FirstLineNumber, sln.FileName, sln.LineNumber); } fileNames.Add(String.Format(CultureInfo.CurrentUICulture, WixStrings.Format_LineNumber, sln.FileName, sln.LineNumber)); } else { if (0 == fileNames.Count) { errorFileName = sln.FileName; } fileNames.Add(sln.FileName); } } string messageType = String.Empty; if (MessageLevel.Warning == messageLevel) { messageType = WixStrings.MessageType_Warning; } else if (MessageLevel.Error == messageLevel) { this.LastErrorNumber = mea.Id; messageType = WixStrings.MessageType_Error; } StringBuilder messageBuilder = new StringBuilder(); string message = String.Format(CultureInfo.InvariantCulture, mea.ResourceManager.GetString(mea.ResourceName), mea.MessageArgs); if (MessageLevel.Information == messageLevel) { messageBuilder.AppendFormat(WixStrings.Format_InfoMessage, message); } else { messageBuilder.AppendFormat(WixStrings.Format_NonInfoMessage, errorFileName, messageType, this.shortAppName ?? "WIX", mea.Id, message); } if (1 < fileNames.Count) { messageBuilder.AppendFormat(WixStrings.INF_SourceTrace, Environment.NewLine); foreach (string fileName in fileNames) { messageBuilder.AppendFormat(WixStrings.INF_SourceTraceLocation, fileName, Environment.NewLine); } messageBuilder.Append(Environment.NewLine); } return(messageBuilder.ToString()); }
/// <summary> /// Replaces parameters in the source text. /// </summary> /// <param name="sourceLineNumbers">The source line information for the function.</param> /// <param name="value">Text that may contain parameters to replace.</param> /// <returns>Text after parameters have been replaced.</returns> public string PreprocessString(SourceLineNumber sourceLineNumbers, string value) { StringBuilder sb = new StringBuilder(); int currentPosition = 0; int end = 0; while (-1 != (currentPosition = value.IndexOf('$', end))) { if (end < currentPosition) { sb.Append(value, end, currentPosition - end); } end = currentPosition + 1; string remainder = value.Substring(end); if (remainder.StartsWith("$", StringComparison.Ordinal)) { sb.Append("$"); end++; } else if (remainder.StartsWith("(loc.", StringComparison.Ordinal)) { currentPosition = remainder.IndexOf(')'); if (-1 == currentPosition) { this.OnMessage(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, remainder)); break; } sb.Append("$"); // just put the resource reference back as was sb.Append(remainder, 0, currentPosition + 1); end += currentPosition + 1; } else if (remainder.StartsWith("(", StringComparison.Ordinal)) { int openParenCount = 1; int closingParenCount = 0; bool isFunction = false; bool foundClosingParen = false; // find the closing paren int closingParenPosition; for (closingParenPosition = 1; closingParenPosition < remainder.Length; closingParenPosition++) { switch (remainder[closingParenPosition]) { case '(': openParenCount++; isFunction = true; break; case ')': closingParenCount++; break; } if (openParenCount == closingParenCount) { foundClosingParen = true; break; } } // move the currentPosition to the closing paren currentPosition += closingParenPosition; if (!foundClosingParen) { if (isFunction) { this.OnMessage(WixErrors.InvalidPreprocessorFunction(sourceLineNumbers, remainder)); break; } else { this.OnMessage(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, remainder)); break; } } string subString = remainder.Substring(1, closingParenPosition - 1); string result = null; if (isFunction) { result = this.EvaluateFunction(sourceLineNumbers, subString); } else { result = this.GetVariableValue(sourceLineNumbers, subString, false); } if (null == result) { if (isFunction) { this.OnMessage(WixErrors.UndefinedPreprocessorFunction(sourceLineNumbers, subString)); break; } else { this.OnMessage(WixErrors.UndefinedPreprocessorVariable(sourceLineNumbers, subString)); break; } } else { if (!isFunction) { this.OnResolvedVariable(new ResolvedVariableEventArgs(sourceLineNumbers, subString, result)); } } sb.Append(result); end += closingParenPosition + 1; } else // just a floating "$" so put it in the final string (i.e. leave it alone) and keep processing { sb.Append('$'); } } if (end < value.Length) { sb.Append(value.Substring(end)); } return(sb.ToString()); }
/// <summary> /// Creates a WixMedia row that belongs to a table. /// </summary> /// <param name="sourceLineNumbers">Original source lines for this row.</param> /// <param name="table">Table this Media row belongs to and should get its column definitions from.</param> public WixMediaRow(SourceLineNumber sourceLineNumbers, Table table) : base(sourceLineNumbers, table) { }
/// <summary> /// Add a variable. /// </summary> /// <param name="sourceLineNumbers">The source line information of the variable.</param> /// <param name="name">The variable name.</param> /// <param name="value">The variable value.</param> internal void AddVariable(SourceLineNumber sourceLineNumbers, string name, string value) { this.AddVariable(sourceLineNumbers, name, value, true); }
/// <summary> /// Parse a field from the xml. /// </summary> /// <param name="reader">XmlReader where the intermediate is persisted.</param> internal override void Parse(XmlReader reader) { Debug.Assert("field" == reader.LocalName); bool empty = reader.IsEmptyElement; this.baseUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { switch (reader.LocalName) { case "cabinetFileId": this.cabinetFileId = reader.Value; break; case "modified": this.Modified = Common.IsYes(SourceLineNumber.CreateFromUri(reader.BaseURI), "field", reader.Name, reader.Value); break; case "previousData": this.PreviousData = reader.Value; break; case "unresolvedPreviousData": this.unresolvedPreviousData = reader.Value; break; case "unresolvedData": this.unresolvedData = reader.Value; break; case "previousCabinetFileId": this.previousCabinetFileId = reader.Value; break; default: if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal)) { throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumber.CreateFromUri(reader.BaseURI), "field", reader.Name)); } break; } } if (!empty) { bool done = false; while (!done && reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: throw new WixException(WixErrors.UnexpectedElement(SourceLineNumber.CreateFromUri(reader.BaseURI), "field", reader.Name)); case XmlNodeType.CDATA: case XmlNodeType.Text: if (0 < reader.Value.Length) { this.Data = reader.Value; } break; case XmlNodeType.EndElement: done = true; break; } } if (!done) { throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumber.CreateFromUri(reader.BaseURI), "field")); } } }