home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_jade.idb / usr / freeware / include / sp / lib / Parser.h.z / Parser.h
Encoding:
C/C++ Source or Header  |  1999-07-21  |  14.8 KB  |  412 lines
  1. // Copyright (c) 1994 James Clark
  2. // See the file COPYING for copying permission.
  3.  
  4. #ifndef Parser_INCLUDED
  5. #define Parser_INCLUDED 1
  6.  
  7. #ifdef __GNUG__
  8. #pragma interface
  9. #endif
  10.  
  11. #include "types.h"
  12. #include "Attribute.h"
  13. #include "Attributed.h"
  14. #include "Boolean.h"
  15. #include "StringC.h"
  16. #include "ElementType.h"
  17. #include "Entity.h"
  18. #include "Event.h"
  19. #include "IList.h"
  20. #include "ISet.h"
  21. #include "Location.h"
  22. #include "Owner.h"
  23. #include "ParserState.h"
  24. #include "Ptr.h"
  25. #include "SgmlParser.h"
  26. #include "StringOf.h"
  27. #include "Undo.h"
  28. #include "Vector.h"
  29.  
  30. #ifdef SP_NAMESPACE
  31. namespace SP_NAMESPACE {
  32. #endif
  33.  
  34. class AllowedParams;
  35. class Param;
  36. class ExternalId;
  37. class PublicId;
  38. class GroupToken;
  39. class AllowedGroupTokens;
  40. struct GroupConnector;
  41. class AllowedGroupConnectors;
  42. class AllowedSdParams;
  43. class Text;
  44. class AttributeList;
  45. class AttributeDefinition;
  46. class AttributeDefinitionList;
  47. class UnivCharsetDesc;
  48. class CharsetInfo;
  49. class CharsetDecl;
  50. class DeclaredValue;
  51. struct SdBuilder;
  52. struct SdParam;
  53. class Syntax;
  54. class ElementDefinition;
  55. class CharSwitcher;
  56. struct StandardSyntaxSpec;
  57. class Undo;
  58. class Decl;
  59.  
  60. class Parser : private ParserState { 
  61. public:
  62.   Parser(const SgmlParser::Params &);
  63.   Event *nextEvent();
  64.   void parseAll(EventHandler &, const volatile sig_atomic_t *cancelPtr);
  65.   ParserState::sdPointer;
  66.   ParserState::instanceSyntaxPointer;
  67.   ParserState::prologSyntaxPointer;
  68.   ParserState::activateLinkType;
  69.   ParserState::allLinkTypesActivated;
  70.   ParserState::entityManager;
  71.   ParserState::entityCatalog;
  72.   ParserState::baseDtd;
  73.   ParserState::options;
  74. private:
  75.   Parser(const Parser &);    // undefined
  76.   void operator=(const Parser &); // undefined
  77.   Boolean setStandardSyntax(Syntax &syn, const StandardSyntaxSpec &,
  78.                 const CharsetInfo &docCharset,
  79.                 CharSwitcher &,
  80.                 Boolean www);
  81.   Boolean addRefDelimShortref(Syntax &syntax,
  82.                   const CharsetInfo &syntaxCharset,
  83.                   const CharsetInfo &docCharset,
  84.                   CharSwitcher &switcher);
  85.   Boolean setRefDelimGeneral(Syntax &syntax,
  86.                  const CharsetInfo &syntaxCharset,
  87.                  const CharsetInfo &docCharset,
  88.                  CharSwitcher &switcher);
  89.   void setRefNames(Syntax &syntax, const CharsetInfo &docCharset, Boolean www);
  90.  
  91.   void giveUp();
  92.   void compileSdModes();
  93.   void compilePrologModes();
  94.   void compileInstanceModes();
  95.   void addNeededShortrefs(Dtd &, const Syntax &);
  96.   Boolean shortrefCanPreemptDelim(const StringC &sr,
  97.                   const StringC &d,
  98.                   Boolean dIsSr,
  99.                   const Syntax &);
  100.   void compileModes(const Mode *modes, int n, const Dtd *);
  101.   void compileNormalMap();
  102.  
  103.   void doInit();
  104.   void doProlog();
  105.   void doDeclSubset();
  106.   void doInstanceStart();
  107.   void doContent();
  108.   void extendNameToken(size_t, const MessageType1 &);
  109.   void extendNumber(size_t, const MessageType1 &);
  110.   void extendHexNumber();
  111.   void extendData();
  112.   void extendS();
  113.   void extendContentS();
  114.   void declSubsetRecover(unsigned startLevel);
  115.   void prologRecover();
  116.   void skipDeclaration(unsigned startLevel);
  117.   Boolean parseElementDecl();
  118.   Boolean parseAttlistDecl();
  119.   Boolean parseNotationDecl();
  120.   Boolean parseEntityDecl();
  121.   Boolean parseShortrefDecl();
  122.   Boolean parseUsemapDecl();
  123.   Boolean parseUselinkDecl();
  124.   Boolean parseDoctypeDeclStart();
  125.   Boolean parseDoctypeDeclEnd(Boolean fake = 0);
  126.   Boolean parseMarkedSectionDeclStart();
  127.   void handleMarkedSectionEnd();
  128.   Boolean parseCommentDecl();
  129.   void emptyCommentDecl();
  130.   Boolean parseExternalId(const AllowedParams &,
  131.               const AllowedParams &,
  132.               Boolean,
  133.               unsigned,
  134.               Param &,
  135.               ExternalId &);
  136.   Boolean parseParam(const AllowedParams &, unsigned, Param &);
  137.   Boolean parseMinimumLiteral(Boolean, Text &);
  138.   Boolean parseAttributeValueLiteral(Boolean, Text &);
  139.   Boolean parseTokenizedAttributeValueLiteral(Boolean, Text &);
  140.   Boolean parseSystemIdentifier(Boolean, Text &);
  141.   Boolean parseParameterLiteral(Boolean, Text &);
  142.   Boolean parseDataTagParameterLiteral(Boolean, Text &);
  143.   // flags for parseLiteral()
  144.   enum {
  145.     literalSingleSpace = 01,
  146.     literalDataTag = 02,
  147.     literalMinimumData = 04,
  148.     // Keep info about delimiters
  149.     literalDelimInfo = 010,
  150.     // Ignore references in the literal
  151.     literalNoProcess = 020,
  152.     // Allow numeric character references to non-SGML characters
  153.     literalNonSgml = 040
  154.     };
  155.   Boolean parseLiteral(Mode litMode, Mode liteMode, size_t maxLength,
  156.                const MessageType1 &tooLongMessage,
  157.                unsigned flags, Text &text);
  158.  
  159.   Boolean parseGroupToken(const AllowedGroupTokens &allow,
  160.               unsigned nestingLevel,
  161.               unsigned declInputLevel,
  162.               unsigned groupInputLevel,
  163.               GroupToken >);
  164.   Boolean parseGroupConnector(const AllowedGroupConnectors &allow,
  165.                   unsigned declInputLevel,
  166.                   unsigned groupInputLevel,
  167.                   GroupConnector &gc);
  168.   Boolean parseGroup(const AllowedGroupTokens &allowToken,
  169.              unsigned declInputLevel,
  170.              Param &parm);
  171.   Boolean parseModelGroup(unsigned nestingLevel, unsigned declInputLevel,
  172.               ModelGroup *&, Mode);
  173.   Boolean parseNameGroup(unsigned declInputLevel, Param &);
  174.   Boolean parseNameTokenGroup(unsigned declInputLevel, Param &);
  175.   Boolean parseDataTagGroup(unsigned nestingLevel, unsigned declInputLevel,
  176.                 GroupToken &);
  177.   Boolean parseDataTagTemplateGroup(unsigned nestingLevel,
  178.                     unsigned declInputLevel, GroupToken &);
  179.  
  180.   Boolean parseElementNameGroup(unsigned declInputLevel, Param &);
  181.   Boolean parseReservedName(const AllowedParams &allow, Param &parm);
  182.   Boolean parseIndicatedReservedName(const AllowedParams &allow, Param &parm);
  183.   Boolean getReservedName(Syntax::ReservedName *);
  184.   Boolean getIndicatedReservedName(Syntax::ReservedName *);
  185.   Boolean parseAttributeValueParam(Param &parm);
  186.   Boolean parseEntityReference(Boolean isParameter,
  187.                    int ignoreLevel,
  188.                    ConstPtr<Entity> &entity,
  189.                    Ptr<EntityOrigin> &origin);
  190.   ContentToken::OccurrenceIndicator getOccurrenceIndicator(Mode);
  191.   Boolean parseComment(Mode);
  192.   Boolean parseNamedCharRef();
  193.   Boolean parseNumericCharRef(Boolean isHex, Char &, Location &);
  194.   Boolean translateNumericCharRef(Char &ch, Boolean &isSgmlChar);
  195.   Boolean parseDeclarationName(Syntax::ReservedName *, Boolean allowAfdr = 0);
  196.   void paramInvalidToken(Token, const AllowedParams &);
  197.   void groupTokenInvalidToken(Token, const AllowedGroupTokens &);
  198.   void groupConnectorInvalidToken(Token, const AllowedGroupConnectors &);
  199.   ElementType *lookupCreateElement(const StringC &);
  200.   RankStem *lookupCreateRankStem(const StringC &);
  201.   Boolean parseExceptions(unsigned declInputLevel,
  202.               Ptr<ElementDefinition> &def);
  203.   void parsePcdata();
  204.   void parseStartTag();
  205.   ElementType *completeRankStem(const StringC &);
  206.   void handleRankedElement(const ElementType *);
  207.   void parseEmptyStartTag();
  208.   void acceptPcdata(const Location &);
  209.   void acceptStartTag(const ElementType *, StartElementEvent *,
  210.               Boolean netEnabling);
  211.   void handleBadStartTag(const ElementType *, StartElementEvent *,
  212.              Boolean netEnabling);
  213.   void undo(IList<Undo> &);
  214.   Boolean tryStartTag(const ElementType *, StartElementEvent *,
  215.               Boolean netEnabling, IList<Event> &);
  216.   void checkExclusion(const ElementType *e);
  217.   Boolean tryImplyTag(const Location &, unsigned &, unsigned &,
  218.               IList<Undo> &, IList<Event> &);
  219.   void pushElementCheck(const ElementType *, StartElementEvent *,
  220.             Boolean netEnabling);
  221.   void pushElementCheck(const ElementType *, StartElementEvent *,
  222.             IList<Undo> &, IList<Event> &);
  223.   void queueElementEvents(IList<Event> &);
  224.   Boolean parseAttributeSpec(Boolean inDeclaration,
  225.                  AttributeList &,
  226.                  Boolean &netEnabling,
  227.                  Ptr<AttributeDefinitionList> &);
  228.  
  229.   Boolean handleAttributeNameToken(Text &text,
  230.                    AttributeList &,
  231.                    unsigned &specLength);
  232.   struct AttributeParameter {
  233.     enum Type {
  234.       end,
  235.       name,
  236.       nameToken,
  237.       vi,
  238.       recoverUnquoted
  239.       };
  240.   };
  241.  
  242.   Boolean parseAttributeParameter(Boolean inDecl,
  243.                   Boolean allowVi,
  244.                   AttributeParameter::Type &result,
  245.                   Boolean &netEnabling);
  246.   void extendUnquotedAttributeValue();
  247.  
  248.   Boolean parseAttributeValueSpec(Boolean inDecl,
  249.                   const StringC &name,
  250.                   AttributeList &atts,
  251.                   unsigned &specLength,
  252.                   Ptr<AttributeDefinitionList> &newAttDefList);
  253.  
  254.   EndElementEvent *parseEndTag();
  255.   void parseEndTagClose();
  256.   void parseEmptyEndTag();
  257.   void parseNullEndTag();
  258.   void endAllElements();
  259.   void acceptEndTag(EndElementEvent *);
  260.   void endTagEmptyElement(const ElementType *,
  261.               Boolean netEnabling,
  262.               Boolean included,
  263.               const Location &startLoc);
  264.   void implyCurrentElementEnd(const Location &);
  265.   void implyEmptyElementEnd(const ElementType *, Boolean included, const Location &);
  266.   void maybeDefineEntity(const Ptr<Entity> &entity);
  267.   Notation *lookupCreateNotation(const StringC &name);
  268.   Boolean parseExternalEntity(StringC &name,
  269.                   Entity::DeclType declType,
  270.                   unsigned declInputLevel,
  271.                   Param &parm);
  272.   ShortReferenceMap *lookupCreateMap(const StringC &);
  273.   StringC prettifyDelim(const StringC &delim);
  274.   void handleShortref(int index);
  275.   Boolean parseProcessingInstruction();
  276.   Boolean parseAttributed(unsigned declInputLevel, Param &parm,
  277.               Vector<Attributed *> &attributed,
  278.               Boolean &isNotation);
  279.   Boolean parseDeclaredValue(unsigned declInputLevel, Boolean isNotation,
  280.                  Param &parm, Owner<DeclaredValue> &value);
  281.   Boolean parseDefaultValue(unsigned declInputLevel, Boolean isNotation,
  282.                 Param &parm, const StringC &attributeName,
  283.                 Owner<DeclaredValue> &declaredValue,
  284.                 Owner<AttributeDefinition> &def,
  285.                 Boolean &anyCurrent);
  286.   Boolean reportNonSgmlCharacter();
  287.   void endInstance();
  288.   Boolean implySgmlDecl();
  289.   Boolean scanForSgmlDecl(const CharsetInfo &initCharset);
  290.   void findMissingMinimum(const CharsetInfo &charset, ISet<WideChar> &);
  291.   Boolean parseSgmlDecl();
  292.   Boolean sdParseSgmlDeclRef(SdBuilder &, SdParam &, ExternalId &);
  293.   Boolean sdParseDocumentCharset(SdBuilder &sdBuilder, SdParam &parm);
  294.   Boolean sdParseCapacity(SdBuilder &sdBuilder, SdParam &parm);
  295.   Boolean sdParseScope(SdBuilder &sdBuilder, SdParam &parm);
  296.   Boolean sdParseSyntax(SdBuilder &sdBuilder, SdParam &parm);
  297.   Boolean sdParseExplicitSyntax(SdBuilder &sdBuilder, SdParam &parm);
  298.   Boolean sdParseSyntaxCharset(SdBuilder &sdBuilder, SdParam &parm);
  299.   Boolean sdParseShunchar(SdBuilder &sdBuilder, SdParam &parm);
  300.   Boolean sdParseFunction(SdBuilder &sdBuilder, SdParam &parm);
  301.   Boolean sdParseNaming(SdBuilder &sdBuilder, SdParam &parm);
  302.   Boolean sdParseDelim(SdBuilder &sdBuilder, SdParam &parm);
  303.   Boolean sdParseNames(SdBuilder &sdBuilder, SdParam &parm);
  304.   Boolean sdParseQuantity(SdBuilder &sdBuilder, SdParam &parm);
  305.   Boolean sdParseEntities(SdBuilder &sdBuilder, SdParam &parm);
  306.   Boolean sdParseFeatures(SdBuilder &sd, SdParam &parm);
  307.   Boolean sdParseAppinfo(SdBuilder &sd, SdParam &parm);
  308.   Boolean sdParseSeealso(SdBuilder &sd, SdParam &parm);
  309.   void requireWWW(SdBuilder &sdBuilder);
  310.   Boolean parseSdParam(const AllowedSdParams &allow, SdParam &);
  311.   Boolean parseSdParamLiteral(Boolean lita, String<SyntaxChar> &str);
  312.   Boolean parseSdSystemIdentifier(Boolean lita, Text &);
  313.   Boolean stringToNumber(const Char *s, size_t length, unsigned long &);
  314.   void sdParamConvertToLiteral(SdParam &parm);
  315.   void sdParamInvalidToken(Token token, const AllowedSdParams &);
  316.   Boolean sdParseCharset(SdBuilder &sdBuilder, SdParam &parm,
  317.              Boolean isDocument,
  318.              CharsetDecl &, UnivCharsetDesc &);
  319.   Boolean sdParseExternalCharset(Sd &, UnivCharsetDesc &desc);
  320.   UnivChar charNameToUniv(Sd &sd, const StringC &name);
  321.   Boolean translateSyntax(CharSwitcher &switcher,
  322.               const CharsetInfo &syntaxCharset,
  323.               const CharsetInfo &docCharset,
  324.               WideChar syntaxChar,
  325.               Char &docChar);
  326.   Boolean translateSyntax(SdBuilder &sdBuilder,
  327.               WideChar syntaxChar, Char &docChar);
  328.   Boolean translateSyntax(SdBuilder &sdBuilder,
  329.               const String<SyntaxChar> &syntaxString,
  330.               StringC &docString);
  331.   Boolean translateSyntaxNoSwitch(SdBuilder &sdBuilder,
  332.                   WideChar syntaxChar, Char &docChar,
  333.                   Number &count);
  334.   Boolean translateName(SdBuilder &sdBuilder,
  335.             const StringC &name,
  336.             StringC &str);
  337.   void translateRange(SdBuilder &sdBuilder, SyntaxChar start,
  338.               SyntaxChar end, ISet<Char> &chars);
  339.   UnivChar translateUniv(UnivChar univChar,
  340.              CharSwitcher &switcher,
  341.              const CharsetInfo &syntaxCharset);
  342.   Boolean univToDescCheck(const CharsetInfo &charset, UnivChar from,
  343.               Char &to);
  344.   Boolean univToDescCheck(const CharsetInfo &charset, UnivChar from,
  345.               Char &to, WideChar &count);
  346.   void translateDocSet(const CharsetInfo &fromCharset,
  347.                const CharsetInfo &toCharset,
  348.                const ISet<Char> &fromSet,
  349.                ISet<Char> &toSet);
  350.   Boolean checkNotFunction(const Syntax &syn, Char c);
  351.   Boolean checkGeneralDelim(const Syntax &syn, const StringC &delim);
  352.   Boolean checkShortrefDelim(const Syntax &syn,
  353.                  const CharsetInfo &charset,
  354.                  const StringC &delim);
  355.   Boolean checkNmchars(const ISet<Char> &set, const Syntax &syntax);
  356.   void intersectCharSets(const ISet<Char> &s1, const ISet<Char> &s2,
  357.              ISet<WideChar> &inter);
  358.   Boolean checkSwitches(CharSwitcher &switcher,
  359.             const CharsetInfo &syntaxCharset);
  360.   Boolean checkSwitchesMarkup(CharSwitcher &switcher);
  361.  
  362.   const StandardSyntaxSpec *lookupSyntax(const PublicId &id);
  363.   Boolean referencePublic(const PublicId &id, PublicId::TextClass,
  364.               Boolean &givenError);
  365.   void checkIdrefs();
  366.   void checkTaglen(Index tagStartIndex);
  367.   void checkSyntaxNamelen(const Syntax &syn);
  368.   void checkElementAttribute(const ElementType *e, size_t checkFrom = 0);
  369.   void checkDtd(Dtd &dtd);
  370.   Boolean maybeStatusKeyword(const Entity &entity);
  371.   void reportAmbiguity(const LeafContentToken *from,
  372.                const LeafContentToken *to1,
  373.                const LeafContentToken *to2,
  374.                unsigned ambigAndDepth);
  375.   Boolean parseLinktypeDeclStart();
  376.   Boolean parseLinktypeDeclEnd();
  377.   Boolean parseLinkDecl();
  378.   Boolean parseIdlinkDecl();
  379.   Boolean parseLinkSet(Boolean idlink);
  380.   void addIdLinkRule(const StringC &id, IdLinkRule &rule);
  381.   void addLinkRule(LinkSet *linkSet,
  382.            const ElementType *sourceElement,
  383.            const ConstPtr<SourceLinkRuleResource> &linkRule);
  384.   Boolean parseResultElementSpec(unsigned declInputLevel,
  385.                  Param &parm,
  386.                  Boolean idlink,
  387.                  Boolean &implied,
  388.                  const ElementType *&resultType,
  389.                  AttributeList &attributes);
  390.   LinkSet *lookupCreateLinkSet(const StringC &name);
  391.   ElementType *lookupResultElementType(const StringC &name);
  392.   void endProlog();
  393.   Boolean parseEntityReferenceNameGroup(Boolean &ignore);
  394.   Boolean parseTagNameGroup(Boolean &active);
  395.   void parseGroupStartTag();
  396.   void parseGroupEndTag();
  397.   Boolean skipAttributeSpec();
  398.   Boolean lookingAtStartTag(StringC &gi);
  399.   void implyDtd(const StringC &gi);
  400.   void findMissingTag(const ElementType *e, Vector<const ElementType *> &);
  401.   unsigned paramsSubdocLevel(const SgmlParser::Params &);
  402.   void addCommonAttributes(Dtd &dtd);
  403.   Boolean parseAfdrDecl();
  404.   void setSdOverrides(Sd &sd);
  405. };
  406.  
  407. #ifdef SP_NAMESPACE
  408. }
  409. #endif
  410.  
  411. #endif /* not Parser_INCLUDED */
  412.