Free dtd software for mac

Logtalk 2.37.5 brings you canvenience of using such an object-oriented logic programming language that can use most Prolog implementations as a back-end compiler.

As a multi-paradigm language, Logtalk includes support for both prototypes and classes, protocols (interfaces), component-based programming through category-based composition, event-driven programming, and high-level multi-threading programming.

Major Features:

1. Separation between interface and implementation: Predicate directives (declarations) can be contained inside protocols (interfaces), which can be implemented by any object.
2. Parametric objects: Object identifiers can be compound terms containing free variables that can be used to parametrize object predicates. This allows us to interpret predicate clauses as providing instantiations of a parametric object identifier. I.e. through parametric object we can associate any number of methods with a compound term.
3. Support for both class-based and prototype-based systems: You may have, in the same application, class-based hierarchies (with instantiation and specialization relations) and prototype-based hierarchies (with extension relations). Moreover, fundamental language features such as protocols (interfaces) and categories (components) can be used simultaneously by classes, instances, and prototypes.
4. Support for multiple object hierarchies: No need to be constrained to a single, lengthy hierarchy rooted in some generic object.
5. Private, protected, and public inheritance: Logtalk supports private, protected, and public inheritance in a way similar to C++. Moreover, any entity relation can be qualified using a scope keyword. E.g. an object can privately implement a protocol, thus making all protocol declared predicates private.
6. Private, protected, and public object predicates: Set the scope of your object predicates to match your protocol design and let the runtime system enforce your choices.
7. Static and dynamic objects: Objects can be either static or dynamic. Static objects are defined in source files which are compiled and loaded in the same way as Prolog files. Dynamic object can be either defined in source files or created at runtime.
8. Static and dynamic object predicates: Any static object may contain both static and dynamic predicates.
9. Logtalk syntax extends standard Prolog syntax: Logtalk uses standard Prolog syntax with the addition of a few operators and directives for a smooth learning curve. Prolog code can be easily encapsulated inside objects with little or no changes. Moreover, Logtalk can transparently interpret most Prolog modules as Logtalk objects for easy reusing of existing code (e.g. libraries).
10. Event-driven programming: Predicates can be implicitly called when a spied event occurs, allowing programming solutions which minimize object coupling. In addition, events provide support for behavioral reflection and can be used to implement the concepts of pointcut and advice found on Aspect-Oriented Programming.
11. Component-based programming: Predicates can be encapsulated inside categories, which can be virtually imported by any object, without any code duplication and irrespective of object hierarchies. Thus, objects may be defined through composition of categories, which act as fine-grained units of code reuse. Categories may also extend existing objects. Categories can be used to implement aspects and mixin-like behavior without resorting to inheritance.
12. Multi-threading programming: High level multi-threading programming is available when running Logtalk with selected back-end Prolog compilers, allowing objects to support both synchronous and asynchronous messages. Independent and-parallelism and competitive or-parallelism are also supported. Easily take advantage of modern multi-processor and multi-core computers without bothering with the details of creating and destroying threads, implement thread communication, or synchronizing threads.
13. Multi-inheritance support: Logtalk supports multi-inheritance of both protocol and implementation. An object may implement several protocols and extend, specialize, or instantiate several objects. Multi-inheritance conflicts are solved implicitly by the Logtalk lookup algorithms or explicitly by using predicate directives.
14. Good performance: Logtalk code is compiled using the same technics that you use to write efficient Prolog code. In addition, Logtalk supports both static binding and dynamic binding (with method lookup caching), greatly improving performance. Benchmark results for some Prolog compilers are available here.
15. Close integration with the ISO Prolog Standard: Logtalk is designed for smooth integration with any Prolog compiler that conforms or closely follows the ISO Prolog Standard.
16. Compatible with most Prolog compilers: Logtalk interfaces with a specific back-end Prolog compiler via a minimal configuration file making it compatible with almost any modern compiler.
17. Automatic generation of XML documentation files: Logtalk automatically generates a documentation file in XML format for every compiled object, protocol, or category. The system includes all the necessary XSL(T) files and scripts to convert documenting files to (X)HTML and PDF.
18. Dynamic language: Logtalk is a dynamic language that allows hierarchies, objects, protocols, categories, and methods (predicates) to be freely created and modified at runtime. Other dynamic language features include support for meta-programming and both structural and behavioral reflection.

EditiX 2009.210709 is created as a simple yet useful XML editor that was designed to help web authors and application programmers take advantage of the latest XML and XML-related technologies such as XSLT / FO and XSD Schema. EditiX provides users with an extensive range of XML functionality within a refined IDE that guides you with intelligent entry helpers.

EditiX has realtime XPath location and syntax error detection. Helpers are also provided with context syntax popup supporting DTD, Schema and RelaxNG. EditiX supports multiple templates and project management. User can apply XSLT or FO Transformation and show the result with a dedicated view. All the process can be managed by shortcuts. EditiX includes default templates with XML, DTD, XHTML, XSLT, XSD, XML RelaxNG, SVG, MathML and XML FO.

