glyph 0.2.0 → 0.3.0

data/book/text/extending.glyph

@@ -1,224 +0,0 @@
-Glyph was created wih extensibility in mind. You can freely extend &[glang] by creating or overriding macros, to do whatever you like. Macro definitions are written in pure Ruby code and placed in @.rb@ files within the @lib/macros/@ folder of your project.
-
-tip[Alternatively, you can also define macros right in your document, using the %>[macro:].]
-
-section[header[Anatomy of a Macro]
-
-This is the source code of a fairly simple macro used to format a note :
-
-<notextile>
-highlight[=ruby|
-macro :note do
-  %{<div class="#{@name}"><span class="note-title">#{@name.to_s.capitalize}</span>
-		#{@value}
-
-    </div>}
-end=]
-</notextile>
-
-The @macro@ method takes a single  @Symbol@ or @String@ parameter, corresponding to the name of the macro. In this case, the entire block (or _body_ of the macro) is a @String@ corresponding to what we want the macro to evaluate to: a @<div>@ tag containing a note. 
-
-The body of the macro is evaluated in the context of the =>[http://yardoc.org/docs/glyph/Glyph/Macro|@Glyph::Macro@] class, therefore its instance variables (like codeph[@name] or codeph[@value]) can be used directly.
-
-box[Why using codeph[@name] instead of just "note"?|
-For the @note@ macro, it absolutely makes no difference. However, by using codeph[@name] it is possible to re-use the same code for the @tip@, @important@ and @caution@ macros as well, which are in fact only aliases of the @note@ macro:
-
-@macro_alias :important => :note@
-@macro_alias :tip => :note@
-@macro_alias :caution => :note@
-] --[End box]
-
-The following table lists all the instance variables that can be used inside macros:
-
-table[
-  tr[
-    th[Variable]
-    th[Description]
-  ]
-  tr[
-    td[codeph[@node]]
-    td[A =>[http://yardoc.org/docs/glyph/Node|@Node@] containing information about the macro, within the document syntax tree. Useful for accessing parent and child macros, and the current =>[http://yardoc.org/docs/glyph/Glyph/Document|@Document@]. Normally, macro nodes contain the following keys:
-* @:name@, the name of the macro.
-* @:value@, the value (i.e. the contents, within the delimiters) of the macro
-* @:source@, a @String@ identifying the source of the macro (a file, a snippet, etc.) 
-* @:document@, the parsed document tree.
-
-Note that the first three keys can also be accessed via instance variables.]
-  ]
-  tr[
-    td[codeph[@name]]
-    td[The name of the macro]
-  ]
-  tr[
-    td[codeph[@value]]
-    td[The full contents (including parameters and nested macros) inside the macro delimiters.]
-  ]
-  tr[
-    td[codeph[@source]]
-    td[A @String@ identifying the source of the macro (a file, a snippet, etc.) ]
-  ]
-  tr[
-    td[codeph[@params]]
-    td[The parameters passed to the macro. In other words, the value of the macro split by pipes (@\|@).]
-  ]
-] --[End Table]
-
-]
-
-section[header[Bookmarks and Headers]
-
-The =>[http://yardoc.org/docs/glyph/Glyph/Macro|@Glyph::Macro@] class also includes a few methods to check and store bookmarks and headers. Consider for example the following source code for the %>[anchor]:
-
-<notextile>
-highlight[=ruby|
-macro :anchor do 
-  ident, title = @params
-  macro_error "Bookmark '#{ident}' already exists" if bookmark? ident
-  bookmark :id => ident, :title => title
-  %{<a id="#{ident}">#{title}</a>}
-end
-=] 
-</notextile>
-
-The @bookmark?@ method can be used to check the existance of a particular ID within the whole document, while the @bookmark@ method is used to store bookmark IDs and titles. In a similar way, you can use @header?@ and @header@ methods to check the existance of headers within the documents or store new ones.
-
-]
-
-section[header[Using Placeholders]
-
-Sometimes you may need to access some data that will not be available until the entire document has been fully parsed and analyzed. For example, in order to be able to validate internal links, it is necessary to know in advance if the bookmark ID referenced in the link exists or not, either before (that's easy) or even _after_ the link. 
-
-Here's the source code of the %>[link]:
-
-<notextile>
-highlight[=ruby|
-macro :link do
-  href, title = @params
-  if href.match /^#/ then
-    anc = href.gsub(/^#/, '').to_sym
-    bmk = bookmark? anc
-    if bmk then
-      title \|\|= bmk[:title]
-    else
-      plac = placeholder do \|document\|
-        macro_error "Bookmark '#{anc}' does not exist" unless document.bookmarks[anc] 
-        document.bookmarks[anc][:title]
-      end
-      title \|\|= plac
-    end
-  end
-  title \|\|= href
-  %{<a href="#{href}">#{title}</a>}
-end
-=]
-</notextile>
-
-If there's already a bookmark stored in the current document, then it is possible to retrieve its title and use it as link text. Otherwise, it is necessary to wait until the entire document has been fully processed and then check if the bookmark exists. To do so, use the @placeholder@ method. When called, this method returns an unique placeholder, which is then substituted with the value of the block, right before the document is finalized.
-
-Within the @placeholder@ block, the @document@ parameter is, by all means, the fully analyzed document.
-]
-
-section[header[Using Validators]
-If you need to make sure that a macro is used properly, consider using =>[http://yardoc.org/docs/glyph/Glyph/Macro/Validators|validators]. These methods can be used anywhere within the macro code to check whether certain conditions are met or not. Some default validators are provided to check the number of parameters of a macro, and they are actually used in some system macros.
-
-If you want to create your own validators, you can call the generic @validate@ method which takes the message to display in case of error, a Hash of options and a block containing the validation to perform.
-
-box[Validating macro placement|
-You can, of course, create your own validators to check whether a macro is used within another. While this may seem a good idea to enforce constraints into the way documents are created, it has one major drawback: if you define a macro with such validation, you're effectively limiting its usage, so for example you won't be able to use within snippets or other custom macros.
-
-Suppose, for example, that the %>[header] is only allowed within a @section@ macro. This means that, for example:
-* the macro cannot be used within @chapter@ or @appendix@ macros.
-* the macro cannot be used in snippets
-
-Even if you consider all the possibilities within the scope of the default macros provided with Glyph, this would also make the @header@ macro unusable within custom macros.
-]
-
-]
-
-section[header[Interpreting Glyph Code]
-
-What if you need to evaluate some Glyph code _within_ a macro? Say for example you want to transform a parameter in a link, and you want to make sure that link gets validated exactly like the others, in this case, you can use the @interpret@ method, as follows:
-
-<notextile>
-highlight[=ruby|
-macro :fmi do
-  topic, href = @params
-  link = placeholder do \|document\| 
-    interpret "link[#{href}]"
-  end
-  %{<span class="fmi">for more information on #{topic}, see #{link}</span>}
-end
-=] 
-</notextile>
-
-When the @interpret@ method is called, the following happens:
-# A new Glyph document is created from the @String@ passed to the method.
-# The bookmarks, headers and placeholders are passed from the main document to the new one. Because they are stored in arrays and hashes, they are passed by reference, so for example any new bookmark stored in the new document will also become available in the main document.
-# Any macro included in the @String@ is evaluated, and the resulting text is returned by the method. Note that this new document does not get finalized: in other words, placeholders will be left as they are, and they'll eventually be replaced when _the main document_ is finalized.
-
-section[header[Encoding and Decoding Glyph Code|encode_decode]
-When you use the @interpret@ method, keep in mind that the code is interpreted _before_ the macro execution ends. This may not always be what you want: if you're nesting macros interpreting @section@ and @header@ macros,for example, your Table of Contents may get messed up, with child sections showing up before their parents. 
-
-To avoid this, you can use the @encode@ and @decode@ methods, as shown in the macros defined for Glyph's =>[http://github.com/h3rald/glyph/blob/master/book/text/changelog.glyph|Changelog]:
-
-<notextile>
-highlight[=ruby|
-macro :issue do
-  exact_parameters 2
-  ident, desc = @params
-  encode %{
-    tr[
-      td[\=>[http://github.com/h3rald/glyph/issues/closed#issue/#{ident}\|##{ident}]]
-      td[textile[#{desc}]]
-    ]
-  }
-end
-
-macro :features do
-  verb = (@name == :features) ? "Implemented" : "Fixed"
-  total = @node.children.length
-  encode %{
-    section[header[#{total} #{@name.to_s.capitalize} #{verb}]
-      table[
-        tr[
-          th[ID]
-          th[Description]
-        ]
-        #@value
-      ]
-    ]
-  }
-end
-
-macro :release do
-  exact_parameters 3
-  number, date, contents = @params
-  interpret %{
-    section[header[v#{number} &ndash; #{date}]
-      #{decode contents}
-    ]
-  }
-end
-=]
-</notextile>
-
-In this case, @issue@ macros are nested within a @features@ macro, which in turn is nested within a @release@ macro. Note that none of these macros have any side effect: they are just used for text expansion. Because we're always going to nest these macros in this way, there's no to have each one interpret Glyph code: it will be the @release@ macro's job to do so. Instead, the @features@ and @issue@ macros just encode text which will then be decoded by the @release@ macro, before being interpreted. 
-
-When you _encode_ a macro, its delimiters (@\[@, @\]@, and @\|@) will be escaped (into ‡\.‡¤\.91\.¤‡\.‡, ‡\.‡¤\.93\.¤‡\.‡, and ‡\.‡¤\.124\.¤‡\.‡ respectively), and when you _decode_ it, they will be unescaped. In a nutshell, you may want to use the encode/decode mechanism when:
-* When you're nesting macros interpreting Glyph code, without side effects.
-* When all you want is to copy some Glyph code from child macros into their parents.
-
-note[These methods are also wrapped in the %>[encode] and in the %>[decode].]
-]
-]
-
-section[header[Further Reading]
-
-For more examples on how to create more complex macros, have a look at the =>[http://github.com/h3rald/glyph/tree/master/macros/|source code] of the existing ones.
-
-To gain a deeper understanding on how macros are executed, have a look at the following Glyph classes:
-* =>[http://yardoc.org/docs/glyph/Glyph/Macro|@Glyph::Macro@]
-* =>[http://yardoc.org/docs/glyph/Glyph/Interpreter|@Glyph::Interpreter@]
-* =>[http://yardoc.org/docs/glyph/Glyph/Document|@Glyph::Document@]
-* =>[http://yardoc.org/docs/glyph/Glyph/Node|@Node@]
-]

data/book/text/getting_started.glyph

@@ -1,158 +0,0 @@
-section[header[Creating your first Glyph Project]
-
-To install Glyph, simply run @gem install glyph@, like with any other Ruby gem. Then, create a new directory and initialize a new Glyph project, like so:
-
-@mkdir@ _==test_document==_
-
-@cd@ _==test_document==_
-
-@glyph init@
-
-That's it. You just created a new Glyph project in the @test_document@ directory.
-
-box[Glyph's dependencies|
-Glyph requires the following gems:
-* extlib
-* gli
-* treetop
-* rake
-
-Additionally, some Glyph macros may require additional gems, such as:
-* RedCloth (\.%>[textile])
-* BlueCloth _or_ RDiscount _or_ Maruku _or_ Kramdown (\.%>[markdown])
-* Haml (if you want to load .sass files with the %>[style])
-]
-
-Every Glyph project is comprised of the following directories:
-* @images/@ -- used to store the image files used in your document.
-* @lib/@ -- used to store your custom Glyph macros and Rake tasks.
-* @output/@ -- used to store your generated output files.
-* @styles/@ -- used to store your stylesheets.
-* @text/*@ -- used to store your source text files.
-
-Additionally, the following files are also created at top level:
-* @config.yml@ -- containing your =>[#cfg|Project Configuration].
-* @document.glyph@ -- containing your =>[#struct|Document Structure]
-* @snippets.yml@ -- containing your text =>[#incl|snippets].
-
-]
-
-section[header[Document Structure|struct]
-
-Every Glyph project contains a @document.glyph@ file that is typically used to define the document structure. The default @document.glyph@ generated automatically when creating a new project is the following:
-
-<notextile>
-code[=
-document[
-  head[style[default.css]]
-  body[
-    titlepage[
-      title[]
-      author[]
-      pubdate[]
-    ]
-    frontmatter[
-      toc[]
-      preface[header[Preface]
-        @[preface.textile]
-      ]
-    ]
-    bodymatter[  
-      chapter[header[Chapter #1]
-        @[chapter_1.textile]
-      ]
-      chapter[header[Chapter #2]
-        @[chapter_2.textile]
-      ]
-    ]
-    backmatter[
-      appendix[header[Appendix A]
-        @[appendix_a.textile]
-      ]
-    ]
-  ]
-]=]
-</notextile>
-
-
-Even without knowing anything about &[glang], you can easily figure out that this file defines a document with a Table of Contents, a Preface and some Chapters. @frontmatter\[\]@, @preface\[\]@, @chapter\[\]@, etc. are all Glyph _macros_ used to define -- in this case -- some structural elements. In practice, this means that if you plan to generate an HTML document, they'll be converted into @<div>@ tags.
-
-Be aware that other macros, on the other hand, are used to do something completely different, e.g.:
-* @toc\[\]@ generates the document's Table of Contents
-* codeph[=@\[\]=] or its alias @include\[\]@ is used to copy the contents of another file stored anywhere in the @text/@ directory.
-
-Let's now analyze this @document.glyph@ more in detail.
-* The @document\[\]@ macro wraps every other macro. This is necessary to create the initial @<html>@ tag.
-* Similarly, @head\[\]@ and @body\[\]@ are used to generate the respective HTML tags. Actually, @head\[\]@ already sets some metadata for you, by default (author and copyright).
-* Within @head\[\]@, the @style\[\]@ macro is used to load the @default.css@ stylesheet, which is one of the =>[#default_styles|default Glyph styleseets].
-* Immediately after the @body\[\]@ macro, the @titlepage\[\]@ macro is used to define (guess...) the first page of your document. @title\[\]@, @author\[\]@  and @pubdate\[\]@ insert the title of the document, its author and the publication date (retrieved from the project's =>[#cfg|configuration settings]).
-* Then, the @frontmatter\[\]@, @bodymatter\[\]@ and @backmatter\[\]@ macros are used to further divide the portions of your document according to the rules of =>[http://en.wikipedia.org/wiki/Book_design|book design]. They are not mandatory, but they can be used, for example, to number your appendixes with letters instead of numbers and similar.
-* @preface\[\]@, @chapter\[\]@, @appendix\[\]@ are just a way to wrap content in @<div>@ tags, from an HTML point of view, but they are also necessary to nest the content of your document and generate the Table of Contents automatically, together with the @header\[\]@ macro.
-
-]
-
-section[header[Project Configuration|cfg]
-
-Glyph stores configuration settings in the following YAML files:
-# Your _Project Configuration_ is stored in the @config.yml@ file, included in each Glyph Project.
-# Your _Global Configuration_ is stored in a @.glyphrc@ file in your $HOME (or ==%HOMEPATH%== on Windows) directory (not created by default).
-# The _System Configuration_ is stored in the source directory of Glyph itself.
-
-When compiling, Glyph loads all these configuration files and merges them according to the following rules:
-* A setting configured in the _Project Configuration_ overrides the same setting in both Global and System configuration.
-* A setting configured in the _Global Configuration_ overrides the same setting in the _System Configuration_
-
-Typically, you should use the _Project Configuration_ for all project-specific settings and the _Global Configuration_ for settings affecting all your projects (for example, you may want to set the $>[document.author] in the Global Configuration instead of setting it in the Project Configuration of all your Glyph projects). The _System Configuration_ is best left untouched.
-
-Instead of editing your configuration settings directly, you can use the #>[config], as follows:
-
-@glyph config@ _setting_ _\[value\]_
-
-If no _value_ is specified, glyph just prints the value of the configuration setting, so typing @glyph config document.author@ right after creating a project (assuming you didn't set this in the Global Configuration) will print nothing, because this setting is blank by default.
-
-To change the value of a configuration setting, specify a value right after the setting, like this:
-
-@glyph config document.author "John Smith"@
-
-tip[It is also possible to change configuration settings inside your document, using the %>[config:].]
-
-In this way, the document author will be set to _John Smith_ for the current project. To save this setting globally, add a @-g@ option, like this:
-
-@glyph config -g document.author "John Smith"@
-
-box[Regarding configuration values and data types...|
-Glyph attempts to "guess" the data type of a configuration values by evaluation (@Kernel#instance_eval@) if the value:
-* is wrapped in quotes (@"@ or @'@) &rarr; @String@
-* starts with a colon (@:@) &rarr; @Symbol@
-* is wrapped in square brackets (@\[@ and @\]@) &rarr; @Array@
-* is wrapped in curly brackets (@{@ and @}@) &rarr; @Hash@
-* is _true_ or _false_ &rarr; @Boolean@
-* is _nil_ &rarr; @NilClass@
-
-Note that this guessing is far from being foolproof: If you type something like _{:test, 2}_, for example, you'll get an error. 
-]
-
-There are plenty of configuration settings that can be modified, but most of them are best if left alone (and in the System Configuration file). 
-
-For a complete reference, see =>[#cfg_ref]. Normally, you may just want to change the following ones:
-
-table[
-	tr[
-		th[Setting]
-		th[Description]
-	]
-	tr[
-		th[@document.author@]
-		td[The author of the document]
-	]
-	tr[
-		th[@document.title@]
-		td[The title of the document]
-	]
-	tr[
-		th[@document.filename@]
-		td[The document file name]
-	]
-]
-
-]

data/book/text/troubleshooting.glyph

@@ -1,179 +0,0 @@
-This chapter lists the most common error messages that can be returned when running a Glyph command. It does not aim to be an exhaustive list, especially if you =>[#extending|extended] Glyph by creating your own macros or you're embedding Ruby code using the %>[ruby] macro.
-
-tip[As a general rule, more diagnostic information is provided if Glyph is run in =>[#debug_switch|debug mode].]
-
-section[header[Generic Errors]
-
-error_table[
-ref_error[Incorrect macro syntax|
-This error is returned if the parsing of the document (or one of its included files) failed. In 99% of the cases, this means there is an extra or missing macro delimiter somewhere.
-]
-ref_error[Invalid alias: macro '_macro-name_' already exists|
-The alias name supplied to the @macro_alias@ method has already been used for another macro or alias.
-]
-ref_error[Undefined macro '_macro-name_'|
-The document contains a macro that does not exist, i.e. it is not a standard or used-defined =>[#macro_ref|Glyph macro or alias].
-]
-ref_error[An error occurred when generating _file-name_.pdf|
-Returned if Prince could not generate the PDF file or if Prince is not installed. Normally, Prince provides additional details on the specific error(s).
-]
-ref_error[Glyph cannot generate PDF. Please specify a valid tools.pdf_generator setting|
-Returned if the $>[tools.pdf_generator] has not be set to a valid PDF renderer. Currently, the only supported value for this setting is @prince@.
-]
-ref_error[The current directory is not a valid Glyph project|
-Returned if a glyph command was executed outside a valid glyph project directory.
-]
-ref_error[Invalid snippet file|
-The @snippet.yml@ file contains invalid data. Most likely, it does not evaluate to a Ruby @Hash@.
-]
-ref_error[Directory '_directory-name_' is not empty|
-Returned when executing the #>[init] in a directory that is not empty.
-]
-ref_error[File '_file-name_' already exists|
-Returned if the name of an existing file was specified as a parameter for the #>[add].
-]
-]
-] --[End Generic Errors]
-
-
-
-section[header[Command Errors]
-
-error_table[
-
-ref_error[Source file '_source-file_' does not exist|
-Returned if Glyph is running in =>[#lite_mode|lite mode] and the specified source file was not found.
-]
-
-ref_error[Source and destination file are the same|
-Returned if Glyph is running in =>[#lite_mode|lite mode] and you specified the same source and destination files.
-]
-
-ref_error[DirectoryWatcher is not available. Install it with: gem install directory_watcher|
-Returned if =>[#auto_regeneration|auto regeneration] is enabled but the @directory_watcher@ gem in not installed.
-]
-
-ref_error[Document cannot be finalized due to previous errors|
-Returned if one or more errors occurred in the document prevented finalization.
-]
-
-ref_error[Please specify a file name|
-No file name was specified for the #>[add].
-]
-
-ref_error[Output target not specified|
-Returned if no target was specified for the #>[compile] _and_ if the $>[document.output] is not set.
-]
-
-ref_error[Unknown output target '_target-name_'|
-An unsupported output target was specified for the #>[compile]. Only the following output targets are supported:
-- @html@
-- @pdf@
-]
-
-ref_error[Too few/too many arguments|
-Returned if the #>[config] was used with no arguments or more than two arguments respectively.
-]
-
-ref_error[Unknown setting '_setting-name_'|
-The name of an unknown setting was specified for the #>[config].
-]
-]
-] --[End Command Errors]
-
-
-
-section[header[Macro Errors]
-
-The following errors are displayed in the form:
-
-_message_
--> source: _macro-source_
--> path: _macro-path_ 
--> value: _macro-value_
-
-Where:
-* _message_ is the error message.
-* _macro-source_ is the file or snippet where the error occurred.
-* _macro-path_ is the full path to the macro that returned the error, within the document syntax tree, e.g. @document/body/bodymatter/chapter/section/header/&@ if the error occurrent in a snippet within the header of a section in the @bodymatter@ part of the document.
-* _macro-value_ is the value of the macro (shown only if Glyph is running in =>[#debug_switch|debug mode]).
-
-error_table[
-
-ref_error[Macro '_name_' takes up to _x_ parameter(s) (_y_ given)|
-Returned if the macro was called with extra parameters.
-]
-
-ref_error[Macro '_name_' takes at least _x_ parameter(s) (_y_ given)|
-Returned if the macro was called with fewer parameters than expected.
-]
-
-ref_error[Macro '_name_' takes exactly _x_ parameter(s) (_y_ given)|
-Returned if the macro was called with a different number of parameters than.
-]
-
-ref_error[Macro not available when compiling a single file.|
-Returned by the %>[include] if used in =>[#lite_mode|lite mode].
-]
-
-ref_error[Filter macro '_extension_' not available|
-Returned by a filter macro if $>[filters.by_file_extension] is set to @true@, but the extension was not recognized.
-]
-
-ref_error[Invalid regular expression: _regexp_|
-Returned by the %>[match] macro if an invalid regular expression was supplied.
-]
-
-ref_error[Macro '_name_' takes no parameters (_x_ given)|
-Returned if the macro was called with parameters but none are requested.
-]
-
-ref_error[No highlighter installed. Please run: gem install coderay|
-Returned by the %>[highlight] macro if no highlighters are installed.
-]
-
-ref_error[CodeRay highlighter not installed. Please run: gem install coderay|
-Returned by the %>[highlight] macro if $>[highlighters.current] is set to @coderay@ but &[coderay] is not installed.
-]
-
-ref_error[UltraViolet highlighter not installed. Please run: gem install ultraviolet|
-Returned by the %>[highlight] macro if $>[highlighters.current] is set to @ultraviolet@ but &[uv] is not installed.
-]
-
-ref_error[Mutual inclusion|
-Returned if a catch-22 situation occurs with macro inclusion, for example if the body of a snippet includes a reference to the same snippet.
-]
-ref_error[Snippet '_snippet-id_' does not exist|
-Returned by the %>[snippet] if an invalid snippet was supplied.
-]
-ref_error[File '_file-name_' not found|
-Returned by the %>[include] if an invalid file was supplied.
-]
-ref_error[Filter macro '_macro-name_' not found|
-Returned by the %>[include] macro if the $>[filters.by_file_extension] is set to @true@ but the file extension of the included file is not recognized as a filter macro.
-]
-ref_error[RedCloth gem not installed. Please run: gem insall RedCloth|
-Returned by the %>[textile] if the RedCloth gem is not installed.
-]
-ref_error[No MarkDown converter installed. Please run: gem insall bluecloth|
-Returned by the %>[markdown] if no valid Markdown converter gem is installed. 
-
-Glyph checks for: BlueCloth, Maruku, Kramdown and RDiscount.
-]
-ref_error[Image/Figure not found|
-Retured by the %>[img] or the %>[fig] respectively, if the specified image file could not be found within the @images/@ folder.
-]
-ref_error[Bookmark '_bookmark-name_' already exists|
-Returned by the %>[anchor] or by the %>[header] if the anchor ID supplied as parameter has already been used in the document.
-]
-ref_error[Bookmark '_bookmark-name_' already exists|
-Returned by the %>[link] if the anchor ID supplied as parameter has not been used in the document.
-]
-ref_error[Stylesheet '_file-name_' not found|
-Returned by the %>[style] if the @.css@ or @.sass@ file supplied as parameter was not found in the @styles/@ directory.
-]
-ref_error[Haml is not installed. Please run: gem install haml|
-Returned by the %>[style] if a @.sass@ file was passed as parameter but the Haml gem is not installed.
-]
-]
-] --[End Macro Errors]