FvMcs.GNU-PROJECT

_CREATED: {2003-02-11}

name::
* McsEngl.conceptItsoft1082,
* McsEngl.GNU-PROJECT@cptItsoft,
* McsEngl.FvMcs.GNU-PROJECT@cptItsoft,
* McsEngl.gnu-project@cptItsoft,
* McsEngl.gnu@cptItsoft1082,

DEFINITION

What is the GNU-Project?
The GNU-Project has been started in 1984 by Richard M. Stallman in order to create a complete Unix-like operating system based on Free Software.
He also started the "Free Software Foundation" to deal with the juristical and organizational aspects of the GNU-Project and also for spreading the use of and knowledge about Free Software. Through the Free Software Foundation the GNU General Public License and the GNU Lesser General Public License (originally called GNU Library Public License) have been formulated and over the years they established themselves as the most widely used licenses for Free Software.
The GNU-Project consists of smaller sub-projects maintained by volunteers or corporations usually with the goal to create or maintain a functional component. These sub-projects themselves are also called "GNU Projects" or "official GNU Projects."
The name of the GNU-Project is derived from the recursive acronym "GNU's Not Unix." Since Unix was originally not only a certain kind of system but rather a product, this sought to symbolize that the GNU Project has the goal to create a system compatible with but not identical to Unix.
The GNU System is (like other Unix operating systems) modular and today especially the GNU System with Linux kernel - the so-called GNU/Linux-System - is widely used and provides the basis for every so-called "Linux-Distribution."
Georg C. F. Greve <greve@gnu.org>
Last update: $Date: 2002/02/07 16:50:09 $ $Author: jneves $
[http://www.fsfeurope.org/documents/gnuproject.en.html]

gnu'EVOLUTION#cptCore546.171#

name::
* McsEngl.gnu'EVOLUTION@cptItsoft,

1984:
Since then the goal was to create a free unix-like system.

gnu'FREE'SOFTWARE'DEFINITION

name::
* McsEngl.gnu'FREE'SOFTWARE'DEFINITION@cptItsoft,

The Free Software Definition
[ Croatian | Czech | Danish | Dutch | English | French | Galician | German | Hungarian | Indonesian | Italian | Japanese | Korean | Norwegian | Polish | Portuguese | Romanian | Russian | Slovenian | Spanish | Swedish | Turkish ]
We maintain this free software definition to show clearly what must be true about a particular software program for it to be considered free software.
``Free software'' is a matter of liberty, not price. To understand the concept, you should think of ``free'' as in ``free speech,'' not as in ``free beer.''
Free software is a matter of the users' freedom to run, copy, distribute, study, change and improve the software. More precisely, it refers to four kinds of freedom, for the users of the software:

The freedom to run the program, for any purpose (freedom 0). The freedom to study how the program works, and adapt it to your needs (freedom 1). Access to the source code is a precondition for this. The freedom to redistribute copies so you can help your neighbor (freedom 2). The freedom to improve the program, and release your improvements to the public, so that the whole community benefits (freedom 3). Access to the source code is a precondition for this. A program is free software if users have all of these freedoms. Thus, you should be free to redistribute copies, either with or without modifications, either gratis or charging a fee for distribution, to anyone anywhere. Being free to do these things means (among other things) that you do not have to ask or pay for permission.
You should also have the freedom to make modifications and use them privately in your own work or play, without even mentioning that they exist. If you do publish your changes, you should not be required to notify anyone in particular, or in any particular way.
The freedom to use a program means the freedom for any kind of person or organization to use it on any kind of computer system, for any kind of overall job, and without being required to communicate subsequently with the developer or any other specific entity.
The freedom to redistribute copies must include binary or executable forms of the program, as well as source code, for both modified and unmodified versions. (Distributing programs in runnable form is necessary for conveniently installable free operating systems.) It is ok if there is no way to produce a binary or executable form for a certain program (since some languages don't support that feature), but you must have the freedom to redistribute such forms should you find or develop a way to make them.
In order for the freedoms to make changes, and to publish improved versions, to be meaningful, you must have access to the source code of the program. Therefore, accessibility of source code is a necessary condition for free software.
In order for these freedoms to be real, they must be irrevocable as long as you do nothing wrong; if the developer of the software has the power to revoke the license, without your doing anything to give cause, the software is not free.
However, certain kinds of rules about the manner of distributing free software are acceptable, when they don't conflict with the central freedoms. For example, copyleft (very simply stated) is the rule that when redistributing the program, you cannot add restrictions to deny other people the central freedoms. This rule does not conflict with the central freedoms; rather it protects them.
Thus, you may have paid money to get copies of free software, or you may have obtained copies at no charge. But regardless of how you got your copies, you always have the freedom to copy and change the software, even to sell copies.
``Free software'' does not mean ``non-commercial''. A free program must be available for commercial use, commercial development, and commercial distribution. Commercial development of free software is no longer unusual; such free commercial software is very important.
Rules about how to package a modified version are acceptable, if they don't effectively block your freedom to release modified versions. Rules that ``if you make the program available in this way, you must make it available in that way also'' can be acceptable too, on the same condition. (Note that such a rule still leaves you the choice of whether to publish the program or not.) It is also acceptable for the license to require that, if you have distributed a modified version and a previous developer asks for a copy of it, you must send one.
In the GNU project, we use ``copyleft'' to protect these freedoms legally for everyone. But non-copylefted free software also exists. We believe there are important reasons why it is better to use copyleft, but if your program is non-copylefted free software, we can still use it.
See Categories of Free Software (18k characters) for a description of how ``free software,'' ``copylefted software'' and other categories of software relate to each other.
Sometimes government export control regulations and trade sanctions can constrain your freedom to distribute copies of programs internationally. Software developers do not have the power to eliminate or override these restrictions, but what they can and must do is refuse to impose them as conditions of use of the program. In this way, the restrictions will not affect activities and people outside the jurisdictions of these governments.
When talking about free software, it is best to avoid using terms like ``give away'' or ``for free'', because those terms imply that the issue is about price, not freedom. Some common terms such as ``piracy'' embody opinions we hope you won't endorse. See Confusing Words and Phrases that are Worth Avoiding for a discussion of these terms. We also have a list of translations of "free software" into various languages.
Finally, note that criteria such as those stated in this free software definition require careful thought for their interpretation. To decide whether a specific software license qualifies as a free software license, we judge it based on these criteria to determine whether it fits their spirit as well as the precise words. If a license includes unconscionable restrictions, we reject it, even if we did not anticipate the issue in these criteria. Sometimes a license requirement raises an issue that calls for extensive thought, including discussions with a lawyer, before we can decide if the requirement is acceptable. When we reach a conclusion about a new issue, we often update these criteria to make it easier to see why certain licenses do or don't qualify.
If you are interested in whether a specific license qualifies as a free software license, see our list of licenses. If the license you are concerned with is not listed there, you can ask us about it by sending us email at <licensing@gnu.org>.

--------------------------------------------------------------------------------
Other Texts to Read Another group has started using the term "open source" to mean something close (but not identical) to "free software". We prefer the term "free software" because, once you have heard it refers to freedom rather than price, it calls to mind freedom.

-------------------------------------------------------------------------------- [ Croatian | Czech | Danish | Dutch | English | French | Galician | German | Hungarian | Indonesian | Italian | Japanese | Korean | Norwegian | Polish | Portuguese | Romanian | Russian | Slovenian | Spanish | Turkish ] Return to GNU's home page.
Please send FSF & GNU inquiries & questions to gnu@gnu.org. There are also other ways to contact the FSF.
Please send comments on these web pages to webmasters@gnu.org, send other questions to gnu@gnu.org.
Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA
Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.
Updated: $Date: 2003/02/07 16:52:55 $ $Author: rps $
--------------------------------------------------------------------------------

What is Free Software?
The philosophy of Free Software goes back to the idea of freely exchanging knowledge and thoughts that can traditionally be found in scientific fields. Just like ideas, software are non-tangible and can be copied without loss. Passing them on is rather the basis of an evolutionary process which fuels the development of thoughts.
In the early eighties, Richard M. Stallman was the first to succeed in formalizing this for software in form of four freedoms.
0. freedom: The freedom to run the program, for any purpose.
1. freedom: The freedom to study how the program works, and adapt it to your needs.
2. freedom: The freedom to redistribute copies.
3. freedom: The freedom to improve the program, and release your improvements to the public, so that the whole community benefits.
Software following these four principles is called "Free Software". You will find detailed information in the Free Software Definition.
To support and realize this, Richard M. Stallman created the "Free Software Foundation" in 1984 and started the GNU-Project. The license of the GNU-Project, the GNU General Public License not only grants the four freedoms described above, it also protects them. Especially because of this protection the GPL is the most-widely used license for Free Software nowadays.
Besides the GPL there are several other licenses granting these freedoms and hence qualifying as Free Software licenses. Of these especially the FreeBSD license should be mentioned. The major difference to the GPL is that it does not seek to protect the freedom.
When talking about Free Software, the most common misconception is the belief that it has to be gratis. This is not the case - in fact a very big part of the Free Software protagonists work on the field of commercial Free Software.
In 1998 the "Open Source Definition" was written by the U.S. citizen Bruce Perens as the main author. Its goal was to describe the technical properties of Free Software and to serve as the fundamental document of the "Open Source" movement.
The "Open Source Definition" itself is a derivate of the "Debian Free Software Guidelines", which is derived from the four freedoms mentioned above. Therefore all three definitions describe the same licenses; the "GNU General Public License" (GPL) is the primary license for all definitions.
It is the self-declared goal of the Open Source movement to be a marketing program for Free Software. This is sought by deliberatly turning away from the philosophical and political background; they are seen as hazardous to commercialization.
Opposed to this, the Free Software movement has always understood the philosophy and the background as an essential part of the movement and one of it's biggest assets.
Georg C. F. Greve <greve@gnu.org>
Last update: $Date: 2002/02/07 16:50:09 $ $Author: jneves $
[http://www.fsfeurope.org/documents/freesoftware.en.html]

gnu'FREE-SOFTWARE-FOUNDATION#cptItsoft1083.3#

name::
* McsEngl.gnu'FREE-SOFTWARE-FOUNDATION@cptItsoft,

gnu'LICENSE

name::
* McsEngl.gnu'LICENSE@cptItsoft,

SPECIFIC:
* GPL
* LGPL#cptItsoft1082.3: attSpe#

gnu'GPL v2 1991.06)

name::
* McsEngl.gnu'GPL v2 1991.06)@cptItsoft,
* McsEngl.conceptItsoft1082.1,
* McsEngl.gnu'general'public'license@cptItsoft1082.1,
* McsEngl.gnu'license@cptItsoft1082.1,

GNU GENERAL PUBLIC LICENSE
Version 2, June 1991

Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

Preamble

The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too.

When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.

We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.

Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and modification follow.

GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING; DISTRIBUTION AND MODIFICATION

0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.

1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.

You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.

2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.
c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.

In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.

3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.

If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.

4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.

6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.

7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.

This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.

8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.

9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.

10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.

NO WARRANTY

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

Appendix: How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.

<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.

<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice

This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License.

gnu'LGPL v2.1 1999.02

name::
* McsEngl.gnu'LGPL v2.1 1999.02@cptItsoft,
* McsEngl.conceptItsoft1082.3,
* McsEngl.gnu'lesser'general'public'license@cptItsoft1082.3,

GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999

Copyright (C) 1991, 1999 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]

Preamble

The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.

When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.

To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.

For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.

We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.

Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.

We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.

For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.

Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.

The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.

GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".

A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)

"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.

1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

a) The modified work must itself be a software library.

b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.

c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.

d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.

(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)

These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.

Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.

If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:

a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)

b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.

c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.

d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.

e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.

For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.

b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.

8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.

11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.

13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

NO WARRANTY

15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Libraries

If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).

To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.

<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.

<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice

That's all there is to it!

gnu'MANIFESTO

name::
* McsEngl.gnu'MANIFESTO@cptItsoft,

Copyright (C) 1985, 1993 Free Software Foundation, Inc. Permission is granted to anyone to make or distribute verbatim copies of this document, in any medium, provided that the copyright notice and permission notice are preserved, and that the distributor grants the recipient permission for further redistribution as permitted by this notice.
Modified versions may not be made.

The GNU Manifesto
[ Czech | Dutch | English | French | German | Italian | Korean | Portuguese ]

The GNU Manifesto (which appears below) was written by Richard Stallman at the beginning of the GNU Project, to ask for participation and support. For the first few years, it was updated in minor ways to account for developments, but now it seems best to leave it unchanged as most people have seen it.
Since that time, we have learned about certain common misunderstandings that different wording could help avoid. Footnotes added in 1993 help clarify these points.
For up-to-date information about the available GNU software, please see the information available on our web server, in particular our list of software.

What's GNU? Gnu's Not Unix!
Translations of the GNU Manifesto are available in French, German, Japanese, Korean, Russian, and Swedish.

--------------------------------------------------------------------------------
GNU, which stands for Gnu's Not Unix, is the name for the complete Unix-compatible software system which I am writing so that I can give it away free to everyone who can use it. (1) Several other volunteers are helping me. Contributions of time, money, programs and equipment are greatly needed.
So far we have an Emacs text editor with Lisp for writing editor commands, a source level debugger, a yacc-compatible parser generator, a linker, and around 35 utilities. A shell (command interpreter) is nearly completed. A new portable optimizing C compiler has compiled itself and may be released this year. An initial kernel exists but many more features are needed to emulate Unix. When the kernel and compiler are finished, it will be possible to distribute a GNU system suitable for program development. We will use TeX as our text formatter, but an nroff is being worked on. We will use the free, portable X window system as well. After this we will add a portable Common Lisp, an Empire game, a spreadsheet, and hundreds of other things, plus on-line documentation. We hope to supply, eventually, everything useful that normally comes with a Unix system, and more.
GNU will be able to run Unix programs, but will not be identical to Unix. We will make all improvements that are convenient, based on our experience with other operating systems. In particular, we plan to have longer file names, file version numbers, a crashproof file system, file name completion perhaps, terminal-independent display support, and perhaps eventually a Lisp-based window system through which several Lisp programs and ordinary Unix programs can share a screen. Both C and Lisp will be available as system programming languages. We will try to support UUCP, MIT Chaosnet, and Internet protocols for communication.
GNU is aimed initially at machines in the 68000/16000 class with virtual memory, because they are the easiest machines to make it run on. The extra effort to make it run on smaller machines will be left to someone who wants to use it on them.
To avoid horrible confusion, please pronounce the `G' in the word `GNU' when it is the name of this project.
Why I Must Write GNU I consider that the golden rule requires that if I like a program I must share it with other people who like it. Software sellers want to divide the users and conquer them, making each user agree not to share with others. I refuse to break solidarity with other users in this way. I cannot in good conscience sign a nondisclosure agreement or a software license agreement. For years I worked within the Artificial Intelligence Lab to resist such tendencies and other inhospitalities, but eventually they had gone too far: I could not remain in an institution where such things are done for me against my will. So that I can continue to use computers without dishonor, I have decided to put together a sufficient body of free software so that I will be able to get along without any software that is not free. I have resigned from the AI lab to deny MIT any legal excuse to prevent me from giving GNU away.
Why GNU Will Be Compatible with Unix Unix is not my ideal system, but it is not too bad. The essential features of Unix seem to be good ones, and I think I can fill in what Unix lacks without spoiling them. And a system compatible with Unix would be convenient for many other people to adopt. How GNU Will Be Available GNU is not in the public domain. Everyone will be permitted to modify and redistribute GNU, but no distributor will be allowed to restrict its further redistribution. That is to say, proprietary (18k characters) modifications will not be allowed. I want to make sure that all versions of GNU remain free. Why Many Other Programmers Want to Help I have found many other programmers who are excited about GNU and want to help. Many programmers are unhappy about the commercialization of system software. It may enable them to make more money, but it requires them to feel in conflict with other programmers in general rather than feel as comrades. The fundamental act of friendship among programmers is the sharing of programs; marketing arrangements now typically used essentially forbid programmers to treat others as friends. The purchaser of software must choose between friendship and obeying the law. Naturally, many decide that friendship is more important. But those who believe in law often do not feel at ease with either choice. They become cynical and think that programming is just a way of making money.
By working on and using GNU rather than proprietary programs, we can be hospitable to everyone and obey the law. In addition, GNU serves as an example to inspire and a banner to rally others to join us in sharing. This can give us a feeling of harmony which is impossible if we use software that is not free. For about half the programmers I talk to, this is an important happiness that money cannot replace.
How You Can Contribute I am asking computer manufacturers for donations of machines and money. I'm asking individuals for donations of programs and work. One consequence you can expect if you donate machines is that GNU will run on them at an early date. The machines should be complete, ready to use systems, approved for use in a residential area, and not in need of sophisticated cooling or power.
I have found very many programmers eager to contribute part-time work for GNU. For most projects, such part-time distributed work would be very hard to coordinate; the independently-written parts would not work together. But for the particular task of replacing Unix, this problem is absent. A complete Unix system contains hundreds of utility programs, each of which is documented separately. Most interface specifications are fixed by Unix compatibility. If each contributor can write a compatible replacement for a single Unix utility, and make it work properly in place of the original on a Unix system, then these utilities will work right when put together. Even allowing for Murphy to create a few unexpected problems, assembling these components will be a feasible task. (The kernel will require closer communication and will be worked on by a small, tight group.)
If I get donations of money, I may be able to hire a few people full or part time. The salary won't be high by programmers' standards, but I'm looking for people for whom building community spirit is as important as making money. I view this as a way of enabling dedicated people to devote their full energies to working on GNU by sparing them the need to make a living in another way.
Why All Computer Users Will Benefit Once GNU is written, everyone will be able to obtain good system software free, just like air.(2) This means much more than just saving everyone the price of a Unix license. It means that much wasteful duplication of system programming effort will be avoided. This effort can go instead into advancing the state of the art.
Complete system sources will be available to everyone. As a result, a user who needs changes in the system will always be free to make them himself, or hire any available programmer or company to make them for him. Users will no longer be at the mercy of one programmer or company which owns the sources and is in sole position to make changes.
Schools will be able to provide a much more educational environment by encouraging all students to study and improve the system code. Harvard's computer lab used to have the policy that no program could be installed on the system if its sources were not on public display, and upheld it by actually refusing to install certain programs. I was very much inspired by this.
Finally, the overhead of considering who owns the system software and what one is or is not entitled to do with it will be lifted.
Arrangements to make people pay for using a program, including licensing of copies, always incur a tremendous cost to society through the cumbersome mechanisms necessary to figure out how much (that is, which programs) a person must pay for. And only a police state can force everyone to obey them. Consider a space station where air must be manufactured at great cost: charging each breather per liter of air may be fair, but wearing the metered gas mask all day and all night is intolerable even if everyone can afford to pay the air bill. And the TV cameras everywhere to see if you ever take the mask off are outrageous. It's better to support the air plant with a head tax and chuck the masks.
Copying all or parts of a program is as natural to a programmer as breathing, and as productive. It ought to be as free.
Some Easily Rebutted Objections to GNU's Goals "Nobody will use it if it is free, because that means they can't rely on any support." "You have to charge for the program to pay for providing the support."
If people would rather pay for GNU plus service than get GNU free without service, a company to provide just service to people who have obtained GNU free ought to be profitable.(3)
We must distinguish between support in the form of real programming work and mere handholding. The former is something one cannot rely on from a software vendor. If your problem is not shared by enough people, the vendor will tell you to get lost.
If your business needs to be able to rely on support, the only way is to have all the necessary sources and tools. Then you can hire any available person to fix your problem; you are not at the mercy of any individual. With Unix, the price of sources puts this out of consideration for most businesses. With GNU this will be easy. It is still possible for there to be no available competent person, but this problem cannot be blamed on distribution arrangements. GNU does not eliminate all the world's problems, only some of them.
Meanwhile, the users who know nothing about computers need handholding: doing things for them which they could easily do themselves but don't know how.
Such services could be provided by companies that sell just hand-holding and repair service. If it is true that users would rather spend money and get a product with service, they will also be willing to buy the service having got the product free. The service companies will compete in quality and price; users will not be tied to any particular one. Meanwhile, those of us who don't need the service should be able to use the program without paying for the service.
"You cannot reach many people without advertising, and you must charge for the program to support that."
"It's no use advertising a program people can get free."
There are various forms of free or very cheap publicity that can be used to inform numbers of computer users about something like GNU. But it may be true that one can reach more microcomputer users with advertising. If this is really so, a business which advertises the service of copying and mailing GNU for a fee ought to be successful enough to pay for its advertising and more. This way, only the users who benefit from the advertising pay for it.
On the other hand, if many people get GNU from their friends, and such companies don't succeed, this will show that advertising was not really necessary to spread GNU. Why is it that free market advocates don't want to let the free market decide this?(4)
"My company needs a proprietary operating system to get a competitive edge."
GNU will remove operating system software from the realm of competition. You will not be able to get an edge in this area, but neither will your competitors be able to get an edge over you. You and they will compete in other areas, while benefiting mutually in this one. If your business is selling an operating system, you will not like GNU, but that's tough on you. If your business is something else, GNU can save you from being pushed into the expensive business of selling operating systems.
I would like to see GNU development supported by gifts from many manufacturers and users, reducing the cost to each.(5)
"Don't programmers deserve a reward for their creativity?"
If anything deserves a reward, it is social contribution. Creativity can be a social contribution, but only in so far as society is free to use the results. If programmers deserve to be rewarded for creating innovative programs, by the same token they deserve to be punished if they restrict the use of these programs.
"Shouldn't a programmer be able to ask for a reward for his creativity?"
There is nothing wrong with wanting pay for work, or seeking to maximize one's income, as long as one does not use means that are destructive. But the means customary in the field of software today are based on destruction.
Extracting money from users of a program by restricting their use of it is destructive because the restrictions reduce the amount and the ways that the program can be used. This reduces the amount of wealth that humanity derives from the program. When there is a deliberate choice to restrict, the harmful consequences are deliberate destruction.
The reason a good citizen does not use such destructive means to become wealthier is that, if everyone did so, we would all become poorer from the mutual destructiveness. This is Kantian ethics; or, the Golden Rule. Since I do not like the consequences that result if everyone hoards information, I am required to consider it wrong for one to do so. Specifically, the desire to be rewarded for one's creativity does not justify depriving the world in general of all or part of that creativity.
"Won't programmers starve?"
I could answer that nobody is forced to be a programmer. Most of us cannot manage to get any money for standing on the street and making faces. But we are not, as a result, condemned to spend our lives standing on the street making faces, and starving. We do something else.
But that is the wrong answer because it accepts the questioner's implicit assumption: that without ownership of software, programmers cannot possibly be paid a cent. Supposedly it is all or nothing.
The real reason programmers will not starve is that it will still be possible for them to get paid for programming; just not paid as much as now.
Restricting copying is not the only basis for business in software. It is the most common basis because it brings in the most money. If it were prohibited, or rejected by the customer, software business would move to other bases of organization which are now used less often. There are always numerous ways to organize any kind of business.
Probably programming will not be as lucrative on the new basis as it is now. But that is not an argument against the change. It is not considered an injustice that sales clerks make the salaries that they now do. If programmers made the same, that would not be an injustice either. (In practice they would still make considerably more than that.)
"Don't people have a right to control how their creativity is used?"
"Control over the use of one's ideas" really constitutes control over other people's lives; and it is usually used to make their lives more difficult.
People who have studied the issue of intellectual property rights carefully (such as lawyers) say that there is no intrinsic right to intellectual property. The kinds of supposed intellectual property rights that the government recognizes were created by specific acts of legislation for specific purposes.
For example, the patent system was established to encourage inventors to disclose the details of their inventions. Its purpose was to help society rather than to help inventors. At the time, the life span of 17 years for a patent was short compared with the rate of advance of the state of the art. Since patents are an issue only among manufacturers, for whom the cost and effort of a license agreement are small compared with setting up production, the patents often do not do much harm. They do not obstruct most individuals who use patented products.
The idea of copyright did not exist in ancient times, when authors frequently copied other authors at length in works of non-fiction. This practice was useful, and is the only way many authors' works have survived even in part. The copyright system was created expressly for the purpose of encouraging authorship. In the domain for which it was invented--books, which could be copied economically only on a printing press--it did little harm, and did not obstruct most of the individuals who read the books.
All intellectual property rights are just licenses granted by society because it was thought, rightly or wrongly, that society as a whole would benefit by granting them. But in any particular situation, we have to ask: are we really better off granting such license? What kind of act are we licensing a person to do?
The case of programs today is very different from that of books a hundred years ago. The fact that the easiest way to copy a program is from one neighbor to another, the fact that a program has both source code and object code which are distinct, and the fact that a program is used rather than read and enjoyed, combine to create a situation in which a person who enforces a copyright is harming society as a whole both materially and spiritually; in which a person should not do so regardless of whether the law enables him to.
"Competition makes things get done better."
The paradigm of competition is a race: by rewarding the winner, we encourage everyone to run faster. When capitalism really works this way, it does a good job; but its defenders are wrong in assuming it always works this way. If the runners forget why the reward is offered and become intent on winning, no matter how, they may find other strategies--such as, attacking other runners. If the runners get into a fist fight, they will all finish late.
Proprietary and secret software is the moral equivalent of runners in a fist fight. Sad to say, the only referee we've got does not seem to object to fights; he just regulates them ("For every ten yards you run, you can fire one shot"). He really ought to break them up, and penalize runners for even trying to fight.
"Won't everyone stop programming without a monetary incentive?"
Actually, many people will program with absolutely no monetary incentive. Programming has an irresistible fascination for some people, usually the people who are best at it. There is no shortage of professional musicians who keep at it even though they have no hope of making a living that way.
But really this question, though commonly asked, is not appropriate to the situation. Pay for programmers will not disappear, only become less. So the right question is, will anyone program with a reduced monetary incentive? My experience shows that they will.
For more than ten years, many of the world's best programmers worked at the Artificial Intelligence Lab for far less money than they could have had anywhere else. They got many kinds of non-monetary rewards: fame and appreciation, for example. And creativity is also fun, a reward in itself.
Then most of them left when offered a chance to do the same interesting work for a lot of money.
What the facts show is that people will program for reasons other than riches; but if given a chance to make a lot of money as well, they will come to expect and demand it. Low-paying organizations do poorly in competition with high-paying ones, but they do not have to do badly if the high-paying ones are banned.
"We need the programmers desperately. If they demand that we stop helping our neighbors, we have to obey."
You're never so desperate that you have to obey this sort of demand. Remember: millions for defense, but not a cent for tribute!
"Programmers need to make a living somehow."
In the short run, this is true. However, there are plenty of ways that programmers could make a living without selling the right to use a program. This way is customary now because it brings programmers and businessmen the most money, not because it is the only way to make a living. It is easy to find other ways if you want to find them. Here are a number of examples.
A manufacturer introducing a new computer will pay for the porting of operating systems onto the new hardware.
The sale of teaching, hand-holding and maintenance services could also employ programmers.
People with new ideas could distribute programs as freeware, asking for donations from satisfied users, or selling hand-holding services. I have met people who are already working this way successfully.
Users with related needs can form users' groups, and pay dues. A group would contract with programming companies to write programs that the group's members would like to use.
All sorts of development can be funded with a Software Tax:
Suppose everyone who buys a computer has to pay x percent of the price as a software tax. The government gives this to an agency like the NSF to spend on software development.
But if the computer buyer makes a donation to software development himself, he can take a credit against the tax. He can donate to the project of his own choosing--often, chosen because he hopes to use the results when it is done. He can take a credit for any amount of donation up to the total tax he had to pay.
The total tax rate could be decided by a vote of the payers of the tax, weighted according to the amount they will be taxed on.
The consequences:
The computer-using community supports software development. This community decides what level of support is needed. Users who care which projects their share is spent on can choose this for themselves. In the long run, making programs free is a step toward the post-scarcity world, where nobody will have to work very hard just to make a living. People will be free to devote themselves to activities that are fun, such as programming, after spending the necessary ten hours a week on required tasks such as legislation, family counseling, robot repair and asteroid prospecting. There will be no need to be able to make a living from programming.
We have already greatly reduced the amount of work that the whole society must do for its actual productivity, but only a little of this has translated itself into leisure for workers because much nonproductive activity is required to accompany productive activity. The main causes of this are bureaucracy and isometric struggles against competition. Free software will greatly reduce these drains in the area of software production. We must do this, in order for technical gains in productivity to translate into less work for us.
--------------------------------------------------------------------------------
Footnotes
(1) The wording here was careless. The intention was that nobody would have to pay for *permission* to use the GNU system. But the words don't make this clear, and people often interpret them as saying that copies of GNU should always be distributed at little or no charge. That was never the intent; later on, the manifesto mentions the possibility of companies providing the service of distribution for a profit. Subsequently I have learned to distinguish carefully between "free" in the sense of freedom and "free" in the sense of price. Free software is software that users have the freedom to distribute and change. Some users may obtain copies at no charge, while others pay to obtain copies--and if the funds help support improving the software, so much the better. The important thing is that everyone who has a copy has the freedom to cooperate with others in using it.
(2) This is another place I failed to distinguish carefully between the two different meanings of "free". The statement as it stands is not false--you can get copies of GNU software at no charge, from your friends or over the net. But it does suggest the wrong idea.
(3) Several such companies now exist.
(4) The Free Software Foundation raises most of its funds from a distribution service, although it is a charity rather than a company. If *no one* chooses to obtain copies by ordering them from the FSF, it will be unable to do its work. But this does not mean that proprietary restrictions are justified to force every user to pay. If a small fraction of all the users order copies from the FSF, that is sufficient to keep the FSF afloat. So we ask users to choose to support us in this way. Have you done your part?
(5) A group of computer companies recently pooled funds to support maintenance of the GNU C Compiler.
--------------------------------------------------------------------------------
Other Texts to Read
--------------------------------------------------------------------------------
Return to GNU's home page. FSF & GNU inquiries & questions to gnu@gnu.org. Other ways to contact the FSF.
Comments on these web pages to webmasters@www.gnu.org, send other questions to gnu@gnu.org.
Copyright notice above.
Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA
Updated: $Date: 2002/06/10 20:26:52 $ $Author: guido_arnold $
--------------------------------------------------------------------------------

gnu'PROJECT

name::
* McsEngl.gnu'PROJECT@cptItsoft,

The GNU Project by Richard Stallman
originally published in the book "Open Sources"
[ Catalan | Czech | English | French | German | Indonesian | Italian | Korean | Russian | Spanish ]

The first software-sharing community
When I started working at the MIT Artificial Intelligence Lab in 1971, I became part of a software-sharing community that had existed for many years. Sharing of software was not limited to our particular community; it is as old as computers, just as sharing of recipes is as old as cooking. But we did it more than most.
The AI Lab used a timesharing operating system called ITS (the Incompatible Timesharing System) that the lab's staff hackers (1) had designed and written in assembler language for the Digital PDP-10, one of the large computers of the era. As a member of this community, an AI lab staff system hacker, my job was to improve this system.
We did not call our software "free software", because that term did not yet exist; but that is what it was. Whenever people from another university or a company wanted to port and use a program, we gladly let them. If you saw someone using an unfamiliar and interesting program, you could always ask to see the source code, so that you could read it, change it, or cannibalize parts of it to make a new program.
(1) The use of "hacker" to mean "security breaker" is a confusion on the part of the mass media. We hackers refuse to recognize that meaning, and continue using the word to mean, "Someone who loves to program and enjoys being clever about it."

The collapse of the community
The situation changed drastically in the early 1980s when Digital discontinued the PDP-10 series. Its architecture, elegant and powerful in the 60s, could not extend naturally to the larger address spaces that were becoming feasible in the 80s. This meant that nearly all of the programs composing ITS were obsolete.
The AI lab hacker community had already collapsed, not long before. In 1981, the spin-off company Symbolics had hired away nearly all of the hackers from the AI lab, and the depopulated community was unable to maintain itself. (The book Hackers, by Steve Levy, describes these events, as well as giving a clear picture of this community in its prime.) When the AI lab bought a new PDP-10 in 1982, its administrators decided to use Digital's non-free timesharing system instead of ITS.
The modern computers of the era, such as the VAX or the 68020, had their own operating systems, but none of them were free software: you had to sign a nondisclosure agreement even to get an executable copy.
This meant that the first step in using a computer was to promise not to help your neighbor. A cooperating community was forbidden. The rule made by the owners of proprietary software was, "If you share with your neighbor, you are a pirate. If you want any changes, beg us to make them."
The idea that the proprietary-software social system--the system that says you are not allowed to share or change software--is antisocial, that it is unethical, that it is simply wrong, may come as a surprise to some readers. But what else could we say about a system based on dividing the public and keeping users helpless? Readers who find the idea surprising may have taken proprietary-software social system as given, or judged it on the terms suggested by proprietary software businesses. Software publishers have worked long and hard to convince people that there is only one way to look at the issue.
When software publishers talk about "enforcing" their "rights" or "stopping piracy", what they actually *say* is secondary. The real message of these statements is in the unstated assumptions they take for granted; the public is supposed to accept them uncritically. So let's examine them.
One assumption is that software companies have an unquestionable natural right to own software and thus have power over all its users. (If this were a natural right, then no matter how much harm it does to the public, we could not object.) Interestingly, the US Constitution and legal tradition reject this view; copyright is not a natural right, but an artificial government-imposed monopoly that limits the users' natural right to copy.
Another unstated assumption is that the only important thing about software is what jobs it allows you to do--that we computer users should not care what kind of society we are allowed to have.
A third assumption is that we would have no usable software (or would never have a program to do this or that particular job) if we did not offer a company power over the users of the program. This assumption may have seemed plausible, before the free software movement demonstrated that we can make plenty of useful software without putting chains on it.
If we decline to accept these assumptions, and judge these issues based on ordinary common-sense morality while placing the users first, we arrive at very different conclusions. Computer users should be free to modify programs to fit their needs, and free to share software, because helping other people is the basis of society.
There is no room here for an extensive statement of the reasoning behind this conclusion, so I refer the reader to the web page, http://www.gnu.org/philosophy/why-free.html.

A stark moral choice.
With my community gone, to continue as before was impossible. Instead, I faced a stark moral choice.
The easy choice was to join the proprietary software world, signing nondisclosure agreements and promising not to help my fellow hacker. Most likely I would also be developing software that was released under nondisclosure agreements, thus adding to the pressure on other people to betray their fellows too.
I could have made money this way, and perhaps amused myself writing code. But I knew that at the end of my career, I would look back on years of building walls to divide people, and feel I had spent my life making the world a worse place.
I had already experienced being on the receiving end of a nondisclosure agreement, when someone refused to give me and the MIT AI lab the source code for the control program for our printer. (The lack of certain features in this program made use of the printer extremely frustrating.) So I could not tell myself that nondisclosure agreements were innocent. I was very angry when he refused to share with us; I could not turn around and do the same thing to everyone else.
Another choice, straightforward but unpleasant, was to leave the computer field. That way my skills would not be misused, but they would still be wasted. I would not be culpable for dividing and restricting computer users, but it would happen nonetheless.
So I looked for a way that a programmer could do something for the good. I asked myself, was there a program or programs that I could write, so as to make a community possible once again?
The answer was clear: what was needed first was an operating system. That is the crucial software for starting to use a computer. With an operating system, you can do many things; without one, you cannot run the computer at all. With a free operating system, we could again have a community of cooperating hackers--and invite anyone to join. And anyone would be able to use a computer without starting out by conspiring to deprive his or her friends.
As an operating system developer, I had the right skills for this job. So even though I could not take success for granted, I realized that I was elected to do the job. I chose to make the system compatible with Unix so that it would be portable, and so that Unix users could easily switch to it. The name GNU was chosen following a hacker tradition, as a recursive acronym for "GNU's Not Unix."
An operating system does not mean just a kernel, barely enough to run other programs. In the 1970s, every operating system worthy of the name included command processors, assemblers, compilers, interpreters, debuggers, text editors, mailers, and much more. ITS had them, Multics had them, VMS had them, and Unix had them. The GNU operating system would include them too.
Later I heard these words, attributed to Hillel (1):

If I am not for myself, who will be for me?

If I am only for myself, what am I?

If not now, when? The decision to start the GNU project was based on a similar spirit.
(1) As an Atheist, I don't follow any religious leaders, but I sometimes find I admire something one of them has said.

Free as in freedom The term "free software" is sometimes misunderstood--it has nothing to do with price. It is about freedom. Here, therefore, is the definition of free software: a program is free software, for you, a particular user, if:

You have the freedom to run the program, for any purpose. You have the freedom to modify the program to suit your needs. (To make this freedom effective in practice, you must have access to the source code, since making changes in a program without having the source code is exceedingly difficult.) You have the freedom to redistribute copies, either gratis or for a fee. You have the freedom to distribute modified versions of the program, so that the community can benefit from your improvements. Since "free" refers to freedom, not to price, there is no contradiction between selling copies and free software. In fact, the freedom to sell copies is crucial: collections of free software sold on CD-ROMs are important for the community, and selling them is an important way to raise funds for free software development. Therefore, a program which people are not free to include on these collections is not free software.
Because of the ambiguity of "free", people have long looked for alternatives, but no one has found a suitable alternative. The English Language has more words and nuances than any other, but it lacks a simple, unambiguous, word that means "free," as in freedom--"unfettered," being the word that comes closest in meaning. Such alternatives as "liberated", "freedom," and "open" have either the wrong meaning or some other disadvantage.

GNU software and the GNU system Developing a whole system is a very large project. To bring it into reach, I decided to adapt and use existing pieces of free software wherever that was possible. For example, I decided at the very beginning to use TeX as the principal text formatter; a few years later, I decided to use the X Window System rather than writing another window system for GNU.
Because of this decision, the GNU system is not the same as the collection of all GNU software. The GNU system includes programs that are not GNU software, programs that were developed by other people and projects for their own purposes, but which we can use because they are free software.

Commencing the project In January 1984 I quit my job at MIT and began writing GNU software. Leaving MIT was necessary so that MIT would not be able to interfere with distributing GNU as free software. If I had remained on the staff, MIT could have claimed to own the work, and could have imposed their own distribution terms, or even turned the work into a proprietary software package. I had no intention of doing a large amount of work only to see it become useless for its intended purpose: creating a new software-sharing community.
However, Professor Winston, then the head of the MIT AI Lab, kindly invited me to keep using the lab's facilities.

The first steps Shortly before beginning the GNU project, I heard about the Free University Compiler Kit, also known as VUCK. (The Dutch word for "free" is written with a V.) This was a compiler designed to handle multiple languages, including C and Pascal, and to support multiple target machines. I wrote to its author asking if GNU could use it.
He responded derisively, stating that the university was free but the compiler was not. I therefore decided that my first program for the GNU project would be a multi-language, multi-platform compiler.
Hoping to avoid the need to write the whole compiler myself, I obtained the source code for the Pastel compiler, which was a multi-platform compiler developed at Lawrence Livermore Lab. It supported, and was written in, an extended version of Pascal, designed to be a system-programming language. I added a C front end, and began porting it to the Motorola 68000 computer. But I had to give that up when I discovered that the compiler needed many megabytes of stack space, and the available 68000 Unix system would only allow 64k.
I then realized that the Pastel compiler functioned by parsing the entire input file into a syntax tree, converting the whole syntax tree into a chain of "instructions", and then generating the whole output file, without ever freeing any storage. At this point, I concluded I would have to write a new compiler from scratch. That new compiler is now known as GCC; none of the Pastel compiler is used in it, but I managed to adapt and use the C front end that I had written. But that was some years later; first, I worked on GNU Emacs.

GNU Emacs
I began work on GNU Emacs in September 1984, and in early 1985 it was beginning to be usable. This enabled me to begin using Unix systems to do editing; having no interest in learning to use vi or ed, I had done my editing on other kinds of machines until then.
At this point, people began wanting to use GNU Emacs, which raised the question of how to distribute it. Of course, I put it on the anonymous ftp server on the MIT computer that I used. (This computer, prep.ai.mit.edu, thus became the principal GNU ftp distribution site; when it was decommissioned a few years later, we transferred the name to our new ftp server.) But at that time, many of the interested people were not on the Internet and could not get a copy by ftp. So the question was, what would I say to them?
I could have said, "Find a friend who is on the net and who will make a copy for you." Or I could have done what I did with the original PDP-10 Emacs: tell them, "Mail me a tape and a SASE, and I will mail it back with Emacs on it." But I had no job, and I was looking for ways to make money from free software. So I announced that I would mail a tape to whoever wanted one, for a fee of $150. In this way, I started a free software distribution business, the precursor of the companies that today distribute entire Linux-based GNU systems.

Is a program free for every user?
If a program is free software when it leaves the hands of its author, this does not necessarily mean it will be free software for everyone who has a copy of it. For example, public domain software (software that is not copyrighted) is free software; but anyone can make a proprietary modified version of it. Likewise, many free programs are copyrighted but distributed under simple permissive licenses which allow proprietary modified versions.
The paradigmatic example of this problem is the X Window System. Developed at MIT, and released as free software with a permissive license, it was soon adopted by various computer companies. They added X to their proprietary Unix systems, in binary form only, and covered by the same nondisclosure agreement. These copies of X were no more free software than Unix was.
The developers of the X Window System did not consider this a problem--they expected and intended this to happen. Their goal was not freedom, just "success", defined as "having many users." They did not care whether these users had freedom, only that they should be numerous.
This lead to a paradoxical situation where two different ways of counting the amount of freedom gave different answers to the question, "Is this program free?" If you judged based on the freedom provided by the distribution terms of the MIT release, you would say that X was free software. But if you measured the freedom of the average user of X, you would have to say it was proprietary software. Most X users were running the proprietary versions that came with Unix systems, not the free version.

Copyleft and the GNU GPL The goal of GNU was to give users freedom, not just to be popular. So we needed to use distribution terms that would prevent GNU software from being turned into proprietary software. The method we use is called "copyleft".(1)
Copyleft uses copyright law, but flips it over to serve the opposite of its usual purpose: instead of a means of privatizing software, it becomes a means of keeping software free.
The central idea of copyleft is that we give everyone permission to run the program, copy the program, modify the program, and distribute modified versions--but not permission to add restrictions of their own. Thus, the crucial freedoms that define "free software" are guaranteed to everyone who has a copy; they become inalienable rights.
For an effective copyleft, modified versions must also be free. This ensures that work based on ours becomes available to our community if it is published. When programmers who have jobs as programmers volunteer to improve GNU software, it is copyleft that prevents their employers from saying, "You can't share those changes, because we are going to use them to make our proprietary version of the program."
The requirement that changes must be free is essential if we want to ensure freedom for every user of the program. The companies that privatized the X Window System usually made some changes to port it to their systems and hardware. These changes were small compared with the great extent of X, but they were not trivial. If making changes were an excuse to deny the users freedom, it would be easy for anyone to take advantage of the excuse.
A related issue concerns combining a free program with non-free code. Such a combination would inevitably be non-free; whichever freedoms are lacking for the non-free part would be lacking for the whole as well. To permit such combinations would open a hole big enough to sink a ship. Therefore, a crucial requirement for copyleft is to plug this hole: anything added to or combined with a copylefted program must be such that the larger combined version is also free and copylefted.
The specific implementation of copyleft that we use for most GNU software is the GNU General Public License, or GNU GPL for short. We have other kinds of copyleft that are used in specific circumstances. GNU manuals are copylefted also, but use a much simpler kind of copyleft, because the complexity of the GNU GPL is not necessary for manuals.
(1) In 1984 or 1985, Don Hopkins (a very imaginative fellow) mailed me a letter. On the envelope he had written several amusing sayings, including this one: "Copyleft--all rights reversed." I used the word "copyleft" to name the distribution concept I was developing at the time.

The Free Software Foundation
As interest in using Emacs was growing, other people became involved in the GNU project, and we decided that it was time to seek funding once again. So in 1985 we created the Free Software Foundation, a tax-exempt charity for free software development. The FSF also took over the Emacs tape distribution business; later it extended this by adding other free software (both GNU and non-GNU) to the tape, and by selling free manuals as well.
The FSF accepts donations, but most of its income has always come from sales--of copies of free software, and of other related services. Today it sells CD-ROMs of source code, CD-ROMs with binaries, nicely printed manuals (all with freedom to redistribute and modify), and Deluxe Distributions (where we build the whole collection of software for your choice of platform).
Free Software Foundation employees have written and maintained a number of GNU software packages. Two notable ones are the C library and the shell. The GNU C library is what every program running on a GNU/Linux system uses to communicate with Linux. It was developed by a member of the Free Software Foundation staff, Roland McGrath. The shell used on most GNU/Linux systems is BASH, the Bourne Again Shell(1), which was developed by FSF employee Brian Fox.
We funded development of these programs because the GNU project was not just about tools or a development environment. Our goal was a complete operating system, and these programs were needed for that goal.
(1) "Bourne again Shell" is a joke on the name ``Bourne Shell'', which was the usual shell on Unix.

Free software support
The free software philosophy rejects a specific widespread business practice, but it is not against business. When businesses respect the users' freedom, we wish them success.
Selling copies of Emacs demonstrates one kind of free software business. When the FSF took over that business, I needed another way to make a living. I found it in selling services relating to the free software I had developed. This included teaching, for subjects such as how to program GNU Emacs and how to customize GCC, and software development, mostly porting GCC to new platforms.
Today each of these kinds of free software business is practiced by a number of corporations. Some distribute free software collections on CD-ROM; others sell support at levels ranging from answering user questions, to fixing bugs, to adding major new features. We are even beginning to see free software companies based on launching new free software products.
Watch out, though--a number of companies that associate themselves with the term "open source" actually base their business on non-free software that works with free software. These are not free software companies, they are proprietary software companies whose products tempt users away from freedom. They call these "value added", which reflects the values they would like us to adopt: convenience above freedom. If we value freedom more, we should call them "freedom subtracted" products.

Technical goals The principal goal of GNU was to be free software. Even if GNU had no technical advantage over Unix, it would have a social advantage, allowing users to cooperate, and an ethical advantage, respecting the user's freedom.
But it was natural to apply the known standards of good practice to the work--for example, dynamically allocating data structures to avoid arbitrary fixed size limits, and handling all the possible 8-bit codes wherever that made sense.
In addition, we rejected the Unix focus on small memory size, by deciding not to support 16-bit machines (it was clear that 32-bit machines would be the norm by the time the GNU system was finished), and to make no effort to reduce memory usage unless it exceeded a megabyte. In programs for which handling very large files was not crucial, we encouraged programmers to read an entire input file into core, then scan its contents without having to worry about I/O.
These decisions enabled many GNU programs to surpass their Unix counterparts in reliability and speed.

Donated computers
As the GNU project's reputation grew, people began offering to donate machines running UNIX to the project. These were very useful, because the easiest way to develop components of GNU was to do it on a UNIX system, and replace the components of that system one by one. But they raised an ethical issue: whether it was right for us to have a copy of UNIX at all.
UNIX was (and is) proprietary software, and the GNU project's philosophy said that we should not use proprietary software. But, applying the same reasoning that leads to the conclusion that violence in self defense is justified, I concluded that it was legitimate to use a proprietary package when that was crucial for developing a free replacement that would help others stop using the proprietary package.
But, even if this was a justifiable evil, it was still an evil. Today we no longer have any copies of Unix, because we have replaced them with free operating systems. If we could not replace a machine's operating system with a free one, we replaced the machine instead.

The GNU Task List
As the GNU project proceeded, and increasing numbers of system components were found or developed, eventually it became useful to make a list of the remaining gaps. We used it to recruit developers to write the missing pieces. This list became known as the GNU task list. In addition to missing Unix components, we listed added various other useful software and documentation projects that, we thought, a truly complete system ought to have.
Today, hardly any Unix components are left in the GNU task list--those jobs have been done, aside from a few inessential ones. But the list is full of projects that some might call "applications". Any program that appeals to more than a narrow class of users would be a useful thing to add to an operating system.
Even games are included in the task list--and have been since the beginning. Unix included games, so naturally GNU should too. But compatibility was not an issue for games, so we did not follow the list of games that Unix had. Instead, we listed a spectrum of different kinds of games that users might like.

The GNU Library GPL
The GNU C library uses a special kind of copyleft called the GNU Library General Public License, which gives permission to link proprietary software with the library. Why make this exception?
It is not a matter of principle; there is no principle that says proprietary software products are entitled to include our code. (Why contribute to a project predicated on refusing to share with us?) Using the LGPL for the C library, or for any library, is a matter of strategy.
The C library does a generic job; every proprietary system or compiler comes with a C library. Therefore, to make our C library available only to free software would not have given free software any advantage--it would only have discouraged use of our library.
One system is an exception to this: on the GNU system (and this includes GNU/Linux), the GNU C library is the only C library. So the distribution terms of the GNU C library determine whether it is possible to compile a proprietary program for the GNU system. There is no ethical reason to allow proprietary applications on the GNU system, but strategically it seems that disallowing them would do more to discourage use of the GNU system than to encourage development of free applications.
That is why using the Library GPL is a good strategy for the C library. For other libraries, the strategic decision needs to be considered on a case-by-case basis. When a library does a special job that can help write certain kinds of programs, then releasing it under the GPL, limiting it to free programs only, is a way of helping other free software developers, giving them an advantage against proprietary software.
Consider GNU Readline, a library that was developed to provide command-line editing for BASH. Readline is released under the ordinary GNU GPL, not the Library GPL. This probably does reduce the amount Readline is used, but that is no loss for us. Meanwhile, at least one useful application has been made free software specifically so it could use Readline, and that is a real gain for the community.
Proprietary software developers have the advantages money provides; free software developers need to make advantages for each other. I hope some day we will have a large collection of GPL-covered libraries that have no parallel available to proprietary software, providing useful modules to serve as building blocks in new free software, and adding up to a major advantage for further free software development.

Scratching an itch?
Eric Raymond says that "Every good work of software starts by scratching a developer's personal itch." Maybe that happens sometimes, but many essential pieces of GNU software were developed in order to have a complete free operating system. They come from a vision and a plan, not from impulse.
For example, we developed the GNU C library because a Unix-like system needs a C library, the Bourne-Again Shell (bash) because a Unix-like system needs a shell, and GNU tar because a Unix-like system needs a tar program. The same is true for my own programs--the GNU C compiler, GNU Emacs, GDB and GNU Make.
Some GNU programs were developed to cope with specific threats to our freedom. Thus, we developed gzip to replace the Compress program, which had been lost to the community because of the LZW patents. We found people to develop LessTif, and more recently started GNOME and Harmony, to address the problems caused by certain proprietary libraries (see below). We are developing the GNU Privacy Guard to replace popular non-free encryption software, because users should not have to choose between privacy and freedom.
Of course, the people writing these programs became interested in the work, and many features were added to them by various people for the sake of their own needs and interests. But that is not why the programs exist.

Unexpected developments At the beginning of the GNU project, I imagined that we would develop the whole GNU system, then release it as a whole. That is not how it happened.
Since each component of the GNU system was implemented on a Unix system, each component could run on Unix systems, long before a complete GNU system existed. Some of these programs became popular, and users began extending them and porting them---to the various incompatible versions of Unix, and sometimes to other systems as well.
The process made these programs much more powerful, and attracted both funds and contributors to the GNU project. But it probably also delayed completion of a minimal working system by several years, as GNU developers' time was put into maintaining these ports and adding features to the existing components, rather than moving on to write one missing component after another.

The GNU Hurd By 1990, the GNU system was almost complete; the only major missing component was the kernel. We had decided to implement our kernel as a collection of server processes running on top of Mach. Mach is a microkernel developed at Carnegie Mellon University and then at the University of Utah; the GNU HURD is a collection of servers (or ``herd of gnus'') that run on top of Mach, and do the various jobs of the Unix kernel. The start of development was delayed as we waited for Mach to be released as free software, as had been promised.
One reason for choosing this design was to avoid what seemed to be the hardest part of the job: debugging a kernel program without a source-level debugger to do it with. This part of the job had been done already, in Mach, and we expected to debug the HURD servers as user programs, with GDB. But it took a long time to make that possible, and the multi-threaded servers that send messages to each other have turned out to be very hard to debug. Making the HURD work solidly has stretched on for many years.

Alix
The GNU kernel was not originally supposed to be called the HURD. Its original name was Alix--named after the woman who was my sweetheart at the time. She, a Unix system administrator, had pointed out how her name would fit a common naming pattern for Unix system versions; as a joke, she told her friends, "Someone should name a kernel after me." I said nothing, but decided to surprise her with a kernel named Alix.
It did not stay that way. Michael Bushnell (now Thomas), the main developer of the kernel, preferred the name HURD, and redefined Alix to refer to a certain part of the kernel--the part that would trap system calls and handle them by sending messages to HURD servers.
Ultimately, Alix and I broke up, and she changed her name; independently, the HURD design was changed so that the C library would send messages directly to servers, and this made the Alix component disappear from the design.
But before these things happened, a friend of hers came across the name Alix in the HURD source code, and mentioned the name to her. So the name did its job.

Linux and GNU/Linux
The GNU Hurd is not ready for production use. Fortunately, another kernel is available. In 1991, Linus Torvalds developed a Unix-compatible kernel and called it Linux. Around 1992, combining Linux with the not-quite-complete GNU system resulted in a complete free operating system. (Combining them was a substantial job in itself, of course.) It is due to Linux that we can actually run a version of the GNU system today.
We call this system version GNU/Linux, to express its composition as a combination of the GNU system with Linux as the kernel.

Challenges in our future
We have proved our ability to develop a broad spectrum of free software. This does not mean we are invincible and unstoppable. Several challenges make the future of free software uncertain; meeting them will require steadfast effort and endurance, sometimes lasting for years. It will require the kind of determination that people display when they value their freedom and will not let anyone take it away.
The following four sections discuss these challenges.

Secret hardware
Hardware manufactures increasingly tend to keep hardware specifications secret. This makes it difficult to write free drivers so that Linux and XFree86 can support new hardware. We have complete free systems today, but we will not have them tomorrow if we cannot support tomorrow's computers.
There are two ways to cope with this problem. Programmers can do reverse engineering to figure out how to support the hardware. The rest of us can choose the hardware that is supported by free software; as our numbers increase, secrecy of specifications will become a self-defeating policy.
Reverse engineering is a big job; will we have programmers with sufficient determination to undertake it? Yes--if we have built up a strong feeling that free software is a matter of principle, and non-free drivers are intolerable. And will large numbers of us spend extra money, or even a little extra time, so we can use free drivers? Yes, if the determination to have freedom is widespread.

Non-free libraries
A non-free library that runs on free operating systems acts as a trap for free software developers. The library's attractive features are the bait; if you use the library, you fall into the trap, because your program cannot usefully be part of a free operating system. (Strictly speaking, we could include your program, but it won't run with the library missing.) Even worse, if a program that uses the proprietary library becomes popular, it can lure other unsuspecting programmers into the trap.
The first instance of this problem was the Motif toolkit, back in the 80s. Although there were as yet no free operating systems, it was clear what problem Motif would cause for them later on. The GNU Project responded in two ways: by asking individual free software projects to support the free X toolkit widgets as well as Motif, and by asking for someone to write a free replacement for Motif. The job took many years; LessTif, developed by the Hungry Programmers, became powerful enough to support most Motif applications only in 1997.
Between 1996 and 1998, another non-free GUI toolkit library, called Qt, was used in a substantial collection of free software, the desktop KDE.
Free GNU/Linux systems were unable to use KDE, because we could not use the library. However, some commercial distributors of GNU/Linux systems who were not strict about sticking with free software added KDE to their systems--producing a system with more capabilities, but less freedom. The KDE group was actively encouraging more programmers to use Qt, and millions of new "Linux users" had never been exposed to the idea that there was a problem in this. The situation appeared grim.
The free software community responded to the problem in two ways: GNOME and Harmony.
GNOME, the GNU Network Object Model Environment, is GNU's desktop project. Started in 1997 by Miguel de Icaza, and developed with the support of Red Hat Software, GNOME set out to provide similar desktop facilities, but using free software exclusively. It has technical advantages as well, such as supporting a variety of languages, not just C++. But its main purpose was freedom: not to require the use of any non-free software.
Harmony is a compatible replacement library, designed to make it possible to run KDE software without using Qt.
In November 1998, the developers of Qt announced a change of license which, when carried out, should make Qt free software. There is no way to be sure, but I think that this was partly due to the community's firm response to the problem that Qt posed when it was non-free. (The new license is inconvenient and inequitable, so it remains desirable to avoid using Qt.)
[Subsequent note: in September 2000, Qt was rereleased under the GNU GPL, which essentially solved this problem.]
How will we respond to the next tempting non-free library? Will the whole community understand the need to stay out of the trap? Or will many of us give up freedom for convenience, and produce a major problem? Our future depends on our philosophy.

Software patents
The worst threat we face comes from software patents, which can put algorithms and features off limits to free software for up to twenty years. The LZW compression algorithm patents were applied for in 1983, and we still cannot release free software to produce proper compressed GIFs. In 1998, a free program to produce MP3 compressed audio was removed from distribution under threat of a patent suit.
There are ways to cope with patents: we can search for evidence that a patent is invalid, and we can look for alternative ways to do a job. But each of these methods works only sometimes; when both fail, a patent may force all free software to lack some feature that users want. What will we do when this happens?
Those of us who value free software for freedom's sake will stay with free software anyway. We will manage to get work done without the patented features. But those who value free software because they expect it to be techically superior are likely to call it a failure when a patent holds it back. Thus, while it is useful to talk about the practical effectiveness of the "cathedral" model of development(1), and the reliability and power of some free software, we must not stop there. We must talk about freedom and principle.

Free documentation
The biggest deficiency in our free operating systems is not in the software--it is the lack of good free manuals that we can include in our systems. Documentation is an essential part of any software package; when an important free software package does not come with a good free manual, that is a major gap. We have many such gaps today.
Free documentation, like free software, is a matter of freedom, not price. The criterion for a free manual is pretty much the same as for free software: it is a matter of giving all users certain freedoms. Redistribution (including commercial sale) must be permitted, on-line and on paper, so that the manual can accompany every copy of the program.
Permission for modification is crucial too. As a general rule, I don't believe that it is essential for people to have permission to modify all sorts of articles and books. For example, I don't think you or I are obliged to give permission to modify articles like this one, which describe our actions and our views.
But there is a particular reason why the freedom to modify is crucial for documentation for free software. When people exercise their right to modify the software, and add or change its features, if they are conscientious they will change the manual too--so they can provide accurate and usable documentation with the modified program. A manual which does not allow programmers to be conscientious and finish the job, does not fill our community's needs.
Some kinds of limits on how modifications are done pose no problem. For example, requirements to preserve the original author's copyright notice, the distribution terms, or the list of authors, are ok. It is also no problem to require modified versions to include notice that they were modified, even to have entire sections that may not be deleted or changed, as long as these sections deal with nontechnical topics. These kinds of restrictions are not a problem because they don't stop the conscientious programmer from adapting the manual to fit the modified program. In other words, they don't block the free software community from making full use of the manual.
However, it must be possible to modify all the *technical* content of the manual, and then distribute the result in all the usual media, through all the usual channels; otherwise, the restrictions do obstruct the community, the manual is not free, and we need another manual.
Will free software developers have the awareness and determination to produce a full spectrum of free manuals? Once again, our future depends on philosophy.

We must talk about freedom Estimates today are that there are ten million users of GNU/Linux systems such as Debian GNU/Linux and Red Hat Linux. Free software has developed such practical advantages that users are flocking to it for purely practical reasons.
The good consequences of this are evident: more interest in developing free software, more customers for free software businesses, and more ability to encourage companies to develop commercial free software instead of proprietary software products.
But interest in the software is growing faster than awareness of the philosophy it is based on, and this leads to trouble. Our ability to meet the challenges and threats described above depends on the will to stand firm for freedom. To make sure our community has this will, we need to spread the idea to the new users as they come into the community.
But we are failing to do so: the efforts to attract new users into our community are far outstripping the efforts to teach them the civics of our community. We need to do both, and we need to keep the two efforts in balance.

"Open Source" Teaching new users about freedom became more difficult in 1998, when a part of the community decided to stop using the term "free software" and say "open source software" instead.
Some who favored this term aimed to avoid the confusion of "free" with "gratis"--a valid goal. Others, however, aimed to set aside the spirit of principle that had motivated the free software movement and the GNU project, and to appeal instead to executives and business users, many of whom hold an ideology that places profit above freedom, above community, above principle. Thus, the rhetoric of "open source" focuses on the potential to make high quality, powerful software, but shuns the ideas of freedom, community, and principle.
The "Linux" magazines are a clear example of this--they are filled with advertisements for proprietary software that works with GNU/Linux. When the next Motif or Qt appears, will these magazines warn programmers to stay away from it, or will they run ads for it?
The support of business can contribute to the community in many ways; all else being equal, it is useful. But winning their support by speaking even less about freedom and principle can be disastrous; it makes the previous imbalance between outreach and civics education even worse.
"Free software" and "open source" describe the same category of software, more or less, but say different things about the software, and about values. The GNU Project continues to use the term "free software", to express the idea that freedom, not just technology, is important.

Try!
Yoda's philosophy ("There is no `try'") sounds neat, but it doesn't work for me. I have done most of my work while anxious about whether I could do the job, and unsure that it would be enough to achieve the goal if I did. But I tried anyway, because there was no one but me between the enemy and my city. Surprising myself, I have sometimes succeeded.
Sometimes I failed; some of my cities have fallen. Then I found another threatened city, and got ready for another battle. Over time, I've learned to look for threats and put myself between them and my city, calling on other hackers to come and join me.
Nowadays, often I'm not the only one. It is a relief and a joy when I see a regiment of hackers digging in to hold the line, and I realize, this city may survive--for now. But the dangers are greater each year, and now Microsoft has explicitly targeted our community. We can't take the future of freedom for granted. Don't take it for granted! If you want to keep your freedom, you must be prepared to defend it.

Footnotes I probably meant to write `of the "bazaar" model', since that was the alternative that was new and initially controversial. -- rms, 2002.

--------------------------------------------------------------------------------
More about the GNU Project
--------------------------------------------------------------------------------
[ Catalan | Czech | English | French | German | Indonesian | Italian | Korean | Russian | Spanish ]
Return to GNU's home page.
Please send FSF & GNU inquiries & questions to gnu@gnu.org. There are also other ways to contact the FSF.
Please send comments on these web pages to webmasters@gnu.org, send other questions to gnu@gnu.org.
Copyright (C) 1998, 2001 Richard Stallman.
Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.
Updated: $Date: 2003/02/08 12:28:52 $ $Author: joanplanas $

gnu'ResourceInfHmnn#cptResource843#

name::
* McsEngl.gnu'ResourceInfHmnn@cptItsoft,

www.gnu.org

www.fsfeurop.org

gnu'ENVIRONMENT#cptCore756#

name::
* McsEngl.gnu'ENVIRONMENT@cptItsoft,

GNU & LINUX

name::
* McsEngl.conceptItsoft1082.2,
* McsEngl.gnu'and'linux@cptItsoft1082.2,
* McsEngl.linux'and'gnu@cptItsoft1082.2,

Linux and the GNU Project
by Richard Stallman
[ Catalan | Chinese(Simplified) | Chinese(Traditional) | Czech | English | French | German | Italian | Japanese | Korean | Polish | Portuguese | Romanian | Russian | Serbo-Croatian | Slovenian ]

Many computer users run a modified version of the GNU system (18k characters) every day, without realizing it. Through a peculiar turn of events, the version of GNU which is widely used today is more often known as ``Linux'', and many users are not aware of the extent of its connection with the GNU Project.
There really is a Linux, and these people are using it, but it is not the operating system. Linux is the kernel: the program in the system that allocates the machine's resources to the other programs that you run. The kernel is an essential part of an operating system, but useless by itself; it can only function in the context of a complete operating system. Linux is normally used in a combination with the GNU operating system: the whole system is basically GNU, with Linux functioning as its kernel.
Many users are not fully aware of the distinction between the kernel, which is Linux, and the whole system, which they also call ``Linux''. The ambiguous use of the name doesn't promote understanding. These users often think that Linus Torvalds developed the whole operating system in 1991, with a bit of help.
Programmers generally know that Linux is a kernel. But since they have generally heard the whole system called ``Linux'' as well, they often envisage a history that would justify naming the whole system after the kernel. For example, many believe that once Linus Torvalds finished writing Linux, the kernel, its users looked around for other free software to go with it, and found that (for no particular reason) most everything necessary to make a Unix-like system was already available.
What they found was no accident--it was the GNU system. The available free software added up to a complete system because the GNU Project had been working since 1984 to make one. The GNU Manifesto (31k characters) had set forth the goal of developing a free Unix-like system, called GNU. The Initial Announcement of the GNU Project also outlines some of the original plans for the GNU system. By the time Linux was written, the system was almost finished.
Most free software projects have the goal of developing a particular program for a particular job. For example, Linus Torvalds set out to write a Unix-like kernel (Linux); Donald Knuth set out to write a text formatter (TeX); Bob Scheifler set out to develop a window system (the X Window system). It's natural to measure the contribution of this kind of project by specific programs that came from the project.
If we tried to measure the GNU Project's contribution in this way, what would we conclude? One CD-ROM vendor found that in their ``Linux distribution'', GNU software was the largest single contingent, around 28% of the total source code, and this included some of the essential major components without which there could be no system. Linux itself was about 3%. So if you were going to pick a name for the system based on who wrote the programs in the system, the most appropriate single choice would be ``GNU''.
But we don't think that is the right way to consider the question. The GNU Project was not, is not, a project to develop specific software packages. It was not a project to develop a C compiler, although we did. It was not a project to develop a text editor, although we developed one. The GNU Project's aim was to develop a complete free Unix-like system: GNU.
Many people have made major contributions to the free software in the system, and they all deserve credit. But the reason it is an integrated system--and not just a collection of useful programs--is because the GNU Project set out to make it one. We made a list of the programs needed to make a complete free system, and we systematically found, wrote, or found people to write everything on the list. We wrote essential but unexciting (1) components because you can't have a system without them. Some of our system components, the programming tools, became popular on their own among programmers, but we wrote many components that are not tools (2). We even developed a chess game, GNU Chess, because a complete system needs good games too.
By the early 90s we had put together the whole system aside from the kernel (and we were also working on a kernel, the GNU Hurd, which runs on top of Mach). Developing this kernel has been a lot harder than we expected; the GNU Hurd started working reliably in 2001. We're now starting to prepare the actual release of the GNU system, with the GNU Hurd.
Fortunately, you didn't have to wait for the Hurd, because Linux was available. When Linus Torvalds wrote Linux, he filled the last major gap. People could then put Linux together with the GNU system to make a complete free system: a Linux-based version of the GNU system; the GNU/Linux system, for short.
Putting them together sounds simple, but it was not a trivial job. Some GNU components(3) needed substantial change to work with Linux. Integrating a complete system as a distribution that would work ``out of the box'' was a big job, too. It required addressing the issue of how to install and boot the system--a problem we had not tackled, because we hadn't yet reached that point. The people who developed the various system distributions made a substantial contribution.
The GNU Project supports GNU/Linux systems as well as the GNU system--even with funds. We funded the rewriting of the Linux-related extensions to the GNU C library, so that now they are well integrated, and the newest GNU/Linux systems use the current library release with no changes. We also funded an early stage of the development of Debian GNU/Linux.
We use Linux-based GNU systems today for most of our work, and we hope you use them too. But please don't confuse the public by using the name ``Linux'' ambiguously. Linux is the kernel, one of the essential major components of the system. The system as a whole is more or less the GNU system, with Linux added. When you're talking about this combination, please call it ``GNU/Linux''.
If you want to make a link on ``GNU/Linux'' for further reference, this page and http://www.gnu.org/gnu/the-gnu-project.html are good choices. If you mention Linux, the kernel, and want to add a link for further reference, http://www.kernel.org/ is a good URL to use.
Addendum: Aside from GNU, one other project has independently produced a free Unix-like operating system. This system is known as BSD, and it was developed at UC Berkeley. It was non-free in the 80s, but became free in the early 90s. A free operating system that exists today is almost certainly either a variant of the GNU system, or a kind of BSD system.
People sometimes ask whether BSD too is a version of GNU, like GNU/Linux. The BSD developers were inspired to make their code free software by the example of the GNU Project, and explicit appeals from GNU activists helped persuade them, but the code had little overlap with GNU. BSD systems today use some GNU programs, just as the GNU system and its variants use some BSD programs; however, taken as wholes, they are two different systems that evolved separately. The BSD developers did not write a kernel and add it to the GNU system, and a name like GNU/BSD would not fit the situation.
[If you would like to learn more about this issue, you can also read our GNU/Linux FAQ.]

Notes: These unexciting but essential components include the GNU assembler, GAS and the linker, GLD, both are now part of the GNU Binutils package, GNU tar, and more.
For instance, The Bourne Again SHell (BASH), the PostScript interpreter Ghostscript, and the GNU C library are not programming tools. Neither are GNUCash, GNOME, and GNU Chess.
For instance, the GNU C library).

-------------------------------------------------------------------------------- Return to GNU's home page. Please send FSF & GNU inquiries & questions to gnu@gnu.org. There are also other ways to contact the FSF.
Please send comments on these web pages to webmasters@www.gnu.org, send other questions to gnu@gnu.org.
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Richard M. Stallman
Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.
Updated: $Date: 2002/12/14 08:34:26 $ $Author: rps $

SPECIFIC

_SPECIFIC#ql:_GENERIC cptItsoft1082#

FvMcs.Cmrpgm.OPERATING-SYSTEM (os)

_CREATED: {2003-02-23} {1994}

name::
* McsEngl.conceptItsoft1111,
* McsEngl.Cmrpgm.OPERATING-SYSTEM (os)@cptItsoft,
* McsEngl.FvMcs.Cmrpgm.OPERATING-SYSTEM (os)@cptItsoft,
* McsEngl.os@cptItsoft,
* McsEngl.pgmOs@cptItsoft,

* McsEngl.operating-system@cptItsoft,
* McsEngl.operating'system@cptItsoft1111,
* McsEngl.OS@cptItsoft,
* McsEngl.os@cptItsoft1111,
* McsEngl.program.system.os@cptItsoft11111,
* McsEngl.program.Operating'System@cptItsoft1111,
====== lagoGreek:
* McsElln.ΛΕΙΤΟΥΡΓΙΚΟ-ΣΥΣΤΗΜΑ@cptItsoft,
* McsElln.ΠΕΡΙΒΑΛΛΟΝ@cptItsoft,

DEFINITION

ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ είναι ΠΡΟΓΡΑΜΜΑ-ΣΥΣΤΗΜΑΤΟΣ που βοηθάει στη διαχείριση του υπολογιστή.
[hmnSngo.1995-03]

ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ είναι το πιο βασικό τμήμα του ΛΟΓΙΣΜΙΚΟΥ ΣΥΣΤΗΜΑΤΟΣ, το σύνολο των προγραμμάτων που ελέγχουν και συντονίζουν τη λειτουργία των μονάδων του υπολογιστή.
[Γιαλούρης κα, Εφαρμογές Πληροφορικής... Α',Β',Γ' Ε.Λυκείου, 1998 α' έκδοση, 75]

Η ΤΙΜΗ 444-8(ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ) στο χαρακτηριστικο FUNCTION(444), ΟΡΙΖΕΙ την έννοια ΛΕΙΤΟΥΡΓΙΚΟ

os'GENERIC

_GENERIC:
* SYSTEM-PROGRAM#cptItsoft331#

os'WHOLE

_WHOLE:
Κάθε λειτουργικο συστημα είναι χαρακτηριστικο της οντοτητας INFORMATION MACHINE SYSTEM#cptIt453#

os'association#cptIt969#

name::
* McsEngl.os'association@cptItsoft,

os'bit-architecture#cptIt472#

name::
* McsEngl.os'bit-architecture@cptItsoft,

_DESCRIPTION:
Ποσότητα μπιτ που επεξεργάζονται σε κάθε κύκλο ρεύματος.
===
32 Bit. ΜΠΟΡΕΙ ΝΑ ΕΚΤΕΛΕΙ ΤΙΣ ΕΝΤΟΛΕΣ ΤΟΥ ΠΟΛΥ ΠΙΟ ΓΡΗΓΟΡΑ, ΜΙΑΣ ΚΑΙ ΣΕ ΚΑΘΕ ΚΥΚΛΟ ΤΟΥ ΡΟΛΟΓΙΟΥ ΜΕΤΑΒΙΒΑΖΕΙ ΜΕΓΑΛΥΤΕΡΟ ΑΡΙΘΜΟ ΕΝΤΟΛΩΝ ΑΠ'ΟΤΙ ΕΝΑ ΔΕΚΑΕΞΑΜΠΙΤΟ ΣΥΣΤΗΜΑ.

os'character-set

name::
* McsEngl.os'character-set@cptItsoft,

_GENERIC:
ALPHABET#cptIt431: attPar#

_DESCRIPTION:
Κάθε λειτουργικό συστημα δουλεύει με κάποιο ΑΛΦΑΒΗΤΟ (στάνταρντ συμβολων, ASCII, UNICODE etc)

os'compatibility-with-other-os

name::
* McsEngl.os'compatibility-with-other-os@cptItsoft,
* McsEngl.conceptIt473,
* McsEngl.compatibility-with-other-OSs@cptItsoft,

DEFINITION

Με πιά άλλα λειτουργικά συστήματα ένα λειτουργικο σύστημα συνεργάζεται.
[ΝΙΚΟΣ, ΝΟΕΜ. 1994]

os'configuration

name::
* McsEngl.os'configuration@cptItsoft,
* McsEngl.conceptItsoft1111.1,
* McsEngl.os'setting@cptItsoft1111.1,

os'environment-variable

name::
* McsEngl.os'environment-variable@cptItsoft,

_DESCRIPTION:
Environment variables are a set of dynamic named values that can affect the way running processes will behave on a computer.

They are part of the operating environment in which a process runs. For example, a running process can query the value of the TEMP environment variable to discover a suitable location to store temporary files, or the HOME or USERPROFILE variable to find the directory structure owned by the user running the process.

They were introduced in their modern form in 1979 with Version 7 Unix, so are included in all Unix operating system flavors and variants from that point onward including Linux and OS X. From PC DOS 2.0 in 1982, all succeeding Microsoft operating systems including Microsoft Windows, and OS/2 also have included them as a feature, although with somewhat different syntax, usage and standard variable names.
[http://en.wikipedia.org/wiki/Environment_variable]

os'PATH-variable

name::
* McsEngl.os'PATH-variable@cptItsoft,

osLinux'PATH:
For example, to add the directory /usr/sbin, the following would be used:
PATH="/usr/sbin:$PATH"
or its single-line equivalent
export PATH=$PATH:/usr/sbin
[http://www.linfo.org/path_env_var.html]

osWin'PATH:
PATH: %SystemRoot%\system32;%SystemRoot%;
%SystemRoot%\System32\Wbem;
\PROGRA~1\COMMON~1\FOLIOS~1;
\PROGRA~1\ULTRAE~1;
\Program Files\jEdit;\Program Files\Java\jdk1.6.0_10\bin;
\Program Files\QuickTime\QTSystem\;
\Program Files\Panda Security\Panda Antivirus Pro 2009\
===
winXp: start/control-panel/system/προχωρημένοι/μεταβλητες-περιβάλλοντος.

os'evaluation#cptCore546.107#

name::
* McsEngl.os'evaluation@cptItsoft,

os'exposition#cptIt148#

name::
* McsEngl.os'exposition@cptItsoft,

os'doing#cptCore475#

name::
* McsEngl.os'doing@cptItsoft,
* McsEngl.os'service@cptItsoft,

GENERAL FUNCTION. OPERATING SYSTEM#cptIt444-8#

_SPECIFIC:
* Provide system services: Transfer info to and from disk, displaying characters on screen, print data
* Provide a user interface: which programs to run
* Coordinate the sequence of events: multiuser
* Control resourses:
* Enforce security:
* Provide tools:
* virtual memory
* efficient system administration.
* vendor service and support
* easy application development
* ability to work in a distributed environment

os'func.FUNCTION'CLASS

name::
* McsEngl.os'func.FUNCTION'CLASS@cptItsoft,

os'func.DIRECTORY'MANAGEMENT

name::
* McsEngl.os'func.DIRECTORY'MANAGEMENT@cptItsoft,

change dir

create dir

delete dir

display current dir/show path

list dir

rename dir

standard dir

types of dir

os'func.FILE'MANAGEMENT

name::
* McsEngl.os'func.FILE'MANAGEMENT@cptItsoft,

backups

classify files

compress files

copy files

delete file

edit file

display the contents of a file, sort file contents

link files

list files

move files

print files

rename file

search for file

sort files

undelete file

view file

os'func.HARDWARE'MANAGEMENT

name::
* McsEngl.os'func.HARDWARE'MANAGEMENT@cptItsoft,

os'func.HELP

name::
* McsEngl.os'func.HELP@cptItsoft,

os'func.MEMORY'MANAGEMENT

name::
* McsEngl.os'func.MEMORY'MANAGEMENT@cptItsoft,

os'func.PRINTING

name::
* McsEngl.os'func.PRINTING@cptItsoft,

os'func.PROCESS'MANAGEMENT

name::
* McsEngl.os'func.PROCESS'MANAGEMENT@cptItsoft,

MULTIPROCESSING

MULTITASKING

background execution

non hang up a bg when logoff

stop a bg process

combine commands

grouping

in turn execution

list of processes

only if first was executed

only if preceding fails

priority

substitution of a command

os'func.SECURITY

name::
* McsEngl.os'func.SECURITY@cptItsoft,

system level

password file

concurrent sessions

intruders

time restriction

user level

group level

change group

directory level

file level

change ownener

change permissions

list of rights

prevent writing on a file

os'func.USER-MANAGEMENT

name::
* McsEngl.os'func.USER-MANAGEMENT@cptItsoft,

add user

delete user

group users

list of users on

user types

os'func.MANAGER'USER'CLASS

name::
* McsEngl.os'func.MANAGER'USER'CLASS@cptItsoft,

os'func.MANAGER'FUNCTION

name::
* McsEngl.os'func.MANAGER'FUNCTION@cptItsoft,

DIRECTORY MANAGEMENT

DIRECTORY I call ANY storage place.

change dir

create dir

delete dir

display current dir

list dir.

rename dir

standard dir.

show path

types of dir

FILE MANAGEMENT manager-functions

backups

group file

HELP

HARDWARE MANAGEMENT

boot the computer

autoexec file:
system login script:
user login script:
program batch file:

close the computer

configure terminals

list of servers

MEMORY MANAGEMENT

USER MANAGEMENT

add user

delete user

group users

list of users on

user types

SECURITY manager-functions

system level

password file

concurrent sessions

intruders

time restriction

user level

group level

change group

directory level

file level

change ownener

change permissions

list of rights

prevent writing on a file

os'func.USER'FUNCTION

name::
* McsEngl.os'func.USER'FUNCTION@cptItsoft,

DIRECTORY MANAGEMENT user-functions

DIRECTORY I call ANY storage place.

change dir

create dir

delete dir

display current dir

list dir.

rename dir

standard dir.

types of dir

FILE MANAGEMENT user-functions

Attributes of a file.

classify files

compress files

copy files

delete file

edit file

display the contents of a file, sort file contents:

link files

list files

move files

print files

rename file

search for file

sort files

undelete file

view file

FILE-SERVER user functions

connection to a file server

list file servers

HELP user function

INFORMATION

list of users

user info

NETWORKING user functions

copy files

game

list of computer to communicate

list the arrived files

mail functions

receive mail

send mail

send message

network connection

remote execution

PROCESS user functions

background execution

non hang up a bg when logoff

stop a bg process

combine commands

grouping

in turn execution

list of processes

only if first was executed

only if preceding fails

priority

substitution of a command

SECURITY user functions

change password

know your rights

system level

file level

VARIABLES

creation

os'func.MISC'CLASS

name::
* McsEngl.os'func.MISC'CLASS@cptItsoft,

os'func.MULTITASKING (πολλές εργασίες)

name::
* McsEngl.os'func.MULTITASKING (πολλές εργασίες)@cptItsoft,

os'func.MULTITHREADING

name::
* McsEngl.os'func.MULTITHREADING@cptItsoft,
* McsEngl.os'MULTITHREADING@cptItsoft,
* McsElln.ΠΟΛΥΝΗΜΑΤΙΚΗ-ΕΠΕΞΕΡΓΑΣΙΑ@cptItsoft,

ΚΑΤΑ ΤΗ ΔΙΑΡΚΕΙΑ ΤΗΣ ΕΚΤΕΛΕΣΗΣ ενος ΠΡΟΓΡΑΜΜΑΤΟΣ, ΜΠΟΡΕΙ ΝΑ ΚΑΝΕΙ ΠΟΛΛΕΣ ΛΕΙΤΟΥΡΓΙΕΣ. ΠΧ SORT AND RECALCULATION IN A SPREADSHEET.

THRENDS: Also common to most new UNIX-like operating systems is a sophisticated multitasking concept called THREADS, with which a process can perform multiple operations simultaneously, sharing information among them. You need this feature to play simultaneously graphics, video, audio.

os'func.PREEMPTIVE'MULTITASKING

name::
* McsEngl.os'func.PREEMPTIVE'MULTITASKING@cptItsoft,
* McsEngl.os'PREEMPTIVE'MULTITASKING@cptItsoft,
* McsElln.ΠΟΛΥΠΡΟΓΡΑΜΜΑΤΙΣΜΟΣ@cptItsoft,

ΕΚΤΕΛΕΙ πολλα ΠΡΟΓΡΑΜΜΑΤΑ ΤΗΝ ΙΔΙΑ ΣΤΙΓΜΗ.
PRE-EMPTING: ΕΙΝΑΙ ΜΕΘΟΔΟΣ ΚΑΤΑΜΕΡΙΣΜΟΥ ΤΟΥ ΧΡΟΝΟΥ ΤΟΥ ΕΠΕΞΕΡΓΑΣΤΗ, ΟΠΟΥ ΚΑΘΕ ΕΡΓΑΣΙΑ ΕΧΕΙ ΣΤΑΝΤΑΡ ΠΕΡΙΘΩΡΙΟ ΧΡΟΝΟΥ.
ΑΛΛΗ ΜΕΘΟΔΟΣ ΕΙΝΑΙ ΠΧ ΝΑ ΓΙΝΕΤΑΙ Η ΕΠΟΜΕΝΗ ΕΡΓΑΣΙΑ ΑΦΟΥ ΤΕΛΕΙΩΣΕΙ Η ΠΡΩΤΗ..

PREEMTIVE ΣΗΜΑΙΝΕΙ ΟΤΙ ΤΟ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ ΕΧΕΙ ΤΟΝ ΕΛΕΓΧΟ ΤΟΥ ΥΠΟΛΟΓΙΣΤΗ ΚΑΘΕ ΣΤΙΓΜΗ, ΚΑΙ ΚΑΜΙΑ ΕΦΑΡΜΟΓΗ ΔΕΝ ΜΠΟΡΕΙ ΝΑ ΜΟΝΟΠΩΛΗΣΕΙ ΤΟΝ ΕΠΕΞΕΡΓΑΣΤΗ ΚΑΙ ΤΟΥΣ ΠΟΡΟΥΣ ΤΟΥ ΣΥΣΤΗΜΑΤΟΣ.

os'func.NETWORKING FUNCTION

name::
* McsEngl.os'func.NETWORKING FUNCTION@cptItsoft,

ΤΟ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ ΤΟΥ ΑΥΡΙΟ ΔΕΝ ΑΠΕΥΘΥΝΕΤΑΙ ΣΕ stand alone ΥΠΟΛΟΓΙΣΤΕΣ ΑΛΛΑ ΚΥΡΙΩΣ ΣΕ ΥΠΟΛΟΓΙΣΤΕΣ ΠΟΥ ΜΕ ΤΟΝ ΕΝΑ ή ΑΛΛΟ ΤΡΟΠΟ ΘΑ ΕΙΝΑΙ ΔΙΚΤΥΩΜΕΝΟΙ, ΑΡΑ ΟΙ ΔΥΝΑΤΟΤΗΤΕΣ ΕΠΙΚΟΙΝΩΝΙΑΣ-ΔΙΚΤΥΩΣΗΣ ΠΡΕΠΕΙ ΑΠΑΡΑΙΤΗΤΩΣ ΝΑ ΕΙΝΑΙ ΕΝΣΩΜΑΤΩΜΕΝΕΣ ΣΕ ΕΝΑ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ ΠΟΥ ΕΠΙΔΙΩΚΕΙ ΤΟΝ ΕΠΙΖΗΛΟ ΤΙΤΛΟ ΤΟΥ ΠΡΟΤΥΠΟΥ. ΑΥΤΟ ΤΟ ΓΕΓΟΝΟΣ ΑΠΟ ΜΟΝΟ ΤΟΥ, ΑΡΚΕΙ ΓΙΑ ΝΑ ΤΕΡΜΑΤΙΣΕΙ ΕΝ ΜΙΑ ΝΥΚΤΙ ΤΗΝ ΖΩΗ ΕΝΟΣ ΟΛΟΚΛΗΡΟΥ ΤΜΗΜΑΤΟΣ ΤΗΣ ΑΓΟΡΑΣ SYSTEM SOFTWARE ΠΟΥ ΑΚΟΟΥΕΙ ΣΤΟ ΟΝΟΜΑ NOS {NETWORK OPERATING SYSTEM} ΚΑΙ ΠΟΥ ΜΕΧΡΙ ΤΩΡΑ ΕΙΧΕ ΣΑ ΣΗΜΑΙΟΦΟΡΟ ΤΗΣ ΤΟ NETWARE.

os'func.PLUNG'PLAY

name::
* McsEngl.os'func.PLUNG'PLAY@cptItsoft,
* McsEngl.P&P= PLUNG AND PLAY@cptItsoft,

Είναι η τεχνολογία αναγνώρισης αυτόματα των συσκευών που αποτελείται ένα κομπιουτερ.

os'doing.INSTALLING#cptIt162#

name::
* McsEngl.os'doing.INSTALLING@cptItsoft,

IN A NEW UNPARTITIONED DISK:
* set the bios to boot from cd.
* put the cd and follow instructions.

os'doing.TIP#cptIt470#

name::
* McsEngl.os'doing.TIP@cptItsoft,

os'file-system

name::
* McsEngl.os'file-system@cptItsoft,
* McsEngl.conceptIt433,
* McsEngl.filesystem@cptIt433, {2013-08-26}
* McsEngl.file-system@cptIt433,
* McsEngl.OS-file-system@cptItsoft,
* McsEngl.os'filesystem@cptIt433,
* McsEngl.fls@cptIt433, {2013-08-26}
* McsEngl.osfs@cptIt433,
====== lagoGreek:
* McsElln.ΣΥΣΤΗΜΑ-ΑΡΧΕΙΩΝ@cptItsoft,

DEFINITION

In computing, a file system (or filesystem) is a type of data store which can be used to store, retrieve and update a set of files. The term refers to either the abstract data structures used to define files, or the actual software or firmware components that implement the abstract ideas.
Some file systems are used on local data storage devices; others provide file access via a network protocol (e.g. NFS, SMB, or 9P clients). Some file systems are "virtual", in that the "files" supplied are computed on request (e.g. procfs) or are merely a mapping into a different file system used as a backing store. The file system manages access to both the content of files and the metadata about those files. It is responsible for arranging storage space; reliability, efficiency, and tuning with regard to the physical storage medium are important design considerations.
[http://en.wikipedia.org/wiki/File_system] {2013-08-26}

File system as an abstract user interface[edit source | editbeta]
In some cases, a file system may not make use of a storage device but can be used to organize and represent access to any data, whether it is stored or dynamically generated (e.g. procfs).
[http://en.wikipedia.org/wiki/File_system] {2013-08-26}

One of the most important functions an operating system performs is imposing organization on the data stored on the disk.
Almost all operating systems use a scheme that involves some king of "table of contents," which is recorded in a SPECIFIC AREA of the disk. The operating system uses this table of contents to keep track of what parts of the disk are used and what information is stored where.

The disk hardware and software divide the disk recording area into CYLINDERS that, in turn, are divided into tracks.

Today a single large disk can contain a dozen or more PARTISIONS, each of which is a file system.

fls'WHOLE

_WHOLE:
* PARTITION-OF-STORAGE-DEVICE

fls'API

name::
* McsEngl.fls'API@cptItsoft,

Utilities, language specific run-time libraries and user programs use file system APIs to make requests of the file system. These include data transfer, positioning, updating metadata, managing directories, managing access specifications, and removal.
[http://en.wikipedia.org/wiki/File_system]

fls'cylinder

name::
* McsEngl.fls'cylinder@cptItsoft,

CYLINDER: the TRUCKS that lie over each other and can be written without movement of the head assembly.

fls'Directory

name::
* McsEngl.fls'Directory@cptItsoft,
* McsEngl.osdir@cptItsoft,
* McsEngl.os'Directory@cptItsoft,

* McsEngl.directory@cptItsoft,
* McsEngl.folder@cptItsoft,
* McsEngl.dr@cptItsoft, {2015-11-22} [dr < fl]
* McsEngl.dr@cptItsoft,
* McsEngl.dir@cptItsoft,

_DEFINITION:
* Unix provides a simple yet powerful scheme for organizing files by using a SPECIAL TYPE OF FILE called a directory. A DIRECTORY is a table of contents, in a special format controlled by unix, that contains a list of files and important information you use to access the files...
Directories can contain entries not only for regular files, but for other directories as well. Such a directory, is sometimes called a subdirectory (although directory and subdirectory are almost always synonymous terms).
[Introduction to unix. Que 1992, 65]

dir'Quantity-of-files-of-dir

name::
* McsEngl.dir'Quantity-of-files-of-dir@cptItsoft,

dir'Structure

name::
* McsEngl.dir'Structure@cptItsoft,

dir.HOME

name::
* McsEngl.dir.HOME@cptItsoft,

_DESCRIPTION:
Where is my home directory located?
Where a user's home directory is located varies from platform to platform and among the users on a single computer. But the actual location of the home directory is available through special environment variables:
Unix/Linux
$HOME
Windows
%USERPROFILE%
Cygwin
$USERPROFILE

In order to find out where these environment variables actually point to, do the following:
on Unix/Linux, open a terminal and type the following command
echo $HOME
on Windows, open a command-prompt and type the following command
echo %USERPROFILE%
on Cygwin, open a bash and type the following command
echo $USERPROFILE
[https://weka.wikispaces.com/Where+is+my+home+directory+located%3F]

fls'disk-partition

name::
* McsEngl.fls'disk-partition@cptItsoft,
* McsEngl.os'partition@cptItsoft,
* McsEngl.partition.harddisk@cptItsoft,

_DESCRIPTION:
No matter which operating system you want to have installed on your machine, there's one thing they all have in common: partitions. These are logical pieces of your actual hard disk space, defining the size and the file system format for the operating systems and data that are going to be placed on them.
[http://www.dedoimedo.com/computers/gparted.html]
===
Today a single large disk can contain a dozen or more partisions, each of which is a FILE SYSTEM.

To simplify, a hard disk is merely a sequence of sectors. A sector is the smallest data unit on a hard disk, and its size is 512 bytes. The sectors on a hard disk of n sectors are numbered from 0 to n-1 .
The first sector (including the sector number 0) contains, amongst others, the table of partitions. As its name suggests, this table contains data on the various partitions on the disk. It can contain a maximum of 4 entries, dividing the disk into four partitions called primary partitions. Each entry on the partition table contains various data, and in particular the number of the sector where the partition begins, the number of the sector where it ends and, finally, its type. An entry may contain nothing.
Normally the partition type specifies the filesystem which the partition is supposed to contain. Each operating system recognizes some of them, but not others. Windows, for example, assumes that each partition whose type proves the presence of a FAT in fact contains a FAT[1]. For Windows, this sort of partition becomes a drive. But there is also a very special type which ensures that a primary partition becomes a partition called extended.
[Mandrake linux 7.0]

32MB BARRIER:
With versions of DOS prior to 4.0 there is a built-in limit on the size of a disk partition. It's just a matter of arithmetic. Using the original design parameters of DOS, we can show how the maximum size disk partition is defined.
The facts: One word, 16 bits, is defined for DOS to access sectors
within its hard disk partition. A single 16-bit binary
word can represent values from zero through 65,535.
This limits the partition's total sector count to 65,536.
Hard disk sectors are 512 bytes long.
Now the arithmetic: 512 bytes times 65,536 sectors = 33,554,432
And since there are 1,048,576 bytes in each megabyte, the maximum size partition calculates to exactly 32 megabytes.
[SOURCE: PC-GLOSSARY 1993]

partition'name

name::
* McsEngl.partition'name@cptItsoft,

_DESCRIPTION:
Windows uses drive letters

In Windows, users are accustomed to referring to their partitions as drives, like C:, D: etc. This is somewhat misleading, because these letters in fact refer to partitions rather than actual drives. If you have a single drive (only C:), then the term partition and drive are synonymous in this case, because a single partition spans the entire size of the hard disk.

However, if you have more than a single drive letter in your My Computer, this means you have several partitions (and maybe even several physical hard disk drives). It is important to remember this.

Linux notation is different

I have explaining the Linux disk notation in many other articles, but for the completeness' sake, I will do it one more time.

Hard drives in Linux are marked by three letters:

IDE drives are marked hdX, where X is one of the four letters a-d. hda is the primary master, hdb is the primary slave, hdc is the secondary master, and hdd is the secondary slave.
SCSI / SATA drives are marked by sdX, where X is any which letter.
Partitions are marked by a number after any three letter combination:

For example, sdb1 is the first partition on the second SCSI / SATA drive. s - SCSI/SATA, d - drive, b - second drive, 1 - first partition. hdc3 is the third partition on on the IDE secondary master.
[http://www.dedoimedo.com/computers/gparted.html#mozTocId576517]

===
Under Linux
Linux uses a far more logical method for naming partitions. Firstly, it does not take into account the type of partitions that you may have, and secondly it names the partitions according to the disk on which they are located. First of all, this is how the disks are named:
- the primary master and primary slave IDE devices (hard disks, CDROM drives or others) are called /dev/hda and /dev/hdb respectively;
- on the secondary interface, they are called /dev/hdc and /dev/hdd for the master and slave respectively;
- if your computer contains other IDE interfaces (for example, the IDE interface present in some SoundBlaster cards), the disks will then be called /dev/hde, /dev/hdf, etc.
- SCSI disks are called /dev/sda, /dev/sdb, etc., in the order of their appearance on the SCSI chain (depending on the increasing IDs). The SCSI CDROM are called /dev/scd0, /dev/scd1, always in the order of their appearance on the SCSI chain.
The partitions are named after the disk on which they are found, in the following way (in the example, we have used the case of partitions on a primary master IDE disk):
the primary (or extended) partitions are called /dev/hda1 to /dev/hda4 where present; the logical partitions, should there be any, bear the names /dev/hda5, /dev/hda6, etc. in their order of appearance in the table of logical partitions.
[Mandrake linux 7.0]
===
Under Windows
As we have already said, Windows allocates letters to the drives depending on the partitions that it finds of a type that it recognizes. Windows never names a disk, only partitions.
So there is never a disk C:, but a drive C:. This C: "drive" is subject to certain restrictions: it has to be a primary partition of a type which is recognized by Windows, and on the first disk seen by BIOS. And finally, this partition must be enabled... This, as a general rule, is the first IDE disk on a PC equipped only with IDE disks or the first SCSI disk on a PC on which SCSI alone has been installed.
The allocation rules for the remaining "drives" are somewhat quaint:
Initially, Windows will look for the primary partitions on the hard disks and their letter allocations, in their order of appearance. Then it scans all the disks and looks for the extended partitions and associated logical partitions and then allocates the letters, always in their order of appearance and if, of course, the logical partitions are of a type it recognizes. Whatever happens, all the "drives" which are not hard disks (CDROM, ZIP and other drives) are only given letters after the "drives" on hard disk, except of course for the floppy drives associated, respectively, to letters A: and B:. This explains why the letter designating your CDROM, for example, is shifted when you add a disk containing at least one Windows partition.
[Mandrake linux 7.0]

partition'GParted

name::
* McsEngl.partition'GParted@cptItsoft,
* McsEngl.GParted@cptItsoft,

_DESCRIPTION:
GParted is one of the most popular partitioning software. It comes included with most modern Linux distributions. It also ships in a large number of dedicated rescue & recovery distributions. To name a few distributions that come with GParted: Ubuntu, Linux Mint, PCLinuxOS, Wolvix, and others.
[http://www.dedoimedo.com/computers/gparted.html#mozTocId442518]

partition'program

name::
* McsEngl.partition'program@cptItsoft,

_SPECIFIC:
* Partition Magic (win)

_EXECUTING:
GParted can be used in two ways: while booted in an operating system or from a live CD. The recommended way of using GParted is from the live environment. Why, you ask? This is because partitioning operations need to be done on hard disks when they are not in use, to avoid data corruption. Partitions that are in use cannot be modified. They are locked by the operating system that uses them.

In technical terms, partitioning can be done only when the hard disk partitions are unmounted. If disks are empty and contain no operating system whatsoever, it does not matter anyway, because the only way you can access the system is from a live environment.

As a rule of thumb, it is always the best idea to handle partitioning from live CD environment. Not surprisingly, almost every single modern Linux distro ships as a bootable live CD. Not only does this allow you to get a first impression of the operating system and check hardware compatibility before deciding whether to commit the distro to hard disk, it also allows you to perform maintenance operations from the live environment.

Nevertheless, you can still use partitioning software against NON-system partition, that is partitions that the operating system is not installed on, and which, on demand can be unmounted. This is true for Windows and Linux alike. And just about any operating system in the world.
[http://www.dedoimedo.com/computers/gparted.html#mozTocId661277]

partition.EXTENDED

name::
* McsEngl.partition.EXTENDED@cptItsoft,

_DESCRIPTION:
One of the primary partitions can be created as the Extended partition. This partition acts as a container for logical partitions.
[http://www.dedoimedo.com/computers/gparted.html#mozTocId958178]
===
There can only be one extended partition per disk. This type of partition exists for various reasons: mainly because it can partition a large hard disk into more than 4 partitions. Then, because of the limitations of the DOS/Windows fdisk, which is unable to create more than one primary partition per disk[2].
Apart from its type, which distinguishes it, an extended partition has the same features as a primary partition, that is a start and end sector number. The space thus allocated to the extended partition is then subdivided into logical partitions using another table with a different format from the table of primary partitions, since the number of logical partitions is only restricted by the space on the disk. It should also be said that there can only be a single extended partition per disk.
The first entry of a logical partition table can be found on the first sector of the extended partition. The start and end sector of the logical partition of each entry appears in the same way, as does its type and the sector number where the following table entry can be found.
[Mandrake linux 7.0]

partition.LOGICAL

name::
* McsEngl.partition.LOGICAL@cptItsoft,

_DESCRIPTION:
Logical partitions have been created to overcome the inherent numerical limitation of primary partitions. One of the primary partitions can be created as the Extended partition. This partition acts as a container for logical partitions. The total number of logical partitions you can create (and use) depends on the disk type and the operating system you're using. For all practical purposes, the number is beyond the needs of any user.

As you can see, we have up to four primary partitions and a de-facto unlimited number of logical ones. Notation-wise, the primary partitions will always be the first four, logical partitions will start with number 5.

Therefore, when someone says sda5, it necessarily means we're talking about a logical partition. Similarly, any partition with a number equal or higher than 5 will always be a logical partition.
[http://www.dedoimedo.com/computers/gparted.html#mozTocId958178]

partition.PRIMARY

name::
* McsEngl.partition.PRIMARY@cptItsoft,

_DESCRIPTION:
Primary partitions are just that, a total of four of which can exist on any one hard disk. To reiterate, there can be only up to four primary partitions on a hard disk. If you have three hard disks on your machine, each one can still hold up to four primary partitions.
[http://www.dedoimedo.com/computers/gparted.html#mozTocId958178]

fls'file

name::
* McsEngl.fls'file@cptItsoft,
* McsEngl.conceptIt354,
* McsEngl.osfil@cptItsoft,
* McsEngl.os'file@cptItsoft,
* McsEngl.computer-file@cptIt354,
* McsEngl.file@cptIt354,
* McsEngl.software.file@cptIt354,

* McsEngl.fl@cptItsoft, {2015-11-22}
* McsEngl.fl@cptItsoft,
====== lagoGreek:
* McsElln.ΑΡΧΕΙΟ@cptItsoft,

DEFINITION

File is SOFTWARE with a name, stored in the computer's storage.
[nikkas 1999oct29]

ΑΡΧΕΙΟ είναι οργανωμένες πληροφορίες που φυλάσσονται σε αποθήκες.

~~FILE is a collection of data stored on disk.~~

file'GENERIC

_GENERIC:
* SOFTWARE#cptItsoft64#

file'WHOLE

_WHOLE:
FILE-SYSTEM#cptIt433#

file'Archive-attribute

name::
* McsEngl.file'Archive-attribute@cptItsoft,

In the DOS environment, every disk file can have four attributes or characteristics associated with it. The one called the archive attribute is actually a bit which is set to one or zero depending on the status of the file.
When the file is backed-up or archived the archive bit is set to one and when the file is changed the archive bit is reset to zero.
The DOS ATTRIB command can be used to view and/or change the status of a file's archive bit.
[SOURCE: PC-GLOSSARY 1993]

file'Format#cptIt164: attPar#

name::
* McsEngl.file'Format@cptItsoft,

file'doing

name::
* McsEngl.file'doing@cptItsoft,

file'deleting

name::
* McsEngl.file'deleting@cptItsoft,

_ADDRESS.WPG:
* https://www.raymond.cc/blog/permanently-delete-and-remove-sensitive-files-to-prevent-data-recovery//

file'name

name::
* McsEngl.file'name@cptItsoft,
* McsEngl.filename@cptItsoft,
* McsEngl.file-name@cptItsoft,

_DESCRIPTION:
A filename (or file name) is used to identify a storage location in the file system. Most file systems have restrictions on the length of filenames. In some file systems, filenames are case-insensitive (i.e., filenames such as FOO and foo refer to the same file); in others, filenames are case-sensitive (i.e., the names FOO and foo refer to two separate files).

Most modern file systems allow filenames to contain a wide range of characters from the Unicode character set. Most file system interface utilities, however, have restrictions on the use of certain special characters, disallowing them within filenames (the file system may use these special characters to indicate a device, device type, directory prefix, or file type). However, these special characters might be allowed by, for example, enclosing the filename with double quotes ("). For simplicity, special characters are generally discouraged within filenames.
[http://en.wikipedia.org/wiki/File_system]

file'program#ql:program.filemanagement@cptIt958#

name::
* McsEngl.file'program@cptItsoft,

SPECIFIC

* file.specific,

Specific_concepts (level 3) =
system program
application program
user data file

_SPECIFIC: file.SPECIFIC_DIVISION.Data:
* data-file
* instruction-file
* mixed-file

file.SPECIFIC-DIVISION.TEXT

name::
* McsEngl.file.SPECIFIC-DIVISION.TEXT@cptItsoft,

_SPECIFIC:
* BINARY_FILE
* TEXT_FILE

file.BINARY

_CREATED: {2007-12-22}

name::
* McsEngl.file.BINARY@cptItsoft,
* McsEngl.binary-based-file@cptIt354i,
* McsEngl.non-human-readable-file@cptIt354i,

_DEFINITION:
Binary files are usually thought of as being a sequence of bytes, which means the binary digits (bits) are grouped in eights. Binary files typically contain bytes that are intended to be interpreted as something other than text characters. Compiled computer programs are typical examples; indeed, compiled applications (object files) are sometimes referred to, particularly by programmers, as binaries. But binary files can also contain images, sounds, compressed versions of other files, etc. — in short, any type of file content whatsoever.
Some binary files contain headers, blocks of metadata used by a computer program to interpret the data in the file. For example, a GIF file can contain multiple images, and headers are used to identify and describe each block of image data. If a binary file does not contain any headers, it may be called a flat binary file.
[http://en.wikipedia.org/wiki/Binary_file]

Viewing binary files
A hex editor or viewer (such as hex dump) may be used to view file data as a sequence of hexadecimal (or decimal, binary or ASCII character) values for corresponding bytes of a binary file.
[http://en.wikipedia.org/wiki/Binary_file]

file.Compressed

name::
* McsEngl.file.Compressed@cptItsoft,
* McsEngl.compressed-file@cptIt354i,
* McsEngl.file.archive@cptItsoft,

To the true definition, an archive file is one that has been copied onto an auxiliary storage medium such as disk or magnetic tape for the purpose of long-term retention.
In the microcomputer world, an archive file is one that has been compressed, squashed, squeezed, crunched, and/or packed with a file archiving program in order to use less disk space and to reduce the transfer time when sending files between computers.
Data Libraries store program and data files in compressed format and rename the files using the ".ARC" or ".ZIP" filename extension.
[SOURCE: PC-GLOSSARY 1993]

file.Data

name::
* McsEngl.file.Data@cptItsoft,
* McsEngl.data-file@cptIt354i,

_DEFINITION:
A data file is a computer file which stores data for use by a computer application or system. It generally does not refer to files that contain instructions or code to be executed (typically called program files), or to files which define the operation or structure of an application or system (which include configuration files, directory files, etc.); but specifically to information used as input, and/or written as output by some other software program.
Data files come in two broad categories: open and closed.
[http://en.wikipedia.org/wiki/Data_file]

file.Instruction

name::
* McsEngl.file.Instruction@cptItsoft,
* McsEngl.conceptIt354,

file.Executable

name::
* McsEngl.file.Executable@cptItsoft,
* McsEngl.executable-file@cptIt354i,

An executable or executable file, in computer science, is a file whose contents are meant to be interpreted as a program by a computer.
[http://en.wikipedia.org/wiki/Executable]

file.Script

name::
* McsEngl.file.Script@cptItsoft,

_DESCRIPTION:
It is a human-readable instruction-file.
[hmnSngo.2011-08-31,]

file.Text-based

_CREATED: {2007-12-22}

name::
* McsEngl.file.Text-based@cptItsoft,
* McsEngl.character-file@cptIt354i,
* McsEngl.human-readable-file@cptIt354i,
* McsEngl.plain-text-file@cptIt354i,
* McsEngl.text-based-file@cptIt354i,

_DEFINITION:
A text file is a generic description of a kind of computer file in a computer file system.[1] At this generic level of description, there are two kinds of computer files: 1) text files; and 2) binary files.[2] This broad two-level distinction is widely recognized and applied in computing, even though it can be misleading, and subject to differing interpretation.[3][4]
The most common basis for distinguishing text files from binary files depends on the how the underlying stored information is ultimately interpreted and processed by the operating system and associated programs.[5] Text files are usually interpreted as consisting solely of characters from a recognized character set. Well-known character sets include the ASCII character set and the Unicode character set.[6]
....
Since plain text is not a formally defined standard, the definition of the format of a plain text file is rather loose. The principle differences are in character sets and character encodings, and conventions about formatting characters semantics.
[http://en.wikipedia.org/wiki/Text_file]

file.SDF

name::
* McsEngl.file.SDF@cptItsoft,

An SDF type file is simply a fixed-length ASCII text file commonly used to transfer data from one computer application to another.
For example, in the dBase programming environment data files can be input and output using this format. Each record in the file or database is of the same length, regardless of the amount of data in the fields that make-up each record.
The following generic dBase command will create an SDF type file:
COPY FILE DATA.DBF TO DATA.TXT TYPE SDF
[SOURCE: PC-GLOSSARY 1993]

fls'file-path

name::
* McsEngl.fls'file-path@cptItsoft,
* McsEngl.filepath@cptItsoft,

_DESCRIPTION:
Long file paths and long file names[edit source | editbeta]
In hierarchical file systems, files are accessed by means of a path that is a branching list of directories containing the file. Different file systems have different limits on the depth of the path. File systems also have a limit on the length of an individual filename.
Copying files with long names or located in paths of significant depth from one file system to another may cause undesirable results. This depends on how the utility doing the copying handles the discrepancy.
[http://en.wikipedia.org/wiki/File_system#Long_file_paths_and_long_file_names]

fls'integrity

name::
* McsEngl.fls'integrity@cptItsoft,

Maintaining integrity[edit source | editbeta]
One significant responsibility of a file system is to ensure that, regardless of the actions by programs accessing the data, the structure remains consistent. This includes actions taken if a program modifying data terminates abnormally or neglects to inform the file system that it has completed its activities. This may include updating the metadata, the directory entry and handling any data that was buffered but not yet updated on the physical storage media.

Other failures which the file system must deal with include media failures or loss of connection to remote systems.

In the event of an operating system failure or "soft" power failure, special routines in the file system must be invoked similar to when an individual program fails.

The file system must also be able to correct damaged structures. These may occur as a result of an operating system failure for which the OS was unable to notify the file system, power failure or reset.

The file system must also record events to allow analysis of systemic issues as well as problems with specific files or directories.
[http://en.wikipedia.org/wiki/File_system]

fls'limitation

name::
* McsEngl.fls'limitation@cptItsoft,

Design limitations[edit source | editbeta]
All file systems have some functional limit that defines the maximum storable data capacity within that system. These functional limits are a best-guess effort by the designer based on how large the storage systems are right now and how large storage systems are likely to become in the future. Disk storage has continued to increase at near exponential rates (see Moore's law), so after a few years, file systems have kept reaching design limitations that require computer users to repeatedly move to a newer system with ever-greater capacity.

File system complexity typically varies proportionally with the available storage capacity. The file systems of early 1980s home computers with 50 KB to 512 KB of storage would not be a reasonable choice for modern storage systems with hundreds of gigabytes of capacity. Likewise, modern file systems would not be a reasonable choice for these early systems, since the complexity of modern file system structures would consume most or all of the very limited capacity of the early storage systems.
[http://en.wikipedia.org/wiki/File_system]

fls'metadata

name::
* McsEngl.fls'metadata@cptItsoft,

_DESCRIPTION:
Other bookkeeping information is typically associated with each file within a file system. The length of the data contained in a file may be stored as the number of blocks allocated for the file or as a byte count. The time that the file was last modified may be stored as the file's timestamp. File systems might store the file creation time, the time it was last accessed, the time the file's metadata was changed, or the time the file was last backed up. Other information can include the file's device type (e.g. block, character, socket, subdirectory, etc.), its owner user ID and group ID, its access permissions and other file attributes (e.g. whether the file is read-only, executable, etc.).

A file system stores all the metadata associated with the file—including the file name, the length of the contents of a file, and the location of the file in the folder hierarchy—separate from the contents of the file.

Most file systems store the names of all the files in one directory in one place—the directory table for that directory—which is often stored like any other file. Many file systems put only some of the metadata for a file in the directory table, and the rest of the metadata for that file in a completely separate structure, such as the inode.

Most file systems also store metadata not associated with any one particular file. Such metadata includes information about unused regions -- free space bitmap, block availability map—and information about bad sectors. Often such information about a allocation group is stored inside the allocation group itself.

Additional attributes can be associated on file systems, such as NTFS, XFS, ext2, ext3, some versions of UFS, and HFS+, using extended file attributes. Some file systems provide for user defined attributes such as the author of the document, the character encoding of a document or the size of an image.

Some file systems allow for different data collections to be associated with one file name. These separate collections may be referred to as streams or forks. Apple has long used a forked file system on the Macintosh, and Microsoft supports streams in NTFS. Some file systems maintain multiple past revisions of a file under a single file name; the filename by itself retrieves the most recent version, while prior saved version can be accessed using a special naming convention such as "filename;4" or "filename(-4)" to access the version four saves ago.

See comparison of file systems#Metadata for details on which file systems support which kinds of metadata.
[http://en.wikipedia.org/wiki/File_system]

fls'relation-to-os

name::
* McsEngl.fls'relation-to-os@cptItsoft,
* McsEngl.os'relation-to-filesystem@cptItsoft,

_DESCRIPTION:
Many operating systems include support for more than one file system. Sometimes the OS and the file system are so tightly interwoven it is difficult to separate out file system functions.
There needs to be an interface provided by the operating system software between the user and the file system. This interface can be textual (such as provided by a command line interface, such as the Unix shell, or OpenVMS DCL) or graphical (such as provided by a graphical user interface, such as file browsers). If graphical, the metaphor of the folder, containing documents, other files, and nested folders is often used (see also: directory and folder).
[http://en.wikipedia.org/wiki/File_system#File_systems_and_operating_systems]

fls'sector

name::
* McsEngl.fls'sector@cptItsoft,

SECTOR: The smallest chunk of data that the disk controller is physically able to READ-WRITE.

fls'security

name::
* McsEngl.fls'security@cptItsoft,

Restricting and permitting access[edit source | editbeta]
See also: Computer security, Password cracking, Filesystem-level encryption, and Encrypting File System
There are several mechanisms used by file systems to control access to data. Usually the intent is to prevent reading or modifying files by a user or group of users. Another reason is to ensure data is modified in a controlled way so access may be restricted to a specific program. Examples include passwords stored in the metadata of the file or elsewhere and file permissions in the form of permission bits, access control lists, or capabilities. The need for file system utilities to be able to access the data at the media level to reorganize the structures and provide efficient backup usually means that these are only effective for polite users but are not effective against intruders.

Methods for encrypting file data are sometimes included in the file system. This is very effective since there is no need for file system utilities to know the encryption seed to effectively manage the data. The risks of relying on encryption include the fact that an attacker can copy the data and use brute force to decrypt the data. Losing the seed means losing the data.
[http://en.wikipedia.org/wiki/File_system]

fls'track

name::
* McsEngl.fls'track@cptItsoft,

Οι λουρίδες (κυκλικοι δίσκοι) που είναι χωρισμένος ο δίσκος. Χωρίζεται σε SECTORS.

fls'utility

name::
* McsEngl.fls'utility@cptItsoft,

The difference between a utility and a built-in core command function is arbitrary, depending on the design of the operating system, and the memory and space limitations of the hardware. For example, in Microsoft MS-DOS, formatting is performed by a utility and simple file copying is a built-in command, while in the Apple DOS, formatting is a built-in command but simple file copying is performed with a utility.

File systems include utilities to initialize, alter parameters of and remove an instance of the file system. Some include the ability to extend or truncate the space allocated to the file system.

Directory utilities create, rename and delete directory entries and alter metadata associated with a directory. They may include a means to create additional links to a directory (hard links in Unix), rename parent links (".." in Unix-like OS), and create bidirectional links to files.

File utilities create, list, copy, move and delete files, and alter metadata. They may be able to truncate data, truncate or extend space allocation, append to, move, and modify files in-place. Depending on the underlying structure of the file system, they may provide a mechanism to prepend to, or truncate from, the beginning of a file, insert entries into the middle of a file or delete entries from a file.

Also in this category are utilities to free space for deleted files if the file system provides an undelete function.

Some file systems defer reorganization of free space, secure erasing of free space and rebuilding of hierarchical structures. They provide utilities to perform these functions at times of minimal activity. Included in this category is the infamous defragmentation utility.

Some of the most important features of file system utilities involve supervisory activities which may involve bypassing ownership or direct access to the underlying device. These include high-performance backup and recovery, data replication and reorganization of various data structures and allocation tables within the file system.
[http://en.wikipedia.org/wiki/File_system]

SPECIFIC

name::
* McsEngl.fls.specific@cptItsoft,

_SPECIFIC:
* DOS-FS#cptIt436: attSpe#
* UNIX FS#ql:unix'file_system#

fls.DATABASE

name::
* McsEngl.fls.DATABASE@cptItsoft,
* McsEngl.database-filesystem@cptItsoft,

_DESCRIPTION:
Database file systems[edit source | editbeta]
Another concept for file management is the idea of a database-based file system. Instead of, or in addition to, hierarchical structured management, files are identified by their characteristics, like type of file, topic, author, or similar rich metadata.[2]

IBM DB2 for i [3] (formerly known as DB2/400 and DB2 for i5/OS) is a database file system as part of the object based IBM i [4] operating system (formerly known as OS/400 and i5/OS), incorporating a single level store and running on IBM Power Systems (formerly known as AS/400 and iSeries), designed by Frank G. Soltis IBM's former chief scientist for IBM i. Around 1978 to 1988 Frank G. Soltis and his team at IBM Rochester have successfully designed and applied technologies like the database file system where others like Microsoft later failed to accomplish.[5] These technologies are informally known as 'Fortress Rochester' and were in few basic aspects extended from early Mainframe technologies but in many ways more advanced from a technology perspective.

Some other projects that aren't "pure" database file systems but that use some aspects of a database file system:

A lot of Web-CMS use a relational DBMS to store and retrieve files. Examples: XHTML files are stored as XML or text fields, image files are stored as blob fields; SQL SELECT (with optional XPath) statements retrieve the files, and allow the use of a sophisticated logic and more rich information associations than "usual file systems".
Very large file systems, embodied by applications like Apache Hadoop and Google File System, use some database file system concepts.
[http://en.wikipedia.org/wiki/File_system#Flash_file_systems]

fls.DISK

name::
* McsEngl.fls.DISK@cptItsoft,

_DESCRIPTION:
Disk file systems[edit source | editbeta]
A disk file system takes advantages of the ability of disk storage media to randomly address data in a short amount of time. Additional considerations include the speed of accessing data following that initially requested and the anticipation that the following data may also be requested. This permits multiple users (or processes) access to various data on the disk without regard to the sequential location of the data. Examples include FAT (FAT12, FAT16, FAT32), exFAT, NTFS, HFS and HFS+, HPFS, UFS, ext2, ext3, ext4, XFS, btrfs, ISO 9660, Files-11, Veritas File System, VMFS, ZFS, ReiserFS and UDF. Some disk file systems are journaling file systems or versioning file systems.

Optical discs[edit source | editbeta]
ISO 9660 and Universal Disk Format (UDF) are two common formats that target Compact Discs, DVDs and Blu-ray discs. Mount Rainier is an extension to UDF supported by Linux 2.6 series and Windows Vista that facilitates rewriting to DVDs.
[http://en.wikipedia.org/wiki/File_system#Disk_file_systems]

fls.DISTRIBUTED file-system

name::
* McsEngl.fls.DISTRIBUTED file-system@cptItsoft,

_SPECIFIC:
NFS
RFS
SMB
XNS

fls.DOS

name::
* McsEngl.fls.DOS@cptItsoft,
* McsEngl.conceptIt436,
* McsEngl.DOS-file-system@cptItsoft,
* McsEngl.dos'fileSystem@cptIt436,
* McsEngl.FileSystem'dos@cptIt436,

DEFINITION

dosfs'DATA-AREA

name::
* McsEngl.dosfs'DATA-AREA@cptItsoft,

DATA AREA: All the sectors after the root directory.

dosfs'CLUSTER

name::
* McsEngl.dosfs'CLUSTER@cptItsoft,

CLUSTER: multi-SECTOR units involved in keeping track of disk space on a sector-by-sector basis. DOS can define a cluster to consist of as many sectors as it wants. The cluster size of a given disk is set during logical formating and does not change thereafter.

dosfs'CYLINDER

name::
* McsEngl.dosfs'CYLINDER@cptItsoft,

CYLINDER: the TRUCKS that lie over each other and can be written without movement of the head assembly.

dosfs'SECTOR

name::
* McsEngl.dosfs'SECTOR@cptItsoft,

SECTOR: The smallest chunk of data that the disk controller is physically able to READ-WRITE, which for all disks so far is 512 bytes.

dosfs'SYSTEM-AREA

name::
* McsEngl.dosfs'SYSTEM-AREA@cptItsoft,

SYSTEM AREA consists of:
1) A partition table. Optional for hard disk
2) The boot record
3) The file allocation table (FAT)
4) The root directory

dosfs'FAT

name::
* McsEngl.dosfs'FAT@cptItsoft,

FAT: File allocation table. A table with the status of all SECTORS. DOS groups contiguous sectors together and deals with them as a unit, CLUSTER, and this is what actually DOS keep track of IN the FAT.
Two bytes are allocated for each cluster on the disk.
The first two entries are reserved for special information and the third entry holds information about the first cluster (Το όνομά του είναι 2, και περιλαμβάνει τους πρώτους sectors από την data area)

dosfs'ROOT-DIRECTORY

name::
* McsEngl.dosfs'ROOT-DIRECTORY@cptItsoft,

ROOT DIRECTORY: It is the third element of the system area, and it is always located immediately following the FAT. The size and location are fixed. They are established during logical formating and cannot be changed afterward.
An ENTRY in the root directory can refer to either a file or a subdirectory.
SUBDIRECTORY is just like any other file, and in function it is exactly like the root directory.

dosfs'track

name::
* McsEngl.dosfs'track@cptItsoft,

Οι λουρίδες (κυκλικοι δίσκοι) που είναι χωρισμένος ο δίσκος. Χωρίζεται σε SECTORS.

fls.FAT32

name::
* McsEngl.fls.FAT32@cptItsoft,

An Enhanced File System for Windows 95
Most new computers are shipping with FAT32, a new extension of Win/DOS's FAT file system. Find out what FAT32 does to solve problems with the old FAT, and other advantages and disadvantages of the new file system.

By Barry Simon

In 1987, there was a crisis in the world of personal computing. The FAT file system, developed ten years earlier by Microsoft for its Standalone Disk Basic interpreter and later adapted to DOS, had been stretched to its limit. FAT could support hard disks only up to 32MB, making new, higher-capacity hard disks all but useless to PC users. Some third-party vendors provided their own ways of accommodating larger hard disks, but it wasn't until the release of DOS 4.0 that the crisis was resolved--for a while.
Significant changes in the structure of the file system in DOS 4.0 allowed the operating system to handle disks up to 128MB; minor extensions added later raised the limit to 2GB. At the time, that seemed like more storage space than anyone would ever need. But if the history of personal computing has shown one thing, it's that "more than anyone would ever need" quickly becomes "not nearly enough for serious work." And indeed, hard disks with a capacity of 2.5GB or more are now commonly available--and the once lofty and liberating 2GB ceiling has suddenly become another obstacle to be surmounted.
For Windows 95 systems, Microsoft has developed FAT32, a new extension of the FAT system that was quietly released with the OEM Service Pack 2. FAT32 is available only on new PCs and not as a Windows 95 upgrade, although Microsoft indicates it will be included in the major Windows upgrade (code-named Memphis) expected later this year. In this article, we'll review the general structure of FAT file systems, then take a look at what's new in FAT32. To avoid confusion, we'll use FAT16 to denote the older, 16-bit version.
The file system depends on a number of special areas of the disk set aside for organization when the disk is formatted: the master boot record, the partition table, the boot record, the file allocation table (from which the FAT system takes its name), and the root directory. At a low level, disks are organized into 512-byte groupings called sectors. The FAT system allocates space for files using a unit called a cluster, made up of an integral number of sectors. The number of sectors in a cluster must be a power of 2. (You can run CHKDSK or SCANDISK to see how big the clusters are on your system.) Microsoft calls these clusters allocation units, and SCANDISK's report includes a notation of their size, such as "16,384 bytes in each allocation unit." You can normally compute the cluster size by dividing the disk size by 64K (65,536 bytes) and rounding up to the nearest power of 2. Thus, a 1.2GB disk has clusters that are 32K in size: 1.2GB (1,258,291.2K) divided by 65,536 is 19.2K, which rounds up to 32K.
The FAT is a database that associates clusters of disk space with files. It has one entry for each cluster. The first two entries contain information about the FAT. The third entry and those following are assigned to clusters of disk space, starting with the first cluster that is available for use by files. FAT entries may contain a few special values to indicate that
the cluster is free--that is, not in use by a file (0000H for FAT16); the cluster contains one or more sectors that are physically damaged and should not be used (FFF7H for FAT16); and the cluster is the final cluster in a file (FFF8-FFFFH for FAT16). For any cluster that is used by a file but is not the file's last cluster, the FAT entry contains the number of the next cluster used by the file.
Each directory, whether the root directory or a subdirectory, is also a database. A DOS directory has one main entry for each file (Windows 95 uses additional entries for long filenames). Unlike the FAT, where each entry has a single field, the entries for a file in a directory have multiple fields (see Figure 1). Some of the fields--name, extension, size, date, and time--can be displayed with the DIR command. But the FAT system relies on a field that DIR does not display--the number of the first cluster assigned to the file.
When a program asks the operating system to provide the contents of a file, the OS looks at the directory entry for the file to find the first cluster. It then looks at the FAT entry for that cluster to find the next cluster in the chain. Repeating this process until it encounters the last cluster for the file, the OS can compute exactly which clusters belong to the file and the order in which they fall. In this way, the OS can provide a program with any part of the file the program asks for. This way of organizing a file is called the FAT chain.
Under the FAT system, files are always allocated an integral number of clusters. On a 1.2GB hard disk with clusters of 32K, a text file containing only the words "hello, world" may have a directory listing of just 12 bytes, but the file will actually take up 32K of disk space. The unused part of the cluster is called slack. Small files may have slack equal to almost an entire cluster; on average, a file will have half a cluster of slack.
On an 850MB hard disk with 16K clusters, with a typical file size of about 50K, about 16 percent of the disk space allocated to files will be wasted in unused but allocated space. One of the ways a disk compression scheme, such as DriveSpace's, creates space is by recycling the disk's slack space for use by other files.
The original FAT file system in DOS 1 used 12-bit FAT entries. (The 12-bit FAT system is still in use today for floppy disks.) DOS 2, which added support for hard disks, shifted to 16-bit FAT entries. The problem that arose in 1987 had its root in the low-level operating system calls to retrieve a disk sector, which involved passing a 16-bit value as a parameter. There are 65,536 distinct 16-bit values; multiplying 65,536 by the 512 bytes in a sector yields 32MB. With regard to sectors on the disk, that was as far as the operating system could count. What DOS 4.0 did was change the low-level sector-handling to use 32-bit parameters.
The current 2GB limit is not actually an operating system problem; it is a problem with existing programs. A disk whose size is 2GB or larger would have clusters of 64K, or 65,536 bytes (see Figure 2). But the largest value that can fit into 16 bits is 65,535; 64K is too large. Microsoft discovered that many programs simply assumed that the number of bytes per cluster fits into 16 bits.
Even if the problem didn't exist at 2GB, the operating system would still balk at disks larger than 4GB. Under FAT16, the OS itself stores the number of sectors per cluster in a single byte in the disk parameter block that is set up by the OS. This number must be a power of 2, and it must be less than 256. Thus, the largest possible cluster size would be 128 sectors, or 64K. So even without the 2GB limit, FAT16 could still accommodate only disks under 4GB.
With the introduction of FAT32, both the FAT entries and the sector numbering are now 32-bit. Here's what that means for you: 4,294,967,296 distinct 32-bit values multiplied by 512 bytes per sector yields a whopping 2 terabytes (2,199,023,255,552 bytes) as the maximum possible disk size under FAT32.
Cutting Some Slack
Continued from Counting Sectors and Clusters
Now that the number of allowed clusters and the number of allowed sectors are the same, you might expect that FAT32, to minimize slack losses, would shift to clusters of one sector. But trade-offs must be made, so the FAT32 specification calls for 4K clusters for drives up to 8GB (see Figure 3).
For one thing, the size of the FAT itself becomes a factor. The operating system keeps two copies of the FAT, so each cluster requires 8 bytes for its FAT entries. On a 2GB disk, the FATs would take 32MB of disk space if clusters were only 512 bytes in size. With 4K clusters, the two FATs require only 4MB, a savings of 28MB.
But the trade-offs involve more than disk space; there are performance issues as well. VCACHE, the built-in disk cache, tries to keep the FAT in RAM for speedier disk access. Obviously, that's easier if individual FATs are 2MB instead of 16MB. You might worry that the larger number of clusters and doubling of FAT entry sizes would result in a less efficient VCACHE, but FAT32 is accompanied by a new cache-handling method that, according to Microsoft, increases overall performance.
Other changes in FAT32
Continued from Cutting Some Slack
To accommodate the larger number of possible clusters, the directory entry for each file must have 4 bytes for the starting cluster of the file, rather than the 2 bytes needed under FAT16. Traditionally, each directory entry is a 32-byte record (as shown in Figure 1). In the middle of the record are 10 bytes (bytes 12 to 21) that Microsoft has reserved for its own future use. Two of those bytes are now used to accommodate the extra bytes needed to specify the starting cluster under FAT32.
The operating system has always kept two copies of the FAT on disk but used only one. With FAT32, the OS can now use either copy. Another change is that the root directory, which used to be of fixed size and location on disk, is now free to grow as necessary, like a subdirectory. There is no longer a limit on the number of directory entries in the root directory. That's especially important, because each long filename uses multiple directory entries. (For details, see "How Windows 95 Stores Long Filenames," PC Magazine, June 25, 1996.)
The combination of a movable root directory and the use of both FAT copies offer the potential of smooth, dynamic resizing of a hard disk--to shrink a partition, for example, to make room for some other operating system. The new approach is safer than ones used by third-party programs to resize partitions under FAT16. (While Windows doesn't include a utility that takes advantage of the potential of FAT32, third-party products that do have been announced. They include PowerQuest's Partition Magic 3.0 and Quarterdeck's PartitionIt.)
Caveats
Continued from Other changes in FAT32
FAT32 is only available for Windows 95. Microsoft has not promised to support it under Windows NT and has hinted it will not do so. The company has stated, however, that if Windows NT 5.0 doesn't support FAT32, it will provide a utility to transform FAT32 disks to NTFS (Windows NT's native file system) so that upgraders won't be in trouble. But for now, if you want to use Windows NT and Windows 95 on the same machine, you need to be sure that any disk space shared by the two operating systems uses FAT16 and not FAT32, which Windows NT won't read, or NTFS, which Windows 95 won't read.
You should also be aware that because the size field in the directory entry is 32 bits, the size of an individual file is limited to 4GB.
Finally, any time the file system changes in a substantial way, you have to expect low-level disk utilities, such as the Norton Utilities, to break. Plan on upgrading them. File managers and viewers (such as Norton Navigator) should continue to work under FAT32.
If we stay with FAT32, it'll be another 15 years before we hit the 2-terabyte limit and need to move to FAT64. With talk of object-oriented file systems, we may confidently predict that by then we'll have moved beyond FAT--just as confidently as we might have predicted in 1987 that FAT would be gone before the 2GB limit was hit.
Barry Simon is a contributing editor of PC Magazine.

fls.FLASH

name::
* McsEngl.fls.FLASH@cptItsoft,

_DESCRIPTION:
A flash file system considers the special abilities, performance and restrictions of flash memory devices. Frequently a disk file system can use a flash memory device as the underlying storage media but it is much better to use a file system specifically designed for a flash device.
[http://en.wikipedia.org/wiki/File_system#Flash_file_systems]

fls.General-Parallel-File-System

name::
* McsEngl.fls.General-Parallel-File-System@cptItsoft,
* McsEngl.GPFS@cptIt433i,

Explosions of data, transactions, and digitally-aware devices are straining IT infrastructure and operations, while storage costs and user expectations are increasing. The IBM General Parallel File System™ (GPFS™), high-performance enterprise file management, can help you move beyond simply adding storage to optimizing data management.
High-performance enterprise file management using GPFS gives your business:
Seamless capacity expansion to handle the explosive growth of digital information and improve efficiency through enterprise wide, interdepartmental information sharing
High reliability/availability to eliminate production outages and provide disruption-free maintenance and capacity upgrades
Performance to satisfy the most demanding applications
Policy-driven automation to ease information life cycle management
Extensible management and monitoring infrastructure to simplify file system administration
Cost-effective disaster recovery and business continuity
[http://www-03.ibm.com/systems/software/gpfs/]

fls.GOOGLE

name::
* McsEngl.fls.GOOGLE@cptItsoft,
* McsEngl.google-file-system@cptItsoft,

_DESCRIPTION:
Google File System (GFS or GoogleFS) is a proprietary distributed file system developed by Google for its own use.[1] It is designed to provide efficient, reliable access to data using large clusters of commodity hardware. A new version of the Google File System is codenamed Colossus.[2]
[http://en.wikipedia.org/wiki/Google_File_System]

fls.HIERARCHICAL

name::
* McsEngl.fls.HIERARCHICAL@cptItsoft,

fls.NETWORK

name::
* McsEngl.fls.NETWORK@cptItsoft,
* McsEngl.network-filesystem@cptItsoft,

_DESCRIPTION:
A network file system is a file system that acts as a client for a remote file access protocol, providing access to files on a server. Examples of network file systems include clients for the NFS, AFS, SMB protocols, and file-system-like clients for FTP and WebDAV.
[http://en.wikipedia.org/wiki/File_system#Network_file_systems]

fls.SHARED-DISK

name::
* McsEngl.fls.SHARED-DISK@cptItsoft,

_DESCRIPTION:
A shared disk file system is one in which a number of machines (usually servers) all have access to the same external disk subsystem (usually a SAN). The file system arbitrates access to that subsystem, preventing write collisions. Examples include GFS2 from Red Hat, GPFS from IBM, SFS from DataPlow, CXFS from SGI and StorNext from Quantum Corporation.
[http://en.wikipedia.org/wiki/File_system#Shared_disk_file_systems]

fls.VIRTUAL

name::
* McsEngl.fls.VIRTUAL@cptItsoft,
* McsEngl.virtual-file-system@cptItsoft,

_DESCRIPTION:
A virtual file system (VFS) is programming that forms an interface between an operating system's kernel and a more concrete file system.
[http://searchservervirtualization.techtarget.com/definition/virtual-file-system-VFS]

fls.ZFS

name::
* McsEngl.fls.ZFS@cptItsoft,
* McsEngl.ZFS@cptItsoft,

_DESCRIPTION:
ZFS is a combined file system and logical volume manager designed by Sun Microsystems. The features of ZFS include protection against data corruption, support for high storage capacities, efficient data compression, integration of the concepts of filesystem and volume management, snapshots and copy-on-write clones, continuous integrity checking and automatic repair, RAID-Z and native NFSv4 ACLs.
ZFS was originally implemented as open-source software, licensed under the Common Development and Distribution License (CDDL). The ZFS name is registered as a trademark of Oracle Corporation.[4]
OpenZFS is an umbrella project aimed at bringing together individuals and companies that use the ZFS file system and work on its improvements.[5][6][7]
[https://en.wikipedia.org/wiki/ZFS]

os'information-machine-to-work-with#cptIt456#

name::
* McsEngl.os'information-machine-to-work-with@cptItsoft,

_DESCRIPTION:
Το χαρακτηριστικο αυτο μπορεί να πάρει τιμή ΚΑΘΕ μερική έννοια της έννοιας <ΠΛΗΡΟΦΟΡΙΑΚΗ ΜΗΧΑΝΗ/456>.

os'PROCESSOR

name::
* McsEngl.os'PROCESSOR@cptItsoft,

MULTIPROCESSING (πολλοι επεξεργαστες)

AMP {Asymetric MultiProcessing},
SMP {Symmetric MultiProcessing},

ΚΑΤΑ ΤΗΝ ΑΣΥΜΜΕΤΡΗ ΠΟΛΥΕΠΕΞΕΡΓΑΣΙΑ, ΤΜΗΜΑΤΑ ΤΩΝ ΥΠΗΡΕΣΙΩΝ ΚΑΙ ΚΛΗΣΕΩΝ ΤΟΥ ΛΕΙΤΟΥΡΓΙΚΟΥ ΣΥΤΗΜΑΤΟΣ ΜΠΟΡΟΥΝ Ν'ΑΝΑΤΕΘΟΥΝ ΣΕ ΣΥΓΚΕΚΡΙΜΕΝΟΥΣ ΕΠΕΞΕΡΓΑΣΤΕΣ ΠΟΥ ΠΡΟΟΡΙΖΟΝΤΑΙ ΓΙ'ΑΥΤΕΣ ΤΙΣ ΣΥΓΚΕΚΡΙΜΕΝΕΣ ΕΡΓΑΣΙΕΣ,
ΕΝΩ ΑΝΤΙΘΕΤΑ ΣΤΗΝ <ΣΥΜΜΕΤΡΙΚΗ ΠΟΛΥΕΠΕΞΕΡΓΑΣΙΑ>, ΚΑΘΕ ΕΠΕΞΕΡΓΑΣΤΗΣ -ΑΠΟ ΟΣΟΥΣ ΔΙΑΘΕΤΕΙ ΤΟ ΣΥΣΤΗΜΑ- ΜΠΟΡΕΙ ΝΑ ΕΚΤΕΛΕΣΕΙ ΟΠΟΙΑΔΗΠΟΤΕ ΕΡΓΑΣΙΑ ΤΟΥ ΑΝΑΤΕΘΕΙ. ΤΑ ΠΛΕΟΝΕΚΤΗΜΑΤΑ ΤΗΣ ΣΥΜΜΕΤΡΙΚΗΣ ΠΟΛΥΕΠΕΞΕΡΓΑΣΙΑΣ ΕΝΑΝΤΙ ΤΗΣ ΑΣΥΜΜΕΤΡΗΣ ΕΙΝΑΙ ΠΡΟΦΑΝΗ.
[CHIP, JUN 1994, 34]

os'RAM

name::
* McsEngl.os'RAM@cptItsoft,

RAM needed and RAM can see.

os'STORAGE

name::
* McsEngl.os'STORAGE@cptItsoft,

STORAGE needed and can use.

ΣΥΣΤΗΜΑ.
[ΝΙΚΟΣ, ΣΕΠΤ. 1994]

OPERATING SYSTEM is the software that
- supervises and
- assist
you and the application programs you run on your computer.

os'kernel

_CREATED: {2013-12-15}

name::
* McsEngl.os'kernel@cptItsoft,

_DESCRIPTION:
In computing, the kernel is a computer program that manages input/output requests from software and translates them into data processing instructions for the central processing unit and other electronic components of a computer. The kernel is a fundamental part of a modern computer's operating system.[1]

When a computer program (in this case called a process) makes requests of the kernel, the request is called a system call. Various kernel designs differ in how they manage system calls (time-sharing) and resources. For example, a monolithic kernel executes all the operating system instructions in the same address space to improve the performance of the system. A microkernel runs most of the operating system's background process in user space,[2] to make the operating system more modular and, therefore, easier to maintain.[3]

For computer programmers, the kernel's interface is a low-level abstraction layer.
[http://en.wikipedia.org/wiki/Kernel_(computing)]

os'live-disk

name::
* McsEngl.os'live-disk@cptItsoft,
* McsEngl.live-CD@cptItsoft,
* McsEngl.live-disk@cptItsoft,
* McsEngl.live-DVD@cptItsoft,

_DESCRIPTION:
A live CD, live DVD, or live disc is a complete bootable computer installation including operating system which runs in a computer's memory, rather than loading from a hard disk drive; the CD itself is read-only. It allows users to run an operating system for any purpose without installing it or making any changes to the computer's configuration. Live CDs can run on a computer without secondary storage, such as a hard disk drive, or with a corrupted hard disk drive or file system, allowing data recovery. A live ISO is an ISO image of a Live CD which can be used in virtual machine environments, mounted as if it were a CD/DVD and used as the virtual machine's boot CD. Live CDs, ISOs, and images usually include an operating system available without charge or restrictive licence such as Linux, rather than a commercial one such as Microsoft Windows, for legal rather than technical reasons.

The functionality of a live CD is also available with a bootable live USB flash drive, or even an external USB drive. These may have the added functionality of writing changes on the bootable medium. Also, solid-state devices are faster than optical drives. Write-locked Live SD WORM systems are the direct solid-state counterpart to live CDs, and can be booted natively in a media card slot or by using a USB adapter. Write-locked Live SD systems avoid excessive write cycles or corruption by ill-conditioned software, such as malware.

While a live CD typically does not alter any operating system or files already installed on a computer's secondary storage (such as hard disk drives), many live CDs include software mechanisms and utilities for altering the host computer's data stores, including installation of an operating system. This is important for the system management aspect of live CDs, which can be useful for removing malware, for drive imaging, and for system recovery. Unless such software is used, at the end of a live CD session the computer remains as it was before. The live system is able to run without permanent installation by placing the files that normally would be stored on a hard drive into RAM, typically in a RAM disk. The computer must have sufficient RAM both to store these files and maintain normal operation.
[http://en.wikipedia.org/wiki/Live_CD]

os'ognCompany#cptEconomy7#

name::
* McsEngl.os'ognCompany@cptItsoft,

MAKER:

VENDOR:

os'price#cptEconomy541.44#

name::
* McsEngl.os'price@cptItsoft,

os'program.APPLICATION#cptIt97#

name::
* McsEngl.os'program.APPLICATION@cptItsoft,

Application program that work with this OS.

os'program.DEVELOPMENT#cptIt430#

name::
* McsEngl.os'program.DEVELOPMENT@cptItsoft,

os'program.OPERATING-SYSTEMS-MANAGEMMENT

name::
* McsEngl.os'program.OPERATING-SYSTEMS-MANAGEMMENT@cptItsoft,

SYSTEM COMMANDER:
$100, from V Communications.
[BYTE, OCT. 1994, 40]

os'ResourceInfHmnn#cptResource843#

name::
* McsEngl.os'ResourceInfHmnn@cptItsoft,

os'structure#cptCore515#

name::
* McsEngl.os'structure@cptItsoft,

kernel, shell, tools.

os'Standard#cptIt139#

name::
* McsEngl.os'Standard@cptItsoft,

os'User-interface#cptIt420#

name::
* McsEngl.os'User-interface@cptItsoft,

osui.CLI (oscli)

name::
* McsEngl.osui.CLI (oscli)@cptItsoft,
* McsEngl.all-text-display-mode@cptItsoft,
* McsEngl.cli@cptItsoft,
* McsEngl.oscli@cptItsoft,
* McsEngl.cli@cptItsoft,

_DESCRIPTION:
An all-text display mode, also referred to as a command line interface (CLI), can be provided by both a console and a terminal window. A console is a display mode for which the entire monitor screen shows only text and no images (including icons, pull-down menus and frames around the text). A terminal window is a text-only window that emulates a console and that can be opened in a GUI (graphical user interface) display mode.
[http://www.linfo.org/command_line.html]

oscli'Command-line

name::
* McsEngl.oscli'Command-line@cptItsoft,
* McsEngl.os'command-line@cptItsoft,
* McsEngl.command-line@cptItsoft,

_DESCRIPTION:
A command line is the space to the right of the command prompt on an all-text display mode on a computer monitor (usually a CRT or LCD panel) in which a user enters commands and data. It provides a means of communication between a user and a computer that is based solely on textual input and output.
[http://www.linfo.org/command_line.html]

oscli'Command-prompt

name::
* McsEngl.oscli'Command-prompt@cptItsoft,
* McsEngl.os'command-prompt@cptItsoft,
* McsEngl.command-prompt@cptItsoft,

_DESCRIPTION:
A command prompt, also referred to as a prompt or a shell prompt, is a short, automatically generated text message at the beginning of the command line that serves to (1) inform a user that the system is ready for the next command, data element or other input and (2) help the user plan and execute subsequent operations. When using the bash shell, which is the default shell on Linux, the command prompt by default contains the name of the user, the name of the computer and the name of the current directory (i.e., the directory in which the user is currently working). For example, the command prompt for a user named andrew who is currently working in a directory named work on a computer named localhost would look like [andrew@localhost work]$.

The terms command line, command prompt and shell prompt are often used synonymously, particularly when instructions regarding commands are being provided. For example, part of an instruction for performing some task might say: "Enter the following at the command line," "Enter the following at the command prompt," or "Enter the following at a shell prompt."
[http://www.linfo.org/command_line.html]

oscli'Synopsis#ql:pcr'synopsis#

name::
* McsEngl.oscli'Synopsis@cptItsoft,

oscli.SHELL

name::
* McsEngl.oscli.SHELL@cptItsoft,
* McsEngl.shell-os@cptItsoft,
* McsEngl.os-shell@cptItsoft,

_DESCRIPTION:
What is "the shell"?
Simply put, the shell is a program that takes your commands from the keyboard and gives them to the operating system to perform. In the old days, it was the only user interface available on a Unix computer. Nowadays, we have graphical user interfaces (GUIs) in addition to command line interfaces (CLIs) such as the shell.
On most Linux systems a program called bash (which stands for Bourne Again SHell, an enhanced version of the original Bourne shell program, sh, written by Steve Bourne) acts as the shell program. There are several additional shell programs available on a typical Linux system. These include: ksh, tcsh and zsh.
[http://linuxcommand.org/lts0010.php]

osui.GUI

name::
* McsEngl.osui.GUI@cptItsoft,
* McsEngl.gui@cptItsoft,
* McsEngl.os'gui@cptItsoft,

os'worker#cptIt6#

name::
* McsEngl.os'worker@cptItsoft,

SPECIFIC

name::
* McsEngl.os.specific@cptItsoft,

_SPECIFIC: os.alphabetically:
* os.AMOEBA#cptItsoft410#
* os.cairo, Microsoft
* os.DOS#cptIt435#
* os.fault_tolerace
* os.Google_Chrome_OS#cptItsoft1037#
* os.Linux#cptItsoft1069#
* os.mobile
* os.network#cptItsoft119#
* os.NEXSTEP FOR INTEL 3.1#cptItsoft533#
* os.object_oriented
* os.OS/2#cptItsoft441#
* os.OS/400,
* os.PEN OS,
* os.pink, IBM/APPLE#cptItsoft768#
* os.SCO UNIX
* os.SOLARIS for intel
* os.spring SUN
* os.SYSTEM 7(MAC)
* os.UNIX#cptItsoft1122#
* os.UNIXWARE#cptItsoft439#
* os.VM/CMS#cptItsoft384#
* os.WINDOWS_3.1#cptItsoft872#
* os.WINDOWS_95/98/ME##
* os.windows_mobile#cptItsoft1014#
* os.WINDOWS_NT/2000/XP#cptItsoft440#

os.SPECIFIC-DIVISION.generic

name::
* McsEngl.os.SPECIFIC-DIVISION.generic@cptItsoft,

_SPECIFIC:
* ABSTRACT OS:
* CONCRETE OS: ανήκουν στο ITSOFT.

os.SPECIFIC-DIVISION.evoluting

name::
* McsEngl.os.SPECIFIC-DIVISION.evoluting@cptItsoft,

ΜΗΔΕΝΙΚΗ ΓΕΝΙΑ

Στην αρχή. Οι προγραμματιστές, μέσω του προγράμματός τους, που έγραφαν σε δυαδική μορφή, είχαν απόλυτο έλεγχο της μηχανής.
[Γιαλούρης κα, Εφαρμογές Πληροφορικής... Α',Β',Γ' Ε.Λυκείου, 1998 α' έκδοση, 77]

ΠΡΩΤΗ ΓΕΝΙΑ

Δεκαετία του 50.
Πρώτα συστήματα 'μαζικής επεξεργασίας' (batch processing).
[Γιαλούρης κα, Εφαρμογές Πληροφορικής... Α',Β',Γ' Ε.Λυκείου, 1998 α' έκδοση, 78]

ΔΕΥΤΕΡΗ ΓΕΝΙΑ

Δεκαετία του 60.
Πολυπρογραμματισμός (πολά προγράμματα συγχρόνως).
[Γιαλούρης κα, Εφαρμογές Πληροφορικής... Α',Β',Γ' Ε.Λυκείου, 1998 α' έκδοση, 78]

ΤΡΙΤΗ ΓΕΝΙΑ

1964 με τη σειρά IBM 360. Ταυτόχρονα 'μαζική επεξεργασία' και καταμερισμός χρόνου.
Ηταν πολύ ΣΥΝΘΕΤΑ λειτουργικά συστήματα και ο χρήστης μπορούσε να 'βλέπει' τη μηχανή μέσα από το πρίσμα του ΛΣ.
[Γιαλούρης κα, Εφαρμογές Πληροφορικής... Α',Β',Γ' Ε.Λυκείου, 1998 α' έκδοση, 80]

ΤΕΤΑΡΤΗ ΓΕΝΙΑ

os.SPECIFIC-DIVISION.size-of-computer

name::
* McsEngl.os.SPECIFIC-DIVISION.size-of-computer@cptItsoft,

_SPECIFIC:
BIG SYSTEM OS:
VM/CMS#cptItsoft384#
MIDDLE SYSTEM OS:
OS/400,
UNIX#cptItsoft243#
WINDOWS NT#cptItsoft440#
SMALL SYSTEM OS:
DOS#cptItsoft435#
PEN OS,
OS/2#cptItsoft441#
SYSTEM 7(MAC)
WINDOWS#cptItsoft872#

os.SPECIFIC-DIVISION.bit-architecture

name::
* McsEngl.os.SPECIFIC-DIVISION.bit-architecture@cptItsoft,

_SPECIFIC:
AMOEBA#cptItsoft410#
NEXSTEP FOR INTEL 3.1#cptItsoft533#
OS/2#cptItsoft441#
UNIXWARE#cptItsoft439#
WINDOWS NT#cptItsoft440#

os.SPECIFIC-DIVISION.INFORMATION-MACHINE-TO-WORK-WITH

name::
* McsEngl.os.SPECIFIC-DIVISION.INFORMATION-MACHINE-TO-WORK-WITH@cptItsoft,

_SPECIFIC:
NETWORK OS#cptIt119#
STAND ALONE OS:
DOS#cptIt435#
WINDOWS,
===
80x86 OS
NEXSTEP FOR INTEL 3.1
SCO UNIX
SOLARIS for intel
WINDOWS'NT
Motorola
SYSTEM 7 (APPLE)
MultiprocessorOS
Pentium
RISC
NEXSTEP
WINDOWS'NT

os.SPECIFIC-DIVISION.characteristic

name::
* McsEngl.os.SPECIFIC-DIVISION.characteristic@cptItsoft,

_SPECIFIC:
FAULT TOLERANCE OS
OBJECT ORIENTED OS
cairo, Microsoft
pink, IBM/APPLE#cptIt768#
spring SUN

os.AGGREGATE

name::
* McsEngl.os.AGGREGATE@cptItsoft,

os.aggregate.LINUX

name::
* McsEngl.os.aggregate.LINUX@cptItsoft,
* McsEngl.osLnx.aggregate@cptItsoft,

Linux has the largest installed base of all general-purpose operating systems, because of the dominance of Android, and is also the leading operating system on servers and other big iron systems such as mainframe computers and virtually all the fastest supercomputers.
[http://cointelegraph.com/news/from-microsoft-to-nasdaq-blockchain-is-gaining-unprecedented-traction]

os.AMOEBA

name::
* McsEngl.os.AMOEBA@cptItsoft,
* McsEngl.conceptItsoft410,
* McsEngl.AMOEBA@cptItsoft,
* McsEngl.amoeba'os@cptItsoft410,
* McsEngl.os.amoeba@cptItsoft410,

DEFINITION

TO AMOEBA ΜΠΟΡΕΙ ΝΑ ΧΑΡΑΚΤΗΡΙΣΤΕΙ ΣΑΝ ΕΝΑ ΓΕΝΙΚΗΣ ΧΡΗΣΗΣ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ, ΣΧΕΔΙΑΣΜΕΝΟ ΝΑ ΧΡΗΣΙΜΟΠΟΙΕΙ ΕΝΑ ΣΥΝΟΛΟ ΜΗΧΑΝΗΜΑΤΩΝ ΚΑΙ ΝΑ ΤΟ ΚΑΝΕΙ ΝΑ ΕΝΕΡΓΕΙ ΣΑΝ ΜΙΑ ΟΝΤΟΤΗΤΑ. ΣΕ ΓΕΝΙΚΕΣ ΓΡΑΜΜΕΣ, ΟΙ ΧΡΗΣΤΕΣ ΔΕΝ ΧΡΕΙΑΖΕΤΑΙ ΝΑ ΓΝΩΡΙΖΟΥΝ ΤΟΝ ΑΡΙΘΜΟ ΚΑΙ ΤΗΝ ΘΕΣΗ ΤΩΝ ΕΠΕΞΕΡΓΑΣΤΩΝ ΠΟΥ ΤΡΕΧΟΥΝ ΤΙΣ ΕΝΤΟΛΕΣ ΤΟΥΣ, ΚΑΘΩΣ ΕΠΙΣΗΣ ΚΑΙ ΤΟΝ ΑΡΙΘΜΟ ΚΑΙ ΤΗΝ ΤΟΠΟΘΕΣΙΑ ΤΩΝ ΣΕΡΒΕΡΣ ΟΠΟΥ ΑΠΟΘΗΚΕΥΟΝΤΑΙ ΤΑ ΑΡΧΕΙΑ ΤΟΥΣ.
[CHIP, JAN 1994, 50]

GENERAL#cptCore50.29.10#

GENERAL'OBJECTS,
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#

WHOLE

WHOLE'OBJECTS,

ognCompany#cptEconomy7#

CREATOR: ANDREW S. TANENBAUM

EVALUATION#cptCore546.107#

ΚΕΝΤΡΙΚΟ ΤΟΥ ΠΛΕΟΝΕΚΤΗΜΑ Η ΔΥΝΑΤΟΤΗΤΑ ΣΦΙΧΤΗΣ ή ΧΑΛΑΡΗΣ ΣΥΜΜΕΤΡΙΚΗΣ ΠΟΛΥΕΠΕΞΕΡΓΑΣΙΑΣ. ΜΕ ΤΟΥΣ ΔΥΟ ΑΥΤΟΥΣ ΑΔΟΚΙΜΟΥΣ ΟΡΟΥΣ ΥΠΟΝΟΕΙΤΑΙ Η ΔΥΝΑΤΟΤΗΤΑ ΠΟΛΥΕΠΕΞΕΡΓΑΣΙΑΣ ΕΙΤΕ ΟΙ ΔΙΑΦΟΡΟΙ ΕΠΕΞΕΡΓΑΣΤΕΣ ΒΡΙΣΚΟΝΤΑΙ ΣΤΟΝ ΙΔΙΟ ΥΠΟΛΟΓΙΣΤΗ, ΕΙΤΕ ΚΑΤΑΝΕΜΗΜΕΝΟΙ ΣΕ ΔΙΑΦΟΡΟΥΣ ΥΠΟΛΟΓΙΣΤΕΣ ΜΕΣΑ ΣΕ ΕΝΑ ΔΙΚΤΥΟ.
[CHIP, JAN 1994, 50]

Doing#cptCore475#

OPERATING SYSTEM#cptIt444-8#

os.CHROMIUM

_CREATED: {2009-11-20}

name::
* McsEngl.conceptItsoft1037,
* McsEngl.chromium@cptItsoft1037,
* McsEngl.chrome-os@cptItsoft1037,
* McsEngl.google-chrome-os@cptItsoft1037,
* McsEngl.os.google-chorme@cptItsoft1037,

chromium'DEFINITION

specific

Google Chrome OS is a project by Google Inc. to develop a lightweight computer operating system devoted to using the World Wide Web.[1] Announced on July 7, 2009, it is set to have a publicly available stable release during the second half of 2010.[2] The Linux-based operating system will sport a graphical user interface based on Google's Chrome web browser and will run on systems with either x86 or ARM processors,[3] and designed for netbooks. Google released the Google Chrome OS open source project on November 19, 2009 as Chromium OS.[4] Originally it was thought to use a new windowing system, but is now confirmed to be using the X.Org Server.[5]
[http://en.wikipedia.org/wiki/Chrome_os] 2009-11-20

chromium'relation-to-linux

name::
* McsEngl.chromium'relation-to-linux@cptItsoft,

_DESCRIPTION:
Yes, Chrome OS is also Linux. It's Linux that uses Google's Chrome Web browser as its main interface.
[http://www.zdnet.com/the-most-popular-end-user-linux-distributions-are-7000017223/]

chromium.SPECIFIC#cptCore546.23#

name::
* McsEngl.chromium.SPECIFIC@cptItsoft,

_SPECIFIC#ql:_GENERIC cptItsoft1037#

chromium'EVOLUTION#cptCore546.171#

name::
* McsEngl.chromium'EVOLUTION@cptItsoft,

{time.2009-11-19}:
Google released the Google Chrome OS open source project on November 19, 2009 as Chromium OS.
[http://en.wikipedia.org/wiki/Chrome_os] 2009-11-20

{time.2009-07-07}:
Announced on July 7, 2009, it is set to have a publicly available stable release during the second half of 2010.
[http://en.wikipedia.org/wiki/Chrome_os] 2009-11-20

chromium'ResourceInfHmnn#cptResource843#

name::
* McsEngl.chromium'ResourceInfHmnn@cptItsoft,

* http://www.youtube.com/watch?v=ANMrzw7JFzA&feature=channell

chromium'chrome

name::
* McsEngl.chromium'chrome@cptItsoft,

SPECIFIC

chromium.CHROME-OS

_CREATED: {2013-12-22}

name::
* McsEngl.chromium.CHROME-OS@cptItsoft,
* McsEngl.chrome-os@cptItsoft,

_DESCRIPTION:
Google Chrome OS is a Linux-based operating system designed by Google to work primarily with web applications. The user interface takes a minimalist approach and consists almost entirely of just the Google Chrome web browser;[3] since the operating system is aimed at users who spend most of their computer time on the Web, the only "native" applications on Chrome OS are a browser, media player and file manager.[4] This means that Chrome OS is almost a pure web thin client OS.[5][6]

Chrome OS is built upon the open source project called Chromium OS[7] which, unlike Chrome OS, can be compiled from the downloaded source code. Chrome OS is the commercial version installed on specific hardware from Google's manufacturing partners.[8] The launch date for retail hardware featuring Chrome OS was delayed from late 2010[9] to June 15, 2011, when "Chromebooks" from Samsung, and then Acer shipped in July.[10]
[http://en.wikipedia.org/wiki/Chrome_OS]

os.DISTRIBUTED

_CREATED: {2013-12-15}

name::
* McsEngl.os.DISTRIBUTED@cptItsoft,
* McsEngl.distributed-os@cptItsoft,

_DESCRIPTION:
A distributed operating system is a software over a collection of independent, networked, communicating, and physically separate computational nodes.[1] Each individual nodes hold a specific software subset of the global aggregate operating system. Each subset is a composite of two distinct service provisioners.[2] The first is a ubiquitous minimal kernel, or microkernel, that directly controls that node’s hardware. Second is a higher-level collection of system management components that coordinate the node's individual and collaborative activities. These components abstract microkernel functions and support user applications.[3]

The microkernel and the management components collection work together. They support the system’s goal of integrating multiple resources and processing functionality into an efficient and stable system.[4] This seamless integration of individual nodes into a global system is referred to as transparency, or single system image; describing the illusion provided to users of the global system’s appearance as a single computational entity.
[http://en.wikipedia.org/wiki/Distributed_operating_system]

os.DOS

name::
* McsEngl.os.DOS@cptItsoft,

osDos'NAME (osDos)#cptCore637#

name::
* McsEngl.osDos'NAME (osDos)@cptItsoft,
* McsEngl.conceptIt435,
* McsEngl.DOS@cptItsoft,
* McsEngl.DOS-os@cptItsoft,
* McsEngl.disk-operating-system@cptItsoft,
* McsEngl.dos@cptIt435,
* McsEngl.osDos@cptIt435,
* McsEngl.os.dos@cptIt435,
* McsEngl.program.system.os.dos@cptIt435,

osDos'APPLICATION#cptIt97#

name::
* McsEngl.osDos'APPLICATION@cptItsoft,

ΥΠΑΡΧΟΥΝ ΠΕΡΙΠΟΥ 45.000 ΕΦΑΡΜΟΓΕΣ ΣΗΜΕΡΑ.
[ΚΑΘΗΜΕΡΙΝΗ, 22 ΑΥΓΟ 1993, 40]

osDos'Batch-file

name::
* McsEngl.osDos'Batch-file@cptItsoft,
* McsEngl.bat-file@cptItsoft,
* McsEngl.batch-file@cptItsoft,
* McsEngl.bile.batch@cptItsoft,
* McsEngl.bile.bat@cptItsoft,

_ARGUMENTS:
* %1, %2, %*(ALL)

_ADDRESS.WPG:
* https://stackoverflow.com/questions/26551/how-do-i-pass-command-line-parameters-to-a-batch-file,

osDos'Command

name::
* McsEngl.osDos'Command@cptItsoft,
* McsEngl.doscmd@cptItsoft,

Για περισσότερες πληροφορίες σχετικά με μια συγκεκριμένη εντολή, πληκτρολογήστε HELP όνομα-εντολής.

* doscmd.ASSOC Εμφανίζει ή τροποποιεί συσχετίσεις επέκτασης αρχείων.

* doscmd.AT Προγραμματίζει την εκτέλεση εντολών και προγραμμάτων σε έναν υπολογιστή.

* doscmd.ATTRIB Εμφανίζει ή αλλάζει τα χαρακτηριστικά αρχείων.

* doscmd.BREAK Ορίζει ή απαλείφει τον εκτεταμένο έλεγχο CTRL+C.

* doscmd.CACLS Εμφανίζει ή τροποποιεί λίστες ελέγχου πρόσβασης (ACL) αρχείων.

* doscmd.CALL Καλεί ένα πρόγραμμα δέσμης από ένα άλλο.

* doscmd.CD Εμφανίζει το όνομα ή τις αλλαγές του τρέχοντος καταλόγου.

* doscmd.CHCP Εμφανίζει ή ορίζει τον αριθμό της ενεργής κωδικοσελίδας.

* doscmd.CHDIR Εμφανίζει το όνομα ή αλλάζει τον τρέχοντα κατάλογο.

* doscmd.CHKDSK Ελέγχει ένα δίσκο και εμφανίζει μια αναφορά κατάστασης.

* doscmd.CHKNTFS Εμφανίζει ή τροποποιεί τον έλεγχο του δίσκου κατά την εκκίνηση.

* doscmd.CLS Καθαρίζει την οθόνη.

* doscmd.CMD Ξεκινά μια νέα περίοδο λειτουργίας του ερμηνευτή εντολών των Windows.

* doscmd.COLOR Ορίζει τα προεπιλεγμένα χρώματα πρώτου πλάνου και παρασκηνίου της κονσόλας.

* doscmd.COMP Συγκρίνει τα περιεχόμενα δύο αρχείων ή συνόλων αρχείων.

* doscmd.COMPACT Εμφανίζει ή τροποποιεί τη συμπίεση αρχείων σε διαμερίσματα NTFS.

* doscmd.CONVERT Μετατρέπει τόμους FAT σε NTFS. Δεν μπορείτε να μετατρέψετε την τρέχουσα μονάδα δίσκου.

* doscmd.COPY Αντιγράφει ένα ή περισσότερα αρχεία σε άλλη θέση.
=== file-creation:
* McsEngl.Dos'file_creation@cptItsoft,
* McsEngl.osDos'file_creation@cptItsoft,
\WINDOWS\system32>copy con cd-decred
cd \users\synagonism\decred
^Z
(then enter)

* doscmd.DATE Εμφανίζει ή ρυθμίζει την ημερομηνία.

* doscmd.DEL Διαγράφει ένα ή περισσότερα αρχεία.
del \dBWORK\dirPgmHitpApidoc\*.* /S /Q

* doscmd.DIR Εμφανίζει λίστα αρχείων και δευτερευόντων καταλόγων σε κατάλογο.

* doscmd.DISKCOMP Συγκρίνει τα περιεχόμενα δύο δισκετών.

* doscmd.DISKCOPY Αντιγράφει τα περιεχόμενα μιας δισκέτας σε άλλη.

* doscmd.DOSKEY Επεξεργάζεται γραμμές εντολών, καλεί ξανά εντολές των Windows και δημιουργεί μακροεντολές.

* doscmd.ECHO Εμφανίζει μηνύματα ή ενεργοποιεί και απενεργοποιεί το echo εντολών.

* doscmd.ENDLOCAL Τερματίζει τη ρύθμιση τοπικών παραμέτρων στις αλλαγές περιβάλλοντος σε ένα αρχείο δέσμης.

* doscmd.ERASE Διαγράφει ένα ή περισσότερα αρχεία.

* doscmd.EXIT Τερματίζει το πρόγραμμα CMD.EXE (ερμηνευτής εντολών).

* doscmd.FC Συγκρίνει δύο αρχεία ή σύνολα αρχείων και εμφανίζει τις διαφορές μεταξύ τους.

* doscmd.FIND Αναζητά συμβολοσειρά κειμένου σε αρχείο ή αρχεία.

* doscmd.FINDSTR Αναζητά συμβολοσειρές σε αρχεία.

* doscmd.FOR Εκτελεί μια καθορισμένη εντολή για κάθε αρχείο ενός συνόλου αρχείων.

* doscmd.FORMAT Διαμορφώνει ένα δίσκο για χρήση με τα Windows.

* doscmd.FTYPE Εμφανίζει ή τροποποιεί τους τύπους αρχείων που χρησιμοποιούνται σε συσχετίσεις επέκτασης αρχείων.

* doscmd.GOTO Μεταβιβάζει τον ερμηνευτή εντολών των Windows σε μια γραμμή με ετικέτα σε ένα πρόγραμμα δέσμης.

* doscmd.GRAFTABL Επιτρέπει στα Windows να εμφανίζουν ένα σύνολο εκτεταμένων χαρακτήρων σε κατάσταση λειτουργίας γραφικών.

* doscmd.HELP Παρέχει πληροφορίες Βοήθειας για εντολές των Windows.

* doscmd.IF Εκτελεί επεξεργασία υπό όρους σε προγράμματα δέσμης.

* doscmd.LABEL Δημιουργεί, αλλάζει ή διαγράφει την ετικέτα τόμου ενός δίσκου.

* doscmd.MD Δημιουργεί έναν κατάλογο.
* doscmd.MKDIR Δημιουργεί έναν κατάλογο.

* doscmd.MODE Ρυθμίζει τις παραμέτρους μιας συσκευής του συστήματος.

* doscmd.MORE Εμφανίζει το αποτέλεσμα κατά μία οθόνη κάθε φορά.

* doscmd.MOVE Μετακινεί ένα ή περισσότερα αρχεία από έναν κατάλογο σε άλλον.

* doscmd.PATH Εμφανίζει ή ορίζει μια διαδρομή αναζήτησης για εκτελέσιμα αρχεία.

* doscmd.PAUSE Αναστέλλει την εκτέλεση ενός προγράμματος δέσμης και εμφανίζει ένα μήνυμα.

* doscmd.POPD Επαναφέρει την προηγούμενη τιμή του τρέχοντα καταλόγου, που αποθηκεύτηκε από την PUSHD.

* doscmd.PRINT Εκτυπώνει ένα αρχείο κειμένου.

* doscmd.PROMPT Αλλάζει τη γραμμή εντολών των Windows.

* doscmd.PUSHD Αποθηκεύει τον τρέχοντα κατάλογο και στη συνέχεια τον αλλάζει.

* doscmd.RD Καταργεί έναν κατάλογο.
* doscmd.RMDIR Καταργεί έναν κατάλογο.
RMDIR [/S] [/Q] [μονάδα δίσκου:]διαδρομή
RD [/S] [/Q] [μονάδα δίσκου:]διαδρομή
/S Καταργεί όλους τους καταλόγους και τα αρχεία στον καθορισμένο
κατάλογο μαζί με τον κατάλογο. Χρησιμοποιείται για τη διαγραφή
ενός δέντρου καταλόγων.
/Q Λειτουργία χωρίς παρέμβαση χρήστη, χωρίς επιβεβαίωση πριν από την
κατάργηση ενός δέντρου καταλόγου με το διακόπτη /S

* doscmd.RECOVER Ανακτά αναγνώσιμες πληροφορίες από προβληματικό ή ελαττωματικό δίσκο.

* doscmd.REM Καταγράφει σχόλια (παρατηρήσεις) σε αρχεία δέσμης ή στο CONFIG.SYS.

* doscmd.REN Μετονομάζει ένα αρχείο ή αρχεία.

* doscmd.RENAME Μετονομάζει ένα αρχείο ή αρχεία.

* doscmd.REPLACE Αντικαθιστά αρχεία.

* doscmd.SET Εμφανίζει, ορίζει ή καταργεί μεταβλητές περιβάλλοντος των Windows.

* doscmd.SETLOCAL Ξεκινά τη μετάφραση των αλλαγών περιβάλλοντος σε ένα αρχείο δέσμης.

* doscmd.SHIFT Μετατρέπει τη θέση των παραμέτρων με δυνατότητα αντικατάστασης σε αρχεία δέσμης.

* doscmd.SORT Ταξινομεί την είσοδο.

* doscmd.START Ξεκινά ένα διαφορετικό παράθυρο για την εκτέλεση ενός καθορισμένου προγράμματος ή εντολής.
===
> start jedit

* doscmd.SUBST Συσχετίζει μια διαδρομή με ένα γράμμα μονάδας δίσκου.

* doscmd.TIME Εμφανίζει ή ορίζει την ώρα του συστήματος.

* doscmd.TITLE Ορίζει τον τίτλο παραθύρου για περίοδο λειτουργίας CMD.EXE.

* doscmd.TREE Εμφανίζει με γραφικά τη δομή καταλόγου μιας μονάδας δίσκου ή μιας διαδρομής.

* doscmd.TYPE Εμφανίζει τα περιεχόμενα ενός αρχείου κειμένου.

* doscmd.VER Εμφανίζει την έκδοση των Windows.

* doscmd.VERIFY Ενημερώνει τα Windows εάν πρέπει να εξακριβωθεί ότι η εγγραφή των αρχείων σας έχει γίνει σωστά σε ένα δίσκο.

* doscmd.VOL Εμφανίζει την ετικέτα και τον σειριακό αριθμό ενός τόμου στο δίσκο.

* doscmd.XCOPY Αντιγράφει αρχεία και δομές καταλόγου.
rem /D=date, /E=subdirectories and empties, /Y=does not ask for confirmation
rem /S=subdirectories, /I=does not ask for directory or file

> xcopy \FILE1 \FILE3 /D /S /Y /I

osDos'doing#cptCore475#

name::
* McsEngl.osDos'doing@cptItsoft,

OPERATING SYSTEM#cptIt444-8#

CHANGE FILE ATTRIBUTES

ATTRIB +-HSRA

osDos'GEM

name::
* McsEngl.osDos'GEM@cptItsoft,
* McsEngl.conceptIt263,
* McsEngl.GEM@cptItsoft,
* McsEngl.gem@cptIt637,

DEFINITION

GEM: ΓΡΑΦΙΚΟ ΠΕΡΙΒΑΛΛΟΝ ΕΡΓΑΣΙΑΣ ΓΙΑ ΤΟ DOS. ΑΝΑΠΤΥΧΘΗΚΕ ΑΠΟ ΤΗΝ DIGITAL RESEARCH.

osDos'geoworks

name::
* McsEngl.osDos'geoworks@cptItsoft,
* McsEngl.conceptItsoft880,
* McsEngl.geoworks@cptItsoft,

DEFINITION

ΓΡΑΦΙΚΟ ΠΕΡΙΒΑΛΟΝ ΕΡΓΑΣΙΑΣ ΓΙΑ ΤΟ DOS. ΠΡΟΣΦΕΡΕΙ ΔΥΝΑΤΟΤΗΤΕΣ MULTITASKING ΤΥΠΟΥ PREEMPTIVE ΚΑΙ ΤΡΕΧΕΙ ΑΚΟΜΑ ΚΑΙ ΣΕ XT.

osDos'measure#cptCore88#

name::
* McsEngl.osDos'measure@cptItsoft,

ΔΙΑΦΟΡΟΙ ΑΝΑΛΥΤΕΣ ΠΙΣΤΕΥΟΥΝ ΟΤΙ Η ΕΓΚΑΤΑΣΤΗΜΕΝΗ ΒΑΣΗ ΧΡΗΣΤΩΝ ΞΕΠΕΡΝΑΕΙ ΤΑ 100 ΕΚΑΤΟΜΜΥΡΙΑ ΠΑΓΚΟΣΜΙΩ.
[ΚΑΘΗΜΕΡΙΝΗ, 13 ΙΟΥΝ 1993, JAC. A. CASE-ΚΕΣΙΣΟΓΛΟΥ]

ΧΡΗΣΙΜΟΠΟΙΕΙΤΑΙ ΣΕ ΠΕΡΙΠΟΥ 60 ΕΚΑΤ. ΠΡΟΣΩΠΙΚΟΥΣ ΥΠΟΛΟΓΙΣΤΕΣ ΕΞΑΣΦΑΛΙΖΟΝΤΑΣ 75% ΤΗΣ ΑΓΟΡΑΣ.
[ΚΑΘΗΜΕΡΙΝΗ, 13 ΙΟΥΝ 1993, ΑΠΟ TIME]

SPECIFIC

name::
* McsEngl.osDos.specific@cptItsoft,

_SPECIFIC:
* DR DOS
* IBM DOS
* MS-DOS#cptItsoft475#

os.INTERNET-OS

name::
* McsEngl.os.INTERNET-OS@cptItsoft,
* McsEngl.internet-operating-system@cptItsoft,
* McsEngl.internet-OS@cptItsoft,

_DESCRIPTION:
Internet operating system, or Internet OS, is a term used in the computer industry to refer to any type of operating system designed to run all of its applications and services through an Internet client, generally a web browser. The advantages of such an OS would be that it would run on a thin client, allowing cheaper, more easily manageable computer systems; it would require all applications to be designed on cross-platform, open standards; and would not tie a user's applications, documents, and preferences to a single computer, but rather place them on the cloud. The Internet OS has also been promoted as the perfect type of platform for software as a service.

The term Internet operating system has been used distinctly from web operating system, which instead refers to distributed operating systems hosted through Internet services themselves.
[http://en.wikipedia.org/wiki/Internet_operating_system]

os.LINUX (osLnx)

_CREATED: {2011-09-07}

name::
* McsEngl.conceptIt497.11,
* McsEngl.conceptIt65,
* McsEngl.conceptItsoft1069,
* McsEngl.osLnx@cptItsoft,
* McsEngl.Linux@cptItsoft,
* McsEngl.LinuxOS@cptItsoft,
* McsEngl.Os.linux@cptItsoft,
* McsEngl.OsLinux@cptItsoft, {2014-02-02}
* McsEngl.unix.linux@cptItsoft,
* McsEngl.osLnx@cptItsoft, {2014-03-07}
* McsEngl.lnx@cptItsoft,
* McsElln.λίνουξ@cptIt65,
* McsElln.λνξ@cptIt,

DEFINITION

Linux: δωρεάν λειτουργικό σύστημα
Προγραμματιστές από διάφορες χώρες ένωσαν τις γνώσεις τους μέσω του Internet και δημιούργησαν το δικό τους περιβάλλον λειτουργίας του ηλεκτρονικού υπολογιστή, το οποίο ήδη βρίσκει ευρεία εφαρμογή και το οποίο ο κάθε ενδιαφερόμενος μπορεί να προμηθευτεί χωρίς να πληρώσει
Από τα πιο εντυπωσιακά αποτελέσματα της δυναμικότητας του Internet είναι το Linux. Το Linux είναι ένα δωρεάν λειτουργικό σύστημα για Η/Υ, που αναπτύσσεται από εθελοντές διαφόρων εθνικοτήτων. Η συνεργασία αυτή γίνεται μέσω του Internet με τη χρήση των βασικών αρχών της τηλεεργασίας. Το Linux διαθέτει τη δομή του Unix, τις εφαρμογές και το περιβάλλον του Unix, αλλά και πλήθος άλλων χαρακτηριστικών (πλήρης ηλεκτρονική τεκμηρίωση, τυποποιημένα εργαλεία κλπ.) που διευκολύνουν την εργασία του χειριστή του.
Είναι η ανταπάντηση των χρηστών, κατά κάποιον τρόπο, στο πώς θα έπρεπε να είναι ένα λειτουργικό σύστημα για Η/Υ. Αντίθετα με αυτό που θα προέβλεπε κανείς, το Linux είναι εξαιρετικά σταθερό, με προηγμένα χαρακτηριστικά (multitasking, multiuser, portable). Τρέχει σε επεξεργαστές χ86, 680χ0, PowerPC, Alpha και άλλους.
Το Linux ανήκει σε μια μεγάλη οικογένεια λογισμικού που λέγεται Free Software (Ελεύθερο Λογισμικό) και η κύρια ιδέα είναι ότι μπορεί και πρέπει ο ένας προγραμματιστής να βασίζεται στη δουλειά του άλλου. Αντίθετα με αυτό που πιστεύεται, αποτέλεσμα και όχι αίτιο αυτής της φιλοσοφίας είναι ότι διατίθεται δωρεάν. Το Ελεύθερο Λογισμικό δεν έχει καμιά σχέση με το «shareware» αφού δεν έχει ημερομηνία λήξης, είναι πάντα διαθέσιμος ο πηγαίος κώδικας (είναι ανοικτής αρχιτεκτονικής), αναπτύσσεται ομαδικά και τυγχάνει ταχύτερης υποστήριξης μέσω του Internet, σε εθελοντική πάντα βάση. Στις ερωτήσεις στο Usenet (ομάδες συζητήσεων comp.os.linux.*) συνήθως απαντάει ο συγγραφέας του λογισμικού... Βλ. http://www.fsf.org, http:// www.gnu.org.
Την ιδέα του Free Software ξεκίνησε ο Richard Μ. Stallman το 1984, διακηρύσσοντας στο τότε μικρό Internet την έναρξη του GNU project. Εκτοτε πολλά προγράμματα δημιουργήθηκαν με αυτή τη φιλοσοφία και είναι χαρακτηριστικό ότι πολλοί τα χρησιμοποιούν χωρίς να ξέρουν από πού προέρχονται:
* gcc (μεταγλωττιστής C/C++, υπόδειγμα στην κατηγορία του),
* ghostscript (postscript renderer),
* apache (web server, είναι το λογισμικό που παρέχει το 49,9% των σελίδων στο Internet!) και πολλά από τα εργαλεία που παρέχονται και στο περιβάλλον των εμπορικών Unix είναι ακριβώς από το GNU project.
Το 1991 είχε ολοκληρωθεί μια μεγάλη συλλογή από προγράμματα για Unix χάρη στο GNU, όταν ο Linus Torvalds (τότε ήταν φοιτητής φινλανδικού πανεπιστημίου) διατύπωσε στο Internet την ιδέα της συγγραφής ενός λειτουργικού συστήματος, εντελώς πειραματικά. Ενα μεγάλο πλήθος hackers έσπευσε και ενσωματώθηκε στην ιδέα και το Linux άρχισε να αναπτύσσεται γρήγορα. Το 1993 έφτασε στην έκδοση 1.0 παίρνοντας πολλαπλές διακρίσεις από περιοδικά και επαγγελματίες του χώρου για τη σταθερότητα και την πληρότητά του.
Η χρήση του στα ακαδημαϊκά και ερευνητικά ιδρύματα είναι ευρεία, καθώς αυτό είναι ουσιαστικά και το περιβάλλον ανάπτυξης του Linux. Ανάμεσα σε πολλούς σημαντικούς οργανισμούς που χρησιμοποιούν το Linux και τις εφαρμογές του, ξεχωρίζουν η NASA και το Max Planck Institut. Σήμερα το Linux αριθμεί πάνω από 5.000.000 χρήστες, με πολλές εταιρείες να το υποστηρίζουν και να το διανέμουν και ακόμη περισσότερες να το χρησιμοποιούν. Είναι ενδεικτικό ότι η πλειοψηφία των παροχέων υπηρεσιών Internet βασίζεται σε μεγάλο βαθμό στο Linux και το ίδιο ισχύει και για την Ελλάδα.
Το Linux αυτή τη στιγμή βρίσκεται στη φάση της τυποποίησης (συμβατότητα POSIX, εξασφάλιση ποιότητας) και η ανάγκη για ένα επαγγελματικό δίκτυο υποστήριξης είναι μεγάλη. Οι πιο πολλές εταιρείες δείχνουν να αγνοούν την ύπαρξή του και τις δυνατότητες συμπίεσης του κόστους αν το χρησιμοποιήσουν, ειδικά σε περιπτώσεις που υλοποιούνται εξυπηρέτες αρχείων, www, ftp, email, news κλπ. (βλ. http://www.secretagent. com).
Στην Ελλάδα αυτή τη στιγμή υπάρχει έντονη κινητικότητα, καθώς έχουν λυθεί τα περισσότερα προβλήματα ελληνικών και έχει γραφεί η σχετική τεκμηρίωση και κάποιες μεταφράσεις κειμένων. Υποστήριξη στους Ελληνες παρέχεται είτε μέσω λίστας (και news) είτε μέσω IRC.
Για περισσότερες πληροφορίες δείτε:
http://www.linux.org
http://sunsite.unc.edu/LDP
http://www.linux.gr.
Γεωργάτος Φώτης gef@ceid. upatras.gr
Π. ΣΠΥΡΑΚΗΣ - Φ. ΓΕΩΡΓΑΤΟΣ
[βημα, 1998ιανο04]

Linux is not an operating system. It is a kernel that can serve as the core for an operating system. What most people mean by “Linux”, though, is an operating system built around the Linux kernel. For use as a desktop PC operating system, all the various “Linux distributions” are basically the same thing: variations of Gnome or KDE sitting atop the ancient X Window System.
Ubuntu is almost certainly the pinnacle of these distributions, but they’re all conceptually the same thing, and the only significant difference is the choice between Gnome and KDE, and even there you’re just choosing between two different environments that are conceptually modeled after Microsoft Windows. The entire X Windows/Gnome/KDE “desktop Linux” racket has never caught any traction with real people. Almost no one wanted it, wants it, or will want it.
--John Gruber
Read the rest in Daring Fireball: Putting What Little We Actually Know About Chrome OS Into Context
[http://www.cafeaulait.org/] 2009-12-18

osLnx'GENERIC

_GENERIC:
* UNIX-OS#cptItsoft1122#
* OS#cptItsoft1111#

osLnx'ENVIRONMENT#cptCore756#

name::
* McsEngl.osLnx'ENVIRONMENT@cptItsoft,

linux-and-gnu#cptItsoft1082.2#

osLnx'command-line

name::
* McsEngl.osLnx'command-line@cptItsoft,
* McsEngl.linux'cmd@cptItsoft,
* McsEngl.linux'shell@cptItsoft,
* McsEngl.linux'console@cptItsoft,
* McsEngl.linux'terminal@cptItsoft,
* McsEngl.osLnx'comd@cptItsoft,
* McsEngl.osLnx'com@cptItsoft,
* McsEngl.bash@cptItsoft,

_DEFINITION:
* The shell's main asset is the number of existing utilities: there are thousands of them, and each one is devoted to a particular task. We will only look at a small number of them here. One of Unix's greatest assets is the ability to combine these utilities, as we shall see later.

osLnx'cmd.FILE-MANAGEMENT

name::
* McsEngl.osLnx'cmd.FILE-MANAGEMENT@cptItsoft,

_WHOLE:
* LINUX-FILE-SYSTEM,

_SPECIFIC:
* chgrp: change group,
* chmod: change mode,
* chown: change owner,
* cp: copy,
* ln: link a file to antother,
* mkdir: make directory,
* mount: links a file-system to file-tree.
* mv: move,
* rm: remove,
* touch: create a file,

osLnx'cmd.ALPHABETICALLY

name::
* McsEngl.osLnx'cmd.ALPHABETICALLY@cptItsoft,

osLnx'cmd.audiocd:/:
* goes to audio cd.

osLnx'cmd.cat:
* osLnx'cat_command,
* print the contents of one or more files to the screen
* $ cat /etc/*-release: prints linux distribution.

osLnx'cmd.cd:
* osLnx'cmd.cd:
* http://www.linuxnix.com/2012/07/23-linux-cd-command-examples.html,
* The cd command is just like the one of DOS, with a few extras. It does just what its acronym says, change the working directory. You can use . and .., which stand respectively for the current directory and its parent directory. Typing cd alone will bring you back to your home directory. Typing cd - will bring you back to the latest directory you were in. And lastly, you can specify the home directory of a user john by typing john (' ' on its own or followed by '/' means your own home directory).
* cd = goes to home.
* cd ~ = goes to home.
* cd .. = goes to previous directory.

osLnx'cmd.chmod:
* change the permissions on a file or change one of the other attributes that make up the file's mode.

osLnx'cmd.echo (osLnx'echo):
* Processes have their environment variables and the shell allows you to view them directly, with the echo command.
* example:
- $ echo $HOME /home/joe =displays the value of $HOME.
- $ echo Hello >myfile = creates the file 'myfile' with content "Hello".

osLnx'cmd.find: finds files and directories.
* osLnx'find_command,
* find / -name <name> -print = searches at root dir

osLnx'cmd.info:
* info pages are another source source of documentation which are more complete than manual pages. The command for accessing info pages is info.
The info pages are arranged in the form of a tree structure with its top called dir. From the top, you can access all existing info pages.
You can call up info in two ways: either with no argument, in which case you will find yourself at the top of the tree structure, or followed by a command or package name, in which case the corresponding page, if it exists, will be opened. For example:
$ info emacs

osLnx'cmd.less:
* a pager. Its name is a play on words related to the first pager ever under Unix, which was called more. A pager is a program which allows a user to view long files page-by-page (more accurately, screen-by-screen). We speak about less rather than more because its use is much more intuitive. Use less to view large files, which do not fit on a screen. For example:
less /usr/doc/HOWTO/PCMCIA-HOWTO
To navigate the file, just use the up and down arrow keys. Use 'q' to quit. less can do far more than that, indeed: just type h for help, and look. But anyway, the goal of this section is just to enable you to read long files, and this goal is now achieved :)

osLnx'cmd.lilo (osLnx'lilo'com): (LInux-LOader)
* lilo -u /dev/hda = removes linux from hda boot sector.
* lilo = installs lilo in boot record.
* Η ντιρεκτίβα boot = στο αρχείο /etc/lilo.conf λέει στο Lilo πού θα πρέπει να τοποθετήσει το primary boot loader. Γενικά, μπορείτε να επιλέξετε είτε το master boot sector (/dev/hda) είτε το root partition της Linux εγκατάστασης σας (συνήθως είναι στο /dev/hda1 ή στο /dev/hda2).

osLnx'cmd.lsb_release -a:
* shows ubuntu version

osLnx'cmd.lsdev:
* lsdev command, which gathers information from these three files (if we look at the contents of /proc/interrupts, we can see that it contains the list of interruptions currently used by the system, along with the peripheral which holds them. Similarly, /proc/ioports contains the list of input/output address ranges currently busy, and lastly /proc/dma does the same for DMA channels. Therefore, in order to chase down a conflict, look at the contents of these three files) and sorts them by peripheral, which is undoubtedly more convenient.

osLnx'cmd.ln:
* ln a b =links the file a with file b.
* whole: file-management-command.

osLnx'cmd.ls:
* listing files (LiSt)
This command is equivalent to dir in DOS, but it can do much much more. In fact, this is largely due to the fact that files can do more too :) The command syntax for ls is as follows:
ls [options] [file|directory] [file|directory...]
If no file or directory is specified on the command line, ls will print the list of files in the current directory. Its options are very numerous and we will only cite a few of them:
-a: List all files, including hidden files (in Unix hidden files are files whose names begin with .); the option -A lists "almost" all files, which means every file the -a option would print except "." and "..";
-R: List recursively, i.e. all files and subdirectories of the directories mentioned in the command line;
-s: Displays the file size in kilobytes next to each file;
-l: Displays additional information about the files;
-i: Displays the inode number (the file's unique number on a filesystem, see chapter 14.0) next to each file;
-d: Displays the directories as normal files instead of listing their contents.

* example:
- ls -al images/*.gif: lists all files (including any hidden files) in directory images/ with names ending in .gif. Note that this also includes the file .gif if one exists.

osLnx'cmd.man:
* The command for displaying a manual page is man, and its syntax is as follows:
man [options] [section] <manual page>

osLnx'cmd.mkdir:
* mkdir is used for creating directories. Its syntax is simple:
mkdir [options] <directory> [directory ...]
Only one option is worth noting: the option -p. If this option is set, mkdir will create parent directories if these did not exist before. If this option is not specified and the parent directories do not exist, mkdir will display an error. Examples:
mkdir foo: creates a directory foo in the current directory;
mkdir -p images/misc docs: creates a directory misc in directory images by first creating the latter if it does not exist, together with a directory docs.

osLnx'cmd.mount:
* The command to mount filesystems is the mount command, and its syntax is as follows:
$ mount [options] <-t type> [-mount options] <device> <mounting point>
In this case, we want to mount our partition on /mnt (or any other mount point you have chosen -- don't forget that it must exist); the command for mounting our newly created partition is as follows:
$ mount -t ext2 /dev/hdb1 /mnt
The -t option is used to specify what type of filesystem the partition is supposed to host. Among the filesystems you will encounter most frequently, are ext2 (the Linux filesystem), vfat (for all DOS/Windows partitions: FAT 12, 16 or 32) and iso9660 (CDROM filesystem).
The -o option is used to specify one or more mounting options. These options depend on the filesystem used. Refer to the mount(8) manual page for more details.
* WHOLE: file-management-commands.
* mount /windows/F : mount my shared 20GB disk.

osLnx'cmd.pwd:
* print working directrory.
*

osLnx'cmd'rm:
* rm: deleting files or directories (ReMove) This command replaces the DOS commands del and deltree, and more. Its syntax is as follows:

rm [options] <file|directory> [file|directory...]
Options include:
-r, or -R: Delete recursively. This option is mandatory for deleting a directory, empty or not. However, there is also the command rmdir for deleting empty directories. -i: Request confirmation before each deletion. It is recommended to alias the bare rm word to rm -i in your shell, and the same goes for cp and mv commands. -f: The opposite of -i, forces deletion of the files or directories, even if the user has no write authorisation on the files[4].

osLnx'cmd.rpm:
** instals programs.
* rpm -Uvh <name>
* rpm -e <name> unistall

osLnx'cmd.su, osLnx'su:
The su command, also referred to as substitute user, super user, or switch user, allows a computer operator to change the current user account associated with the running virtual console.
By default, and without any other command line argument, this will elevate the current user to the superuser of the local system.
[http://en.wikipedia.org/wiki/Su_(Unix)]
===
* The command to "become" root when you have launched a shell as a user is su:

osLnx'cmd.sudo,
* osLnx'sudo,
* osLnx'sudo,
This means that in the terminal you should use sudo for commands that require root privileges; simply prepend sudo to all the commands you would normally run as Root.
[https://help.ubuntu.com/community/RootSudo]
===
Sudo stands for either "substitute user do" or "super user do" (depending upon how you want to look at it). What sudo does is incredibly important and crucial to many Linux distributions. Effectively, sudo allows a user to run a program as another user (most often the root user). There are many that think sudo is the best way to achieve "best practice security" on Linux. There are some, however, that feel quite the opposite. Regardless of where you stand, and what distribution you are currently using, there will come a time when you will have to take advantage of sudo. Whether you will need to simply use sudo or you will have to configure sudo you will want to know the ins and outs of this powerful tool.
[http://www.linux.com/learn/tutorials/306766:linux-101-introduction-to-sudo]

osLnx'cmd.tar, osLnx'tar:
* tar: Tape ARchiver:
* http://www.thegeekstuff.com/2010/04/unix-tar-command-examples//
* Extract a *.tar file using option xvf
$ tar xvf archive_name.tar
* Extract a gzipped tar archive ( *.tar.gz ) using option xvzf
$ tar xvfz archive_name.tar.gz
===
Although we have already seen a use for tar in chapter 21.0, we haven't explained how it works. This is what this section is here for. As for find, tar is a long standing Unix utility, and as such its sytax is a bit special. The syntax is:
$ tar [options] [files...]
Now, here is a list of options. Note that all of them have an equivalent long option, but you will have to refer to the manual page for this as they won't be listed here. And of course, not all options will be listed either :)
Note: the initial dash (-) of short options is not now deprecated with tar, except after a long option.
c: This option is used in order to create new archives. x: This option is used in order to extract files from an existing archive. t: List files from an existing archive. v: This will simply list the files are they are added to an archive or extracted from an archive, or, in conjunction with the t option (see above), it outputs a long listing of file instead of a short one. f <file>: Create archive with name <file>, extract from archive <file> or list files from archive <file>. If this parameter is not given, the default file will be /dev/rmt0, which is generally the special file associated to a streamer. If the file parameter is - (a dash), the input or output (depending on whether you create an archive or extract from one) will be associated to the standard input or standard output. z: Tells tar that the archive to create should be compressed with gzip, or that the archive to extract from is compressed with gzip. y: Same as z, but the program used for compression is bzip2. p: When extracting files from an archive, preserve all file attributes, including ownership, last access time and so on. Very useful for filesystem dumps. r: Append the list of files given on the command line to an existing archive. Note that the archive to which you want to append files should not be compressed! A: Append archives given on the command line to the one submitted with the f option. Similarly to r, the archives should not be compressed in order for this to work.
There are many, many, many other options, you may want to refer to the tar(1) for a whole list. See, for example, the d option. Now, on for a little practice. Say you want to create an archive of all images in /shared/images, compressed with bzip2, named images.tar.bz2 and located in your home directory. You will then type:
## Note: you must be in the directory from which# you want to archive files!
# $ cd /shared $ tar cyf ~/images.tar.bz2 images/
As you can see, we have used three options here: c told tar that we wanted to create an archive, y told it that we wanted it compressed with bzip2, and f /images.tar.bz2 told it that the archive was to be created in our home directory, with name images.tar.bz2. We may want to check if the archive is valid now. We can just check this out by listing its files:
## Get back to our home directory# $ cd $ tar tyvf images.tar.bz2
Here, we told tar to list (t) files from archive images.tar.bz2 (f images.tar.bz2), warned that this archive was compressed with bzip2 (y), and that we wanted a long listing (v). Now, say you have erased the images directory. Fortunately, your archive is intact, and you now want to extract it back to its original place, in /shared. But as you don't want to break your find command for new images, you need to preserve all file attributes:
## cd to the directory where you want to extract# $ cd /shared $ tar yxpf ~/images.tar.bz2
And here you are!
Now, let's say you want to extract the directory images/cars from the archive, and nothing else. Then you can type this:
$ tar yxf ~/images.tar.bz2 images/cars
In case you would worry about this, don't: no, if you try to back up special files, tar will take them as what they are, special files, and will not dump their contents. So yes, you can safely put /dev/mem in an archive :) Oh, and it also deals correctly with links, so do not worry for this either. For symbolic links, also look at the h option in the manpage.

osLnx'cmd.touch:
* Initially, the touch command is not intended for creating files but for updating file access and modification times[3]. However, one of its side-effects is to create the files mentioned if they did not exist before. The syntax is:
touch [options] file [file...]
So running the command:
touch file1 images/file2
will create a file called file1 in the current directory and a file file2 in directory images.

osLnx'cmd.unmount:
* The syntax is simple:
umount <mounting point|device>
So, to unmount our new partition, we can type:
$ umount /mnt
or else:
$ umount /dev/hdb1

osLnx'cmd.yast2:
goes to control-panel.

An A-Z Index of the Bash command line for Linux.
a
osLnx'cmd.alias Create an alias •
osLnx'cmd.apropos Search Help manual pages (man -k)
osLnx'cmd.apt-get Search for and install software packages (Debian/Ubuntu)
osLnx'cmd.aptitude Search for and install software packages (Debian/Ubuntu)
osLnx'cmd.aspell Spell Checker
osLnx'cmd.awk Find and Replace text, database sort/validate/index
b
osLnx'cmd.basename Strip directory and suffix from filenames
osLnx'cmd.bash GNU Bourne-Again SHell
osLnx'cmd.bc Arbitrary precision calculator language
osLnx'cmd.bg Send to background
osLnx'cmd.break Exit from a loop •
osLnx'cmd.builtin Run a shell builtin
osLnx'cmd.bzip2 Compress or decompress named file(s)
c
osLnx'cmd.cal Display a calendar
osLnx'cmd.case Conditionally perform a command
osLnx'cmd.cat Concatenate and print (display) the content of files
osLnx'cmd.cd Change Directory
osLnx'cmd.cfdisk Partition table manipulator for Linux
osLnx'cmd.chgrp Change group ownership
osLnx'cmd.chmod Change access permissions
osLnx'cmd.chown Change file owner and group
osLnx'cmd.chroot Run a command with a different root directory
osLnx'cmd.chkconfig System services (runlevel)
osLnx'cmd.cksum Print CRC checksum and byte counts
osLnx'cmd.clear Clear terminal screen
osLnx'cmd.cmp Compare two files
osLnx'cmd.comm Compare two sorted files line by line
osLnx'cmd.command Run a command - ignoring shell functions •
osLnx'cmd.continue Resume the next iteration of a loop •
osLnx'cmd.cp Copy one or more files to another location
osLnx'cmd.cron Daemon to execute scheduled commands
osLnx'cmd.crontab Schedule a command to run at a later time
osLnx'cmd.csplit Split a file into context-determined pieces
osLnx'cmd.cut Divide a file into several parts
d
osLnx'cmd.date Display or change the date & time
osLnx'cmd.dc Desk Calculator
osLnx'cmd.dd Convert and copy a file, write disk headers, boot records
osLnx'cmd.ddrescue Data recovery tool
osLnx'cmd.declare Declare variables and give them attributes •
osLnx'cmd.df Display free disk space
osLnx'cmd.diff Display the differences between two files
osLnx'cmd.diff3 Show differences among three files
osLnx'cmd.dig DNS lookup
osLnx'cmd.dir Briefly list directory contents
osLnx'cmd.dircolors Colour setup for `ls'
osLnx'cmd.dirname Convert a full pathname to just a path
osLnx'cmd.dirs Display list of remembered directories
osLnx'cmd.dmesg Print kernel & driver messages
osLnx'cmd.du Estimate file space usage
e
osLnx'cmd.echo Display message on screen •
osLnx'cmd.egrep Search file(s) for lines that match an extended expression
osLnx'cmd.eject Eject removable media
osLnx'cmd.enable Enable and disable builtin shell commands •
osLnx'cmd.env Environment variables
osLnx'cmd.ethtool Ethernet card settings
osLnx'cmd.eval Evaluate several commands/arguments
osLnx'cmd.exec Execute a command
osLnx'cmd.exit Exit the shell
osLnx'cmd.expect Automate arbitrary applications accessed over a terminal
osLnx'cmd.expand Convert tabs to spaces
osLnx'cmd.export Set an environment variable
osLnx'cmd.expr Evaluate expressions
f
osLnx'cmd.false Do nothing, unsuccessfully
osLnx'cmd.fdformat Low-level format a floppy disk
osLnx'cmd.fdisk Partition table manipulator for Linux
osLnx'cmd.fg Send job to foreground
osLnx'cmd.fgrep Search file(s) for lines that match a fixed string
osLnx'cmd.file Determine file type
osLnx'cmd.find Search for files that meet a desired criteria
osLnx'cmd.fmt Reformat paragraph text
osLnx'cmd.fold Wrap text to fit a specified width.
osLnx'cmd.for Expand words, and execute commands
osLnx'cmd.format Format disks or tapes
osLnx'cmd.free Display memory usage
osLnx'cmd.fsck File system consistency check and repair
osLnx'cmd.ftp File Transfer Protocol
osLnx'cmd.function Define Function Macros
osLnx'cmd.fuser Identify/kill the process that is accessing a file
g
osLnx'cmd.gawk Find and Replace text within file(s)
osLnx'cmd.getopts Parse positional parameters
osLnx'cmd.grep Search file(s) for lines that match a given pattern
osLnx'cmd.groupadd Add a user security group
osLnx'cmd.groupdel Delete a group
osLnx'cmd.groupmod Modify a group
osLnx'cmd.groups Print group names a user is in
osLnx'cmd.gzip Compress or decompress named file(s)
h
osLnx'cmd.hash Remember the full pathname of a name argument
osLnx'cmd.head Output the first part of file(s)
osLnx'cmd.help Display help for a built-in command •
osLnx'cmd.history Command History
osLnx'cmd.hostname Print or set system name
i
osLnx'cmd.iconv Convert the character set of a file
osLnx'cmd.id Print user and group id's
osLnx'cmd.if Conditionally perform a command
osLnx'cmd.ifconfig Configure a network interface
osLnx'cmd.ifdown Stop a network interface
osLnx'cmd.ifup Start a network interface up
osLnx'cmd.import Capture an X server screen and save the image to file
osLnx'cmd.install Copy files and set attributes
j
osLnx'cmd.jobs List active jobs •
osLnx'cmd.join Join lines on a common field
k
osLnx'cmd.kill Stop a process from running
osLnx'cmd.killall Kill processes by name
l
osLnx'cmd.less Display output one screen at a time
osLnx'cmd.let Perform arithmetic on shell variables •
osLnx'cmd.ln Create a symbolic link to a file
osLnx'cmd.local Create variables •
osLnx'cmd.locate Find files
osLnx'cmd.logname Print current login name
osLnx'cmd.logout Exit a login shell •
osLnx'cmd.look Display lines beginning with a given string
osLnx'cmd.lpc Line printer control program
osLnx'cmd.lpr Off line print
osLnx'cmd.lprint Print a file
osLnx'cmd.lprintd Abort a print job
osLnx'cmd.lprintq List the print queue
osLnx'cmd.lprm Remove jobs from the print queue
osLnx'cmd.ls List information about file(s)
osLnx'cmd.lsof List open files
m
osLnx'cmd.make Recompile a group of programs
osLnx'cmd.man Help manual
osLnx'cmd.mkdir Create new folder(s)
osLnx'cmd.mkfifo Make FIFOs (named pipes)
osLnx'cmd.mkisofs Create an hybrid ISO9660/JOLIET/HFS filesystem
osLnx'cmd.mknod Make block or character special files
osLnx'cmd.more Display output one screen at a time
osLnx'cmd.mount Mount a file system
osLnx'cmd.mtools Manipulate MS-DOS files
osLnx'cmd.mtr Network diagnostics (traceroute/ping)
osLnx'cmd.mv Move or rename files or directories
osLnx'cmd.mmv Mass Move and rename (files)
n
osLnx'cmd.netstat Networking information
osLnx'cmd.nice Set the priority of a command or job
osLnx'cmd.nl Number lines and write files
osLnx'cmd.nohup Run a command immune to hangups
osLnx'cmd.notify-send Send desktop notifications
osLnx'cmd.nslookup Query Internet name servers interactively
o
osLnx'cmd.open Open a file in its default application
osLnx'cmd.op Operator access
p
osLnx'cmd.passwd Modify a user password
osLnx'cmd.paste Merge lines of files
osLnx'cmd.pathchk Check file name portability
osLnx'cmd.ping Test a network connection
osLnx'cmd.pkill Stop processes from running
osLnx'cmd.popd Restore the previous value of the current directory
osLnx'cmd.pr Prepare files for printing
osLnx'cmd.printcap Printer capability database
osLnx'cmd.printenv Print environment variables
osLnx'cmd.printf Format and print data •
osLnx'cmd.ps Process status
osLnx'cmd.pushd Save and then change the current directory
osLnx'cmd.pwd Print Working Directory
q
osLnx'cmd.quota Display disk usage and limits
osLnx'cmd.quotacheck Scan a file system for disk usage
osLnx'cmd.quotactl Set disk quotas
r
osLnx'cmd.ram ram disk device
osLnx'cmd.rcp Copy files between two machines
osLnx'cmd.read Read a line from standard input •
osLnx'cmd.readarray Read from stdin into an array variable •
osLnx'cmd.readonly Mark variables/functions as readonly
osLnx'cmd.reboot Reboot the system
osLnx'cmd.rename Rename files
osLnx'cmd.renice Alter priority of running processes
osLnx'cmd.remsync Synchronize remote files via email
osLnx'cmd.return Exit a shell function
osLnx'cmd.rev Reverse lines of a file
osLnx'cmd.rm Remove files
osLnx'cmd.rmdir Remove folder(s)
osLnx'cmd.rsync Remote file copy (Synchronize file trees)
s
osLnx'cmd.screen Multiplex terminal, run remote shells via ssh
osLnx'cmd.scp Secure copy (remote file copy)
osLnx'cmd.sdiff Merge two files interactively
osLnx'cmd.sed Stream Editor
osLnx'cmd.select Accept keyboard input
osLnx'cmd.seq Print numeric sequences
osLnx'cmd.set Manipulate shell variables and functions
osLnx'cmd.sftp Secure File Transfer Program
osLnx'cmd.shift Shift positional parameters
osLnx'cmd.shopt Shell Options
osLnx'cmd.shutdown Shutdown or restart linux
osLnx'cmd.sleep Delay for a specified time
osLnx'cmd.slocate Find files
osLnx'cmd.sort Sort text files
osLnx'cmd.source Run commands from a file `.'
osLnx'cmd.split Split a file into fixed-size pieces
osLnx'cmd.ssh Secure Shell client (remote login program)
osLnx'cmd.strace Trace system calls and signals
osLnx'cmd.su Substitute user identity
osLnx'cmd.sudo Execute a command as another user
osLnx'cmd.sum Print a checksum for a file
osLnx'cmd.suspend Suspend execution of this shell •
osLnx'cmd.symlink Make a new name for a file
osLnx'cmd.sync Synchronize data on disk with memory
t
osLnx'cmd.tail Output the last part of file
osLnx'cmd.tar Tape ARchiver
osLnx'cmd.tee Redirect output to multiple files
osLnx'cmd.test Evaluate a conditional expression
osLnx'cmd.time Measure Program running time
osLnx'cmd.times User and system times
osLnx'cmd.touch Change file timestamps
osLnx'cmd.top List processes running on the system
osLnx'cmd.traceroute Trace Route to Host
osLnx'cmd.trap Run a command when a signal is set(bourne)
osLnx'cmd.tr Translate, squeeze, and/or delete characters
osLnx'cmd.true Do nothing, successfully
osLnx'cmd.tsort Topological sort
osLnx'cmd.tty Print filename of terminal on stdin
osLnx'cmd.type Describe a command •
u
osLnx'cmd.ulimit Limit user resources •
osLnx'cmd.umask Users file creation mask
osLnx'cmd.umount Unmount a device
osLnx'cmd.unalias Remove an alias •
osLnx'cmd.uname Print system information
osLnx'cmd.unexpand Convert spaces to tabs
osLnx'cmd.uniq Uniquify files
osLnx'cmd.units Convert units from one scale to another
osLnx'cmd.unset Remove variable or function names
osLnx'cmd.unshar Unpack shell archive scripts
osLnx'cmd.until Execute commands (until error)
osLnx'cmd.uptime Show uptime
osLnx'cmd.useradd Create new user account
osLnx'cmd.userdel Delete a user account
osLnx'cmd.usermod Modify user account
osLnx'cmd.users List users currently logged in
osLnx'cmd.uuencode Encode a binary file
osLnx'cmd.uudecode Decode a file created by uuencode
v
osLnx'cmd.v Verbosely list directory contents (`ls -l -b')
osLnx'cmd.vdir Verbosely list directory contents (`ls -l -b')
osLnx'cmd.vi Text Editor
osLnx'cmd.vmstat Report virtual memory statistics
w
osLnx'cmd.wait Wait for a process to complete •
osLnx'cmd.watch Execute/display a program periodically
osLnx'cmd.wc Print byte, word, and line counts
osLnx'cmd.whereis Search the user's $path, man pages and source files for a program
osLnx'cmd.which Search the user's $path for a program file
osLnx'cmd.while Execute commands
osLnx'cmd.who Print all usernames currently logged in
osLnx'cmd.whoami Print the current user id and name (`id -un')
osLnx'cmd.wget Retrieve web pages or files via HTTP, HTTPS or FTP
osLnx'cmd.write Send a message to another user
x
osLnx'cmd.xargs Execute utility, passing constructed argument list(s)
osLnx'cmd.xdg-open Open a file or URL in the user's preferred application.
osLnx'cmd.yes Print a string until interrupted
osLnx'cmd.. Run a command script in the current shell
osLnx'cmd.!! Run the last command again
osLnx'cmd.### Comment / Remark
Commands marked • are bash built-ins, these are available under all shells.
[http://ss64.com/bash/]

osLnx'shell.Bash

name::
* McsEngl.osLnx'shell.Bash@cptItsoft,
* McsEngl.Bash-shell@cptItsoft,

_DESCRIPTION:
Bash is a popular text-based shell and command-language. It is the default shell included within Ubuntu and other Linux distros, and in macOS. Users type commands into a shell to execute scripts and/or run commands and tools to accomplish many tasks.
[https://docs.microsoft.com/el-gr/windows/wsl/faq#what-is-bash]
===
* BASH: the default shell provided with Linux-Mandrake, Bash,

osLnx'compilation

name::
* McsEngl.osLnx'compilation@cptItsoft,

./configure:
runs the configure file in current directory

make:
runs compilation

make install:
does the installation.

osLnx'doing

name::
* McsEngl.osLnx'doing@cptItsoft,

_DEFINITION:
the functions we can do with the OS.

osLnx'PROGRAM-INSTALLATION

name::
* McsEngl.osLnx'PROGRAM-INSTALLATION@cptItsoft,

UBUNTU:
* system/...synaptic
* Right click on the file and chose open with "GDebi Package Installer".

osLnx'PROGRAM-EXECUTION

name::
* McsEngl.osLnx'PROGRAM-EXECUTION@cptItsoft,
* McsEngl.osLnx'execute-program@cptItsoft,
* McsEngl.osLnx'load-program@cptItsoft,
* McsEngl.osLnx'run-program@cptItsoft,

_UBUNTU:
1. DASH (super-key), write name of program
2. terminal (ctrl+alt+t) write name of program.

osLnx'FILE-MANAGEMENT

name::
* McsEngl.osLnx'FILE-MANAGEMENT@cptItsoft,
* McsEngl.ubuntu'nautilus@cptItsoft,

_UBUNTU:
* custom: super+N,

_SHORTCUT:
This list may not be exhaustive, feel free to edit this answer to add more if I have missed any out. All the following work in Nautilus 3.6 (as shipped with Ubuntu 13.04):

New tab Ctrl+T

New window Ctrl+N

New folder Shift+Ctrl+N

Open folder in new tab Shift+Return

Properties Alt+Return

Close window Ctrl+W

Close all windows (quit) Ctrl+Q

Make link Ctrl+M

Add bookmark Ctrl+D

Edit bookmarks Ctrl+B

Undo Ctrl+Z

Redo Ctrl+Y

Cut Ctrl+X

Copy Ctrl+C

Paste Ctrl+V

Select all Ctrl+A

Select items matching Ctrl+S

Invert selection Shift+Ctrl+I

Show hidden files Ctrl+H

Zoom in Ctrl++

Zoom out Ctrl+-

Normal size Ctrl+0

List view Ctrl+1

Icons view Ctrl+2

Go to home directory Alt+Home

Go to parent directory Alt+Up Arrow

Go back Alt+Left Arrow

Go forward Alt+Right Arrow

Go to specified location Ctrl+L

Search files (find) Ctrl+F
[http://askubuntu.com/questions/293985/what-are-the-new-nautilus-3-6-shortcuts-in-ubuntu-13-04]

osLnx'file_content:
_cmd: cat filename
// print the contents of one or more files to the screen.

osLnx'SYSTEM-MANAGEMENT

name::
* McsEngl.osLnx'SYSTEM-MANAGEMENT@cptItsoft,

osLnx'DISTANCE-LOGING

name::
* McsEngl.osLnx'DISTANCE-LOGING@cptItsoft,

_Ubuntu:
vnc
81.186.147.145:5901
- filezilla: sftp, 8022.

FileZilla (from windows):
server: gymeleou.dyndns.org
username: gymeleou
password: ...
port: 8022
τύπος σύνδεσης: ftp over ssh (sftp)

Αν το δοκιμάζεις από Ubuntu, τότε δεν χρειάζεται καν ο filezilla, μπορείς να συνδεθείς και από το τοποθεσίες => σύνδεση στον εξυπηρετητή => τύπος υπηρεσίας: ssh.

Κατά τη σύνδεση θα σε ρωτήσει αν εμπιστεύεσαι το κλειδί, αλλά απλά πατάς "Ναι", δεν χρειάζεται να εισάγεις κάποιο κλειδί.

osLnx'USER-MANAGEMENT

name::
* McsEngl.osLnx'USER-MANAGEMENT@cptItsoft,

The concept of users and groups is extremely important, for it has a direct influence on all other concepts that this chapter will introduce.
Linux is a true multi-user system, so in order to use your Linux machine you must have an account on it. When you created a user at installation time you had, in fact, created a user account. You may remember you were prompted for the following items:
the "real name" of the user (in fact, whatever you want), a login name, a password (you did put one, didn't you? :) ).
The two important parameters here are the login name (commonly abbreviated by login) and the password. These are what you will use in order to connect to the system.
Another action which occurred when creating a user account is the creation of a group. By default, the installation program will have created one group per user. As we will see later, groups are useful when you have to share files between several people. A group can therefore hold as many users as you wish, and it's very common to see such a separation in large systems. For example: In a university you can have one group per department, another group for teachers, and so on. The reverse is also true: a user can be member of one or more groups. A math teacher, for example, can be a member of the teachers group and also be in the group of his beloved math students.
All this does not say how you can log in. Here it comes.
If you have chosen to have the graphical interface upon bootup, your startup screen will look similar to figure 8.1.
Figure 8.1 Graphical mode login session
In order to log in, you must enter your login name into the Login: text field, then enter your password into the password field. Note that you'll have to type your password blindly: there will be no echo into the text field.
If you are in console mode, your screen will look similar to figure 4.2.
Figure 4.2 Console mode login session
You will then have to enter your login name at the Login: prompt and press Return, after which the login program (called, surprise surprise, login) will display a Password: prompt, and you will obey by typing the password for this account -- always blindly!
Note that you can log in several times with the same account, on additional consoles and under X. Each session that you open is independent, and it's even possible to have several X sessions. By default, Linux-Mandrake has six virtual consoles in addition to the one reserved to the graphical interface. You can switch to any of them by typing the key sequence Ctrl-Alt-F<n>, where <n> is the number of the console which you want to switch to. In general, the graphical interface is on console number 7.
In addition to the creation of user accounts, you will also have noticed that during the install, DrakX (or the program you used) will have prompted you for the password of a very special user: root. This user is special for a simple reason: it's the account normally held by the system administrator which will most likely be you. For your system's security, it is very important that the root account always be protected by a good password.
If you regularly login as root it is very easy to make a mistake which can render your system unusable; only one mistake can do it. In particular, if you have not created a password for the root account any user can alter any part of your system. This is obviously not a very good idea.
It is worth mentioning that internally, the system does not identify you with your login name but with a unique number assigned to this login name: the user ID (UID for short). Similarly, every group is identified by its group ID (GID) and not its name.
[Mandrake 7.0 docs]

osLnx'user.UBUNTU

name::
* McsEngl.osLnx'user.UBUNTU@cptItsoft,

OBUNTU 8.04:
nikkas 56789
root 56789nk

osLnx'doing.CONFIGURING

name::
* McsEngl.osLnx'doing.CONFIGURING@cptItsoft,
* McsEngl.osLnx'settings@cptItsoft,

_SPECIFIC:
* STARTUP-PROCEDURE:
* HARDWARE-INSTALLATION:
HARD-DISK-INSTALLATION
* SOFTWARE-INSTALLATION
* INTERNET-CONNECTION

STARTUP-PROCEDURE:
* In the Unix tradition, there are two system startup schemes: the BSD scheme and the "System V" scheme, both named after the Unix system which implemented them first (resp. Berkeley Software Distribution and AT&T Unix System V). The BSD scheme is the simplest, but the System V scheme, although less easy to understand (which is what this chapter is for), is markedly more flexible to use.
When the system starts, after the kernel has configured everything and mounted the root filesystem, it starts the /sbin/init program. init is the father of all processes of the system, and it is responsible for taking the system to the desired runlevel. We will look at runlevels in the next section.
The init configuration file is /etc/inittab. This file has its own manual page (man inittab), but here we will describe only a few of the instructions.
[Mandrake 7.0 doc]

SUSE

/etc/lilo.conf:
* contains the boot sequence

The KDE control center (shown figure 5.25) brings together all the aspects of the KDE configuration.

INTERNET-CONECTION:
* Configuring an Internet connection using two tools: Kppp and LinuxConf.

HARD-DISK-INSTALATION:
* /etc/fstab add line of the disk you added. /windows/F filesystem
* create directory: /windows/F

osLnx'doing.INSTALLING

name::
* McsEngl.osLnx'doing.INSTALLING@cptItsoft,
* McsEngl.osLnx'installing@cptItsoft,

_ADDRESS.WPG:
* http://www.linuxliveusb.com//
* http://www.pendrivelinux.com/put-ubuntu-10-04-on-flash-drive-using-windows//
* https://help.ubuntu.com/community/WindowsDualBoot,

TYPES:
1) ON A DIFFERENT PARTITION:
2) ON WINDOWS: This installation mode is undoubtedly the easiest, but, as has already been mentioned, it has its disadvantages:
- it is slow in comparison with a real installation: loopback mounting of a file (this is the method used) is not as fast as a filesystem located on a dedicated partition;
- if you have to re-install Windows, your Linux-Mandrake system will also be lost...

osLnx'PARTITION-OF-DISK

name::
* McsEngl.osLnx'PARTITION-OF-DISK@cptItsoft,

For Ubuntu only in ONE disk:
1. delete previous partitions.
2. Primary /boot, 500MB, Ext2. the boot partition. This is where programs critical for booting the system will reside.
3. /, the root directory. 20.000 Ext4, The bulk of the programs used for running the system will be installed here.
4. Swap, 5000 unformatted disk space for use as virtual memory.
5. /home, the partition where your home directory will be located. In the course of using the system, files and folders you create will reside in various folders here.
[http://www.linuxbsdos.com/2011/05/04/manual-disk-partitioning-guide-for-ubuntu-11]

Δημιουργία ΛΟΓΙΚΟΥ 50 GB
2 SWAP
18 HOME
30 ROOT

osLnx'RECOVERING-UBUNTU-AFTER-WIN-INSTALLATION

name::
* McsEngl.osLnx'RECOVERING-UBUNTU-AFTER-WIN-INSTALLATION@cptItsoft,

* https://help.ubuntu.com/community/RecoveringUbuntuAfterInstallingWindows:
* Recovering Ubuntu after installing Windows
1. Boot the Desktop/Live CD.
2. Open a terminal (Applications -> Accessories -> Terminal)
3. Start grub as root with the following command :
* sudo grub
4. You will get a grub prompt (see below) which we will use to find the root partition and install grub to the MBR (hd0,0)
Type the following and press enter: find /boot/grub/stage1
Using this information, set the root device: grub> root (hd1,4)
Install Grub ON first disk: grub> setup (hd0)
Exit Grub: grub> quit
5. Reboot (to hard drive). Grub should be installed and both Ubuntu and Windows should have been automatically detected.

As a standalone cd/floppy/usb

Download Super Grub Disk (http://forjamari.linex.org/projects/supergrub/)

Burn into a cdrom (better) or a floppy

Boot from it

Select: GRUB => MBR & !LINUX! (>2) MANUAL |8-)

Select the Linux or Grub installation you want to restore.

You see the message: SGD has done it!

Reboot

You're done.

osLnx'doing.STARTUP

name::
* McsEngl.osLnx'doing.STARTUP@cptItsoft,

osLnx'startup.UBUNTU

name::
* McsEngl.osLnx'startup.UBUNTU@cptItsoft,

ΑΥΤΟΜΑΤΗ_ΕΙΣΟΔΟΣ:
* Σύστημα/ΔιαχείρισηΣυστήματος/ΠροτιμήσειςΠαραθύρουΕισόδου: ασφάλεια, ενεργοποίηση αυτόματης εισόδου, χρήστης.

osLnx'editor

name::
* McsEngl.osLnx'editor@cptItsoft,

SPECIFIC:
* editor
* gedit
* kedit
* kwright
* vi

osLnx'error

name::
* McsEngl.osLnx'error@cptItsoft,

Errors: Linux System Errors

When system requests fail, error code are returned. To understand the nature of the error these codes need to be interpreted. They are recorded in:-
/usr/include/asm/errno.h
Here is a copy of that file as of Aug 2004 on RedHat 7.3
#define EPERM 1 /* Operation not permitted */
#define ENOENT 2 /* No such file or directory */
#define ESRCH 3 /* No such process */
#define EINTR 4 /* Interrupted system call */
#define EIO 5 /* I/O error */
#define ENXIO 6 /* No such device or address */
#define E2BIG 7 /* Arg list too long */
#define ENOEXEC 8 /* Exec format error */
#define EBADF 9 /* Bad file number */
#define ECHILD 10 /* No child processes */
#define EAGAIN 11 /* Try again */
#define ENOMEM 12 /* Out of memory */
#define EACCES 13 /* Permission denied */
#define EFAULT 14 /* Bad address */
#define ENOTBLK 15 /* Block device required */
#define EBUSY 16 /* Device or resource busy */
#define EEXIST 17 /* File exists */
#define EXDEV 18 /* Cross-device link */
#define ENODEV 19 /* No such device */
#define ENOTDIR 20 /* Not a directory */
#define EISDIR 21 /* Is a directory */
#define EINVAL 22 /* Invalid argument */
#define ENFILE 23 /* File table overflow */
#define EMFILE 24 /* Too many open files */
#define ENOTTY 25 /* Not a typewriter */
#define ETXTBSY 26 /* Text file busy */
#define EFBIG 27 /* File too large */
#define ENOSPC 28 /* No space left on device */
#define ESPIPE 29 /* Illegal seek */
#define EROFS 30 /* Read-only file system */
#define EMLINK 31 /* Too many links */
#define EPIPE 32 /* Broken pipe */
#define EDOM 33 /* Math argument out of domain of func */
#define ERANGE 34 /* Math result not representable */
#define EDEADLK 35 /* Resource deadlock would occur */
#define ENAMETOOLONG 36 /* File name too long */
#define ENOLCK 37 /* No record locks available */
#define ENOSYS 38 /* Function not implemented */
#define ENOTEMPTY 39 /* Directory not empty */
#define ELOOP 40 /* Too many symbolic links encountered */
#define EWOULDBLOCK EAGAIN /* Operation would block */
#define ENOMSG 42 /* No message of desired type */
#define EIDRM 43 /* Identifier removed */
#define ECHRNG 44 /* Channel number out of range */
#define EL2NSYNC 45 /* Level 2 not synchronized */
#define EL3HLT 46 /* Level 3 halted */
#define EL3RST 47 /* Level 3 reset */
#define ELNRNG 48 /* Link number out of range */
#define EUNATCH 49 /* Protocol driver not attached */
#define ENOCSI 50 /* No CSI structure available */
#define EL2HLT 51 /* Level 2 halted */
#define EBADE 52 /* Invalid exchange */
#define EBADR 53 /* Invalid request descriptor */
#define EXFULL 54 /* Exchange full */
#define ENOANO 55 /* No anode */
#define EBADRQC 56 /* Invalid request code */
#define EBADSLT 57 /* Invalid slot */

#define EDEADLOCK EDEADLK

#define EBFONT 59 /* Bad font file format */
#define ENOSTR 60 /* Device not a stream */
#define ENODATA 61 /* No data available */
#define ETIME 62 /* Timer expired */
#define ENOSR 63 /* Out of streams resources */
#define ENONET 64 /* Machine is not on the network */
#define ENOPKG 65 /* Package not installed */
#define EREMOTE 66 /* Object is remote */
#define ENOLINK 67 /* Link has been severed */
#define EADV 68 /* Advertise error */
#define ESRMNT 69 /* Srmount error */
#define ECOMM 70 /* Communication error on send */
#define EPROTO 71 /* Protocol error */
#define EMULTIHOP 72 /* Multihop attempted */
#define EDOTDOT 73 /* RFS specific error */
#define EBADMSG 74 /* Not a data message */
#define EOVERFLOW 75 /* Value too large for defined data type */
#define ENOTUNIQ 76 /* Name not unique on network */
#define EBADFD 77 /* File descriptor in bad state */
#define EREMCHG 78 /* Remote address changed */
#define ELIBACC 79 /* Can not access a needed shared library */
#define ELIBBAD 80 /* Accessing a corrupted shared library */
#define ELIBSCN 81 /* .lib section in a.out corrupted */
#define ELIBMAX 82 /* Attempting to link in too many shared libraries */
#define ELIBEXEC 83 /* Cannot exec a shared library directly */
#define EILSEQ 84 /* Illegal byte sequence */
#define ERESTART 85 /* Interrupted system call should be restarted */
#define ESTRPIPE 86 /* Streams pipe error */
#define EUSERS 87 /* Too many users */
#define ENOTSOCK 88 /* Socket operation on non-socket */
#define EDESTADDRREQ 89 /* Destination address required */
#define EMSGSIZE 90 /* Message too long */
#define EPROTOTYPE 91 /* Protocol wrong type for socket */
#define ENOPROTOOPT 92 /* Protocol not available */
#define EPROTONOSUPPORT 93 /* Protocol not supported */
#define ESOCKTNOSUPPORT 94 /* Socket type not supported */
#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
#define EPFNOSUPPORT 96 /* Protocol family not supported */
#define EAFNOSUPPORT 97 /* Address family not supported by protocol */
#define EADDRINUSE 98 /* Address already in use */
#define EADDRNOTAVAIL 99 /* Cannot assign requested address */
#define ENETDOWN 100 /* Network is down */
#define ENETUNREACH 101 /* Network is unreachable */
#define ENETRESET 102 /* Network dropped connection because of reset */
#define ECONNABORTED 103 /* Software caused connection abort */
#define ECONNRESET 104 /* Connection reset by peer */
#define ENOBUFS 105 /* No buffer space available */
#define EISCONN 106 /* Transport endpoint is already connected */
#define ENOTCONN 107 /* Transport endpoint is not connected */
#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */
#define ETOOMANYREFS 109 /* Too many references: cannot splice */
#define ETIMEDOUT 110 /* Connection timed out */
#define ECONNREFUSED 111 /* Connection refused */
#define EHOSTDOWN 112 /* Host is down */
#define EHOSTUNREACH 113 /* No route to host */
#define EALREADY 114 /* Operation already in progress */
#define EINPROGRESS 115 /* Operation now in progress */
#define ESTALE 116 /* Stale NFS file handle */
#define EUCLEAN 117 /* Structure needs cleaning */
#define ENOTNAM 118 /* Not a XENIX named type file */
#define ENAVAIL 119 /* No XENIX semaphores available */
#define EISNAM 120 /* Is a named type file */
#define EREMOTEIO 121 /* Remote I/O error */
#define EDQUOT 122 /* Quota exceeded */

#define ENOMEDIUM 123 /* No medium found */
#define EMEDIUMTYPE 124 /* Wrong medium type */
[http://www-numi.fnal.gov/offline_software/srt_public_context/WebDocs/Errors/unix_system_errors.html]

osLnx'evaluation#cptCore546.107#

name::
* McsEngl.osLnx'evaluation@cptItsoft,

_DESCRIPTION:
Date: Tue, 21 Apr 1998 23:36:21 GMT From: Andrew Gardner <andrewgardner@technologist.com>
All kidding aside, there is a point that I was trying to make. Linux is a superior operating system. Unfortunately, the only people who seem to know about the reasons why are college students like me, or people who were college students like me. Because this is a discussion and not an article, I'll be brief. Here's a laundry list of why Linux is better for the web community and developers specifically: 1. Superior performance in server operations. NT simply can not stand up to Unix and Linux especially when it comes to peak performance issues on web servers, and most especially web based databases. Its the truth.
2. No one can get to your site if the server is down. And Linux is more stable than NT by far. Also, you can load and unload kernel modules without restarting the system, unlike NT which generally needs a reboot to load or unload drivers.
3. Remote administration. Its really hard to access your server from across the building, let alone across the country if you run an NT server. Any Linux server can be remotely maintained from any computer with a telnet app. NT has so few command line options, you really need to be there to fix it.
4. Linux is free. NT costs a lot of money. And Linux is commerically supported, if your organization needs it. Companies like Redhat Software make their money through providing support. Linux support is commercial through companies like Redhat, and free from almost every nerd on the planet (just like me).
Sorry to make such a long post, but I thought it was necessary to infuse a little intelligence into the discussion.

osLnx'version

name::
* McsEngl.osLnx'version@cptItsoft,

Installed in my computer on 2003-02-21:
* SuSE 8.0

The latest stable version of the Linux kernel is: 2.4.20 2002-11-28 23:54 UTC
The latest beta version of the Linux kernel is: 2.5.60 2003-02-10 19:05 UTC

osLnx'file-system

name::
* McsEngl.osLnx'file-system@cptItsoft,
* McsEngl.osLnx'fs@cptItsoft,

_DEFINITION:
* FILE-SYSTEM is the organization-method of INFORMATION in a strorage-device's-partition.
[hmnSngo.2003-02-26]

_GENERIC:
* UNIX-FILESYSTEM,

_WHOLE:
* As we already mentioned in the Install guide, every hard disk is divided into several partitions, and each of these partitions contains a filesystem. While Windows gives a letter to each of these filesystems (or actually, only to those it recognizes), Linux has a unique tree structure of files, and each filesystem is mounted at one location in the tree structure.
[Mandrake 7.0 doc]

osLnx'fs.SPECIFIC:
* ext2fs (EXTended 2 FileSystem)

./ = at current directory

osLnx'fs'FHS:
* Filesystem Hierarchy Standard. A document containing guidelines for a coherent file tree organisation on Unix systems. Linux-Mandrake complies with this standard.

osLnx'fs'FILE:
* Everything is a file: Here, "everything" really means everything. A hard disk, a partition on a hard disk, a parallel port, a connection to a web site, an Ethernet card, all these are files. Even directories are files. Linux recognizes many types of files in addition to the standard files and directories. Note that by file type here, we don't mean the type of the contents of a file: for Linux and any Unix system, a file, whether it be a GIF image, a binary file or whatever, is just a stream of bytes. Differentiating files according to their contents is left to applications.
[Mandrake 7.0 doc]
[We need another name to express this entity, because the name 'file' we use as the directory's complement. nikkas 2003-02-26]
* File-names begining with a PERIOD are not showed by the ls command.
* inode number, the file's unique number on a filesystem.

osLnx'fs'FILE'PERMITION:
*
- Read permission (r): For a file, this allows its contents to be read. For a directory, this allows its contained files to be displayed, if and only if the execute permission is also set for this directory;
- Write permission (w): For a file, this allows its contents to be modified. For a directory, it allows the files contained therein to be modified and deleted, even if the person is not owner of the file;
- eXecute permission (x): For a file, this allows for its execution (as a consequence, only executable files should normally have this permission set). For a directory, this allows a user to traverse it (which means going into or through that directory).

osLnx'fs'FILE'TYPE:
* We have already seen two types of files: regular files (-) and directories (d).
* Character mode files: These files are either
- special system files (such as /dev/null, which we have already seen), or
- peripherals (serial or parallel ports),
which share the particularity that their contents (if they have any) are not buffered (which means that they are not kept into memory). Such files are identified by the letter 'c'.
* Block mode files: These files are peripherals, and as opposed to character files, their contents are buffered. Files entering this category are, for example, hard disks, partitions on a hard disk, floppy drives, CDROM drives and so on. Files /dev/hda, /dev/sda5 are example of block mode files. On a ls -l output, these are identified by the letter 'b'.
* Symbolic links: These files are very common, and heavily used in the Linux-Mandrake system startup procedure (see chapter 18.0). As their name says, their purpose is to link files in a symbolic way, which means that such files may or may not point to an existing file. This will be explained later in this chapter. They are very frequently called "soft links", and are identified by an 'l'.
* Named pipes: In case you were wondering, yes, these are very similar to pipes used in shell commands, but with the particularity that these ones actually have names. Read on to learn more. They are very rare, however, and it's very unlikely that you will see one during your journey into the file tree. Just in case you do, the letter identifying them is 'p'.
* Sockets: This is the file type for all network connections. Only a few of them have names, though. What's more, there are different types of sockets and only one can be linked, but this is way beyond the scope of this book. Such files are identified by the letter 's'.

* sh = script file (like bat in DOS)
* Shareable and unshareable, static and variable data:
Data on a Unix system can be classified according to these two criteria. You will have guessed what they both mean: shareable data is data that can be common to several machines in a network, while unshareable data cannot be. Static data must not been modified in normal use, while variable data can be. As we explore the tree structure, we will classify the different directories into each of these categories.
Note that these classifications are only recommended. You are not obliged to follow them, but adopting these guidelines will greatly help you manage your system. Note, too, that the static/variable distinction only applies to the use of the system and not its configuration. If you install a program, you will obviously have to modify "normally" static directories, e.g. /usr.

osLnx'fs'COMMANDS:

osLnx'fs'INODE_TABLE:
* We should add that ext2fs, like all other Unix filesystems, stores files, whichever their type, in an inode table. One particularity is that a file is not identified by its name, but by an inode number. In fact, not every file has a name.

osLnx'fs'DIRECTORY

name::
* McsEngl.osLnx'fs'DIRECTORY@cptItsoft,
* McsEngl.osLnx'directory@cptItsoft,

* McsEngl.osLnx'directory@cptItsoft,

_DESCRIPTION:
* Directory is a special-file that contains a LIST of entries of other files.

osLnx'cmd.DIRECTORY::
* dir
* ls
* pwd
* mkdir: make directory,
* rmdir Remove folder(s),
* vdir:

osLnx'fs.dir.root:
* The root directory (/) contains the whole system hierarchy.

osLnx'fs.dir.bin (osLnx'bin_dir):
* contains mostly EXECUTABLE system-programs.

osLnx'fs.dir.dev (osLnx'dev_dir):
* device files.

osLnx'fs.dir.etc (osLnx'etc_dir):
* The /etc directory is one of the essential directories in any Unix system. It contains all the basic system configuration files. Please do not delete it to save space! Likewise, if you want to extend your tree structure over several partitions, remember that /etc must not be put on a separate partition: it is needed for system initialization.
* passwd and shadow file: these two files are text files which contains all the system users and their passwords (encrypted :)). shadow is only there are if you use shadow passwords, but it is the default installation option;
* inittab file: is the configuration file for the program init, which plays a fundamental role when starting up the system, as we will see later on;
* services file: this file contains a list of existing network services;
* profile: this is the shell configuration file, although certain shells use others. For example, Bash uses bashrc;
* crontab: configuration file of cron, the program responsible for periodic execution of commands.

osLnx'fs.dir.home (osLnx'home_dir):
* /home: contains all the personal directories of users of the system. This directory may or may not be shareable (some large networks make it shareable by NFS), and it is obviously variable.

osLnx'fs.dir.lib (osLnx'lib_dir):
* libraries

osLnx'fs.dir.mnt (osLnx'mnt_dir):
* /mnt: directory containing the mounting points for the temporary file systems. Variable, unshareable.

osLnx'fs.dir.opt (osLnx'opt_dir):
* /opt: this directory contains packages not required for system operation. It is recommended to place static files (binaries, libraries, manual pages, etc.) for such packets in /opt/package_name and their specific configuration files for the machine in /etc/opt.

osLnx'fs.dir.proc (osLnx'proc_dir):
* The /proc/sys subdirectory The role of this subdirectory is to report different kernel parameters, and to allow for changing in real time some of these parameters. As opposite to all other files in /proc, some files in this directory are writable, but for root only.
* Apart from the directories asociated to the different processes, /proc also contains a myriad of information on the hardware present in your machine.

osLnx'fs.dir.root (osLnx'root_dir):
* /root: personal directory of the Almighty. Variable, unshareable.

osLnx'fs.dir.sbin (osLnx'sbin_dir):
* /sbin: contains the system binaries essential to system startup, operable by root only. A normal user can also run them but will not get very far. Static, unshareable.

osLnx'fs.dir.usr (osLnx'usr_dir):
* files of general use to the users of a unix system.
* The /usr directory is the main application storage directory. All the binary files in this directory must not be required for the system startup or maintenance, since the /usr hierarchy is very often a separate filesystem. Given its often large size, /usr has its own hierarchy of subdirectories.
* /usr/local: this is the directory where you should install your personal applications. The installation program will have created the necessary hierarchy: lib/, man/, etc.

osLnx'fs.dir.var (osLnx'var_dir):
* /var: location for data which may be modified in real time by programs (e.g. the e-mail server, audit programs, the print server, etc.). All of /var is variable, but its different subdirectories may be shareable or unshareable.

osLnx'fl'file

name::
* McsEngl.osLnx'fl'file@cptItsoft,

osLnx'cmd.FILE::
* rm = remove|delete file,

osLnx'graphical-environment

name::
* McsEngl.osLnx'graphical-environment@cptItsoft,
* McsEngl.conceptItsoft1069.2,
* McsEngl.osLnx'gui@cptIt1069.2,
* McsEngl.osLnx'desktop'environment@cptIt1069.2,
* McsEngl.osLnx'graphical'userinterface@cptIt1069.2,

GENERIC:
* GUI

_FUNCTION:
* CONTROL-CENTER,
* FILE-MANAGER,
* FONT-MANAGER,
* SHORTCUTS,

_SPECIFIC:
* GNOME:
* KDE: the default graphical environment of Linux-Mandrake.

osLnx'GNOME

name::
* McsEngl.osLnx'GNOME@cptItsoft,

_DEFINITION:
* GNOME is a user-friendly desktop environment that includes its own complete set of applications and utilities.

GENERIC:
* LINUX-GUI

osLnx'gnome'SHORTCUT:
* Alt-F1 (or the Windows key) opens the Main Menu.

osLnx'gnome'STRUCTURE:
* A typical GNOME desktop consists of three areas:
1) The desktop, on which frequently used files and folders may be placed.
2) Panels across the top & bottom of the screen which are used to start applications and switch between desktops.
3) A tasklist to switch between currently running applications.
[Mandrake 9.0 tutorial]

osLnx'KDE

name::
* McsEngl.osLnx'KDE@cptItsoft,
* McsEngl.conceptItsoft1069.3,
* McsEngl.osLnx'k'desktop'environment@cptItsoft,

_DEFINITION:
* It is a desktop-environment.

_GENERIC:
* LINUX-GUI#cptItsoft1069.2#

osLnx'kde'CONTROL'PANEL:
* The KDE control center (shown figure 5.25) brings together all the aspects of the KDE configuration. You can access it directly from the K menu.

osLnx'kde'FILE'MANAGER:
* Click on the icon that looks like a button with a picture of a house on it. You can use this button to access files in your home directory using Konqueror, KDE's File Manager.
[Mandrake 9.0 tutorial]

osLnx'kde'FONT'MANAGER:

osLnx'kde'SHORTCUTS:
* Press Alt-F2 to get a mini command prompt to execute a single command.
* Press Alt-Tab to switch between apps and Ctrl-Tab to switch between desktops using the keyboard.
* Ctrl-F[1..8] Switch to a specific desktop

osLnx'kde'STRUCTURE:
* A typical KDE desktop consists of three areas:
1) The desktop, on which frequently used files and folders may be placed.
2) A kicker across the bottom of the screen which is used to start applications and switch between desktops.
3) A taskbar to switch between currently running applications.
[Mandrake 9.0 tutorial]

* A typical KDE desktop consists of three areas:
A panel at the bottom of the screen, used to start applications and switch between desktops. Among other things, it contains the Application Starter, a large "K" icon which displays a menu of applications to start when clicked.
A taskbar at the upper-left corner of the screen, used to switch between and manage currently running applications. Click on an application on the taskbar to zip to the application.
The desktop itself, on which frequently used files and folders may be placed. KDE provides multiple desktops, each of which has its own windows. Click on the numbered buttons on the panel to switch between desktops.
[Mandrake 7.0 docs]

osLnx'Kernel

name::
* McsEngl.osLnx'Kernel@cptItsoft,

_ADDRESS.WPG:
* https://kernelnewbies.org//
* https://kernelnewbies.org/KernelGlossary,

osLnx'LTSP

name::
* McsEngl.osLnx'LTSP@cptItsoft,
* McsEngl.conceptItsoft65.1,
* McsEngl.LTSP@cptItsoft,
* McsEngl.ltsp@cptItsoft65.1,
* McsEngl.linux-terminal-server-project-65.1@cptItsoft,
* McsEngl.linux-thin-client-65.1@cptItsoft,

_DEFINITION:
* Linux Terminal Server Project (LTSP) provides a way for you to build a server and then add diskless computers to the server thus creating a huge savings for an organization. To the user, they will not recognize that the computer they are at is without a hard drive. They typically notice the fast speed at which the workstation runs and the features that are available.
[http://beginlinux.com/server_training/126-linux-terminal-server/1053-ltsp-on-ubuntu-804] 2009-01-09

ltsp'ADMINISTRATOR

name::
* McsEngl.ltsp'ADMINISTRATOR@cptItsoft,

gksu nautilus: ανήγει το file-manager ως root/administrator.

ltsp'client

name::
* McsEngl.ltsp'client@cptItsoft,

ltsp.client.CDROM

name::
* McsEngl.ltsp.client.CDROM@cptItsoft,

F12: choose cdrom with net-boot.

ltsp.client.UBUNTU

name::
* McsEngl.ltsp.client.UBUNTU@cptItsoft,

1) Εχω ένα σταθμό εργασίας με ubuntu και θέλω να κάνει εκκίνηση από το
δίκτυο.
Ο σύνδεσμος που έχεις "http://appnr.com/install/grub-ipxe" δεν δουλεύει.
Τι κάνω?
===
Άνοιξε ένα τερματικό και δώσε:
sudo apt-get install grub-ipxe

ltsp'COMMAND

name::
* McsEngl.ltsp'COMMAND@cptItsoft,

AltF2= open dialog to run a command.

gksu nautilus: ανήγει το file-manager ως root/administrator.
Η αντίστοιχη εντολή της gksu στο τερματικό ονομάζεται sudo, δηλαδή κάνει δυνατή την εκτέλεση προγραμμάτων / εντολών με δικαιώματα διαχειριστή.

ltsp'Connected-client

name::
* McsEngl.ltsp'Connected-client@cptItsoft,

> Είθελα να μου υπενθυμίσεις! πως γίνεται "network boot" σε ένα ΚΑΙΝΟΥΡΓΙΟ υπολογιστή στο δίκτυο.
===
* http://ts.sch.gr/wiki/Linux/LTSP/Εκίνηση_από_το_δίκτυο,
Υποστήριξη από το BIOS
Εάν οι κάρτες δικτύου των σταθμών εργασίας είναι ενσωματωμένες στη μητρική πλακέτα και όχι επιπρόσθετες σε PCI slot, κατά πάσα πιθανότητα θα υποστηρίζουν εκκίνηση από το δίκτυο. Υπάρχει μια μικρή πιθανότητα να το υποστηρίζουν ακόμα κι αν είναι σε PCI slot, αλλά αυτό συμβαίνει μόνο σε πολύ ακριβές κάρτες και είναι σπάνιο.

Μπείτε στο BIOS των υπολογιστών και ορίστε όσες από τις παρακάτω ρυθμίσεις βρείτε:

Onboard H/W LAN: Enabled (για την ενεργοποίηση της κάρτας δικτύου της μητρικής) Lan-1st-Boot-Device02.jpg
Onboard LAN Boot ROM: Enabled (για την ενεργοποίηση της Boot ROM της κάρτας δικτύου), εναλλακτικά μπορεί να το βρείτε ως PXE: Enable
First Boot Device: LAN (για την επιλογή της κάρτας δικτύου ως 1ης στη σειρά εκκίνησης)
[http://ts.sch.gr/wiki/Linux/LTSP/%CE%95%CE%BA%CE%BA%CE%AF%CE%BD%CE%B7%CF%83%CE%B7_%CE%B1%CF%80%CF%8C_%CF%84%CE%BF_%CE%B4%CE%AF%CE%BA%CF%84%CF%85%CE%BF]
===
Αν έχει windows:
* http://ts.sch.gr/tech/win32-loader,
Αν έχει linux ή τίποτα:
* http://alkisg.mysch.gr/steki/index.php?topic=1451.0,

ltsp'REMOTE-ACCESS

name::
* McsEngl.ltsp'REMOTE-ACCESS@cptItsoft,

Δηλαδή:
server: gymeleou.dyndns.org
username: gymeleou
password: gymele59
port: 8022
τύπος σύνδεσης: ftp over ssh (sftp)

Αν το δοκιμάζεις από Ubuntu, τότε δεν χρειάζεται καν ο filezilla, μπορείς να συνδεθείς και από το τοποθεσίες => σύνδεση στον εξυπηρετητή => τύπος υπηρεσίας: ssh.

ltsp'Resource

name::
* McsEngl.ltsp'Resource@cptItsoft,

* http://ts.sch.gr/wiki/Linux/LTSP,

* http://www.ltsp.org/
* http://sourceforge.net/apps/mediawiki/ltsp/index.php?title=Main_Page

* https://help.ubuntu.com/community/UbuntuLTSP.

* \DATA1\data3INFO\OS\UBUNTU\Ubuntu0810LTSP.pdf.

* https://help.ubuntu.com/community/ThinClientHowto.

osLnx'organization

name::
* McsEngl.osLnx'organization@cptItsoft,

osLnx'Linux-foundation

name::
* McsEngl.osLnx'Linux-foundation@cptItsoft,

Linux Foundation quietly drops community representation
Jan. 20th, 2016 02:28 pm
[personal profile] mjg59
The Linux Foundation is an industry organisation dedicated to promoting, protecting and standardising Linux and open source software[1]. The majority of its board is chosen by the member companies - 10 by platinum members (platinum membership costs $500,000 a year), 3 by gold members (gold membership costs $100,000 a year) and 1 by silver members (silver membership costs between $5,000 and $20,000 a year, depending on company size). Up until recently individual members ($99 a year) could also elect two board members, allowing for community perspectives to be represented at the board level.

As of last Friday, this is no longer true. The by-laws were amended to drop the clause that permitted individual members to elect any directors. Section 3.3(a) now says that no affiliate members may be involved in the election of directors, and section 5.3(d) still permits at-large directors but does not require them[2]. The old version of the bylaws are here - the only non-whitespace differences are in sections 3.3(a) and 5.3(d).

These changes all happened shortly after Karen Sandler announced that she planned to stand for the Linux Foundation board during a presentation last September. A short time later, the "Individual membership" program was quietly renamed to the "Individual supporter" program and the promised benefit of being allowed to stand for and participate in board elections was dropped (compare the old page to the new one). Karen is the executive director of the Software Freedom Conservancy, an organisation involved in the vitally important work of GPL enforcement. The Linux Foundation has historically been less than enthusiastic about GPL enforcement, and the SFC is funding a lawsuit against one of the Foundation's members for violating the terms of the GPL. The timing may be coincidental, but it certainly looks like the Linux Foundation was willing to throw out any semblance of community representation just to ensure that there was no risk of someone in favour of GPL enforcement ending up on their board.

Much of the code in Linux is written by employees paid to do this work, but significant parts of both Linux and the huge range of software that it depends on are written by community members who now have no representation in the Linux Foundation. Ignoring them makes it look like the Linux Foundation is interested only in promoting, protecting and standardising Linux and open source software if doing so benefits their corporate membership rather than the community as a whole. This isn't a positive step.

[1] Article II of the bylaws
[2] Other than in the case of the TAB representative, an individual chosen by a board elected via in-person voting at a conference
[http://mjg59.dreamwidth.org/39546.html]

osLnx'process

name::
* McsEngl.osLnx'process@cptItsoft,

osLnx'Process'Tree:
* As with files, all processes that run on a Linux system are organized in the form of a tree, and each process has a number (its PID, Process ID), together with the number of its parent process (PPID, Parent Process ID).
This means that there is a process at the top of the tree structure, the equivalent of the root for filesystems: init (see Reference manual), which is always numbered 1. The next section will explain two commands, ps and pstree, which allow you to obtain information on a running process.
[Mandrake Linux 7.0]

osLnx'Signal:
* Every process in Unix can react to signals sent to it. There exist 31 different signals. For each of these signals, the process can reset the default behavior, except for two signals: signal number 9 (KILL), and signal number 19 (STOP).
Signal 9 kills a process irrevocably, without giving it the time to terminate properly. This is the signal you send to a process which is stuck or exhibits other problems. A full list of signals is available using the command kill -l.
[Mandrake Linux 7.0]

osLnx'ENVIRONMENT'VARIABLE

name::
* McsEngl.osLnx'ENVIRONMENT'VARIABLE@cptItsoft,

Processes have their environment variables and the shell allows you to view them directly, with the echo command. Some interesting variables are:
- 'HOME': This environment variable contains a string representing your home directory.
- 'PATH': This variable contains the list of all directories in which the shell should look for executables when you type a command. Note that unlike DOS, by default, a shell will not look for commands in the current directory!
- 'USERNAME': This variable contains your login name.
- 'UID': Contains your user ID.
- 'PS1': Contains the value for your prompt. It is often a combination of special sequences, you may read the bash(1) manual page for more information (also see chapter 11.0).

osLnx'program.SYSTEM

name::
* McsEngl.osLnx'program.SYSTEM@cptItsoft,

SPECIFIC:
* BOCHS (emulator)
* COMPRESSION
* RPM#cptItsoft1069.4: attSpe#
* USER-INTERFACE
* WINE (win to unix)#cptItsoft1069.4: attSpe#

osLnx'RPM

name::
* McsEngl.osLnx'RPM@cptItsoft,
* McsEngl.conceptItsoft1069.4,
* McsEngl.rpm@cptIt1069.4; red hat package management,

_DEFINITION:
* Πρόκειται για ένα ευέλικτο σύστημα ΔΙΑΧΕΙΡΙΣΗΣ-ΕΦΑΡΜΟΓΩΝ, που εισήχθη για πρώτη φορά στη διανομή της Red Hat, αλλά σήμερα χρησιμοποιείται από πολλούς μικρούς και μεγάλους διανομείς.

GENERIC:
* SOFTWARE-INSTALLATION

PROGRAMS:
The program which we will use is rpm (the RedHat Package Manager), a text mode program.
Several graphical versions of rpm are available: Kpackage (a KDE application), GnoRPM (an application for GNOME) and the new Linux-Mandrake application RPMDrake.

osLnx'rpm.CONSOLE:
* Assuming that you have an RPM called foo-1.0-1.i386.rpm in the directory, you can install it by entering the following command:
$ rpm -ivh foo-1.0-1.i386.rpm
If you want to upgrade a package (for example foo 1.1 has come out), you will have to use -Uvh instead of -ivh.

osLnx'rpm.KPACKAGE:
* Kpackage is the KDE package management program. This is the program with which KFM associates RPM packages: clicking on an RPM package in KFM will start Kpackage with this RPM, and here you will see the information on the package. Kpackage also supports Drag'n'Drop, and you can drag an RPM from KFM to an existing Kpackage window.

osLnx'WINE

name::
* McsEngl.osLnx'WINE@cptItsoft,
* McsEngl.conceptItsoft1069.5,
* McsEngl.pgmWine@cptItsoft,
* McsEngl.wine-program@cptIt1069.5,

_DEFINITION:
* Wine is an implementation of the Windows API, and can be used as a library to port Windows applications to Unix.

Installing Windows Applications Using Wine
To install Windows applications using Wine, follow these instructions:
1. Download the Windows application from any source (e.g. download.com). Download the .EXE (executable).
2. Place it in a convenient directory (e.g. the desktop, or home folder).
3. Open the terminal, and cd into the directory where the .EXE is located.
4. Type wine the-name-of-the-application.extension (e.g. wine realplayer.exe).
This will start the .EXE using Wine. If it is an installer, it should then run as it would in Windows. If the application asks for a directory to install the application to, select put it under \Program Files.

wine'MenuFont

name::
* McsEngl.wine'MenuFont@cptItsoft,

INCREASING_MENUFONT:
UBUNTU8.04:
At file "home/.wine/user.reg" I changed the first hex FROM "f5" TO "ee"
"MenuFont"=hex:ee,ff,ff,ff,00,00,00,00,00,00,00,00,00,00,00,00,90,01,00,00,00,\
00,00,a1,00,00,00,00,4d,00,53,00,20,00,53,00,68,00,65,00,6c,00,6c,00,20,00,\
44,00,6c,00,67,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,\
00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00

wine'HELP

name::
* McsEngl.wine'HELP@cptItsoft,

https://help.ubuntu.com/community/Wine

osLnx'program.SYSTEM.NO#cptIt97#

name::
* McsEngl.osLnx'program.SYSTEM.NO@cptItsoft,
* McsEngl.osLnx'PROGRAM@cptItsoft,
* McsEngl.osLnx'program.application@cptItsoft,

_GENERIC:
* UNIX-APPLICATION-PROGRAM
* APPLICATION-PROGRAM#cptIt97#

_SPECIFIC:
* TEXT-MODE PROGRAM,
* GRAPHICAL PROGRAM,

* XMMS = like winamp

How to Run a Java Program Script in Ubuntu

By Kristen Leigh Grubb, eHow Contributor
updated: January 27, 2010
I want to do this! What's This?

To run Java programs, or scripts, in Ubuntu and other Linux distributions, you must first have a Java runtime environment installed. There are open-source Java packages available, but since the Sun Java package is available from the "Universe" repository, it is best to install that package. The Sun Java package is the package created directly from the Sun Microsystems binaries. Once the Java packages are installed and set up correctly, the script can be run from the command line.
Difficulty: Easy
Instructions

1.
1

Open a terminal window. This is where you will type the following commands.
2.
2

Type the command "sudo apt-get install sun-java6-bin, sun-java6-jre" to install the proper Java packages.
3.
3

Type the command "sudo update-java-alternatives --set java-6-sun" to correctly set the correct packages as default.
4.
4

Type the command "cd <path_to_java_program>" to navigate to the directory where the Java script is held. Replace "<path_to_java_program>" with the correct path for your system.
5.
5

Type the command "java <java_program>" to execute the program. Replace "<java_program>" with the correct name of the script you want to run.

Read more: How to Run a Java Program Script in Ubuntu | eHow.com http://www.ehow.com/how_5919277_run-java-program-script-ubuntu.html#ixzz0xDBJkGbW

How do I write a script?

1. Make a new file and begin the file with the line#!/bin/bash

2. Write the commands you want to excecute in the file

3. Save the file

4. Make the file excecutable by issuing the command chmod +x <the_file> (or you can edit the files properties via nautilus)

And that's it!

Later you can run the script by typing ./<the_file> when you are in the right directory, or you can move the file to /usr/local/bin - then you can run the script by typing <the_file> anywhere.

osLnx'shortcut

name::
* McsEngl.osLnx'shortcut@cptItsoft,

C+A+K = change keyboard.

osLnx'shortcut'create

name::
* McsEngl.osLnx'shortcut'create@cptItsoft,
* McsEngl.osLnx'create.shortcut@cptItsoft,

_UBUNTU:
1) press the start/super button on your keyboard
2) type in "system settings" without the quotes into the search box
3) select "system settings" to bring up the system settings window
4) select "keyboard" from the available settings
5) go to the "shortcuts" tab and click the plus button to add a new shortcut
6) in the name field, type something like "nautilus"
7) in the command field, type "nautilus /home/userName" without the quotes,where
userName is the name of the logged on user. for example nautilus /home/samuel
8) after you apply, click to the right of your created shortcut, you should see new
accerelator". then type your key combination(i used ctrl+E) for instance
9) there you go with your new shortcut key for nautilus
[http://askubuntu.com/questions/58738/how-do-i-create-a-keyboard-shortcut-to-load-nautilus]

osLnx'shortcut.UBUNTU

name::
* McsEngl.osLnx'shortcut.UBUNTU@cptItsoft,

change_user: C+A+BackSpace

Open_terminal: C+A+t

osLnx'ResourceInfHmnn#cptResource843#

name::
* McsEngl.osLnx'ResourceInfHmnn@cptItsoft,

isrc.linux.GENERIC:
* http://www.linux.gr.
* http://www.linux.org/:
one of the very first sites dedicated to Linux, it contains a whole slew of links to other useful sites;
* https://kernelnewbies.org/
* https://lwn.net//

isrc.linux.PROGRAM.APPLICATION:
* http://freshmeat.net/:
if you want the latest applications in the Linux world, here is where you want to go;

isrc.linux.PROGRAM.SYSTEM:
* distributions or utilities.
* http://www.kernel.org/
* http://www.kde.org.
* ftp://ftp.kde.org

isrc.linux.AUDIO:
* http://audio.netpedia.net/aqht.html: Under Linux there is a Audio-Quality-HOWTO document that helps get audio up and running. AT time of writting it can be found

osLnx'source.DOCUMENTATION

name::
* McsEngl.osLnx'source.DOCUMENTATION@cptItsoft,
* McsEngl.osLnx'documentation@cptItsoft,
* McsEngl.osLnx'source.help@cptItsoft,

_SPECIFIC:
* MAN-COMMAND
* INFO-COMMAND
* HOW-TO
* DIRECTORY
* INTERNET-WEB
* INTERNET-NWESGROUP

INTERNET:
* http://www.linux-howto.com/: documentation, and documentation again :)
* http://sunsite.unc.edu/LDP
LDP: Linux Documentation Project. A nonprofit organisation which maintains Linux documentation. Its mostly known documents are HOWTOs, but it also maintains FAQs, and even a few books.

osLnx'source.UBUNTU

name::
* McsEngl.osLnx'source.UBUNTU@cptItsoft,

osLnx'variable.ENVIRONMENTAL

name::
* McsEngl.osLnx'variable.ENVIRONMENTAL@cptItsoft,
* McsEngl.osLnx'environmental'variable@cptItsoft,

.bashrc:
PATH=$PATH:/root/bin
export PATH

CREATE VARIABLE:
export ESTDIR=/home/awb/projects/1.4.1/speech_tools
export FESTVOXDIR=/home/awb/projects/festvox

VIEW VARIABLE:
$ echo $HOME

_SPECIFIC:
* Processes have their environment variables and the shell allows you to view them directly, with the echo command.
Some interesting variables are:
- 'HOME': This environment variable contains a string representing your home directory.
- 'PATH': This variable contains the list of all directories in which the shell should look for executables when you type a command. Note that unlike DOS, by default, a shell will not look for commands in the current directory!
- 'USERNAME': This variable contains your login name.
- 'UID': Contains your user ID.
- 'PS1': Contains the value for your prompt. It is often a combination of special sequences, you may read the bash(1) manual page for more information (also see chapter 11.0).

To have the shell print the value of a variable, you must put a $ in front of its name. Here, echo will help you:
$ echo Hello
Hello
$ echo $HOME
/home/joe
[Mandrake 7.0 docs]

osLnx'path

name::
* McsEngl.osLnx'path@cptItsoft,
* McsEngl.osLnx'path@cptItsoft,

_DESCRIPTION:
To change your $PATH you have to either edit ~/.profile (or ~/.bash_profile) for each user or global $PATH setting in /etc/profile.

Simply append another path to it like so:

/usr/local/bin:/usr/local/sbin:/custom/path
You can also do:

PATH = $PATH:/custom/path
[https://stackoverflow.com/questions/49857020/how-do-i-set-path-variables-in-linux-just-like-in-windows]

===
export PATH=`pwd`/out/gcc/Release

osLnx'variable.UBUNTU

name::
* McsEngl.osLnx'variable.UBUNTU@cptItsoft,

SPECIFIC

name::
* McsEngl.osLnx.specific@cptItsoft,

osLnx.AntiX

name::
* McsEngl.osLnx.AntiX@cptItsoft,

_DESCRIPTION:
* for old computer.

_ADDRESS.WPG:
* https://opensource.ellak.gr/2018/11/24/antix-to-linux-gia-palious-ipologistes-pou-dini-zoi-se-pc-i-laptop-akoma-ki-an-ine-antikes/,

osLnx.DISTRIBUTION

name::
* McsEngl.osLnx.DISTRIBUTION@cptItsoft,
* McsEngl.conceptItsoft1069.1,
* McsEngl.linux.distribution@cptItsoft,
* McsEngl.linux.distro@cptItsoft,
* McsEngl.osLnx.distro@cptItsoft,
====== lagoGreek:
* McsElln.λνξ.ΔΙΑΝΟΜΗ@cptItsoft,

_DEFINITION:
* Linux kernel is covered by the GNU Public License, and usually comes with many diffrent programs and utilities. These software bundles are called distributions.

_POPULARITY:
As for the "traditional" Linux desktop, the current DistroWatch list from fifth place to first, reads like this: Fedora, Debian, Mageia, Ubuntu, and Mint.
[http://www.zdnet.com/the-most-popular-end-user-linux-distributions-are-7000017223/]

SPECIFIC:
* Android##
* Caldera,
* Conectiva,
* Debian
* Fedora##
* MandrakeSoft,
* Mint##
* OS/X##
* Red Hat,
* SuSE,
* Ubuntu,

osLnx.EDUBUNTU

name::
* McsEngl.osLnx.EDUBUNTU@cptItsoft,

osLnx.LIGHTWEIGHT

_CREATED: {2013-12-15}

name::
* McsEngl.osLnx.LIGHTWEIGHT@cptItsoft,
* McsEngl.lightweight-linux-distro@cptItsoft,
* McsEngl.linux.lightweight@cptItsoft,

_SPECIFIC:
* Crunchbang Linux 10
* lubuntu##
* Macpup 528
* Peppermint OS Two
* Puppy Linux

osLnx.LUBUNTU

_CREATED: {2013-12-15}

name::
* McsEngl.osLnx.LUBUNTU@cptItsoft,
* McsEngl.lubuntu@cptItsoft,

_DESCRIPTION:
Lubuntu is a flavor of Ubuntu based on the Lightweight X11 Desktop Environment (LXDE), as its default GUI. The goal is to provide a very lightweight distribution, with all the advantages of the Ubuntu world (repositories, support, etc.). Lubuntu is targeted at "normal" PC and laptop users running on low-spec hardware. Such users may not know how to use command line tools, and in most cases they just don't have enough resources for all the bells and whistles of the "full-featured" mainstream distributions.

With many LXDE components, Lubuntu also uses well-known applications, such as Firefox, Openbox, Pidgin, to name a few. The Lubuntu project wiki contains more information on the project and the applications used available.
[http://lubuntu.net/]
===
Previous image 2 of 6 Next image
Gallery

1. Lubuntu 11.10

Lubuntu is an Ubuntu-based distribution which uses the lightweight LXDE desktop environment, as opposed to Ubuntu's attractive but increasingly resource-heavy Gnome. It's even lighter than Xubuntu, which in recent versions has recommended you have at least 512MB RAM. Lubuntu, on the other hand, can run in 128MB RAM, but we'd recommend at least 256MB.

A big advantage of Lubuntu is that it's based on Ubuntu, so you have access to Ubuntu's comprehensive support forums and compatible software. What's surprising about Lubuntu is how attractive it is, especially compared to old-school Puppy or minimalist Crunchbang. The default colour scheme is blue-grey, giving everything a smart, metallic look and, apart from some slightly amateurish icons in the main menu, it looks highly professional.

The default browser is Chromium, the open source browser on which Google's Chrome is based. For word processing and spreadsheet work you have the lightweight Abiword and Gnumeric packages, which may not be as powerful as OpenOffice or LibreOffice but start quickly and are far less resource-hungry. You have access to a huge amount of third-party software via the Synaptic Package Manager, which also makes everything easy to install.

If you're after a lightweight but thoroughly modern operating system, Lubuntu is it.
[http://www.expertreviews.co.uk/general/1289197/top-5-lightweight-linux-distros-for-older-pcs/3]

osLnx.LXLE

name::
* McsEngl.osLnx.LXLE@cptItsoft,

_ADDRESS.WPG:
* http://www.lxle.net/

_DESCRIPTION:
Full featured OS for an aging PC.

14.04.2 & 12.04.5 New Release

Light on resources; Heavy on functions.
Always based on Ubuntu/Lubuntu LTS.
Uses an optimized LXDE user interface.
Four familiar desktop layout paradigms.
Prudent full featured Apps preinstalled.
Latest stable versions of major software.
Added PPAs extends available software.
Weather, Aero Snap, Quick Launch
Random Wallpaper, Panel Trash access
Theme consistency throughout system.
100 gorgeous wallpapers preinstalled.
Numerous other tweaks/additions.
32 and 64 bit OS versions available.
Boots & is online in less than 1 minute.
[http://www.lxle.net/]

osLnx.MINT

_CREATED: {2013-12-22}

name::
* McsEngl.osLnx.MINT@cptItsoft,
* McsEngl.LinuxMint@cptItsoft,

_DESCRIPTION:
The purpose of Linux Mint is to produce a modern, elegant and comfortable operating system which is both powerful and easy to use.

Started in 2006, Linux Mint is now the 4th most widely used home operating system behind Microsoft Windows, Apple Mac OS and Canonical's Ubuntu.

Some of the reasons for the success of Linux Mint are:

It works out of the box, with full multimedia support and is extremely easy to use.
It's both free of cost and open source.
It's community-driven. Users are encouraged to send feedback to the project so that their ideas can be used to improve Linux Mint.
Based on Debian and Ubuntu, it provides about 30,000 packages and one of the best software managers.
It's safe and reliable. Thanks to a conservative approach to software updates, a unique Update Manager and the robustness of its Linux architecture, Linux Mint requires very little maintenance (no regressions, no antivirus, no anti-spyware...etc).
[http://www.linuxmint.com/about.php]

Is Linux Mint suitable for companies?
Yes. Linux Mint provides Long-Term Support (LTS) releases which are supported for a duration of 5 years.

lnxMnt'Resource

name::
* McsEngl.lnxMnt'Resource@cptItsoft,

_ADDRESS.WPG:
* https://linuxmint.com/documentation/user-guide/Cinnamon/english_18.0.pdf,

osLnx.UBUNTU (osUbt)

_CREATED: {2009-01-09}

name::
* McsEngl.osLnx.UBUNTU (osUbt)@cptItsoft,
* McsEngl.conceptItsoft1069.6,
* McsEngl.osUbt@cptItsoft,
* McsEngl.osUbuntu@cptItsoft,
* McsEngl.ubuntu@cptItsoft,

_DEFINITION:
Ubuntu (IPA: [u??bu?ntu?] in English,[2] [u`?u'ntu'] in Zulu) is a computer operating system based on Debian GNU/Linux, a popular Linux distribution. Its name comes from the Zulu word "ubuntu", translated as humanity, describing the ubuntu philosophy: "I am who I am because of those around me," a positive aspect of community. Ubuntu's goals include providing an up-to-date, stable operating system for the average user, with a strong focus on usability and ease of installation. Ubuntu has been rated as the most popular Linux distribution for the desktop, claiming approximately 30% of desktop Linux installations in 2007.[3]
[http://en.wikipedia.org/wiki/Ubuntu] 2009-01-09

{time.2013-03-23}:
=== China chooses Ubuntu as state-endorsed operating system
CNET 16 hours ago
Written by
Don Reisinger
Canonical, which runs Ubuntu, is working with the Chinese Ministry of Industry and Information Technology on the project. Don Reisinger.

osUbt'command-line

name::
* McsEngl.osUbt'command-line@cptItsoft,

osUbt'cmd.do-release-upgrade:
sudo do-release-upgrade
* update the-os.

osUbt'appnr

name::
* McsEngl.osUbt'appnr@cptItsoft,
* McsEngl.appnr@cptItsoft,

_DESCRIPTION:
Appnr is a web-based package browser that install applications on Ubuntu. This is a web interface for APT system, and the package is downloaded and installed from Ubuntu/Third-party repositories.
[http://blog.appnr.com/about/]

osUbt'Network

name::
* McsEngl.osUbt'Network@cptItsoft,

_ADDRESS.WPG:
* https://help.ubuntu.com/lts/serverguide/network-configuration.html,

osUbt'resourceInfHmn#cptResource843#

name::
* McsEngl.osUbt'resourceInfHmn@cptItsoft,

_ADDRESS.WPG:
* http://askubuntu.com/
* http://www.linuxliveusb.com//

osUbt'doing

name::
* McsEngl.osUbt'doing@cptItsoft,

osUbt'Remote-connecting

name::
* McsEngl.osUbt'Remote-connecting@cptItsoft,

_ADDRESS.WPG:
* http://www.technig.com/remote-access-windows-10-via-ubuntu-vise-versa//

osUbt.SERVER

name::
* McsEngl.osUbt.SERVER@cptItsoft,

_DESCRIPTION:
What's the difference between the server version and the desktop version?
Copied as-is from Ubuntu docs:

The first difference is in the CD contents. The "Server" CD avoids including what Ubuntu considers desktop packages (packages like X, Gnome or KDE), but does include server related packages (Apache2, Bind9 and so on). Using a Desktop CD with a minimal installation and installing, for example, apache2 from the network, one can obtain the exact same result that can be obtained by inserting the Server CD and installing apache2 from the CD-ROM.
The Ubuntu Server Edition installation process is slightly different from the Desktop Edition. Since by default Ubuntu Server doesn't have a GUI, the process is menu driven, very similar to the Alternate CD installation process.
Before 12.04, Ubuntu server installs a server-optimized kernel by default. Since 12.04, there is no difference in kernel between Ubuntu Desktop and Ubuntu Server since linux-image-server is merged into linux-image-generic.
For Ubuntu LTS releases before 12.04, the Ubuntu Desktop Edition only receives 3 years of support. This was increased to 5 years in Ubuntu LTS 12.04 In contrast, all Ubuntu LTS Server Edition releases are supported for 5 years.
[http://askubuntu.com/a/31082]

osLnx.EVOLUTING#cptCore546.171#

name::
* McsEngl.osLnx.EVOLUTING@cptItsoft,

{time.1991}:
He began his work in 1991 when he released version 0.02 and worked steadily until 1994 when version 1.0 of the Linux Kernel was released. The current full-featured version is 2.0, and development continues with several updates that are available for public use.
[1998feb]

os.MAC-OS-X (osx) {2001-}

_CREATED: {2013-12-15}

name::
* McsEngl.os.MAC-OS-X (osx) {2001-}@cptItsoft,
* McsEngl.conceptItsoft1111.2,
* McsEngl.mac-os-x@cptItsoft1111.2,
* McsEngl.os-x@cptItsoft1111.2, {2012}
* McsEngl.osx@cptItsoft1111.2,
* McsEngl.os-ten@cptItsoft1111.2,

_DESCRIPTION:
OS X /?o? ?s ?t?n/,[10] previously Mac OS X,[11] is a series of Unix-based graphical interface operating systems developed, marketed, and sold by Apple Inc. It is designed to run exclusively on Mac computers, having been pre-loaded on all Macs since 2002. It was the successor to Mac OS 9, released in 1999, the final release of the "classic" Mac OS, which had been Apple's primary operating system since 1984. The first version released was Mac OS X Server 1.0 in 1999, and a desktop version, Mac OS X v10.0 "Cheetah" followed on March 24, 2001. Previous releases of OS X were named after big cats; for example, OS X v10.8 was referred to as "Mountain Lion". However, with the announcement of OS X Mavericks this was dropped in favor of Californian landmarks.[12]

OS X, whose X is the Roman numeral for 10 and is a prominent part of its brand identity, is built on technologies developed at NeXT between the second half of the 1980s and Apple's purchase of the company in late 1996. The 'X' is also used to emphasize the relatedness between OS X and UNIX. Versions 10.5 "Leopard" running on Intel processors,[3] 10.6 "Snow Leopard",[4] 10.7 "Lion",[5] 10.8 "Mountain Lion",[6] and 10.9 "Mavericks"[7] have obtained UNIX 03 certification. iOS, which runs on the iPhone, iPod Touch,[13] iPad, and the 2nd and 3rd generation Apple TV,[14] shares the Darwin core and many frameworks with OS X. An unnamed variant of v10.4 powered the first generation Apple TV.[15]

Mac OS X 10.7 "Lion" was the first version of OS X to drop support for 32-bit Intel processors and run exclusively on 64-bit Intel CPUs.

The server edition, OS X Server, was architecturally identical to its desktop counterpart, and included tools to facilitate management of workgroups of OS X machines, and to provide network services. Starting with v10.7 "Lion", OS X Server is no longer offered as a separate operating system product; instead, the server management tools are available for purchase separately, and are preloaded on the server models of Mac Pro and Mac Mini along with OS X.
[http://en.wikipedia.org/wiki/OS_X]

os.MAC-OS-CLASSIC {1984-2001}

name::
* McsEngl.os.MAC-OS-CLASSIC {1984-2001}@cptItsoft,
* McsEngl.conceptItsoft828,
* McsEngl.System7@cptItsoft,
* McsEngl.MAC-OS@cptItsoft,
* McsEngl.mac-os-classic@cptItsoft,

DEFINITION

THE MAC OS.

The "classic" Mac OS is characterized by its monolithic system. Versions of Mac OS up through System 4 only ran one application at a time. Even so, it was noted for its ease of use. Mac OS gained cooperative multitasking with System 5, which ran on the Mac SE and Macintosh II. It was criticized for its very limited memory management, lack of protected memory, and susceptibility to conflicts among operating system "extensions" that provide additional functionality (such as networking) or support for a particular device. Some extensions didn't work properly together, or only worked when loaded in a particular order. Troubleshooting Mac OS extensions could be a time-consuming process of trial and error.

The Macintosh originally used the Macintosh File System (MFS), a flat file system with only one level of folders. This was quickly replaced in 1985 by the Hierarchical File System (HFS), which had a true directory tree. Both file systems are otherwise compatible.

Most file systems used with DOS, Unix, or other operating systems treat a file as simply a sequence of bytes, requiring an application to know which bytes represent what type of information. By contrast, MFS and HFS give files two different "forks". The data fork contains the same sort of information as other file systems, such as the text of a document or the bitmaps of an image file. The resource fork contains other structured data such as menu definitions, graphics, sounds, or code segments. A file might consist only of resources with an empty data fork, or only a data fork with no resource fork. A word processor file could contain its text in the data fork and styling information in the resource fork, so that an application which doesn’t recognize the styling information can still read the raw text.

On the other hand, these forks would provide a challenge to interoperability with other operating systems: how does one copy a dual-forked file into a different file system, or across a file-transfer system, or embed it into email? In copying or transferring a MacOS file to a non-Mac system, the default implementations would simply strip the file of its resource fork. Most data files contained only nonessential information in their resource fork, such as window size and location, but program files would be inoperative without their resources. This necessitated such encoding schemes as BinHex and MacBinary, which allowed a user to encode a dual-forked file into a single stream, or take a single stream so-encoded and reconstitute it into a dual-forked file usable by MacOS.

PowerPC versions of OS X up to and including OS X v10.4 Tiger (support for Classic was dropped by Apple with v10.5 Leopard's release and it is no longer included) include a compatibility layer for running older Mac applications, the Classic Environment. This runs a full copy of the older Mac OS, version 9.1 or later, in an OS X process. PowerPC-based Macs shipped with Mac OS 9.2 as well as OS X. Mac OS 9.2 had to be installed by the user— it was not installed by default on hardware revisions released after the release of OS X 10.4 Tiger. Most well-written "classic" applications function properly under this environment, but compatibility is only assured if the software was written to be unaware of the actual hardware, and to interact solely with the operating system. The Classic Environment is not available on Intel-based Macintosh systems due to the incompatibility of Mac OS 9 with the x86 hardware.

Users of the classic Mac OS generally upgraded to OS X, but many criticized it as being more difficult and less user-friendly than the original Mac OS, for the lack of certain features that had not been re-implemented in the new OS, or for being slower on the same hardware (especially older hardware), or other, sometimes serious incompatibilities with the older OS.[8] Because drivers (for printers, scanners, tablets, etc.) written for the older Mac OS are not compatible with OS X, and due to the lack of OS X support for older Apple machines, a significant number of Macintosh users continued using the older classic Mac OS.

In June 2005, Steve Jobs announced at the Worldwide Developers Conference keynote that Apple computers would be transitioning from PowerPC to Intel processors and thus dropping compatibility on new machines for Mac OS Classic. At the same conference, Jobs announced Developer Transition Kits that included beta versions of Apple software including OS X that developers could use to test their applications as they ported them to run on Intel-powered Macs. In January 2006, Apple released the first Macintosh computers with Intel processors, an iMac and the MacBook Pro, and in February 2006, Apple released a Mac mini with an Intel Core Solo and Duo processor. On May 16, 2006, Apple released the MacBook, before completing the Intel transition on August 7 with the Mac Pro. To ease the transition for early buyers of the new machines, Intel-based Macs included an emulation technology called Rosetta, which allows them to run OS X software that was compiled for PowerPC-based Macintoshes. Rosetta runs transparently, creating a user experience identical to running the software on a PowerPC machine, though execution is typically slower than with native code. Rosetta was an optional installation in OS X 10.6 Snow Leopard and is not available at all in OS X 10.7 Lion.
[http://en.wikipedia.org/wiki/Mac_os#.22Classic.22_Mac_OS_.281984.E2.80.932001.29] {2013-12-15}

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#

DOING#cptCore475#

version7
Δικτυα: Οι δυνατότητες χειρισμου δεικτύου προσφέρονται απ'ευθείας με το λειτουργικό σύστημα.

version7.1
Θα είναι έτοιμο τελη 1992. Θά έχει την τεχνολογία WorldScript που θα επιτρέπει την προσαρμογη του συστήματος γρήγορα στις περισότερες γλωσες του κόσμου. It will use 2byte character-storage scheme.

os.MICROSOFT-WINDOWS (osWin)

_CREATED: {2011-09-18}

name::
* McsEngl.os.MICROSOFT-WINDOWS (osWin)@cptItsoft,
* McsEngl.conceptIt118,
* McsEngl.conceptIt746,
* McsEngl.conceptItsoft440OldNT,
* McsEngl.chicago@cptItsoft,
* McsEngl.ms-windows-95@cptItsoft,
* McsEngl.ms'windows95@cptIt118,
* McsEngl.os.windows@cptItsoft,
* McsEngl.osWin@cptItsoft, {2014-02-02}
* McsEngl.win@cptIt118, {2011-09-18}
* McsEngl.win95@cptIt118,
* McsEngl.win98@cptIt118,
* McsEngl.winMe@cptIt118,
* McsEngl.winOS@cptItsoft, {2017-10-29}
* McsEngl.windows95@cptIt118,
* McsEngl.windows98@cptItsoft,
* McsEngl.winXP@cptIt118, {2011-09-18}
* McsEngl.winVista@cptIt118, {2011-09-18}
* McsEngl.win7@cptIt118, {2011-09-18}

* McsEngl.microsoft'win'xp@cptItsoft440,
* McsEngl.ms'win'xp@cptItsoft440,
* McsEngl.os.win'nt@cptItsoft440,
* McsEngl.win2000@cptItsoft440,
* McsEngl.win'nt@cptItsoft440,
* McsEngl.win'xp@cptItsoft440,
* McsEngl.windows-2000-professional/server/advanced-server@cptItsoft,
* McsEngl.windows-nt@cptItsoft,
* McsEngl.windows-xp-(eXPerience)-home/professional@cptItsoft,
* McsEngl.winxp@cptItsoft440,
* McsEngl.whistler-(xp)@cptItsoft,

DEFINITION

WINDOWS NT is a 32bit operating-system#cptIt119.1# of Microsoft corporation.
===
ΣΥΜΦΩΝΑ ΠΑΝΤΑ ΜΕ ΤΗ MICROSOFT ΗΡΘΑΝ ΓΙΑ ΝΑ ΓΕΦΥΡΩΣΟΥΝ ΤΟ ΧΑΣΜΑ ΠΟΥ ΧΩΡΙΖΕ ΤΙΣ ΔΙΑΦΟΡΕΤΙΚΕΣ ΠΛΑΤΦΟΡΜΕΣ ΤΟΥ HARDWARE.

osWin'GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
*-#ql:[Level CONCEPT:rl? conceptIt434]#NETWORK-OS#cptIt119#

INFO-TECH-BUSINESS#cptEconomy7.108#

MICROSOFT#cptItorg1672#

_winNT:
CREATOR:
DAVID CUTTLER, ΚΑΤΑΣΚΕΥΑΣΕ ΚΑΙ ΤΟ VMS of DEC.

osWin'application-program

name::
* McsEngl.osWin'application-program@cptItsoft,
* McsEngl.osWin'app@cptItsoft,

osWin'startmenu

name::
* McsEngl.osWin'startmenu@cptItsoft,

_WIN10:
\ProgramData\Microsoft\Windows\Start Menu\Programs

osWin'startup

name::
* McsEngl.osWin'startup@cptItsoft,

REGISTRY:
* HKEY_CURRENT_USER\Sosftware\Microsoft\CurrentVersion\Run:
MSMSGS
"\Program Files\Messenger\msmsgs.exe" /background

ΠΡΟΓΡΑΜΜΑΤΑ\ΕΚΙΝΝΗΣΗ:
* "\Program Files\Adobe\Acrobat 7.0\Reader\reader_sl.exe"

osWin'bit-architecture#cptIt472#

name::
* McsEngl.osWin'bit-architecture@cptItsoft,

64-bit:

32-bit:
32 Bit. ΜΠΟΡΕΙ ΝΑ ΕΚΤΕΛΕΙ ΤΙΣ ΕΝΤΟΛΕΣ ΤΟΥ ΠΟΛΥ ΠΙΟ ΓΡΗΓΟΡΑ, ΜΙΑΣ ΚΑΙ ΣΕ ΚΑΘΕ ΚΥΚΛΟ ΤΟΥ ΡΟΛΟΓΙΟΥ ΜΕΤΑΒΙΒΑΖΕΙ ΜΕΓΑΛΥΤΕΡΟ ΑΡΙΘΜΟ ΕΝΤΟΛΩΝ ΑΠ'ΟΤΙ ΕΝΑ ΔΕΚΑΕΞΑΜΠΙΤΟ ΣΥΣΤΗΜΑ.

osWin'character#cptIt431#

name::
* McsEngl.osWin'character@cptItsoft,

_winxp:
* ΐ,ΰ --> ctr+alt+;->ι,υ. (ή παλιό shift+w->ι,υ)
* € --> greek-keyboard: ctr+alt+e, en-keyboard: alt+0128,

Θα χρησιμοποιει το UNICODE 2^16 characters, so multilingual.

Υποστηρίζουν γραμματοσειρές UNICODE και 'προέτρεψαν' τους κατασκευαστές λογισμικού να υποστηρίξουν πολλαπλές 'γλώσσες' στο ίδιο αρχείο.
[ΡΑΜ, ΟΚΤ. 1996, 52]

H κωδικοσελίδα του DOS είναι 737, ενώ των windows είναι 1253.
* για να γίνεται η σωστή ΜΕΤΑΦΡΑΣΗ πρεπει στο
system.ini, [keyboard] να υπάρχει
oemansi.bin=xlat737.bin
όπου xlat737.bin είναι ένα αρχείο στο win\system.
* Παλιότερες εφαρμογές για να βλέπουν unicode fonts πρεπει στο win.ini [font substitutes] να δηλωθεί το υποσύνολο στο οποίο ανήκουν τα ελληνικα (161)πχ
ArialGreek,161=Arial,161
ArialGreek,0=Arial,161
δηλαδή όπου βλεπεις ArialGreek χρησιμοποίησε το υποσύνολο 161 της Arial.
[RAM 1997apr, 230]

osWin'Font

name::
* McsEngl.osWin'Font@cptItsoft,

Needs RESTART when we change the-registry.

_RESOURCE:
* https://docs.microsoft.com/en-us/globalization/input/font-technology,
the registry entry of “Arial,0” with the value of “Arial,161” will substitute Arial with ANSI_CHARSET to Arial with GREEK_CHARSET.

_WIN10:
Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontSubstitutes
- Arial,0 => Arial,161
- Non-unicode-programs: English(USA)
Then some dialogs used greek fonts.
[hmnSngo.2017-05-17]
===
I changed the raster fonts settings in the registry so the English fonts will be used (just copy the text below and create a .reg file) -
-----
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts]
"Courier 10,12,15"="COURE.FON"
'Courier 10,12,15 (120)'="COURF.FON"
"MS Serif 8,10,12,14,18,24"="SERIFE.FON"
'MS Serif 8,10,12,14,18,24 (120)'="SSERIFF.FON"
"MS Sans Serif 8,10,12,14,18,24"="SSERIFE.FON"
'MS Sans Serif 8,10,12,14,18,24 (120)'="SSERIFF.FON"
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\GRE_Initialize\LargeFont]
"FIXEDFON.FON"="8514fix.fon"
"FONTS.FON"="8514sys.fon"
"OEMFONT.FON"="8514oeme.fon"
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\GRE_Initialize\SmallFont]
"FIXEDFON.FON"="vgafix.fon"
"FONTS.FON"="vgasys.fon"
"OEMFONT.FON"="vgaoem.fon"
-----
In the CMD and PowerShell Terminal I changed the font to Consolas 14 because I have no solution for dosapp.fon (Terminal Raster Fonts)
I know that this is a workaround but applications that had issues work for me now.
This is based on -
https://support.microsoft.com/en-us/help/2396756/applications-using-bitmap-font-gets-effected-with-rendering-issues-if-during-windows-7-setup-high-dpi-is-deteted-and-dpi-is-set-to-120-or-higher
Hope it helps.
[https://answers.microsoft.com/en-us/windows/forum/windows_10-other_settings/windows-10-1703-locale-problem-non-unicode/d3976da6-577f-45e2-a84f-067a6dcb8c6b]

windows95:
* WINDOWS EXPLORER: είχε πολύ μικρά γράμματα. Αφαίρεσα τις serif*.fon και sserife.fon. Επειδή απο τα win δε μπορούσα να το κάνω γιατί τις χρησιμοποιούσε, πήγα σε DOS κατάσταση μόνο και απο εκεί τις διέγραψα.
* FOLIO VIEWS: για τη helv χρηισμοποιεί την sseriff.fon.
* ULTRAEDIT: 8514fix.fon έσβησα και έτσι χρησιμοποίησε το vgafix.fon που είναι πιο μικρά.

_ADDRESS.WPG:
* http://www.askvg.com/tip-how-to-change-fonts-of-menus-dialog-box-and-other-text-in-windows-8-and-later//

osWin'Keyboard

name::
* McsEngl.osWin'Keyboard@cptItsoft,
* McsEngl.osWin'keyboard@cptItsoft,

_win10:
* ctrl+shift+esc = task-manager,
* win+R = run command prompt.

_GREEK:
* 1) ctrl+alt+; 2) vowel
ΰ (alt0224) ή right-alt+shift+; και μετά το φωνήεν.
ΐ (alt0192) ή right-alt+shift+; και ΜΕΤΑ το φωνήεν

AutoHotKey

name::
* McsEngl.AutoHotKey@cptItsoft,

_ADDRESS.WPG:
1) https://brushingupscience.com/2015/12/28/add-any-symbol-without-leaving-the-keyboard/
(downloads: AutoHotkey_1.1.30.03_setup.exe)
2) edit 'insert_symbols.ahk' file in \Users\synagonism\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
::aaa::α
::aac::?
::aag::?
::aam::?
3) - type 'aaa'+spacebar=α, ...

osWin'command-line

name::
* McsEngl.osWin'command-line@cptItsoft,

osWin'PowerShell (wps)

name::
* McsEngl.osWin'PowerShell (wps)@cptItsoft,
* McsEngl.PowerShell@cptItsoft,
* McsEngl.Windows-PowerShel@cptItsoft,
* McsEngl.wps@cptItsoft,
* McsEngl.powerShell@cptItsoft,

_DESCRIPTION:
Windows 10 ships with PowerShell v 5. It is a command-line shell and scripting language, built on the .NET Framework, designed for system administration, IT professionals and developers.

How to open an elevated PowerShell prompt
To open an elevated PowerShell prompt, in the taskbar search, type powershell.
Now see the result Windows PowerShell which appears on the top. Right-click on it and select Run as Administrator.
The UAC prompt will ask you for your consent. Click yes, and the prompt will open.
[http://www.thewindowsclub.com/how-to-open-an-elevated-powershell-prompt-in-windows-10]

wps'Command

name::
* McsEngl.wps'Command@cptItsoft,

_DESCRIPTION:
Windows PowerShell commands, called cmdlets, let you manage the computers from the command line.
Windows PowerShell providers let you access data stores, such as the registry and certificate store, as easily as you access the file system.
In addition, Windows PowerShell has a rich expression parser and a fully developed scripting language.
[https://technet.microsoft.com/en-us/library/bb978526]

Microsoft.PowerShell.Core Cmdlets:
wps'Add_History
Appends entries to the session history.

wps'Add_PSSnapin
Adds one or more Windows PowerShell snap-ins to the current session.

wps'Clear_History
Deletes entries from the command history.

wps'Connect_PSSession
Reconnects to disconnected sessions.

wps'Debug_Job
Debugs a running background, remote, or Windows PowerShell Workflow job.

wps'Disable_PSRemoting
Prevents remote users from running commands on the local computer.

wps'Disable_PSSessionConfiguration
Disables session configurations on the local computer.

wps'Disconnect_PSSession
Disconnects from a session.

wps'Enable_PSRemoting
Configures the computer to receive remote commands.

wps'Enable_PSSessionConfiguration
Enables the session configurations on the local computer.

wps'Enter_PSHostProcess
Connects to and enters into an interactive session with a local process.

wps'Enter_PSSession
Starts an interactive session with a remote computer.

wps'Exit_PSHostProcess
Closes an interactive session with a local process.

wps'Exit_PSSession
Ends an interactive session with a remote computer.

wps'Export_Console
Exports the names of snap-ins in the current session to a console file.

wps'Export_ModuleMember
Specifies the module members that are exported.

wps'ForEach_Object
Performs an operation against each item in a collection of input objects.

wps'Get_Command
Gets all commands.

wps'Get_Help
Displays information about Windows PowerShell commands and concepts.

wps'Get_History
Gets a list of the commands entered during the current session.

wps'Get_Job
Gets Windows PowerShell background jobs that are running in the current session.

wps'Get_Module
Gets the modules that have been imported or that can be imported into the current session.

wps'Get_PSHostProcessInfo

wps'Get_PSSession
Gets the Windows PowerShell sessions on local and remote computers.

wps'Get_PSSessionCapability
Gets the capabilities of a specific user on a constrained session configuration.

wps'Get_PSSessionConfiguration
Gets the registered session configurations on the computer.

wps'Get_PSSnapin
Gets the Windows PowerShell snap-ins on the computer.

wps'Import_Module
Adds modules to the current session.

wps'Invoke_Command
Runs commands on local and remote computers.

wps'Invoke_History
Runs commands from the session history.

wps'New_Module
Creates a new dynamic module that exists only in memory.

wps'New_ModuleManifest
Creates a new module manifest.

wps'New_PSRoleCapabilityFile
Creates a file that defines a set of capabilities to be exposed through a session configuration.

wps'New_PSSession
Creates a persistent connection to a local or remote computer.

wps'New_PSSessionConfigurationFile
Creates a file that defines a session configuration.

wps'New_PSSessionOption
Creates an object that contains advanced options for a PSSession.

wps'New_PSTransportOption
Creates an object that contains advanced options for a session configuration.

wps'Out_Default
Sends the output to the default formatter and to the default output cmdlet.

wps'Out_Host
Sends output to the command line.

wps'Out_Null
Deletes output instead of sending it down the pipeline.

wps'Receive_Job
Gets the results of the Windows PowerShell background jobs in the current session.

wps'Receive_PSSession
Gets results of commands in disconnected sessions.

wps'Register_ArgumentCompleter
Registers a custom argument completer.

wps'Register_PSSessionConfiguration
Creates and registers a new session configuration.

wps'Remove_Job
Deletes a Windows PowerShell background job.

wps'Remove_Module
Removes modules from the current session.

wps'Remove_PSSession
Closes one or more Windows PowerShell sessions (PSSessions).

wps'Remove_PSSnapin
Removes Windows PowerShell snap-ins from the current session.

wps'Resume_Job
Restarts a suspended job.

wps'Save_Help
Downloads and saves the newest help files to a file system directory.

wps'Set_PSDebug
Turns script debugging features on and off, sets the trace level, and toggles strict mode.

wps'Set_PSSessionConfiguration
Changes the properties of a registered session configuration.

wps'Set_StrictMode
Establishes and enforces coding rules in expressions, scripts, and script blocks.

wps'Start_Job
Starts a Windows PowerShell background job.

wps'Stop_Job
Stops a Windows PowerShell background job.

wps'Suspend_Job
Temporarily stops workflow jobs.

wps'Test_ModuleManifest
Verifies that a module manifest file accurately describes the contents of a module.

wps'Test_PSSessionConfigurationFile
Verifies the keys and values in a session configuration file.

wps'Unregister_PSSessionConfiguration
Deletes registered session configurations from the computer.

wps'Update_Help
Downloads and installs the newest help files on your computer.

wps'Wait_Job
Suppresses the command prompt until one or all of the Windows PowerShell background jobs running in the session are completed.

wps'Where_Object
Selects objects from a collection based on their property values.
[https://msdn.microsoft.com/powershell/reference/5.1/microsoft.powershell.core/microsoft.powershell.core]

Get-Help <cmdlet-name> -Online

Update-Help

wps'Resource

name::
* McsEngl.wps'Resource@cptItsoft,

_ADDRESS.WPG:
* You can find help for Windows PowerShell online in the TechNet Library
beginning at http://go.microsoft.com/fwlink/?LinkID=108518.

WIN7

DOS-AS-ADMINISTRATOR:
* right-click on icon.

bcdboot:
add the boot files to the C: partition.
bcdboot \Windows /s C:

XP PRO

RD /S /Q dirname: DELETE A DIRECTORY.
** /s = and all subdirectories.
** /q = when delete subdirectories does NOT ask the user for it.

XCOPY:
/D:m-d-y Αν δεν δοθεί ημερομηνία αντιγράφει μόνο τα νεότερα αρχεία.
/S Αντιγράφει και υποκαταλόγους εκτός από κενούς
/F εμφανίζει τα ονόματα των αρχείων
/Y δεν εμφανίζει την ερώτηση επαλήθευσης

osWin'evaluation#cptCore546.107#

name::
* McsEngl.osWin'evaluation@cptItsoft,

_winNT:
DRAWBACKS
- ΔΕΝ ΕΧΟΥΝ ΥΠΗΡΕΣΙΑ ΚΑΤΑΛΟΓΩΝ. ΜΙΑ ΚΑΤΑΝΕΜΗΜΕΝΗ ΥΠΗΡΕΣΙΑ ΚΑΘΟΛΙΚΩΝ ΚΑΤΑΛΟΓΩΝ. ΑΚΟΜΑ ΚΑΙ Ο ΠΡΟΗΓΜΕΝΟΣ ΕΞΥΠΗΡΕΤΗΤΗΣ ΔΕΝ ΦΤΑΝΕΙ ΤΗΝ NOVEL
[RAM, JUN 1993, 62]
===
- ΙΣΤΟΡΙΚΗ ΑΝΙΚΑΝΟΤΗΤΑ ΝΑ ΠΟΥΛΗΣΕΙ ΛΟΓΙΣΜΙΚΟ ΔΙΚΤΥΩΝ ΣΕ ΕΤΑΙΡΙΕΣ.
- Current command-line scripting
- No integral 3-D graphics API
===
Είχε την πρόθεση να αντικαταστήσει κάθε μορφή (συμβατικών) windows και dos.
[RAM, 1998jun, 102]

_win98
** το μεγαλύτερο κομμάτι των βελτιώσεων/αλλαγών είναι κρυμμένο στον πυρήνα και όχι στο περιβάλλον εργασίας.
[RAM 1998jun, 103]
** η ΣΗΜΑΝΤΙΚΟΤΕΡΗ ΑΛΛΑΓΗ είναι η ενσωμάτωση της ιντερνετικής πλοήγησης.
** υποστήριξη
- USB (σύνδεση εξωτερικών συσκευών χωρίς επανεκκινήσεις),
- IEEE 1394 (συνδέσεις ήχου και εικόνας),
- AGP,
- DVD,
- ACPI (δίνει τη δυνατότητα να ανοίγετε και να κλεινετε το μηχανημα όπως την τηλεόραση)
- πολλαπλών οθονών (μοιράζεται σε πολλές οθόνες ένα το περιβάλλον εργασίας)
- OnPower (atx motherbords το υποστηρίζουν)
- active desktop (desktop as a web page)
- fat32 (cluster 4k instead of 32k of fat16)
- directX για παιγνίδια ενσωματωμένη.
[RAM 1998jun, 103]
** Ta windows98 είναι το τελευταίο μέλος της οικογένειας των βασισμένων σε DOS λειτουργικών συστημάτων.
[RAM 1998jun, 103]

** Microsoft acknowledges that Windows 98 is more of an evolution than a revolution in personal computing, but says there are still compelling reasons to take the leap. "Applications load so much faster," said Smith. "It's about 36 percent faster than Windows 95 and it takes up less hard disk space, so that's important for consumers."
[cnet 1998jun25]

Τα windows95 και τα windowsnt είναι οι ενδιάμεσοι σταθμοί προς το Cairo.
[COMPUTER GO, MAY 1995, 120]

osWin'comparison

name::
* McsEngl.osWin'comparison@cptItsoft,

Comparing Windows: XP vs. Vista vs. 7 Windows XP Windows Vista Windows 7
Minimum hardware

* --Processor: 300MHz
* --RAM: 128MB
* --Super VGA graphics device
* --HD: 4.2GB (for SP3)

* --Processor: 1GHz
* --RAM: 1GB (32-bit), 2GB (64-bit)
* --Support for DirectX 9 graphics device with 128MB of memory
* --HD: 20GB (32-bit), 40GB (64-bit)

* --Processor: 1 GHz
* --RAM: 1GB (32-bit), 2GB (64-bit)
* --Support for DirectX 9 graphics device with 128MB of memory
* --HD: 16GB (32-bit), 20GB (64-bit)

Interface

* --Luna theme
* --Introduces task-based windows options
* --Skinning possible but difficult
* --Desktop Cleanup Wizard automates removing old icons

* --Aero theme
* --Introduces transparent panes, window animations, live thumbnails of running programs
* --New desktop sidebar supports gadgets
* --Supports touch screens

* --Aero theme
* --Supports slideshow backgrounds, RSS and theme packs
* --Introduces Aero Shake and Aero Snap
* --Desktop gadgets can be placed anywhere
* --Supports multitouch on touch screens

Explorer

* --Replaces tree navigation by default with task pane
* --Improves image handling
* --Offers thumbnail previews and group views
* --Supports some metadata

* --Task pane integrated into toolbar
* --New breadcrumb navigation
* --New metadata display
* --Improved icon resolution
* --Some documents can be edited from the preview pane

* --Support for federated searches and libraries
* --Virtual folders aggregate content from local and networked drives

Start menu

* --New layout
* --Devices and some Control Panel options appear in menu

* --Added search box
* --All Programs folder changed to a nested format
* --Configurable power button
* --User profile picture

* --Taskbar jumps appear in the Start menu and replace the right column when viewed
* --Documents, Pictures, Music buttons now link to their libraries
* --Control Panel options have been integrated into search results

Taskbar

* --New look
* --Hideable icons in System Tray

* --Refreshed look
* --Alt-Tab hot key now shows preview thumbnail of program

* --Interactive mouse-over preview panes
* --Replacement of the Quick Launch bar with pinned programs
* --Program-specific jump lists based on pinned programs
* --Aero Peek for mouse-over desktop viewing
* --Revamped System Tray

Devices

* --Introduces Universal Plug-n-Play
* --New driver library allows for downgrading drivers when necessary

* --Debuts portable device API, designed to communicate with cell phones, PDAs, and portable media players
* --Introduces Sync Center for managing data synchronizations

* --New Device Stage provides a centralized, unified window for managing all aspects of printers and portable devices

Misc.

* --Introduces context-menu CD and DVD burning from Windows Explorer
* --Supports multiple versions of a single DLL to prevent programs from overwriting each other
* --Introduces Hibernate and Sleep modes
* --Remote Desktop for accessing a computer from another location
* --Fast user account switching

* --Built-in drive partitioning
* --More powerful screen-capturing tool
* --Hybrid Sleep and better configuration options for more nuanced power management
* --User-based file-type associations
* --Previous Version automatically backs up changes to individual files

* --Expands Windows Explorer disc burning to include ISOs
* --Introduces XP Mode
* --Expanded options for disabling components
* --Can search text in scanned TIFF
* --Additional power-saving features for laptops
[http://reviews.cnet.com/windows/microsoft-windows-7-professional/4505-3672_7-33704140.html?tag=contentMain;contentBody] 2009-11-03

osWin'compatibility-with-other-os#cptIt473#

name::
* McsEngl.osWin'compatibility-with-other-os@cptItsoft,

_winNT:
ΣΤΗ ΓΡΑΜΜΗ ΕΝΤΟΛΩΝ ΜΠΟΡΕΙ ΝΑ ΞΕΚΙΝΗΣΕΙ ΚΑΝΕΙΣ ΟΠΟΙΑΔΗΠΟΤΕ ΕΝΤΟΛΗ, ΟΠΟΙΟΥΔΗΠΟΤΕ ΛΕΙΤΟΥΡΓΙΚΟΥ ΣΥΣΤΗΜΑΤΟΣ DOS, WINDOWS, UNIX.
===
It will run DOS, Windows, new 32-bit applications, OS/2 applications, X window.
===
Posix (το διεθνες στάνταρ του UNIX) support. Αυτο γινεται μέσω του Remote Procedure Calls. O ίδιος μηχανισμός θα μπορούσε να χρησιμοποιηθεί αργότερα και για τη μεταφορά εφαρμογών από άλλα λειτουργικά συστήματα.

osWin'doing#cptCore475#

name::
* McsEngl.osWin'doing@cptItsoft,

_SPECIFIC:
* ACCESS to 'MICROSOFT NETWORK'.
===
* ΚΤΙΖΕΙ ΠΑΝΩ ΣΤΗΝ ΠΛΑΤΦΟΡΜΑ ΤΩΝ ΝΤ ΜΗΧΑΝΙΣΜΟΥ ΚΕΝΤΡΙΚΗΣ ΔΙΑΧΕΙΡΙΣΗΣ ΟΜΑΔΩΝ ΧΡΗΣΤΩΝ ΚΑΙ ΔΙΑΘΕΤΕΙ ΕΝΣΩΜΑΤΩΜΕΝΑ ΕΡΓΑΛΕΙΑ ΔΙΑΧΕΙΡΙΣΗΣ ΔΙΣΚΩΝ ΜΕ ΤΕΧΝΙΚΕΣ MIRRORING AND RAID

osWin'Remote-connection

name::
* McsEngl.osWin'Remote-connection@cptItsoft,
* McsEngl.osWin'remote-connection@cptItsoft,

_DESCRIPTION:
From Windows 10, type “mstsc” on run and press enter to open remote desktop protocol.

_ADDRESS.WPG:
* http://www.technig.com/remote-access-windows-10-via-ubuntu-vise-versa//

osWin'MULTIPROCESSING

name::
* McsEngl.osWin'MULTIPROCESSING@cptItsoft,

ΕΠΙΤΡΕΠΕΙ ΤΗ ΣΥΜΜΕΤΡΙΚΗ (= ο ίδιος επεξεργαστής κάνει πολές δουλειές) ΧΡΗΣΗ ΠΕΡΙΣΣΟΤΕΡΩΝ ΤΟΥ ΕΝΟΣ ΕΠΕΞΕΡΓΑΣΤΗ.
ΓΙΑ ΤΑ ΝΤ Ο ΥΠΟΛΟΓΙΣΤΗΣ ΜΕ ΕΝΑΝ ΕΠΕΞΕΡΓΑΣΤΗ ΕΙΝΑΙ ΠΙΑ ΠΑΡΩΧΗΜΕΝΗ ΠΕΡΙΠΤΩΣΗ. ΕΧΟΝΤΑΣ ΚΑΤΑΣΚΕΥΑΣΤΗ ΕΞΑΡΧΗΣ ΓΙΑ ΣΥΜΜΕΤΡΙΚΗ ΠΟΛΥΕΠΕΞΕΡΓΑΣΙΑ.

osWin'MULTITASKING

name::
* McsEngl.osWin'MULTITASKING@cptItsoft,

ΥΠΟΣΤΗΡΙΖΕΙ ΠΡΟΕΚΤΟΠΙΣΤΙΚΗ ΠΟΛΥΝΗΜΑΤΙΚΗ ΠΟΛΥΔΙΕΡΓΑΣΙΑ.
PREEMTIVE ΣΗΜΑΙΝΕΙ ΟΤΙ ΤΟ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ ΕΧΕΙ ΤΟΝ ΕΛΕΓΧΟ ΤΟΥ ΥΠΟΛΟΓΙΣΤΗ ΚΑΘΕ ΣΤΙΓΜΗ, ΚΑΙ ΚΑΜΙΑ ΕΦΑΡΜΟΓΗ ΔΕΝ ΜΠΟΡΕΙ ΝΑ ΜΟΝΟΠΩΛΗΣΕΙ ΤΟΝ ΕΠΕΞΕΡΓΑΣΤΗ ΚΑΙ ΤΟΥΣ ΠΟΡΟΥΣ ΤΟΥ ΣΥΣΤΗΜΑΤΟΣ.

osWin'NETWORKING

name::
* McsEngl.osWin'NETWORKING@cptItsoft,

Windows7:
Δεν έβλεπε τους άλλους υπολογιστές:
- είθελε το workgroup: homenet
- το οικιακό-δίκτυο (με άλλους win7) δε χρειάζεται.

ΕΡΜΗΣ ΘΑ ΕΛΕΓΧΕΙ ΤΟ ΔΙΚΤΥΟ.

ΕΝΣΩΜΑΤΩΜΕΝΗ ΥΠΟΣΤΗΡΙΞΗ ΔΙΚΤΥΩΝ.

ΜΠΟΡΕΙ ΝΑ ΣΥΝΕΡΓΑΣΤΕΙ ΜΕ ΔΙΚΤΥΑ NOVELL NETWARE, MICROSOFT LAN MANAGER, DEC PATHWORKS, IBM LAN SERVER.

ΜΕ ΤΑ Remote Access Service ΕΝΑΣ ΠΕΛΑΤΗΣ ΣΥΝΔΕΕΤΑΙ ΜΕ ΕΝΑΝ ΕΞΥΠΗΡΕΤΗΤΗ ΜΕΣΩ ΤΗΣ ΤΗΛΕΦΩΝΙΚΗΣ ΓΡΑΜΜΗΣ ή X.25.

Ο ΚΑΘΕ ΥΠΟΛΟΓΙΣΤΗΣ ΜΕ NT ΜΠΟΡΕΙ ΤΑΥΤΟΧΡΟΝΑ ΝΑ ΕΙΝΑΙ ΠΕΛΑΤΗΣ ΚΑΙ ΕΞΥΠΗΡΕΤΗΤΗΣ.

Η ΔΙΚΤΥΑΚΗ ΕΝΣΩΜΑΤΩΣΗ ΕΧΕΙ ΕΝΣΩΜΑΤΩΘΕΙ ΑΠΟ ΤΗ ΦΑΣΗ ΣΧΕΔΙΑΣΜΟΥ, ΚΑΤΙ ΠΟΥ ΠΡΩΤΗ ΕΦΑΡΜΟΣΕ Η SUN ΑΠΟΤΕΛΕΣΜΑΤΙΚΑ.

osWin'Repair

name::
* McsEngl.osWin'Repair@cptItsoft,

Download the PC Repair Utility to scan and identify Windows Errors on Windows 10.
Update your PC and eliminate potential threats:
Scan your PC for Windows errors with 1 click
Remove Viruses and repair damage caused
Eliminate all Malware from your PC
* http://en.reimageplus.com/land/sqh/index.php?tracking=twc&banner=direct&adgroup=direct&ads_name=direct&keyword=direct,

osWin'SECURITY

name::
* McsEngl.osWin'SECURITY@cptItsoft,

Η ΑΣΦΑΛΕΙΑ ΠΟΥ ΠΑΡΕΧΟΥΝ ΕΙΝΑΙ ΥΨΗΛΟΤΑΤΟΥ ΕΠΙΠΕΔΟΥ ΚΑΙ ΠΛΗΡΟΥΝ ΤΙΣ ΕΞΑΙΡΕΤΙΚΑ ΑΥΣΤΗΡΕΣ ΠΡΟΔΙΑΓΡΑΦΕΣ C2 TOY NCSC.(ΑΜΕΡΙΚΑΝΙΚΟ ΠΕΝΤΑΓΩΝΟ)

osWin'APT

name::
* McsEngl.osWin'APT@cptItsoft,

advanced parallel technology.
Είναι ενσωματωμένη στο λειτουργικο και είναι προιόν έρευνας της Microcom. Επιτρέπει τη χρήση της παράλληλης θύρας και μερικά μόντεμ έχουν τέτοια θύρα με αποτέλεσμα η ταχύτητα να φτάνει στα 300.000 bps.

osWin'doing.INSTALLING#cptIt162#

name::
* McsEngl.osWin'doing.INSTALLING@cptItsoft,
* McsEngl.osWin'installing@cptItsoft,

WIN98:
** complete edition
** upgrade edition
Η αναβάθμιση χρειάζεται πάνω από μισή ώρα.

osWin'installing-from-usb

name::
* McsEngl.osWin'installing-from-usb@cptItsoft,

_ADDRESS.WPG:
* http://www.raymond.cc/blog/how-to-install-windows-7-faster-using-usb-flash-drive//

osWin'remove-ubuntu

name::
* McsEngl.osWin'remove-ubuntu@cptItsoft,

_DESCRIPTION:
If you want to remove Ubuntu, use any partitioning tool to delete the Linux partitions and resize the Windows partition to fill the drive. You can do this with Partition Magic on Windows, or use the Ubuntu installation disc. Boot from the disc and run System > Administration > Partition Editor. From here you can delete the Linux partitions. Ubuntu uses two by default; a smallish swap partition and a large one for everything else. Make sure you only remove partitions that are marked as type swap or ext3 - any NTFS or FAT partitions are for Windows. This removes the Ubuntu data from your computer but leaves the Grub bootloader.

You this need to boot from your Windows CD to remove this. Select the rescue option and run fixmbr. This will restore the disk's boot code back to the Windows settings and your computer will now boot straight into Windows when you power up. All of this assumes that you took the installation option to resize the Windows partition. If you told the installer to use the whole disk, it will have wiped your Windows installation from the hard drive. In this case, the only way to get Windows back is to reinstall it.
[http://www.tuxradar.com/answers/554]

osWin'RECOVERING

name::
* McsEngl.osWin'RECOVERING@cptItsoft,
* McsEngl.osWin'reset@cptItsoft,
* McsEngl.osWin'restore@cptItsoft,

_win10:
* http://windows.microsoft.com/en-us/windows-10/windows-10-recovery-options,
===
* RESTORE TO A PREVIOUS POINT:
- settings/update-and-security/search for recovery/open-system-restore

_WINXP:
Recovering after removing UBUNTU (grub):
1) start with win instalation disk
2) choose recovery
3) run fixmbr to Repair the master boot record of the boot disk.

_WIN98:
RECOVERING WIN after removing linux:
* start with win98 disk
* fdisk /mbr

osWin'UNINSTALLATION

name::
* McsEngl.osWin'UNINSTALLATION@cptItsoft,

ΑΠΕΓΚΑΤΑΣΤΑΣΗ ΤΩΝ WIN 2000 (εγκαταστημένα με 95/98):
α) ξεκινάμε με δισκέτα των 95/95
β) εκτελούμε την εντολή: a:>sys c:
γ) μετά μπορούμε να διαγράψουμε τα αρχεία boot.ini, ntldr, ntdetect.com,pagefile.sys, hyberfil.sys.

αρχεία του NT loader:
Boot.ini Bootsect.dos Ntdetect.com Ntldr

osWin'file-system#cptIt433#

name::
* McsEngl.osWin'file-system@cptItsoft,

NTFS. ΚΑΙΝΟΥΡΓΙΟ ΜΑΣ ΦΕΡΝΕΙ ΣΤΗ ΔΕΚΑΕΤΙΑ ΤΟΥ 90.
ΟΝΟΜΑΤΑ ΑΡΧΕΙΩΝ ΜΕΧΡΙ 256 ΧΑΡΑΚΤΗΡΕΣ ΚΑΙ ΚΕΝΑ.

ΜΑΚΡΙΑ ΟΝΟΜΑΤΑ ΑΡΧΕΙΩΝ, 16 ΒΙΤ.

Q: Is it possible to convert a FAT32 Hard Drive to NTFS without losing all data on the drive? I like to change from FAT32 to NTFS, my operating system is Windows XP PRO, how can I do that? Without the lost of my programs?
A: Standard Windows utility that is called CONVERT serves this purpose
Just go to the Command Prompt and execute the command:
\> CONVERT C: /fs:ntfs
Where C: is a name of the drive you want to convert.
After machine re-boot conversion process will start and you'll have your FAT32 converted to NTFS without of data loss.

NTFS ==> FAT 32:
* format it from a dos command.

osWin'directory

name::
* McsEngl.osWin'directory@cptItsoft,

osWin'StartMenu-directory

name::
* McsEngl.osWin'StartMenu-directory@cptItsoft,

_osWin10:
* \ProgramData\Microsoft\Windows\Start Menu\Programs

osWin'dir.Startup

name::
* McsEngl.osWin'dir.Startup@cptItsoft,

_osWin10:
* \Users\synagonism\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
* \ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp

osWin'appdata

name::
* McsEngl.osWin'appdata@cptItsoft,

run: %APPDATA%:

osWin10:
\Users\YourUserName\Appdata\Roaming

osWin7:
\Users\YourUserName\Appdata\ (Vista and 7)

osWinXp:
c:/documents and settings/user/application data
\Documents and Settings\YourUserName\Application data\ (XP)

osWin'userprofile

name::
* McsEngl.osWin'userprofile@cptItsoft,

%USERPROFILE%
c:/documents and settings/user/

osWin'Symbolic-link

name::
* McsEngl.osWin'Symbolic-link@cptItsoft,
* McsEngl.osWin'symbolic-link@cptItsoft,

> mklink /D \Users\synagonism\AppData\Roaming\Parity\Ethereum\dapps\ethcoredap \dirBCN\ethcoredapp\dist
symbolic link created for \Users\synagonism\AppData\Roaming\Parity\Ethereum\dapps\ethcoredap <<===>> \dirBCN\ethcoredapp\dist
// in dir ...Etherereum\daps creates a-symbolic-link with name ethcoredap to '\dirBCN\ethcoredapp\dist'

osWin'file-association

name::
* McsEngl.osWin'file-association@cptItsoft,

_WinXp:
On the list of files to 'open with' I could not see 'jedit.exe'.
===
In registry this name existed for another non-existed directory. Setting the correct path, worked.
[hmnSngo.2013-09-26]

osWin'GUI

name::
* McsEngl.osWin'GUI@cptItsoft,

_winNT:
το ίδιο ΜΗΧΑΝΗΜΑ ΜΠΟΡΕΙ ΝΑ ΕΞΥΠΗΡΕΤΕΙ ΠΟΛΛΟΥΣ ΧΡΗΣΤΕΣ ΜΕ ΔΙΚΟ ΤΟΥΣ ΠΕΡΙΒΑΛΟΝ.

osWin'Hardware

name::
* McsEngl.osWin'Hardware@cptItsoft,

win2000:
Before you install Windows 2000, make sure your computer meets the following minimum hardware requirements:
* 133 MHz Pentium or higher microprocessor (or equivalent).
Windows 2000 Professional supports up to two processors on a single computer.
* 64 megabytes (MB) of RAM recommended minimum. 32 MB of RAM is the minimum supported. 4 gigabytes (GB) of RAM is the maximum.
* A 2 GB hard disk with 650 MB of free space. If you're installing over a network, more free hard disk space is required.
* VGA or higher resolution monitor.
* Keyboard.
* Microsoft Mouse or compatible pointing device (optional).

network-info-machine#cptIt262#

HARDWARE DEMAND: 8/16MB RAM, BIG HARD DISK 80MB with swapfile needed

osWin'PROCESSOR

name::
* McsEngl.osWin'PROCESSOR@cptItsoft,

Will support
386, 486, RISC, Mips R4000, Alpha, Intergraph PROCESSORS.

ΜΠΟΡΕΙ ΝΑ ΔΟΥΛΕΨΕΙ ΜΕ ΔΙΑΦΟΡΕΤΙΚΟΥΣ ΕΠΕΞΕΡΓΑΣΤΕΣ. INTEL, RISC --- MIPS 4000(ARC), ALPHA, INTERGRAPH

osWin'RAM

name::
* McsEngl.osWin'RAM@cptItsoft,

16 MB MIN, 2GB MAX

ME ΧΩΡΟ ΔΙΕΥΘΥΝΣΕΩΝ 32 ΜΠΙΤ, Η ΜΝΗΜΗ ΠΟΥ ΜΠΟΡΕΙ ΝΑ ΔΕΙ ΤΟ ΛΕΙΤΟΥΡΓΙΚΟ ΕΙΝΑΙ 4 GB, ΟΣΗ ΔΗΛΑΔΗ ΚΑΙ ΕΝΑΣ ΕΠΕΞΕΡΓΑΣΤΗΣ 386 ή 486.
- ΑΠΟ ΑΥΤΑ ΣΕ ΜΙΑ ΕΦΑΡΜΟΓΗ ΜΠΟΡΟΥΝ ΝΑ ΔΙΑΤΕΘΟΥΝ ΤΟ ΜΕΓΙΣΤΟ 2 GB.

ΤΟ ΑΛΛΟ ΚΑΛΟ ΕΙΝΑΙ Η ΓΡΑΜΜΙΚΟΤΗΤΑ ΤΗΣ, ΤΟ ΓΕΓΟΝΟΣ ΔΗΛΑΔΗ ΟΤΙ ΟΙ ΕΦΑΡΜΟΓΕΣ ΜΠΟΡΟΥΝ ΕΛΕΥΘΕΡΑ ΝΑ "ΚΟΨΟΥΝ" ΚΑΙ ΝΑ ΧΡΗΣΙΜΟΠΟΙΗΣΟΥΝ ΑΠΟ ΤΗ ΜΝΗΜΗ ΑΥΤΟ ΑΚΡΙΒΩΣ ΤΟ ΚΟΜΜΑΤΙ ΠΟΥ ΧΡΕΙΑΖΟΝΤΑΙ. ΤΟ DOS ΧΡΗΣΙΜΟΠΟΙΕΙ ΚΟΜΑΤΙΑ ΤΩΝ 64 ΚΒ, ΜΕ ΠΕΡΙΟΡΙΣΜΟ ΣΤΟ 1 ΜΒ ΚΑΙ ΑΝΩΤΕΡΗ ΑΥΞΗΣΗ ΣΤΑ 256 ΜΒ ΜΕ ΚΟΛΠΑΚΙΑ.

osWin'Display

name::
* McsEngl.osWin'Display@cptItsoft,

osWin10:
run: dxdiag
= display info

osWin'STORAGE

name::
* McsEngl.osWin'STORAGE@cptItsoft,

SECONDARY MEMORY: ΑΡΚΕΤΑ TERABYTES

osWin'Help

name::
* McsEngl.osWin'Help@cptItsoft,

osWin'Cortana

name::
* McsEngl.osWin'Cortana@cptItsoft,

winctn.OPEN:
Open Cortana
If your phone has Cortana, to open Cortana, tap and hold the search key .
[http://guides.virginmedia.com/data/downloads/microsoft_lumia_650_user_manual.pdf]

winctn.create_a_note:
Tap and hold the search key , and say Create a note and what you want to have in the note.

winctn.DO_AN_IMPRESSION:
Think you can do a good Schwarzenegger? Ask Cortana to "Do an impression" for you next time you and your friends are aping someone famous. You'll be surprised with what she pulls up.

winctn.How_do_you_say_X_in_russian

winctn.Make_an_appointment,

winctn.open_camera:

winctn.open_maps:

winctn.REMIND_ME
Maybe you're someone who needs a reminder here and there throughout the day. Cortana can set reminders that trigger when you reach a certain place or a certain time of day. Perhaps you have to visit the bank after work; just say "Remind me when I leave work to visit the bank." Cortana's smart location processing has already figured out where you work is, and when you leave that location you'll get a reminder to visit the bank. The same works for picking up the mail when you get home or any other combination of task and location.

winctn.ROCK_PAPER_SCISSORS:
Cortana loves to compete — just say "rock, paper, scissors" the next time you need help picking a victor. Cortana will pick one of the three from the classic zero-sum hand game, so make sure you've already made your decision (she won't be cheating by using the camera to see your play).

winctn.SHOW_ME
On your PC, ask Cortana to "Show me pictures from last week" in order to pull up pictures from the corresponding time period. This also works with Word and Excel documents. Can't remember what you named the first draft of your essay? Ask Cortana to find it for you.

winctn. Skype_call or Skype video call, followed by the name
of the contact.

winctn.WHAT_SONG
Cortana can essentially replace the popular song-identification app Shazam. If you hear a song and would like to know its name and creator, just ask Cortana for help. "What song is playing?" should do the trick.

osWin'Interface-language#cptIt469#

name::
* McsEngl.osWin'Interface-language@cptItsoft,

Θα υποστηρίζουν 30 γλώσσες.
[COMPUTER GO, MAY 1995, 76]

osWin'Internet

name::
* McsEngl.osWin'Internet@cptItsoft,

SMTP= athena.compulink.gr
POP3= athena.compulink.gr
NNTP= news.compulink.gr
POP USER NAME= nikas@athena.compulink.gr
MAIL DIR= ...netscape\mail
NEWS DIR= ...netscape\news

IP ADDRESS: 192.0.2.1
MASK: 255.255.255.0
DNS: 193.92.197.105
139.91.1.1
nikas, compulink.gr
WIN: no
ΠΡΟΧΩΡΗΜΕΝΟΥΣ: καμμία
ΣΥΝΔΕΣΕΙΣ: πελάτης για δικτυα microsoft
ΠΥΛΗ: 193.92.197.99

DYNAMIC PPP CONECTION

DIUL-UP NETWORKING:
* MAKE NEW CONNECTION

**** PROPERTIES on new connection
*GENERAL\CONFIGURE\CONNECTION:
-8, none, 1
- uncheck wait for dial tone before dialing
-ADVANCED:
use error control/copress data
use flow control/hardware
extra atx3

*SERVER TYPE:
-PPP:Windows..
check Log on to network
check enable software compression
check TCP/IP
-TCP/IP SETTINGS:
check server assigned ip address
check server assigned name server addresses (compulink checks spesify name server address)
check use default gateway on remote network
uncheck use ip header compression

* SCRIPTING:
we can specify a script, but must unchek 'bring window after dialing' on general\configure\options

CONTROL PANEL\NETWORK:
* Θα πρέπει να έχει:
Clients for Microsoft network
Dialup adapter
TCP/IP

** TCP/IP\PROPERTIES:
--ip address: obtain automatically
--DNS CONF: enable, host, domain, serch order
--GATEWAY:
--BINDINGS: clients for microsoft net
--ADVANCED: set this as default
--WIN CONF: disable

osWin'Linux-subsystem (wsl)

name::
* McsEngl.osWin'Linux-subsystem (wsl)@cptItsoft,
* McsEngl.osWin'Linux@cptItsoft,
* McsEngl.Windows-subsystem-for-Linux@cptItsoft,
* McsEngl.wsl@cptItsoft,

_DESCRIPTION:
The Windows Subsystem for Linux lets developers run Linux environments -- including most command-line tools, utilities, and applications -- directly on Windows, unmodified, without the overhead of a virtual machine.
[https://docs.microsoft.com/el-gr/windows/wsl/about]

name::
* McsEngl.Bash-on-Windows@cptItsoft,
* McsEngl.WSL@cptItsoft,

_DESCRIPTION:
Bash on Windows provides developers with a familiar Bash shell and Linux environment in which you can run most Linux command-line tools, directly on Windows, UNMODIFIED, without needing an entire Linux virtual machine!

Bash/WSL allows you to:
Run common command-line utilities such as grep, sed, awk, etc.
Use the Linux-compatible filesystem & hierarchy and access fixed Windows storage mounted under /mnt/...
Run Bash shell scripts and Linux command-line apps. including
o Tools: vim, emacs, tmux
o Languages: Javascript/node.js, Ruby, Python, C/C++, C# & F#, Rust, Go, etc.
o Services: sshd, MySQL, Apache, lighttpd,
Install additional Linux tools using apt
Invoke Windows applications from within Bash
Invoke Linux applications from within Windows!
Bash on Windows runs Ubuntu user-mode binaries provided by Canonical. This means the command-line utilities are the same as those that run within a native Ubuntu environment.
[https://msdn.microsoft.com/en-us/commandline/wsl/about]

wsl'distribution

name::
* McsEngl.wsl'distribution@cptItsoft,
* McsEngl.wslconfig@cptItsoft,

_DESCRIPTION:
WSL Config (wslconfig.exe) is a command-line tool for managing Linux distributions running on the Windows Subsystem for Linux (WSL). It lets you list available distributions, set a default distribution, and uninstall distributions.

While WSL Config is helpful for settings that span or coordinate distributions, each Linux distribution independently manages its own configurations. To see distribution-specific commands, run [distro.exe] /?. For example ubuntu /?.

To see all available options for wslconfig, run: wslconfig /?
[https://docs.microsoft.com/el-gr/windows/wsl/wsl-config]

wsl'installing

name::
* McsEngl.wsl'installing@cptItsoft,

_ADDRESS.WPG:
* https://docs.microsoft.com/el-gr/windows/wsl/install-win10,

wsl'uninstalling

name::
* McsEngl.wsl'uninstalling@cptItsoft,

How do I uninstall WSL?
Open a command prompt and run:
lxrun /uninstall /full
[https://docs.microsoft.com/el-gr/windows/wsl/faq#how-do-i-uninstall-wsl]

wsl'command

name::
* McsEngl.wsl'command@cptItsoft,

wsl'wsl::
* wsl ~ = open bash in home/user

wsl'bash.exe::
lxrun and bash.exe and associated tools are deprecated in the Fall Creators Update.
[https://docs.microsoft.com/el-gr/windows/wsl/reference]

wsl'lxrun::
lxrun and bash.exe and associated tools are deprecated in the Fall Creators Update.
[https://docs.microsoft.com/el-gr/windows/wsl/reference]

wsl'cd:
cd /mnt/d/dirPgmWeb

wsl'app

name::
* McsEngl.wsl'app@cptItsoft,

_DESCRIPTION:
Can I run ALL Linux apps in WSL?
No! WSL is a tool aimed at enabling users who need them to run Bash and core Linux command-line tools on Windows.

WSL does not aim to support GUI desktops or applications (e.g. Gnome, KDE, etc.)

Also, even though you will be able to run many popular server applications (e.g. Redis), we do not recommend WSL for server scenarios – Microsoft offers a variety of solutions for running production Ubuntu workloads in Azure, Hyper-V, and Docker.
[https://docs.microsoft.com/el-gr/windows/wsl/faq#can-i-run-all-linux-apps-in-wsl]

wsl'app.nodejs

name::
* McsEngl.wsl'app.nodejs@cptItsoft,

_ADDRESS::
* how to install: https://gist.github.com/micahgodbolt/8b9a338c8bab7bc147975646ea20826c,

wsl'file-system

name::
* McsEngl.wsl'file-system@cptItsoft,

LOCATION::
\Users\synagonism\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs
* old_location: %localappdata%\lxss\

How do I use a Windows file with a Linux app?
One of the benefits of WSL is being able to use the same file with both Windows and Linux apps or tools.

One of the main limitations of using WSL is that changing Linux files with a Windows app or tool is not allowed. See: Do not change Linux files using Windows apps and tools

However changing Windows files with a Linux app or tools is allowed.

One way to use a Windows file with a Linux app is to use an absolute path, e.g. /mnt/c/Users/<Windows User>/Documents/Projects/<filename>.

However not all Linux apps or tools can access a file using /mnt.

A solution is to create a symbolic link.

Windows directory: \Users\<Windows User>\Documents\Projects Note: This directory exist.

Linux directory: /home/<Linux User>/Projects Note: This directory does not exist.
[https://docs.microsoft.com/el-gr/windows/wsl/faq#how-do-i-use-a-windows-file-with-a-linux-app]

wsl'resource

name::
* McsEngl.wsl'resource@cptItsoft,

_ADDRESS.WPG:
* https://docs.microsoft.com/el-gr/windows/wsl/about,
* https://github.com/Microsoft/WSL/issues,
* https://blogs.msdn.microsoft.com/wsl/
===
* http://eos.tokenika.io/installing-and-running-eos-on-windows.html,
* https://msdn.microsoft.com/en-us/commandline/wsl/install_guide,

osWin'orgProducing

name::
* McsEngl.osWin'orgProducing@cptItsoft,

_SPECIFIC:
MICROSOFT#cptItorg1672#

osWin'price#cptEconomy541.44#

name::
* McsEngl.osWin'price@cptItsoft,

_winNT:
$495 1 user.[may 1993], $1500 Network edition.

osWin'programing-language

name::
* McsEngl.osWin'programing-language@cptItsoft,

LANGUAGE: C.

osWin'registry

name::
* McsEngl.osWin'registry@cptItsoft,
* McsEngl.registry'of'winxp@cptItsoft440i,

*** regedit:
registry editor.

*** scanreg:
registry scanning.
- scanreg /?: help
- scanreg /backup:
- scanreg /restore:

STORAGE:
- \windows\system32\config
- \Documents and Settings\user name

CD-AUTOPLAY:
** XP-->HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\CdRom= autorun 0 for off.

EXIT:
** XP:
HKEY_CURRENT_USER\ControlPanel\Desktop\WaitToKillServiceTimeout=4000
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\WaitToKillServiceTimeout=4000

FROM NETWORK NOT VISIBLE:
** XP:
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer
Right klik on explorer, New, DWORD Value.
rename the file to NoNetHood, right klik on it and modify
select Base Desimal,
value=1

The Registry
is a central database that is created by Windows 95 during installation. The entries in that database consist of the
- hardware,
- software,
- users, and
- preferences data for a single PC, or any PC on a network.
Whenever the user makes changes to the Control Panel settings, File Associations, System Policies, or installed software, the changes are reflected in the Registry.

These Registry settings can be viewed with the Registry Editor (REGEDIT.EXE), which is installed into the Windows\System folder when Windows 95 is installed from CD-ROM. The floppy disk version of Windows 95 will NOT install this editor.
By default, REGEDIT.EXE will NOT appear on any of the system's menus, or the Start button. So, you will have to add your own shortcut, or you can click on the START button, select RUN, and in the OPEN: command line type REGEDIT and press ENTER. If the Registry Editor is installed on your system, it will appear on your Desktop, ready to use.

The Registry replaces the dreaded .INI files from Windows 3.1, and because the information is presented in hierarchical form, the Registry supports nested folders, which .INI files do not support. One of the many benefits of this is that in a network environment, users can log onto any PC in the network, just as it were the very same PC on their desk! In addition, several users can store configuration data on a single machine.

REBOOT OR NOT

We DON'T need to reboot the computer in order to work new changes in registry. We have only to close the registry.
[nikos, 1997dec17]

JAVA CLASSES

Local_Machine\SOFTWARE\MICROSOFT\CODE STORE DATABASE\
GLOBAL NAMESPACES\JAVA PACKAGES\COM\MS\XML:
I only write the 'path' where the whole package is NOT the classes.

The six Hkey- handles

Hkey_Local_Machine
Contains computer specific information about the type of hardware, software, and other preferences on a given PC. This information is used for all users who log onto this computer.

Hkey_Current_Config
This Key points to a branch of the Key Hkey_Local_Machine \Config that contains information about the current hardware configuration.

Hkey_Dyn_Data
This Key points to a branch of Hkey_Local_Machine that contains various bits of information regarding the System's Plug and Play configuration. This information is DYNAMIC, meaning that it may change as devices are added to or removed from the computer.

Hkey_Classes_Root
This Key points to a branch of Hkey_Local_Machine that describes certain software settings. This Key contains essential information about OLE and drag and drop operations, shortcuts, and core aspects of the Windows 95 GUI.

Hkey_Users
This Key contains information about the users that log onto the computer. Both generic and user-specific information is used, and each user who uses the system has their own Subkey.

Hkey_Current_User
This Key points to a branch of Hkey_Users for the user who is currently logged onto the system.

Control Panel Power at your fingertips!

Now, with the technique below, you'll get a cascading menu off of the main Control panel item. All applets are presented as choices in this submenu. In fact, where in the main Control Panel window, you cannot select which applets you'd like to display (or possibly remove), but here, the choices are completely customizable.
In fact, I'd suggest that you try both tips, and let the menu selections reside next to each other. Try them both and see which of the two is a better idea. I'm pretty positive that you will agree with me that the second idea is the way to go.

1. Right click the Start Button. Choose EXPLORE.

2. Explorer opens with a view of the Start Menu.

3. Right click in the right-hand pane.

4. Left click "New" and then "Folder".

5. This will create an icon called "New Folder".

6. Type Binary I.D.# for Control Panel to create a name for this new folder, including the period, braces & hyphens.
Copy ALL next line as name on "new folder".
Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}

7. When finished, press ENTER.

8. Open up this new folder and copy the shortcuts to the Control Panel applets that you want to appear on the cascading menu. Place them in this newly created folder.

9. Close Explorer when finished.

10. The next time that you click on START, the Windows 95 Control Panel's applets appear ready to use in a cascading menu! Very cool!

You can also use this same technique to do the same with your My Computer, Printers, disk drives, and Dial-Up Networking folders. Just make sure that you have the proper binary I.D. for the cascading menu that you are trying to create.
Printers.{2227A280-3AEA-1069-A2DE-08002B30309D}

RESTORE TO LAST SUCCESFULL BOOT

1. Start on DOS

2. Go to win directory

3. Make SYSTEM.DAT/DA0 and USER.DAT/DA0 writable and not hidden:
attrib -h -r -s system.dat ...

4. copy DA0 to DAT

5. restart

osWin'Screen

name::
* McsEngl.osWin'Screen@cptItsoft,

osWin10:
* menu: "Snipping Tool"
* win+G => game bar for Screen recording.
* win+Alt+PrntScreen => screen capture,
===
* http://betanews.com/2015/07/19/windows-10-secret-screen-recording-tool//

osWin'Settings (Control-panel)

name::
* McsEngl.osWin'Settings (Control-panel)@cptItsoft,
* McsEngl.osWin'settings@cptItsoft,
* McsEngl.osWin'configuring@cptItsoft,
* McsEngl.osWin'Control-panel@cptItsoft,
* McsEngl.osWin'configuring@cptItsoft,
* McsEngl.osWin'settings@cptItsoft,

osWin'Account

name::
* McsEngl.osWin'Account@cptItsoft,

Change-local-online-account-signin:
// osWin10
> settings / accounts / signin with account

osWin'Environment-variable

name::
* McsEngl.osWin'Environment-variable@cptItsoft,
* McsEngl.osWin'ENVIRONMENTAL-VARIABLE@cptItsoft,

_DESCRIPTION:
$ set
# display environment-variables.

_SPECIFIC:
* PATH#ql:oswin'path#

Variable Windows XP Windows Vista/7
%ALLUSERSPROFILE% \Documents and Settings\All Users \ProgramData
%APPDATA% \Documents and Settings\{username}\Application Data \Users\{username}\AppData\Roaming
%COMPUTERNAME% {computername} {computername}
%COMMONPROGRAMFILES% \Program Files\Common Files \Program Files\Common Files
%COMMONPROGRAMFILES(x86)% \Program Files (x86)\Common Files (only in 64-bit version) \Program Files (x86)\Common Files (only in 64-bit version)
%COMSPEC% \Windows\System32\cmd.exe \Windows\System32\cmd.exe
%HOMEDRIVE% C: C:
%HOMEPATH% \Documents and Settings\{username} \Users\{username}
%LOCALAPPDATA% \Users\{username}\AppData\Local
%LOGONSERVER% \\{domain_logon_server} \\{domain_logon_server}
%PATH% \Windows\system32;\Windows;\Windows\System32\Wbem;{plus program paths} \Windows\system32;\Windows;\Windows\System32\Wbem;{plus program paths}
%PATHEXT% .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.WSF;.WSH .com;.exe;.bat;.cmd;.vbs;.vbe;.js;.jse;.wsf;.wsh;.msc
%PROGRAMDATA% %SystemDrive%\ProgramData
%PROGRAMFILES% %SystemDrive%\Program Files %SystemDrive%\Program Files
%PROGRAMFILES(X86)% %SystemDrive%\Program Files (x86) (only in 64-bit version) %SystemDrive%\Program Files (x86) (only in 64-bit version)
%PROMPT% Code for current command prompt format. Code is usually $P$G Code for current command prompt format. Code is usually $P$G
%PSModulePath% %SystemRoot%\system32\WindowsPowerShell\v1.0\Modules\
%PUBLIC% %SystemDrive%\Users\Public
{Drive}:\$Recycle.Bin \Recycle.Bin \$Recycle.Bin
%SystemDrive% C: C:
%SystemRoot% The Windows directory, usually \Windows, formerly \WINNT %SystemDrive%\Windows
%TEMP% and %TMP% %SystemDrive%\Documents and Settings\{username}\Local Settings\Temp %SystemDrive%\Users\{username}\AppData\Local\Temp
%USERDOMAIN% {userdomain} {userdomain}
%USERNAME% {username} {username}
%USERPROFILE% %SystemDrive%\Documents and Settings\{username} %SystemDrive%\Users\{username}
%windir% %SystemDrive%\WINDOWS %SystemDrive%\WINDOWS
[http://en.wikipedia.org/wiki/Environment_variable]

osWin'PATH:
\Ruby200\bin;
\TCL\BIN;
\WINDOWS\SYSTEM32;
\WINDOWS;
\WINDOWS\SYSTEM32\WBEM;
\LUA\5.1;
\LUA\5.1\CLIBS;
\MINGW\BIN;
\PROGRA~1\COMMON~1\FOLIOS~1;
\PROGRAM FILES\COMMON FILES\TELECA SHARED;
\PROGRAM FILES\POSTGRESQL\9.1\BIN;
\PROGRAM FILES\MYSQL\MYSQL SERVER 5.5\BIN;
\PROGRAM FILES\MYSQL\MYSQL SERVER 5.5\LIB;
\PROGRAM FILES\TORTOISESVN\BIN;
\PROGRAM FILES\SLIKSVN\BIN;
\Program Files\QuickTime\QTSystem\;
\Program Files\ATI Technologies\ATI.ACE\Core-Static;
\Program Files\Git\cmd;
\Program Files\jEdit;
\Program Files\Java\jdk1.7.0\bin;
\Program Files\nodejs\;
\pgmWEB\pgmDART\dart\dart-sdk\bin;
\pgmJAVA\ANT\180\BIN;
\pgmWEB\pgmOPA\Opa\bin;

Have you tried using

set NODE_ENV=production

This should be executed in the command prompt where you intend to run your node app.

osWin'program-shortcut

name::
* McsEngl.osWin'program-shortcut@cptItsoft,

_win11:
\ProgramData\Microsoft\Windows\Start Menu\Programs\

osWin'Ease-of-access

name::
* McsEngl.osWin'Ease-of-access@cptItsoft,

_win10:
Now go to "Ease of Access -> Other options" page and set the option "Play animations in Windows" to Off.
[http://www.askvg.com/master-tutorial-to-make-windows-10-super-fast/]

osWin'Keyboard

name::
* McsEngl.osWin'Keyboard@cptItsoft,

remove

_win10M:
Remove Keyboards:
If you want to remove a keyboard, you need to press and hold the keyboard you want to remove and you get the option “remove”. Click the remove button and the keyboard will be removed from the system.
[http://www.wpxbox.com/add-keyboards-windows-10-mobile/]

osWin'Personalization

name::
* McsEngl.osWin'Personalization@cptItsoft,

_win10:
Now go to "Personalization -> Colors" page and set the option "Make Start, taskbar, and action center transparent" to Off.
[http://www.askvg.com/master-tutorial-to-make-windows-10-super-fast/]

osWin10

_win10:
* http://www.laptopmag.com/articles/windows-10-settings-to-change,
* Enable System Protection / Create a Restore Point,
* Show File Extensions and Hidden Files,
* Disable User Account Control,
* Disable the Lock Screen: regedit, HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows, Key, DWORD, NoLockScreen, 1.
* Change Your Default Browser: Settings/System/Default-apps
* Speed Up Your Shutdowns: WaitToKillServiceTimeout 2000 (5000 dft)

osWin'time

name::
* McsEngl.osWin'time@cptItsoft,

_win10:
Instructions to fix the Windows 10 time being wrong
Just follow the instructions below and your Windows time problems will disappear.
Press Windows key + r ( + r).
Type services.msc.
Click Windows Time in the Name column.
Alternate click and then click Properties.
Change Startup type to Automatic (if it’s not already set to Automatic).
Click Start if the service isn’t started.
[https://www.organicweb.com.au/20209/general-technology/windows10-time/]

osWin'Storage#cptIt14#

name::
* McsEngl.osWin'Storage@cptItsoft,

fd-80 greek version

WINDOWS95B
DISK D

osWin'structure#cptCore515#

name::
* McsEngl.osWin'structure@cptItsoft,

_winNT:
ΑΡΧΙΤΕΚΤΟΝΙΚΗ ΠΥΚΡΟΠΗΡΥΝΑ

osWin'Tips#cptIt470#

name::
* McsEngl.osWin'Tips@cptItsoft,
* McsEngl.win'issue@cptItsoft,

FILE ASSOCIATIONS:
To view a file with another appl, other than the associated one,
a) add this appl to sendTo folder in windows directory
b) right clik on the file and choose sendTo from the popup menu.
[xml dev 1999may07]

TO ALLOW CAPITAL LETTERS ON FOLDER NAMES:
EXPLORER:
VIEW\FOLDER OPTIONS\VIEW\Allow all uppercase names

SCRIPTING:
Make sure that you have the .js extension registered with wscript.exe. This is the Window Scripting Host executable.
Go to http://msdn.microsoft.com/scripting and download the scripting engine for JScript. You can then install it and it should run.

_PROGRAM_LOCAL_SETTINGS:
* winkey+R goes to win-explorer.

The GitHub folder in the Local and Roaming app data directories

On Windows Vista or higher, delete the %LocalAppData%\GitHub and the %AppData%\GitHub directories.

Tip: To locate these directories, open Windows Explorer, type the directory information into the address bar, and hit Enter.
On Windows XP, delete the %USERPROFILE%\Local Settings\Application Data\GitHub directory. Note that this path may be in a different language if you're using a non-English version of Windows.

ΣΕ ΔΙΚΤΥΑ ΕΙΝΑΙ ΚΑΛΑ ΝΑ ΑΦΗΣΟΥΜΕ ΣΕ ΕΝΑ ΔΙΣΚΟ ΤΟ DOS.

osWin'restore-system

name::
* McsEngl.osWin'restore-system@cptItsoft,
* McsEngl.osWin'recoverty@cptItsoft,

osWin10

Creates restore dvd (double layer):
isoburn /q e: \windows\redvd\RestoreDVD.iso

osWinXp

_winXp:
* open from another os.
* \System Volume Information\_restore\RPxxxx\Snapshot (contains previous restore points)
* copy
_REGISTRY_USER_.DEFAULT
_REGISTRY_MACHINE_SECURITY
_REGISTRY_MACHINE_SOFTWARE
_REGISTRY_MACHINE_SYSTEM
_REGISTRY_MACHINE_SAM
* to \windows\system32\config\
and rename to: default, sam, security, software, system,
[http://support.microsoft.com/kb/307545]

osWin'system-volume-information

name::
* McsEngl.osWin'system-volume-information@cptItsoft,

_winXp:
Windows XP Professional using the NTFS File System on a Workgroup or Standalone Computer

Click Start, and then click My Computer.
On the Tools menu, click Folder Options.
On the View tab, click Show hidden files and folders.
Clear the Hide protected operating system files (Recommended) check box. Click Yes when you are prompted to confirm the change.
Clear the Use simple file sharing (Recommended) check box.
Click OK.
Right-click the System Volume Information folder in the root folder, and then click Properties.
Click the Security tab.
Click Add, and then type the name of the user to whom you want to give access to the folder. Typically, this is the account with which you are logged on. Click OK, and then click OK again.
Double-click the System Volume Information folder in the root folder to open it.
[http://support.microsoft.com/kb/309531]

XP

win'DISK'PARTITIONING:
* run diskpart
* list disk
* select disk
* clean = clean the partitions
* create partition
* assign = assigns a letter
* format the disk.
[hmnSngo.2003-02-25]

win'RECORDING:
At control-panel/sound/recording/recording-control
WE must have select "MICROFHONE" in order to be able to record through microphone.

win'RECOVERY'CONSOLE:
* start on CD setup
* xit R when ask for instalation.

win'SAFEMODE:
* hit F8 at startup.

osWin'Tool

name::
* McsEngl.osWin'Tool@cptItsoft,

_XP_PRO:
*** environmental variables:
- πίνακας-ελέγχου, σύστημα, για προχωρημένους, μεταβλητές-περιβάλλοντος.
===
* osWin'msinfo32:
- shows system info.
===
* osWin'msconfig:
configures boot.ini, win.ini, etc.
===
* osWin'explorer:
The file manager program.
'explorer \Documents and Settings\HoKoNoUmo\Application Data\jEdit\'

osWin'UWP

_CREATED: {2016-08-23}

name::
* McsEngl.osWin'UWP@cptItsoft,
* McsEngl.Universal-Windows-Platform@cptItsoft,
* McsEngl.UWP@cptItsoft,
* McsEngl.Universal-Windows-Platform@cptItsoft,
* McsEngl.UWP@cptItsoft,
* McsEngl.uwa@cptItsoft,

_DESCRIPTION:
Universal Windows Platform (UWP), is a platform-homogeneous application architecture created by Microsoft and first introduced in Windows 10. The purpose of this software platform is to help develop Universal apps that run on both Windows 10 and Windows 10 Mobile without the need to be re-written for each. It supports Windows application development using C++, C#, VB.NET, or XAML. The API is implemented in C++, and supported in C++, VB.NET, C#, F# and JavaScript.[1] Designed as an extension to the Windows Runtime platform first introduced in Windows Server 2012 and Windows 8, the UWP allows developers to create applications that will potentially run on multiple types of devices.[2]
[https://en.wikipedia.org/wiki/Universal_Windows_Platform]

uwp'Desktop-application-converter

name::
* McsEngl.uwp'Desktop-application-converter@cptItsoft,

_ADDRESS.WPG:
* https://msdn.microsoft.com/en-us/windows/uwp/porting/desktop-to-uwp-run-desktop-app-converter,

SPECIFIC

* osWin.specific,

osWin.WIN10

name::
* McsEngl.osWin.WIN10@cptItsoft,
* McsEngl.osW10@cptItsoft,
* McsEngl.win10@cptItsoft,

_ADDRESS.WPG:
* https://www.pcsteps.gr/75566-αναβάθμιση-windows-10-από-7-και-8-1-χωρίς-κράτηση//
* http://www.theverge.com/2015/5/7/8568473/windows-10-last-version-of-windows: Why Microsoft is calling Windows 10 'the last version of Windows'
* http://www.techradar.com/news/software/operating-systems/10-great-new-features-in-windows-10-1267365,

osWin.Win10Mobile (osW10m)

name::
* McsEngl.osWin.Win10Mobile (osW10m)@cptItsoft,
* McsEngl.osW10m@cptItsoft,

osW10m'Universal-apps

name::
* McsEngl.osW10m'Universal-apps@cptItsoft,

3) Windows 10 Mobile: Universal Apps
A really cool feature of Windows 10 Mobile is that it uses a universal app system that allows devices written for Windows 10 on a PC to be easily ported to Windows 10 Mobile devices. This essentially means that any app made for the PC can run on a Windows 10 Mobile device with not much code tweaking involved.
[http://www.knowyourmobile.com/mobile-phones/windows-10/23234/windows-10-mobile-release-date-features]

osW10m'WiFi

name::
* McsEngl.osW10m'WiFi@cptItsoft,

_DESCRIPTION:
When I changed password, I had to RESTART the-device to be connected.
[hmnSngo.2017-02-25]

osWin.Win9

name::
* McsEngl.osWin.Win9@cptItsoft,
* McsEngl.win9@cptItsoft,

_DESCRIPTION:
Next year, though, when Windows 9 is released across every form factor and unifies the app ecosystem across smartphones, tablets, and desktops, then Microsoft actually stands a chance against Google and Apple.
[http://www.extremetech.com/computing/168168-windows-9-will-unify-the-smartphone-tablet-desktop-and-console-but-is-it-too-little-too-late, October 8, 2013]

osWin.WinXP

name::
* McsEngl.osWin.WinXP@cptItsoft,

Η Κίνα επιμένει με Windows XP
Τετάρτη, 23 Απριλίου 2014 16:03 UPD:16:03
EPA/JENS BUETTNER
Υπολογίζεται ότι ποσοστό 70% των προσωπικών υπολογιστών στη χώρα συνεχίζει να χρησιμοποιεί XP (φωτογραφία αρχείου).
Η Κινεζική κυβέρνηση θα συνεχίσει να χρησιμοποιεί τροποποιημένες εκδόσεις του λειτουργικού συστήματος Windows XP, καθώς θεωρεί ότι η αναβάθμιση στο Windows 8 θα ήταν πολύ ακριβή.
Η υποστήριξη του λειτουργικού συστήματος Windows XP από τη Microsoft έπαψε, επίσημα, στις 8 Απριλίου, ωστόσο η κινεζική αγορά παραμένει προσηλωμένη σε αυτό. Μάλιστα, τα XP συνεχίζουν να αποτελούν το κύριο λειτουργικό σύστημα της κινεζικής δημόσιας διοίκησης.
Υπολογίζεται ότι ποσοστό 70% των προσωπικών υπολογιστών στη χώρα συνεχίζει να χρησιμοποιεί XP, δηλαδή ένας αριθμός περίπου 200 εκατομμυρίων συστημάτων, σύμφωνα με έρευνα της StatCounter. Αξίζει να σημειωθεί ότι το ποσοστό χρήσης των XP στις ΗΠΑ έχει περιοριστεί στο ποσοστό του 18%.
Σύμφωνα με δηλώσεις του αναπληρωτή διευθυντή της κινεζικής Εθνικής Διεύθυνσης Πνευματικών Δικαιωμάτων, Yan Xiaohong, στο δίκτυο Sky, η αναβάθμιση σε κάποια νεότερη έκδοση των Windows δεν εξετάζεται καν. Ο λόγος είναι καθαρά οικονομικός.
Η Διεύθυνση υπολόγισε ότι για κάθε άδεια χρήσης των Windows 8 το κόστος, στην Κίνα, θα ήταν περί τα 103 ευρώ, ενώ με ειδικές εκπτώσεις το ποσό αυτό θα μπορούσε να κατέβει στα 35 ευρώ. Ωστόσο, ακόμη και έτσι το συνολικό κόστος για τον κινεζικό δημόσιο τομέα θεωρήθηκε υπερβολικό.
Παράλληλα, σε αντίθεση με κυβερνητικές υπηρεσίες ευρωπαϊκών χωρών, η Κίνα δεν θα προχωρήσει ούτε και σε συμφωνία επέκτασης υποστήριξης για τα XP με τη Microsoft. Αντίθετα, σύμφωνα με τον Yan, κινεζικές εταιρείες ασφαλείας εργάζονται ήδη ώστε να αναπτύξουν πακέτα βελτίωσης του παλαιού λειτουργικού συστήματος, σε μια προσπάθεια να περιοριστούν τα κενά ασφαλείας.
[http://www.naftemporiki.gr/story/798811/i-kina-epimenei-me-windows-xp]

osWin.EVOLUTING#cptCore546.171#

name::
* McsEngl.osWin.EVOLUTING@cptItsoft,
* McsEngl.osWin.evoluting@cptItsoft,

{time.2015-07-29}:
=== win10 release

{time.2012}:
=== windows 8 on octomber.

2009-10-22:
win7 release.

2001-10-25:
win xp released.

2000.09:
win me. release (H τελευταία έκδοση που είναι συνέχεια των 16μπιτων windows).

2000.02:
win 2000: release.

* 2000:
64bit θα έχουν δημιουργηθεί.
[RAM, JAN. 1996, 28]

{time.1998}:
1998jun25:
Windows launch muted in Europe
By Reuters
Special to CNET NEWS.COM June 25, 1998, 1:30 p.m. PT Windows 98 hit the ground walking in Europe today.
Overshadowed by the continent's frenzied infatuation with World Cup soccer and its bitter antitrust suit, Microsoft is soft-peddling its latest operating system. The software giant kept advertising to a minimum and actually delayed the launch in some countries, mindful of summer vacation
Windows 98 was launched in 40 countries around the world today, but in Europe it only hit the store shelves in Britain and in local language versions in Germany and Spain.
=== 1998jun:
windows 98
===
1998.06:
win 98. release.

1997:
win nt 4.0: release.

1995.08:
win 95.
===
1995aug:
win 95, Το πρώτο αμιγές παραθυρικό λειτουργικό σύστημα για την καταναλωτική αγορά.
[RAM, 1998jun, 102]

1994.09:
win nt 3.5 κυκλοφόρησαν.
[RAM, 1998jun, 102]

1993.05:
win nt 3.1

1992.04:
win 3.1: release.

1988:
win nt: ξεκινά ο σχεδιασμός (καθαρός 32μπιτος κώδικας).

1985.06:
win 1.0: κυκλοφορία.

1983.11:
Η επίσημη αναγγελία των windows.

os.Windows3.1

name::
* McsEngl.conceptItsoft872,
* McsEngl.microsoft windows 3.1@cptItsoft,
* McsEngl.os.windows3.1@cptItsoft872,
* McsEngl.windows3.1@cptItsoft872,

DEFINITION

WINDOWS is a gui STAND-ALONE-OS#cptIt11# of microsoft company, that works with the DOS.
[nikos, June 1995]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
STAND-ALONE OS#cptIt11#

INFO-TECH-BUSINESS#cptEconomy7.108#

MICROSOFT#cptItorg1672#

EVALUATION#cptCore546.107#

Τα windows 3.1 καινοτομουν σε τρεις βασικους τομεις:
1.παροχη διανυσματικων γραμματοσειρων, TrueType
2.βελτιωση της DDE (Δυναμικης Ανταλλαγη Δεδομενων) που πετυχαινε αμφιδρομες διασυνδεσεις προγραμματων.
3. Ενσωματωμενες multimedia extensions.

EVOLUTION#cptCore546.171#

FUTURE:
- WIN 32s(subset), ΕΠΕΚΤΑΣΗ ΤΟΥ 3.1 (ΚΥΚΛΟΦΟΡΕΙ ΙΟΥΝΙΟ 93)
- CHICAGO, ΣΧΕΔΙΑΖΕΤΑΙ WINDOWS4-DOS7

VERSION#cptIt471#

1993.11:
windows 3.11

1992.04:
έκδοση 3.1, έλαβε χώρα η μεγάλη έκρηξη.
[RAM, 1998.06, 102]

1990.05:
version 3.0
[RAM, 1998.06, 102]

1987:
έκδοση 2.0

1985.11:
έκδοση 1.0
[RAM, 1998.06, 102]

1983.11:
Πρώτη δημόσια ανακοίνωση, πριν κυκλοφορήσει ο Mac.
[RAM, 1998.06, 102]

1981.09:
Αρχισε να εργάζεται στο προϊόν.
[RAM, 1998.06, 102]

DOING#cptCore475#

operating-system#cptIt444-8#

STORAGE#cptIt14#

The back up is from the 5.25 because I have the greek windows only in 5.25 format.

TIPS#cptIt470#

ΕΓΚΑΤΑΣΤΑΣΗ:
ΕΠΕΙΔΗ ΤΑ ΕΛΛΗΝΙΚΑ ΗΤΑΝ ΣΕ 5.25 ΔΙΣΚΕΤΑ, Η ΕΓΚΑΤΑΣΤΑΣΗ ΕΓΙΝΕ ΜΕ ΤΙΣ ΜΕΓΑΛΕΣ ΔΙΣΚΕΤΕΣ, ΟΙ ΜΙΚΡΕΣ ΔΕΝ ΔΟΥΛΕΥΑΝ.
ΤΑ BACK UP ΠΟΥ ΚΡΑΤΗΣΑ, ΕΝΩ ΕΙΝΑΙ 3.5 ΔΙΣΚΕΤΕΣ, ΠΕΡΙΕΧΟΥΝ ΤΗΝ ΣΕΙΡΑ ΤΩΝ ΑΡΧΕΙΩΝ ΤΩΝ 5.25 ΔΙΣΚΕΤΩΝ.

WIN /S:
Run in standard mode.

WIN /3:
Run in 386 enhanced mode.

ΑΠΟΘΗΚΕΥΣΗ ΟΘΟΝΩΝ:
--παταμε "print screen" και στο Paintbrush ενεργοποιούμε το Paste. "alt"+"print screen"= μόνο το ενεργό παράθυρο.
--ΑΝ ΤΟ ΠΡΟΓΡΑΜΜΑ ΕΙΝΑΙ DOS, ΓΙΑ ΝΑ ΠΑΡΟΥΜΕ ΤΗΝ ΟΘΟΝΗ ΑΡΚΕΙ ΝΑ ΤΟ ΒΑΛΟΥΜΕ ΣΕ WINDOW ΚΑΙ ΟΧΙ ΣΕ FULL SCREEN.

START UP:
ΚΡΑΤΩΝΤΑΣ ΤΟ ΚΟΥΜΠΙ SHIFT ΟΤΑΝ ΑΝΟΙΓΕΙ ΤΟ ΠΡΟΓΡΑΜΜΑ ΔΕΝ ΤΡΕΧΟΥΝ ΤΑ ΠΡΟΓΡΑΜΜΑΤΑ ΠΟΥ ΒΡΙΣΚΟΝΤΑΙ ΣΤΟ START UP.

ΝΑ ΜΗ ΚΛΙΝΟΥΜΕ ΤΟ ΚΟΜΠΟΥΤΕΡ ΜΕ WINDOWS ΑΝΟΙΚΤΑ.

CARDS PROGRAM:
ΕΝΑΣ ΤΡΟΠΟΣ ΝΑ ΠΑΡΟΥΜΕ ΤΑ ΠΕΡΙΕΧΟΜΕΝΑ ΑΠΟ ΤΙΣ ΚΑΡΤΕΣ ΕΙΝΑΙ ΝΑ ΤΥΠΩΣΟΥΜΕ ΣΕ ΑΡΧΕΙΟ. ΟΜΩΣ ΣΑΝ ΝΤΙΦΟΛΤ ΕΚΤΥΠΩΤΗ ΝΑ ΒΑΛΟΥΜΕ GENERIC, ΚΑΙ ΣΤΟΥΣ ΕΠΕΚΤΑΣΙΜΟΥΣ ΧΑΡΑΚΤΗΡΕΣ ΤΟΥ ΝΑ ΒΑΛΟΥΜΕ ΟΤΙ ΦΑΙΝΕΤΑΙ ΣΤΗΝ ΟΘΟΝΗ ΝΑ ΕΙΝΑΙ ΚΑΙ ΣΤΟΝ ΕΚΤΥΠΩΤΗ.

WIN.INI

Κάθε αλλαγή που γίνεται, λαμβάνει χώρα όταν ξανατρέξουν από την αρχή τα windows.
[NIKOS, MAR. 1996]

os.Windows_FOR_WORKGROUPS

name::
* McsEngl.conceptItsoft871,
* McsEngl.wfw@cptItsoft871,
* McsEngl.Windows for workgroups: MICROSOFT@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#

INFO-TECH-BUSINESS#cptEconomy7.108#

MICROSOFT#cptItorg1672#

EVALUATION#cptCore546.107#

Είναι το ΠΙΟ ΓΝΩΣΤΟ δίκτυο peer-to-peer.
[COMPUTER GO, APRIL 1995, 79]

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

3.1

DOING#cptCore475#

operating-system#cptIt444-8#

ΕΙΝΑΙ ΕΝΑ ΟΜΟΤΙΜΟ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ ΔΙΚΤΥΟΥ. ΔΙΑΘΕΤΕΙ
* ΠΡΟΣΒΑΣΗ ΣΕ ΔΙΚΤΥΑ ΠΕΛΑΤΗ-ΕΞΥΠΗΡΕΤΗΤΗ
* ΗΛΕΚΤΡΟΝΙΚΟ ΤΑΧΥΔΡΟΜΕΙΟ
* ΠΡΟΓΡΑΜΜΑΤΙΣΜΟ ΧΡΟΝΟΥ ΤΩΝ ΧΡΗΣΤΩΝ ΕΡΓΟΜΑΔΩΝ.

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

HARDWARE: 286, 2MB RAM, NETWORK CARD.
MEMORY: ΤΟ ΠΡΑΚΤΙΚΟ ΜΙΝΙΜΟΥΜ ΕΙΝΑΙ 6-8 ΜΒ.

os.Windows_mobile

_CREATED: {2008-05-05}

name::
* McsEngl.conceptItsoft1014,
* McsEngl.windows-mobile@cptItsoft1014,
* McsEngl.osWinM@cptItsoft,
* McsEngl.winMbl@cptItsoft1014, {2012-11-06}
* McsEngl.wm-itsoft1014@cptItsoft,

DEFINITION

_DESCRIPTION:
Windows Mobile is a family of mobile operating system developed by Microsoft for smartphones and Pocket PCs.[2] Windows Mobile is the predecessor of Windows Phone. In February 2010, Microsoft announced Windows Phone to supersede Windows Mobile, with the new operating system incompatible with Windows Mobile devices and software.[3] As a result, Windows Mobile has been discontinued.
The final version of Windows Mobile, released after the announcement of Windows Phone, was 6.5.5. Microsoft has stated that the Windows Phone operating system is incompatible with devices designed for Windows Mobile as "Windows Mobile 6.x devices do not meet Windows Phone hardware requirements designed to ensure a consistent user and developer experience",[4] and software designed for Windows Mobile is incompatible with the new operating system.[5]
[http://en.wikipedia.org/wiki/Windows_Mobile] {2012-11-06}

wm'GENERIC

_GENERIC:
* program.system.os.mobile#cptItsoft1014#

wm'SHORTCUTS

name::
* McsEngl.wm'SHORTCUTS@cptItsoft,

Understanding Windows Mobile Shortcuts

Shortcuts provides users an easier way to launch applications. On a WM device, a user can tap on a shortcut and the associated application will be launched automatically. Shortcuts can contain target application path along with any neccessary parameter information.

Users can create their own shortcuts by:

1. Establishing ActiveSync connection between the device and the desktop computer.
2. Explore the Mobile Device folder and browse to the folder which contains the target file/folder.
3. Right-click on the target and select Create Shortcut menu item. This will generate a shortcut (.lnk) file in the same folder.
4. Move or copy the shortcut if you want it anywhere else on the device.

Format of Windows Mobile Shortcut (.lnk) files

To know the format of a shortcut, copy the shortcut or .lnk file to the desktop and open it in a text editor such as Notepad. A typical shortcut on a Windows Mobile device will have the following format

xx#"\{PATH}\{APPLICATION_NAME}"

where xx is number of characters in the above text excluding xx#.

For e.g.

23#"\Windows\iexplore.exe" is content of a shortcut to Pocket Internet Explorer

where 23 is the count of characters after#.
and \Windows\iexplore.exe is the target path
Posted on: Nov 22, 2007
[http://www.askarya.com/articles/winmobile_shortcuts.asp]

os.MOBILE

_CREATED: {2012-11-06}

name::
* McsEngl.conceptItsoft1016,
* McsEngl.mobile-operating-system@cptItsoft1016, {2012-11-06}
* McsEngl.osMbl@cptItsoft1016,

DEFINITION

A mobile operating system, also referred to as mobile OS, is the operating system that operates a smartphone, tablet, PDA, or other digital mobile devices. Modern mobile operating systems combine the features of a personal computer operating system with touchscreen, cellular, Bluetooth, WiFi, GPS mobile navigation, camera, video camera, speech recognition, voice recorder, music player, Near field communication, personal digital assistant (PDA), and other features.
[http://en.wikipedia.org/wiki/Mobile_operating_system]

osMbl'GENERIC

_GENERIC:
* program.system.os#cptItsoft1111#

SPECIFIC

name::
* McsEngl.osMbl.specific@cptItsoft,

_SPECIFIC:
* osMbl.android#cptItsoft1017#
* osMbl.windows_mobile#cptItsoft1014#

os.mobile.ANDROID {2007} (osArd)

_CREATED: {2012-11-06}

name::
* McsEngl.conceptItsoft1017,
* McsEngl.Android-os@cptItsoft,
* McsEngl.osArd@cptItsoft,
* McsEngl.android@cptItsoft, {2012-11-06}
* McsEngl.os.android@cptItsoft,
* McsEngl.osAndroid@cptItsoft,
* McsEngl.osArd@cptItsoft,
* McsEngl.osAnd@cptItsoft,

DEFINITION

Android was developed by a small startup company that was purchased by Google Inc. in 2005, and Google continues to update the software. Android is a Linux-derived OS backed by Google, along with major hardware and software developers (such as Intel, HTC, ARM, Samsung, Motorola and eBay, to name a few), that form the Open Handset Alliance.[6] Released on November 5th 2007, the OS received praise from a number of developers upon its introduction.[7] Android releases prior to 2.0 (1.0, 1.5, 1.6) were used exclusively on mobile phones. Most Android phones, and some Android tablets, now use a 2.x release. Android 3.0 was a tablet-oriented release and does not officially run on mobile phones. The current Android version is 4.1. Android releases are nicknamed after sweets or dessert items like Cupcake (1.5), Frozen Yogurt (2.2), Honeycomb (3.0), Ice Cream Sandwich (4.0) and Jelly Bean (4.1). Most major mobile service providers carry an Android device. Since the HTC Dream was introduced, there has been an explosion in the number of devices that carry Android OS. From Q2 of 2009 to the second quarter of 2010, Android's worldwide market share rose 850% from 1.8% to 17.2%. On 15 November 2011, Android reached 52.5% of the global smartphone market share.[8]
[http://en.wikipedia.org/wiki/Mobile_operating_system] {2012-11-06}

osArd'GENERIC

_GENERIC:
* program.system.os.mobile#cptItsoft1014#
===
It can be thought of as a mobile operating system. But it is not limited to mobile only. It is currently used in various devices such as mobiles, tablets, televisions etc.
[http://www.javatpoint.com/android-tutorial]

osArd'relation-to-linux

name::
* McsEngl.osArd'relation-to-linux@cptItsoft,

_DESCRIPTION:
Yes, Android is Linux. It was always Linux. There were differences at one time, but Android officially rejoined the Linux family in March 2012.
[http://www.zdnet.com/the-most-popular-end-user-linux-distributions-are-7000017223/]

osArd'ATTRIBUTE#cptCore546.174#

name::
* McsEngl.osArd'ATTRIBUTE@cptItsoft,

_ATTRIBUTE:
Company / developer Google
Open Handset Alliance
Android Open Source Project
Programmed in C, C++, Java[1]
OS family Unix-like, Linux
Working state Current
Source model Open source[2]
Initial release September 23, 2008[3]
Latest stable release 4.2.1 Jelly Bean / November 27, 2012; 4 days ago[4][5]
Marketing target Smartphones
Tablet computers
Available language(s) Multi-lingual
Package manager Google Play, APK
Supported platforms ARM, MIPS,[6] x86[7]
Kernel type Monolithic (modified Linux kernel)
Default user interface Graphical (Multi-touch)
License Apache License 2.0
Linux kernel patches under GNU GPL v2[8]
Official website www.android.com
[http://en.wikipedia.org/wiki/Android_(operating_system)]

osArd'Android-studio (pgmAds)

name::
* McsEngl.osArd'Android-studio (pgmAds)@cptItsoft,
* McsEngl.android-studio@cptItsoft,
* McsEngl.pgmAds@cptItsoft,
* McsEngl.program.android-studio@cptItsoft,

_ADDRESS.WPG:
* https://developer.android.com/studio/install.html,

osArd'App (pard)

name::
* McsEngl.osArd'App (pard)@cptItsoft,
* McsEngl.ardp@cptItsoft,
* McsEngl.pard@cptItsoft,
* McsEngl.pgm.android@cptItsoft,
* McsEngl.program.android@cptItsoft,

* McsEngl.ardp@cptItsoft,
* McsEngl.osArd'program@cptItsoft,
* McsEngl.pgmArd@cptItsoft,

_GENERIC:
* mobile-program#ql:pgmcmr.mobile#

pard'DEFINITION

name::
* McsEngl.pard'DEFINITION@cptItsoft,

_DESCRIPTION:
Android applications are usually developed in the Java language using the Android Software Development Kit.
[https://www.tutorialspoint.com/android/android_overview.htm]
===
Google releases the Android code as open source, under the Apache License.[11] The Android Open Source Project (AOSP), led by Google, is tasked with the maintenance and further development of Android.[12] Additionally, Android has a large community of developers writing applications ("apps") that extend the functionality of devices, written primarily in a customized version of Java.[13] They are available for download through Google Play or third-party sites. In October 2012, there were approximately 700,000 apps available for Android, and the estimated number of applications downloaded from Google Play (and the now-defunct Android Market) was 25 billion.[14][15]
[http://en.wikipedia.org/wiki/Android_(operating_system)]

pard'API

name::
* McsEngl.pard'API@cptItsoft,
* McsEngl.ardapi@cptItsoft,

ardapi.VERSION

name::
* McsEngl.ardapi.VERSION@cptItsoft,
* McsEngl.ardapi-level@cptItsoft,

What is API level?
API Level is an integer value that uniquely identifies the framework API revision offered by a version of the Android platform.

Platform Version API Level VERSION_CODE
Android 6.0 ardapi.23 MARSHMALLOW
Android 5.1 ardapi.22 LOLLIPOP_MR1
Android 5.0 ardapi.21 LOLLIPOP
Android 4.4W ardapi.20 KITKAT_WATCH KitKat for Wearables Only
Android 4.4 ardapi.19 KITKAT
Android 4.3 ardapi.18 JELLY_BEAN_MR2
Android 4.2,
Android 4.2.2 ardapi.17 JELLY_BEAN_MR1
Android 4.1,
Android 4.1.1 ardapi.16 JELLY_BEAN
Android 4.0.3,
Android 4.0.4 ardapi.15 ICE_CREAM_SANDWICH_MR1
Android 4.0, 4.0.1,
Android 4.0.2 ardapi.14 ICE_CREAM_SANDWICH
Android 3.2 ardapi.13 HONEYCOMB_MR2
Android 3.1.x ardapi.12 HONEYCOMB_MR1
Android 3.0.x ardapi.11 HONEYCOMB
Android 2.3.4
Android 2.3.3 ardapi.10 GINGERBREAD_MR1
Android 2.3.2
Android 2.3.1
Android 2.3 ardapi.9 GINGERBREAD
Android 2.2.x ardapi.8 FROYO
Android 2.1.x ardapi.7 ECLAIR_MR1
Android 2.0.1 ardapi.6 ECLAIR_0_1
Android 2.0 ardapi.5 ECLAIR
Android 1.6 ardapi.4 DONUT
Android 1.5 ardapi.3 CUPCAKE
Android 1.1 ardapi.2 BASE_1_1
Android 1.0 ardapi.1 BASE
[https://www.tutorialspoint.com/android/android_overview.htm]

pard'APK

name::
* McsEngl.pard'APK@cptItsoft,
* McsEngl.apk-file@cptItsoft,
* McsEngl.APK-file@cptItsoft,
* McsEngl.Android-application-package-file@cptItsoft,
* McsEngl.osArd'APK@cptItsoft,

_ADDRESS.WPG:
* https://www.androidpit.com/android-for-beginners-what-is-an-apk-file,

_DESCRIPTION:
Android application package file (APK) is the file format used to distribute and install application software and middleware onto Google's Android operating system. To make an APK file, a program for Android is first compiled, and then all of its parts are packaged into one file. This holds all of that program's code (such as .dex files), resources, assets, certificates, and manifest file. As is the case with many file formats, APK files can have any name needed, but must end with the four character, three letter extension, .apk.[1][2][3][4]

APK files are ZIP file formatted packages based on the JAR file format, with .apk file extensions. The MIME type associated with APK files is application/vnd.android.package-archive.[5]

[edit]Contents

An APK file is an archive that usually contains the following folders:

META-INF directory:
MANIFEST.MF: the Manifest file
CERT.RSA: The certificate of the application.
CERT.SF: The list of resources and SHA-1 digest; for example:
Signature-Version: 1.0
Created-By: 1.0 (Android)
SHA1-Digest-Manifest: wxqnEAI0UA5nO5QJ8CGMwjkGGWE=
...
Name: res/layout/exchange_component_back_bottom.xml
SHA1-Digest: eACjMjESj7Zkf0cBFTZ0nqWrt7w=
...
Name: res/drawable-hdpi/icon.png
SHA1-Digest: DGEqylP8W0n0iV/ZzBx3MW0WGCA=
lib: the directory containing the compiled code that is specific to a software layer of a processor, the folder is split into more folders within it:
armeabi: compiled code for all ARM based processors only
armeabi-v7a: compiled code for all ARMv7 and above based processors only
x86: compiled code for x86 processors only
mips: compiled code for MIPS processors only
res: the directory containing resources not compiled into resources.arsc (see below).
AndroidManifest.xml: An additional Android manifest file, describing the name, version, access rights, referenced library files for the application. This file may be in Android binary XML that can be converted into human-readable plaintext XML with tools such as AXMLPrinter2, apktool, or Androguard.
classes.dex: The classes compiled in the dex file format understandable by the Dalvik virtual machine
resources.arsc : a file containing pre-compiled resources, such as binary XML for example.
[http://en.wikipedia.org/wiki/APK_(file_format)]

pard'doing.CLOSING

name::
* McsEngl.pard'doing.CLOSING@cptItsoft,

_ADDRESS.WPG:
* http://www.wikihow.com/Close-Apps-on-Android,

_DESCRIPTION:
1) recent-menu
2) settings/app/running
3) Quitting the-app
[http://www.wikihow.com/Close-Apps-on-Android]

pard'Resource

name::
* McsEngl.pard'Resource@cptItsoft,

_DESCRIPTION:
* https://developer.android.com/training/basics/firstapp/index.html,

pard'store.Amazon-Appstore

name::
* McsEngl.pard'store.Amazon-Appstore@cptItsoft,
* McsEngl.osArd'Amazon-Appstore@cptItsoft,

The Amazon Appstore is a mobile application store for the Google Android operating system and was opened on March 22, 2011. Available in US, UK, [2] Germany, France, Italy and Spain[3] only, it was launched with around 3,800 applications both free or paid. Developers are paid 70% of the list price.[4]

On September 28, 2011, Amazon unveiled a new low-cost tablet, the Kindle Fire.[5] This tablet, which is designed for media consumption in the Amazon ecosystem, relies solely on the Amazon Appstore for its marketplace, eschewing Google's Market. Alongside the tablet was a new design for the Amazon Appstore designed to better integrate with the tablet's user interface.

The Amazon Appstore includes a "free app a day" feature.[6] Every day, an application, frequently a game, is offered for free. On the launch day, this game was Angry Birds Rio (Ad-Free), in itself a promotional game.[7] On The European launch day the free app was Angry Birds (Ad-Free). The Free App of the Day feature makes an exception to Amazon's 20% of list price term, giving the developer 0% of the list price during the feature day.[8]

The store's "Test Drive" feature allows users to try an application in their web browser by launching a virtual copy of Android in the Amazon EC2 cloud for half an hour.[9]

The Amazon Appstore was originally only available in the US[10] but on 30 August 2012 it was made available in many European countries including the UK[11]
[http://en.wikipedia.org/wiki/Amazon_Appstore]

pard'store.Google-play

name::
* McsEngl.pard'store.Google-play@cptItsoft,
* McsEngl.osArd'Google-play@cptItsoft,

Google Play, formerly known as the Android Market, is a digital application distribution platform for Android developed and maintained by Google. The service allows users to browse and download music, magazines, books, movies, television programs, and applications that were published through Google.

Applications are available either for free or at a cost, and they can be downloaded directly to an Android or Google TV device through the Play Store or onto a personal computer via its website.[1][2] These applications are generally targeted to users based on a particular hardware attribute of their device, such as a motion sensor (for motion-dependent games) or a front-facing camera (for online video calling).

On March 6, 2012, with the merging of the Android Market and Google Music, the service was renamed Google Play to coincide with the rebranding of Google's digital distribution strategy.[3]
[http://en.wikipedia.org/wiki/Google_Play]

SPECIFIC

pard.LOCATION-SERVICES

name::
* McsEngl.pard.LOCATION-SERVICES@cptItsoft,

_ADDRESS.WPG:
* https://www.tutorialspoint.com/android/android_location_based_services.htm,

pard.Google-authenticator

name::
* McsEngl.pard.Google-authenticator@cptItsoft,

_DESCRIPTION:
* https://g.co/2sc for settings,

osArd'Dalvik-virtual-machine (DVM)

name::
* McsEngl.osArd'Dalvik-virtual-machine (DVM)@cptItsoft,
* McsEngl.dalvik-virtual-machine@cptItsoft,
* McsEngl.dvm@cptItsoft,

_DESCRIPTION:
Dalvik Virtual Machine | DVM

As we know the modern JVM is high performance and provides excellent memory management. But it needs to be optimized for low-powered handheld devices as well.

The Dalvik Virtual Machine (DVM) is an android virtual machine optimized for mobile devices. It optimizes the virtual machine for memory, battery life and performance.

Dalvik is a name of a town in Iceland. The Dalvik VM was written by Dan Bornstein.

The Dex compiler converts the class files into the .dex file that run on the Dalvik VM. Multiple class files are converted into one dex file.

Let's see the compiling and packaging process from the source file:

Dalvik Virtual Machine Flow
The javac tool compiles the java source file into the class file.

The dx tool takes all the class files of your application and generates a single .dex file. It is a platform-specific tool.

The Android Assets Packaging Tool (aapt) handles the packaging process.
[http://www.javatpoint.com/dalvik-virtual-machine]

osArd'Organization

name::
* McsEngl.osArd'Organization@cptItsoft,

osArdogn.OHA {2007}

name::
* McsEngl.osArdogn.OHA {2007}@cptItsoft,

What is Open Handset Alliance (OHA)

It's a consortium of 84 companies such as google, samsung, AKM, synaptics, KDDI, Garmin, Teleca, Ebay, Intel etc.

It was established on 5th November, 2007, led by Google. It is committed to advance open standards, provide services and deploy handsets using the Android Plateform.
[http://www.javatpoint.com/android-what-where-and-why]

osArd'ResourceInfHmnn#cptResource843#

name::
* McsEngl.osArd'ResourceInfHmnn@cptItsoft,

_ADDRESS.WPG:
* http://www.android.com//
* http://www.codeproject.com/Articles/802449/Article-Introduction-to-Android,
* http://www.codeproject.com/Articles/802352/Create-Your-st-Android-Application,
=== developing
* https://developer.android.com/training/index.html,

osArd'Security

name::
* McsEngl.osArd'Security@cptItsoft,

_ADDRESS.WPG:
* https://www.grahamcluley.com/2016/03/android-trojan-intercepts-sms-messages-bank-accounts//

osArd'Settings

name::
* McsEngl.osArd'Settings@cptItsoft,

osArd'Sim-card-pin

name::
* McsEngl.osArd'Sim-card-pin@cptItsoft,

_DESCRIPTION:
In the Settings menu, choose Security, then Set up SIM card lock.
[http://www.groovypost.com/howto/android-disable-change-pin-code/]

osArd'DOING

name::
* McsEngl.osArd'DOING@cptItsoft,

osArd'connecting-to-computer

name::
* McsEngl.osArd'connecting-to-computer@cptItsoft,

_DESCRIPTION:
1) cable
2) swiping down for settings
3) USB usage: file transfering,

osArd'find-lost-phone

name::
* McsEngl.osArd'find-lost-phone@cptItsoft,

ANDROID
How to Find a Lost Android Phone Using Google Search
Joel Lee November 18, 2016 1 minute
Nowadays, there are few mundane mistakes as costly and annoying as losing one’s phone. It could fall out of your pocket as you exit a cab, or you could accidentally leave it at the library, or it might be lifted off of you when you aren’t looking.

When this happens, the usual answer is to use something like Android Device Manager or one of these third-party phone locator apps. But the next time this happens, you might fare better with this simple Google Search trick.

But first, in order for this to work:

Install the Google App.
Log into the app with your Google account.
In it, Now Cards must be enabled.
In it, Web & App Activity must be enabled.
Location reporting must be set to High Accuracy.
Once all of that is set up, searching for your phone is simple.

Open a web browser on your PC.
Log into the same Google account as your phone.
Type find my phone into Google Search.
This will bring up a map view with the pinpointed location of your device. Is it accurate to its exact location? No, but it gets pretty close — about 50–100 feet.

If you’re close to it but still need more help locating the device, you can click on the Ring button in the map view. This will cause your device to ring loudly for up to 5 minutes, instantly giving away the device’s position. Once found, you can disable ringing by hitting the Power button.

Just be careful that you never give away your Google account details, otherwise someone can log into it and ring your phone at any time from anywhere!

What do you do when you’ve lost your Android phone? How often do you lose it, anyway? Let us know in the comments!
[http://www.makeuseof.com/tag/find-lost-android-phone-using-google-search/]

osArd'run-winapp-on-phone

name::
* McsEngl.osArd'run-winapp-on-phone@cptItsoft,

_ADDRESS::
* https://techspying.com/how-to-run-exe-files-on-android/

osArd.EVOLUTING#cptCore546.171#

name::
* McsEngl.osArd.EVOLUTING@cptItsoft,

{time.2015-12-09}:
=== osArd.6-0-1.2015-12-09.Marshmallow / December 9, 2015; API-23
=== osArd.6.Marshmallow.2015
Now on Tap feature[193]
Doze mode[194]
App Standby feature
Alphabetically accessible vertical application drawer[195]
Application search bar and favorites
Native fingerprint reader support
Direct Share feature for target-specific sharing between apps[196]
Renamed "Priority" mode to "Do Not Disturb" mode
App Linking for faster instinctive opening of links with corresponding applications[197][198]
Larger Application folders with multiple pages
Post-install/run-time permission requests
USB Type-C support
Demo Mode feature for screenshot-capture usage[199]
Automatic full data backup and restore for apps[200]
4K display mode for apps[201]
Adoptable External storage to behave like Internal Storage[202]
MIDI support for musical instruments[203]
Experimental multi-window feature[204][205]
Partial app permissions reintroduced
[https://en.wikipedia.org/wiki/Android_version_history#Android_6.0.E2.80.936.0.1_Marshmallow_.28API_level_23.29]

{time.2014-11-12}:
=== osArd.5.2014-11-12.Lollipop 5.0–5.1.1 November 12, 2014 API-21–22
=== osArd.Lollipop.5.2014
Android Runtime (ART) with ahead-of-time (AOT) compilation and improved garbage collection (GC), replacing Dalvik that combines bytecode interpretation with trace-based just-in-time (JIT) compilation[166][168]
Support for 64-bit CPUs
OpenGL ES 3.1 and Android Extension Pack (AEP) on supported GPU configurations
Recent activities screen with tasks instead of applications, up to a configured maximum of tasks per application
Vector drawables, which scale without losing definition
Support for print previews
Material design, bringing a restyled user interface
Refreshed lock screen, no longer supporting widgets[169]
Refreshed notification tray and quick settings pull-down
Project Volta, for battery life improvements
Searches can be performed within the system settings for quicker access to particular settings
Lock screen provides shortcuts to application and notification settings[170]
Guest logins and multiple user accounts are available on more devices, such as phones.[171]
Audio input and output through USB devices
Third-party applications regain the ability to read and modify data located anywhere on external storage, such as on SD cards.[172][173]
Pinning of an application's screen for restricted user activity.[170]
Recently used applications are remembered even after restarting the device.[170]
WebViews receive updates independently through Google Play for security reasons, instead of relying on system-wide vendor updates[174]
Addition of 15 new languages: Basque, Bengali, Burmese, Chinese (Hong Kong), Galician, Icelandic, Kannada, Kyrgyz, Macedonian, Malayalam, Marathi, Nepali, Sinhala, Tamil and Telugu[175]
Tap and Go allows users to quickly migrate to a new Android device, using NFC and Bluetooth to transfer Google Account details, configuration settings, user data and installed applications[170]
A flashlight-style application is included, working on supported devices with a camera flash.[170]
User-customizable priorities for application notifications.[176]
Smart lock feature[177]
SELinux in enforcing mode for all domains
Updated emoji[178]
Improved accessibility support (e.g. switch access support)[179][179]
Block-based over-the-air (OTA) updates for new devices[180]
[https://en.wikipedia.org/wiki/Android_version_history#Android_5.0.E2.80.935.0.2_Lollipop_.28API_level_21.29]

{time.2013-10-31}:
=== osArd.KitKat.4.4 4.4–4.4.4, 4.4W–4.4W.2 October 31, 2013 API-19–20

{time.2012}:
It had a worldwide smartphone market share of 75% during the third quarter of 2012,[18] with 500 million devices activated and 1.3 million activations per day.[19][20] Application of the operating system has also moved beyond mobile phones and tablets; amongst others, televisions, smartbooks and cameras have been released running Android.
[http://en.wikipedia.org/wiki/Android_(operating_system)]

{time.2012-07-09}:
=== Jelly Bean 4.1–4.3.1 July 9, 2012 API-16–18

{time.2011-10-18}:
=== osArd.4-0.2011-10-18.Ice_Cream_Sandwich 4.0–4.0.4 October 18, 2011 API-14–15

{time.2011-02-22}:
=== osArd.3-0.2011-02-22.Honeycomb[a] 3.0–3.2.6 February 22, 2011 API-11–13

{time.2010}:
The first Android-powered phone was sold in October 2008,[16] and by the end of 2010 Android had become the world's leading smartphone platform, overtaking Symbian which held the record previously.[17]
[http://en.wikipedia.org/wiki/Android_(operating_system)]

{time.2010-12-06}:
=== Gingerbread 2.3–2.3.7 December 6, 2010 API-9–10

{time.2010-05-20}:
=== Froyo 2.2–2.2.3 May 20, 2010 API-8

{time.2009-10-26}:
=== osArd.2-0.2009-10-26.Eclair 2.0–2.1 October 26, 2009 API-5–7

{time.2009-09-15}:
=== Donut 1.6 September 15, 2009 API-4

{time.2009-04-27}:
=== Cupcake 1.5 April 27, 2009 API-3

{time.2009-02-09}:
=== 1.1 February 9, 2009 API-2

{time.2008}:
The first Android-powered phone was sold in October 2008,[16]
[http://en.wikipedia.org/wiki/Android_(operating_system)]

{time.2008-09-23}:
=== osArd.1-0.2008-09-23 September 23, 2008 API-1

osArd.8.Oreo

name::
* McsEngl.osArd.8.Oreo@cptItsoft,
* McsEngl.osAndroid.8.oreo@cptItsoft,

osArd.7.Nougat

name::
* McsEngl.osArd.7.Nougat@cptItsoft,

_DESCRIPTION:
Android 7.0 Nougat
Android 7.0 brings new features for performance, productivity, and security. Test your apps with new system behaviors to save power and memory. Take advantage of multi-window UI, direct reply notifications and more.
[https://developer.android.com/about/versions/nougat/index.html]

osArd.6.Marshmallow

name::
* McsEngl.osArd.6.Marshmallow@cptItsoft,
* McsEngl.osArd.6.marshmallow@cptItsoft,

_DESCRIPTION:
Android 6.0 Marshmallow
Get your apps ready for Android 6.0 Marshmallow! Explore what's new — runtime permissions, Doze and App Standby power-saving features, new assist technology, and more.
[https://developer.android.com/about/versions/marshmallow/index.html]

os.mobile.iOS {2007}

_CREATED: {2013-12-15}

name::
* McsEngl.os.mobile.iOS {2007}@cptItsoft,
* McsEngl.iPhone-OS@cptItsoft,
* McsEngl.iOS@cptItsoft,
* McsEngl.os.iOS@cptItsoft,

_DESCRIPTION:
iOS (previously iPhone OS) is a mobile operating system developed and distributed by Apple Inc. Originally unveiled in 2007 for the iPhone, it has been extended to support other Apple devices such as the iPod Touch (September 2007), iPad (January 2010), iPad Mini (November 2012) and second-generation Apple TV (September 2010). Unlike Microsoft's Windows Phone and Google's Android, Apple does not license iOS for installation on non-Apple hardware. As of October 2013, Apple's App Store contained more than 1 million iOS applications, 475,000 of which were optimised for iPad.[5] These apps have collectively been downloaded more than 60 billion times.[6] It had a 21% share of the smartphone mobile operating system units shipped in the fourth quarter of 2012, behind Google's Android.[7] In June 2012, it accounted for 65% of mobile web data consumption (including use on both the iPod Touch and the iPad).[8] At the half of 2012, there were 410 million devices activated.[9] According to the special media event held by Apple on September 12, 2012, 400 million devices had been sold by June 2012.[10]

The user interface of iOS is based on the concept of direct manipulation, using multi-touch gestures. Interface control elements consist of sliders, switches, and buttons. Interaction with the OS includes gestures such as swipe, tap, pinch, and reverse pinch, all of which have specific definitions within the context of the iOS operating system and its multi-touch interface. Internal accelerometers are used by some applications to respond to shaking the device (one common result is the undo command) or rotating it in three dimensions (one common result is switching from portrait to landscape mode).

iOS is derived from OS X, with which it shares the Darwin foundation and various application frameworks. iOS is Apple's mobile version of the OS X operating system used on Apple computers.

Major versions of iOS are released annually. The current release, iOS 7, was released on September 18, 2013. In iOS, there are four abstraction layers: the Core OS layer, the Core Services layer, the Media layer, and the Cocoa Touch layer. The current version of the operating system (iOS 7.0.4), dedicates 1–1.5 GB of the device's flash memory for the system partition, using roughly 800 MB of that partition (varying by model) for iOS itself.[11][12] It runs on the iPhone 4 and later, 2nd-generation iPad and later, all models of the iPad Mini, the 5th-generation iPod Touch, and Apple TV.
[http://en.wikipedia.org/wiki/IOS]

os.NETWORK

name::
* McsEngl.os.NETWORK@cptItsoft,
* McsEngl.conceptIt119,
* McsEngl.NETWORK-operating-system@cptItsoft,
* McsEngl.network'OperatingSystem@cptIt119,
* McsEngl.nos@cptIt119,
* McsEngl.os.network@cptIt119,
* McsEngl.osNet@cptItsoft,

DEFINITION

Τα λειτουργικά συστήματα δικτύου έχουν αρχιτεκτονική πολλών εργασιών (multitasking) και πολλών χρηστών (multiuser). Μοιάζουν με αυτα των μινικομπούτερς και μεινφρέιμς.

ΑΝ μείνετε σε χάρντγουερ στάνταρ του ΙΕΕΕ ΤΟΤΕ μπορείτε να επιλέξετε πρακτικά οποιοδήποτε ΛΣ δικτύου.

osNet'doing#cptCore475#

name::
* McsEngl.osNet'doing@cptItsoft,

+++OPERATING SYSTEM#cptIt444-8#

osNet'HARDWARE-OF-COMPUTER-STRUCTURE#cptIt456#

name::
* McsEngl.osNet'HARDWARE-OF-COMPUTER-STRUCTURE@cptItsoft,

+++NETWORK#cptIt262#

Οι τιμές χαρακτηριστικών που ΟΡΙΖΟΥΝ την έννοια, θα έχουν 3 αστεράκια.
[ΝΙΚΟΣ, 24 ΣΕΠΤ. 1994]

SPECIFIC

name::
* McsEngl.osNet.specific@cptItsoft,

_SPECIFIC:
* Appleshare
* DECnet#cptItsoft591# Digital Equipment Corp.,
* LAN Manager#cptItsoft69# 2.0, Microsoft
* POWERserve, Performance Technology
* Nexos, DSC Communications
* PromisLAN, MOSES COMPUTERS INC.,

osNet.MULTIUSER

name::
* McsEngl.osNet.MULTIUSER@cptItsoft,

_SPECIFIC:
* 386/multiware#cptItsoft502#
* AMIGA#cptItsoft515#
* CONCURENT DOS 386#cptItsoft579#
* DR MULTIUSER DOS#cptItsoft599#
* PC-MOS/386#cptItsoft747#
* PICK#cptItsoft763#
* QUICK CONNECT/386#cptItsoft789#
* THEOS#cptItsoft837#
* UNIX#cptItsoft1122#
* VM/386 MULTIUSER#cptItsoft865#

osNet.DOS-FAMILY

name::
* McsEngl.osNet.DOS-FAMILY@cptItsoft,

DOS Network operating systems:
επιτρέπουν σε πολλούς client να παρέχουν οδηγούς δίσκων, εκτυπωτές και άλλες δυνατότητες στο δίκτυο, peer-to-peer resourse sharing.

programs#ql:([Level BOOK: cpt.4][Level OBJECT:rl? operating'system dos])#

_SPECIFIC:
* 10NET, DCA, DOS
* AMSNOS#cptItsoft513# Amstrad

osNet.UNIX-FAMILY

name::
* McsEngl.osNet.UNIX-FAMILY@cptItsoft,
* McsEngl.UNIX-γένος@cptItsoft,

_SPECIFIC:
* InvisibleLAN, INVISIBLE SOFTWARE INC., UNIX
* LANtastic#cptItsoft668#ql:os.lantastic## ARTISOFT INC., DOS WIN
* NetWare#cptItsoft56# NOVELL, unix
* VINES#cptItsoft104# Banyan, unix

os.net.10NET

name::
* McsEngl.os.net.10NET@cptItsoft,
* McsEngl.conceptItsoft501,
* McsEngl.10NET@cptItsoft,
* McsEngl.10net@cptItsoft501,
* McsEngl.os.10net@cptItsoft,

DEFINITION

10NET is a NETWORK-OPERATING-SYSTEM#cptIt119.1#, ...
[NIKOS, JULY 1995]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

DOING#cptCore475#

+++operating-system#cptIt444-8#

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.net.386-MultiWare

name::
* McsEngl.os.net.386-MultiWare@cptItsoft,
* McsEngl.conceptItsoft502,
* McsEngl.386/MultiWare@cptItsoft,
* McsEngl.386multiware@cptItsoft502,
* McsEngl.os.386-multiware@cptItsoft,

DEFINITION

386/MULTIWARE is a multiuser NETWORK-OS#cptIt119.1#.
[NIKOS, JULY 1995]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

INFO-TECH-BUSINESS#cptEconomy7.108#

maker: Alloy Computer products,

greek vendor: Talos ltd tel.6001205-7...

COMPATIBILITY-WITH-OTHER-OS#cptIt473#

DOS

DOING#cptCore475#

operating-system#cptIt444-8#

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

PRICE#cptEconomy541.44#

GRD.95000, 162, 295 χιλιάδες αντίστοιχα για 3, 5, 21 χρήστες.

os.net.AMIGA

name::
* McsEngl.os.net.AMIGA@cptItsoft,
* McsEngl.conceptItsoft515,
* McsEngl.Amiga@cptItsoft,
* McsEngl.amiga@cptItsoft119,
* McsEngl.os.amiga@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* dos-os##

INFO-TECH-BUSINESS#cptEconomy7.108#

Commodore

DOING#cptCore475#

operating-system#cptIt444-8#, multitasking,

os.net.AMSNOS

name::
* McsEngl.os.net.AMSNOS@cptItsoft,
* McsEngl.conceptItsoft513,
* McsEngl.AMSNOS@cptItsoft513,
* McsEngl.os.amsnos@cptItsoft,

DEFINITION

AMSNOS is a NETWORK-OS#cptIt119.1# for 3-6 PCs.
[NIKOS, JULY 1995]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* dos-os##

INFO-TECH-BUSINESS#cptEconomy7.108#

AMSTRAD-HELLAS#cptItorg57#

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

PRICE#cptEconomy541.44#

90.000 δρχ. 70.000 Δρχ για 3 χρήστες με τις καρτες και τα καλώδια.

os.net.Concurent-DOS-386

name::
* McsEngl.os.net.Concurent-DOS-386@cptItsoft,
* McsEngl.conceptItsoft579,
* McsEngl.Concurent-DOS-386@cptItsoft,
* McsEngl.os.concurent-dos-386@cptItsoft,

DEFINITION

DOS MULTIUSER

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* dos-os##

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.net.DR-MULTIUSER-DOS

name::
* McsEngl.os.net.DR-MULTIUSER-DOS@cptItsoft,
* McsEngl.conceptItsoft599,
* McsEngl.DR-MULTIUSER-DOS@cptItsoft,
* McsEngl.os.dr-multiuser-dos@cptItsoft,

DEFINITION

DOS MULTIUSER MULTITASKING,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

INFO-TECH-BUSINESS#cptEconomy7.108#

Digital research,

vendors:
LAN WAN Network & Communications 9025645,
SMM ABEE 9710512

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.net.LANtastic

name::
* McsEngl.os.net.LANtastic@cptItsoft,
* McsEngl.conceptItsoft668,
* McsEngl.LANtastic@cptItsoft,
* McsEngl.os.lantastic@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

INFO-TECH-BUSINESS#cptEconomy7.108#

ARTISOFT INC.,

Αμυ αε.

Θεοδόσης ΑΒΕΕ 9520907-9,

COMPATIBILITY-WITH-OTHER-OS#cptIt473#

DOS, WINDOWS, MAC, NETWARE, OS/2, UNIX

EVALUATION#cptCore546.107#

COMMENTS:
1. Μοιραζμος CD'ROM συσκευών.
2. Συμβατότητα με NetBIOS.
3. Ηλεκτρονικό Ταχυδρομείο.
4. Φωνητικό ηλεκτρονικό ταχυδρομείο.
5. Καλή τιμή για 2 έως 100 χρήστες.

* Το διαθέτει τώρα και σε παραθυρική έκδοση. Εινα ετσι ενσωματωμένο που αποτελεί δομική προέκταση τών windows.

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

4.1
5.0(1993)

DOING#cptCore475#

operating-system#cptIt444-8# peer-to-peer. Δεν χρειάζεται server

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

PRICE#cptEconomy541.44#

$300 το πληρες. 120 χιλιάδες το starter kit (hard soft)

os.net.NOVELL-NETWARE-2.2

name::
* McsEngl.os.net.NOVELL-NETWARE-2.2@cptItsoft,
* McsEngl.conceptItsoft56,
* McsEngl.novell-NETWARE-2.2@cptItsoft,
* McsEngl.novell'netware2.2@cptItsoft56,

DEFINITION

NetWare operating system developed by Novell, Inc., that runs in FILE SERVERS and routers and controls system resources and information processing on an entire network or internetwork.
[NETWARE 2.2 CONCEPTS, 92]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

EVALUATION#cptCore546.107#

ΠΛΕΟΝΕΚΤΗΜΑΤΑ

1. Μπορεί να τρέξει σε μια ποικιλία δικτύων. Ethernet, Token Ring, ARCnet και μπορεί να εχει τοπολογια διαύλου, αστεριου, δακτυλιου.

ΜΕΙΟΝΕΚΤΗΜΑΤΑ

1. Τα δεδομένα που ορίζουν γκρουπ, δικαιώματα, χρήστες πρέπει να συντηρούνται σε κάθε σερβερ αρχείων.

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

ELS (Entry Level System)
Advanced 286
Advanced 286 SFT (system fault tolerance)

3.11 είναι τουλάχιστον η όγδοη έκδοση ενός προϊόντος το οποίο εξυπηρετεί περισότερους από 4.000.000 ανθρώπους σε πάνω απο 400.000 LAN.

FILE-SYSTEM#cptIt433#

It has a hierarchical filing system.

FORMAT:
fileserver\volume:directory\subdirectory\filename.

FILE SERVERS
VOLUMES(can be hard disks, or you can have many in one hdisk)
DIRECTORIES
SUBDIRECTORIES

DOING#cptCore475#

operating system#cptIt444-8#

FUNCTION CLASS

DIRECTORY MANAGEMENT

assign dir. locations (drives): MAP

change dir

copy dir: COPY; XCOPY; NCOPY; FILER

create dir: FILER; MD

delete dir: RD; FILER

display current dir

display list of dir: FILER; LISTDIR

path: FILESERVER\VOLUME:DIRECTORY\SUBDIRECTORY

rename dir: REN; RENDIR

standard dir.

types of dir

FILE MANAGEMENT

HELP: HELP; F1 at menu; COMMAND /HELP

INSTALL APPLICATIONS

MULTIPROCESSING

MULTITASKING

PRINTING

SECURITY

NETWORK SECURITY: (login security) SECURITY

account restrictions

station/time restrictions

passwords

usernames

USER SECURITY:

TRUSTEE RIGHTS:
Read, Write, Create, Erase, Modify, Filescan, Accesscontrol.
FILER, GRANT, REMOVE, REVOKE, SYSCON.

EFFECTIVE RIGHTS:
trustee rights minus maximum rights mask of a directory.
FILLER, RIGHTS, TLIST, WHOAMI /R.

DIRECTORY SECURITY:

ATTRIBUTES: (προηγουνται των effective rights)
Hidden, Normal, Private, Sy-stem.

RIGHTS (Maximum Rights Mask):
Read, Write, Create, Erase, Modify, Filescan, Accesscontrol.
FILER, FLAGDIR, NDIR

owner: FILER/current dir

FILE SECURITY:

ATTRIBUTES:
Archiveneeded, eXecuteonly, Hidden, Indexed, Ro/Rw, Shareable, Sy-stem, Transactional)
FILER, FLAG, NDIR

SYSTEM MANAGEMENT

BOOT

FILESERVER,
WORKSTATION

CLOSE

FILESERVER: \>CONSOLE, :DOWN
WORKSTATION: \>LOGOUT

USER MANAGEMENT

INFORMATION

display a list of users: USERLIST

PASSWORD: [supr]SYSCON; SETPASS

TYPES

MANAGER FUNCTIONS

ΠΡΟΣΟΧΗ: Οι μερικές έννοιες manager/user functions αποτελούν μια ΚΛΑΣΗ την USER CLASS.

DIRECTORY MANAGEMENT

change dir

copy dir

NCOPY, FILER

create dir

MD, FILER

delete dir

RD, FILER

display current dir

list directory

LISTDIR, FILER, NDIR

list of drives

MAP

list volumes

CHKVOL

rename dir

RENDIR

show path

MAP

standard dir.

SYS:SYSTEM (για διαχειριστή αρχείου),

SYS:PUBLIC (βοηθητικά για όλους χρήστες),

SYS:LOGIN,

SYS:MAIL

types

VOLUMES
DIRECTORIES
SUBDIRECTORIES

ΠΡΟΣΟΧΗ:
DRIVE (logical pointers) στο Netware ονομάζουν ΚΑΙ ένα τυχαίο directory. Μπορεί να είναι 26 όσα και τα γραματα.
LOCAL: A-E
NETWORK: F-Z.
SEARCH: (το αντίστοιχο του Autoexec PATH)

FILE MANAGEMENT manager-functions

backups

group file

HARDWARE MANAGEMENT

boot the computer

autoexec file:
system login script: SYSCON\SUPERVISOR OPTIONS\SYST LOGIN SCRIPT
user loging script: SYSCON
program batch file:

close the computer

configure terminals

list of servers

LSIST

HELP

F1. at menu.

HELP= folio views help.

MEMORY MANAGEMENT

USER MANAGEMENT

add user

SYSCON(1) bindery 2)password 3)name)\USER INFO

delete user

REMOVE

group users

SYSCON\GROUPS INFO

list of users on

USERLIST

user types

supervisor, operator, user

SECURITY manager-functions

system level

password file

concurrent sessions

SYSCON\USER INFO\CLARK\ACC RESTRICT\LIMIT

intruders

SYSCON\SUPER OPT\INTRUDER

time restriction

SYSCON\USER INFO\CLARK\TIME RESTRICTIONS

user level

group level

change group

directory level

FILER

file level

change ownner

FILER

change permissions

list of rights

prevent writing on a file

USER FUNCTIONS

DIRECTORY MANAGEMENT user-functions

change dir

create dir

MD, FILER

delete dir

display current dir

list directory

LISTDIR

list fs

CHKVOL

rename dir

RENDIR

standard dir.

SYS:SYSTEM (για διαχειριστή αρχείου),

SYS:PUBLIC (βοηθητικά για όλους χρήστες),

SYS:LOGIN,

SYS:MAIL

types

VOLUMES
DIRECTORIES
SUBDIRECTORIES

FILE MANAGEMENT user-functions

Attributes of a file.

classify files

compress files

copy files

NCOPY

delete file

edit file

display the contents of a file, sort file contents:

link files

list files

NDIR

move files

print files

NPRINT

rename file

search for file

sort files

undelete file

SALVAGE

view file

FILE-SERVER user functions

connection to file server

ATTACH.

list file servers

SLIST

HELP user-function

INFORMATION

list of users

USERLIST.

user info

WHOAMI /A /G /R /S

NETWORKING user functions

copy files

game

NCSNIPES

list of computer to communicate

list the arrived files

mail functions

receive mail

send mail

send message

SEND

message mgt

CASTOFF, CASTON

network connection

LOGOUT: αποσύνδεση

remote execution

PROCESS user functions

background execution

non hang up a bg when logoff

stop a bg process

combine commands

grouping

in turn execution

list of processes

only if first was executed

only if preceding fails

priority

substitution of a command

SECURITY user functions

change password

SETPASS

know your rights

RIGHTS

system level

SETPASS, LOGIN, LOGOFF

file level

change group: GRANT
change ownener: GRANT
change permissions: REVOKE, FLAG, FLAGDIR
list of rights: TLIST
prevent writing on a file: HOLDON

VARIABLES

creation

ALPHABETICALL CLASS

ADMINISTRATOR
FILE MANAGEMENT
BACKUP
NCOPY
NPRINT
MANAGEMENT
CLEAR STATION xx= διακόπτει το χχ σταθμό εργασίας.
NAVIGATION
ATTACH= σύνδεση με ένα αλλο σέρβερ.
CASTON= επιτρέπει το δέξιμο μηνυμάτων.
LISTDIR= λίστα υποκαταλόγων.
NAME= δίνει το όνομα φάιλ σέρβερ
NDIR=
SEND=
SLIST= λίστα όλων file servers.
USERS
USERLIST=λίστα χρηστών
WHOAMI=πληροφορίες για χρήστη
SECURITY
GRANT= αποδιδει δικαιώματα
RIGHTS=
SETPASS= αλλαγη πασγουορντ.
TLIST= δινει λιστα δικαιωματων καταλόγου
SPACE MANAGEMENT
VOLUME= ελεύθερος χώρος
START/CLOSE
DOWN=
LOGIN server/user=

INSTALLATION:
NETGEN
COMPSURF: φορμάρει το δίσκο του file server.
NET&SOS: Run Netware.
SHGEN: Δημιουργει workstation shells.
*δημιουργία καταλόγων στον φάιλ σερβερ.
*δημιουργία system login script, login script (autoexec.bat!)
SYSCON= ομάδες χρηστών
*προσθήκη ασφάλειας.
*παράμετροι εκτυπωτών.
*MENU

MACHINE CLASS

FILE SERVER FUNCTIONS

Οι εντολες ΚΟΝΣΟΛΑΣ Μπορούν να πληκρολογηθούν από την κονσόλα του File Server ONLY. Εχουν επίπτωση σε όλο το δικτυο.

BROADCAST
CLEAR STATION
CONFIG
CONSOLE
DISABLE LOGIN
DISK
DISMOUNT
DOS
DOWN
ENABLE LOGIN
MONITOR
MOUNT
NAME
OFF
REMIRROR
SEND
SET TIME
UNMIRROR
VAR

WORKSTATION FUNCTIONS

Οι εντολες ΣΤΑΘΜΟΥ ΕΡΓΑΣΙΑΣ πρεπει να πληκτρολογούνται απο τους σταθμους εργασιας.

ATTACH
CAPTURE
CASTOFF
CASTON
ENDCAP
HOLDOFF
LOLDON
LISTDIR
LOGIN
LOGOUT
MAP
NCOPY
NDIR
NPRINT
NSNIPES
RIGHTS
SENT
SETPASS
SLIST
SYSTIME
USERLIST
WHOAMI

MISC CLASS

SUPERVISOR

CHKVOL
FLAG
FLAGDIR
GRANT
LARCHIVE
LRESTORE
NARCHIVE
NRESTORE
NVER
PSTAT
PURGE
REMOVE
RENDIR
REVOKE
SALVAGE
SETTTS
SLIST
SMODE
TLIST
VERSION

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

STANDARD#cptIt139#

Η κυκλοφορία των δεδομένων σ'ένα δίκτυο NetWare γίνεται με το πρωτόκολλο IPX.

os.net.NOVELL-NETWARE-3.11

name::
* McsEngl.os.net.NOVELL-NETWARE-3.11@cptItsoft,
* McsEngl.conceptItsoft107,
* McsEngl.novell-netware-3.11@cptItsoft,
* McsEngl.novell-netware3.11@cptItsoft107,
* McsEngl.os.novell-netware-3.11@cptItsoft,

DEFINITION

Είναι μια έκδοση που έχει γραφτεί απο την αρχή.

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

INFO-TECH-BUSINESS#cptEconomy7.108#

NOVELL#cptItorg1684#

EVALUATION#cptCore546.107#

Για πάνω απο 30 χρήστες ειναι το καλύτερο λειτουργικό σύστημα.

DOING#cptCore475#

operating system#cptIt444-8#

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

Μέγιστη RAM=4GB,

Μέγιστη STORAGE=32ΤΒ.

Δυναμική επανακατανομή της μνήμης αυτόματα.

Επιτρέπει μεχρι 16 εκτυπωτες στο δίκτυο.

os.net.NOVELL-NETWARE-4

name::
* McsEngl.os.net.NOVELL-NETWARE-4@cptItsoft,
* McsEngl.conceptItsoft457,
* McsEngl.novell-netware-4.0@cptItsoft,
* McsEngl.novell'netware4@cptItsoft457,
* McsEngl.os.novell-netware-4@cptItsoft,

DEFINITION

NOVELL NETWARE 4 is the server-based NOS of Novell
[COMPUTER GO, APRIL 1995, 87]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

INFO-TECH-BUSINESS#cptEconomy7.108#

NOVELL#cptItorg1684#

COMPATIBILITY-WITH-OTHER-OS#cptIt473#

ΛΕΙΤΟΥΡΙΚΑ ΣΥΣΤΗΜΑΤΑ ΣΤΟ ΔΙΚΤΥΟ:
DOS, WINDOWS, OS/2, MAC, NFS UNIX, SOON WINDOWS NT.
ΟΛΑ ΑΥΤΑ ΤΑ ΣΥΣΤΗΜΑΤΑ ΜΠΟΡΟΥΝ ΝΑ ΣΥΝΔΕΘΟΥΝ ΣΤΟΝ ΙΔΙΟ server ΚΑΙ ΝΑ ΜΟΙΡΑΣΤΟΥΝ ΤΙΣ ΙΔΙΕΣ ΥΠΗΡΕΣΙΕΣ, ΕΝΩ ΟΙ ΧΡΗΣΤΕΣ ΘΑ ΣΥΝΕΧΙΣΟΥΝ ΝΑ ΕΡΓΑΖΟΝΤΑΙ ΣΤΟ ΔΙΚΟ ΤΟΥΣ ΓΝΩΡΙΜΟ ΠΕΡΙΒΑΛΛΟΝ.

EVALUATION#cptCore546.107#

ΕΙΝΑΙ ΣΗΜΕΡΑ ΤΟ ΔΗΜΟΦΙΛΕΣΤΕΡΟ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ ΔΙΚΤΥΩΝ ΓΙΑ ΚΑΘΕ ΕΙΔΟΥΣ ΕΓΚΑΤΑΣΤΑΣΗ ΑΠΟ ΤΟΠΙΚΑ ΜΕΧΡΙ ΔΥΟ ΗΠΕΙΡΩΝ.
Η ΝΕΑ ΕΚΔΟΣΗΣ ΚΑΤΑΦΕΡΝΕΙ ΝΑ ΔΙΑΤΗΡΕΙ ΤΙΣ ΤΕΧΝΟΛΟΓΙΚΕΣ ΑΠΟΣΤΑΣΕΙΣ.
- ΕΙΝΑΙ 4ης ΓΕΝΙΑΣ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ ΔΙΚΤΥΩΝ, ΕΝΩ Η MICROSOFT ΟΥΣΙΑΣΤΙΚΑ ΤΩΡΑ ΜΠΑΙΝΕΙ ΔΥΝΑΜΙΚΑ ΣΤΟ ΧΩΡΟ.[67]
[COMPUTER GO, JUN 1993, 102]

DISADVANTAGES#cptIt468#

ΔΕΝ ΥΠΟΣΤΗΡΙΖΕΙ ΜΗΧΑΝΗΜΑΤΑ ΜΕ ΠΟΛΛΑΠΛΟΥΣ ΕΠΕΞΕΡΓΑΣΤΕΣ.

ΔΙΑΦΟΡΕΣ ΜΕ ΠΡΟΗΓΟΥΜΕΝΕΣ ΕΚΔΟΣΕΙΣ

Η ΒΑΣΙΚΗ ΔΙΑΦΟΡΑ ΕΙΝΑΙ ΟΤΙ ΜΕ ΤΟ 3.11 Ο ΧΡΗΣΤΗΣ ΕΒΛΕΠΕ ΤΟΝ SERVER, ΕΝΩ ΤΩΡΑ ΒΛΕΠΕΙ ΤΟ ΕΥΡΥ ΔΙΚΤΥΟ ΚΑΙ ΠΑΙΡΝΕΙ ΤΙΣ ΠΛΗΡΟΦΟΡΙΕΣ ΧΩΡΙΣ ΝΑ ΕΝΔΙΑΦΕΡΕΤΑΙ ΓΙΑ ΤΕΧΝΙΚΕΣ ΠΡΟΔΙΑΓΡΑΦΕΣ.

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

1994:
version4.1

DOING#cptCore475#

operating system#cptIt444-8#

CONECTIONS

ΧΡΗΣΤΕΣ ΑΝΑ ΕΞΥΠΗΡΕΤΗΤΗ: 1000 ΑΠΟ 250.
ΕΚΤΥΠΩΤΕΣ ΑΝΑ ΕΞΥΠΗΡΕΤΗΤΗ: 255
ΕΞΥΠΗΡΕΤΗΤΕΣ: 54.000 ΑΠΟ 8.

NETWORK MANAGEMENT

NDS {Netware Directory Services}: ΜΙΑ ΚΑΤΑΝΕΜΗΜΕΝΗ ΑΝΤΙΚΕΙΜΕΝΟΣΤΡΑΦΗ ΒΑΣΗ ΔΕΔΟΜΕΝΩΝ, ΜΕ ΟΛΕΣ ΤΙΣ ΠΛΗΡΟΦΟΡΙΕΣ ΓΙΑ ΤΟΥΣ ΠΟΡΟΥΣ ΤΟΥ ΔΙΚΤΥΟΥ.

Η ΣΥΝΔΕΣΗ ΤΟΥ ΧΡΗΣΤΗ ΣΤΟ ΔΙΚΤΥΟ ΓΙΝΕΤΑΙ ΜΙΑ ΦΟΡΑ ΚΑΙ ΔΕΝ ΓΙΝΕΤΑΙ ΣΕ ΣΥΓΚΕΚΡΙΜΕΝΟ ΕΞΥΠΗΡΕΤΗΤΗ. ΑΚΟΜΑ Ο ΣΤΑΘΜΟΣ ΠΟΥ ΧΡΗΣΙΜΟΠΟΙΕΙ ΜΠΟΡΕΙ ΝΑ ΒΡΙΣΚΕΤΑΙ ΣΕ ΑΛΛΟ ΓΡΑΦΕΙΟ ή ΑΛΛΗ ΠΟΛΗ.

ΟΙ ΧΡΗΣΤΕΣ ΜΠΟΡΟΥΝ ΝΑ ΠΡΟΣΠΕΛΑΣΟΥΝ ΜΙΑ ΥΠΗΡΕΣΙΑ ΧΩΡΙΣ ΝΑ ΞΕΡΟΥΝ ΤΟΝ ΕΞΥΠΗΡΕΤΗΤΗ ΠΟΥ ΤΗΝ ΠΑΡΕΧΕΙ. Η ΑΝΑΖΗΤΗΤΗ ΤΩΝ ΠΟΡΩΝ ΓΙΝΕΤΑΙ ΔΗΛΑΔΗ ΑΥΤΟΜΑΤΑ ΑΠΟ ΤΟ ΛΕΙΤΟΥΡΓΙΚΟ ΣΥΣΤΗΜΑ.

ΤΑ ΑΝΤΙΚΕΙΜΕΝΑ ΤΟΥ ΔΙΚΤΥΟΥ ΕΧΟΥΝ "ΙΔΙΟΤΗΤΕΣ" ΚΑΙ Ο ΧΡΗΣΤΗΣ ΜΠΟΡΕΙ ΝΑ ΚΑΝΕΙ ΑΝΑΖΗΤΗΣΗ ΒΑΣΕΙ ΑΥΤΩΝ ΤΩΝ ΙΔΙΟΤΗΤΩΝ.

ΕΡΓΑΛΕΙΑ ΔΙΑΧΕΙΡΙΣΗΣ:
ΥΠΑΡΧΟΥΝ ΤΑ NLM ΠΟΥ ΠΡΟΣΦΕΡΟΥΝ ΣΥΓΚΕΚΡΙΜΕΝΕΣ ΥΠΗΡΕΣΙΕΣ ΚΑΙ ΑΓΟΡΑΖΟΝΤΑΙ ΞΕΧΩΡΙΣΤΑ.

ENHANCED NDS:
The NDS of 4.1

TSAPI

Είναι η λύση της Νοβέλ για την ΟΛΟΚΛΗΡΩΣΗ του τηλεφωνικού δικτύου στο ΥΠΟΛΟΓΙΣΤΙΚΟ ΔΙΚΤΥΟ.
[COMPUTER GO, APRIL 1995, 89]

INFORMATION-MACHINE-TO-WORK-WITH#cptIt456#

RAM: AT LEAST 6MB
HD: FROM 12 TO 60 MB.

ΔΙΑΧΕΙΡΙΣΗ ΑΠΟΘΗΚΕΥΤΙΚΩΝ ΜΕΣΩΝ

64 ΜΟΝΑΔΕΣ ΔΙΣΚΩΝ, 32ΤΒ ΑΠΟΘΗΚΕΥΤΙΚΟ ΧΩΡΟ, ΟΣΟ ΚΑΙ Η ΕΚΔΟΣΗ 3.11.

ΤΑ ΑΝΤΙΓΡΑΦΑ ΜΠΟΡΟΥΝ ΝΑ ΓΙΝΟΝΤΑΙ ΑΠΟ ΕΝΑΝ ΕΞΥΠΗΡΕΤΗΤΗ ΚΑΙ ΠΡΟΒΛΕΠΕΤΑΙ ΣΤΟ ΜΕΛΛΟΝ Η ΠΡΟΣΘΕΣΗ ΚΕΝΤΡΙΚΟΥ backup ΑΚΟΜΑ ΚΑΙ ΓΙΑ ΤΟΥΣ ΣΚΛΗΡΟΥΣ ΔΙΣΚΟΥΣ ΤΩΝ ΣΤΑΘΜΩΝ ΕΡΓΑΣΙΑΣ.

ΚΑΝΕΙ ΣΥΜΠΙΕΣΗ ΔΕΔΟΜΕΝΩΝ. ΣΤΟ ΥΠΟΒΑΘΡΟ ΟΤΑΝ ΔΕΝ ΓΙΝΟΝΤΑΙ ΑΛΛΕΣ ΛΕΙΤΟΥΡΓΙΕΣ. ΣΥΜΠΙΕΖΕΙ ΔΗΛΑΔΗ ΤΑ ΑΡΧΕΙΑ ΠΟΥ ΔΕΝ ΧΡΗΣΙΜΟΠΟΙΟΥΝΤΑΙ ΣΥΧΝΑ

ΕΙΣΗΓΑΓΕ ΤΗ sub-block allocation ΣΤΗΝ ΕΓΓΡΑΦΗ ΤΟΥ ΔΙΣΚΟΥ, ΚΑΙ ΕΤΣΙ ΕΚΜΕΤΑΛΛΕΥΕΤΑΙ ΚΑΛΛΙΤΕΡΑ ΤΟ ΧΩΡΟ ΤΟΥ ΔΙΣΚΟΥ.

ΜΗΧΑΝΙΣΜΟΣ DATA MIGRATION. ΜΕΤΑΦΕΡΕΙ ΑΠΟ ΣΚΛΗΡΟΥΣ ΔΙΣΚΟΥΣ ΣΕ ΦΘΗΝΟΤΕΡΑ ΑΠΟΘΗΚΕΥΤΙΚΑ ΜΕΣΑ ΑΡΧΕΙΑ ΠΟΥ ΔΕΝ ΧΡΗΣΙΜΟΠΟΙΟΥΝΤΑΙ ΣΥΧΝΑ.

ΕΚΤΕΤΑΜΕΝΑ ΔΙΚΤΥΑ

ΕΙΝΑΙ ΡΑΜΕΝΑ ΓΙΑ ΕΚΤΕΤΑΜΕΝΑ ΔΙΚΤΥΑ.
ΕΠΙΤΑΧΥΝΣΗ ΣΤΑ ΠΡΩΤΟΚΟΛΛΑ ΕΠΙΚΟΙΝΩΝΙΑΣ.

INSTALLATION#cptIt162#

ΣΗΜΑΝΤΙΚΑ ΒΕΛΤΙΩΜΕΝΗ.

ΥΠΑΡΧΟΥΝ ΠΡΟΓΡΑΜΜΑΤΑ ΑΝΑΒΑΘΜΙΣΗΣ ΕΤΣΙ ΩΣΤΕ ΝΑ ΔΙΑΤΗΡΗΘΕΙ Η ΥΠΑΡΧΟΥΣΑ ΔΟΜΗ.

PRICE#cptEconomy541.44#

$1.400 5 users [jun 1993]
$48.000 1000 users [jun 1993]

measure#cptCore88#

ΔΕΝ ΕΚΤΙΜΑΤΑΙ ΟΤΙ Η ΕΛΛΗΝΙΚΗ ΑΓΟΡΑ ΘΑ ΕΙΝΑΙ ΤΟΥΛΑΧΙΣΤΟΝ ΓΙΑΥΤΟ ΤΟ ΧΡΟΝΟ ΣΗΜΑΝΤΙΚΗ. ΤΑ ΔΙΚΤΥΑ ΠΟΛΛΑΠΛΩΝ SERVER, KAI ΓΕΝΙΚΟΤΕΡΑ ΕΥΡΕΙΑΣ ΖΩΝΗΣ, ΕΙΝΑΙ ΠΑΡΑ ΠΟΛΥ ΛΙΓΑ ΣΤΗΝ ΕΛΛΑΔΑ.
[COMPUTER GO, JUN 1993, Γ. ΠΑΠΑΔΟΠΟΥΛΟΣ ABC]

SECURITY#cptIt302#

VERSION4.1:
C2

ΥΛΟΠΟΙΕΙ ΑΛΓΟΡΙΘΜΟΥΣ ΚΡΥΠΤΟΓΡΑΦΗΣΗΣ RSA ΚΑΤΑ ΤΗ ΦΑΣΗ ΤΗΣ ΣΥΝΔΕΣΗΣ ΜΕ ΤΟ ΔΙΚΤΥΟ.

ΓΙΑ ΠΡΩΤΗ ΦΟΡΑ ΔΙΚΑΙΩΜΑΤΑ AUDITING (ΠΑΡΑΚΟΛΟΥΘΗΣΗΣ) ΤΟΥ ΣΥΣΤΗΜΑΤΟΣ ΔΙΝΟΝΤΑΙ ΚΑΙ ΣΕ ΧΡΗΣΤΕΣ.

ΔΕΝ ΕΧΕΙ ΑΚΟΜΑ ΤΟ ΠΙΣΤΟΠΟΙΗΤΙΚΟ ΑΣΦΑΛΕΙΑΣ C2.

ΜΗΧΑΝΙΣΜΟΣ MIRRORING, ΕΤΣΙ ΩΣΤΕ ΑΝ ΧΑΛΑΣΕΙ ΕΝΑΣ ΔΙΣΚΟΣ ΝΑ ΥΠΑΡΧΕΙ ΤΟ ΑΝΤΙΤΥΠΟ-ΤΟΥ.

os.net.PC-MOS-386

name::
* McsEngl.os.net.PC-MOS-386@cptItsoft,
* McsEngl.conceptItsoft747,
* McsEngl.os.pc-mos-386@cptItsoft,
* McsEngl.PC-MOS/386@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
* NETWORK-OS#cptIt119#
* dos-os##

DOING#cptCore475#

MULTIUSER,

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.net.OS2-LAN-SERVER

name::
* McsEngl.os.net.OS2-LAN-SERVER@cptItsoft,
* McsEngl.conceptItsoft937,
* McsEngl.os2LanServer@cptItsoft937,
* McsEngl.os.os2-lan-server@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

INFO-TECH-BUSINESS#cptEconomy7.108#

IBM

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

4.0

ADVANCED & ENTRY EDITION

FILE-SYSTEM#cptIt433#

ADVANCED:
HPFS

SECURITY#cptIt302#

DISK MIRRORING

os.net.PICK

name::
* McsEngl.os.net.PICK@cptItsoft,
* McsEngl.conceptItsoft763,
* McsEngl.os.pick@cptItsoft,
* McsEngl.Pick@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

DOING#cptCore475#

MULTIUSER

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.net.Quick-Connect/386

name::
* McsEngl.os.net.Quick-Connect/386@cptItsoft,
* McsEngl.conceptItsoft789,
* McsEngl.os.quick-connect-386@cptItsoft,
* McsEngl.Quick-Connect-386@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
* NETWORK-OS#cptIt119#
* dos-os##

DOING#cptCore475#

MULTIUSER,

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.net.THEOS

name::
* McsEngl.os.net.THEOS@cptItsoft,
* McsEngl.conceptItsoft837,
* McsEngl.os.theos@cptItsoft,
* McsEngl.Theos@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

DOING#cptCore475#

MULTIUSER,

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.net.VINES

name::
* McsEngl.os.net.VINES@cptItsoft,
* McsEngl.conceptItsoft104,
* McsEngl.os.vines@cptItsoft,
* McsEngl.VINES-os@cptItsoft,
* McsEngl.vines@cptItsoft104,
* McsEngl.Virtual-NEtworking-Software@cptItsoft,

DEFINITION

VINES: NETWORK OPERATING SYSTEM OF BANYAN SYSTEM.

GENERIC

_GENERIC:
NETWORK-OS#cptIt119#

ognCompany#cptEconomy7#

COMPANY: Banyan System,

vendor: Computer Bank AE 6844429 .

EVALUATION#cptCore546.107#

ΠΛΕΟΝΕΚΤΗΜΑΤΑ:
1. Ισχυρές δυνατότητες επικοινωνιών
2. Εχει δυνατότητα να συνδέει διαφορετικους σερβερς σε μεγάλες αποστάσεις μέσω μιας ποικιλίας εναλλακτικών λύσεων επικοινωνίας μεγάλων αποστάσεων.

PRICE#cptEconomy541.44#

PRICE: ..5, 10, 20, απειροι κοστίζουν 1825, 3300, 5300, 9900 δολ αντίστοιχα.:

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

4.11

1993:
5.50 ΣΗΜΑΝΤΙΚΟΤΕΡΗ ΒΕΛΤΙΩΣΗ Η ΕΝΣΩΜΑΤΩΣΗ ΤΟΥ STREETTALK III

WAN

ΥΠΟΣΤΗΡΙΞΗ ISDN KAI T1.

os.net.VM-386-MultiUser

name::
* McsEngl.os.net.VM-386-MultiUser@cptItsoft,
* McsEngl.conceptItsoft865,
* McsEngl.os.vm-386-multiuser@cptItsoft,
* McsEngl.VM/386-MultiUser@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#

INFO-TECH-BUSINESS#cptEconomy7.108#

Intelligent Graphics Corp.

DOING#cptCore475#

make DOS MULTIUSER,

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.NEXTSTEP

name::
* McsEngl.os.NEXTSTEP@cptItsoft,
* McsEngl.conceptItsoft533,
* McsEngl.os.nextstep@cptItsoft533,
* McsEngl.NEXTSTEP-operating-system@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
OBJECT-ORIENTED-PROGRAM#cptIt951#

INFO-TECH-BUSINESS#cptEconomy7.108#

NEXT COMPUTER, STEVE JOBS

EVALUATION#cptCore546.107#

Είναι το πρώτο πλήρες αντικειμενοστραφές ΛΣ.
Αν θέλαμε να περιγράψουμε το interface με γνωστούς όρους, θα μπορούσαμε να αναφέρουμε ότι διαθέτει την πολύ καλή αισθητική των windows95, σε συνδυασμό με τον προσανατολισμό στα αντικείμενα του OS/2. Πιό βαθιά, έχουμε να κάνουμε με ενα UNIX σύστημα το οποίο παρέχει de facto άψογες δυνατότητες multiuser και multitasking.
[COMPUTER GO, JAN. 1996, 183]

ΤΟ ΛΕΙΤΟΥΡΓΙΚΟ ΚΑΙ ΕΥΡΥΤΕΡΟ ΛΟΓΙΣΜΙΚΟ ΤΗΣ NEXT, ΤΟ ΛΕΓΟΜΕΝΟ NEXTSTEP, ΑΝΑΓΝΩΡΙΖΕΤΑΙ ΑΠΟ ΕΙΔΙΚΟΥΣ ΣΑΝ ΤΟ ΠΙΟ ΠΡΟΗΓΜΕΝΟ ΣΤΗΝ ΑΓΟΡΑ ΣΗΜΕΡΑ.
[ΚΑΘΗΜΕΡΙΝΗ, 7 ΜΑΡΤ 1993, 44]

DRAWBACKS
* NO RISC support
* Completely proprietary
* Few shrink-wrapped applications

EVOLUTION#cptCore546.171#

1989:
Nextstep 1.0
[COMPUTER GO, JAN. 1996, 182]

1995:
Nextstep 3.3

DOING#cptCore475#

OPERATING SYSTEM#cptIt444-8#

MULTIPROCESSING SYMMETRIC,

MULTITHREADING,

CAPABILITIES:
* Object oriented
* easily networked
* integrated audio
* well integrated GUI
* Easily customized

NETWORKING

ΤΑΥΤΟΧΡΟΝΗ ΠΡΟΣΠΕΛΑΣΗ ΠΟΛΛΩΝ ΧΡΗΣΤΩΝ.

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

DEMAND: 24MB RAM, 120MB HD. (FOR intel)

ΤΩΡΑ ΤΟ ΛΕΙΤΟΥΡΓΙΚΟ ΥΠΑΡΧΕΙ ΜΟΝΟ ΣΤΑ ΜΗΧΑΝΗΜΑΤΑ ΤΗΣ NEXT.
- ΕΓΙΝΕ ΓΝΩΣΤΟ ΟΤΙ ΔΙΑΠΡΑΓΜΑΤΕΥΕΤΑΙ ΜΕ HP, ΩΣΤΕ ΝΑ ΜΠΟΡΕΙ ΝΑ ΣΥΝΕΡΓΑΣΘΕΙ ΜΕ ΤΟΥΣ ΣΤΑΘΜΟΥΣ ΕΡΓΑΣΙΑΣ ΤΗΣ.
- Η ΕΤΑΙΡΙΑ ΔΟΥΛΕΥΕΙ ΚΑΙ ΓΙΑ ΤΗΝ ΑΝΑΠΤΥΞΗ ΤΟΥ NEXTSTEP 486, SOFTWARE ΣΥΜΒΑΤΟΥ ΜΕ IBM ΥΠΟΛΟΓΙΣΤΕΣ, ΤΟ ΟΠΟΙΟ ΠΡΟΚΕΙΤΑΙ ΝΑ ΠΑΡΟΥΣΙΑΣΘΕΙ ΜΕΣΑ ΣΤΟ 1993.
[COMPUTER ΓΟ, ΜΑΡΤ 1993, 16]

structure#cptCore515#

MICROKERNERL: MACH of Carnegie Mellon.

os.org.APPLE

_CREATED: {2013-12-15}

name::
* McsEngl.os.org.APPLE@cptItsoft,

_SPECIFIC:
Operating systems by Apple Inc.
Macintosh
Mac OS
System 6
Taligent
System 7
Mac OS 8
Copland
Mac OS 9
A/UX
Mac OS X Family
Mac OS X Server
Darwin
Mac OS X
A/ROSE
Rhapsody
MkLinux

Mobile
iOS
Newton OS

Apple I/II/III/Lisa
ProDOS
SOS
Lisa OS
Apple DOS
GS/OS
[http://en.wikipedia.org/wiki/Mac_os]

os.org.MICROSOFT

name::
* McsEngl.os.org.MICROSOFT@cptItsoft,

os.OS/2

name::
* McsEngl.os.OS/2@cptItsoft,
* McsEngl.conceptItsoft441,
* McsEngl.os.os2@cptItsoft441,
* McsEngl.OS/2-operating-system@cptItsoft,
* McsEngl.os2@cptItsoft441,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#

ALPHABET#cptIt431#

ΕΛΛΗΝΙΚΑ. ΕΛΟΤ 928 ΓΙΑ WINDOWS

APPLICATION#cptIt97#

ΚΑΤΑ ΤΗΝ ΙΒΜ ΣΗΜΕΡΑ ΥΠΑΡΧΟΥΝ ΠΕΡΙ ΤΙΣ 1000 ΕΦΑΡΜΟΓΕΣ
[RAM, ΜΑΡΤ 1993, 44]

BIT-ARCHITECTURE#cptIt472#

32bit.

32bit graphics engine. Αυτό σημαίνει οτι οι εντολες σχεδιασμου στην οθόνη τυγχάνουν επεξεργασιας 32μπιτ, γεγονος που επιταχύνει κατά πολυ την ενημέρωση της οθόνης, ακόμη και σε εφαρμογές windows, αφού και αυτών οι κλήσεις εξυπηρετούνται από τον ίδιο κώδικα του OS/2.

COMPATIBILITY-WITH-OTHER-OS#cptIt473#

4. τρέχει πολλαπλές εκδοχές DOS WIN.

EVALUATION#cptCore546.107#

PROS

ΕΙΝΑΙ ΠΡΑΓΜΑΤΙΚΑ ΕΝΑ ΚΑΛΥΤΕΡΟ ΠΕΡΙΒΑΛΛΟΝ ΓΙΑ ΟΛΕΣ ΤΙΣ ΕΦΑΡΜΟΓΕΣ, ΜΟΛΟΝΟΤΙ ΔΕΝ ΕΧΕΙ ΚΕΡΔΙΣΕΙ ΤΗΝ ΕΜΠΙΣΤΟΣΥΝΗ ΤΟΥ ΚΟΣΜΟΥ.
- ΜΠΟΡΕΙ ΝΑ ΜΕΤΑΦΕΡΕΙ ΠΛΗΡΟΦΟΡΙΕΣ ΑΠΟ DOS TO WINDOWS PROGRAMMS.
[COMPUTER GO, JAN 1994, 22]

Η ΕΚΔΟΣΗΣ 2.1 ΤΡΕΧΕΙ ΤΙΣ ΕΦΑΡΜΟΓΕΣ WINDOWS ΓΡΗΓΟΡΟΤΕΡΑ ΑΠΟ ΤΑ WINDOWS.
[CHIP, 1994, 32]

PROS:
- ΕΙΝΑΙ OBJECT ORIENTED, ΕΝΩ ΤΟ ΝΤ ΟΧΙ.
- ΠΛΗΡΗ ΥΠΟΣΤΗΡΙΞΗ ΣΥΣΚΕΥΩΝ MULTIMEDIA.

CONS

It is NOT a multiuser OS as UNIX is.

Lack of user/developer acceptance.

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

1996:
4.0 version (Merlin).

WARP ο κωδικός της νέας έκδοσης.
[PC MASTER, OCT. 1994, 47]

2.2

1993:
2.1 ΚΥΡΙΟ ΑΤΟΥ ΕΧΕΙ 32ΜΠΙΤΗ ΜΗΧΑΝΗ ΓΡΑΦΙΚΩΝ.

1992 SPRING:
2.0 Δεν υπστήριζε Windows 3.1, SVGA drivers.

1.3 σε αυτή την έκδοση σταμάτησε η Microsoft τη συνεργασία.

1987:
1

FILE-SYSTEM#cptIt433#

HPFS (high performance file system).

File names bigger than 11 characters.

DOING#cptCore475#

OPERATING SYSTEM#cptIt444-8#

MULTITASKING

- πολυδιεργασια.
- Multithreaded

NETWORKING

NETWORKS: TCP/IP, X.25, ETHERNET, TOKEN RING.

INTERNET UTILITY
Θα προσφέρει η νέα έκδοση [COMPUTER GO, OCT. 1994, 46]

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

DEMAND: 386, 6MB RAM, 70MB HD.

BUS

2. bus 2 times bigger.

RAM

3. διάφραγμα απόλυτου διαχωρισμου μνήμης.

32bit virtual memory

PLUNG&PLAY

Το wrap 4.0 είναι η πρώτη έκδοση που το υποστηρίζει.
[ΡΑΜ, ΟΚΤ. 1996, 114]

PRICE#cptEconomy541.44#

59000+ΦΠΑ (IBM HELLAS)/ 19.000

measure#cptCore88#

ΗΔΗ ΔΗΛΩΝΕΙ ΟΤΙ ΔΙΕΘΕΣΕ ΠΕΡΙΣΣΟΤΕΡΑ ΑΠΟ 1 ΕΚΑΤΟΜΜΥΡΙΟ ΚΟΜΜΑΤΙΑ ΣΤΟΥΣ ΠΡΩΤΟΥΣ 3 ΜΗΝΕΣ ΤΗΣ ΚΥΚΛΟΦΟΡΙΑΣ.
[RAM, MAR 1993, 44]

USER-INTERFACE#cptIt420#

To wrap 4.0 υπακούει στη δική σας φωνή.
[ΡΑΜ, ΟΚΤ. 1996, 114]

os.measure#cptCore88#

name::
* McsEngl.os.measure@cptItsoft,

{time.2015.06}
Statistics provided by Net Applications show that Window 7 has reached a market share of 60.98 percent in June 2015, obviously remaining the number one desktop operating system in the whole world.
Windows 8.1 is second in this list with 13.12 percent, while Windows XP is still being used by 13.12 percent of the PC owners across the world. Windows 8 has dropped even more to 2.90 percent, while Windows 10 keeps gaining share despite the preview tag, but it only reached 0.16 percent last month.
[http://news.softpedia.com/news/windows-7-reaches-60-percent-market-share-for-the-first-time-in-history-485763.shtml]

os.PINK

name::
* McsEngl.os.PINK@cptItsoft,
* McsEngl.conceptItsoft768,
* McsEngl.pink@cptItsoft768,
* McsEngl.os.pink@cptItsoft768,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
* OBJECT-ORIENTED-PROGRAM#cptIt951#

INFO-TECH-BUSINESS#cptEconomy7.108#

IBM APPLE... taligent on future(1995).

DOING#cptCore475#

multiprocessor,

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.ReactOS

_CREATED: {2013-06-17}

name::
* McsEngl.os.ReactOS@cptItsoft,
* McsEngl.ReactOS@cptItsoft,

_DESCRIPTION:
ReactOS® is a free open source operating system based on the best design principles found in the Windows NT® architecture (Windows versions such as Windows XP, Windows 7, Windows Server 2012 are built on Windows NT architecture). Written completely from scratch, ReactOS is not a Linux based system, and shares none of the UNIX architecture.

The main goal of the ReactOS® project is to provide an operating system which is binary compatible with Windows. This will allow your Windows® applications and drivers to run as they would on your Windows system. Additionally, the look and feel of the Windows operating system is used, such that people accustomed to the familiar user interface of Windows® would find using ReactOS straightforward. The ultimate goal of ReactOS® is to allow you to use it as alternative to Windows® without the need to change software you are used to.

ReactOS 0.3.15 is still in alpha stage, meaning it is not feature-complete and is recommended only for evaluation and testing purposes.
[http://www.reactos.org/]

_EVOLUTING:
News
2013-06-01 , Z98
Sourceforge Project of the Month
2013-05-30 , Z98
ReactOS 0.3.15 Released

os.SmartOS

_CREATED: {2013-08-01}

name::
* McsEngl.os.SmartOS@cptItsoft,
* McsEngl.SmartOS@cptItsoft,

_DESCRIPTION:
SmartOS is an open-source Unix-like operating system that combines OpenSolaris technology with Linux KVM virtualization.[1] Its core kernel contributed to illumos project. It features four technologies, ZFS, DTrace, Zones and KVM.[2][3] SmartOS is designed to be particularly suitable for building clouds and generating appliances.[4] It is developed for Joyent Cloud.
A partnership between Joyent and 10gen, the company that develops MongoDB, announced product/technology enhancements to increase performance, flexibility and scalability.[5]
[http://en.wikipedia.org/wiki/SmartOS] 2013-08-01,
===
SmartOS: The Worlds Most Advanced Operating System
Joyent SmartOS provides a combination of hardware and operating system (OS) virtualization to support efficient, reliable and high performing cloud computing.
Scale. An ultra-lean hypervisor that produces frictionless scale and fast provisioning.
Trust. The ZFS file system guarantees data integrity and prevent silent data corruption.
Secure. OS virtualization with highly secure zones, and KVM for legacy apps.
Reliable. Run from a live image. Impossible to fail upgrades when you can rollback to an earlier image.
Resilient. Service Management Facility (SMF) recovers faster from system failures. Fair share scheduling, CPU caps, and disk I/O throttling ensures better performance across the Joyent cloud.
Visibility. DTrace, lets you see everything that's happening throughout the software stack - safely, in real time, in production.
[https://www.joyent.com/technology/smartos]

os.TAILS

name::
* McsEngl.os.TAILS@cptItsoft,
* McsEngl.tails@cptItsoft,

_DESCRIPTION:
Tails is a live operating system, that you can start on almost any computer from a DVD, USB stick, or SD card. It aims at preserving your privacy and anonymity, and helps you to:
use the Internet anonymously and circumvent censorship;
all connections to the Internet are forced to go through the Tor network;
leave no trace on the computer you are using unless you ask it explicitly;
use state-of-the-art cryptographic tools to encrypt your files, emails and instant messaging.
[https://tails.boum.org/]

os.UNIXWARE

name::
* McsEngl.os.UNIXWARE@cptItsoft,
* McsEngl.conceptItsoft439,
* McsEngl.unixware-unix-operating-system@cptItsoft,
* McsEngl.unixware@cptItsoft439,

DEFINITION

is a UNIX-OS#cptIt243.1# for intel processor.
[NIKOS, JUNE 1995]

client-server

Operating system:
* Univel claims that UnixWare is capable of running all the traditional Unix applications, as well as DOS and Windows programs, without any performance degradation.
* Runs easily on a standard Intel-based desktop
* Simplified installation
* Integration of Novell's networking protocols
* good security
* Open Look and Motif desktop managers. ΓΡΑΦΙΚΑ ΠΕΡΙΒΑΛΟΝΤΑ.

ΠΟΛΛΟΙ ΤΟ ΘΕΩΡΟΥΝ ΣΤΡΑΤΗΓΙΚΗ ΑΠΑΝΤΙΣΗ ΤΗΣ NOVELL STA WINDOWS NT.
[RAM, SEP 1993]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

INFO-TECH-BUSINESS#cptEconomy7.108#

SCO το αγοράζει από τη NOVELL
[COMPUTER GO, NOV. 1995, 63]

UNIVEL (USL and NOVELL)
* 1993 Novell buys Unix labs of AT&T

ΑΝΤΙΠΡΟΣΩΠΟΣ
α) LAN WAN NETWORKS & COMMUNICATIONS,
β) ΠΟΥΛΙΑΔΗΣ & ΣΥΝΕΡΓΑΤΕΣ,
γ) ABC:

COMPATIBILITY-WITH-OTHER-OS#cptIt473#

ΜΕ ΤΟ DOS MERGE ΤΡΕΧΟΥΝ DOS APPLICATIONS.

UNIX ΓΙΑ PC, ΚΑΤΑΠΟΛΕΜΗΣΗ ΤΩΝ WINDOWS NT.

BIT-ARCHITECTURE#cptIt472#

* 32bit.

EVALUATION#cptCore546.107#

* Cannot run NetWare NLMs

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

1995:
version 2

ΔΙΑΤΙΘΕΤΑΙ ΣΕ client personal edition ΟΣΟ ΚΑΙ ΣΕ ΕΚΔΟΣΗ ΓΙΑ ΑΠΕΥΘΕΙΑΣ ΕΓΚΑΤΑΣΤΑΣΗ ΣΤΟ server.

APPLICATION EDITION
PERSONAL EDITION

DOING#cptCore475#

OPERATING SYSTEM#cptIt444-8#

NETWORKING

ME VOLUME ΓΙΝΕΤΑΙ ΠΡΟΣΠΕΛΑΣΗ ΣΤΑ ΑΡΧΕΙΑ ΤΟΥ ΔΙΚΤΥΟΥ.

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

PRICE#cptEconomy541.44#

65500 ΔΡΧ ΠΡΟΣΩΠΙΚΗ ΕΚΔΟΣΗ, [ΣΕΠΤ 1993],

$300, $1430 SERVER. [JUNE 1993]

os.VM/CMS

name::
* McsEngl.os.VM/CMS@cptItsoft,
* McsEngl.conceptItsoft384,
* McsEngl.VM'CMS@cptItsoft384,
* McsEngl.VM/CMS-{conversational-monitoring-system}-OPERATING-SYSTEM@cptItsoft,

DEFINITION

It is an operating system for IBM mainframes.
It is an IBM 3270 terminal oriented system.
It is part of an operating system known as VM/SP {Virtual Machine/System Product} running on the GWU's IBM mainframe computer.

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#

DOING#cptCore475#

OPERATING SYSTEM#cptIt444-8#

USER FUNCTIONS

FILE MANAGEMENT

ATTRIBUTES of a FILE:
"filename" "filetype" "filemode"

filename= 8 characters.

filetype= 8 characters, Some with special meaning are.
ADA
ASSEMBLE
EXEC
FORTRAN
LISTING
SCRIPT
SAS
WATFIV

filemode= the disk where the file can be found.

COPY FILES:
<COPYFILE oldf newf>=

DELETE FILE:
<ERASE fn ft fm>=

EDIT FILE:
<TYPE fn ft fm>= δειχνει τα περιεχομενα του αρχειου στην οθονη.
<XEDIT>= edit file.

LIST FILES:
<FILELIST filename filetype filemode> = displays the list of files.
(xedit commands can be used to manipulate the list).
<HELP CMS FILELIST> = help on filelist command.
<LISTFILE> = displays the files on accessed disks.
<RDRLIST>= displays the files on virtual reader.

QUERY DISK= statistics on your disks.

DISKS AVAILABLE:
DISK A/191 A-DISK: read/write disk for permanent storage.
DISK B: scratch disk, it is erased after log off.
VIRTUAL READER: contains the files sent to you until you receive them.
DISK S: READ ONLY WITH IBM SOFTWARE.
DISK Y: read only GWU computer center soft.
DISK U: read only GWU CIRC SOFT.
DISK V: IBM HELP files

HELP-function

HELP= a menu driven system of help.

<HELP "CMS/XEDIT/CP/REXX/GWU/7171/TCPIP/VMBATCH" "command">= provides help for the specific command.

<HELP CMS "command">= ΒΟΗΘΕΙΑ ΓΙΑ ΟΠΟΙΑΔΗΠΟΤΕ ΕΝΤΟΛΗ.

MULTITASKING

HX= halts the execution of a program.
HT= halts the typing of a file on screen.
SET FULLSCREEN "on/off"= fullscreen enables you to type commands anywhere on screen.

NETWORKING FUNCTION

BITNET NODE: GWUVM.BITNET
INTERNET NODE: GWUVM.GWU.EDU or 128.164.1.234
HELP TCPIP MENU

NEWS-function

HELP NEWS MENU= provides online news of the system.

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

MACHINES: IBM 4381/R13 (GWU)

os.UNIX

_CREATED: {2003-02-26} {1994}

name::
* McsEngl.conceptItsoft1122,
* McsEngl.conceptIt243,,
* McsEngl.os.unix@cptItsoft1122,
* McsEngl.UNIX operating system,
* McsEngl.unix@cptItsoft1122,

unix'DEFINITION

Είναι ενα ΛΣ πολλαπλών εργασιών, πολλαπλών χρηστών για μινικομπούτερς.

unix'GENERIC

_GENERIC:
* program.system.os#cptItsoft1111#

unix'APPLICATION#cptIt97#

name::
* McsEngl.unix'APPLICATION@cptItsoft,

unix'ASSOCIATION#cptIt969#

name::
* McsEngl.unix'ASSOCIATION@cptItsoft,

unix user association
FSF {free software foundation}
UniForum
USENIX

unix vendor organization
OSF {Open Software Foundation}
UI {unix international}

unix'ognCompany#cptEconomy7#

name::
* McsEngl.unix'ognCompany@cptItsoft,

unix'CONFIGURATION

name::
* McsEngl.unix'CONFIGURATION@cptItsoft,

unix'EVALUATION#cptCore546.107#

name::
* McsEngl.unix'EVALUATION@cptItsoft,

1) multitasking for each user.
2) graphics
3) cross-platform compatibility in one package
4) remote application execution
5) client/server program support
6) multiuser access
7) network printer services
8) seamless file sharing
9) Device independence. You can tell a program to send data to screen/printer.
10) Portability. Run on a wide range of computer makes and models FROM PCs TO MAINFRAMES. Open Systems. No other approaches this level of portability.
11) Tools Approach.

NEGATIVES:
1) It is still too hard to use and administer
2) not compatible enough across implementations
3) too maried to its old character-based, command-line, serial-terminal traditions.

unix'Evoluting#cptCore546.171#

name::
* McsEngl.unix'Evoluting@cptItsoft,

unix'FUTURE

name::
* McsEngl.unix'FUTURE@cptItsoft,

Analysts believe that Windows NT will slow Unix's growth.

unix'HISTORY

name::
* McsEngl.unix'HISTORY@cptItsoft,

=======

1992: UNIX had the 86% of the workstation market.

=======

1990: AT&T releasse System V Release 4

1986: DEC released the first commercial X Windows workstation.

1984: NFS was developed by Sun for its unix syste SunOS.

1984: 4.2 BSD

1983: AT&T released System V

1982: David Korn at AT&T Bell Labs wrote the Korn Shell.

1981: 4.1 BSD

1981: AT&T released System III

=======

1976: UUCP was originally written by Mike Lesk at AT&T.

1975: Sixth Edition

1973: Ξαναγραφτηκε ξανά χρησιμοποιώντας την μόλις δημιουργημένη γλώσα C.

=======

1969: The earliest UNIX.

unix'EXPOSITION#cptIt148#

name::
* McsEngl.unix'EXPOSITION@cptItsoft,

unix'file-system

name::
* McsEngl.unix'file-system@cptItsoft,
* McsEngl.unix'fs@cptItsoft,
* McsEngl.unix-file-system@cptItsoft,
* McsEngl.FileSystem.unix@cptItsoft,
* McsEngl.unix'FileSystem@cptItsoft,

GENERIC:
* FILE-SYSTEM#cptIt433#

BOOT BLOCK

BOOT BLOCK: occupies the first 512 bytes of the file system and contains a small program, called the BOOT PROGRAM, which loads the unix kernel and begins executing it.
Corresponds to DOS boot sector.

SUPERBLOCK

SUPERBLOCK: contains information about
* the size of the disk
* the unused disk area
* the name of the file system.
Corresponds to DOS file allocation Table.

i-NODE LIST

I-NODE LIST: Each i-node is 64 bytes long and a typical unix file system contains a list of several thousand i-nodes.

Each i-node contains information for a file or directory. The i-nodes are numbered, and the unix identify a file not by name but by the file's i-node number. When all i-nodes are used you cannot create anymore files on that disk.

The information stored in each is the one presented with ls -l command. Notably missing from the i-node information is the NAME of the file. File names are provided by directories.

DATA BLOCKS

DATA BLOCKS: Usally each block use 1024 bytes. Unix uses the i-node associated with a particular file as a table of contents for locating the data blocks that contain the data for that file.

directories are stored like a file. They have an i-node and data blocks. The data on each directory are the names of its files with their i-nodes.

QUANTITY OF FILES/DIR

Each file system can hold at most 65,534 files and directories.

unix'Doing#cptCore475#

name::
* McsEngl.unix'Doing@cptItsoft,

OPERATING SYSTEM#cptIt444-8#

FORMAT: commandname [options] [arguments]
* Arguments often are the names of files with the information to be processed.
* Options are preceded by a dash and tell a command to perform its function in a slightly different way.
* Unix is case censitive.
* The maximum length of any UNIX command is 5K characters.

MANAGER FUNCTIONS

FILE MANAGEMENT manager functions

backups:
tar, cpio, dcopy, copy, volcopy

group file: /etc/group

HARDWARE MANAGEMENT

autoexec file:
/etc/rc

boot the computer:
/unix/xenix, init, /etc/rc, gettys

close the computer: shutdown

configure terminals:
/etc/initab, /etc/gettydefs

USER MANAGEMENT

add user:
1. pick a file system for her home dir,
2. make an entry in the password file,
3. assign a password,
4. modify the group file,
5. create a home dir,
6. create a .profile,
7. configure terminal

delete user:
1. back up his home dir,
2. remove his home dir,
3. remove the entry from password file,
4. modify group file,
5. modify terminal

list of users on:
who

SECURITY

system level:
password file:
/etc/passwd

file level:
change group: chgrp
change ownenr: chown
change permissions: chmod

USER FUNCTIONS

DIRECTORY MANAGEMENT user functions

change dir: cd

create dir: mddir

delete dir: rmdir

display current dir: pwd

FILE MANAGEMENT user functions

classify files: file

compress files: pack

copy files: cp

delete file: rm

edit files:
sort file contents: sort

link files: ln

list files: ls

move files: mv

print files: lp

rename file: mv

search for file: grep, find

sort files: sort

view file: cat, pg, more

FILE SYSTEM user functions

check fs: fsck

create fs: mkfs

list fs: df.

NETWORKING user funtions

copy files: uucp

list of computer to communicate: uuname

list the arrived files: uupick

mail:
send mail: mail
send message: write

remote execution: uux

PROCESS user functions

background execution: & at the end of command
non hang up a bg when logoff: nohup
stop a bg process: kill

combine commands: |

grouping: ()

in turn execution: ;

list of processes: ps

only if first was executed: &&

only if preceding fails: ||

priority:
less priority: nice

substitution of a command: ``

NETWORKING-function

networking unix computers
NFS {network file system} Sun
RFS {remote file sharing}, AT&T
UUCP {Unix to Unix copy} the first protocol

UTILITIES

* Merge from Locus Computing= Visual mode simulator. dos+unix.
* SoftPC=emulator. dos+unix, slow.
* SunIPC=plug in board. dos+unix.
* VP/ix from Sunsoft=visual mode simulator. enables to run UNIX and DOS

VARIABLES

creation: variable=value

unix'FILE#cptIt354#

name::
* McsEngl.unix'FILE@cptItsoft,

unix'GUI

name::
* McsEngl.unix'GUI@cptItsoft,

unix'HARDWARE'DEMAND#cptIt1#

name::
* McsEngl.unix'HARDWARE'DEMAND@cptItsoft,

network#cptIt262#

unix'INSTALLATION

name::
* McsEngl.unix'INSTALLATION@cptItsoft,

unix'script

name::
* McsEngl.unix'script@cptItsoft,

unix'shebang (#!)

name::
* McsEngl.unix'shebang (#!)@cptItsoft,
* McsEngl.shebang.unix@cptItsoft,

_DESCRIPTION:
In computing, a shebang (also called a sha-bang,[1][2][3] hashbang,[4][5] pound-bang,[2][6] hash-exclam,[2] or hash-pling[2][7]), is the character sequence consisting of the characters number sign and exclamation mark (that is, "#!") at the beginning of a script.

Under Unix-like operating systems, when a script with a shebang is run as a program, the program loader parses the rest of the script's initial line as an interpreter directive; the specified interpreter program is run instead, passing to it as an argument the path that was initially used when attempting to run the script.[8] For example, if a script is named with the path "path/to/script", and it starts with the following line:

#!/bin/sh
then the program loader is instructed to run the program "/bin/sh" instead (usually this is the Bourne shell or a compatible shell), passing "path/to/script" as the first argument.

The shebang line is usually ignored by the interpreter because the "#" character is a comment marker in many scripting languages; some language interpreters that do not use the hash mark to begin comments (such as Scheme) still may ignore the shebang line in recognition of its purpose.[9]
[http://en.wikipedia.org/wiki/Shebang_(Unix)]

unix'SHELL

name::
* McsEngl.unix'SHELL@cptItsoft,
* McsEngl.unix'command-line-interpreter@cptItsoft,

_DEFINITION:
A Unix shell is a command-line interpreter or shell that provides a traditional user interface for the Unix operating system and for Unix-like systems. Users direct the operation of the computer by entering command input as text for a command line interpreter to execute or by creating text scripts of one or more such commands.
[http://en.wikipedia.org/wiki/Unix_shell]

_SPECIFIC:
The most influential Unix shells have been the Bourne shell and the C shell. The Bourne shell, sh, was written by Stephen Bourne at AT&T. sh is the original Unix command line interpreter; it introduced the basic features common to all the Unix shells, including piping, here documents, command substitution, variables, control structures for condition-testing and looping and filename wildcarding. The language, including the use of a reversed keyword to mark the end of a block, was influenced by ALGOL 68.[1]

The C shell, csh, was written by Bill Joy while a graduate student at University of California, Berkeley. The language, including the control structures and the expression grammar, was modeled on C. The C shell also introduced a large number of features for interactive work, including the history and editing mechanisms, aliases, directory stacks, tilde notation, cdpath, job control and path hashing.

Both shells have been used as coding base and model for many derivative and work-alike shells with extended feature sets.
[http://en.wikipedia.org/wiki/Unix_shell]

unix'shell.sh

name::
* McsEngl.unix'shell.sh@cptItsoft,

unix'shell.csh

name::
* McsEngl.unix'shell.csh@cptItsoft,

unix'shell.bash

name::
* McsEngl.unix'shell.bash@cptItsoft,
* McsEngl.unix'bash@cptItsoft,
* McsEngl.unix'GNU-Bourne-Again-SHell@cptItsoft,

DESCRIPTION
Bash is an sh-compatible command language interpreter that executes commands read from the standard input or from a file. Bash also incorporates useful features from the Korn and C shells (ksh and csh).

Bash is intended to be a conformant implementation of the IEEE POSIX Shell and Tools specification (IEEE Working Group 1003.2).
[http://linux.about.com/library/cmd/blcmdl1_sh.htm]

unix'ResourceInfHmnn#cptResource843#

name::
* McsEngl.unix'ResourceInfHmnn@cptItsoft,

UNIX publications
UNIX Review
UNIX Today
UNIXWorld

unix'structure#cptCore515#

name::
* McsEngl.unix'structure@cptItsoft,

PARTS: Kernel, Shell, Tools

unix'PRICE#cptEconomy541.44#

name::
* McsEngl.unix'PRICE@cptItsoft,

unix'PROFESSIONAL#cptIt6#

name::
* McsEngl.unix'PROFESSIONAL@cptItsoft,

unix'TIP#cptIt470#

name::
* McsEngl.unix'TIP@cptItsoft,

unix'TROUBLESHOOTING#cptIt52#

name::
* McsEngl.unix'TROUBLESHOOTING@cptItsoft,

SPECIFIC

unix.specific,

_SPECIFIC:
* VERSIONS: At least 25 different Unixes exist now (1992), but 6 provides dominate:
* LINUX#cptItsoft1069#

unix.SPECIFIC-DIVISION.processor

name::
* McsEngl.unix.SPECIFIC-DIVISION.processor@cptItsoft,

_SPECIFIC:
* unix-on-intel-processor##
* unix-on-non-intel-processor##

unix.SPECIFIC-DIVISION.company

name::
* McsEngl.unix.SPECIFIC-DIVISION.company@cptItsoft,

_SPECIFIC:
* A/UX 3.0 (1992), Apple#cptItsoft517#
BSD 4.3, University of California at Berkeley
AIX, IBM
Coherent, Mark Williams Co.
Destiny, USL... PC. Διακινείται απο Novell
ESIX, Esix Computer
HP-UX, Hewlett-Packard
NonStop-UX, Tandem
Open Desktop 2.0, SCO
OSF/1 Open Software Foundation
Ultrix, DEC
UNICOS, Cray
Uniplus, Unisoft
UTS, Amdahl
Venix, Venturecom
XENIX, Microsoft
===
AT&T,
Esix computer,
Mark Williams, Coherent, 7th ed. less $100
Microport,
SCO,
Sun Microsystems, SunOS
The Santa Cruz Operation, Open Desktop 2.0
Hewlett-Packard, HP-UX
Unix Software Laboratories, SVR4.2
DEC, Ultrix
IBM, AIX

unix.INTERACTIVE-UNIX-SYSTEM-V/386 {1987}

name::
* McsEngl.unix.INTERACTIVE-UNIX-SYSTEM-V/386 {1987}@cptItsoft,
* McsEngl.conceptItsoft655,
* McsEngl.INTERACTIVE-UNIX-SYSTEM-V/386-(1987)@cptItsoft,
* McsEngl.os.interactive-unix-system-v-386@cptItsoft,

DEFINITION

is a UNIX-OS#cptIt243.1# for intel processor.
[NIKOS, JUNE 1995]

GENERIC

_GENERIC:
* program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

INFO-TECH BUSINESS#cptEconomy7.108#

Sunsoft, ΑΝΤΙΠΡΟΣΩΠΟΣ ALTEC,

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

3.0, 4.0(1993)

DOING#cptCore475#

operating-system#cptIt444-8#

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

INTEL PROCESSOR

PRICE#cptEconomy541.44#

$900 ΧΩΡΙΣ NETWORK.

unix.MACH

name::
* McsEngl.unix.MACH@cptItsoft,
* McsEngl.conceptItsoft683,
* McsEngl.Mach@cptItsoft,
* McsEngl.os.mach@cptItsoft,

DEFINITION

ΕΙΝΑΙ ΜΙΑ ΠΑΡΑΛΑΓΗ ΤΟΥ UNIX, ΠΟΥ ΑΡΧΙΣΕ ΝΑ ΑΝΑΠΤΥΣΣΕΤΑΙ ΤΟ 1984 ΣΤΟ ΠΑΝΕΠΙΣΤΗΜΙΟ CARNEGIE-MELLON.
ΠΡΟΚΕΙΤΑΙ ΓΙΑ ΕΝΑ object oriented OS.

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#
OBJECT-ORIENTED-PROGRAM#cptIt951#

unix.org.APPLE-A-UX

name::
* McsEngl.unix.org.APPLE-A-UX@cptItsoft,
* McsEngl.conceptItsoft517,
* McsEngl.os.apple-a-ux@cptItsoft,
* McsEngl.unix.apple-a-ux@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
* unix-os##

INFO-TECH-BUSINESS#cptEconomy7.108#

Apple computer corporation.

DOING#cptCore475#

operating-system#cptIt444-8#

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

unix.org.DEC-OSF-1

name::
* McsEngl.unix.org.DEC-OSF-1@cptItsoft,
* McsEngl.conceptItsoft590,
* McsEngl.DEC-OSF/1@cptItsoft,
* McsEngl.DIGITAL-UNIX; 1995 name@cptItsoft,
* McsEngl.os.dec-osf-1@cptItsoft,
* McsEngl.unix.dec-osf-1@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

INFO-TECH-BUSINESS#cptEconomy7.108#

DEC

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

1.2

1995:
3.2

DOING#cptCore475#

θα διατιθεται απο μαρτιο 1993. το πρωτο πραγματικό 64μπιτο λειτουργικό σύστημα.

OSF/1 Release 1.1 της Οpen Software foundation: η τελευταια εκδοση του UNIX.
θα πουλειται απο Ιούνη 1992. Μπορει να τρέχει σε συστήματα μόνο με 4ΜΒ μνήμη.
Κοστίζει 85.000 δολ με την άδεια χρήσης και δικαίωμα διανομής.
Υποστηριζει διεθνεις γλώσες, γιαπωνέζικα κ.α.
Στοχεύει τους Μ/Υ οπως το Unix System 4.2.

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

Χρησιμοποιείται σε όλα τα συστήματα που βασίζονται στον επεξεργαστή Alpha της DEC.
[COMPUTER GO, MAY 1995, 54]

unix.org.SCO-MPX

name::
* McsEngl.unix.org.SCO-MPX@cptItsoft,
* McsEngl.conceptItsoft801,
* McsEngl.os.sco-mpx@cptItsoft,
* McsEngl.SCO-MPX@cptItsoft,
* McsEngl.unix.sco-mpx@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

DOING#cptCore475#

ΥΠΟΣΤΗΡΙΖΕΙ ΔΕΥΤΕΡΟ ΕΠΕΞΕΡΓΑΣΤΗ

unix.org.SCO-UNIX

name::
* McsEngl.unix.org.SCO-UNIX@cptItsoft,
* McsEngl.conceptItsoft802,
* McsEngl.os.sco-unix@cptItsoft,
* McsEngl.SCO-UNIX-4.0@cptItsoft,
* McsEngl.unix.sco-unix@cptItsoft,

DEFINITION

is a UNIX-OS#cptIt243.1# for intel processor.
[NIKOS, JUNE 1995]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

INFO-TECH-BUSINESS#cptEconomy7.108#

SANTA CRUZ OPERATION,

ΑΝΤΙΠΡΟΣΩΠΟΣ ALGOSYSTEMS

EVALUATION#cptCore546.107#

ΠΙΟ ΔΙΑΔΕΔΟΜΕΝΟ ΓΙΑ INTEL MHXANHMATA,

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

unix.org.WYSE-UNIX-System-V/386

name::
* McsEngl.unix.org.WYSE-UNIX-System-V/386@cptItsoft,
* McsEngl.conceptItsoft886,
* McsEngl.os.wyse-unix-system-v-386@cptItsoft,
* McsEngl.unix.wyse-unix-system-v-386@cptItsoft,
* McsEngl.WYSE-UNIX-System-V/386@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

INFO-TECH-BUSINESS#cptEconomy7.108#

ΑΝΤΙΠΡΟΣΩΠΟΣ DATAMEDIA

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

unix.PLAN-9

name::
* McsEngl.unix.PLAN-9@cptItsoft,
* McsEngl.conceptItsoft770,
* McsEngl.Plan-9@cptItsoft,
* McsEngl.os.plan-9@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

unix.PowerOpen

name::
* McsEngl.unix.PowerOpen@cptItsoft,
* McsEngl.conceptItsoft772,

name::
* McsEngl.os.PowerOpen@cptItsoft,
* McsEngl.PowerOpen@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#
* mac-os##

DOING#cptCore475#

multiprocessor ΕΠΕΞΕΡΓΑΣΤΕΣ PowerPC, Motorola.
ΘΑ ΒΑΣΙΖΕΤΑΙ ΣΤΟ UNIX OSF/1.

unix.processor.INTEL

name::
* McsEngl.unix.processor.INTEL@cptItsoft,

_SPECIFIC:
* Interactive UNIX System V/386#cptIt655, SunSoft: attSpe#
* SCO UNIX#cptIt802: attSpe#
* Solaris#cptIt409: attSpe#
* SVR4.2##cptItsoft438#, USL: attSpe#
* UnixWare##cptItsoft439#, Univel (USL, Novell): attSpe#

unix.processor.INTEL.NO

name::
* McsEngl.unix.processor.INTEL.NO@cptItsoft,

unix.SVR4.2

name::
* McsEngl.unix.SVR4.2@cptItsoft,
* McsEngl.conceptItsoft438,
* McsEngl.os.SVR4.2@cptItsoft,
* McsEngl.SVR4.2-Unix-System-V-release-4.2-(destiny)@cptItsoft,

DEFINITION

Sold as UnixWare by Univel (Novell+USL).

is a UNIX-OS#cptIt243.1# for intel processor.
[NIKOS, JUNE 1995]

Η εταιρεία Unix Systems Laboratories, θυγατρική της AT&T, ανακοίνωσε τη διάθεση της νεας version του Unix-System V, Release 4.2, που εχει στόχο την αγορά των προσωπικών υπολογιστων.
Θελουν να ανταγωνιστούν το Windows NT
[COMPUTER Ιουλ-Αυγ 1992]

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

INFO-TECH-BUSINESS#cptEconomy7.108#

Sold as UnixWare by Univel (Novell+USL).

COMPATIBILITY-WITH-OTHER-OS#cptIt473#

Compatibility with 7 leading Unix implementations, including SunOS/Solaris, SVR3.2, BSD, Xenix.

DOING#cptCore475#

2) Inclusion of TCP/IP networking

HARDWARE-DEMAND#cptIt1#

SVR4.2's minimum configuration is a 16-MHz 386SX with 4MB of memory.

unix.V

name::
* McsEngl.unix.V@cptItsoft,
* McsEngl.conceptItsoft852,
* McsEngl.os.V@cptItsoft,

GENERIC

_GENERIC:
*-#ql:[Level CONCEPT:rl? conceptIt434]#program.system.os#cptItsoft1111#
NETWORK-OS#cptIt119#
* unix-os#cptItsoft1122#

HARDWARE-DEMAND#cptIt1#

network-info-machine#cptIt262#

os.UNIX-LIKE

_CREATED: {2013-12-17}

name::
* McsEngl.os.UNIX-LIKE@cptItsoft,
* McsEngl.unix-like-os@cptItsoft,

_DESCRIPTION:
A Unix-like (sometimes referred to as UN*X or *nix) operating system is one that behaves in a manner similar to a Unix system, while not necessarily conforming to or being certified to any version of the Single UNIX Specification.

There is no standard for defining the term, and some difference of opinion is possible as to the degree to which a given operating system is "Unix-like".

The term can include free and open-source operating systems inspired by Bell Labs' Unix or designed to emulate its features, commercial and proprietary work-alikes, and even versions based on the licensed UNIX source code (which may be sufficiently "Unix-like" to pass certification and bear the "UNIX" trademark).
[http://en.wikipedia.org/wiki/Unix-like]

os.WEB-OPERATING-SYSTEM

_CREATED: {2013-07-30}

name::
* McsEngl.os.WEB-OPERATING-SYSTEM@cptItsoft,
* McsEngl.web-operating-system@cptItsoft,
* McsEngl.webOS@cptItsoft,

_DESCRIPTION:
Web operating system and webOS are metacomputing terms that refer to network services for Internet scale distributed computing, as in the WebOS Project at UC Berkeley,[1] and the WOS Project.[2] In both cases, the scale of the "web operating system" extends across the Internet, like the web.

However, the terms webOS and web operating system have been employed more broadly and with far greater popularity in the context of "the web as in HTTP", and for many meanings ranging from singular systems to collections of systems.[3][4][5][6] In April 2002, Tim O'Reilly spoke of "the emergent Internet operating system" as an open collection of Web services.[7]

Common to uses for collections of systems, a web operating system is distinct from Internet operating systems in that it is independent of the traditional individual computer operating system. This conception of the system reflects an evolution of research in the field of operating systems into the increasingly minimized (for example, TinyOS and Exokernel) and distributed (for example, Inferno), and for distributed systems increasingly defined in terms of the specification of their network protocols more than their implementations (for example, Plan9's 9P).

In a usage referring to singular network services, a web operating system is another name for a Webtop. These services turn the desktop into a service that runs on the Internet[8] rather than on the local computer. As these services include a file system and application management system, they increasingly overlap with the functionality of a traditional desktop computer operating system.

In a usage referring to desktop (or handheld) computer application environments, a web operating system is a traditional operating system that is focused on supporting Web applications themselves, or a desktop operating system solely providing Web access.[9][10][11] Systems like these also are known as kiosks.
[http://en.wikipedia.org/wiki/Web_operating_system]

os.VirtualBox

name::
* McsEngl.os.VirtualBox@cptItsoft,
* McsEngl.virtualBox@cptItsoft,
* McsEngl.osVbx@cptItsoft,
* McsEngl.pgmVbx@cptItsoft,
* McsEngl.pgm.virtualBox@cptItsoft,

_DESCRIPTION:
VirtualBox is a cross-platform virtualization application. What does that mean? For one thing,
it installs on your existing Intel or AMD-based computers, whether they are running Windows,
Mac, Linux or Solaris operating systems. Secondly, it extends the capabilities of your existing
computer so that it can run multiple operating systems (inside multiple virtual machines) at the
same time. So, for example, you can run Windows and Linux on your Mac, run Windows Server
2008 on your Linux server, run Linux on your Windows PC, and so on, all alongside your existing
applications. You can install and run as many virtual machines as you like – the only practical
limits are disk space and memory
[http://download.virtualbox.org/virtualbox/5.1.22/UserManual.pdf]

os.EVOLUTING#cptCore546.171#

name::
* McsEngl.os.EVOLUTING@cptItsoft,

{time.2001-10-25}:
Windows XP released.

os'future

name::
* McsEngl.os'future@cptItsoft,

ΠΟΛΛΕΣ ΠΡΟΒΛΕΨΕΙΣ ΑΝΑΦΕΡΟΥΝ ΟΤΙ ΜΕΧΡΙ ΤΟ ΕΤΟΣ 2000 ΟΛΟΙ ΟΙ ΥΠΟΛΟΓΙΣΤΕΣ ΤΟΥ ΠΛΑΝΗΤΗ ΘΑ ΣΥΝΔΕΟΝΤΑΙ ΣΕ ΚΑΠΟΙΟΥ ΕΙΔΟΥΣ ΔΙΚΤΥΟ (ΤΟΠΙΚΟ ή ΕΥΡΕΙΑΣ ΠΕΡΙΟΧΗΣ) ΚΑΙ ΑΥΤΟ ΣΗΜΑΙΝΕΙ ΟΤΙ ΤΑ ΔΙΑΧΩΡΙΣΤΙΚΑ ΤΕΙΧΗ ΑΝΑΜΕΣΑ ΣΤΑ ΛΕΙΤΟΥΡΓΙΚΑ ΣΥΣΤΗΜΑΤΑ ΣΥΝΤΟΜΑ ΘΑ ΕΞΑΛΕΙΦΘΟΥΝ.
[CHIP, JAN 1994, 54]

os'RELEASE

name::
* McsEngl.os'RELEASE@cptItsoft,

The date of market release of the system.

os'version#cptIt471#

name::
* McsEngl.os'version@cptItsoft,

FvMcs.Cmrpgm.JAVA

name::
* McsEngl.conceptItsoft1200,
* McsEngl.Cmrpgm.JAVA@cptItsoft,
* McsEngl.FvMcs.Cmrpgm.JAVA@cptItsoft,
* McsEngl.java-program@cptItsoft,
* McsEngl.java'program@cptItsoft1200,
* McsEngl.jv'program@cptItsoft1200,

DEFINITION

Programs are organized sets of packages.
[spec jvm 2, 1999]

An application is Java program that runs with a Java virtual machine (Java VM) that is installed on the client system. Applications typically consist of one or more forms or applets, including the components on that form, and programming which add functionality to the forms and components on the form.
[Reprint permission by Symantec, Visual Cafe 1996]

jvp'GENERIC

_GENERIC:
* application#ql:[Level CONCEPT:rl? conceptIt97]##cptIt97#
* PROGRAM#cptIt59#

jvp'WHOLE

_WHOLE:
* java-softsys#ql:jv'software_system###

Thus, the skeleton of any Java program is a class definition.
[JavaSoft Tutorial, 1996jul06]

jvp'API (PACKAGE)

name::
* McsEngl.jvp'API (PACKAGE)@cptItsoft,
* McsEngl.jvp'package@cptItsoft1200,

_DEFINITION: the structure of the elements (classes/interfaces) of the program.

jvp'CONVENTION

name::
* McsEngl.jvp'CONVENTION@cptItsoft,

NAME NOTATION:
1) xxxx_yyyy: a part of xxx
2) xxxxYyyyy: a specific of xxxx
[hknu_2006-09-03]

jvp'CONVERTION

name::
* McsEngl.jvp'CONVERTION@cptItsoft,

APPLET to APPLICATION:
To convert an applet into an application, you need to add a main() method that creates an instance of a Frame subclass, creates an instance of the Applet (or Panel or Canvas) subclass, adds the instance to the Frame, and then calls the init() and start() methods of the instance. The Frame subclass should have a handleEvent() implementation that handles WINDOW_DESTROY events in the appropriate way.
[Java Tutorial, 1996dec24]

jvp'DESIGN

name::
* McsEngl.jvp'DESIGN@cptItsoft,

What is a good Java program design, and how do you create one?

jvp'EXECUTION

name::
* McsEngl.jvp'EXECUTION@cptItsoft,

1. VIRTUAL-MACHINE START-UP

A Java Virtual Machine starts up
- by loading a specified class and
- then invoking the method main in this specified class.
[lang spec, 1996aug]

2. LOADING THE 'TEST' CLASS

jv'Loading

Loading is the process of finding the binary form of a class or interface type with a particular name and constructing, from that binary form, a Class object to represent the class or interface.
[spec jvm 1, 1996sep]

in a UNIX implementation, the command line:
java Test reboot Bob Dot Enzo
will typically start a Java Virtual Machine by invoking method main of class Test (a class in an unnamed package), passing it an array containing the four strings "reboot", "Bob", "Dot", and "Enzo".

The initial attempt to execute the method main of class Test discovers that the class Test is not loaded-that is, that the virtual machine does not currently contain a binary representation for this class. The virtual machine then uses a class loader to attempt to find such a binary representation. If this process fails, then an error is thrown.
[lang spec, 1996aug]

The loading process is implemented by the class ClassLoader#ql:jv'classloader# and its subclasses. Different subclasses of ClassLoader may implement different loading policies.
[lang spec, 1996aug]

3. LINKING THE CLASS TEST

name::
* McsEngl.3. LINKING THE CLASS TEST@cptItsoft,
* McsEngl.jv'Linking@cptItsoft,
* McsEngl.jv'linking-time@cptItsoft,
* McsEngl.jv'linking-process@cptItsoft,

Linking is the process of taking a binary form of a class or interface type and combining it into the runtime state of the Java Virtual Machine so that it can be executed.
[spec jvm 1, 1996sep]

After Test is loaded, it must be initialized before main can be invoked. And Test, like all (class or interface) types, must be linked before it is initialized.
Linking involves
- verification,
- preparation and (optionally)
- resolution.
[lang spec, 1996aug]

VERIFICATION OF CLASS TEST

Verification checks that the loaded representation of Test is well-formed, with a proper symbol table. Verification also checks that the code that implements Test obeys the semantic requirements of Java and the Java Virtual Machine. If a problem is detected during verification, then an error is thrown. Verification is described further in §12.3.1.
[lang spec, 1996aug]

PREPARATION OF CLASS TEST

Preparation involves allocation of static storage and any data structures that are used internally by the virtual machine, such as method tables. If a problem is detected during preparation, then an error is thrown. Preparation is described further in §12.3.2.
[lang spec, 1996aug]

RESOLUTION OF CLASS TEST

Resolution is the process of checking symbolic references from Test to other classes and interfaces, by loading the other classes and interfaces that are mentioned and checking that the references are correct.
The resolution step is optional at the time of initial linkage.
[lang spec, 1996aug]

4. INITIALIZATION OF CLASS TEST

name::
* McsEngl.4. INITIALIZATION OF CLASS TEST@cptItsoft,
* McsEngl.jv'Initialization'Of'A'Class@cptItsoft,

Initialization of a class consists of executing its static initializers and the initializers for static fields declared in the class.
[spec jvm 1, 1996sep]

Initialization consists of
execution of any class variable initializers and static initializers of the class Test, in textual order.

But before Test can be initialized, its direct superclass must be initialized, as well as the direct superclass of its direct superclass, and so on, recursively.

If class Test has another class Super as its superclass, then Super must be initialized before Test. This requires loading, verifying, and preparing Super if this has not already been done and, depending on the implementation, may also involve resolving the symbolic references from Super and so on, recursively.
[lang spec, 1996aug]

ORDER:
Within a class, the order of initialization is strictly in the order that the variables are defined within the class. Even if the variable definitions are scattered throughout in between method definitions, the variables are initialized before any methods can be called, even the constructor.
[B. ECKEL, Thinking In Java, 1997aug18, 112]

Loading of (SUPER) Classes and Interfaces

Loading
refers to the process of finding the binary form of a class or interface type with a particular name, perhaps by computing it on the fly, but more typically by retrieving a binary representation previously computed from source code by a compiler, and constructing, from that binary form, a Class object to represent the class or interface.
[lang spec, 1996aug]

The loading process is implemented by the class ClassLoader#ql:jv'class.classloader# (§20.14) and its subclasses.
[lang spec, 1996aug]

Linking of (SUPER) Classes and Interfaces

Linking
is the process of taking a binary form of a class or interface type and combining it into the runtime state of the Java Virtual Machine, so that it can be executed. A class or interface type is always loaded before it is linked.
Three different activities are involved in linking: verification, preparation, and resolution of symbolic references.
[lang spec, 1996aug]

VERIFICATION

Verification ensures that the binary representation of a class or interface is structurally correct.
[lang spec, 1996aug]

PREPARATION

Preparation involves
- creating the static fields (class variables and constants) for a class or interface and
- initializing such fields to the standard default values (§4.5.4).
[lang spec, 1996aug]

RESOLUTION

A Java binary file references other classes and interfaces and their fields, methods, and constructors symbolically, using the fully-qualified names of the other classes and interfaces (§13.1). For fields and methods, these symbolic references include the name of the class or interface type that declares the field or method as well as the name of the field or method itself, together with appropriate type information.
Before a symbolic reference can be used it must be undergo resolution, wherein a symbolic reference
- is checked to be correct and, typically,
- replaced with a direct reference that can be more efficiently processed if the reference is used repeatedly.
[lang spec, 1996aug]

INITIALIZATION OF SUPER classes and interfaces

Initialization of a class consists of
executing its static initializers and the initializers for static fields (class variables) declared in the class. Initialization of an interface consists of executing the initializers for fields (constants) declared there.
[lang spec, 1996aug]

5. INVOKING THE MAIN-METHOD

Finally, after completion of the initialization for class Test (during which other consequential loading, linking, and initializing may have occurred), the method main of Test is invoked.
[lang spec, 1996aug]

Unloading of Classes and Interfaces

6. VIRTUAL MACHINE EXIT

A Java Virtual Machine terminates all its activity and exits when one of two things happens:
* All the threads that are not daemon threads (§20.20.24) terminate.
* Some thread invokes the exit method (§20.16.2) of class Runtime or class System and the exit operation is not forbidden by the security manager (§20.17.13).
[lang spec, 1996aug]

jvp'preference

name::
* McsEngl.jvp'preference@cptItsoft,
* McsEngl.jvp'option@cptItsoft,
* McsEngl.jv'PREFERENCES@cptItsoft,

_DESCRIPTION:
Your Java programs run within some environment. That is, the program runs in an environment where there's a host machine, a current directory, user preferences for window color, font, font size, and other environmental attributes. In addition to these system (or runtime) attributes, your program can set up certain, configurable, program-specific attributes. Program attributes are often called preferences and allow the user to configure various startup options, preferred window size, and so on.

Java programs can manage program attributes through three mechanisms:
- properties,
- application command line arguments, and
- applet parameters.
[Java Tutorial, 1996dec24]

jv'COMMAND'LINE'ARGUMENT

name::
* McsEngl.jv'COMMAND'LINE'ARGUMENT@cptItsoft,

Command line arguments are passed in an array of Strings.
The first array component is the Zeroth.
All are passed as String values, never as numbers.

jv'ex.Command'line'argument:
class printArgs {
public static void main (String args[]) {
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
[Harold Course 1997]

jvp.SPECIFIC#cptCore546.23#

name::
* McsEngl.jvp.SPECIFIC@cptItsoft,

_SPECIFIC:#ql:_GENERIC cptItsoft1200)#,
* EDITOR
* DATABASE
* PARSER#cptItsoft1200.1: attSpe#
* Java SCS##cptIt356.12#: attSpe#
-------------------------------------------------------------------------------------
* eXist (opensource, xml database, fulltext search, http://exist-db.org)
* BeanBox
* JFreeReport (generates PDF, http://www.object-refinery.com/jfreereport/index.html, opensource)
* JObjects (www.jobjects.com, full-text-search, not opensource),

jvp.SPECIFIC-DIVISION.STANDALONE

name::
* McsEngl.jvp.SPECIFIC-DIVISION.STANDALONE@cptItsoft,

* jvp.APPLICATION#cptItsoft1212: attSpe#
* jvp.APPLET#cptItsoft1030: attSpe#
* jvp.APPLICATION'AND'APPLET

jvp.eXist

name::
* McsEngl.jvp.eXist@cptItsoft,

eXist is an Open Source native XML database featuring pluggable storage backends, efficient, index-based XPath query processing, extensions for keyword search and tight integration with existing XML development tools. The database is lightweight, completely written in Java and may be easily deployed in a number of ways, running either as a stand-alone server process, inside a servlet-engine or directly embedded into an application.
The database is currently best suited for applications dealing with small to large collections of XML documents, which are occasionally updated. Depending on how the database engine has been deployed, eXist offers several interfaces to application developers, including HTTP, XML-RPC, SOAP and WebDAV. Java developers should have a look at the XML:DB API, which provides a common interface to access XML database services.
eXist integrates well with Apache's Cocoon, allowing developers to create complex web applications entirely based on XML and related technologies.
[http://exist-db.org]

jvp.BeanBox

name::
* McsEngl.jvp.BeanBox@cptItsoft,

BeanBox
is Sun's sample CONTAINER for testing visible Beans.

beanbox'AboutDialog.class

beanbox'BeanBox.class
A Panel#ql:jv'panel#.
** BeanBox(): Initialize a new BeanBox.
** doInsert(Object, boolean): Insert a given Component instance into the current BeanBox.
** mouseClicked(MouseEvent)
** mouseDragged(MouseEvent)
** mouseEntered(MouseEvent)
** mouseExited(MouseEvent)
** mouseMoved(MouseEvent)
** mousePressed(MouseEvent)
** mouseReleased(MouseEvent)
** paint(Graphics) Repaint the current beanbox.
** queueMenuItem(ActionEvent) Schedule a menu item to be executed asynchronously in the BeanBox's menu handling thread.
** run()
** save() This implements the "save" menu item.
** updateMenuBar(MenuBar) Update the MenuBar for the current beanBox and focus bean.

beanbox'BeanBoxAppletContext.class

beanbox'BeanBoxAppletStub.class

beanbox'BeanBoxFrame.class:
** The START class
extends java.awt.Frame
implements java.awt.LayoutManager, java.lang.Runnable, java.awt.event.ActionListener
public static void main(java.lang.String[]);
public BeanBoxFrame();
public void actionPerformed(java.awt.event.ActionEvent);
static java.lang.Object getCurrentBean();
static java.awt.Component getCurrentComponent();
static sun.beanbox.Wrapper getCurrentWrapper();
static sun.beanbox.BeanBox getCurrentBeanBox();
static void setCurrentComponent(java.awt.Component);
public void run();
public void setCustomizer(java.beans.Customizer);
public void dispose();
public static java.lang.String getClipDir();
public static java.lang.String getClipFileName();
public static java.lang.String getClipResource();
public static java.lang.String getTmpDir();
public void addLayoutComponent(String, Component);
public void removeLayoutComponent(java.awt.Component);
public java.awt.Dimension preferredLayoutSize(java.awt.Container);
public java.awt.Dimension minimumLayoutSize(java.awt.Container);
public void layoutContainer(java.awt.Container);
public static BeanBox getTopBox();
public static Wrapper getTopWrapper();
public static ToolBox getToolBox();
public static boolean showTimes();
public static boolean getHideInvisibleBeans();
public static void setHideInvisibleBeans(boolean);
public static void setDesignTime(boolean);
public static java.lang.String getVersionID();

beanbox'CustomizerDialog.class

beanbox'DoOnBean.class
Interface
** action(JarInfo, BeanInfo, String)
** error(String)
** error(String, Exception)

beanbox'EditedAdaptor.class

beanbox'ErrorDialog.class

beanbox'EventTargetDialog.class

beanbox'FileExtension.class

beanbox'HookupManager.class

beanbox'InputStreamProducer.class:
An interface for producing an InputStream on demand
** getInputStream()

beanbox'JarInfo.class

beanbox'JarLoader.class

beanbox'Manifest.class

beanbox'MessageHeader.class

beanbox'MessageDialog.class

beanbox'MyProducer.class

beanbox'ObjectInputStreamWithLoader.class

beanbox'OurLabel.class

beanbox'PropertyCanvas.class

beanbox'PropertyDialog.class

beanbox'PropertyHookup.class

beanbox'PropertyHookupTarget.class

beanbox'PropertyNameDialog.class

beanbox'PropertySelector.class

beanbox'PropertySheet.class:
-extends Frame

beanbox'PropertySheetPanel.class:
** PropertySheetPanel(TestFrame frame)
** setTarget(Object targ)
** stretch()
** doLayout()
** setCustomizer(Customizer c)
** wasModified(PropertyChangeEvent evt)
** warning(String s)
** error(String message, Exception ex)

beanbox'PropertyText.class

beanbox'Report.class

beanbox'SimpleClassLoader.class

** ourLoader
** urlPrefix

** applyDefinitions(Vector) May want to add some support for reporting classes replicated across different JAR files.
** createLoader(String, String) Returns an InputStream on the resource
** findClass(String) Public version of findLoadedClass() to expose it across
** getLocalResource(String, String)
** getLocalResourceAsStream(String, String)
** getResource(String)
** getResourceAsStream(String)
** loadClass(String, boolean) This is the main method for ClassLoaders, that is being redefined
** loadFromFile(String) Helper function; load a class from a file
** setDefinition(String, byte[]) Set some bytecodes as a definition for a class.
** setLocalResourceSource(String, InputStreamProducer#ql:beanbox'inputstreamproducer.class#) Assign an InputStream as the source for a given property name This value comes first after the system resources

beanbox'StartFrame.class

beanbox'Timer.class:
A utility class to help time internal operations.

beanbox'ToolBox.class

beanbox'ToolBoxPanel$Helper.class

beanbox'ToolBoxPanel.class

beanbox'WindowCloser.class
--extends Object implements WindowListener
**WindowCloser(Window) Create an adaptor to listen for window closing events on the given window and actually perform the close.
**WindowCloser(Window, boolean) Create an adaptor to listen for window closing events on the given window and actually perform the close.
**windowActivated(WindowEvent)
**windowClosed(WindowEvent)
**windowClosing(WindowEvent)
**windowDeactivated(WindowEvent)
**windowDeiconified(WindowEvent)
**windowIconified(WindowEvent)
**windowOpened(WindowEvent)

beanbox'Wrapper.class
It is a Panel.
** Wrapper(Object)
** activate()
** deactivate()
** doLayout()
** doMouseStuff(MouseEvent)
** findWrapper(Component) Static method to map from an AWT component to the associated Wrapper.
** getBean(): get the wrapped bean.
** getChild(): get the AWT component used to represent the wrapped bean.
** getPreferredSize()
** handleEvent(Event): Deprecated.
** mouseClicked(MouseEvent)
** mouseDragged(MouseEvent)
** mouseEntered(MouseEvent)
** mouseExited(MouseEvent)
** mouseMoved(MouseEvent)
** mousePressed(MouseEvent)
** mouseReleased(MouseEvent)
** paint(Graphics)
** setActive(boolean)
** setBounds(int, int, int, int)

beanbox'WrapperEventTarget.class

beanbox'PROCESS:
*beanboxFrame: MAIN()
-Timer(): startMillis = (new Date()).getTime(); endMillis = 0;
-Beans.setDesignTime(true);
-StartFrame();
-BeanBoxFrame();
--toolBox = new ToolBox(20, 20);
--topBox = new BeanBox();
--topWrapper = new Wrapper(topBox); //wrapps the beanbox
--doSetCurrentFocus(topWrapper);
---propertySheet.setTarget(the wrapper's bean)
-starter.dispose();

jvp.ClassViewer

name::
* McsEngl.jvp.ClassViewer@cptItsoft,
* McsEngl.jv'ex.class.viewer@cptItsoft,

FUNCTION:
It shows the fields and methods of a java .class file.

CLASS CVFrame

// Contains a FRAME that holds the CVPanel on which information is painted.
FIELDS:
** mainWnd: static Frame
METHODS:
** CVFrame
** main

CLASS CVPanel

// contains a panel on which information for a class is painted.
FIELDS:
**
METHODS:
** CVPanel(): do nothing.
** private void DisplayInfo(): creates a ClassInfo object
** protected static void FillClassDefNotFound():
puts on 'classdef_notfound_msg' class loader message.
** public void init():
** public void paint(Graphics g):

CLASS ClassInfoView

extends BorderedPanel

CLASS BorderedPanel

extends Panel

CLASS ClassInfo

METHODS:
** public ClassInfo(DataInputStream dataInputStream)
** public ClassInfo(String string)

CLASS Infobase:

METHODS:
** InfoBase()
** CheckIndexesRange(int int): boolean
** Description(ConstantInfo): String

jvp.DATABASE

name::
* McsEngl.jvp.DATABASE@cptItsoft,

HIERARCHICAL DATABASE:
Not a definite answer, but I may have at least some pointers for you ...
1) Ozone (http://www.ozone-db.org/ozone_main.html) is probably the nearest project to what you're describing.
2) There is a category for this at the ODP : http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/Tools/Databases/
3) We've created a mailing list to discuss similar subjects (http://www.egroups.com/group/xml-server/info.html)
[2000jan09]

Bowerbird has an open source XML database called XDBM. I haven't looked under the cover yet but it might serve your purpose.
http://www.bowerbird.com.au/XDBM/
[2000jan09]

You can do what you want with the Poet OSS. It's an object database, which of course means it can be but needn't be hierarchical. It has complete Java bindings. There's a free eval version for download...You only have to pay when you start shipping that killer app.
I support Poet's Content Management System. This is the database the CMS is built on and it's good stuff. (Or I wouldn't have taken the job:))
[2000jan09]

jvp.EDITOR

name::
* McsEngl.jvp.EDITOR@cptItsoft,

SPECIFIC:
* jEdit (www.jedit.org)
* JEXT (www.jext.org)

jvp.FILE'CONCATENATION

name::
* McsEngl.jvp.FILE'CONCATENATION@cptItsoft,

/* 1998jan05 NiKas
Reads an argument file (contains the names of files to concatenate) and writes all contents to one output file. It takes HALF the time than the 1.0 version. */
import java.io.*;
class Concat11 {

public static void main (String args[]) {
if (args.length==0){ System.out.println("usage: java Concat infile outfile"); System.exit(1); }

try { /* inf contains the names of ALL the files to be concatenated */
BufferedReader br = new BufferedReader (new FileReader(args[0]));
String infstring; /* bw will contain all the output information. */
BufferedWriter bw = new BufferedWriter (new FileWriter(args[1]));

/* reads the information of ONE file (infstring) */
while ((infstring=br.readLine()) !=null){
BufferedReader br2 = new BufferedReader(new FileReader(infstring)); String desc;
try {while ((desc=br2.readLine()) !=null) {bw.write(desc); bw.newLine();} }
catch (EOFException e){}
br2.close(); }
br.close(); bw.close(); }

catch (FileNotFoundException e){System.out.println(e);}
catch (IOException e){System.out.println(e);}
}
}

/* Nikos Kasselouris
* 1997may15
* usage: java concatenation infile outfile
* 'infile' contains the files to be concatenated.
*/
import java.io.*;
import java.io.FileNotFoundException;
import java.io.IOException;

class Concatenation {
public static void main (String args[]) {
if (args.length==0){
System.out.println("usage: java Concatenation infile outfile");
System.exit(1);
}
try {
//br= contains the NAMES of ALL the files to be concatenated
//1.0 code: DataInputStream inf = new DataInputStream (new FileInputStream(args[0]));
BufferedReader br = new BufferedReader(new FileReader(args[0]));
String infstring;
//pw= will contain all the output information.
//1.0 code: PrintStream ps = new PrintStream (new FileOutputStream(args[1]));
PrintWriter pw = new PrintWriter (new FileOutputStream(args[1]));
//this while-loop takes a filename fron 'br' and appends the information on 'pw'
while ((infstring=br.readLine()) !=null){
//br2= containts the information of one file, with name infstring.
BufferedReader br2 = new BufferedReader(new FileReader(infstring));
String line;
try {while ((line=br2.readLine()) !=null) {pw.println(line); }}
catch (EOFException e){}
br2.close();
}
pw.close();
} //end try
catch (FileNotFoundException e){System.out.println(e);}
catch (IOException e){System.out.println(e);}
} // main ends here
}

/* 1997feb10 NK
Reads an argument file (contains the names of files ton concatenate)
and writes all contents to one output file */

import java.io.*;
class Concat {

public static void main (String args[]) {
if (args.length==0){
System.out.println("usage: java Concat infile outfile");
System.exit(1);
}
try {
//inf contains the names of ALL the files to be concatenated
DataInputStream inf = new DataInputStream (new FileInputStream(args[0]));
String infstring;
//ps will contain all the output information.
PrintStream ps = new PrintStream (new FileOutputStream(args[1]));
//reads the information of ONE file (infstring)
while ((infstring=inf.readLine()) !=null){
DataInputStream dis = new DataInputStream(new FileInputStream(infstring));
String desc;
try {while ((desc=dis.readLine()) !=null) {ps.println(desc);}
}
catch (EOFException e){}
dis.close();
}
} //end try
catch (FileNotFoundException e){System.out.println(e);}
catch (IOException e){System.out.println(e);}
} // main ends here
}

/*This program has 3 warnings becase classes are deprecated */

jvp.conversion.number

name::
* McsEngl.jvp.conversion.number@cptItsoft,

// Nikos 1997jun14.
class HexToInt {
public static void main (String args[]){
if (args.length != 1) {
System.err.println("Usage: java Main <file>");
System.exit(-1);
}
int k = Integer.decode("0x"+args[0]).intValue();
System.out.println("Hexadecimal = "+args[0]+", Integer = "+k);
}
}

// Nikos 1997jun14. USAGE: java IntToHex <int>
class IntToHex {
public static void main (String args[]){
String hex = Integer.toHexString(Integer.valueOf(args[0]).intValue());
System.out.println("Integer ="+args[0]+", Hexadecimal ="+hex);
}
}

jvp.GLOBAL'PROGRAM

name::
* McsEngl.jvp.GLOBAL'PROGRAM@cptItsoft,
* McsEngl.jv'global'program@cptItsoft,

Definition:
A global program is a program that tailors the presentation of information to the user according to the user's preferred language and customs.
[Java Tutorial, 1996dec24]

When writing a program for the global market, programmers have many issues to consider:
- Character handling,
- bundling language-dependent resources,
- sorting (collation),
- text boundaries, and
- date and number formatting.
[Java Tutorial, 1996dec24]

CONVERT A PROGRAM TO A GLOBAL ONE

1. Create a Locale variable: Locale locale = Locale.US;

2. Create ResourceBundles for locale-sensitive-data, labels, menu commands, exceptions etc:
ResourceBundle labels = ResourceBundle.getBundle("LabelsBundle", locale);

3. Use the locale specific data:
setTitle(labels.getString("titleLabel"));

jv'LOCALE

name::
* McsEngl.jv'LOCALE@cptItsoft,

SOURCE: JavaSoft API11#ql::2nfoJAPI11.NFO:class.locale#.

PACKAGE: java.util.

SUPERCLASS: java.lang.Object.

A Locale object represents a specific geographical, political, or cultural region. An operation that requires a Locale to perform its task is called locale-sensitive and uses the Locale to tailor information for the user. For example, displaying a number is a locale-sensitive operation--the number should be formatted according to the customs/conventions of the user's native country, region, or culture.
[API 1.1]

METHOD INDEX:
clone():
equals(Object):
getCountry():
getDefault():
getDisplayCountry():
getDisplayCountry(Locale):
getDisplayLanguage():
getDisplayLanguage(Locale):
getDisplayName():
getDisplayName(Locale):
getDisplayVariant():
getDisplayVariant(Locale):
getISO3Country():
getISO3Language():
getLanguage():
getVariant():
hashCode():
setDefault(Locale):
toString():

The Available locales are:
en en_US ar ar_AE ar_BH ar_DZ ar_EG ar_IQ ar_JO ar_KW ar_LB ar_LY ar_MA ar_OM ar_QA ar_SA ar_SD ar_SY ar_TN ar_YE be be_BY bg bg_BG ca ca_ES cs cs_CZ da da_DK
de de_AT de_AT_EURO de_CH de_DE de_DE_EURO de_LU de_LU_EURO
el el_GR
en_AU en_CA en_GB en_IE en_IE_EURO en_NZ en_ZA es es_AR es_BO es_CL es_CO es_CR es_DO es_EC es_ES es_ES_EURO es_GT es_HN es_MX es_NI es_PA es_PE es_PR es_PY es_SV es_UY es_VE et et_EE fi fi_FI fi_FI_EURO
fr fr_BE fr_BE_EURO fr_CA fr_CH fr_FR fr_FR_EURO fr_LU fr_LU_EURO hr hr_HR hu hu_HU is is_IS it it_CH it_IT it_IT_EURO iw iw_IL ja ja_JP ko ko_KR lt lt_LT lv lv_LV mk mk_MK nl nl_BE nl_BE_EURO nl_NL nl_NL_EURO no no_NO no_NO_NY pl pl_PL pt pt_BR pt_PT pt_PT_EURO ro ro_RO ru ru_RU sh sh_YU sk sk_SK sl sl_SI sq sq_AL sr sr_YU sv sv_SE th th_TH tr tr_TR uk uk_UA zh zh_CN zh_HK zh_TW
[jdk1.2]

jv'ResourceBundle

name::
* McsEngl.jv'ResourceBundle@cptItsoft,

SOURCE: JavaSoft API11#ql::2nfoJAPI11.NFO:class.resourcebundle#.

PACKAGE: java.util.

SUPERCLASS: java.lang.Object.

FUNCTION:
The first step to take in preparing your program is to enable translation of display strings by separating them out from the rest of your code. With Java, this is done via ResourceBundles. These provide a general mechanism that allows you to access strings and other objects according to locale conventions. In principle, they are fairly simple: they just provide a mapping from <key,locale> to <value>.
[Taligent 1997jun]

To isolate locale-sensitive data you put them into resource bundles.
[Java Tutorial, 1996dec24]

When your program needs a locale-specific object, it loads the ResourceBundle class using the getBundle method:
ResourceBundle myResources =
ResourceBundle.getBundle("MyResources", currentLocale);

You retrieve an object from resource bundle using the appropriate GETTER-METHOD. Because OkKey and CancelKey are both strings, you would use getString to retrieve them:
button1 = new Button(myResourceBundle.getString("OkKey"));

Keys are always Strings. The values can be any type of object.

You do not have to restrict yourself to using a single family of ResourceBundles. For example, you could have
** a set of bundles for exception messages, ExceptionResources (ExceptionResources_fr, ExceptionResources_de, ...), and
** one for widgets, WidgetResource (WidgetResources_fr, WidgetResources_de, ...);
breaking up the resources however you like.

However, they also supply inheritance among locale resources that allows you to minimize duplication across countries, and gives you a graceful degradation in case the exact locale does not have localized resources.
[Taligent 1997jun]

METHOD INDEX:
** (stat) getBundle(String): Get the appropriate ResourceBundle subclass.
** (stat) getBundle(String, java.util.Locale): Get the appropriate ResourceBundle subclass.
** (inst) getKeys(): Return an enumeration of the keys.
** (inst) getMenu(String): Get an object from a ResourceBundle.
** (inst) getMenuBar(String): Get an object from a ResourceBundle.
** (inst) getObject(String): Get an object from a ResourceBundle.
** (inst) getString(String): Get an object from a ResourceBundle.
** (inst) getStringArray(String): Get an object from a ResourceBundle.
** (inst) handleGetObject(String): Get an object from a ResourceBundle.
** (inst) setParent(java.util.ResourceBundle): Set the parent bundle of this bundle.

jv'ListResourceBundle

name::
* McsEngl.jv'ListResourceBundle@cptItsoft,

SOURCE: JavaSoft API11#ql::2nfoJAPI11.NFO:class.listresourcebundle#.

PACKAGE: java.util.

SUPERCLASS: java.util.ResourceBundle.

FUNCTION:
ListResourceBundle is an abstract class that stores its resources in a list of key-value pairs (an array whose elements are two-element subarrays).

jv'ex.listResourceBundle:
class MyResource_fr extends ListResourceBundle {
public Object[][] getContents() {
return contents;
}
static final Object[][] contents = {
// LOCALIZE THIS
{"s1", "3"}, // starting value in choice field
{"s2", "MonDisk"}, // starting value in string field
...
{"s16", new Dimension(1,3)} // real object, not just string
// END OF MATERIAL TO LOCALIZE
};
}

jv'PropertyResourceBundle

name::
* McsEngl.jv'PropertyResourceBundle@cptItsoft,

SOURCE: JavaSoft API11#ql::2nfoJAPI11.NFO:class.propertyresourcebundle#.

PACKAGE: java.util.

SUPERCLASS: java.util.ResourceBundle.

FUNCTION:
You can also use a PropertyResourceBundle instead of a ListResourceBundle. In that case, what you do is to follow the same pattern, but instead of creating a class, you put the {key, value} pairs into a PropertyFile. The name of the property file is the same as the name of the ListResourceBundle that you would have had. Since you don't have classes any more, put your static rb into someplace convenient, such as in your applet, and use that name for references (e.g. MyApplet.rb.getString("CleanCartridge")). However, if you use a PropertyResourceBundle, be aware that you can only extract strings, not other classes.
[Taligent 1997jun]

jv'Format

name::
* McsEngl.jv'Format@cptItsoft,

SOURCE: JavaSoft API11#ql::2nfoJAPI11.NFO:class.format#.

PACKAGE: java.text.

SUPERCLASS: java.lang.Object.

SUBCLASS: DateFormat, MessageFormat, NumberFormat.

FUNCTION:
Format is an abstract base class for formatting locale-sensitive information such as dates, messages, and numbers.
[API1.1]

jv'DateFormat

name::
* McsEngl.jv'DateFormat@cptItsoft,

date formats cover both dates and times

jv'MessageFormat

name::
* McsEngl.jv'MessageFormat@cptItsoft,

jv'ex.messageformat:
Old
myCheckbox = new Checkbox(MyResources.rb.getString("DeleteBefore") + someDate);
// insert localized {key, value}, pairs below {"DeleteBefore", "Delete all files before "},

New
MessageFormat mf = new MessageFormat(MyResources.rb.getString("DeleteBefore")); myCheckbox = new Checkbox(mf.format(new Object[] {someDate}));
// insert localized {key, value}, pairs below {"DeleteBefore", "Delete files before {0}"},

jv'NumberFormat

name::
* McsEngl.jv'NumberFormat@cptItsoft,

SOURCE: JavaSoft API11#ql::2nfoJAPI11.NFO:class.numberformat#.

Number formats handle general numbers and currencies;

jv'ex.numberFormat:
Old
myTextField.setText(myNumber);
New
NumberFormat nf = (NumberFormat)(MyResources.rb.getObject("PageNumberFormat")); myTextField.setText(nf.format(myNumber));
// insert localized {key, value}, pairs below
{"PageNumberFormat", new DecimalFormat("#,##0")}, ...

jv'ex.numberFormat:
NumberFormat currencyFmt = NumberFormat.getDefaultCurrency( Locale.GERMANY );
System.out.println("My salary: " + currencyFmt( 24.63 ));

jvp.GRAPH

name::
* McsEngl.jvp.GRAPH@cptItsoft,

> > ILOG JViews has a pure java graph layout toolkit.
> > http://www.ilog.com/products/jviews/

Is this not one of the most expensive he could find .. :-) ..
Their are other commcericals too, like the new impressive JLoox ..
For poor people like us, their is also a nice Java2D based graph edititing framework called diva .. is free and with source code ..
http://www-cad.eecs.berkeley.edu/diva
I use them to build an interactive graph editor with them ..
What I'm missing so far is, that he knows only nodes and edges, but we need ports in the model and visualisation too !
Good luck !
Frank
Frank Gruetzmacher Ph : +49/3677/691167 Scientific Assistant, grue@inf-technik.tu-ilmenau.de Department for Microelectronic Circuits and Systems Technical University Ilmenau PoBox 10 0565 D-98684 Ilmenau
[advjava {1999-09-22}]

jvp.HOTJAVA

name::
* McsEngl.jvp.HOTJAVA@cptItsoft,

HotJava#cptItsoft1023: attSpe#

jvp.App.Installer

name::
* McsEngl.jvp.App.Installer@cptItsoft,

Xenonsoft, South London, England is very pleased to announce the availability of:

FreeInstaller, version 0.2.0

A software installer that can install Java and non-Java from a self extracting archive. The software is open source and is distributed "as free software.". Please read the LICENSE*.

The FreeInstaller software can be obtain from the FTP server:
`ftp://ftp.demon.net/pub/java'
or as a last resort `http://www.xenonsoft.demon.co.uk/software.html'.
[xmldev {1999-04-05}]

jvp.IntlWindow (IW)

name::
* McsEngl.jvp.IntlWindow (IW)@cptItsoft,

SOURCE:
JavaSoft Tutorial 1997jul08 (...\int\datamgmt\example-1.1)

FUNCTION:
Displays information in 3 Locals.

It uses a cardlayout to display the different locals. It uses ResourceBundles for Headings and for data, NumberFormat for numbers, and properties file for large text.

PROCESS:
*IntWindow.main
**IntlWindow();
***createGUIElements();
****MediaTracker(this);
****FlagCanvas(flags[i], this, flags[i].getWidth(this), flags[i].getHeight(this));
****LinguaPanel(supportedLocales[i], defaultFont, boldFont);
*****ResourceBundle labels = ResourceBundle.getBundle("LabelsBundle", locale);
*****ResourceBundle paragraph = ResourceBundle.getBundle("ParagraphBundle", locale);
*****ResourceBundle numbers = ResourceBundle.getBundle("NumbersBundle", locale);

CLASSES:
IntWindow.class
FlagCanvas.class
LinguaPanel.class
LabelsBundle.class
NumbersBundle.class
ParagraphBundle.class

IntWindow'IntWindow.class:
-the main class.
* extends Frame.
FIELD.cards: Panel= This panel contains the Locals in cardlayout#ql:jv'cardlayout#.
FIELD.currentLocale: Locale#ql:jv'locale# =
FIELD.supportedLocales: Locale[]
FIELD.flags: Image[] = contains the flag images.
FIELD.flagCanvases: FlagCanvas#ql:class.flagcanvas#[]
FIELD.selectedFlag: int
FIELD.defaultFont: Font
FIELD.boldFont: Font
CONSTRUCTOR.IntlWindow
METHOD.handleEvent(Event e): boolean= destroy the window
METHOD.main(String[] args): void
METHOD.createGUIElements(): void
METHOD.selectFlag(FlagCanvas f): void

IntWindow'FlagCanvas.class:
* extends Canvas#ql:jv'canvas#
FIELD.selected; boolean
FIELD.pappy; Container
FIELD.image; Image
FIELD.trueSizeKnown; boolean
FIELD.minSize; Dimension
FIELD.w, h; int
CONSTRUCTOR.FlagCanvas(Image image, IntlWindow parent, int initialWidth, int initialHeight)
METHOD.mouseDown(Event evt, int x, int y)
METHOD.isSelected()
METHOD.setSelected(boolean check)
METHOD.preferredSize()
METHOD.minimumSize()
METHOD.paint (Graphics g)

IntWindow'LinguaPanel.class:
contains all info for a Locale
*extends Panel
FIELD.Label localeLabel; =
FIELD.Label localeValue;
FIELD.Label dateLabel;
FIELD.Label dateValue;
FIELD.Date date;
FIELD.DateFormat dateFormatter;
FIELD.Label gdpLabel;
FIELD.Label gdpValue;
FIELD.Double gdp;
FIELD.NumberFormat gdpFormatter;
FIELD.Label populationLabel;
FIELD.Label populationValue;
FIELD.Integer population;
FIELD.NumberFormat populationFormatter;
FIELD.Label literacyLabel;
FIELD.Label literacyValue;
FIELD.Double literacy;
FIELD.NumberFormat literacyFormatter;
FIELD.TextArea description;
FIELD.Font defaultFont;
FIELD.Font boldFont;
CONSTRUCTOR.LinguaPanel(Locale locale, Font defaultFont, Font boldFont)
METHOD.layoutGUI(): void

IntWindow'LabelsBundle.class:
For each locale contains the names of labels
* extends ListResourceBuncle
LocaleLabel
DateLabel
GDPLabel
PopulationLabel
LiteracyLabel

IntWindow'NumbersBundle.class:
-contains the numbers
* extends ListResourceBuncle
GDP
Population
Literacy

IntWindow'ParagraphBundle.class:
-contains the description
* extends ParagraphResourceBuncle
LocaleDescription

IntlWindow.java

name::
* McsEngl.IntlWindow.java@cptItsoft,

import java.awt.*; import java.awt.event.*; import java.util.Locale; import java.applet.Applet; import java.net.URL; import java.awt.image.ImageProducer; import java.awt.Toolkit;

public class IntlWindow
extends Frame
implements WindowListener {

Applet parentApplet = null;
Panel cards;
private Locale currentLocale;
private Locale[] supportedLocales = { Locale.US, Locale.FRANCE, Locale.UK };
private Image[] flags;
private FlagCanvas[] flagCanvases; private int selectedFlag = -1;
private Image[] soundImages;
private String[] soundNames = { "book", "car", "dog", "apple" };
private Font defaultFont; private Font boldFont;

public IntlWindow(Applet parentApplet) {
currentLocale = getLocale();
for (int i = 0; i < supportedLocales.length; i++) { if (currentLocale == supportedLocales[i]) selectedFlag = i; }
if (selectedFlag == -1) { currentLocale = supportedLocales[0]; selectedFlag = 0; }
this.parentApplet = parentApplet; createGUIElements(); addWindowListener(this); }

public static void main(String[] args) { IntlWindow window = new IntlWindow(null);
window.pack(); window.show(); }
public void selectFlag(FlagCanvas f) { for (int i = 0; i < flagCanvases.length; i++) { if (f == flagCanvases[i]) { selectedFlag = i; flagCanvases[i].setSelected(true); } else flagCanvases[i].setSelected(false); } currentLocale = supportedLocales[selectedFlag]; ((CardLayout)cards.getLayout()).show(cards, currentLocale.getDisplayName()); doLayout(); }

public void windowClosed(WindowEvent event) { }
public void windowDeiconified(WindowEvent event) { }
public void windowIconified(WindowEvent event) { }
public void windowActivated(WindowEvent event) { }
public void windowDeactivated(WindowEvent event) { }
public void windowOpened(WindowEvent event) { }

public void windowClosing(WindowEvent event) { if (parentApplet != null) { dispose(); } else { System.exit(0); } }

private void createGUIElements() {
defaultFont = new Font("Helvetica", Font.PLAIN, 14);
boldFont = new Font(defaultFont.getName(), Font.BOLD, defaultFont.getSize());
setFont(defaultFont);
// load the images that are shared between all of the linguaPanels // first the flags
MediaTracker tracker = new MediaTracker(this);
flags = new Image[supportedLocales.length];
flagCanvases = new FlagCanvas[supportedLocales.length];
for (int i = 0; i < supportedLocales.length; i++) {
String s = "flag_" + supportedLocales[i].toString() + ".gif"; try { URL url = getClass().getResource(s); flags[i] = Toolkit.getDefaultToolkit().getImage(url); } catch (Exception e) { System.err.println("Couldn't load flag image: " + s); e.printStackTrace(); }
tracker.addImage(flags[i], i); }
// then the sound images
soundImages = new Image[soundNames.length];
for (int i = 0; i < soundNames.length; i++) { String s = soundNames[i] + ".gif"; try { URL url = getClass().getResource(s); soundImages[i] = Toolkit.getDefaultToolkit().getImage(url); } catch (Exception e) { System.err.println("Couldn't load sound image: " + s); e.printStackTrace(); } tracker.addImage(soundImages[i], i + supportedLocales.length); }
// wait for all of the images to be loaded
try { tracker.waitForAll(); } catch (InterruptedException e) { System.err.println("exception from tracker"); e.printStackTrace(); }

// now add the flag images to this window
Panel p = new Panel();
p.setLayout(new FlowLayout());
for (int i = 0; i < flags.length; i++) { flagCanvases[i] = new FlagCanvas(flags[i], this, flags[i].getWidth(this), flags[i].getHeight(this)); p.add(flagCanvases[i]); } flagCanvases[selectedFlag].setSelected(true); add("North", p);
// create a card panel cards = new Panel(); cards.setLayout(new CardLayout());
// create the LinguaPanels that go into the card layout
for (int i = 0; i < supportedLocales.length; i ++) { LinguaPanel linguaPanel = null; try { linguaPanel = new LinguaPanel(supportedLocales[i], parentApplet, defaultFont, boldFont, soundImages, soundNames); } catch (java.util.MissingResourceException e) { System.err.println("Couldn't create a LinguaPanel for " + supportedLocales[i]); System.err.println(e); }
// add it to the card layout cards.add(supportedLocales[i].getDisplayName(), linguaPanel); }
// add the card layout to this window add("Center", cards); } }

FlagCanvas.java

name::
* McsEngl.FlagCanvas.java@cptItsoft,

import java.awt.*; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent;

class FlagCanvas extends Canvas {

private boolean selected = false;
Container pappy; Image image; boolean trueSizeKnown = false; Dimension minSize; int w, h;

public FlagCanvas(Image image, IntlWindow parent, int initialWidth, int initialHeight) { if (image == null) { System.err.println("Canvas got invalid image object!"); return; }
this.image = image; pappy = parent;
w = initialWidth+2; h = initialHeight+2;
minSize = new Dimension(w,h);
addMouseListener(new MyAdapter()); }

class MyAdapter extends MouseAdapter { public void mouseClicked(MouseEvent evt) { ((IntlWindow)pappy).selectFlag(this$0); } }

public boolean isSelected() { return selected; }
public void setSelected(boolean check) { selected = check; repaint(); }
public Dimension getPreferredSize() { return getMinimumSize(); }
public synchronized Dimension getMinimumSize() { return minSize; }

public void paint (Graphics g) { if (image != null) { if (!trueSizeKnown) { int imageWidth = image.getWidth(this); int imageHeight = image.getHeight(this);
if ((imageWidth > 0) && (imageHeight > 0)) { trueSizeKnown = true;
//Component-initiated resizing. w = imageWidth + 2; h = imageHeight + 2; minSize = new Dimension(w,h); setSize(w, h); pappy.validate(); } }
g.drawImage(image, 1, 1, this); if (selected) g.draw3DRect(0, 0, w-1, h-1, true); } } }

LabelsBundle.java

name::
* McsEngl.LabelsBundle.java@cptItsoft,

import java.util.ListResourceBundle;

public class LabelsBundle
extends ListResourceBundle {

public Object[][] getContents() { return contents; }

static final Object[][] contents = { // LOCALIZE THIS
{ "LocaleLabel", "Locale: " }, { "DateLabel", "Today's Date: " }, { "TimeLabel", "Current Time (in {0}): " }, { "RepCity", "San Francisco" }, { "TimeZone", "PST" },
{ "GDPLabel", "Per Capita GDP: " }, { "PopulationLabel", "Population: " }, { "LiteracyLabel", "Literacy Rate: " },
// END "LOCALIZE THIS" }; }

LabelsBundle-fr.java

name::
* McsEngl.LabelsBundle-fr.java@cptItsoft,

import java.util.ListResourceBundle;

public class LabelsBundle_fr
extends ListResourceBundle {

public Object[][] getContents() { return contents; }

static final Object[][] contents = { // LOCALIZE THIS
{ "LocaleLabel", "Locale_FR: " },
{ "DateLabel", "Date_FR: " },
{ "TimeLabel", "Current Time (in {0})_FR:" },
{ "RepCity", "Paris" },
{ "TimeZone", "ECT" },
{ "GDPLabel", "Per Capita GDP_FR: " },
{ "PopulationLabel", "Population_FR: " },
{ "LiteracyLabel", "Literacy Rate_FR: " },
// END "LOCALIZE THIS" }; }

LinguaPanel.java

name::
* McsEngl.LinguaPanel.java@cptItsoft,

import java.awt.*;
import java.applet.Applet;
import java.util.Locale; import java.util.ResourceBundle; import java.util.Calendar; import java.util.Date; import java.util.TimeZone;
import java.text.NumberFormat; import java.text.DateFormat; import java.text.MessageFormat;
import java.net.URL;

class LinguaPanel
extends Panel
implements Runnable {

private Label localeLabel; private Label localeValue;
private Label dateLabel; private Label dateValue; private Calendar cal; private Date date; private DateFormat dateFormatter;
private Label timeLabel; private Label timeValue; private DateFormat timeFormatter;
private Label gdpLabel; private Label gdpValue; private Double gdp; private NumberFormat gdpFormatter;
private Label populationLabel; private Label populationValue; private Integer population; private NumberFormat populationFormatter;
private Label literacyLabel; private Label literacyValue; private Double literacy; private NumberFormat literacyFormatter;
private TextArea description;
private SoundCanvas[] soundCanvases; private Panel soundPanel;
private Font defaultFont; private Font boldFont;
private Thread clockThread = null; private Locale currentLocale;

LinguaPanel(Locale locale, Applet parentApplet, Font defaultFont, Font boldFont, Image[] soundImages, String[] soundNames)
throws java.util.MissingResourceException {
ResourceBundle labels = ResourceBundle.getBundle("LabelsBundle", locale); ResourceBundle paragraph = ResourceBundle.getBundle("ParagraphBundle", locale); ResourceBundle numbers = ResourceBundle.getBundle("NumbersBundle", locale); ResourceBundle soundBundle = ResourceBundle.getBundle("SoundBundle", locale);
currentLocale = locale;
// create the GUI elements for the locale name display
localeLabel = new Label(); localeLabel.setFont(boldFont); localeValue = new Label();
add(localeLabel); add(localeValue);
// create the GUI elements for the Date display and add them to the window
dateLabel = new Label(); dateLabel.setFont(boldFont); dateValue = new Label();
add(dateLabel); add(dateValue);
timeLabel = new Label(); timeLabel.setFont(boldFont); timeValue = new Label();
add(timeLabel); add(timeValue);
// create the GUI elements for the gdp display and add them to the window gdpLabel = new Label(); gdpLabel.setFont(boldFont); gdpValue = new Label();
add(gdpLabel); add(gdpValue);
// create the GUI elements for the population display and add them to the window populationLabel = new Label(); populationLabel.setFont(boldFont); populationValue = new Label();
add(populationLabel); add(populationValue);
// create the GUI elements for the literacy display and add them to the window literacyLabel = new Label(); literacyLabel.setFont(boldFont); literacyValue = new Label();
add(literacyLabel); add(literacyValue);
// create the sound canvases and add them to the window soundPanel = new Panel(); soundPanel.setLayout(new FlowLayout()); soundCanvases = new SoundCanvas[soundImages.length]; for (int i = 0; i < soundCanvases.length; i++) { soundCanvases[i] = new SoundCanvas(soundImages[i], this, soundImages[i].getHeight(this), soundImages[i].getWidth(this), soundBundle.getString(soundNames[i]), parentApplet); soundPanel.add(soundCanvases[i]); } add(soundPanel);
// create a text area
description = new TextArea(paragraph.getString("LocaleDescription"), 7, 10, TextArea.SCROLLBARS_VERTICAL_ONLY); description.setEditable(false); add(description);
// set text for GUI items based on locale localeLabel.setText(labels.getString("LocaleLabel")); localeValue.setText(currentLocale.getDisplayName(currentLocale));
Object[] args = { labels.getString("RepCity") }; String result = MessageFormat.format(labels.getString("TimeLabel"), args); timeLabel.setText(result);
timeFormatter = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale); TimeZone tz = TimeZone.getTimeZone(labels.getString("TimeZone")); timeFormatter.setTimeZone(tz);
updateTime(currentLocale);
dateLabel.setText(labels.getString("DateLabel")); dateFormatter = DateFormat.getDateInstance(DateFormat.DEFAULT, currentLocale); dateFormatter.setTimeZone(tz); dateValue.setText(dateFormatter.format(date));
gdpLabel.setText(labels.getString("GDPLabel")); gdpFormatter = NumberFormat.getCurrencyInstance(currentLocale); gdp = (Double) numbers.getObject("GDP"); gdpValue.setText(gdpFormatter.format(gdp));
populationLabel.setText(labels.getString("PopulationLabel")); populationFormatter = NumberFormat.getNumberInstance(currentLocale); population = (Integer) numbers.getObject("Population"); populationValue.setText(populationFormatter.format(population));
literacyLabel.setText(labels.getString("LiteracyLabel")); literacyFormatter = NumberFormat.getPercentInstance(currentLocale); literacy = (Double) numbers.getObject("Literacy"); literacyValue.setText(literacyFormatter.format(literacy));
layoutGUI();
if (clockThread == null) { clockThread = new Thread(this, "Clock"); clockThread.start(); } }
private void updateTime(Locale locale) { cal = Calendar.getInstance(); date = cal.getTime(); timeValue.setText(timeFormatter.format(date)); }
private void layoutGUI() { GridBagConstraints c = new GridBagConstraints(); GridBagLayout gridbag = new GridBagLayout(); setLayout(gridbag);
c.fill = GridBagConstraints.BOTH;
// layout locale stuff c.insets = new Insets(5,5,0,5); c.anchor = GridBagConstraints.EAST; c.fill = GridBagConstraints.VERTICAL; c.gridwidth = 1; // reset to the default c.weightx = 1.0; // 2 columns of equal width gridbag.setConstraints(localeLabel, c);
c.anchor = GridBagConstraints.CENTER; // reset to default c.fill = GridBagConstraints.BOTH; //reset to app default c.gridwidth = GridBagConstraints.REMAINDER; // end of row gridbag.setConstraints(localeValue, c);
// layout time stuff c.insets = new Insets(0,5,0,5); c.anchor = GridBagConstraints.EAST; c.fill = GridBagConstraints.VERTICAL; c.gridwidth = 1; // reset to the default c.weightx = 1.0; // 2 columns of equal width gridbag.setConstraints(timeLabel, c);
c.fill = GridBagConstraints.BOTH; //reset to app default c.gridwidth = GridBagConstraints.REMAINDER; // end of row gridbag.setConstraints(timeValue, c);
// layout date stuff c.insets = new Insets(0,5,0,5); c.anchor = GridBagConstraints.EAST; c.fill = GridBagConstraints.VERTICAL; c.gridwidth = 1; // reset to the default c.weightx = 1.0; // 2 columns of equal width gridbag.setConstraints(dateLabel, c);
c.anchor = GridBagConstraints.CENTER; // reset to default c.fill = GridBagConstraints.BOTH; //reset to app default c.gridwidth = GridBagConstraints.REMAINDER; // end of row gridbag.setConstraints(dateValue, c);
// layout gdp stuff c.anchor = GridBagConstraints.EAST; c.fill = GridBagConstraints.VERTICAL; c.gridwidth = 1; //reset to the default c.weightx = 0.0; //reset to the default gridbag.setConstraints(gdpLabel, c);
c.anchor = GridBagConstraints.CENTER; // reset to default c.fill = GridBagConstraints.BOTH; //reset to app default c.gridwidth = GridBagConstraints.REMAINDER; // end of row gridbag.setConstraints(gdpValue, c);
// layout population stuff c.anchor = GridBagConstraints.EAST; c.fill = GridBagConstraints.VERTICAL; c.gridwidth = 1; //reset to the default gridbag.setConstraints(populationLabel, c);
c.anchor = GridBagConstraints.CENTER; // reset to default c.fill = GridBagConstraints.BOTH; //reset to app default c.gridwidth = GridBagConstraints.REMAINDER; // end of row gridbag.setConstraints(populationValue, c);
// layout population literacy stuff c.anchor = GridBagConstraints.EAST; c.fill = GridBagConstraints.VERTICAL; c.gridwidth = 1; //reset to the default gridbag.setConstraints(literacyLabel, c);
c.anchor = GridBagConstraints.CENTER; // reset to default c.fill = GridBagConstraints.BOTH; //reset to app default c.gridwidth = GridBagConstraints.REMAINDER; // end of row gridbag.setConstraints(literacyValue, c);
// layout image panel c.insets = new Insets(5,5,5,5); c.fill = GridBagConstraints.BOTH; c.gridwidth = GridBagConstraints.REMAINDER; // end of row gridbag.setConstraints(soundPanel, c);
// layout text area c.fill = GridBagConstraints.BOTH; c.gridwidth = GridBagConstraints.REMAINDER; // end of row c.weighty = 1.0; // as tall as possible gridbag.setConstraints(description, c);
}
// [PENDING: should stop this thread when applet is asked to stop]

public synchronized void run() { // loop terminates when clockThread is set to null in stop() while (Thread.currentThread() == clockThread) { updateTime(currentLocale); try { Thread.sleep(1000); } catch (InterruptedException e){ } } }
}

NumbersBundle.java

name::
* McsEngl.NumbersBundle.java@cptItsoft,

import java.util.ListResourceBundle;

public class NumbersBundle extends ListResourceBundle {

public Object[][] getContents() { return contents; }

static final Object[][] contents = { // LOCALIZE THIS
{ "GDP", new Double(24700) },
{ "Population", new Integer(260713585) },
{ "Literacy", new Double(0.97) },
// END "LOCALIZE THIS" }; }

PictureCanvas.java

name::
* McsEngl.PictureCanvas.java@cptItsoft,

import java.awt.*;

class PictureCanvas extends Canvas {

Container pappy; Image image; boolean trueSizeKnown = false; Dimension minSize; int w, h;

public PictureCanvas(Image image, Container parent, int initialWidth, int initialHeight) { if (image == null) { System.err.println("Canvas got invalid image object!"); return; }
this.image = image; pappy = parent;
w = initialWidth; h = initialHeight;
minSize = new Dimension(w,h); }

public Dimension getPreferredSize() { return getMinimumSize(); }
public synchronized Dimension getMinimumSize() { return minSize; }

public void paint (Graphics g) { if (image != null) { if (!trueSizeKnown) { int imageWidth = image.getWidth(this); int imageHeight = image.getHeight(this);
if ((imageWidth > 0) && (imageHeight > 0)) { trueSizeKnown = true;
//Component-initiated resizing.
w = imageWidth; h = imageHeight; minSize = new Dimension(w,h); setSize(w, h); pappy.validate(); } }
g.drawImage(image, 0, 0, this); } }
}

SoundBundle.java

name::
* McsEngl.SoundBundle.java@cptItsoft,

import java.util.ListResourceBundle; import java.util.Locale;

public abstract class SoundBundle
extends ListResourceBundle {

Object[][] contents; String soundNames[] = { "book", "car", "dog", "apple" };

public SoundBundle(Locale myLocale) {
String localeName = myLocale.toString();
contents = new Object[soundNames.length][2];
for (int i = 0; i < soundNames.length; i++) { contents[i][0] = soundNames[i]; contents[i][1] = soundNames[i] + "_" + localeName + ".au"; } }

public Object[][] getContents() { return contents; } }

SoundCanvas.java

name::
* McsEngl.SoundCanvas.java@cptItsoft,

import java.awt.*; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.applet.Applet;
import java.net.URL; import java.net.MalformedURLException;

class SoundCanvas extends PictureCanvas {

String audioClipName = null; Applet parentApplet = null;

public SoundCanvas(Image image, LinguaPanel parent, int initialWidth, int initialHeight, String audioClipName, Applet parentApplet) { super(image, parent, initialWidth, initialHeight); this.audioClipName = audioClipName; this.parentApplet = parentApplet; addMouseListener(new MyAdapter()); }

class MyAdapter extends MouseAdapter { public void mouseClicked(MouseEvent evt) { if ((audioClipName != null) && (parentApplet != null)) { try { URL auURL = new URL(parentApplet.getCodeBase(), audioClipName); parentApplet.play(auURL); } catch (java.net.MalformedURLException e) { } } } } }

jvp.JESS

name::
* McsEngl.jvp.JESS@cptItsoft,

ANNOUNCING Jess 3.0b2 The Java Expert System Shell ----------------------------------------------------------------------
Jess is a clone of the popular CLIPS expert system shell written entirely in Java. With Jess, you can conveniently give your applets the ability to 'reason'. Since it was first released in Spring 1996, The response to Jess has been overwhelming; this announcement is going out to almost 5,000 registered Jess users. This new version incorporates a lot of the feedback I've received from Jess's users, to whom I am grateful for their advice and suggestions, especially during this beta period.
Jess version 3.0b2 is the second beta release of a major new version of Jess. Jess 3.0 adds significant new features like multifields, multislots, and incremental reset, includes a number of bug fixes, a more flexible user function interface, *lots* of new built-in functions, and a general code cleanup and reorganization (a 'jess' package.) Jess 3.0b2 incorporates, for the first time, a simple interactive command-line interface, and fixes all of the reported bugs from the 3.0b1 release. It does not incorporate all new features suggested during the first beata; a few more of these will be included in the final release.
Jess 3.0b2 is compatible with all versions of Java starting with version 1.0.2. It is (in particular) Java 1.1.2 compatible.
Jess 3.0b2 can be downloaded from http://herzberg.ca.sandia.gov/jess/ .
This is the second public beta of Jess 3.0; I invite feedback and bug reports. There probably will not be another beta before 3.0 final.
[1997jul23]

jess'RETE

name::
* McsEngl.jess'RETE@cptItsoft,

The Rete class contains the expert system engine.

jess'JESP

name::
* McsEngl.jess'JESP@cptItsoft,

The Jesp class contains the Jess parser.

jvp.JHelp

name::
* McsEngl.jvp.JHelp@cptItsoft,

SOURCE: \java\app\1.1\jhelp...,

_FUNCTION:
displays html-files with links.

COMPANY:
dba Moondog Software. William Giel.

VERSION:
2.0 for java 1.1

PROCESS:
**jHelpAppTest.Main
--AppFrame("jHelp Application Demo", 350, 300);
---htmlHelpFrame#ql:jhelp'htmlhelpframe.class#(this,"newdocs/jhelp_toc.html");
----htmlHelpFrame.construct(AppFrame, "newdoc/jhelp_toc.html", 320, 400, 0);
-----add buttons
-----htmlHelpPanel(object=AppFrame, string=newdoc/.html, backButton, forwardButton, k=0);
------goToBase = "";
------sb = new Scrollbar();
------htmlHelpCanvas(object, string, sb, component1, component2);
-------getHelpVectors(object, string);
// here I don't know how
------layoutComponents(i); //add canvas and scrollbar
-----add listeners

jhelp'jHelpAppTest.class:
Frame that holds the application
** main(String args[])

jhelp'AppFrame.class:
extends Frame
implements ActionListener, WindowListener
** AppFrame(String title,int width, int height)
** addMenuItem(Menu menu, MenuItem item):
1. add items to menu 2. add actionListeners to items
** actionPerformed(ActionEvent e)
** windowClosed(WindowEvent event)

jhelp'DynamicEditor.class:
extends Frame
implements ActionListener,WindowListener, KeyListener
** DynamicEditor(String content, htmlHelpFrame hf)
** newActionButton(String caption)
** addActionListener(ActionListener l)
** removeActionListener(ActionListener l)
** windowClosed(WindowEvent event){}...
** show()
** dispose()
** showHelp()
** keyTyped(KeyEvent e){}
keyReleased(KeyEvent e){}
keyPressed(KeyEvent e)

------------------------------------------------------

*jhelp'htmlBookmark.class:
* y int:
* hyperName String
** init()
** isHyperName(String)
** geyYPosition()

*jhelp'htmlBorderPanel.class:
Panel
* label String
* width int
* height int
** init()
** init(String)
** setBounds(int, int, int, int)
** insets(): deprecated
** update(Graphics)

*jhelp'htmlCanvasEvent.class:
extends ActionEvent
* NEWTITLE int
** init(Component, String)

*jhelp'htmlColors.class:
extends Hashtable
** init()

*jhelp'htmlContext.class:
* fileName String:
* context String:
** int(String, String)
** getFileName() String:
** getContext() String:

*jhelp'htmlFontCache.class:
* SERIF=0
* SANSSERIF=1
* MONOSPACED=2
* fonts Font[][]
* minSize int:
** init(int, int)

*jhelp'htmlFormatControl.class:
implements htmlFormatDefaults, htmlTagConstants
*(45)
** getBulletType() int:
** getNumberBullet() String:
** getRoundBullet() int:
** reset()

*jhelp'htmlFormatDefaults.class:
interface
*(11)

*jhelp'htmlFoundText.class:
** int()
** getX()
** getY()
** getWidth()
** getHeight()
** getIndex()

jhelp'htmlHelpCanvas.class:
extends Canvas
implements MouseMotionListerner, MouseListener, HelpStrings
*(29)
** init(Object, String, Scrollbar)
** init(Object, String, Scrollbar, Component, Component)
** getHelpVectors(Object, String)
** setText(htmlVector)
** addFile(Object, String)
** addHTMLString(Object, String, String)
** paint(Graphics)
** update(Graphics)
** setWaitCursor()
** setDefaultCursor()
** mouse...()
** addActionListener(ActionListener)
** removeActionListener(ActionListener)
** goTo(int)
** goTo(String)
** goTo(String, int)
** goBack()
** goForward)
** find(Container, String, boolean, boolean)
** findNext(Container, String, boolean, boolean)
** clearHighlights()
** findText(Container, String, boolean, boolean, int)
** getContext(String)
** printHelpFile(Frame)
** getCurrentName()
** setMaxCache(int)
** getMaxCache()

*jhelp'htmlHelpFrame.class:
extends Frame
implements ActionListener, WinListener, KeyListener, htmlHelpStrings
* hp htmlHelpPanel#ql:jhelp'htmlhelppanel.class#:
* closeButton, backButton, forwardButton, searchButton, printButton
* redraw boolean:
* hsd htmlSearchDialog:
* hsdShowing boolean:
* resized boolean:
* hsize
* vsize
**(25)
** htmlHelpFrame(Object, String)
** htmlHelpFrame(Object, String, int, int)
** htmlHelpFrame(Object, String, int)
** construct (Object, String, int, int, int)
** addFile(Object, String)
** addHTMLString(Object, String, String)
** show(String): shows the html-file with 'string' name.
** show()
** setShowBase(String): declares the DIR where the html-files are.
** getCurrentFileName()
** window...()
** key...()
** closeMe()
** actionPerformed(ActionEvent)
** setMaxCache(int)
** getMaxCache()

*jhelp'htmlHelpPanel.class:
extends Panel
implements ActionListener, KeyListener, AdjustmentListener, htmlHelpStrings
*(10)
public static final String DYN_PREFIX = "dynamic:";
public static final String DYN_NAME = "_$$DYNAMIC$$_";
public static final String DYNAMIC = "dynamic:_$$DYNAMIC$$_";
private htmlHelpCanvas#ql:jhelp'htmlhelpcanvas.class# canvas;
private Scrollbar sb;
private String lastSearchText;
private boolean lastMatchCase;
private boolean lastWholeWord;
private String goToBase;
private ActionListener actionListener;

jhelp'htmlHelpStrings.class:
interface
Defines some final Strings for use in the programe.

jhelp'htmlHyperLink.class:
* max_x
* max_y
* min_x
* min_y
* hyperName String
** init(Point, Dimension, String)
** isHyperLink(int, int)
** getHyperName() String:

jhelp'htmlImage.class:
*(12)

*jhelp'htmlMessageBox.class:
extends Dialog
implements AcitonListener
* BUTTON=OK
* button
* parent Frame:
** showMessage(Container, String, String)
** init(Frame, String, String)

*jhelp'htmlMessageLine.class:
extends Canvas
* message String
** init()
** init(String)
** setMessage(String)
** getMessage() String
** paint(Graphics)

jhelp'htmlObject.class:
implements htmlFormatDefaults, htmlTagConstants

jhelp'htmlSearchData.class:
* searchText String
* matchCase boolean
* wholeWord boolean
** init(String, boolean, boolean)
** getWholeWord()
** getMatchCase()

jhelp'htmlSearchDialog.class:
extends Dialog
implements ActionLis, WList, KeyList, html
* findButton
* nextButton
* closeButton
* searchText TextField
* matchCase Checkbox
* wholeWord Checkbox

jhelp'htmlSearchEvent.class
extends ActionEvent
* CLOSE=0
* FIND=1
* FINDNEXT=2
* hsd htmlSearchData
** init(Object, int, htmlSearchData)
** getData() htmlSearchData

jhelp'htmlSpecialCharacters.class
extends Properties

jhelp'htmlStackObject.class
* fileName String
* index int
** init(String, int)
** getFileName() String
** getIndex() int
** equals(htmlStackObject) boolean

*jhelp'htmlRecessPanel.class:

jhelp'htmlTag.class:
implements htmlTagConstants
* fc htmlFontCache
* tag String
* tagID int
* htp htmlTagParser
** init(htmlFormatControl, String)

*jhelp'htmlTagConstants.class:
interface

jhelp'htmlTagParser.class: There is a problem here!

jhelp'htmlVector.class:
extends vector
implements htmlFormatDefaults, htmlHelpStrings
* instance Object:
* fileName String:
* images Vector:
* imageNames Vector:
* title String:
* bgColor Color:
* fgColor Color:
* image Image:
* oldWidth int:
* oldHeight int:
* hfc htmlFormatControl:
** init (Object, String)
** init (Object, String, String)
** replace(String, String, String) String:
** modifyPreFormat(String) String:
** parseHelpFiles(String) Vector:
** getHelpFile(Object, String) String:
** getHelpString(String) String:
** strip(String, String, String) String:
** parseContentText(String)
** addImageObject(String)
** parseContent(String)
** loadImages(Vector)
** parsImages(String) String
** unpadTags(String) String
** setLineHeights(Graphics, int) int
** isHyperLink(int, int) boolean
** getHyperLing(int, int) String
** getHyperLinkPosition(String) int
** checkMatching(String) boolean
** draw(Graphics int int) Image
** getBackground() Color
** getTitle() String
** getFileName() String
** getTopObject(int) int
** getTopPosition(int) int

jvp.NOTEPAD (np)

name::
* McsEngl.jvp.NOTEPAD (np)@cptItsoft,

FUNCTION: A simple Text-Editor, implementing JTextArea.

VERSION 1.2

CLASSES:
ElementTreePanel$1.class
ElementTreePanel$2.class
ElementTreePanel$ElementTreeModel.class
ElementTreePanel.class
Notepad$1.class
Notepad$2.class
Notepad$ActionChangedListener.class
Notepad$AppCloser.class
Notepad$ExitAction.class
Notepad$FileLoader.class
Notepad$NewAction.class
Notepad$OpenAction.class
Notepad$RedoAction.class
Notepad$ShowElementTreeAction.class
Notepad$StatusBar.class
Notepad$UndoAction.class
Notepad$UndoHandler.class
Notepad.class

FILES:
ElementTreePanel.java
Notepad.java
resources\Notepad.properties

np'ElementTreePanel.java (etp)

name::
* McsEngl.np'ElementTreePanel.java (etp)@cptItsoft,

import javax.swing.*; import javax.swing.event.*; import javax.swing.text.*; import javax.swing.tree.*; import javax.swing.undo.*; import java.awt.*; import java.util.*;

/** * Displays a tree showing all the elements in a text Document. Selecting * a node will result in reseting the selection of the JTextComponent. * This also becomes a CaretListener to know when the selection has changed * in the text to update the selected item in the tree. * * @author Scott Violet * @version 1.6 08/26/98 */

np'etp'METHODS:
ElementTreePanel(JTextComponent editor)
/* Document listener methods */
public void insertUpdate(DocumentEvent e)
public void removeUpdate(DocumentEvent e)
public void changedUpdate(DocumentEvent e)
protected void updateTree(DocumentEvent event)
protected void updateTree(DocumentEvent event, Element element)
/* implementation of CaretListener INTERFACE */
public void caretUpdate(CaretEvent e)
protected TreePath getPathForIndex(int position, Object root, Element rootElement)
/* TreeSelectionListener interface impl */
public void valueChanged(TreeSelectionEvent e)
/* local methods */
protected JTree getTree()
protected JTextComponent getEditor()
public DefaultTreeModel getTreeModel()

public class ElementTreePanel
extends JPanel
implements CaretListener, DocumentListener, TreeSelectionListener {

np'etp'FIELDS:
/** Tree showing the documents element structure. */
protected JTree tree;
/** Text component showing elemenst for. */
protected JTextComponent editor;
/** Model for the tree. */
protected ElementTreeModel treeModel;
/** Set to true when updatin the selection. */
protected boolean updatingSelection;

public np'etp'ElementTreePanel(JTextComponent editor)
{
this.editor = editor;
Document document = editor.getDocument(); /* editor is a JTextComponent */
/* Create the tree. */
treeModel = new ElementTreeModel#ql:np'etp'ElementTreeModel#(document);
tree = new JTree(treeModel) {

public String convertValueToText(Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
/* Should only happen for the root */
if(!(value instanceof Element)) return value.toString(); Element e = (Element)value; AttributeSet as = e.getAttributes#ql::INDEX-of-JDK1.2-API:jv'getAttributes#().copyAttributes#ql::INDEX-of-JDK1.2-API:jv'copyAttributes#();
/*copyAttributes() Returns an attribute set that is guaranteed not to change over time.*/ String asString;
if(as != null) { StringBuffer retBuffer = new StringBuffer("["); Enumeration names = as.getAttributeNames(); while(names.hasMoreElements()) { Object nextName = names.nextElement(); if(nextName != StyleConstants.ResolveAttribute#ql::INDEX-of-JDK1.2-API:jv'ResolveAttribute#) { retBuffer.append(" "); retBuffer.append(nextName); retBuffer.append("="); retBuffer.append(as.getAttribute(nextName)); } } retBuffer.append(" ]"); asString = retBuffer.toString(); } else asString = "[ ]"; if(e.isLeaf()) return e.getName() + " [" + e.getStartOffset() + ", " + e.getEndOffset() +"] Attributes: " + asString; return e.getName() + " [" + e.getStartOffset() + ", " + e.getEndOffset() + "] Attributes: " + asString; } };

tree.addTreeSelectionListener(this); /* changes on tree, are reflected on editor */ /* Don't show the root, it is fake. */
tree.setRootVisible(false);
/* Since the display value of every node after the insertion point // changes every time the text changes and we don't generate a change // event for all those nodes the display value can become off.
// This can be seen as '...' instead of the complete string value. // This is a temporary workaround, increase the needed size by 15, // hoping that will be enough. */
tree.setCellRenderer#ql::INDEX-of-JDK1.2-API:jv'setCellRenderer#(new DefaultTreeCellRenderer#ql::INDEX-of-JDK1.2-API:jv'DefaultTreeCellRenderer#() { public Dimension getPreferredSize() { Dimension retValue = super.getPreferredSize(); if(retValue != null) retValue.width += 15; return retValue; } });

/* become a listener on the document to update the tree. */ document.addDocumentListener(this);
/* Become a CaretListener selects the tree-path that coresponds in editor-caret */ editor.addCaretListener(this);
/* configure the panel and frame containing it. */
setLayout(new BorderLayout()); add(new JScrollPane(tree), BorderLayout.CENTER);
/* Add a label above tree to describe what is being shown */
JLabel label = new JLabel("Elements that make up the current document", SwingConstants#ql::INDEX-of-JDK1.2-API:jv'SwingConstants#.CENTER);
label.setFont(new Font("Dialog", Font.BOLD, 14)); add(label, BorderLayout.NORTH); setPreferredSize(new Dimension(200, 400)); }

/* DocumentListener */
/** * Gives notification that there was an insert into the document. The * given range bounds the freshly inserted region. * * @param e the document event */

public void np'etp'insertUpdate(DocumentEvent e) { updateTree(e); }

/** * Gives notification that a portion of the document has been * removed. The range is given in terms of what the view last * saw (that is, before updating sticky positions). * * @param e the document event */

public void np'etp'removeUpdate(DocumentEvent e) { updateTree(e); }

/** * Gives notification that an attribute or set of attributes changed. * * @param e the document event */

public void np'etp'changedUpdate(DocumentEvent e) { updateTree(e); }

/* implementation of CaretListener INTERFACE
selects the tree-path that coresponds in editor-caret */ /** * Messaged when the selection in the editor has changed. Will update * the selection in the tree. */
public void np'etp'caretUpdate(CaretEvent e) { if(!updatingSelection) { JTextComponent editor = getEditor(); int selBegin = Math.min(e.getDot(), e.getMark()); int end = Math.max(e.getDot(), e.getMark()); Vector paths = new Vector(); TreeModel model = getTreeModel(); Object root = model.getRoot(); int rootCount = model.getChildCount(root);
// Build an array of all the paths to all the character elements // in the selection. for(int counter = 0; counter < rootCount; counter++) { int start = selBegin;
while(start <= end) { TreePath path = getPathForIndex(start, root, (Element)model.getChild(root, counter)); Element charElement = (Element)path. getLastPathComponent();
paths.addElement(path); if(start >= charElement.getEndOffset()) start++; else start = charElement.getEndOffset(); } }
// If a path was found, select it (them). int numPaths = paths.size();
if(numPaths > 0) { TreePath[] pathArray = new TreePath[numPaths];
paths.copyInto(pathArray); updatingSelection = true; try { getTree().setSelectionPaths(pathArray); getTree().scrollPathToVisible(pathArray[0]); } finally { updatingSelection = false; } } } }

/* TreeSelectionListener interface impl selects the element in editor */
/** * Called whenever the value of the selection changes. * @param e the event that characterizes the change. */

public void np'etp'valueChanged(TreeSelectionEvent e) { JTree tree = getTree();
if(!updatingSelection && tree.getSelectionCount() == 1) { TreePath selPath = tree.getSelectionPath(); Object lastPathComponent = selPath.getLastPathComponent();
if(!(lastPathComponent instanceof DefaultMutableTreeNode)) { Element selElement = (Element)lastPathComponent;
updatingSelection = true; try { getEditor().select(selElement.getStartOffset(), selElement.getEndOffset()); } finally { updatingSelection = false; } } } }

/* Local methods */

/** * @return tree showing elements. */
protected JTree np'etp'getTree() { return tree; }

/** * @return JTextComponent showing elements for. */
protected JTextComponent np'etp'getEditor() { return editor; }

/** * @return TreeModel implementation used to represent the elements. */
public DefaultTreeModel np'etp'getTreeModel() { return treeModel; }

/** * Updates the tree based on the event type. This will invoke either * updateTree with the root element, or handleChange. */
protected void np'etp'updateTree(DocumentEvent event) { updatingSelection = true; try { TreeModel model = getTreeModel(); Object root = model.getRoot();
for(int counter = model.getChildCount(root) - 1; counter >= 0; counter--) { updateTree(event, (Element)model.getChild(root, counter)); } } finally { updatingSelection = false; } }

/** * Creates TreeModelEvents based on the DocumentEvent and messages * the treemodel. This recursively invokes this method with children * elements. * @param event indicates what elements in the tree hierarchy have * changed. * @param element Current element to check for changes against. */
protected void np'etp'updateTree(DocumentEvent event, Element element) { DocumentEvent.ElementChange ec = event.getChange(element); if (ec != null) { Element[] removed = ec.getChildrenRemoved(); Element[] added = ec.getChildrenAdded(); int startIndex = ec.getIndex();
// Check for removed. if(removed != null && removed.length > 0) { int[] indices = new int[removed.length]; for(int counter = 0; counter < removed.length; counter++) { indices[counter] = startIndex + counter; } getTreeModel().nodesWereRemoved((TreeNode)element, indices, removed); } // check for added if(added != null && added.length > 0) { int[] indices = new int[added.length]; for(int counter = 0; counter < added.length; counter++) { indices[counter] = startIndex + counter; } getTreeModel().nodesWereInserted((TreeNode)element, indices); } } if(!element.isLeaf()) { int startIndex = element.getElementIndex (event.getOffset()); int elementCount = element.getElementCount(); int endIndex = Math.min(elementCount - 1, element.getElementIndex (event.getOffset() + event.getLength()));
if(startIndex > 0 && startIndex < elementCount && element.getElement(startIndex).getStartOffset() == event.getOffset()) { // Force checking the previous element. startIndex--; } if(startIndex != -1 && endIndex != -1) { for(int counter = startIndex; counter <= endIndex; counter++) { updateTree(event, element.getElement(counter)); } } } else { // Element is a leaf, assume it changed getTreeModel().nodeChanged((TreeNode)element); } }

/** * Returns a TreePath to the element at <code>position</code>. */
protected TreePath np'etp'getPathForIndex(int position, Object root, Element rootElement) { TreePath path = new TreePath(root); Element child = rootElement.getElement (rootElement.getElementIndex(position));
path = path.pathByAddingChild(rootElement); path = path.pathByAddingChild(child); while(!child.isLeaf()) { child = child.getElement(child.getElementIndex(position)); path = path.pathByAddingChild(child); } return path; }

/** * ElementTreeModel is an implementation of TreeModel to handle displaying * the Elements from a Document. AbstractDocument.AbstractElement is * the default implementation used by the swing text package to implement * Element, and it implements TreeNode. This makes it trivial to create * a DefaultTreeModel rooted at a particular Element from the Document. * Unfortunately each Document can have more than one root Element. * Implying that to display all the root elements as a child of another * root a fake node has be created. This class creates a fake node as * the root with the children being the root elements of the Document * (getRootElements). * This subclasses DefaultTreeModel. The majority of the TreeModel * methods have been subclassed, primarily to special case the root. */

public static class np'etp'ElementTreeModel
extends DefaultTreeModel#ql::INDEX-of-JDK1.2-API:jv'DefaultTreeModel#
{ protected Element[] rootElements;

public ElementTreeModel(Document document)
{ super(new DefaultMutableTreeNode#ql::INDEX-of-JDK1.2-API:jv'DefaultMutableTreeNode#("root"), false);
rootElements = document.getRootElements#ql::INDEX-of-JDK1.2-API:jv'getRootElements#(); }

/** * Returns the child of parent at index index in * the parent's child array. parent must be a node * previously obtained from this data source. This should * not return null if index is a valid index for * parent (that is index >= 0 && index * < getChildCount(parent)). * * @param parent a node in the tree, obtained from this data source * @return the child of parent at index index */
public Object getChild(Object parent, int index)
{ if(parent == root) return rootElements[index]; return super.getChild(parent, index); }

/** * Returns the number of children of parent. Returns 0 * if the node is a leaf or if it has no children. * parent must be a node previously obtained from this * data source. * * @param parent a node in the tree, obtained from this data source * @return the number of children of the node parent */
public int getChildCount(Object parent)
{ if(parent == root) return rootElements.length; return super.getChildCount(parent); }

/** * Returns true if node is a leaf. It is possible for * this method to return false even if node has no * children. A directory in a filesystem, for example, may * contain no files; the node representing the directory is * not a leaf, but it also has no children. * * @param node a node in the tree, obtained from this data source * @return true if node is a leaf */

public boolean isLeaf(Object node) { if(node == root) return false; return super.isLeaf(node); }

/** * Returns the index of child in parent. */

public int getIndexOfChild(Object parent, Object child) { if(parent == root) { for(int counter = rootElements.length - 1; counter >= 0; counter--) { if(rootElements[counter] == child) return counter; } return -1; } return super.getIndexOfChild(parent, child); }

/** * Invoke this method after you've changed how node is to be * represented in the tree. */

public void nodeChanged(TreeNode node) { if(listenerList != null && node != null) { TreeNode parent = node.getParent();
if(parent == null && node != root) { parent = root; } if(parent != null) { int anIndex = getIndexOfChild(parent, node);
if(anIndex != -1) { int[] cIndexs = new int[1];
cIndexs[0] = anIndex; nodesChanged(parent, cIndexs); } } } }

/** * Returns the path to a particluar node. This is recursive. */

protected TreeNode[] getPathToRoot(TreeNode aNode, int depth) { TreeNode[] retNodes;
/* Check for null, in case someone passed in a null node, or they passed in an element that isn't rooted at root. */ if(aNode == null) { if(depth == 0) return null; else retNodes = new TreeNode[depth]; } else { depth++; if(aNode == root) retNodes = new TreeNode[depth]; else { TreeNode parent = aNode.getParent();
if(parent == null) parent = root; retNodes = getPathToRoot(parent, depth); } retNodes[retNodes.length - depth] = aNode; } return retNodes; }

} /* end of inner class ElementTreeModel */

}

VERSION swing061

SOURCE: swing0.6.1 example

FUNCTION:
a simple editor.

CLASSES:
class Notepad extends JPanel
class FileLoader extends Thread

FILES:
Notepad.java
Notepad.properties

np061.Notepad.class

name::
* McsEngl.np061.Notepad.class@cptItsoft,

np061.METHODS:
public static void main#ql:np'main#(String[] args)
Notepad#ql:np'Notepad#()
protected JTextComponent createEditor()
protected JMenuBar createMenubar#ql:np'createMenubar#()
protected JMenu createMenu#ql:np'createMenu#(String key)
protected JMenuItem createMenuItem(String cmd)
protected Component createStatusbar()
private Component createToolbar#ql:np'createToolbar#()
protected Component createTool#ql:np'createTool#(String key)
protected JButton createToolbarButton#ql:np'createToolbarButton#(String key)
public Action[] getActions()
protected JTextComponent getEditor()
protected Frame getFrame()
protected JMenuItem getMenuItem(String cmd)
protected Action getAction(String cmd)
protected String getResourceString(String nm)
protected URL getResource(String key)
protected Container getToolbar()
protected JMenuBar getMenubar()
protected String[] tokenize#ql:np'tokenize#(String input)

np061.INNER'CLASSES:
protected static final class AppCloser extends WindowAdapter
class StatusBar#ql:np'StatusBar# extends Container {
class OpenAction#ql:np'OpenAction# extends NewAction {
class NewAction#ql:np'NewAction# extends AbstractAction {
class ExitAction#ql:np'ExitAction# extends AbstractAction {

================== CODE ==============

/* * @(#)Notepad.java 1.44 97/10/06 * * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved. * * This software is the confidential and proprietary information of Sun * Microsystems, Inc. ("Confidential Information"). You shall not * disclose such Confidential Information and shall use it only in * accordance with the terms of the license agreement you entered into * with Sun. * * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING * THIS SOFTWARE OR ITS DERIVATIVES. * */

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.URL;
import java.util.*;
import com.sun.java.swing.text.*;
import com.sun.java.swing.*;

/** * Sample application using the simple text editor component that * supports only one font. * * @author Timothy Prinzing * @version 1.44 10/06/97 */

class Notepad
extends JPanel {

/*np061.FIELDS: */
private static ResourceBundle#ql::API12.NFO:class.ResourceBundle# resources;
static {
try {resources = ResourceBundle.getBundle("Notepad", Locale.getDefault()); }
catch (MissingResourceException mre) { System.err.println("Notepad.properties not found"); System.exit(1); }
}

private JTextComponent editor;
private Hashtable commands;
private Hashtable menuItems;
private JMenuBar menubar;
private JToolBar toolbar;
private#ql:jv'private'keyword# Container status;
protected#ql:jv'protected'keyword# FileDialog fileDialog;
/** * Suffix applied to the key used in resource file * lookups for an image. */
public static final String imageSuffix = "Image";
/** * Suffix applied to the key used in resource file * lookups for a label. */
public static final String labelSuffix = "Label";
/** * Suffix applied to the key used in resource file * lookups for an action. */
public static final String actionSuffix = "Action";
/** * Suffix applied to the key used in resource file * lookups for tooltip text. */
public static final String tipSuffix = "Tooltip";
public static final String openAction = "open";
public static final String newAction = "new";
public static final String saveAction = "save";
public static final String exitAction = "exit";

/** * Actions defined by the Notepad class */
private Action[] defaultActions = { new NewAction(), new OpenAction(), new ExitAction() };

public static void np061.main(String[] args)
{
try { String vers = System.getProperty("java.version");
if (vers.compareTo#ql::API12.NFO:class.string#("1.1.2") < 0) { System.out.println("!!!WARNING: Swing must be run with a " + "1.1.2 or higher version VM!!!"); }
JFrame#ql::API12.NFO:class.jframe# frame = new JFrame();
frame.setTitle(resources.getString("Title")); frame.setBackground(Color.lightGray); frame.getContentPane().setLayout(new BorderLayout()); frame.getContentPane().add("Center", new Notepad#ql:np'Notepad#()); frame.addWindowListener(new AppCloser#ql:np'AppCloser#()); frame.pack();
frame.setSize(500, 600); frame.show(); }
catch (Throwable t) {System.out.println("uncaught exception: " + t); t.printStackTrace(); } }

np061.Notepad()
// extends JPanel
{ super#ql::API12.NFO:class.jpanel#(true);
setBorder(BorderFactory#ql::API12.NFO:class.BorderFactory#.createEtchedBorder());
setLayout(new BorderLayout());
// create the embedded JTextComponent
editor = createEditor#ql:np'createEditor#();
editor.setFont(new Font("Courier", Font.PLAIN, 12));

// install the command table
commands = new Hashtable();
Action#ql::API12.NFO:interface.action#[] actions = getActions#ql:np'getActions#();
for (int i = 0; i < actions.length; i++)
{
Action a = actions[i];
commands.put(a.getText(Action.NAME), a);
}
JScrollPane#ql::API12.NFO:class.JScrollPane# scroller = new JScrollPane(); JViewport#ql::API12.NFO:class.JViewport# port = scroller.getViewport(); port.add(editor);
try { String vpFlag = resources.getString("ViewportBackingStore"); Boolean bs = new Boolean#ql::API12.NFO:class.boolean#(vpFlag); port.setBackingStoreEnabled(bs.booleanValue#ql::API12.NFO:booleanValue method#()); } catch (MissingResourceException mre) { // just use the viewport default }
menuItems = new Hashtable();
menubar = createMenubar#ql:np'createMenubar#();
add("North", menubar);
JPanel panel = new JPanel(); panel.setLayout(new BorderLayout()); panel.add("North", createToolbar#ql:np'createToolbar#()); panel.add("Center", scroller);
add("Center", panel);
add("South", createStatusbar#ql:np'createStatusbar#()); }

/** * Fetch the list of actions supported by this * editor. It is implemented to return the list * of actions supported by the embedded JTextComponent * augmented with the actions defined locally. */
public Action[] np061.getActions()
{ return TextAction#ql::API12.NFO:class.TextAction#.augmentList(editor#ql::API12.NFO:class.jtextarea#.getActions(), defaultActions#ql:np'fields defaultActions#); }

/** * Create an editor to represent the given document. */
protected JTextComponent np061.createEditor()
{ return new JTextArea#ql::API12.NFO:class.JTextArea#(); }

/** * Fetch the editor contained in this panel */
protected JTextComponent np061.getEditor()
{ return editor; }

/** * To shutdown when run as an application. This is a * fairly lame implementation. A more self-respecting * implementation would at least check to see if a save * was needed. */

protected static final class np061.AppCloser extends WindowAdapter#ql::API12.NFO:class.WindowAdapter# {
public void windowClosing(WindowEvent e) { System.exit(0); }
}

/** * Find the hosting frame, for the file-chooser dialog. */
protected Frame np061.getFrame()
{ for (Container p = getParent#ql::API12.NFO:getParent rl5#(); p != null; p = p.getParent())
{ if (p instanceof Frame) { return (Frame) p; } } return null; }

/** * This is the hook through which all menu items are * created. It registers the result with the menuitem * hashtable so that it can be fetched with getMenuItem(). * @see#getMenuItem */

protected JMenuItem np061.createMenuItem(String cmd)
{JMenuItem mi = new JMenuItem(getResourceString(cmd + labelSuffix));
URL url = getResource#ql:np'getResource#(cmd + imageSuffix);
if (url != null) {
mi.setHorizontalTextPosition(JButton.RIGHT);
mi.setIcon(new ImageIcon(url)); }
String astr = getResourceString(cmd + actionSuffix);
if (astr == null) { astr = cmd; }
mi.setActionCommand(astr); Action a = getAction(astr);
if (a != null) { mi.addActionListener(a); } else { mi.setEnabled(false); } menuItems.put(cmd, mi); return mi; }

/** * Fetch the menu item that was created for the given * command. * @param cmd Name of the action. * @returns item created for the given command or null * if one wasn't created. */
protected JMenuItem np061.getMenuItem(String cmd)
{ return (JMenuItem) menuItems.get(cmd); }

protected Action np061.getAction(String cmd)
{ return (Action) commands#ql:np'fields commands#.get#ql::API12.NFO:class.hashtable#(cmd); }

protected String np061.getResourceString(String nm)
{ String str;
try { str = resources#ql:np'fields resources#.getString#ql::API12.NFO:getString rl5#(nm); }
catch (MissingResourceException mre) { str = null; } return str; }

protected URL np061.getResource(String key)
{ String name = getResourceString#ql:np'getResourceString#(key);
if (name != null) { URL url = this.getClass#ql::API12.NFO:getClass rl5#().getResource(name); return url; } return null; }

protected Container np061.getToolbar()
{ return toolbar; }

protected JMenuBar np061.getMenubar()
{ return menubar; }

/** * Create a status bar */
protected Component np061.createStatusbar()
{ // need to do something reasonable here
status#ql:np'fields status# = new StatusBar(); return status; }

/** * Create the toolbar. By default this reads the * resource file for the definition of the toolbar. */
private Component np061.createToolbar()
{toolbar = new JToolBar#ql::API12.NFO:JToolBar rl5#();
String[] toolKeys = tokenize#ql:np'tokenize#(getResourceString("toolbar"));
for (int i = 0; i < toolKeys.length; i++) {
if (toolKeys[i].equals("-")) { toolbar.add(Box.createHorizontalStrut(5)); }
else { toolbar.add(createTool#ql:np'createTool#(toolKeys[i])); } } toolbar.add(Box#ql::API12.NFO:class.box#.createHorizontalGlue()); return toolbar; }

/** * Hook through which every toolbar item is created. */
protected Component np061.createTool(String key)
{ return createToolbarButton#ql:np'createToolbarButton#(key); }

/** * Create a button to go inside of the toolbar. By default this * will load an image resource. The image filename is relative to * the classpath (including the '.' directory if its a part of the * classpath), and may either be in a JAR file or a separate file. * * @param key The key in the resource file to serve as the basis * of lookups. */

protected JButton np061.createToolbarButton(String key)
{ URL url = getResource#ql:np'getresource#(key + imageSuffix);
JButton b = new JButton#ql::API12.NFO:JButton rl5#(new ImageIcon#ql::API12.NFO:ImageIcon rl5#(url))
{ public float getAlignmentY() { return 0.5f; } }; b.setRequestFocusEnabled#ql::API12.NFO:setRequestFocusEnabled rl5#(false); b.setMargin(new Insets#ql::API12.NFO:class.Insets#(1,1,1,1));

String astr = getResourceString(key + actionSuffix#ql:np'fields actionSuffix#);
if (astr == null) { astr = key; }
Action a = getAction#ql:np'getAction#(astr); //(Action) commands#ql:np'fields commands#.get#ql::API12.NFO:class.hashtable#(cmd)
if (a != null) { b.setActionCommand#ql::API12.NFO:class.button#(astr); b.addActionListener(a); } else { b.setEnabled(false); }

String tip = getResourceString(key + tipSuffix);
if (tip != null) { b.setToolTipText#ql::API12.NFO:setToolTipText rl5#(tip); } return b; }

/** * Take the given string and chop it up into a series * of strings on whitespace boundries. This is useful * for trying to get an array of strings out of the * resource file. */

protected String[] np061.tokenize(String input)
{ Vector v = new Vector();
StringTokenizer t = new StringTokenizer#ql::API12.NFO:StringTokenizer rl5#(input);
String cmd[];
while (t.hasMoreTokens()) v.addElement(t.nextToken()); cmd = new String[v.size()]; for (int i = 0; i < cmd.length; i++) cmd[i] = (String) v.elementAt(i);
return cmd; }

/** * Create the menubar for the app. By default this pulls the * definition of the menu from the associated resource file. */
protected JMenuBar np061.createMenubar()
{ JMenuItem mi;
JMenuBar mb = new JMenuBar();
String[] menuKeys = tokenize(getResourceString("menubar"));
for (int i = 0; i < menuKeys.length; i++) { JMenu m = createMenu#ql:np'createMenu#(menuKeys[i]); if (m != null) { mb.add(m); } } return mb; }

/** * Create a menu for the app. By default this pulls the * definition of the menu from the associated resource file. */
protected JMenu np061.createMenu(String key)
{ String[] itemKeys = tokenize(getResourceString(key));
JMenu menu = new JMenu(getResourceString(key + "Label"));
for (int i = 0; i < itemKeys.length; i++) {
if (itemKeys[i].equals("-")) { menu.addSeparator(); }
else { JMenuItem mi = createMenuItem#ql:np'createMenuItem#(itemKeys[i]); menu.add(mi); }
} return menu; }

/** * FIXME - I'm not very useful yet */
class np061.StatusBar extends Container {
public StatusBar() { super();
setLayout(new BoxLayout#ql::API12.NFO:class.BoxLayout#(this, BoxLayout.X_AXIS)); }
public void paint(Graphics g) { super.paint(g); }
}

// --- action implementations -----------------------------------

class np061.OpenAction extends NewAction#ql:np'NewAction# {
OpenAction() { super(openAction); }

public void actionPerformed(ActionEvent e) {
Frame frame = getFrame#ql:np'getFrame#();
if (fileDialog#ql:np'fields fileDialog# == null) { fileDialog = new FileDialog(frame); } fileDialog.setMode#ql::API12.NFO:setmode rl5#(FileDialog.LOAD); fileDialog.show();
String file = fileDialog.getFile#ql::API12.NFO:getFile rl5#();
if (file == null) { return; }
String directory = fileDialog.getDirectory();
File f = new File(directory, file);
if (f.exists()) { super#ql:np'newaction#.actionPerformed(e); frame.setTitle(file); Thread loader = new FileLoader#ql:np'fileloader.class#(f, editor.getDocument(), status); loader.start(); } }
}

class np061.NewAction extends AbstractAction#ql::API12.NFO:class.AbstractAction# {

NewAction() { super(newAction); }

NewAction(String nm) { super(nm); }

public void actionPerformed(ActionEvent e) {
getEditor#ql:np'getEditor#().setDocument#ql::API12.NFO:class.jtextarea#(new PlainDocument#ql::API12.NFO:class.PlainDocument#()); validate#ql::API12.NFO:validate rl5#(); }
}

/** * Really lame implementation of an exit command */
class np061.ExitAction extends AbstractAction {
ExitAction() { super(exitAction); }
public void actionPerformed(ActionEvent e) { System.exit(0); }
}

} /* end of notepad class */

np061.FileLoader.class

name::
* McsEngl.np061.FileLoader.class@cptItsoft,

/** * Thread to load a file into the text storage model */
class np061.FileLoader extends Thread#ql::API12.NFO:class.Thread# {

Document doc; File f; Container status;

FileLoader(File f, Document doc, Container status)
{ setPriority(4); this.f = f; this.doc = doc; this.status = status; }

public void run()
{ try { sleep(50); // avoid deadlock with focus setting code
// initialize the statusbar status.removeAll(); JProgressBar progress = new JProgressBar#ql::API12.NFO:class.JProgressBar#(); progress.setMinimum(0); progress.setMaximum((int) f.length()); status.add(progress); validateAll();
// try to start reading
Reader in = new FileReader(f); char[] buff = new char[4096]; int nch; while ((nch = in.read(buff, 0, buff.length)) != -1) { doc.insertString(doc.getLength(), new String(buff, 0, nch), null); progress.setValue(progress.getValue() + nch); }
// we are done... get rid of progressbar status.removeAll(); validateAll(); } catch (IOException e) { System.err.println(e.toString()); } catch (InterruptedException e) { System.err.println(e.getMessage()); } catch (BadLocationException e) { System.err.println(e.getMessage()); } }

public void validateAll()
{ synchronized (status.getTreeLock()) { Container c = status; for (Container p = status.getParent(); p != null && ! p.isValid(); p = p.getParent()) { c = p; } c.validate(); } }

}

np061.Notepad.properties

name::
* McsEngl.np061.Notepad.properties@cptItsoft,

# @(#)Notepad.properties 1.5 97/09/24## Resource strings for Notepad example
Title=Notepad
ViewportBackingStore=false

# menubar definition
# Each of the strings that follow form a key to be used to the actual menu definition.
menubar=file edit debug

# file Menu definition
# Each of the strings that follow form a key to be# used as the basis of a menu item definition.## open -> Notepad.openAction# new -> Notepad.newAction# save -> Notepad.saveAction# exit -> Notepad.exitAction
file=new open save - exit
fileLabel=File
openLabel=Open
openImage=images/open.gif
newLabel=New
newImage=images/new.gif
saveLabel=Save
saveImage=images/save.gif
exitLabel=Exit

# edit Menu definition
# cut -> JTextComponent.cutAction# copy -> JTextComponent.copyAction# paste -> JTextComponent.pasteAction
edit=cut copy paste
editLabel=Edit
cutLabel=Cut
cutAction=cut-to-clipboard
cutImage=images/cut.gif
copyLabel=Copy
copyAction=copy-to-clipboard
copyImage=images/copy.gif
pasteLabel=Paste
pasteAction=paste-from-clipboard
pasteImage=images/paste.gif

## debug Menu definition
debug=dump
debugLabel=Debug
dumpLabel=Dump model to System.err
dumpAction=dump-model

# toolbar definition## Each of the strings that follow form a key to be# used as the basis of the tool definition. Actions# are of course sharable, and in this case are shared# with the menu items.
toolbar=new open save - cut copy paste
newTooltip=Create a new file
openTooltip=Open a file
saveTooltip=Save to a file
cutTooltip=Move selection to clipboard
copyTooltip=Copy selection to clipboard
pasteTooltip=Paste clipboard to selection

jvp.PARSER

name::
* McsEngl.jvp.PARSER@cptItsoft,
* McsEngl.conceptItsoft1200.1,
* McsEngl.java'parser@cptItsoft1200.1,
* McsEngl.jv'parser'program@cptItsoft12001,

GENERIC-PARSER:
* JavaCC#cptItsoft1204#

XML-PARSER:
* ALFRED,

jvp.property'editor

name::
* McsEngl.jvp.property'editor@cptItsoft,

SOURCE: \java\scsc\beans

PROCESS:
-TestFrame.Main()
--SimpleBean();
--Wrapper(bean, "SimpleBean");
--TestFrame(topWrapper, 300, 59);

TestFrame.class:
- Frame to present the properties of a bean.
** main()
** TestFrame(Wrapper target, int x, int y)
** setTarget(Wrapper targ)
** windowOpened(WindowEvent e)...

Wrapper.class:
- Panel,
** Wrapper(Object bean, String beanName)
** initialize()
** readObject(ObjectInputStream s)
** writeNakedBean(ObjectOutputStream oos)
** getBean()
** getBeanName()
** getChild()
** findWrapper(Component comp)
** doLayout()
** sizeToFit()
** setActive(boolean isActive)
** getPreferredSize()
** childHasStupidPreferredSize()
** setBounds(int x, int y, int width, int height)
** paint(Graphics g)
** activate()
** deactivate()
** showInvisibleBeans(boolean show)
** useNewEventModel()
** getHashBars(Component c)

PropertySheetPanel.class:
** PropertySheetPanel(TestFrame frame)
** setTarget(Object targ)
** doLayout()
** setCustomizer(Customizer c)
** warning(String s)
** error(String message, Exception ex)

OurLabel.class:
extends Canvas
** OurLabel(String label)
** paint(Graphics g)

jvp.SAMPLETREE (smtr)

name::
* McsEngl.jvp.SAMPLETREE (smtr)@cptItsoft,

SOURCE:
* SWING 0.6.1
* version 1.9 09/26/97
* author Scott Violet
* Copyright (c) 1997 Sun Microsystems

FUNCTION:
A demo for illustrating how to do different things with JTree. The data that this displays is rather boring, that is each node will have 7 children that have random names based on the fonts. Each node is then drawn with that font and in a different color. While the data isn't interesting the example illustrates a number of things:
* For an example of dynamicaly loading children refer to DynamicTreeNode.
* For an example of adding/removing/inserting/reloading refer to the inner classes of this class, AddAction, RemovAction, InsertAction and ReloadAction.
* For an example of creating your own cell renderer refer to SampleTreeCellRenderer.
* For an example of subclassing JTreeModel for editing refer to SampleTreeModel.

SOURCE FILES:
SampleTree.java: The main class
DynamicTreeNode.java
SampleData.java
SampleTreeCellRenderer.java
SampleTreeModel.java

smtr'SampleTree.java

name::
* McsEngl.smtr'SampleTree.java@cptItsoft,

import com.sun.java.swing.*;
import com.sun.java.swing.event.*;
import com.sun.java.swing.tree.*;
import java.awt.BorderLayout; import java.awt.Color; import java.awt.Dimension; import java.awt.FlowLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent;

public class SampleTree {

smtr'st'FIELDS:
/** Window for showing Tree. */
protected JFrame frame;
/** Tree used for the example. */
protected JTree tree;
/** Tree model. */
protected DefaultTreeModel treeModel;

/* Constructs a new instance of SampleTree. */
public smtr'st'SampleTree() {
JMenuBar menuBar = constructMenuBar#ql:smtr'st'constructMenuBar#();
JPanel panel = new JPanel(true);
frame = new JFrame("SampleTree");
frame.getContentPane().add("Center", panel);
frame.setJMenuBar(menuBar);
frame.setBackground(Color.lightGray);
/* Create the JTreeModel. */
DefaultMutableTreeNode root = createNewNode#ql:smtr'st'createNewNode#("Root");
treeModel = new SampleTreeModel#ql:smtr'stm'sampletreemodel#(root);
/* Create the tree. */
tree = new JTree(treeModel);
/* Make the tree use an instance of SampleTreeCellRenderer for drawing. */
tree.setCellRenderer(new SampleTreeCellRenderer());
/* Make tree ask for the height of each row. */
tree.setRowHeight(-1);
/* Put the Tree in a scroller. */ JScrollPane sp = new JScrollPane(); sp.setPreferredSize(new Dimension(300, 300)); sp.getViewport().add(tree);
/* And show it. */
panel.setLayout(new BorderLayout()); panel.add("Center", sp); panel.add("South", constructOptionsPanel());
frame.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0);}});
frame.pack(); frame.show(); }

/** Constructs a JPanel containing check boxes for the different * options that tree supports. */

private JPanel smtr'st'constructOptionsPanel() {
JCheckBox aCheckbox; JPanel retPanel = new JPanel(false); JPanel borderPane = new JPanel(false);
borderPane.setLayout(new BorderLayout()); retPanel.setLayout(new FlowLayout());
aCheckbox = new JCheckBox("show handles"); aCheckbox.setSelected(tree.getShowsRootHandles()); aCheckbox.addChangeListener(new ShowHandlesChangeListener()); retPanel.add(aCheckbox);
aCheckbox = new JCheckBox("show root"); aCheckbox.setSelected(tree.isRootVisible()); aCheckbox.addChangeListener(new ShowRootChangeListener()); retPanel.add(aCheckbox);
aCheckbox = new JCheckBox("editable"); aCheckbox.setSelected(tree.isEditable()); aCheckbox.addChangeListener(new TreeEditableChangeListener()); aCheckbox.setToolTipText("Triple click to edit"); retPanel.add(aCheckbox);
borderPane.add(retPanel, "North");
/* Create a set of radio buttons that dictate what selection should be allowed in the tree. */ ButtonGroup group = new ButtonGroup(); JPanel buttonPane = new JPanel(false); JRadioButton button;
buttonPane.setLayout(new FlowLayout()); button = new JRadioButton("Single");
button.addActionListener(new AbstractAction() {
public boolean isEnabled() { return true; }
public void actionPerformed(ActionEvent e) { tree.getSelectionModel().setSelectionMode (TreeSelectionModel.SINGLE_TREE_SELECTION); } }); group.add(button); buttonPane.add(button); button = new JRadioButton("Contiguous");
button.addActionListener(new AbstractAction() { public boolean isEnabled() { return true; } public void actionPerformed(ActionEvent e) { tree.getSelectionModel().setSelectionMode (TreeSelectionModel.CONTIGUOUS_TREE_SELECTION); } }); group.add(button); buttonPane.add(button); button = new JRadioButton("Discontiguous");
button.addActionListener(new AbstractAction() { public boolean isEnabled() { return true; } public void actionPerformed(ActionEvent e) { tree.getSelectionModel().setSelectionMode (TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION); } }); button.setSelected(true); group.add(button); buttonPane.add(button);
borderPane.add(buttonPane, "South"); return borderPane; }

/** Construct a menu. */
private JMenuBar smtr'st'constructMenuBar() {
JMenu menu;
JMenuBar menuBar = new JMenuBar();
JMenuItem menuItem;
/* Good ol exit. */
menu = new JMenu("File");
menuBar.add(menu);
menuItem = menu.add(new JMenuItem("Exit"));
menuItem.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {System.exit(0); }} );
/* Tree related stuff. */
menu = new JMenu("Tree");
menuBar.add(menu);
menuItem = menu.add(new JMenuItem("Add"));
menuItem.addActionListener(new AddAction());
menuItem = menu.add(new JMenuItem("Insert"));
menuItem.addActionListener(new InsertAction());
menuItem = menu.add(new JMenuItem("Reload"));
menuItem.addActionListener(new ReloadAction());
menuItem = menu.add(new JMenuItem("Remove"));
menuItem.addActionListener(new RemoveAction());
return menuBar; }

/** * Returns the TreeNode instance that is selected in the tree. * If nothing is selected, null is returned. */
protected DefaultMutableTreeNode smtr'st'getSelectedNode() {
TreePath selPath = tree.getSelectionPath();
if(selPath != null) return (DefaultMutableTreeNode)selPath.getLastPathComponent(); return null; }

protected DefaultMutableTreeNode smtr'st'createNewNode(String name) {
return new DynamicTreeNode#ql:smtr'dtn'dynamictreenode#(new SampleData(null, Color.black, name)); }

/** * AddAction is used to add a new item after the selected item. */

class smtr'st'AddAction
extends Object
implements ActionListener {
/** Number of nodes that have been added. */
public int addCount;
/** * Messaged when the user clicks on the Add menu item. * Determines the selection from the Tree and adds an item * after that. If nothing is selected, an item is added to * the root. */ public void actionPerformed(ActionEvent e) { int newIndex; DefaultMutableTreeNode lastItem = getSelectedNode(); DefaultMutableTreeNode parent;
/* Determine where to create the new node. */ if(lastItem != null) parent = (DefaultMutableTreeNode)lastItem.getParent(); else parent = (DefaultMutableTreeNode)treeModel.getRoot(); if(lastItem == null) newIndex = treeModel.getChildCount(parent); else newIndex = parent.getIndex(lastItem) + 1;
/* Let the treemodel know. */ treeModel.insertNodeInto(createNewNode("Added " + Integer.toString(addCount++)), parent, newIndex); } } // End of SampleTree.AddAction

/** * InsertAction is used to insert a new item before the selected item. */

class smtr'st'InsertAction extends Object implements ActionListener { /** Number of nodes that have been added. */ public int insertCount;
/** * Messaged when the user clicks on the Insert menu item. * Determines the selection from the Tree and inserts an item * after that. If nothing is selected, an item is added to * the root. */ public void actionPerformed(ActionEvent e) { int newIndex; DefaultMutableTreeNode lastItem = getSelectedNode(); DefaultMutableTreeNode parent;
/* Determine where to create the new node. */ if(lastItem != null) parent = (DefaultMutableTreeNode)lastItem.getParent(); else parent = (DefaultMutableTreeNode)treeModel.getRoot(); if(lastItem == null) newIndex = treeModel.getChildCount(parent); else newIndex = parent.getIndex(lastItem);
/* Let the treemodel know. */ treeModel.insertNodeInto(createNewNode("Inserted " + Integer.toString(insertCount++)), parent, newIndex); } } // End of SampleTree.InsertAction

/** * ReloadAction is used to reload from the selected node. If nothing * is selected, reload is not issued. */

class smtr'st'ReloadAction extends Object implements ActionListener { /** * Messaged when the user clicks on the Reload menu item. * Determines the selection from the Tree and asks the treemodel * to reload from that node. */ public void actionPerformed(ActionEvent e) { DefaultMutableTreeNode lastItem = getSelectedNode();
if(lastItem != null) treeModel.reload(lastItem); } } // End of SampleTree.ReloadAction

/** * RemoveAction removes the selected node from the tree. If * The root or nothing is selected nothing is removed. */

class smtr'st'RemoveAction extends Object implements ActionListener { /** * Removes the selected item as long as it isn't root. */ public void actionPerformed(ActionEvent e) { DefaultMutableTreeNode lastItem = getSelectedNode();
if(lastItem != null && lastItem != (DefaultMutableTreeNode)treeModel.getRoot()) { treeModel.removeNodeFromParent(lastItem); } } } // End of SampleTree.RemoveAction

/** * ShowHandlesChangeListener implements the ChangeListener interface * to toggle the state of showing the handles in the tree. */

class smtr'st'ShowHandlesChangeListener extends Object implements ChangeListener { public void stateChanged(ChangeEvent e) { tree.setShowsRootHandles(((JCheckBox)e.getSource()).isSelected()); }
} // End of class SampleTree.ShowHandlesChangeListener

/** * ShowRootChangeListener implements the ChangeListener interface * to toggle the state of showing the root node in the tree. */

class smtr'st'ShowRootChangeListener extends Object implements ChangeListener { public void stateChanged(ChangeEvent e) { tree.setRootVisible(((JCheckBox)e.getSource()).isSelected()); }
} // End of class SampleTree.ShowRootChangeListener

/** * TreeEditableChangeListener implements the ChangeListener interface * to toggle between allowing editing and now allowing editing in * the tree. */

class smtr'st'TreeEditableChangeListener
extends Object
implements ChangeListener {

public void stateChanged(ChangeEvent e) { tree.setEditable(((JCheckBox)e.getSource()).isSelected()); }

} // End of class SampleTree.TreeEditableChangeListener

static public void smtr'st'main(String args[]) { new SampleTree(); }

}

smtr'DynamicTreeNode.java

name::
* McsEngl.smtr'DynamicTreeNode.java@cptItsoft,

import com.sun.java.swing.tree.DefaultMutableTreeNode; import java.awt.Color; import java.awt.Font; import java.awt.Toolkit; import java.util.Random;

/** * DynamicTreeNode illustrates one of the possible ways in which dynamic * loading can be used in tree. The basic premise behind this is that * getChildCount() will be messaged from JTreeModel before any children * are asked for. So, the first time getChildCount() is issued the * children are loaded. * It should be noted that isLeaf will also be messaged from the model. * The default behavior of TreeNode is to message getChildCount to * determine this. As such, isLeaf is subclassed to always return false. * There are others ways this could be accomplished as well. Instead of * subclassing TreeNode you could subclass JTreeModel and do the same * thing in getChildCount(). Or, if you aren't using TreeNode you could * write your own TreeModel implementation. * Another solution would be to listen for TreeNodeExpansion events and * the first time a node has been expanded post the appropriate insertion * events. I would not recommend this approach though, the other two * are much simpler and cleaner (and are faster from the perspective of * how tree deals with it). * * NOTE: getAllowsChildren() can be messaged before getChildCount(). * For this example the nodes always allow children, so it isn't * a problem, but if you do support true leaf nodes you may want * to check for loading in getAllowsChildren too. * * @version 1.3 09/23/97 * @author Scott Violet */

public class DynamicTreeNode
extends DefaultMutableTreeNode { // Class stuff.

smtr'dtn'FIELDS:
/** Number of names. */
static protected float nameCount;
/** Names to use for children. */
static protected String[] names;
/** Potential fonts used to draw with. */
static protected Font[] fonts;
/** Used to generate the names. */
static protected Random nameGen;
/** Number of children to create for each node. */
static protected final int DefaultChildrenCount = 7;
static { String[] fontNames;
try { fontNames = Toolkit.getDefaultToolkit().getFontList(); } catch (Exception e) { fontNames = null; }
if(fontNames == null || fontNames.length == 0) { names = new String[] {"Mark Andrews", "Tom Ball", "Alan Chung", "Rob Davis", "Jeff Dinkins", "Amy Fowler", "James Gosling", "David Karlton", "Dave Kloba", "Dave Moore", "Hans Muller", "Rick Levenson", "Tim Prinzing", "Chester Rose", "Ray Ryan", "Georges Saab", "Scott Violet", "Kathy Walrath", "Arnaud Weber" }; }
else { /* Create the Fonts, creating fonts is slow, much better to do it once. */ int fontSize = 12;
names = fontNames; fonts = new Font[names.length]; for(int counter = 0, maxCounter = names.length; counter < maxCounter; counter++) { try { fonts[counter] = new Font(fontNames[counter], 0, fontSize); } catch (Exception e) { fonts[counter] = null; } fontSize = ((fontSize + 2 - 12) % 12) + 12; } } nameCount = (float)names.length; nameGen = new Random(System.currentTimeMillis()); }

/** Have the children of this node been loaded yet? */
protected boolean hasLoaded;

/** * Constructs a new DynamicTreeNode instance with o as the user * object. */

public smtr'dtn'DynamicTreeNode(Object o) { super(o); }

public boolean smtr'dtn'isLeaf() { return false; }

/** * If hasLoaded is false, meaning the children have not yet been * loaded, loadChildren is messaged and super is messaged for * the return value. */

public int smtr'dtn'getChildCount() { if(!hasLoaded) { loadChildren(); } return super.getChildCount(); }

/** * Messaged the first time getChildCount is messaged. Creates * children with random names from names. */

protected void smtr'dtn'loadChildren() { DynamicTreeNode newNode; Font font; int randomIndex; SampleData data;
for(int counter = 0; counter < DynamicTreeNode.DefaultChildrenCount; counter++) { randomIndex = (int)(nameGen.nextFloat() * nameCount); if(fonts != null) font = fonts[randomIndex]; else font = null; if(counter % 2 == 0) data = new SampleData(font, Color.red, names[randomIndex]); else data = new SampleData(font, Color.blue, names[randomIndex]); newNode = new DynamicTreeNode(data); /* Don't use add() here, add calls insert(newNode, getChildCount()) so if you want to use add, just be sure to set hasLoaded = true first. */ insert(newNode, counter); } /* This node has now been loaded, mark it so. */ hasLoaded = true; } }

smtr'SampleData.java

name::
* McsEngl.smtr'SampleData.java@cptItsoft,

import java.awt.Color; import java.awt.Font;

/** * @version 1.1 07/29/97 * @author Scott Violet */
public class SampleData
extends Object {

smtr'sd'FIELDS:
/** Font used for drawing. */ protected Font font;
/** Color used for text. */ protected Color color;
/** Value to display. */ protected String string;

/** * Constructs a new instance of SampleData with the passed in * arguments. */ public smtr'sd'SampleData(Font newFont, Color newColor, String newString) { font = newFont; color = newColor; string = newString; }

/** * Sets the font that is used to represent this object. */
public void smtr'sd'setFont(Font newFont) { font = newFont; }

/** * Returns the Font used to represent this object. */
public Font smtr'sd'getFont() { return font; }

/** * Sets the color used to draw the text. */
public void smtr'sd'setColor(Color newColor) { color = newColor; }

/** * Returns the color used to draw the text. */
public Color smtr'sd'getColor() { return color; }

/** * Sets the string to display for this object. */
public void smtr'sd'setString(String newString) { string = newString; }

/** * Returnes the string to display for this object. */
public String smtr'sd'string() { return string; }

public String smtr'sd'toString() { return string; } }

smtr'SampleTreeCellRenderer.java

name::
* McsEngl.smtr'SampleTreeCellRenderer.java@cptItsoft,

import com.sun.java.swing.Icon; import com.sun.java.swing.ImageIcon; import com.sun.java.swing.JLabel; import com.sun.java.swing.JTree; import com.sun.java.swing.tree.TreeCellRenderer; import com.sun.java.swing.tree.DefaultMutableTreeNode; import java.awt.Component; import java.awt.Color; import java.awt.Font; import java.awt.Graphics;

public class SampleTreeCellRenderer
extends JLabel
implements TreeCellRenderer {

smtr'stcr'FIELDS:
/** Font used if the string to be displayed isn't a font. */
static protected Font defaultFont;
/** Icon to use when the item is collapsed. */
static protected ImageIcon collapsedIcon;
/** Icon to use when the item is expanded. */
static protected ImageIcon expandedIcon;
/** Color to use for the background when selected. */
static protected final Color SelectedBackgroundColor = Color.yellow;//new Color(0, 0, 128);
static {
try { defaultFont = new Font("SansSerif", 0, 12); } catch (Exception e) {}
try { collapsedIcon = new ImageIcon("images/collapsed.gif"); expandedIcon = new ImageIcon("images/expanded.gif"); } catch (Exception e) { System.out.println("Couldn't load images: " + e); } }
/** Whether or not the item that was last configured is selected. */ protected boolean selected;

/** * This is messaged from JTree whenever it needs to get the size * of the component or it wants to draw it. * This attempts to set the font based on value, which will be * a TreeNode. */

public Component smtr'stcr'getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) { Font font; String stringValue = tree.convertValueToText(value, selected, expanded, leaf, row, hasFocus);
/* Set the text. */ setText(stringValue);
/* Set the image. */ if(expanded) setIcon(expandedIcon); else if(!leaf) setIcon(collapsedIcon); else setIcon(null);
/* Set the color and the font based on the SampleData userObject. */
SampleData userObject = (SampleData)((DefaultMutableTreeNode)value) .getUserObject(); if(hasFocus) setForeground(Color.cyan); else setForeground(userObject.getColor()); if(userObject.getFont() == null) setFont(defaultFont); else setFont(userObject.getFont());
/* Update the selected flag for the next paint. */ this.selected = selected;
return this; }

/** * paint is subclassed to draw the background correctly. JLabel * currently does not allow backgrounds other than white, and it * will also fill behind the icon. Something that isn't desirable. */

public void smtr'stcr'paint(Graphics g) { Color bColor; Icon currentI = getIcon();
bColor = selected ? SelectedBackgroundColor : Color.white; g.setColor(bColor); if(currentI != null && getText() != null) { int offset = (currentI.getIconWidth() + getIconTextGap());
g.fillRect(getX() + offset, getY(), getWidth() - 1 - offset, getHeight() - 1); } else g.fillRect(getX(), getY(), getWidth()-1, getHeight()-1); super.paint(g); } }

smtr'SampleTreeModel

name::
* McsEngl.smtr'SampleTreeModel@cptItsoft,

import com.sun.java.swing.tree.DefaultTreeModel; import com.sun.java.swing.tree.TreeNode; import com.sun.java.swing.tree.TreePath; import com.sun.java.swing.tree.DefaultMutableTreeNode; import java.awt.Color;

/** * SampleTreeModel extends JTreeModel to extends valueForPathChanged. * This method is called as a result of the user editing a value in * the tree. If you allow editing in your tree, are using TreeNodes * and the user object of the TreeNodes is not a String, then you're going * to have to subclass JTreeModel as this example does. * * @version 1.3 09/23/97 * @author Scott Violet */

public class SampleTreeModel
extends DefaultTreeModel {

/*Creates a new instance of SampleTreeModel with newRoot set to the root of this model. */
public smtr'stm'SampleTreeModel(TreeNode newRoot)
{ super(newRoot); }

/*Subclassed to message setString() to the changed path item. */
public void smtr'stm'valueForPathChanged(TreePath path, Object newValue) {
/* Update the user object. */ DefaultMutableTreeNode aNode = (DefaultMutableTreeNode)path.getLastPathComponent();
SampleData sampleData = (SampleData)aNode.getUserObject();
sampleData.setString((String)newValue); /* UUUhhhhh, pretty colors. */ sampleData.setColor(Color.green);
/* Since we've changed how the data is to be displayed, message nodeChanged. */ nodeChanged(aNode); } }

jvp.SORT.BUBBLE

name::
* McsEngl.jvp.SORT.BUBBLE@cptItsoft,

import java.util.*;
class BubbleSort{
public static void main (String args[]){
int[] n = new int[10];
Random myRandom = new Random();

for (int i=0; i<10; i++){
n[i] = myRandom.nextInt();
}

System.out.println("Before sorting:");
for (int i=0; i<10; i++){
System.out.println("n[" +i+ "] = " +n[i]);
}

boolean sorted=false;
while (!sorted){
sorted=true;
for (int i=0; i<9; i++){
if (n[i]>n[i+1]){
int temp=n[i];
n[i]=n[i+1];
n[i+1]=temp;
sorted=false;
}
}
}

System.out.println();
System.out.println("After sorting:");
for (int i=0; i<10; i++){
System.out.println("n["+i+"] = " +n[i]);
}
}
}

jvp.STYLEPAD (stp)

name::
* McsEngl.jvp.STYLEPAD (stp)@cptItsoft,

1.2

FUNCTION:
Sample application using JTextPane.
author: Timothy Prinzing
version: 1.8 08/26/98

SOURCE: jdk12\demo

FILES:
ElementTreePanel.java
Notepad.java
Woderlad.java

1.1

SOURCE: swing0.6.1

CLASSES:
Stylepad.class

FILES:
Stylepad.java
Stylepad.properties
Wonderland.java

// Notepad files

stp'STYLEPAD.JAVA

name::
* McsEngl.stp'STYLEPAD.JAVA@cptItsoft,

stp'METHODS:
public Stylepad()
public static void main#ql:stp'main#(String[] args)
public Action[] getActions()
protected String getResourceString(String nm)
protected JTextComponent createEditor#ql:stp'createEditor#()
protected JMenu createMenu(String key)
JMenu createColorMenu()
void initDocument#ql:stp'initDocument#(DefaultStyledDocument doc, StyleContext sc)
JComboBox createFamilyChoices()

INNER CLASS:
class OpenAction extends AbstractAction
class SaveAction#ql:stp'SaveAction# extends AbstractAction
class NewAction extends AbstractAction
class ColoredSquare implements Icon

import java.awt.*; import java.awt.event.*; import java.net.URL; import java.util.Locale; import java.util.MissingResourceException; import java.util.ResourceBundle; import com.sun.java.swing.text.*; import com.sun.java.swing.*;
import java.io.*;

/** * Sample application using JTextPane. * * @author Timothy Prinzing * @version 1.26 10/06/97 */
public class Stylepad extends Notepad#ql:np'Notepad# {

stp'FIELDS:
private static ResourceBundle resources;
static { try { resources = ResourceBundle.getBundle("Stylepad", Locale.getDefault()); } catch (MissingResourceException mre) { System.err.println("Stylepad.properties not found"); System.exit(0); } }

public stp'Stylepad()
{ super#ql:np'notepad#(); }

public static void stp'main(String[] args)
{ String vers = System.getProperty("java.version"); if (vers.compareTo("1.1.2") < 0) { System.out.println("!!!WARNING: Swing must be run with a " + "1.1.2 or higher version VM!!!");
}
JFrame frame = new JFrame(); frame.setTitle(resources.getString("Title")); frame.setBackground(Color.lightGray); frame.getContentPane().setLayout(new BorderLayout());
frame.getContentPane().add("Center", new Stylepad#ql:stp'Stylepad#()); frame.addWindowListener(new AppCloser#ql:np'appcloser#());
frame.pack(); frame.setSize(600, 480); frame.show(); }

/** * Fetch the list of actions supported by this * editor. It is implemented to return the list * of actions supported by the superclass * augmented with the actions defined locally. */
public Action[] stp'getActions()
{ Action[] defaultActions = { new NewAction(), new OpenAction(), new SaveAction() };
return TextAction.augmentList(super.getActions(), defaultActions); }

/** * Try and resolve the resource name in the local * resource file, and if not found fall back to * the superclass resource file. */
protected String stp'getResourceString(String nm)
{ String str;
try { str = this.resources.getString(nm); }
catch (MissingResourceException mre) { str = super.getResourceString(nm); } return str; }

/** * Create an editor to represent the given document. */
protected JTextComponent stp'createEditor()
{
StyleContext#ql::API12.NFO:class.StyleContext# sc = new StyleContext();
DefaultStyledDocument#ql::API12.NFO:class.DefaultStyledDocument# doc = new DefaultStyledDocument(sc);
initDocument#ql:stp'initDocument#(doc, sc);
return new JTextPane#ql::API12.NFO:class.JTextPane#(doc); }

/** * Create a menu for the app. This is redefined to trap * a couple of special entries for now. */
protected JMenu stp'createMenu(String key)
{ if (key.equals("color")) { return createColorMenu(); } return super.createMenu(key); }

// this will soon be replaced
JMenu stp'createColorMenu()
{ ActionListener a; JMenuItem mi; JMenu menu = new JMenu(getResourceString("color" + labelSuffix)); mi = new JMenuItem(resources.getString("Red")); mi.setHorizontalTextPosition(JButton.RIGHT); mi.setIcon(new ColoredSquare(Color.red)); a = new StyledEditorKit.ForegroundAction("set-foreground-red", Color.red); //a = new ColorAction(se, Color.red); mi.addActionListener(a); menu.add(mi); mi = new JMenuItem(resources.getString("Green")); mi.setHorizontalTextPosition(JButton.RIGHT); mi.setIcon(new ColoredSquare(Color.green)); a = new StyledEditorKit.ForegroundAction("set-foreground-green", Color.green); //a = new ColorAction(se, Color.green); mi.addActionListener(a); menu.add(mi); mi = new JMenuItem(resources.getString("Blue")); mi.setHorizontalTextPosition(JButton.RIGHT); mi.setIcon(new ColoredSquare(Color.blue)); a = new StyledEditorKit.ForegroundAction("set-foreground-blue", Color.blue); //a = new ColorAction(se, Color.blue); mi.addActionListener(a); menu.add(mi);
return menu; }

void stp'initDocument(DefaultStyledDocument doc, StyleContext sc)
{
Wonderland w = new Wonderland#ql:stp'w'Wonderland#(doc, sc);
Icon alice = new ImageIcon(resources.getString("aliceGif"));
w.loadDocument#ql:stp'w'loadDocument#(); }

JComboBox createFamilyChoices()
{ JComboBox b = new JComboBox(); String[] fonts = getToolkit().getFontList(); for (int i = 0; i < fonts.length; i++) { b.addItem(fonts[i]); } return b; }

/** * Trys to read a file which is assumed to be a * serialization of a document. */
class stp'OpenAction extends AbstractAction
{

OpenAction() { super(openAction); }

public void actionPerformed(ActionEvent e) { Frame frame = getFrame(); if (fileDialog == null) { fileDialog = new FileDialog(frame); } fileDialog.setMode(FileDialog.LOAD); fileDialog.show(); String file = fileDialog.getFile(); if (file == null) { return; } String directory = fileDialog.getDirectory(); File f = new File(directory, file); if (f.exists()) {
try { FileInputStream fin = new FileInputStream(f); ObjectInputStream istrm = new ObjectInputStream(fin);
Document doc = (Document) istrm.readObject(); getEditor().setDocument(doc);
frame.setTitle(file); validate(); }
catch (IOException io) { // should put in status panel System.err.println("IOException: " + io.getMessage()); } catch (ClassNotFoundException cnf) { // should put in status panel System.err.println("Class not found: " + cnf.getMessage()); } } else { // should put in status panel System.err.println("No such file: " + f); } } }

/** * Trys to write the document as a serialization. */
class stp'SaveAction extends AbstractAction
{
SaveAction() { super(saveAction); }
public void actionPerformed(ActionEvent e) {
Frame frame = getFrame();
if (fileDialog == null) { fileDialog = new FileDialog(frame); }
fileDialog.setMode(FileDialog.SAVE);
fileDialog.show();
String file = fileDialog.getFile();
if (file == null) { return; }
String directory = fileDialog.getDirectory();
File f = new File(directory, file);
try {
FileOutputStream fstrm = new FileOutputStream(f);
ObjectOutput ostrm = new ObjectOutputStream(fstrm);
ostrm.writeObject(getEditor().getDocument());
ostrm.flush(); }
catch (IOException io) { // should put in status panel System.err.println("IOException: " + io.getMessage()); }
} }

/** * Creates an empty document. */
class stp'NewAction extends AbstractAction
{
NewAction() { super(newAction); }
public void actionPerformed(ActionEvent e) { getEditor().setDocument(new DefaultStyledDocument()); validate(); } }

class stp'ColoredSquare implements Icon
{ Color color; public ColoredSquare(Color c) { this.color = c; }
public void paintIcon(Component c, Graphics g, int x, int y) { Color oldColor = g.getColor(); g.setColor(color); g.fill3DRect(x,y,getIconWidth(), getIconHeight(), true); g.setColor(oldColor); } public int getIconWidth() { return 12; } public int getIconHeight() { return 12; }
} }

stp'WONDERLAND.JAVA

name::
* McsEngl.stp'WONDERLAND.JAVA@cptItsoft,

import java.util.Locale; import java.util.MissingResourceException; import java.util.ResourceBundle;
import java.net.URL; import java.util.Hashtable; import java.awt.Color; import com.sun.java.swing.*; import com.sun.java.swing.text.*;

/** * hack to load attributed content */
public class Wonderland {

stp'w'Wonderland(DefaultStyledDocument doc, StyleContext styles)
{ this.doc = doc; this.styles = styles; runAttr = new Hashtable(); }

void stp'w'loadDocument()
{ createStyles#ql:stp'w'createStyles#();
for (int i = 0; i < data#ql:stp'w'fields data#.length; i++)
{ Paragraph p = data[i]; addParagraph#ql:stp'w'addParagraph#(p); }
}

void stp'w'addParagraph(Paragraph p)
{ try { Style s = null;
for (int i = 0; i < p.data.length; i++)
{ Run run = p.data[i]; s = (Style) runAttr.get(run.attr); doc.insertString#ql::API12.NFO:class.defaultstyleddocument#(doc.getLength(), run.content, s); //offset, string, attribute
}
// set logical style
Style ls = styles.getStyle(p.logical); doc.setLogicalStyle#ql::API12.NFO:setLogicalStyle rl5#(doc.getLength() - 1, ls); doc.insertString(doc.getLength(), "\n", null); } catch (BadLocationException e) { System.err.println("Internal error: " + e); } }

void stp'w'createStyles()
{ // no attributes defined
Style#ql::API12.NFO:interface.style# s = styles#ql:stp'w'fields styles#.addStyle(null, null);
runAttr.put("none", s);

s = styles.addStyle(null, null);
StyleConstants#ql::API12.NFO:class.StyleConstants#.setItalic(s, true);
StyleConstants.setForeground(s, new Color(153,153,102));
runAttr.put("cquote", s); // catepillar quote
s = styles.addStyle(null, null);
StyleConstants.setItalic(s, true);
StyleConstants.setForeground(s, new Color(51,102,153));
runAttr.put("aquote", s); // alice quote

try { ResourceBundle resources = ResourceBundle.getBundle("Stylepad", Locale.getDefault()); s = styles.addStyle(null, null); Icon alice = new ImageIcon(resources.getString("aliceGif")); StyleConstants.setIcon(s, alice); runAttr.put("alice", s); // alice
s = styles.addStyle(null, null); Icon caterpillar = new ImageIcon(resources.getString("caterpillarGif")); StyleConstants.setIcon(s, caterpillar); runAttr.put("caterpillar", s); // caterpillar
s = styles.addStyle(null, null); Icon hatter = new ImageIcon(resources.getString("hatterGif")); StyleConstants.setIcon(s, hatter); runAttr.put("hatter", s); // hatter }
catch (MissingResourceException mre) { // can't display image }
Style def = styles.getStyle(StyleContext.DEFAULT_STYLE);
Style heading = styles.addStyle("heading", def); StyleConstants.setFontFamily(heading, "Helvetica"); StyleConstants.setBold(heading, true); StyleConstants.setAlignment(heading, StyleConstants.ALIGN_CENTER); StyleConstants.setSpaceAbove(heading, 10); StyleConstants.setSpaceBelow(heading, 10); StyleConstants.setFontSize(heading, 18);
// Title
Style sty = styles.addStyle("title", heading);
StyleConstants.setFontSize(sty, 32);
// edition
sty = styles.addStyle("edition", heading); StyleConstants.setFontSize(sty, 16);
// author sty = styles.addStyle("author", heading); StyleConstants.setItalic(sty, true); StyleConstants.setSpaceBelow(sty, 25);
// subtitle sty = styles.addStyle("subtitle", heading); StyleConstants.setSpaceBelow(sty, 35);
// normal sty = styles.addStyle("normal", def); StyleConstants.setLeftIndent(sty, 10); StyleConstants.setRightIndent(sty, 10); StyleConstants.setFontFamily(sty, "Helvetica"); StyleConstants.setFontSize(sty, 14); StyleConstants.setSpaceAbove(sty, 4); StyleConstants.setSpaceBelow(sty, 4); }

static class stp'w'Paragraph
{

Paragraph(String logical, Run[] data)
{ this.logical = logical; this.data = data;
}

String logical;
Run[] data;
}

static class stp'w'Run
{
Run(String attr, String content)
{ this.attr = attr; this.content = content;
}
String attr; String content; }

stp'w'FIELDS:
DefaultStyledDocument doc;
StyleContext styles;
Hashtable runAttr;

Paragraph[] data = new Paragraph#ql:stp'w'Paragraph#[] {

new Paragraph("title", new Run[] {new Run("none", "ALICE'S ADVENTURES IN WONDERLAND") }),

new Paragraph("author", new Run[] { new Run("none", "Lewis Carroll") }),

new Paragraph("heading", new Run[] { new Run("alice", " ") }),

new Paragraph("edition", new Run[] { new Run("none", "THE MILLENNIUM FULCRUM EDITION 3.0") }),
new Paragraph("heading", new Run[] { new Run("none", "CHAPTER V") }),
new Paragraph("subtitle", new Run[] { new Run("none", "Advice from a Caterpillar") }),
new Paragraph("normal", new Run[] { new Run("none", " "), }),
new Paragraph("normal", new Run[] { new Run("none", "The Caterpillar and Alice looked at each other for some time in silence: at last the Caterpillar took the hookah out of its mouth, and addressed her in a languid, sleepy voice.") }),
new Paragraph("normal", new Run[] { new Run("cquote", "Who are YOU? "), new Run("none", "said the Caterpillar.") }),

new Paragraph("normal", new Run[] { new Run("none", "This was not an encouraging opening for a conversation. Alice replied, rather shyly, "), new Run("aquote", "I--I hardly know, sir, just at present--at least I know who I WAS when I got up this morning, but I think I must have been changed several times since then. "), }),

new Paragraph("heading", new Run[] { new Run("caterpillar", " ") }),

new Paragraph("normal", new Run[] {
new Run("cquote", "What do you mean by that? "),
new Run("none", " said the Caterpillar sternly. "),
new Run("cquote", "Explain yourself!"), }),

new Paragraph("normal", new Run[] { new Run("aquote", "I can't explain MYSELF, I'm afraid, sir"), new Run("none", " said Alice, "), new Run("aquote", "because I'm not myself, you see."), }), new Paragraph("normal", new Run[] { new Run("cquote", "I don't see,"), new Run("none", " said the Caterpillar."), }), new Paragraph("normal", new Run[] { new Run("aquote", "I'm afraid I can't put it more clearly, "), new Run("none", "Alice replied very politely, "), new Run("aquote", "for I can't understand it myself to begin with; and being so many different sizes in a day is very confusing."), }), new Paragraph("normal", new Run[] { new Run("cquote", "It isn't, "), new Run("none", "said the Caterpillar.") }), new Paragraph("normal", new Run[] { new Run("aquote", "Well, perhaps you haven't found it so yet,"), new Run("none", " said Alice; "), new Run("aquote", "but when you have to turn into a chrysalis--you will some day, you know--and then after that into a butterfly, I should think you'll feel it a little queer, won't you?") }), new Paragraph("normal", new Run[] { new Run("cquote", "Not a bit, "), new Run("none", "said the Caterpillar.") }), new Paragraph("normal", new Run[] { new Run("aquote", "Well, perhaps your feelings may be different,"), new Run("none", " said Alice; "), new Run("aquote", "all I know is, it would feel very queer to ME."), }), new Paragraph("normal", new Run[] { new Run("cquote", "You!"), new Run("none", " said the Caterpillar contemptuously. "), new Run("cquote", "Who are YOU?"), }), new Paragraph("normal", new Run[] { new Run("normal", "Which brought them back again to the beginning of the conversation. Alice felt a little irritated at the Caterpillar's making such VERY short remarks, and she drew herself up and said, very gravely, "), new Run("aquote", "I think, you ought to tell me who YOU are, first."), }), new Paragraph("normal", new Run[] { new Run("cquote", "Why? "), new Run("none", "said the Caterpillar."), }), new Paragraph("heading", new Run[] { new Run("hatter", " ") }), new Paragraph("normal", new Run[] { new Run("none", " "), }), new Paragraph("normal", new Run[] { new Run("none", " "), }), new Paragraph("normal", new Run[] { new Run("none", " "), }) };

}

jvp.TREE.NIKOS (ntr)

_CREATED: 1997dec11

name::
* McsEngl.jvp.TREE.NIKOS (ntr)@cptItsoft,

FUNCTION:
Creates a tree with predefind nodes. From a menu you can add, insert, remove nodes.
It consists of ONE source file, NikosTree.java.

CLASSES:
NikosTree.class

FILES:
NikosTree.java

ntr'METHODS:
public NikosTree()
private JMenuBar constructMenuBar()
protected DefaultMutableTreeNode getSelectedNode()
protected DefaultMutableTreeNode createNewNode(String name)
static public void main#ql:ntr'main#(String args[])

INNER CLASSES:
class AddAction extends Object implements ActionListener
class InsertAction extends Object implements ActionListener
class ReloadAction extends Object implements ActionListener

=============== CODE ===============

import com.sun.java.swing.*; import com.sun.java.swing.event.*; import com.sun.java.swing.tree.*; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Dimension; import java.awt.FlowLayout; import java.awt.Font; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent;

public class NikosTree {

ntr'FIELDS:
protected JFrame frame;
protected JTree tree;
protected DefaultTreeModel treeModel;

public ntr'NikosTree() {
JMenuBar menuBar = constructMenuBar#ql:ntr'constructMenuBar#();
JPanel panel = new JPanel(true);
frame = new JFrame("NikosTree");
frame.getContentPane().add("Center", panel);
frame.setJMenuBar(menuBar);
frame.setBackground(Color.lightGray);
/* Create the JTreeModel. */
DefaultMutableTreeNode root = createNewNode#ql:ntr'createNewNode#("111");
treeModel = new DefaultTreeModel(root); treeModel.insertNodeInto(createNewNode("222"), root, 0); DefaultMutableTreeNode nik3 = createNewNode("333"); treeModel.insertNodeInto(nik3, root, 1); treeModel.insertNodeInto(createNewNode("555"), nik3, 0); treeModel.insertNodeInto(createNewNode("666"), nik3, 1); treeModel.insertNodeInto(createNewNode("777"), nik3, 2); treeModel.insertNodeInto(createNewNode("444"), root, 2);
tree = new JTree(treeModel);
/* Make tree ask for the height of each row. */
tree.setRowHeight(-1);
/* Put the Tree in a scroller. */
JScrollPane sp = new JScrollPane#ql::API12.NFO:class.JScrollPane#();
sp.setPreferredSize(new Dimension(500, 300));
sp.getViewport().add(tree); /* And show it. */ panel.setLayout(new BorderLayout());
panel.add("Center", sp);
frame.addWindowListener( new WindowAdapter() {public void windowClosing(WindowEvent e) {System.exit(0);} } );
frame.pack(); frame.show(); }

/** Construct a menu. */
private JMenuBar ntr'constructMenuBar()
{
JMenu menu;
JMenuBar menuBar = new JMenuBar();
JMenuItem menuItem;
/* Good ol exit. */
menu = new JMenu("File"); menuBar.add(menu);
menuItem = menu.add(new JMenuItem("Exit")); menuItem.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {System.exit(0); }});
/* Tree related stuff. */
menu = new JMenu("Tree"); menuBar.add(menu);
menuItem = menu.add(new JMenuItem("Add")); menuItem.addActionListener(new AddAction());
menuItem = menu.add(new JMenuItem("Insert")); menuItem.addActionListener(new InsertAction());
menuItem = menu.add(new JMenuItem("Reload")); menuItem.addActionListener(new ReloadAction());
menuItem = menu.add(new JMenuItem("Remove")); menuItem.addActionListener(new RemoveAction());
return menuBar; }

protected DefaultMutableTreeNode ntr'getSelectedNode()
{
TreePath selPath = tree.getSelectionPath();
if(selPath != null) return (DefaultMutableTreeNode)selPath.getLastPathComponent();
return null; }

protected DefaultMutableTreeNode ntr'createNewNode(String name)
{ return new DefaultMutableTreeNode#ql:DefaultMutableTreeNode:API12.NFO#(name); }

/** * AddAction is used to add a new item AFTER the selected item. */
class ntr'AddAction
extends Object
implements ActionListener
{
/** Number of nodes that have been added. */
public int addCount;
public void actionPerformed(ActionEvent e) {
int newIndex;
DefaultMutableTreeNode lastItem = getSelectedNode(); DefaultMutableTreeNode parent;
/* Determine where to create the new node. */ if(lastItem != null) parent = (DefaultMutableTreeNode)lastItem.getParent(); else parent = (DefaultMutableTreeNode)treeModel.getRoot(); if(lastItem == null) newIndex = treeModel.getChildCount(parent); else newIndex = parent.getIndex(lastItem) + 1;
/* Let the treemodel know. */
treeModel.insertNodeInto(createNewNode("Added "+Integer.toString(addCount++)), parent, newIndex); } } // End of NikosTree.AddAction

/** * InsertAction is used to insert a new item before the selected item. */
class ntr'InsertAction extends Object implements ActionListener {
/** Number of nodes that have been added. */ public int insertCount;
/** * Messaged when the user clicks on the Insert menu item. * Determines the selection from the Tree and inserts an item * after that. If nothing is selected, an item is added to * the root. */ public void actionPerformed(ActionEvent e) { int newIndex; DefaultMutableTreeNode lastItem = getSelectedNode(); DefaultMutableTreeNode parent;
/* Determine where to create the new node. */ if(lastItem != null) parent = (DefaultMutableTreeNode)lastItem.getParent(); else parent = (DefaultMutableTreeNode)treeModel.getRoot(); if(lastItem == null) newIndex = treeModel.getChildCount(parent); else newIndex = parent.getIndex(lastItem);
/* Let the treemodel know. */ treeModel.insertNodeInto(createNewNode("Inserted " + Integer.toString(insertCount++)), parent, newIndex); } } // End of NikosTree.InsertAction

/** * ReloadAction is used to reload from the selected node. If nothing * is selected, reload is not issued. */
class ntr'ReloadAction extends Object implements ActionListener { /** * Messaged when the user clicks on the Reload menu item. * Determines the selection from the Tree and asks the treemodel * to reload from that node. */ public void actionPerformed(ActionEvent e) { DefaultMutableTreeNode lastItem = getSelectedNode(); if(lastItem != null) treeModel.reload(lastItem); } } // End of NikosTree.ReloadAction

/** * RemoveAction removes the selected node from the tree. If * The root or nothing is selected nothing is removed. */
class ntr'RemoveAction extends Object implements ActionListener { /** * Removes the selected item as long as it isn't root.

*/ public void actionPerformed(ActionEvent e) { DefaultMutableTreeNode lastItem = getSelectedNode(); if(lastItem != null && lastItem != (DefaultMutableTreeNode)treeModel.getRoot()) { treeModel.removeNodeFromParent(lastItem); } } } // End of NikosTree.RemoveAction

static public void ntr'main(String args[])
{ new NikosTree#ql:ntr'NikosTree#(); }

}

jvp.XML.AELFRED (zlf)

name::
* McsEngl.jvp.XML.AELFRED (zlf)@cptItsoft,

FUNCTION:
It is a XML parser.

VERSION:
Version: 1.0beta3

AUTHOR:
Copyright (c) 1997 by Microstar Software Ltd., written by David Megginson <dmeggins@microstar.com>

SOURCE'FILES:
XmlParser.java
XmlProcessor.java: interface
------------------------
XmlApp#ql:zlf'xmlapp.java#.java: implements XmlProcessor

HOW TO USE IT:
File here = new File(".");
URL baseURL, docURL;
baseURL = new URL("file", "localhost", here.getAbsolutePath());
docURL = new URL(baseURL, xmlFile);
XmlParser parser = new XmlParser(null, docURL);
XmlApp processor = new XmlApp();
parser.run(processor);

URL createURL(String fileName)
{ URL url = null;
try { url = new URL(fileName); }

catch (MalformedURLException ex)
{ File f = new File(fileName);
try { String path = f.getAbsolutePath();
// This is a bunch of weird code that is required to make a valid URL on the Windows platform, due to inconsistencies in what getAbsolutePath returns.
String fs = System.getProperty("file.separator");
if (fs.length() == 1)
{ char sep = fs.charAt(0);
if (sep != '/') path = path.replace(sep, '/');
if (path.charAt(0) != '/') path = '/' + path;
} path = "file://" + path; url = new URL(path); }
catch (MalformedURLException e)
{ System.out.println("Cannot create url for: " + fileName); System.exit(0); }
} return url; }

zlf'XmlParser.java (xp)

name::
* McsEngl.zlf'XmlParser.java (xp)@cptItsoft,

// XmlParser.java: the main parser class.// NO WARRANTEE! See README, and copyright below.// $Id: XmlParser.java,v 1.54 1997/12/10 22:00:23 david Exp david $

zlf'xp'METHODS:
** public XmlParser#ql:zlf'xp'XmlParser#(): Zero-argument constructor.
** public XmlParser#ql:zlf'xp'xmlparser url#(String, URL): Construct a new XML parser for a specific document. The URL that contains the root of the XML document.

** void checkEncoding#ql:zlf'xp'checkEncoding# (String encodingName)
** void cleanupVariables#ql:zlf'xp'cleanupVariables# ()
** void copyUcs2ReadBuffer#ql:zlf'xp'copyUcs2ReadBuffer# (int count, int shift1, int shift2)
** void copyUcs4ReadBuffer#ql:zlf'xp'copyUcs4ReadBuffer# (int count, int shift1, int shift2, int shift3, int shift4)
** void copyUtf8ReadBuffer#ql:zlf'xp'copyUtf8ReadBuffer# (int count) throws IOException
** void copyIso8859_1ReadBuffer#ql:zlf'xp'copyIso8859# (int count)
** void dataBufferAppend#ql:zlf'xp'dataBufferAppend# (char c)
** void dataBufferAppend (char ch[], int start, int length)
** void dataBufferAppend (String s)
** void dataBufferFlush#ql:zlf'xp'dataBufferFlush#(): flush the characters of dataBuffer to processor
** void dataBufferNormalize#ql:zlf'xp'dataBufferNormalize# ()
** String dataBufferToString#ql:zlf'xp'dataBufferToString# ()
** public Enumeration declaredAttributes#ql:zlf'xp'declaredAttributes# (String name): Get the declared attributes for an element type.
** public Enumeration declaredElements#ql:zlf'xp'declaredElements#(): return An enumeration of all element types declared for this document (as Strings).
** public Enumeration declaredEntities#ql:zlf'xp'declaredEntities#() Get declared entities.
** public Enumeration declaredNotations#ql:zlf'xp'declaredNotations#() Get declared notations.
** void detectEncoding#ql:zlf'xp'detectEncoding# () throws IOException
** void error#ql:zlf'xp'error# (String message, String textFound, String textExpected)
** void error (String message, char textFound, String textExpected)
** char[] extendBuffer#ql:zlf'xp'extendBuffer# (char buffer[], int newCapacity)
** void filterCR#ql:zlf'xp'filterCR# ()
** Object[] getAttribute#ql:zlf'xp'getAttribute# (String elName, String name)
** public String getAttributeDefaultValue#ql:zlf'xp'getAttributeDefaultValue#(String, String) Retrieve the default value of a declared attribute.
** public int getAttributeDefaultValueType#ql:zlf'xp'getAttributeDefaultValueType# (String, String) Retrieve the default value type of a declared attribute.
** public String getAttributeEnumeration#ql:zlf'xp'getAttributeEnumeration#(String, String) Retrieve the allowed values for an enumerated attribute type.
** public String getAttributeExpandedValue#ql:zlf'xp'getAttributeExpandedValue#(String, String) Retrieve the expanded value of a declared attribute.
** public int getAttributeType#ql:zlf'xp'getAttributeType#(String, String) Retrieve the declared type of an attribute.
** Hashtable getElementAttributes#ql:zlf'xp'getElementAttributes# (String name)
** public String getElementContentModel#ql:zlf'xp'getElementContentModel#(String) Look up the content model of an element.
** public int getElementContentType#ql:zlf'xp'getElementContentType#(String) Look up the content type of an element.
** public String getEntityNotationName#ql:zlf'xp'getEntityNotationName#(String) Get the notation name associated with an NDATA entity.
** public String getEntityPublicId#ql:zlf'xp'getEntityPublicId#(String) Return an external entity's public identifier, if any.
** public URL getEntitySystemId#ql:zlf'xp'getEntitySystemId#(String) Return an external entity's system identifier.
** public int getEntityType#ql:zlf'xp'getEntityType#(String) Find the type of an entity.
** public String getEntityValue#ql:zlf'xp'getEntityValue#(String) Return the value of an internal entity. eg: name= nk, value= Nikos Kasselouris
** int getNextUtf8Byte#ql:zlf'xp'getNextUtf8Byte# (int pos, int count) throws IOException
** public String getNotationPublicId#ql:zlf'xp'getNotationPublicId#(String) Look up the public identifier for a notation.
** public URL getNotationSystemId#ql:zlf'xp'getNotationSystemId#(String) Look up the system identifier for a notation.
** public XmlProcessor getProcessor#ql:zlf'xp'getProcessor#() Return the processor for this parser.
** public String getPublicId#ql:zlf'xp'getPublicId#() Get the public ID for this processor.
** public URL getSystemId#ql:zlf'xp'getSystemId#() Get the system ID for this processor.
** void initializeVariables#ql:zlf'xp'initializeVariables# ()
** final boolean isWhitespace#ql:zlf'xp'isWhitespace# (char c)
** URL makeUrl#ql:zlf'xp'makeUrl# (String sysid) throws IOException

** void parseAttDef#ql:zlf'xp'parseAttDef# (String elementName) throws IOException
** void parseAttlistDecl#ql:zlf'xp'parseAttlistDecl# () throws IOException
** void parseAttribute#ql:zlf'xp'parseAttribute# (String name) throws IOException
** void parseCDSect#ql:zlf'xp'parseCDSect# () throws IOException
** void parseCharRef#ql:zlf'xp'parseCharRef# () throws IOException
** void parseComment#ql:zlf'xp'parseComment# () throws IOException
** void parseConditionalSect#ql:zlf'xp'parseConditionalSect# () throws IOException
** void parseContent#ql:zlf'xp'parseContent# () throws IOException
** void parseContentspec#ql:zlf'xp'parseContentspec# (String name) throws IOException
** void parseCp#ql:zlf'xp'parseCp# () throws IOException { char c;
** void parseDefault#ql:zlf'xp'parseDefault# (String elementName, String name, int type, String enum) throws IOException
** void parseDoctypedecl#ql:zlf'xp'parseDoctypedecl# () throws IOException
** void parseDocument#ql:zlf'xp'parseDocument# () throws IOException
** void parseElement#ql:zlf'xp'parseElement# () throws IOException
** void parseElements#ql:zlf'xp'parseElements# () throws IOException
** void parseElementdecl#ql:zlf'xp'parseElementdecl# () throws IOException
** void parseEnumeration#ql:zlf'xp'parseEnumeration# () throws IOException
** void parseEntityDecl#ql:zlf'xp'parseEntityDecl# () throws IOException
** void parseEntityRef#ql:zlf'xp'parseEntityRef# (boolean externalAllowed) throws IOException
** void parseEq#ql:zlf'xp'parseEq# () throws IOException: Parse an equals sign surrounded by optional whitespace.
** void parseETag#ql:zlf'xp'parseETag# () throws IOException
** void parseMarkupdecl#ql:zlf'xp'parseMarkupdecl# () throws IOException
** void parseMisc#ql:zlf'xp'parseMisc# () throws IOException
** void parseMixed#ql:zlf'xp'parseMixed# () throws IOException
** void parseNotationDecl () throws IOException
** void parseNotationType () throws IOException
** void parsePCData () throws IOException
** void parsePEReference () throws IOException
** void parsePI () throws IOException
** void parseProlog () throws IOException
** void parseTextDecl () throws IOException
** void parseXMLDecl#ql:zlf'xp'parseXMLDecl# () throws IOException

** void popInput () throws IOException
** void pushCharArray (String ename, char ch[], int length) throws IOException
** void pushInput (String ename)
** void pushString (String ename, String s) throws IOException
** void pushUrl (String ename, String publicId, URL systemId) throws IOException
** void parseUntil (String delim) throws IOException
** void read8bitEncodingDeclaration () throws IOException
** int readAttType () throws IOException
** char readCh () throws IOException
** void readDataChunk () throws IOException
** String[] readExternalIds (boolean inNotation) throws IOException
** String readLiteral (int flags) throws IOException
** String readNmtoken (boolean isName) throws IOException
** void require (char delim) throws IOException
** void require (String delim) throws IOException
** void requireWhitespace () throws IOException
** public void run#ql:zlf'xp'run#() Run a parse.
** public synchronized void run#ql:zlf'xp'run#(XmlProcessor) Parse an XML document.
** void setAttribute (String elName, String name, int type, String enumeration, String value, int valueType)
** void setElement (String name, int contentType, String contentModel, Hashtable attributes)
** void setEntity (String eName, int eClass, String pubid, URL sysid, String value, String nName)
** void setExternalDataEntity (String eName, String pubid, URL sysid, String nName)
** void setExternalTextEntity (String eName, String pubid, URL sysid)
** void setInternalEntity (String eName, String value)
** void setNotation (String nname, String pubid, URL sysid)
** public void setProcessor#ql:zlf'xp'setProcessor#(XmlProcessor) Set the processor for this parser.
** public void setPublicId#ql:zlf'xp'setPublicId#(String) Set the public ID for this parser.
** public void setSystemId#ql:zlf'xp'setSystemId#(URL) Set the system ID for this processor.
** void skipUntil (String delim) throws IOException
** void skipWhitespace () throws IOException
** boolean tryEncoding (byte sig[], byte b1, byte b2, byte b3, byte b4)
** boolean tryEncoding (byte sig[], byte b1, byte b2)
** void tryPEReference () throws IOException
** boolean tryRead (char delim) throws IOException
** boolean tryRead (String delim) throws IOException
** boolean tryWhitespace () throws IOException
** void unread (char c) throws IOException
** void unread (char ch[], int length) throws IOException
** void unread (String s) throws IOException

117 FUNCTIONS

================== CODE ====================

package com.microstar.xml;

import java.io.*;
import java.util.*;
import java.net.*;

/** * Parse XML documents and return parse events through call-backs. * @author Copyright (c) 1997 by Microstar Software Ltd. * @author written by David Megginson <dmeggins@microstar.com> * @version 1.0beta3 * @see XmlProcessor */

public class XmlParser implements Runnable#ql::2nfoJAPI11.NFO:interface.Runnable# {

////////////////////////////////////////////////////////////////////// // TODO: // - go over productions in new version of spec // - check that I am handling surrogates correctly. // - read encoding from HTTP header when available // - provide better reporting for character-encoding errors. //////////////////////////////////////////////////////////////////////

//zlf'xp'FIELDS:
// // Use special cheats that speed up the code (currently about 25%), // but may cause problems with future maintenance and add to the // class file size (about 400 bytes). //
private final static boolean USE_CHEATS = true;

////////////////////////////////////////////////////////////////////////
// Constants.
////////////////////////////////////////////////////////////////////////
// // Constants for element content-type#ql:xml'element'content#. //
/** * Constant: an element has not been declared. * @see#getElementContentType */
public final static int CONTENT_UNDECLARED = 0;
/** * Constant: the element has a content model of ANY. * @see#getElementContentType */
public final static int CONTENT_ANY = 1;
/** * Constant: the element has declared content of EMPTY. * @see#getElementContentType */
public final static int CONTENT_EMPTY = 2;
/** * Constant: the element has mixed content. * @see#getElementContentType */
public final static int CONTENT_MIXED = 3;
/** * Constant: the element has element content. * @see#getElementContentType */
public final static int CONTENT_ELEMENTS = 4;

// // Constants for the entity type. //
/** * Constant: the entity has not been declared. * @see#getEntityType */
public final static int ENTITY_UNDECLARED = 0;
/** * Constant: the entity is internal. * @see#getEntityType */
public final static int ENTITY_INTERNAL = 1;
/** * Constant: the entity is external, non-XML data. * @see#getEntityType */
public final static int ENTITY_NDATA = 2;
/** * Constant: the entity is external XML data. * @see#getEntityType */
public final static int ENTITY_TEXT = 3;

// // Constants for attribute type. //
/** * Constant: the attribute has not been declared for this element type. * @see#getAttributeType */
public final static int ATTRIBUTE_UNDECLARED = 0;
/** * Constant: the attribute value is a string value. * @see#getAttributeType */
public final static int ATTRIBUTE_CDATA = 1;
/** * Constant: the attribute value is a unique identifier. * @see#getAttributeType */
public final static int ATTRIBUTE_ID = 2;
/** * Constant: the attribute value is a reference to a unique identifier. * @see#getAttributeType */
public final static int ATTRIBUTE_IDREF = 3;
/** * Constant: the attribute value is a list of ID references. * @see#getAttributeType */
public final static int ATTRIBUTE_IDREFS = 4;
/** * Constant: the attribute value is the name of an entity. * @see#getAttributeType */
public final static int ATTRIBUTE_ENTITY = 5;
/** * Constant: the attribute value is a list of entity names. * @see#getAttributeType */
public final static int ATTRIBUTE_ENTITIES = 6;
/** * Constant: the attribute value is a name token. * @see#getAttributeType */
public final static int ATTRIBUTE_NMTOKEN = 7;
/** * Constant: the attribute value is a list of name tokens. * @see#getAttributeType */
public final static int ATTRIBUTE_NMTOKENS = 8;
/** * Constant: the attribute value is a token from an enumeration. * @see#getAttributeType */ public final static int ATTRIBUTE_ENUMERATED = 9;
/** * Constant: the attribute is the name of a notation. * @see#getAttributeType */
public final static int ATTRIBUTE_NOTATION = 10;

// // When the class is loaded, populate the hash table of // attribute types. //
/** * Hash table of attribute types. */
private static Hashtable attributeTypeHash;
static { attributeTypeHash = new Hashtable();
attributeTypeHash.put("CDATA", new Integer(ATTRIBUTE_CDATA)); attributeTypeHash.put("ID", new Integer(ATTRIBUTE_ID)); attributeTypeHash.put("IDREF", new Integer(ATTRIBUTE_IDREF)); attributeTypeHash.put("IDREFS", new Integer(ATTRIBUTE_IDREFS)); attributeTypeHash.put("ENTITY", new Integer(ATTRIBUTE_ENTITY)); attributeTypeHash.put("ENTITIES", new Integer(ATTRIBUTE_ENTITIES)); attributeTypeHash.put("NMTOKEN", new Integer(ATTRIBUTE_NMTOKEN)); attributeTypeHash.put("NMTOKENS", new Integer(ATTRIBUTE_NMTOKENS)); attributeTypeHash.put("NOTATION", new Integer(ATTRIBUTE_NOTATION)); }

// // Constants for supported encodings. //
private final static int ENCODING_UTF_8 = 1;
private final static int ENCODING_ISO_8859_1 = 2;
private final static int ENCODING_UCS_2_12 = 3;
private final static int ENCODING_UCS_2_21 = 4;
private final static int ENCODING_UCS_4_1234 = 5;
private final static int ENCODING_UCS_4_4321 = 6;
private final static int ENCODING_UCS_4_2143 = 7;
private final static int ENCODING_UCS_4_3412 = 8;

// // Constants for attribute default value. //
/** * Constant: the attribute is not declared. * @see#getAttributeDefaultValueType */
public final static int ATTRIBUTE_DEFAULT_UNDECLARED = 0;
/** * Constant: the attribute has a literal default value specified. * @see#getAttributeDefaultValueType * @see#getAttributeDefaultValue */
public final static int ATTRIBUTE_DEFAULT_SPECIFIED = 1;
/** * Constant: the attribute was declared#IMPLIED. * @see#getAttributeDefaultValueType */ public final static int ATTRIBUTE_DEFAULT_IMPLIED = 2;
/** * Constant: the attribute was declared#REQUIRED. * @see#getAttributeDefaultValueType */ public final static int ATTRIBUTE_DEFAULT_REQUIRED = 3;
/** * Constant: the attribute was declared#FIXED. * @see#getAttributeDefaultValueType * @see#getAttributeDefaultValue */
public final static int ATTRIBUTE_DEFAULT_FIXED = 4;

// // Constants for input. //
private final static int INPUT_NONE = 0;
private final static int INPUT_INTERNAL = 1;
private final static int INPUT_EXTERNAL = 2;

// // Flags for reading literals. //
private final static int LIT_CHAR_REF = 1;
private final static int LIT_ENTITY_REF = 2;
private final static int LIT_PE_REF = 4;
private final static int LIT_NORMALIZE = 8;

// The current XML processor interface. //
XmlProcessor processor;

// I/O information. //
private InputStream is; // current input stream
private int line; // current line number
private int sourceType; // type of input source
private Stack inputStack; // stack of input soruces
private URLConnection-2nfo\JAPI11.NFO#ql:class.URLConnection#, externalEntity; // current external entity
private int encoding; // current character encoding.

// Maintain a count'of'errors. //
private int errorCount;

// Buffers for decoded but unparsed character input. //
private final static int READ_BUFFER_MAX = 32768;
private char readBuffer[];
private int readBufferPos;
private int readBufferLength;
private int readBufferOverflow; // overflow character from last data chunk.

// Buffer for undecoded raw byte input. //
private byte rawReadBuffer[];

// Buffer for parsed character data. //
private static int DATA_BUFFER_INITIAL = 4096;
private char dataBuffer[];
private int dataBufferPos;

// Buffer for parsed names. //
private static int NAME_BUFFER_INITIAL = 1024;
private char nameBuffer[];
private int nameBufferPos;

// Hashtables for DTD information on elements, entities, and notations#ql:xml'notation'declaration#. //
private Hashtable elementInfo;
private Hashtable entityInfo;
private Hashtable notationInfo;

// Element type currently in force. //
private String currentElement;
private int currentElementContent;

// Base external identifiers for resolution. //
// publicId The public identifier for the root of the XML document, or null if there is no public identifier.
private String basePublicId = null;
// systemId The URL that contains the root of the XML document.
private URL baseSystemId;
private int baseEncoding;
// // Stack of entity names, to help detect recursion. //
private Stack entityStack;
// // Array of currently-recognised attributes. //
private String tagAttributes[];
private int tagAttributePos;
// // Utility flag: have we noticed a CR while reading the last // data chunk? If so, we will have to go back and normalise // CR/LF. //
private boolean sawCR;

/** * Zero-argument constructor. * * Before running the parser, you must supply at least a system ID * and a processor. * @see#setPublicId#ql:zlf'xp'setpublicid# * @see#setSystemId * @see#run() * @see#run(XmlProcessor) */

public zlf'xp'XmlParser ()
{ }

/** * Construct a new XML parser for a specific document. * The constructor will not actually open a connection to the URL * or start parsing -- use the run() method for that. * You must set a processor before calling run().
* @param publicId The public identifier for the root of the XML * document, or null if there is no public identifier.
* @param systemId The URL that contains the root of the XML document. * @see#run() * @see#run(XmlProcessor) */

public zlf'xp'XmlParser (String publicId, URL systemId)
{ this.basePublicId = publicId; this.baseSystemId = systemId; }

/** * Set the public ID for this parser. * You do not need to set a public ID to parse a document. * Throws an error if you have already set a public identifier.
* @param publicId The new public identifier. * @see#getPublicId */

public void zlf'xp'setPublicId (String publicId)
{ if (this.basePublicId == null) { basePublicId = publicId; } else { throw new Error("Public ID already set."); } }

/** * Get the public ID for this processor. * @return The public identifier, or null if none is set. * @see#setPublicId */

public String zlf'xp'getPublicId ()
{ return basePublicId#ql:zlf'xp'fields basePublicId#; }

/** * Set the system ID for this processor. * You must set a system ID before you can start * a parse. * Throws an error if you have already set a system identifier. * @param systemId The system identifier. * @see#getSystemId * @see#run */

public void zlf'xp'setSystemId (URL systemId)
{ if (baseSystemId == null) { baseSystemId = systemId; } else { throw new Error("System ID already set."); } }

/** * Get the system ID for this processor. * @return The system identifier. * @see#setSystemId */

public URL zlf'xp'getSystemId ()
{ return baseSystemId; }

/** * Set the processor for this parser. * You may change the processor at any time. * @param processor The processor to receive the parse events. * @see#getProcessor * @see#run() * @see#run(XmlProcessor) */

public void zlf'xp'setProcessor (XmlProcessor processor)
{ this.processor = processor; }

/** * Return the processor for this parser. * @return The processor, or null if none is set. * @see#setProcessor */

public XmlProcessor zlf'xp'getProcessor ()
{ return processor; }

/** * Run a parse. * You must set a system identifier and a processor before * invoking this method, or it will throw an error. * @see#run(XmlProcessor) * @see#setPublicId * @see#setSystemId * @see#setProcessor */

public void zlf'xp'run ()
{ if (processor == null) { throw new Error("must set a processor using setProcessor()"); } else { run(processor); } }

/** * Parse an XML document. * You may parse a document more than once, but only one thread * may call this method for an object at one time.
* @param processor The object that will receive the parse events. * @see#run() * @see#setPublicId * @see#setSystemId */

public synchronized void zlf'xp'run (XmlProcessor processor)
{
this.processor = processor;
if (baseSystemId == null) { throw new Error("must set a URL with setSystemId."); }
initializeVariables#ql:zlf'xp'initializeVariables#();
// Set the default entities here.
setInternalEntity#ql:zlf'xp'setInternalEntity#("amp", "&"); setInternalEntity("lt", "<"); setInternalEntity("gt", ">"); setInternalEntity("apos", "'"); setInternalEntity("quot", """);
processor.startDocument#ql:zlf'*'startdocument#(this, basePublicId, baseSystemId);
try
{ pushUrl#ql:zlf'xp'pushUrl#("[document]", null, baseSystemId); parseDocument#ql:zlf'xp'parseDocument#();
if (readBufferPos < readBufferLength || is.available() > 0) { error("end of XML document before end of input", null, null); }
}
catch (IOException e) { error(e.getMessage(), null, null); }
processor.endDocument#ql:zlf'*'endDocument#(this, errorCount); cleanupVariables#ql:zlf'xp'cleanupVariables#(); }

/////////////////// Error reporting. ////////////////////////////

/** * Report a serious error. * @param message The error message. * @param textFound The text that caused the error (or null). * @see XmlProcessor#error * @see#line */

void zlf'xp'error (String message, String textFound, String textExpected)
{ errorCount++;
processor.error(this, message, textFound, textExpected, externalEntity.getURL(), line); }

/** * Report a serious error. * @param message The error message. * @param textFound The text that caused the error (or null). */

void zlf'xp'error (String message, char textFound, String textExpected)
{ error(message, new Character(textFound).toString(), textExpected); }

///////////////// Major syntactic productions. ////////////////////////

/** * Parse an XML document. * <pre> * [1] document ::= prolog element Misc* * </pre> * This is the top-level parsing function for a single XML * document. As a minimum, a well-formed document must have * a document element, and a valid document must have a prolog * as well. */

void zlf'xp'parseDocument () throws IOException
{ char c;
parseProlog#ql:zlf'xp'parseProlog#();
require#ql:zlf'xp'require#('<');
parseElement#ql:zlf'xp'parseElement#();
try { parseMisc#ql:zlf'xp'parseMisc#(); }
catch (EOFException e) { return; }
}

/** * Parse a comment and discard its contents. * <pre> * [18] Comment ::= '" * </pre> * (The <code>"); }

/** * Parse a processing instruction and do a call-back. * <pre> * [19] PI ::= '<?' Name (S (Char* - (Char* '?>' Char*)))? '?>' * </pre> * (The <code><?</code> has already been read.) * An XML processing instruction must begin with * a Name, which is the instruction's target. */

void zlf'xp'parsePI () throws IOException
{ String name;
name = readNmtoken#ql:zlf'xp'readNmtoken#(true);
if (!tryRead("?>")) { requireWhitespace(); parseUntil("?>"); processor.processingInstruction#ql:zlf'*'processingInstruction#(this, name, dataBufferToString()); } }

/** * Parse a CDATA marked section. * <pre> * [20] CDSect ::= CDStart CData CDEnd * [21] CDStart ::= '<![CDATA[' * [22] CData ::= (Char* - (Char* ']]>' Char*)) * [23] CDEnd ::= ']]>' * </pre> * (The '<![CDATA[' has already been read.) * Note that this just appends characters to the dataBuffer, * without actually generating an event. */

void zlf'xp'parseCDSect () throws IOException
{ parseUntil#ql:zlf'xp'parseUntil#("]]>"); }

/* Parse the prolog of an XML document.
* [24] prolog ::= XMLDecl? Misc* (Doctypedecl Misc*)?
There are a couple of tricks here. First, it is necessary to * declare the XML default attributes after the DTD (if present) * has been read. Second, it is not possible to expand general * references in attribute value literals until after the entire * DTD (if present) has been parsed.
We do not look for the XML declaration here, because it is * handled by pushUrl(). * @see pushUrl */

void zlf'xp'parseProlog () throws IOException
{ parseMisc#ql:sxz'xp'parseMisc#();
if (tryRead#ql:zlf'xp'tryRead#("<!DOCTYPE")) { parseDoctypedecl#ql:zlf'xp'parseDoctypedecl#(); parseMisc(); } }

/** * Parse the XML declaration. * <pre> * [25] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' * [26] VersionInfo ::= S 'version' Eq ('"1.0"' | "'1.0'") * [33] SDDecl ::= S 'standalone' Eq "'" ('yes' | 'no') "'" * | S 'standalone' Eq '"' ("yes" | "no") '"' * [78] EncodingDecl ::= S 'encoding' Eq QEncoding * </pre> * ([80] to [82] are also significant.) * (The <code><?xml</code> and whitespace have already been read.) * TODO: validate value of standalone. * @see#parseTextDecl * @see#checkEncoding */

void zlf'xp'parseXMLDecl () throws IOException
{ String version; String encodingName = null; String standalone = null;
// Read the version.
require("version"); parseEq(); version = readLiteral(0); if (!version.equals("1.0")) { error("unsupported XML version", version, "1.0"); }
// Try reading an encoding declaration.
skipWhitespace();
if (tryRead("encoding")) { parseEq(); encodingName = readLiteral(0); checkEncoding(encodingName); }
// Try reading a standalone declaration
skipWhitespace();
if (tryRead("standalone")) { parseEq(); standalone = readLiteral(0); }
skipWhitespace(); require("?>"); }

/** * Parse the Encoding PI. * <pre> * [78] EncodingDecl ::= S 'encoding' Eq QEncoding * [79] EncodingPI ::= '<?xml' S 'encoding' Eq QEncoding S? '?>' * [80] QEncoding ::= '"' Encoding '"' | "'" Encoding "'" * [81] Encoding ::= LatinName * [82] LatinName ::= [A-Za-z] ([A-Za-z0-9._] | '-')* * </pre> * (The <code><?xml</code>' and whitespace have already been read.) * @see#parseXMLDecl * @see#checkEncoding */

void zlf'xp'parseTextDecl () throws IOException
{ String encodingName = null; // Read an optional version. if (tryRead("version")) { String version; parseEq(); version = readLiteral(0); if (!version.equals("1.0")) { error("unsupported XML version", version, "1.0"); } requireWhitespace(); }
// Read the encoding. require("encoding"); parseEq(); encodingName = readLiteral(0); checkEncoding(encodingName);
skipWhitespace(); require("?>"); }

/** * Check that the encoding specified makes sense. * Compare what the author has specified in the XML declaration * or encoding PI with what we have detected. * This is also important for distinguishing among the various * 7- and 8-bit encodings, such as ISO-LATIN-1 (I cannot autodetect * those). * @param encodingName The name of the encoding specified by the user. * @see#parseXMLDecl * @see#parseTextDecl */

void zlf'xp'checkEncoding (String encodingName)
{ encodingName = encodingName.toUpperCase();
switch (encoding#ql:zlf'xp'fields encoding#) {
// 8-bit encodings
case ENCODING_UTF_8:
if (encodingName.equals("ISO-8859-1")) { encoding = ENCODING_ISO_8859_1; } else if (!encodingName.equals("UTF-8")) { error("unsupported 8-bit encoding", encodingName, "UTF-8 or ISO-8859-1"); } break;

// 16-bit encodings
case ENCODING_UCS_2_12:
case ENCODING_UCS_2_21: if (!encodingName.equals("ISO-10646-UCS-2") && !encodingName.equals("UTF-16")) { error("unsupported 16-bit encoding", encodingName, "ISO-10646-UCS-2"); } break;

// 32-bit encodings
case ENCODING_UCS_4_1234:
case ENCODING_UCS_4_4321:
case ENCODING_UCS_4_2143:
case ENCODING_UCS_4_3412: if (!encodingName.equals("ISO-10646-UCS-4")) { error("unsupported 32-bit encoding", encodingName, "ISO-10646-UCS-4"); } } }

/** * Parse miscellaneous markup outside the document element and DOCTYPE * declaration. * <pre> * [27] Misc ::= Comment | PI | S * </pre> */

void zlf'xp'parseMisc () throws IOException
{ while (true) { skipWhitespace();
if (tryRead("<?")) { parsePI(); }
else if (tryRead("<!--")) { parseComment(); } else { return; } }
}

/** * Parse a document-type-declaration#ql:xml'ex.document'type'declaration#.
* [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' %markupdecl* ']' S?)? '>'
(The <!DOCTYPE has already been read.) */

void zlf'xp'parseDoctypedecl () throws IOException
{
char c;
String doctypeName, ids[];

// Read the document type name.
requireWhitespace#ql:sxz'xp'requireWhitespace#(); doctypeName = readNmtoken#ql:sxz'xp'readNmtoken#(true);

// Read the ExternalIDs.
skipWhitespace(); ids = readExternalIds#ql:sxz'xp'readExternalIds#(false);

// Look for a declaration subset.
skipWhitespace();
if (tryRead('[')) { // loop until the subset ends
while (true) { skipWhitespace();
if (tryRead(']')) { break; // end of subset } else { parseMarkupdecl(); } } }

// Read the external subset, if any
if (ids[1] != null) { pushUrl#ql:sxz'xp'pushUrl#("[external subset]", ids[0], makeUrl#ql:sxz'xp'makeUrl#(ids[1]));
// Loop until we end up back at '>'
while (true) { skipWhitespace(); if (tryRead('>')) { break; } else { parseMarkupdecl#ql:sxz'xp'parseMarkupdecl#(); } } }
else { // No external subset.
skipWhitespace(); require('>'); }

processor.doctypeDecl#ql:sxz'xa'doctypeDecl#(this, doctypeName, ids[0], ids[1]);
// Expand general entities in default values of attributes. (Do this after the doctypeDecl event!).
// expandAttributeDefaultValues(); }

/** * Parse a markup declaration in the internal or external DTD subset. * <pre> * [29] markupdecl ::= ( %elementdecl | %AttlistDecl | %EntityDecl | * %NotationDecl | %PI | %S | %Comment | * InternalPERef ) * [30] InternalPERef ::= PEReference * [31] extSubset ::= (%markupdecl | %conditionalSect)* * </pre> */

void zlf'xp'parseMarkupdecl () throws IOException
{ if (tryRead("<!ELEMENT")) { parseElementdecl(); }
else if (tryRead("<!ATTLIST")) { parseAttlistDecl(); }
else if (tryRead("<!ENTITY")) { parseEntityDecl(); }
else if (tryRead("<!NOTATION")) { parseNotationDecl(); }
else if (tryRead("<?")) { parsePI(); }
else if (tryRead("<!--")) { parseComment(); }
else if (tryRead("%")) { parsePEReference(); }
else if (tryRead("<![")) { parseConditionalSect(); }
else { error("expected markup declaration", null, null); } }

/** * Parse an element, with its tags. * <pre> * [33] STag ::= '<' Name (S Attribute)* S? '>' [WFC: unique Att spec] * [38] element ::= EmptyElement | STag content ETag * [39] EmptyElement ::= '<' Name (S Attribute)* S? '/>' * [WFC: unique Att spec] * </pre> * (The '<' has already been read.) * NOTE: this method actually chains onto parseContent(), if necessary, * and parseContent() will take care of calling parseETag(). */

void zlf'xp'parseElement () throws IOException
{ String gi; char c;
int oldElementContent = currentElementContent;
String oldElement = currentElement;
// This is the (global) counter for the array of specified attributes.
tagAttributePos = 0;
// Read the element type name.
gi = readNmtoken(true);
currentElement = gi;
currentElementContent = getElementContentType(gi);
// Read the attributes, if any. After this loop, we should be just in front of the closing delimiter.
skipWhitespace(); c = readCh();
while (c != '/' && c != '>')
{ unread(c); parseAttribute#ql:zlf'xp'parseAttribute#(gi); skipWhitespace(); c = readCh(); } unread(c);
// Supply any defaulted attributes.
Enumeration atts = declaredAttributes#ql:zlf'xp'declaredAttributes#(gi);
if (atts != null) { String aname; loop: while (atts.hasMoreElements()) { aname = (String)atts.nextElement(); // See if it was specified.
for (int i = 0; i < tagAttributePos; i++) { if (tagAttributes[i] == aname) { continue loop; } } // I guess not...

processor.attribute#ql:zlf'*'attribute#(this, aname, getAttributeExpandedValue(gi,aname), false); } }

// Figure out if this is a start tag or an empty element, and dispatch an event accordingly.
c = readCh();
switch (c) {
case '>': processor.startElement(this, gi); parseContent(); break;
case '/': require('>'); processor.startElement(this, gi); processor.endElement(this, gi); break; }
// Restore the previous state.
currentElement = oldElement;
currentElementContent = oldElementContent; }

/** * Parse an attribute#ql:xml'ex.attribute# assignment. * <pre> * [34] Attribute ::= Name Eq AttValue * </pre>
* @param name The name of the attribute's element. * @see XmlProcessor#attribute */

void zlf'xp'parseAttribute (String name) throws IOException
{ String aname; int type; String value;
// Read the attribute name.
aname = readNmtoken#ql:zlf'xp'readNmtoken#(true).intern#ql::2nfoJAPI11.NFO:intern rl5#();
type = getAttributeDefaultValueType(name, aname);
// Parse '='
parseEq();
// Read the value, normalizing whitespace // if it is not CDATA.
if (type == ATTRIBUTE_CDATA || type == ATTRIBUTE_UNDECLARED) { value = readLiteral(LIT_CHAR_REF | LIT_ENTITY_REF); }
else { value = readLiteral(LIT_CHAR_REF | LIT_ENTITY_REF | LIT_NORMALIZE); }
// Inform the processor about the attribute.
processor.attribute#ql:zlf'xpr'attribute#(this, aname, value, true);
// Note that the attribute has been // specified.
if (tagAttributePos == tagAttributes.length) { String newAttrib[] = new String[tagAttributes.length * 2]; System.arraycopy(tagAttributes, 0, newAttrib, 0, tagAttributePos); tagAttributes = newAttrib; } tagAttributes[tagAttributePos++] = aname; }

/** * Parse an equals sign surrounded by optional whitespace. * [35] Eq ::= S? '=' S? */

void zlf'xp'parseEq () throws IOException
{ skipWhitespace(); require('='); skipWhitespace(); }

/** * Parse an end tag. * [36] ETag ::= '</' Name S? '>' * *NOTE: parseContent() chains to here. */

void zlf'xp'parseETag () throws IOException
{ String name; name = readNmtoken(true);
if (!name.equals(currentElement#ql:zlf'xp'fields currentElement#)) { error("mismatched end tag", name, currentElement); }
skipWhitespace();
require('>');

processor.endElement(this, name); }

/** * Parse the content of an element.
* [37] content ::= (element | PCData | Reference | CDSect | PI | Comment)*
* [68] Reference ::= EntityRef | CharRef */

void zlf'xp'parseContent () throws IOException
{ String data; char c;
while (true) {
switch (currentElementContent)
{ case CONTENT_ANY:
case CONTENT_MIXED:
case CONTENT_UNDECLARED: parsePCData(); break;
case CONTENT_ELEMENTS: skipWhitespace(); break;
}
// Handle delimiters
c = readCh();
switch (c)
{ case '&': // Found "&" c = readCh(); if (c == '#') { parseCharRef(); } else { unread(c); parseEntityRef(true); } break;
case '<': // Found "<"
c = readCh(); switch (c)
{case '!': // Found "<!" c = readCh(); switch (c)
{ case '-': // Found "<!-" require('-'); parseComment(); break;
case '[': // Found "<![" require("CDATA["); parseCDSect(); break;
default: error("expected comment or CDATA section", c, null); break;
} break;
case '?': // Found "<?" dataBufferFlush(); parsePI(); break;
case '/': // Found "</" dataBufferFlush(); parseETag(); return;
default: // Found "<" followed by something else dataBufferFlush(); unread(c); parseElement(); break; } } } }

/** * Parse an element type declaration. * [40] elementdecl ::= '<!ELEMENT' S %Name S (%S S)? %contentspec S? '>' * [VC: Unique Element Declaration] * *NOTE: the '<!ELEMENT' has already been read. */

void zlf'xp'parseElementdecl () throws IOException
{ String name;
requireWhitespace();
// Read the element type name.
tryPEReference(); name = readNmtoken(true);
tryPEReference(); requireWhitespace();
// Read the content model.
tryPEReference(); parseContentspec(name);
skipWhitespace(); require#ql:zlf'xp'require#('>'); }

/** * Content specification. * [41] contentspec ::= 'EMPTY' | 'ANY' | Mixed | elements */

void zlf'xp'parseContentspec (String name) throws IOException
{ if (tryRead#ql:zlf'xp'tryRead#("EMPTY")) { setElement(name, CONTENT_EMPTY, null, null); return; } else if (tryRead("ANY")) { setElement(name, CONTENT_ANY, null, null); return; } else { require('('); dataBufferAppend('('); skipWhitespace(); tryPEReference(); if (tryRead("#PCDATA")) { dataBufferAppend("#PCDATA"); parseMixed(); setElement(name, CONTENT_MIXED, dataBufferToString(), null); } else { parseElements(); setElement(name, CONTENT_ELEMENTS, dataBufferToString(), null); } } }

/** * Parse an element-content model. * [42] elements ::= (choice | seq) ('?' | '*' | '+')? * [44] cps ::= S? %cp S? * [45] choice ::= '(' S? %ctokplus (S? '|' S? %ctoks)* S? ')' * [46] ctokplus ::= cps ('|' cps)+ * [47] ctoks ::= cps ('|' cps)* * [48] seq ::= '(' S? %stoks (S? ',' S? %stoks)* S? ')' * [49] stoks ::= cps (',' cps)* * *NOTE: the opening '(' and S have already been read. * *TODO: go over parameter entity boundaries more carefully. */

void zlf'xp'parseElements () throws IOException
{ char c; char sep;
// Parse the first content particle skipWhitespace(); tryPEReference(); parseCp();
// Check for end or for a separator. skipWhitespace(); c = readCh(); switch (c) { case ')': dataBufferAppend(')'); c = readCh(); switch (c) { case '*': case '+': case '?': dataBufferAppend(c); break; default: unread(c); } return; case ',': // Register the separator. case '|': sep = c; dataBufferAppend(c); break; default: error("bad separator in content model", c, null); return; }
// Parse the rest of the content model. while (true) { skipWhitespace(); tryPEReference(); parseCp(); skipWhitespace(); c = readCh(); if (c == ')') { dataBufferAppend(')'); break; } else if (c != sep) { error("bad separator in content model", c, null); return; } else { dataBufferAppend(c); } }
// Check for the occurrence indicator. c = readCh(); switch (c) { case '?': case '*': case '+': dataBufferAppend(c); return; default: unread(c); return; } }

/** * Parse a content-particle#ql:xmlnt'cp#.
* [43] cp ::= (Name | choice | seq) ('?' | '*' | '+') * *NOTE: I actually use a slightly different production here: * cp ::= (elements | (Name ('?' | '*' | '+')?)) */

void zlf'xp'parseCp () throws IOException
{ char c;
if (tryRead('(')) { dataBufferAppend('('); parseElements(); }
else { dataBufferAppend(readNmtoken(true)); c = readCh(); switch (c) { case '?': case '*': case '+': dataBufferAppend(c); break; default: unread(c); break; } } }

/** * Parse mixed content. * [50] Mixed ::= '(' S? %( %'#PCDATA' (S? '|' S? %Mtoks)* ) S? ')*' * | '(' S? %('#PCDATA') S? ')' * [51] Mtoks ::= %Name (S? '|' S? %Name)* * *NOTE: the S and '#PCDATA' have already been read. */

void zlf'xp'parseMixed () throws IOException
{ char c;
// Check for PCDATA alone. skipWhitespace(); if (tryRead(')')) { dataBufferAppend(")*"); if (tryRead('*')) { dataBufferAppend('*'); } return; }
// Parse mixed content. skipWhitespace(); while (!tryRead(")*")) { require('|'); dataBufferAppend('|'); skipWhitespace(); tryPEReference(); dataBufferAppend(readNmtoken(true)); skipWhitespace(); } dataBufferAppend(")*"); }

/** * Parse an attribute list declaration. * [52] AttlistDecl ::= '<!ATTLIST' S %Name S? %AttDef+ S? '>' * *NOTE: the '<!ATTLIST' has already been read. */

void zlf'xp'parseAttlistDecl () throws IOException
{ String elementName;
requireWhitespace#ql:zlf'xp'requireWhitespace#(); tryPEReference(); elementName = readNmtoken(true); requireWhitespace(); while (!tryRead('>')) { parseAttDef(elementName); skipWhitespace(); } }

/** * Parse a single attribute definition. * [53] AttDef ::= S %Name S %AttType S %Default */

void zlf'xp'parseAttDef (String elementName) throws IOException
{ String name; int type; String enum = null;
// Read the attribute name.
tryPEReference#ql:zlf'xp'tryPEReference#();
name = readNmtoken(true);
// Read the attribute type.
requireWhitespace(); tryPEReference(); type = readAttType();
// Get the string of enumerated values // if necessary.
if (type == ATTRIBUTE_ENUMERATED || type == ATTRIBUTE_NOTATION) { enum = dataBufferToString(); }
// Read the default value.
requireWhitespace(); tryPEReference(); parseDefault(elementName, name, type, enum); }

/** * Parse the attribute type. * [54] AttType ::= StringType | TokenizedType | EnumeratedType * [55] StringType ::= 'CDATA' * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | * 'NMTOKEN' | 'NMTOKENS' * [57] EnumeratedType ::= NotationType | Enumeration * *TODO: validate the type!! */

int zlf'xp'readAttType () throws IOException
{ String typeString; Integer type;
if (tryRead('(')) { parseEnumeration(); return ATTRIBUTE_ENUMERATED; } else { typeString = readNmtoken(true); if (typeString.equals("NOTATION")) { parseNotationType(); } type = (Integer)attributeTypeHash.get(typeString); if (type == null) { error("illegal attribute type", typeString, null); return ATTRIBUTE_UNDECLARED; } else { return type.intValue(); } } }

/** * Parse an enumeration. * [60] Enumeration ::= '(' S? %Etoks (S? '|' S? %Etoks)* S? ')' * [61] Etoks ::= %Nmtoken (S? '|' S? %Nmtoken)* * *NOTE: the '(' has already been read. */

void zlf'xp'parseEnumeration () throws IOException
{ char c;
dataBufferAppend('(');
// Read the first token. skipWhitespace(); tryPEReference(); dataBufferAppend(readNmtoken(true)); // Read the remaining tokens.
skipWhitespace(); while (!tryRead(')')) { require('|'); dataBufferAppend('|'); skipWhitespace(); tryPEReference(); dataBufferAppend(readNmtoken(true)); skipWhitespace(); } dataBufferAppend(')'); }

/** * Parse a notation type for an attribute. * [58] NotationType ::= %'NOTATION' S '(' S? %Ntoks (S? '|' S? %Ntoks)* * S? ')' * [59] Ntoks ::= %Name (S? '|' S? %Name) * *NOTE: the 'NOTATION' has already been read */

void zlf'xp'parseNotationType () throws IOException
{ requireWhitespace(); require('(');
parseEnumeration(); }

/** * Parse the default value for an attribute. * [62] Default ::= '#REQUIRED' | '#IMPLIED' | ((%'#FIXED' S)? %AttValue */

void zlf'xp'parseDefault (String elementName, String name, int type, String enum) throws IOException
{ int valueType = ATTRIBUTE_DEFAULT_SPECIFIED; String value = null; boolean normalizeWSFlag;
if (tryRead('#')) {
if (tryRead("FIXED")) { valueType = ATTRIBUTE_DEFAULT_FIXED; requireWhitespace(); value = readLiteral(LIT_CHAR_REF); }
else if (tryRead("REQUIRED")) { valueType = ATTRIBUTE_DEFAULT_REQUIRED; } else if (tryRead("IMPLIED")) { valueType = ATTRIBUTE_DEFAULT_IMPLIED; } else { error("illegal keyword for attribute default value", null, null); } } else { value = readLiteral(LIT_CHAR_REF); } setAttribute(elementName, name, type, enum, value, valueType); }

/** * Parse a conditional-section#ql:xml'conditional'section#. * [63] conditionalSect ::= includeSect || ignoreSect * [64] includeSect ::= '<![' %'INCLUDE' '[' (%markupdecl*)* ']]>' * [65] ignoreSect ::= '<![' %'IGNORE' '[' ignoreSectContents* ']]>' * [66] ignoreSectContents ::= ((SkipLit | Comment | PI) -(Char* ']]>')) * | ('<![' ignoreSectContents* ']]>') * | (Char - (']' | [<'"])) * | ('<!' (Char - ('-' | '['))) * *NOTE: the '<![' has already been read. * *TODO: verify that I am handling ignoreSectContents right. */

void zlf'xp'parseConditionalSect () throws IOException
{ tryPEReference(); if (tryRead("INCLUDE")) { skipWhitespace(); while (!tryRead("]]>")) { tryPEReference(); parseMarkupdecl(); skipWhitespace(); } } else if (tryRead("IGNORE")) { int nesting = 1; char c; for (int nest = 1; nest > 0; ) { c = readCh(); switch (c) { case '<': if (tryRead("![")) { nest++; } case ']': if (tryRead("]>")) { nest--; } } } } }

/** * Read a character-reference#ql:xml'ex.character'referece#.
* [67] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';' * *NOTE: the '&#' has already been read. */

void zlf'xp'parseCharRef () throws IOException
{ int value = 0; char c;
if (tryRead('x')) { loop1: while (true) { c = readCh(); switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'a': case 'A': case 'b': case 'B': case 'c': case 'C': case 'd': case 'D': case 'e': case 'E': case 'f': case 'F': value *= 16; value += Integer.parseInt(new Character(c).toString(), 16); break; case ';': break loop1; default: error("illegal character in character reference", c, null); break loop1; } } }

else { loop2: while (true) { c = readCh(); switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': value *= 10; value += Integer.parseInt(new Character(c).toString(), 10); break; case ';': break loop2; default: error("illegal character in character reference", c, null); break loop2; } } }
// Check for surrogates: 00000000 0000xxxx yyyyyyyy zzzzzzzz // (1101|10xx|xxyy|yyyy + 1101|11yy|zzzz|zzzz:
if (value <= 0x0000ffff) { // no surrogates needed dataBufferAppend((char)value); }
else if (value <= 0x000fffff) { // > 16 bits, surrogate needed dataBufferAppend((char)(0xd8 | ((value & 0x000ffc00) >> 10))); dataBufferAppend((char)(0xdc | (value & 0x0003ff))); }
else { // too big for surrogate error("character reference " + value + " is too large for UTF-16", new Integer(value).toString(), null); } }

/** * Parse a reference. * [69] EntityRef ::= '&' Name ';' * *NOTE: the '&' has already been read. * @param externalAllowed External entities are allowed here. */

void zlf'xp'parseEntityRef (boolean externalAllowed) throws IOException
{ String name;
name = readNmtoken(true); require(';'); switch (getEntityType(name)) { case ENTITY_UNDECLARED: error("reference to undeclared entity", name, null); break; case ENTITY_INTERNAL: pushString(name, getEntityValue(name)); break; case ENTITY_TEXT: if (externalAllowed) { pushUrl(name, getEntityPublicId(name), getEntitySystemId(name)); } else { error("reference to external entity in attribute value.", name, null); } break; case ENTITY_NDATA: if (externalAllowed) { error("data entity reference in content", name, null); } else { error("reference to external entity in attribute value.", name, null); } break; } }

/** * Parse a parameter entity reference. * [70] PEReference ::= '%' Name ';' * *NOTE: the '%' has already been read. */

void zlf'xp'parsePEReference () throws IOException
{ String name;
name = "%" + readNmtoken(true); require(';'); switch (getEntityType(name)) { case ENTITY_UNDECLARED: error("reference to undeclared entity", name, null); break; case ENTITY_INTERNAL: pushString(name, getEntityValue(name)); break; case ENTITY_TEXT: pushUrl(name, getEntityPublicId(name), getEntitySystemId(name)); break; } }

/** * Look for an optional PEReference. */

void zlf'xp'tryPEReference () throws IOException
{ if (tryRead#ql:zlf'xp'tryRead#('%')) { parsePEReference(); } }

/** * Parse an entity declaration. * [71] EntityDecl ::= '<!ENTITY' S %Name S %EntityDef S? '>' * | '<!ENTITY' S '%' S %Name S %EntityDef S? '>' * [72] EntityDef ::= EntityValue | ExternalDef * [73] ExternalDef ::= ExternalID %NDataDecl? * [74] ExternalID ::= 'SYSTEM' S SystemLiteral * | 'PUBLIC' S PubidLiteral S SystemLiteral * [75] NDataDecl ::= S %'NDATA' S %Name * *NOTE: the '<!ENTITY' has already been read. */

void zlf'xp'parseEntityDecl () throws IOException
{ char c; boolean peFlag = false; String name, value, notationName, ids[];
// Check for a parameter entity.
requireWhitespace(); if (tryRead('%')) { peFlag = true; requireWhitespace(); }
// Read the entity name, and prepend '%' if necessary.
tryPEReference(); name = readNmtoken(true); if (peFlag) { name = "%" + name; }
// Read the entity value.
requireWhitespace(); tryPEReference(); c = readCh(); unread(c);
if (c == '"' || c == '\'') { // Internal entity. value = readLiteral(LIT_CHAR_REF|LIT_PE_REF); setInternalEntity(name,value); }
else { // Read the external IDs ids = readExternalIds(false); if (ids[1] == null) { error("system identifer missing", name, null); }
// Check for NDATA declaration. skipWhitespace(); tryPEReference(); if (tryRead("NDATA")) { requireWhitespace(); tryPEReference(); notationName = readNmtoken(true); setExternalDataEntity(name, ids[0], makeUrl(ids[1]), notationName); } else { setExternalTextEntity(name, ids[0], makeUrl(ids[1])); } }
// Finish the declaration.
skipWhitespace(); require('>'); }

/** * Parse a notation declaration. * [81] NotationDecl ::= '<!NOTATION' S %Name S %ExternalID S? '>' * *NOTE: the '<!NOTATION' has already been read. */

void zlf'xp'parseNotationDecl () throws IOException
{ String nname, ids[];
requireWhitespace(); tryPEReference(); nname = readNmtoken(true);
requireWhitespace(); tryPEReference();
// Read the external identifiers. ids = readExternalIds(true); if (ids[0] == null && ids[1] == null) { error("external identifer missing", nname, null); }
// Register the notation. setNotation(nname, ids[0], makeUrl(ids[1]));
skipWhitespace(); require('>'); }

/** * Parse PCDATA. * <pre> * [16] PCData ::= [^<&]* * </pre> * The trick here is that the data stays in the dataBuffer without * necessarily being converted to a string right away. */

void zlf'xp'parsePCData () throws IOException
{ char c;
// Start with a little cheat -- in most // cases, the entire sequence of // character data will already be in // the readBuffer; if not, fall through to // the normal approach. if (USE_CHEATS) { int lineAugment = 0;
loop: for (int i = readBufferPos; i < readBufferLength; i++) { switch (readBuffer[i]) { case '&': case '<': int start = readBufferPos; readBufferPos = i; line += lineAugment; dataBufferAppend(readBuffer, start, i-start); return; case '\n': lineAugment++; break; } } }
// OK, the cheat didn't work; start over // and do it by the book. while (true) { c = readCh(); switch (c) { case '<': case '&': unread(c); return; default: dataBufferAppend(c); break; } } }

///// High-level reading and scanning methods. ///////////////////

/** * Require whitespace characters. * [1] S ::= (#x20 |#x9 |#xd |#xa)+ */

void zlf'xp'requireWhitespace () throws IOException
{ char c = readCh();
if (isWhitespace(c)) { skipWhitespace(); }
else { error("whitespace expected", c, null); } }

/** * Skip whitespace characters. * [1] S ::= (#x20 |#x9 |#xd |#xa)+ */

void zlf'xp'skipWhitespace () throws IOException
{ // Start with a little cheat. Most of // the time, the white space will fall // within the current read buffer; if // not, then fall through.
if (USE_CHEATS) { int lineAugment = 0;
for (int i = readBufferPos; i < readBufferLength; i++) {
switch (readBuffer[i]) { case ' ': case '\t': case '\r': break; case '\n': lineAugment++; break; default: readBufferPos = i; line += lineAugment; return; } } }
// OK, do it by the book.
char c = readCh(); while (isWhitespace(c)) { c = readCh(); } unread(c); }

/** * Read a name or name token.
* [5] Name ::= (Letter | '_' | ':') (NameChar)*
* [7] Nmtoken ::= (NameChar)+ * *NOTE: [6] is implemented implicitly where required. */

String zlf'xp'readNmtoken (boolean isName) throws IOException
{ char c;
if (USE_CHEATS) { for (int i = readBufferPos; i < readBufferLength; i++) { switch (readBuffer[i]) { case '<': case '>': case '&': case ',': case '|': case '*': case '+': case '?': case ')': case '=': case '\'': case '"': case '[': case ' ': case '\t': case '\r': case '\n': case ';': case '/': case '#': int start = readBufferPos; if (i == start) { error("name expected", readBuffer[i], null); } readBufferPos = i; return new String(readBuffer, start, i - start); } } }
nameBufferPos = 0;
// Read the first character.
loop: while (true) { c = readCh(); switch (c) { case '<': case '>': case '&': case ',': case '|': case '*': case '+': case '?': case ')': case '=': case '\'': case '"': case '[': case ' ': case '\t': case '\n': case '\r': case ';': case '/': unread(c); if (nameBufferPos == 0) { error("name expected", null, null); } String s = new String(nameBuffer,0,nameBufferPos); nameBufferPos = 0; return s; default: nameBuffer = extendBuffer(nameBuffer, nameBufferPos); nameBuffer[nameBufferPos++] = c; } } }

/** * Read a literal. * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' * | "'" ([^<&'] | Reference)* "'" * [11] SystemLiteral ::= '"' URLchar* '"' | "'" (URLchar - "'")* "'" * [13] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'" * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' * | "'" ([^%&'] | PEReference | Reference)* "'" */

String zlf'xp'readLiteral (int flags) throws IOException
{ char delim, c; int startLine = line;
// Find the delimiter. delim = readCh(); if (delim != '"' && delim != '\'' && delim != (char)0) { error("expected '\"' or \"'\"", delim, null); return null; }
// Read the literal. try { c = readCh();
loop: while (c != delim) { switch (c) { // Literals never have line ends case '\n': case '\r': c = ' '; break; // References may be allowed case '&': if ((flags & LIT_CHAR_REF) > 0) { c = readCh(); if (c == '#') { parseCharRef(); c = readCh(); continue loop; // check the next character } else if ((flags & LIT_ENTITY_REF) > 0) { unread(c); parseEntityRef(false); c = readCh(); continue loop; } else { dataBufferAppend('&'); } } break;
// PE References may be allowed case '%': if ((flags & LIT_PE_REF) > 0) { parsePEReference(); c = readCh(); continue; // check the next character } break; default: break; } dataBufferAppend(c); c = readCh(); } } catch (EOFException e) { error("end of input while looking for delimiter (started on line " + startLine + ')', null, new Character(delim).toString()); }
// Normalise whitespace if necessary. if ((flags & LIT_NORMALIZE) > 0) { dataBufferNormalize(); }
// Return the system literal. return dataBufferToString(); }

/** * Try reading external identifiers. * The system identifier is not required for notations. * @param inNotation Are we in a notation? * @return A two-member String array containing the identifiers. */

String[] zlf'xp'readExternalIds (boolean inNotation) throws IOException
{ char c; String ids[] = new String[2];
if (tryRead("PUBLIC")) { requireWhitespace(); ids[0] = readLiteral(LIT_NORMALIZE); // public id if (inNotation) { skipWhitespace(); if (tryRead('"') || tryRead('\'')) { ids[1] = readLiteral(0); } } else { requireWhitespace(); ids[1] = readLiteral(0); // system id } } else if (tryRead("SYSTEM")) { requireWhitespace(); ids[1] = readLiteral(0); // system id }
return ids; }

/** * Test if a character is whitespace. * <pre>
* [1] S ::= (#x20 |#x9 |#xd |#xa)+ * </pre> * @param c The character to test. * @return true if the character is whitespace. */

final boolean zlf'xp'isWhitespace (char c)
{ switch ((int)c) {
case 0x20:
case 0x09:
case 0x0d:
case 0x0a: return true;
default: return false;
} }

///////////////////////// Utility routines. /////////////////////////////

/** * Extend the size of a buffer. */

char[] zlf'xp'extendBuffer (char buffer[], int newCapacity)
{ int capacity = buffer.length;
if (newCapacity < buffer.length) { return buffer; }
else
{ char newBuffer[];
while (capacity <= newCapacity) { capacity *= 2; }
newBuffer = new char[capacity];
System.arraycopy(buffer, 0, newBuffer, 0, buffer.length);
return newBuffer;
} }

/** * Add a character to the data buffer. */

void zlf'xp'dataBufferAppend (char c)
{ // Expand buffer if necessary.
dataBuffer = extendBuffer#ql:zlf'xp'extendBuffer#(dataBuffer, dataBufferPos);
dataBuffer[dataBufferPos++] = c; }

/** * Add a string to the data buffer. */

void zlf'xp'dataBufferAppend (String s)
{ dataBufferAppend(s.toCharArray(), 0, s.length()); }

/** * Append (part of) a character array to the data buffer. */

void zlf'xp'dataBufferAppend (char ch[], int start, int length)
{ dataBuffer = extendBuffer(dataBuffer, dataBufferPos + length); System.arraycopy((Object)ch, start, (Object)dataBuffer, dataBufferPos, length); dataBufferPos += length; }

/** * Normalise whitespace in the data buffer. */

void zlf'xp'dataBufferNormalize ()
{ int i = 0; int j = 0; int end = dataBufferPos;
// Skip whitespace at the start.
while (j < end && isWhitespace#ql:zlf'xp'isWhitespace#(dataBuffer[j])) { j++; }
// Skip whitespace at the end.
while (end > j && isWhitespace(dataBuffer[end - 1])) { end --; }
// Start copying to the left.
while (j < end)
{ char c = dataBuffer[j++];
// Normalise all other whitespace to // a single space.
if (isWhitespace(c)) { while (j < end && isWhitespace(dataBuffer[j++])) { } dataBuffer[i++] = ' '; dataBuffer[i++] = dataBuffer[j-1]; }
else { dataBuffer[i++] = c; }
}
// The new length is <= the old one.
dataBufferPos = i; }

/** * Convert the data buffer to a string. */

String zlf'xp'dataBufferToString ()
{ String s = new String#ql::2nfoJAPI11.NFO:string rl5#(dataBuffer#ql:zlf'xp'fields dataBuffer#,0,dataBufferPos); //array of characters
dataBufferPos = 0; return s; }

/** * Flush the contents of the data buffer to the processor. */

void zlf'xp'dataBufferFlush()
{ if (dataBufferPos > 0)
{ processor.data#ql:zlf'xpr'data#(this, dataBufferToString#ql:zlf'xp'dataBufferToString#()); } }

/** * Require a string to appear, or throw an exception. */

void zlf'xp'require (String delim) throws IOException
{ char ch[] = delim.toCharArray();
for (int i = 0; i < ch.length; i++) { require(ch[i]); } }

/** * Require a character to appear, or throw an exception. */

void zlf'xp'require (char delim) throws IOException
{ char c = readCh#ql:zlf'xp'readCh#();
if (c != delim) { error#ql:zlf'xp'error#("expected character", c, new Character(delim).toString()); } }

/** * Convert a (possibly relative) system identifier into a URL.
* @param sysid The system identifier.
* @return A URL for the system identifier. */

URL zlf'xp'makeUrl (String sysid) throws IOException
{ if (sysid == null) { return null; }
else { return new URL#ql::2nfoJAPI11.NFO:url rl5#(externalEntity#ql:zlf'xp'fields externalEntity#.getURL#ql::2nfoJAPI11.NFO:class.URLConnection#(), sysid); } }

/////////////////// XML query routines. /////////////////////////

// Elements //

/** * Get the declared elements for an XML document. * The results will be valid only after the DTD (if any) has been * parsed.
* @return An enumeration of all element types declared for this document (as Strings).
* @see#getElementContentType#ql:zlf'xp'getElementContentType# * @see#getElementContentModel */

public Enumeration#ql:jv'enumeration# zlf'xp'declaredElements ()
{ return elementInfo#ql:zlf'xp'fields elementInfo#.keys(); }

/** * Look up the content type of an element.
* @param name The element type name. * @return An integer constant representing the content type. * @see#getElementContentModel * @see#CONTENT_UNDECLARED * @see#CONTENT_ANY#ql:zlf'xp'fields CONTENT ANY# * @see#CONTENT_EMPTY * @see#CONTENT_MIXED * @see#CONTENT_ELEMENTS */

public int zlf'xp'getElementContentType (String name)
{ Object element[] = (Object[])elementInfo#ql:zlf'xp'fields elementinfo#.get(name); if (element == null) { return CONTENT_UNDECLARED; } else { return ((Integer)element[0]).intValue(); } }

/** * Look up the content model of an element. * The result will always be null unless the content type is * CONTENT_ELEMENTS or CONTENT_MIXED. * @param name The element type name. * @return The normalised content model, as a string. * @see#getElementContentType */

public String zlf'xp'getElementContentModel (String name)
{ Object element[] = (Object[])elementInfo.get(name); if (element == null) { return null; } else { return (String)element[1]; } }

/** * Register an element. * Array format: * element type * attribute hash table */

void zlf'xp'setElement (String name, int contentType, String contentModel, Hashtable attributes)
{ Object element[];
// Try looking up the element element = (Object[])elementInfo.get(name);
// Make a new one if necessary. if (element == null) { element = new Object[3]; element[0] = new Integer(CONTENT_UNDECLARED); element[1] = null; element[2] = null; } else if (contentType != CONTENT_UNDECLARED && ((Integer)element[0]).intValue() != CONTENT_UNDECLARED) { error("multiple declarations for element type", name, null); return; }
// Insert the content type, if any. if (contentType != CONTENT_UNDECLARED) { element[0] = new Integer(contentType); }
// Insert the content model, if any. if (contentModel != null) { element[1] = contentModel; }
// Insert the attributes, if any. if (attributes != null) { element[2] =attributes; }
// Save the element info. elementInfo.put(name,element); }

/** * Look up the attribute-hashtable for an element. * The hash table is the second item in the element array. */

Hashtable zlf'xp'getElementAttributes (String name)
{ Object element[] = (Object[])elementInfo.get(name);
if (element == null) { return null; }
else { return (Hashtable)element[2]; } }

// Attributes //

/** * Get the declared attributes for an element type.
* @param name The name of the element type. * @return An Enumeration of all the attributes declared for * a specific element type. The results will be valid only * after the DTD (if any) has been parsed. * @see#getAttributeType * @see#getAttributeEnumeration * @see#getAttributeDefaultValueType * @see#getAttributeDefaultValue * @see#getAttributeExpandedValue */

public Enumeration zlf'xp'declaredAttributes (String name)
{Hashtable attlist = getElementAttributes#ql:zlf'xp'getElementAttributes#(name);
if (attlist == null) { return null; }
else { return attlist.keys(); }
}

/** * Retrieve the declared type of an attribute.
* @param name The name of the associated element. * @param aname The name of the attribute.
* @return An integer constant representing the attribute type. * @see#ATTRIBUTE_UNDECLARED * @see#ATTRIBUTE_CDATA * @see#ATTRIBUTE_ID * @see#ATTRIBUTE_IDREF * @see#ATTRIBUTE_IDREFS * @see#ATTRIBUTE_ENTITY * @see#ATTRIBUTE_ENTITIES * @see#ATTRIBUTE_NMTOKEN * @see#ATTRIBUTE_NMTOKENS * @see#ATTRIBUTE_ENUMERATED * @see#ATTRIBUTE_NOTATION */

public int zlf'xp'getAttributeType (String name, String aname)
{ Object attribute[] = getAttribute#ql:zlf'xp'getAttribute#(name, aname);
if (attribute == null) { return ATTRIBUTE_UNDECLARED; }
else { return ((Integer)attribute[0]).intValue()#ql::2nfoJAPI11.NFO:intValue rl5#; } }

/** * Retrieve the allowed values for an enumerated attribute type.
* @param name The name of the associated element. * @param aname The name of the attribute. * @return A string containing the token list. * @see#ATTRIBUTE_ENUMERATED * @see#ATTRIBUTE_NOTATION */

public String zlf'xp'getAttributeEnumeration (String name, String aname)
{ Object attribute[] = getAttribute#ql:zlf'xp'getattribute#(name, aname); if (attribute == null) { return null; } else { return (String)attribute[3]; } }

/** * Retrieve the default value of a declared attribute.
* @param name The name of the associated element.
* @param aname The name of the attribute. * @return The default value, or null if the attribute was *#IMPLIED or simply undeclared and unspecified. * @see#getAttributeExpandedValue */

public String zlf'xp'getAttributeDefaultValue (String name, String aname)
{ Object attribute[] = getAttribute(name, aname); if (attribute == null) { return null; } else { return (String)attribute[1]; } }

/** * Retrieve the expanded value of a declared attribute. * All general entities will be expanded. * @param name The name of the associated element. * @param aname The name of the attribute. * @return The expanded default value, or null if the attribute was *#IMPLIED or simply undeclared * @see#getAttributeDefaultValue */

public String zlf'xp'getAttributeExpandedValue (String name, String aname)
{ Object attribute[] = getAttribute(name, aname); if (attribute == null) { return null; } else if (attribute[4] == null && attribute[1] != null) { try { pushString(null, (char)0 + (String)attribute[1] + (char)0); attribute[4] = readLiteral(LIT_NORMALIZE | LIT_CHAR_REF | LIT_ENTITY_REF); } catch (IOException e) {} } return (String)attribute[4]; }

/** * Retrieve the default value type of a declared attribute. * @see#ATTRIBUTE_DEFAULT_SPECIFIED * @see#ATTRIBUTE_DEFAULT_IMPLIED * @see#ATTRIBUTE_DEFAULT_REQUIRED * @see#ATTRIBUTE_DEFAULT_FIXED */
// name= element name
// aname = attribute name

public int zlf'xp'getAttributeDefaultValueType (String name, String aname)
{ Object attribute[] = getAttribute#ql:zlf'xp'getAttribute#(name, aname); if (attribute == null) { return ATTRIBUTE_DEFAULT_UNDECLARED; } else { return ((Integer)attribute[2]).intValue(); } }

/** * Register an attribute declaration for later retrieval. * Format: * - String type * - String default value * - int value type * *TODO: do something with attribute types. */

void zlf'xp'setAttribute (String elName, String name, int type, String enumeration, String value, int valueType)
{ Hashtable attlist; Object attribute[];
// Create a new hashtable if necessary. attlist = getElementAttributes(elName); if (attlist == null) { attlist = new Hashtable(); }
// Check that the attribute doesn't // already exist! if (attlist.get(name) != null) { return; } else { attribute = new Object[5]; attribute[0] = new Integer(type); attribute[1] = value; attribute[2] = new Integer(valueType); attribute[3] = enumeration; attribute[4] = null; attlist.put(name.intern(), attribute);
// Use CONTENT_UNDECLARED to avoid overwriting // existing element declaration. setElement(elName,CONTENT_UNDECLARED, null, attlist); } }

/** * Retrieve the three-member array representing an * attribute declaration. */

Object[] zlf'xp'getAttribute (String elName, String name)
{ Hashtable attlist; Object attribute[];
attlist = getElementAttributes#ql:zlf'xp'getElementAttributes#(elName); if (attlist == null) { return null; }
attribute = (Object[])attlist.get(name); return attribute; }

// Entities //

/** * Get declared entities.
* @return An Enumeration of all the entities declared for * this XML document. The results will be valid only * after the DTD (if any) has been parsed. * @see#getEntityType * @see#getEntityPublicId * @see#getEntitySystemId * @see#getEntityValue * @see#getEntityNotationName */

public Enumeration zlf'xp'declaredEntities ()
{ return entityInfo.keys(); }

/** * Find the type of an entity.
* @returns An integer constant representing the entity type.
* @see#ENTITY_UNDECLARED#ql:zlf'xp'FIELDS ENTITY UNDECLARED# * @see#ENTITY_INTERNAL * @see#ENTITY_NDATA * @see#ENTITY_TEXT */

public int zlf'xp'getEntityType (String ename)
{ Object entity[] = (Object[])entityInfo.get(ename); if (entity == null) { return ENTITY_UNDECLARED; } else { return ((Integer)entity[0]).intValue(); } }

/** * Return an external entity's public identifier, if any.
* @param ename The name of the external entity.
* @return The entity's system identifier, or null if the * entity was not declared, if it is not an * external entity, or if no public identifier was * provided.
* @see#getEntityType#ql:zlf'xp'getEntityType# */

public String zlf'xp'getEntityPublicId (String ename)
{ Object entity[] = (Object[])entityInfo.get(ename); if (entity == null) { return null; } else { return (String)entity[1]; } }

/** * Return an external-entity#ql:xml'entity.external#'s system identifier. * @param ename The name of the external entity. * @return The entity's system identifier, or null if the * entity was not declared, or if it is not an * external entity. * @see#getEntityType */

public URL zlf'xp'getEntitySystemId (String ename)
{ Object entity[] = (Object[])entityInfo.get(ename); if (entity == null) { return null; } else { return (URL)entity[2]; } }

/** * Return the value of an internal-entity#ql:xml'entity.internal#. * @param ename The name of the internal entity. * @return The entity's value, or null if the entity was * not declared, or if it is not an internal entity. * @see#getEntityType */
// name= nk, value= Nikos Kasselouris

public String zlf'xp'getEntityValue (String ename)
{ Object entity[] = (Object[])entityInfo.get(ename); if (entity == null) { return null; } else { return (String)entity[3]; } }

/** * Get the notation name associated with an NDATA-entity#ql:xml'ndata'keyword#.
* @param ename The NDATA entity name.
* @return The associated notation name, or null if the * entity was not declared, or if it is not an * NDATA entity.
* @see#getEntityType */

public String zlf'xp'getEntityNotationName (String eName)
{ Object entity[] = (Object[])entityInfo.get(eName); if (entity == null) { return null; } else { return (String)entity[4]; } }

/** * Register an entity declaration for later retrieval. */

void zlf'xp'setInternalEntity (String eName, String value)
{ setEntity#ql:zlf'xp'setEntity#(eName, ENTITY_INTERNAL, null, null, value, null); }

/** * Register an external data entity. */

void zlf'xp'setExternalDataEntity (String eName, String pubid, URL sysid, String nName)
{ setEntity(eName, ENTITY_NDATA, pubid, sysid, null, nName); }

/** * Register an external text entity. */

void zlf'xp'setExternalTextEntity (String eName, String pubid, URL sysid)
{ setEntity(eName, ENTITY_TEXT, pubid, sysid, null, null); }

/** * Register an entity declaration for later retrieval. */

void zlf'xp'setEntity (String eName, int eClass, String pubid, URL sysid, String value, String nName)
{ Object entity[];
if (entityInfo.get(eName) == null) { entity = new Object[5]; entity[0] = new Integer(eClass); entity[1] = pubid; entity[2] = sysid; entity[3] = value; entity[4] = nName; entityInfo.put(eName,entity); }
}

// Notations. //

/** * Get declared notations. * @return An Enumeration of all the notations declared for * this XML document. The results will be valid only * after the DTD (if any) has been parsed. * @see#getNotationPublicId * @see#getNotationSystemId */

public Enumeration zlf'xp'declaredNotations ()
{ return notationInfo.keys(); }

/** * Look up the public identifier for a notation#ql:xml'notation'declaration#. * You will normally use this method to look up a notation * that was provided as an attribute value or for an NDATA entity. * @param nname The name of the notation. * @return A string containing the public identifier, or null * if none was provided or if no such notation was * declared. * @see#getNotationSystemId */

public String zlf'xp'getNotationPublicId (String nname)
{ Object notation[] = (Object[])notationInfo.get(nname); if (notation == null) { return null; } else { return (String)notation[0]; } }

/** * Look up the system identifier for a notation. * You will normally use this method to look up a notation * that was provided as an attribute value or for an NDATA entity. * @param nname The name of the notation. * @return A string containing the system identifier, or null * if no such notation was declared. * @see#getNotationPublicId */

public URL zlf'xp'getNotationSystemId (String nname) { Object notation[] = (Object[])notationInfo.get(nname); if (notation == null) { return null; } else { return (URL)notation[1]; } }

/** * Register a notation declaration for later retrieval. * Format: * - public id * - system id */

void zlf'xp'setNotation (String nname, String pubid, URL sysid)
{ Object notation[];
if (notationInfo.get(nname) == null) { notation = new Object[2]; notation[0] = pubid; notation[1] = sysid; notationInfo.put(nname,notation); } else { error("multiple declarations of notation", nname, null); } }

////////////////////// High-level I/O. //////////////////////////////

/** * Read a single character from the readBuffer. * The readDataChunk() method maintains the buffer. * If we hit the end of an entity, try to pop the stack and * keep going. * (This approach doesn't really enforce XML's rules about * entity boundaries, but this is not currently a validating * parser). * This routine also attempts to keep track of the current * position in external entities, but it's not entirely accurate. * @return The next available input character. * @see#unread(char) * @see#unread(String) * @see#readDataChunk * @see#readBuffer * @see#line * @return The next character from the current input source. */

char zlf'xp'readCh () throws IOException
{// As long as there's nothing in the read buffer, try reading more data (for an external entity) or popping the entity stack (for either).
while (readBufferPos >= readBufferLength)
{ switch (sourceType) {
case INPUT_EXTERNAL:
readDataChunk#ql:sxz'xp'readDataChunk#(); while (readBufferLength < 1) { popInput#ql:sxz'xp'popInput#(); } break;
default: popInput(); break;
}
}
if (readBuffer[readBufferPos] == '\n') { line++; }
return readBuffer[readBufferPos++]; }

/** * Push a single character back onto the current input stream. * This method usually pushes the character back onto * the readBuffer, while the unread(String) method treats the * string as a new internal entity. * I don't think that this would ever be called with * readBufferPos = 0, because the methods always reads a character * before unreading it, but just in case, I've added a boundary * condition. * @param c The character to push back. * @see#readCh * @see#unread(String) * @see#unread(char[]) * @see#readBuffer */

void zlf'xp'unread (char c) throws IOException
{ // Normal condition. if (readBufferPos > 0) { readBuffer[--readBufferPos] = c; } else { pushString(null, new Character(c).toString()); } }

/** * Push a string back onto the current input stream. * NOTE: you must never push back a string that you * haven't actually read: use pushString() instead. * @see#readCh * @see#unread(char) * @see#unread(char[]) * @see#readBuffer * @see#pushString */

void zlf'xp'unread (String s) throws IOException
{ int len = s.length(); if (len < readBufferPos) { readBufferPos -= len; } else { pushString(null, s); } }

/** * Push a char array back onto the current input stream. * NOTE: you must never push back characters that you * haven't actually read: use pushString() instead. * @see#readCh * @see#unread(char) * @see#unread(String) * @see#readBuffer * @see#pushString */

void zlf'xp'unread (char ch[], int length) throws IOException
{ if (length < readBufferPos) { readBufferPos -= length; } else { pushString(null, new String(ch, 0, length)); } }

/** * Push a new external input source. * The source will be either an external text entity, or the DTD * external subset. * TO DO: Right now, this method always attempts to autodetect * the encoding; in the future, it should allow the caller to * request an encoding explicitly, and it should also look at the * headers with an HTTP connection. * @param url The java.net.URL object for the entity. * @see XmlProcessor#resolveEntity * @see#pushString * @see#sourceType * @see#pushInput * @see#detectEncoding * @see#sourceType * @see#readBuffer */

void zlf'xp'pushUrl (String ename, String publicId, URL systemId) throws IOException
{// Give the user a chance to intercept // and supply a different systemId, or // null if the entity should be skipped.
systemId = processor.resolveEntity#ql:zlf'*'resolveEntity#(this, ename, publicId, systemId);
if (systemId == null) { return; }
// Push the existing status
pushInput(ename);
// Set the new status
sourceType = INPUT_EXTERNAL;
// Open a connection and get the InputStream.
externalEntity = systemId.openConnection();
externalEntity.connect();
is = externalEntity.getInputStream();
if (!is.markSupported()) { is = new BufferedInputStream(is); } line = 1;
// Create a new read buffer. // (Note the four-character margin)
readBuffer = new char[READ_BUFFER_MAX+4]; readBufferPos = 0; readBufferLength = 0;
// Attempt to detect the encoding.
detectEncoding#ql:zlf'xp'detectEncoding#();
// Read the XML/Encoding declaration.
if (tryRead("<?xml")) { if (tryWhitespace()) { if (inputStack.size() > 0) { parseTextDecl(); } else { parseXMLDecl(); } } else { unread("xml"); parsePI(); } } }

/** * Attempt to detect the encoding of an entity. * The trick here (as suggested in the XML standard) is that * any entity not in UTF-8, or in UCS-2 with a byte-order mark, * must begin with an XML declaration or an encoding * declaration; we simply have to look for "<?XML" in various * encodings. * This method has no way to distinguish among 8-bit encodings. * Instead, it assumes UTF-8, then (possibly) revises its assumption * later in checkEncoding(). Any ASCII-derived 8-bit encoding * should work, but most will be rejected later by checkEncoding(). * I don't currently detect EBCDIC, since I'm concerned that it * could also be a valid UTF-8 sequence; I'll have to do more checking * later. * @see#tryEncoding(byte[], byte, byte, byte, byte) * @see#tryEncoding(byte[], byte, byte) * @see#checkEncoding * @see#read8bitEncodingDeclaration */

void zlf'xp'detectEncoding () throws IOException
{ byte signature[] = new byte[4];
// Read the first four bytes for // autodetection. is.mark#ql::2nfoJAPI11.NFO:class.inputstream#(4); is.read(signature); is.reset();
// Look for a known signature.
if (tryEncoding(signature, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x3c)) { // UCS-4 must begin with "<!XML" // 0x00 0x00 0x00 0x3c: UCS-4, big-endian (1234)
encoding = ENCODING_UCS_4_1234; }
else if (tryEncoding(signature, (byte)0x3c, (byte)0x00, (byte)0x00, (byte)0x00)) { // UCS-4 must begin with "<!XML" // 0x3c 0x00 0x00 0x00: UCS-4, little-endian (4321) encoding = ENCODING_UCS_4_4321; }
else if (tryEncoding(signature, (byte)0x00, (byte)0x00, (byte)0x3c, (byte)0x00)) { // UCS-4 must begin with "<!XML" // 0x00 0x00 0x3c 0x00: UCS-4, unusual (2143) encoding = ENCODING_UCS_4_2143; }
else if (tryEncoding(signature, (byte)0x00, (byte)0x3c, (byte)0x00, (byte)0x00)) { // UCS-4 must begin with "<!XML" // 0x00 0x3c 0x00 0x00: UCS-4, unusual (3421) encoding = ENCODING_UCS_4_3412; }
else if (tryEncoding(signature, (byte)0xfe, (byte)0xff)) { // UCS-2 with a byte-order marker. // 0xfe 0xff: UCS-2, big-endian (12) encoding = ENCODING_UCS_2_12; is.read(); is.read(); }
else if (tryEncoding(signature, (byte)0xff, (byte)0xfe)) { // UCS-2 with a byte-order marker. // 0xff 0xfe: UCS-2, little-endian (21) encoding = ENCODING_UCS_2_21; is.read(); is.read(); }
else if (tryEncoding(signature, (byte)0x00, (byte)0x3c, (byte)0x00, (byte)0x3f)) { // UCS-2 without a BOM must begin with "<?XML" // 0x00 0x3c 0x00 0x3f: UCS-2, big-endian, no byte-order mark encoding = ENCODING_UCS_2_12; error("no byte-order mark for UCS-2 entity", null, null); }
else if (tryEncoding(signature, (byte)0x3c, (byte)0x00, (byte)0x3f, (byte)0x00)) { // UCS-2 without a BOM must begin with "<?XML" // 0x3c 0x00 0x3f 0x00: UCS-2, little-endian, no byte-order mark encoding = ENCODING_UCS_2_21; error("no byte-order mark for UCS-2 entity", null, null); }
else if (tryEncoding(signature, (byte)0x3c, (byte)0x3f, (byte)0x78, (byte)0x6d)) { // Some kind of 8-bit encoding with "<?XML" // 0x3c 0x3f 0x78 0x6d: UTF-8 or other 8-bit markup (read ENCODING) encoding = ENCODING_UTF_8; read8bitEncodingDeclaration(); } else { // Some kind of 8-bit encoding without "<?XML" // (otherwise) UTF-8 without encoding/XML declaration encoding = ENCODING_UTF_8; } }

/** * Check for a four-byte signature. * Utility routine for detectEncoding(). * Always looks for some part of "<?XML" in a specific encoding. * @param sig The first four bytes read. * @param b1 The first byte of the signature * @param b2 The second byte of the signature * @param b3 The third byte of the signature * @param b4 The fourth byte of the signature * @see#detectEncoding */

boolean zlf'xp'tryEncoding (byte sig[], byte b1, byte b2, byte b3, byte b4)
{ return (sig[0] == b1 && sig[1] == b2 && sig[2] == b3 && sig[3] == b4); }

/** * Check for a two-byte signature. * Looks for a UCS-2 byte-order mark. * Utility routine for detectEncoding(). * @param sig The first four bytes read. * @param b1 The first byte of the signature * @param b2 The second byte of the signature * @see#detectEncoding */

boolean zlf'xp'tryEncoding (byte sig[], byte b1, byte b2)
{ return ((sig[0] == b1) && (sig[1] == b2)); }

/** * This method pushes a string back onto input. * It is useful either as the expansion of an internal entity, * or for backtracking during the parse. * Call pushCharArray() to do the actual work. * @param s The string to push back onto input. * @see#pushCharArray */

void zlf'xp'pushString (String ename, String s) throws IOException
{ char ch[] = s.toCharArray(); pushCharArray(ename, ch, ch.length); }

/** * Push a new internal input source. * This method is useful for expanding an internal entity, * or for unreading a string of characters. It creates a new * readBuffer containing the characters in the array, instead * of characters converted from an input byte stream. * I've added a couple of optimisations: don't push zero- * length strings, and just push back a single character * for 1-character strings; this should save some time and memory. * @param ch The char array to push. * @see#pushString * @see#pushUrl * @see#readBuffer * @see#sourceType * @see#pushInput */

void zlf'xp'pushCharArray (String ename, char ch[], int length) throws IOException
{ // Push the existing status pushInput(ename); sourceType = INPUT_INTERNAL; readBuffer = ch; readBufferPos = 0; readBufferLength = length; readBufferOverflow = -1; }

/** * Save the current input source onto the stack. * This method saves all of the global variables associated with * the current input source, so that they can be restored when a new * input source has finished. It also tests for entity recursion. * The method saves the following global variables onto a stack * using a fixed-length array: * <ol> * <li>sourceType * <li>externalEntity * <li>readBuffer * <li>readBufferPos * <li>readBufferLength * <li>line * <li>encoding * </ol> * @param ename The name of the entity (if any) causing the new input. * @see#popInput * @see#sourceType * @see#externalEntity * @see#readBuffer * @see#readBufferPos * @see#readBufferLength * @see#line * @see#encoding */

void zlf'xp'pushInput (String ename)
{ Object input[] = new Object[9];
// Check for entity recursion. if (ename != null) { // Cannot use Vector.contains() here, // because I don't want to intern // the entity name (see checkEntityEnd()). Enumeration entities = entityStack.elements(); while (entities.hasMoreElements()) { String e = (String)entities.nextElement(); if (e != null && e.equals(ename)) { error("recursive reference to entity", ename, null); } } } entityStack.push(ename);
// Don't bother if there is no input. if (sourceType == INPUT_NONE) { return; }
// Set up a snapshot of the current // input source. input[0] = new Integer(sourceType); input[1] = externalEntity; input[2] = readBuffer; input[3] = new Integer(readBufferPos); input[4] = new Integer(readBufferLength); input[5] = new Integer(line); input[6] = new Integer(encoding); input[7] = new Integer(readBufferOverflow); input[8] = is;
// Push it onto the stack. inputStack.push(input); }

/** * Restore a previous input source. * This method restores all of the global variables associated with * the current input source. * @exception java.io.EOFException * If there are no more entries on the input stack. * @see#pushInput * @see#sourceType * @see#externalEntity * @see#readBuffer * @see#readBufferPos * @see#readBufferLength * @see#line * @see#encoding */

void zlf'xp'popInput () throws IOException
{ Object input[];
// Throw an EOFException if there // is nothing else to pop. if (inputStack.isEmpty()) { throw new EOFException(); } else { String s; input = (Object[])inputStack.pop(); s = (String)entityStack.pop(); }
sourceType = ((Integer)input[0]).intValue(); externalEntity = (URLConnection)input[1]; readBuffer = (char[])input[2]; readBufferPos = ((Integer)input[3]).intValue(); readBufferLength = ((Integer)input[4]).intValue(); line = ((Integer)input[5]).intValue(); encoding = ((Integer)input[6]).intValue(); readBufferOverflow = ((Integer)input[7]).intValue(); is = (InputStream)input[8]; }

/** * Return true if we can read the expected character. * Note that the character will be removed from the input stream * on success, but will be put back on failure. Do not attempt to * read the character again if the method succeeds. * @param delim The character that should appear next. For a * insensitive match, you must supply this in upper-case. * @return true if the character was successfully read, or false if * it was not. * @see#tryRead(String) */

boolean zlf'xp'tryRead (char delim) throws IOException
{ char c;
// Read the character
c = readCh#ql:zlf'xp'readCh#();
// Test for a match, and push the character back if the match fails.
if (c == delim) { return true; }
else { unread#ql:zlf'xp'unread#(c); return false; } }

/** * Return true if we can read the expected string. * This is simply a convenience method. * Note that the string will be removed from the input stream * on success, but will be put back on failure. Do not attempt to * read the string again if the method succeeds. * This method will push back a character rather than an * array whenever possible (probably the majority of cases). * NOTE: This method currently has a hard-coded limit * of 100 characters for the delimiter. * @param delim The string that should appear next. * @return true if the string was successfully read, or false if * it was not. * @see#tryRead(char) */

boolean zlf'xp'tryRead (String delim) throws IOException
{ char ch[] = delim.toCharArray(); char saved[] = new char[100];
// Compare the input, character- // by character.
for (int i = 0; i < ch.length; i++) { saved[i] = readCh();
// If we failed, push the saved characters as if they were an internal entity.
if (saved[i] != ch[i])
{ if (i == 0) { unread(saved[0]); } else { unread(saved, i+1); } return false; }
}
return true; }

/** * Return true if we can read some whitespace. * This is simply a convenience method. * This method will push back a character rather than an * array whenever possible (probably the majority of cases). * @return true if whitespace was found. */

boolean zlf'xp'tryWhitespace () throws IOException
{ char c; c = readCh(); if (isWhitespace(c)) { skipWhitespace(); return true; } else { unread(c); return false; } }

/** * Read all data until we find the specified string. * This is especially useful for scanning marked sections. * This is a a little inefficient right now, since it calls tryRead() * for every character. * @param delim The string delimiter * @see#tryRead(String, boolean) * @see#readCh */

void zlf'xp'parseUntil (String delim) throws IOException
{ char c; int startLine = line;
try { while (!tryRead(delim)) { c = readCh(); dataBufferAppend(c); } } catch (EOFException e) { error("end of input while looking for delimiter (started on line " + startLine + ')', null, delim); } }

/** * Skip all data until we find the specified string. * This is especially useful for scanning comments. * This is a a little inefficient right now, since it calls tryRead() * for every character. * @param delim The string delimiter * @see#tryRead(String, boolean) * @see#readCh */

void zlf'xp'skipUntil (String delim) throws IOException
{ while (!tryRead(delim)) { readCh(); } }

/** * Read just the encoding declaration (or XML declaration) at the * start of an external entity. * When this method is called, we know that the declaration is * present (or appears to be). We also know that the entity is * in some sort of ASCII-derived 8-bit encoding. * The idea of this is to let us read what the 8-bit encoding is * before we've committed to converting any more of the file; the * XML or encoding declaration must be in 7-bit ASCII, so we're * safe as long as we don't go past it. */

void zlf'xp'read8bitEncodingDeclaration () throws IOException
{ int ch; readBufferPos = readBufferLength = 0;
while (true) { ch = is.read(); readBuffer[readBufferLength++] = (char)ch; switch (ch) { case (int)'>': return; case -1: error("end of file before end of XML or encoding declaration.", null, "?>"); return; } if (readBuffer.length == readBufferLength) { error("unfinished XML or encoding declaration", null, null); } } }

////////////////// Low-level I/O. //////////////////////////////////

/** * Read a chunk of data from an external input source. * This is simply a front-end that fills the rawReadBuffer * with bytes, then calls the appropriate encoding handler. * @see#encoding * @see#rawReadBuffer * @see#readBuffer * @see#filterCR * @see#copyUtf8ReadBuffer * @see#copyIso8859_1ReadBuffer * @see#copyUcs_2ReadBuffer * @see#copyUcs_4ReadBuffer */

void zlf'xp'readDataChunk () throws IOException
{ int count, i, j;
// Read as many bytes as possible into the read buffer.
count = is#ql:zlf'xp'fields is#.read(rawReadBuffer, 0, READ_BUFFER_MAX);
// See if we have any overflow.
if (readBufferOverflow > -1) { readBuffer[0] = (char)readBufferOverflow; readBufferPos = 1; sawCR = true; }
else { readBufferPos = 0; sawCR = false; }
// Dispatch to an encoding-specific // reader method to populate the // readBuffer.
switch (encoding) {
case ENCODING_UTF_8: copyUtf8ReadBuffer(count); break;
case ENCODING_ISO_8859_1: copyIso8859_1ReadBuffer#ql:zlf'xp'copyIso8859#(count); break;
case ENCODING_UCS_2_12: copyUcs2ReadBuffer(count, 8, 0); break;
case ENCODING_UCS_2_21: copyUcs2ReadBuffer(count, 0, 8); break;
case ENCODING_UCS_4_1234: copyUcs4ReadBuffer(count, 24, 16, 8, 0); break; case ENCODING_UCS_4_4321: copyUcs4ReadBuffer(count, 0, 8, 16, 24); break; case ENCODING_UCS_4_2143: copyUcs4ReadBuffer(count, 16, 24, 0, 8); break; case ENCODING_UCS_4_3412: copyUcs4ReadBuffer(count, 8, 0, 24, 16); break; }
// Filter out all carriage returns // if we've seen any.
if (sawCR) { filterCR(); }
// Reset the position.
readBufferPos = 0; }

/** * Filter carriage returns in the read buffer. * CRLF becomes LF; CR becomes LF. * @see#readDataChunk * @see#readBuffer * @see#readBufferOverflow */

void zlf'xp'filterCR ()
{ int i, j;
loop: for (i = 0, j = 0; j < readBufferLength; i++, j++) {
switch (readBuffer[j]) {
case '\r': if (j == readBufferLength - 1) { readBufferOverflow = '\r'; readBufferLength--; break loop; } else if (readBuffer[j+1] == '\n') { j++; } readBuffer[i] = '\n'; break;
case '\n':
default: readBuffer[i] = readBuffer[j]; break; } } readBufferLength = i; }

/** * Convert a buffer of UTF-8-encoded bytes into UTF-16 characters. * When readDataChunk() calls this method, the raw bytes are in * rawReadBuffer, and the final characters will appear in * readBuffer. * The tricky part of this is dealing with UTF-8 multi-byte * sequences, but it doesn't seem to slow things down too much. * @param count The number of bytes to convert. * @see#readDataChunk * @see#rawReadBuffer * @see#readBuffer * @see#getNextUtf8Byte */

void zlf'xp'copyUtf8ReadBuffer (int count) throws IOException
{ int i = 0; int j = readBufferPos; int b1; boolean isSurrogate = false;
while (i < count) { b1 = rawReadBuffer[i++]; isSurrogate = false;
// Determine whether we are dealing with a one-, two-, three-, or four- byte sequence.
if ((b1 & 0x80) == 0) { // 1-byte sequence: 000000000xxxxxxx = 0xxxxxxx readBuffer[j++] = (char)b1; }
else if ((b1 & 0xe0) == 0xc0) { // 2-byte sequence: 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx readBuffer[j++] = (char)(((b1 & 0x1f) << 6) | getNextUtf8Byte(i++, count)); }
else if ((b1 & 0xf0) == 0xe0) { // 3-byte sequence: zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx readBuffer[j++] = (char)(((b1 & 0x0f) << 12) | (getNextUtf8Byte(i++, count) << 6) | getNextUtf8Byte(i++, count)); }
else if ((b1 & 0xf8) == 0xf0) { // 4-byte sequence: 11101110wwwwzzzzyy + 110111yyyyxxxxxx // = 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx // (uuuuu = wwww + 1) isSurrogate = true; int b2 = getNextUtf8Byte(i++, count); int b3 = getNextUtf8Byte(i++, count); int b4 = getNextUtf8Byte(i++, count); readBuffer[j++] = (char)(0xd800 | ((((b1 & 0x07) << 2) | ((b2 & 0x30) >> 4) - 1) << 6) | ((b2 & 0x0f) << 2) | ((b3 & 0x30) >> 4)); readBuffer[j++] = (char)(0xdc | ((b3 & 0x0f) << 6) | b4); // TODO: test that surrogate value is legal. } else { // Otherwise, the 8th bit may not be set in UTF-8 error("bad start for UTF-8 byte sequence", new Integer(b1).toString(), null); } if (readBuffer[j-1] == '\r') { sawCR = true; } } // How many characters have we read? readBufferLength = j; }

/** * Return the next byte value in a UTF-8 sequence. * If it is not possible to get a byte from the current * entity, throw an exception.
* @param pos The current position in the rawReadBuffer.
* @param count The number of bytes in the rawReadBuffer
* @return The significant six bits of a non-initial byte in * a UTF-8 sequence. * @exception EOFException If the sequence is incomplete. */

int zlf'xp'getNextUtf8Byte (int pos, int count) throws IOException
{ int val;
// Take a character from the buffer or from the actual input stream.
if (pos < count) { val = rawReadBuffer[pos]; } else { val = is.read(); if (val == -1) { throw new EOFException("incomplete UTF-8 sequence"); } }
// Check for the correct bits at the // start. if ((val & 0xc0) != 0x80) { throw new IOException("malformed UTF-8 sequence"); }
// Return the significant bits. return (val & 0x3f); }

/** * Convert a buffer of ISO-8859-1-encoded bytes into UTF-16 characters. * When readDataChunk() calls this method, the raw bytes are in * rawReadBuffer, and the final characters will appear in * readBuffer. * This is a direct conversion, with no tricks.
* @param count The number of bytes to convert. * @see#readDataChunk * @see#rawReadBuffer * @see#readBuffer */

void zlf'xp'copyIso8859_1ReadBuffer (int count)
{ int i, j;
for (i = 0, j = readBufferPos; i < count; i++, j++)
{readBuffer[j] = (char)(rawReadBuffer[i] & 0xff);
if (readBuffer[j] == '\r') { sawCR = true; }
}
readBufferLength = j; }

/** * Convert a buffer of UCS-2-encoded bytes into UTF-16 characters. * When readDataChunk() calls this method, the raw bytes are in * rawReadBuffer, and the final characters will appear in * readBuffer.
* @param count The number of bytes to convert.
* @param shift1 The number of bits to shift byte 1.
* @param shift2 The number of bits to shift byte 2 * @see#readDataChunk * @see#rawReadBuffer * @see#readBuffer */

void zlf'xp'copyUcs2ReadBuffer (int count, int shift1, int shift2)
{ int j = readBufferPos#ql:readBufferPos zlf'xp'fields#;
if (count > 0 && (count % 2) != 0) {error("odd number of bytes in UCS-2 encoding", null, null); }
for (int i = 0; i < count; i+=2)
{ readBuffer[j++] = (char)((rawReadBuffer[i] << shift1) | (rawReadBuffer[i+1] << shift2));
if (readBuffer[j-1] == '\r') { sawCR = true; } } readBufferLength = j; }

/** * Convert a buffer of UCS-4-encoded bytes into UTF-16 characters. * When readDataChunk#ql:zlf'xp'readDataChunk#() calls this method, the raw bytes are in * rawReadBuffer, and the final characters will appear in * readBuffer. * Java has 16-bit chars, but this routine will attempt to use * surrogates to encoding values between 0x00010000 and 0x000fffff. * @param count The number of bytes to convert. * @param shift1 The number of bits to shift byte 1. * @param shift2 The number of bits to shift byte 2 * @param shift3 The number of bits to shift byte 2 * @param shift4 The number of bits to shift byte 2 * @see#readDataChunk * @see#rawReadBuffer * @see#readBuffer */

void zlf'xp'copyUcs4ReadBuffer (int count, int shift1, int shift2, int shift3, int shift4)
{ int j = readBufferPos; int value;
if (count > 0 && (count % 4) != 0) { error("number of bytes in UCS-4 encoding not divisible by 4", new Integer(count).toString(), null); } for (int i = 0; i < count; i+=4) { value = ((rawReadBuffer[i] << shift1) | (rawReadBuffer[i+1] << shift2) | (rawReadBuffer[i+2] << shift3) | (rawReadBuffer[i+3] << shift4)); if (value < 0x0000ffff) { readBuffer[j++] = (char)value; if (value == (int)'\r') { sawCR = true; } } else if (value < 0x000fffff) { readBuffer[j++] = (char)(0xd8 | ((value & 0x000ffc00) >> 10)); readBuffer[j++] = (char)(0xdc | (value & 0x0003ff)); } else { error("value cannot be represented in UTF-16", new Integer(value).toString(), null); } } readBufferLength = j; }

////////////////////////// Local Variables. /////////////////////

/** * Re-initialize the variables for each parse. */

void zlf'xp'initializeVariables ()
{ // No errors; first line
errorCount = 0; line = 1;
// Set up the buffers for data and names
dataBufferPos = 0;
dataBuffer = new char[DATA_BUFFER_INITIAL]; nameBufferPos = 0;
nameBuffer = new char[NAME_BUFFER_INITIAL];
// Set up the DTD hash tables
elementInfo = new Hashtable(); entityInfo = new Hashtable();
notationInfo = new Hashtable();
// Set up the variables for the current // element context.
currentElement = null;
currentElementContent = CONTENT_UNDECLARED;
// Set up the input variables
sourceType = INPUT_NONE;
inputStack = new Stack();
entityStack = new Stack();
externalEntity = null;
tagAttributePos = 0;
tagAttributes = new String[100];
rawReadBuffer = new byte[READ_BUFFER_MAX];
readBufferOverflow = -1; }

/** * Clean up after the parse to allow some garbage collection. * Leave around anything that might be useful for queries. */

void zlf'xp'cleanupVariables ()
{ errorCount = -1; line = -1; dataBuffer = null; nameBuffer = null; currentElement = null; currentElementContent = CONTENT_UNDECLARED; sourceType = INPUT_NONE; inputStack = null; externalEntity = null;
entityStack = null; tagAttributes = null; }

}

zlf'XmlProcessor (xpr)

name::
* McsEngl.zlf'XmlProcessor (xpr)@cptItsoft,

// XmlProcessor.java: the callback interface.// NO WARRANTEE! See README, and copyright below.

zlf'xpr'METHODS:
** attribute(XmlParser, String, String, boolean) Attribute.
** data(XmlParser, String) Character data.
** doctypeDecl(XmlParser, String, String, String) Document type declaration.
** endDocument(XmlParser, int) End the document.
** endElement(XmlParser, String) End an element.
** error(XmlParser, String, String, String, URL, int) Fatal XML parsing error.
** processingInstruction(XmlParser, String, String) Processing instruction.
** resolveEntity(XmlParser, String, String, URL) Resolve an External Entity.
** startDocument(XmlParser, String, URL) Start the document.
** startElement(XmlParser, String) Start an element.

================ CODE =================

package com.microstar.xml;

import java.net.*;

/** * XML Processing Interface. * Whenever you parse an XML document, you must provide an object * from a class that implements this interface. The XML parser * will call the object's methods to report significant parsing events, * such as data or the start and end of elements. * @author Copyright (c) 1997 by Microstar Software Ltd. * @author written by David Megginson <dmeggins@microstar.com> * @version 1.0beta * @see XmlParser * @see XmlParser#run() * @see XmlParser#run(XmlProcessor) */

public interface XmlProcessor {

/** * Resolve an External Entity. * Give the processor a chance to resolve external entities when * they occur. The XML parser will invoke this method only for * external text (XML) entities and the external DTD subset (if any), * since NDATA entities are not allowed in data. * Normally, this function should simply return the system Id * argument, but if you want, you can look up the public ID in a * catalogue and return a different system ID, or return null to * instruct the parser to ignore the entity reference. * Note that XML treats the external DTD subset as if it were * an external entity. * @param parser The parser making the callback. * @param publicId The public identifier, or null if none was supplied. * @param systemId The system identifier. * @return A system ID (URL), or null if the parser should ignore * this entity. */

public URL zlf'xpr'resolveEntity (XmlParser parser, String ename, String publicId, URL systemId);

/** * Start the document. * The XML parser will invoke this method just before it * attempts to read the first entity (the root of the document). * @param parser The parser making the callback. * @param pubid The public identifier of the document (if any). * @param sysid The URL of the document. * @see#endDocument */

public void zlf'xpr'startDocument (XmlParser parser, String pubid, URL sysid);

/** * End the document. * The XML parser will invoke this method once, when it has * finished parsing the XML document. * @param parser The parser making the callback. * @param errorCount The number of errors encountered. * @see#startDocument */

public void zlf'xpr'endDocument (XmlParser parser, int errorCount);

/** * Document type declaration. * The XML parser will invoke this method when or if it encounters * the document type (DOCTYPE) declaration. * @param parser The parser making the callback. * @param name The document type name. * @param pubid The public identifier, or null if unspecified. * @param sysid The system identifier, or null if unspecified. */

public void zlf'xpr'doctypeDecl (XmlParser parser, String name, String pubid, String sysid);

/** * Attribute. * The XML parser will invoke this method once for each attribute * (specified or defaulted) before reporting a startElement event. * It is up to your processor to collect the attributes, if * necessary.
* @param parser The parser making the callback.
* @param name The name of the attribute.
* @param type The type of the attribute (see below).
* @param value The value of the attribute, or null if the attribute * is#IMPLIED. * @para isSpecified True if the value was specified, false if it * was defaulted. * @see#startElement * @see XmlParser#declaredAttributes * @see XmlParser#getAttributeType * @see XmlParser#getAttributeDefaultValue */

public void zlf'xpr'attribute (XmlParser parser, String aname, String value, boolean isSpecified);

/** * Start an element. * The XML parser will invoke this method at the beginning of each * element, after calling attribute() for each attribute. * @param parser The parser making the callback. * @param name The element type name. * @see#attribute * @see#endElement * @see XmlParser#declaredElements * @see XmlParser#getElementContentType */

public void zlf'xpr'startElement (XmlParser parser, String name);

/** * End an element. * The XML parser will invoke this method at the end of each element * (including EMPTY elements). * @param parser The parser making the callback. * @param name The element type name. * @see#startElement * @see XmlParser#declaredElements * @see XmlParser#getElementContentType */

public void zlf'xpr'endElement (XmlParser parser, String name);

/** * Character data. * The XML parser will invoke this method once for each chunk of * character data found in the contents of elements. Note that * the parser may break up a long sequence of characters into * smaller chunks, and call this method once for each chunk. * @param parser The parser making the callback. * @param data The character data. */

public void zlf'xpr'data (XmlParser parser, String data);

/** * Processing instruction. * The XML parser will invoke this method once for each * processing instruction. Note that processing instructions may * appear outside of the top-level element. * @param parser The parser making the callback. * @param target The target application. * @param data The contents of the processing instruction. */

public void zlf'xpr'processingInstruction (XmlParser parser, String target, String data);

/** * Fatal XML parsing error. * The XML parser will invoke this method whenever it encounters * a serious error. The parser will attempt to continue past this * point so that you can find more possible error points, but if * this method is called you should assume that the document is * corrupt and should not try to use its contents. * @param parser The parser making the callback. * @param message The error message. * @param found The text that caused the error if relevant, or null. * @param expected The text expected if relevant, or null. * @param url The URL of the entity that contains the error. * @param line The approximate line number of the error. * @param col The approximate column number of the error. */

public void zlf'xpr'error (XmlParser parser, String message, String found, String expected, URL url, int line);
}

zlf'XmlApp.java (xa)

name::
* McsEngl.zlf'XmlApp.java (xa)@cptItsoft,

// XmlApp.java: base class for Ζlfred demos.// NO WARRANTEE! See README, and copyright below.

zlf'xa'METHODS:
public URL resolveEntity (XmlParser p, String ename, String publicId, URL systemId)
public void startDocument (XmlParser p, String pubid, URL sysid)
public void endDocument (XmlParser p, int errorCount)
public void doctypeDecl (XmlParser p, String name, String pubid, String sysid)
public void attribute (XmlParser p, String name, String value, boolean isSpecified)
public void startElement (XmlParser p, String name)
public void endElement (XmlParser p, String name)
public void data (XmlParser p, String data)
public void processingInstruction (XmlParser p, String target, String data)
public void error (XmlParser p, String message, String found, String expected, URL url, int line)
static void doParse (String url, XmlProcessor processor) throws IOException
void displayText (String text)
String escape (String in)
public void init ()
public boolean action (Event ev, Object target)
public void startParse ()

================ CODE ===================

import com.microstar.xml.*;
import java.io.*;
import java.net.*;
import java.awt.*;

/** * Base class for Ζlfred demonstration applications. * This class fills in the basic interface, and provides * an I/O infrastructure for simple applications and applets. * @author Copyright (c) 1997 by Microstar Software Ltd.; * @author written by David Megginson <dmeggins@microstar.com> * @version $Revision: 1.5 $ * @see com.microstar.xml.XmlParser * @see com.microstar.xml.XmlProcessor * @see EventDemo * @see EsisDemo * @see TimerDemo */

public class XmlApp
extends java.applet.Applet
implements XmlProcessor {

/* zlf'xa'FIELDS: *//** * Flag to show whether we're running as an applet or application. */
public boolean isApplet = false;

TextArea textArea; Panel buttonPanel; Button startButton;

////////////////////////////////////////////////////////////////////// // Implementation of XmlParser interface. // // The following methods provide a full skeleton implementation of the // XmlProcessor interface, so that subclasses can override only // the methods they need. //////////////////////////////////////////////////////////////////////

/** * Resolve an external entity. * This method could generate a new URL by looking up the * public identifier in a hash table, or it could replace the * URL supplied with a different, local one; for now, however, * just return the URL supplied. * @see com.Microstar.xml.XmlProcessor#resolveEntity */

public URL zlf'xa'resolveEntity (XmlParser p, String ename, String publicId, URL systemId)
{ return systemId; }

/** * Handle the start of the document. * Do nothing for now. Subclasses can override this method * if they want to take a specific action. * This method will always be called first. * @see com.Microstar.xml.XmlProcessor#startDocument */

public void zlf'xa'startDocument (XmlParser p, String pubid, URL sysid)
{ }

/** * Handle the end the document. * Do nothing for now. Subclasses can override this method * if they want to take a specific action. * This method will always be called last. * @see com.Microstar.xml.XmlProcessor#endDocument */

public void zlf'xa'endDocument (XmlParser p, int errorCount)
{ }

/** * Handle a DOCTYPE declaration. * Do nothing for now. Subclasses can override this method * if they want to take a specific action. * Well-formed XML documents might not have one of these. * The query methods in XmlParser will return useful * values only after this callback. * @see com.Microstar.xml.XmlProcessor#doctypeDecl */

public void zlf'xa'doctypeDecl (XmlParser p, String name, String pubid, String sysid)
{ }

/** * Handle an attribute value specification. * Do nothing for now. Subclasses can override this method * if they want to take a specific action. * @see com.Microstar.xml.XmlProcessor#attribute */

public void zlf'xa'attribute (XmlParser p, String name, String value, boolean isSpecified) { }

/** * Handle the start of an element. * Do nothing for now. Subclasses can override this method * if they want to take a specific action. * @see com.Microstar.xml.XmlProcessor#startElement */

public void zlf'xa'startElement (XmlParser p, String name)
{ }

/** * Handle the end of an element. * Do nothing for now. Subclasses can override this method * if they want to take a specific action. * @see com.Microstar.xml.XmlProcessor#endElement */

public void zlf'xa'endElement (XmlParser p, String name)
{ }

/** * Handle character data. * Do nothing for now. Subclasses can override this method * if they want to take a specific action. * @see com.Microstar.xml.XmlProcessor#data */

public void zlf'xa'data (XmlParser p, String data)
{ }

/** * Handle a processing instruction. * Do nothing for now. Subclasses can override this method * if they want to take a specific action. * @see com.Microstar.xml.XmlProcessor#processingInstruction */

public void zlf'xa'processingInstruction (XmlParser p, String target, String data)
{ }

/** * Handle a parsing error. * By default, print a message and throw an Error. * Subclasses can override this method if they want to do something * different. * @see com.Microstar.xml.XmlProcessor#error */

public void zlf'xa'error (XmlParser p, String message, String found, String expected, URL url, int line)
{
displayText("FATAL ERROR: " + message); displayText(" at " + url.toString() + ": line " + line); if (found != null) { displayText(" Found: " + found); } if (expected != null) { displayText(" Expected: " + expected); } throw new Error(message); }

////////////////////////////////////////////////////////////////////// // General utility methods. //////////////////////////////////////////////////////////////////////

/** * Start a parse in application mode. * Output will go to STDOUT. * @see#displayText * @see com.microstar.xml.XmlParser#run(com.microstar.xml.XmlProcessor) */

static void zlf'xa'doParse (String url, XmlProcessor processor) throws IOException
{
// url= the xml-file
File here = new File("."); URL baseURL; URL docURL;
baseURL = new URL("file", "localhost", here.getAbsolutePath#ql::2nfoJAPI11.NFO:class.file#());
docURL = new URL#ql::2nfoJAPI11.NFO:class.url#(baseURL,url);
// create the parse
XmlParser parser = new XmlParser#ql:zlf'xp'xmlparser#(null, docURL);
parser.run#ql:zlf'xp'run synchronized#(processor);
}

/** * Display text on STDOUT or in an applet TextArea. */

void zlf'xa'displayText (String text)
{ if (isApplet) { textArea.appendText(text + '\n'); }
else { System.out.println(text); }
}

/** * Escape a string for printing. */

String zlf'xa'escape (String in)
{
char arr[];
if (in == null) { return "[null]"; }
arr = in.toCharArray(); StringBuffer out = new StringBuffer(); for (int i = 0; i < arr.length; i++) { switch (arr[i]) { case '\\': out.append("\\\\"); break; case '\n': out.append("\\n"); break; case '\t': out.append("\\t"); break; case '\r': out.append("\\r"); break; case '\f': out.append("\\f"); break; default: out.append(arr[i]); break; } } return out.toString(); }

////////////////////////////////////////////////////////////////////// // Applet support. // // These methods and variables are used only if we are running as an // applet. //////////////////////////////////////////////////////////////////////

/** * Initialise the applet the first time it runs. */

public void zlf'xa'init ()
{ startButton = new Button("Parse " + getParameter("url")); isApplet = true; textArea = new TextArea(); buttonPanel = new Panel(); buttonPanel.setLayout(new FlowLayout()); setLayout(new BorderLayout()); buttonPanel.add("Center", startButton); add("Center", textArea); add("South", buttonPanel); }

/** * React to a button press. * This uses the old event model, so that it will work with * existing browsers. It will cause a 'deprecated' warning * when you compile. */

public boolean zlf'xa'action (Event ev, Object target)
{ if (target == startButton.getLabel()) { startParse(); return true; } else { return false; } }

/** * Start a parse (in response to a button press). * Erase the text area, then start the parser running, using * the value of the "url" parameter. */

public void zlf'xa'startParse ()
{ textArea.setText(""); try { XmlParser parser = new XmlParser(null, new URL(getDocumentBase(),getParameter("url"))); parser.run(this); } catch (Exception e) { displayText("Caught exception: " + e.getMessage()); } }

}

zlf'EventDemo.java (ed)

name::
* McsEngl.zlf'EventDemo.java (ed)@cptItsoft,

// EventDemo.java: demonstration application showing Ζlfred's event stream.// NO WARRANTEE! See README, and copyright below.

zlf'ed'METHODS:
public static void main (String args[])
public URL resolveEntity (XmlParser p, String ename, String publicId, URL systemId)

============ CODE ==========

import com.microstar.xml.*;
import java.net.*;
import java.io.*;

/** * Demonstration application showing Ζlfred's event stream. * Usage: <code>java EventDemo <url></code> * Or, use it as an applet, supplying the URL as the <code>url</code> * parameter. * @author Copyright (c) 1997 by Microstar Software Ltd.; * @author written by David Megginson <dmeggins@microstar.com> * @version $Revision: 1.8 $ * @see com.microstar.xml.XmlParser * @see com.microstar.xml.XmlProcessor * @see XmlApp */

public class EventDemo
extends XmlApp#ql:zlf'xmlapp.java# {

/** * Entry point for an application. */

public static void zlf'ed'main (String args[]) throws IOException
{ doParse#ql:zlf'xa'doparse#(args[0], new EventDemo()); }

/** * Resolve an entity and print an event. * @see com.microstar.xml.XmlProcessor#resolveEntity */

public URL zlf'ed'resolveEntity (XmlParser p, String ename, String publicId, URL systemId)
{ displayText("Resolving entity: name=" + ename + ", pubid="+ publicId + ", sysid=" + systemId); return systemId; }

/** * Handle the start of the document by printing an event. * @see com.microstar.xml.XmlProcessor#startDocument */

public void zlf'ed'startDocument (XmlParser p, String publicId, URL systemId)
{ displayText#ql:zlf'xa'displaytext#("Start document: pubid=" + publicId + ", sysid=" + systemId); }

/** * Handle the end of the document by printing an event. * @see com.microstar.xml.XmlProcessor#endDocument */

public void zlf'ed'endDocument (XmlParser p, int errorCount)
{ displayText("End document: errors=" + errorCount); }

/** * Handle a DOCTYPE declaration by printing an event. * @see com.microstar.xml.XmlProcessor#doctypeDecl */

public void zlf'ed'doctypeDecl (XmlParser p, String name, String pubid, String sysid)
{ displayText("Doctype declaration: name=" + name + ", pubid=" + pubid + ", sysid=" + sysid); }

/** * Handle an attribute value assignment by printing an event. * @see com.microstar.xml.XmlProcessor#attribute */

public void zlf'ed'attribute (XmlParser p, String name, String value, boolean isSpecified)
{ String s; if (isSpecified) { s = " (specified)"; } else { s = " (defaulted)"; } displayText("Attribute: name=" + name + ", value=" + value + s); }

/** * Handle the start of an element by printing an event. * @see com.microstar.xml.XmlProcessor#startElement */

public void zlf'ed'startElement (XmlParser p, String name)
{displayText("Start element: name=" + name); }

/** * Handle the end of an element by printing an event. * @see com.microstar.xml.XmlProcessor#endElement */

public void zlf'ed'endElement (XmlParser p, String name)
{ displayText("End element: name=" + name); }

/** * Handle character data by printing an event. * @see com.microstar.xml.XmlProcessor#data */

public void zlf'ed'data (XmlParser p, String data)
{ displayText("Data: " + escape#ql:zlf'xa'escape#(data)); }

/** * Handle a processing instruction by printing an event. * @see com.microstar.xml.XmlProcessor#processingInstruction */

public void zlf'ed'processingInstruction (XmlParser p, String target, String data)
{ displayText("Processing Instruction: target=" + target + ", data=" + data); }

}// end of EventDemo.java

zlf'DtdDemo.java (dd)

name::
* McsEngl.zlf'DtdDemo.java (dd)@cptItsoft,

import com.microstar.xml.*; import java.io.*; import java.net.*; import java.util.*;

/** * Demonstration application showing DTD queries. * Usage: <code>java DtdDemo <url></code> * Or, use it as an applet, supplying the URL as the <code>url</code> * parameter. * Note: This does not preserve any processing instructions * or parameter entities in the DTD; otherwise, produces a fully expanded * and normalised version. * @author Copyright (c) 1997 by Microstar Software Ltd.; * @author written by David Megginson <dmeggins@microstar.com> * @version $Revision: 1.4 $ * @see com.microstar.xml.XmlParser * @see com.microstar.xml.XmlProcessor * @see XmlApp */

public class DtdDemo extends XmlApp {

/** * Entry point for an application (applets enter through XmlApp.init()). * @see XmlApp.init */

public static void zlf'dd'main (String args[]) throws IOException, ClassNotFoundException
{ doParse#ql:zlf'xa'doparse#(args[0], new DtdDemo()); }

/** * Print a comment showing where the DTD (if any) begins. */

public void zlf'dd'startDocument (XmlParser p, String pubid, URL sysid)
{ displayText("<-- Start of DTD for " + sysid.toString() + " -->\n"); }

/** * Print a comment showing where the DTD (if any) ends. */

public void zlf'dd'endDocument (XmlParser p, int errorCount)
{ displayText("<-- End of DTD -->"); }

/** * Dump the DTD. * Once this event is received, we know that the DTD is * completely parsed, and can use AElfred's query routines * to reconstruct a normalised version of it. * @see#dumpNotations * @see#dumpEntities * @see#dumpElements */

public void zlf'dd'doctypeDecl (XmlParser p, String name, String pubid, String sysid)
{ dumpNotations#ql:zlf'dd'dumpNotations#(p); dumpEntities#ql:zlf'dd'dumpEntities#(p); dumpElements#ql:zlf'dd'dumpElements#(p); }

/** * Produce normalised declarations for all notations. * @see#makeExternalIdentifiers */

public void zlf'dd'dumpNotations (XmlParser p) { Enumeration notationNames = p.declaredNotations(); String nname; String extId;
// Mark the beginning of a new section. displayText("<-- Notation Declarations -->\n");
// Loop through all declared notations. while (notationNames.hasMoreElements()) { nname = (String)notationNames.nextElement(); extId = makeExternalIdentifiers(p.getNotationPublicId(nname), p.getNotationSystemId(nname).toString()); displayText("<!NOTATION " + nname + + ' ' + extId + ">\n"); } }

/** * Produce normalised declarations for all general entities. * @see#makeLiteral * @see#makeExternalIdentifiers */

public void zlf'dd'dumpEntities (XmlParser p)
{ Enumeration entityNames = p.declaredEntities(); String ename; String value;
// Mark the beginning of a new section. displayText("<-- Entity Declarations -->\n");
// Loop through all the declared // entities. while (entityNames.hasMoreElements()) {
ename = (String)entityNames.nextElement();
// Skip parameter entities. if (ename.startsWith("%")) { continue; }
// Construct a value based on the // class of entity. value = null; switch (p.getEntityType(ename)) { // Internal text entity case XmlParser.ENTITY_INTERNAL: value = makeLiteral(p.getEntityValue(ename)); break; // External binary entity case XmlParser.ENTITY_NDATA: value = makeExternalIdentifiers(p.getEntityPublicId(ename), p.getEntitySystemId(ename).toString()) + "NDATA " + p.getEntityNotationName(ename); break; // External text entity case XmlParser.ENTITY_TEXT: value = makeExternalIdentifiers(p.getEntityPublicId(ename), p.getEntitySystemId(ename).toString()); break; }
// Print a normalised declaration. displayText("<!ENTITY " + ename + ' ' + value + ">\n"); } }

/** * Produce normalised declarations for all elements. * @see#dumpAttributes */

public void zlf'dd'dumpElements (XmlParser p)
{ Enumeration elementNames = p.declaredElements#ql:zlf'xp'declaredElements#();
String elname;
// Mark the beginning of a new section.
displayText("<-- Element Type Declarations -->\n");
// Loop through all of the declared elements.
while (elementNames.hasMoreElements())
{ String contentSpec = "ANY";
elname = (String)elementNames.nextElement();
// Construct a content spec based on the element's content type.
switch (p.getElementContentType#ql:zlf'xp'getElementContentType#(elname))
{ case XmlParser.CONTENT_EMPTY: contentSpec = "EMPTY"; break;
case XmlParser.CONTENT_ANY: contentSpec = "ANY"; break;
case XmlParser.CONTENT_ELEMENTS:
case XmlParser.CONTENT_MIXED: contentSpec = p.getElementContentModel(elname); break;
}
// Print a normalised element type // declaration.
displayText("<!ELEMENT " + elname + ' ' + contentSpec + ">");
// Print the ATTLIST declaration, // if any.
dumpAttributes#ql:zlf'dd'dumpAttributes#(p, elname);
// Blank line.
displayText(""); } }

/** * Dump attributes for an element. * @see#makeAttributeType * @see#makeAttributeValue */

void zlf'dd'dumpAttributes (XmlParser p, String elname)
{ Enumeration attributeNames = p.declaredAttributes(elname);
String aname; String type; String value;
// Skip if there are no declared // attributes for this element // type.
if (attributeNames == null) { return; }
// Print the start of the ATTLIST // declaration.
displayText("<!ATTLIST " + elname);
// Loop through all of the declared // attributes.
while (attributeNames.hasMoreElements())
{
aname = (String)attributeNames.nextElement();
type = makeAttributeType(p, elname, aname);
value = makeAttributeValue#ql:zlf'dd'makeAttributeValue#(p, elname, aname);
// Print the declaration for a // single attribute. displayText(" " + aname + ' ' + type + ' ' + value); }
// Finish the ATTLIST declaration. displayText(">"); }

/** * Generate the attribute type as a normalised string. */

String zlf'dd'makeAttributeType (XmlParser p, String elname, String aname) { // Construct a string equivalent // of the attribute type. switch (p.getAttributeType(elname, aname)) { case XmlParser.ATTRIBUTE_CDATA: return "CDATA"; case XmlParser.ATTRIBUTE_ID: return "ID"; case XmlParser.ATTRIBUTE_IDREF: return "IDREF"; case XmlParser.ATTRIBUTE_IDREFS: return "IDREFS"; case XmlParser.ATTRIBUTE_ENTITY: return "ENTITY"; case XmlParser.ATTRIBUTE_ENTITIES: return "ENTITIES"; case XmlParser.ATTRIBUTE_NMTOKEN: return "NMTOKEN"; case XmlParser.ATTRIBUTE_NMTOKENS: return "NMTOKENS"; case XmlParser.ATTRIBUTE_ENUMERATED: // An enumeration. return p.getAttributeEnumeration(elname, aname); case XmlParser.ATTRIBUTE_NOTATION: // An enumeration of notations. return "NOTATION " + p.getAttributeEnumeration(elname, aname); } return null; }

/** * Generate a full attribute default value. * @see#makeLiteral */

String zlf'dd'makeAttributeValue (XmlParser p, String elname, String aname)
{ // Generate a default value based // on the type.
switch (p.getAttributeDefaultValueType#ql:zlf'xp'getAttributeDefaultValueType#(elname, aname)) { case XmlParser.ATTRIBUTE_DEFAULT_IMPLIED: return "#IMPLIED"; case XmlParser.ATTRIBUTE_DEFAULT_SPECIFIED: return makeLiteral#ql:zlf'dd'makeLiteral#(p.getAttributeDefaultValue(elname, aname)); case XmlParser.ATTRIBUTE_DEFAULT_REQUIRED: return "#REQUIRED"; case XmlParser.ATTRIBUTE_DEFAULT_FIXED: return "#FIXED " + makeLiteral(p.getAttributeDefaultValue(elname,aname)); } return null; }

/** * Construct a string equivalent of external identifiers. * @see#makeLiteral */

String zlf'dd'makeExternalIdentifiers (String pubid, String sysid) { String extId = "";
if (pubid != null) { extId = "PUBLIC " + makeLiteral(pubid); if (sysid != null) { extId = extId + ' ' + makeLiteral(sysid); } } else { extId = "SYSTEM " + makeLiteral(sysid); }
return extId; }

/** * Quote a literal, and escape any '"' or non-ASCII characters within it. */

String zlf'dd'makeLiteral (String data)
{ char ch[] = data.toCharArray();
StringBuffer buf = new StringBuffer();
buf.append('"');
for (int i = 0; i < ch.length; i++) { if (ch[i] == '"') { buf.append(""); } else if ((int)ch[i] > 0x7f) { buf.append("&#" + (int)ch[i] + ";"); } else { buf.append(ch[i]); } } buf.append('"');
return buf.toString(); }
}

jvp.XML.IBM (xi)

name::
* McsEngl.jvp.XML.IBM (xi)@cptItsoft,

jvp.XML.IBM.PARSER (xip)

name::
* McsEngl.jvp.XML.IBM.PARSER (xip)@cptItsoft,

jvp.XML.IBM.TRLX/PARSER (xit)

name::
* McsEngl.jvp.XML.IBM.TRLX/PARSER (xit)@cptItsoft,

xit'version:
19980206

xit'author:
TAMURA Kent <kent@trl.ibm.co.jp>

xit'FUNCTION:
XML Syntax Checker.

xit'SOURCE'FILES:
DefaultElementFactory.java
ElementFactory.java
ElementHandler.java
ErrorListener.java
MIME2Java.java
NoRequiredAttributeHandler.java
PIHandler.java
PreRootHandler.java
SAXDriver.java
StartTagHandler.java
Stderr.java
StreamProducer.java
trlx.java

jvp.XML.IBM.CDFEDITOR (xice)

name::
* McsEngl.jvp.XML.IBM.CDFEDITOR (xice)@cptItsoft,

xice'VERSION:
version 19980206

xice'FUNCTION:
CDF EDITOR.

xice'AUTHOR:
URAMOTO Naohiko <uramoto@trl.ibm.co.jp>

xice'SOURSE'FILES:
CdfEditor.java
cdfeStatus.java
Gateway.java
LabelEdt.java
ProcCHANNEL.java
ProcITEM.java
PropertyBox.java
SelectMenu.java
Transform.java
XMLComponent.java
XMLComponentEdt.java
XMLComponentM.java

CdfEditor.java (xice'ce)

name::
* McsEngl.CdfEditor.java (xice'ce)@cptItsoft,

xice'ce'METHODS:
public static void main#ql:xice'ce'main#(String args[]) throws IOException
public CdfEditor (String cdfFileName) throws FileNotFoundException, IOException
public void actionPerformed(ActionEvent e)

================

package com.ibm.xml.cdfedit;

/* * History: * 19971028: Version 1.0 * 19980202: changes for new processor API. (Kent) * */

import com.ibm.xml.parser.*;
import com.ibm.xml.siteoutliner.*;
import java.awt.*; import java.awt.event.*; import java.io.*; import java.net.*;

/** * * @version 19980206 * @author URAMOTO Naohiko <uramoto@trl.ibm.co.jp> */ public class CdfEditor
extends Frame
implements ActionListener{

xice'ce'FIELDS:
Frame f;
ScrollPane sp;
XMLComponent xc = null;
public PropertyBox pbox;
SiteOutlinerUI ui;
SiteOutliner so;

public xice'ce'CdfEditor (String cdfFileName) throws FileNotFoundException, IOException
{
FileInputStream is;
f = new Frame("TRL CDF Editor Version 1.0");
// Property Box //
pbox = new PropertyBox("Property Box");
try { if (!cdfFileName.equals("")) { is = new FileInputStream(cdfFileName); Transform tf = new Transform(cdfFileName, "com.ibm.xml.cdfedit.Proc"); xc = tf.readStream((InputStream )is); is.close(); } // if (null != xc) { if (true) { f.setLayout(new BorderLayout()); f.setBackground(new Color(0xff, 0xff, 0xff));
if (null != xc) { Gateway g = new Gateway(); ((XMLComponentM)xc).setGateway(g); f.add(g, "South"); } sp = new ScrollPane(); f.add(sp, "Center");
MenuBar menubar = new MenuBar(); f.setMenuBar(menubar); Menu fileMenu = new Menu("File"); fileMenu.setFont(new Font("Helvetica", Font.PLAIN, 14)); MenuItem item; item = new MenuItem("Open"); fileMenu.add(item); item.addActionListener(this);
item = new MenuItem("Scan"); fileMenu.add(item); item.addActionListener(this);
item = new MenuItem("Save"); fileMenu.add(item); item.addActionListener(this); item = new MenuItem("Quit"); fileMenu.add(item); item.addActionListener(this);
menubar.add(fileMenu);
if (xc != null) sp.add(xc);
f.pack(); f.setSize(600, 600); f.show(); } else System.err.println("Main: xc is null"); } catch (Exception e) { System.err.println(e.getMessage()); } }

public static void xice'ce'main(String args[]) throws IOException
{
try { if (args.length == 1) { new CdfEditor#ql:xice'ce'CdfEditor#(args[0]); }
else { new CdfEditor(""); } }
catch (Exception e) { System.err.println(e.getMessage()); } }

public void xice'ce'actionPerformed(ActionEvent e)
{ Cursor cursor = new Cursor(Cursor.WAIT_CURSOR); f.setCursor(cursor);
if (e.getActionCommand().equals("Quit")) { System.exit(0); }
else if (e.getActionCommand().equals("Scan")) {
Frame f2 = new Frame("Site Outliner"); f2.setSize(300, 300); ui = new SiteOutlinerUI(f2); ui.show();
so = new SiteOutliner(ui); TXDocument doc = so.getDocument();
Gateway g = new Gateway(); f.add(g, "South");
Transform tf = new Transform("", "com.ibm.xml.cdfedit.Proc"); xc = tf.makeComponent((TXElement)doc.getDocumentElement());
((XMLComponentM)xc).setGateway(g); ((XMLComponentM) xc).setGateway( ((XMLComponentM )xc).getGateway());
sp.add(xc); f.pack(); f.show();
} /* so = new SiteOutliner(); so.show(); */

else if (e.getActionCommand().equals("Open")) {
Frame fin = new Frame("Open CDF File"); FileDialog fd = new FileDialog(fin, "Select CDF File");
fd.show();
String cdfFileDir = fd.getDirectory(); String cdfFileName = fd.getFile(); try { FileInputStream is; xc = null; is = new FileInputStream(cdfFileDir+cdfFileName); Transform tf = new Transform(cdfFileName, "com.ibm.xml.cdfedit.Proc"); xc = tf.readStream((InputStream )is); is.close();
if (null != xc) { Gateway g = new Gateway(); ((XMLComponentM)xc).setGateway(g); f.add(g, "South"); sp.add(xc); f.pack(); f.show(); } // pbox.pack(); //pbox.show(); } catch (Exception ex) { System.err.println(ex.getMessage()); } } else if (e.getActionCommand().equals("Save")) { Frame fin = new Frame("Save CDF File"); FileDialog fd = new FileDialog(fin, "Select CDF File", FileDialog.SAVE);
fd.show();
String cdfFileDir = fd.getDirectory(); String cdfFileName = fd.getFile();
try { FileOutputStream os; os = new FileOutputStream(cdfFileDir+cdfFileName); if (xc != null) { TXElement el = ((XMLComponentEdt ) xc).getElement(); if (el.getParentNode() instanceof TXDocument) { TXDocument doc = (TXDocument )el.getParentNode(); doc.print(new PrintWriter(new OutputStreamWriter(os))); os.close(); } }
} catch (Exception ex) { System.err.println(ex.getMessage()); }
}
f.setCursor(new Cursor(Cursor.DEFAULT_CURSOR)); }
}

PropertyBox.java (xice'pb)

name::
* McsEngl.PropertyBox.java (xice'pb)@cptItsoft,

package com.ibm.xml.cdfedit;

import com.ibm.xml.parser.*; import java.awt.*; import java.net.*; import java.io.*; import java.awt.event.*;

/** * * @version 19980206 * @author Naohiko Uramoto */

public class PropertyBox
extends Frame
implements ActionListener, TextListener {

xice'pb'FIELDS:
Label hrefLabel = new Label(); TextField titleTF = new TextField(); Label elementLabel = new Label(); TextField hrefTF = new TextField(); TextField etypeTF = new TextField(); Label titleLabel = new Label(); Label authorLabel = new Label(); TextField authorTF = new TextField(); TextField abstTF = new TextField(); Label abstLabel = new Label(); Button applyBtn = new Button(); Button quitBtn = new Button(); XMLComponentEdt xmlc;
boolean author, abst, href, tit;

public xice'pb'PropertyBox (XMLComponentEdt xc)
{
super(""); xmlc = xc; // setFont(new Font("Helvetica", Font.PLAIN, 14)); setLayout(null); this.setSize(new Dimension(510, 260)); this.setBounds(500, 20,510, 260); this.setTitle("Property Box");
hrefLabel.setFont(new Font("Helvetica", 1, 16)); hrefLabel.setText("HREF"); // titleTF.setFont(new Font("TimesRoman", 0, 14)); elementLabel.setFont(new Font("Helvetica", 1, 16)); elementLabel.setText("ELEMENT"); // etypeTF.addActionListener(this);
hrefTF.setFont(new Font("TimesRoman", 0, 14)); etypeTF.setForeground(Color.red); // etypeTF.setFont(new Font("Helvetica", 1, 16)); etypeTF.setText("CHANNEL"); titleLabel.setFont(new Font("Helvetica", 1, 16)); titleLabel.setText("TITLE"); // authorLabel.setFont(new Font("Helvetica", 1, 16)); // authorLabel.setText("AUTHOR"); // authorTF.setFont(new Font("TimesRoman", 0, 14)); //abstTF.setFont(new Font("TimesRoman", 0, 14)); abstLabel.setFont(new Font("Helvetica", 1, 16)); abstLabel.setText("ABSTRACT"); applyBtn.setFont(new Font("SansSerif", 0, 16)); applyBtn.setLabel("Apply"); quitBtn.setFont(new Font("SansSerif", 0, 16)); quitBtn.setLabel("Quit");
quitBtn.addActionListener(this); applyBtn.addActionListener(this);
add(hrefLabel); hrefLabel.setLocation(26, 119); hrefLabel.setSize(48,30);
add(titleTF); titleTF.setLocation(120, 78); titleTF.setSize(379, 27);
add(elementLabel); elementLabel.setLocation(27, 30); elementLabel.setSize(85, 32);
add(hrefTF); hrefTF.setLocation(119, 119); hrefTF.setSize(379, 27);
add(etypeTF); etypeTF.setLocation(120, 30); etypeTF.setSize(113, 30);
add(titleLabel); titleLabel.setLocation(25, 80); titleLabel.setSize(48, 30);
// add(authorLabel); // authorLabel.setLocation(25, 160); // authorLabel.setSize(69, 30);
// add(authorTF); // authorTF.setLocation(119, 160); // authorTF.setSize(379, 27);
add(abstTF); abstTF.setLocation(119, 160); abstTF.setSize(379, 27);
add(abstLabel); abstLabel.setLocation(25, 160); abstLabel.setSize(93, 30);
add(applyBtn); applyBtn.setLocation(119, 201); applyBtn.setSize(114, 42);
add(quitBtn); quitBtn.setLocation(273, 201); quitBtn.setSize(119, 42);
author = abst = href = tit = false;
if (xc instanceof ProcITEM) { etypeTF.setText("ITEM"); } else { etypeTF.setText("CHANNEL"); } TXElement el = xc.getElement().searchChildren("TITLE"); String estr; if (el != null) { estr = el.getText(); if (estr != null) titleTF.setText(estr); else titleTF.setText(""); } else abstTF.setText(""); el = xc.getElement().searchChildren("ABSTRACT"); if (el != null) { estr = el.getText(); if (estr != null) abstTF.setText(estr); else abstTF.setText(""); } else abstTF.setText("");
estr = xc.getElement().getAttribute("HREF"); if (estr != null) hrefTF.setText(estr); else hrefTF.setText("");
titleTF.addTextListener(this); abstTF.addTextListener(this); hrefTF.addTextListener(this);
}

/* public static void main(String arges[]) { PropertyBox f = new PropertyBox("Property Box"); f.show(); } */

public void xice'pb'textValueChanged(TextEvent e)
{ if (e.getSource() == titleTF) { tit = true; } if (e.getSource() == abstTF) { abst = true; } if (e.getSource() == hrefTF) { href = true; }
}

public void xice'pb'actionPerformed(ActionEvent e)
{ if (e.getSource() == quitBtn) { setVisible(false); } else if (e.getSource() == applyBtn) { if (tit) { modifyContent("TITLE"); tit = false; } else if (abst) { modifyContent("Abstract"); abst = false; } } }

public void xice'pb'modifyContent(String tag)
{ if (xmlc instanceof ProcCHANNEL) { if (tag.equals("TITLE")) { ((ProcCHANNEL )xmlc).setLabel(titleTF.getText()); } // else if (tag.equals("ABSTRACT")) { // ((ProcCHANNEL )xmlc).setLabel(abstTF.getText()); // } TXElement ecTemp = xmlc.getElement(); TXElement ec = ecTemp.searchChildren(tag); Child textChild[] = ec.getChildrenArray(); // Element update // System.out.println( ((TXElement )textChild[0]).getText()); if (textChild[0] instanceof TXText) { if (tag.equals("TITLE")) { ((TXText )textChild[0]).setData(titleTF.getText()); } else if (tag.equals("Abstract")) { ((TXText )textChild[0]).setData(abstTF.getText()); } } } else if (xmlc instanceof ProcITEM) { if (tag.equals("TITLE")) { ((ProcITEM )xmlc).setStr(titleTF.getText()); } else if (tag.equals("ABSTRACT")) { ((ProcITEM )xmlc).setStr(abstTF.getText()); } TXElement ecTemp = xmlc.getElement(); TXElement ec = ecTemp.searchChildren(tag); Child textChild[] = ec.getChildrenArray(); if (textChild[0] instanceof TXText){ if (tag.equals("TITLE")) { ((TXText )textChild[0]).setData(titleTF.getText()); } else if (tag.equals("ABSTRACT")) { ((TXText )textChild[0]).setData(abstTF.getText()); } } } // ((ProcCHANNEL )xmlc).m_ltitle.doLayout(); xmlc.doLayout(); Container co = xmlc.getParent(); while (co != null) { co.doLayout(); co = co.getParent(); } } }

jvp.XML.JUMBO

name::
* McsEngl.jvp.XML.JUMBO@cptItsoft,

VERSION: 1998jan a

FUNCTION: SGML viewer.

AUTHOR: P.M. Rust.

SOURSE FILES:

jvp.XML.LARK (lk)

name::
* McsEngl.jvp.XML.LARK (lk)@cptItsoft,

VERSION: 1.0B 1998jan05

FUNCTION: it is an XML parser.

AUTHOR: Tim Bray.

SOURSE FILES:
Driver.java: An example that initiates parsing.

Lark.java
XmlInputStream.java
Handler.java
Element.java

lk'Driver.java

name::
* McsEngl.lk'Driver.java@cptItsoft,

_DEFINITION:
This class is an example of how to use lark.

import java.io.*;
import java.util.*;
import textuality.lark.*;

class Driver{

static int[] sOffsets = new int[2];
static String sCRLF = new String("\r\n");

public static void main( String args[] )
throws FileNotFoundException, IOException, InterruptedException, Exception {

Lark lark = null;
XmlInputStream r = null;
Handler h = new Handler#ql:lk'h'methods#();
Element root;
Properties props = System.getProperties();
if (args.length == 0) {
System.out.println("usage: jview Driver <input-file>");
return;
}
System.out.println("Hello Tim");
lark = new Lark#ql:lk'l'lark#();
System.out.println(lark);
r = new XmlInputStream#ql:lk'x'XmlInputStream#(new FileInputStream(args[0]));
lark.setDocumentEntityName#ql:lk'l'setDocumentEntityName#(args[0]);
lark.processExternalEntities#ql:lk'l'processExternalEntities#(true);
System.out.println("Parsing...");
root = lark.readXML#ql:lk'l'readXML#(h, r, "file://" + ((String) props.get("user.dir")).replace('\\', '/')
+ "/" + args[0]);
System.out.println("Done.");
}

}

lk'Lark.java (l)

name::
* McsEngl.lk'Lark.java (l)@cptItsoft,

lk'l'METHODS:
public Lark() throws Exception
public Lark(String[] emptyElementTypes) throws Exception
public Lark(String[] entityNames, String[] entityValues) throws Exception
public Lark(String[] emptyElementTypes, String[] entityNames, String[] entityValues) throws Exception
private void constructor(String[] emptyElementTypes, String[] entityNames, String[] entityValues) throws Exception

public void buildTree(boolean build)
private static int byteFromString(String s, int which)
private boolean complain(Handler handler, String message, int c)
private static void doGT(String Transitions, String specials, int TCount, char[] On, int OCount, byte mask)
public void processExternalEntities(boolean process)
public Element readXML(Handler handler) throws java.io.IOException, Exception, InterruptedException
public Element readXML(Handler handler, XmlInputStream input) throws java.io.IOException, InterruptedException, Exception
public Element readXML(Handler handler, XmlInputStream input, String baseURL) throws java.io.IOException, InterruptedException, Exception
public void saveText#ql:lk'l'saveText#(boolean save)
public void setDocumentEntityName(String name)
private void signalWFError()
public String toString()

=============== code ===============

package textuality.lark;

import java.util.*; import java.io.*; import java.net.*;

public class Lark {

lk'l'FIELDS:
// compiled DFA follows
static final byte CharRefV = 1;
static final byte ColdStartV = 2; static final byte DeclareNotationV = 3; static final byte DeclareUnparsedV = 4; static final byte DebugV = 5; static final byte DoANYV = 6; static final byte DoEMPTYV = 7; static final byte DoMixedV = 8; static final byte EndAttrValV = 9; static final byte EndAttributeV = 10; static final byte EndDTDV = 11; static final byte EndGIV = 12; static final byte EndSaveV = 13; static final byte EnterAttrValV = 14; static final byte EnterEntValV = 15; static final byte EnterIgnoredMSV = 16; static final byte EnterIncludedMSV = 17; static final byte FloatingMSEV = 18; static final byte GotXMLDV = 19; static final byte HashRefV = 20; static final byte HotStartV = 21; static final byte InKWV = 22; static final byte KeywordV = 23; static final byte LeaveMarkedSectV = 24; static final byte MarkAmpV = 25; static final byte MarkConnectorV = 26; static final byte MarkLtV = 27; static final byte MarkPCV = 28; static final byte MarkPcAtTopLevelV = 29; static final byte MarkRepV = 30; static final byte PopV = 31; static final byte PopCPV = 32; static final byte PushV = 33; static final byte ReportAttDeclV = 34; static final byte ReportAttlistV = 35; static final byte ReportDefKWV = 36;
static final byte ReportDoctypeV = 37;
static final byte ReportETagV = 38; static final byte ReportInternalEntityV = 39; static final byte ReportPIV = 40; static final byte ReportReferenceV = 41; static final byte ReportSTagV = 42; static final byte ReportEmptyV = 43; static final byte ReportSystemTextEntityV = 44; static final byte ReportTextV = 45; static final byte SaveExtraV = 46; static final byte SignalPEV = 47; static final byte StartCMV = 48; static final byte StartCPV = 49; static final byte StuffCharV = 50;
// First, the individual character transitions, as triples
static final String sOCT = "\u003c\u0101\u2108\u013f\ucb02\u3e03\u033c\u0504\u3c06\u0521" + "\u0805\u3f0c\u0621\u0906\u3f0c\u0721\u0a07\u2fa3\u073f\u0c08" + "\u2d13\u0844\u0b09\u2d13\u0a2d\u120a\u5b1a\u0d3f\u100e\u3f11" + "\u0f3f\u1110\u3eb0\u113e\ub011\u3f11\u122d\u1413\u2d15\u142d" + "\u1615\u2d17\u162d\u1817\u2d19\u183e\ub019\u3eb0\u1a43\u0b1b" + "\u5b1c\u1c5d\u1d1d\u5d1e\u1e3e\ub01e\u5d1e\u213e\u0421\u5022" + "\u2153\u2a21\u5b30\u2255\u0b24\u2226\u2425\u3324\u2725\u2527" + "\ub026\u22b0\u2822\u2e28\u2533\u2827\u2d2a\u590b\u2c22\u2e2c" + "\u2533\u2c27\u2d2d\u27b0\u2e22\ub02f\u3e04\u2f5b\u3030\u2533" + "\u303c\u3630\u5d31\u313e\u0431\u5d32\u323e\u3034\u3bb0\u353e" + "\u0436\u2137\u363f\u0c37\u2d48\u3741\u0b37\u4578\u374e\u0b37" + "\u5b44\u3b50\u0b3b\u530b\u3d22\u263d\u2725\u3e3e\u303f\u222e" + "\u3f27\u2d3f\u3e30\u4122\u2e41\u272d\u423e\u3043\u3e30\u4425" + "\u3344\u4945\u4547\u0b45\u4e0b\u465b\u3047\u5b30\u482d\u4949" + "\u2d4a\u4a2d\u4b4b\u3e30\u4d25\u334f\u2533\u4f3e\u3051\u2533" + "\u5128\u5251\u430b\u5145\u5951\u4962\u514e\u6852\u2533\u5329" + "\u5753\u7c55\u5425\u3354\u2957\u547c\u5555\u2533\u5629\u5756" + "\u7c55\u594e\u5a5a\u545b\u5b49\u5c5c\u545d\u5d49\u5f5d\u595e" + "\u5f45\u6060\u5361\u6244\u6363\u5264\u6445\u6565\u4666\u6653" + "\u6768\u4d0b\u684f\u0b6a\u2533\u6a28\u6b6b\u2533\u6c29\u726c" + "\u7c6e\u6d25\u336d\u2972\u6d7c\u6e6e\u2533\u6f29\u726f\u7c6e" + "\u7053\u7172\u22af\u7223\u7372\u2533\u7227\uad73\u460b\u7349" + "\u0b73\u520b\u743e\u3075\u3e30\u7722\uaf77\u2533\u7727\uad78" + "\u4c0b\u784e\u0b7a\u2533\u7b25\u337b\u287e\u7b41\u0b7b\u450b" + "\u7c3e\u307d\u3e30\u7e23\u0b7e\u2533\u7e28\u817f\u2a80\u7f2b" + "\u807f\u3e30\u7f3f\u8080\u2533\u803e\u3081\u2533\u8128\u8182" + "\u2930\u822a\u8482\u2b84\u822c\u8582\u3f84\u827c\u8983\u2930" + "\u832a\u8483\u2b84\u832c\u8583\u3f84\u837c\u8984\u2533\u8429" + "\u3084\u2c85\u847c\u8985\u2533\u8528\u8186\u2930\u862a\u8886" + "\u2b88\u862c\u8586\u3f88\u8729\u3087\u2a88\u872b\u8887\u2c85" + "\u873f\u8888\u2533\u8829\u3088\u2c85\u8925\u3389\u2881\u8a29" + "\u308a\u2a8c\u8a2b\u8c8a\u3f8c\u8a7c\u898b\u2930\u8b2a\u8c8b" + "\u2b8c\u8b3f\u8c8b\u7c89\u8c25\u338c\u2930\u8c7c\u898d\u2533" + "\u8d29\u938d\u7c8e\u8e25\u338f\u2991\u8f7c\u8e90\u2533\u9029" + "\u9190\u7c8e\u912a\u9292\u2533\u923e\u3093\u2a92\u933e\u3095" + "\u2596\u9725\u3399\u229a\u9925\u3399\u279b\u9950\u2299\u532a" + "\u9a22\ub09a\u2533\u9a26\ub69b\u2533\u9b26\ub69b\u27b0\u9c25" + "\u339c\u3e30\u9d3e\u309e\u2533\u9e3e\u309e\u4e0b\ua025\u33a1" + "\u3e30\ua23e\u30a4\u3eb0\ua53e\ub0a6\u2fa7\ua63e\ub0a7\u3eb0" + "\ua82f\ua7a8\u3eb0\ua93d\uabaa\u3dab\uab22\uaeab\u27ac\uac26" + "\ub6ac\u27b0\uac3c\uacad\u26b6\uad27\ub0ae\u22b0\uae26\ub6ae" + "\u3cae\uaf22\ub0af\u26b6\ub026\ub6b0\u3c07\ub05d\ub1b1\u26b6" + "\ub13c\u07b1\u5db2\ub226\ub6b2\u3c07\ub23e\ub0b2\u5db2\ub33c" + "\ub4b4\u21b5\ub43f\u0cb5\u2d12\ub623\ub7b6\u61c3\ub667\ubbb6" + "\u6cbd\ub671\ubfb7\u30b7\ub731\ub7b7\u32b7\ub733\ub7b7\u34b7" + "\ub735\ub7b7\u36b7\ub737\ub7b7\u38b7\ub739\ub7b7\u3bb0\ub778" + "\ub8b8\u3bb0\ub93b\ub0ba\u3bb0\ubb74\ubcbc\u3bb0\ubd74\ubebe" + "\u3bb0\ubf75\uc0c0\u6fc1\uc174\uc2c2\u3bb0\uc36d\uc7c3\u70c4" + "\uc46f\uc5c5\u73c6\uc63b\ub0c7\u70c8\uc83b\ub0c9\u3eb0\uca3e" + "\u30cb\u78cc\ucc3f\u10cc\u6dcd\ucd3f\u10cd\u6cce\ucf76\u0bd0" + "\u3dd1\ud122\u0bd1\u270b\ud23f\ue2d3\u3fe2\ud365\u0bd3\u730b" + "\ud43d\ud6d5\u3dd6\ud622\ud8d6\u27d7\ud727\ud9d8\u22d9\ud93f" + "\ue2da\u3fe2\uda73\u0bdb\u3ddd\udc3d\udddd\u22df\udd27\udede" + "\u6e0b\ude79\u0bdf\u6e0b\udf79\u0be0\u3fe2\ue13f\ue2e2\u3eb0";
// Special actions for the previous table
static final String sOCSI = "\u0100\u0200\u0101\u0002\u0003\u0000\u0405\u0607\u0800\u090a" + "\u000b\u0b00\u0000\u0000\u0000\u0c0d\u0e0f\u1000\u1112\u1314" + "\u1415\u1617\u1817\u1919\u1a1b\u1a1c\u1a1d\u1a19\u1915\u151e" + "\u0100\u1300\u1f20\u1300\u2100\u2200\u2300\u2425\u2626\u2728" + "\u2827\u2828\u2727\u2900\u2a2b\u2c2d\u0000\u0000\u2e2f\u3031" + "\u0a32\u0a0a\u0a33\u0900\u3409\u0035\u0900\u0000\u0000\u0000" + "\u0000\u0000\u0000\u0036\u3738\u0039\u0900\u3a09\u003b\u0900" + "\u003c\u0f3d\u3c3e\u3f40\u4141\u3c42\u3c43\u4445\u4600\u4748" + "\u494a\u4b4c\u4d4e\u4e00\u4e4f\u0050\u5152\u5353\u5453\u5455" + "\u4e4e\u564e\u5657\u5556\u5658\u5952\u5353\u5a53\u554e\u4e00" + "\u4e5b\u5500\u5c5d\u5253\u5353\u5a55\u4e4e\u4e00\u5e55\u005f" + "\u0000\u605a\u5a61\u0000\u6263\u0062\u6200\u6465\u6665\u6767" + "\u1968\u696a\u6b19\u6c6d\u6e6f\u6e70\u7172\u7273\u745a\u7576" + "\u0077\u7800\u7979\u7a7b\u017a\u7c7b\u7d01\u7c7d\u7e7f\u007e" + "\u7f00\u7e7f\u8000\u0000\u8182\u0000\u0000\u0000\u0000\u0000" + "\u0000\u0000\u0083\u0083\u0c20\u0084\u0085\u0000\u0086\u0000" + "\u0000\u8700\u880f\u0000\u0900\u0900\u8900\u8a8b\u0000\u8c8d" + "\u0900\u0f0f\u0909\u0000\u8e09\u000f\u0f8f\u9091\u9209\u0093";
// Now the transitions on 'S' static final String sST = "\u0003\u0303\u0404\u0d0e\u0e0e\u1f1f\u20b0\u2121\u2324\u2424" + "\u2728\u2828\u2b2c\u2c2c\u2f2f\u3030\u3135\u3535\u3839\u3939" + "\u3a3b\u3b3b\u3c3d\u3e3f\u4041\u4243\u4444\u4646\u4747\u4c4d" + "\u4d4d\u4e4f\u4f4f\u5051\u5151\u5252\u5354\u5454\u5555\u5654" + "\u5772\u5872\u5e72\u6172\u6372\u6672\u6772\u696a\u6a6a\u6b6b" + "\u6c6d\u6d6d\u6e6e\u6f6d\u7072\u7172\u7272\u744f\u754f\u7677" + "\u7777\u797a\u7a7a\u7b7b\u7c7c\u7d7d\u7e7e\u7f80\u8080\u8181" + "\u8284\u8384\u8484\u8585\u8688\u8788\u8888\u8989\u8a8c\u8b8c" + "\u8c8c\u8d8d\u8e8e\u8f90\u9090\u9292\u9392\u9495\u9595\u9697" + "\u9797\u9899\u9999\u9c9c\u9d9e\u9e9e\u9fa0\ua0a0\ua1a2\ua2a2" + "\ua4a5\ua5a5\ua6a8\ua8a8\ua9aa\uaaaa\uabab\ub3b3\ucc0e\ucd0e" + "\ucecf\ucfcf\ud0d0\ud1d1\ud2d3\ud3d3\ud4d5\ud5d5\ud6d6\ud9da" + "\udada\udbdc\udcdc\udddd\ue0e1\ue1e1";
// Special actions for the previous table
static final String sSI = "\u0000\u0009\u0000\u9400\u0000\u0000\u0000\u0000\u0000\u0000" + "\u0900\u0000\u0900\u0000\u0000\u0009\u0078\u0000\u0000\u0000" + "\u0009\u0909\u0909\u0900\u0000\u0000\u0000\u0909\u0095\u9596" + "\u0000\u0000\u0000\u0000\u0000\u5a00\u0000\u5a00\u0000\u5a00" + "\u0000\u005a\u0000\u6200\u0097\u0009\u0000\u0000\u0000\u0000" + "\u5a00\u5a00\u7800\u0000\u0909\u0900\u0000\u0000\u0900\u0000" + "\u0009\u0000\u0900";
// Now the transitions on 'NameStart'
static final String sNST = "\u01a6\u05a6\u06a6\u07a6\u0c0d\u1f20\u3334\u393a\u4d4e\u4f50" + "\u6b6c\u6e6f\u7a20\u8586\u898a\u8e8f\u9598\u9633\u9798\ua0a1" + "\ua3a4\ua8a9\ub6ba\ucb0d";
// Special actions for the previous table
static final String sNSI = "\u0a0a\u0a0a\u0098\n\u0a0a\u0000\u990a\u0a0a\u0a9a\u0a0a" + "\u0a0a\u0000";
// Now the transitions on 'NameC'
static final String sNCT = "\u0d0d\u2020\u3434\u3a3a\u4e4e\u5050\u5253\u5353\u5556\u5656" + "\u6c6c\u6f6f\u7e82\u8182\u8282\u8686\u8a8a\u8f8f\u9898\ua1a1" + "\ua4a4\ua6a6\ua9a9\ubaba\ubbba\ubcba\ubdba\ubeba\ubfba\uc0ba" + "\uc1ba\uc2ba\uc3ba\uc4ba\uc5ba\uc6ba\uc7ba\uc8ba\ucc0d\ucd0d" + "\uce0d";
// Special actions for the previous table static final String sNCI = "\u0000\u0000\u0000\u0000\u0000\u0000\u9b0a\u0000\u0000\u0000" + "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + "\u0000";
// Now the transitions on 'Hex' static final String sHT = "\ub8b8";
// Special actions for the previous table static final String sHI = "\u0000";
// Now the transitions on 'PubID' static final String sPub = "\u2525\u2626";
// Special actions for the previous table static final String sPubI = "\u0000";
// Now the transitions on 'EncName' static final String sEN = "\ud7d7\ud8d8";
// Special actions for the previous table static final String sENI = "\u0000";
// Now the transitions on '.' static final String sDT = "\u0202\u0b0b\u0e0f\u0f0f\u110f\u1414\u1515\u1614\u1715\u1c1c" + "\u1d1c\u1e1c\u29b0\u2d2d\u2e2e\u4949\u4a49\u9a9a\u9b9b\uacac" + "\uadad\uaeae\uafaf\ub0b0\ub1b0\ub2b0\ub9b9\uc9c9\ucaca";
// Special actions for the previous table static final String sDS = "\u009c\u0a00\u0000\u0000\u0000\u9d9e\u9f00\u0000\u0000\u0000" + "\u0000\u0000\u0000\u0000\u0000";
// Now the main list of special actions, pointed to // by the DfaAction table.
static final byte sSL[][] = { { 0 }, /* 1 */ { 27 }, /* 2 */ { 2, 33, -124 }, /* 3 */ { 2, 33, -123 }, /* 4 */ { 2, 33, 49 }, /* 5 */ { 33, -124 }, /* 6 */ { 23, 0, -96, 1 }, /* 7 */ { 33, -123 }, /* 8 */ { 33, 49 }, /* 9 */ { 13 }, /* 10 */ { 21 }, /* 11 */ { 31, 40 }, /* 12 */ { 31, 2 }, /* 13 */ { 31 }, /* 14 */ { 23, 1, -100, 1 }, /* 15 */ { 2 }, /* 16 */ { 45 }, /* 17 */ { 45, 2 }, /* 18 */ { 46, 1, 93, 45 }, /* 19 */ { 11 }, /* 20 */ { 33, -80 }, /* 21 */ { 37 }, /* 22 */ { 23, 2, -92, 2 }, /* 23 */ { 2, 33, -88 }, /* 24 */ { 28, 2, 33, -91 }, /* 25 */ { 31, 13 }, /* 26 */ { 2, 33, -86 }, /* 27 */ { 28, 2, 33, -87 }, /* 28 */ { 23, 3, -84, 2 }, /* 29 */ { 28, 2, 33, -83 }, /* 30 */ { 29, 2, 33, -79 }, /* 31 */ { 24 }, /* 32 */ { 31, 41 }, /* 33 */ { 2, 33, -79 }, /* 34 */ { 23, 5, -51, 1 }, /* 35 */ { 23, 4, -71, 1 }, /* 36 */ { 23, 7, -67, 1 }, /* 37 */ { 23, 6, -63, 1 }, /* 38 */ { 2, 33, -65 }, /* 39 */ { 3 }, /* 40 */ { 2, 33, -61 }, /* 41 */ { 28, 2, 33, -59 }, /* 42 */ { 23, 9, -56, 2 }, /* 43 */ { 23, 8, -57, 2 }, /* 44 */ { 17 }, /* 45 */ { 16 }, /* 46 */ { 28, 2, 33, -50 }, /* 47 */ { 28, 2, 33, -48 }, /* 48 */ { 35 }, /* 49 */ { 28, 2, 33, -46 }, /* 50 */ { 21, 23, 10, -39, 1 }, /* 51 */ { 28, 2, 33, -45 }, /* 52 */ { 28, 2, 33, -43 }, /* 53 */ { 28, 2, 33, -42 }, /* 54 */ { 23, 12, -15, 2 }, /* 55 */ { 23, 11, -22, 2 }, /* 56 */ { 28, 2, 33, -21 }, /* 57 */ { 28, 2, 33, -20 }, /* 58 */ { 28, 2, 33, -18 }, /* 59 */ { 28, 2, 33, -17 }, /* 60 */ { 2, 14, 33, -48 }, /* 61 */ { 28, 2, 33, -13 }, /* 62 */ { 23, 15, -9, 1 }, /* 63 */ { 23, 14, -10, 1 }, /* 64 */ { 23, 13, -11, 1 }, /* 65 */ { 36, 34, 35 }, /* 66 */ { 28, 2, 33, -8 }, /* 67 */ { 23, 17, -6, 2 }, /* 68 */ { 23, 16, 21, 2 }, /* 69 */ { 28, 2, 33, -5 }, /* 70 */ { 28, 2, 33, -4 }, /* 71 */ { 23, 19, -2, 1 }, /* 72 */ { 23, 18, -3, 1 }, /* 73 */ { 7 }, /* 74 */ { 6 }, /* 75 */ { 23, 20, 14, 0 }, /* 76 */ { 28, 2, 33, -1 }, /* 77 */ { 48, 49, 33, 4 }, /* 78 */ { 30 }, /* 79 */ { 28, 2, 33, 1 }, /* 80 */ { 28, 2, 33, 2 }, /* 81 */ { 49, 33, 4 }, /* 82 */ { 12, 32 }, /* 83 */ { 12, 30 }, /* 84 */ { 12, 26 }, /* 85 */ { 32 }, /* 86 */ { 26 }, /* 87 */ { 28, 2, 33, 5 }, /* 88 */ { 28, 2, 33, 6 }, /* 89 */ { 49, 33, 8 }, /* 90 */ { 12 }, /* 91 */ { 28, 2, 33, 9 }, /* 92 */ { 28, 2, 33, 10 }, /* 93 */ { 49, 33, 12 }, /* 94 */ { 28, 2, 33, 13 }, /* 95 */ { 28, 2, 33, 14 }, /* 96 */ { 28, 2, 33, 15 }, /* 97 */ { 28, 2, 33, 17 }, /* 98 */ { 8 }, /* 99 */ { 28, 2, 33, 19 }, /* 100 */ { 28, 2, 33, 24 }, /* 101 */ { 2, 15, 33, 29 }, /* 102 */ { 28, 2, 33, 26 }, /* 103 */ { 33, 30 }, /* 104 */ { 28, 2, 33, 27 }, /* 105 */ { 25, 33, 27 }, /* 106 */ { 28, 2, 33, 28 }, /* 107 */ { 25, 33, 28 }, /* 108 */ { 28, 2, 33, 29 }, /* 109 */ { 39 }, /* 110 */ { 44 }, /* 111 */ { 28, 2, 33, 31 }, /* 112 */ { 23, 21, 32, 1 }, /* 113 */ { 28, 2, 33, 33 }, /* 114 */ { 13, 4 }, /* 115 */ { 12, 38 }, /* 116 */ { 38 }, /* 117 */ { 12, 42 }, /* 118 */ { 43 }, /* 119 */ { 42 }, /* 120 */ { 10 }, /* 121 */ { 2, 14, 33, 41 }, /* 122 */ { 45, 25, 2, 33, 45 }, /* 123 */ { 31, 9 }, /* 124 */ { 31, 9, 34 }, /* 125 */ { 45, 25, 2, 33, 47 }, /* 126 */ { 45, 25, 2, 33, 49 }, /* 127 */ { 45, 27 }, /* 128 */ { 18 }, /* 129 */ { 2, 33, 52 }, /* 130 */ { 33, 52 }, /* 131 */ { 31, 20 }, /* 132 */ { 31, 1, 62 }, /* 133 */ { 31, 1, 60 }, /* 134 */ { 31, 1, 34 }, /* 135 */ { 31, 1, 39 }, /* 136 */ { 31, 1, 38 }, /* 137 */ { 23, 22, 81, 1 }, /* 138 */ { 23, 24, 83, 1 }, /* 139 */ { 23, 23, 83, 1 }, /* 140 */ { 21, 23, 25, 85, 1 }, /* 141 */ { 21, 23, 26, 92, 1 }, /* 142 */ { 21, 23, 27, 92, 1 }, /* 143 */ { 23, 29, 97, 2 }, /* 144 */ { 23, 28, 97, 2 }, /* 145 */ { 21, 23, 31, 97, 2 }, /* 146 */ { 21, 23, 30, 97, 2 }, /* 147 */ { 31, 19 }, /* 148 */ { 31, 12 }, /* 149 */ { 36, 34 }, /* 150 */ { 36 }, /* 151 */ { 47 }, /* 152 */ { 21, 33, -94 }, /* 153 */ { 21, 33, -4 }, /* 154 */ { 28, 21, 33, 22 }, /* 155 */ { 21, 48 }, /* 156 */ { 22 }, /* 157 */ { 46, 1, 93 }, /* 158 */ { 46, 2, 93, 93 }, /* 159 */ { 31, 50 } };
// State off-the-rails error messages static final String sErrorMessages[] = { /* 0 */ "in prolog", "", "", "", /* 4 */ "after DTD", /* 5 */ "after <", "", "", /* 8 */ "after <!", "", "", "", /* 12 */ "in processing instruction", "", "", "", "", "", /* 18 */ "after <!-", "", /* 20 */ "in comment", /* 21 */ "in comment", "", "", "", "", /* 26 */ "in <![CDATA[", /* 27 */ "after <![CDATA", "", "", "", /* 31 */ "after <!DOCTYPE", /* 32 */ "reading element type", /* 33 */ "after DOCTYPE Name", /* 34 */ "in PUBLIC keyword", /* 35 */ "after PUBLIC", /* 36 */ "after PUBLIC keyword", /* 37 */ "in PUBLIC identifier", "", /* 39 */ "after PUBLIC identifier", "", /* 41 */ "after SYSTEM identifier", /* 42 */ "in SYSTEM keyword", /* 43 */ "after SYSTEM", /* 44 */ "after SYSTEM keyword", "", "", /* 47 */ "after DTD SYSTEM identifier", /* 48 */ "in internal subset", /* 49 */ "] in internal subset", /* 50 */ "]] in internal subset", /* 51 */ "in PE reference", "", /* 53 */ "after internal subset", /* 54 */ "after < in internal subset", /* 55 */ "after <! in internal subset", /* 56 */ "after <!NOTATION", "", "", "", /* 60 */ "after PUBLIC in <!NOTATION", "", /* 62 */ "after PUBLIC identifier", "", /* 64 */ "after SYSTEM in <!NOTATION", "", /* 66 */ "after External ID in <!NOTATION", "", /* 68 */ "after <![ in internal subset", /* 69 */ "after <[I in internal subset", /* 70 */ "after <![INCLUDE", /* 71 */ "after <![IGNORE", /* 72 */ "after <!- in internal subset", /* 73 */ "in comment", "", /* 75 */ "after '--' in comment in internal subset", /* 76 */ "after <!ATTLIST", /* 77 */ "after <!ATTLIST", /* 78 */ "in element type in <!ATTLIST", /* 79 */ "in <!ATTLIST", /* 80 */ "in attribute name in <!ATTLIST", /* 81 */ "after attribute name in <!ATTLIST", /* 82 */ "in tokenized attribute value", "", "", "", "", "", /* 88 */ "after CDATA in <!ATTLIST", /* 89 */ "in ENTIT(Y,IES) keyword in <!ATTLIST", "", "", "", "", "", "", "", "", /* 98 */ "in ID(REF(S)) keyword in <!ATTLIST", "", "", "", "", "", /* 104 */ "after N in <!ATTLIST type keyword", /* 105 */ "after NOTATION in <!ATTLIST", /* 106 */ "after NOTATION in <!ATTLIST", /* 107 */ "in NOTATION list in <!ATTLIST", "", "", "", "", /* 112 */ "after NMTOKEN in <!ATTLIST", "", /* 114 */ "after <!ATTLIST type", /* 115 */ "after# in <!ATTLIST default", /* 116 */ "after#REQUIRED", /* 117 */ "after#IMPLIED", /* 118 */ "after#FIXED", "", /* 120 */ "after <!E in internal subset", /* 121 */ "after <!ELEMENT", "", /* 123 */ "after element type in declaration", /* 124 */ "after EMPTY", /* 125 */ "after ANY", /* 126 */ "after <!ELEMENT (", /* 127 */ "after element-content declaration", "", /* 129 */ "start of content particle", "", /* 131 */ "after first (...) of content particle", "", /* 133 */ "after , in content particle", "", /* 135 */ "after ) in content article", /* 136 */ "after member of sequence", /* 137 */ "after | in content particle", "", /* 139 */ "after ) in content article", /* 140 */ "after member of choice", /* 141 */ "after#PCDATA", /* 142 */ "after (#PCDATA|", /* 143 */ "in element type in mixed declaration", /* 144 */ "after element type in mixed declaration", /* 145 */ "after mixed declaration", "", /* 147 */ "after (#PCDATA)", /* 148 */ "after <!ENTITY", "", /* 150 */ "after <!ENTITY %", /* 151 */ "after '<!ENTITY % '", /* 152 */ "in <!ENTITY name", /* 153 */ "after <!ENTITY name", /* 154 */ "internal entity declaration", "", /* 156 */ "after <!ENTITY value", /* 157 */ "after entity SYSTEM ID", "", /* 159 */ "after NDATA", /* 160 */ "after NDATA keyword", "", /* 162 */ "after NDATA entity declaration", /* 163 */ "after </", /* 164 */ "in element type in end-tag", /* 165 */ "after element type in end-tag", /* 166 */ "in element type in start-tag", /* 167 */ "after '/' in start-tag", /* 168 */ "in start-tag", /* 169 */ "in attribute name in start-tag", /* 170 */ "after attribute name in start-tag", /* 171 */ "after AttrName= in start-tag", "", "", "", "", /* 176 */ "in character data", "", "", /* 179 */ "after end of document", /* 180 */ "after '<' after document", /* 181 */ "after '<!' after document", /* 182 */ "after '&'", /* 183 */ "in numeric character ref", /* 184 */ "in hex character ref", "", /* 186 */ "in entity name", /* 187 */ "after &g", /* 188 */ "after &gt", /* 189 */ "after &l", /* 190 */ "after &lt", /* 191 */ "after &q", /* 192 */ "after &qu", /* 193 */ "after &quo", /* 194 */ "after &quot", /* 195 */ "after &a", /* 196 */ "after &ap", /* 197 */ "after &apo", /* 198 */ "after &apos", /* 199 */ "after &am", /* 200 */ "after &amp", "", "", /* 203 */ "after <?", /* 204 */ "after <?x", /* 205 */ "after <?xm", /* 206 */ "after <?xml", /* 207 */ "in XML declaration", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" };

// Keyword strings
static final String sKW[] = { "DOCTYPE", "CDATA", "PUBLIC", "SYSTEM", "NOTATION", "ATTLIST", "SYSTEM", "PUBLIC", "INCLUDE", "IGNORE", "CDATA", "NOTATION", "NMTOKEN", "REQUIRED", "IMPLIED", "FIXED", "ENTITY", "ELEMENT", "EMPTY", "ANY", "PCDATA", "NDATA", "version", "'1.0'", "\"1.0\"", "encoding", "standalone", "standalone", "'yes'", "'no'", "\"yes\"", "\"no\"", "" };

// Per-state fallbacks
static final byte sFB[] = { -124, -125, -124, -125, -123, -122, -123, 74, 74, -123, 74, -127, 74, 74, 74, 74, 74, 74, 74, 74, -107, -107, -107, -107, -107, -107, -99, -99, 74, 74, 74, -96, -96, -94, -91, -91, 75, 75, 75, 75, -96, -96, -83, -83, 75, 74, 74, -96, -79, -79, -79, -79, -79, 49, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, -54, -54, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 74, 75, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, 74, 75, 49, 49, 49, 52, 74, 74, 58, 58, 58, 49, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49 };

// End of compiled DFA
static final String sLarkMajorVersion = "1"; static final String sLarkMinorVersion = "0 final beta";
static final String sCopyright = "Copyright (c) 1997-98 Tim Bray.\n All rights reserved; the right to use these class files for any purpose\n is hereby granted to everyone.";

// Statics
static final int sScratchAttCount = 20; // storage size for attributes
static short[][] sD; // The DFA
static final String sNullString = new String("");
static char[] sOS; // Set of specialactions assoc. with a Group Transition
static final int sTextBufSize = 512; // Initial size of text gathering space
static final char[] sS = { ' ', '\n', '\r', '\t' }; // White space group trans.
static short sStateMask = 0xff;
static short sSpecialMask = (short) 0xff00;
static byte sSpecialShift = 8;
static byte sMaxDigitsInHexCRef = 4;

// error messages
static final String sBadNest = "Encountered ";
static final String sBadParenInCM = "Too many )'s in content-model."; static final String sBadRefEnd = "Entity ended in middle of markup."; static final String sBustedKW = "Error trying to match keyword ";
static final String sCantGetURL = "Can't fetch external entity: "; static final String sCaseBotch = "Start/End tags differ only in case: "; static final String sDupeAttributeName = "Duplicate attribute name: "; static final String sEntityNesting = "Element does not end in the same entity that it started in."; static final String sExpected = " expected "; static final String sExtRefInAttr = "External entity reference in attribute value: &"; static final String sFloatingMSE = "Stray ]]>."; static final String sGenEnd = "\n ...assumed "; static final String sHexCRefTooLong = "Too many digits in &#X... reference."; static final String sIllegalCharacter = "Non-Unicode character"; static final String sLTInAttrVal = "Less-than in attribute value."; static final String sMaybeExternal = " - maybe declared externally?"; static final String sMSinSubset = "INCLUDE/IGNORE section in internal DTD subset."; static final String sNonNameChar = "Invalid character in name"; static final String sNoRoot = "No root element."; static final String sNoSuchEntity = "Undeclared entity '"; static final String sNoTopLevelPE = "PE in internal subset not at top level."; static final String sNotOpened = " with no start-tag."; static final String sPEwithNDATA = " NDATA keyword in parameter entity declaration."; static final String sPITargetXML = "PI target cannot match 'xml'."; static final String sPrematureEOF = "End of document entitity before end of root element."; static final String sRecursiveRef = "Recursive entity reference."; static final String sRottenURL = "Can't parse external URL: ["; static final String sTagsPastRoot = "Encountered start-tag after end of root element.";

// machinery for checking NameC & NameStart
static final byte[] sCharClasses = new byte[227]; static final byte sNameCMask = 0x01; static final byte sNameStartMask = 0x02; static boolean[] sIsChar = null;
// states to remember
// where we pop to after the external subset int mStateBeforeDTD = 0; // can read declarations static final int sDTDState = 48; // after root element static final int sAfterDocState = 179; // end of elem-content decl static final int sDoneElementContentState = 127; // basic char-data & attrval static final int sInDocState = 176; static final int sDQAValState = 174; static final int sSQAValState = 172;
// One string per unique Attribute/Attribute/Entity name
Namer mANames = new Namer(false);
Namer mElNames = new Namer(true);
Namer mEntNames = new Namer(false);
// top-level document entity name
String mDocumentName = "(Document Entity)";
// Build-element-tree boolean, and trip for first time it's true
boolean mBuildTree = false;
boolean mBuilding = false;
boolean mSawRoot = false;
// Follow-external-text entities boolean
boolean mProcessExternalEntities = false;

// State variables: boolean mPEDecl = false;
// what kind of entity declaration?
boolean mInEntityVal = false; // internal entity replacement text decl?
boolean mWFError = false; // Have seen a WF error?
boolean mRefIsToPE = false; // Ref being processed is to a PE boolean mInExternalDecls = false; // in external subset or external PE boolean mBypassedExternalDecls = false;
// INCLUDE/IGNORE bookkeeping // -1 means we're not ignoring. Any other value is the mMarkedSectionDepth // at which the IGNORE section was recognized int mMarkedSectionDepth = 0; int mIgnoredSection = -1;
// keyword matching int mKeyword = 0, mKeywordPos = 0;
// Current saved characters, and count, // and control for whether to save 'em, and threshold to grow the buffer // XXX rethink - a lot of these can be locals, not members char[] mCharBuf = new char[sTextBufSize]; int mSavedCharCount; boolean mSaving; int mThreshold = sTextBufSize - 1;
// If given, the buffer where the Document Entity really is byte[] mDocEntityBuffer = null;
// Stacks GIs and entities, just for nesting consistency checks Stack mStack = new Stack();
// GI's of elements considered empty
Hashtable mEmpty = null;
// Entity lookup Hashtable mInternalEntities = new Hashtable(100, 10); Hashtable mExternalTextEntities = new Hashtable(100, 10); Hashtable mInternalPEs = new Hashtable(100, 10); Hashtable mExternalPEs = new Hashtable(100, 10);
// current entity
Entity mCurrentEntity = null;
// Chars & lines in current entity int mInputCharCount = 0; int mInputLineCount = 1; int mLineOffset = 0;
// Shallow state stack int[] mPushedState = new int[20]; int mStateStackInd = 0;
// Saved parts of current object, & current count Vector mSaved = new Vector(20); int mSavedStringCount;
// Currently saving character data in tree?
boolean mSaveText = false;
// Only exists when we're reading an attribute Text mCurrentAttrVal = null;
// Efficient Attribute generation Attribute[][] mScratchAttrs = new Attribute[sScratchAttCount][];
// Current state (DFA index) int mState;

// Current working element
Element mCurrentElement = null;

// Saved offsets
int mLastLtOffset = 0;
int mLastAmpOffset = 0;
int mLastTextOffset = 0;

// Static constructor initializes DFA from packed tables
static { int i, s, c, oneSpecial; sD = new short[227][128]; sOS = new char[128]; boolean dropOut; Text text;
// Init from the single-char transitions for (i = 0; i < 360; i++) { s = byteFromString(sOCT, i*3); c = byteFromString(sOCT, (i*3) + 1); sD[s][c] = (short) byteFromString(sOCT, (i*3) + 2); oneSpecial = byteFromString(sOCSI, i); if (oneSpecial != 0) sD[s][c] |= (short) (oneSpecial << sSpecialShift); }
// Init from white-space transitions doGT(sST, sSI, 126, sS, 4, (byte) 0);
// from Hex transitions for (i = 0; i < 10; i++) sOS[i] = (char) ('0' + i); for (i = 0; i < 6; i++) { sOS[10 + i] = (char) ('a' + i); sOS[16 + i] = (char) ('A' + i); } doGT(sHT, sHI, 1, sOS, 22, (byte) 0);
// init name trans arrays for (i = 0; i < 227; i++) sCharClasses[i] = 0;
// Init from NameStart transitions for (i = 0; i < 26; i++) { sOS[i] = (char) ('a' + i); sOS[i + 26] = (char) ('A' + i); } doGT(sNST, sNSI, 24, sOS, 52, sNameStartMask);
// from NameC transitions for (i = 0; i < 10; i++) sOS[i + 52] = (char) ('0' + i); i = 62; sOS[i++] = '-'; sOS[i++] = '.'; sOS[i++] = '_'; sOS[i++] = ':'; doGT(sNCT, sNCI, 41, sOS, i, sNameCMask);
// from EncName (name char - ':') --i; doGT(sEN, sENI, 2, sOS, i, (byte) 0);
// from PubIDChar (NameChar - _ + [-'()+,./:=?] i = 62; sOS[i++] = '-'; sOS[i++] = '\''; sOS[i++] = '('; sOS[i++] = ')'; sOS[i++] = '+'; sOS[i++] = ','; sOS[i++] = '.'; sOS[i++] = '/'; sOS[i++] = ':'; sOS[i++] = '='; sOS[i++] = '?'; sOS[i++] = ' '; doGT(sPub, sPubI, 2, sOS, i, (byte) 0);
// from '.' transitions sIsChar = new boolean[128]; for (i = 0; i < 128; i++) sIsChar[i] = false; sIsChar[0x9] = sIsChar[0xa] = sIsChar[0xd] = true; i = 0; sOS[i++] = (char) 0x9; sOS[i++] = (char) 0xa; sOS[i++] = (char) 0xd; for (c = 0x20; c < 128; c++) { sOS[i++] = (char) c; sIsChar[c] = true; } doGT(sDT, sDS, 29, sOS, i, (byte) 0); }

// pull out a byte from a half-char in one of the big strings
private static int lk'l'byteFromString(String s, int which)
{ char c = s.charAt(which / 2); if ((which & 1) != 0) return c & 0xff; else return c >> 8; }

// load up the DFA from one of the group-transition arrays
private static void lk'l'doGT(String Transitions, String specials, int TCount, char[] On, int OCount, byte mask)
{ int i, j, s, c, oneSpecial;
for (i = 0; i < TCount; i++) { s = byteFromString(Transitions, i*2); sCharClasses[s] |= mask; for (j = 0; j < OCount; j++) { c = On[j];
// if the transition is already set, we ignore this one's effects if (sD[s][c] != 0) continue; sD[s][c] = (short) byteFromString(Transitions, (i*2) + 1); oneSpecial = byteFromString(specials, i); if (oneSpecial != 0) sD[s][c] |= (short) (oneSpecial << sSpecialShift); } } }

// Constructors
public lk'l'Lark() throws Exception
{ constructor#ql:lk'l'constructor#(null, null, null); }

public lk'l'Lark(String[] emptyElementTypes) throws Exception
{ constructor(emptyElementTypes, null, null); }

public lk'l'Lark(String[] entityNames, String[] entityValues) throws Exception
{ constructor(null, entityNames, entityValues); }

public lk'l'Lark(String[] emptyElementTypes, String[] entityNames, String[] entityValues) throws Exception
{ constructor(emptyElementTypes, entityNames, entityValues); }

private void lk'l'constructor( String[] emptyElementTypes,
String[] entityNames,
String[] entityValues) throws Exception
{ int i, j; char[] eval;
// load up the scratch attributes. The idea is that if we're just // doing the event stream, we don't want to do a new Attribute[X] // and then X new Attribute() calls for each element with X attributes; // so we keep an array of sScratchAttCount attribute vectors around, // each element "I" of which is a precooked vector of I attributes. //

for (i = 1; i < sScratchAttCount#ql:lk'l'fields sScratchAttCount#; i++) {
mScratchAttrs[i] = new Attribute[i];
for (j = 0; j < i; j++) mScratchAttrs[i][j] = new Attribute(null, (String) null); }

if (emptyElementTypes != null && mEmpty == null) {
mEmpty#ql:mEmpty lk'l'fields# = new Hashtable(emptyElementTypes.length * 10, 10);
for (i = 0; i < emptyElementTypes.length; i++)
mEmpty.put(emptyElementTypes[i], sNullString#ql:sNullString lk'l'fields#); }

if (entityNames != null) { if (entityValues == null || entityNames.length != entityValues.length) throw(new Exception("Entity Name and Value args don't match")); for (i = 0; i < entityNames.length; i++) {
eval#ql:eval# = entityValues[i].toCharArray(); mInternalEntities.put(entityNames[i], eval); } } }

public String lk'l'toString()
{ return "Lark V" + sLarkMajorVersion + "." + sLarkMinorVersion + " " + sCopyright; }

public void lk'l'buildTree(boolean build)
{ mBuildTree = build; }

public void lk'l'saveText(boolean save)
{ mSaveText = save; }

public void lk'l'processExternalEntities(boolean process)
{ mProcessExternalEntities#ql:mProcessExternalEntities# = process; }

public void lk'l'setDocumentEntityName(String name)
{ mDocumentName#ql:mDocumentName lk'l'fields# = name;
if (mCurrentEntity#ql:mCurrentEntity lk'l'fields# != null) mCurrentEntity.setDescription#ql:lk'e'setDescription#(name); }

// no input stream provided - assume current state is valid
public Element lk'l'readXML(Handler handler) throws java.io.IOException, Exception, InterruptedException
{ if (mCurrentEntity == null) throw new Exception("Called readXML with no input stream established."); return reader(handler, mCurrentEntity.input()); }

// XmlInputStream provided - assume it's new
public Element lk'l'readXML(Handler handler, XmlInputStream input) throws java.io.IOException, InterruptedException, Exception
{ mCurrentEntity = new Entity(true, input, null, mDocumentName, null, false, null); return reader(handler, input); }

// XmlInputStream provided - assume it's new; also we have a URL
public Element lk'l'readXML(Handler handler, XmlInputStream input, String baseURL) throws java.io.IOException, InterruptedException, Exception
{
URL url;
try { url = new URL(baseURL); }
catch (MalformedURLException x) { StringBuffer error = new StringBuffer(sRottenURL).append(baseURL); error = error.append("]");
// need an entity to issue a warning mCurrentEntity = new Entity(true, input, null, "Dummy", null, false, null); handler.doSyntaxError(mCurrentEntity, error.toString(), ' '); return null; }
mCurrentEntity = new Entity#ql:lk'e'entity#(true, input, null, mDocumentName#ql:mDocumentName lk'l'fields#, null, false, url);
return reader#ql:lk'l'reader#(handler, input); }

// byte-buffer provided - make an inputstream and put it on stack
public Element lk'l'readXML(Handler handler, byte[] buffer) throws java.io.IOException, InterruptedException, Exception
{ XmlInputStream stream;
mDocEntityBuffer = buffer; stream = new XmlInputStream(new ByteArrayInputStream(buffer)); mCurrentEntity = new Entity(true, stream, null, mDocumentName, null, false, null); return reader(handler, stream); }

private Element lk'l'reader(Handler handler, XmlInputStream input) throws java.io.IOException, InterruptedException, Exception
{
int c;
// char read
int b;
// transition index
short transition;
int i, j, k, next, max, special, on = 0;
int cModelStart = 0;
byte[] specials;
int acount, dcount, dused;
int[] offsets = new int[2];
boolean more = true;
boolean dropOut = false, turnOnSave, empty;
char[] eval;
char[] newbuf;
Attribute[] theseAttributes;
String str = null, ename = null, url = null;
Element parent;
Element el;
Text text;
Segment seg;
StringBuffer error = null;
Object[] attlist;
int stuffedChar = 0;
Hashtable internalTable, externalTable;
// should be in static initialization, but we need to do it here // because we want to get the element from the Handler callback // and this is the first time we have the Handler.

if (mCurrentElement#ql:mCurrentElement# == null) mCurrentElement = handler.element#ql:lk'h'element#();
while (more) { if (stuffedChar == 0) c = input.getXmlChar(); else { c = stuffedChar; stuffedChar = 0; }

while (c == -1 && mCurrentEntity.parent() != null) { Entity oldEntity;
// we've come to the end of an entity text = currentText(); if (text != null) { // close off the text segment for this entity if (mSaveText || (mCurrentAttrVal != null)) // need more thought... but I don't *think* this can // come out of a buffer, so if we're saving text, the app // will have to find storage for what's now in mCharBuf
seg = new Segment(mCurrentEntity, mLastTextOffset, mSavedCharCount, mSavedCharCount, mCharBuf); else seg = new Segment(mCurrentEntity, mLastTextOffset, mInputCharCount - mLastTextOffset); text.addSegment(seg); }
if (!mInEntityVal) { mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset); if ((mState == sInDocState) && !mWFError) { dropOut = dropOut || handler.doText(mCurrentEntity, mCurrentElement, mCharBuf, mSavedCharCount); } }

if (!mCurrentEntity.isPE()) mSavedCharCount = 0;
// now climb the entity stack oldEntity = mCurrentEntity; mCurrentEntity = mCurrentEntity.parent(); input = mCurrentEntity.input(); mLastTextOffset = mInputCharCount = mCurrentEntity.offset(); mInputLineCount = mCurrentEntity.lineCount(); mLineOffset = mCurrentEntity.lineOffset(); mStack.pop();
// if we finished a PE and aren't in an entityval, append a space
if (oldEntity.isPE() && !mInEntityVal) c = ' '; else c = input.getXmlChar();
// if we just stopped reading the external subset // XXX fix this stupid conditional if ( mState == sDTDState && mStateStackInd == 1 && mPushedState[0] == mStateBeforeDTD && mCurrentEntity.parent() == null) { mStateStackInd = 0; mState = mStateBeforeDTD; }
// otherwise we popped out of a parsed entity - we better end // back in base-content or attribute-value state
else if ( (!oldEntity.isPE()) && mSawRoot && (mState != sSQAValState) && (mState != sDQAValState) && (mState != sInDocState)) if (complain(handler, sBadRefEnd, ' ')) return null; }
// we're outta data
if (c == -1) { // must have seen exactly one element if (!mSawRoot) { handler.doSyntaxError(mCurrentEntity, sNoRoot, ' '); signalWFError(); } else if (!mStack.empty()) { handler.doSyntaxError(mCurrentEntity, sPrematureEOF, ' '); signalWFError(); }
break; }
// We use b as the index for the DFA... b = c;
// ... because the DFA is only ASCII-sized and we might get // non-ASCII characters, but that's OK, we'll pretend.
if (c > 127) { // in most cases, we're going to be OK, so check for do-nothing // case first i = sCharClasses[mState]; if (i == 0) { // if not a legal character, signal with '1' if ( (c > '\ud7ff' && c < '\ue000') || c == '\ufffe' || c == '\uffff') b = 1;
else // neither NameC nor NameStart are interesting here, just // pretend we saw a '~', which will only match . b = '~'; }
// If a nameC is OK, pretend we saw a '1' else if ((i & sNameCMask) != 0 && CharClasses.isNameC((char) c)) b = '1';
// If a namestart transition is OK, pretend we saw an 'a' else if ( (i & sNameStartMask) != 0 && CharClasses.isNameStart((char) c)) b = 'a';
// not a legal character else b = 0; }
// All this work to enable these three lines of code
transition = sD[mState][b]; next = transition & sStateMask; special = (transition >> sSpecialShift) & 0xff;
// error handling if (next == 0) { String msg;
if (c > 127 && b == 1) msg = sIllegalCharacter; else if (c > 127 && b == 0) msg = sNonNameChar; else { i = mState; while (sErrorMessages[i].equals(sNullString)) i--; msg = sErrorMessages[i]; }
// unstack (heuristics at work) if (mStateStackInd > 0) mState = mPushedState[0]; next = sFB[mState] + 127; mSaving = false; clearSaved(); mSavedCharCount = 0; mStateStackInd = 0; if (complain(handler, msg, c)) return null; }
// can't set this directly from the transition as it's used for fallback mState = next;
// offset book-keeping mInputCharCount++; if (c == '\n') { mInputLineCount++; mLineOffset = 0; } else if (c != '\r') mLineOffset++;
// are there any specials attached to this transition? turnOnSave = false; if (special != 0) { // special dispatching specials = sSL[special]; special = 0;
while (special < specials.length) { // special < specials.length

switch(on = specials[special++]) { // Switch(Special)

case CharRefV: // if we're in an entity val, leave the character ref the way it is if (mInEntityVal) { special++; break; }
mCharBuf[0] = (char) specials[special]; text = currentText(); if (text != null) { if (mSaveText || (mCurrentAttrVal != null)) seg = new Segment(mCurrentEntity, mLastAmpOffset, mInputCharCount - mLastAmpOffset, 1, specials, special); else seg = new Segment(mCurrentEntity, mLastAmpOffset, mInputCharCount - mLastAmpOffset); text.addSegment(seg); } if ((mCurrentAttrVal == null) && !mWFError) dropOut = handler.doText(mCurrentEntity, mCurrentElement, mCharBuf, 1); special++; mLastTextOffset = mInputCharCount; turnOnSave = true; mSavedCharCount = 0; mSaving = false; break;

case ColdStartV: turnOnSave = true; mLastTextOffset = mInputCharCount; break;

case DeclareNotationV: clearSaved(); break;

case DeclareUnparsedV: if (mPEDecl) dropOut = complain(handler, sPEwithNDATA, ' ');
else if (mIgnoredSection == -1) { mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset - 1); if (!mWFError) { dropOut = handler.doSystemBinaryEntity(mCurrentEntity, (String) mSaved.elementAt(0), (String) mSaved.elementAt(1), (String) mSaved.elementAt(2)); } } clearSaved(); break;

case DebugV: break;
case DoANYV: clearSaved(); break;
case DoEMPTYV: clearSaved(); break;
case DoMixedV: clearSaved(); break;

case EndAttrValV: if (mSavedCharCount > 0) { seg = new Segment(mCurrentEntity, mLastTextOffset, mSavedCharCount, mSavedCharCount, mCharBuf); mCurrentAttrVal.addSegment(seg); } mSaving = false; mSaved.addElement(mCurrentAttrVal); mSavedCharCount = 0; mSavedStringCount++; mCurrentAttrVal = null; break;

case EndAttributeV: mSaving = false; mSaved.addElement(mANames.checkAndAdd(mCharBuf, mSavedCharCount)); mSavedCharCount = 0; mSavedStringCount++; break;
case EndDTDV: break;
case EndGIV: mSaving = false; mSaved.addElement(mElNames.checkAndAdd(mCharBuf, mSavedCharCount)); mSavedCharCount = 0; mSavedStringCount++; break;
case EndSaveV: mSaving = false; mSaved.addElement(new String(mCharBuf, 0, mSavedCharCount)); mSavedCharCount = 0; mSavedStringCount++; break;

case EnterAttrValV: mCurrentAttrVal = new Text(); break;
case EnterEntValV: mInEntityVal = true; break;

case EnterIgnoredMSV: // if this is the internal subset, complain if (!mInExternalDecls) dropOut = complain(handler, sMSinSubset, ' ');
// if we're not already ignoring, record the fact if (mIgnoredSection == -1) mIgnoredSection = mMarkedSectionDepth; mMarkedSectionDepth++; break;
case EnterIncludedMSV: // if this is the internal subset, complain if (!mInExternalDecls) dropOut = complain(handler, sMSinSubset, ' ');
mMarkedSectionDepth++; break;
case FloatingMSEV: dropOut = complain(handler, sFloatingMSE, ' '); break;
case GotXMLDV: String version = "1.0", encoding = null, standalone = null; if (mSavedStringCount > 1) { str = (String) mSaved.elementAt(1); if (str.equals("encoding")) encoding = (String) mSaved.elementAt(2); else standalone = (String) mSaved.elementAt(2); } if (mSavedStringCount > 3) standalone = (String) mSaved.elementAt(4); if (standalone != null) standalone = standalone.substring(0, standalone.length() - 1); clearSaved(); dropOut = handler.doXmlDeclaration(version, encoding, standalone); break;

case HashRefV:
// where the ref starts depends on whether we're in an // EntityVal (any old place in the text) or otherwise // (at the start of mCharBuf). if (mInEntityVal) { k = mSavedCharCount - (mInputCharCount - mLastAmpOffset); k+= 2; } else k = 0;
if (mCharBuf[k + 1] == 'x') { // mCharBuf contains '#xhhhh..." if ((mSavedCharCount - (k + 2)) > sMaxDigitsInHexCRef) { dropOut = complain(handler, sHexCRefTooLong, c); c = 0; } else { c = 0; for (i = 2; (k + i) < mSavedCharCount; i++) c = (c * 16) + Character.digit(mCharBuf[k + i], 16); } } else { // mCharBuf contains '#\d+' c = 0; for (i = 1; (k + i) < mSavedCharCount; i++) c = (c * 10) + Character.digit(mCharBuf[k + i], 10); }
// is this thing legal? if ( (c < 128 && !sIsChar[c]) || (c > '\ud7ff' && c < '\ue000') || (c == '\ufffe' || c == '\uffff')) dropOut = complain(handler, sIllegalCharacter, c);
// if we're in an entity value, forget the reference, // pretend we just read the computed character, // and we're outta here if (mInEntityVal) { mSavedCharCount -= (mInputCharCount - mLastAmpOffset); mSavedCharCount++; break; }
// Build a new segment for the character text = currentText(); mCharBuf[0] = (char) c; if (text != null) { if (mSaveText || (mCurrentAttrVal != null)) { newbuf = new char[1]; newbuf[0] = (char) c; seg = new Segment(mCurrentEntity, mLastAmpOffset, mInputCharCount - mLastAmpOffset, 1, newbuf, 0); } else seg = new Segment(mCurrentEntity, mLastAmpOffset, mInputCharCount - mLastAmpOffset); text.addSegment(seg); }
if ((mCurrentAttrVal == null) && !mWFError) dropOut = handler.doText(mCurrentEntity, mCurrentElement, mCharBuf, 1); mSavedCharCount = 0;
// if we're saving text, we don't want to save this thing // we just computed if (mSaving) { mSaving = false; turnOnSave = true; } break;

case HotStartV: mCharBuf[mSavedCharCount++] = (char) c; turnOnSave = true; break;

case InKWV: // matching in a string if (c != sKW[mKeyword].charAt(mKeywordPos++)) { dropOut = complain(handler, sBustedKW + sKW[mKeyword], c);
// once we're hosed... if (mStateStackInd > 0) mState = mPushedState[0]; mState = sFB[mState] + 127; clearSaved(); mSavedCharCount = 0; break; }
// exhausted string? if (mKeywordPos >= sKW[mKeyword].length()) mState = mPushedState[--mStateStackInd];
break;

case KeywordV: mKeyword = specials[special++]; mPushedState[mStateStackInd++] = specials[special++] + 127; mKeywordPos = specials[special++]; break;

case LeaveMarkedSectV: if (mMarkedSectionDepth == 0) { dropOut = complain(handler, sFloatingMSE, ' '); break; } mMarkedSectionDepth--; if (mIgnoredSection == mMarkedSectionDepth) mIgnoredSection = -1; break;

case MarkAmpV: mLastAmpOffset = mInputCharCount - 1; break;

case MarkConnectorV: break;

case MarkLtV: if (mCurrentAttrVal != null) dropOut = complain(handler, sLTInAttrVal, ' ');
else mLastLtOffset = mInputCharCount - 1; break;

case MarkPCV: mRefIsToPE = true; mLastAmpOffset = mInputCharCount - 1;
// not at top level - can't be internal subset if (!mInExternalDecls) dropOut = complain(handler, sNoTopLevelPE, c); break;
case MarkPcAtTopLevelV: mRefIsToPE = true; mLastAmpOffset = mInputCharCount - 1; break;

case MarkRepV: break;
case PopV: // conditional only necessary because we might've had a // syntax error and unrolled the state stack if (mStateStackInd > 0) mState = mPushedState[--mStateStackInd]; break;
case PopCPV: if (mIgnoredSection != -1) { clearSaved(); break; }
// hit ')' in a content particle; if we've unrolled // the whole stack, then we'll record the element // declaration --mStateStackInd; if (mStateStackInd < cModelStart) { // unbalanced parantheses dropOut = complain(handler, sBadParenInCM, c); break; } clearSaved(); mState = mPushedState[mStateStackInd]; break;
case PushV: mPushedState[mStateStackInd++] = specials[special++] + 127; break;
case ReportAttDeclV: if (mIgnoredSection != -1) break;
// if the attlist isn't of size 3N + 1, then we lost a // trailing missing default; stick it on to save run-time if (((mSavedStringCount - 1) % 3) != 0) { mSaved.addElement(null); mSavedStringCount++; }
break;

case ReportAttlistV: if (mIgnoredSection == -1) { mCurrentEntity.setOffsets(mLastLtOffset, mInputLineCount, mLineOffset); attlist = new Object[mSavedStringCount]; for (i = 0; i < mSavedStringCount; i++) attlist[i] = mSaved.elementAt(i); if (!mWFError) dropOut = handler.doAttlist(mCurrentEntity, attlist);
// File away any defaults for instance processing rememberDefaults(mSaved, mSavedStringCount); } clearSaved(); break;

case ReportDoctypeV#ql:ReportDoctypeV#: // First saved string is the doctype name. // If there are two, the second is the SYSTEM ID // If there are three, the second is the PUBLIC ID // and the third the System ID mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset); if (!mWFError) { url = null; str = (String) mSaved.elementAt(0); switch (mSavedStringCount) { case 1: dropOut = handler.doDoctype(mCurrentEntity, str, null, null); break; case 2: dropOut = handler.doDoctype(mCurrentEntity, str, null, url = (String) mSaved.elementAt(1)); break; case 3: dropOut = handler.doDoctype(mCurrentEntity, str, (String) mSaved.elementAt(1), url = (String) mSaved.elementAt(2)); break; }

if (url != null) { // If we got a SYSTEM ID and have been told to process // external entities, pretend we saw an external // entity ref if (!mProcessExternalEntities) mBypassedExternalDecls = true; else { URL newURL = null;
// lotta common code here with ReportRef below... // but two return values needed, dropOut and input try { newURL = new URL(mCurrentEntity.baseURL(), url); input = new XmlInputStream(newURL.openStream()); } catch (MalformedURLException x) { error = new StringBuffer(sRottenURL).append(url).append("]"); } catch (IOException x) { error = new StringBuffer(sCantGetURL).append(url); } if (error != null) { dropOut = handler.doSyntaxError(mCurrentEntity, error.toString(), c); signalWFError(); } else { // no error mInputCharCount = 0; mInputLineCount = 1; mCurrentEntity = new Entity(true, input, null, url, mCurrentEntity, true, newURL); mPushedState[0] = mStateBeforeDTD = mState; mInExternalDecls = true; mStateStackInd = 1; mState = sDTDState; mStack.push(mCurrentEntity); } // no error } // want external entities } // we have a SYSTEM id } // !mWFError clearSaved(); break;

case ReportETagV: mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset); str = (String) mSaved.elementAt(0); clearSaved();
// check proper nesting next = mStack.search(str); if (next == 1) { // yes, nesting is clean mStack.pop();
mLastTextOffset = mInputCharCount; mCurrentElement.setOffsets(-1, mInputCharCount);
// really only necessary if not building tree mCurrentElement.setType(str);

if (!mWFError) dropOut = dropOut || handler.doETag(mCurrentEntity, mCurrentElement);
if (mBuildTree && ((parent = mCurrentElement.parent()) != null)) mCurrentElement = parent;
// last tag? if (mStack.empty()) mState = sAfterDocState; else turnOnSave = true; }
else { // oops, nesting botched somehow; check for case botch if ( (!mStack.empty()) && (mStack.peek() instanceof String) && str.equalsIgnoreCase((String) mStack.peek())) { // top-of-stack element that should match differs only in case error = new StringBuffer(sCaseBotch); error = error.append((String) mStack.pop()).append("/").append(str); }
// could be element/entity mismatch else if ( (!mStack.empty()) && (mStack.peek() instanceof Entity)) { while ( (!mStack.empty()) && (!(mStack.peek() instanceof String))) mStack.pop(); error = new StringBuffer(sEntityNesting); next = mStack.search(str); } else if (next > 1) { // element at top of stack doesn't match end tag; // We're into heuristics here; // Try popping off any other apparently-closed elements error = new StringBuffer(sBadNest); error = error.append("</").append(str).append(">"); error = error.append(sExpected).append("</"); error = error.append((String) mStack.peek()).append(">"); for (i = 1; i < next; i++) { error = error.append(sGenEnd).append("</"); error = error.append((String) mStack.pop()).append(">"); if (mBuildTree) { mCurrentElement.offsets(offsets); error = error.append(" (start offset: " + offsets[0] + ", "); error = error.append("line " + mCurrentElement.startedOnLine()); } if ( mBuildTree && ((parent = mCurrentElement.parent()) != null)) mCurrentElement = parent; }
// don't forget to pop the one we saw mStack.pop(); if (mBuildTree) mCurrentElement = mCurrentElement.parent(); } else if (next == -1) { // no match to this end-tag on the stack error = new StringBuffer(sBadNest); error = error.append("</").append(str).append(">"); error = error.append(sNotOpened); }
// common error code dropOut = handler.doSyntaxError(mCurrentEntity, error.toString(), ' '); signalWFError(); } break;

case ReportInternalEntityV: if (mIgnoredSection != -1) { clearSaved(); break; }
// We want to use these as a char[] array, so have to // convert them back since they were saved as a string, // oh well i = mSavedStringCount - 2; j = mSavedStringCount - 1; str = (String) mSaved.elementAt(j); eval = str.toCharArray(); mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset);
// if we were in an internal entity value, we're not now mInEntityVal = false;
if (!mWFError) dropOut = handler.doInternalEntity(mCurrentEntity, (String) mSaved.elementAt(i), eval);
// don't do it if it's already defined str = (String) mSaved.elementAt(i); if (mPEDecl) { if ( mInternalPEs.get(str) == null && mExternalPEs.get(str) == null) mInternalPEs.put(str, eval); } else { if ( mInternalEntities.get(str) == null && mExternalTextEntities.get(str) == null) mInternalEntities.put((String) mSaved.elementAt(i), eval); }
mPEDecl = false; mSaved.removeElementAt(j); mSaved.removeElementAt(i); mSavedStringCount -= 2; break;

case ReportDefKWV: // we just saw#IMPLIED,#REQUIRED, or#FIXED mSaving = false; mSavedCharCount = 0; break;

case ReportPIV: // First string is target; anything saved up // is the rest of the PI String target, rest = null; target = (String) mSaved.elementAt(0); if (target.equalsIgnoreCase("xml")) dropOut = complain(handler, sPITargetXML, ' '); if (mSavedCharCount > 0) rest = new String(mCharBuf, 0, mSavedCharCount - 1);
mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset); if (!mWFError) dropOut = dropOut || handler.doPI(mCurrentEntity, target, rest); mSavedCharCount = 0; clearSaved(); mSaving = false; if (mState == sInDocState) turnOnSave = true; break;

case ReportReferenceV:
// if we're in an entity val, leave the reference the way it is, // unless it's a PERef, in which case we expand it inline // 'str' is the entity name boolean busted = false; if (mInEntityVal) { char[] temp; int len; if (!mRefIsToPE) break;
len = (mInputCharCount - mLastAmpOffset) - 2; temp = new char[len]; for (i = 0; i < len; i++) temp[i] = mCharBuf[i + mSavedCharCount - len]; str = mEntNames.checkAndAdd(temp, len); mSavedCharCount -= (mInputCharCount - mLastAmpOffset); mSavedCharCount++; } else str = mEntNames.checkAndAdd(mCharBuf, mSavedCharCount);
// check for recursive ref Entity parentEntity; for (parentEntity = mCurrentEntity; parentEntity != null; parentEntity = parentEntity.parent()) { if (str == parentEntity.name()) { dropOut = dropOut || handler.doSyntaxError(mCurrentEntity, sRecursiveRef, ' '); signalWFError(); busted = true; } } if (busted) break;
// set offsets to tell handler where reference started mCurrentEntity.setOffsets(mLastAmpOffset, mInputLineCount, mLineOffset - (mInputCharCount - mLastAmpOffset));
// which tables we look in depends on whether this is a // general or parameter entity if (mRefIsToPE) { internalTable = mInternalPEs; externalTable = mExternalPEs; } else { internalTable = mInternalEntities; externalTable = mExternalTextEntities; }
if ((eval = (char[]) internalTable.get(str)) != null) {
// yep, it's an internal entity if (!mWFError) dropOut = handler.doEntityReference(mCurrentEntity, str);
// reset offsets for actual input position (after reference) mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset); mInputCharCount = 0; mInputLineCount = 1; input = new XmlInputStream(eval); mCurrentEntity = new Entity(false, input, str, "Internal: (" + str + ")", mCurrentEntity, mRefIsToPE, mCurrentEntity.baseURL()); } else if ((url = (String) externalTable.get(str)) != null) { // this is an external entity
// yes, it's an external entity if (!mWFError) dropOut = handler.doEntityReference(mCurrentEntity, str);
// reset offsets for actual input position (after reference) mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset);
// XML disallows external entities in attribute values if (mCurrentAttrVal != null) { error = new StringBuffer(sExtRefInAttr).append(str).append(";"); dropOut = handler.doSyntaxError(mCurrentEntity, error.toString(), ' '); signalWFError(); busted = true; }
// OK, let's go try to read the external entity else { // we have a URL, and we're not in an attribute val URL newURL = null;
if (mProcessExternalEntities) { try { newURL = new URL(mCurrentEntity.baseURL(), url); input = new XmlInputStream(newURL.openStream()); } catch (MalformedURLException x) { error = new StringBuffer(sRottenURL).append(url); } catch (IOException x) { error = new StringBuffer(sCantGetURL).append(url); } if (error != null) { dropOut = handler.doSyntaxError(mCurrentEntity, error.toString(), ' '); signalWFError(); busted = true; } else { mInputCharCount = 0; mInputLineCount = 1; mCurrentEntity = new Entity(true, input, str, url, mCurrentEntity, mRefIsToPE, newURL); } } // if mProcessExternalEntities
// an external entity, but we're not going to process it. // This *might* amount to bypassing an external declaration, // but only if this is a PE *and* we're in the base DTD state // else if ((mState == sDTDState) && (!mInExternalDecls) && mRefIsToPE) { mBypassedExternalDecls = true; busted = true; } } // we have a URL, and we're not in an attribute val } // this is an external entity
else { // This entity didn't turn up in any of our tables // This is technically a WF violation, but we can ignore // it if they haven't asked for external entities busted = true; error = new StringBuffer(sNoSuchEntity); error = error.append(str).append("'"); if (mBypassedExternalDecls) { error = error.append(sMaybeExternal); dropOut = handler.doWarning(mCurrentEntity, error.toString()); } else { signalWFError(); dropOut = handler.doSyntaxError(mCurrentEntity, error.toString(), ' '); }
// reset offsets for actual input position (after reference) mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset); }
// if this is a PE, and we're not in an EntityValue, prepend space // Also, this is the one case where we dereference entities in // a mode where no text is being saved if (mRefIsToPE && !mInEntityVal) { stuffedChar = ' '; } else { turnOnSave = true; mLastTextOffset = mInputCharCount; }
// if busted == false, then we really did enter the new // entity = push it on the stack if (!busted) mStack.push(mCurrentEntity);
mSaving = false; if (!mInEntityVal) mSavedCharCount = 0; mRefIsToPE = false; break;

case ReportSTagV:

case ReportEmptyV: Attribute[] defaultAttributes = null;
acount = (mSavedStringCount - 1) / 2; defaultAttributes = mElNames.defaultAttributes(); dcount = (defaultAttributes == null) ? 0 : defaultAttributes.length;
// have to figure out which of the defaults are needed // because they haven't been supplied dused = dcount; for (i = 1; i < mSavedStringCount; i += 2) { str = (String) mSaved.elementAt(i);
// check against the defaults for this element type for (j = 0; j < dcount; j++) if (str == defaultAttributes[j].name()) dused--;
// check for dupe attribute names for (k = i + 2; k < mSavedStringCount; k += 2) if (str == (String) mSaved.elementAt(k)) dropOut = complain(handler, sDupeAttributeName + str, ' '); } if (mBuildTree) { parent = mCurrentElement; mCurrentElement = handler.element(); if (mBuilding) mCurrentElement.setParent(parent); mBuilding = true; theseAttributes = new Attribute[acount + dused]; for (i = 0; i < acount; i++) theseAttributes[i] = new Attribute(null, (String) null); } else theseAttributes = mScratchAttrs[acount + dused];
str = (String) mSaved.elementAt(0); mCurrentElement.setType(str); if (on == ReportEmptyV) { mCurrentElement.setEmpty(true); empty = true; } else { if (mEmpty != null && mEmpty.get(str) != null) { mCurrentElement.setEmpty(true); empty = true; } else { empty = false; mCurrentElement.setEmpty(false); mStack.push(str); } } for (i = 0; i < acount; i++) { theseAttributes[i].setName((String) mSaved.elementAt((i*2) + 1)); theseAttributes[i].setValue((Text) mSaved.elementAt((i*2) + 2)); }
// once again, only supply missing defaulted attributes dused = 0; for (i = 0; i < dcount; i++) { for (j = 0; j < acount; j++) if (mSaved.elementAt((j*2) + 1) == defaultAttributes[i].name()) break; if (j == acount) theseAttributes[acount + dused++] = defaultAttributes[i]; }
mCurrentElement.setAllAttributes(theseAttributes); mCurrentEntity.setOffsets(mLastLtOffset, mInputLineCount, mLineOffset); if (empty) mCurrentElement.setOffsets(mLastLtOffset, mInputCharCount); else mCurrentElement.setOffsets(mLastLtOffset, -1); mCurrentElement.setStartedOnLine(mInputLineCount); mSawRoot = true;
if (!mWFError) { dropOut = handler.doSTag(mCurrentEntity, mCurrentElement);
}
if (mBuildTree && ((parent = mCurrentElement.parent()) != null)) { parent.addChild(mCurrentElement); if (empty) mCurrentElement = parent; } if (empty && mStack.empty()) mState = sAfterDocState; mLastTextOffset = mInputCharCount; turnOnSave = true; clearSaved(); break;

case ReportSystemTextEntityV: if (mIgnoredSection != -1) { clearSaved(); break; }
mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset);
// might have (sigh) a PUBLIC ID if (mSavedStringCount == 2) str = (String) mSaved.elementAt(1); else str = (String) mSaved.elementAt(2);
ename = (String) mSaved.elementAt(0); if (mPEDecl) { if ( mInternalPEs.get(ename) == null && mExternalPEs.get(ename) == null) mExternalPEs.put(ename, str); } else { if ( mInternalEntities.get(ename) == null && mExternalTextEntities.get(ename) == null) mExternalTextEntities.put(ename, str); }
if (!mWFError) dropOut = handler.doSystemTextEntity(mCurrentEntity, (String) mSaved.elementAt(0), str); clearSaved(); break;

case ReportTextV: mSaving = false; if (mSavedCharCount == 0) break;
text = currentText(); if (text != null) { if (mCurrentAttrVal != null) // adding to an attr val, just make the storage seg = new Segment(mCurrentEntity, mLastTextOffset, mSavedCharCount, mSavedCharCount, mCharBuf); else if (mSaveText) { // if saving text if (mDocEntityBuffer != null) // if we're reading out of the base buffer seg = new Segment(mCurrentEntity, mLastTextOffset, mSavedCharCount, mSavedCharCount, mDocEntityBuffer, mLastTextOffset); else // else he has to find a place to put it seg = new Segment(mCurrentEntity, mLastTextOffset, mSavedCharCount, mSavedCharCount, mCharBuf); } // if saving text else // not saving text seg = new Segment(mCurrentEntity, mLastTextOffset, mSavedCharCount); text.addSegment(seg); } mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset - 1); if ((mCurrentAttrVal == null) && !mWFError) { dropOut = dropOut || handler.doText(mCurrentEntity, mCurrentElement, mCharBuf, mSavedCharCount); }
mSavedCharCount = 0; break;

case SaveExtraV: max = specials[special++]; for (i = 0; i < max; i++) mCharBuf[mSavedCharCount++] = (char) specials[special++]; mSaving = true; break;
case SignalPEV: mPEDecl = true; break;
case StartCMV: cModelStart = mStateStackInd; mPushedState[mStateStackInd++] = sDoneElementContentState; clearSaved(); break;
case StartCPV: clearSaved(); break;

case StuffCharV: stuffedChar = c; break;
} // Switch(special)
if (dropOut) { more = false; break; } } // special < specials.length } // if (special != 0)
if (mSaving) { // expand with 1 left to spare, so that we can // HotStart with no check if (mSavedCharCount == mThreshold) { newbuf = new char[mCharBuf.length * 2]; for (i = 0; i < mCharBuf.length; i++) newbuf[i] = mCharBuf[i]; mCharBuf = newbuf; mThreshold = mCharBuf.length - 1; } mCharBuf[mSavedCharCount++] = (char) c; }
if (turnOnSave) mSaving = true; } // while (more)
if (mWFError || !mBuildTree) return null;
if (mBuildTree) { for (el = mCurrentElement, parent = el.parent(); parent != null; el = parent, parent = el.parent()) ; // Empty return el; } else return mCurrentElement; }

private void lk'l'clearSaved()
{ mSaved.removeAllElements(); mSavedStringCount = 0; }

// Return the Text object to which some newly discovered text should // be added // If we're not building the tree or in an attribute value, then there's // no need to be wrangling text objects, so return null
private Text lk'l'currentText()
{ Vector children; Object last; Text text;
// if we're doing an attribute, then that'll be it if (mCurrentAttrVal != null) return mCurrentAttrVal;
// not an attribute; if the last child of the current element // is a Text, just append to it. Otherwise make a new one for // the purpose, but only if we're building the tree. if (!mBuildTree) return null;
children = mCurrentElement.children(); if (!children.isEmpty()) { last = children.lastElement(); if (last instanceof Text) return (Text) last; } text = new Text(); children.addElement(text); return text; }
// Stash the defaults associated with a GI private void rememberDefaults(Vector saved, int count) { int i, j, d; int dcount = 0; Attribute[] defaults; Attribute[] oldDefaults; boolean[] haveDefaults; String type = (String) mSaved.elementAt(0);
// do we have defaults for this guy already? oldDefaults = mElNames.getDefaults(type);
// count attrs with defaults haveDefaults = new boolean[(count - 1) / 3]; for (i = 1; i < count; i += 3) { d = (i - 1) / 3; haveDefaults[d] = false; if (mSaved.elementAt(i + 2) != null) { // we have a default dcount++; haveDefaults[d] = true;
// but if we already did, ignore it if (oldDefaults != null) for (j = 0; j < oldDefaults.length; j++)
// these are both in namer, so uniquified strings if (mSaved.elementAt(i) == oldDefaults[j].name()) { dcount--; haveDefaults[d] = false; } } }
if (oldDefaults != null) dcount += oldDefaults.length; defaults = new Attribute[dcount]; j = 0; for (i = 1; i < count; i += 3) if (haveDefaults[(i-1) / 3]) defaults[j++] = new Attribute((String) mSaved.elementAt(i), (Text) mSaved.elementAt(i + 2));
if (oldDefaults != null) for (i = 0; i < oldDefaults.length; i++) defaults[j++] = oldDefaults[i];
mElNames.updateDefaults(type, defaults); }

private void lk'l'signalWFError()
{ mWFError = true; }

private boolean lk'l'complain(Handler handler, String message, int c)
{ mCurrentEntity.setOffsets(mInputCharCount, mInputLineCount, mLineOffset); signalWFError(); return handler.doSyntaxError(mCurrentEntity, message, c); } }

lk'Handler.java (h)

name::
* McsEngl.lk'Handler.java (h)@cptItsoft,

lk'h'METHODS:

public boolean doAttlist(Entity e, Object[] parts)
public boolean doDoctype(Entity e, String rootType, String publicID, String systemID)
public boolean doEntityReference(Entity e, String name)
public boolean doETag(Entity e, Element element)
public boolean doInternalEntity(Entity e, String name, char[] value)
public boolean doPI(Entity e, String target, String rest)
public boolean doSTag(Entity e, Element element)
public boolean doSystemBinaryEntity(Entity e, String name, String extID, String notation)
public boolean doSyntaxError(Entity e, String message, int c)
public boolean doSystemTextEntity(Entity e, String name, String extID)
public boolean doText(Entity ent, Element el, char[] text, int length)
public boolean doValidityError(Entity ent, String message)
public boolean doWarning(Entity e, String message)
public boolean doXmlDeclaration(String version, String encoding, String Standalone)
public Element element()

========== CODE ==========

package textuality.lark;

// Class designed to handle parsing events generated by Lark.
// Subclass this to do what you will.
// Each method, if it returns true, will cause readXML to // return control to the caller

public class Handler {

// Attlist declaration. The first string will be the GI, // the next 3N the parts of the attlist; each triple contains // the attr name, its type, and either null, meaning no default value, // or the default value as a Text object
public boolean lk'h'doAttlist(Entity e, Object[] parts)
{ return false; }

// Doctype declaration
public boolean lk'h'doDoctype(Entity e, String rootType, String publicID, String systemID)
{ return false; }

// Entity reference detected; e is the containing entity, // not the one that was detected
public boolean lk'h'doEntityReference(Entity e, String name)
{ return false; }

// End-tag detected; the element should be complete if the tree is being // built; otherwise, the only useful information is the end-offset and // the type.
public boolean lk'h'doETag(Entity e, Element element)
{ return false; }

// Internal (text) entity declaration
public boolean lk'h'doInternalEntity(Entity e, String name, char[] value)
{ return false; }

public boolean lk'h'doPI(Entity e, String target, String rest)
{ return false; }

// Start tag detected; the element will in general be // incomplete, unless element.empty() is true
public boolean lk'h'doSTag(Entity e, Element element)
{ return false; }

// Error condition detected; the entity e will have the // current locational information filled in
public boolean lk'h'doSyntaxError(Entity e, String message, int c)
{ System.out.print("Lark:" + e.description() + ":" + e.lineCount() + ":" + e.lineOffset() + ":E:Fatal: " + message); if (c != ' ') System.out.print(" - character '"+ (char) c+"'"); while (!e.textIsReal()) { e = e.parent(); System.out.print("\n from:" + e.description() + ":" + e.lineCount() + ":" + e.lineOffset()); } System.out.println();
return false; }

// NDATA entity declaration
public boolean lk'h'doSystemBinaryEntity(Entity e, String name, String extID, String notation)
{ return false; }

// External text entity declaration; external ID is a URL
public boolean lk'h'doSystemTextEntity(Entity e, String name, String extID)
{ return false; }

// Detected a text segment
public boolean lk'h'doText(Entity ent, Element el, char[] text, int length)
{ //System.out.println("TEXT ("+ (new String(text, 0, length))+")"); return false; }

// detected a validity error
public boolean lk'h'doValidityError(Entity ent, String message)
{ System.out.println("Lark:" + ent.description() + ":" + ent.lineCount() + ":" + ent.lineOffset() + ":V: " + message); return false; }

// A warning from Lark
public boolean lk'h'doWarning(Entity e, String message)
{ System.out.println("Lark:" + e.description() + ":" + e.lineCount() + ":" + e.lineOffset() + ":W: " + message); return false; }

// XML Declaration
public boolean lk'h'doXmlDeclaration(String version, String encoding, String Standalone)
{ return false; }

// used when a new element is needed. If you want to // subclass element use your own, here's the place to hook in
public Element lk'h'element()
{ return new Element#ql:lk'el'Element#(); }

}

lk'Element.java (el)

name::
* McsEngl.lk'Element.java (el)@cptItsoft,

lk'el'METHODS:
public Element()

public void addChild(Element child)
public Attribute[] allAttributes()
public Attribute attribute(String name)
public Vector children()
public String content()
public boolean empty()
public void offsets(int[] offsets)
public Element parent()
public void setAllAttributes(Attribute[] attributes)
public void setAttribute(String name, String value)
public void setEmpty(boolean empty)
public void setOffsets(int start, int end)
public void setParent(Element parent)
public void setStartedOnLine(int line)
public void setType(String type)
public int startedOnLine()
public String type()

package textuality.lark;

import java.util.*;

// Lark's view of an XML element
public class Element
implements Cloneable {

lk'el'FIELDS:
String mType; // the GI
Attribute[] mAttrs; // Attributes
boolean mEmpty; // true if this is an Empty element
// offset info. XXX this is not too useful as it stands, // since they are relative to the containing Entity
int[] mOffsets = new int[2]; int mStartedOnLine;

// Children are a Vector because they might be Elements // and they might be Text objects
Vector mChildren = new Vector();

// Parent element. null does not mean this is the root, // it just means this is where Lark started constructing // the tree.
Element mParent;

// Trivial get/set methods
public lk'el'Element()
{ mParent = null; }

public void lk'el'setStartedOnLine(int line)
{ mStartedOnLine = line; }

public int lk'el'startedOnLine()
{ return mStartedOnLine; }

public String lk'el'type()
{ return mType; }

public void lk'el'setType(String type)
{ mType = type; }

public Attribute[] lk'el'allAttributes()
{ return mAttrs; }

public void lk'el'setAllAttributes(Attribute[] attributes)
{ mAttrs = attributes; }

public boolean lk'el'empty()
{ return mEmpty; }

public void lk'el'setEmpty(boolean empty)
{ mEmpty = empty; }

public void lk'el'offsets(int[] offsets)
{ offsets[0] = mOffsets[0]; offsets[1] = mOffsets[1]; }

public void lk'el'addChild(Element child)
{ mChildren.addElement(child); }

public Element lk'el'parent()
{ return mParent; }

public void lk'el'setParent(Element parent)
{ mParent = parent; }

public Vector lk'el'children()
{ return mChildren; }

// usually, Lark doesn't know the start and end at the same time
public void lk'el'setOffsets(int start, int end)
{ if (start != -1) mOffsets[0] = start; if (end != -1) mOffsets[1] = end; }

// get attribute by name
public Attribute lk'el'attribute(String name)
{ int i; for (i = 0; i < mAttrs.length; i++) if (name.equals(mAttrs[i].name())) return mAttrs[i]; return null; }

// set attribute by name
public void lk'el'setAttribute(String name, String value)
{ int i; for (i = 0; i < mAttrs.length; i++) if (name.equals(mAttrs[i].name())) mAttrs[i].setValue(value); }

// get content of element as string (*dangerous*)
public String lk'el'content()
{ int i; StringBuffer content = new StringBuffer(); Object child;
for (i = 0; i < mChildren.size(); i++) { child = mChildren.elementAt(i); if (child instanceof Text) content.append(child.toString()); else if (child instanceof Element) content.append(((Element) child).content()); } return new String(content); }

}

lk'Attribute.java (a)

name::
* McsEngl.lk'Attribute.java (a)@cptItsoft,

lk'a'METHODS:
public Attribute(String name, String value)
public Attribute(String name, Text text)
public String name()
public void setName(String name)
public String value()
public void setValue(String value)
public void setValue(Text text)

package textuality.lark;
public class Attribute {

lk'a'FIELDS:
String mName;
String mValue;
Text mText;

public lk'a'Attribute(String name, String value)
{ mName = name; mValue = value; }

// constructor based on Text
public lk'a'Attribute(String name, Text text)
{ mName = name; mValue = null; mText = text; }

public String lk'a'name()
{ return mName; }

public void lk'a'setName(String name)
{ mName = name; }

public String lk'a'value()
{ if (mValue == null) mValue = mText.toString(); return mValue; }

public void lk'a'setValue(String value)
{ mValue = value; }

public void lk'a'setValue(Text text)
{ mText = text; mValue = null; }

}

lk'XmlInputStream (x) extends BufferedInputStream

name::
* McsEngl.lk'XmlInputStream (x) extends BufferedInputStream@cptItsoft,

lk'x'METHODS:
public XmlInputStream(char[] charBuf)
public XmlInputStream(InputStream in) throws IOException, Exception
public String encoding()
public int getXmlChar() throws IOException
private void testStream() throws Exception

package textuality.lark;

import java.io.*;

public class XmlInputStream
extends BufferedInputStream {

// this exists to provide getXmlChar; the implementation is I think // pretty efficient for ISOLatin1 and native encodings, UTF8 is // inefficient enough that I just copied the implementation from // the Unicode standard, to avoid having to think
// XXX to-do: the GetChar needs to be enhanced to // say how many underlying bytes were consumed in // producing the char() object.

lk'x'FIELDS:
static final int sISOLatin1V = 1;
static final int sNativeFEFFV = 2;
static final int sNativeFFFEV = 3;
static final int sFirstBytesV = 4;
static final int sJustCharsV = 5;
static final int sUTF8V = 6;
static final int s2power6 = 0x40;
static final int s2power12 = 0x1000;
static final int s2power18 = 0x40000;
static final int s2power24 = 0x1000000;
static final int s2power30 = 0x40000000;
static byte[] sJunkBytes = {0, 0};
static ByteArrayInputStream sJunkBA = new ByteArrayInputStream(sJunkBytes); static String sBotchedEncPI = "Broken Encoding Declaration in initial PI";
static String sCantDo = "Can't process encoding: '";
static String sNativeNoBOM = "Native (UCS-2 or UTF-16) encoding needs Byte Order Mark";
int mInputEncoding = sISOLatin1V;
int mCharBufInd = 0;
int mFirstBytesRead = 0;
char[] mCharBuf;
int mLowUTF16Waiting = 0;
// for testing the stream's encoding // The trick is, unless we're operating out of a char buffer, we // initially read some stuff into mFirst2Bytes and decide on that // basis what the encoding will be. Then we live in sFirstBytesV mode // for a couple of calls int mEncodingWillBe = -1;

public lk'x'XmlInputStream(InputStream in) throws IOException, Exception
{ super(in); testStream#ql:lk'x'testStream#(); }

public lk'x'XmlInputStream(char[] charBuf)
{ super(sJunkBA); mInputEncoding = sJustCharsV; mCharBuf = charBuf; }

public String lk'x'encoding()
{ int encoding;
if (mInputEncoding == sFirstBytesV) encoding = mEncodingWillBe; else encoding = mInputEncoding;
switch (encoding) { case sISOLatin1V: return "ISOLatin1"; case sNativeFEFFV: return "Native"; case sNativeFFFEV: return "Native"; case sJustCharsV: return "Native"; // ??? guess have to testStream? case sUTF8V: return "UTF-8"; default: return "ISOLatin1"; } }

public int lk'x'getXmlChar() throws IOException
{ int c1, c2; int y, x, z, w, v, u, plane;
switch (mInputEncoding) { // Optimization note: we could in fact have separate subclasses for each of // these puppies and thus avoid one switch() statement per character case sISOLatin1V: // this feels dangerous and evil; but these fields // are, after all, documented if (count > 0 && pos < count) { c1 = (int) buf[pos++]; if (c1 < 0) c1 = 128 + (c1 & 0x7f); return c1; } else return read();
case sNativeFEFFV: if (count>0 && pos<count){if ((c1=buf[pos++])<0)c1=128+(c1&0x7f);}else c1=read(); if (count>0 && pos<count){if ((c2=buf[pos++])<0)c2=128+(c2&0x7f);}else c2=read(); return (c1 << 8) | c2;
case sNativeFFFEV: if (count>0 && pos<count){if ((c1=buf[pos++])<0)c1=128+(c1&0x7f);}else c1=read(); if (count>0 && pos<count){if ((c2=buf[pos++])<0)c2=128+(c2&0x7f);}else c2=read(); return (c2 << 8) | c1;
case sFirstBytesV: if (mCharBufInd == mFirstBytesRead) { mInputEncoding = mEncodingWillBe; return getXmlChar(); } return mCharBuf[mCharBufInd++];
case sJustCharsV: if (mCharBufInd == mCharBuf.length) return -1; return mCharBuf[mCharBufInd++];
case sUTF8V:
// to quote Unicode, from // http://www.unicode.org/unicode/standard/wg2n1036.html // z < C0; z; // z < E0; y; (z-C0)*2^6 + (y-80); // z < F0; y; x; (z-E0)*2^12 + (y-80)*2^6 + (x-80); // z < F8; y; x; w; (z-F0)*2^18 + (y-80)*2^12 + (x-80)*2^6 + (w-80); // z < FC; y; x; w; v; (z-F8)*2^24 + (y-80)*2^18 + (x-80)*2^12 + (w-80)*2^6 + (v - 80); // z; y; x; w; v; u; (z-FC)*2^30 + (y-80)*2^24 + (x-80)*2^18 + (w-80)*2^12 + (v-80)*2^6 + (u-80); if (mLowUTF16Waiting != 0) { c1 = mLowUTF16Waiting; mLowUTF16Waiting = 0; return c1; }
// this feels dangerous and evil; but these fields // are, after all, documented if (count > 0 && pos < count) { c1 = (int) buf[pos++]; if (c1 < 0) c1 = 128 + (c1 & 0x7f); } else c1 = read(); if (c1 < 0xc0) { return c1; } if (c1 < 0xe0) { z = c1; y = read(); return ((z-0xC0)*s2power6) + (y-0x80); } if (c1 < 0xf0) { z = c1; y = read(); x = read(); return ((z-0xE0)*s2power12) + ((y-0x80)*s2power6) + (x-0x80); } // here we blow past 16 bits c2 = 0; if (c1 < 0xf8) { z = c1; y = read(); x = read(); w = read(); c2 = ((z-0xF0)*s2power18) + ((y-0x80)*s2power12) + ((x-0x80)*s2power6) + (w-0x80); } else if (c1 < 0xfc) { z = c1; y = read(); x = read(); w = read(); v = read(); c2 = ((z-0xF8)*s2power24) + ((y-0x80)*s2power18) + ((x-0x80)*s2power12) + ((w-0x80)*s2power6) + (v - 0x80); } else { z = c1; y = read(); x = read(); w = read(); v = read(); u = read(); c2 = ((z-0xFC)*s2power30) + ((y-0x80)*s2power24) + ((x-0x80)*s2power18) + ((w-0x80)*s2power12) + ((v-0x80)*s2power6) + (u-0x80); }
// which plane? plane = c2 >> 16; if ((c2 >> 16) > 0x10) throw new IOException("UTF8 encodes non-Unicode character");
// make UTF16 c2 &= 0xffff; plane--; // d800 represents plane *1*, not plane 0 c2 |= (plane << 16); mLowUTF16Waiting = c2 & 0xdfff; return (c2 >> 10) & 0xdbff;
default: throw new IOException("Bogus Input Encoding in getXmlChar()"); } }

private void lk'x'testStream() throws Exception
{ int bytesRead;
int i, j; char stopper; String PI;
mCharBuf#ql:mCharBuf lk'x'fields# = new char[256]; mCharBuf[0] = (char) super.read();
mCharBuf[1] = (char) super.read();
if (mCharBuf[0] == 0xff && mCharBuf[1] == 0xfe)
{ mInputEncoding = sNativeFFFEV; return; }
if (mCharBuf[0] == 0xfe && mCharBuf[1] == 0xff)
{ mInputEncoding = sNativeFEFFV; return; }
// assume ISOLatin1
mEncodingWillBe = sISOLatin1V;
mFirstBytesRead = bytesRead = 2; mInputEncoding = sFirstBytesV;
// If no PI, all done
if (mCharBuf[0] != '<' || mCharBuf[1] != '?') return;
// read PI // If we run off the end of file, serve the bozos right
do { mCharBuf[bytesRead++] = (char) super.read(); }
while (mCharBuf[bytesRead - 2] != '?' || mCharBuf[bytesRead - 1] != '>'); mFirstBytesRead = bytesRead;
// now the PI is in mCharBuf
PI = new String(mCharBuf, 0, bytesRead);
// if it doesn't begin <?XML, and have ENCODING then we'll just use default
if (PI.indexOf("<?xml") != 0) return; i = PI.indexOf("encoding"); if (i == -1) return;
// remember encoding S? '=' S? i += 8;
while (Segment.isSpaceChar(mCharBuf[i]) && (i < bytesRead)) i++; if (i == bytesRead || mCharBuf[i] != '=') throw new Exception(sBotchedEncPI); i++;
while (Segment.isSpaceChar(mCharBuf[i]) && (i < bytesRead)) i++; if (i == bytesRead) throw new Exception(sBotchedEncPI);
if (mCharBuf[i] == '"' || mCharBuf[i] == '\'') stopper = mCharBuf[i]; else throw new Exception(sBotchedEncPI); i++;
for (j = i; j < bytesRead && mCharBuf[j] != stopper; j++) ; if (j == bytesRead) throw new IOException(sBotchedEncPI);
PI = new String(mCharBuf, i, j - 1); PI = PI.toUpperCase(); if ( PI.indexOf("UTF-16") != -1 || PI.indexOf("UTF16") != -1 || PI.indexOf("UCS-2") != -1 || PI.indexOf("UCS2") != -1) throw new Exception(sNativeNoBOM);
if (PI.indexOf("UTF-8") != -1 || PI.indexOf("UTF8") != -1) { // fine, UTF-8 declared! mEncodingWillBe = sUTF8V; return; }
if ( PI.indexOf("LATIN1") != -1 || PI.indexOf("LATIN-1") != -1 || PI.indexOf("ASCII") != -1) // default return;
throw new Exception(sCantDo#ql:sCantDo# + PI + "'"); }

}

lk'Entity.java (e)

name::
* McsEngl.lk'Entity.java (e)@cptItsoft,

lk'e'METHODS:
public Entity(boolean textIsReal, XmlInputStream input, String name, String desc, Entity parent, boolean isPE, URL baseURL)

public int offset()
public void setOffsets(int offset, int lineCount, int lineOffset)
public int lineCount()
public int lineOffset()
public boolean textIsReal()
public XmlInputStream input()
public Entity parent()
public boolean isPE()
public void setBaseURL(URL baseURL)
public URL baseURL()
public String description()
public void setDescription(String desc)
public String name()

package textuality.lark;

import java.io.*; import java.net.*;

// Lark's view of a Text Entity
public class Entity
implements Cloneable#ql::2nfoJAPI11.NFO:interface.cloneable# {

lk'e'FIELDS:
// locational info
int mOffset; int mLineCount; int mLineOffset; // how far into this line
// not true for internal entities - XXX - should be internal boolean mTextIsReal;
// true if this is a parameter entity boolean mPE = false;
// name by which it's referred to, if any String mName = null;
// for resolving external URLs URL mBaseURL = null;
XmlInputStream mInput; // read characters for this entity
String mDescription; // metadata
Entity mParent; // entity tree; null means doc entity

// Constructor
public lk'e'Entity(boolean textIsReal, XmlInputStream input, String name, String desc, Entity parent, boolean isPE, URL baseURL)
{ mOffset = 0; mLineCount = 1; mTextIsReal = textIsReal; mInput = input; mName = name; mDescription = desc; mParent = parent; mPE = isPE; mBaseURL = baseURL; }

// trivial get/set methods only

public int lk'e'offset()
{ return mOffset; }

public void lk'e'setOffsets(int offset, int lineCount, int lineOffset)
{ if (offset != -1) mOffset = offset; if (lineCount != -1) mLineCount = lineCount; if (lineOffset != -1) mLineOffset = lineOffset; }

public int lk'e'lineCount()
{ return mLineCount; }

public int lk'e'lineOffset()
{ return mLineOffset; }

public boolean lk'e'textIsReal()
{ return mTextIsReal; }

public XmlInputStream lk'e'input()
{ return mInput; }

public Entity lk'e'parent()
{ return mParent; }

public boolean lk'e'isPE()
{ return mPE; }

public void lk'e'setBaseURL(URL baseURL)
{ mBaseURL = baseURL; }

public URL lk'e'baseURL()
{ return mBaseURL; }

public String lk'e'description()
{ return mDescription; }

public void lk'e'setDescription(String desc)
{ mDescription#ql:mDescription# = desc; }

public String lk'e'name()
{ return mName; }

}

lk'Segment.java (s)

name::
* McsEngl.lk'Segment.java (s)@cptItsoft,

package textuality.lark;

public class Segment {

// A piece of Text in an SGML element can be composed of // different pieces, which come from different places. // This includes chunks of text which appear between the // start-tag and end-tag, and text that is accessed from // internal and external entities. We call these "segments". // While many applications do not care where the characters // come from, an application that is interested in locational // information, such as an indexer, will need to know, for // each piece, where it came from, and what its logical // offset is. Note that the range of "source" bytes that // generate a segment's text may be smaller than the // number of characters in a segment, e.g. // <!entity "foo" "find outer otter"> // or larger, e.g. // <!entity> "nbsp" " "> // so we have to track the SourceLength and DataLength // separately. // This implementation of a Segment will find storage // text, if required, as a char[] array, or will, if // signalled, use existing storage, in either a char[] // or byte[] array.

lk's'FIELDS:
Entity mSourceEntity = null; int mSourceOffset = -1; int mSourceLength = 0; char[] mCharBase = null; byte[] mByteBase = null; int mDataOffset = -1; int mDataLength = -1; boolean mDataAreChars = false; // else, bytes
// our character storage static final int sBufSize = 8192; static char[] sCharBuf = new char[sBufSize + 1]; static int sCurrentIndex = 0; static String sNotSaved = "[Lark: not saved]"; static Object sHeapLock = new Object();
static boolean[] sIsSpace; static { int i; sIsSpace = new boolean[128]; for (i = 0; i < 128; i++) sIsSpace[i] = false; sIsSpace[' '] = sIsSpace['\t'] = sIsSpace['\r'] = sIsSpace['\n'] = true; }

// no bytes nor storage provided, just record offset/length stats
public lk's'Segment(Entity entity, int sourceOffset, int sourceLength)
{ commonInit(entity, sourceOffset, sourceLength); }

// data's address/length provided, as bytes
public lk's'Segment(Entity entity, int sourceOffset, int sourceLength, int dataLength, byte[] base, int dataOffset)
{ commonInit(entity, sourceOffset, sourceLength); mByteBase = base; mDataLength = dataLength; mDataOffset = dataOffset; mDataAreChars = false; }

// data's address/length provided, as chars
public Segment(Entity entity, int sourceOffset, int sourceLength, int dataLength, char[] base, int dataOffset)
{ commonInit(entity, sourceOffset, sourceLength); mCharBase = base; mDataLength = dataLength; mDataOffset = dataOffset; mDataAreChars = true; }

// data-chars provided... find a place to put them
public lk's'Segment(Entity entity, int sourceOffset, int sourceLength, int dataLength, char[] data)
{ int i; commonInit(entity, sourceOffset, sourceLength); // find some storage
// if the object by itself is bigger than a whole buffer pool, // don't get fancy, just grab the space if (dataLength > sBufSize) { mCharBase = new char[dataLength]; for (i = 0; i < sourceLength; i++) mCharBase[i] = data[i]; mDataOffset = 0; mDataLength = dataLength; return; }

// it will fit in a block. We'll synchronize to allow us // to use a static char[] as a heap; if there's enough // space in the heap for this chunk, use it; otherwise // discard the current heap, potentially wasting space, // and get a new one lk's'synchronized(sHeapLock)
{ if (dataLength > (sBufSize - sCurrentIndex)) { sCharBuf = new char[sBufSize]; sCurrentIndex = 0; } mDataAreChars = true; mCharBase = sCharBuf; mDataOffset = sCurrentIndex; mDataLength = dataLength; for (i = 0; i < dataLength; i++) sCharBuf[sCurrentIndex++] = data[i]; } }

private void lk's'commonInit(Entity entity, int sourceOffset, int sourceLength)
{ mSourceEntity = entity; mSourceOffset = sourceOffset; mSourceLength = sourceLength; }

public Entity lk's'entity()
{ return mSourceEntity; }

public int lk's'sourceOffset()
{ return mSourceOffset; }

public int lk's'sourceLength()
{ return mSourceLength; }

public char[] lk's'charBase()
{ return mCharBase; }

public byte[] lk's'byteBase() { return mByteBase; }

public int lk's'dataOffset() { return mDataOffset; }

public int lk's'dataLength() { return mDataLength; }

public String lk's'toString()
{ if (mDataAreChars) { if (mCharBase == null) return sNotSaved; return new String(mCharBase, mDataOffset, mDataLength); } else { if (mByteBase == null) return sNotSaved; return new String(mByteBase, 0, mDataOffset, mDataLength); } }

public static boolean
lk's'isSpaceChar(char c)
{ return ((c < 128) && sIsSpace[c]); }

public boolean lk's'isSpace() {
int i; char c; if (mDataAreChars) { for (i = 0; i < mDataLength; i++) { c = mCharBase[mDataOffset + i]; if ((c > 127) || !sIsSpace[c]) return false; } } else if (mByteBase == null) { return false; } else { for (i = 0; i < mDataLength; i++) { c = (char) mByteBase[mDataOffset + i]; if ((c > 127) || !sIsSpace[c]) return false; } } return true; }

}

lk'Text.java (t)

name::
* McsEngl.lk'Text.java (t)@cptItsoft,

package textuality.lark;

import java.util.*;

public class Text {

// This is a Text object, which can appear in the Children() // of an element. The text itself is actually stored in a // Vector of Segments; this object really only exists to // provide a nice singular object to sit in the parse // tree, and to avoid recalculating the String value // of a multi-segment object.

lk't'FIELDS:
Vector mSegments = new Vector(); String mString;

public void lk't'addSegment(Segment segment)
{ mSegments.addElement(segment); mString = null; }

public Vector lk't'segments()
{ return mSegments; }

// construct string only on request
public String lk't'toString()
{ Enumeration e; Segment seg = null; if (mString == null) { mString = new String(); for (e = mSegments.elements(); e.hasMoreElements(); ) { seg = (Segment) e.nextElement(); mString = mString.concat(seg.toString()); } } return mString; }

public boolean lk't'isSpace()
{ int i; Segment seg = null;
for (i = 0; i < mSegments.size(); i++) { seg = (Segment) mSegments.elementAt(i); if (!seg.isSpace()) return false; } return true; }

}

lk'Namer.java (n)

name::
* McsEngl.lk'Namer.java (n)@cptItsoft,

package textuality.lark;

import java.util.*;

// This class provides a symbol table for element, attribute, // and entity names; the idea is you pass in the buffer you've // been accumulating chars in, along the with the number you've // accumulated. This is a subclass of vector; the vector // contains char[] arrays, and member Vector that contains // the corresponding strings, and a member vector that if // non-null, contains the corresponding default attributes.// We search the local vector of char[]'s for a match to the // name passed in and either find the string if it's already there, // or make it if it's not.// The motivation is // [a] to avoid doing new String() calls for every little markup chunk we // run across, // [b] to provide a handy & efficient way to avoid looking up the default // attributes that may be on-hand for every GI, and // [c] to allow to check for GI/attribute/entity equality simply by // doing (a == b) rather than a.equals(b)

public class Namer extends Vector {

lk'n'FIELDS:
Vector mStrings = new Vector(capacity()); Vector mDefaultList;
// this is a member to allow quick lookup of default attrs // for a start tag GI without repeating the search int mLastFoundAt = -1;
static Attribute[] sPlaceHolder = new Attribute[0];

public lk'n'Namer(boolean maintainDefaults)
{ if (maintainDefaults) mDefaultList = new Vector(capacity()); }

public String lk'n'checkAndAdd(char[] name, int nlen)
{ boolean foundIt = false; int i; char[] member; String str; Attribute defaults[];
if (elementCount == 0) mLastFoundAt = 0; else { mLastFoundAt = search(name, nlen);
if (mLastFoundAt < elementCount) { member = (char[]) elementData[mLastFoundAt]; if (nlen == member.length) { for (i = 0; i < nlen; i++) if (name[i] != member[i]) break; foundIt = (i == nlen); } } } if (!foundIt) { member = new char[nlen]; for (i = 0; i < nlen; i++) member[i] = name[i]; insertElementAt(member, mLastFoundAt); str = new String(member); mStrings.insertElementAt(str, mLastFoundAt); if (mDefaultList != null) mDefaultList.insertElementAt(sPlaceHolder, mLastFoundAt); } else str = (String) mStrings.elementAt(mLastFoundAt); return str; }
// return the default attributes for the last GI // looked up public Attribute[] defaultAttributes() throws Exception { if (mLastFoundAt == -1 || mDefaultList == null) throw(new Exception("Improper call to Namer.defaultAttributes"));
return (Attribute[]) mDefaultList.elementAt(mLastFoundAt); }

public void lk'n'updateDefaults(String type, Attribute[] defaults)
{ mDefaultList.setElementAt(defaults, mStrings.indexOf(type)); } public Attribute[] getDefaults(String type) { return (Attribute []) mDefaultList.elementAt(mStrings.indexOf(type)); }

// return the index in the vectors where this ought to go (it may // already be there)
private int lk'n'search(char[] name, int nlen)
{ int high, low, probe, i; char[] member; int mlen; int selector = 0;
low = -1; high = elementCount;
// binary search; there are a *lot* of ways to get this wrong while ((high - low) > 1) { // invariant: 'high' either points at the first pos after the array, or // it points at an entry which is greater than or equal to 'name'; 'low' // is either -1 or points at an entry which is strictly less than 'name' probe = (high + low) / 2; member = (char []) elementData[probe]; mlen = member.length; for (i = 0, selector = 0; selector == 0; i++) { if (i == nlen) // name <= member selector = -1; else if (i == mlen) // name > member selector = 1; else selector = name[i] - member[i]; } if (selector < 0) high = probe; else low = probe; } return high; }

}

jvp.XML.MSXML

name::
* McsEngl.jvp.XML.MSXML@cptItsoft,

msxml#cptItsoft1201: attSpe#

FvMcs.MSXML

name::
* McsEngl.conceptItsoft1201,
* McsEngl.MSXML@cptItsoft,
* McsEngl.FvMcs.MSXML@cptItsoft,
* McsEngl.msxml@cptItsoft1201,

GENERIC

_GENERIC:
Java Application#cptItsoft1200#

msxml'MSXML'CLASS

name::
* McsEngl.msxml'MSXML'CLASS@cptItsoft,

SOURCE: Microsoft, Version 1.6

_DEFINITION:
This program parses the given XML file and optionally dumps the resulting data structures to standard output.
Arguments:
-d dumps the tree structure of elements.
-t specifies that you want to time the parsing. Specify how many times to parse the file in order to get get good time measurements).
-o Provides a filename for dumping output. This is useful for test data that gets messed up by PrintStream).
-e character encoding for output other than that of the input.
-c Output in compact mode (no newlines or tabs).
-p Output in compact mode (no newlines or tabs).
-i Switch to case insensitive.
-s Write out short end tags.

msxml'xml'METHODS
public static void main#ql:msxml'xml'main#(String args[])

createURL()
dumpSchema()
dumpTree()
msxml()
parseArgs()
static void printUsage#ql:msxml'xml'printUsage# (PrintStream o)
reportTimes()
Start()
Stop()

================================================================

import com.ms.xml.parser.*; import com.ms.xml.om.Document; import com.ms.xml.om.Element; import com.ms.xml.util.XMLOutputStream; import com.ms.xml.util.Name; import com.ms.xml.om.ElementEnumeration; import com.ms.xml.om.ElementImpl;
import java.util.Enumeration; import java.io.*; import java.io.PrintStream; import java.net.*;

class msxml

msxml'xml'FIELDS:
static String fileName;
static boolean output = false; // display or not the result of parsing.
static boolean tree = false; // create or not tree
static boolean schema = false;
static int loops = 1; //from timing the parsing.
static boolean timeit = false;
static boolean caseInsensitive = false;
static boolean stream = false;
static long start = 0;
static long min =0;
static long max = 0;
static long count = 0;
static long sum = 0;
static int style = 0; // arg -s
static OutputStream#ql::JAPI101.NFO:class.OutputStream# out = System.out; // or -o output.xml
static String outputEncoding = null;
static boolean shortEndTags = false;

public static void msxml'xml'main(String args[])
{ parseArgs#ql:msxml'xml'parseargs#(args);
if (fileName == null) { printUsage(System.out); }

else
{ URL url = createURL#ql:MSXML'XML'createURL#(fileName);
Document d = new Document#ql:msxml'd'document#();

try {

for (long i = 0; i < loops#ql:msxml'xml'fields loops#; i++)
{ Start#ql:msxml'xml'Start#(); InputStream instream = null; d.setCaseInsensitive(caseInsensitive#ql:msxml'xml'fields caseInsensitive#); //default false

if (stream#ql:msxml'xml'fields stream#) { try { instream = url.openStream#ql::JAPI101.NFO:openStream rl5#(); } //stream default false
catch (IOException e) { System.out.println("Error opening input stream for \"" + url.toString() + "\": " + e.toString()); System.exit(0); } d.load#ql:msxml'd'load#(instream); }
else { d.load#ql:msxml'd'load#(url); }

Stop(); } // end for
if (timeit) reportTimes#ql:msxml'xml'reportTimes#(System.out); //uses System.out as printstream.
} //end try

catch (ParseException e) { d.reportError(e, System.out); d = null; // don't dump tree then. }

if (d != null)
{
if (tree#ql:msxml'xml'fields tree#) { try { dumpTree#ql:msxml'xml'dumpTree#(d, new PrintStream(out#ql:msxml'xml'fields out#)," "); } //out default System.out
catch( IOException e ) { System.out.println( "Error saving output stream." ); } }

else if (schema#ql:msxml'xml'fields schema#) { try { dumpSchema(d,d.createOutputStream(out)); }
catch( IOException e ) { System.out.println( "Error saving output stream." ); } }

else if (output#ql:msxml'xml'fields output# ) {
if( outputEncoding != null ) //default null
d.setEncoding( outputEncoding#ql:msxml'xml'fields outputEncoding# );
d.setOutputStyle#ql:msxml'd'setOutputStyle#(style#ql:msxml'xml'fields style#); /default 0
try { XMLOutputStream xout = d.createOutputStream#ql:msxml'd'createOutputStream#(out); xout.setShortEndTags#ql:msxml'xmlos'setShortEndTags#( shortEndTags ); d.save#ql:msxml'd'save#(xout); } catch( IOException e ) { System.out.println( "Error saving output stream." ); } }

} //end if d
} //end else
System.exit(0); }

static void msxml'xml'printUsage(PrintStream o) {
o.println("Usage: jview msxml [-d] [-t num] [-e encoding] [-o filename] [-c|-p] [-i] [-s] filename");
o.println();
o.println("Version: 1.0.6.6");
o.println();
o.println("This program parses the given XML file and optionally dumps"); o.println("the resulting data structures to standard output.\n"); o.println("Arguments:");
o.println("-t\tspecifies that you want to time the parsing.");
o.println("\tSpecify how many times to parse the file in order");
o.println("\tto get get good time measurements).");
o.println("-o\tProvides a filename for dumping output."); o.println("\tThis is useful for test data that gets messed up by PrintStream)."); o.println("-e\tcharacter encoding for output other"); o.println("\tthan that of the input."); o.println("-c\tOutput in compact mode (no newlines or tabs)."); o.println("-p\tOutput in compact mode (no newlines or tabs)."); o.println("-i\tSwitch to case insensitive.\n"); o.println("-s\tWrite out short end tags.\n"); }

static void msxml'xml'parseArgs(String args[])
{ for (int i = 0; i < args.length; i++)
{if (args[i].equals("-d")) { output#ql:msxml'xml'fields output# = true; }
else if (args[i].equals("-d1")) { tree = true; output = true; } else if (args[i].equals("-d2")) { schema = true; output = true; } else if (args[i].equals("-t")) { i++; Integer value = new Integer(args[i]); loops#ql:msxml'xml'fields loops# = value.intValue(); timeit = true; }
else if (args[i].equals("-i")) { caseInsensitive = true; }
else if (args[i].equals("-o"))
{ i++; try { out#ql:msxml'xml'fields out# = new FileOutputStream#ql::JAPI101.NFO:class.FileOutputStream#( args[i] ); }catch( IOException e ) { out = System.out; } }
else if (args[i].equals("-e")) { i++; outputEncoding = args[i]; } else if (args[i].equals("-c")) { style = XMLOutputStream.COMPACT; } else if (args[i].equals("-p")) { style = XMLOutputStream.PRETTY; } else if (args[i].equals("-s")) { shortEndTags = true; } else { fileName = args[i]; }
} }

static void msxml'xml'Start()
{ start = System.currentTimeMillis(); }

static void msxml'xml'Stop()
{ long end = System.currentTimeMillis(); long time = end-start; if (timeit) System.out.println("time=" + time); // + " created=" + Name.created + " reused=" + Name.reused); // Name.created = 0; // Name.reused = 0; if (min == 0 || time < min) min = time; if (max == 0 || time > max) max = time; sum += (end-start); count++; }

static void msxml'xml'reportTimes(PrintStream o)
{ o.println("Parsed " + count + " times:");
o.println("\tMin="+ min + " milliseconds.");
o.println("\tMax="+ max + " milliseconds.");
o.println("\tAverage="+ (sum/count) + " milliseconds."); }

static URL msxml'xml'createURL(String fileName)
{ URL url = null;
try { url = new URL(fileName); }

catch (MalformedURLException ex)
{ File f = new File(fileName);
try { String path = f.getAbsolutePath();
// This is a bunch of weird code that is required to make a valid URL on the Windows platform, due to inconsistencies in what getAbsolutePath returns.
String fs = System.getProperty("file.separator");
if (fs.length() == 1)
{ char sep = fs.charAt(0);
if (sep != '/') path = path.replace(sep, '/');
if (path.charAt(0) != '/') path = '/' + path;
} path = "file://" + path; url = new URL(path); }
catch (MalformedURLException e)
{ System.out.println("Cannot create url for: " + fileName); System.exit(0); }
} return url; }

static void msxml'xml'dumpTree(Element
throws IOException
{ if (indent.length() > 0)
String lines
boolean dumpText
boolean dumpTagName
boolean dumpAttributes

switch (e.getType#ql:ms
case Element.CDATA#ql:msxml'e'fields
case Element.DOCUMENT:
case Element.DTD:
case Element.ELEMENT:
case Element.ENTITY:
case Element.ENTITYREF:
case Element.NOTATION:
case Element.ELEMENTDECL:
case Element.PCDATA:
case Element.PI:

case Element.NAMESPACE:

case Element.WHITESPACE:
for (int i = 0; i < len; i++)
dumpAttributes = false;
} //end SWITCH

if (dumpTagName) {

if (e.getType() == Element.ENTITY)

else if (e.getType()
XMLOutputStream
ed.getContent().save(null, out);

if (dumpAttributes)
XMLOutputStream

if (dumpText &&

o.println#ql::JAPI101.NFO:println
String newLines = "";
if (lines.length() > 0)
else {

for (ElementEnumeration
if (! en.hasMoreElements())
if (lines.length() > 0)
}

static void msxml'xml'dumpSchema(Document d, XMLOutputStream s)
throws IOException
{Element schema = d.getDTD#ql:msxml'd'getdtd#().getSchema-#ql:msxml'dtd'getSchema#();
schema.save(s); }

com.ms.xml.om.*

name::
* McsEngl.com.ms.xml.om.*@cptItsoft,

msxml'Document'D (ext-ElementImpl; impl-ElementFactory)

name::
* McsEngl.msxml'Document'D (ext-ElementImpl; impl-ElementFactory)@cptItsoft,

PACKAGE: com.ms.xml.om.

FUNCTION:
This class implements an XML document, which can be thought of as the root of a tree. Each XML tag can either represent a node or a leaf of this tree. The Document class allows you to load an XML document, manipulate it, and then save it back out again. The document can be loaded by specifying a URL or an input stream.

msxml'd'METHODS:
public Document();
public Document(ElementFactory f);
public void addChild#ql:msxml'd'addChild#(Element elem, Element after);
public void clear();
public final Element createElement#ql:msxml'd'createElement#(int type, Name tag);
public final Element createElement(int type, String tag);
public final Element createElement(int type);
public XMLOutputStream createOutputStream#ql:msxml'd'createOutputStream#(OutputStream out): Creates an XML output stream matching the format found on load().
public final Enumeration elementDeclarations();
public Element#ql:msxml'element'e# findEntity#ql:msxml'd'findEntity#( Name name );
public final String getCharset();
public final Name getDocType();
public DTD getDTD();
public final String getDTDURL();
public Element getElementDecl( Name name );
public final String getEncoding();
public long getFileModifiedDate#ql:msxml'd'getFileModifiedDate#();
public final String getId#ql:msxml'd'getId#();
public int getOutputStyle();
public Element getParent();
public final Element getRoot();
public String getText#ql:msxml'd'gettext#();
public int getType#ql:msxml'd'gettype#(); //Retrieves the document type. Return the value defined by Element.DOCUMENT#ql:msxml'e'fields document#.
public final String getURL();
public final String getVersion();
public boolean isCaseInsensitive();
public void load(String urlstr) throws ParseException;
public void load(URL url) throws ParseException;
public void load(InputStream in) throws ParseException;
public void parsed(Element e);
public void removeChild(Element elem);
public void reportError(ParseException e, OutputStream out);
public void save#ql:msxml'd'save#(XMLOutputStream o): Saves the document to the given output stream.
** public void show(XMLOutputStream o): Saves to o in order to show it.
public void setCaseInsensitive(boolean yes);
public final void setCharset(String encoding);
public final void setEncoding( String encoding );
public void setOutputStyle(int style);
public void setText#ql:msxml'd'setText#(String text);
public void setURL( String urlstr ) throws ParseException;
public final void setVersion( String version );

====================================================================

public class Document
extends ElementImpl#ql:msxml'elementimpl#
implements ElementFactory {

msxml'd'FIELDS:
protected DTD dtd;
protected ElementFactory factory; //The factory used to create the elements in the document.
URL URLdoc; //URL if passed in.
Element DTDnode; //Root of External DTD tree.
Element root; //Root of element tree.
Element XML; // XML declaration
String outputEncoding;
Parser parser;
int outputStyle; //DEFAULT = 0; PRETTY = 1; COMPACT = 2;
boolean caseInsensitive;
static Name nameVERSION = Name.create#ql:msxml'nm'create#("VERSION");
static Name nameENCODING = Name.create("ENCODING");
static Name nameDOCTYPE = Name.create("DOCTYPE");
static Name nameNAME = Name.create#ql:msxml'nm'create#("NAME");
static Name nameURL = Name.create("URL");
static Name namePUBLICID = Name.create("PUBLICID");
static Name nameXML = Name.create("XML");
static String defaultEncoding = "UTF-8";
static String defaultVersion = "1.0";

public msxml'd'Document()
{outputStyle#ql:msxml'd'fields outputStyle# = XMLOutputStream.DEFAULT#ql:msxml'xmlos'fields DEFAULT#;
factory#ql:msxml'd'fields factory# = new ElementFactoryImpl#ql:msxml'efi'elementfactoryimpl#();
dtd = new DTD#ql:msxml'dtd'dtd#();
caseInsensitive = false; }

public msxml'd'Document(ElementFactory f)
{ outputStyle = XMLOutputStream.DEFAULT; factory = f; dtd = new DTD(); caseInsensitive = false; }

public int msxml'd'getType()
//Retrieves the document type. Return the value defined by Element.DOCUMENT#ql:msxml'e'fields document#.
{ return DOCUMENT; }

public String msxml'd'getText()
//Returns a plain text (that is, not marked-up) representation of the entire document.
{ return (root != null) ? root.getText#ql:msxml'ei'gettext#() : null; }

public void msxml'd'setText(String text)
{ if (root#ql:msxml'd'fields root# != null) //root is element
root.setText#ql:msxml'ei'setText#(text); }

public Element msxml'd'getParent() { return null; }

public void msxml'd'addChild(Element elem, Element after)
{ if (elem.getType() == Element.ELEMENT#ql:msxml'e'fields ELEMENT#) { root = elem; }
else if (elem.getType() == Element.PI && elem.getTagName() == nameXML) { XML = elem; }
else if (elem.getType() == Element.DTD) { DTDnode = elem; } super.addChild#ql:msxml'ei'addChild#(elem,after); }

public void msxml'd'removeChild(Element elem)
{ super.removeChild(elem);
if (root == elem) { root = null; } else if (XML == elem) { XML = null; } else if (XML == DTDnode) { DTDnode = null; } }

public final Element msxml'd'getRoot()
{ return root; }

private final Element msxml'd'getXML()
{ return XML#ql:msxml'd'fields xml#; }

public final String msxml'd'getVersion()
{ if (getXML() != null) { Object v = getXML().getAttribute(nameVERSION); if (v != null) return v.toString(); } return defaultVersion; }

public final void msxml'd'setVersion( String version )
{ // BUG - if we have no XML node we should create one. if (getXML() != null) { getXML().setAttribute(nameVERSION, version ); } }

public final String msxml'd'getEncoding()
{ if( outputEncoding != null ) return outputEncoding; else { if (getXML() != null) { Object v = getXML().getAttribute(nameENCODING); if (v != null) return v.toString(); } return defaultEncoding; } }

public final void msxml'd'setEncoding( String encoding )
{ outputEncoding = encoding; }

public final String msxml'd'getCharset()
{ return getEncoding(); }

public final void msxml'd'setCharset(String encoding)
{ setEncoding(encoding); }

public final Name msxml'd'getDocType()
{ if (DTDnode == null) return null;
Object v = DTDnode.getAttribute#ql:msxml'ei'getAttribute#(nameNAME#ql:msxml'd'fields nameNAME#);
if (v != null) return (Name)v;
return null; }

public final String msxml'd'getDTDURL()
{if (DTDnode == null) return null; Object v = DTDnode.getAttribute(nameURL); if (v != null) return v.toString(); return null; }

public final String msxml'd'getURL()
{ return URLdoc.toString(); }

public long msxml'd'getFileModifiedDate()
{ if (URLdoc != null) { if (URLdoc.getProtocol().equals("file")) { File f = new File(URLdoc.getFile()); return f.lastModified(); } else { try { URLConnection URLcon = URLdoc.openConnection(); URLcon.connect(); return URLcon.getLastModified(); } catch(IOException ie) { return 0; } } }

else { return 0; } }

public final String msxml'd'getId()
{ if (DTDnode == null) return null; Object v = DTDnode.getAttribute(namePUBLICID#ql:msxml'd'fields namePUBLICID#); if (v != null) return v.toString(); return null; }

public final Element msxml'd'createElement(int type, Name tag)
{ return factory.createElement(type, tag); }

public final Element msxml'd'createElement(int type, String tag)
{ return factory.createElement(type, Name.create(tag)); }

public final Element msxml'd'createElement(int type)
{ return factory.createElement(type, null); }

public void msxml'd'parsed(Element e) { factory.parsed(e); }

public void msxml'd'setCaseInsensitive(boolean yes) { caseInsensitive = yes; }

public boolean msxml'd'isCaseInsensitive() { return caseInsensitive; }

public void msxml'd'load(String urlstr)
throws ParseException
{ URL url;
try { url = new URL( urlstr ); }
catch( MalformedURLException e ) { throw new ParseException("MalformedURLException: " + e); }
load(url); }

public void msxml'd'setURL( String urlstr )
throws ParseException
{ load( urlstr); }

public void msxml'd'load(URL url) throws ParseException
{clear#ql:msxml'd'clear#(); URLdoc = url; parser = new Parser#ql:msxml'p'parser#();
parser.parse#ql:msxml'p'parse url#(url, this, dtd, this, caseInsensitive);}

public void msxml'd'load(InputStream in)
throws ParseException
{ clear#ql:msxml'd'clear#();
parser = new Parser#ql:msxml'p'parser#();
parser.parse#ql:msxml'p'parse#(in, this#ql:msxml'ef'methods#, dtd, this#ql:msxml'd'fields root#, caseInsensitive#ql:msxml'd'fields caseInsensitive#); //in, factrory, dtd, root, casein
}

public void msxml'd'reportError(ParseException e, OutputStream out)
{ if (parser != null) parser.report(e,out); }

public void msxml'd'setOutputStyle(int style)
{ outputStyle = style; }

public int msxml'd'getOutputStyle()
{ return outputStyle; }

public XMLOutputStream#ql:msxml'xmlos'methods# msxml'd'createOutputStream(OutputStream out)
throws IOException
{ XMLOutputStream o = null;

if( outputEncoding == null ) { // Create an output stream that will save in same format as // was found in input stream.
if (parser != null) o = parser.createOutputStream#ql:msxml'p'createoutputstream#( out ); }

if (o == null) { // Create an output stream that is appropriate for // encoding specified in the setEncoding method.
Element XML = getXML#ql:msxml'd'getXML#();
o = new XMLOutputStream( out ); //out is a parameter of this method
if (XML != null) { XML.setAttribute(nameENCODING, outputEncoding ); o.setEncoding( outputEncoding, true, true ); }
}
o.setOutputStyle(outputStyle); o.dtd = getDTD#ql:msxml'd'getDTD#(); return o; }

public void msxml'd'save(XMLOutputStream o)
throws IOException
{ o.dtd = dtd; // make sure dtd is set correctly.

for (ElementEnumeration ee = new ElementEnumeration#ql:msxml'ee'elementenumeration#(this); ee.hasMoreElements(); ) { Element e = (Element)ee.nextElement();

if (e == DTDnode#ql:msxml'd'fields dtdnode#) { // Make sure we write the DOCTYPE in correct syntax and in // the correct location - relative to surrounding COMMENT // and PI elements.
o.writeChars#ql:msxml'xmlos'writeChars# ("<!DOCTYPE ");
Name docType = getDocType#ql:msxml'd'getDocType#();
if (docType.getNameSpace#ql:msxml'nm'getNameSpace#() != null)
o.writeQualifiedName(getDocType(), Atom.create(""));
else o.writeChars(docType.getName());
if (getDTDURL() != null) {
if (getId() != null) { o.writeChars(" PUBLIC "); o.writeQuotedString(getId()); o.write(' '); }
else { o.writeChars(" SYSTEM "); } o.writeQuotedString(getDTDURL()); }
// If we have children then there was an internal // subset that also needs to be written out.
if (e.numElements() > 0) { o.writeChars(" ["); o.writeNewLine(); o.addIndent(1); o.savingDTD = true;
for (ElementEnumeration en = new ElementEnumeration(e); en.hasMoreElements();) { Element child = (Element)en.nextElement(); child.save(o); } o.savingDTD = false;
o.addIndent(-1); o.write(']'); }
o.write('>'); o.writeNewLine(); }

else if (e == XML#ql:msxml'd'fields xml#) { o.writeChars("<?XML");
for (Enumeration en = e.getAttributes(); en.hasMoreElements(); ) { Attribute a = (Attribute)en.nextElement(); o.writeChars(" " + a.getName() + "="); o.writeQuotedString(a.getValue().toString()); } o.writeChars("?>"); o.writeNewLine(); }

else { e.save#ql:msxml'ei'save#(o); }
} }

public final Enumeration msxml'd'elementDeclarations()
{ return (Enumeration)(new ElementDeclEnumeration(dtd.elementDeclarations())); }

public Element msxml'd'getElementDecl( Name name )
{ return dtd.findElementDecl(name).toSchema(); }

public Element msxml'd'findEntity( Name name )
{ return dtd.findEntity#ql:msxml'dtd'findEntity#(name).toSchema(); }

public void msxml'd'clear()
{DTDnode = null; dtd = new DTD#ql:msxml'dtd'dtd#(); // use DTD clear when reusing a DTD
root = null; XML = null; URLdoc = null; outputEncoding = null; super.clear#ql:msxml'ei'clear#(); }

public DTD msxml'd'getDTD()
{ return dtd#ql:msxml'd'fields dtd#; }

msxml'DocumentBeanInfo'DBI

name::
* McsEngl.msxml'DocumentBeanInfo'DBI@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
This class provides specialized JavaBeans support for the Document class to resolve which overloaded functions are accessible through scripting.

=================================================================

package com.ms.xml.om;

package com.ms.xml.om; import java.beans.*; import java.lang.reflect.Method;

public class DocumentBeanInfo
extends SimpleBeanInfo {

public MethodDescriptor[] getMethodDescriptors()
//Returns the method descriptions for the methods that are to be made available through scripting.
{ // First find the "method" objects. Method addChildMethod; Method removeChildMethod; Method createElement1Method; Method createElement2Method; Method parsedMethod; Method loadMethod; // Method reportErrorMethod; // Method createOutputStreamMethod; // Method saveMethod; Method elementDeclarationsMethod; Method clearMethod;
Class args[] = { }; Class addChildArgs[] = { Element.class, Element.class }; Class elementArgs[] = { Element.class }; Class createElement1Args[] = { int.class, String.class }; Class createElement2Args[] = { int.class }; Class loadArgs[] = { String.class }; // Class reportErrorArgs[] = { ParseException.class, OutputStream.class }; // Class createOutputStreamArgs[] = { OutputStream.class }; // Class saveArgs[] = { XMLOutputStream.class };
try { addChildMethod = Document.class.getMethod("addChild", addChildArgs); removeChildMethod = Document.class.getMethod("removeChild", elementArgs); createElement1Method = Document.class.getMethod("createElement", createElement1Args); createElement2Method = Document.class.getMethod("createElement", createElement2Args); parsedMethod = Document.class.getMethod("parsed", elementArgs); loadMethod = Document.class.getMethod("load", loadArgs); // reportErrorMethod = Document.class.getMethod("reportError", reportErrorArgs); // createOutputStreamMethod = Document.class.getMethod("createOutputStream", createOutputStreamArgs); // saveMethod = Document.class.getMethod("save", saveArgs); elementDeclarationsMethod = Document.class.getMethod("elementDeclarations", args); clearMethod = Document.class.getMethod("clear", args); } catch (Exception ex) { // "should never happen" throw new Error("Missing method: " + ex); }
// Now create the MethodDescriptor array // with visible event response methods: MethodDescriptor result[] = { new MethodDescriptor(addChildMethod), new MethodDescriptor(removeChildMethod), new MethodDescriptor(createElement1Method), new MethodDescriptor(createElement2Method), new MethodDescriptor(parsedMethod), new MethodDescriptor(loadMethod), // new MethodDescriptor(reportErrorMethod), // new MethodDescriptor(createOutputStreamMethod), // new MethodDescriptor(saveMethod), new MethodDescriptor(elementDeclarationsMethod), new MethodDescriptor(clearMethod), };
return result; }

msxml'Element'E INTERFACE

name::
* McsEngl.msxml'Element'E INTERFACE@cptItsoft,

_DEFINITION:
This interface implements an Element object. Each XML tag in a document is represented by an Element object in the XML parse tree. The elements are named with a string, have attributes, and can contain child nodes.
There are seven types of elements, DOCUMENT, ELEMENT, PCDATA, PI, META, COMMENT, and CDATA.

====================================================================

package com.ms.xml.om;

import com.ms.xml.util.Name; import com.ms.xml.util.Attributes; import com.ms.xml.util.XMLOutputStream; import java.lang.String; import java.util.Enumeration; import java.io.IOException;

public interface Element

msxml'e'FIELDS:
static public final int ELEMENT = 0; //The root element of an xml file.
static public final int PCDATA = 1;
static public final int COMMENT = 2;
static public final int DOCUMENT = 3;
static public final int DTD = 4; //The DOCTYPE declaration
static public final int PI = 5;
static public final int CDATA = 6; //"<![CDATA[" + getText() + "]]>", data on comments
static public final int ENTITY = 7;
static public final int NOTATION = 8;
static public final int ELEMENTDECL = 9;
static public final int NAMESPACE = 10; //"<?XML::NAMESPACE"
static public final int ENTITYREF = 11; //%,&
static public final int WHITESPACE = 12;
static public final int INCLUDESECTION = 13; //"<![INCLUDE[", <![%
static public final int IGNORESECTION = 14;

msxml'e'METHODS:
public Enumeration getAttributes();
public void addChild(Element elem, Element after);
public void addChild(Element elem, int pos, int reserved);
public Object getAttribute(String name);
public Object getAttribute(Name n);
public Element getChild(int index);
public int getType();
public String getText();
public Element getParent();
public Enumeration getElements();
public ElementCollection getChildren();
public int numElements();
public void removeChild(Element elem);
public int numAttributes();
public void removeAttribute(String name);
public void removeAttribute(Name name);
public void setParent(Element parent);
public void setAttribute(String name, Object value);
public void setAttribute(Name name, Object value);
public void setText(String text);
public void save(XMLOutputStream o) throws IOException;
public Element toSchema();

msxml'ElementCollection'EC

name::
* McsEngl.msxml'ElementCollection'EC@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
This class provides a collection interface to elements similar to the element collections found in the Internet Explorer 4.0 Dynamic HTML object model.

msxml'ec'METHODS:
public ElementCollection(Element root);
public ElementCollection(Element root, Name tag, int type);
public Element getChild#ql:msxml'ec'getchild#(int index);
public int getLength();
public Object item(String name);
public Element item(String name, int index);

=============================================================

package com.ms.xml.om;

import com.ms.xml.util.Name; import com.ms.xml.om.ElementCollection;

public class ElementCollection {

msxml'ec'FIELDS:
Element root;
ElementEnumeration items;
int length;
Element current;
int currentindex;

/** * Creates new collection object for given element. */

public msxml'ec'ElementCollection(Element root)
{ this.root = root; this.items = new ElementEnumeration(root,null,Element.ELEMENT); currentindex = 0; // not initialized current = (Element)items.nextElement(); length = -1; }

/** * Creates a new collection for iterating over the immediate children * of the given root node that have matching tag names and/or * element types. * @param root The root to form the collection around. * @param tag The name of the tag; this parameter can be null if the name is not important. * @param type The element type. Element.ELEMENT is the most * common. If * the element type is not important, pass -1. */

public msxml'ec'ElementCollection(Element root, Name tag, int type)
{ this.root = root; this.items = new ElementEnumeration(root, tag, type); length = -1; // not initialized currentindex = 0; // not initialized current = (Element)items.nextElement(); }

/** * Retrieves the number of items in the collection. * @return the item count. */
public int msxml'ec'getLength()
{ if (length == -1) { items.reset(); length = 0; while (items.hasMoreElements()) { items.nextElement(); length++; } items.reset(); currentindex = 0; // not initialized current = (Element)items.nextElement(); } return length; }

/** * Retrieves a named item or a collection of matching items. * @param name The name of the item or collection of matching items. * @return the requested item. Possible types of objects * returned are Element, ElementCollection, * or null. */

public Object msxml'ec'item(String name)
{ try { int i = Integer.parseInt(name); return getChild(i); } catch (Exception e) { } ElementCollection col = new ElementCollection(root,Name.create(name),Element.ELEMENT); if (col.getLength() == 1) { // only one match, so return it. return col.getChild(0); } // otherwise return the new collection. return col; }

/** * Retrieves a specified item from the collection by index. * @param index The index of the item in the element collection. * @return the requested child node; returns null if not found. */

public Element msxml'ec'getChild(int index)
{ // This is an optimization to help sequential // calls to item with sequentially increasing // indexes be linear in performance. if (currentindex == index) { return current; } else if (currentindex > index) { // have to reset and start over. currentindex = 0; items.reset(); } // must not use else here since we change currentindex above. if (currentindex < index) { while (currentindex < index && items.hasMoreElements()) { current = (Element)items.nextElement(); currentindex++; } } if (currentindex != index) { // Still didn't find it. Mustn't be there. return null; } return current; }

/** * Retrieves a specified item from the collection of matching items. * @param name The name of the matching items. * @param index The index of the specific matching item to return. * @return the requested item if it is found; returns null if it is not * found. */

public Element msxml'ec'item(String name, int index)
{ ElementCollection col = new ElementCollection(root,Name.create(name),Element.ELEMENT); return col.getChild(index); }

}

msxml'ElementDeclEnumeration'EDE

name::
* McsEngl.msxml'ElementDeclEnumeration'EDE@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
A simple Enumeration for iterating over ElementDecls

msxml'ede'METHODS:
public ElementDeclEnumeration(Enumeration elemDecls);
public ElementDeclEnumeration(Element e);
public boolean hasMoreElements();
public Object nextElement();

===============================================================

package com.ms.xml.om;

import com.ms.xml.util.Name; import java.util.Enumeration;

public class ElementDeclEnumeration
implements Enumeration {

/** * Creates new enumerator for enumerating over all of the children * of the given root node.

*/ public ElementDeclEnumeration(Enumeration elemDecls) { this.elemDecls = elemDecls; }
/** * Creates new enumerator for enumerating over all of the children * of the given root node.

*/ public ElementDeclEnumeration(Element e) { this.elemDecls = (e != null) ? e.getElements() : null; }
/** * Return whether or not there are any more matching elements.

* @return true if the next call to nextElement will return * non null result.

*/ public boolean hasMoreElements() { return elemDecls.hasMoreElements(); }
/** * Return the next matching element.

* @return Element or null of there are no more matching elements.

*/ public Object nextElement() { Element elemDecl = (Element)elemDecls.nextElement(); return elemDecl.toSchema(); }
Enumeration elemDecls; }

msxml'ElementEnumeration'EE

name::
* McsEngl.msxml'ElementEnumeration'EE@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
This class is a simple Enumeration for iterating over the immediate children of a given node in the XML tree. It does not walk the entire tree.

msxml'ee'METHODS:
public ElementEnumeration(Element root);
public ElementEnumeration(Element root, Name tag, int type);
public boolean hasMoreElements();
public Object nextElement();
public void reset();

====================================================================

package com.ms.xml.om;

import com.ms.xml.util.Name; import java.util.Enumeration;

/** * This class is a simple Enumeration for iterating over the immediate children * of a given node in the XML tree. This is not a hierarchical * iterator. It does not walk the entire tree. * * @version 1.0, 7/11/97 * @see Element * @see Name */

public class ElementEnumeration
implements Enumeration {

msxml'ee'FIELDS:
Element root;
Enumeration children;
Name tag;
Element next;
int type;

/** * Creates a new enumerator for enumerating over all of the children * of the given root node. * @param root The element whose children are going to be enumerated. */

public msxml'ee'ElementEnumeration(Element root)
{ this.root = root;
this.tag = null; this.next = null;
this.children#ql:msxml'ee'fields children# = (root != null) ? root.getElements#ql:msxml'*'getElements#() : null; this.type = -1; }

/** * Creates a new enumerator for enumerating over the immediate children * of the given root node that have matching tag names and/or types. * @param root The element whose children are going to be enumerated. * @param tag The name of the tag; this parameter can be null if the name is not important. * @param type The element type. <code>Element.ELEMENT</code> is the most common. If the * element type is not important, pass -1. */

public msxml'ee'ElementEnumeration(Element root, Name tag, int type) { this.root = root; this.tag = tag; this.next = null; this.children = (root != null) ? root.getElements() : null; this.type = type; }

/** * Determines if there are any more matching elements. * @return true if the next call to <code>nextElement</code> will return * a non-null result. */

public boolean msxml'ee'hasMoreElements() { if (next == null) { next = getNext(); } return (next != null) ? true : false; }

/** * Retrieves the next matching element. * @return <code>Element</code> or null if there are no more matching elements. */

public Object msxml'ee'nextElement() { if (next != null) { Element result = next; next = null; return result; } return getNext(); }

/** * Resets the iterator so that you can iterate through the elements again. * @return No return value. */

public void msxml'ee'reset() { children = (root != null) ? root.getElements() : null; }

/** * Internal method for getting next element. */

Element msxml'ee'getNext() { if (children != null) { while (children.hasMoreElements()) { Element e = (Element)children.nextElement(); if (tag == null && type == -1) return e; if (type != -1 && e.getType() != type) continue; if (tag != null && e.getTagName() != tag) continue; return e; } } return null; }

}

msxml'ElementFactory'EF INTERFACE

name::
* McsEngl.msxml'ElementFactory'EF INTERFACE@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
This interface specifies a method to create elements for an XML element tree. This is used by the XML Document to create nodes in the tree as it parses the elements.

msxml'ef'METHODS:
Element createElement(int type, Name#ql:msxml'name# tag);
void parsed(Element elem);

==================================================================

package com.ms.xml.om;

import com.ms.xml.util.Name;

/** * This interface specifies a method to create elements * for an XML element tree. This is used by the XML Document to create * nodes in the tree as it parses the elements. * * @version 1.0, 10 Mar 1997 * @author Istvan Cseri */

public interface ElementFactory {

/** * Creates an element with the specified tag for the * specified type of element. * * @param tag The name of the element. * @param type One of the predefined Element types that * can be returned from <code>Element.getType</code>. * @return the created element. * @see Element */

Element createElement(int type, Name tag);

/** * Notifies that the element is fully parsed. * * @param elem The element parsed. * @see Element */

void parsed(Element elem);

}

msxml'ElementFactoryImpl'EFI

name::
* McsEngl.msxml'ElementFactoryImpl'EFI@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
This class represents the default implementation for the element factory.

msxml'efi'METHODS:
Element createElement(int type, Name#ql:msxml'name# tag);
void parsed(Element elem);

===================================================================

package com.ms.xml.om;

import com.ms.xml.util.Name;

public class ElementFactoryImpl
implements ElementFactory {

public msxml'efi'ElementFactoryImpl()
{ }

public Element msxml'efi'createElement(int type, Name tag)
{ return new ElementImpl#ql:msxml'ei'elementimpl#(tag, type); }

public void msxml'efi'parsed(Element elem)
//This method is called when the element is fully parsed.
{}

msxml'ElementImpl'EI

name::
* McsEngl.msxml'ElementImpl'EI@cptItsoft,

PACKAGE: com.ms.xml.om

FUNCTION:
This class represents the default implementation of the Element interface.
These are created by the XML parser when using the default element factory.

msxml'ei'METHODS:
public Enumeration getAttributes();
public void addChild#ql:msxml'ei'addChild#(Element elem, Element after);
public void addChild(Element elem, int pos, int reserved);
public Object getAttribute(String name);
public Object getAttribute(Name n);
public Element getChild(int index);
public int getType();
public String getText#ql:msxml'ei'gettext#();
public Element getParent();
public Enumeration getElements();
public ElementCollection#ql:msxml'ElementCollection# getChildren();
public int numElements();
public void removeChild(Element elem);
public int numAttributes();
public void removeAttribute(String name);
public void removeAttribute(Name name);
public void setParent(Element parent);
public void setAttribute(String name, Object value);
public void setAttribute(Name name, Object value);
public void setText#ql:msxml'ei'setText#(String text);
public void save#ql:msxml'ei'save#(XMLOutputStream o) throws IOException;
public Element toSchema();

========================= CODE ============================

package com.ms.xml.om;

import com.ms.xml.util.Attribute; import com.ms.xml.util.Attributes; import com.ms.xml.util.Name; import com.ms.xml.util.Atom; import com.ms.xml.util.XMLOutputStream; import com.ms.xml.util.EnumWrapper; import com.ms.xml.parser.ElementDecl; import com.ms.xml.parser.AttDef; import com.ms.xml.parser.DTD;
import java.io.IOException; import java.lang.String; import java.util.Vector; import java.util.Enumeration;

public class ElementImpl
implements Element#ql:msxml'element#, java.io.Serializable

msxml'ei'FIELDS:
Name#ql:msxml'nm'name# tag; //Tag of the element (markup).
int type;
String text; //Text for element.
Element parent;
Vector children; //Children element list.
Document doc#ql:msxml'ei'* doc ^msxml'ei'fields#; //Cached pointer to owning Document
protected Attributes#ql:msxml'atts'Attributes# attrlist;
static Atom nameXML = Atom.create#ql:msxml'at'create#("XML");
static Name nameXMLSPACE = Name.create("XML-SPACE","XML");
static Name nameXMLAS = Name.create("AS", "XML");
static Name nameXMLHREF = Name.create("HREF", "XML");

public msxml'ei'ElementImpl()
{this(null, Element.ELEMENT); }

public msxml'ei'ElementImpl(Name tag, int type)
{ this.tag = tag; this.type = type; }

public Name msxml'ei'getTagName()
{ return tag; }

public int msxml'ei'getType()
{ return type#ql:msxml'ei'fields type#; }

public String msxml'ei'getText()
/** * Returns the non-marked-up text contained by this element. * For text elements, this is the raw data. For elements * with child nodes, this method traverses the entire subtree and * appends the text for each terminal text element, effectively * stripping out the XML markup for the subtree. For example, * if the XML document contains the following: <AUTHOR> <FIRST>William</FIRST> <LAST>Shakespeare</LAST> </AUTHOR> Document.getText returns "William Shakespeare". */
{
if (type == ENTITYREF) { Document d = getDocument(); if (d != null) { DTD dtd = d.getDTD(); if (dtd != null) { Element ent = dtd.findEntity(getTagName()); if (ent != null) { return ent.getText(); } } } }

else if (children == null || type == CDATA || type == PCDATA || type == WHITESPACE) { return text == null ? new String("") : text; }

else if (children != null) { StringBuffer sb = new StringBuffer();
for (Enumeration en = children.elements(); en.hasMoreElements(); ) {
if (sb.length() > 0) sb.append(' '); sb.append(((Element)en.nextElement()).getText()); }
return sb.toString(); } return ""; }

public void msxml'ei'setText(String text)
{ // No restrictions here, so that subclasses can use this.
this.text#ql:msxml'ei'fields text# = text; }

public Element msxml'ei'getParent()
//Retrieves the parent of this element. Every element in the tree except the Document
// object itself, has a parent. Return the parent element or null if the element is at the
// root of the tree.
{ return parent; }

public void msxml'ei'setParent(Element parent)
{ this.parent#ql:msxml'ei'fields parent# = parent;
doc = null; // reset cached doc pointer. }

public Enumeration msxml'ei'getElements()
{ if (children == null) return EnumWrapper.emptyEnumeration;
return children#ql:msxml'ei'fields children#.elements(); //vector of childrens }

public ElementCollection msxml'ei'getChildren() { return new ElementCollection(this); }

public int msxml'ei'numAttributes() { return (attrlist == null) ? 0 : attrlist.size(); }

public int msxml'ei'numElements()
//Retrieves the number of child elements.
{ return (children#ql:msxml'ei'fields children# == null) ? 0 : children.size#ql::2nfoJAPI11.NFO:class.vector#(); } //children is a vector

public void msxml'ei'addChild(Element elem, Element after)
{ if (children#ql:msxml'ei'fields children# == null) { children = new Vector(4); }
if (after == null) { children.addElement#ql::JAPI101.NFO:addElement rl5#(elem); }
else if (after == this) { children.insertElementAt#ql::JAPI101.NFO:insertElementAt rl5# (elem, 0); }
else { children.insertElementAt(elem, children.indexOf(after) + 1); } elem.setParent#ql:msxml'ei'setParent#(this); }

public void msxml'ei'addChild(Element elem, int pos, int reserved) { if (pos == 0) addChild(elem, this); else if (pos < 0 || pos > numElements()-1) addChild(elem, null); else addChild(elem, getChild(pos-1)); }

public Element msxml'ei'getChild(int index)
{ if (children#ql:msxml'ei'fields children# != null && index >= 0 && index < children.size()) { try { return (Element)children.elementAt(index); } catch (Exception e) { } } return null; }

public void msxml'ei'removeChild(Element elem)
{ if (children != null) { elem.setParent(null); children.removeElement(elem); } }

public Enumeration msxml'ei'getAttributes() { if (attrlist == null) return EnumWrapper.emptyEnumeration; return attrlist.attributes(); }

public Object msxml'ei'getAttribute(String name)
{ return getAttribute(qualifyName#ql:msxml'ei'qualifyName#(name)); }

public Object msxml'ei'getAttribute(Name attrName)
//Retrieves an attribute's value given its name.
{ Object obj = null;
if (attrlist#ql:msxml'ei'fields attrlist# != null) { obj = attrlist.get(attrName); } return obj; }

public void msxml'ei'setAttribute(String name, Object value)
{setAttribute(qualifyName(name), value); }

public void msxml'ei'removeAttribute(String name) { removeAttribute(qualifyName(name)); }

public void msxml'ei'removeAttribute(Name attrName) { if (attrlist != null) { attrlist.remove(attrName); } }

public String msxml'ei'toString() { return getClass().getName() + "[tag=" + tag + ",type=" + type + ",text=" + text + "]"; }

public void msxml'ei'setAttribute(Name attrName, Object value)
{if (attrlist == null) { attrlist = new Attributes();} attrlist.put(attrName, value); }

void msxml'ei'clear()
//Removes child nodes and attributes.
{ if (children != null) children.removeAllElements(); text = null; parent = null; if (attrlist != null) attrlist.removeAll(); }

public void msxml'ei'saveAttributes(Atom ns, XMLOutputStream o) throws IOException
{ for (Enumeration en = getAttributes(); en.hasMoreElements(); ) { Attribute a = (Attribute)en.nextElement();
Name n = a.getName();
o.write(' ');
if (n == nameXMLSPACE) o.writeChars(n.getName());
else o.writeQualifiedName(n, ns);
o.write('='); boolean qualified = isAttributeQualified(n,o.dtd); Object attr = a.getValue(); if (attr instanceof Name) { o.write('\"'); if (qualified) o.writeQualifiedName((Name)attr, ns); else o.writeChars(attr.toString()); o.write('\"'); } else if (attr instanceof Vector) { Vector v = (Vector)attr; o.write('\"'); for (Enumeration av = v.elements(); av.hasMoreElements();) { Name avn = (Name)av.nextElement(); if (qualified) o.writeQualifiedName(avn, ns); else o.writeChars(avn.toString()); if (av.hasMoreElements()) o.write(' '); } o.write('\"'); } else o.writeQuotedString(attr.toString()); } }

public boolean msxml'ei'isAttributeQualified(Name attr, DTD dtd) { if (dtd != null) { ElementDecl ed = dtd.findElementDecl(tag); if (ed != null) { AttDef ad = ed.findAttDef(attr); if (ad != null) { int t = ad.getType(); if (t == AttDef.ENTITY || t == AttDef.ENTITIES || t == AttDef.NOTATION) { return true; } } } } return false; }

public Element msxml'ei'toSchema() { return this; }

void msxml'ei'writeTagName(XMLOutputStream o) throws IOException
{ Element parent = getParent#ql:msxml'ei'getParent#();
Name tagName = getTagName#ql:msxml'ei'getTagName#();
if (parent != null && parent.getTagName() != null && parent.getTagName().getNameSpace() != null)
{ o.writeQualifiedName#ql:msxml'xmlos'writeQualifiedName#(tagName, parent.getTagName().getNameSpace()); }

else if (tagName.getNameSpace() != null)
{ o.writeQualifiedName(tagName, Atom.create("")); }

else { o.writeChars(tagName.getName#ql:msxml'nm'getName#()); } }

public void msxml'ei'save(XMLOutputStream o) throws IOException
{
if (getType#ql:msxml'ei'getType#() != WHITESPACE#ql:msxml'*'fields WHITESPACE#) o.writeIndent#ql:msxml'xmlos'writeIndent#();
int type = getType();

switch (type) {
case Element.WHITESPACE:
if (o.getOutputStyle() == XMLOutputStream.DEFAULT) o.writeChars(getText#ql:msxml'ei'getText#()); break;

case Element.ELEMENT:
case Element.ENTITY#ql:msxml'e'fields ENTITY#: // in schema format
{ int oldStyle = -1; boolean wasmixed = o.mixed#ql:msxml'xmlos'fields mixed#;
if (tag != null) { o.writeChars("<"); // Write out the tag name
writeTagName#ql:msxml'ei'writeTagName#(o); // Write out the attributes. saveAttributes#ql:msxml'ei'saveAttributes#(getTagName().getNameSpace(), o); // Find out if we're preserving white space.
Object v = getAttribute#ql:msxml'ei'getAttribute#(nameXMLSPACE#ql:msxml'ei'* nameXMLSPACE#);
String value = null;
if (v != null) value = v.toString();
if (value != null) { oldStyle = o.getOutputStyle(); boolean preserveWS = value.equalsIgnoreCase#ql::JAPI101.NFO:equalsIgnoreCase rl5#("preserve"); o.setOutputStyle(preserveWS ? XMLOutputStream.COMPACT : XMLOutputStream.PRETTY); } // Write the close start tag.
if (numElements() > 0) { o.write('>'); }
else { o.writeChars("/>"); } } // find out if this is a mixed element.
ElementEnumeration ee = null;
o.mixed = false; // not inherited down heirarchy.
for (ee = new ElementEnumeration(this); ee.hasMoreElements(); ) { Element ne = (Element)ee.nextElement();
if (ne.getType() == PCDATA || ne.getType() == ENTITYREF) { o.mixed = true; break; } } o.writeNewLine(); o.addIndent(1);
o.nameSpaceContext#ql:msxml'xmlos'fields nameSpaceContext#.push#ql:msxml'nsc'methods#();
for (ee = new ElementEnumeration(this); ee.hasMoreElements(); ) { Element ne = (Element)ee.nextElement(); ne.save(o); } o.nameSpaceContext.pop#ql:msxml'nsc'pop#(); o.addIndent(-1);
if (tag != null && numElements() > 0) { o.writeIndent();
if (o.isShortEndTags#ql:msxml'xmlos'isShortEndTags#()) o.writeChars("</>"); // short end tags save space ! else { o.writeChars("</"); writeTagName(o); o.writeChars(">"); }
if (oldStyle != -1) { o.setOutputStyle(oldStyle); } o.mixed = wasmixed; o.writeNewLine(); } } break;

case Element.PI: o.writeChars("<?"); o.writeQualifiedName(getTagName(), null); saveAttributes(getTagName().getNameSpace(), o); o.writeChars(getText() + "?>"); o.writeNewLine(); break;

case Element.CDATA#ql:msxml'e'fields cdata#: o.writeChars("<![CDATA[" + getText() + "]]>"); o.writeNewLine(); break;

case Element.PCDATA:
o.writeChars(getText#ql:msxml'ei'getText#());
o.writeNewLine(); break;

case Element.ENTITYREF#ql:msxml'e'fields ENTITYREF#: if (o.savingDTD) { o.write('%'); } else { o.write('&'); } o.writeQualifiedName(getTagName(), getParent().getTagName().getNameSpace()); o.writeChars(";"); if (o.savingDTD) o.writeNewLine(); break;

case Element.COMMENT: o.writeChars(""); o.writeNewLine(); break;

case Element.NAMESPACE#ql:msxml'e'fields NAMESPACE#: o.writeChars("<?XML::NAMESPACE"); saveAttributes(nameXML, o); o.writeChars("?>"); o.writeNewLine(); // record name space context Atom as, href; as = Atom.create(getAttribute(nameXMLAS).toString()); href = Atom.create(getAttribute(nameXMLHREF).toString()); o.nameSpaceContext.addNameSpace(href, as); break;

case Element.INCLUDESECTION#ql:msxml'e'fields INCLUDESECTION#: if (tag == null) { o.writeChars("<![INCLUDE["); } else { o.writeChars("<![%"); o.writeChars(tag.toString()); o.writeChars(";["); } for (ElementEnumeration ee = new ElementEnumeration(this); ee.hasMoreElements(); ) { Element e = (Element)ee.nextElement(); e.save(o); } o.writeChars("]]>"); break;

case Element.IGNORESECTION:
if (tag == null) { o.writeChars("<![IGNORE["); }
else { o.writeChars("<![%"); o.writeChars(tag.toString()); o.writeChars(";["); } for (ElementEnumeration ee = new ElementEnumeration(this); ee.hasMoreElements(); ) { Element e = (Element)ee.nextElement(); e.save(o); } break;
} //END SWITCH

o.flush(); }

Name msxml'ei'qualifyName(String string)
{ int pos = string.indexOf#ql::JAPI101.NFO:class.string#("::");
if (pos != -1) { String sn = string.substring(0,pos);
Atom namespace = getNamespace#ql:msxml'ei'getNamespace#(sn);
String name = string.substring(pos+2);
return Name.create(name, namespace); }
else if (tag != null) { return Name.create(string, tag.getNameSpace()); } return Name.create(string); }

Atom msxml'ei'getNamespace(String str)
{ Atom name = Atom.create(str);
Document d = getDocument#ql:msxml'ei'getDocument#();
if (d != null) { DTD dtd = d.getDTD();
if (dtd != null) { Atom namespace = dtd.findLongNameSpace#ql:msxml'dtd'findLongNameSpace#(name); if (namespace != null) return namespace; } } return name; }

Document msxml'ei'getDocument()
{ if (doc#ql:msxml'ei'fields doc# == null)
{ Element e = this;
while (e.getParent() != null) { e = e.getParent(); }
if (e instanceof Document) { doc = (Document)e; }
}
return doc; }

msxml'ElementImplBeanInfo'EIBI

name::
* McsEngl.msxml'ElementImplBeanInfo'EIBI@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
This class provides specialized JavaBeans support for the ElementImpl class to resolve which overloaded functions are accessible through scripting.

public MethodDescriptor[] getMethodDescriptors()

====================================================================

package com.ms.xml.om; import java.beans.*; import java.lang.reflect.Method;
/** * This class provides specialized JavaBeans support for the * <code>ElementImpl</code> class to resolve which overloaded functions * are accessible through scripting.

*/ public class ElementImplBeanInfo extends SimpleBeanInfo { private final static Class beanClass = ElementImpl.class;
/** * Returns the method descriptions for the methods that are * to be made available through scripting.

* @return an array of <code>MethodDescriptor</code> objects.

*/ public MethodDescriptor[] getMethodDescriptors() { // First find the "method" objects.

Method numElementMethod; Method addChildMethod; Method getChildMethod; Method removeChildMethod; Method numAttributesMethod; Method getAttributeMethod; Method setAttributeMethod; Method removeAttributeMethod; // Method saveMethod; Class args[] = { }; Class addChildArgs[] = { Element.class, int.class, int.class }; Class getChildArgs[] = { int.class }; Class removeChildArgs[] = { Element.class }; Class getAttributeArgs[] = { String.class }; Class setAttributeArgs[] = { String.class , Object.class }; // Class saveArgs[] = { XMLOutputStream.class };
try { numElementMethod = ElementImpl.class.getMethod("numElements", args); addChildMethod = ElementImpl.class.getMethod("addChild", addChildArgs); getChildMethod = ElementImpl.class.getMethod("getChild", getChildArgs); removeChildMethod = ElementImpl.class.getMethod("removeChild", removeChildArgs); numAttributesMethod = ElementImpl.class.getMethod("numAttributes", args); getAttributeMethod = ElementImpl.class.getMethod("getAttribute", getAttributeArgs); setAttributeMethod = ElementImpl.class.getMethod("setAttribute", setAttributeArgs); removeAttributeMethod = ElementImpl.class.getMethod("removeAttribute", getAttributeArgs); // saveMethod = ElementImpl.class.getMethod("save", saveArgs); } catch (Exception ex) { // "should never happen" throw new Error("Missing method: " + ex); }
// Now create the MethodDescriptor array // with visible event response methods: MethodDescriptor result[] = { new MethodDescriptor(numElementMethod), new MethodDescriptor(addChildMethod), new MethodDescriptor(getChildMethod), new MethodDescriptor(removeChildMethod), new MethodDescriptor(numAttributesMethod), new MethodDescriptor(getAttributeMethod), new MethodDescriptor(setAttributeMethod), new MethodDescriptor(removeAttributeMethod) // new MethodDescriptor(saveMethod) };
return result; }
}

msxml'SiblingEnumeration'SE

name::
* McsEngl.msxml'SiblingEnumeration'SE@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
An Enumeration for iterating over the siblings (αδέλφια) of a given node in the XML tree

msxml'se'METHODS:
public SiblingEnumeration(Element node);
public SiblingEnumeration(Element node, boolean enumDir );
public boolean hasMoreElements();
public Object nextElement();
public void reset();

===========================================================

package com.ms.xml.om;

import com.ms.xml.util.EnumWrapper; import com.ms.xml.util.Name; import com.ms.xml.util.Queue; import java.util.Enumeration; import java.util.Stack;

public class SiblingEnumeration
implements Enumeration {

msxml'se'FIELDS:
Element originalNode;
Element next;
// Sibling enumeration
Element parent;
Enumeration siblings;
int siblingIndex;
boolean enumerationDir; // true = forwards - false = backwards

/** * Creates new iterator for iterating over all of the children * of the given root node. */

public msxml'se'SiblingEnumeration(Element node)
{ Initialize( node, true ); }

public msxml'se'SiblingEnumeration(Element node, boolean enumDir )
{ Initialize( node, enumDir ); }

private void msxml'se'Initialize( Element node, boolean enumDir )
{ this.originalNode = node; this.enumerationDir = enumDir; this.next = null; this.parent = null; this.siblings = null; this.siblingIndex = 0;
if( node != null ) { this.parent = node.getParent(); if( this.parent!=null ) { if( !enumDir ) // backwards traversal { // locate the given node in the children list int i = 0;
Enumeration en = this.parent.getElements(); while( en.hasMoreElements() && (Element)en.nextElement() != node ) i++; // If (i >= numElements) then node was not found. // This should never happen, since parent = node.getParent() this.siblingIndex = (i < this.parent.numElements() ) ? i : 0; } else // default to forward traversal { // Advance siblings enumerator to correct position this.siblings = this.parent.getElements(); while( siblings.hasMoreElements() && (Element)siblings.nextElement() != node ) ; } } } }

/** * Reset the iterator so you can iterate through the elements again. */

public void msxml'se'reset()
{ Initialize( originalNode, enumerationDir ); }

/** * Return whether or not there are any more matching elements. * @return true if the next call to nextElement will return * non null result. */

public boolean msxml'se'hasMoreElements() { if (next == null) { next = next(); } return (next != null) ? true : false; }

/** * Return the next matching element. * @return Element or null of there are no more matching elements. */
public Object msxml'se'nextElement()
{ if (next != null) { Element result = next; next = null; return result; } return next(); }

/** * Internal method for getting next element. */
Element msxml'se'next() { if( !enumerationDir ) // backwards traversal return prevSibling(); else // default to forward traversal return nextSibling(); }

Element msxml'se'nextSibling()
{ if (siblings != null) { Element e = (Element)siblings.nextElement(); return e; } return null; }

Element msxml'se'prevSibling()
{ if( parent != null )
{ Element e = parent.getChild#ql:msxml'ei'getChild#( --siblingIndex ); return e; } return null; }

}

msxml'TreeEnumeration'TE

name::
* McsEngl.msxml'TreeEnumeration'TE@cptItsoft,

PACKAGE: com.ms.xml.om

_DEFINITION:
An Enumeration for iterating over the entire subtree of a given node in the XML tree, DFS or BFS

msxml'te'METHODS:
public TreeEnumeration(Element node);
public TreeEnumeration(Element node, boolean enumDir );
public boolean hasMoreElements();
public Object nextElement();
public void reset();

==================================================================

package com.ms.xml.om;

import com.ms.xml.util.EnumWrapper; import com.ms.xml.util.Name; import com.ms.xml.util.Queue; import java.util.Enumeration; import java.util.Stack;

public class TreeEnumeration
implements Enumeration {

msxml'te'FIELDS:
Element originalNode;
Element next;
Enumeration children;
// DFSTree enumeration
Stack DFSstack;
Element curr;
// BFSTree enumeration
Queue BFSqueue;
boolean enumerationDir; // true = DFS tree - false = BFS tree

/** * Creates new iterator for iterating over all of the children of the given root node. */
public TreeEnumeration(Element node)
{ Initialize( node, true ); } public TreeEnumeration(Element node, boolean enumDir ) { Initialize( node, enumDir ); }

private void Initialize( Element node, boolean enumDir ) { this.originalNode = node; this.enumerationDir = enumDir; this.next = null;
this.DFSstack = null; this.BFSqueue = null;
this.curr = node; this.children = new EnumWrapper(node);
if( !enumDir ) // BFS traversal { this.BFSqueue = new Queue(); } else // default to DFS traversal { this.next = node; children.nextElement(); this.DFSstack = new Stack(); } }

/** * Reset the iterator so you can iterate through the elements again. */
public void reset() { Initialize( originalNode, enumerationDir ); }

/** * Return whether or not there are any more matching elements. * @return true if the next call to nextElement will return * non null result. */
public boolean hasMoreElements() { if (next == null) { next = next(); } return (next != null) ? true : false; }

/** * Return the next matching element. * @return Element or null of there are no more matching elements. */
public Object nextElement()
{ if (next != null)
{ Element result = next; next = null; return result; }
return next(); }

/** * Internal method for getting next element. */
Element next() { if( !enumerationDir ) // BFS traversal return nextElementTreeBFS(); else // default to DFS traversal return nextElementTreeDFS(); }

Element nextElementTreeDFS()
{ while (curr != null) { // try to go down a level DFSstack.push(children); children = curr.getElements(); // try next at this level if (children.hasMoreElements()) { curr = (Element)children.nextElement(); return curr; } // go back up for (curr = curr.getParent(); curr != null; curr = curr.getParent()) { if(DFSstack.empty()) return null; // If the original node is not the root of tree...
children = (Enumeration)DFSstack.pop(); if (children.hasMoreElements()) { curr = (Element)children.nextElement(); return curr; } } } return null; }

Element nextElementTreeBFS() { while (curr != null) { while( !children.hasMoreElements() ) { children = (Enumeration)BFSqueue.pull(); if( children == null ) return null; }
// go to the next child curr = (Element)children.nextElement(); BFSqueue.push(curr.getElements()); return curr; } return null; }

}

com.ms.xml.parser.*

name::
* McsEngl.com.ms.xml.parser.*@cptItsoft,

msxml'AttDef'AD

name::
* McsEngl.msxml'AttDef'AD@cptItsoft,

PACKAGE: com.ms.xml.parser

_DEFINITION:
This object describes an attribute type and potential values.

msxml'ad'METHODS:
public Object getDefault();
public Name getName();
public int getPresence();
public int getType();

==================================================

public class AttDef
implements java.io.Serializable

msxml'ad'FIELDS:
public static final int CDATA = 0;
public static final int ID = 1;
public static final int IDREF = 2;
public static final int IDREFS = 3;
public static final int ENTITY = 4;
public static final int ENTITIES = 5;
public static final int NMTOKEN = 6;
public static final int NMTOKENS = 7;
public static final int NOTATION = 8;
public static final int ENUMERATION= 9;

public static final int DEFAULT = 0; public static final int REQUIRED = 1; public static final int IMPLIED = 2; public static final int FIXED = 3;

Name name; //name of attribute declared

byte type;
byte presence;
Object def; //default value, can be null
Vector values; //array of values for enumerated and notation types

static Name nameATTRIBUTE = Name.create("ATTRIBUTE","XML"); static Name nameID = Name.create("ID","XML"); static Name nameDEFAULT = Name.create("DEFAULT","XML"); static Name namePRESENCE = Name.create("PRESENCE","XML"); static Name nameVALUES = Name.create("VALUES","XML"); static Name nameTYPE = Name.create("TYPE","XML");

String msxml'ad'typeToString() { switch(type) { case ID: return "ID"; case IDREF: return "IDREF"; case IDREFS: return "IDREFS"; case ENTITY: return "ENTITY"; case ENTITIES: return "ENTITIES"; case NMTOKEN: return "NMTOKEN"; case NMTOKENS: return "NMTOKENS"; case NOTATION: return "NOTATION"; case ENUMERATION: return "ENUMERATION"; case CDATA: default: return "CDATA"; } }

String msxml'ad'presenceToString() { switch(presence) { case IMPLIED: return "IMPLIED"; case REQUIRED: return "REQUIRED"; case FIXED: return "FIXED"; case DEFAULT: default: return "DEFAULT"; } }

msxml'ad'AttDef(Name name, int type)
{ this(name, type, null, 0, null); }

msxml'ad'AttDef(Name name, int type, Vector values)
{ this(name, type, null, 0, values); }

msxml'ad'AttDef(Name name, int type, Object def, int presence) { this(name, type, def, presence, null); }

msxml'ad'AttDef(Name name, int type, Object def, int presence, Vector values) { this.name = name; this.type = (byte)type; this.def = def; this.presence = (byte)presence; this.values = values; }

final Object msxml'ad'parseAttribute(Element e, Parser parser) throws ParseException { parser.parseToken(Parser.QUOTE, "string"); return parseAttValue(e, parser, false); }

private void msxml'ad'reportMismatch(Parser parser) throws ParseException { parser.error("Attribute " + name + " should have the fixed value \"" + def + "\""); }

private void msxml'ad'reportEmpty(Parser parser, String s) throws ParseException { parser.error("Expected " + parser.tokenString(parser.NAME, s) + " insteadof " + parser.tokenString(parser.token, null)); }

final Object msxml'ad'parseAttValue(Element e, Parser parser, boolean inDTD) throws ParseException { int i; Vector names; Name name = null; Object value; StringBuffer buf;
switch(type) { case CDATA: parser.scanString(parser.quote, '&', '&', '<'); value = parser.text; if (!inDTD && presence == FIXED && !def.toString().equals(parser.text)) reportMismatch(parser); break; case ID: parser.simplename++; parser.parseToken(parser.NAME, "ID"); parser.simplename--; parser.parseToken(parser.QUOTE, "string"); if (!inDTD) { if (presence == FIXED && (Name)def != parser.name) reportMismatch(parser); Element e1 = parser.dtd.findID(parser.name); if (e1 != null) { parser.error("ID " + name + " is already used on element " + e1.getTagName()); } parser.dtd.addID(parser.name, e); } value = parser.name; break; case IDREF: case IDREFS: names = new Vector(); buf = new StringBuffer(); parser.simplename++; i = parser.parseNames(names, Parser.INVALIDTOKEN, buf); parser.simplename--; if (i == 0) reportEmpty(parser, "IDREF"); if (i > 1 && type == IDREF) parser.error("IDREF type attribute \"" + this.name + "\" cannot refer to more than one ID."); if (!inDTD) { for (--i; i >= 0; --i) { name = (Name)names.elementAt(i); if (presence == FIXED) { if (type == IDREFS) checkFixed(name, parser); else if ((Name)def != name) reportMismatch(parser); } if (parser.dtd.findID(name) == null) { // add it to linked list to check later parser.dtd.addIDCheck(name, parser.reader.line, parser.reader.column - 1, parser.reader.owner); } } }
value = type == IDREF ? (Object)names.elementAt(0) : (Object)names; break; case ENTITY: case ENTITIES: buf = new StringBuffer(); names = new Vector(); parser.nouppercase++; i = parser.parseNames(names, Parser.INVALIDTOKEN, buf); parser.nouppercase--; if (i == 0) reportEmpty(parser, "ENTITY name"); if (i > 1 && type == ENTITY) parser.error("ENTITY type attribute \"" + this.name + "\" cannot refer to more than one entity."); for (--i; i >= 0; --i) { name = (Name)names.elementAt(i); if (parser.dtd.findEntity(name) == null) { parser.error("Couldn't find entity '" + name + "'"); } if (!inDTD && presence == FIXED) { if (type == ENTITIES) checkFixed(name, parser); else if (name != (Name)def) reportMismatch(parser); } }
value = type == ENTITY ? (Object)names.elementAt(0) : (Object)names; break; case NMTOKEN: case NMTOKENS: buf = new StringBuffer(); names = new Vector(); parser.nametoken++; i = parser.parseNames(names, Parser.INVALIDTOKEN, buf); parser.nametoken--; if (i == 0) reportEmpty(parser, "NMTOKEN"); if (i > 1 && type == NMTOKEN) parser.error("NMTOKEN type attribute \"" + this.name + "\" cannot refer to more than one name token."); if (!inDTD && presence == FIXED) { if (type == NMTOKEN) { if ((Name)def != (Name)names.elementAt(0)) reportMismatch(parser); } else { for (i = values.size() - 1; i >= 0; i--) { checkFixed((Name)values.elementAt(i), parser); } } }
value = type == NMTOKEN ? (Object)names.elementAt(0) : (Object)names; break; case NOTATION: case ENUMERATION: if (type == ENUMERATION) parser.nametoken++; parser.parseToken(parser.NAME, "name"); if (type == ENUMERATION) parser.nametoken--; parser.parseToken(parser.QUOTE, "string"); for (i = values.size() - 1; i >= 0; i--) { if ((Name)values.elementAt(i) == parser.name) { break; } } if (i < 0) { parser.error("Attribute value '" + parser.name + "' is not in the allowed set."); } if (!inDTD && presence == FIXED && parser.name != def) reportMismatch(parser);
value = parser.name; break; default: value = null; } return value; }

private void msxml'ad'checkFixed(Name name, Parser parser) throws ParseException { Vector v = (Vector)def; int i; for (i = v.size() - 1; i >= 0; i--) { if ((Name)v.elementAt(i) == name) { break; } } if (i < 0) { parser.error("Attribue value " + name + " is not in the fixed value set."); } }

Element msxml'ad'toSchema() { Element attribute = new ElementImpl( nameATTRIBUTE, Element.ELEMENT ); attribute.setAttribute( nameID, name.getName() ); attribute.setAttribute( nameTYPE, typeToString() );
if( presence != DEFAULT ) attribute.setAttribute( namePRESENCE, presenceToString() ); if( type == ENUMERATION ) { String valueString = ""; for (int i = 0; i < values.size(); i++) { Name name = (Name)values.elementAt(i); valueString = valueString + name.toString(); if (i < values.size() - 1) valueString = valueString + " "; } attribute.setAttribute( nameVALUES, valueString ); }
if( def != null ) attribute.setAttribute( nameDEFAULT, def );
return attribute; }

void msxml'ad'save(Atom ns, XMLOutputStream o) throws IOException { if (name == Parser.nameXMLSpace) o.writeChars(name.getName()); else o.writeQualifiedName(name, ns); switch(type) { case CDATA: o.writeChars(" CDATA"); break; case ID: o.writeChars(" ID"); break; case IDREF: o.writeChars(" IDREF"); break; case IDREFS: o.writeChars(" IDREFS"); break; case ENTITY: o.writeChars(" ENTITY"); break; case ENTITIES: o.writeChars(" ENTITIES"); break; case NMTOKEN: o.writeChars(" NMTOKEN"); break; case NMTOKENS: o.writeChars(" NMTOKENS"); break; case NOTATION: o.writeChars(" NOTATION"); // fall through case ENUMERATION: o.writeChars(" ("); for (int i = 0; i < values.size(); i++) { Name name = (Name)values.elementAt(i); if (type == NOTATION) o.writeQualifiedName(name, ns); else o.writeChars(name.toString()); if (i < values.size() - 1) o.write('|'); } o.write(')'); break; } switch (presence) { case REQUIRED: o.writeChars("#REQUIRED"); break; case IMPLIED: o.writeChars("#IMPLIED"); break; case DEFAULT: case FIXED: if (presence == FIXED) o.writeChars("#FIXED"); if (def != null) { o.writeChars(" "); switch (type) { case CDATA: case ID: case IDREF: case NMTOKEN: case ENUMERATION: o.writeQuotedString(def.toString()); break; case NOTATION: case ENTITY: o.write('\"'); o.writeQualifiedName((Name)def, ns); o.write('\"'); break; case ENTITIES: case IDREFS: case NMTOKENS: o.write('\"'); int i = 0; for (Enumeration e = ((Vector)def).elements(); e.hasMoreElements();) { if (i++ > 0) o.write(Parser.OR); if (type == ENTITIES) o.writeQualifiedName((Name)e.nextElement(), ns); else o.writeChars(e.nextElement().toString()); } o.write('\"'); break; } } break; } }

public Object msxml'ad'getDefault() { return def; }

public Name msxml'ad'getName() { return name; }

public int msxml'ad'getType() { return (int)type; }

public int msxml'ad'getPresence() { return (int)presence; }

msxml'ContentModel'CM

name::
* McsEngl.msxml'ContentModel'CM@cptItsoft,

_DEFINITION:
This class represents the content model definition for a given XML element. The content model is defined in the element declaration in the Document Type Definition (DTD); for example, (a,(b|c)*,d). The content model is stored in an expression tree of Node objects for use by the XML parser during validation.

msxml'cm'METHODS:
public byte getType();
public void save(Atom ns, XMLOutputStream o) throws IOException;
public Element toSchema();
public String toString();

============================================

public class ContentModel
implements java.io.Serializable {

msxml'cm'FIELDS:
Node content; //content model points to syntax tree
Terminal end; //end node
Vector terminalnodes;
Hashtable symboltable;
Vector symbols;
Vector Dtrans;
public static final byte EMPTY = 1;
public static final byte ANY = 2;
public static final byte ELEMENTS = 4;
byte type;

static Name nameEMPTY = Name.create("EMPTY","XML"); static Name nameANY = Name.create("ANY","XML");

public byte msxml'cm'getType() { return type; }

public String msxml'cm'toString() { String s; switch(type) { case EMPTY: s = "EMPTY"; break; case ANY: s = "ANY"; break; case ELEMENTS: s = "ELEMENTS"; break; default: s = "*UNKNOWN*"; } return "Content: type=" + s; }

final void msxml'cm'parseModel(Parser parser) throws ParseException { terminalnodes = new Vector(); symboltable = new Hashtable(); symbols = new Vector(); // create parse tree for content expression content = parseRootNode(parser); // add end node end = new Terminal(this, null); content = new Sequence(content, end);
// calculate followpos for terminal nodes int terminals = terminalnodes.size(); BitSet[] followpos = new BitSet[terminals]; for (int i = 0; i < terminals; i++) { followpos[i] = new BitSet(terminals); } content.calcfollowpos(followpos);
// state table Vector Dstates = new Vector(); // transition table Dtrans = new Vector(); // lists unmarked states Vector unmarked = new Vector(); // state lookup table Hashtable statetable = new Hashtable();
BitSet empty = new BitSet(terminals); statetable.put(empty, new Integer(-1)); // current state processed int state = 0;
// start with firstpos at the root BitSet set = content.firstpos(terminals); statetable.put(set, new Integer(Dstates.size())); unmarked.addElement(set); Dstates.addElement(set); int[] a = new int[symbols.size() + 1]; Dtrans.addElement(a); if (set.get(end.pos)) { a[symbols.size()] = 1; // accepting }
// check all unmarked states while (unmarked.size() > 0) { int[] t = (int[])Dtrans.elementAt(state); set = (BitSet)unmarked.elementAt(0); unmarked.removeElementAt(0);
// check all input symbols for (int sym = 0; sym < symbols.size(); sym++) { Name n = (Name)symbols.elementAt(sym);
BitSet newset = new BitSet(terminals); // if symbol is in the set add followpos to new set for (int i = 0; i < terminals; i++) { if (set.get(i) && ((Terminal)terminalnodes.elementAt(i)).name == n) { newset.or(followpos[i]); } }
Integer lookup = (Integer)statetable.get(newset); // this state will transition to int transitionTo; // if new set is not in states add it if (lookup == null) { transitionTo = Dstates.size(); statetable.put(newset, new Integer(transitionTo)); unmarked.addElement(newset); Dstates.addElement(newset); a = new int[symbols.size() + 1]; Dtrans.addElement(a); if (newset.get(end.pos)) { a[symbols.size()] = 1; // accepting } } else { transitionTo = lookup.intValue(); } // set the transition for the symbol t[sym] = transitionTo; } state++; } }

final Node msxml'cm'parseList(Parser parser) throws ParseException { //use Hashtable to check name uniqueness Hashtable symbols = new Hashtable(); symbols.put(parser.name, parser.name);
Node n = parseNode(parser); int cpType = parser.token;
switch (parser.token) { case Parser.COMMA: parser.nextToken(); n = new Sequence(n, parseNode(parser)); break; case Parser.OR: parser.nextToken(); if (parser.token == parser.NAME) { if (symbols.contains(parser.name)) parser.error("Warning: Repeated element in content model: " + parser.name ); else symbols.put(parser.name, parser.name); } n = new Choice(n, parseNode(parser)); break; case Parser.RPAREN: return n; default: parser.error("Illegal token in content model: " + parser.tokenString(parser.token)); }
for (;;) { if (parser.token == Parser.RPAREN) return n; else if (cpType == Parser.COMMA && parser.token == Parser.COMMA) { parser.nextToken(); n = new Sequence(n, parseNode(parser)); } else if (cpType == Parser.OR && parser.token == Parser.OR) { parser.nextToken(); if (parser.token == parser.NAME) { if (symbols.contains(parser.name)) parser.error("Repeated element in content model: " + parser.name ); else symbols.put(parser.name, parser.name); } n = new Choice(n, parseNode(parser)); } else parser.error("Illegal token in content model: " + parser.tokenString(parser.token)); } }

final Node msxml'cm'parseNode(Parser parser) throws ParseException { Node n;
switch (parser.token) { case Parser.LPAREN: parser.nextToken(); n = parseList(parser); break; case Parser.NAME: n = new Terminal(this, parser.name); break; default: n = null; parser.error("Illegal token in content model: " + parser.tokenString(parser.token)); } return finishNode(parser, n); }

final Node msxml'cm'finishNode(Parser parser, Node m) throws ParseException { Node n;
switch (parser.lookahead) { case Parser.ASTERISK: parser.nextToken(); n = new Closure(m); break; case Parser.PLUS: parser.nextToken(); n = new ClosurePlus(m); break; case Parser.QMARK: parser.nextToken(); n = new Qmark(m); break; default: n = m; } parser.nextToken(); return n; }

final Node msxml'cm'parseRootNode(Parser parser) throws ParseException { Node n;
switch (parser.token) { case Parser.LPAREN: parser.nextToken(); if (parser.token == Parser.HASH) return parseMixed(parser); else n = parseList(parser); break; case Parser.NAME: n = new Terminal(this, parser.name); break; default: n = null; parser.error("Expected ANY, EMPTY or '(' instead of: " + parser.tokenString(parser.token)); } return finishNode(parser, n); }

final Node msxml'cm'parseMixed(Parser parser) throws ParseException { Node n; Hashtable symbols= new Hashtable(); parser.parseKeyword(Parser.PCDATA, "PCDATA"); n = new Terminal(this, parser.name); symbols.put(parser.name, parser.name); parser.nextToken(); switch (parser.token) { case Parser.RPAREN: // create a closure even if there is no asterisk. n = new Closure(n); if (parser.lookahead == Parser.ASTERISK) { parser.nextToken(); } break; case Parser.OR: for (;;) { if (parser.token == Parser.OR) { parser.nextToken(); if (parser.token == parser.NAME) { if (symbols.contains(parser.name)) parser.error("Repeated element in content model: " + parser.name); else symbols.put(parser.name, parser.name); } n = new Choice(n, parseNode(parser)); } else if (parser.token == Parser.RPAREN) { if (parser.lookahead == Parser.ASTERISK) { parser.nextToken(); n = new Closure(n); } else parser.error("Expected '*' instead of: " + parser.tokenString(parser.token)); break; } else { parser.error("Illegal token in content model: " + parser.tokenString(parser.token)); break; } } break; default: parser.error("Illegal token in content model: " + parser.tokenString(parser.token)); } parser.nextToken(); return n; }

final void msxml'cm'initContent(Context context, Parser parser) throws ParseException { context.state = 0; if (Dtrans != null && Dtrans.size() > 0) { context.matched = ((int[])Dtrans.elementAt(context.state))[symbols.size()] > 0; } else { context.matched = true; } }

final boolean msxml'cm'acceptEmpty() { if (type == ANY || type == EMPTY) return true; Node node = ((Sequence)content).left; if (node instanceof Qmark || node instanceof Closure) return true; return false; }

final boolean msxml'cm'allowText() { switch (type) { case ANY: return true; case EMPTY: return false; default: Node node = ((Sequence)content).left; if (node instanceof Closure) { node = ((Closure)node).node; while (node instanceof Sequence) { node = ((Sequence)node).left; } if (node instanceof Terminal && ((Terminal)node).name == Node.namePCDATA) { return true; } } return false; } }

final Vector msxml'cm'expectedElements(int state) { int[] t = (int[])Dtrans.elementAt(state); Vector names = new Vector();
for (Enumeration e = terminalnodes.elements(); e.hasMoreElements();) { Name n = ((Terminal)e.nextElement()).name; if (n != null && !names.contains(n)) { Integer lookup = (Integer)symboltable.get(n); if (lookup != null && t[lookup.intValue()] != -1) { names.addElement(n); } } } return names; }

final boolean msxml'cm'checkContent(Context context, Element e, Parser parser) throws ParseException { if (type == ANY) { context.matched = true; return true; } Name n = null; if (e.getType() == Element.PCDATA || e.getType() == Element.ENTITYREF) { n = Parser.namePCDATA; } else { n = e.getTagName(); }
if (n != null) { Integer lookup = (Integer)symboltable.get(n); if (lookup != null) { int sym = lookup.intValue(); int state = ((int[])Dtrans.elementAt(context.state))[sym]; if (state == -1) { parser.error("Pattern mismatch in content of '" + e.getParent().getTagName() + "'. Expected " + expectedElements(context.state)); } else { context.state = state; context.matched = ((int[])Dtrans.elementAt(context.state))[symbols.size()] > 0; } return true; } else { Vector v = expectedElements(context.state); if (v.isEmpty()) parser.error("Invalid element '" + n + "' in content of '" + context.ed.name + "'. Expected closing tag."); else parser.error("Invalid element '" + n + "' in content of '" + context.ed.name + "'. Expected " + v); } } else { parser.error("Invalid element in content of '" + context.ed.name + "'"); } return false; }

public Element msxml'cm'toSchema() { Element elementContent = null;
switch (type) { case EMPTY: elementContent = new ElementImpl( nameEMPTY, Element.ELEMENT ); break; case ANY: elementContent = new ElementImpl( nameANY, Element.ELEMENT ); break; case ELEMENTS: if (content != null) { Element dummyNode = new ElementImpl( Name.create("DUMMYNODE"), Element.ELEMENT ); ((Sequence)content).left.toSchema(Parser.HASH, 0, dummyNode); elementContent = dummyNode.getChild(0); } break; }
return elementContent; }

public void msxml'cm'save(Atom ns, XMLOutputStream o) throws IOException { switch (type) { case EMPTY: o.writeChars("EMPTY"); break; case ANY: o.writeChars("ANY"); break; case ELEMENTS: if (content != null) ((Sequence)content).left.save(o, Parser.HASH, 0, ns); // skip outer sequence node break; } }

msxml'DTD

name::
* McsEngl.msxml'DTD@cptItsoft,

_DEFINITION:
This class contains all the Document Type Definition (DTD) information for an XML document.

msxml'dtd'METHODS:
public final void addLoadedNameSpace(Atom url);
public final void addNameSpace(Atom as, Atom href);
final public void clear();
public final Enumeration elementDeclarations();
public final Enumeration entityDeclarations();
public final ElementDecl findElementDecl(Name name);
public final Entity findEntity(Name n);
public final Atom findLoadedNameSpace(Atom url);
public final Atom findLongNameSpace(Atom as);
public final Notation findNotation(Name name);
public final Atom findShortNameSpace(Atom href);
final public Name getDocType();
final public Element getSchema();
static public boolean isReservedNameSpace(Atom n);
public final Enumeration notationDeclarations();
final public void save(XMLOutputStream o) throws IOException;

==================================================================

public class DTD
implements java.io.Serializable {

msxml'dtd'FIELDS:
static Hashtable builtin;
Hashtable entities;
Hashtable elementdecls;
Hashtable notations;
Hashtable shortNameSpaces;
Hashtable longNameSpaces;
Hashtable loadedNameSpaces;
transient Hashtable ids;
transient IDCheck idCheck;
Name docType;
Element schema = null;
static Atom nameXML = Atom.create("XML");

public msxml'dtd'DTD() { }

final void msxml'dtd'addEntity(Entity en) {
if (entities == null) { entities = new Hashtable(); } entities.put(en.name, en); }

public final Entity msxml'dtd'findEntity(Name n)
{ // First see if fully qualified entity is defined in DTD
Object o = null;
if (entities != null) { o = (Entity)entities.get(n); }
// Then see if the entity minus the namespace matches // a built in entity. This allows & to be used in // the scope of another namespace, otherwise the user // would have to use &::amp; which is wierd.
if (o == null) { o = builtin.get(n.getName()); }
if (o != null) { return (Entity)o; } return null; }

final void msxml'dtd'addElementDecl(ElementDecl ed) { if (elementdecls == null) { elementdecls = new Hashtable(); } elementdecls.put(ed.name, ed); }

public final ElementDecl msxml'dtd'findElementDecl(Name name) { return elementdecls == null ? null : (ElementDecl)elementdecls.get(name); }

public final Enumeration msxml'dtd'elementDeclarations() { return elementdecls == null ? EnumWrapper.emptyEnumeration : elementdecls.elements(); }

public final Enumeration msxml'dtd'entityDeclarations() { return entities == null ? EnumWrapper.emptyEnumeration : entities.elements(); }

public final Enumeration msxml'dtd'notationDeclarations() { return notations == null ? EnumWrapper.emptyEnumeration : notations.elements(); }

final void msxml'dtd'addNotation(Notation no) { if (notations == null) { notations = new Hashtable(); } notations.put(no.name, no); }

public final Notation msxml'dtd'findNotation(Name name) { return notations == null ? null : (Notation)notations.get(name); }

public final void msxml'dtd'addNameSpace(Atom as, Atom href) { if (shortNameSpaces == null) { shortNameSpaces = new Hashtable(); longNameSpaces = new Hashtable(); } shortNameSpaces.put(href, as); longNameSpaces.put(as, href); }

public final Atom msxml'dtd'findShortNameSpace(Atom href) { return shortNameSpaces == null ? null : (Atom)shortNameSpaces.get(href); }

public final Atom msxml'dtd'findLongNameSpace(Atom as)
{return longNameSpaces == null ? null : (Atom)longNameSpaces#ql:msxml'dtd'fields longNameSpaces#.get(as); //from hashtable
}

static public boolean msxml'dtd'isReservedNameSpace(Atom n) { return (n == nameXML); }

public final Atom msxml'dtd'findLoadedNameSpace(Atom url) { if (url == null) return null; return loadedNameSpaces == null ? null : (Atom)loadedNameSpaces.get(url); }

public final void msxml'dtd'addLoadedNameSpace(Atom url) { if (loadedNameSpaces == null) { loadedNameSpaces = new Hashtable(); } loadedNameSpaces.put(url, url); }

final void msxml'dtd'addID(Name name, Element e) { if (ids == null) { ids = new Hashtable(); } ids.put(name, e); }

final Element msxml'dtd'findID(Name name) { return ids == null ? null : (Element)ids.get(name); }

final void msxml'dtd'addIDCheck(Name name, int line, int col, Object owner) { idCheck = new IDCheck(idCheck, name, line, col, owner); }

final void msxml'dtd'checkIDs() throws ParseException { while(idCheck != null) { if (findID(idCheck.name) == null) { throw new ParseException("Couldn't find element with ID '" + idCheck.name.toString() + "'", idCheck.line, idCheck.col, idCheck.owner); } idCheck = idCheck.next; } }

final public Element msxml'dtd'getSchema()
{ if(schema#ql:schema msxml'dtd'fields# == null )
{ schema = new ElementImpl#ql:msxml'ei'elementimpl#( Name.create#ql:msxml'nm'create#("SCHEMA","XML"), Element.ELEMENT#ql:msxml'e'fields# );
if( docType != null ) schema.setAttribute( Name.create("ID","XML"), docType );
Enumeration e; if (longNameSpaces != null) { e = longNameSpaces.keys(); for( ; e.hasMoreElements(); ) { Atom as = (Atom)e.nextElement(); Element ns = new ElementImpl( Name.create("NAMESPACE","XML"), Element.PI ); ns.setAttribute(Name.create("HREF","XML"),longNameSpaces.get(as)); ns.setAttribute(Name.create("AS","XML"),as); schema.addChild( ns, null ); } }
e = notationDeclarations(); for( ; e.hasMoreElements(); ) { Element curr = (Element)e.nextElement(); Element currSchema = curr.toSchema(); if( currSchema != null ) schema.addChild( currSchema, null ); }
e = entityDeclarations(); for( ; e.hasMoreElements(); ) { Element curr = (Element)e.nextElement(); Element currSchema = curr.toSchema(); if( currSchema != null ) schema.addChild( currSchema, null ); }
e = elementDeclarations(); for( ; e.hasMoreElements(); ) { Element curr = (Element)e.nextElement(); Element currSchema = curr.toSchema(); if( currSchema != null ) schema.addChild( currSchema, null ); } }
return schema; }

final public void msxml'dtd'save(XMLOutputStream o)
throws IOException
{ if (notations#ql:msxml'dtd'fields notations# != null) { Enumeration e = notations.elements(); while (e.hasMoreElements()) { Notation n = (Notation)e.nextElement(); o.writeIndent(); n.save(o); } } if (entities != null) { Enumeration e = entities.elements(); while (e.hasMoreElements()) { Entity en = (Entity)e.nextElement(); o.writeIndent(); en.save(o); } } if (elementdecls != null) { Enumeration e = elementdecls.elements(); while (e.hasMoreElements()) { ElementDecl decl = (ElementDecl)e.nextElement(); o.writeIndent(); decl.save(o); } } }

final public void msxml'dtd'clear()
{ if (ids != null) ids.clear(); idCheck = null; }

final public Name msxml'dtd'getDocType()
{ return docType; }

msxml'ElementDecl'ED

name::
* McsEngl.msxml'ElementDecl'ED@cptItsoft,

_DEFINITION:
The class represents an element declaration in an XML Document Type Definition (DTD).

msxml'ed'METHODS:
public final AttDef findAttDef(Name name);
public final ContentModel getContent();
public final Name getName();
public void save(XMLOutputStream o) throws IOException;
public Element toSchema();

================================================================

public class ElementDecl
extends ElementImpl
implements java.io.Serializable

FIELDS:
Name name;
private Vector attdefs;
private ContentModel content;
ElementDecl base;
Vector interfaces;
Element schema = null;
static Name nameELEMENTTYPE = Name.create("ELEMENTTYPE","XML");
static Name nameID = Name.create("ID", "XML");

msxml'ed'ElementDecl(Name name) { super(name,Element.ELEMENTDECL); this.name = name; }

final void msxml'ed'parseModel(Parser parser) throws ParseException { content = new ContentModel(); parser.parseKeyword(0, "EMPTY|...");
// check for extends NAME if (parser.token == Parser.EXTENDS) { parser.parseToken(Parser.NAME, "base element declaration"); base = parser.dtd.findElementDecl(parser.name); if (base == null) { parser.error("Didn't find element declaration to extend " + parser.name); } parser.parseKeyword(0, "EMPTY|..."); }
// check for implements NAME, NAME, ... if (parser.token == Parser.IMPLEMENTS) { interfaces = new Vector(); int i = parser.parseNames(interfaces, Parser.COMMA, null); for (--i; i >= 0; i--) { ElementDecl ed = parser.dtd.findElementDecl((Name)interfaces.elementAt(i)); if (ed == null) { parser.error("Didn't find element declaration to implement " + interfaces.elementAt(i)); } else { interfaces.setElementAt(ed, i); } } // parseNames called nextToken() already... if (parser.token == Parser.NAME) { parser.token = parser.lookup(name.getName()); } }
switch (parser.token) { case Parser.EMPTY: content.type = ContentModel.EMPTY; parser.nextToken(); break; case Parser.ANY: content.type = ContentModel.ANY; parser.nextToken(); break; case Parser.LPAREN: content.type = ContentModel.ELEMENTS; content.parseModel(parser); break; case Parser.TAGEND: // it's ok to not to have content model if inherited if (base != null) { content = base.content; break; } default: parser.error("Expected EMPTY, ANY, or '('."); } if (parser.token != Parser.TAGEND) { parser.error("Element declaration syntax error. Expected '>' instead of '" + parser.tokenString(parser.token) + "'"); } }

final void msxml'ed'parseAttList(Parser parser) throws ParseException { int i; Vector names; AttDef attdef; parser.nextToken(); while (parser.token == Parser.NAME) { Name n = parser.name;
// make sure XML-SPACE belongs to the XML namespace. if (n.getName().equals(parser.nameXMLSpace.getName())) n = parser.nameXMLSpace;
parser.parseKeyword(0, "Attdef"); switch (parser.token) { case Parser.CDATA: case Parser.ID: case Parser.IDREF: case Parser.IDREFS: case Parser.ENTITY: case Parser.ENTITIES: case Parser.NMTOKEN: case Parser.NMTOKENS: attdef = new AttDef(n, Parser.CDATA - parser.token + AttDef.CDATA); break; case Parser.NOTATION: parser.parseToken(Parser.LPAREN, "("); names = new Vector(); i = parser.parseNames(names, Parser.INVALIDTOKEN, null); for (--i; i >= 0; i--) { Name name = (Name)names.elementAt(i); if (parser.dtd.findNotation(name) == null) { parser.error("Notation not declared '" + name + "'"); } } parser.parseToken(Parser.RPAREN, ")"); attdef = new AttDef(n, AttDef.NOTATION, names); break; case Parser.LPAREN: parser.nametoken++; names = new Vector(); i = parser.parseNames(names, Parser.OR, null); parser.nametoken--; if (parser.token != Parser.RPAREN) { parser.error("Expected )"); } attdef = new AttDef(n, AttDef.ENUMERATION, names); break; default: attdef = null; parser.error("Unknown token in attlist declaration " + parser.token); break; } if (parser.nextToken() == Parser.HASH) { parser.parseKeyword(0, "attribute default"); switch (parser.token) { case Parser.REQUIRED: attdef.presence = (byte)AttDef.REQUIRED; break; case Parser.IMPLIED: attdef.presence = (byte)AttDef.IMPLIED; break; case Parser.FIXED: attdef.presence = (byte)AttDef.FIXED; break; default: parser.error("Expected 'REQUIRED', 'IMPLIED', or 'FIXED'."); } parser.nextToken(); } if (attdef.presence == (byte)AttDef.FIXED || attdef.presence == (byte)AttDef.DEFAULT) { switch(parser.token) { case Parser.QUOTE: attdef.def = attdef.parseAttValue(this, parser, true); parser.nextToken(); break; default: parser.error("Expected FIXED or DEFAULT value for " + attdef.name); } } addAttDef(attdef); } }

final void msxml'ed'initContent(Context context, Parser parser) throws ParseException { context.ed = this; AttDef attdef = findAttDef(parser.nameXMLSpace); if (attdef != null) { Object defval = attdef.getDefault(); if (defval != null) { // The XML-SPACE declaration has a default value, which // should be used as default for context.preserveWS field. String s = (String)defval; context.preserveWS = s.equalsIgnoreCase("preserve"); } } content.initContent(context, parser); }

final boolean msxml'ed'checkContent(Context context, Element e, Parser parser) throws ParseException { return content.checkContent(context, e, parser); }

final boolean msxml'ed'acceptEmpty() { return content.acceptEmpty(); }

final Vector msxml'ed'expectedElements(int state) { return content.expectedElements(state); }

final void msxml'ed'checkOwnAttributes(Element e, Parser parser) throws ParseException { if (attdefs == null) return;
for (Enumeration en = attdefs.elements(); en.hasMoreElements();) { AttDef ad = (AttDef)en.nextElement(); if (ad.getPresence() == AttDef.REQUIRED && e.getAttribute(ad.getName()) == null) parser.error("Attribute '" + ad.getName() + "' is required."); } }

final void msxml'ed'checkAttributes(Element e, Parser parser) throws ParseException { checkOwnAttributes(e, parser); if (base != null) { base.checkOwnAttributes(e, parser); } if (interfaces != null) { for (Enumeration en = interfaces.elements(); en.hasMoreElements(); ) { ((ElementDecl)en.nextElement()).checkOwnAttributes(e, parser); } } }

public final ContentModel msxml'ed'getContent() { return content; }

public final Name msxml'ed'getName()
// Retrieves the name of the element declaration.
{ return name; }

final void msxml'ed'parseAttribute(Element e, Name name, Parser parser) throws ParseException { AttDef attdef = findAttDef(name); if (attdef == null) { parser.error("Illegal attribute name " + name); } Object value = attdef.parseAttribute(e, parser); e.setAttribute(name, value); }

final void msxml'ed'addAttDef(AttDef attdef) { if (attdefs == null) { attdefs = new Vector(); } attdefs.addElement(attdef); }

public final AttDef msxml'ed'findAttDef(Name name) { if (attdefs != null) { for (Enumeration en = attdefs.elements(); en.hasMoreElements();) { AttDef attdef = (AttDef)en.nextElement(); if (attdef.name == name) return attdef; } } if (base != null) { AttDef attdef = base.findAttDef(name); if (attdef != null) return attdef; } if (interfaces != null) { for (Enumeration en = interfaces.elements(); en.hasMoreElements(); ) { AttDef attdef = ((ElementDecl)en.nextElement()).findAttDef(name); if (attdef != null) return attdef; } } return null; }

public Element msxml'ed'toSchema() { if( schema == null ) { Element elementType = new ElementImpl( nameELEMENTTYPE, Element.ELEMENT ); elementType.setAttribute( nameID, name );
Element elementContent = content.toSchema(); elementType.addChild( elementContent, null );
if (attdefs != null) { Enumeration e = attdefs.elements(); while (e.hasMoreElements()) { AttDef def = (AttDef)e.nextElement(); elementType.addChild( def.toSchema(), null ); } }
schema = elementType; } return schema; }

public void msxml'ed'save(XMLOutputStream o) throws IOException { o.writeIndent(); o.writeChars("<!ELEMENT "); o.writeQualifiedName(name, null); o.writeChars(" "); Atom ns = name.getNameSpace(); content.save(ns, o); o.write('>');
if (attdefs != null) { // have to turn on PRETTY output for this to work properly. int style = o.getOutputStyle(); o.setOutputStyle(XMLOutputStream.PRETTY); o.writeNewLine(); Enumeration e = attdefs.elements(); o.writeIndent(); o.writeChars("<!ATTLIST "); o.writeQualifiedName(name, null); o.writeChars(" "); while (e.hasMoreElements()) { o.writeNewLine(); AttDef def = (AttDef)e.nextElement(); o.addIndent(1); o.writeIndent(); o.addIndent(-1); def.save(ns, o); } o.write('>'); o.setOutputStyle(style); } o.writeNewLine(); }

final boolean msxml'ed'allowText() { return content.allowText(); }

msxml'Entity'EN

name::
* McsEngl.msxml'Entity'EN@cptItsoft,

_DEFINITION:
This class implements an Entity object representing an XML internal or external entity as defined in the XML Document Type Definition (DTD).

msxml'en'METHODS:
public Object getAttribute(Name attName);
public Enumeration getAttributes();
public Name getName();
public Name getTagName();
public void save(XMLOutputStream o) throws IOException;
public void setText(String text);

==============CODE=================================

public class Entity
extends ElementImpl
implements java.io.Serializable {

msxml'en'FIELDS:
static String nameENTITY = "ENTITY";
static Atom nameXML = Atom.create("XML");
static Atom nameSpaceID = Atom.create("//XML/NAMESPACE");

Name name;
String url;
String pubid;
String text;
char cdata;
Name ndata;
int line;
int column;
boolean par;
boolean sys;
boolean parsed;
static Name nameNAME = Name.create("NAME","XML");
static Name namePUBLICID = Name.create("PUBLICID","XML");
static Name nameSYSTEMID = Name.create("SYSTEMID","XML");
static Name nameINTENTITYDCL = Name.create("INTENTITYDCL","XML");
static Name nameEXTENTITYDCL = Name.create("EXTENTITYDCL","XML");
static Name nameNOTATION = Name.create("NOTATION","XML");
static Name namePAR = Name.create("PAR","XML");

msxml'en'Entity(Name name, boolean par) { super(Name.create(nameENTITY, nameXML), Element.ENTITY); this.name = name; this.par = par; this.parsed = false; }

msxml'en'Entity(Name name, boolean par, String text) { this(name, par); setText(text); setPosition(0, 0); }

msxml'en'Entity(Name name, boolean par, int c) { this(name, par); cdata = (char)c; super.setText(String.valueOf(cdata)); setPosition(0, 0); }

EntityReader msxml'en'getReader(EntityReader prev) { return new EntityReader( new StringInputStream(text), line, column, prev, this); }

void msxml'en'setURL(String url) { this.url = url; sys = true; }

String msxml'en'getURL() { return url; }

void msxml'en'setNDATA(Name name) { ndata = name; }

public void msxml'en'setText(String text) { this.text = text; sys = false; }

void msxml'en'setPosition(int line, int column) { this.line = line; this.column = column; }

int msxml'en'getLength() { if (cdata > 0) return -1; else if (text == null) return 0; else return text.length(); }

char msxml'en'getChar(int index) { if (text == null) return cdata; else return text.charAt(index); }

public Object msxml'en'getAttribute(Name attName) { // lazy construct the ElementImpl set of attributes. getAttributes(); return super.getAttribute(attName); }

public Enumeration msxml'en'getAttributes() { // lazy construct the ElementImpl set of attributes. if (super.getAttribute(nameNAME) == null) { setAttribute(nameNAME,name); if (pubid != null) setAttribute(namePUBLICID, pubid); if (url != null) setAttribute(nameSYSTEMID, url); if (ndata != null) setAttribute(nameNOTATION, ndata); // setAttribute(namePAR, (par == true) ? "TRUE" : "FALSE"); } return super.getAttributes(); }

public void msxml'en'save(XMLOutputStream o) throws IOException { if (o.savingDTD) { o.writeIndent(); saveEntity(o); o.writeNewLine(); } else { super.save(o); } }

public void msxml'en'saveEntity(XMLOutputStream o) throws IOException { o.writeChars("<!ENTITY "); if (par) o.writeChars("% "); o.writeQualifiedName(name, null); o.writeChars(" ");
if (url != null) { if (pubid == null) o.writeChars("SYSTEM "); else { o.writeChars("PUBLIC "); o.writeQuotedString(pubid); o.write(' '); } o.writeQuotedString(url.toString()); if (ndata != null) { o.writeChars(" NDATA "); o.writeQualifiedName(ndata, name.getNameSpace()); } } else if (text != null) o.writeQuotedString(text);
o.write('>'); }

public Name msxml'en'getName() { return name; }

public Name msxml'en'getTagName() { if( sys ) return nameEXTENTITYDCL; else return nameINTENTITYDCL; }

msxml'Notation'N

name::
* McsEngl.msxml'Notation'N@cptItsoft,

_DEFINITION:
This class implements an entity object representing an XML notation.

msxml'n'METHODS:
public void save(XMLOutputStream o) throws IOException;
public Element toSchema();

=================================================================

package com.ms.xml.parser;

import com.ms.xml.om.ElementImpl; import com.ms.xml.om.Element;
import com.ms.xml.util.Name; import com.ms.xml.util.XMLOutputStream; import java.io.*;

public class Notation
extends ElementImpl
implements java.io.Serializable {

msxml'n'FIELDS:
/** * Name of Notation */
Name name;
/** * Url */
String url;
/** * pubid */
String pubid;
/** * Type of notation (Parser.SYSTEM or Parser.PUBLIC) */
int type;
/** * Schema representation */
Element schema = null;
static Name nameNAME = Name.create("NAME");
static Name nameSYSTEMID = Name.create("SYSTEMID");
static Name namePUBLICID = Name.create("PUBLICID");
static Name nameNOTATION = Name.create("NOTATION");

msxml'n'Notation(Name name)
{ super(name,Element.NOTATION); this.name = name; }
void setURL(String url) { this.url = url; }

public Element msxml'n'toSchema()
{ if( schema == null ) { Element notationElement = new ElementImpl( nameNOTATION, Element.ELEMENT ); notationElement.setAttribute( nameNAME, name.toString() ); if( url != null ) { notationElement.setAttribute( nameSYSTEMID, url ); } if( pubid != null ) { notationElement.setAttribute( namePUBLICID, pubid ); } schema = notationElement; }
return schema; }

/** * Saves the notation to the given output stream with indenting and new lines. * @param o The output stream. * @exception IOException if there is a problem writing to the output stream. */

public void msxml'n'save(XMLOutputStream o) throws IOException { o.writeIndent(); o.writeChars("<!NOTATION "); o.writeQualifiedName(name, null); o.writeChars(" ");
if (type == Parser.PUBLIC) { o.writeChars("PUBLIC "); o.writeQuotedString(pubid); o.write(' '); o.writeQuotedString(url); } else { o.writeChars("SYSTEM "); o.writeQuotedString(url); } o.write('>'); o.writeNewLine(); }

}

msxml'ParseException'PE

name::
* McsEngl.msxml'ParseException'PE@cptItsoft,

_DEFINITION:
This class signals that a parsing exception of some sort has occurred.

msxml'pe'METHODS:
public ParseException();
public ParseException(String s);
public ParseException(String s, int line, int column, Object owner);

==================================================================

package com.ms.xml.parser;

import java.lang.Exception;

public class ParseException
extends Exception {

msxml'pe'FIELDS:
public int column; //The position on the line where the error was found.
public int line; //The line where the error was found.
public Object owner; The parser context in which the error occurred.

/** * Constructs a <code>ParseException</code> exception with no detail message. */

public msxml'pe'ParseException()
{ super(); }

/** * Constructs a <code>ParseException</code> exception with a specified * message. * @param s The detail message. * */

public msxml'pe'ParseException(String s) { super(s); line = column = 0; owner = null; }

/** * Constructs a <code>ParseException</code> exception with detail about * what occurred. * * @param s The detail message. * @param line The line number of the input where the error was found. * @param column The position on the line. * @param owner The context in which the error was encountered. * This is either an <code>Entity</code> object or a <code>Parser</code> * object. */

public msxml'pe'ParseException(String s, int line, int column, Object owner) { super(s); this.line = line; this.column = column; this.owner = owner; }

}

msxml'Parser'P

name::
* McsEngl.msxml'Parser'P@cptItsoft,

_DEFINITION:
This class implements an eXtensible Markup Language (XML) parser according to the latest World Wide Web Consortium (W3C) working draft of the XML specification. This parser class is used internally by the XML document load method, so you shouldn't need to use it directly.

msxml'p'METHODS:
public Parser();
public final XMLOutputStream createOutputStream(OutputStream out);
public final void loadDTD(String urlStr, Atom nameSpace) throws ParseException;
public final void parse(URL url, ElementFactory factory, DTD dtd, Element root, boolean caseInsensitive) throws ParseException;
final public void parse(InputStream in, ElementFactory factory, DTD dtd, Element root, boolean caseInsensitive) throws ParseException;
final public void report(ParseException e, OutputStream out);

==================================================================

public class Parser {

msxml'p'FIELDS:
static final int TAGSTART = '<';
static final int TAGEND = '>';
static final int SLASH = '/';
static final int EQ = '=';
static final int LPAREN = '(';
static final int RPAREN = ')';
static final int BANG = '!';
static final int QMARK = '?';
static final int DASH = '-';
static final int PERCENT = '%';
static final int AMP = '&';
static final int LEFTSQB = '[';
static final int RIGHTSQB = ']';
static final int QUOTE = '\'';
static final int OR = '|';
static final int ASTERISK = '*';
static final int PLUS = '+';
static final int HASH = '#';
static final int COMMA = ',';
static final int INVALIDTOKEN = 0;
static final int EOF = -1;
static final int WHITESPACE = -2;
static final int WORDCHAR = -3;
static final int NAME = -4;
static final int TEXT = -5;
static final int PITAGSTART = -6;
static final int PITAGEND = -7;
static final int DECLTAGSTART = -8;
static final int CLOSETAGSTART = -9;
static final int EMPTYTAGEND = -10;
static final int COMMENT = -11;
static final int DOCTYPE = -12;
static final int SYSTEM = -13;
static final int CDATATAGSTART = -14;
static final int ELEMENT = -15;
static final int EMPTY = -16;
static final int ANY = -17;
static final int PCDATA = -18;
static final int ATTLIST = -19;
static final int CDATA = -20;
static final int ID = -21;
static final int IDREF = -22;
static final int IDREFS = -23;
static final int ENTITY = -24;
static final int ENTITIES = -25;
static final int NMTOKEN = -26;
static final int NMTOKENS = -27;
static final int NOTATION = -28;
static final int ENUMERATION = -29;
static final int FIXED = -30;
static final int REQUIRED = -31;
static final int IMPLIED = -32;
static final int NDATA = -33;
static final int INCLUDETAGSTART= -34;
static final int IGNORETAGSTART = -35;
static final int NAMESPACE = -36;
static final int EXTENDS = -37;
static final int IMPLEMENTS = -38;
static final int XML = -39;
static final int VERSION = -40;
static final int ENCODING = -41;
static final int RMD = -42;
static final int CDEND = -43;
static final int PUBLIC = -100;

ElementFactory factory;
DTD dtd;
Element root;
Vector contexts = new Vector(16);
int contextAt = 0;
Context current;
EntityReader reader;
XMLInputStream xmlIn;
boolean inTag;
boolean seenWS;
int lookahead;
char quote;
char chars[] = new char[8192];
int charAt;
char buf[] = new char[8192];
int bufAt;
int nameappend;
static Hashtable tokens;
int token;
int keyword;
int nouppercase;
int substitution;
int breakText;
int nametoken;
int simplename;
int inEntityRef;
boolean expandNamedEntities;
static boolean jdk11; //
Name name;
String text;
URL url;
Name docType;
boolean internalSubset;
boolean caseInsensitive;
boolean firstLine = true;
static ElementDecl XMLDecl;
Name conditionRef;
static int RMD_ALL = 0;
static int RMD_NONE = 1;
static int RMD_INTERNAL = 2;
int rmd;
static int chartype[] = new int[256];
static char charupper[] = new char[256];
static final int FWHITESPACE = 1;
static final int FDIGIT = 2;
static final int FLETTER = 4;
static final int FMISCNAME = 8;
static final int FSTARTNAME = 16;
static final char nameSpaceSeparator = ':';
static boolean strict = false;
static Name nameComment;
static Name nameCDATA;
static Name namePCDATA;
static Name nameVERSION;
static Name nameENCODING;
static Name nameDOCTYPE;
static Name nameXML;
static Name nameRMD;
static Name nameNONE;
static Name nameINTERNAL;
static Name nameALL;
static Name nameURL;
static Name namePUBLICID;
static Name nameNAME;
static Name nameXMLSpace;
static Name nameXMLAS;
static Name nameXMLHREF;
static Name nameXMLNameSpace;
static Atom atomXML;

public msxml'p'Parser()
{String version = System.getProperty("java.version");
jdk11#ql:msxml'p'fields jdk11# = version.equals("1.1") ? true : false;
caseInsensitive = false; }

public final XMLOutputStream msxml'p'createOutputStream(OutputStream out)
{ if (xmlIn#ql:msxml'p'fields xmlIn# != null) return xmlIn.createOutputStream#ql:msxml'xmlis'createOutputStream#(out);
return null; }

public final void msxml'p'loadDTD(String urlStr, Atom nameSpace) throws ParseException;

public final void msxml'p'parse( URL url,
ElementFactory#ql:msxml'elementfactory# factory,
DTD#ql:msxml'dtd# dtd,
Element root,
boolean caseInsensitive) throws ParseException;
{ this.dtd = dtd; this.root = root; setURL#ql:msxml'p'setURL#(url); setFactory#ql:msxml'p'setfactory#(factory); this.caseInsensitive = caseInsensitive; safeParse#ql:msxml'p'safeparse#(); }

final public void msxml'p'parse( InputStream in,
ElementFactory factory,
DTD dtd,
Element root,
boolean caseInsensitive) throws ParseException;
{ this.dtd = dtd; url = null; this.root = root; setInputStream(in); setFactory(factory); this.caseInsensitive = caseInsensitive; safeParse(); }

final public void msxml'p'report(ParseException e, OutputStream out)
{ PrintStream o = new PrintStream(out); String s = null;
o.println(e.getMessage());
if (e.owner instanceof Parser) { URL u = ((Parser)e.owner).url; if (u != null) s = u.toString(); } else if (e.owner instanceof Entity) { s = "Parsing <" + ((Entity)e.owner).name + ">"; } else { s = "Parsing"; } o.println("Location: " + s + "(" + e.line + "," + e.column + ")"); o.print("Context: "); for (int i = 0; i < contextAt; i++) { Name name = ((Context)contexts.elementAt(i)).e.getTagName(); if (name != null) o.print("<" + name + ">"); } o.print("<"); if (current != null) o.print(current.e.getTagName()); o.println(">"); }

final void msxml'p'safeParse() throws ParseException
{try { parseDocument#ql:msxml'p'parsedocument#(); }
catch (ParseException e)
{ if (xmlIn != null) { try { xmlIn.close(); } catch (Exception f) { } } throw e; } try { xmlIn.close(); } catch (Exception f) { } }

public final msxml'p'XMLOutputStream createOutputStream(OutputStream out)
{ if (xmlIn != null) return xmlIn.createOutputStream(out); return null; }

final void msxml'p'error(String s) throws ParseException { int i = 1; // BUGBUG: the position may still be incorrect if (token == NAME) i = name.toString().length(); throw new ParseException(s, reader.line, reader.column - 1 - i, reader.owner); }

final void msxml'p'advance() throws ParseException
{ lookahead = reader.read(); // if EOF and reading 'included' entity pop it... while (lookahead == -1 && reader.owner != this) { // For external text entities there may be some PCDATA // left over that needs to be added also. if (charAt != 0) { addPCDATA(); } reader = reader.prev; pop(); // pop the entity element if (! inTag) charAt = 0; lookahead = reader.read(); } }

final int msxml'p'nextToken() throws ParseException
{bufAt = 0; int bufStart = bufAt;

if (inTag || ! current.preserveWS)
{while (isWhiteSpaceChar((char)lookahead)) { if (! inTag) {buf[bufAt++] = (char)lookahead; seenWS = true; } advance();}
}

if (inTag)
{ switch (lookahead)
{case -1: token = EOF; break; case '>': token = TAGEND; inTag = false; advance(); break; case '/': advance(); if (lookahead == '>')
{token = EMPTYTAGEND; inTag = false; advance(); }
break; case '?': advance();
if (current.e.getType() == Element.ELEMENTDECL) {token = QMARK;}
else {if (lookahead == '>') { token = PITAGEND; inTag = false; advance(); } else { token = QMARK; } } break; case '=': case '(': case ')': case ',': case '|': case '[': case ']': case '*': case '+': case '#': token = lookahead; advance(); break; case '%': advance(); if (substitution > 0 && isNameChar((char)lookahead)) { scanEntityRef(true); return nextToken(); } token = PERCENT; break; case '\"': case '\'': quote = (char)lookahead; token = QUOTE; advance(); break; default: if (isNameChar((char)lookahead) || nameSpaceSeparator == (char)lookahead) { scanName("name");
if (keyword > 0) { token = lookup(name.getName()); } } else { error("Unexpected token '" + (char)lookahead + "' inside tag <" + current.e.getTagName() + ">"); } } } else { if (seenWS && ! current.lastWasWS && (lookahead == -1 || lookahead == '<') ) { Element e = addNewElement(Element.WHITESPACE, null, false); String ws = new String(buf, bufStart, bufAt - bufStart); e.setText(ws); } switch (lookahead) { case -1: token = EOF; break; case '<': inTag = true; seenWS = false; // reset advance(); switch (lookahead) { case '?': token = PITAGSTART; advance(); break; case '!': token = DECLTAGSTART; advance(); if (lookahead == '-') { advance(); if (lookahead == '-') { token = COMMENT; advance(); } else { error("Bad comment start syntax. Expected '<!--'"); } } else if (lookahead == '[') { advance(); boolean ref = false; // whether the keyword is a parameter entity reference if (lookahead == '%') { advance(); Entity n = scanEntityRef(true); conditionRef = n.getName(); ref = true; // entity reference encountered } else { conditionRef = null; }
parseKeyword(0, "CDATA or Conditional section start tag");
if (token == INCLUDETAGSTART || token == IGNORETAGSTART || token == CDATA && !ref) { // scanned <![CDATA if (token == CDATA) token = CDATATAGSTART; else inTag = false;
if (lookahead == '[') { advance(); } else { if (token == CDATATAGSTART) error("Bad CDATA start syntax. Expected '['"); else error("Bad conditional section start syntax. Expected '['"); } } else { error("Bad start tag: '<!['" + tokenString(token) + token); } } break; case '/': token = CLOSETAGSTART; advance(); break; default: token = TAGSTART; } break; case ']': // check CDEND "]]>' first advance(); if (lookahead == ']') { advance(); if (lookahead == TAGEND) { advance(); token = CDEND; break; } else { reader.push((char)lookahead); reader.push(']'); lookahead = ']'; } } else { reader.push((char)lookahead); lookahead = ']'; }
// check end of internal set of DTD ']' if (breakText == lookahead) { advance(); token = RIGHTSQB; break; }
// fall thru to text otherwise default: token = TEXT; break; } } return token; }

final String msxml'p'tokenString(int token) { return tokenString(token,null); }

final String msxml'p'tokenString(int token, String s) { switch (token) { case TAGSTART : return "start tag(<)"; case TAGEND : return "tag end(>)"; case SLASH : return "/"; case EQ : return "="; case LPAREN : return "("; case RPAREN : return ")"; case BANG : return "!"; case QMARK : return "question mark(?)"; case DASH : return "-"; case PERCENT : return "percent(%)"; case AMP : return "&"; case LEFTSQB : return "["; case RIGHTSQB : return "]"; case QUOTE : return "quote(' or \")"; case OR : return "|"; case ASTERISK : return "*"; case PLUS : return "+"; case HASH : return "#"; case COMMA : return ","; case INVALIDTOKEN : return "invalidtoken"; case EOF : return "EOF"; case WHITESPACE : return "whitespace"; case WORDCHAR : return "word character"; case NAME : if (s != null) return s; else return "NAME '" + name + "'"; case TEXT : return "TEXT '" + text + "'"; case PITAGSTART : return "<?"; case PITAGEND : return "?>"; case CDEND : return "]]>"; case DECLTAGSTART : return "<!"; case CLOSETAGSTART : return "</"; case EMPTYTAGEND : return "/>"; case COMMENT : return "<!--"; case DOCTYPE : return "DOCTYPE"; case SYSTEM : return "SYSTEM"; case CDATATAGSTART : return "<![CDATA"; case ELEMENT : return "ELEMENT"; case EMPTY : return "EMPTY"; case ANY : return "ANY"; case PCDATA : return "PCDATA"; case ATTLIST : return "ATTLIST"; case CDATA : return "CDATA"; case ID : return "ID"; case IDREF : return "IDREF"; case IDREFS : return "IDREFS"; case ENTITY : return "ENTITY"; case ENTITIES : return "ENTITIES"; case NMTOKEN : return "NMTOKEN"; case NMTOKENS : return "NMTOKENS"; case NOTATION : return "NOTATION"; case ENUMERATION : return "ENUMERATION"; case FIXED : return "FIXED"; case REQUIRED : return "REQUIRED"; case IMPLIED : return "IMPLIED"; case NDATA : return "NDATA"; case INCLUDETAGSTART: return "INCLUDETAGSTART"; case IGNORETAGSTART : return "IGNORETAGSTART"; case NAMESPACE : return "NAMESPACE"; case PUBLIC : return "PUBLIC"; default: return s; } }

final int msxml'p'lookup(String n) { Object o = tokens.get(n); if (o != null) { token = ((Integer)o).intValue(); } else { token = NAME; }
return token; }

static final msxml'p'boolean isWhiteSpaceChar(char c) { if (c < 256) { return (chartype[c] & FWHITESPACE) != 0; } else { if (jdk11) return Character.isWhitespace(c);
return Character.isSpace(c); } }

static final msxml'p'boolean isNameChar(char c) { if (c < 256) { return (chartype[c] & (FLETTER | FDIGIT | FMISCNAME)) != 0; } else { return Character.isLetter(c) || Character.isDigit(c) || c == '-' || c == '_' || c == '.'; } // BUGBUG:: according to spec, should allow combiningChar, Ignorable, and Extender chars as well }

final void msxml'p'scanName(String s) throws ParseException
{String n = null; Atom ns = null; boolean scanned = false;
if (nameappend == 0) { bufAt = 0; } int bufStart = bufAt;
if (nameSpaceSeparator != (char)lookahead) { bufAt = scanSimpleName(bufAt, s); scanned = true; }
if (nametoken == 0 && simplename == 0 && nameSpaceSeparator == (char)lookahead)
{int nsgap = 1; bufAt++; advance#ql:msxml'p'advance#(); // Make second colon optional.
if (nameSpaceSeparator == (char)lookahead) { nsgap++; bufAt++; advance(); }
if (scanned) // name space found { if (caseInsensitive) n = new String(buf, bufStart, bufAt - bufStart - nsgap).toUpperCase(); else n = new String(buf, bufStart, bufAt - bufStart - nsgap); Atom atom = Atom.create(n);
if (DTD.isReservedNameSpace(atom)) { ns = atom; }
else { // check the current context first ns = current.findNameSpace(atom);
if (ns == null) { // check the global name space when the name space is not defined in current context ns = dtd.findLongNameSpace(atom); if (ns == null) error("Name space not defined '" + n + "'"); }
}
} bufStart = bufAt; bufAt = scanSimpleName(bufAt, s); //
else {// report error and throw // error("Expecting namespace separator ':' instead of '" + (char)lookahead + "'"); // } }
else { if ((nametoken == 0 && simplename == 0) || inEntityRef > 0) ns = current.defaultNameSpace; }
if ((nametoken == 0 && simplename == 0) || inEntityRef > 0) current.nameSpace = ns;
if ((keyword > 0 && inEntityRef == 0) || ns == null) name = Name.create(buf, bufStart, bufAt - bufStart);
else name = Name.create(new String(buf, bufStart, bufAt - bufStart), ns); token = NAME; }

final char msxml'p'toUpperCase(char c) { if (nouppercase != 0) return c; else { if (c < 256) { return charupper[c]; } else { return Character.toUpperCase(c); } } }

final int msxml'p'scanSimpleName(int bufAt, String s) throws ParseException { boolean startname;
if (lookahead < 256) { startname = (chartype[lookahead] & (FLETTER | FSTARTNAME)) != 0; } else { startname = Character.isLetter((char)lookahead) || lookahead == '_'; } if (!startname) { if (!(nametoken > 0 && Character.isDigit((char)lookahead))) { // report error and throw error("Expecting " + s + " instead of '" + (char)lookahead + "'"); } } if (caseInsensitive) { buf[bufAt++]=toUpperCase((char)lookahead); advance(); while (isNameChar((char)lookahead)) { buf[bufAt++] = toUpperCase((char)lookahead); advance(); } } else { buf[bufAt++]=(char)lookahead; advance(); while (isNameChar((char)lookahead)) { buf[bufAt++] = (char)lookahead; advance(); } } return bufAt; }

final void msxml'p'scanText(int eref, int cref, boolean stripws) throws ParseException { charAt = 0;
while (lookahead != -1 && lookahead != '<' && lookahead != breakText && (charAt + 1) < chars.length) { if (lookahead == cref) { if (seenWS) { chars[charAt++] = ' '; seenWS = false; } advance(); if (lookahead == '#') { scanCharRef(); } else if (isNameChar((char)lookahead)) { scanEntityRef(false); } else { chars[charAt++] = (char)cref; } } else if (lookahead == eref) { if (seenWS) { chars[charAt++] = ' '; seenWS = false; } advance(); if (isNameChar((char)lookahead)) { scanEntityRef(eref == '%'); } else { chars[charAt++] = (char)cref; } } else { if (stripws && isWhiteSpaceChar((char)lookahead)) { seenWS = true; } else { if (seenWS) { chars[charAt++] = ' '; seenWS = false; } chars[charAt++] = (char)lookahead; } advance(); } } token = TEXT; }

final Entity msxml'p'scanEntityRef(boolean par) throws ParseException { nouppercase++; inEntityRef++; scanName("entity ref"); inEntityRef--; nouppercase--; if (lookahead != ';') { error("Entity reference syntax error " + name); } Entity en = dtd.findEntity(name); if (en == null) { String msg = "Missing entity '" + name + "'."; if (rmd != RMD_ALL) { msg += "\nPerhaps you need to change the RMD attribute to 'ALL'."; } error(msg); }
if (par != en.par) { if (par) error("Entity '" + name + "' is not a parameter entity."); else error("Entity '" + name + "' is a parameter entity."); }
if (par) // in DTD { // BUG: We still haven't finished this yet. // In the case where a parameter entity is used // inside an element declaration, for example, // we will forget this fact in the saved document.
if (! inTag) // add an entity reference node { addNewElement(Element.ENTITYREF, name, false); } if (en.getURL() == null) // parse entity text { push(en); reader = en.getReader(reader); } else // get external DTD { if (en.ndata != null) error("Binary parameter entity " + name.toString() + "cannot be used in DTD");
if (rmd == RMD_ALL) loadDTD(en.getURL(), current.defaultNameSpace); } } else // in document { if (! inTag) { // Put current substring in new PCDATA node. addPCDATA(); charAt = 0; // Now we need to store a special ENTITYREF // node in the tree to remember where the entities // are so we can save them back out. addNewElement(Element.ENTITYREF, name,true); } if (en.getLength() == -1) // special characters { // skip it since the special built in entities // do not require parsing. } else { if (! en.parsed) { if (en.getURL() == null) // parse entity text { en.parsed = true; push(en); reader = en.getReader(reader); } else if (en.ndata == null && rmd == RMD_ALL) { en.parsed = true; push(en); try { URL u = new URL(url,en.getURL()); reader = new EntityReader( u.openStream(), reader.line, reader.column, reader, en); } catch (Exception e) { error("Cannot load external text entity: " + name.toString()); } } } } } advance(); return en; }

final void msxml'p'scanCharRef() throws ParseException { int n = 0;
if (lookahead == '#') { advance(); if (lookahead == 'x' || lookahead == 'X') { advance(); for (int i = 0; i < 4; i++) { if (lookahead >= '0' && lookahead <= '9') { n = n * 16 + lookahead - '0'; } else if (lookahead >= 'a' && lookahead <= 'f') { n = n * 16 + lookahead - 'a' + 10; } else if (lookahead >= 'A' && lookahead <= 'F') { n = n * 16 + lookahead - 'A' + 10; } else { error("Bad character reference syntax. Expecting &#xx;"); } advance(); } } else while (lookahead >= '0' && lookahead <= '9') { n = n * 10 + lookahead - '0'; advance(); } }
if (lookahead != ';') { error("Bad character reference syntax. Expecting &#xx;"); } else { chars[charAt++] = (char)n; } advance(); }

final void msxml'p'scanString(int endChar, int eref, int cref, int breakChar) throws ParseException { charAt = 0; while (lookahead != -1 && lookahead != endChar) { if (lookahead == breakChar) { error("Illegal character in string " + (char)lookahead); } else if (lookahead == cref) { advance(); if (lookahead == '#') { scanCharRef(); } else if (isNameChar((char)lookahead)) { if (expandNamedEntities) { scanEntityRef(false); } else { chars[charAt++] = (char)cref; } } else { chars[charAt++] = (char)lookahead; } } else if (lookahead == eref) { advance(); if (isNameChar((char)lookahead)) { if (expandNamedEntities) { scanEntityRef(eref == '%'); } else { chars[charAt++] = (char)eref; } } else { chars[charAt++] = (char)lookahead; } } else { chars[charAt++] = (char)lookahead; advance(); } } if (lookahead == endChar) { advance(); } else { error("Unterminated string"); } text = new String(chars, 0, charAt); }

final String msxml'p'scanUrl() throws ParseException { parseToken(QUOTE, "Url"); scanString(quote, 0xFFFF, 0xFFFF, 0xFFFF); return text; }

final void msxml'p'parseToken(int t, String s) throws ParseException { if (nextToken() != t) { error("Expected " + tokenString(t,s) + " instead of " + tokenString(token)); } }

final void msxml'p'checkToken(int t, String s) throws ParseException { if (token != t) { error("Expected " + tokenString(t,s) + " instead of " + tokenString(token)); } }

final void msxml'p'parseKeyword(int k, String s) throws ParseException { keyword++; if (k == 0) { nextToken(); } else { parseToken(k, s); } keyword--; }

final int msxml'p'parseNames(Vector names, int separator, StringBuffer value) throws ParseException { int i = 0; bufAt = 0; if (value != null) nameappend++; while (nextToken() == NAME) { // Insert space to separate names for the returned // concatenated String value. if (i > 0) { buf[bufAt++] = ' '; } names.addElement(name); i++; if (separator != INVALIDTOKEN && nextToken() != OR) break; } if (value != null) { value.append(buf, 0, bufAt); nameappend--; } return i; }

final void msxml'p'parseDocument() throws ParseException
{expandNamedEntities#ql:msxml'p'fields expandNamedEntities# = true; rmd = RMD_ALL#ql:msxml'p'fields RMD ALL#; internalSubset = false; seenWS#ql:msxml'p'fields seenWS# = false; contextAt = 0;
// The default is to strip white space.
// This default is also assumed in Document.save#ql:msxml'd'save#(). // So changing the default would also require some changes // to the implementation of Document.save().
newContext#ql:msxml'p'newcontext#(root, false, null, null);
parseProlog#ql:msxml'p'parseProlog#(); parseRootElement#ql:msxml'p'parseRootElement#();
if (lookahead != -1)
{nextToken#ql:msxml'p'nextToken#(); tryMisc#ql:msxml'p'trymisc#();
if (lookahead != -1)error("Expected comments, PI, or EOF instead of " + tokenString(token)); } dtd.checkIDs(); }

void msxml'p'newContext(Element e, boolean preserveWS, Atom nameSpace, Hashtable spaceTable)
{if (contextAt == contexts.size()) { current = new Context(e, preserveWS, nameSpace, spaceTable); contexts.addElement(current); }
else { current = (Context)contexts.elementAt(contextAt); current.reset(e, preserveWS, nameSpace, spaceTable); } }

final void msxml'p'push(Element e) { contextAt++; // White space handling is inherited. newContext(e, current.preserveWS, current.nameSpace, current.spaceTable); return; }

final void msxml'p'pop() { current = (Context)contexts.elementAt(--contextAt); }

final void msxml'p'parseProlog() throws ParseException
{if (lookahead != -1)
{nextToken(); if (token == PITAGSTART) { parseToken(NAME, "PI tag"); if (name == nameXML) { // 10/21/97 CJL - Disabled this check for CDF compatibility.// if (current.lastWasWS) // error("An XML declaration can only appear in the very beginning of the document."); parseXMLDecl(); } else
{if (name == nameXMLNameSpace) parseNameSpaceDecl(true, true);
else finishPI(); } nextToken(); firstLine = false; } } tryMisc(); tryDocTypeDecl(); tryMisc(); }

final void msxml'p'parseXMLDecl() throws ParseException { Element xml = addNewElement(Element.PI, name,false); push(xml); // so that error reporting is correct. ElementDecl ed = current.ed; current.ed = XMLDecl;
// check version information parseKeyword(VERSION, nameVERSION.toString()); parseToken(EQ,"="); parseToken(QUOTE, "string"); scanString(quote, 0xFFFF, 0xFFFF, 0xFFFF); if (!text.equals("1.0")) error("Expected VERSION 1.0 instead of " + text); xml.setAttribute(nameVERSION, text);
// check encoding information parseKeyword(0, nameENCODING.toString()); String encoding = null; if (token == ENCODING) { parseToken(EQ,"="); parseToken(QUOTE, "string"); scanString(quote, 0xFFFF, 0xFFFF, 0xFFFF); xml.setAttribute(nameENCODING, text); encoding = text; parseKeyword(0, nameRMD.toString()); }
// check RMD if (token == RMD) { parseToken(EQ,"="); parseToken(QUOTE, "string"); scanString(quote, 0xFFFF, 0xFFFF, 0xFFFF); Name value = Name.create(text); if (value == nameNONE) { rmd = RMD_NONE; } else if (value == nameINTERNAL) { rmd = RMD_INTERNAL; } else if (value == nameALL) { rmd = RMD_ALL; } else { error("Expected NONE, INTERNAL, or ALL instead of " + value); } xml.setAttribute(nameRMD, value.toString()); nextToken(); } if (encoding != null) { try { xmlIn.setEncoding(encoding); } catch (IOException e) { error("Unsupported XML encoding: \"" + encoding + "\"" + "\nLow level error: " + e.getMessage()); } } if (token != PITAGEND) error("Expected " + tokenString(PITAGEND) + " instead of " + tokenString(token)); current.ed = ed; pop(); }

final void msxml'p'tryMisc() throws ParseException
{for (;;)
{ switch#ql:jv'statement.switch# (token)
{ case PITAGSTART: parsePI(true); break; case COMMENT: parseComment(); break; default: return; }
if (lookahead != -1) { nextToken(); }
else { token = EOF; break; }
firstLine = false; } }

final void msxml'p'tryDocTypeDecl() throws ParseException { if (token == DECLTAGSTART) { firstLine = false; parseKeyword(DOCTYPE, "Doctype"); Element dtdElement = addNewElement( Element.DTD, nameDOCTYPE, false); parseToken(NAME, "Doctype name"); docType = name; dtd.docType = name;
dtdElement.setAttribute(nameNAME,docType); parseKeyword(0, "ExternalID"); switch(token) { case SYSTEM: dtdElement.setAttribute(nameURL, scanUrl()); nextToken(); break; case PUBLIC: parseKeyword(0, "String"); if (token == QUOTE) { expandNamedEntities = false; scanString(quote, 0xFFFF, 0xFFFF, 0xFFFF); expandNamedEntities = true; dtdElement.setAttribute(namePUBLICID,text); } else error("Expected " + tokenString(QUOTE) + " instead of " + tokenString(token)); dtdElement.setAttribute(nameURL, scanUrl()); nextToken(); break; } if (token == LEFTSQB) { // set up context for [...] inTag = false; breakText = ']'; internalSubset = true; // Push the dtd element so we can add to it. push(dtdElement); parseInternalSubset(); if (token != RIGHTSQB) { error("Expected " + tokenString(RIGHTSQB)); } // restore context inTag = true; internalSubset = false; breakText = 0; pop(); nextToken(); } Object urlStr = dtdElement.getAttribute(nameURL); if (urlStr != null && rmd == RMD_ALL) { loadDTD(urlStr.toString(), null); } if (token != TAGEND) { error("Expected " + tokenString(TAGEND) + " instead of " + tokenString(token)); } if (lookahead != -1) { nextToken(); } } }

public final void msxml'p'loadDTD(String urlStr, Atom nameSpace) throws ParseException { try { URL u = new URL(url, urlStr); Parser parser = new Parser(); parser.dtd = this.dtd; parser.setURL(u); parser.setFactory(factory); parser.caseInsensitive = this.caseInsensitive; Element root = factory.createElement(Element.ELEMENT, nameDOCTYPE); parser.newContext(root, false, nameSpace, current.spaceTable); parser.parseInternalSubset(); } catch (IOException e) { error("Couldn't find external DTD '" + urlStr + "'"); } }

final Element msxml'p'addNewElement(int type, Name name, boolean validate) throws ParseException { // Make sure we don't add multiple whitespace nodes, // as would be the case while parsing ATTLISTS if (type == Element.WHITESPACE) { current.lastWasWS = true; } else { current.lastWasWS = false; } Element e = factory.createElement(type, name); current.e.addChild(e, null); if (validate && rmd != RMD_NONE && current.ed != null) { current.ed.checkContent(current, e, this); } return e; }

final void msxml'p'parseInternalSubset() throws ParseException { substitution++; for (;;) { switch(nextToken()) { case TEXT: if (lookahead == '%') { // entity reference advance(); scanEntityRef(true); } else { error("Unexpected text in DTD."); return; } break; case RIGHTSQB: if (!internalSubset) System.out.println("Illegal token in DTD: " + token); case EOF: substitution--; return; case PITAGSTART: parsePI(true); break; case COMMENT: parseComment(); break; case DECLTAGSTART: parseKeyword(0, "ENTITY|..."); switch (token) { case ENTITY: parseEntityDecl(); break; case ELEMENT: parseElementDecl(); break; case ATTLIST: parseAttListDecl(); break; case NOTATION: parseNotation(); break; default: error("Unknown DTD keyword " + name); } break; case INCLUDETAGSTART: parseIncludeSection(); break; case IGNORETAGSTART: parseIgnoreSection(); break; default: return; } } }

final void msxml'p'parseIncludeSection() throws ParseException { Element e = addNewElement(Element.INCLUDESECTION, conditionRef, false); push(e); parseInternalSubset(); pop(); }

final void msxml'p'parseIgnoreSection() throws ParseException { Element e = addNewElement(Element.IGNORESECTION, conditionRef, false); charAt = 0; push(e); parseIgnoreSectContent();
// add contents as PCDATA, which includes the conditional section closing tag ']]>' if (charAt > 0) { Element t = addNewElement(Element.PCDATA, null, true); t.setText(new String(chars, 0, charAt)); charAt = 0; } pop(); }

final void msxml'p'addChar() throws ParseException { if (lookahead == -1) error("Unexpected EOF.");
chars[charAt++] = (char)lookahead; if (charAt == chars.length) { Element t = addNewElement(Element.PCDATA, null, true); t.setText(new String(chars, 0, charAt)); charAt = 0; } advance(); }

final void msxml'p'checkCDEND(boolean expected) throws ParseException { boolean yes = false;
if (lookahead == ']') { addChar(); if (lookahead == ']') { addChar(); if (lookahead == '>') { if (!expected) error("Bad Ignore conditional section syntex. ']]>' is not allowed here."); yes = true; addChar(); } } }
if (!yes && expected) error("Bad Ignore conditional section syntex. Expected ']]>'."); }

final void msxml'p'parseIgnoreSectContent() throws ParseException { boolean stop = false;
while (lookahead != ']') { switch (lookahead) { case '\'': case '\"': // SkipLit int quote = lookahead; addChar(); while (lookahead != quote) { checkCDEND(false); addChar(); } addChar(); break; case '<': addChar(); switch (lookahead) { case '!': addChar(); switch (lookahead) { case '-': // comment addChar(); if (lookahead != '-') error("Bad comment syntax. Expected '-'."); addChar(); while (!stop) { if (lookahead == '-') { addChar(); if (lookahead == '-') { addChar(); if (lookahead == '>') { addChar(); stop = true; } else { error("Bad comment syntax. Expected '>'."); } } } else { addChar(); } } stop = false; break; case '[': // IgnoreSectContents addChar(); parseIgnoreSectContent(); break; default: // Single character addChar(); break; } break; case '?': // PI addChar(); while (!stop) { if (lookahead == '?') { addChar(); if (lookahead == '>') { addChar(); stop = true; } } else { addChar(); } } stop = false; break; default: // Syntax error error("Bad character in IGNORE conditional section."); } break; default: addChar(); break; } }
// checking closing tag ']]>' checkCDEND(true); }

final void msxml'p'parseEntityDecl() throws ParseException { boolean par = false; nouppercase++; if (nextToken() == PERCENT) { par = true; parseToken(NAME, "Entity name"); } else { if (token != NAME) { error("Expected entity name instead of " + tokenString(token)); } } nouppercase--;
Entity en = dtd.findEntity(name); if (en != null) { System.err.println("Warning: Entity '" + name + "' already defined, using the first definition."); } else { en = new Entity(name, par); dtd.addEntity(en); if (internalSubset) { // Save this entity in the <!DOCTYPE> // Element tree so we can save it back out. current.e.addChild(en,null); current.lastWasWS = false; } }
// push so that we can give correct error message when an error is found in nextToken() // this is also necessary for NDATA to have name space push(en);
parseKeyword(0, "String or SYSTEM"); if (token == PUBLIC) // Is this SGML Compatibility ??? { parseKeyword(0, "String"); if (token == QUOTE) { expandNamedEntities = false; scanString(quote, 0xFFFF, 0xFFFF, 0xFFFF); expandNamedEntities = true; en.pubid = text; token = SYSTEM; // assure to get url } else error("Expected " + tokenString(QUOTE) + " instead of " + tokenString(token)); }
switch (token) { case QUOTE: { int line = reader.line; int column = reader.column; expandNamedEntities = false; scanString(quote, '%', '&', 0xFFFF); expandNamedEntities = true; en.setText(text); en.setPosition(line, column); } nextToken(); break; case SYSTEM: en.setURL(scanUrl()); parseKeyword(0, "ndata"); if (token == NDATA) { parseToken(NAME, "ndata name"); Notation notationName = dtd.findNotation(name); if (notationName == null) error("Notation: " + name + " has not been declared yet"); en.setNDATA(name); nextToken(); } break; default: error("Expected " + tokenString(QUOTE) + " or " + tokenString(SYSTEM) + " instead of " + tokenString(token)); }
checkToken(TAGEND, ">"); pop(); }

private void msxml'p'addNameSpace(Atom as, Atom href, boolean global) throws ParseException { if (as == null || href == null) { error("Name space syntax error."); } if (DTD.isReservedNameSpace(as)) error(as.toString() + " is a reserved name space."); if (global) { Atom aname = dtd.findShortNameSpace(href); if (aname != null) { if (aname != as) error("Cannot give two short references '" + aname.toString() + "' and '" + as.toString() + "' to the same name space: '" + href.toString() + "'"); } else { aname = dtd.findLongNameSpace(as); if (aname != null) error("Short reference '" + as.toString() + "' is used by name space '" + aname.toString() + "'"); dtd.addNameSpace(as, href); } } else current.addNameSpace(as, href); }

final void msxml'p'parseNotation() throws ParseException { parseToken(NAME, "Notation name"); Notation no = dtd.findNotation(name); if (no != null) { error("Notation already declared " + name); }
no = new Notation(name); dtd.addNotation(no); if (internalSubset) { // Save this notation in the <!DOCTYPE> // Element tree so we can save it back out. current.e.addChild(no,null); current.lastWasWS = false; }
// needed to write correct error message push(no);
parseKeyword(0, "SYSTEM or PUBLIC"); if (token != SYSTEM && token != PUBLIC) { error("Expected " + tokenString(SYSTEM) + " or " + tokenString(PUBLIC) + " instead of " + tokenString(token)); } no.type = token;
if (no.type == PUBLIC) { parseKeyword(0, "String"); if (token == QUOTE) { expandNamedEntities = false; scanString(quote, 0xFFFF, 0xFFFF, 0xFFFF); expandNamedEntities = true; no.pubid = text; } else error("Expected " + tokenString(QUOTE) + " instead of " + tokenString(token)); }
no.setURL(scanUrl()); parseToken(TAGEND, ">"); pop(); }

final ElementDecl msxml'p'createElementDecl(Vector v) throws ParseException {
if (token != NAME) { error("Expected " + tokenString(NAME) + " instead of " + tokenString(token)); } if (dtd.findElementDecl(name) != null) { error("Element '" + name + "' already declared."); } ElementDecl ed = new ElementDecl(name); current.lastWasWS = false; dtd.addElementDecl(ed); v.addElement(ed); return ed; }

final void msxml'p'parseElementDecl() throws ParseException { Vector v = new Vector(); ElementDecl ed;
nextToken(); ed = createElementDecl(v); if (internalSubset) { // Save this element in the <!DOCTYPE> // Element tree so we can save it back out. current.e.addChild(ed,null); } // push to handle name space push(ed); ed.parseModel(this); checkToken(TAGEND, ">"); pop(); }

final ElementDecl msxml'p'findElementDecl(Vector v) throws ParseException { if (token != NAME) { error("Expected " + tokenString(NAME) + " instead of " + tokenString(token)); } ElementDecl ed = dtd.findElementDecl(name);
if (ed == null) { error("Missing Element declaration '" + name + "'"); } v.addElement(ed); return ed; }

final void msxml'p'parseAttListDecl() throws ParseException { Vector v = new Vector(); ElementDecl ed;
nextToken(); ed = findElementDecl(v); // push to handle name space push(ed); ed.parseAttList(this); checkToken(TAGEND, ">"); pop(); }

private void msxml'p'reportMismatch(int state, String msg) throws ParseException { if (current.ed == null) // this should never happen unless the parser is in incorrect state { error("Content mismatch. Stopped at state " + state); }
Vector els = current.ed.expectedElements(state); error(msg + " Expected elements " + els); }

final void msxml'p'parseElement() throws ParseException { boolean empty = false;
for (;;) { if (empty && token != CLOSETAGSTART) error("Expected " + tokenString(CLOSETAGSTART) + " instead of " + tokenString(token)); empty = false;
switch(token) { case TAGSTART: scanName("element tag");
if (lookup(name.getName()) == NAMESPACE && name.getNameSpace() == atomXML) { parseNameSpaceDecl(false, false); break; }
ElementDecl ed = dtd.findElementDecl(name);
Element e = addNewElement(Element.ELEMENT, name, true); push(e);
if (ed != null) { if (ed.getContent().type == ContentModel.EMPTY) { empty = true; } ed.initContent(current, this); } else { // set matched so parsecontent won't complain current.matched = true; }
parseAttributes(e); if (token == EMPTYTAGEND) { if (ed != null && !ed.acceptEmpty()) { reportMismatch(0, name.getName() + " cannot be empty."); } factory.parsed(current.e); pop(); empty = false; } else if (token != TAGEND ) { error("Expected " + tokenString(TAGEND) + " instead of " + tokenString(token)); } else if (lookahead != '<' && empty) { error("Expected " + tokenString(TAGEND) + " instead of '" + (char)lookahead + "'"); } break; case TEXT: parseText('&', '&'); break; case PITAGSTART: parsePI(false); break; case COMMENT: parseComment(); break; case CDATATAGSTART: parseCDATA(); break; case CLOSETAGSTART: if (!current.matched) // error { reportMismatch(current.state, current.e.getTagName().getName() + " is not complete."); } if (lookahead != '>') // allow </> { if (lookahead == '/') advance(); else { scanName("element close tag"); if (name != current.e.getTagName()) { error("Close tag " + name + " does not match start tag " + current.e.getTagName()); } } } parseToken(TAGEND, ">"); factory.parsed(current.e); pop(); break; case EOF: if (contextAt == 1) { error("Expected the end of root element instead of end of file."); break; } default: error("Bad token in element content: " + tokenString(token)); } if (contextAt == 0) break; nextToken(); } }

final void msxml'p'parseRootElement() throws ParseException
{if (token != TAGSTART)
error("Start of root element expected instead of " + tokenString(token)); scanName#ql:msxml'p'scanName#("element tag");
if (docType != null)
{if (name != docType) error("Root element name must match the DOCTYPE name"); }
if (name == nameXMLNameSpace)
{parseNameSpaceDecl(false, false); return; }
ElementDecl ed = dtd.findElementDecl(name);
Element e = addNewElement(Element.ELEMENT, name, false); push(e); boolean empty = false;
if (ed != null)
{if (ed.getContent().type == ContentModel.EMPTY) { empty = true; } ed.initContent(current, this);
} else { // set matched so parsecontent won't complain current.matched = true; }
parseAttributes#ql:msxml'p'parseAttributes#(e);
if (token == EMPTYTAGEND) { if (ed != null && !ed.acceptEmpty()) reportMismatch(0, "Root element " + e.getTagName().getName() + " cannot be empty."); empty = true; } else if (token != TAGEND) { if (e.getAttributes() == EnumWrapper.emptyEnumeration) error("No attribute is declared for element '" + e.getTagName() + "', expected " + tokenString(TAGEND)); error("Expected " + tokenString(TAGEND) + " instead of " + tokenString(token)); } if (empty) { pop(); nextToken(); } else { nextToken(); parseElement(); } return; }

final void msxml'p'parseAttributes(Element e) throws ParseException
{boolean ns = false;
while (nextToken() == NAME)
{Name currName = name; // Because parseAttributes may reset name, currName // is needed to hold name and check for nameXMLSpace // make sure XML-SPACE belongs to the XML namespace.
if (currName.getName().equals(nameXMLSpace.getName()))
{currName = nameXMLSpace; ns = true; }
if (e.getAttribute(currName) != null)
{error("An attribute cannot appear more than once in the same start tag"); } parseToken(EQ, "=");
if (current.ed != null) {current.ed.parseAttribute(e, currName, this); }
else { parseToken(QUOTE, "string"); scanString(quote, '&', '&', '<'); e.setAttribute(currName, text); } }
if (ns) { Object attr = e.getAttribute(nameXMLSpace); if (attr != null) { String s = null; if (attr instanceof String) { s = (String)attr; } else if (attr instanceof Atom) { s = attr.toString(); } else if (attr instanceof Name) { s = ((Name)attr).getName().toString(); }
if (s != null && s.equalsIgnoreCase("preserve")) { current.preserveWS = true; } else if (s != null && s.equalsIgnoreCase("default")) { current.preserveWS = false; } else { error("Invalid value '" + s + "' for XML-SPACE attribute."); } } }
if (current.ed != null) current.ed.checkAttributes(e, this); }

final void msxml'p'parseContent(Element e) throws ParseException { while (nextToken() != CLOSETAGSTART) { switch (token) { case TEXT: parseText('&', '&'); break; case TAGSTART: parseElement(); break; case PITAGSTART: parsePI(false); break; case DECLTAGSTART: parseElement(); break; case COMMENT: parseComment(); break; case CDATATAGSTART: parseCDATA(); break; default: error("Bad token in element content: " + tokenString(token)); } } if (!current.matched) { error("Content mismatch, stopped at state " + current.state); } if (lookahead != TAGEND) { scanName("element close tag"); if (name != current.e.getTagName()) { error("Close tag mismatch: " + name + " instead of " + current.e.getTagName()); } } parseToken(TAGEND, ">"); }

final Element msxml'p'parsePI(boolean global) throws ParseException { parseKeyword(0, "PI name"); if (token == XML) { if (!firstLine) error("An XML declaration can only appear in the very beginning of the document."); else { parseXMLDecl(); return null; } } else if (token == NAMESPACE) return parseNameSpaceDecl(global, true); else if (token != NAME) { error("Expecting PI name instead of " + tokenString(token)); }
return finishPI(); }

final Element msxml'p'parseNameSpaceDecl(boolean global, boolean PI) throws ParseException { Element e = addNewElement(Element.NAMESPACE, name, false); push(e); parseAttributes(e); pop();
if (PI && token != PITAGEND) { error("Expected PI tag end '?>' instead of " + tokenString(token)); } else if (!PI && token != EMPTYTAGEND) { error("Expected " + tokenString(EMPTYTAGEND) + " instead of " + tokenString(token)); }
Object asStr = e.getAttribute(nameXMLAS); Object hrefStr = e.getAttribute(nameXMLHREF);
if (asStr == null || hrefStr == null) { error("Missing attribute 'AS' or 'HREF'"); }
Atom as, href; if (caseInsensitive) { as = Atom.create(asStr.toString().toUpperCase()); href = Atom.create(hrefStr.toString().toUpperCase()); } else { as = Atom.create(asStr.toString()); href = Atom.create(hrefStr.toString()); } if (DTD.isReservedNameSpace(as)) { error(as.toString() + " is a reserved name space."); }
addNameSpace(as, href, global);
if (rmd == RMD_ALL) { // load name space // if the dtd has not been loaded, load it if (dtd.findLoadedNameSpace(href) == null) { dtd.addLoadedNameSpace(href); loadDTD(href.toString(), href); } } return e; }

final Element msxml'p'finishPI() throws ParseException { Element e = addNewElement(Element.PI, name, false);
charAt = 0; boolean stop = false; while (lookahead != -1) { chars[charAt++] = (char)lookahead; if (lookahead == '?') { advance(); if (lookahead == '>') { charAt--; stop = true; } } else { advance(); } if (charAt == chars.length || stop) { push(e); Element t = addNewElement(Element.CDATA, null, false); pop(); t.setText(new String(chars, 0, charAt)); charAt = 0; if (stop) break; } }
parseToken(TAGEND, "PI end"); return e; }

final Element msxml'p'parseText(int eref, int cref) throws ParseException { scanText(eref, cref, ! current.preserveWS); return addPCDATA(); }

final Element msxml'p'addPCDATA() throws ParseException { if (charAt > 0 || seenWS) { if (seenWS) { chars[charAt++] = ' '; seenWS = false; } text = new String(chars, 0, charAt); Element t = addNewElement(Element.PCDATA, null, true); t.setText(text); return t; } seenWS = false; return null; }

final Element msxml'p'parseComment() throws ParseException { Element e = addNewElement(Element.COMMENT, nameComment, false);
charAt = 0; boolean stop = false; while (lookahead != -1) { chars[charAt++] = (char)lookahead; if (lookahead == '-') { advance(); if (lookahead == '-') { advance(); if (lookahead == TAGEND) { charAt--; stop = true; } else if (strict) { error("Bad comment syntax. Expected '>'."); } else { reader.push((char)lookahead); lookahead = '-'; } } } else { advance(); } if (charAt == chars.length || stop) { push(e); Element t = addNewElement(Element.CDATA, null, false); pop(); t.setText(new String(chars, 0, charAt)); charAt = 0; if (stop) break; }
}
parseToken(TAGEND, "comment end"); return e; }

final void msxml'p'parseCDATA() throws ParseException { charAt = 0; boolean stop = false; while (lookahead != -1) { chars[charAt++] = (char)lookahead; if (lookahead == ']') { advance(); if (lookahead == ']') { advance(); if (lookahead == TAGEND) { charAt--; stop = true; } else { reader.push((char)lookahead); lookahead = ']'; } } } else { advance(); }
if (charAt == chars.length || stop) { Element t = addNewElement(Element.CDATA, nameCDATA, false); t.setText(new String(chars, 0, charAt)); charAt = 0; if (stop) break; } }
parseToken(TAGEND, "CDATA end"); }

final private void msxml'p'setURL(URL u) throws ParseException
{ url = u;
boolean opt = System.getProperty("os.name").substring(0, 7).equals("Windows");
String err; // // on windows system, try to use optimized inputstream //
if (opt) { try { xmlIn = new XMLInputStream(u); reader = new EntityReader(xmlIn, 1, 1, null, this); advance(); return; } catch (IOException e) { opt = false; err = e.toString(); } }
// If not on windows, or if on windows but failed to open the optimized // input stream, then use the I/O facilities provided by Java //

if (!opt) {
try { setInputStream#ql:msxml'p'setInputStream#( new BufferedInputStream#ql::JAPI101.NFO:BufferedInputStream rl5#(url.openStream())); }
catch (IOException e) { throw new ParseException("Error opening input stream for \"" + url.toString() + "\": " + e.toString()); } } }

final private void msxml'p'setInputStream(InputStream in) throws ParseException
{ xmlIn = new XMLInputStream(in); reader = new EntityReader(xmlIn, 1, 1, null, this); advance(); }

final private void msxml'p'setFactory(ElementFactory f)
{ factory = f; }

com.ms.xml.util.*

name::
* McsEngl.com.ms.xml.util.*@cptItsoft,

msxml'Atom'AT

name::
* McsEngl.msxml'Atom'AT@cptItsoft,

PACKAGE: com.ms.xml.util

_DEFINITION:
This is a general purpose object to allow efficient sharing of duplicate strings in the system.

msxml'at'METHODS:
public static Atom create(String s);
public boolean equals(Object that);
public int hashCode();
public String toString();

==================================================================

package com.ms.xml.util;

import java.lang.String; import java.util.Hashtable;

/** * This is a general purpose object to allow efficient * sharing of duplicate strings in the system. It does this by * creating a global HashTable of all Atoms that have been * constructed. * * @version 1.0, 6/3/97 */

public class Atom implements java.io.Serializable {

msxml'at'fields:
/** * The shared string */
String s;
/** * Cached hash value for improved compare speed. */
int hash;
/** * Hash table for shared atoms. */
static Hashtable atoms = new Hashtable(500);

/** * Creates Atom new object with the passed in collation key. * This is private because all Atoms should be constructed * via the static Atom.create() method. */ Atom(String s, int h) { this.s = s; this.hash = h; }

/** * private constructor */
Atom()
{ }

/** * Create a Atom object for this string. * Atoms are case sensitive - i.e. it assumes any case folding * has already been done. */

public static Atom create(String s)
{ if (s == null) return null;
Object o = atoms#ql:msxml'at'fields atoms#.get(s); if (o == null) { Atom n = new Atom(s, s.hashCode()); atoms.put(s, n); return n; } else { return (Atom)o; } } private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException { s = (String)stream.readObject(); hash = stream.readInt(); if (atoms.get(s) == null) { atoms.put(s, this); } }

private void writeObject(java.io.ObjectOutputStream stream) throws java.io.IOException { stream.writeObject(s); stream.writeInt(hash); } /** * Return the hash code for the name.

* @return returns the hash code for the name.

*/ public int hashCode() { return hash; } /** * Return the string represented by the Atom.

*/ public String toString() { return s; } /** * Return whether this Atom is equal to another given Atom.

*/ public boolean equals(Object that) { if (this == that) { return true; } if (that == null || getClass() != that.getClass()) { return false; } return s.equals(((Atom)that).s); } }

msxml'Attribute'ATT

name::
* McsEngl.msxml'Attribute'ATT@cptItsoft,

PACKAGE: com.ms.xml.util

_DEFINITION:
This class encapsulates an attribute name and value pair.
This class encapsulates a simple Name/Value pair which is used for XML Attributes. The Name is a true Name object and the Value can be a String, Name, or Vector of Names.

msxml'att'METHODS:
public Attribute();
public Attribute(Name n, Object v);
public Name getName();
public Object getValue();

=================================================================

package com.ms.xml.util;
/** * This class encapsulates an attribute name and value pair.

* * @version 1.0, 6/3/97 */ public class Attribute implements java.io.Serializable { Name name; Object value;
/** * Construct empty attribute.

*/ public Attribute() { }
/** * Construct attribute with given name and value.

*/ public Attribute(Name n, Object v) { name = n; value = v; }
/** * Return the name.

*/ public Name getName() { return name; }
/** * Return the value.

*/ public Object getValue() { return value; }
/** * Used by Attributes, private to this package */ void setValue(Object o) { value = o; } }

msxml'Attributes'ATTS

name::
* McsEngl.msxml'Attributes'ATTS@cptItsoft,

PACKAGE: com.ms.xml.util

_DEFINITION:
A class that encapsulates a list of attribute/value pairs.

msxml'atts'METHODS:
public Attributes();
public Attributes(int elems);
public Attributes(ReadOnlyAttributes attrs);
public Attributes(Vector v);
public Object put(Name name, Object value);
public Object put(Attribute v);
public void remove(Name name);
public void removeAll();

==============================================================

package com.ms.xml.util;

import java.util.Vector; import java.util.Enumeration;

/** * A class that encapsulates a list of attribute/value pairs. * * @version 1.0, 6/3/97 */

public class Attributes
extends ReadOnlyAttributes#ql:msxml'roa'methods#
implements java.io.Serializable {

/** * Construct empty attributes collection. */

public msxml'atts'Attributes() { }

/** * Construct attributes collection with given number of empty slots. * The collection will grow automatically * if you add more than this number. * @param elems the number of attributes to reserve initially. */

public msxml'atts'Attributes(int elems) { super(elems); }

/** * Construct attributes collection by copying the passed attributes. * * @param attrs attributes to clone */

public msxml'atts'Attributes(ReadOnlyAttributes attrs) { Vector v = attrs.attributes; if (v != null) { int l = v.size(); attributes = new Vector(l); attributes.setSize(l); for (int i = 0; i < l; i++) { Attribute a = (Attribute)v.elementAt(i); attributes.setElementAt(new Attribute(a.name, a.getValue()), i); } } }

/** * Construct attributes collection using the vector of attributes. * * @param v Attribute vector */

public msxml'atts'Attributes(Vector v) { super(v); }

/** * Removed the named attribute from the collection. */

public void msxml'atts'remove(Name name) { Attribute a = lookup(name); if (a != null) { attributes.removeElement(a); } }

/** * Add a new attribute/value pair, or replace the value for * attribute if it already exists. * @return the previous value for the name attribute or null. */

public Object msxml'atts'put(Name name, Object value) { Attribute a = lookup(name); Object o = null; if (a != null) { o = a.getValue(); a.setValue(value); } else { attributes.addElement(new Attribute(name, value)); } return o; }

/** * Add a new attribute or replace the attribute * if it already exists. * @return the previous value for the name attribute or null. */

public Object msxml'atts'put(Attribute v) { Object o = null; Attribute a = lookup(v.getName()); if (a != null) { o = a.getValue(); attributes.removeElement(a); } attributes.addElement(v); return o; }

public void msxml'atts'removeAll() { attributes.removeAllElements(); }

}

msxml'EnumWrapper'EW

name::
* McsEngl.msxml'EnumWrapper'EW@cptItsoft,

PACKAGE: com.ms.xml.util

_DEFINITION:

public class EnumWrapper
implements Enumeration

msxml'ew'Fields:
public static EnumWrapper emptyEnumeration;

msxml'ew'METHODS:
public EnumWrapper(Object o);
public boolean hasMoreElements();
public Object nextElement();}

========================================================

package com.ms.xml.util;
import java.util.Enumeration;
public class EnumWrapper implements Enumeration { public static EnumWrapper emptyEnumeration = new EnumWrapper(null);
public EnumWrapper(Object o) { object = o; done = false; }
public boolean hasMoreElements() { return (! done && object != null); }
public Object nextElement() { if (! done) { done = true; return object; } return null; }
boolean done; Object object; }

msxml'Name'NM

name::
* McsEngl.msxml'Name'NM@cptItsoft,

PACKAGE: com.ms.xml.util

FUNCTION:
This is a general purpose name object to allow efficient sharing of duplicate names in the system. It does this by creating a global HashTable of all names that have been constructed. Names are different from Atoms#ql:msxml'atom# in that they can be qualified by a separate namespace string - so in effect that are compound atoms.

msxml'nm'METHODS:
public String getName();
public static Name create(String name);
public static Name create(char val[], int offset, int len);
public static Name create(String name, String ns);
public static Name create(String name, Atom nameSpace);
public boolean equals(Object that);
public Atom getNameSpace();
public int hashCode();
public static Name parse(String s);
public void save(XMLOutputStream o);
public String toString()

====================== CODE ===========================

package com.ms.xml.util;

import java.io.*; import java.util.Hashtable;
import com.ms.xml.parser.DTD;

public class Name
implements java.io.Serializable {

msxml'nm'FIELDS:
static final String separator = "::";
static Hashtable names = new Hashtable(500); // Hash table for shared qualified names.
static StringHashtable snames = new StringHashtable(500); //Hash table for shared simple names.
Atom nameSpace; //A name is a compound object containing two atoms.
String name;
int hash;
static public long created = 0;
static public long reused = 0;

msxml'nm'Name(String name, Atom nameSpace, int hash)
// The constructor is private because all names should be constructed using the static Name.create() methods
{ this.name = name; this.nameSpace = nameSpace; this.hash = hash; }

public String msxml'nm'getName()
{ return name#ql:msxml'nm'fields name#; }

public Atom msxml'nm'getNameSpace()
{ return nameSpace#ql:msxml'nm'fields nameSpace#; }

public boolean msxml'nm'equals(Object that)
{ if (this == that) { return true; } if (that == null || getClass() != that.getClass()) { return false; }
Name t = (Name)that; if (nameSpace != null) { if (!nameSpace.equals(t.nameSpace)) return false; } else if (t.nameSpace != null) return false; return this.name.equals(t.name); }

public static Name msxml'nm'create(String name)
// Create an unqualified Name.
{ if (name == null) return null; Object o = snames.get(name); if (o == null) { // add new name to simple names hash table. int h = name.hashCode(); Name result = new Name(name, null, h); snames.put(name, result); created++; return result; } reused++; // return existing name and drop 'result' on the floor. return (Name)o; }

public static Name msxml'nm'create(char val[], int offset, int len)
{ Object o = snames.get(val, offset, len); if (o == null) { // add new name to simple names hash table. String name = new String(val, offset, len); int h = name.hashCode(); Name result = new Name(name, null, h); snames.put(name, result); created++; return result; } reused++; // return existing name and drop 'result' on the floor. return (Name)o; }

public static Name msxml'nm'create(String name, String ns)
// Create a Name object for the given name and namespace. The strings are case sensitive.
{ if (name == null) return null; if (ns == null) return create(name); return create(name,Atom.create(ns)); }

public static Name msxml'nm'create(String name, Atom#ql:msxml'atom# nameSpace)
// Create a Name object for the given name and namespace where the name and Namespace are already Atoms. The strings are case sensitive.
{if (name == null) return null; if (nameSpace == null) return create(name); int h = name.hashCode() + nameSpace.hashCode(); Name result = new Name(name, nameSpace, h); Object o = names.get(result); if (o == null) { // add new name to hash table. names.put(result, result); created++; return result; } else { reused++; // return existing name and drop 'result' on the floor. return (Name)o; } }

private void msxml'nm'readObject(java.io.ObjectInputStream stream)
throws java.io.IOException, ClassNotFoundException
{ name = (String)stream.readObject(); nameSpace = (Atom)stream.readObject(); if (names.get(this) == null) { names.put(this, this); } } private void writeObject(java.io.ObjectOutputStream stream) throws java.io.IOException { stream.writeObject(name); stream.writeObject(nameSpace); }

public static Name msxml'nm'parse(String s)
// Create a Name object by parsing this string.
{ String name, namespace; int i = s.indexOf(separator); if (i == -1) { namespace = null; name = s; } else { namespace = s.substring(0, i); name = s.substring(i + separator.length(), s.length()); } return create(name, namespace); }

public String msxml'nm'toString()
{ if (nameSpace != null) return nameSpace.toString() + separator + name; else return name; }

public void msxml'nm'save(XMLOutputStream o)
{ if (name == null) return; try { if (nameSpace == null) o.writeChars(name); else { o.writeChars(o.dtd.findShortNameSpace(nameSpace).toString() + separator + name); } } catch (IOException e) { System.out.println(e); } }

public int msxml'nm'hashCode()
// return the hash code for this name object
{ return hash; }

}

msxml'NameSpaceContext'NSC

name::
* McsEngl.msxml'NameSpaceContext'NSC@cptItsoft,

PACKAGE: com.ms.xml.util

msxml'nsc'METHODS:
public final void addNameSpace(Atom url, Atom n);
public final Atom findNameSpace(Atom n);
public final void pop();
public final void push();

public class NameSpaceContext

============================================================

package com.ms.xml.util;

import java.util.Hashtable; import java.util.Stack;

public class NameSpaceContext {

/** * add name space. long name is the key */
public final void msxml'nsc'addNameSpace(Atom url, Atom n) { current.put(url, n); }

/** * find name space, long name is the key */
public final Atom msxml'nsc'findNameSpace(Atom n) { return (Atom)current.get(n); }

public final void msxml'nsc'push()
{ contexts.push(current);
current = (Hashtable)current.clone(); }

public final void msxml'nsc'pop()
{ current = (Hashtable)contexts.pop#ql::JAPI101.NFO:pop rl5#(); }

msxml'nsc'FIELDS:
Hashtable current = new Hashtable();
/** * Stack to keep track of contexts */
Stack contexts = new Stack(); }

msxml'Queue'Q

name::
* McsEngl.msxml'Queue'Q@cptItsoft,

PACKAGE: com.ms.xml.util

msxml'q'METHODS:
public Queue();
public boolean empty();
public Object peek();
public Object pull();
public Object push(Object item);
public int search(Object o);

public class Queue
extends Vector

==============================================================

package com.ms.xml.util;
import java.util.Vector;
public class Queue extends Vector { /** * Creates a new queue with no elements. */ public Queue() { super(); }
public boolean empty() { return isEmpty(); } /** * Looks at the object at the front of this queue without removing it */ public Object peek() { return firstElement(); }
/** * Removes the object at the front of queue and returns that object */ public Object pull() { if( isEmpty() ) return null;
Object first = firstElement(); removeElementAt(0); return first; }
/** * Pushes an item onto the end of this queue */ public Object push(Object item) { addElement( item ); return item; }
/** * Determines if an object is in this queue. */ public int search(Object o) { return lastIndexOf(o); } }

msxml'ReadOnlyAttributes'ROA

name::
* McsEngl.msxml'ReadOnlyAttributes'ROA@cptItsoft,

PACKAGE: com.ms.xml.util

_DEFINITION:
Attributes wrapper class which provides read only access.

msxml'roa'METHODS:
public ReadOnlyAttributes();
public ReadOnlyAttributes(Vector v);
public ReadOnlyAttributes(int elems);
public Enumeration attributes();
public Object get(Name name);
public Attribute lookup(Name name);
public int size();
public String toString();}

public class ReadOnlyAttributes
implements java.io.Serializable

==============================================================

package com.ms.xml.util;
import java.util.Vector; import java.util.Enumeration;
/** * Attributes wrapper class which provides read only access.

* * @author Istvan Cseri * @version 1.0, 5/6/97 */ public class ReadOnlyAttributes implements java.io.Serializable { /** * Collection of Attribute objects.

*/ Vector attributes;
/** * Construct empty attributes collection.

*/ public ReadOnlyAttributes() { attributes = new Vector(); }
/** * Construct attributes collection using the vector of attributes.

* * @param v Attribute vector */ public ReadOnlyAttributes(Vector v) { attributes = v; }
/** * Construct attributes collection with given number of empty slots.

* The collection will grow automatically * if you add more than this number.

* @param elems the number of attributes to reserve initially.

*/ public ReadOnlyAttributes(int elems) { attributes = new Vector(elems); }
/** * Return the number of attribute/value pairs in the collection.

*/ public int size() { return attributes.size(); }
/** * Find the named attribute and return the associated value.

*/ public Object get(Name name) { Attribute a = lookup(name); if (a == null) { return null; } return a.getValue(); }
/** * Return an Enumeration for iterating through the attributes.

*/ public Enumeration attributes() { return attributes.elements(); }
public Attribute lookup(Name name) { for (Enumeration e = attributes.elements(); e.hasMoreElements(); ) { Attribute a = (Attribute)e.nextElement(); if (a.name == name) { return a; } } return null; }
public String toString() { return getClass().getName(); } }

msxml'StringHashtable'SH

name::
* McsEngl.msxml'StringHashtable'SH@cptItsoft,

PACKAGE: com.ms.xml.util

_DEFINITION:
This simple hashtable uses strings as the keys.

msxml'sh'METHODS:
public StringHashtable();
public StringHashtable(int size);
public Object get(String key);
public Object get(char chars[], int offset, int length);
public Object put(String key, Object value);

public class StringHashtable

==================================================================

package com.ms.xml.util;
class Entry { int hash; String key; Object value; Entry next;
Entry(String key, Object value, int hash) { this.key = key; this.value = value; this.hash = hash; } }
/** * This simple hashtable uses strings as the keys.

* * @version 1.0, 6/3/97 */ public class StringHashtable { Entry[] entries;
/** * Construct empty hashtable.

*/ public StringHashtable() { this(13); }
/** * Construct empty hashtable.

*/ public StringHashtable(int size) { this.entries = new Entry[size]; }
/** * Add object to the hashtable.

*/ public Object put(String key, Object value) { int hash = key.hashCode(); int index = ((hash & 0x7FFFFFFF) % entries.length); for (Entry entry = entries[index]; entry != null; entry = entry.next) { if (entry.hash == hash && entry.key.equals(key)) { Object o = entry.value; entry.value = value; return o; } } Entry entry = new Entry(key, value, hash); entry.next = entries[index]; entries[index] = entry; return null; }
/** * Get a value from the hashtable.

*/ public Object get(String key) { int hash = key.hashCode(); int index = ((hash & 0x7FFFFFFF) % entries.length); for (Entry entry = entries[index]; entry != null; entry = entry.next) { if (entry.hash == hash && entry.key.equals(key)) { return entry.value; } } return null; }
/** * Get a value from the hashtable.

*/ public Object get(char chars[], int offset, int length) { // calculate hashcode the same way as the String class...

int hash = 0; int off = offset;
if (length < 16) { for (int i = length; i > 0; i--) { hash = (hash * 37) + chars[off++]; } } else { // only sample some characters int skip = length / 8; for (int i = length; i > 0; i -= skip, off += skip) { hash = (hash * 39) + chars[off]; } } int index = ((hash & 0x7FFFFFFF) % entries.length); for (Entry entry = entries[index]; entry != null; entry = entry.next) { nextEntry: { if (entry.hash == hash) { String key = entry.key; if (key.length() == length) { while(--length >= 0) { if (chars[offset + length] != key.charAt(length)) break nextEntry; } return entry.value; } } } } return null; } }

msxml'StringInputStream'SIS

name::
* McsEngl.msxml'StringInputStream'SIS@cptItsoft,

PACKAGE: com.ms.xml.util

public class StringInputStream
extends InputStream

msxml'sis'METHODS:
public StringInputStream(String text);
public int read() throws IOException;

=================================================================

package com.ms.xml.util;
import java.io.*;
public class StringInputStream extends InputStream {
public StringInputStream(String text) { size = text.length(); index = 0; buf = text; }
public int read() throws IOException { if (index < size) return buf.charAt(index++); return -1; }
int size; int index; String buf; }

msxml'XMLInputStream'XMLIS

name::
* McsEngl.msxml'XMLInputStream'XMLIS@cptItsoft,

PACKAGE: com.ms.xml.util

_DEFINITION:
A Reader specifically for dealing with different encoding formats as well as liitleendian files.

public class XMLInputStream
extends InputStream#ql::JAPI101.NFO:class.InputStream#

msxml'xmlis'FIELDS:
public boolean caseInsensitive;

msxml'xmlis'METHODS:
public XMLInputStream(URL url) throws IOException;
public XMLInputStream(InputStream in);

public void close() throws IOException;
public XMLOutputStream createOutputStream( OutputStream out);
public int read() throws IOException;
public void setEncoding( String encoding ) throws IOException;

==========================================================

package com.ms.xml.util;

import java.io.*;
import java.net.*;
import com.ms.xml.xmlstream.*;

/** * * A Reader specifically for dealing with different encoding formats * as well as liitleendian files. * * @version 1.0, 6/10/97 */

public class XMLInputStream
extends InputStream {

msxml'xmlis'FIELDS:
/** * The state enumerators */ static final int INPUTSR = 1; // The different states that concern the read() static final int UCS2 = 2; // The POP states imply that there are characters static final int ASCII = 3; // stored in the next[] stack. There are separate static final int INPUTSR_POP = 4; // states for POP in order to speed up the read().
static final int UCS2_POP = 5; // There is still room for future additions, such
static final int ASCII_POP = 6; // as a UCS-4 state. // NOTE: All encodings that can use InputStreamReader // fall into the INPUTSR state /** * input buffer size on windows platforms */ static final int SIZE = 1024; // input buffer size
/** * encoding numbers */ static final int INTUTF8 = 0; static final int INTASCII = 1; static final int INTUCS2 = 2; static final int INTUCS4 = 3; static final int INTEBCDIC = 4; static final int INT1252 = 5;

/** * Builds the XMLInputStream. * This constructor is intended to be called on Windows to speed up input * speed. The decoding is done by IXMLStream * * Note: * This constructor relies on CXMLStream class in xmlurlstream.dll. If * xmlurlstream.dll or xmlurlstream.tlb is not properly registered on the * system, or the encoding of the input stream cannot be handled, * this constructor throws an IOException */

public msxml'xmlis'XMLInputStream(URL url) throws IOException { try { xmlis = (IXMLStream) new XMLStream(); intEncoding = xmlis.Open(url.toString()); } catch (Throwable e) { throw new IOException("Error opening input stream for \"" + url.toString() + "\": " + e.toString()); }
onWindows = true;
switch (intEncoding) {
case INTUTF8: encoding = "UTF-8"; break;
case INTASCII: encoding = "ASCII"; break;
case INTUCS2: encoding = "UCS-2"; break;
case INTUCS4: encoding = "UCS-4"; break;
case INTEBCDIC: encoding = "EBCDIC"; break;
case INT1252: encoding = "windows-1252"; break;
default: throw new IOException("Error opening input stream for \"" + url.toString() + "\""); } }

/** * Builds the XMLInputStream. * Reads the first four bytes of the InputStream in order to make a guess * as to the character encoding of the file. * Assumes that the document is following the XML standard and that * any non-UTF-8 file will begin with a <?XML> tag. */

public msxml'xmlis'XMLInputStream(InputStream in) { String version = System.getProperty("java.version"); jdk11 = version.equals("1.1") ? true : false;
littleendian = false; caseInsensitive = false;
byteOrderMark = false; encoding = "UTF-8"; // Default encoding
this.in = in; this.insr = null;
readState = ASCII;
boolean setDefault = false;
try { char c1, c2, c3, c4;
c1 = (char)in.read(); c2 = (char)in.read(); c3 = (char)in.read(); c4 = (char)in.read(); if( c1 == 0xFE && c2 == 0xFF && c3 == 0x00 && c4 == 0x3C ) { // UCS-2, big-endian littleendian = false; byteOrderMark = true; readState = UCS2_POP; encoding = "UCS-2"; } else if( c1 == 0xFF && c2 == 0xFE && c3 == 0x3C && c4 == 0x00 ) { // UCS-2, little-endian littleendian = true; byteOrderMark = true; readState = UCS2_POP; encoding = "UCS-2";
this.in = new ByteSwapInputStream( in ); } else if( c1 == 0x00 && c2 == 0x3C && c3 == 0x00 && c4 == 0x3F ) { // UCS-2, big-endian, no Byte Order Mark littleendian = false; readState = UCS2_POP; encoding = "UCS-2"; } else if( c1 == 0x3C && c2 == 0x00 && c3 == 0x3F && c4 == 0x00 ) { // UCS-2, little-endian, no Byte Order Mark littleendian = true; readState = UCS2_POP; encoding = "UCS-2";
this.in = new ByteSwapInputStream( in ); } else if( c1 == 0x3C && c2 == 0x3F && Character.toUpperCase(c3) == 0x58 && Character.toUpperCase(c4) == 0x4D ) { // UTF-8, ISO 646, ASCII, some part of ISO 8859, Shift-JIS, EUC, // or any other encoding that ensures that ASCII has normal positions readState = ASCII_POP; encoding = "ASCII"; } else if( c1 == 0x00 && c2 == 0x00 && c3 == 0x00 && c4 == 0x3C ) { // UCS-4, big-endian machine (1234 order) readState = ASCII_POP; // Until UCS-4 is implemented encoding = "UCS-4"; } else if( c1 == 0x3C && c2 == 0x00 && c3 == 0x00 && c4 == 0x00 ) { // UCS-4, little-endian machine (4321 order) readState = ASCII_POP; // Until UCS-4 is implemented encoding = "UCS-4"; } else if( c1 == 0x00 && c2 == 0x00 && c3 == 0x3C && c4 == 0x00 ) { // UCS-4, unusual octet order (2143 order) readState = ASCII_POP; // Until UCS-4 is implemented encoding = "UCS-4"; } else if( c1 == 0x00 && c2 == 0x3C && c3 == 0x00 && c4 == 0x00 ) { // UCS-4, unusual octet order (3412 order) readState = ASCII_POP; // Until UCS-4 is implemented encoding = "UCS-4"; } else if( c1 == 0x4C && c2 == 0x6F && c3 == 0xE7 && c4 == 0xD4 ) { // EBCDIC - We do NOT support this! readState = ASCII_POP; // Until EBCDIC is implemented encoding = "EBCDIC"; } else { // UTF-8 without an <?XML> tag (assuming data is not corrupt) setDefault = true; }
if( !encoding.equals( "UCS-2" ) ) { push(c4); push(c3); push(c2); push(c1); } else { if( littleendian ) { push(c3); push(c4); if( !byteOrderMark ) { push(c1); push(c2); } } else { push(c4); push(c3); if( !byteOrderMark ) { push(c2); push(c1); } } } } catch (IOException e) { // Can't do lookahead, so use default UTF-8 setDefault = true; }
pos = -1;
if( setDefault ) { try { if (! jdk11) throw new IOException("Readers not supported in JDK 1.0"); // guess that the <?xml encoding=...?> tag will be read in // less that 4096 bytes. if (! in.markSupported()) { in = new BufferedInputStream(in); } in.mark(4096); insr = new InputStreamReader( in, "UTF8" ); readState = INPUTSR_POP; encoding = "UTF-8"; } catch( IOException e2 ) { // If there is an exception we can // just continue and treat file like ASCII text. readState = ASCII_POP; encoding = "ASCII"; } } }
private void push(char next) { if (index == 3) { System.exit(0); } this.next[++index] = next; }

/** * Returns the next unicode char in the stream. The read done * depends on the current readState. POP states imply that there * are characters that have been pushed onto the next[] stack. */

public int msxml'xmlis'read() throws IOException { // On windows if (onWindows) { int len = 0; if (index >= size) { if (eof) return -1; try { len = xmlis.Read(buffer, SIZE); } catch (Exception e) { // System.out.println("Unexpected error: " + e.toString()); return -1; } if (len <= 0) return -1; if (len < SIZE) eof = true; size = len; index = 0; } int rc = buffer[index++]; if (rc == 0) { String err = "Stream error: unexpected null"; throw new IOException(err); } return rc; }
// On other platform switch( readState ) { case INPUTSR: pos++; return insr.read(); case ASCII: return in.read(); case UCS2: { int b1, b2;
b1 = in.read(); if( b1 == -1 ) return -1; b2 = in.read();
return ((b1 << 8) | b2); } case INPUTSR_POP: if (index >= 0) { return next[index--]; } else { readState = INPUTSR; return read(); } case UCS2_POP: { int b1, b2;
if (index >= 0) { b1 = next[index--]; } else { readState = UCS2; b1 = in.read(); } if( b1 == -1 ) return -1; if (index >= 0) { b2 = next[index--]; } else { readState = UCS2; b2 = in.read(); }
return ((b1 << 8) | b2); } case ASCII_POP: default: if (index >= 0) { return next[index--]; } else { readState = ASCII; return in.read(); } } }

/** * Defines the character encoding of the stream. The new character encoding * must agree with the encoding determined by the constructer. setEncoding * is used to clarify between encodings that are not fully determinable * through the first four bytes in a stream and not to change the encoding. * This method must be called within 4096 reads() after construction. */

public void msxml'xmlis'setEncoding( String encoding ) throws IOException { insr = null; String encvm; // Java VM's version of encoding. int newEncoding = 0;
if( encoding.equalsIgnoreCase( "ISO-10646-UCS-2" ) || encoding.equalsIgnoreCase( "UCS-2" ) ) { if( !this.encoding.equalsIgnoreCase( "UCS-2" ) ) throw new IOException( "Illegal Change of Encoding" );
readState = UCS2; this.encoding = "UCS-2"; return; } else if( encoding.equalsIgnoreCase( "Shift_JIS" ) ) { if (onWindows) throw new IOException( "SJIS not yet supported" ); encvm = "SJIS"; } else if( encoding.equalsIgnoreCase( "ISO-8859-1" ) ) { if (onWindows) throw new IOException( "8859_1 not yet supported" ); encvm = "8859_1"; } else if( encoding.equalsIgnoreCase( "ISO-10646-UCS-4" ) ) { // UCS-4 NOT YET SUPPORTED! throw new IOException( "UCS-4 not yet supported" ); } else if( encoding.equalsIgnoreCase( "UTF-8" ) ) { encvm = "UTF8"; newEncoding = INTUTF8; } else { if (onWindows) { if (encoding.equals("windows-1252")) newEncoding = INT1252 ; else throw new IOException( encoding + " not yet supported" ); } encvm = encoding; // try passing through to VM... }
if( !this.encoding.equalsIgnoreCase( "ASCII" ) && !this.encoding.equalsIgnoreCase( "UTF-8" ) ) throw new IOException( "Illegal Change of Encoding" ); if (onWindows) { if (intEncoding != newEncoding) { xmlis.SetEncoding(newEncoding, index); index = size = 0; } return; } if (this.encoding.equalsIgnoreCase( "ASCII" )) { insr = null; readState = ASCII_POP; } else { if (jdk11) { if (pos != -1) { in.reset(); // This fixes a nasty bug in that InputStreamReaders in.skip(pos+1); // now buffer their input. } insr = new InputStreamReader( in, encvm ); readState = INPUTSR; this.encoding = encoding; } else { throw new IOException( encvm + " is not supported by your Java Virtual Machine." + " Try installing the latest VM from http://www.microsoft.com/java/download.htm"); } } }

/** * Creates a new XMLOutputStream with the proper initial state. * XMLOutputStreams should always be created through this method * if the output stream is to mimic this input stream. */

public XMLOutputStream msxml'xmlis'createOutputStream( OutputStream out)
{ XMLOutputStream xmlOut = new XMLOutputStream( out );
try { xmlOut.setEncoding#ql:msxml'xmlos'setEncoding# ( encoding, littleendian, byteOrderMark ); }
catch (IOException e ) { // Hmm. This should never happen because we already // successfully created the input stream. } return xmlOut; }

/** * Close the stream and release system resources. */

public void msxml'xmlis'close() throws IOException { if (xmlis != null) xmlis.Close(); else if (insr != null) insr.close(); else if (in != null) in.close(); }

/** * Character pushed back into the stream. * Need to be able push back four characters for auto-encoding * detection support. */

private int next[] = new int[4]; private int index = -1;
/** * The stream readers */ private InputStream in; private InputStreamReader insr;
/** * We remember the current position in the input stream so that * we can re-scan input after doing a reset() when setEncoding * is called. We have to do a mark()/reset() on setEncoding because * the first UTF8 InputStreamReader may buffer the input ! */ private int pos = 0;
/** * Character encoding state */ private String encoding; private boolean littleendian; // file littleendian (only applies to UCS-2 encoded files) private boolean byteOrderMark; // byteOrderMark at the beginning of file (UCS-2) private int readState; private boolean jdk11;
/** * Instance varibales for Windows platforms */ private IXMLStream xmlis = null; // input stream pointer private int intEncoding = -1; // encoding of input stream private int[] buffer = new int[SIZE]; // input buffer private int size = -1; // bytes in buffer private boolean eof = false; // whether the end of input stream has been reached private boolean onWindows = false; // whether this program is running on a windows machine
/** * Whether the document to be parsed caseInsensitive. * (if so, all names are folded to upper case). * Default is 'false'. */
public boolean caseInsensitive;

}

msxml'XMLOutputStream'XMLOS

name::
* McsEngl.msxml'XMLOutputStream'XMLOS@cptItsoft,

PACKAGE: com.ms.xml.util

_DEFINITION:
A writer specifically designed for dealing with XML, incluing XML encoding as well as liitleendian files, and XML namespaces and white space handling.

public class XMLOutputStream
extends OutputStream

msxml'xmlos'METHODS:
public XMLOutputStream( OutputStream out);
public void close#ql:msxml'xmlos'close#() throws IOException;
public void flush#ql:msxml'xmlos'flush#() throws IOException;
public void setEncoding( String encoding, boolean littleendian, boolean byteOrderMark ) throws IOException;
public void write#ql:msxml'xmlos'write#( int c ) throws IOException;
public void writeChars#ql:msxml'xmlos'writeChars#( String str ) throws IOException;
public void writeQualifiedName(Name n, Atom ns) throws IOException;
public void writeQuotedString( String str ) throws IOException;

================================================================

package com.ms.xml.util;

import com.ms.xml.parser.DTD;
import java.io.*;

/** * * A writer specifically designed for dealing with XML, incluing * XML encoding as well as liitleendian files, and XML namespaces * and white space handling. * * @version 1.0, 6/10/97 */

public class XMLOutputStream extends OutputStream {

msxml'xmlos'FIELDS:
/** * The state enumerators */
static final int OUTPUTSW = 1; // The different states that concern the write()
static final int UCS2 = 2; // The UCS2_BOM implies a ByteOrderMark must be written.
static final int UCS2_BOM = 3; // NOTE: All encodings that can use OutputStreamWriter
static final int ASCII = 4; // fall into the OUTPUTSW state

public static int DEFAULT = 0; // default
public static int PRETTY = 1; // pretty output
public static int COMPACT = 2; // no new lines or tabs.

/** * The stream readers */
private OutputStream out;
private OutputStreamWriter outsw;
/** * The system newline character */
String newline#ql:msxml'xmlos'* newline ^msxml'xmlos'fields#;
/** * Character encoding state */
boolean littleendian;
String encoding;
private int writeState;
/** * output styling. */
int outputStyle;
boolean jdk11;
public boolean mixed;
private int indent; //denotes the number of tabs to usee
/** * needed for saving in correct format */
public DTD dtd;
/** * needed for saving in correct format */
public NameSpaceContext nameSpaceContext = new NameSpaceContext#ql:msxml'namespacecontext'nsc#();
/** * whether we are in the scope of saving a DTD or not */
public boolean savingDTD;
/** * whether to write out short end tags */
boolean shortEndTags;

/** * Builds the XMLOutputStream. * It is created as a standard UTF-8 output stream. * A subsequent call to setEncoding will specify the correct * character encoding required. XMLOutputStreams can be built * by using the createOutputStream method contained in XMLInputStream. */

public msxml'xmlos'XMLOutputStream( OutputStream out)
{ String version = System.getProperty("java.version");
jdk11 = version.equals("1.1") ? true : false; outputStyle = DEFAULT;
littleendian = false; savingDTD = false;
mixed = false; shortEndTags = false; this.out = out;
newline = System.getProperty("line.separator");
indent = 0; // We default immediately to UTF-8
try { if (! jdk11) throw new IOException("Writers not supported in JDK 1.0");
this.outsw = new OutputStreamWriter( out, "UTF8" ); writeState = OUTPUTSW; encoding = "UTF-8"; }
catch( IOException e ) { // If there is an exception (there should never be) we can // just continue and treat file like ASCII text. this.outsw = null; writeState = ASCII; encoding = "ASCII"; } }

/** * Pass-through of inherited OutputStream method. */

public void msxml'xmlos'flush() throws IOException
{ if( outsw#ql:msxml'xmlos'fields outsw# != null ) outsw.flush();
else out.flush(); }

/** * Pass-through of inherited OutputStream method. */

public void msxml'xmlos'close() throws IOException
{ if( outsw != null ) outsw.close(); else out.close(); }

/** * Defines the character encoding of the output stream. */

public void msxml'xmlos'setEncoding( String encoding, boolean littleendian, boolean byteOrderMark ) throws IOException
{ outsw = null; String vmenc = encoding;
if( encoding.equalsIgnoreCase( "UTF-8" ) ) { vmenc = "UTF8"; }
else if( encoding.equalsIgnoreCase( "Shift_JIS" ) ) { vmenc = "SJIS"; }
else if( encoding.equalsIgnoreCase( "ISO-8859-1" ) ) { vmenc = "8859_1"; }
else if( encoding.equalsIgnoreCase( "ISO-10646-UCS-4" ) || encoding.equalsIgnoreCase( "UCS-4" )) { // UCS-4, NOT YET SUPPORTED! throw new IOException( "UCS-4 not yet supported" ); }
else if( encoding.equalsIgnoreCase( "UCS-2" ) ) { // We only set the byteOrderMark if the initialEncoding is UCS-2. // Otherwise the flag is irrelant and we should ignore it. if( byteOrderMark ) writeState = UCS2_BOM; else writeState = UCS2;
this.encoding = "UCS-2"; if( littleendian ) { this.littleendian = true; out = new ByteSwapOutputStream( out ); } return; // we're done ! UCS-2 is handled manually. } else { // If none of the conditionals equate to true, // the inital writing is treated like ASCII text. writeState = ASCII; this.encoding = "ASCII"; }
if (encoding.equalsIgnoreCase("ASCII")) { outsw = null; } else { try { if (! jdk11) throw new IOException("Writers not supported in JDK 1.0"); outsw = new OutputStreamWriter( out, vmenc ); writeState = OUTPUTSW; this.encoding = encoding; } catch( IOException e ) { // If there is an exception (there should never be) we can // just continue and treat file like ASCII text. throw new IOException( vmenc + " is not supported by your Java Virtual Machine." + " Try installing the latest VM from http://www.microsoft.com/java/download.htm"); } } }

/** * writes a character to the stream according to the current writeState. * There is an extra state for a UCS-2 requiring a ByteOrderMark so as to * avoid an extra conditional in every UCS2 write. The ByteOrderMark will only * be written once at the beginning of the file. */

public void msxml'xmlos'write( int c ) throws IOException
{ switch( writeState ) {
case OUTPUTSW: outsw.write( c ); break;

case UCS2: { int byte1, byte2;
byte1 = c >> 8; byte2 = c & 0xff;
out.write(byte1); out.write(byte2); } break;

case UCS2_BOM: // We need to put a ByteOrderMark to immitate original file. { int byte1, byte2;
writeState = UCS2; // We now go to a normal UCS-2 state.
out.write( 0xfe ); out.write( 0xff ); byte1 = c >> 8; byte2 = c & 0xff;
out.write(byte1); out.write(byte2); } break;

case ASCII:
default: out.write( c ); break; } }

/** * This method writes out the fully qualified name, using * the appropriate short name syntax. For example: "foo::bar". * @param n the name being written
* @param ns the name space which defines the context * in which the name was defined. */

public void msxml'xmlos'writeQualifiedName(Name n, Atom ns) throws IOException
{
Atom sns = n.getNameSpace#ql:msxml'nm'getNameSpace#(); Atom shortName = sns;
if (sns == ns) { writeChars(n.getName()); return; }
if (sns != null) { if (dtd != null && ! dtd.isReservedNameSpace(sns)) { shortName = nameSpaceContext.findNameSpace(sns);
if (shortName == null) shortName = dtd.findShortNameSpace(sns); } writeChars(shortName.toString() + "::" + n.getName()); }
else { if (ns == null) writeChars(n.getName()); else writeChars("::" + n.getName()); } }

/** * Write the given string. */

public void msxml'xmlos'writeChars( String str ) throws IOException
{ int strLen = str.length();
for( int i = 0; i<strLen; i++ ) { this.write#ql:msxml'xmlos'write#( str.charAt( i ) ); }
}

/** * Write out the string with quotes around it. * This method uses the quotes that are appropriate for the string. * I.E. if the string contains a ' then it uses ", & vice versa. */

public void msxml'xmlos'writeQuotedString( String str ) throws IOException { char quote = '"'; if (str.indexOf('"') >= 0 && str.indexOf('\'') < 0) { quote = '\''; } write(quote);
int strLen = str.length(); for( int i = 0; i<strLen; i++ ) { int ch = str.charAt( i ) ; if (ch == quote) { if (quote == '"') writeChars("""); else writeChars("'"); } else { this.write(ch); } }
write(quote); }

/** * Write a new line or do nothing if output style is COMPACT. */

public void msxml'xmlos'writeNewLine() throws IOException
{ if (outputStyle == PRETTY && ! mixed) { this.writeChars( newline#ql:msxml'xmlos'fields newline# ); } }

/** * Set the relative indenting level. Eg indent(+1) or indent(-1). * The indent level controls what writeIndent writes. */

public void msxml'xmlos'addIndent(int offset)
{ indent += offset; }

/** * Write the appropriate indent - given current indent level, * or do nothing if output style is COMPACT. */

public void msxml'xmlos'writeIndent() throws IOException
{ if (outputStyle == PRETTY && ! mixed#ql:msxml'xmlos'fields mixed#)
{ for (int i = 0; i < indent#ql:msxml'xmlos'fields indent#; i++) this.write('\t'); } }

/** * Set the output style (PRETTY or COMPACT). */

public void msxml'xmlos'setOutputStyle(int style) { outputStyle = style; }

/** * Return the current output style. */

public int msxml'xmlos'getOutputStyle() { return outputStyle; }

/** * Set short end tags */

public void msxml'xmlos'setShortEndTags(boolean yes)
{ shortEndTags = yes; }

/** * Return true if we are writing short end tags */

public boolean msxml'xmlos'isShortEndTags()
{ return shortEndTags; }

}

msxml'XMLViewer'class

name::
* McsEngl.msxml'XMLViewer'class@cptItsoft,

SOURCE: msxml 1.6

_DEFINITION:
The main xml-viewer class.

xmlv'METHODS:
**public void init()
**public void createFrame()
**public XMLViewer(): do nothing
**public String getAppletInfo()
**public boolean handleEvent(Event evt)
**public boolean action(Event evt, Object what): handls events parse, view, choice.
**public void destroy(): nothing
**public void start()
**public String getParameter(String name)
**public void parse(String fileName)
**public void stop()
**public URL createURL(String fileName)
**public void view#ql:xmlv'view#(String fileName): view file in xml format
**public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height)
**public static void main#ql:xmlv'main#(String args[])

xmlv'PROCEDURE:
** init#ql:xmlv'init#(): creates the user'interface. The treeview is a canvas.
** start#ql:xmlv'start#():

===================================================================

public class XMLViewer
extends Applet#ql:jv'applet'class# {

xmlv'FIELDS:
String input; //holds the xml file.
TextField text; //here we enter the url of xml file.
Choice choice;
TextArea results; //displays the results of parsing
Document d = new Document();
XMLTreeView viewer;
XMLTreeView viewer2; //+
URL baseurl; //holds the url of the html file
XMLViewerFrame frame;
final String OPENFOLDERPATH = "Open.gif";
final String CLOSEDFOLDERPATH = "Closed.gif";
int imageCount;

public boolean xmlv'action(Event evt, Object what)
// deprecated should register this component as ActionListener on component which fires action events.
{if (evt.id == Event.ACTION_EVENT)
{String s = (String)evt.arg;
if (s.equals("Parse")) { results.setText#ql:jv'textarea#("Parsing: " + text.getText#ql:jv'textfield#()); parse#ql:xmlv'parse#(text.getText()); return true;}
else
if (s.equals("View")) {view#ql:xmlv'view#(text.getText()); return true; }
else
if (evt.target == choice ) {viewer.action#ql:xmlv'tv'action#(evt, what);}
} return false;}

public void xmlv'createFrame()
//creates the userinterface of the applet in a Border Layout.
//north: a panel that holds 3 other panels for buttons, textfield, choice.
//center: a scroller that holds a xmltreeviewer
//south: a textarea for messages
{ frame = new XMLViewerFrame#ql:xmlv'vf'xmlviewerframe#("XMLViewer",this); frame.show(); frame.hide();
frame.resize(frame.insets().left + frame.insets().right + 640, frame.insets().top + frame.insets().bottom + 480); frame.setLayout(new BorderLayout());
//panel for buttons parse and view
Panel buttonPanel = new Panel(); buttonPanel.setLayout( new FlowLayout() ); buttonPanel.add("Center", new Button("Parse")); buttonPanel.add("East", new Button("View"));
//panel2 for textfield and buttons
Panel panel1 = new Panel(); panel1.setLayout( new BorderLayout() ); text = new TextField(); panel1.add("Center", (Component)text); panel1.add("East", buttonPanel);
//panel2 for choice under textfield
Panel panel2 = new Panel(); panel2.setLayout( new BorderLayout() ); choice = new Choice(); panel2.add("Center", (Component)choice);
//panel for textfield/buttons/choice
Panel panel = new Panel(); panel.setLayout( new BorderLayout() ); panel.add("North",panel1); panel.add("South",panel2); frame.add("North", panel);
//create textarea for south of frame
results = new TextArea(5,100); results.setEditable(false); frame.add("South", results);
//create scroller for center
viewer = new XMLTreeView#ql:xmlv'tv'xmltreeview#();
frame.add("Center", new Scroller#ql:xmlv's'scroller#( viewer ));
// Set the open and closed folder images.
Image openFolder = getImage(getCodeBase(), OPENFOLDERPATH); Image closedFolder = getImage(getCodeBase(), CLOSEDFOLDERPATH); int h = openFolder.getHeight(this); h = closedFolder.getHeight(this); imageCount= 2; viewer.openFolder = openFolder; viewer.closedFolder = closedFolder; viewer.choice = choice; viewer.setBackground(Color.white);
//+viewer2.openFolder = openFolder; viewer2.closedFolder = closedFolder; viewer2.choice = choice; viewer2.setBackground(Color.white);
frame.show(); frame.resize(640, 480); }

public URL xmlv'createURL(String fileName)
//for a filename gives its url (whole path).
{ URL url = null;
try { baseurl = getDocumentBase(); url = new URL#ql:jv'url#(baseurl,fileName); }
catch (MalformedURLException ex) { try { File f = new File(fileName); url = new URL("file:///" + f.getAbsolutePath()); } catch (MalformedURLException ex2) { } } return url; }

public void xmlv'destroy()
{}

public String xmlv'getAppletInfo()
{return "Name: XMLViewer\r\n" + "Author: Chris Lovett and Jeffrey Goldberg\r\n" + "Created with Microsoft Visual J++ Version 1.1"; }

public String xmlv'getParameter(String name)
{ if (name.equals("Input") && input != null) return input; return super.getParameter(name); }

public boolean xmlv'handleEvent(Event evt)
{switch (evt.id){// Application shutdown (e.g. user chooses Close from the system menu).
case Event.ACTION_EVENT: action(evt,evt.target); return true;
default: return super.handleEvent(evt); }}

public boolean xmlv'imageUpdate(Image img, int infoflags, int x, int y, int width, int height)
{ // this method is called when GIF's are loaded so we can force a repaint.
if ((infoflags & ALLBITS) == ALLBITS) { // Image is now complete...
repaint(); imageCount--; if (imageCount <= 0) return false; } return true; }

public void xmlv'init()
{ createFrame#ql:xmlv'createframe#(); }

public static void xmlv'main(String args[])
{XMLViewer applet_XMLViewer = new XMLViewer();
XMLViewerFrame frame = new XMLViewerFrame("XMLViewer",applet_XMLViewer);
frame.show(); frame.hide(); frame.resize(frame.insets().left + frame.insets().right + 640, frame.insets().top + frame.insets().bottom + 480);
// The following code starts the applet running within the scrollpane window, which is running within the fram window. // It also calls GetParameters() to retrieve parameter values from the // command line, and sets m_fStandAlone to true to prevent init() from // trying to get them from the HTML page.
applet_XMLViewer.input = args[0]; frame.add("Center",applet_XMLViewer); applet_XMLViewer.m_fStandAlone = true; applet_XMLViewer.init(); applet_XMLViewer.start(); frame.show(); }

public void xmlv'parse(String fileName)
//filename= the xml file
{ try
{ boolean alive = frame.isAlive#ql:xmlv'vf'isalive#();
if (! alive) { createFrame();} else { viewer.viewText#ql:xmlv'tv'fields# = false; }
URL url = createURL#ql:xmlv'createurl#(fileName); text#ql:xmlv'fields#.setText(url.toString());
if (! alive) { TimerThread t = new TimerThread(this,250,"Parse"); t.start(); return;} ByteArrayOutputStream s = new ByteArrayOutputStream#ql::JAPI101.NFO:class.ByteArrayOutputStream#();
//+ByteArrayOutputStream s2 = new ByteArrayOutputStream();
viewer.load#ql:xmlv'tv'load#(url, s);
//+viewer2.load(url,s);
results#ql:xmlv'fields results#.setText(s.toString());
if (frame != null) { frame.show();}
} catch (Exception e){ results.setText(e.toString()); } }

public void xmlv'start():
{String urlparam = getParameter("URL");
parse#ql:xmlv'parse#(urlparam); } //urlparam=the xml file.

public void xmlv'stop():
{}

public xmlv'XMLViewer():
{ }

public void xmlv'view(String fileName):
// dispalys the 'fileName' in xml notation
{try {ByteArrayOutputStream s = new ByteArrayOutputStream(); viewer.viewText = true; viewer.reorient#ql:xmlv'bc'reorient#(); viewer.fileName = createURL#ql:xmlv'createurl#(fileName); viewer.load#ql:xmlv'tv'load#(createURL(fileName), s); results.setText(s.toString()); repaint();
} catch (Exception e){results.setText(e.toString());} }

xmlv'BufferedCanvas

name::
* McsEngl.xmlv'BufferedCanvas@cptItsoft,

abstract class BufferedCanvas extends Canvas#ql:jv'canvas#.

xmlv'bc'FIELDS:
private int tx = 0;
private int ty = 0;
int displayWidth = 0;
int displayHeight = 0;
boolean redraw = true;
Dimension offDimension = new Dimension(0,0);
Image[] offImage = new Image[2];
Graphics[] offGraphics = new Graphics[2];
int curr = 0;
int bad = 1;
public final int DISPLAY_SIZE_CHANGE = 10000;
public final int CLIPBUFFER = 2;
public final int BUFFER = 5;
public final int INDENT = 5;
public final int LEVELINDENT = 10;
public final int SPACING = 3;
public final int OVAL_SIZE = 10;
public final int RECT_SIZE = 8;
public final int FOLDER_SIZE = 15;
public int LINE_SIZE = 15;
public FontMetrics fm;
private Font fnt;
boolean jdk11;

xmlv'bc'BufferedCanvas()
{ String version = System.getProperty#ql:jv'system'class#("java.version");
jdk11 = version.equals("1.1") ?-true-:-false;#ql:jv'conditional'operator#
String[] nms = Toolkit.getDefaultToolkit().getFontList(); fnt = new Font( nms[0], Font.PLAIN, 12 ); fm = Toolkit.getDefaultToolkit().getFontMetrics( fnt ); LINE_SIZE = fm.getHeight() + SPACING;
// Does the canvas not contain an integer number of lines?
int modSize = size().height %#ql:jv'operator.modulus# LINE_SIZE;
if( modSize != (BUFFER*2) ) { resize( size().width, size().height - modSize + (BUFFER*2)); } }

public void xmlv'bc'paint( Graphics g )
{ update#ql:xmlv'bc'update#(g); }

abstract public void xmlv'bc'paintBuffer( Graphics g )

public void xmlv'bc'invalidateBuffer()
{ redraw = true; }

public void xmlv'bc'reorient():
{ tx#ql:xmlv'bc'fields# = 0; ty = 0; redraw = true; }

public void xmlv'bc'newGraphics()
{Dimension d = size(); offDimension#ql:xmlv'bc'fields# = d;
for( int i = 0; i <= 1; i ++ )
{offImage[i] = createImage(d.width, d.height);
offGraphics[i] = offImage[i].getGraphics(); offGraphics[i].setColor(getBackground());
offGraphics[i].fillRect(0, 0, d.width, d.height); offGraphics[i].setColor(Color.black); offGraphics[i].clipRect(BUFFER,CLIPBUFFER,d.width-BUFFER*2,d.height-CLIPBUFFER*2);
} curr = 0; bad = 1; }

public void xmlv'bc'checkGraphics()
{ Dimension d = size(); // Have we resized the image?
if ( d.width != offDimension.width || d.height != offDimension.height ) { newGraphics(); redraw = true; }
// Does the canvas not contain an integer number of lines (with buffer padding)?
int modSize = size().height % LINE_SIZE;
if( modSize != (BUFFER*2) ) { resize( size().width, size().height - modSize + (BUFFER*2)); } }

public void xmlv'bc'checkEmptySpace()
{ // Is there empty space at the bottom of the screen? if( ( ty + getCanvasHeight() ) > displayHeight ) { int newty = displayHeight - getCanvasHeight(); if( newty < 0 ) { newty = 0; } setVert( newty ); } }

public void xmlv'bc'update( Graphics g )
{ checkGraphics#ql:xmlv'bc'checkGraphics#();
if( redraw ) { offGraphics[curr].translate( -tx + BUFFER, -ty + BUFFER ); offGraphics[curr].setFont( fnt ); paintBuffer(offGraphics[curr]); offGraphics[curr].translate( tx - BUFFER, ty - BUFFER);
redraw = false;
checkEmptySpace(); }
g.drawRect( 0,0,size().width-1, size().height-1); g.drawRect( 1,1,size().width-3, size().height-3); g.clipRect(BUFFER,CLIPBUFFER,size().width-BUFFER*2,size().height-CLIPBUFFER*2); g.drawImage(offImage[curr], BUFFER, BUFFER, this);
}

public int xmlv'bc'getHorz()
{ return tx; }

public int xmlv'bc'getHorzLines()
{ return tx / LINE_SIZE; }

public void xmlv'bc'zeroHorz()
{ setHorz( 0 ); }

public void xmlv'bc'scrollHorz( int scrollx )
{ int pixelx = scrollx * LINE_SIZE; setHorz( tx + pixelx ); }

protected void xmlv'bc'setHorz( int newtx )
{ if( tx != newtx ) { if( newtx + getCanvasWidth() > displayWidth ) newtx = displayWidth - getCanvasWidth(); if( newtx < 0 ) newtx = 0; redraw = true; tx = newtx; repaint(); } }

public int xmlv'bc'getVert()
{ return ty; }

public int xmlv'bc'getVertLines()
{ return ty / LINE_SIZE; }

public void xmlv'bc'zeroVert()
{ setVert( 0 ); }

public void xmlv'bc'setTopLine( int topline )
{ int newy = YPOS(topline); setVert( newy ); }

public void xmlv'bc'setBottomLine( int botline )
{ int newy = YPOS(botline) - (getCanvasHeight() - LINE_SIZE); setVert( newy ); }

public void xmlv'bc'scrollVert( int scrolly )
{ int pixely = scrolly * LINE_SIZE; setVert( ty + pixely ); }

private void xmlv'bc'setVert( int newty )
{ if( ty != newty ) { if( newty + getCanvasHeight() > displayHeight ) newty = displayHeight - getCanvasHeight(); if( newty < 0 ) newty = 0;
newty = newty - ( newty % LINE_SIZE );
int diff = newty - ty; ty = newty;
if( diff < 0 ) // Scrolled up { diff *= -1;
if( diff > getCanvasHeight() / 4 ) { redraw = true; } else { Graphics tGraphics;
offGraphics[bad].drawImage( offImage[curr], 0, diff, this ); tGraphics = offGraphics[bad].create(); tGraphics.clipRect( BUFFER, CLIPBUFFER, getCanvasWidth(), diff+(BUFFER-CLIPBUFFER) ); tGraphics.setColor( getBackground() ); tGraphics.fillRect( BUFFER, CLIPBUFFER, getCanvasWidth(), diff+(BUFFER-CLIPBUFFER) ); tGraphics.setColor( Color.black );
tGraphics.translate( -tx + BUFFER, -ty + BUFFER); tGraphics.setFont( fnt ); paintBuffer(tGraphics);
bad = ( bad == 1 ) ? 0 : 1; curr = ( curr == 1 ) ? 0 : 1; } } else // Scrolled down { if( diff > getCanvasHeight() / 4 ) { redraw = true; } else { Graphics tGraphics;
offGraphics[bad].drawImage( offImage[curr], 0, -diff, this ); tGraphics = offGraphics[bad].create(); tGraphics.clipRect( BUFFER, getCanvasHeight()-diff-LINE_SIZE, getCanvasWidth(), diff + (LINE_SIZE * 2) ); tGraphics.setColor( getBackground() ); tGraphics.fillRect( BUFFER, getCanvasHeight()-diff-LINE_SIZE, getCanvasWidth(), diff + (LINE_SIZE * 2) ); tGraphics.setColor( Color.black );
tGraphics.translate( -tx + BUFFER, -ty + BUFFER); tGraphics.setFont( fnt ); paintBuffer(tGraphics);
bad = ( bad == 1 ) ? 0 : 1; curr = ( curr == 1 ) ? 0 : 1; } } repaint(); } }

public int xmlv'bc'getDisplayHeightLines()
{ return displayHeight / LINE_SIZE; }

public int xmlv'bc'getDisplayWidthLines()
{ return displayWidth / LINE_SIZE; }

public int xmlv'bc'xmlv'bc'getCanvasHeight()
{ return size().height - (BUFFER*2); }

public int xmlv'bc'getCanvasWidth()
{ return size().width - (BUFFER*2); }

public int xmlv'bc'getCanvasHeightLines() { return ( size().height - (BUFFER*2) ) / LINE_SIZE; }

public int xmlv'bc'getCanvasWidthLines()
{ return size().width / LINE_SIZE; }

public int xmlv'bc'YPOS( int y )
{return( y * LINE_SIZE ); }

xmlv'Scroller

name::
* McsEngl.xmlv'Scroller@cptItsoft,

extends Panel#ql:jv'panel#.

xmlv's'FIELDS:
Scrollbar vert;
Scrollbar horz;
BufferedCanvas canvas;
final int HORZ = 0;
final int VERT = 1;

public xmlv's'Scroller(BufferedCanvas canvas)
// setLayout(new BorderLayout())
// put scrollbars on east and south
// put canvas on center.
// validate()
{this.canvas = canvas;
horz = new Scrollbar(Scrollbar.HORIZONTAL);
vert = new Scrollbar(Scrollbar.VERTICAL);
setLayout(new BorderLayout()); add("Center", canvas); add("East", vert); add("South", horz); validate(); resizeHorizontal(); resizeVertical(); }

private void xmlv's'quickScroll( Object target, int scrollAmt )
{ if( target == vert ) { canvas.scrollVert( scrollAmt ); resizeVertical(); } else if( target == horz ) { canvas.scrollHorz( scrollAmt ); resizeHorizontal(); } }

private void xmlv's'quickScroll( int dir, int scrollAmt )
{ if( dir == VERT ) // vert { canvas.scrollVert( scrollAmt ); resizeVertical(); } if( dir == HORZ ) // horz { canvas.scrollHorz( scrollAmt ); resizeHorizontal(); } }

public boolean xmlv's'handleEvent( Event evt )
{ switch( evt.id ) { case Event.SCROLL_LINE_UP: case Event.SCROLL_LINE_DOWN: case Event.SCROLL_ABSOLUTE: { int newPos = ( ( Integer ) evt.arg ).intValue(); if( evt.target == vert ) { canvas.scrollVert( newPos - canvas.getVertLines() ); resizeVertical(); } else if( evt.target == horz ) { canvas.scrollHorz( newPos - canvas.getHorzLines() ); resizeHorizontal(); } return true; } case Event.SCROLL_PAGE_UP: case Event.SCROLL_PAGE_DOWN: { if( evt.target == vert ) { resizeVertical(); } else if( evt.target == horz ) { resizeHorizontal(); } return true; } case canvas.DISPLAY_SIZE_CHANGE: { update(); return true; } } return super.handleEvent( evt ); }

public boolean xmlv's'keyDown( Event evt, int key )
{ switch( evt.key ) { case Event.UP: quickScroll( VERT, -1 ); break; case Event.PGUP: quickScroll( VERT, -1 * canvas.getCanvasHeightLines() ); break; case Event.DOWN: quickScroll( VERT, 1 ); break; case Event.PGDN: quickScroll( VERT, canvas.getCanvasHeightLines() ); break; case Event.RIGHT: quickScroll( HORZ, 1 ); break; case Event.LEFT: quickScroll( HORZ, -1 ); break; } return false; }

void xmlv's'resizeHorizontal()
{ int canvasWidthLines = canvas.getCanvasWidthLines(); int displayWidthLines = canvas.getDisplayWidthLines();
if( canvasWidthLines <= 0 ) { return; }horz.setValues( canvas.getHorzLines(), (int)(canvasWidthLines * 0.9), 0, displayWidthLines-1 ); horz.setPageIncrement( ( int ) ( canvasWidthLines * 0.9 )); return; }

void xmlv's'resizeVertical()
{ int canvasHeightLines = canvas.getCanvasHeightLines(); int displayHeightLines = canvas.getDisplayHeightLines();
// To keep things simpler, the vertical scrollbar will always // appear, regardless of need.
if( canvasHeightLines <= 0 || canvasHeightLines > displayHeightLines) { vert.setValues( 0, 1, 0, 1); }
vert.setValues( canvas.getVertLines(), canvasHeightLines, 0, displayHeightLines-1); vert.setPageIncrement( canvasHeightLines ); return; }

public void xmlv's'update( Graphics g )
{ resizeHorizontal(); resizeVertical(); }

public void xmlv's'update()
{ resizeHorizontal(); resizeVertical(); }

public void xmlv's'paint( Graphics g )
{ resizeHorizontal(); resizeVertical(); }

xmlv'SpecialEnumeration'SE

name::
* McsEngl.xmlv'SpecialEnumeration'SE@cptItsoft,

class SpecialEnumeration implements Enumeration

xmlv'se'FIELDS:
Element next;
Enumeration en;

public xmlv'se'SpecialEnumeration(Element e)
{this.en = new ElementEnumeration#ql:msxml'elementenumeration#(e); next#ql:xmlv'se'next#(); }

public boolean xmlv'se'hasMoreElements()
{ return (next != null); }

public Object xmlv'se'nextElement()
{ Element result = next; next(); return result; }

void xmlv'se'next()
{ while (en.hasMoreElements())
{next= (Element)en.nextElement(); if (next.getType() != Element.WHITESPACE) return; } next = null; }

xmlv'XMLViewerFrame

name::
* McsEngl.xmlv'XMLViewerFrame@cptItsoft,

extends Frame#ql:jv'frame#.

xmlv'vf'FIELDS:
Applet parent;
boolean alive;

public xmlv'vf'XMLViewerFrame(String str, Applet parent)
{ super (str); alive = true; this.parent = parent; }

public boolean xmlv'vf'handleEvent(Event evt)
{ switch (evt.id)
{case Event.WINDOW_DESTROY: alive = false; dispose(); return true;
default: return super.handleEvent(evt);
}
}

public boolean xmlv'vf'action(Event evt, Object what)
{ if( parent != null ) return parent.handleEvent(evt); else return false; }

public boolean xmlv'vf'isAlive()
// with the creation of the frame alive=true
{ return alive#ql:xmlv'vf'fields#; }

xmlv'XMLTreeView

name::
* McsEngl.xmlv'XMLTreeView@cptItsoft,

_DEFINITION:

xmlv'tv'METHODS:
**XMLTreeView#ql:xmlv'tv'xmltreeview#():
nothing
**public void load#ql:xmlv'tv'load#(URL url, OutputStream results):
**public void getMaxBranch#ql:xmlv'tv'getmaxbranch#( Element e, int branch )
**public String elementPos#ql:xmlv'tv'elementpos#( Element e ):
returns the path of an element in choice.
**public void setViewChoiceHelp#ql:xmlv'tv'setViewChoiceHelp#( Element e ):
adds on choice the path of the element AND its parents.
**public void setViewChoice#ql:xmlv'tv'setViewChoice#( Element e ):
**public void paintBuffer#ql:xmlv'tv'paintBuffer#( Graphics g )
**public int viewDoc#ql:xmlv'tv'viewdoc#(Graphics g):
feeds TreeHeighLines
**public void drawTreeLines#ql:xmlv'tv'drawtreelines#( Graphics g, int y, boolean hasChildren, boolean hidden, boolean isHead )
**public void drawTextLines#ql:xmlv'tv'drawtextlines#( Graphics g, int y, int height )
**public void drawElement#ql:xmlv'tv'drawElement#( Graphics g, Element child, int x, int y )
**public int drawTree#ql:xmlv'tv'drawtree#(Graphics g, Element e, int x, int y)
**public void drawAttributes#ql:xmlv'tv'drawattributes#(Graphics g, Element e, int x, int y)
**public int drawText#ql:xmlv'tv'drawtext#(Graphics g, String text, int x, int y, int max, boolean skipWhiteSpace, int l, boolean attribute, boolean draw)
**public boolean isWhiteSpace#ql:xmlv'tv'iswhitespace#(char ch)
**public boolean isElement#ql:xmlv'tv'iselement#(Element e)
**public int findElementAt#ql:xmlv'tv'findElementAt#( Element e, int x, int y, int x1, int y1 )
**public int findElementAtLine#ql:xmlv'tv'findElementAtLine#( Element e, int line, int x1, int y1 )
**public int findElement#ql:xmlv'tv'findElement#( Element e, Element find, int x1, int y1 )
**public boolean mouseMove#ql:xmlv'tv'mousemove#(Event evt, int x, int y):
focus event
**public boolean mouseDrag( Event evt, int x, int y )
**public boolean mouseDown#ql:xmlv'tv'mouseDown#(Event evt, int x, int y):
choiceview, expand tree
**public boolean mouseUp#ql:xmlv'tv'mouseup#(Event evt, int x, int y):
collapse/expand tree
**public Element lastVisibleChild( Element parent )
**public Element prevVisibleElement( Element current )
**public Element nextVisibleElement( Element current, Element original )
**public boolean keyDown#ql:xmlv'tv'keyDown#( Event evt, int key ):
events with keys
**public boolean action#ql:xmlv'tv'action#(Event evt, Object what):
choice action
**public boolean handleEvent#ql:xmlv'tv'handleEvent#( Event evt ):
focus

============== CODE ===============

import java.awt.*; import java.awt.Choice; import java.io.*; import java.util.Enumeration; import com.ms.xml.parser.*; import com.ms.xml.om.*; import com.ms.xml.util.*; import java.net.URL; import Scroller;

class XMLTreeView
extends BufferedCanvas#ql:xmlv'bufferedcanvas#.

xmlv'tv'FIELDS:
public Image openFolder;
public Image closedFolder;
Document d = new Document#ql:msxml'd'document#();
Element head = null; // the element that heads the view
int headX, headY;
Element pressed; // the element that the mouse is currently pressing
Element inside; // the element that the mouse is over
Element focus; // the element with focus
int focusY;
boolean hasFocus = false; // This indicates if the focus has focus, not the window.
Element found;
int foundX, foundY; //+coordinates of found-element.
int prevX = 0;
int prevY = 0;
int maxWidth = 0;
boolean boxClick; // was the click on the box or on the tag
int ax = 0; // position of attributes for "inside" element.
int ay = 0; // Variables for keeping track of the tree branch drawing
int maxBranch;
int[] treeLines;
int currLines;
boolean viewText;
URL fileName;
Choice choice;
boolean sizeChange = true;
boolean doneDraw = false;
boolean stopDraw = false;
Name kInside = Name.create#ql:msxml'name#("_INSIDE");
Name kPressed = Name.create("_PRESSED");
Name kHidden = Name.create("_HIDDEN"); //+ collapse/expand tree
Name kFocus = Name.create("_FOCUS");
Name kHeight = Name.create("_HEIGHT");

xmlv'tv'XMLTreeView()
{}

public void xmlv'tv'load(URL url, OutputStream results)
//
{ PrintStream o = new PrintStream#ql::JAPI101.NFO:printstream rl5 constructor#(results);
try {d.load#ql:msxml'd'load#(url); o.println("Done."); }
catch (ParseException e){ d.reportError(e, results); o.println(e.toString()); } newGraphics#ql:xmlv'bc'newgraphics#(); //(BufferedCanvas Reset the graphic image.
maxBranch#ql:xmlv'tv'fields maxBranch# = 0;
getMaxBranch#ql:xmlv'tv'getMaxBranch#(this.d, 0); // This is needed so we can draw the proper tree lines later on.
setViewChoice#ql:xmlv'tv'setviewchoice#( this.d.getRoot#ql:msxml'd'getroot#() ); //displays the root
focus#ql:xmlv'tv'fields focus# = head; focusY = 0; focus.setAttribute#ql:msxml'e'methods#( kFocus, "TRUE" ); repaint(); }

public void xmlv'tv'getMaxBranch( Element e, int branch ):
//+ puts on maxBranch the number of all nodes.
{if( e.numElements#ql:msxml'ei'numelements#() > 0) { for( Enumeration en = new SpecialEnumeration#ql:xmlv'se'specialenumeration#(e); en.hasMoreElements(); ) {Element child = ( Element )en.nextElement();
getMaxBranch( child, branch + 1 ); } }
else {if( branch > maxBranch ) maxBranch = branch;} }

public String xmlv'tv'elementPos( Element e )
//+returns the path of an element in choice.
{ String elPos = new String(""); Element curr = e;
while( curr!=null &&#ql:jv'operator.conditional'and# curr!=this.d )
{ Name currTagName = curr.getTagName#ql:msxml'ei'getTagName#(); if( currTagName != null ) elPos = currTagName.toString() + "\\" + elPos; curr = curr.getParent();
} return elPos; }

public void xmlv'tv'setViewChoiceHelp( Element e )
//+ adds on choice the path of the element AND its parents.
{ if( e!=null && e!=this.d )
{setViewChoiceHelp( e.getParent() ); choice.addItem( elementPos#ql:xmlv'tv'elementpos#(e) ); } }

public void xmlv'tv'setViewChoice( Element e )
// TreeView displays only the element e.
// How I can make it displays only first children????
{sizeChange#ql:xmlv'tv'fields sizeChange# = true;
if( jdk11 ) // There is NO WAY to remove items from choice box before jdk11!
{choice.removeAll(); setViewChoiceHelp#ql:xmlv'tv'setViewChoiceHelp#( e ); int num = choice.countItems(); if( num == 0 ) return; choice.select( num-1 );
}
head = e; found = null; findElement#ql:xmlv'tv'findElement#( this.d, head, 15, 0 );
if( found != null ) { headX = foundX; headY = foundY; }
else { headX = 0; headY = 0; }
if( focus#ql:xmlv'tv'fields# != null ) focus.removeAttribute( kFocus );
focus = head; focus.setAttribute( kFocus, "TRUE" ); focusY = headY; reorient#ql:xmlv'bc'reorient#();
postEvent#ql::2nfoJAPI11.NFO:class.event#(new Event(null, DISPLAY_SIZE_CHANGE, null)); invalidateBuffer#ql:xmlv'bc'invalidatebuffer#(); }

public void xmlv'tv'paintBuffer( Graphics g )
//
{ int treeHeightLines = 0; maxWidth = 0; g.setColor(Color.white);
Dimension dim = size(); //+size is a deprecated canvas method.
Rectangle clip = g.getClipRect#ql::2nfoJAPI11.NFO:class.graphics#(); //+JDK version 1.1, replaced by getClipBounds().
g.fillRect(clip.x, clip.y, clip.width, clip.height); g.setColor(Color.black);
if( !viewText )
{treeLines = new int[maxBranch#ql:xmlv'tv'fields maxBranch#]; currLines = 0; doneDraw = false; stopDraw = false;
try {if( head != null && head != this.d ) {treeHeightLines = drawTree(g, head, 15, 0 ); } else { treeHeightLines = drawTree(g, this.d, 15, 0); } }
catch( Exception e ) { treeHeightLines = 0; g.setColor(Color.black); g.drawString(e.toString(),10,15); }
if (inside != null && pressed == null) { drawAttributes(g, inside, ax, ay); }
} else { treeHeightLines = viewDoc#ql:xmlv'tv'viewdoc#(g); }
if( sizeChange#ql:xmlv'tv'fields sizeChange# ) { if ( getDisplayHeightLines#ql:xmlv'bc'getdisplayheightlines#() != treeHeightLines + 1 ) { displayHeight = YPOS(treeHeightLines + 1); } if( displayWidth != maxWidth ) { displayWidth = maxWidth; } sizeChange = false; postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); } }

public int xmlv'tv'viewDoc(Graphics g)
//
{ int y = 1;
try { InputStream i = fileName#ql:xmlv'tv'fields fileName#.openStream#ql::2nfoJAPI11.NFO:class.url#(); int rc = 0; byte b[] = new byte[4096]; while ( rc >= 0 )
{ rc = i.read(b); if( rc > 0 ) { String s = new String(b); int texth = drawText#ql:xmlv'tv'drawtext#(g, s, 10, y, size().width, false, rc, false, false ); Rectangle textRect = new Rectangle( 10, YPOS(y), size().width, YPOS(texth) ); Rectangle onScreen = g.getClipRect(); if( textRect.intersects( onScreen ) ) {y = drawText( g, s, 10, y, getCanvasWidth(), false, rc, false, true ); } else y = texth; b = new byte[4096]; }
} }
catch (IOException e) { }
return y; }

public void xmlv'tv'drawTreeLines( Graphics g, int y, boolean hasChildren, boolean hidden, boolean isHead )
//
{ if( isHead )
{ if( hasChildren ) { g.drawLine(headX + 20 + 5, YPOS(y) + (fm.getMaxAscent()/2), headX + 20 + 9, YPOS(y) + (fm.getMaxAscent()/2));
// Line coming out of folder
if(!hidden) g.drawLine(headX + 20 + LEVELINDENT+INDENT, YPOS(y) + 12, headX + 20 + LEVELINDENT+INDENT, YPOS(y) + (LINE_SIZE)); } return;
}
for ( int i = 0; i < currLines-1; i++ ) { if( treeLines[i] >= 0 ) g.drawLine(treeLines[i],YPOS(y), treeLines[i],YPOS(y)+(LINE_SIZE)); }

if( currLines != 0 )
{ boolean lastChild = false; int x = treeLines[currLines-1]; if( x < 0 ) { x *= -1; lastChild = true; }
if( !hasChildren ) { if( !lastChild ) g.drawLine(x, YPOS(y), x, YPOS(y) + (LINE_SIZE)); else g.drawLine(x, YPOS(y), x, YPOS(y) + (fm.getMaxAscent()/2)); g.drawLine(x, YPOS(y) + (fm.getMaxAscent()/2), x + 15, YPOS(y) + (fm.getMaxAscent()/2)); }
else { // Need to avoid click box
g.drawLine(x, YPOS(y), x, YPOS(y) + 1 ); if( !lastChild ) g.drawLine(x, YPOS(y) + 1 + RECT_SIZE, x, YPOS(y) + (LINE_SIZE)); g.drawLine(x + 5, YPOS(y) + (fm.getMaxAscent()/2), x + 9, YPOS(y) + (fm.getMaxAscent()/2));
// Line coming out of folder
if( !hidden ) g.drawLine(x + LEVELINDENT+INDENT, YPOS(y) + 12, x + LEVELINDENT+INDENT, YPOS(y) + (LINE_SIZE)); }
} int b = 10000; }

public void xmlv'tv'drawTextLines( Graphics g, int y, int height )
{ for( int i = 0; i < currLines-1; i++ ) { if( treeLines[i] >= 0 ) g.drawLine(treeLines[i],YPOS(y), treeLines[i],YPOS(y)+YPOS(height+1)); }

if( currLines != 0 ) { boolean lastChild = false; int x = treeLines[currLines-1]; if( x < 0 ) { x *= -1; lastChild = true; } if( !lastChild ) g.drawLine(x, YPOS(y), x, YPOS(y) + YPOS(height+1)); else g.drawLine(x, YPOS(y), x, YPOS(y) + (fm.getMaxAscent()/2)); g.drawLine(x, YPOS(y) + (fm.getMaxAscent()/2), x + 4, YPOS(y) + (fm.getMaxAscent()/2)); } }

public void xmlv'tv'drawElement( Graphics g, Element child, int x, int y )
//+ draws one element?
{ int width = fm.stringWidth( child.getTagName().toString() );
String pressed = (String)child.getAttribute( kPressed );
String inside = (String)child.getAttribute( kInside );
String focus = (String)child.getAttribute( kFocus ); String hidden = (String)child.getAttribute( kHidden );
if (inside != null && inside.equals("TRUE")) g.setColor(Color.blue);
// Only set new color for INSIDE
boolean hasChildren = (child.numElements#ql:msxml'ei'numElements#() > 0);
if (hasChildren) { g.drawRect( x+1,YPOS(y)+1,RECT_SIZE,RECT_SIZE ); if (pressed != null && pressed ==inside) {g.drawRect(x+2,YPOS(y)+2,RECT_SIZE-2,RECT_SIZE-2);} } else { g.drawOval(x+20,YPOS(y),OVAL_SIZE,OVAL_SIZE); }

if( focus != null ) {
if( hasFocus ) { g.setColor( Color.blue ); g.fillRect( x+(OVAL_SIZE+FOLDER_SIZE+(INDENT*2))-SPACING, YPOS(y)-SPACING, width+(SPACING*2), fm.getMaxAscent()+(SPACING*2) ); g.setColor( Color.white ); g.drawString(child.getTagName().toString(), x+OVAL_SIZE+FOLDER_SIZE+(INDENT*2),YPOS(y)+fm.getMaxAscent()); g.setColor( Color.black ); }
else { g.drawRect( x+(OVAL_SIZE+FOLDER_SIZE+(INDENT*2))-SPACING, YPOS(y)-SPACING, width+(SPACING*2), fm.getMaxAscent()+(SPACING*2) ); g.drawString(child.getTagName().toString(), x+OVAL_SIZE+FOLDER_SIZE+(INDENT*2),YPOS(y)+fm.getMaxAscent()); } }
else g.drawString(child.getTagName().toString(), x+OVAL_SIZE+FOLDER_SIZE+(INDENT*2),YPOS(y)+fm.getMaxAscent());

if (child.numAttributes() > 0 && child == this.inside && pressed == null) { ax = x + 15 + 10; ay = y + 2; }

if( hasChildren ) {
if( hidden != null && hidden.equals("TRUE") ) { g.drawLine(x+5,YPOS(y)+3,x+5,YPOS(y)+7); g.drawLine(x+3,YPOS(y)+5,x+7,YPOS(y)+5); g.drawImage(closedFolder, x+OVAL_SIZE+INDENT, YPOS(y)-SPACING, this); }
else { g.drawLine(x+3,YPOS(y)+5,x+7,YPOS(y)+5); g.drawImage(openFolder, x+OVAL_SIZE+INDENT, YPOS(y)-SPACING, this);} }

if (inside != null && inside.equals("TRUE")) g.setColor(Color.black);
// Set color back to black after INSIDE
drawTreeLines#ql:xmlv'tv'drawtreelines#(g,y,hasChildren, (hidden != null && hidden.equals("TRUE")), (child == head)); }

public int xmlv'tv'drawTree(Graphics g, Element e, int x, int y)
// draws the tree downward
{if( stopDraw#ql:xmlv'tv'fields stopDraw# ||#ql:jv'operator.conditional'or# e == null ) return y;
if( isElement#ql:xmlv'tv'isElement#(e))
{ boolean eHasChildren = (e.numElements() > 0);
Rectangle onScreen = g.getClipRect(); int width = fm.stringWidth(e.getTagName().toString())+OVAL_SIZE+FOLDER_SIZE+(INDENT*2); if( width + x > maxWidth ) maxWidth = width + x; Rectangle elDraw = new Rectangle( x,YPOS(y), width, LINE_SIZE );
if( elDraw.intersects( onScreen ) ) { // We need to draw!
doneDraw = true; drawElement#ql:xmlv'tv'drawelement#( g, e, x, y ); } else
if( doneDraw && !sizeChange ) { stopDraw = true; return y; }
if( eHasChildren && e.getAttribute(kHidden) == null )
{ // Turn lines on
treeLines[currLines]=x+20; int tmpLines=currLines; currLines++; //Recurse down the tree
//+this draws all the childrens.
for( Enumeration en = new SpecialEnumeration#ql:xmlv'se'specialenumeration#(e); en.hasMoreElements(); )
{ Element child = (Element)en.nextElement();
if( !en.hasMoreElements() ) // Negative number implies this is last child.
treeLines[tmpLines] *= -1; y = drawTree(g,child,x+LEVELINDENT+INDENT,y+1 ); if( stopDraw ) return y;
} // Turn lines off completely

currLines--;}
} else if (e.getText() != null)
{ String sHeight = (String)e.getAttribute( kHeight ); int height; if( sHeight == null || sizeChange) { // measure only
height = drawText(g, e.getText(),x+LEVELINDENT, y, getCanvasWidth() - x - 20, true, 0, false, false) - y; e.setAttribute(kHeight, Integer.toString(height)); } else { height = Integer.valueOf(sHeight).intValue(); } Rectangle onScreen = g.getClipRect(); // We add one to height because text lines reach down below the text.
Rectangle elDraw = new Rectangle( x,YPOS(y), getCanvasWidth() - x - 20, YPOS(height+1) ); if( elDraw.intersects( onScreen ) )
{ Color c = Color.black; switch (e.getType()) {
case Element.PI: c = Color.magenta; break;
case Element.ENTITY: c = Color.green; c.darker(); break;
case Element.CDATA: c = Color.gray; break;
case Element.PCDATA: c = Color.black; break;
case Element.COMMENT: c = Color.red; break; }
g.setColor(c); // draw the text
int y2 = drawText(g, e.getText(),x+10, y, getCanvasWidth() - x - 20, true, 0, false, true); e.setAttribute(kHeight, Integer.toString(y2-y)); // Draw the tree lines
g.setColor(Color.black); drawTextLines(g,y,(y2-y)); y = y2;
} else { // measure only
int y2 = drawText(g, e.getText(), x+10, y, getCanvasWidth() - x - 20, true, 0, false, false); e.setAttribute(kHeight, Integer.toString(y2-y)); y = y2; }
} return y; }

public void xmlv'tv'drawAttributes(Graphics g, Element e, int x, int y)
//
{ int na = e.numAttributes(); String names = new String(); String values = new String(); int height = 0; int col1 = 0; int col2 = 0;
if (na > 0) { boolean first = true; for (Enumeration ena = e.getAttributes(); ena.hasMoreElements(); ) { Attribute a = (Attribute)ena.nextElement(); if( a.getName() != null && a.getName().toString().length() > 0 && a.getName().toString().charAt(0) != '_' ) { int w = fm.stringWidth(a.getName().toString()); if (w > col1) col1 = w; String value = a.getValue().toString(); w = fm.stringWidth(value); if (w > col2) col2 = w; // The attribute height will never change, so we just need to find it once. String sHeight = (String)e.getAttribute( kHeight ); int tHeight; if( sHeight == null ) { tHeight = (drawText(g,value,x,(y+height)+1,col2+3,true,0,true, false) - (y+height)); e.setAttribute(kHeight, Integer.toString(tHeight)); } else { tHeight = Integer.valueOf(sHeight).intValue(); } height += tHeight; names += a.getName() + "\n"; values += value + "\n"; } } }
if( y+height+1 > getVertLines() + getCanvasHeightLines() ) { y = y - height - 3; // Put the attribute above the Element rather then below } if (height > 0) { g.setColor(Color.yellow); int w = 3+col1+6+col2+3; int h = 3+YPOS(height)+3; g.fillRect(x,YPOS(y-1)+fm.getMaxAscent(),w,h); g.setColor(Color.black); g.drawRect(x,YPOS(y-1)+fm.getMaxAscent(),w,h); int x2 = x+3+col1+3; g.drawLine(x2,YPOS(y-1)+fm.getMaxAscent(),x2,YPOS(y-1)+fm.getMaxAscent()+h); x += 3; drawText(g, names, x, y, col1 + 3, true, 0, true, true); x += col1+6; drawText(g, values, x, y, col2 + 3, true, 0, true, true); } }

public int xmlv'tv'drawText(Graphics g, String text, int x, int y, int max, boolean skipWhiteSpace, int l, boolean attribute, boolean draw)

{ if( text == null || text.length() == 0 ) return y;
if (max < 5) // make sure we have room to draw text. return y; int i = 0; int len; int w = 0;
if( l == 0 ) len = text.length(); else len = l; // skip leading white space. while (i < len && skipWhiteSpace && isWhiteSpace(text.charAt(i))) i++; int j = i; int k = i; while (i < len) { char ch = text.charAt(i); int cw = fm.charWidth(ch); w += cw; if (w > max || ch == '\n') { if( ch == '\n' && text.charAt(i-1) == 0x0D ) j = i-1; else if (attribute || k == j) j = i; if (draw) { String sub = text.substring(k,j); g.drawString(sub,x,YPOS(y)+fm.getMaxAscent()); } y++; // skip white space. if( ch == '\n' && text.charAt(i-1) == 0x0D ) j = i+1; while (skipWhiteSpace && j < len && isWhiteSpace(text.charAt(j))) j++; i = j; k = j; w = 0; } else { if (skipWhiteSpace && isWhiteSpace(ch)) { j = i; } i++; } } if (draw) { String remaining = text.substring(k); g.drawString(remaining,x,YPOS(y)+fm.getMaxAscent()); } return y; }

public boolean xmlv'tv'isWhiteSpace(char ch)
{ return Character#ql::2nfoJAPI11.NFO:class.character#.isSpace(ch) || ch == 13; }//depr Replaced by isWhitespace(char).

public boolean xmlv'tv'isElement(Element e)
{ return e.getType#ql:msxml'ei'getType#() == Element.ELEMENT; }

public int xmlv'tv'findElementAt( Element e, int x, int y, int x1, int y1 )
//+
{ if ( isElement(e) )
{boolean eHasChildren = (e.numElements() > 0); Rectangle r = new Rectangle( x1,YPOS(y1),OVAL_SIZE,OVAL_SIZE ); int width = FOLDER_SIZE + INDENT + fm.stringWidth( e.getTagName().toString() ); Rectangle r2 = new Rectangle( x1+OVAL_SIZE+INDENT,YPOS(y1)-SPACING, width, fm.getMaxAscent()+(SPACING*2)); if( r.inside(x,y) ) // inside the check box { boxClick = true; found = e; return y1; } if( r2.inside(x,y) ) // inside the tag { boxClick = false; found = e; return y1; }
if( eHasChildren && e.getAttribute(kHidden) == null ) { // Recurse down tree
for( Enumeration en = new SpecialEnumeration(e); en.hasMoreElements(); ) { Element child = ( Element )en.nextElement(); int y2 = findElementAt( child,x,y,x1+LEVELINDENT+INDENT,y1+1 ); if ( found != null ) return y2; y1 = y2; } } } else { String s = (String)e.getAttribute(kHeight); if (s != null) y1 += Integer.valueOf(s).intValue(); } return y1; }

public int xmlv'tv'findElementAtLine( Element e, int line, int x1, int y1 )
{ if( line == y1 ) { if ( isElement(e) ) { found = e; return y1; } else { found = prevVisibleElement( e ); Element temp = found; found = null; return findElement(head, temp, 15 + headX, headY); } } if( isElement(e) ) { if( e.numElements() > 0 && e.getAttribute(kHidden) == null ) { for( Enumeration en = new SpecialEnumeration(e); en.hasMoreElements(); ) { Element child = ( Element )en.nextElement(); int y2 = findElementAtLine( child,line,x1+LEVELINDENT+INDENT,y1+1 ); if ( found != null ) return y2; y1 = y2; } } } else { String s = (String)e.getAttribute(kHeight); if (s != null) y1 += Integer.valueOf(s).intValue(); }
return y1; }

public int xmlv'tv'findElement( Element e, Element find, int x1, int y1 )

{if ( isElement(e) )
{ if( e == find ) { found = e; foundX#ql:xmlv'tv'fields foundx# = x1; foundY = y1; return y1; }
if( e.numElements() > 0 && e.getAttribute(kHidden) == null )
{// Recurse down the tree
for( Enumeration en = new SpecialEnumeration(e); en.hasMoreElements(); ) { Element child = ( Element )en.nextElement(); int y2 = findElement( child,find, x1+LEVELINDENT+INDENT,y1+1 ); if ( found != null ) return y2; y1 = y2; }
} }
else {String s = (String)e.getAttribute(kHeight); if (s != null) y1 += Integer.valueOf(s).intValue(); }
return y1; }

public boolean xmlv'tv'mouseMove(Event evt, int x, int y)
//+ focus event
{if( viewText ) return false;
if( x == prevX#ql:xmlv'tv'fields prevX# && y == prevY ) return false; prevX = x; prevY = y;
found = null; x += (getHorz#ql:xmlv'bc'gethorz#() - (BUFFER#ql:xmlv'bc'fields BUFFER#*2)); y += (getVert() - (BUFFER*2)); findElementAt#ql:xmlv'tv'findElementAt#( head#ql:xmlv'tv'fields head#,x,y,15 + headX, headY ); if( found != inside#ql:xmlv'tv'fields inside# && inside != null ) { inside.removeAttribute( kInside ); inside = null; invalidateBuffer(); repaint(); } if( found != null ) { found.setAttribute( kInside,"TRUE" ); inside = found;
invalidateBuffer(); repaint(); } return true; }

public boolean xmlv'tv'mouseDrag( Event evt, int x, int y )
//+
{ if( viewText ) return false;
found = null; x += (getHorz() - (BUFFER*2)); y += (getVert() - (BUFFER*2)); findElementAt( head,x,y,15 + headX, headY ); if( found != inside && inside != null ) { // inside should be redrawNew inside.removeAttribute(kInside); inside = null;
invalidateBuffer(); repaint(); } if( found != null && found == pressed ) { found.setAttribute( kInside,"TRUE" ); inside = found;
invalidateBuffer(); repaint(); } return true; }

public boolean xmlv'tv'mouseDown(Event evt, int x, int y)
{if( viewText ) return false;
found = null; boxClick = false; x += (getHorz() - (BUFFER*2)); y += (getVert() - (BUFFER*2)); int foundY; foundY = findElementAt( head,x,y,15 + headX, headY ); if( found != null ) { hasFocus = true;
if( focus != null ) // We need to remove the previous focus { focus.removeAttribute( kFocus ); focus = null; } if (inside != null) { inside.removeAttribute(kInside); inside = null; }
//+ double click
if( evt.clickCount > 1 )
{ setViewChoice( found ); repaint(); return true; }
if( boxClick ) { found.setAttribute( kPressed,"TRUE" ); sizeChange = true; pressed = found; }
found.setAttribute( kFocus,"TRUE" ); inside = found; found.setAttribute( kInside,"TRUE" ); focus = found; focusY = foundY; invalidateBuffer(); repaint(); } else if( hasFocus && focus != null ) { hasFocus = false; invalidateBuffer(); repaint(); } return true; }

public boolean xmlv'tv'mouseUp(Event evt, int x, int y)
//+ collapse/expand tree
{if( viewText ) return false;
found = null; boxClick = false; x += (getHorz() - (BUFFER*2)); y += (getVert() - (BUFFER*2)); findElementAt( head,x,y,15 + headX, headY ); if( found == pressed && boxClick == true )

//+ when kHidden=true => we can collapse the tree.
{ if( pressed.getAttribute(kHidden#ql:xmlv'tv'fields kHidden#) != null ) { pressed.removeAttribute( kHidden ); } else { pressed.setAttribute#ql:msxml'ei'setattribute#( kHidden, "TRUE" ); } sizeChange = true; invalidateBuffer(); repaint(); }
if( pressed != null ) { pressed.removeAttribute( kPressed ); pressed.removeAttribute( kInside ); pressed = null; inside = null;
invalidateBuffer(); repaint(); } return true; }

public Element xmlv'tv'lastVisibleChild( Element parent )

{boolean hasChildren = ( parent.numElements() > 0 ); if( !hasChildren || parent.getAttribute( kHidden ) != null ) return parent; Enumeration en = new SpecialEnumeration(parent); Element child; Element lastElement = null; while( en.hasMoreElements() ) { child = ( Element )en.nextElement(); if( isElement(child)) lastElement = child; }
if( lastElement == null ) return parent; else return lastVisibleChild( lastElement ); }

public Element xmlv'tv'prevVisibleElement( Element current )
{ Element parent = current.getParent(); if( parent == null ) return null; Element curr = null; Element lastElement = null; Enumeration en = new SpecialEnumeration(parent); while( en.hasMoreElements() ) { curr = ( Element )en.nextElement(); if( curr == current ) { if( lastElement == null ) return parent; else { return lastVisibleChild( lastElement ); } } if( isElement(curr) ) lastElement = curr; }
// Something went wrong... return null; }

public Element xmlv'tv'nextVisibleElement( Element current, Element original )
{ boolean seenOriginal = ( original == current ); boolean hasChildren = ( current.numElements() > 0 ); String hidden = (String)current.getAttribute( kHidden );
if( hasChildren && ( hidden == null ) ) { Enumeration en = new SpecialEnumeration(current); while( en.hasMoreElements() ) { Element child = ( Element )en.nextElement(); if( seenOriginal ) { if( isElement(child) ) { return child; } } if( child == original ) seenOriginal = true; } } Element parent = current.getParent(); if( parent == null ) return null; else return nextVisibleElement( parent, current ); }

public boolean xmlv'tv'keyDown( Event evt, int key )
{if( viewText ) return false;
switch( key )
{case Event.UP: {if( focus == head ) return true;
Element newFocus = prevVisibleElement( focus ); if( newFocus != null && newFocus != this.d ) { focus.removeAttribute( kFocus ); focus = newFocus; // We need to reset position
found = null; focusY = findElement( head, focus, 15 + headX, headY ); if( focusY < getVertLines() ) { setTopLine( focusY ); } else if( focusY >= getVertLines() + getCanvasHeightLines() ) { setBottomLine( focusY ); }
focus.setAttribute( kFocus, "TRUE" ); hasFocus = true; // We need to set a new inside
if( inside != null ) inside.removeAttribute( kInside ); inside = focus; inside.setAttribute( kInside, "TRUE" );
postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); invalidateBuffer(); repaint(); } } return true;

case Event.PGUP: { if( focus == head ) return true; focus.removeAttribute( kFocus ); found = null; int tempY = findElementAtLine( head, getVertLines(), 15 + headX, headY ); if( focus == found ) { found = null; tempY = findElementAtLine( head, getVertLines() - getCanvasHeightLines(), 15 + headX, headY ); } if( found != null && tempY > headY ) { if( tempY >= getVertLines() + getCanvasHeightLines() ) { setBottomLine( tempY ); } else if( tempY < getVertLines() ) { setTopLine( tempY ); } focus = found; focusY = tempY; } else // go to top of the list { focus = head; // This will return first vis. focusY = headY; setTopLine( focusY ); } focus.setAttribute( kFocus, "TRUE" ); hasFocus = true;
// We need to set a new inside if( inside != null ) inside.removeAttribute( kInside ); inside = focus; inside.setAttribute( kInside, "TRUE" );
invalidateBuffer(); repaint(); postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); } return true;

case Event.DOWN: { if( focus == lastVisibleChild( head ) ) return true;
Element newFocus = nextVisibleElement( focus, focus ); if( newFocus != null ) { focus.removeAttribute( kFocus ); focus = newFocus;
// We need to reset position found = null; focusY = findElement( head, focus, 15 + headX, headY ); if( focusY >= getVertLines() + getCanvasHeightLines() ) { setBottomLine( focusY ); } else if( focusY < getVertLines() ) { setTopLine( focusY ); }
focus.setAttribute( kFocus, "TRUE" ); hasFocus = true;
// We need to set a new inside if( inside != null ) inside.removeAttribute( kInside ); inside = focus; inside.setAttribute( kInside, "TRUE" );
postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); invalidateBuffer(); repaint(); } } return true;

case Event.PGDN: { Element last = lastVisibleChild(head); if( focus == last ) return true; found = null; int lastY = findElement( head, last, 15 + headX, headY );
focus.removeAttribute( kFocus ); found = null; int tmpY = findElementAtLine( head, getVertLines()+getCanvasHeightLines()-1, 15 + headX, headY ); if( focus == found ) { found = null; tmpY = findElementAtLine( head, getVertLines()+2*getCanvasHeightLines(), 15 + headX, headY ); } if( found != null && tmpY < lastY ) { if( tmpY >= getVertLines() + getCanvasHeightLines() ) { setBottomLine( tmpY ); } else if( tmpY < getVertLines() ) { setTopLine( tmpY ); } focus = found; focusY = tmpY; } else // Just go to bottom of visible list { focus = last; focusY = lastY; setBottomLine( focusY ); } focus.setAttribute( kFocus, "TRUE" ); hasFocus = true;
// We need to set a new inside if( inside != null ) inside.removeAttribute( kInside ); inside = focus; inside.setAttribute( kInside, "TRUE" );
invalidateBuffer(); repaint(); postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); } return true;

case '\n': setViewChoice#ql:xmlv'tv'setviewchoice#( focus ); repaint(); return true;

case Event.RIGHT: { boolean hasChildren = ( focus.numElements() > 0 ); if( hasChildren ) { if (focus.getAttribute( kHidden ) != null) { keyDown( null, ' ' ); } keyDown( null, Event.DOWN ); } } return true;

// expand/collapse tree with spacebar
case ' ': { boolean hasChildren = ( focus#ql:xmlv'tv'fields focus#.numElements() > 0 ); if(hasChildren) {if (focus.getAttribute#ql:msxml'ei'getattribute#( kHidden#ql:xmlv'tv'fields kHidden# ) == null ) { focus.setAttribute( kHidden, "TRUE" ); } else {focus.removeAttribute( kHidden ); } sizeChange = true; postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); invalidateBuffer(); repaint(); } } return true;

case Event.LEFT: { // Otherwise do the standard left movement Element parent = focus.getParent(); if( parent == null ) return true; if( focus == head ) { parent = head.getParent(); if( parent == null || parent == this.d ) return true; setViewChoice( parent ); repaint();
// We need to set a new inside if( inside != null ) inside.removeAttribute( kInside ); inside = focus; inside.setAttribute( kInside, "TRUE" ); hasFocus = true; return true; } focus.removeAttribute( kFocus ); focus = parent; focus.setAttribute( kFocus, "TRUE" ); hasFocus = true;
// We need to reset position found = null; focusY = findElement( head, focus, 15 + headX, headY ); if( focusY < getVertLines() ) { setTopLine( focusY ); sizeChange = true; postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); } else if( focusY >= getVertLines() + getCanvasHeightLines() ) { setBottomLine( focusY ); sizeChange = true; postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); }
// We need to set a new inside if( inside != null ) inside.removeAttribute( kInside ); inside = focus; inside.setAttribute( kInside, "TRUE" );
invalidateBuffer(); repaint(); } return true;

case Event.HOME: { // Give head of list focus.
if( focus == head ) return true;
focus.removeAttribute( kFocus );
focus = head; focusY = headY; setTopLine( focusY ); focus.setAttribute( kFocus, "TRUE" ); hasFocus = true;
// We need to set a new inside if( inside != null ) inside.removeAttribute( kInside ); inside = focus; inside.setAttribute( kInside, "TRUE" );
invalidateBuffer(); repaint(); postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); } return true;

case Event.END: { // Give last item in list focus
Element last = lastVisibleChild(head); if( focus == last ) return true; found = null; int lastY = findElement( head, last, 15 + headX, headY );
focus.removeAttribute( kFocus );
focus = last; focusY = lastY; setBottomLine( focusY ); focus.setAttribute( kFocus, "TRUE" ); hasFocus = true;
// We need to set a new inside if( inside != null ) inside.removeAttribute( kInside ); inside = focus; inside.setAttribute( kInside, "TRUE" );
invalidateBuffer(); repaint(); postEvent(new Event(null, DISPLAY_SIZE_CHANGE, null)); } return true; } return false; }

public boolean xmlv'tv'action(Event evt, Object what)
// choice action
{ if( evt.id == Event.ACTION_EVENT ) {String s = (String)evt.arg;
if (evt.target == choice )
{ choice.select#ql:jv'choice'select#( s ); int pos = choice.getSelectedIndex#ql:jv'choice'getselectedindex#(); Element newHead = head;
for( int i = choice.countItems(); i > pos+1; i-- ) {if( newHead != null ) // This shouldn't ever be the case... but to be safe.
newHead = newHead.getParent(); }
if( newHead != head && newHead != null ) {setViewChoice#ql:xmlv'tv'setViewChoice#( newHead ); repaint();}
} } return false; }

public boolean xmlv'tv'handleEvent( Event evt )
//replaced by processEvent(AWTEvent).
{ switch( evt.id ) {
case Event#ql::2nfoJAPI11.NFO:class.event#.LOST_FOCUS: { if (inside != null) { inside.removeAttribute( kInside ); inside = null; } hasFocus = false; invalidateBuffer#ql:xmlv'bc'invalidatebuffer#(); repaint(); } break;
case Event.GOT_FOCUS: { hasFocus = true; invalidateBuffer(); repaint(); } break; }
return super#ql::2nfoJAPI11.NFO:class.canvas#.handleEvent( evt ); }

FvMcs.SPHINX4

_CREATED: {2006-12-19}

name::
* McsEngl.conceptItsoft1210,
* McsEngl.sphinx4@cptItsoft1210,

sphinx'DEFINITION

Sphinx-4 is a state-of-the-art speech recognition system written entirely in the JavaTM programming language. It was created via a joint collaboration between the Sphinx group at Carnegie Mellon University, Sun Microsystems Laboratories, Mitsubishi Electric Research Labs (MERL), and Hewlett Packard (HP), with contributions from the University of California at Santa Cruz (UCSC) and the Massachusetts Institute of Technology (MIT).

Sphinx-4 started out as a port of Sphinx-3 to the Java programming language, but evolved into a recognizer designed to be much more flexible than Sphinx-3, thus becoming an excellent platform for speech research.
[project page]

sphinx'GENERIC

_GENERIC:
* SPEECH-RECOGNIZER#cptIt540.1#
* Sphinx-4 is an HMM-based speech recognizer.

sphinx'WHOLE

_WHOLE:
* SPEECH-RECOGNITION-FIELD#cptIt540#

sphinx'APPLICATION

name::
* McsEngl.sphinx'APPLICATION@cptItsoft,

sphinx'app.HelloWorld

name::
* McsEngl.sphinx'app.HelloWorld@cptItsoft,
* McsEngl.sphinx'hw@cptItsoft,

_ALGORITHM:
* url = HelloWorld.class.getResource("helloworld.config.xml");
* ConfigurationManager#ql:sphinx'cm# cm = new ConfigurationManager(url);
* uses a SaxLoader#ql:sphinx'saxloader'class# for this url and creates:
- a RawPropertyData for each component, in which adds its properties.
- returns a Map (compName, compRawPropertyData)
- Passes-Through the globalProperties for processing.
* Recognizer#ql:sphinx'recognizer# recognizer = (Recognizer) cm.lookup("recognizer");
* Microphone microphone = (Microphone) cm.lookup("microphone");
* recognizer.allocate();
checkState(RecognizerState.DEALLOCATED);
setState(RecognizerState.ALLOCATING);
decoder.allocate();
searchManager.allocate();
linguist.allocate();
pruner.allocate();
scorer.allocate();
setState(RecognizerState.ALLOCATED);
setState(RecognizerState.READY);

* recognizer.recognize();
result = decoder.decode(referenceText);
searchManager.startRecognition();
linguist.startRecognition();
pruner.startRecognition();
scorer.startRecognition();
localStart();
Result result;
do {
result#ql:sphinx'result'class# = searchManager.recognize(featureBlockSize);
result = new Result(activeList#ql:sphinx'partitionactivelist'class#, resultList,
currentFrameNumber, done, logMath);
if (result != null) {
result.setReferenceText(referenceText);
fireResultListeners(result);
}
} while (result != null && !result.isFinal());
searchManager.stopRecognition();
return result;

ORDER OF COMPONENT CREATION:
Creating: recognizer: Recognizer
Creating: decoder: Decoder
Creating: searchManager#ql:sphinx'searchmanager#: SimpleBreadthFirstSearchManager#ql:sphinx'SimpleBreadthFirstSearchManager#:
Creating: logMath: LogMath
Creating: flatLinguist#ql:sphinx'flatlinguist#: FlatLinguist
Creating: (ac-model#ql:sphinx'acousticmodel#) wsj: Model
Creating: wsjLoader: ModelLoader
Creating: unitManager#ql:sphinx'unitmanager#: UnitManager
Creating: jsgfGrammar#ql:sphinx'grammar#: JSGFGrammar
Creating: dictionary: FastDictionary,
Creating: trivialPruner: SimplePruner
Creating: threadedScorer: ThreadedAcousticScorer

Creating: epFrontEnd: FrontEnd#ql:sphinx'frontend#:
Creating: microphone: Microphone
Creating: speechClassifier: SpeechClassifier
Creating: speechMarker: SpeechMarker
Creating: nonSpeechDataFilter: NonSpeechDataFilter
Creating: premphasizer: Preemphasizer
Creating: windower: RaisedCosineWindower
Creating: fft: DiscreteFourierTransform
Creating: melFilterBank: MelFrequencyFilterBank
Creating: dct: DiscreteCosineTransform
Creating: liveCMN: LiveCMN
Creating: featureExtraction: DeltasFeatureExtractor

Creating: activeList#ql:sphinx'activelist#: PartitionActiveListFactory
Creating: accuracyTracker: AccuracyTracker
Creating: speedTracker: SpeedTracker
Creating: memoryTracker: MemoryTracker

sphinx'BUILD

name::
* McsEngl.sphinx'BUILD@cptItsoft,

FUNCTION:

sphinx'decoder'PACKAGE

name::
* McsEngl.sphinx'decoder'PACKAGE@cptItsoft,
* McsEngl.edu.cmu.shpinx.decoder@cptItsoft,

DEFINETRO:
Package#ql:sphinx'package# edu.cmu.sphinx.decoder
Provides a set of high level classes that can be used to configure and initiate the speech recognition decoding process.

PART-PACKAGES:
edu.cmu.sphinx.decoder.pruner Provides an interface that represents the pruning facility

edu.cmu.sphinx.decoder.scorer Provides an interface that represents entities that can be scored, and an interface and several implementations of a scorer that can score these entities.

edu.cmu.sphinx.decoder.search#ql:sphinx'search# Provides classes and interfaces that are used to manage the search through the search graph.

Class Summary
BatchResults Provides summary results for a batch run of the decoder
Decoder The primary decoder class

sphinx'Decoder'CLASS

name::
* McsEngl.sphinx'Decoder'CLASS@cptItsoft,
* McsEngl.sphinx'Decoder@cptItsoft,

DEFINETRO:
public class edu.cmu.shpinx.decoder.Decoder
extends java.lang.Object
implements Configurable

The primary decoder class.

FUNCTION:
* The Decoder merely tells the SearchManager to recognize a set of Feature#ql:sphinx'feature# frames.
...
The primary role of the Sphinx-4 Decoder block is to use Features#ql:sphinx'feature# from the FrontEnd in conjunction with the SearchGraph#ql:sphinx'searchgraph# from the Linguist to generate Result hypotheses.
[whitepaper]

* The decoder will construct the search manager, which in turn constructs the scorer, the pruner, and the active list.
[project page]

_WHOLE:
* Recognizer#ql:sphinx'Recognizer#

sphinx'decoder.PRUNER'PACKAGE

name::
* McsEngl.sphinx'decoder.PRUNER'PACKAGE@cptItsoft,
* McsEngl.sphinx'pruner'package@cptItsoft,

_DEFINITION:
Package edu.cmu.sphinx.decoder.pruner
Provides an interface that represents the pruning facility

FUNCTION:
As you can see from the above graph, a lot of the nodes have self transitions. This can lead to a very large number of possible paths through the graph. As a result, finding the best possible path can take a very long time. The purpose of the pruner is to reduce the number of possible paths during the search, using heuristics like pruning away the lowest scoring paths.
[project page]

Interface Summary
Pruner Provides a mechanism for pruning a set of StateTokens

Class Summary
NullPruner A Null pruner.
SimplePruner Performs the default pruning behavior which is to invoke the purge on the active list

sphinx'decoder.SCORER'PACKAGE

name::
* McsEngl.sphinx'decoder.SCORER'PACKAGE@cptItsoft,
* McsEngl.sphinx'scorer@cptItsoft,

_DEFINITION:
Package edu.cmu.sphinx.decoder.scorer
Provides an interface that represents entities that can be scored, and an interface and several implementations of a scorer that can score these entities.
[javadoc 10b]

Interface Summary
AcousticScorer Provides a mechanism for scoring a set of HMM states
Scoreable Represents an entity that can be scored against a data

Class Summary
SimpleAcousticScorer A Simple acoustic scorer.
ThreadedAcousticScorer An acoustic scorer that breaks the scoring up into a configurable number of separate threads.

sphinx'AcousticScorer'INTERFACE

name::
* McsEngl.sphinx'AcousticScorer'INTERFACE@cptItsoft,
* McsEngl.sphinx'acousticscorer@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.decoder.scorer.AcousticScorer
extends Configurable

Provides a mechanism for scoring a set of HMM states

SPESIFEPTO:
All Known Implementing Classes:
ParallelAcousticScorer, SimpleAcousticScorer, ThreadedAcousticScorer

sphinx'Scoreable'INTERFACE

name::
* McsEngl.sphinx'Scoreable'INTERFACE@cptItsoft,
* McsEngl.sphinx'scoreable@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.decoder.scorer.Scoreable

Represents an entity that can be scored against a data

Method Summary
float calculateScore(Data#ql:sphinx'data# data, boolean keepData, float gain)
Calculates a score against the given data.
int getFrameNumber()
Returns the frame number that this Scoreable should be scored against.
float getScore()
Retrieves a previously calculated (and possibly normalized) score
float normalizeScore(float maxScore)
Normalizes a previously calculated score

SPESIFEPTO:
All Known Implementing Classes:
Token

sphinx'decoder.SEARCH'PACKAGE

name::
* McsEngl.sphinx'decoder.SEARCH'PACKAGE@cptItsoft,
* McsEngl.sphinx'search'package@cptItsoft,

_DEFINETRO:
Package edu.cmu.sphinx.decoder.search
Provides classes and interfaces that are used to manage the search through the search-graph#ql:sphinx'searchgraph#.
[javadoc 10b]

Interface Summary:
ActiveList#ql:sphinx'active'list# An active list is maintained as a sorted list Note that all scores are represented in LogMath logbase
ActiveListFactory Creates new active lists.
ActiveListManager An active list is maintained as a sorted list
SearchManager#ql:sphinx'searchmanager# Defines the interface for the SearchManager.
TokenStack A stack of tokens at a SentenceHMMState, allowing more than one path through the state.

Class Summary:
AlternateHypothesisManager Created by IntelliJ IDEA.
ArrayTokenStack An array implementation of TokenStack.
PartitionActiveListFactory A factory for PartitionActiveLists
Partitioner Partitions a list of tokens according to the token score.
SimpleActiveListFactory A factory for simple active lists
SimpleActiveListManager A list of ActiveLists.
SimpleBreadthFirstSearchManager Provides the breadth first search.
SortingActiveListFactory
Token#ql:sphinx'token# Represents a single state in the recognition trellis.
WordActiveListFactory A factory for WordActiveList.
WordPruningBreadthFirstSearchManager Provides the breadth first search.

sphinx'ActiveList'INTERFACE

name::
* McsEngl.sphinx'ActiveList'INTERFACE@cptItsoft,
* McsEngl.sphinx'ActiveList@cptItsoft,
* McsEngl.sphinx'Active'List@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.decoder.search.ActiveList

An active list is maintained as a sorted list Note that all scores are represented in LogMath logbase

A list of tokens#ql:sphinx'token# representing all the states in the search graph that are active in the current feature frame.
[javadoc 10b]

FUNCTION:
The active list is a component that requires explanation. Remember we mentioned that there can be many possible paths through the search-graph#ql:sphinx'searchgraph#. Sphinx-4 currently implements a token-passing algorithm. Each time the search arrives at the next state in the graph, a token#ql:sphinx'token# is created. A token points to the previous token, as well as the next state. The active list keeps track of all the current active paths through the search graph by storing the last token of each path. A token has the score of the path at that particular point in the search. To perform pruning, we simply prune the tokens in the active list.

_WHOLE:
* SearchManager#ql:sphinx'SearchManager#

_SPESIFEPTO:
* PartitionActiveList#ql:sphinx'partitionactivelist'class#

sphinx'ActiveListFactory'INTERFACE

name::
* McsEngl.sphinx'ActiveListFactory'INTERFACE@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.decoder.search.ActiveListFactory
extends Configurable#ql:sphinx'configurable#

Creates new active lists.

Field Summary
static java.lang.String PROP_ABSOLUTE_BEAM_WIDTH
property that sets the desired (or target) size for this active list.
static int PROP_ABSOLUTE_BEAM_WIDTH_DEFAULT
The default value for the PROP_ABSOLUTE_BEAM_WIDTH property
static java.lang.String PROP_RELATIVE_BEAM_WIDTH
Property that sets the minimum score relative to the maximum score in the list for pruning.
static double PROP_RELATIVE_BEAM_WIDTH_DEFAULT
The default value for the PROP_RELATIVE_BEAM_WIDTH property
static java.lang.String PROP_STRICT_PRUNING
Property that indicates whether or not the active list will implement 'strict pruning'.
static boolean PROP_STRICT_PRUNING_DEFAULT
The default for the PROP_STRICT_PRUNING property

Method Summary
ActiveList newInstance()
Creates a new active list of a particular type

Methods inherited from interface edu.cmu.sphinx.util.props.Configurable
getName, newProperties, register

SPESIFEPTO:
All Known Implementing Classes:
PartitionActiveListFactory#ql:sphinx'PartitionActiveListFactory*#, SimpleActiveListFactory, SortingActiveListFactory, WordActiveListFactory,

sphinx'SearchManager'INTERFACE

name::
* McsEngl.sphinx'SearchManager'INTERFACE@cptItsoft,
* McsEngl.sphinx'SearchManager@cptItsoft,
* McsEngl.sphinx'Search'Manager@cptItsoft,

_DEFINETRO:
public interface#ql:jv'interface# edu.cmu.sphinx.decoder.search.SearchManager
extends Configurable
Defines the interface for the SearchManager. The SearchManager's primary role is to execute the search for a given number of frames. The SearchManager will return interim results as the recognition proceeds and when recognition completes a final result will be returned.
[javadoc 10b]

_FUNCTION:
* The SearchManager in the Decoder uses the Features#ql:sphinx'feature# from the FrontEnd and the SearchGraph#ql:sphinx'search'graph# from the Linguist to perform the actual decoding, generating Results.
[whitepaper]
* Once this graph is constructed, the sequence of parametrized speech signals (i.e., the features) is matched against different paths through the graph to find the best fit. The best fit is usually the least cost or highest scoring path, depending on the implementation. In Sphinx-4, the task of searching through the graph for the best path is done by the search manager.
[project page]

_IMPLEMENTATION:
Each SearchManager implementation uses a token passing algorithm as described by Young [24].
[24] S. J. Young, N. H. Russell, and J. H. S. Russell, “Token passing: A simple conceptual model for connected speech recognition systems,” Cambridge University Engineering Dept, UK, Tech. Rep. CUED/F-INFENG/TR38, 1989.
[whitepaper]

_WHOLE:
* Decoder#ql:sphinx'Decoder#

Method Summary
void allocate()
Allocates the resources necessary for this search.
void deallocate()
Deallocates resources necessary for this search.
Result recognize(int nFrames)
Performs recognition.
void startRecognition()
Prepares the SearchManager for recognition.
void stopRecognition()
Performs post-recognition cleanup.

_SPESIFEPTO:
All Known Implementing Classes:
ParallelSearchManager, SimpleBreadthFirstSearchManager, WordPruningBreadthFirstSearchManager

sphinx'PartitionActiveList'CLASS

name::
* McsEngl.sphinx'PartitionActiveList'CLASS@cptItsoft,

DEFINETRO:
* INNER CLASS in PartitionActiveListFactory
class PartitionActiveList implements ActiveList#ql:sphinx'activelist#

_FIELD:
private int size = 0;
private int absoluteBeamWidth;
private float logRelativeBeamWidth;
private Token bestToken;
// when the list is changed these things should be changed/updated as well
private Token[] tokenList;
private Partitioner partitioner = new Partitioner();

sphinx'PartitionActiveListFactory'CLASS

name::
* McsEngl.sphinx'PartitionActiveListFactory'CLASS@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.decoder.search.PartitionActiveListFactory
extends java.lang.Object
implements ActiveListFactory

A factory for PartitionActiveLists

sphinx'Token'CLASS

name::
* McsEngl.sphinx'Token'CLASS@cptItsoft,
* McsEngl.sphinx'token@cptItsoft,

_DEFINITION:
public class edu.cmu.sphinx.decoder.search.Token
extends java.lang.Object
implements Scoreable#ql:sphinx'scorable#

Represents a single state in the recognition trellis. Subclasses of a token are used to represent the various emitting state. All scores are maintained in LogMath log base
[javadoc 10b]

Each SearchManager-implementation#ql:sphinx'search'manager# uses a token passing algorithm as described by Young [24]. A Sphinx-4 token is an object that is associated with a SearchState and contains
- the overall acoustic and language scores of the path at a given point,
- a reference to the SearchState,
- a reference to an input Feature frame, and
- other relevant information.
The SearchState reference allows the SearchManager to relate a token to its state output distribution, context-dependent phonetic unit, pronunciation, word, and grammar state. Every partial hypothesis terminates in an active token.
[whitepaper]

_FIELD:

* searchState: UnitSearchState, WordSearchState, HMMSearchState#ql:sphinx'HMMSearchState#,
* location: of this Token in the ActiveList#ql:sphinx'activelist#.
* appObject: the feature (Data#ql:sphinx'data#) for this Token.

Method Summary
float calculateScore(Data feature, boolean keepData, float gain)
Calculates a score against the given feature.
Token child(SearchState state, float logTotalScore, float logLanguageScore, float logInsertionProbability, int frameNumber)
Constructs a new token that continues the search from the current token.
void dumpTokenPath()
dumps a branch of tokens
void dumpTokenPath(boolean includeHMMStates)
dumps a branch of tokens
float getAcousticScore()
Returns the acoustic score for this token (in logMath log base)
java.lang.Object getAppObject()
Returns the application object
Data getData()
Returns the feature for this Token.
int getFrameNumber()
Returns the frame number for this token.
float getInsertionProbability()
Returns the insertionPenalty associated with this token
float getLanguageScore()
Returns the language score associated with this token
int getLocation()
Returns the location of this Token in the ActiveList.
Token getPredecessor()
Returns the predecessor for this token, or null if this token has no predecessors
float getScore()
Returns the score for the token.
SearchState getSearchState()
Returns the SearchState associated with this token
Word getWord()
Returns the word of this Token, the search state is a WordSearchState.
java.lang.String getWordPath()
Returns the string of words for this token, with embedded silences
java.lang.String getWordPath(boolean wantFiller)
Returns the string of words leading up to this token.
java.lang.String getWordPathNoFiller()
Returns the string of words for this token, with no embedded filler words
java.lang.String getWordUnitPath()
Returns the string of words and units for this token, with embedded silences.
float getWorkingScore()
Gets the working score.
boolean isEmitting()
Determines if this token is associated with an emitting state.
boolean isFinal()
Determines if this token is associated with a final SentenceHMM state.
boolean isWord()
Determines if this token marks the end of a word
float normalizeScore(float maxLogScore)
Normalizes a previously calculated score
void setAppObject(java.lang.Object obj)
Sets the application object
void setLocation(int location)
Sets the location of this Token in the ActiveList.
static void setPredecessorClass(java.util.Set bpClasses)
Set the predecessor class.
void setScore(float logScore)
Sets the score for this token
void setWorkingScore(float logScore)
Sets the working score for this token
static void showCount()
Shows the token count
java.lang.String toString()
Retrieves the string representation of this object
boolean validate()
Determines if this branch is valid

sphinx'SimpleBreadthFirstSearchManager'CLASS

name::
* McsEngl.sphinx'SimpleBreadthFirstSearchManager'CLASS@cptItsoft,
* McsEngl.sphinx'SimpleBreadthFirstSearchManager@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.decoder.search.SimpleBreadthFirstSearchManager
extends java.lang.Object
implements SearchManager

Provides the breadth first search. To perform recognition an application should call initialize before recognition begins, and repeatedly call recognize until Result.isFinal() returns true. Once a final result has been obtained, terminate should be called. All scores and probabilities are maintained in the log math log domain.

sphinx'FRONTEND'PACKAGE

name::
* McsEngl.sphinx'FRONTEND'PACKAGE@cptItsoft,
* McsEngl.sphinx'FRONTEND'PACKAGE@cptItsoft,

_DEFINETRO:
Package#ql:sphinx'package# edu.cmu.sphinx.frontend
Provides a set of high level classes and interfaces that are used to perform digital signal processing for speech recognition.

PART-PACKAGES:
edu.cmu.sphinx.frontend.endpoint Provides classes and interfaces used for speech endpointing.

edu.cmu.sphinx.frontend.feature Provides classes that processes features.

edu.cmu.sphinx.frontend.filter Provides classes that implement frequency filters

edu.cmu.sphinx.frontend.frequencywarp Provides classes that perform frequency warping.

edu.cmu.sphinx.frontend.transform Provides classes that transform data from one domain into another.

edu.cmu.sphinx.frontend.util Provides classes that are generally useful to the various frontend classes.

edu.cmu.sphinx.frontend.window Provides classes that implement windowing functions

Interface Summary
Data#ql:sphinx'data# Implements the interface for all Data objects that passes between DataProcessors.
DataProcessor#ql:sphinx'dataprocessor# A processor that performs a signal processing function.
SignalListener The listener interface for being informed when a Signal is generated.

Class Summary
BaseDataProcessor#ql:sphinx'basedataprocessor# An abstract DataProcessor implementing elements common to all concrete DataProcessors, such as name, predecessor, and timer.
DataEndSignal A signal that indicates the end of data.
DataStartSignal A signal that indicates the start of data.
DoubleData A Data object that holds data of primitive type double.
FloatData A Data object that holds data of primitive type float.
FrontEnd#ql:sphinx'front'end# FrontEnd is a wrapper class for the chain of front end processors.
Signal#ql:sphinx'signal# Indicates events like beginning or end of data, data dropped, quality changed, etc..

Exception Summary
DataProcessingException Thrown to indicate that a DataProcessor has problems processing incoming Data objects.

sphinx'Data'INTERFACE

name::
* McsEngl.sphinx'Data'INTERFACE@cptItsoft,
* McsEngl.sphinx'Data@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.frontend.Data

Implements the interface for all Data objects that passes between DataProcessors. Subclass of Data can contain the actual data, or be a signal (e.g., data start, data end, speech start, speech end).

_SPESIFEPTO:
All Known Implementing Classes:
DoubleData, FloatData, Signal#ql:sphinx'signal#,
SpeechClassifiedData,

sphinx'DataProcessor'INTERFACE

name::
* McsEngl.sphinx'DataProcessor'INTERFACE@cptItsoft,
* McsEngl.sphinx'DataProcessor@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.frontend.DataProcessor
extends Configurable#ql:sphinx'configurable#

A processor that performs a signal processing function. Since a DataProcessor usually belongs to a particular front end pipeline, you can name the pipeline it belongs to in the initialize method. (Note, however, that it is not always the case that a DataProcessor belongs to a particular pipeline. For example, the Microphoneclass is a DataProcessor, but it usually does not belong to any particular pipeline.

Method Summary
Data getData()
Returns the processed Data output.
java.lang.String getName()
Returns the name of this DataProcessor.
DataProcessor getPredecessor()
Returns the predecessor DataProcessor.
void initialize()
Initializes this DataProcessor.
void setPredecessor(DataProcessor predecessor)
Sets the predecessor DataProcessor.

Methods inherited from interface edu.cmu.sphinx.util.props.Configurable
newProperties, register

sphinx'BaseDataProcessor'CLASS

name::
* McsEngl.sphinx'BaseDataProcessor'CLASS@cptItsoft,
* McsEngl.sphinx'BaseDataProcessor@cptItsoft,

DEFINETRO:
public abstract class edu.cmu.sphinx.frontend.BaseDataProcessor
extends java.lang.Object
implements DataProcessor#ql:sphinx'dataprocessor#

An abstract DataProcessor implementing elements common to all concrete DataProcessors, such as name, predecessor, and timer.

_GENERIC:
* All Implemented Interfaces:
Configurable, DataProcessor

_SPESIFEPTO:
* Direct Known Subclasses:
BatchCMN, DataDumper, DeltasFeatureExtractor, DiscreteCosineTransform, DiscreteFourierTransform, FrameDropper,
- FrontEnd, LiveCMN, MelFrequencyFilterBank, Microphone, NonSpeechDataFilter, PLPCepstrumProducer, PLPFrequencyFilterBank, Preemphasizer, RaisedCosineWindower, S3FeatureExtractor, SpeechClassifier, SpeechMarker, StreamCepstrumSource, StreamDataSource,

sphinx'FrontEnd'CLASS

name::
* McsEngl.sphinx'FrontEnd'CLASS@cptItsoft,
* McsEngl.sphinx'FrontEnd@cptItsoft,
* McsEngl.sphinx'Front'End@cptItsoft,

_DEFINETRO:
public class edu.cmu.sphinx.frontend.FrontEnd
extends BaseDataProcessor#ql:sphinx'BaseDataProcessor#

FrontEnd is a wrapper class for the chain of front end processors. It provides methods for manipulating and navigating the processors.

_FUNCTION:
* The FrontEnd takes one or more input signals and parameterizes them into a sequence of Features#ql:sphinx'feature#.
[whitepaper]
* During speech recognition, features are derived from the incoming speech (we will use "speech" to mean the same thing as "audio") in the same way as in the training process. The component of the recognizer that generates these features is called the front end. These live features are scored against the acoustic model. The score obtained indicates how likely that a particular set of features (extracted from live audio) belongs to the phoneme of the corresponding acoustic model.
[project page]

sphinx'Signal'CLASS

name::
* McsEngl.sphinx'Signal'CLASS@cptItsoft,
* McsEngl.sphinx'Signal@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.frontend.Signal
extends java.lang.Object
implements Data#ql:sphinx'data#

Indicates events like beginning or end of data, data dropped, quality changed, etc.. It implements the Data interface, and it will pass between DataProcessors to inform them about the Data that is passed between DataProcessors.

Method Summary
long getTime()
Returns the time this Signal was created.

SPESIFEPTO:
Direct Known Subclasses:
DataEndSignal, DataStartSignal, SpeechEndSignal, SpeechStartSignal

sphinx'frontend.endpoint'PACKAGE

name::
* McsEngl.sphinx'frontend.endpoint'PACKAGE@cptItsoft,
* McsEngl.sphinx'@cptItsoft,

Class Summary
NonSpeechDataFilter Given a sequence of Data, filters out the non-speech regions.
SpeechClassifier Implements a level tracking endpointer invented by Bent Schmidt Nielsen.
SpeechEndSignal A signal that indicates the end of speech.
SpeechMarker Converts a stream of SpeechClassifiedData objects, marked as speech and non-speech, and mark out the regions that are considered speech.
SpeechStartSignal A signal that indicates the start of speech.

sphinx'frontend.feature'PACKAGE

name::
* McsEngl.sphinx'frontend.feature'PACKAGE@cptItsoft,
* McsEngl.sphinx'feature@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.frontend.feature
Provides classes that processes features. Examples include batch mode cepstral mean normalization, and the computation of delta and double delta of features.

Class Summary
BatchCMN Applies cepstral mean normalization (CMN), sometimes called channel mean normalization, to incoming cepstral data.
DeltasFeatureExtractor Computes the delta and double delta of input cepstrum (or plp or ...).
FrameDropper Drops certain feature frames, usually to speed up decoding.
LiveCMN Subtracts the mean of all the input so far from the Data objects.
S3FeatureExtractor Computes the delta and double delta of input cepstrum (or plp or ...).

_SPESIFEPTO:
* sphinx'CEPSTRUM: The features that SphinxTrain generate are called cepstrum. Cepstrum are usually 13-dimensional. The features that Sphinx-4 generates are more than cepstrum. It is 39-dimensional, and consists of the cepstrum, the delta of the cepstrum, and the double delta of the cepstrum (thus 3X the size).
[FAQ]

sphinx'frontend.filter'PACKAGE

name::
* McsEngl.sphinx'frontend.filter'PACKAGE@cptItsoft,
* McsEngl.sphinx'filter@cptItsoft,

_DEFINETRO:
Package edu.cmu.sphinx.frontend.filter
Provides classes that implement frequency filters

Class Summary
Preemphasizer Implements a high-pass filter that compensates for attenuation in the audio data.

sphinx'frontend.frequencywarp'PACKAGE

name::
* McsEngl.sphinx'frontend.frequencywarp'PACKAGE@cptItsoft,
* McsEngl.sphinx'frequencywarp@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.frontend.frequencywarp
Provides classes that perform frequency warping.

Class Summary
FrequencyWarper Defines the Bark frequency warping function.
LinearPredictor Computes the linear predictive model using the Levinson-Durbin algorithm.
MelFilter Defines a triangular mel-filter.
MelFrequencyFilterBank Filters an input power spectrum through a bank of number of mel-filters.
PLPCepstrumProducer Computes the PLP cepstrum from a given PLP Spectrum.
PLPFilter Defines a filter used by the PLPFrequencyFilterBank class.
PLPFrequencyFilterBank Filters an input power spectrum through a PLP filterbank.

sphinx'frontend.transform'PACKAGE

name::
* McsEngl.sphinx'frontend.transform'PACKAGE@cptItsoft,
* McsEngl.sphinx'transform@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.frontend.transform
Provides classes that transform data from one domain into another. For example, the discrete fourier transform transform data from the time domain to the frequency domain.

sphinx'frontend.util'PACKAGE

name::
* McsEngl.sphinx'frontend.util'PACKAGE@cptItsoft,
* McsEngl.sphinx'util'frontend@cptItsoft,

Class Summary
ConcatFileDataSource Concatenates a list of audio files as one continuous audio stream.
DataDumper Dumps the data
DataUtil Defines utility methods for manipulating data values.
EnergyPlotter Plots positive energy values of a cepstrum to stdout.
Microphone A Microphone captures audio data from the system's underlying audio input systems.
StreamCepstrumSource Produces Mel-cepstrum data from an InputStream.
StreamDataSource A StreamDataSource converts data from an InputStream into Data objects.
Utterance Represents the complete audio data of an utterance.

sphinx'Microphone'CLASS

name::
* McsEngl.sphinx'Microphone'CLASS@cptItsoft,

DEFINETRO:
public class Microphone extends BaseDataProcessor#ql:sphinx'basedataprocessor#

sphinx'frontend.window'PACKAGE

name::
* McsEngl.sphinx'frontend.window'PACKAGE@cptItsoft,
* McsEngl.sphinx'window@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.frontend.window
Provides classes that implement windowing functions

Class Summary
RaisedCosineWindower Slices up a Data object into a number of overlapping windows (usually refered to as "frames" in the speech world).

sphinx'FEATURE

name::
* McsEngl.sphinx'FEATURE@cptItsoft,

* The features that SphinxTrain generate are called cepstrum. Cepstrum are usually 13-dimensional. The features that Sphinx-4 generates are more than cepstrum. It is 39-dimensional, and consists of the cepstrum, the delta of the cepstrum, and the double delta of the cepstrum (thus 3X the size).
[faq]
* The last DataProcessor in each chain is responsible for producing a Data object composed of parameterized signals, called Features, to be used by the Decoder.
[whitepaper]

sphinx'SPEAKER'IDENTIFICATION

name::
* McsEngl.sphinx'SPEAKER'IDENTIFICATION@cptItsoft,

Does Sphinx-4 support speaker identification?

Sphinx-4 currently does not support speaker identification, which is the process of identifying who is speaking. However, the architecture of Sphinx-4 is flexible enough for someone to add such capabilities. To learn more about speaker identification: http://www.speech.cs.cmu.edu/comp.speech/Section6/Q6.6.html

Speaker recognition is the process of automatically recognizing who is speaking on the basis of individual information included in speech signals. It can be divided into Speaker Identification and Speaker Verification. Speaker identification determines which registered speaker provides a given utterance from amongst a set of known speakers. Speaker verification accepts or rejects the identity claim of a speaker - is the speaker the person they say they are?

Speaker recognition technology makes it possible to a the speaker's voice to control access to restricted services, for example, phone access to banking, database services, shopping or voice mail, and access to secure equipment.

Both technologies require users to "enroll" in the system, that is, to give examples of their speech to a system so that it can characterise (or learn) their voice patterns.

sphinx'FUNCTION

name::
* McsEngl.sphinx'FUNCTION@cptItsoft,

_INPUT:
- audio data.
- input speech data.
- input signals.
- utterance.

_PROCESS:
1) The FrontEnd#ql:sphinx'frontend# takes one or more input signals and parameterizes them into a sequence of Features#ql:sphinx'feature#.

2) The linguist#ql:sphinx'linguist# will construct the acoustic-model#ql:sphinx'acousticmodel#, the dictionary#ql:sphinx'dictionary#, and the language-model#ql:sphinx'languagemodel#. It will use the knowledge from these three components to construct a search-graph#ql:sphinx'searchgraph# that is appropriate for the task.

3) The primary role of the Sphinx-4 Decoder#ql:sphinx'decoder# block is to use Features#ql:sphinx'feature# from the FrontEnd in conjunction with the SearchGraph#ql:sphinx'searchgraph# from the Linguist to generate Result-hypotheses#ql:sphinx'result'class#.
[whitepaper]

When the application asks the recognizer to perform recognition, the search-manager#ql:sphinx'search'manager# will ask the scorer to score each token in the active-list#ql:sphinx'active'list# against the next feature vector obtained from the front end. This gives a new score for each of the active paths. The pruner will then prune the tokens (i.e., active paths) using certain heuristics. Each surviving paths will then be expanded to the next states, where a new token will be created for each next state.
The process repeats itself until no more feature vectors can be obtained from the front end for scoring. This usually means that there is no more input speech data.
At that point, we look at all paths that have reached the final exit state, and return the highest scoring path as the result to the application.
[project page]

When the recognizer starts up, it constructs
1) the front end (which generates features from speech),
2) the decoder, and
3) the linguist (which generates the search graph) according to the configuration specified by the user. These components will in turn construct their own subcomponents.
[project page]

_OUTPUT:
The primary role of the Sphinx-4 Decoder#ql:sphinx'decoder# block is to use Features#ql:sphinx'feature# from the FrontEnd in conjunction with the SearchGraph#ql:sphinx'searchgraph# from the Linguist to generate Result-hypotheses#ql:sphinx'result#.
[whitepaper]

sphinx'INSTALATION

name::
* McsEngl.sphinx'INSTALATION@cptItsoft,

sphinx'instrumentation'PACKAGE

name::
* McsEngl.sphinx'instrumentation'PACKAGE@cptItsoft,

sphinx'jsapi'PACKAGE

name::
* McsEngl.sphinx'jsapi'PACKAGE@cptItsoft,

DEFINETRO:
Provides support for the Java Speech API for Sphinx-4

Class Summary
JSGFGrammar Defines a BNF-style grammar based on JSGF grammar rules in a file.
SphinxEngineCentral Provides a list of SphinxRecognizerModeDesc objects that define the available operating modes of the sphinx recognition engine.
SphinxRecognizer A SphinxRecognizer provides access to Sphinx speech recognition capabilities.
SphinxRecognizerModeDesc Provides information about a specific operationg mode of a sphinx recognition engine.

sphinx'linguist'PACKAGE

name::
* McsEngl.sphinx'linguist'PACKAGE@cptItsoft,

_DEFINETRO:
Package#ql:sphinx'package# edu.cmu.sphinx.linguist
Provides a set of interfaces and classes that are used to define the search-graph#ql:sphinx'searchgraph# used by the decoder. Implementations of the Linguist interface are used by the decoder to create the search graph. The search graph is a directed graph formed by SearchState and SearchStateArc objects. Some implementations of the Linguist may build the search graph based upon a Grammar, which represents a graph of words and probabilities. This package provides a number of different implementations of Grammar

FUNCTION:
* The Linguist translates any type of standard language-model#ql:sphinx'language'model#, along with pronunciation information from the Dictionary#ql:sphinx'dictionary# and structural information from one or more sets of AcousticModels#ql:sphinx'acoustic'model#, into a SearchGraph#ql:sphinx'search'graph#.
[whitepaper]
* the linguist will construct the acoustic model, the dictionary, and the language model. It will use the knowledge from these three components to construct a search graph that is appropriate for the task.
[project page]

Description:
Provides a set of interfaces and classes that are used to define the search graph used by the decoder. Implementations of the Linguist interface are used by the decoder to create the search graph. The search graph is a directed graph formed by SearchState and SearchStateArc objects. Some implementations of the Linguist may build the search graph based upon a Grammar, which represents a graph of words and probabilities. This package provides a number of different implementations of Grammar
[javadoc 10b]

PART-PACKAGES:
edu.cmu.sphinx.linguist.acoustic Provides classes that represent the acoustic model.

edu.cmu.sphinx.linguist.acoustic.tiedstate Provides classes that represent acoustic model in terms of a set of tied states.

edu.cmu.sphinx.linguist.acoustic.trivial Provides classes that represent a trivial acoustic model.

edu.cmu.sphinx.linguist.dflat

edu.cmu.sphinx.linguist.dictionary Provides a generic interface to a dictionary as well as several implementations.

edu.cmu.sphinx.linguist.flat Provides an implementation of the Linguist that statically represents the search space as a flat graph, where each word in the vocabulary has its own branch.

edu.cmu.sphinx.linguist.language.grammar Provides classes and interfaces that can be used to represent a graph of words and word transitions.

edu.cmu.sphinx.linguist.language.ngram Provides classes and interfaces that represent a stochastic language model

edu.cmu.sphinx.linguist.language.ngram.large Provides an implementation of the LanguageModel interface.

edu.cmu.sphinx.linguist.lextree Provides an implementation of the Linguist that represents the search space as a lex tree.

edu.cmu.sphinx.linguist.util Provides a set of classes that are useful by implementations of the Linguist interface.

Interface Summary
* HMMSearchState#ql:sphinx'HMMSearchState*# Represents a single hmm state in a language search space
Linguist#ql:sphinx'linguist# The linguist is responsible for representing and managing the search space for the decoder.
SearchGraph#ql:sphinx'searchgraph# Represents a search graph
SearchState#ql:sphinx'searchstate# Represents a single state in a language search space
SearchStateArc Represents a single state in a language search space
UnitSearchState Represents a unit state in a search space
WordSearchState Represents a single word state in a language search space

Class Summary
LinguistProcessor A standard interface for a linguist processor
WordSequence This class can be used to keep track of a word sequence.

sphinx'HMMSearchState'INTERFACE

name::
* McsEngl.sphinx'HMMSearchState'INTERFACE@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.linguist.HMMSearchState
extends SearchState#ql:sphinx'SearchState#

Represents a single hmm state in a language search space

Method Summary
HMMState#ql:sphinx'hmmstate'interface# getHMMState()
Gets the hmm state

sphinx'Linguist'INTERFACE

name::
* McsEngl.sphinx'Linguist'INTERFACE@cptItsoft,
* McsEngl.sphinx'Linguist@cptItsoft,

DEFINETRO:
public interface#ql:jv'interface# edu.cmu.sphinx.linguist.Linguist
extends Configurable

The linguist is responsible for representing and managing the search space for the decoder. The role of the linguist is to provide, upon request, the search graph that is to be used by the decoder. The linguist is a generic interface that provides language model services. The main role of any linguist is to represent the search space for the decoder.

PROPERTY:
<property name="logMath" value="logMath"/>
<property name="grammar" value="jsgfGrammar"/>
<property name="acousticModel" value="wsj"/>
<property name="wordInsertionProbability"
value="${wordInsertionProbability}"/>
<property name="languageWeight" value="${languageWeight}"/>
<property name="unitManager" value="unitManager"/>

All Known Implementing Classes:
DynamicFlatLinguist, FlatLinguist, LexTreeLinguist,

sphinx'SearchGraph'INTERFACE

name::
* McsEngl.sphinx'SearchGraph'INTERFACE@cptItsoft,
* McsEngl.sphinx'SearchGraph@cptItsoft,
* McsEngl.sphinx'Search'Graph@cptItsoft,
* McsEngl.sphinx'SearchSpace@cptItsoft,
* McsEngl.sphinx'SearchNode@cptItsoft,

_DEFINETRO:
public interface#ql:jv'interface# edu.cmu.sphinx.linguist.SearchGraph
Represents a search graph

* The SearchGraph is a directed graph composed of optionally emitting SearchStates#ql:sphinx'searchstate# and SearchStateArcs#ql:sphinx'searchstatearc# with transition probabilities. Each state in the graph can represent components from the LanguageModel (words in rectangles), Dictionary (sub-word units in dark circles) or AcousticModel (HMMs).
[whitepaper]

The process of speech recognition is to find the best possible sequence of words (or units) that will fit the given input speech. It is a search problem, and in the case of HMM-based recognizers, a graph search problem. The graph represents all possible sequences of phonemes in the entire language of the task under consideration. The graph is typically composed of the HMMs of sound units concatenated in a guided manner, as specified by the grammar of the task. As an example, lets look at a simple search graph that decodes the words "one" and "two". It is composed of the HMMs of the sounds units of the words "one" and "two":

Constructing the above graph requires knowledge from various sources. It requires a dictionary, which maps the word "one" to the phonemes W, AX and N, and the word "two" to T and OO. It requires the acoustic model to obtain the HMMs for the phonemes W, AX, N, T and OO. In Sphinx-4, the task of constructing this search graph is done by the linguist.

Method Summary:
SearchState getInitialState()
Retrieves initial search state
int getNumStateOrder()
Returns the number of different state types maintained in the search graph

_CREATION:
* the linguist will construct the acoustic-model#ql:sphinx'acousticmodel#, the dictionary#ql:sphinx'dictionary#, and the language-model#ql:sphinx'languagemodel#. It will use the knowledge from these three components to construct a search graph that is appropriate for the task.
[project page]

sphinx'SearchState'INTERFACE

name::
* McsEngl.sphinx'SearchState'INTERFACE@cptItsoft,
* McsEngl.sphinx'SearchState@cptItsoft,
* McsEngl.sphinx'Search'State@cptItsoft,

_DEFINETRO:
public interface edu.cmu.sphinx.linguist.SearchState
Represents a single state in a language search space.

* Each state in the graph can represent components from the LanguageModel (words in rectangles), Dictionary (sub-word units in dark circles) or AcousticModel (HMMs).

Method Summary
java.lang.Object getLexState()
Returns the lex tree state
int getOrder()
Returns the order of this particular state
java.lang.String getSignature()
Returns a unique signature for this state
SearchStateArc[] getSuccessors()
Gets a successor to this search state
WordSequence getWordHistory()
Gets the word history for this state
boolean isEmitting()
Determines if this is an emitting state
boolean isFinal()
Determines if this is a final state
java.lang.String toPrettyString()
Returns a pretty version of the string representation for this object

_SPESIFEPTO:
All Known Subinterfaces:
HMMSearchState, UnitSearchState, WordSearchState

All Known Implementing Classes:
HMMStateState, LexTreeLinguist.LexTreeEndUnitState, LexTreeLinguist.LexTreeEndWordState, LexTreeLinguist.LexTreeHMMState, edu.cmu.sphinx.linguist.lextree.LexTreeLinguist.LexTreeState, LexTreeLinguist.LexTreeUnitState, LexTreeLinguist.LexTreeWordState, PronunciationState, SentenceHMMState, UnitState,

sphinx'SearchStateArc'INTERFACE

name::
* McsEngl.sphinx'SearchStateArc'INTERFACE@cptItsoft,
* McsEngl.sphinx'SearchStateArc@cptItsoft,
* McsEngl.sphinx'Search'State'Arc@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.linguist.SearchStateArc

Method Summary
float getAcousticProbability()
Gets the language probability of entering this state
float getInsertionProbability()
Gets the insertion probability of entering this state
float getLanguageProbability()
Gets the language probability of entering this state
float getProbability()
Gets the composite probability of entering this state
SearchState getState()
Gets a successor to this search state

sphinx'linguist.ACOUSTIC'PACKAGE

name::
* McsEngl.sphinx'linguist.ACOUSTIC'PACKAGE@cptItsoft,
* McsEngl.sphinx'acoustic'package@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.linguist.acoustic

Provides classes that represent the acoustic model. The acoustic model is represented as a set of hidden markov models (HMMs) associated with a unit of speech.
[javadoc 10b]

Interface Summary
* AcousticModel#ql:sphinx'acousticmodel# Represents the generic interface to the Acoustic Model for sphinx4
* HMM#ql:sphinx'hmm'interface# Represents a hidden-markov-model.
* HMMState#ql:sphinx'HMMState*# Represents a single state in an HMM

Class Summary
Context Represents the context for a unit
HMMPosition Defines possible positions of HMMs.
HMMStateArc Represents a transition to single state in an HMM All probabilities are maintained in linear base
LeftRightContext Represents the context for a unit
Unit Represents a unit of speech.
UnitManager Manages the set of units for a recognizer

sphinx'AcousticModel'INTERFACE

name::
* McsEngl.sphinx'AcousticModel'INTERFACE@cptItsoft,
* McsEngl.sphinx'AcousticModel@cptItsoft,

_DEFINITION:
public interface edu.cmu.sphinx.linguist.acoustic.AcousticModel
Represents the generic interface to the Acoustic Model for sphinx4
[javadoc 10b]
* The AcousticModel module provides a mapping between a unit of speech and an HMM that can be scored against incoming features#ql:sphinx'feature# provided by the FrontEnd.
[whitepaper]

* Each acoustic model implements the AcousticModel interface. For example, the WSJ models are wrapped by a class called edu.cmu.sphinx.model.acoustic.WSJ_8gau_13dCep_16k_40mel_130Hz_6800Hz, which implements the AcousticModel interface. This implementation class is in the JAR file of the models, together with the actual data files of the model. This way, two simple steps are need to use a particular acoustic model:
1. Include the JAR file in your classpath.
2. Specify the model implementation class in the config file.
[project page]

_CREATION:
How can I train my own acoustic models?
Sphinx-4 loads Sphinx-3 acoustic models. These can be trained with the Sphinx-3 Trainer called SphinxTrain#ql:sphinx'sphinxtrain#.

acmd'ATTRIBUTE

name::
* McsEngl.acmd'ATTRIBUTE@cptItsoft,

Field Summary
static java.lang.String PROP_LOCATION
The directory where the acoustic model data can be found.
static java.lang.String PROP_LOCATION_DEFAULT
The default value of PROP_LOCATION.

Method Summary
void allocate()
Gets this acoustic model ready to use, allocating all necessary resources.
void deallocate()
Deallocates previously allcoated resources
java.util.Iterator getContextIndependentUnitIterator()
Returns an iterator that can be used to iterate through all the CI units in the acoustic model
java.util.Iterator getHMMIterator()
Returns an iterator that can be used to iterate through all the HMMs of the acoustic model
int getLeftContextSize()
Returns the size of the left context for context dependent units
java.lang.String getName()
Returns the name of this AcousticModel, or null if it has no name.
java.util.Properties getProperties()
Returns the properties of this acoustic model.
int getRightContextSize()
Returns the size of the right context for context dependent units
HMM lookupNearestHMM(Unit unit, HMMPosition position, boolean exactMatch)
Given a unit, returns the HMM that best matches the given unit.

acmd'DEFINITION'FILE

name::
* McsEngl.acmd'DEFINITION'FILE@cptItsoft,

_DESCRIPTION:
The model definition file in a way ties everything together.
If the recognition system models phonemes, there is an HMM for each phoneme. The model definition file has one line for each phoneme. The phoneme could be in a context dependent or independent.
Each line, therefore, identifies a unique HMM. This line has
- the phoneme identification,
- the non-required left or right context,
- the index of a transition matrix, and, for each state,
- the index of a mean vector, a variance vector, and a set of mixture weights.

#base lft rt p attrib tmat ... state id's ...
+AH+ - - - filler 0 0 1 2 N
+BREATH+ - - - filler 1 3 4 5 N
+CLICK+ - - - filler 2 6 7 8 N
+GRUNT+ - - - filler 3 9 10 11 N
+NOISE+ - - - filler 4 12 13 14 N
+RING+ - - - filler 5 15 16 17 N
+SLAM+ - - - filler 6 18 19 20 N
+SMACK+ - - - filler 7 21 22 23 N
+TONE+ - - - filler 8 24 25 26 N
AA - - - n/a 9 27 28 29 N
AE - - - n/a 10 30 31 32 N
AH - - - n/a 11 33 34 35 N
AO - - - n/a 12 36 37 38 N
AW - - - n/a 13 39 40 41 N

AA AA AA s n/a 9 153 185 226 N
AA AA AE s n/a 9 153 185 226 N
AA AA AH s n/a 9 153 185 226 N
AA AA AO s n/a 9 153 185 226 N
AA AA AW s n/a 9 153 185 226 N

acmd'SPESIFEPTO

name::
* McsEngl.acmd'SPESIFEPTO@cptItsoft,

_SPESIFEPTO:
* All Known Implementing Classes:
Model16, Model8, ModelTD, TiedStateAcousticModel, TrivialAcousticModel#ql:sphinx'trivialacousticmodel#,

* The two main acoustic models that are used by Sphinx-4,
- TIDIGITS and
- Wall Street Journal, are already included in the "lib" directory of the binary distribution. For the source distribution, you will build it when you type ant at the top level directory. Our regression tests also uses the
- RM1 and
- HUB4 models, which are available for download separately on the download page.
[project page]

sphinx'HMM'INTERFACE

name::
* McsEngl.sphinx'HMM'INTERFACE@cptItsoft,

DEFINETRO: sphinx'HMM,

_DEFINETRO:
public interface edu.cmu.sphinx.linguist.acoustic.HMM

Represents a hidden-markov-model. An HMM consists of
- a unit (context dependent or independent),
- a transition matrix from state to state, and
- a sequence of senones#ql:sphinx'senone# associated with each state.
This representation of an HMM is a specialized left-to-right markov model. No backward transitions are allowed.

_DESCRIPTION:
* HMM stands for Hidden Markov Models, which is a type of statistical model.

* An HMM models a process using a sequence of states. Associated with each state, there is a probability density function. A popular choice for this function is a Gaussian mixture, that is, a summation of Gaussians. As you may recall, a single Gaussian is defined by a mean and a variance, or, in the case of a multidimensional Gaussian, by a mean vector and a covariance matrix, or, under some simplifying assumptions, a variance vector.

The "means" and "variances" files in the "continuous" directory contain exactly this: a table in which each line contains a mean vector or a variance vector respectively. The dimension of these vectors is the same as the incoming data, the encoded speech signal. The Gaussian mixture is a summation of Gaussians, with different weights for different Gaussians.

The "mixture_weights" file contains this: each line contains the weights for a combination of Gaussians.

The HMM is a model with a set of states. The transitions between states have an associated probability. These probabilities make up the transition matrices stored in the "transition_matrices" file.

The files in the "continuous" directory are, therefore, tables, or pools, of means, variances, mixture weights, and transition probabilities.

_PART:
* Unit#ql:sphinx'unit#:
* HMMState#ql:sphinx'hmmstate'interface#:
* HMMPosition:

_SPESEFEPTO:
* SenoneHMM#ql:sphinx'senonehmm'class#:
* CompositeSenone
* GaussianMixture (simple)

sphinx'HMMState'INTERFACE

name::
* McsEngl.sphinx'HMMState'INTERFACE@cptItsoft,

DEFINETRO:
public interface HMMState

Represents a single state in an HMM.

_WHOLE:
* HMM:

_PART:
* successors: HMMStateArc[]

_SPESIFEPTO:
* SenoneHMMState:

* ExitState: a non Emmiting.

sphinx'HMMPosition'CLASS

name::
* McsEngl.sphinx'HMMPosition'CLASS@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.linguist.acoustic.HMMPosition
extends java.lang.Object
implements java.io.Serializable

Defines possible positions of HMMs. Note that even though the positions are defined to be within words, some recognizers may classify positions in terms of other elements besides words.

_WHOLE:
* HMM#ql:sphinx'hmm#

_PART:
* name: String. the representation for this position
* index: int. Each HMMPosition maintains a unique index.
* map: LinkedHashMap(name, index)

sphinx'Unit'CLASS

name::
* McsEngl.sphinx'Unit'CLASS@cptItsoft,
* McsEngl.sphinx'unit@cptItsoft,

_DEFINETRO:
public class edu.cmu.sphinx.linguist.acoustic.Unit
extends java.lang.Object

Represents a unit of speech. Units may represent phones, words or any other suitable unit

_WHOLE:
* HMM#ql:sphinx'hmm#

_PART:
* name: String.
* Context#ql:sphinx'conTEXT#:
* baseUnit: Unit.
* baseID: int

_SPESIFEPTO:
* sphinx'FILLER'UNIT: are non-speech sounds.
* sphinx'SILENCE'UNIT: the filler SIL.
* sphinx'CONTEXT'DEPENDENT'UNIT: if has context.

sphinx'UnitManager'CLASS

name::
* McsEngl.sphinx'UnitManager'CLASS@cptItsoft,
* McsEngl.sphinx'UnitManager@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.linguist.acoustic.UnitManager
extends java.lang.Object
implements Configurable

Manages the set of units for a recognizer

_WHOLE:
* Linguist#ql:sphinx'linguist#

sphinx'linguist.acoustic.TIEDSTATE'PACKAGE

name::
* McsEngl.sphinx'linguist.acoustic.TIEDSTATE'PACKAGE@cptItsoft,
* McsEngl.sphinx'tiedstate'package@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.linguist.acoustic.tiedstate

Provides classes that represent acoustic model in terms of a set of tied states. HMM states are represented by senones which in turn are represented by gaussian mixtures.

Interface Summary
Loader Generic interface for a loader of acoustic models
Saver Generic interface for a saver of acoustic models
* Senone#ql:sphinx'senone'interface# Represents a set of acoustic data that can be scored against a feature

Class Summary
* CompositeSenone#ql:sphinx'compositesenone'class# Represents a composite senone.
* GaussianMixture Represents a concrete implementation of a simple senone.
* sphinx'HMMManager Manages HMMs.
* sphinx'MixtureComponent Defines the set of shared elements for a GaussianMixture.
* sphinx'Pool Used to pool shared objects in the acoustic model
* sphinx'PropertiesDumper Dumps out information about an acoustic model.
* SenoneHMM#ql:sphinx'senonehmm'class# Represents a hidden-markov-model.
* SenoneHMMState Represents a single state in an HMM
* SenoneSequence#ql:sphinx'senonesequence'class# Contains an ordered list of senones.
* sphinx'Sphinx3Loader Loads a tied-state acoustic model generated by the Sphinx-3 trainer.
* sphinx'TiedStateAcousticModel Loads a tied-state acoustic model generated by the Sphinx-3 trainer.

sphinx'Senone'INTERFACE

name::
* McsEngl.sphinx'Senone'INTERFACE@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.linguist.acoustic.tiedstate.Senone
extends java.io.Serializable

Represents a set of acoustic data that can be scored against a feature.

* senones (tied gaussian mixtures).

_SPESIFEPTO:
* CompositeSenone Represents a composite senone.
* GaussianMixture#ql:sphinx'GaussianMixture*# Represents a concrete implementation of a simple senone.

sphinx'CompositeSenone'CLASS

name::
* McsEngl.sphinx'CompositeSenone'CLASS@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.linguist.acoustic.tiedstate.CompositeSenone
extends java.lang.Object
implements Senone, java.io.Serializable

Represents a composite senone. A composite senone consists of a set of all possible senones for a given state. CompositeSenones are used when the exact context of a senone is not known. The CompositeSenone represents all the possible senones.

This class currently only needs to be public for testing purposes.

Note that all scores are maintained in LogMath log base

_GENERIC:
* Senone#ql:sphinx'senone'interface#

sphinx'GaussianMixture'CLASS

name::
* McsEngl.sphinx'GaussianMixture'CLASS@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.linguist.acoustic.tiedstate.GaussianMixture
extends java.lang.Object
implements Senone

Represents a concrete implementation of a simple senone. A simple senone is a set of probability density functions implemented as a gaussian mixture.

All scores and weights are maintained in LogMath log base.

_GENERIC:
* Senone#ql:sphinx'senone'interface#.

_FIELD:
* MixtureComponent[]:

sphinx'SenoneHMM'CLASS

name::
* McsEngl.sphinx'SenoneHMM'CLASS@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.linguist.acoustic.tiedstate.SenoneHMM
extends java.lang.Object
implements HMM#ql:sphinx'hmm'interface#

Represents a hidden-markov-model. An HMM consists of a unit (context dependent or independent), a transition matrix from state to state, and a sequence of senones associated with each state. This representation of an HMM is a specialized left-to-right markov model. No backward transitions are allowed.

_PART:
* Unit:
* SenoneHMMState:
* SenoneSequence
* HMMPosition

_SPESIFEPTO:
* CompositeSenone
* GaussianMixture (simple)

sphinx'SenoneHMMState'CLASS

name::
* McsEngl.sphinx'SenoneHMMState'CLASS@cptItsoft,

_DEFINETRO:
public class edu.cmu.sphinx.linguist.acoustic.tiedstate.SenoneHMMState
extends java.lang.Object
implements HMMState

Represents a single state in an HMM

_GENERIC:
* HMMState:

_WHOLE:
* SenoneHMM#ql:sphinx'senonehmm'class#

_PART:
* Senone:
* archs (HMMStateArc[]): the state of successor states for this state
* state (int): the index for this particular state.

sphinx'SenoneSequence'CLASS

name::
* McsEngl.sphinx'SenoneSequence'CLASS@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.linguist.acoustic.tiedstate.SenoneSequence
extends java.lang.Object
implements java.io.Serializable

Contains an ordered list of senones.

sphinx'linguist.acoustic.TRIVIAL'PACKAGE

name::
* McsEngl.sphinx'linguist.acoustic.TRIVIAL'PACKAGE@cptItsoft,
* McsEngl.sphinx'trivial'package@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.linguist.acoustic.trivial
Provides classes that represent a trivial acoustic model. This acoustic model is used to demonstrate how to write one's own acoustic model.

Class Summary
TrivialAcousticModel Represents the generic interface to the Acoustic Model for sphinx4

sphinx'TrivialAcousticModel'CLASS

name::
* McsEngl.sphinx'TrivialAcousticModel'CLASS@cptItsoft,
* McsEngl.sphinx'trivialacousticmodel@cptItsoft,

_GENERIC:
* AcousticModel#ql:sphinx'acousticmodel#

sphinx'linguist.DFLAT'PACKAGE

name::
* McsEngl.sphinx'linguist.DFLAT'PACKAGE@cptItsoft,
* McsEngl.sphinx'dflat'package@cptItsoft,

Class Summary
DynamicFlatLinguist A simple form of the linguist.
OutOfGrammarGraph Builds a grammar sub-graph that matches all phones.

sphinx'linguist.DICTIONARY'PACKAGE

name::
* McsEngl.sphinx'linguist.DICTIONARY'PACKAGE@cptItsoft,
* McsEngl.sphinx'dictionary'package@cptItsoft,

_DEFINITION:
* Package edu.cmu.sphinx.linguist.dictionary
Provides a generic interface to a dictionary as well as several implementations. The dictionary provides a mechanism for determining the pronunciation of a word.
[javadoc 10b]
* The Dictionary provides pronunications for words found in the LanguageModel#ql:sphinx'languagemodel#. The pronunciations break words into sequences of sub-word units found in the AcousticModel#ql:sphinx'acousticmodel#. The Dictionary interface also supports the classification of words and allows for a single word to be in multiple classes.
Sphinx-4 currently provides implementions of the Dictionary interface to support the CMU Pronouncing Dictionary [23]. The various implementations optimize for usage patterns based on the size of the active vocabulary. For example, one implementation will load the entire vocabulary at system initialization time, whereas another implementation will only obtain pronunciations on demand.
[whitepaper]

Interface Summary
Dictionary Provides a generic interface to a dictionary.

Class Summary
FastDictionary Creates a dictionary by quickly reading in an ASCII-based Sphinx-3 format dictionary.
FullDictionary Creates a dictionary by reading in an ASCII-based Sphinx-3 format dictionary.
Pronunciation Provides pronunciation information for a word.
Word Represents a word, its spelling and its pronunciation.
WordClassification Provides a classification of words

_CREATION:
How can I create my own dictionary?

Sphinx-4 currently supports dictionaries in the CMU dictionary format. The CMU dictionary format is described in the FullDictionary javadocs.

Each line of the dictionary specifies the word, followed by spaces or tab, followed by the pronuncation (by way of the list of phones) of the word. Each word can have more than one pronunciations. For example, a digits dictionary will look like:
ONE HH W AH N
ONE(2) W AH N
TWO T UW
THREE TH R IY
FOUR F AO R
FIVE F AY V
SIX S IH K S
SEVEN S EH V AH N
EIGHT EY T
NINE N AY N
ZERO Z IH R OW
ZERO(2) Z IY R OW
OH OW

In the above example, the words "one" and "zero" have two pronunciations each.

Some more details on the format of the dictionary can be found at the CMU Pronouncing Dictionary page.

Note that the phones used to define the pronunciation for a word can be arbitrary strings. It is important however, that they match the units in the acoustic model. If you unpack an acoustic model you will find among the many files a file with the suffix ".mdef". This file contains a mapping of units to senones (tied gaussian mixtures). The first column in this file represent the unit names (phone) used by the acoustic model.

Your dictionary should use these units to define the pronunciation for a word.

sphinx'Word'CLASS

name::
* McsEngl.sphinx'Word'CLASS@cptItsoft,
* McsEngl.sphinx'Word@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.linguist.dictionary.Word
extends java.lang.Object

Represents a word, its spelling and its pronunciation.

Method Summary
Pronunciation getMostLikelyPronunciation()
Get the highest probability pronunciation for a word
Pronunciation[] getPronunciations()
Retrieves the pronunciations of this word
Pronunciation[] getPronunciations(WordClassification wordClassification)
Retrieves the pronunciations of this word
java.lang.String getSpelling()
Returns the spelling of the word.
boolean isFiller()
Determines if this is a filler word
boolean isSentenceEndWord()
Returns true if this word is an end of sentence word
boolean isSentenceStartWord()
Returns true if this word is a start of sentence word
java.lang.String toString()
Returns a string representation of this word, which is the spelling

sphinx'linguist.FLAT'PACKAGE

name::
* McsEngl.sphinx'linguist.FLAT'PACKAGE@cptItsoft,
* McsEngl.sphinx'flat'package@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.linguist.flat

Provides an implementation of the Linguist that statically represents the search space as a flat graph, where each word in the vocabulary has its own branch. This linguist is suitable for small and medium size vocabularies.

sphinx'FlatLinguist'CLASS

name::
* McsEngl.sphinx'FlatLinguist'CLASS@cptItsoft,
* McsEngl.sphinx'FlatLinguist@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.linguist.flat.FlatLinguist
extends java.lang.Object
implements Linguist, Configurable

A simple form of the linguist. The flat linguist takes a Grammar-graph#ql:sphinx'grammargraph# (as returned by the underlying, configurable grammar), and generates a search graph for this grammar. It makes the following simplifying assumptions:
* Zero or one word per grammar node
* No fan-in allowed ever
* No composites (yet)
* Only Unit, HMMState, and pronunciation states (and the initial/final grammar state are in the graph (no word, alternative or grammar states attached).
* Only valid tranisitions (matching contexts) are allowed
* No tree organization of units
* Branching grammar states are allowed

Note that all probabilties are maintained in the log math domain

_GENERIC:
All Implemented Interfaces:
Configurable, Linguist#ql:sphinx'linguist#

_SPESIFEPTO:
Direct Known Subclasses:
ParallelSimpleLinguist

sphinx'linguist.language.GRAMMAR'PACKAGE

name::
* McsEngl.sphinx'linguist.language.GRAMMAR'PACKAGE@cptItsoft,
* McsEngl.sphinx'grammar'package@cptItsoft,

_DEFINETRO:
Package edu.cmu.sphinx.linguist.language.grammar

Provides classes and interfaces that can be used to represent a graph of words and word transitions.

_WHOLE:
* Linguist-Package#ql:sphinx'linguist#

Class Summary
ForcedAlignerGrammar Creates a grammar from a reference sentence.
FSTGrammar Loads a grammar from a file representing a finite-state transducer (FST) in the 'ARPA' grammar format.
* Grammar Classes that implement this interface create grammars.
GrammarArc Represents a single transition out of a grammar node.
GrammarNode Represents a grammar node in a grammar.
LMGrammar Defines a simple grammar based upon a language model.
SimpleWordListGrammar Defines a grammar based upon a list of words in a file.

sphinx'Grammar'CLASS

name::
* McsEngl.sphinx'Grammar'CLASS@cptItsoft,
* McsEngl.sphinx'LanguageModelGraph@cptItsoft,
* McsEngl.sphinx'Grammar@cptItsoft,
* McsEngl.sphinx'GrammarGraph@cptItsoft,

DEFINETRO:
public abstract class edu.cmu.sphinx.linguist.language.grammar.Grammar
implements Configurable

* A grammar is represented as a graph of grammar nodes and arcs.

* The LanguageModel module of the Linguist provides word-level language structure, which can be represented by any number of pluggable implementations.
These implementations typically fall into one of two categories: graph-driven grammars and stochastic N-Gram models.

The graph-driven grammar represents a directed word graph where each node represents a single word and each arc represents the probability of a word transition taking place.

The stochastic N-Gram models provide probabilities for words given the observation of the previous n-1 words.
[whitepaper]

_PART:
* GrammarNode:
* GrammarArc:
* GrammarPoint:

_GENERIC:
All Implemented Interfaces:
Configurable,

_SPESIFEPTO:
* Direct Known Subclasses:
ForcedAlignerGrammar, FSTGrammar, JSGFGrammar#ql:sphinx'jsGFGRAMMAR*#, LMGrammar, SimpleWordListGrammar

sphinx'GrammarArc'CLASS

name::
* McsEngl.sphinx'GrammarArc'CLASS@cptItsoft,

DEFINETRO:
package edu.cmu.sphinx.linguist.language.grammar;
public class GrammarArc

* Represents a single transition out of a grammar node. The grammar represented is a stochastic grammar, each transition has a probability associated with it. The probabilities are relative and are not necessarily constrained to total 1.0.
Note that all probabilities are maintained in the LogMath log base

sphinx'GrammarNode'CLASS

name::
* McsEngl.sphinx'GrammarNode'CLASS@cptItsoft,

DEFINETRO:
package edu.cmu.sphinx.linguist.language.grammar;
public class GrammarNode

* A grammar node usually represents
- a word or words, but it can also be a
- transition point or simply
- silence.

sphinx'linguist.language.NGRAM'PACKAGE

name::
* McsEngl.sphinx'linguist.language.NGRAM'PACKAGE@cptItsoft,
* McsEngl.sphinx'ngram'package@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.linguist.language.ngram

Provides classes and interfaces that represent a stochastic language model

Interface Summary
LanguageModel Represents the generic interface to an N-Gram language model.

Class Summary
SimpleNGramModel An ascii ARPA language model loader.

sphinx'LanguageModel'INTERFACE

name::
* McsEngl.sphinx'LanguageModel'INTERFACE@cptItsoft,
* McsEngl.sphinx'LanguageModelStochastic@cptItsoft,
* McsEngl.sphinx'Language'Model@cptItsoft,

_DEFINETRO:
public interface edu.cmu.sphinx.linguist.language.ngram.LanguageModel
extends Configurable

Represents the generic interface to an N-Gram language model.
Note that all probabilities are in LogMath log base, except as otherwise noted.
[javadoc 10b]

* The LanguageModel module of the Linguist provides word-level language structure, which can be represented by any number of pluggable implementations.
These implementations typically fall into one of two categories: graph-driven grammars and stochastic N-Gram models.

The graph-driven grammar represents a directed word graph where each node represents a single word and each arc represents the probability of a word transition taking place.

The stochastic N-Gram models provide probabilities for words given the observation of the previous n-1 words.
[whitepaper]

sphinx'linguist.language.ngram.LARGE'PACKAGE

name::
* McsEngl.sphinx'linguist.language.ngram.LARGE'PACKAGE@cptItsoft,
* McsEngl.sphinx''package@cptItsoft,

sphinx'linguist.LEXTREE'PACKAGE

name::
* McsEngl.sphinx'linguist.LEXTREE'PACKAGE@cptItsoft,
* McsEngl.sphinx'LexTree@cptItsoft,

_DEFINETRO:
Package edu.cmu.sphinx.linguist.lextree

Provides an implementation of the Linguist that represents the search space as a lex tree. This linguist dynamically generates the search states based upon the lex tree. The lex tree is generated from the vocabulary supplied by the LanguageModel. The lex tree nodes contained 'compressed' hmm nodes. The final unit of a word is not expanded until search time. This avoids the large fanout that typically occurs at word endings, reducing memory consumption and startup time significantly.
[javadoc 10b]

Class Summary
LexTreeLinguist A linguist that can represent large vocabularies efficiently.

sphinx'linguist.UTIL'PACKAGE

name::
* McsEngl.sphinx'linguist.UTIL'PACKAGE@cptItsoft,

sphinx'model'PACKAGE

name::
* McsEngl.sphinx'model'PACKAGE@cptItsoft,
* McsEngl.sphinx'acousticmodel@cptItsoft,

_WHOLE:
* Linguist#ql:sphinx'linguist#

sphinx'package.TIDIGITS

name::
* McsEngl.sphinx'package.TIDIGITS@cptItsoft,
* McsEngl.sphinx'tidigits'package@cptItsoft,
* McsEngl.edu.cmu.sphinx.model.acoustic.TIDIGITS-8gau-13dCep-16k-40mel-130Hz-6800Hz@cptItsoft,

sphinx'package.WSJ16

name::
* McsEngl.sphinx'package.WSJ16@cptItsoft,
* McsEngl.sphinx'model16@cptItsoft,
* McsEngl.sphinx'wsj16'package@cptItsoft,
* McsEngl.edu.cmu.sphinx.model.acoustic.WSJ-8gau-13dCep-16k-40mel-130Hz-6800Hz@cptItsoft,

Class Summary
Model Loads a tied-state acoustic model generated by the Sphinx-3 trainer.
ModelLoader Loads a tied-state acoustic model generated by the Sphinx-3 trainer.
PropertiesDumper Dumps out information about an acoustic model.

STATISTICS:
INFO: Pool model16/cd_continuous_8gau/means Entries: 33176

INFO: Pool model16/cd_continuous_8gau/variances Entries: 33176

INFO: Pool model16/cd_continuous_8gau/transition_matrices Entries: 49

INFO: Pool model16/cd_continuous_8gau/mixture_weights Entries: 4147

INFO: Pool senones Entries: 4147

INFO: Pool meanTransformationMatrix Entries: 1
INFO: Pool varianceTransformationMatrix Entries: 1

INFO: Context Independent Unit Entries: 49

INFO: HMM Manager: 110878 hmms

sphinx'package.WSJ8

name::
* McsEngl.sphinx'package.WSJ8@cptItsoft,
* McsEngl.sphinx'wsj8'package@cptItsoft,
* McsEngl.edu.cmu.sphinx.model.acoustic.WSJ-8gau-13dCep-8kHz-31mel-200Hz-3500Hz@cptItsoft,

sphinx'PACKAGE

name::
* McsEngl.sphinx'PACKAGE@cptItsoft,
* McsEngl.sphinx'architecture@cptItsoft,
* McsEngl.sphinx'STRUCTURE@cptItsoft,

_SPESIFEPTO:
* edu.cmu.sphinx.decoder#ql:sphinx'decoder'package# Provides a set of high level classes that can be used to configure and initiate the speech recognition decoding process.

* edu.cmu.sphinx.frontend#ql:sphinx'frontend'package# Provides a set of high level classes and interfaces that are used to perform digital signal processing for speech recognition.

* edu.cmu.sphinx.instrumentation#ql:sphinx'instrumentation'package# Provides a set of classes that monitor and track operational aspects of the Sphinx system.

* edu.cmu.sphinx.jsapi#ql:sphinx'jsapi'package# Provides support for the Java Speech API for Sphinx-4

* edu.cmu.sphinx.linguist#ql:sphinx'linguist'package# Provides a set of interfaces and classes that are used to define the search graph used by the decoder.

* edu.cmu.sphinx.recognizer#ql:sphinx'recognizer'package# Provides a set of high level classes and interfaces that are used to perform speech recognition with the Sphinx-4 speech recognition system.

* edu.cmu.sphinx.research#ql:sphinx'research'package#:

* edu.cmu.sphinx.result#ql:sphinx'result# Provides a set of classes that represent the result of a recognition.

* edu.cmu.sphinx.tools#ql:sphinx'tools'package#:

* edu.cmu.sphinx.util#ql:sphinx'util'package# Provides a set of general purpose utility classes for Sphinx.

sphinx'recognizer'PACKAGE

name::
* McsEngl.sphinx'recognizer'PACKAGE@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.recognizer Description

Provides a set of high level classes and interfaces that are used to perform speech recognition with the Sphinx-4 speech recognition system.

Interface Summary
sphinx'StateListener The listener interface for receiving recognizer status events. Implements EventListener#ql:jv'eventlistener#.

Class Summary
* Recognizer#ql:sphinx'recognizer# The Sphinx-4 recognizer.
sphinx'RecognizerState Defines the possible states of the recognizer.

sphinx'Recognizer'CLASS

name::
* McsEngl.sphinx'Recognizer'CLASS@cptItsoft,
* McsEngl.sphinx'Recognizer@cptItsoft,

_DEFINETRO:
public class edu.cmu.sphinx.recognizer.Recognizer
extends java.lang.Object
implements Configurable

The Sphinx-4 recognizer. This is the main entry point for Sphinx-4.

sphinx'research'PACKAGE

name::
* McsEngl.sphinx'research'PACKAGE@cptItsoft,

PART-PACKAGES:
edu.cmu.sphinx.research.parallel Provides a search manager (and supporting classes) that can perform recognition on parallel feature streams.

sphinx'result'PACKAGE

name::
* McsEngl.sphinx'result'PACKAGE@cptItsoft,

DEFINETRO:
Package#ql:sphinx'package# edu.cmu.sphinx.result
Provides a set of classes that represent the result of a recognition. Results can maintained in a lattice, which is a directed graph of all the possible words recognized.

Interface Summary
ConfidenceResult Shows the confidence information about a Result.
ConfidenceScorer Computes confidences for a Result.
Path Represents a path of words through the recognition result lattice.
ResultListener The listener interface for being informed when new results are generated.
WordResult Represents a word in a recognition result.

Class Summary
ConfusionSet A confusion set is a set of words with their associated posteriors.
Edge Edges are part of Lattices.
FrameStatistics Contains statistics about a frame.
GDLLatticeFactory Creates a Lattice from a GDL (AISee) Lattice file.
Lattice Provides recognition lattice results.
LatticeOptimizer Class used to collapse all equivalent paths in a Lattice.
MAPConfidenceScorer Computes confidences for the highest scoring path in a Result.
Node Nodes are part of Lattices.
Result Provides recognition results.
Sausage A Sausage is a sequence of confusion sets, one for each position in an utterance.
SausageMaker The SausageMaker takes word lattices as input and turns them into sausages (Confusion Networks) according to Mangu, Brill and Stolcke, "Finding Consensus in Speech Recognition: word error minimization and other applications of confusion networks", Computer Speech and Language, 2000.
SimpleWordResult Represents a single word result with associated scoring and timing information.
TokenGraphDumper Dumps out the GDL graph of all the result token chains in a Result, as well as all the alternate hypotheses along those chains.
WordResultPath An implementation of a result Path that computes scores and confidences on the fly.

spinx'ConfusionSet'CLASS

name::
* McsEngl.spinx'ConfusionSet'CLASS@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.result.ConfusionSet
extends java.util.TreeMap

A confusion set is a set of words with their associated posteriors. In Java terms it's a SortedMap from posteriors to sets of WordResults, but the class is called a set because that's what this beast is known as in the literature.

Author: pgorniak

sphinx'Lattice'CLASS

name::
* McsEngl.sphinx'Lattice'CLASS@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.result.Lattice
extends java.lang.Object

Provides recognition lattice results. Lattices are created from Results which can be partial or final.

Lattices describe all theories considered by the Recognizer that have not been pruned out. Lattices are a directed graph containing Nodes and Edges. A Node that correponds to a theory that a word was spoken over a particular period of time. An Edge that corresponds to the score of one word following another. The usual result transcript is the sequence of Nodes though the Lattice with the best scoring path. Lattices are a useful tool for analyzing "alternate results".

sphinx'Result'class

name::
* McsEngl.sphinx'Result'class@cptItsoft,

DEFINETRO:
public class edu.cmu.sphinx.result.Result
extends java.lang.Object

Provides recognition results. Results can be partial or final. A result should not be modified before it is a final result. Note that a result may not contain all possible information.

How do I use the Result object?

A search result typically consists of a number of hypothesis. Each hypothesis is represented by a path through the search space. Each path is represented by a single token#ql:sphinx'token#. The token corresponds to the end point of the path. Using the token.getPredecessor() method it is possible for an application to trace back through the entire path to the beginning of the utterance.

Each token along the path contains numerous interesting data that can be used by the application including:
* the total path score up to this point (retrieved by getScore())
* A frame number indicating which input frame this token is associated with
* A pointer to a state in the search graph corresponding to this token (A token may correspond to a word, unit, HMM, HMM state or other things). This pointer allows the application to retrieve the word, unit, or hmm information associated with the token.

The method getScore() returns the path score for the path represented by a particular token This is the total score (which includes the language, acoustic and insertion components). The getAcousticScore returns the acoustic score for a token. This score represents how well the associated search state matches the input feature for the frame associated with the token. This is typically only for 'emitting' states. The getLanguageScore() returns the language component of the score The getInsertionProbability() returns the insertion component of the score. So the method getScore returns (all values are in the log domain):
entryScore + getAcousticScore() + getLanguageScore() + getInsertionProbability()
(where entryScore is token.getPredecessor().getScore() )

_FIELD:
private ActiveList activeList#ql:sphinx'activelist#;
private List resultList; The list contains zero or more result Token objects that represents the leaf nodes of all final branches in the result (sometimes referred to as the 'lattice').
private AlternateHypothesisManager alternateHypothesisManager;
private boolean isFinal = false;
private int currentFrameNumber;
private String reference;
private LogMath logMath;

_SPESIFEPTO:
* Partial Result,
* Final Result:

sphinx'ResourceInfHmnn#cptResource843#

name::
* McsEngl.sphinx'ResourceInfHmnn@cptItsoft,

PROJECT-PAGE (HOME):
http://cmusphinx.sourceforge.net/sphinx4/

sphinx'TOOLS'PACKAGE

name::
* McsEngl.sphinx'TOOLS'PACKAGE@cptItsoft,

PART-PACKAGES:
edu.cmu.sphinx.tools.audio Provides an tool that records and displays the waveform and spectrogram of an audio signal.

edu.cmu.sphinx.tools.batch Provides an tool that performs batch-mode speech recognition

edu.cmu.sphinx.tools.feature Provides an tool that generates different types of features (MFCC, PLP, spectrum) from audio files.

edu.cmu.sphinx.tools.live Provides an tool that performs pseudo-live-mode speech recognition

edu.cmu.sphinx.tools.tags Provides tools to post-process JSGF RuleParse objects using ECMAScript Action Tags for JSGF.

sphinx'TRAINING

name::
* McsEngl.sphinx'TRAINING@cptItsoft,

Sphinx-4 is an HMM-based speech recognizer. HMM stands for Hidden Markov Models, which is a type of statistical model. In HMM-based speech recognizers, each unit of sound (usually called a phoneme) is represented by a statistical model that represents the distribution of all the evidence (data) for that phoneme. This is called the acoustic model for that phoneme. When creating an acoustic model, the speech signals are first transformed into a sequence of vectors that represent certain characteristics of the signal, and the parameters of the acoustic model are then estimated using these vectors (usually called features). This process is called training the acoustic models.

sphinx'SphinxTrain

name::
* McsEngl.sphinx'SphinxTrain@cptItsoft,
* McsEngl.sphtrain@cptItsoft,

_DEFINETRO:
This is SphinxTrain, Carnegie Mellon University's open source
acoustic model trainer.

_ADDRESS.WPG:
For up-to-date information, please see the web site at
http://cmusphinx.org

Additional information can be found in the web page above, and also at:
http://www.speech.cs.cmu.edu/sphinxman/scriptman1.html

sphtrain'FEATURE

name::
* McsEngl.sphtrain'FEATURE@cptItsoft,
* McsEngl.sphtrain'cepstrum@cptItsoft,

sphtrain'INSTALATION

name::
* McsEngl.sphtrain'INSTALATION@cptItsoft,

Installation Guide:
^^^^^^^^^^^^^^^^^^^
This sections contain installation guide for various platforms.
All Platforms:
^^^^^^^^^^^^^^
You will need Perl to use the scripts provided. Linux usually comes
with some version of Perl. If you do not have Perl installed, please
check:

http://www.perl.org

where you can download it for free. For Windows, a popular version,
ActivePerl, is available from ActiveState at:

http://www.activestate.com/Products/ActivePerl/

Linux/Unix Installation:
^^^^^^^^^^^^^^^^^^^^^^^^
This distribution now uses GNU autoconf to find out basic information
about your system, and should compile on most Unix and Unix-like
systems, and certainly on Linux. To build, simply run

./configure
make

(Or whatever you call GNU Make). This should configure everything
automatically. The code has been tested with gcc.

Also, check the section title "All Platforms" above.

Windows Installation:
^^^^^^^^^^^^^^^^^^^^^
To compile SphinxTrain in Visual C++ 6.0,
1, uncompress the file (e.g. using WinZip) and save it to the disk.
2, click SphinxTrain.dsw.
3, build all projects; each of them is a tool used by the training script.

Step 3 can be done easily in VC6.0 by clicking the "Build" menu at the
top bar, and selecting "Batch Build...". Make sure all projects are
selected, preferably the "Release" version of each. You can also run
with the "Debug" version, but this version is usually slower.

If you are using cygwin, the installation procedure is very similar to
the Unix installation.

Also, check the section title "All Platforms" above.

sphinx'util'PACKAGE

name::
* McsEngl.sphinx'util'PACKAGE@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.util
Provides a set of general purpose utility classes for Sphinx. This is a grab bag of classes that generally useful but not specific to any one sphinx subsystem.

PART-PACKAGES:
edu.cmu.sphinx.util.props Provides a mechanism for managing persistent configuration data.

sphinx'util'props'PACKAGE

name::
* McsEngl.sphinx'util'props'PACKAGE@cptItsoft,
* McsEngl.sphinx'props'package@cptItsoft,

DEFINETRO:
Package edu.cmu.sphinx.util.props
Provides a mechanism for managing persistent configuration data. The configuration manager and the associated set of interfaces and classes provides the following services:
* Loads configuration data from an XML-based configuration file.
* Manages the component life-cycle for Configurable objects
* Allows discovery of components via name or type.

Interface Summary
Configurable#ql:sphinx'configurable# Defines the interface that must be implemented by any configurable component in Sphinx-4.
PropertySheet A property sheet defines a collection of properties for a single component in the system.
Resetable Defines the interface for an object that is resetable

Class Summary
ConfigurationManager#ql:sphinx'configurationmanager# Manages the configuration for the system.
PropertyType an enum-style type that defines the possible property types.
RawPropertyData#ql:sphinx'rawpropertydata# Holds the raw property data just as it has come in from the properties file.
Registry#ql:sphinx'registry# Used to register properties
SaxLoader Loads configuration from an XML file
Symbol#ql:sphinx'symbol'class# Represents an entry in the symbol table
ValidatingPropertySheet An implementation of the property sheet that validates the properties against a registry.

Exception Summary
PropertyException Indicates that a problem occurred while setting one or more properties for this component

sphinx'Configurable'INTERFACE

name::
* McsEngl.sphinx'Configurable'INTERFACE@cptItsoft,
* McsEngl.sphinx'configurable@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.util.props.Configurable

Defines the interface that must be implemented by any configurable component in Sphinx-4. The life cycle of a component is as follows:
* Construction - the component constructor is called. Typically the constructor does little, if any work, since the component has not been configured yet.
* Registration of properties - shortly after construction, the components register method is called. This allows the component to register all configuration parameters. This registration includes the names and the types of all configuration data expected by the component. Only properties of these names and types will be allowed by the configuration system. Note that if a component is derived from another Configurable its register method should call super.register before registering its own properties.
* Configuration - shortly after registration, the component's newProperties method is called. This method is called with a PropertySheet containing the properties (from the external config file). The component should extract the properties from the property sheet and validate them. Invalid properties should be reported by throwing a PropertyException. Typically, once a component gets its configuration data via the newData method, the component will initialize itself. Currently, the newProperties method is called only once as a result of system configuration during startup. However, future extensions to the configuration manager may allow configuration changes while the system is running. Therefore, a well behaved component should react properly to multiple newProperties calls.

Method Summary
java.lang.String getName()
Retrieves the name for this configurable component
void newProperties(PropertySheet ps)
This method is called when this configurable component has new data.
void register(java.lang.String name, Registry registry)
Register my properties.

_SPESIFEPTO:
All Known Subinterfaces:
AcousticScorer, ActiveListFactory, ActiveListManager, DataProcessor, Dictionary, LanguageModel, Linguist, Loader, Pruner, SearchManager

All Known Implementing Classes:
AccuracyTracker, BaseDataProcessor, BatchModeRecognizer, BeamFinder, ConfigMonitor, Decoder, DynamicFlatLinguist, FastDictionary, FeatureStream, FlatLinguist, FullDictionary, Grammar, LargeTrigramModel, LexTreeLinguist, LinguistProcessor, LiveModeRecognizer, LogMath, MAPConfidenceScorer, MemoryTracker, Model, Model, Model, ModelLoader, ModelLoader, ModelLoader, NullPruner, ParallelAcousticScorer, ParallelSearchManager, PartitionActiveListFactory, Recognizer, RecognizerMonitor, RejectionTracker, SausageMaker, SimpleAcousticScorer, SimpleActiveListFactory, SimpleActiveListManager, SimpleBreadthFirstSearchManager, SimpleNGramModel, SimplePruner, SimpleWordListGrammar, SortingActiveListFactory, SpeedTracker, Sphinx3Loader, ThreadedAcousticScorer, TiedStateAcousticModel, TokenScorePruner, UnitManager, WordActiveListFactory, WordPruningBreadthFirstSearchManager

sphinx'PropertySheet'INTERFACE

name::
* McsEngl.sphinx'PropertySheet'INTERFACE@cptItsoft,
* McsEngl.sphinx'PropertySheet@cptItsoft,

DEFINETRO:
public interface edu.cmu.sphinx.util.props.PropertySheet

A property sheet defines a collection of properties for a single component in the system.

_SPESIFEPTO:
All Known Implementing Classes:
ValidatingPropertySheet,

sphinx'ConfigurationManager'CLASS

name::
* McsEngl.sphinx'ConfigurationManager'CLASS@cptItsoft,
* McsEngl.sphinx'cm@cptItsoft,
* McsEngl.sphinx'ConfigurationManager@cptItsoft,
* McsEngl.sphinx'Configuration'Manager@cptItsoft,

_DEFINETRO:
public class edu.cmu.sphinx.util.props.ConfigurationManager
extends java.lang.Object

Manages the configuration for the system. The configuration manager provides the following services:
* Loads configuration data from an XML-based configuration file.
* Manages the component life-cycle for Configurable objects
* Allows discovery of components via name or type.

_FUNCTION:
Most of these components represents interfaces. The search manager, linguist, acoustic model, dictionary, language model, active list, scorer, pruner, and search graph are all Java interfaces. There can be different implementations of these interfaces. For example, there are two different implementations of the search manager. Then, how does the system know which implementation to use? It is specified by the user via the configuration file, an XML-based file that is loaded by the configuration manager. In this configuration file, the user can also specify the properties of the implementations. One example of a property is the sample rate of the incoming speech data.
[project page]

Field Summary
static java.lang.String PROP_COMMON_LOG_LEVEL
A common property (used by all components) that sets the log level for the component.
static java.lang.String PROP_COMMON_LOG_TERSE
A common property (used by all components) that sets the tersness of the log output
static java.lang.String PROP_SHOW_CREATIONS
Sphinx Property that defines whether or not the configuration manager will trace object creations
static boolean PROP_SHOW_CREATIONS_DEFAULT
The default value for PROP_SHOW_CREATIONS
private java.util.Map globalProperties= new LinkedHashMap();

private static java.util.regex.Pattern globalSymbolPattern

private java.util.Map rawPropertyMap

private boolean showCreations

private java.util.Map symbolTable: {compName, compSymbol#ql:sphinx'symbol'class#} (java.lang.String name, PropertySheet#ql:sphinx'propertysheet# propertySheet, Registry registry, Configurable obj)

Constructor Summary
ConfigurationManager(java.net.URL#ql:jv'url# url): Creates a new configuration manager.
rawPropertyMap = loader(url);
applySystemProperties(rawPropertyMap, globalProperties);
configureLogger();
showCreations = "true".equals(getMyGlobalProperty(PROP_SHOW_CREATIONS));

Method Summary
void editConfig(java.lang.String name)

java.lang.String[] getInstanceNames(java.lang.Class type)
Gets all instances that are of the given type or are assignable to that type.
PropertySheet getPropertySheet(java.lang.String instanceName)
Returns the property sheet for the given object instance
Registry getRegistry(java.lang.String instanceName)
Returns the registry for the given object instance
* Configurable sphinx'cm'lookup(java.lang.String name)
Looks up a configurable component by name.
void save(java.io.File file)
Saves the current configuration to the given file
void setProperty(java.lang.String component, java.lang.String prop, java.lang.String value)
Sets the property of the given component to the given value.
void showConfig()
Shows the current configuration
void showConfig(java.lang.String name)
Show the configuration for the compnent with the given name
void showConfigAsGDL(java.lang.String path)
Dumps the config as a GDL plot
void showConfigAsHTML(java.lang.String path)
Dumps the config as a set of HTML tables

* private Map sphinx'cm'loader(URL url) throws IOException {
SaxLoader saxLoader = new SaxLoader(url, globalProperties);
return saxLoader.load();
}

sphinx'Configuration'File

name::
* McsEngl.sphinx'Configuration'File@cptItsoft,
* McsEngl.sphinx'cf@cptItsoft,

_EXAMPLE:
<config>
<component name="mySampleComponent"
type="edu.cmu.sphinx.sample.MyComponent"/>

<component name="concatDataSource" type="edu...ConcatFileDataSource">
<property name="sampleRate" value="16000"/>
<property name="transcriptFile" value="reference.txt"/>
<property name="silenceFile" value="/lab/speech/sph/silence1sec.raw"/>
<property name="bytesPerRead" value="320"/>
<property name="batchFile" value="tidigits.batch"/>
<property name="addRandomSilence" value="true"/>
</component>

<component name="fileManager" type="edu.cmu.sphinx.sample.FileManager">
<propertylist name="fileNames">
<item>file1.txt</item>
<item>file2.txt</item>
<item>file3.txt</item>
</propertylist>
</component>

</config>

COMPONENT'S'TYPE:
The type of this component is edu.cmu.sphinx.sample.MyComponent which must implement the Configurable#ql:sphinx'configurable# interface.

COMPONENT'S'PROPERTY:
In Sphinx-4, we call the configuration data for a component its properties. Here, we are defining six properties for the concatDataSource component. Properties are simple name/value pairs and are set with the <property> statement as shown above.
If a property is omitted from the configuration file, the component will usually provide a default value for the property.

You may have noticed that properties can be defined out side of any component, at the configuration level. These are called global properties.
These global variables can then be used in the property statements inside components. A variable is referenced using the syntax ${variableName}.
Using a global property allows us to have a single point where the sample rate is defined. To change the sample rate, we only have to change the single number.

There is a special global property called showCreations. If this property is set to "true" the configuration manager will trace the names of all components that are being created, as they are being created. This can sometimes help track down missing or extra components.

Error Checking:
When a configuration file is loaded, the configuration manager will check for certain errors and abort the process if an error is detected. Some of the errors that are detected are:
* Invalid XML - the file is not a valid XML file
* Unknown XML elements - there are unknown elements in the file.
* Missing, extra or Unknown XML attributes - an element has been given the wrong number of attribute
* Multiply defined properties - a property for a component has been defined more than once.
* Bad data type for a property - a given value cannot be converted to the declared type for a property
* Multiply defined components - a component can be defined only once
* Out-of-range-data for a component - the given value for a component property is out of the range.

sphinx'PropertyType'CLASS

name::
* McsEngl.sphinx'PropertyType'CLASS@cptItsoft,
* McsEngl.sphinx'PropertyType@cptItsoft,

DEFINETRO:
public abstract class edu.cmu.sphinx.util.props.PropertyType
extends java.lang.Object

an enum-style type that defines the possible property types.

sphinx'RawPropertyData'CLASS

name::
* McsEngl.sphinx'RawPropertyData'CLASS@cptItsoft,
* McsEngl.sphinx'RawPropertyData@cptItsoft,

DEFINETRO:
class edu.cmu.sphinx.util.props.RawPropertyData
extends java.lang.Object

Holds the raw property data just as it has come in from the properties file.
* For ONE component.

FIELD:
private String name;
private String className;
private Map properties;

CONSTRUCTOR:
RawPropertyData(String name, String className) {
this.name = name;
this.className = className;
properties = new HashMap();
}

sphinx'Registry'CLASS

name::
* McsEngl.sphinx'Registry'CLASS@cptItsoft,
* McsEngl.sphinx'Registry@cptItsoft,

_DEFINETRO:
public class edu.cmu.sphinx.util.props.Registry
extends java.lang.Object

Used to register properties
* Stores the properties of a Configurable#ql:sphinx'configurable#. [nikkas]

Field Summary
private Configurable configurable
private java.util.Map map= new HashMap();

Constructor Summary
Registry(Configurable obj)
Creates a new registry for an object

Method Summary
(package private) Configurable getOwner()
Gets the owner for this registry: the configurable-object
(package private) java.util.Collection getRegisteredProperties()
Returns the list of registered properties: the names.
(package private) PropertyType lookup(java.lang.String propertyName)
Lookup a property in the registry
void register(java.lang.String propertyName, PropertyType myType)
Registers a property with this registry

sphinx'SaxLoader'CLASS

name::
* McsEngl.sphinx'SaxLoader'CLASS@cptItsoft,

FIELD:
private URL url;
private Map rpdMap; //{compName, compRawPropertyData}
private Map globalProperties;

CONSTRUCTOR:
SaxLoader(URL url, Map globalProperties) {
this.url = url;
this.globalProperties = globalProperties;
}

METHOD#ql:jv'method#:
* Map load() throws IOException:
1) Returns the HashMap{compName, compRawPropertyData}
2) In ARGUMENT globalProperties, adds the ones in url.

sphinx'Symbol'CLASS

name::
* McsEngl.sphinx'Symbol'CLASS@cptItsoft,

DEFINETRO:
class edu.cmu.sphinx.util.props.Symbol
extends java.lang.Object

Represents an entry in the symbol table.
* Holds of a configurable-compenent: nameString, PropertySheet#ql:sphinx'propertysheet#, Registry#ql:sphinx'registry#, Object.

Constructor Summary
Symbol(java.lang.String name, PropertySheet propertySheet, Registry registry, Configurable obj)
Creates a symbol table entry

sphinx'ValidatingPropertySheet'CLASS

name::
* McsEngl.sphinx'ValidatingPropertySheet'CLASS@cptItsoft,

DEFINETRO:
class edu.cmu.sphinx.util.props.ValidatingPropertySheet
extends java.lang.Object
implements PropertySheet

An implementation of the property sheet that validates the properties against a registry#ql:sphinx'registry#.

_GENERIC:
All Implemented Interfaces:
PropertySheet

CONSTRUCTOR:
ValidatingPropertySheet(ConfigurationManager cm, Registry registry,
RawPropertyData#ql:sphinx'RawPropertyData# rpd) throws PropertyException

sphinx.SPECIFIC#cptCore546.23#

name::
* McsEngl.sphinx.SPECIFIC@cptItsoft,

1.0 beta:
In this release, we have provided the following new features and
improvements over the 0.1 alpha release:
- Confidence scoring
- Dynamic grammar support
- JSGF limitations removed
- Improved performance for large, perplex JSGF grammars
- Filler support for JSGF Grammars
- Out-of-grammar utterance rejection
- Narrow bandwidth acoustic model
- WSJ5K Language model
- More demonstration programs
- Better control over microphone selection
- Lots of bug fixes

0.1 alpha:

FvMcs.JAVA-STANDALONE-PROGRAM

_CREATED: {2003-02-13}

name::
* McsEngl.conceptItsoft1212,
* McsEngl.JAVA-STANDALONE-PROGRAM@cptItsoft,
* McsEngl.FvMcs.JAVA-STANDALONE-PROGRAM@cptItsoft,
* McsEngl.java-application@cptItsoft,
* McsEngl.java'application@cptItsoft1199,
* McsEngl.jv'app@cptItsoft1199,
* McsEngl.jv'application@cptItsoft1199,

DEFINITION

The most common Java programs are applications and applets.
- Applications are standalone programs, such as the HotJava browser.
- Applets are similar to applications, but they don't run standalone. Instead, applets adhere to a set of conventions that lets them run within a Java-compatible browser. If you're using a browser that can view applets, you should see an animation just below this paragraph -- that's an applet embedded in this HTML page.
[http://java.sun.com/tutorial/index.html]

API

app'MAIN'MEHTOD#cptItsoft1012.16#

name::
* McsEngl.app'MAIN'MEHTOD@cptItsoft,

DEFINITION

FreeTTS is a speech synthesis system written entirely in the JavaTM programming language. It is based upon Flite (http://www.cmuflite.org/): a small run-time speech synthesis engine developed at Carnegie Mellon University. Flite is derived from the Festival (http://www.cstr.ed.ac.uk/projects/festival/) Speech Synthesis System from the University of Edinburgh and the FestVox (http://festvox.org/) project from Carnegie Mellon University.

ftts'GENERIC

_GENERIC:
* Text-To-Speech-Sythesis (tts)#cptIt541#
sss (speech synthesis system) || speech-synthesizer

ftts'APP

name::
* McsEngl.ftts'APP@cptItsoft,

ftts'app.fttsEX

name::
* McsEngl.ftts'app.fttsEX@cptItsoft,

FttsEx.main():
VoiceDiphone vd = new VoiceDiphone(...)
vd.allocate();
vd.speak(args[0]);

VoiceDiphone.allocate():
audioOutput = new AudioOutput();
outputQueue = createOutputThread();
setupFeatureSet();
setupUtteranceProcessors();
setupFeatureProcessors();

VoiceDiphone.speak(text):
VoiceDiphone.speak(FttsSpeakable speakable)
getAudioPlayer().startFirstSampleTimer();
for (Iterator i = tokenize(speakable);
!speakable.isCompleted() && i.hasNext() ; )
utterance = new Utterance(VoiceDiphone.this, tokenList);
utterance.setSpeakable(speakable);
utterance.setFirst(first);
Utterance utterance = (Utterance) i.next();
processUtterance(utterance);

VoiceDiphone.processUtterance(utterance):
for (int i = 0; i < processors.length && !u.getSpeakable().isCompleted(); i++)
{ runProcessor(processors[i], u); }
outputUtterance(u);

VoiceDiphone.runProcessor(processors[i], u):
//runs the utterance-processeros

* TokenToWords: The TokenToWords UtteranceProcessor creates a word-Relation#ql:ftts'word'relation# from the token Relation by iterating through the token Relation Item list and creating one or more words for each token.

* Phraser: The Phraser processor creates a phrase-Relation#ql:ftts'relation.frase# in the Utterance. The phrase Relation represents how the Utterance is to be broken into phrases when spoken. The phrase Relation consists of an Item marking the beginning of each phrase in the Utterance. This phrase Item has as its daughters the list of words that are part of the phrase.
The Phraser builds the phrase Relation by iterating through the Word Relation created by the TokenToWords processor. The Phraser uses a Phrasing CART to determine where the phrase breaks occur and creates the phrase Items accordingly.

* Segmenter: The Segmenter iterates through each word in the Utterance. For each word, the Segmenter performs the following steps:
* Retrieves the phones that are associated with the word from the Lexicon . Each word is organized in a Relation called "SylStructure#ql:ftts'sylstructure'relation#".
* Iterates through each phone of the word, adding the phone to a Relation called "Segment#ql:ftts'segment'relation#".
* Determines where syllable breaks occur (with help from the lexicon) and notes the syllable break points in a Relation called "Syllable#ql:ftts'syllable'relation#"
* If the lexicon indicates that a particular phone is stressed, then the syllable that contains that phone is marked as "stressed".
When the Segmenter is finished, three new Relations have been added to the Utterance that denote the syllable structure and units for the Utterance.

* PauseGenerator: The PauseGenerator annotates an Utterance with pause information. It inserts a pause at the beginning of the segment list (thus all Utterances start with a pause). It then iterates through the phrase Relation (set up by the Phraser) and inserts a pause before the first segment of each phrase.

* Intonator: The Intonator processor annotates the syllable-Relation#ql:ftts'syllable'relation# of an Utterances with "accent" and "endtone" features.

* Durator: The Durator is responsible for determining the ending time for each unit in the segment-list#ql:ftts'segment'relation#. Each unit is finally tagged with an "end" attribute that indicates the time, in seconds, at which the unit should be completed.

* ContourGenerator: The ContourGenerator#ql:ftts'contourgenerator# is responsible for calculating the F0 (Fundamental Frequency) curve for an Utterance.
The ContourGenerator creates the "target"-Relation#ql:ftts'target'relation# and populates it with target points that mark the time and target frequency for each segment.

* DiphoneUnitSelector#ql:ftts'diphoneunitselector'class#: Creates the unit-relation#ql:ftts'unit'relation#.

* DiphonePitchmarkGenerator#ql:ftts'DiphonePitchmarkGenerator*#: The PitchMarkGenerator is responsible for calculating pitchmarks for the Utterance. The pitchmarks are generated by iterating through the target Relation and calculating a slope based upon the desired time and F0 values for each Item in the target Relation. The resulting slope is used to calculate a series of target times for each pitchmark. These target times are stored in an LPCResult object that is added to the Utterance.

* UnitConcatenator#ql:ftts'unitconcatenator'class#: The UnitConcatenator processor is responsible for gathering all of the diphone data and joining it together. For each Item in the unit Relation (recall this was the set of diphones) the UnitConcatenator extracts the unit sample data from the unit based upon the target times as stored in the LPC result.

VoiceDiphone.outputUtterance(Utterance utterance):
// Sends the given utterance to the audio output processor
// creates the wave
getAudioPlayer().reset();
runProcessor(audioOutput, utterance);
AudioOutput.processUtterance(Utterance utterance)
LPCRresult.playWave(audioPlayer, utterance)//plays

ftts'app.fttsJTime

name::
* McsEngl.ftts'app.fttsJTime@cptItsoft,

CMUClusterUnitVoice..speak(FreeTTSSpeakable speakable) {

1) Tokenization: the Voice uses the Tokenizer as returned from the getTokenizer method to break a FreeTTSSpeakable object is into a series of Utterances. The CMUDiphoneVoice uses the com.sun.speech.freetts.en.TokenizerImpl Tokenizer which is designed to parse and tokenize the English language.
Relation.Token is created with Utterance creation through Tokenizer of Voice.

2) Each Utterance: processUtterance(utterance);

2a) runProcessor(): run all processors except audiooutput.
* TokenToWords: The TokenToWords UtteranceProcessor creates a word-Relation#ql:ftts'word'relation# from the token Relation by iterating through the token Relation Item list and creating one or more words for each token.

* PartOfSpeechTagger: The PartOfSpeechTagger UtteranceProcessor is a place-holder processor that currently does nothing.

* CARTPhraser: The Phraser processor creates a phrase-Relation#ql:ftts'relation.frase# in the Utterance. The phrase Relation represents how the Utterance is to be broken into phrases when spoken. The phrase Relation consists of an Item marking the beginning of each phrase in the Utterance. This phrase Item has as its daughters the list of words that are part of the phrase.
The Phraser builds the phrase Relation by iterating through the Word Relation created by the TokenToWords processor. The Phraser uses a Phrasing CART to determine where the phrase breaks occur and creates the phrase Items accordingly.

* Segmenter: The Segmenter iterates through each word in the Utterance. For each word, the Segmenter performs the following steps:
* Retrieves the phones that are associated with the word from the Lexicon . Each word is organized in a Relation called "SylStructure#ql:ftts'sylstructure'relation#".
* Iterates through each phone of the word, adding the phone to a Relation called "Segment#ql:ftts'segment'relation#".
* Determines where syllable breaks occur (with help from the lexicon) and notes the syllable break points in a Relation called "Syllable#ql:ftts'syllable'relation#"
* If the lexicon indicates that a particular phone is stressed, then the syllable that contains that phone is marked as "stressed".
When the Segmenter is finished, three new Relations have been added to the Utterance that denote the syllable structure and units for the Utterance.

* PauseGenerator: The PauseGenerator annotates an Utterance with pause information. It inserts a pause at the beginning of the segment list (thus all Utterances start with a pause). It then iterates through the phrase Relation (set up by the Phraser) and inserts a pause before the first segment of each phrase.

* CARTIntonator: The Intonator processor annotates the syllable-Relation#ql:ftts'syllable'relation# of an Utterances with "accent" and "endtone" features.
This processor relies on two CARTs : an accent CART and a tone CART.

* PostLexicalAnalyzer: The PostLexicalAnalyzer is responsible for performing any fix ups before the next phase of processing.

* CARTDurator: The Durator is responsible for determining the ending time for each unit in the segment-list#ql:ftts'segment'relation#. The Durator uses a CART to look up the statistical average duration and standard deviation for each phone and calculates an exact duration based upon the CART derived adjustment. Each unit is finally tagged with an "end" attribute that indicates the time, in seconds, at which the unit should be completed.

* ContourGenerator: The ContourGenerator#ql:ftts'contourgenerator# is responsible for calculating the F0 (Fundamental Frequency) curve for an Utterance.
The ContourGenerator creates the "target"-Relation#ql:ftts'target'relation# and populates it with target points that mark the time and target frequency for each segment.

* ClusterUnitSelector: Creates the unit-relation#ql:ftts'unit'relation#.

* ClusterUnitPitchmarkGenerator: The PitchMarkGenerator is responsible for calculating pitchmarks for the Utterance. The pitchmarks are generated by iterating through the target Relation and calculating a slope based upon the desired time and F0 values for each Item in the target Relation. The resulting slope is used to calculate a series of target times for each pitchmark. These target times are stored in an LPCResult object that is added to the Utterance.

* UnitConcatenator#ql:ftts'unitconcatenator'class#: The UnitConcatenator processor is responsible for gathering all of the diphone data and joining it together. For each Item in the unit Relation (recall this was the set of diphones) the UnitConcatenator extracts the unit sample data from the unit based upon the target times as stored in the LPC result.

2b) outputUtterance(utterach, runTimer): creates the wave
AudioOutput.processUtterance(Utterance utterance)
LPCRresult.playWave(audioPlayer, utterance)
}

ftts'app.fttsHW

name::
* McsEngl.ftts'app.fttsHW@cptItsoft,

CMUDiphoneVoice.speak(FreeTTSSpeakable speakable) {

1) Tokenization: the Voice uses the Tokenizer as returned from the getTokenizer method to break a FreeTTSSpeakable object is into a series of Utterances. The CMUDiphoneVoice uses the com.sun.speech.freetts.en.TokenizerImpl Tokenizer which is designed to parse and tokenize the English language.
Relation.Token is created with Utterance creation through Tokenizer of Voice.

2) Each Utterance: processUtterance(utterance);

2a) runProcessor(): run all processors except audiooutput.
* TokenToWords: The TokenToWords UtteranceProcessor creates a word-Relation#ql:ftts'word'relation# from the token Relation by iterating through the token Relation Item list and creating one or more words for each token.

* PartOfSpeechTagger: The PartOfSpeechTagger UtteranceProcessor is a place-holder processor that currently does nothing.

* CARTPhraser: The Phraser processor creates a phrase-Relation#ql:ftts'relation.frase# in the Utterance. The phrase Relation represents how the Utterance is to be broken into phrases when spoken. The phrase Relation consists of an Item marking the beginning of each phrase in the Utterance. This phrase Item has as its daughters the list of words that are part of the phrase.
The Phraser builds the phrase Relation by iterating through the Word Relation created by the TokenToWords processor. The Phraser uses a Phrasing CART to determine where the phrase breaks occur and creates the phrase Items accordingly.

* Segmenter: The Segmenter iterates through each word in the Utterance. For each word, the Segmenter performs the following steps:
* Retrieves the phones that are associated with the word from the Lexicon . Each word is organized in a Relation called "SylStructure#ql:ftts'sylstructure'relation#".
* Iterates through each phone of the word, adding the phone to a Relation called "Segment#ql:ftts'segment'relation#".
* Determines where syllable breaks occur (with help from the lexicon) and notes the syllable break points in a Relation called "Syllable#ql:ftts'syllable'relation#"
* If the lexicon indicates that a particular phone is stressed, then the syllable that contains that phone is marked as "stressed".
When the Segmenter is finished, three new Relations have been added to the Utterance that denote the syllable structure and units for the Utterance.

* PauseGenerator: The PauseGenerator annotates an Utterance with pause information. It inserts a pause at the beginning of the segment list (thus all Utterances start with a pause). It then iterates through the phrase Relation (set up by the Phraser) and inserts a pause before the first segment of each phrase.

* CARTIntonator: The Intonator processor annotates the syllable-Relation#ql:ftts'syllable'relation# of an Utterances with "accent" and "endtone" features.
This processor relies on two CARTs : an accent CART and a tone CART.

* PostLexicalAnalyzer: The PostLexicalAnalyzer is responsible for performing any fix ups before the next phase of processing.

* CARTDurator: The Durator is responsible for determining the ending time for each unit in the segment-list#ql:ftts'segment'relation#. The Durator uses a CART to look up the statistical average duration and standard deviation for each phone and calculates an exact duration based upon the CART derived adjustment. Each unit is finally tagged with an "end" attribute that indicates the time, in seconds, at which the unit should be completed.

* ContourGenerator: The ContourGenerator#ql:ftts'contourgenerator# is responsible for calculating the F0 (Fundamental Frequency) curve for an Utterance.
The ContourGenerator creates the "target"-Relation#ql:ftts'target'relation# and populates it with target points that mark the time and target frequency for each segment.

* DiphoneUnitSelector#ql:ftts'diphoneunitselector'class#: Creates the unit-relation#ql:ftts'unit'relation#.

* DiphonePitchmarkGenerator#ql:ftts'DiphonePitchmarkGenerator*#: The PitchMarkGenerator is responsible for calculating pitchmarks for the Utterance. The pitchmarks are generated by iterating through the target Relation and calculating a slope based upon the desired time and F0 values for each Item in the target Relation. The resulting slope is used to calculate a series of target times for each pitchmark. These target times are stored in an LPCResult object that is added to the Utterance.

* UnitConcatenator#ql:ftts'unitconcatenator'class#: The UnitConcatenator processor is responsible for gathering all of the diphone data and joining it together. For each Item in the unit Relation (recall this was the set of diphones) the UnitConcatenator extracts the unit sample data from the unit based upon the target times as stored in the LPC result.

2b) outputUtterance(utterach, runTimer): creates the wave
AudioOutput.processUtterance(Utterance utterance)
LPCRresult.playWave(audioPlayer, utterance)
}

ftts'app.MbrolaHW

name::
* McsEngl.ftts'app.MbrolaHW@cptItsoft,

_RUN:
java -Dmbrola.base=mbrola MbrolaHW

List voices:
VoiceManager voiceManager = VoiceManager.getInstance();
Voice[] voices = voiceManager.getVoices();

Get Voice:
Voice helloVoice = voiceManager.getVoice("mbrola_us1");

_ALLOCATE:
helloVoice.allocate();

_SPEAK:
helloVoice.speak("Thank you for giving me a voice. ");
return speak(new FreeTTSSpeakableImpl(text));
MbrolaVoice: Processing Utterance: Thank you for giving me a voice.
MbrolaVoice: Running ..TokenToWords
MbrolaVoice: Running ..PartOfSpeechTagger
MbrolaVoice: PartOfSpeechTagger does nothing!
MbrolaVoice: Running ..CARTPhraser
MbrolaVoice: Running ..Segmenter
MbrolaVoice: Running ..PauseGenerator
MbrolaVoice: Running ..CARTIntonator
MbrolaVoice: Running ..PostLexicalAnalyzer
MbrolaVoice: Running ..CARTDurator
MbrolaVoice: Running ..ContourGenerator
MbrolaVoice: Running ..ParametersToMbrolaConverter
MbrolaVoice: Running ..MbrolaCaller

Clean up and leave:
helloVoice.deallocate();
System.exit(0);

ftts'cart'PACKAGE

name::
* McsEngl.ftts'cart'PACKAGE@cptItsoft,

FULLNAME: com.sun.speech.freetts.cart;

DEFINETRO:
Classification and Regression Trees (CARTs) based on the Breiman, Friedman, Olshen, and Stone document "Classification and Regression Trees." Wadsworth, Belmont, CA, 1984.

Interface Summary
CART Generic interface for Classification and Regression Trees (CARTs) based on the Breiman, Friedman, Olshen, and Stone document "Classification and Regression Trees."

Class Summary
CARTImpl Implementation of a Classification and Regression Tree (CART) that is used more like a binary decision tree, with each node containing a decision or a final value.
Durator Determines duration timing for Relation.SEGMENT relations in an utterance.
Intonator Annotates the Relation.SYLLABLE relations of an utterance with "accent" and "endtone" features.
Phraser Creates a Relation.PHRASE relation, grouping Relation.WORD relations by breaks.

NODE:
each node contains a decision or a final value.

DECISION-NODE:
The decision nodes in the CART trees operate on an Item and have the following format:
NODE feat operand value qfalse
Where
- feat is an string that represents a feature to pass to the "findFeature" method of an item.
- value represents the value to be compared against the feature obtained from the item via the feat string.
- operand is the operation to do the comparison. The available operands are as follows:
< - the feature is less than value
= - the feature is equal to the value
> - the feature is greater than the value
MATCHES - the feature matches the regular expression stored in value
IN - [[[TODO: still guessing because none of the CART's in Flite seem to use IN]]] the value is in the list defined by the feature.
For < and >, this CART coerces the value and feature to float's.
For =, this CART coerces the value and feature to string and checks for string equality.
For MATCHES, this CART uses the value as a regular expression and compares the obtained feature to that.
- qfalse value represents the index of the array to go to if the comparison does not match. In this implementation, qtrue index is always implied, and represents the next element in the array.

ROOT-NODE:
The root node of the CART is the first element in the array.

FINAL-NODE:
The final nodes have the * following form:
LEAF value
Where value represents the value of the node. Reaching a final node indicates the interpretation is over and the value of the node is the interpretation result.

PROCESS:
Passes an item through the CART and returns the interpretation.
The interpretations always start at the root node of the CART and continue until a final node is found.

IMPLEMENTATION:
A CART is represented by an array in this implementation.

ftts'Durator'CLASS

name::
* McsEngl.ftts'Durator'CLASS@cptItsoft,
* McsEngl.ftts'CARTDurator@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.cart.Durator
implements UtteranceProcessor

_WHOLE:
* PACKAGE: com.sun.speech.freetts.cart

PART: FUNCTION:
The Durator is responsible for determining the ending time for each unit in the segment list. The Durator uses a CART to look up the statistical average duration and standard deviation for each phone and calculates an exact duration based upon the CART derived adjustment. Each unit is finally tagged with an "end" attribute that indicates the time, in seconds, at which the unit should be completed.

ftts'Intonator'CLASS

name::
* McsEngl.ftts'Intonator'CLASS@cptItsoft,
* McsEngl.ftts'CARTIntonator@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.cart.Intonator
extends java.lang.Object
implements UtteranceProcessor

Annotates the Relation.SYLLABLE relations of an utterance with "accent" and "endtone" features. Though not required, a typical use of this is to use the ToBI (tones and break indeces) scheme for transcribing intonation and accent in English, developed by Janet Pierrehumbert and Mary Beckman. This implementation is independent of the ToBI scheme: ToBI annotations are not used by this class, but are merely copied from the CART result to the "accent" and "endtone" features of the Relation.SYLLABLE relation.

* The Intonator processor annotates the syllable Relation of an Utterances with "accent" and "endtone" features. A typical application of this uses the ToBI (tones and break indices) scheme for transcribing intonation and accent in English, developed by Janet Pierrehumbert and Mary Beckman.
The intonation is independent of the ToBI annotation: ToBI annotations are not used by this class, but are merely copied from the CART result to the "accent" and "endtone" features of the syllable Relation.
This processor relies on two CARTs : an accent CART and a tone CART. This processor iterates through each syllable in the syllable relation, applies each CART to the syllable and sets the accent and endtone features of the Item based upon the results of the CART processing.

ftts'Phraser'CLASS

name::
* McsEngl.ftts'Phraser'CLASS@cptItsoft,
* McsEngl.ftts'CARTPhraser@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.cart.Phraser
extends java.lang.Object
implements UtteranceProcessor

Creates a Relation.PHRASE relation, grouping Relation.WORD relations by breaks.
** PACKAGE: com.sun.speech.freetts.cart.
** FUNCTION:
The Phraser processor creates a phrase Relation in the Utterance. The phrase Relation represents how the Utterance is to be broken into phrases when spoken. The phrase Relation consists of an Item marking the beginning of each phrase in the Utterance. This phrase Item has as its daughters the list of words that are part of the phrase.

CART:
phrasing_cart.txt

EXAMPLE:
1) The car, which you look, is mine.
========= Relation: Phrase =========
Phrase:BB
d:the
d:car
Phrase:BB
d:which
d:you
d:look
Phrase:BB
d:is
d:mine

2) The car which you look is mine.
========= Relation: Phrase =========
Phrase:BB
d:the
d:car
d:which
d:you
d:look
d:is
d:mine

ftts'clunit'PACKAGE

name::
* McsEngl.ftts'clunit'PACKAGE@cptItsoft,

DEFINETRO:
Support for cluster unit selection of audio data as described in the Black and Taylor document "Automatically clustering similar units for unit selection in speech synthesis", published in Proceedings of the Eurospeech 1997, Rhodes, Greece.

_WHOLE: PACKAGE:
com.sun.speech.freetts

PART: Class Summary
ClusterUnitDatabase Provides support for the cluster unit database.
ClusterUnitPitchmarkGenerator Calculates the pitchmarks.
ClusterUnitSelector Generates the Unit Relation of an Utterance from the Segment Relation.

ftts'ClusterUnitSelector'CLASS

name::
* McsEngl.ftts'ClusterUnitSelector'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.clunits.ClusterUnitSelector
extends java.lang.Object
implements UtteranceProcessor

Generates the Unit Relation of an Utterance from the Segment Relation.

ftts'cmu'us'kal'PACKAGE

name::
* McsEngl.ftts'cmu'us'kal'PACKAGE@cptItsoft,

ftts'kevin16'DiphoneDB

name::
* McsEngl.ftts'kevin16'DiphoneDB@cptItsoft,

DB Features dumped on Jan 14 2002
NAME cmu_us_kal
SAMPLE_RATE 16000
NUM_CHANNELS 16
COEFF_MIN -7.992630
COEFF_RANGE 15.822620

ftts'PHONE (41):
aa
ae
ah
ao
aw
ax
ay
b
ch
d
dh
eh
er
ey
f
g
hh
ih
iy
jh
k
l
m
n
ng
ow
oy
p
pau
r
s
sh
t
th
uh
uw
v
w
y
z
zh

ftts'PHONE'DURATION:
*** phone mead standard-deviation
aa 0.109230 0.045992
ae 0.115669 0.047921
ah 0.062256 0.029903
ao 0.091841 0.049984
aw 0.159485 0.064687
ax 0.053852 0.033216
ay 0.151095 0.045892
b 0.063457 0.027020
ch 0.135828 0.043586
d 0.050917 0.031666
dh 0.035688 0.021493
eh 0.109237 0.046925
er 0.100174 0.044822
ey 0.165883 0.075700
f 0.096548 0.028515
g 0.077797 0.027193
hh 0.067775 0.021633
ih 0.062962 0.030609
iy 0.126115 0.063085
jh 0.083748 0.029496
k 0.089048 0.040764
l 0.065292 0.033114
m 0.074447 0.044589
n 0.058944 0.029727
ng 0.065651 0.022119
ow 0.146084 0.052605
oy 0.160374 0.077629
p 0.099085 0.033806
pau 0.200000 0.100000
r 0.052082 0.023499
s 0.108565 0.041973
sh 0.126018 0.023275
t 0.074067 0.037846
th 0.116027 0.054892
uh 0.061596 0.023654
uw 0.102018 0.047394
v 0.045676 0.017954
w 0.052598 0.024618
y 0.056909 0.027740
z 0.088234 0.038770
zh 0.152593 0.092321

ftts'DOCS

name::
* McsEngl.ftts'DOCS@cptItsoft,

LOCAL:
* /JAVA/APP/SOUND/SPEECH/SYTHESIS/FREETTS121/docs/index.html:
* /JAVA/APP/FREETTS121/javadoc/index.html:
* /JAVA/APP/FREETTS121/docs/ProgrammerGuide.html:

ftts'diphone'PACKAGE

name::
* McsEngl.ftts'diphone'PACKAGE@cptItsoft,

DEFINETRO:
Package com.sun.speech.freetts.diphone
Support for diphones encoded using residual excited linear prediction (RELP)

PART: Class Summary:
Diphone Represents two adjacent phones.
DiphonePitchmarkGenerator Calculates pitchmarks.
DiphoneUnitDatabase Represents and manages the unit data for all diphones.
DiphoneUnitSelector Generates the Unit Relation of an Utterance from the Segment Relation.

ftts'Diphone'CLASS

name::
* McsEngl.ftts'Diphone'CLASS@cptItsoft,

_DEFINITION:
public class com.sun.speech.freetts.diphone.Diphone
extends java.lang.Object

Represents two adjacent phones. A diphone is defined by its name, the set of audio data, and information used to help stitch diphones together. This class is immutable.
a FreeTTS diphone is an ARAY of SAMPLES.

_WHOLE: PACKAGE: com.sun.speech.freetts.diphone;

PART: FIELD:
** private final static int MAGIC = 0xFACE0FF;
** private final static int NAME_LENGTH = 8;
** private String name;
** private int midPoint; It is the INDEX of the middle sample.
** private Sample[] samples;
** private int unitSizePart1; The sum of residuals of the samples from first to middle sampel (not included)
** private int unitSizePart2; The sum of residuals of sampels from middle (included) to the end.

ftts'DiphonePitchmarkGenerator'CLASS

name::
* McsEngl.ftts'DiphonePitchmarkGenerator'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.diphone.DiphonePitchmarkGenerator
extends java.lang.Object
implements UtteranceProcessor

Calculates pitchmarks. This is an utterance processor that expects the utterance to have a target relation. It will create an LPCResult#ql:ftts'lpcresult'class# and add it to the utterance based upon features of the target relation.

The PitchMarkGenerator is responsible for calculating pitchmarks for the Utterance. The pitchmarks are generated by iterating through the target-Relation#ql:ftts'target'relation# and calculating a slope based upon the desired time and F0 values for each Item in the target Relation. The resulting slope is used to calculate a series of target times for each pitchmark. These target times are stored in an LPCResult object that is added to the Utterance.

ftts'DiphoneUnitDatabase'CLASS

name::
* McsEngl.ftts'DiphoneUnitDatabase'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.diphone.DiphoneUnitDatabase
extends java.lang.Object

Represents and manages the unit data for all diphones. The diphone data set is stored in a set of data files. These data are loaded by this class into internal data structures before diphone synthesis can occur.

ftts'DiphoneUnitSelector'CLASS

name::
* McsEngl.ftts'DiphoneUnitSelector'CLASS@cptItsoft,

DEFINETRO:
public class class com.sun.speech.freetts.diphone.DiphoneUnitSelector
extends java.lang.Object
implements UtteranceProcessor

Generates the Unit-Relation#ql:ftts'unit'relation# of an Utterance from the Segment-Relation#ql:ftts'segment'relation#.

The UnitSelector that is used by the CMUDiphoneVoice creates a Relation in the Utterance called "unit". This relation contains Items that represent the diphones for the unit. This processor iterates through the segment list and builds up diphone names by assembling two adjacent phone names. The diphone is added to the unit Relation along with timing information about the diphone.

ftts'PHONESET

name::
* McsEngl.ftts'PHONESET@cptItsoft,

US_PHONSET: MBROLA-US
ah bUt, hUsh V
ax About, cAnoe
aa fAther, wAshington A

eh gEt, fEAther E
ae fAt, bAd {

ih bIt, shIp I
iy bEAt, shEEp i

ao lAWn, dOOr, mAll O

uh fUll, wOOd U
uw fOOl, fOOd u

aw hOW, sOUth, brOWser aU
ay hIde, bIble AI
ey gAte, Ate EI
ow lOne, nOse @U
oy tOY, OYster OI

el tabLE, usabLE
em systEM, communisM
en beatEN
er fERtile, sEARch, makER r=
========================
b Book, aBrupt b
ch CHart, larCH tS
d Done, baD d
dh THat, faTHer D
f Fat, lauGH f
g Good, biGGer g
hh Hello, loopHole h
jh diGit, Jack dz
k Camera, jaCK, Kill k
l Late, fuLL l
m Man, gaMe m
n maN, New n
ng baNG, sittiNG N
p Pat, camPer p
r Reason, caR, r
s Sit, maSS s
sh SHip, claSH S
t Tap, baT t
th THeatre, baTH T
v Various, haVe v
w Water, cobWeb
y Yellow, Yacht j
z Zero, quiZ, boyS z
zh viSion, caSual Z
pau short silence _
[festvox_18.html]

ftts'en'PACKAGE

name::
* McsEngl.ftts'en'PACKAGE@cptItsoft,

FULLNAME: com.sun.speech.freetts.en

_WHOLE: PACKAGE:
* freetts,

PART: PACKAGE:
* us#ql:ftts'us'com'package#

PART: CLASS:
ContourGenerator Calculates the F0 curve for an utterance based on the Black and Hunt article "Generating F0 Contours from ToBI Labels Using Linear Regression," ICSLP96, vol.
PartOfSpeechTagger Tags the words in the utterance with their part-of-speech.
PauseGenerator Annotates an utterance with pause information.
PostLexicalAnalyzer Annotates the utterance with post lexical information.
TokenizerImpl Implements the tokenizer interface.

ftts'ContourGenerator'CLASS

name::
* McsEngl.ftts'ContourGenerator'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.en.ContourGenerator
extends java.lang.Object
implements UtteranceProcessor

Calculates the F0 curve for an utterance based on the Black and Hunt article "Generating F0 Contours from ToBI Labels Using Linear Regression," ICSLP96, vol. 3, pp 1385-1388, Philadelphia, PA. 1996.

The ContourGenerator creates the "target"-Relation#ql:ftts'target'relation# and populates it with
- target points that mark the time and
- target frequency for each segment.
The ContourGenerator is driven by a a file of feature model terms. For example, CMUDiphoneVoice uses com/sun/speech/freetts/en/us/f0_lr_terms.txt.

The ContourGenerator iterates through each syllable in the Utterance and applies the linear regression model as follows:
* For each entry in the feature/model/terms table, extract the named feature.
* Compare the feature value to the ToBI label as specified in the table.
* If the features match, then use the start/midpoint and end to update the curve.
* Add the new target point to the target Relation

ftts'PartOfSpeechTagger'CLASS

name::
* McsEngl.ftts'PartOfSpeechTagger'CLASS@cptItsoft,

public class com.sun.speech.freetts.en.PartOfSpeechTagger
extends java.lang.Object
implements UtteranceProcessor

Tags the words in the utterance with their part-of-speech. Currently this does nothing.

ftts'PostLexicalAnalyzer'CLASS

name::
* McsEngl.ftts'PostLexicalAnalyzer'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.en.PostLexicalAnalyzer
extends java.lang.Object
implements UtteranceProcessor

Annotates the utterance with post lexical information.
The PostLexicalAnalyzer is responsible for performing any fix ups before the next phase of processing. For instance, the CMUDiphoneVoice provides a PostLexicalAnalyzer that performs two functions:
Fix AH The diphone data for the CMUDiphoneVoice does not have any diphone data for the "ah" diphone. The CMU Lexicon that is used by the CMUDiphoneVoice, however, contains a number of words that reference the "ah" diphone. The CMUDiphoneVoice PostLexicalAnalyzer iterates through all phones in the segment Relation and replaces them with "aa" diphones.
Fix Apostrophe-S This step iterates through the segments and looks for words associated with the segments that contain an apostrophe-s. The processor then inserts a 'schwa' phoneme in certain cases.

ftts'PauseGenerator'CLASS

name::
* McsEngl.ftts'PauseGenerator'CLASS@cptItsoft,

public class com.sun.speech.freetts.en.PauseGenerator
extends java.lang.Object
implements UtteranceProcessor

Annotates an utterance with pause information.

The PauseGenerator annotates an Utterance with pause information. It inserts a pause at the beginning of the segment list (thus all Utterances start with a pause). It then iterates through the phrase Relation (set up by the Phraser) and inserts a pause before the first segment of each phrase.

ftts'TokenizerImpl'CLASS

name::
* McsEngl.ftts'TokenizerImpl'CLASS@cptItsoft,

** The tokenizer takes as input a SPEAKABLE and outputs tokens and breaks. The list of tokesn among breakes is the utterances.

CLASS: public class TokenizerImpl implements Tokenizer,
PACKAGE: com.sun.speech.freetts.en

ftts'engine'PACKAGE

name::
* McsEngl.ftts'engine'PACKAGE@cptItsoft,

FULLNAME: com.sun.speech.engine

DEFINETRO:
contains support for JSAPI 1.0. Various packages can be found in this tree.
[API 1.2.1]

ftts'freetts'PACKAGE

name::
* McsEngl.ftts'freetts'PACKAGE@cptItsoft,

FULLNAME: com.sun.speech.freetts

PART: PACKAGE:
The com.sun.speech.freetts package is broken down further into sets of sub-packages as follows:

* com.sun.speech.freetts contains high-level interfaces and classes for FreeTTS. Much non-language and voice dependent code can be found here.
* com.sun.speech.freetts.diphone provides support for diphone encoded speech.
* com.sun.speech.freetts.clunits provides support for cluster-unit encoded speech.
* com.sun.speech.freetts.lexicon provides definition and implementation of the Lexicon and Letter-to-Sound Rules.
* com.sun.speech.freetts.util provides a set of tools and utilities.
* com.sun.speech.freetts.audio provides audio output support.
* com.sun.speech.freetts.cart provides interface and implementations of several Classification and Regression Trees (CART).
* com.sun.speech.freetts.relp provides support for Residual Excited Linear Predictive (RELP) decoding of audio samples.
* com.sun.speech.freetts.en contains English specific code.
* com.sun.speech.freetts.en.us contains US-English specific code.
[API 1.2.1]

ftts'Dumpable'INTERFACE

name::
* McsEngl.ftts'Dumpable'INTERFACE@cptItsoft,

DEFINETRO:
public interface com.sun.speech.freetts.Dumpable

Tags an object that can be dumped for debugging purposes.

METHOD:
public void dump(PrintWriter pw, int padding, String title);
- @param padding the number of spaces in the string

ftts'FeatureProcessor'INTERFACE

name::
* McsEngl.ftts'FeatureProcessor'INTERFACE@cptItsoft,

_DEFINITION:
public interface com.sun.speech.freetts.FeatureProcessor.

Performs a specific type of processing on an item and returns an object.

_PART:
method Summary
java.lang.String process(Item#ql:ftts'item'class# item)
Performs some processing on the given item.

_SPESIFEPTO:
* All Known Implementing Classes:
FeatureProcessors.Accented, FeatureProcessors.AccentedSylIn, FeatureProcessors.Gpos, FeatureProcessors.LastAccent, FeatureProcessors.MonthRange, FeatureProcessors.NumDigits, FeatureProcessors.PH_CPlace, FeatureProcessors.PH_CType, FeatureProcessors.PH_CVox, FeatureProcessors.PH_VC, FeatureProcessors.PH_VFront, FeatureProcessors.PH_VHeight, FeatureProcessors.PH_VLength, FeatureProcessors.PH_VRnd, FeatureProcessors.PosInSyl, FeatureProcessors.PositionType, FeatureProcessors.SegCodaFric, FeatureProcessors.SegCodaGlide, FeatureProcessors.SegCodaNasal, FeatureProcessors.SegCodaStop, FeatureProcessors.SegmentDuration, FeatureProcessors.SegOnsetCoda, FeatureProcessors.SegOnsetFric, FeatureProcessors.SegOnsetGlide, FeatureProcessors.SegOnsetNasal, FeatureProcessors.SegOnsetStop, FeatureProcessors.StressedSylIn, FeatureProcessors.StressedSylOut, FeatureProcessors.SubPhrases, FeatureProcessors.SylBreak, FeatureProcessors.SylCodaSize, FeatureProcessors.SylIn, FeatureProcessors.SylOnsetSize, FeatureProcessors.SylOut, FeatureProcessors.TokenPosGuess, FeatureProcessors.WordBreak, FeatureProcessors.WordNumSyls, FeatureProcessors.WordPunc

* (inner-classes of com.sun.speech.freetts.en.us.FeatureProcessors)
"word_break", WordBreak();
"word_punc", WordPunc();
"gpos", Gpos(pos);
"word_numsyls", WordNumSyls();
"ssyl_in", StressedSylIn();
"syl_in", SylIn();
"syl_out", SylOut();
"ssyl_out", StressedSylOut();
"syl_break", SylBreak();
"old_syl_break", SylBreak();
"num_digits", NumDigits();
"month_range", MonthRange();
"token_pos_guess", TokenPosGuess();
"segment_duration", SegmentDuration();
"sub_phrases", SubPhrases();
"asyl_in", AccentedSylIn();
"last_accent", LastAccent();
"pos_in_syl", PosInSyl();
"position_type", PositionType();
"ph_cplace", PH_CPlace();
"ph_ctype", PH_CType();
"ph_cvox", PH_CVox();
"ph_vc", PH_VC();
"ph_vfront", PH_VFront();
"ph_vheight", PH_VHeight();
"ph_vlng", PH_VLength();
"ph_vrnd", PH_VRnd();
"seg_coda_fric", SegCodaFric();
"seg_onset_fric", SegOnsetFric();
"seg_coda_stop", SegCodaStop();
"seg_onset_stop", SegOnsetStop();
"seg_coda_nasal", SegCodaNasal();
"seg_onset_nasal", SegOnsetNasal();
"seg_coda_glide", SegCodaGlide();
"seg_onset_glide", SegOnsetGlide();
"seg_onsetcoda", SegOnsetCoda();
"syl_codasize", SylCodaSize();
"syl_onsetsize", SylOnsetSize();
"accented", Accented();

ftts'FeatureSet'INTERFACE

name::
* McsEngl.ftts'FeatureSet'INTERFACE@cptItsoft,

_DEFINITION:
public interface com.sun.speech.freetts.FeatureSet
extends Dumpable

FeatureSets are merely name/value pairs, that an ITEM contains.

An Utterance consists of a set of Relations and a set of features called FeatureSets.

CLASS: public class FeatureSetImpl implements FeatureSet

PACKAGE: com.sun.speetch.freetts

ftts'FEATURE.accent:
!H*,
H*, default
L+H*,
NONE

ftts'feature.endtone:
H-,
H-H%,
L-H%,
L-L%, default
NONE

ftts'FEATURE:
FEATURE_SILENCE = pau
join_type = simple_join

break = 1
name =
R:SylStructure.parent.R:Token.parent.EMPH = String(1)

R:SylStructure.parent.R:Word.n.gpos = String(0)(cc)(content)(in)

R:SylStructure.parent.R:Word.p.gpos = String(0)(content)(in)

R:SylStructure.parent.R:Word.p.p.gpos = String(in)(to)

R:SylStructure.parent.gpos = String(aux)(cc)(det)(in)(md)(to)(wp)

n.R:SylStructure.parent.R:Token.parent.EMPH = String(1)

n.n.syl_break = String(0)
n.n.syl_break = String(3)

n.stress = String(0)

n.syl_break = String(0)
n.syl_break = String(1)

p.R:SylStructure.parent.R:Token.parent.EMPH = String(1)

p.p.syl_break = String(0,3,4)

p.syl_break = String(0,3)

ssyl_in = String(0,1,3,4,10)

ssyl_out = String(2,4,10)

stress = String(0)

syl_break = String(0,1,3)

syl_in = String(2,3,4,6,7)

syl_out = String(0,2,4,5)

ftts'feature.UTTERANCE:
* input_text = contains the text we want to speak.
* target_lpcres = LPCResult
* UTT_NAME (SampleInfo) = SampleInfo

ftts'FreeTTSSpeakable'INTERFACE

name::
* McsEngl.ftts'FreeTTSSpeakable'INTERFACE@cptItsoft,

DEFINETRO:
public interface com.sun.speech.freetts.FreeTTSSpeakable

Represents something that should be spoken.

Anything that is a source of text that needs to be spoken with FreeTTS is first converted into a FreeTTSSpeakable. One implementation of this interface is FreeTTSSpeakableImpl. This implementation will wrap the most common input forms (a String, an InputStream, or a JSML XML document) as a FreeTTSSpeakable. A FreeTTSSpeakable is given to a Voice to be spoken.

_SPESIFEPTO:
All Known Implementing Classes:
FreeTTSSpeakableImpl, FreeTTSSynthesizerQueueItem

ftts'UtteranceProcessor'INTERFACE

name::
* McsEngl.ftts'UtteranceProcessor'INTERFACE@cptItsoft,

_DEFINITION:
Interface com.sun.speech.freetts.UtteranceProcessor

An UtteranceProcessor is any object that implements the UtteranceProcessor interface. An UtteranceProcessor takes as input an Utterance and performs some operation on the Utterance.

_WHOLE:
PACKAGE: com.sun.speech.freetts,

PART: METHOD:
void processUtterance(Utterance u),

_SPESIFEPTO:
All Known Implementing Classes:
AudioOutput,
ClusterUnitPitchmarkGenerator,
ClusterUnitSelector,
ContourGenerator,
DiphonePitchmarkGenerator,
DiphoneUnitSelector,
Durator,
Intonator,
PartOfSpeechTagger,
PauseGenerator,
Phraser,
PostLexicalAnalyzer,
Segmenter,
TokenToWords,
UnitConcatenator,
Voice, (this recals all other processors)

ftts'FeatureSetImpl'CLASS

name::
* McsEngl.ftts'FeatureSetImpl'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.FeatureSetImpl
extends java.lang.Object
implements FeatureSet

PART-FIELD:
private Map featureMap;
static DecimalFormat formatter;

ftts'Utterance'CLASS

name::
* McsEngl.ftts'Utterance'CLASS@cptItsoft,

_DEFINITION:
public class com.sun.speech.freetts.Utterance
extends java.lang.Object
implements FeatureSet, java.io.Serializable

The Voice converts a FreeTTSSpeakable into a series of Utterances.
The rules for breaking a FreeTTSSpeakable into an Utterance is generally language dependent. For instance, an English Voice may chose to break a FreeTTSSpeakable into Utterances based upon sentence breaks.

An Utterance consists of a set of Relations and a set of features called FeatureSets.
[\JAVA\APP\FREETTS\FTTS110\docs\ProgrammerGuide.html]

The basic building block for Festival is the utterance. The structure consists of a set of relations over a set of items. Each item represents a object such as a word, segment, syllable, etc. while relations relate these items together. An item may appear in multiple relations, such as a segment will be in a Segment relation and also in the SylStructure relation. Relations define an ordered structure over the items within them, in general these may be arbitrary graphs but in practice so far we have only used lists and trees Items may contain a number of features.
[festvox_7.html]

_WHOLE: PACKAGE: package com.sun.speech.freetts;

PART: FIELD:
private Voice voice;
private FeatureSetImpl#ql:ftts'featuresetimpl'class# features;
private FeatureSetImpl relations;
private Vector listeners = null;
private boolean first; // first utterance in a connected series
private boolean last; // last in a connected series
private FreeTTSSpeakable speakable;

ftts'Relation'CLASS

name::
* McsEngl.ftts'Relation'CLASS@cptItsoft,

_DEFINITION:
public class com.sun.speech.freetts.Relation
extends java.lang.Object
implements Dumpable,

Represents an ordered set of Items and their associated children. A relation has a name and a list of items, and is added to an Utterance via an UtteranceProcessor.
[API 121]

A Relation is a named LIST of Items. An Utterance can hold an arbitrary number of Relations. A typical UtteranceProcessor may iterate through one Relation and create a new Relation. For instance, a word normalization UtteranceProcessor could iterate through a token Relation and generate a word Relation based upon token-to-word rules. A detailed description of the Utterance processing and how it affects the Relations in an Utterance is described below

_WHOLE: PACKAGE:
package com.sun.speech.freetts;

_WHOLE:
Utterance.relations (FeatureSet).
The FeatureSet "relations" of the class Utterance, contains the relations.

PART-FIELD:
private String name;
private Utterance#ql:ftts'utterance'class# owner; An utterance can have many Relations.
private Item#ql:ftts'item'class# head; The FIRST Item of this relation
private Item tail; The LAST Item of this relation

_SPESIFEPTO:
Relation: Created by:
Token (Utterance)
Word (WordRelation)
Phrase (CARTPhraser)
Syllable (Segmenter|Intonator)
SylStructure (Segmenter)
Segment (Segmenter)
Target (ContourGenerator)
Unit (DiphoneUnitSelector)

ftts'TOKEN'RELATION (ftts'Relation.TOKEN)

name::
* McsEngl.ftts'TOKEN'RELATION (ftts'Relation.TOKEN)@cptItsoft,

** A Tokenizer breaks an input stream of text into a series of Tokens defined by the com.sun.speech.freetts.Token class. Typically, a Token represents a single word in the input stream. Additionally, a Token will include such information as the surrounding punctuation and whitespace, and the position of the token in the input stream.
The English Tokenizer (com.sun.speech.freetts.en.TokenizerImpl) relies on a set of symbols being defined that specify what characters are to be considered whitespace and punctuation.
The Tokenizer defines a method called isBreak that is used to determine when the input stream should be broken and a new Utterance is generated. For example, the English Tokenizer has a set of rules to detect an end of sentence. If the current token should start a new sentence, then the English Tokenizer isBreak method returns true.
A higher level Tokenizer, FreeTTSSpeakableTokenizer repeatedly calls the English Tokenizer and places each token into a list. When the Tokenizer isBreak method indicates that a sentence break has occurred, the Voice creates a new Utterance with the current list of tokens.

CREATION:
Relation.Token is created with Utterance creation through Tokenizer of Voice.

========= Relation: Token =========
Token:thank
line_number=0
file_pos=6
punc=
prepunctuation=
whitespace=
d:thank
Token:you
line_number=0
file_pos=10
punc=.
prepunctuation=
whitespace=
d:you

ftts'WORD'RELATION (ftts'Relation.WORD)

name::
* McsEngl.ftts'WORD'RELATION (ftts'Relation.WORD)@cptItsoft,

The TokenToWords-UtteranceProcessor creates a word Relation from the token-Relation by iterating through the token Relation Item list and creating one or more words for each token. For most tokens there is a one to one relationship between words and tokens, in which case a single word Item is generated for the token item. Other tokens, such as: "2001" generate multiple words "two thousand one". Each word is created as an Item and added to the word Relation. Additionally, each word Item is added as a daughter to the corresponding token in the token Relation.

========= Relation: Word =========
Word:thank
Word:you

ftts'PHRASE'RELATION (ftts'Relation.FRASE)

name::
* McsEngl.ftts'PHRASE'RELATION (ftts'Relation.FRASE)@cptItsoft,

The Phraser-processor creates a phrase-Relation in the Utterance. The phrase Relation represents how the Utterance is to be broken into phrases when spoken. The phrase Relation consists of an Item marking the beginning of each phrase in the Utterance. This phrase Item has as its daughters the list of words that are part of the phrase.
The Phraser builds the phrase Relation by iterating through the Word Relation created by the TokenToWords processor. The Phraser uses a Phrasing CART to determine where the phrase breaks occur and creates the phrase Items accordingly.

========= Relation: Phrase =========
Phrase:BB
d:thank
d:you

ftts'SYLSTRUCTURE'RELATION (ftts'Relation.SYLSTRUCTURE)

name::
* McsEngl.ftts'SYLSTRUCTURE'RELATION (ftts'Relation.SYLSTRUCTURE)@cptItsoft,

The Segmenter is one of the more complex UtteranceProcessors. It is responsible for determining where syllable breaks occur in the Utterance. It organizes this information in several new Relations in the Utterance.
The Segmenter iterates through each word in the Utterance. For each word, the Segmenter performs the following steps:
Retrieves the phones that are associated with the word from the Lexicon . Each word is organized in a Relation called "SylStructure".
Iterates through each phone of the word, adding the phone to a Relation called "Segment".
Determines where syllable breaks occur (with help from the lexicon) and notes the syllable break points in a Relation called "Syllable"
If the lexicon indicates that a particular phone is stressed, then the syllable that contains that phone is marked as "stressed".
When the Segmenter is finished, three new Relations have been added to the Utterance that denote the syllable structure and units for the Utterance.

========= Relation: SylStructure =========
SylStructure:thank
d:
accent=H*
stress=1
d:th
end=0,328567
d:ae
end=0,467317
d:ng
end=0,548433
d:k
end=0,613050
SylStructure:you
d:
endtone=L-L%
stress=0
d:y
end=0,672579
d:uw
end=0,883995

CLUSTER: ========= Relation: SylStructure =========
SylStructure:the
d:
stress=0
d:dh
unit_this_move=5207
unit_prev_move=10106
selected_unit=211
clunit_cands=VC: Score 0 ival 233 Pos 0
clunit_name=dh_the
end=0,231057
d:ax
selected_unit=118
clunit_cands=VC: Score 0 ival 116 Pos 0
clunit_name=ax_the
end=0,276456

ftts'SEGMENT'RELATION (ftts'Relation.SEGMENT)

_CREATED: by Semgenter#ql:ftts'segmenter'class#.

name::
* McsEngl.ftts'SEGMENT'RELATION (ftts'Relation.SEGMENT)@cptItsoft,

MODIFIED:
* The Durator#ql:ftts'durator'class# is responsible for determining the ending time for each unit in the segment list.

========= Relation: Segment =========
Segment:pau
end=0,200000
d:pau-th
unit=pau-th
target_end=3200
Segment:th
end=0,328567
d:pau-th
unit=pau-th
target_end=4228
d:th-ae
unit=th-ae
target_end=5257

CLUSTER: ========= Relation: Segment =========
Segment:pau
selected_unit=645
clunit_cands=VC: Score 0 ival 664 Pos 0
clunit_name=pau_0
end=0,200000
Segment:dh
unit_this_move=5207
unit_prev_move=10106
selected_unit=211
clunit_cands=VC: Score 0 ival 233 Pos 0
clunit_name=dh_the
end=0,231057
Segment:ax
selected_unit=118
clunit_cands=VC: Score 0 ival 116 Pos 0
clunit_name=ax_the
end=0,276456

ftts'SYLLABLE'RELATION (ftts'Relation.SYLLABLE)

name::
* McsEngl.ftts'SYLLABLE'RELATION (ftts'Relation.SYLLABLE)@cptItsoft,

_CREATION:
* Segmenter.

_MODIFICATION:
* The Intonator#ql:ftts'intonator'class# processor annotates the syllable-Relation#ql:ftts'syllable'relation# of an Utterances with "accent" and "endtone" features.

========= Relation: Syllable =========
Syllable:
accent=H*
stress=1
Syllable:
endtone=L-L%
stress=0

ftts'TARGET'RELATION (ftts'Relation.TARGET)

name::
* McsEngl.ftts'TARGET'RELATION (ftts'Relation.TARGET)@cptItsoft,

The ContourGenerator is responsible for calculating the F0 (Fundamental Frequency) curve for an Utterance. The paper: Generating F0 contours from ToBI labels using linear regression by Alan W. Black, Andrew J. Hunt, describes the techniques used.
The ContourGenerator creates the "target" Relation and populates it with target points that mark the time and target frequency for each segment. The ContourGenerator is driven by a a file of feature model terms. For example, CMUDiphoneVoice uses com/sun/speech/freetts/en/us/f0_lr_terms.txt.

========= Relation: Target =========
Target:
f0=85,464897
pos=0,000000
Target:
f0=85,464897
pos=0,200000
Target:
f0=106,377335
pos=0,397942
Target:
f0=90,172653
pos=0,613050
Target:
f0=94,020287
pos=0,778287
Target:
f0=91,019341
pos=0,883995
Target:
f0=91,019341
pos=1,083995

ftts'UNIT'RELATION (ftts'relation.UNIT)

_CREATED: by XUnitSelector.

name::
* McsEngl.ftts'UNIT'RELATION (ftts'relation.UNIT)@cptItsoft,

The UnitSelector that is used by the CMUDiphoneVoice creates a Relation in the Utterance called "unit". This relation contains Items that represent the diphones for the unit. This processor iterates through the segment-list#ql:ftts'segment'relation# and builds up diphone names by assembling two adjacent phone names. The diphone is added to the unit Relation along with timing information about the diphone.

========= Relation: Unit =========
Unit:pau-th
unit=pau-th
target_end=3200
Unit:pau-th
unit=pau-th
target_end=4228
Unit:th-ae
unit=th-ae
target_end=5257
Unit:th-ae
unit=th-ae
target_end=6367
Unit:ae-ng
unit=ae-ng
target_end=7477
Unit:ae-ng
unit=ae-ng
target_end=8125
Unit:ng-k
unit=ng-k
target_end=8774
Unit:ng-k
unit=ng-k
target_end=9291
Unit:k-y
unit=k-y
target_end=9808
Unit:k-y
unit=k-y
target_end=10285
Unit:y-uw
unit=y-uw
target_end=10761
Unit:y-uw
unit=y-uw
target_end=12452
Unit:uw-pau
unit=uw-pau
target_end=14143
Unit:uw-pau
unit=uw-pau
target_end=15743

CLUSTER-UNIT: ========= Relation: Unit =========
Unit:pau
target_end=2075
instance=0
unit_end=10106
unit_start=10093
unit=pau_0
unit_entry=645
Unit:dh
target_end=4167
instance=22
unit_end=5220
unit_start=5207
unit=dh_the
unit_entry=211
Unit:ax
target_end=4629
instance=10
unit_end=5224
unit_start=5220
unit=ax_the
unit_entry=118

ftts'Item'CLASS

name::
* McsEngl.ftts'Item'CLASS@cptItsoft,

_DEFINETRO:
public class com.sun.speech.freetts.Item implements Dumpable

Represents a node in a Relation.
A Relation is a list of Item objects.

An Item contains a set of Features (as described previously, FeatureSets are merely name/value pairs).

An Item can have a list of daughter Items as well.

Items in a Relation are linked to Items in the same and other Relations. For instance, the words in a word Relation are linked back to the corresponding tokens in the token Relation. Similarly, a word in a word Relation is linked to the previous and next words in the word Relation. This gives an UtteranceProcessor the capability of easily traversing from one Item to another.

_WHOLE:
* PACKAGE: package com.sun.speech.freetts;
* OBJECT: A Relation is a list of Item objects.

PART: FIELD:
private Relation ownerRelation;
private ItemContents contents; (FeatureSet of features and relations)
private Item parent;
private Item daughter;
private Item next;
private Item prev;

PART: METHOD:
* public java.lang.Object findFeature(java.lang.String pathAndFeature)
Finds the feature by following the given path. Path is a string of ":" or "." separated strings with the following interpretations:
* n - next item
* p - previous item
* parent - the parent
* daughter - the daughter
* daughter1 - same as daughter
* daughtern - the last daughter
* R:relname - the item as found in the given relation 'relname'
The last element of the path will be interpreted as a voice/language specific feature function (if present) or an item feature name. If the feature function exists it will be called with the item specified by the path, otherwise, a feature will be retrieved with the given name. If neither exist than a String "0" is returned.

ftts'ItemContents'CLASS

name::
* McsEngl.ftts'ItemContents'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.ItemContents
extends java.lang.Object

Contains the information that is shared between multiple items.

PART-FIELD:
private FeatureSetImpl features;
private FeatureSetImpl relations;

ftts'Segmenter'CLASS

name::
* McsEngl.ftts'Segmenter'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.Segmenter
extends java.lang.Object
implements UtteranceProcessor

Annotates an utterance with Relation.SYLLABLE, Relation.SYLLABLE_STRUCTURE, and Relation.SEGMENT. To determine stress, the isStressed method relies upon a phone ending in the number "1". Subclasses should override isStressed and deStress if stresses are determined in other ways.

ftts'Voice'CLASS

name::
* McsEngl.ftts'Voice'CLASS@cptItsoft,

_DEFINITION:
public abstract class com.sun.speech.freetts.Voice
extends java.lang.Object
implements UtteranceProcessor, Dumpable

The Voice is the central processing point for FreeTTS. The Voice takes as input a FreeTTSSpeakable, translates the text associated with the FreeTTSSpeakable into speech and generates audio output corresponding to that speech. The Voice is the primary customization point for FreeTTS. Language, speaker, and algorithm customizations can all be performed by extending the Voice.

Performs text-to-speech using a series of UtteranceProcessors. It is the main conduit to the FreeTTS speech synthesizer. It can perform TTS on ASCII text, a JSML document, an InputStream, or a FreeTTSSpeakable, by invoking the method speak.
Before a Voice can perform TTS, it must have a Lexicon, from which it gets the vocabulary, and an AudioPlayer, to which it sends the synthesized output.
Example (using the CMUDiphoneVoice, CMULexicon and JavaClipAudioPlayer):
Voice voice = new CMUDiphoneVoice();
// sets the Lexicon
voice.setLexicon(new CMULexicon());
// sets the AudioPlayer
voice.setAudioPlayer(new JavaClipAudioPlayer());
// loads the Voice
voice.load();
// start talking
voice.speak("I can talk forever without getting tired!");

INPUT:
A Voice will accept a FreeTTSSpeakable via the Voice.speak method and process it.

PART: METHOD:
* The speak() method of Voice takes the "speakable" and creates "utterances" with tokens.

ftts'VoiceManager'CLASS

name::
* McsEngl.ftts'VoiceManager'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.VoiceManager
extends java.lang.Object

Provides access to voices for all of FreeTTS. There is only one instance of the VoiceManager. Each call to getVoices() creates a new instance of each voice.

ftts'lexicon'PACKAGE

name::
* McsEngl.ftts'lexicon'PACKAGE@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.lexicon.LetterToSoundImpl
extends java.lang.Object
implements LetterToSound

Provides the phone list for words using the CMU6 letter-to-sound (LTS) rules, which are based on the Black, Lenzo, and Pagel paper, "Issues in Building General Letter-to-Sound Rules." Proceedings of ECSA Workshop on Speech Synthesis, pages 77-80, Australia, 1998.

ftts'PROCESSING'WALKTHROUGH

name::
* McsEngl.ftts'PROCESSING'WALKTHROUGH@cptItsoft,

In this section we will describe the detailed processing performed by the CMUDiphoneVoice. This voice is an unlimited-domain voice that uses diphone synthesis to generate speech. It is derived from the CMUVoice class. The CMUVoice describes the general processing required for an English voice without specifying how unit selection and concatenation is performed. Subclasses of the CMUVoice (CMUDiphoneVoice and CMUClusterUnitVoice) provide this specialization.
Processing starts with the speak method found in com.sun.speech.freetts.Voice. The speak method performs the following tasks:
- Tokenization
- TokenToWords
- PartOfSpeechTagger
- Phraser
- Segmenter
- PauseGenerator
- Intonator
- PostLexicalAnalyzer
- Durator
- ContourGenerator
- UnitSelector
- PitchMarkGenerator
- UnitConcatenator

1) set the voice:
Voice voice = new CMUDiphoneVoice();
setRate(150f);
setPitch(100F);
setPitchRange(11F);

2) // sets the Lexicon:
voice.setLexicon(new CMULexicon());
this.lexicon = new CMULexicon()
this("cmulex");
Class cls = CMULexicon.class;
URL letterToSoundURL = cls.getResource(basename + "_lts.bin");
URL compiledURL = cls.getResource(basename + "_compiled.bin");
URL addendaURL = cls.getResource(basename + "_addenda.bin");
setLexiconParameters(compiledURL, addendaURL, letterToSoundURL, true);
//Type of lexicon to load: private boolean binary = false;

3) // sets the AudioPlayer:
voice.setAudioPlayer(new JavaClipAudioPlayer());
audioPlayer = player;
debug = Boolean.getBoolean("speech.audio.AudioPlayer.debug");
closeDelay = Long.getLong ("speech.audio.AudioPlayer.closeDelay", 150L).longValue();
setPaused(false);

4) // loads the Voice:
voice.load();
lexicon.load();
BulkTimer.LOAD.start("Lexicon");
InputStream compiledIS = Utilities.getInputStream(compiledURL);
InputStream addendaIS = Utilities.getInputStream(addendaURL);
addenda = createLexicon(addendaIS, binary, 50);
compiled = createLexicon(compiledIS, binary, 65000);
addendaIS.close();
compiledIS.close();
loaded = true;
BulkTimer.LOAD.stop("Lexicon");
letterToSound = new LetterToSoundImpl(letterToSoundURL, binary);
audioOutput = getAudioOutput();
if (outputQueue == null) { outputQueue = createOutputThread();}
loader();
loaded = true;

loader();
setupFeatureSet();
FeatureSet features = getFeatures();
features.setString(FEATURE_SILENCE, "pau");
features.setString("join_type", "simple_join");

setupUtteranceProcessors();
List processors = getUtteranceProcessors();
BulkTimer.LOAD.start("CartLoading");
CARTImpl numbersCart = new CARTImpl(this.getClass().getResource("nums_cart.txt"));
CARTImpl phrasingCart = new CARTImpl(this.getClass().getResource("phrasing_cart.txt"));
CARTImpl accentCart = new CARTImpl(this.getClass().getResource("int_accent_cart.txt"));
CARTImpl toneCart = new CARTImpl(this.getClass().getResource("int_tone_cart.txt"));
CARTImpl durzCart = new CARTImpl(this.getClass().getResource("durz_cart.txt"));
BulkTimer.LOAD.stop("CartLoading");
BulkTimer.LOAD.start("UtteranceProcessors");
PhoneDurations phoneDurations = new PhoneDurationsImpl( this.getClass().getResource("dur_stat.txt"));
PronounceableFSM prefixFSM = new PrefixFSM (this.getClass().getResource("prefix_fsm.txt"));
PronounceableFSM suffixFSM = new SuffixFSM (this.getClass().getResource("suffix_fsm.txt"));

processors.add(new TokenToWords(numbersCart, prefixFSM, suffixFSM));
processors.add(new PartOfSpeechTagger());
processors.add(new Phraser(phrasingCart));
processors.add(new Segmenter());
processors.add(new PauseGenerator());
processors.add(new Intonator(accentCart, toneCart));
processors.add(getPostLexicalAnalyzer());
processors.add(new Durator(durzCart, 150.0f, phoneDurations));
processors.add(new ContourGenerator(this.getClass().getResource("f0_lr_terms.txt"), 170.0f, 34.0f));

processors.add(getUnitSelector());
processors.add(getPitchmarkGenerator());
processors.add(getUnitConcatenator());
BulkTimer.LOAD.stop("UtteranceProcessors");

setupFeatureProcessors();
BulkTimer.LOAD.start("FeatureProcessing");
PartOfSpeech pos = new PartOfSpeechImpl(this.getClass().getResource("part_of_speech.txt"), "content");
phoneSet = new PhoneSetImpl(this.getClass().getResource("phoneset.txt"));

addFeatureProcessor("word_break", new FeatureProcessors.WordBreak());
addFeatureProcessor("word_punc", new FeatureProcessors.WordPunc());
addFeatureProcessor("gpos", new FeatureProcessors.Gpos(pos));
addFeatureProcessor("word_numsyls",new FeatureProcessors.WordNumSyls());
addFeatureProcessor("ssyl_in", new FeatureProcessors.StressedSylIn());
addFeatureProcessor("syl_in", new FeatureProcessors.SylIn());
addFeatureProcessor("syl_out", new FeatureProcessors.SylOut());
addFeatureProcessor("ssyl_out", new FeatureProcessors.StressedSylOut());
addFeatureProcessor("syl_break", new FeatureProcessors.SylBreak());
addFeatureProcessor("old_syl_break", new FeatureProcessors.SylBreak());
addFeatureProcessor("num_digits", new FeatureProcessors.NumDigits());
addFeatureProcessor("month_range", new FeatureProcessors.MonthRange());
addFeatureProcessor("token_pos_guess", new FeatureProcessors.TokenPosGuess());
addFeatureProcessor("segment_duration", new FeatureProcessors.SegmentDuration());
addFeatureProcessor("sub_phrases", new FeatureProcessors.SubPhrases());
addFeatureProcessor("asyl_in", new FeatureProcessors.AccentedSylIn());
addFeatureProcessor("last_accent", new FeatureProcessors.LastAccent());
addFeatureProcessor("pos_in_syl", new FeatureProcessors.PosInSyl());
addFeatureProcessor("position_type", new FeatureProcessors.PositionType());
addFeatureProcessor("ph_cplace", new FeatureProcessors.PH_CPlace());
addFeatureProcessor("ph_ctype", new FeatureProcessors.PH_CType());
addFeatureProcessor("ph_cvox", new FeatureProcessors.PH_CVox());
addFeatureProcessor("ph_vc", new FeatureProcessors.PH_VC());
addFeatureProcessor("ph_vfront", new FeatureProcessors.PH_VFront());
addFeatureProcessor("ph_vheight", new FeatureProcessors.PH_VHeight());
addFeatureProcessor("ph_vlng", new FeatureProcessors.PH_VLength());
addFeatureProcessor("ph_vrnd", new FeatureProcessors.PH_VRnd());
addFeatureProcessor("seg_coda_fric", new FeatureProcessors.SegCodaFric());
addFeatureProcessor("seg_onset_fric", new FeatureProcessors.SegOnsetFric());
addFeatureProcessor("seg_coda_stop", new FeatureProcessors.SegCodaStop());
addFeatureProcessor("seg_onset_stop", new FeatureProcessors.SegOnsetStop());
addFeatureProcessor("seg_coda_nasal", new FeatureProcessors.SegCodaNasal());
addFeatureProcessor("seg_onset_nasal", new FeatureProcessors.SegOnsetNasal());
addFeatureProcessor("seg_coda_glide", new FeatureProcessors.SegCodaGlide());
addFeatureProcessor("seg_onset_glide", new FeatureProcessors.SegOnsetGlide());
addFeatureProcessor("seg_onsetcoda", new FeatureProcessors.SegOnsetCoda());
addFeatureProcessor("syl_codasize", new FeatureProcessors.SylCodaSize());
addFeatureProcessor("syl_onsetsize", new FeatureProcessors.SylOnsetSize());
addFeatureProcessor("accented", new FeatureProcessors.Accented());
BulkTimer.LOAD.stop("FeatureProcessing");

5) // start talking:
voice.speak("I can talk forever without getting tired!");
speak(new FreeTTSSpeakableImpl(text));
...tokenizes the speakable to utterances.
processUtterance(utterance);
...itterate through all uttprocessors
runProcessor(processors[i], u, runTimer);
outputUtterance(u, runTimer);
runProcessor(audioOutput, utterance, timer); (relp.AudioOutput)
processor.processUtterance(utterance);
LPCResult lpcResult = (LPCResult) utterance.getObject("target_lpcres");
SampleInfo sampleInfo = (SampleInfo) utterance.getObject(SampleInfo.UTT_NAME);
AudioPlayer audioPlayer = utterance.getVoice().getAudioPlayer();
audioPlayer.setAudioFormat(getAudioFormat(sampleInfo));
audioPlayer.setVolume(utterance.getVoice().getVolume());
utterance.getVoice().log(" AudioOutput: === " + utterance.getString("input_text"));
if (!lpcResult.playWave(audioPlayer)) {throw new ProcessException("Output Cancelled"); }
LPCResult.playWaveSamples(player, getNumberOfSamples() * 2);
player.begin(getNumberOfSamples() * 2);
ok = player.write(samples, 0, s);
write(audioData, 0, audioData.length); (JavaClipAudioPlayer)
System.arraycopy(bytes, offset, outputData, curIndex, size);
//the outputData has the audio data.
ok = player.end();
clip.start();
dumpWave(u); --->Voice.

ftts'relp'PACKAGE

name::
* McsEngl.ftts'relp'PACKAGE@cptItsoft,

FULLNAME: com.sun.speech.freetts.relp
Support for Residual Excited Linear Predictive (RELP) decoding of audio samples

Class Summary
AudioOutput Supports generating audio output from an utterance.
LPCResult Contains the result of linear predictive coding processing.
Sample A single short term sample containing Residual Excited Linear Predictive (RELP) frame and residual voice data.
SampleInfo Describes global sample parameters.
SampleSet Represents the frame and residual data used by the diphone database used Residual Excited Linear Predictive synthesizer
UnitConcatenator Concatenates the Units in the given Utterance to the target_lpc result.

ftts'AudioOutput'CLASS

name::
* McsEngl.ftts'AudioOutput'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.relpAudioOutput
implements UtteranceProcessor.

** FUNCTION:
Once all Utterance processing has been applied, the Voice sends the Utterance to the AudioOutput UtteranceProcessor. The AudioOutput processor may run in a separate thread to allow Utterance processing to overlap with audio output, ensuring the lowest sound latency possible.

ftts'LPCResult'CLASS

name::
* McsEngl.ftts'LPCResult'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.relp.LPCResult
extends java.lang.Object

Contains the result of linear predictive coding processing.

PART: METHOD:
* void dumpASCII()
Dumps the wave data associated with this result
* boolean playWave(AudioPlayer player, Utterance utterance)
Synthesize a Wave from this LPCResult

========== LPCResult ==========
Num_of_Frames: 98
Num_of_Channels: 16
Num_of_Samples: 17416
Sample_Rate: 16000
LPC_Minimum: -7,992630
LPC_Range: 15,822620
Residual_Fold: 1
Post_Emphasis: 0,000000
Times:
133 268 404 543 683 825 969 1115 1263 1414 1567 1722 1880 2040 2203 2370
...
Frames: 32076
31676
...
Sizes: 133 135 136 139 140 142 144 146 148 151 153 155 158 160 163 167 169 ...
Residuals: 254
255
...

ftts'Sample'CLASS

name::
* McsEngl.ftts'Sample'CLASS@cptItsoft,

_DEFINETRO:
public class com.sun.speech.freetts.relp.Sample
extends java.lang.Object

A single short term sample containing
- Residual Excited Linear Predictive (RELP) frame and
- residual voice data.

PART: FIELD:
** private short[] frameData;
** private byte[] residualData;
** private int residualSize; //Holds the quantity of residuals. It is the first number in RESIDUAL line.

NAME cmu_us_kal
SAMPLE_RATE 16000
NUM_CHANNELS 16
COEFF_MIN -7.992630
COEFF_RANGE 15.822620
DIPHONE aa-aa 0 7 13
FRAME 43223 18758 48823 20524 40364 29920 34186 29373 40545 24124 41173 28415 34282 34004 31267 33899
RESIDUAL 185 250 125 252 124 253 250 255 251 248 125 242 ...

* frameData is an array of size=num_channels (16)
* residualSize = 185
* residualData = byte[185]

ftts'UnitConcatenator'CLASS

name::
* McsEngl.ftts'UnitConcatenator'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.relp.UnitConcatenator
extends java.lang.Object
implements UtteranceProcessor

Concatenates the Units in the given Utterance to the target_lpc result. This class is an UtteranceProcessor. It defines a method processUtterance that helps populate the target_lpcres#ql:ftts'lpcresult'class# relation.

The UnitConcatenator processor is responsible for gathering all of the diphone data and joining it together. For each Item in the unit-Relation#ql:ftts'unit'relation# (recall this was the set of diphones) the UnitConcatenator extracts the unit sample data from the unit based upon the target times as stored in the LPC result.

ftts'ResourceInfHmnn#cptResource843#

name::
* McsEngl.ftts'ResourceInfHmnn@cptItsoft,

isrc.freetts:
* http://freetts.sourceforge.net/docs/index.php:

ftts'us'com'PACKAGE

name::
* McsEngl.ftts'us'com'PACKAGE@cptItsoft,

FULLNAME: com.sun.speech.freetts.en.us

PART: PACKAGE:
* cmu_us_kal#ql:ftts'cmu'us'kal'package#

PART: Class Summary:
CMUArcticVoice Experimental class that selects units for the CMU ARCTIC voices.
CMUClusterUnitVoice Defines voice that does cluster unit selection.
CMUDiphoneVoice Defines an unlimited-domain diphone synthesis based voice
CMULexicon Provides a CMU lexicon-specific implementation of a Lexicon that is stored in a text file.
CMUTimeLexicon Provides a CMU time lexicon-specific implementation of a Lexicon.
CMUTimeVoice Defines limited domain synthesis voice that specializes in telling the time.
CMUVoice Provides generic support for a CMU Voice
FeatureProcessors Provides the set of feature processors that are used by this language as part of the CART processing.
FeatureProcessors.Accented Checks to see if the given syllable is accented.
FeatureProcessors.AccentedSylIn Counts the number of accented syllables since the last major break.
FeatureProcessors.Gpos Returns a guess of the part-of-speech.
FeatureProcessors.LastAccent Find the last accented syllable This is a feature processor.
FeatureProcessors.MonthRange Returns true ("1") if the given item is a number between 0 and 32 exclusive, otherwise, returns "0".
FeatureProcessors.NumDigits Returns the length of the string.
FeatureProcessors.PH_CPlace Return consonant cplace l-labial a-alveolar p-palatal b-labio_dental d-dental v-velar This is a feature processor.
FeatureProcessors.PH_CType Return consonant type s-stop f-fricative a-affricative n-nasal * l-liquid This is a feature processor.
FeatureProcessors.PH_CVox Return consonant voicing +=on -=off This is a feature processor.
FeatureProcessors.PH_VC Return vowel or consonant +=on -=off This is a feature processor.
FeatureProcessors.PH_VFront Return vowel frontness 1-front 2-mid 3-back This is a feature processor.
FeatureProcessors.PH_VHeight Return vowel height 1-high 2-mid 3-low This is a feature processor.
FeatureProcessors.PH_VLength Return vowel length s-short l-long d-dipthong a-schwa This is a feature processor.
FeatureProcessors.PH_VRnd Return vowel rnd (lip rounding) lip rounding +=on -=off This is a feature processor.
FeatureProcessors.PosInSyl Finds the position of the phoneme in the syllable This is a feature processor.
FeatureProcessors.PositionType Classifies the the syllable as single, initial, mid or final.
FeatureProcessors.SegCodaFric Checks for fricative This is a feature processor.
FeatureProcessors.SegCodaGlide Checks for coda glide This is a feature processor.
FeatureProcessors.SegCodaNasal Checks for coda nasal This is a feature processor.
FeatureProcessors.SegCodaStop Checks for coda stop This is a feature processor.
FeatureProcessors.SegmentDuration Returns the duration of the given segment This is a feature processor.
FeatureProcessors.SegOnsetCoda Checks for onset coda This is a feature processor.
FeatureProcessors.SegOnsetFric Checks for fricative This is a feature processor.
FeatureProcessors.SegOnsetGlide Checks for onset glide This is a feature processor.
FeatureProcessors.SegOnsetNasal Checks for onset nasal This is a feature processor.
FeatureProcessors.SegOnsetStop Checks for onset stop This is a feature processor.
FeatureProcessors.StressedSylIn Counts the number of stressed syllables since the last major break.
FeatureProcessors.StressedSylOut Counts the number of stressed syllables until the next major break.
FeatureProcessors.SubPhrases Counts the number of phrases before this one.
FeatureProcessors.SylBreak Determines the break level after this syllable This is a feature processor.
FeatureProcessors.SylCodaSize Determines the coda size This is a feature processor.
FeatureProcessors.SylIn Counts the number of stressed syllables since the last major break.
FeatureProcessors.SylOnsetSize Determines the onset size of this syllable This is a feature processor.
FeatureProcessors.SylOut Counts the number of stressed syllables since the last major break.
FeatureProcessors.TokenPosGuess Attempts to guess the part of speech.
FeatureProcessors.WordBreak Determines the word break.
FeatureProcessors.WordNumSyls Returns as an Integer the number of syllables in the given word.
FeatureProcessors.WordPunc Determines the word punctuation.
NumberExpander Expands Strings containing digits characters into a list of words representing those digits.
PrefixFSM Implements a finite state machine that checks if a given string is a prefix.
PronounceableFSM Implements a finite state machine that checks if a given string is pronounceable.
SuffixFSM Implements a finite state machine that checks if a given string is a suffix.
TokenToWords Converts the Tokens (in US English words) in an Utterance into a list of words.
USEnglish Provides the definitions for US English whitespace, punctuations, prepunctuation, and postpunctuation symbols.
WordRelation Helper class to add words and breaks into a Relation object.

ftts'CMUVoice'CLASS

name::
* McsEngl.ftts'CMUVoice'CLASS@cptItsoft,

DEFINETRO:
public abstract class com.sun.speech.freetts.en.us.CMUVoice
extends Voice

Provides generic support for a CMU Voice

Direct Known Subclasses:
CMUClusterUnitVoice, CMUDiphoneVoice, MbrolaVoice

ftts'TokenToWords'CLASS

name::
* McsEngl.ftts'TokenToWords'CLASS@cptItsoft,

DEFINETRO:
public class com.sun.speech.freetts.en.us.TokenToWords
extends java.lang.Object
implements UtteranceProcessor

Converts the Tokens (in US English words) in an Utterance into a list of words. It puts the produced list back into the Utterance. Usually, the tokens that gets expanded are numbers like "23" (to "twenty" "three").

* It translates the following code from flite:
lang/usenglish/us_text.c

The TokenToWords UtteranceProcessor creates a word Relation from the token Relation by iterating through the token Relation Item list and creating one or more words for each token. For most tokens there is a one to one relationship between words and tokens, in which case a single word Item is generated for the token item. Other tokens, such as: "2001" generate multiple words "two thousand one". Each word is created as an Item and added to the word Relation. Additionally, each word Item is added as a daughter to the corresponding token in the token Relation.
** PACKAGE: com.sun.speech.freetts.en.us.
** ADDITION: voice.processors.add(new TokenToWords(numbersCart, prefixFSM, suffixFSM));
where:
PronounceableFSM prefixFSM = new PrefixFSM (this.getClass().getResource("prefix_fsm.txt"));
PronounceableFSM suffixFSM = new SuffixFSM (this.getClass().getResource("suffix_fsm.txt"));

ftts'PronounceableFSM:
public class PronounceableFSM
Implements a finite state machine that checks if a given string is pronounceable. If it is pronounceable, the method accept() will return true.

ftts'us'de'PACKAGE

name::
* McsEngl.ftts'us'de'PACKAGE@cptItsoft,

FULLNAME:

ftts'util'PACKAGE

name::
* McsEngl.ftts'util'PACKAGE@cptItsoft,

FULLNAME: com.sun.speech.freetts.util
Provides a set of tools and utililties used by FreeTTS

Class Summary
BulkTimer Provides a suite of timers that are used to collect and generate performance metrics for FreeTTS.
SegmentRelationUtils Provides a set of utilities for the SegmentRelation.
Timer Keeps track of execution times.
Utilities Provides a set of generic utilities used by freetts.
WaveUtils Provides a set of utilities for prrocessing wave/audio data.

DEFINITION

Pellet is a free open-source Java-based reasoner for SROIQ with simple datatypes (i.e., for OWL 1.1). It implements a tableau-based decision procedure for general TBoxes (subsumption, satisfiability, classification) and ABoxes (retrieval, conjunctive query answering). It supports the OWL-API, the DIG-API, and Jena interface and comes with numerous other features.
[http://www.cs.man.ac.uk/~sattler/reasoners.html]

Pellet, in its core, is a Description Logic reasoner based on tableaux
algorithms. The tableaux reasoner checks the consistency of a knowledge
base and all the other reasoning services are reduced to consistency
checking. The reasoner is designed so that different tableaux algorithms
can be plugged in. The default algorithm handles SROIQ(D)
but there are several other tableaux algorithms implemented, e.g. for
non-monotonic extensions and for integration with rules.
[http://pellet.owldl.com/papers/sirin07pellet.pdf]

pellet'GENERIC

_GENERIC:
* DESCRIPTION_LOGIC_SYSTEM#cptIt503#

pellet'FUNCTION

name::
* McsEngl.pellet'FUNCTION@cptItsoft,

pellet'OPTIMIZATION

name::
* McsEngl.pellet'OPTIMIZATION@cptItsoft,

Optimizations Pellet implements most of the state of the art optimization techniques provided in the DL literature including
- Normalization,
- Simplification,
- Absorption,
- Semantic Branching,
- Backjumping,
- Caching Satisfiability Status,
- Top-Bottom Search for Classification, and
- Model Merging (see [2] for details about these techniques).
In addition, Pellet incorporates several novel optimizations to improve
the reasoning performance in the presence of nominals (enumerated
classes) and individuals. Reasoning with nominals is especially
challenging since some of the existing optimizations in DL
reasoners, such as Chain Contraction, are not applicable anymore.
Moreover, in the presence of nominals, assertions about instances can
affect the concept satisfiability and classification results.We have developed
a suite of new optimizations to tackle this problem. Two key
ones are (see [3] for the rest) are Nominal Absorption, a technique
where axioms involving enumerations are absorbed into type assertions,
and Nominal-based Model Merging, a technique to detect obvious
non-subsumptions and non-instantiations by exploiting the fact
that nominals always have a fixed interpretation in the domain. These
optimizations prove sufficient to handle even the notoriously difficult
Wine ontology, and, indeed, all ontologies with nominals we have
encountered.
Another novel optimization technique implemented in Pellet is for incremental
reasoning against dynamic knowledge bases. In many contexts
(ontology editors, web portals, sensor streams), the knowledge
base is in constant flux.We have developed techniques [4] to reuse the
reasoning results from previous steps to process updates incrementally.
Our preliminary results show up to three orders of magnitude
improvement after an ABox addition or deletion.
[http://pellet.owldl.com/papers/sirin07pellet.pdf]

pellet'PACKAGE

name::
* McsEngl.pellet'PACKAGE@cptItsoft,

pellet'SERVICE

name::
* McsEngl.pellet'SERVICE@cptItsoft,

FEATURES:
* Standard Reasoning Services
* Multiple Interfaces to the Reasoner
* Conjunctive Query Answering
* Datatype Reasoning
* Rules Support
* Ontology Analysis and Repair
* Ontology Debugging
* Incremental Reasoning
[http://pellet.owldl.com/features]

It offers a panoply of features including conjunctive query answering,
rule support, E-Connection reasoning, and axiom pinpointing,
among others.
[http://pellet.owldl.com/papers/sirin07pellet.pdf]

pellet'ResourceInfHmnn#cptResource843#

name::
* McsEngl.pellet'ResourceInfHmnn@cptItsoft,

SITE:
http://pellet.owldl.com//

pellet'STRUCTURE

name::
* McsEngl.pellet'STRUCTURE@cptItsoft,

System Architecture Figure 1 shows the main components of Pellet.
Pellet, in its core, is a Description Logic reasoner based on tableaux
algorithms. The tableaux reasoner checks the consistency of a knowledge
base and all the other reasoning services are reduced to consistency
checking. The reasoner is designed so that different tableaux algorithms
can be plugged in. The default algorithm handles SROIQ(D)
but there are several other tableaux algorithms implemented, e.g. for
non-monotonic extensions and for integration with rules.
[http://pellet.owldl.com/papers/sirin07pellet.pdf]

pellet'USER-INTERFACE

name::
* McsEngl.pellet'USER-INTERFACE@cptItsoft,

To make its reasoning capabilities easily accessible to users, Pellet provides various interfaces including
- a commandline interface,
- an interactiveWeb form for zero-install use,
- DIG server implementation, and
- API bindings for RDF/OWL toolkits Jena and Manchester OWL-API.
[http://pellet.owldl.com/papers/sirin07pellet.pdf]

pellet'VERSION

name::
* McsEngl.pellet'VERSION@cptItsoft,

* pellet-1.5.0.zip (Jul 20, 2007)
* pellet-1.5-RC1.zip (Jun 7, 2007)
* pellet-1.4.zip (Mar 16, 2007)

pellet'ENVIRONMENT

name::
* McsEngl.pellet'ENVIRONMENT@cptItsoft,

pellet'CREATOR

name::
* McsEngl.pellet'CREATOR@cptItsoft,

Contributors, Funders, and Friends of Pellet
Pellet was started at the Mindswap Lab directed by Dr. James Hendler and funded by various organizations. The project was initiated by Bijan Parsia and mainly implemented by Evren Sirin. Over the years, many other people contributed to Pellet (in alpahabetical order): Ron Alford, Bernardo Cuenca-Grau, Christian Halaschek-Wiener, Daniel Hewlett, Michael Grove, Aditya Kalyanpur, Jordan Katz, Vladimir Kolovski, Rick Murphy, Edna Ruckhaus, Michael Smith. Pellet has also received many bug reports and fixes from users, which helped us improve the quality of the reasoner.

As of the 1.4 release, Pellet development shifted to Clark & Parsia, which offers commercial support and customization for Pellet.
[http://pellet.owldl.com/about/]

overview of itsoft

FvMcs.3DGRAPH

GENERIC

OPERATING-SYSTEM#cptIt434#

STORAGE#cptIt14#

FvMcs.3D Studio

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

FvMcs.3S/ITP

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

OPERATING-SYSTEM#cptIt434#

FvMcs.3S/ΑΚΤΟΠΛΟΙΚΑ

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

FvMcs.AAPLAY

DEFINITION

GENERIC

OPERATING-SYSTEM#cptIt434#

STORAGE#cptIt14#

FvMcs.ACROBAT

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

DOING#cptCore475#

OPERATING-SYSTEM#cptIt434#

PRICE#cptEconomy541.44#

STORAGE#cptIt14#

FvMcs.ACTION

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

OPERATING-SYSTEM#cptIt434#

PRICE#cptEconomy541.44#

FvMcs.ACTOR

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

OPERATING-SYSTEM#cptIt434#

PRICE#cptEconomy541.44#

FvMcs.ADDRESS BANK

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

STORAGE#cptIt14#

FvMcs.ADOBE ILLUSTRATOR

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

OPERATING-SYSTEM#cptIt434#

FvMcs.ΑMI PRO

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

EVALUATION#cptCore546.107#

DOING#cptCore475#

OPERATING-SYSTEM#cptIt434#

PRICE#cptEconomy541.44#

FvMcs.ANIMATOR STUDIO

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

DOING#cptCore475#

FvMcs.APPROACH; Lotus

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

EVOLUTION#cptCore546.171#

VERSION#cptIt471#

OPERATING-SYSTEM#cptIt434#

FvMcs.ARCVIEW

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

OPERATING-SYSTEM#cptIt434#

FvMcs.ARTIST

DEFINITION

GENERIC

INFO-TECH-BUSINESS#cptEconomy7.108#

PRICE#cptEconomy541.44#

STORAGE#cptIt14#