Major Features:

1. Project
   • Relative paths (preference application/project/relativePath for disabling it).
   • Drag'n Drop starts slowly avoiding moving by error a project branch.
   • Delete key for removing a project element.
   • Filter by document type (menu Popup).
2. XML Tree
   • Drag and drop of nodes takes into account auto-closed elements.
   • Ctrl key while dragging for duplicating the nodes.
   • Drag and drop from the tree to the editor for copying a node.
   • Popup on a node for displaying another attribute.
3. Editor
   • Cursor location is restored after formatting.
   • Expression highlighting (parenthesis...).
4. Interface
   • "Close all except the current one" action.
5. XSD Editor
   • The attribute view is by default optional (delimiters in the border).
   • The group ref view is minimized.
   • New export image action ( png or jpg ) in the designer.
   • Delete key in the visual mode is managed.
6. XSLT Editor
   • The document type (XSLT 1.0 or 2.0) is now displayed in the XSLT window.
7. DocBook
   • HTML help output is managed.
   • DocBook properties are available.

Enhancements:

• Bugs fixed
• • XML catalog management fixed.
  • Couldn't parse an XML document with both a DTD and a schema.
  • Color of the '=' character could not be changed.
  • Formatting with text trimming could remove line breaks.
  • Couldn't add element in the visual mode for extension fixed.
  • Error message when importing a project for opened items.

Linguistic Tree Constructor (LTC) is a program for analyzing text in terms of syntax trees. That is, it assists in building a rigorous hierarchy of syntactic elements on top of the words in a given piece of text.
This is done by interacting with a tree-view of the text, gradually building the analysis. This can be done either bottom-up or top-down, or in a mix of both styles.
Linguistic Tree Constructor is a free tool for drawing linguistic syntactic trees, running on Mac OS X, Win32, and Linux platforms.

Enhancements
- Upgraded to Emdros 3.1.1.pre05.
- Upgraded to wxWidgets 2.8.10 on Win32.
- Upgraded to MUI2.nsh for ltc.nsi.in (NSIS installer script).
- Fixed missing trailing semicolon in Categories entry in SRC/linguistic-tree-constructor.desktop.
- COPYING now has DOS line endings.
- SRC/mainframe.cpp: ABOUT box now shows 2009, not 2008, as Copyright year.
- Added possibility of signing up for announcements mailinglist on Windows, via a special menu entry in the Start --> Programs --> LingTreeConstructor.
- Added Help menu items for seeting LTC website and subscribing to mailinglists (all platforms).Upgraded to Emdros 3.0.2.pre18, which gives a speed increase, especially for large files.
- Fixed bug #2455029: "Ampersand in filename results in empty tree"
- Fixed bug #2455039: "DTD does not parse" (due to # IMPLIED)

Inspired by XProc and SXPipe, Cocoatron is a simple way to create XML pipelines visually -- without writing a line of custom glue code in Java, C++ or other languages.
Conceptually, Cocoatron is a combination of XProc and Apples Automator application. XProc is the W3Cs spec for high-level descriptions of XML processing pipelines. Automator is Apples graphical application for creating scripting pipelines with drag-and-drop simplicity.
Implemented using the powerful libxml2 framework, Cocoatron includes support for XInclude, EXSLT, XSLT 1.0, XQuery, and validation against W3C XML Schema, DTD, and RELAX NG XML syntax.
Cocoatron is written in Objective-C and C, and is based on:
- libxml
- libxslt
- libexslt
- Apples Cocoa Frameworks
- Apples NSXML Framework
Installation: To install, download Cocoatron and unzip. Then drag the Cocoatron .action and .definition files to ~/Library/Automator. You may need to create this folder.

XMLStarlet is a set of command line utilities (tools) which can be used to transform, query, validate, and edit XML documents and files using simple set of shell commands in similar way it is done for plain text files using UNIX grep, sed, awk, diff, patch, join, etc commands.
The XMLStarlet set of command line utilities can be used by those who have to deal with many XML documents on a UNIX shell command prompt as well as for automated XML processing with shell scripts.
Main features:
- Check or validate XML files (simple well-formedness check, DTD, XSD, RelaxNG)
- Calculate values of XPath expressions on XML files (such as running sums, etc)
- Search XML files for matches to given XPath expressions
- Apply XSLT stylesheets to XML documents (including EXSLT support, and passing parameters to stylesheets)
- Query XML documents (ex. query for value of some elements of attributes, sorting, etc)
- Modify or edit XML documents (ex. delete some elements)
- Format or "beautify" XML documents (as changing indentation, etc)
- Fetch XML documents using http:// or ftp:// URLs
- Browse tree structure of XML documents (in similar way to ls command for directories)
- Include one XML document into another using XInclude
- XML c14n canonicalization
- Escape/unescape special XML characters in input text
- Print directory as XML document
- Convert XML into PYX format (based on ESIS - ISO 8879), and vice versa
System requirements:
- libxml2
- libxslt
NOTE: XMLStartlet is licensed and distributed under the terms of the MIT license.