From e19f05a11c7537e906568517314e33163835df58 Mon Sep 17 00:00:00 2001 From: dehilsterlexis Date: Mon, 10 Oct 2016 14:23:43 -0400 Subject: [PATCH] IDE-569 Syntax highlight KEL Fixed IDE-569 Signed-off-by: dehilsterlexis --- EclEditor/CMakeLists.txt | 8 +- EclEditor/Catalogue.cxx | 2 + EclEditor/LexESDL.cxx | 20 +- EclEditor/LexGENERAL.cxx | 173 ++ EclEditor/LexKEL.cxx | 324 ++++ EclEditor/SciLexer.h | 32 +- comms/AttributeType.cpp | 6 + comms/AttributeType.h | 3 + docs/LangColorECL.xml | 397 +++++ docs/LangColorESDL.xml | 109 ++ docs/LangColorKEL.xml | 157 ++ docs/LangColorSalt.xml | 135 ++ docs/LanguageColor.xml | 420 +---- docs/LanguageRefECL.xml | 2913 ++++++++++++++++++++++++++++++++++ docs/LanguageRefESDL.xml | 10 +- docs/LanguageRefKEL.xml | 968 ++++++++++++ docs/LanguageReference.xml | 2958 +---------------------------------- docs/SyntaxColorSamples.xml | 40 + en_us/en_us.rc | 5 +- en_us/resource.h | 1 + wlib/LangRef.cpp | 279 +++- wlib/LangRef.h | 9 + wlib/PreferenceDlg.cpp | 334 +++- wlib/SourceView.cpp | 36 +- 24 files changed, 5877 insertions(+), 3462 deletions(-) create mode 100644 EclEditor/LexGENERAL.cxx create mode 100644 EclEditor/LexKEL.cxx create mode 100644 docs/LangColorECL.xml create mode 100644 docs/LangColorESDL.xml create mode 100644 docs/LangColorKEL.xml create mode 100644 docs/LangColorSalt.xml create mode 100644 docs/LanguageRefECL.xml create mode 100644 docs/LanguageRefKEL.xml create mode 100644 docs/SyntaxColorSamples.xml diff --git a/EclEditor/CMakeLists.txt b/EclEditor/CMakeLists.txt index 044ddca8..59f364e5 100644 --- a/EclEditor/CMakeLists.txt +++ b/EclEditor/CMakeLists.txt @@ -1,14 +1,18 @@ project( ECLEDITOR ) set ( SRCS + lexgeneral.cxx lexecl.cxx lexsalt.cxx lexesdl.cxx + lexkel.cxx ${SCINTILLA_INCLUDE_DIR}/include/SciLExer.h - ${ECLEDITOR_SOURCE_DIR}/LexSALT.cxx - ${SCINTILLA_INCLUDE_DIR}/lexers/LexESDL.cxx + ${ECLEDITOR_SOURCE_DIR}/lexers/LexGENERAL.cxx + ${ECLEDITOR_SOURCE_DIR}/lexers/LexSALT.cxx + ${ECLEDITOR_SOURCE_DIR}/lexers/LexKEL.cxx + ${ECLEDITOR_SOURCE_DIR}/lexers/LexESDL.cxx ${SCINTILLA_INCLUDE_DIR}/Src/AutoComplete.cxx ${SCINTILLA_INCLUDE_DIR}/Src/AutoComplete.h diff --git a/EclEditor/Catalogue.cxx b/EclEditor/Catalogue.cxx index 64258274..96945ae5 100644 --- a/EclEditor/Catalogue.cxx +++ b/EclEditor/Catalogue.cxx @@ -81,9 +81,11 @@ int Scintilla_LinkLexers() { //++Autogenerated -- run src/LexGen.py to regenerate //**\(\tLINK_LEXER(\*);\n\) + LINK_LEXER(lmGENERAL); LINK_LEXER(lmECL); LINK_LEXER(lmESDL); LINK_LEXER(lmSALT); + LINK_LEXER(lmKEL); /* LINK_LEXER(lmA68k); diff --git a/EclEditor/LexESDL.cxx b/EclEditor/LexESDL.cxx index dcc3cae7..409ecf39 100644 --- a/EclEditor/LexESDL.cxx +++ b/EclEditor/LexESDL.cxx @@ -1,6 +1,6 @@ // Scintilla source code edit control /** @file LexESDL.cxx - ** Lexer for C++, C, Java, and JavaScript. + ** Lexer for ESDL. **/ // Copyright 1998-2005 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. @@ -98,7 +98,6 @@ static void ColouriseESDLDocSensitive(unsigned int startPos, int length, int ini WordList &listAttributes = *keywordlists[2]; char s[1000]; - int parens = 0; bool checkword = false; // look back to set chPrevNonWhite properly for better regex colouring @@ -132,6 +131,7 @@ static void ColouriseESDLDocSensitive(unsigned int startPos, int length, int ini sc.ForwardSetState(SCE_ESDL_DEFAULT); } break; + case SCE_ESDL_SEPARATOR: case SCE_ESDL_STRUCTURE: case SCE_ESDL_DATATYPE: case SCE_ESDL_ATTRIBUTE: @@ -168,19 +168,16 @@ static void ColouriseESDLDocSensitive(unsigned int startPos, int length, int ini else if (sc.ch == '"') { sc.SetState(SCE_ESDL_STRING); } - else if (sc.ch == '(' || sc.ch == '<' || sc.ch == '{') { + else if (sc.ch == '(' || sc.ch == '<' || sc.ch == '{' || sc.ch == '[') { checkword = true; - parens++; } - else if (sc.ch == ')' || sc.ch == '>' || sc.ch == '}') { - parens--; + else if (sc.ch == ')' || sc.ch == '>' || sc.ch == '}' || sc.ch == ']') { + checkword = true; } - else if (sc.ch == ' ') { - strtrim(s); + else if (sc.ch == ' ' || sc.ch == ',' || sc.ch == '.' || sc.ch == ';') { checkword = true; } - else if (sc.ch == '\r') { - strtrim(s); + else if (sc.ch == '\r' || sc.ch == '\n') { checkword = true; } else if (sc.Match('/', '*')) { @@ -196,7 +193,6 @@ static void ColouriseESDLDocSensitive(unsigned int startPos, int length, int ini sc.SetState(SCE_ESDL_COMMENTLINE); } if (checkword) { - strtrim(s); if (listStructures.InList(s)) { sc.ChangeState(SCE_ESDL_STRUCTURE); } @@ -206,7 +202,7 @@ static void ColouriseESDLDocSensitive(unsigned int startPos, int length, int ini else if (listAttributes.InList(s)) { sc.ChangeState(SCE_ESDL_ATTRIBUTE); } - sc.SetState(SCE_ESDL_DEFAULT); + sc.SetState(SCE_ESDL_SEPARATOR); } } } diff --git a/EclEditor/LexGENERAL.cxx b/EclEditor/LexGENERAL.cxx new file mode 100644 index 00000000..ea1c4dc7 --- /dev/null +++ b/EclEditor/LexGENERAL.cxx @@ -0,0 +1,173 @@ +// Scintilla source code edit control +/** @file LexGENERAL.cxx + ** Lexer for general color preferences. Not an attribute type. + **/ +// Copyright 1998-2005 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(disable: 4786) +#endif +#ifdef __BORLANDC__ +// Borland C++ displays warnings in vector header without this +#pragma option -w-ccc -w-rch +#endif + +#include +#include +#include +#include + +#include "ILexer.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#include "PropSetSimple.h" +#include "WordList.h" +#include "LexAccessor.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "CharacterSet.h" +#include "LexerModule.h" +#include "OptionSet.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +// Preconditions: sc.currentPos points to a character after '+' or '-'. +// The test for pos reaching 0 should be redundant, +// and is in only for safety measures. +// Limitation: this code will give the incorrect answer for code like +// a = b+++/ptn/... +// Putting a space between the '++' post-inc operator and the '+' binary op +// fixes this, and is highly recommended for readability anyway. +static bool FollowsPostfixOperator(StyleContext &sc, Accessor &styler) { + int pos = (int) sc.currentPos; + while (--pos > 0) { + char ch = styler[pos]; + if (ch == '+' || ch == '-') { + return styler[pos - 1] == ch; + } + } + return false; +} + +static void strtrim(char* str) { + int start = 0; // number of leading spaces + char* buffer = str; + while (*str && (*str == ' ' || *str == '\r' || *str == '\n' || *str == '\t')) + { + *str++; + ++start; + } + while (*str++); // move to end of string + int end = str - buffer - 1; + while (end > 0 && (buffer[end - 1] == ' ' || buffer[end - 1] == '\n' || buffer[end - 1] == '\r' || buffer[end - 1] == '\t')) --end; // backup over trailing spaces + buffer[end] = 0; // remove trailing spaces + if (end <= start || start == 0) return; // exit if no leading spaces or string is now empty + str = buffer + start; + while ((*buffer++ = *str++)); // remove leading spaces: K&R +} + +static void ColouriseGENERALDocSensitive(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler) { + + WordList &headerList = *keywordlists[0]; + WordList &thorList = *keywordlists[1]; + WordList &hthorList = *keywordlists[2]; + WordList &roxieList = *keywordlists[3]; + WordList &localList = *keywordlists[4]; + + char s[1000]; + bool checkword = false; + int linetype = 0; + + StyleContext sc(startPos, length, initStyle, styler); + int line = 0; + + for (; sc.More(); sc.Forward()) { + sc.GetCurrentLowered(s, sizeof(s)); + strtrim(s); + + // Determine if the current state should terminate. + switch (sc.state) { + case SCE_GEN_HEADER: + if (sc.chPrev == ':') { + sc.ChangeState(SCE_GEN_DEFAULT); + sc.SetState(SCE_GEN_DELIMITER); + if (linetype == SCE_GEN_CARET) + sc.ForwardSetState(SCE_GEN_CARET); + else + sc.ForwardSetState(SCE_GEN_DEFAULT); + } + break; + case SCE_GEN_CARET: + case SCE_GEN_THOR_BACKGROUND: + case SCE_GEN_HTHOR_BACKGROUND: + case SCE_GEN_ROXIE_BACKGROUND: + case SCE_GEN_LOCAL_BACKGROUND: + if (sc.atLineEnd) + { + sc.SetState(SCE_GEN_DEFAULT); + } + break; + } + + if (sc.state == SCE_GEN_DEFAULT) { + checkword = false; + if (headerList.InList(s)) { + if (stricmp(s, "caret") == 0) + { + sc.SetState(SCE_GEN_HEADER); + linetype = SCE_GEN_CARET; + } + else if (stricmp(s, "target") == 0) + { + sc.ChangeState(SCE_GEN_HEADER); + linetype = SCE_GEN_TARGET; + } + } + else { + if (thorList.InList(s)) { + sc.ChangeState(SCE_GEN_THOR_BACKGROUND); + sc.SetState(SCE_GEN_THOR_BACKGROUND); + } + else if (hthorList.InList(s)) { + sc.ChangeState(SCE_GEN_HTHOR_BACKGROUND); + sc.SetState(SCE_GEN_HTHOR_BACKGROUND); + } + else if (roxieList.InList(s)) { + sc.ChangeState(SCE_GEN_ROXIE_BACKGROUND); + sc.SetState(SCE_GEN_ROXIE_BACKGROUND); + } + else if (localList.InList(s)) { + sc.ChangeState(SCE_GEN_LOCAL_BACKGROUND); + sc.SetState(SCE_GEN_LOCAL_BACKGROUND); + } + } + } + } + sc.Complete(); +} + +static void FoldGENERALDoc(unsigned int startPos, int length, int initStyle, + WordList *[], Accessor &styler) { +} + +static const char * const generalWordLists[] = { + "Headers", + "Thor", + "HThor", + "Roxie", + "Local", + 0, + }; + +LexerModule lmGENERAL(SCLEX_GENERAL, ColouriseGENERALDocSensitive, "general", FoldGENERALDoc, generalWordLists); diff --git a/EclEditor/LexKEL.cxx b/EclEditor/LexKEL.cxx new file mode 100644 index 00000000..15e4b72a --- /dev/null +++ b/EclEditor/LexKEL.cxx @@ -0,0 +1,324 @@ +// Scintilla source code edit control +/** @file LexKEL.cxx + ** Lexer for KEL. + **/ +// Copyright 1998-2005 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(disable: 4786) +#endif +#ifdef __BORLANDC__ +// Borland C++ displays warnings in vector header without this +#pragma option -w-ccc -w-rch +#endif + +#include +#include +#include +#include + +#include "ILexer.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#include "PropSetSimple.h" +#include "WordList.h" +#include "LexAccessor.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "CharacterSet.h" +#include "LexerModule.h" +#include "OptionSet.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static bool IsSpaceEquiv(int state) { + return (state <= SCE_C_COMMENTDOC) || + // including SCE_C_DEFAULT, SCE_C_COMMENT, SCE_C_COMMENTLINE + (state == SCE_C_COMMENTLINEDOC) || (state == SCE_C_COMMENTDOCKEYWORD) || + (state == SCE_C_COMMENTDOCKEYWORDERROR); +} + +static bool IsStreamCommentStyleEsdl(int style) { + return style == SCE_KEL_COMMENT || + style == SCE_KEL_COMMENTLINE || + style == SCE_KEL_COMMENTDOC; +} + +// Preconditions: sc.currentPos points to a character after '+' or '-'. +// The test for pos reaching 0 should be redundant, +// and is in only for safety measures. +// Limitation: this code will give the incorrect answer for code like +// a = b+++/ptn/... +// Putting a space between the '++' post-inc operator and the '+' binary op +// fixes this, and is highly recommended for readability anyway. +static bool FollowsPostfixOperator(StyleContext &sc, Accessor &styler) { + int pos = (int) sc.currentPos; + while (--pos > 0) { + char ch = styler[pos]; + if (ch == '+' || ch == '-') { + return styler[pos - 1] == ch; + } + } + return false; +} + +static void strtrim(char* str) { + int start = 0; // number of leading spaces + char* buffer = str; + while (*str && (*str == ' ' || *str == '\r' || *str == '\n' || *str == '\t')) + { + *str++; + ++start; + } + while (*str++); // move to end of string + int end = str - buffer - 1; + while (end > 0 && (buffer[end - 1] == ' ' || buffer[end - 1] == '\n' || buffer[end - 1] == '\r' || buffer[end - 1] == '\t')) --end; // backup over trailing spaces + buffer[end] = 0; // remove trailing spaces + if (end <= start || start == 0) return; // exit if no leading spaces or string is now empty + str = buffer + start; + while ((*buffer++ = *str++)); // remove leading spaces: K&R +} + +static void ColouriseKELDocSensitive(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler) { + + WordList &listWord1 = *keywordlists[0]; + WordList &listAggregate = *keywordlists[1]; + WordList &listDate = *keywordlists[2]; + WordList &listFunction = *keywordlists[3]; + WordList &listECL = *keywordlists[4]; + WordList &listType = *keywordlists[5]; + WordList &listBoolean = *keywordlists[6]; + + char s[1000]; + bool checkword = false; + + // look back to set chPrevNonWhite properly for better regex colouring + if (startPos > 0) { + int back = startPos; + while (--back && IsSpaceEquiv(styler.StyleAt(back))) + ; + } + + StyleContext sc(startPos, length, initStyle, styler); + int line = 0; + + for (; sc.More(); sc.Forward()) { + // Handle line continuation generically. + if (sc.ch == '\\') { + if (sc.chNext == '\n' || sc.chNext == '\r') { + sc.Forward(); + if (sc.ch == '\r' && sc.chNext == '\n') { + sc.Forward(); + } + continue; + } + } + + sc.GetCurrentLowered(s, sizeof(s)); + strtrim(s); + + // Determine if the current state should terminate. + switch (sc.state) { + case SCE_KEL_STRING: + if (sc.Match('\'')) { + sc.ForwardSetState(SCE_KEL_DEFAULT); + } + break; + case SCE_KEL_SEPARATOR: + case SCE_KEL_WORD1: + case SCE_KEL_AGGREGATE: + case SCE_KEL_DATE: + case SCE_KEL_ECL: + case SCE_KEL_FUNCTION: + case SCE_KEL_TYPE: + case SCE_KEL_BOOLEAN: + sc.SetState(SCE_SALT_DEFAULT); + break; + case SCE_KEL_COMMENT: + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_KEL_DEFAULT); + } + break; + case SCE_KEL_COMMENTDOC: + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_KEL_DEFAULT); + } + break; + case SCE_KEL_COMMENTLINE: + if (sc.atLineStart) { + sc.SetState(SCE_KEL_DEFAULT); + } + break; + } + + // Determine if a new state should be entered. + int lineCurrent = styler.GetLine(sc.currentPos); + int lineState = styler.GetLineState(lineCurrent); + + if (sc.state == SCE_KEL_DEFAULT) { + checkword = false; + if (lineState) { + sc.SetState(lineState); + } + else if (sc.ch == '\'') { + sc.SetState(SCE_KEL_STRING); + } + else if (sc.ch == '(' || sc.ch == '<' || sc.ch == '{') { + checkword = true; + } + else if (sc.ch == ')' || sc.ch == '>' || sc.ch == '}') { + checkword = true; + } + else if (sc.ch == ',' || sc.ch == '=' || sc.ch == ':' || sc.ch == ' ' || sc.ch == ' ') { + checkword = true; + } + else if (sc.ch == '\r'|| sc.ch == '\n') { + checkword = true; + } + else if (sc.Match('/', '*')) { + if (sc.Match("/**") || sc.Match("/*!")) { // Support of Qt/Doxygen doc. style + sc.SetState(SCE_KEL_COMMENT); + } + else { + sc.SetState(SCE_KEL_COMMENT); + } + sc.Forward(); // Eat the * so it isn't used for the end of the comment + } + else if (sc.Match('/', '/')) { + sc.SetState(SCE_KEL_COMMENTLINE); + } + if (checkword) { + if (listWord1.InList(s)) { + sc.ChangeState(SCE_KEL_WORD1); + } + else if (listAggregate.InList(s)) { + sc.ChangeState(SCE_KEL_AGGREGATE); + } + else if (listDate.InList(s)) { + sc.ChangeState(SCE_KEL_DATE); + } + else if (listFunction.InList(s)) { + sc.ChangeState(SCE_KEL_FUNCTION); + } + else if (listECL.InList(s)) { + sc.ChangeState(SCE_KEL_ECL); + } + else if (listType.InList(s)) { + sc.ChangeState(SCE_KEL_TYPE); + } + else if (listBoolean.InList(s)) { + sc.ChangeState(SCE_KEL_BOOLEAN); + } + sc.SetState(SCE_KEL_SEPARATOR); + } + } + } + sc.Complete(); +} + +static bool IsStreamCommentStyle(int style) { + return style == SCE_C_COMMENT || + style == SCE_C_COMMENTDOC || + style == SCE_C_COMMENTDOCKEYWORD || + style == SCE_C_COMMENTDOCKEYWORDERROR; +} + +// Store both the current line's fold level and the next lines in the +// level store to make it easy to pick up with each increment +// and to make it possible to fiddle the current level for "} else {". +static void FoldKELDoc(unsigned int startPos, int length, int initStyle, + WordList *[], Accessor &styler) { + bool foldComment = true; + bool foldPreprocessor = true; + bool foldCompact = true; + bool foldAtElse = true; + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelCurrent = SC_FOLDLEVELBASE; + if (lineCurrent > 0) + levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16; + int levelMinCurrent = levelCurrent; + int levelNext = levelCurrent; + char chNext = styler[startPos]; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int stylePrev = style; + style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (foldComment && IsStreamCommentStyleEsdl(style)) { + if (!IsStreamCommentStyleEsdl(stylePrev)) { + levelNext++; + } + else if (!IsStreamCommentStyleEsdl(styleNext) && !atEOL) { + // Comments don't end at end of line and the next character may be unstyled. + levelNext--; + } + } + if (foldComment && (style == SCE_KEL_COMMENTLINE)) { + if ((ch == '/') && (chNext == '/')) { + char chNext2 = styler.SafeGetCharAt(i + 2); + if (chNext2 == '{') { + levelNext++; + } + else if (chNext2 == '}') { + levelNext--; + } + } + } + if (atEOL || (i == endPos - 1)) { + int levelUse = levelCurrent; + if (foldAtElse) { + levelUse = levelMinCurrent; + } + int lev = levelUse | levelNext << 16; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if (levelUse < levelNext) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelCurrent = levelNext; + levelMinCurrent = levelCurrent; + if (atEOL && (i == static_cast(styler.Length() - 1))) { + // There is an empty line at end of file so give it same level and empty + styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG); + } + visibleChars = 0; + } + if (!IsASpace(ch)) + visibleChars++; + } +} + +static const char * const kelWordLists[] = { + "KEL Word", + "KEL Aggregate", + "KEL Date", + "KEL Function", + "KEL ECL", + "KEL Type", + "KEL Boolean", + 0, + }; + +LexerModule lmKEL(SCLEX_KEL, ColouriseKELDocSensitive, "kel", FoldKELDoc, kelWordLists); diff --git a/EclEditor/SciLexer.h b/EclEditor/SciLexer.h index 83982866..1ee72f82 100644 --- a/EclEditor/SciLexer.h +++ b/EclEditor/SciLexer.h @@ -120,6 +120,9 @@ #define SCLEX_ECL 105 #define SCLEX_ESDL 198 #define SCLEX_SALT 199 +#define SCLEX_KEL 200 +#define SCLEX_HIPIE 201 +#define SCLEX_GENERAL 202 #define SCLEX_AUTOMATIC 1000 #define SCE_P_DEFAULT 0 #define SCE_P_COMMENTLINE 1 @@ -1571,16 +1574,39 @@ #define SCE_ESDL_COMMENTDOC 3 #define SCE_ESDL_STRING 4 #define SCE_ESDL_STRUCTURE 5 -#define SCE_ESDL_DATATYPE 18 -#define SCE_ESDL_ATTRIBUTE 19 +#define SCE_ESDL_DATATYPE 6 +#define SCE_ESDL_ATTRIBUTE 7 +#define SCE_ESDL_SEPARATOR 8 #define SCE_SALT_DEFAULT 0 #define SCE_SALT_COMMENT 1 #define SCE_SALT_COMMENTLINE 2 #define SCE_SALT_COMMENTDOC 3 #define SCE_SALT_NUMBER 4 #define SCE_SALT_COMMAND 5 -#define SCE_SALT_FIELDNAME 18 +#define SCE_SALT_FIELDNAME 6 #define SCE_SALT_ARGUMENTS 7 #define SCE_SALT_OPERATOR 8 #define SCE_SALT_SEPARATOR 9 +#define SCE_KEL_DEFAULT 0 +#define SCE_KEL_COMMENT 1 +#define SCE_KEL_COMMENTLINE 2 +#define SCE_KEL_COMMENTDOC 3 +#define SCE_KEL_STRING 4 +#define SCE_KEL_WORD1 5 +#define SCE_KEL_AGGREGATE 6 +#define SCE_KEL_DATE 7 +#define SCE_KEL_FUNCTION 8 +#define SCE_KEL_ECL 9 +#define SCE_KEL_TYPE 10 +#define SCE_KEL_BOOLEAN 11 +#define SCE_KEL_SEPARATOR 12 +#define SCE_GEN_DEFAULT 0 +#define SCE_GEN_CARET 1 +#define SCE_GEN_THOR_BACKGROUND 2 +#define SCE_GEN_HTHOR_BACKGROUND 3 +#define SCE_GEN_ROXIE_BACKGROUND 4 +#define SCE_GEN_LOCAL_BACKGROUND 5 +#define SCE_GEN_HEADER 6 +#define SCE_GEN_TARGET 7 +#define SCE_GEN_DELIMITER 8 #endif diff --git a/comms/AttributeType.cpp b/comms/AttributeType.cpp index 4bd761e9..e7506439 100644 --- a/comms/AttributeType.cpp +++ b/comms/AttributeType.cpp @@ -6,6 +6,7 @@ #include // =========================================================================== +#define ATTRIBUTE_TYPE_GENERAL _T("general") #define ATTRIBUTE_TYPE_ECL _T("ecl") #define ATTRIBUTE_TYPE_ECLMOD _T("eclmod") #define ATTRIBUTE_TYPE_ECLLIB _T("ecllib") @@ -275,6 +276,10 @@ IAttributeType * CreateIAttributeType(const std::_tstring & repositoryType, cons retVal->Update(description); return retVal; } +IAttributeType * CreateIAttributeGENERALType() +{ + return AttributeTypeCache.Get(new CAttributeType(ATTRIBUTE_TYPE_GENERAL)); +} IAttributeType * CreateIAttributeECLType() { return AttributeTypeCache.Get(new CAttributeType(ATTRIBUTE_TYPE_ECL)); @@ -313,6 +318,7 @@ IAttributeType * CreateIAttributeLUCIFAMILYType() } unsigned int GetAttributeTypes(IAttributeTypeVector & types) { + types.push_back(CreateIAttributeGENERALType()); types.push_back(CreateIAttributeECLType()); types.push_back(CreateIAttributeESDLType()); types.push_back(CreateIAttributeECMType()); diff --git a/comms/AttributeType.h b/comms/AttributeType.h index 6b3fa0e1..9dd234f9 100644 --- a/comms/AttributeType.h +++ b/comms/AttributeType.h @@ -36,9 +36,12 @@ __interface IAttributeType : public IUnknown }; typedef StlLinked IAttributeTypeAdapt; typedef std::vector IAttributeTypeVector; + +COMMS_API IAttributeType * CreateIAttributeGENERALType(); COMMS_API IAttributeType * CreateIAttributeECLType(); COMMS_API IAttributeType * CreateIAttributeESDLType(); COMMS_API IAttributeType * CreateIAttributeECMType(); +COMMS_API IAttributeType * CreateIAttributeKELType(); COMMS_API IAttributeType * CreateIAttributeSALTType(); COMMS_API IAttributeType * CreateIAttributeType(const std::_tstring & repositoryType, const std::_tstring & description = _T("")); COMMS_API unsigned int GetAttributeTypes(IAttributeTypeVector & types); diff --git a/docs/LangColorECL.xml b/docs/LangColorECL.xml new file mode 100644 index 00000000..2b45b89a --- /dev/null +++ b/docs/LangColorECL.xml @@ -0,0 +1,397 @@ + + + + + 32 + 0 + + 0 + + 0 + Default + 0 + 16777215 + Courier New + 10 + 0 + + + + 1 + + 1 + Comment + 32768 + + + + + + + + 2 + + 2 + CommentLine + 32768 + + + + + + + + 3 + + 3 + Number + + + + + + + + + 4 + + 4 + String + 8421504 + + + + + + + + 5 + + 5 + Word0 + 255 + + + + + + + + 6 + + 6 + Operator + + + + + + + + + 7 + + 7 + Character + 8421504 + + + + + + + + 8 + + 8 + UUID + + + + + + + + + 9 + + 9 + Preprocessor + 8404992 + + + + + + + + 10 + + 10 + Unknown + + + + + + + + + 11 + + 11 + Identifier + + + + + + + + + 12 + + 12 + StringEOL + + + + + + + + + 13 + + 13 + Verbatim + + + + + + + + + 14 + + 14 + RegEx + + + + + + + + + 15 + + 15 + CommentLineDoc + + + + + + + + + 16 + + 16 + Word1 + 8388608 + + + + 1 + + + + 17 + + 17 + CommentDocKeyword + 8355711 + + + + 1 + + + + 18 + + 18 + CommentDocKeywordError + 255 + + + + + + + + 19 + + 19 + Word2 + 128 + + + + + + + + 20 + + 20 + Word3 + 128 + + + + + + + + 21 + + 21 + Word4 + 8388736 + + + + + + + + 22 + + 22 + Word5 + 8388736 + + + + + + + + 23 + + 23 + CommentDoc + 8355711 + + + + + + + + 24 + + 24 + Added + + 15007713 + + + + + + + 25 + + 25 + Deleted + + 15000804 + + + + + + + 26 + + 26 + Changed + + 14804223 + + + + + + + 27 + + 27 + Moved + + 16777152 + + + + + + + 34 + + 34 + Bracelight + + + + + 1 + + + + 35 + + 35 + Bracebad + 255 + + + + + + + + 36 + + 36 + AnnotationWarning + 32896 + 15794175 + Verdana + + + + + + 37 + + 37 + AnnotationError + 128 + 15790335 + + + + + + + \ No newline at end of file diff --git a/docs/LangColorESDL.xml b/docs/LangColorESDL.xml new file mode 100644 index 00000000..d8acb2c3 --- /dev/null +++ b/docs/LangColorESDL.xml @@ -0,0 +1,109 @@ + + + + + 8 + 0 + + 0 + + 0 + Default + 0 + 16777215 + Courier New + 10 + 0 + + + + 1 + + 1 + Comment + 32768 + + + + + + + + 2 + + 2 + CommentLine + 32768 + + + + + + + + 3 + + 3 + CommentDoc + 8355711 + + + + + + + + 4 + + 4 + String + 8421504 + + + + + + + + 5 + + 5 + Structure + 16711680 + + + + + + + + 6 + + 6 + Datatype + 8519755 + + + + + + + + 7 + + 7 + Attribute + 8519755 + + + + + + + + \ No newline at end of file diff --git a/docs/LangColorKEL.xml b/docs/LangColorKEL.xml new file mode 100644 index 00000000..2abc8126 --- /dev/null +++ b/docs/LangColorKEL.xml @@ -0,0 +1,157 @@ + + + + + 12 + 0 + + 0 + + 0 + Default + 0 + 16777215 + Courier New + 10 + 0 + + + + 1 + + 1 + Comment + 32768 + + + + + + + + 2 + + 2 + CommentLine + 32768 + + + + + + + + 3 + + 3 + CommentDoc + 8355711 + + + + + + + + 4 + + 4 + String + 8421504 + + + + + + + + 5 + + 5 + Word1 + 16711680 + + + + + + + + 6 + + 6 + Aggregate + 10485760 + + + + + + + + 7 + + 7 + Date + 2124031 + + + + + + + + 8 + + 8 + Function + 8421504 + + + + + + + + 9 + + 9 + ECL + 8421504 + + + + + + + + 10 + + 10 + Type + 12614523 + + + + + + + + 11 + + 11 + Boolean + 255 + + + + + + + + \ No newline at end of file diff --git a/docs/LangColorSalt.xml b/docs/LangColorSalt.xml new file mode 100644 index 00000000..971752cd --- /dev/null +++ b/docs/LangColorSalt.xml @@ -0,0 +1,135 @@ + + + + + 10 + 0 + + 0 + + 0 + Default + 0 + 16777215 + Courier New + 10 + 0 + + + + 1 + + 1 + Comment + 32768 + + + + + + + + 2 + + 2 + CommentLine + 32768 + + + + + + + + 3 + + 3 + CommentDoc + 8355711 + + + + + + + + 4 + + 4 + Number + + + + + + + + + 5 + + 5 + Command + 16711680 + + + + + + + + 6 + + 6 + Fieldname + 139 + + + + + + + + 7 + + 7 + Arguments + + + + + + + + + 8 + + 8 + Operator + 8421504 + + + + + + + + 9 + + 9 + Separator + + + + + + + + + \ No newline at end of file diff --git a/docs/LanguageColor.xml b/docs/LanguageColor.xml index 809c0d2e..4a3a1dfb 100644 --- a/docs/LanguageColor.xml +++ b/docs/LanguageColor.xml @@ -5,352 +5,16 @@ - 38 + 6 0 + tracking_level="0" + version="0"> 0 0 - EclDefault - - - - - - - - - 1 - - 1 - Comment - 32768 - - - - - - - - 2 - - 2 - CommentLine - 32768 - - - - - - - - 3 - - 3 - Number - - - - - - - - - 4 - - 4 - String - 8421504 - - - - - - - - 5 - - 5 - Word0 - 16711680 - - - - - - - - 6 - - 6 - Operator - - - - - - - - - 7 - - 7 - Character - 8421504 - - - - - - - - 8 - - 8 - UUID - - - - - - - - - 9 - - 9 - Preprocessor - 8404992 - - - - - - - - 10 - - 10 - Unknown - - - - - - - - - 11 - - 11 - Identifier - - - - - - - - - 12 - - 12 - StringEOL - - - - - - - - - 13 - - 13 - Verbatim - - - - - - - - - 14 - - 14 - RegEx - - - - - - - - - 15 - - 15 - CommentLineDoc - - - - - - - - - 16 - - 16 - Word1 - 8388608 - - - - 1 - - - - 17 - - 17 - CommentDocKeyword - 8355711 - - - - 1 - - - - 18 - - 18 - CommentDocKeywordError - 255 - - - - - - - - 19 - - 19 - Word2 - 128 - - - - - - - - 20 - - 20 - Word3 - 128 - - - - - - - - 21 - - 21 - Word4 - 8388736 - - - - - - - - 22 - - 22 - Word5 - 8388736 - - - - - - - - 23 - - 23 - CommentDoc - 8355711 - - - - - - - - 24 - - 24 - Added - - 15007713 - - - - - - - 25 - - 25 - Deleted - - 15000804 - - - - - - - 26 - - 26 - Changed - - 14804223 - - - - - - - 27 - - 27 - Moved - - 16777152 - - - - - - - 32 - - 32 Default 0 16777215 @@ -360,57 +24,9 @@ - 34 - - 34 - Bracelight - - - - - 1 - - - - 35 - - 35 - Bracebad - 255 - - - - - - - - 36 - - 36 - AnnotationWarning - 32896 - 15794175 - Verdana - - - - - - 37 - - 37 - AnnotationError - 128 - 15790335 - - - - - - - 38 + 1 - 38 + 1 Caret 32768 @@ -420,21 +36,21 @@ - 39 + 2 - 39 + 2 ThorBackground - + 16777215 - 40 + 3 - 40 + 3 HThorBackground 15132390 @@ -444,24 +60,24 @@ - 41 + 4 - 41 - LocalBackground + 4 + RoxieBackground - 15138798 + 16771043 - 42 + 5 - 42 - RoxieBackground + 5 + LocalBackground - 16771043 + 15138798 diff --git a/docs/LanguageRefECL.xml b/docs/LanguageRefECL.xml new file mode 100644 index 00000000..992b4bd7 --- /dev/null +++ b/docs/LanguageRefECL.xml @@ -0,0 +1,2913 @@ + + + + + 363 + 0 + + 1 + ABS + ABS(expression) + ABS( + ) + + + + 1 + ACOS + ACOS(cosine) + ACOS( + ) + + + + 1 + AGGREGATE + AGGREGATE( recordset, resultrec,maintransform [ , mergetransform (RIGHT1,RIGHT2) ] [, groupingfields ] [, LOCAL | FEW | MANY] ) + AGGREGATE( + ) + + + + 1 + ALLNODES + ALLNODES(operation) + ALLNODES( + ) + + + + 1 + ASCII + ASCII(recordset) + ASCII( + ) + + + + 1 + ASIN + ASIN(sine) + ASIN( + ) + + + + 1 + ASSTRING + ASSTRING( value ) + ASSTRING( + ) + + + + 1 + ATAN + ATAN(tangent) + ATAN( + ) + + + + 1 + ATAN2 + ATAN2( y, x ) + ATAN2( + ) + + + + 1 + AVE + AVE(recordset,field) + AVE( + , ) + + + + 1 + CASE + CASE(expression, caseval => value, [... , caseval => value, ] elsevalue) + CASE( + => , ) + + + + 1 + CATCH + CATCH( recset, action ) + CATCH( + ) + + + + 1 + CHOOSE + CHOOSE(expression, value, ... , value, elsevalue) + CHOOSE( + ) + + + + 1 + CHOOSEN + CHOOSEN(recordset,n) + CHOOSEN( + , ) + + + + 1 + CHOOSESETS + CHOOSESETS( recordset, condition  => n [ ... , condition => n ] ) + CHOOSESETS( + ) + + + + 1 + CLUSTERSIZE + CLUSTERSIZE + CLUSTERSIZE + + + + + 1 + COMBINE + COMBINE(leftrecset,rightrecset [,transform] [,LOCAL]) + COMBINE( + ) + + + + 1 + CORRELATION + CORRELATION(recset, valuex, valuey [,expression ] [,KEYED] ) + CORRELATION( + ) + + + + 1 + COS + COS(angle) + COS( + ) + + + + 1 + COSH + COSH(angle) + COSH( + ) + + + + 1 + COUNT + COUNT(recordset [ , expression ] ) + COUNT( + ) + + + + 1 + COVARIANCE + COVARIANCE(recset, valuex, valuey [,expression ] [,KEYED] ) + COVARIANCE( + ) + + + + 1 + CRON + CRON( time ) + CRON( + ) + + + + 1 + DATASET + DATASET( file, recorddef, mode [ , parentfile [ , linkexpression ] ] [,OPT ] ) + DATASET( + ) + + + + 1 + DEDUP + DEDUP(recordset [, expression [,ALL] [,KEEP n ] [,keeper] ] [, LOCAL ] ) + DEDUP( + ) + + + + 1 + DEFINE + DEFINE(pattern,symbol) + DEFINE( + ) + + + + 1 + DENORMALIZE + DENORMALIZE(parentrecset, childrecset, condition, transform [,LOCAL]) + DENORMALIZE( + ) + + + + 1 + DICTIONARY + DICTIONARY(dataset, structure) + DICTIONARY( + ) + + + + 1 + DISTRIBUTE + DISTRIBUTE(recordset, expression ) + DISTRIBUTE( + ) + + + + 1 + DISTRIBUTED + DISTRIBUTED(recordset, expression ) + DISTRIBUTED( + ) + + + + 1 + DISTRIBUTION + DISTRIBUTION(recordset) + DISTRIBUTION( + ) + + + + 1 + EBCDIC + EBCDIC(recordset) + EBCDIC( + ) + + + + 1 + ENTH + ENTH(recordset, numerator [, denominator [, which ] ] [, LOCAL] ) + ENTH( + ) + + + + 1 + ERROR + ERROR( errorcode, errormessage) + ERROR( + ) + + + + 1 + EVALUATE + EVALUATE(onerecord, value) + EVALUATE( + ) + + + + 1 + EVENT + EVENT( event ) + EVENT( + ) + + + + 1 + EVENTEXTRA + EVENTEXTRA( tag ) + EVENTEXTRA( + ) + + + + 1 + EVENTNAME + EVENTNAME + EVENTNAME + + + + + 1 + EXISTS + EXISTS(recordset) + EXISTS( + ) + + + + 1 + EXP + EXP(n) + EXP( + ) + + + + 1 + FAILCODE + FAILCODE + FAILCODE + + + + + 1 + FAILMESSAGE + FAILMESSAGE [(tag)] + FAILMESSAGE( + ) + + + + 1 + FETCH + FETCH(recordset, index, position, transform [,LOCAL] ) + FETCH( + ) + + + + 1 + FROMUNICODE + FROMUNICODE( unicodestring, encoding ) + FROMUNICODE( + ) + + + + 1 + FROMXML + FROMXML( record, xmlstring ) + FROMXML( + ) + + + + 1 + GETENV + GETENV( name [, default ] ) + GETENV( + ) + + + + 1 + GETISVALID + GETISVALID( expression ) + GETISVALID( + ) + + + + 1 + GLOBAL + GLOBAL( expression ) + GLOBAL( + ) + + + + 1 + GRAPH + GRAPH(recordset,iterations,processor) + GRAPH( + ) + + + + 1 + GROUP + GROUP( recordset [, breakcriteria [, ALL ] ] [, LOCAL ] ) + GROUP( + ) + + + + 1 + HASH + HASH(expressionlist) + HASH( + ) + + + + 1 + HASH32 + HASH32(expresionlist) + HASH32( + ) + + + + 1 + HASH64 + HASH64( expressionlist ) + HASH64( + ) + + + + 1 + HASHCRC + HASHCRC( expressionlist ) + HASHCRC( + ) + + + + 1 + HASHMD5 + HASHMD5(expressionlist) + HASHMD5( + ) + + + + 1 + HAVING + HAVING(groupeddataset,expression) + HAVING( + ) + + + + 1 + HTTPCALL + HTTPCALL( url, httpmethod, responsemimetype, outstructure [, options ] ) + HTTPCALL + ) + + + + 1 + HTTPHEADER + HTTPHEADER( name, value ) + HTTPHEADER + ) + + + + 1 + IF + IF(expression,truevalue,falsevalue) + IF( + ) + + + + 1 + IFF + IFF(expression,truevalue,falsevalue) + IFF( + ) + + + + 1 + INDEX + INDEX( baserecordset, recorddef, indexfile) + INDEX( + ) + + + + 1 + INTFORMAT + INTFORMAT(expression, width, mode) + INTFORMAT( + ) + + + + 1 + ISVALID + ISVALID( field ) + ISVALID( + ) + + + + 1 + ITERATE + ITERATE(recordset, transform [,LOCAL] ) + ITERATE( + ) + + + + 1 + JOIN + JOIN(leftrecset, rightrecset, condition [, transform] [, jointype] [, FIRST] [, LOCAL] [, LOOKUP] [, NOSORT] [, KEYED(index) ] [, SKEW(threshold) ] ) + JOIN( + ) + + + + 1 + KEYUNICODE + KEYUNICODE( string ) + KEYUNICODE( + ) + + + + 1 + LENGTH + LENGTH(expression) + LENGTH( + ) + + + + 1 + LIBRARY + LIBRARY(module,interface [(parameters)]) + LIBRARY( + ) + + + + 1 + LIMIT + LIMIT( recset, maxrecs [, failclause ] ) + LIMIT( + ) + + + + 1 + LN + LN(n) + LN( + ) + + + + 1 + LOCAL + LOCAL(data) + LOCAL( + ) + + + + 1 + LOG + LOG(n) + LOG( + ) + + + + 1 + LOOP + LOOP(dataset,loopcount,loopbody [,PARALLEL(iterations | iterationlist [,default])) + LOOP( + ) + + + + 1 + MAP + MAP(expression => value, [ expression => value, ... , ] elsevalue) + MAP( + => , ) + + + + 1 + MATCHED + MATCHED([pattern]) + MATCHED( + ) + + + + 1 + MATCHLENGTH + MATCHLENGTH([pattern]) + MATCHLENGTH( + ) + + + + 1 + MATCHPOSITION + MATCHPOSITION([pattern]) + MATCHPOSITION( + ) + + + + 1 + MATCHTEXT + MATCHTEXT( [pattern] ) + MATCHTEXT( + ) + + + + 1 + MATCHUNICODE + MATCHUNICODE([pattern]) + MATCHUNICODE( + ) + + + + 1 + MAX + MAX(recordset,field) + MAX( + ) + + + + 1 + MERGE + MERGE( recordlist ) + MERGE( + ) + + + + 1 + MERGEJOIN + MERGEJOIN(setofdatasets,joincondition,SORTED(fields) [,jointype] [,DEDUP]) + MERGEJOIN( + ) + + + + 1 + MIN + MIN(recordset,field) + MIN( + ) + + + + 1 + NOFOLD + NOFOLD( expression ) + NOFOLD( + ) + + + + 1 + NOLOCAL + NOLOCAL(data) + NOLOCAL( + ) + + + + 1 + NONEMPTY + NONEMPTY(recordsetlist) + NONEMPTY( + ) + + + + 1 + NORMALIZE + NORMALIZE(recordset, expression, transform [, LOCAL ]) + NORMALIZE( + ) + + + + 1 + PARSE + PARSE( dataset, data, pattern, resultstructure, flags ) + PARSE( + ) + + + + 1 + PIPE + PIPE( command, recorddef ) or PIPE( recordset, command [, recorddef ] ) + PIPE( + ) + + + + 1 + POWER + POWER(base,exponent) + POWER( + ) + + + + 1 + PRELOAD + PRELOAD( ) + PRELOAD( + ) + + + + 1 + PROCESS + PROCESS(recordset,datarow,dstransfrom,rowtransform) + PROCESS( + ) + + + + 1 + PROJECT + PROJECT(recordset, transform) + PROJECT( + ) + + + + 1 + PULL + PULL(dataset) + PULL( + ) + + + + 1 + RANDOM + RANDOM() + RANDOM() + + + + + 1 + RANGE + RANGE(setofdatasets,setofintegers) + RANGE( + ) + + + + 1 + RANK + RANK(position, set [ ,DESCEND ]) + RANK( + ) + + + + 1 + RANKED + RANKED(position, set [ ,DESCEND ]) + RANKED( + ) + + + + 1 + REALFORMAT + REALFORMAT(value,width,decimals) + REALFORMAT( + ) + + + + 1 + RECORDOF + RECORDOF( dataset) + RECORDOF( + ) + + + + 1 + REGEXFIND + REGEXFIND(regex,parsetext [,flag]) + REGEXFIND( + ) + + + + 1 + REGEXREPLACE + REGEXREPLACE( regexpression, parsetext, replacement ) + REGEXREPLACE( + ) + + + + 1 + REGROUP + REGROUP(recset, ... ,recset) + REGROUP( + ) + + + + 1 + REJECTED + REJECTED(condition, ... ,condition) + REJECTED( + ) + + + + 1 + ROLLUP + ROLLUP(recordset, condition, transform [, LOCAL] ) + ROLLUP( + ) + + + + 1 + ROUND + ROUND(realvalue) + ROUND( + ) + + + + 1 + ROUNDUP + ROUNDUP(realvalue) + ROUNDUP( + ) + + + + 1 + ROW + ROW( { values }, recstruct ) + ROW( { + }, ) + + + + 1 + ROWDIFF + ROWDIFF( left, right [, COUNT] ) + ROWDIFF( + ) + + + + 1 + SAMPLE + SAMPLE(recordset, interval, which) + SAMPLE( + ) + + + + 1 + SET + SET(dataset,field) + SET( + ) + + + + 1 + SIN + SIN(angle) + SIN( + ) + + + + 1 + SINH + SINH(angle) + SINH( + ) + + + + 1 + SIZEOF + SIZEOF(data) + SIZEOF( + ) + + + + 1 + SOAPCALL + SOAPCALL( [ recset, ] url, service, instructure, DATASET(outstructure) | outstructure, options ) + SOAPCALL + ) + + + + 1 + SORT + SORT(recordset,value [, JOINED( joinedset )][, SKEW( threshold )][, LOCAL ]) + SORT( + ) + + + + 1 + SORTED + SORTED(recordset,value1,...,valuen) + SORTED( + ) + + + + 1 + SQRT + SQRT(n) + SQRT( + ) + + + + 1 + STEPPED + STEPPED(index,fields) + STEPPED( + ) + + + + 1 + STORED + STORED(interface) + STORED( + ) + + + + 1 + SUM + SUM(recordset,field) + SUM( + ) + + + + 1 + TABLE + TABLE(recordset,format [,expression [,FEW] ] [, LOCAL ] ) + TABLE( + ) + + + + 1 + TAN + TAN(angle) + TAN( + ) + + + + 1 + TANH + TANH(angle) + TANH( + ) + + + + 1 + THISNODE + THISNODE(operation) + THISNODE( + ) + + + + 1 + TOPN + TOPN(recordset,count,sorts) + TOPN( + ) + + + + 1 + TOUNICODE + TOUNICODE( textstring, encoding ) + TOUNICODE( + ) + + + + 1 + TOXML + TOXML( record ) + TOXML( + ) + + + + 1 + TRANSFER + TRANSFER(value,type) + TRANSFER( + ) + + + + 1 + TRIM + TRIM(string_value [ ,flag ] ) + TRIM( + ) + + + + 1 + TRUNCATE + TRUNCATE(real_value) + TRUNCATE( + ) + + + + 1 + TYPEOF + TYPEOF( attr ) + TYPEOF( + ) + + + + 1 + UNGROUP + UNGROUP( groupedrecset ) + UNGROUP( + ) + + + + 1 + UNICODEORDER + UNICODEORDER(left,right,locale) + UNICODEORDER( + ) + + + + 1 + VARIANCE + VARIANCE(recset,valuex [,expression][,KEYED]) + VARIANCE( + ) + + + + 1 + WHICH + WHICH(condition,...,condition) + WHICH( + ) + + + + 1 + WORKUNIT + WORKUNIT + WORKUNIT + + + + + 1 + XMLDECODE + XMLDECODE( xml ) + XMLDECODE( + ) + + + + 1 + XMLENCODE + XMLENCODE( unicode ) + XMLENCODE( + ) + + + + 1 + XMLTEXT + XMLTEXT( 'xpath' ) + XMLTEXT( + ) + + + + 1 + XMLUNICODE + XMLUNICODE( 'xpath' ) + XMLUNICODE( + ) + + + + 2 + APPLY + [name := ] APPLY(dataset, action [, action]) + APPLY( + ) + + + + 2 + ASSERT + [name := ] ASSERT( condition [,message] [,FAIL]) + ASSERT( + ) + + + + 2 + BUILD + [name := ] BUILD(dataset [, file] ) + BUILD( + ) + + + + 2 + BUILDINDEX + [name := ] BUILDINDEX(baserecordset, [indexdef], indexfile) + BUILDINDEX( + ) + + + + 2 + EVALUATE + [name := ] EVALUATE( function ) + EVALUATE( + ) + + + + 2 + FAIL + [name := ] FAIL( errormessage ) + FAIL( + ) + + + + 2 + KEYDIFF + [name := ] KEYDIFF(index1, index2, file ) + KEYDIFF( + ) + + + + 2 + KEYPATCH + [name := ] KEYPATCH(index, patchfile, newfile ) + KEYPATCH( + ) + + + + 2 + LOADXML + [name := ] LOADXML( xmlstring ) + LOADXML( + ) + + + + 2 + NOTHOR + [name := ] NOTHOR(action) + NOTHOR( + ) + + + + 2 + NOTIFY + [name := ] NOTIFY(event ,subtype ) + NOTIFY( + ) + + + + 2 + OUTPUT + [name := ] OUTPUT(recordset [ ,format ] [ ,file ] ) + OUTPUT( + ,{ }) + + + + 2 + PARALLEL + [name := ] PARALLEL( actionlist ) + PARALLEL( + ) + + + + 2 + SEQUENTIAL + [name := ] SEQUENTIAL( actionlist ) + SEQUENTIAL( + ) + + + + 2 + SOAPCALL + [name := ] SOAPCALL( [ recset, ] url, service, instructure, options ) + SOAPCALL( + ) + + + + 2 + WAIT + [name := ] WAIT( event ) + WAIT( + ) + + + + 3 + ALL + + ALL + + + + + 3 + AND + + AND + + + + + 3 + ANY + + ANY + + + + + 3 + AS + + AS + + + + + 3 + FROM + + FROM + + + + + 3 + ATMOST + ATMOST( n ) + ATMOST( + ) + + + + 3 + BEFORE + + BEFORE + + + + + 3 + BEGINC + + BEGINC + + + + + 3 + BEST + + BEST + + + + + 3 + BETWEEN + + BETWEEN + AND + + + + 3 + CASE + CASE(pattern) + CASE( + ) + + + + 3 + CONST + + CONST + + + + + 3 + COUNTER + + COUNTER + + + + + 3 + CSV + CSV ( options ) + CSV( + ) + + + + 3 + DESCEND + + DESCEND + + + + + 3 + EMBED + EMBED ( language ) + EMBED + + + + + 3 + ENCRYPT + + ENCRYPT + + + + + 3 + END + + END + + + + + 3 + ENDC + + ENDC + + + + + 3 + ENDEMBED + + ENDEMBED + + + + + 3 + ENDMACRO + + ENDMACRO + + + + + 3 + ENUM + ENUM( [ type ,] name [=value] [ , name [=value] ... ] ) + ENUM + + + + + 3 + EXCEPT + + EXCEPT + + + + + 3 + EXCLUSIVE + + EXCLUSIVE + + + + + 3 + EXPIRE + EXPIRE( days ) + EXPIRE( + ) + + + + 3 + EXPORT + + EXPORT + + + + + 3 + EXTEND + + EXTEND + + + + + 3 + FALSE + + FALSE + + + + + 3 + FEW + + FEW + + + + + 3 + FIRST + + FIRST + + + + + 3 + FLAT + + FLAT + + + + + 3 + FULL + + FULL + + + + + 3 + FUNCTION + + FUNCTION + + + + + 3 + FUNCTIONMACRO + + FUNCTIONMACRO + + + + + 3 + GROUP + + GROUP + + + + + 3 + HEADER + HEADER( number of header recs ) + HEADER( + ) + + + + 3 + HEADING + HEADING( headertext [,footertext]) + HEADING( + ) + + + + 3 + HOLE + + HOLE + + + + + 3 + IFBLOCK + IFBLOCK( condition ) ... END; + IFBLOCK( + ) + + + + 3 + IMPORT + IMPORT module + IMPORT + + + + + 3 + IN + value IN set + IN + + + + + 3 + JOINED + JOINED( joinedset ) + JOINED( + ) + + + + 3 + KEEP + KEEP n + KEEP + + + + + 3 + KEYED + keyed JOIN + KEYED( + ) + + + + 3 + LAST + + LAST + + + + + 3 + LEFT + + LEFT + + + + + 3 + LIMIT + LIMIT( value [, SKIP ] ) + LIMIT( + ) + + + + 3 + LOAD + + LOAD + + + + + 3 + LOCAL + + LOCAL + + + + + 3 + LOCALE + LOCALE( localestring ) + LOCALE( + ) + + + + 3 + LOOKUP + + LOOKUP + + + + + 3 + MACRO + + MACRO + + + + + 3 + MANY + + MANY + + + + + 3 + MAXCOUNT + + MAXCOUNT + + + + + 3 + MAXLENGTH + MAXLENGTH( length ) + MAXLENGTH( + ) + + + + 3 + MIN SKEW + + MIN SKEW + + + + + 3 + MODULE + + MODULE + + + + + 3 + INTERFACE + + MODULE + + + + + 3 + NAMED + + NAMED + + + + + 3 + NOCASE( + NOCASE(expression) + NOCASE + ) + + + + 3 + NOROOT + + NOROOT + + + + + 3 + NOSCAN + + NOSCAN + + + + + 3 + NOSORT + + NOSORT + + + + + 3 + NOT + + NOT + + + + + 3 + OF + + OF + + + + + 3 + ONLY + + ONLY + + + + + 3 + OPT + + OPT + + + + + 3 + OR + + OR + + + + + 3 + OUTER + + OUTER + + + + + 3 + OVERWRITE + + OVERWRITE + + + + + 3 + PACKED + + PACKED + + + + + 3 + PARTITION + + PARTITION + + + + + 3 + PENALTY + PENALTY(cost) + PENALTY( + ) + + + + 3 + PHYSICALLENGTH + + PHYSICALLENGTH + + + + + 3 + PIPE + + PIPE( + ) + + + + 3 + QUOTE + QUOTE( [ delimiter ] ) + QUOTE( + ) + + + + 3 + RECORD + + RECORD| + |END; + + + + 3 + REPEAT + + REPEAT + + + + + 3 + RETURN + + RETURN + + + + + 3 + RIGHT + + RIGHT + + + + + 3 + ROWS + ROWS( LEFT | RIGHT ) + ROWS + + + + + 3 + SCAN + + SCAN + + + + + 3 + SELF + + SELF. + + + + + 3 + SEPARATOR + SEPARATOR( delimiters ) + SEPARATOR( + ) + + + + 3 + SERVICE + + SERVICE + + + + + 3 + SHARED + + SHARED + + + + + 3 + SKEW + SKEW( limit [, target ] ) + SKEW( + ) + + + + 3 + SKIP + SKIP [ ( condition ) ] + SKIP + + + + + 3 + SQL + + SQL + + + + + 3 + STORE + + STORE + + + + + 3 + TERMINATOR + TERMINATOR( delimiter ) + TERMINATOR( + ) + + + + 3 + THOR + + THOR + + + + + 3 + THRESHOLD + THRESHOLD( size ) + THRESHOLD( + ) + + + + 3 + TOKEN + TOKEN(pattern) + TOKEN( + ) + + + + 3 + TRANSFORM + + TRANSFORM + + + + + 3 + TRIM + + TRIM + + + + + 3 + TRUE + + TRUE + + + + + 3 + TYPE + + TYPE + + + + + 3 + UNICODEORDER + UNICODEORDER( expr1, expr2, localestring ) + UNICODEORDER( + ) + + + + 3 + UNSORTED + + UNSORTED + + + + + 3 + VALIDATE + + VALIDATE( + ) + + + + 3 + VIRTUAL + + VIRTUAL + + + + + 3 + WHOLE + + WHOLE + + + + + 3 + WILD + + WILD( + ) + + + + 3 + WITHIN + + WITHIN + + + + + 3 + XML + XML [ (xpath) ] + XML( + ) + + + + 3 + XPATH + + XPATH + + + + + 3 + AFTER + + AFTER + + + + + 3 + CLUSTER + + CLUSTER + + + + + 3 + COMPRESSED + + COMPRESSED + + + + + 3 + COMPRESSION + + COMPRESSION + + + + + 3 + DEFAULT + + DEFAULT + + + + + 3 + ENCODING + + ENCODING + + + + + 3 + ESCAPE + + ESCAPE + + + + + 3 + FILEPOSITION + + FILEPOSITION + + + + + 3 + FORWARD + + FORWARD + + + + + 3 + GROUPED + + GROUPED + + + + + 3 + INNER + + INNER + + + + + 3 + INTERNAL + + INTERNAL + + + + + 3 + LINKCOUNTED + + LINKCOUNTED + + + + + 3 + LITERAL + + LITERAL + + + + + 3 + LITTLE_ENDIAN + + LITTLE_ENDIAN + + + + + 3 + LZW + + LZW + + + + + 3 + MOFN + + XPATH + + + + + 3 + MULTIPLE + + MULTIPLE + + + + + 3 + NAMESPACE + + NAMESPACE + + + + + 3 + NOCASE + + NOCASE + + + + + 3 + NOTRIM + + NOTRIM + + + + + 3 + NOXPATH + + NOXPATH + + + + + 3 + ONFAIL + + ONFAIL + + + + + 3 + OVERWRITE + + OVERWRITE + + + + + 3 + PREFETCH + + PREFETCH + + + + + 3 + RETRY + + RETRY + + + + + 3 + RIGHT1 + + RIGHT1 + + + + + 3 + RIGHT2 + + RIGHT2 + + + + + 3 + ROWSET + + ROWSET + + + + + 3 + XPATH + + XPATH + + + + + 3 + SCOPE + + SCOPE + + + + + 3 + SMART + + SMART + + + + + 3 + SOAPACTION + + SOAPACTION + + + + + 3 + STABLE + + STABLE + + + + + 3 + TIMELIMIT + + TIMELIMIT + + + + + 3 + TIMEOUT + + XPATH + + + + + 3 + UNORDERED + + UNORDERED + + + + + 3 + UNSTABLE + + UNSTABLE + + + + + 3 + UPDATE + + UPDATE + + + + + 3 + USE + + USE + + + + + 3 + WIDTH + + WIDTH + + + + + 3 + __COMPRESSED__ + + __COMPRESSED__ + + + + + 4 + ASCII + + ASCII + + + + + 4 + BIG_ENDIAN + + BIG_ENDIAN + + + + + 4 + BOOLEAN + + BOOLEAN + + + + + 4 + DATA + + DATA + + # + + + 4 + DECIMAL + + DECIMAL + + #_# + + + 4 + EBCDIC + + EBCDIC + + + + + 4 + GROUPED + + GROUPED + + + + + 4 + INTEGER + + INTEGER + + 1,2,3,4,5,6,7,8,| + + + 4 + LINKCOUNTED + + LINKCOUNTED + + + + + 4 + PATTERN + + PATTERN + + + + + 4 + QSTRING + + QSTRING + + #| + + + 4 + REAL + + REAL + + 4,8,| + + + 4 + RECORD + + RECORD + + + + + 4 + RULE + + RULE + + + + + 4 + SET OF + + SET OF + + + + + 4 + STREAMED + + STREAMED + + + + + 4 + STRING + + STRING + + #| + + + 4 + TOKEN + + TOKEN + + + + + 4 + UDECIMAL + + UDECIMAL + + #_# + + + 4 + UNICODE + + UNICODE + + #| + + + 4 + UNSIGNED + + UNSIGNED + + 1,2,3,4,5,6,7,8,| + + + 4 + VARSTRING + + VARSTRING + + #| + + + 4 + VARUNICODE + + VARUNICODE + + #| + + + 5 + CHECKPOINT + + : CHECKPOINT( + ) + + + + 5 + DEPRECATED + + : DEPRECATED + + + + + 5 + FAILCODE + + FAILCODE + + + + + 5 + FAILMESSAGE + + FAILMESSAGE + + + + + 5 + FAILURE + + : FAILURE( + ) + + + + 5 + GLOBAL + + : GLOBAL + + + + + 5 + INDEPENDENT + + : INDEPENDENT + + + + + 5 + ONWARNING + + : ONWARNING( + ) + + + + 5 + PERSIST + + : PERSIST + + + + + 5 + PRIORITY + + : PRIORITY + + + + + 5 + RECOVERY + + : RECOVERY( + ) + + + + 5 + STORED + + : STORED( + ) + + + + 5 + SUCCESS + + : SUCCESS( + ) + + + + 5 + WAIT + + WAIT( + ) + + + + 5 + WHEN + + : WHEN( + ) + + + + 6 + #APPEND + #APPEND( symbol , expression ) + #APPEND( + ) + + + + 6 + #BREAK + + #BREAK + + + + + 6 + #DECLARE + #DECLARE( symbol ) + #DECLARE( + ) + + + + 6 + #DEMANGLE + #DEMANGLE( identifier ) + #DEMANGLE( + ) + + + + 6 + #END + + #END + + + + + 6 + #FOR + #FOR( tag [ ( filter ) ] ) + #FOR( + ) + + + + 6 + #GETDATATYPE + #GETDATATYPE( field ) + #GETDATATYPE( + ) + + + + 6 + #IF + #IF( condition ) + #IF( + ) + + + + 6 + #INMODULE + #INMODULE( module, attribute ) + #INMODULE( + ) + + + + 6 + #LOOP + + #LOOP + + + + + 6 + #MANGLE + #MANGLE( string ) + #MANGLE( + ) + + + + 6 + #ONWARNING + #ONWARNING(code, action) + #ONWARNING( + ) + + + + 6 + #OPTION + #OPTION('optionname',value) + #OPTION( + ) + + + + 6 + #SET + #SET( symbol, expression ) + #SET( + ) + + + + 6 + #STORED + #STORED( 'name', value ) + #STORED( + ) + + + + 6 + #UNIQUENAME + #UNIQUENAME( namevar [,template]) + #UNIQUENAME( + ) + + + + 6 + #WORKUNIT + #WORKUNIT() + #WORKUNIT( + ) + + + + 6 + Integer Symbol Value + + % + % + + + + 6 + Text Symbol Value + + %' + '% + + + + + diff --git a/docs/LanguageRefESDL.xml b/docs/LanguageRefESDL.xml index 89129104..d23b4416 100644 --- a/docs/LanguageRefESDL.xml +++ b/docs/LanguageRefESDL.xml @@ -1,4 +1,4 @@ - + @@ -10,10 +10,10 @@ EXAMPLE: ESPstruct NameBlock { - string FirstName; - string MiddleName; - string LastName; - int Age; + string FirstName; + string MiddleName; + string LastName; + int Age; }; diff --git a/docs/LanguageRefKEL.xml b/docs/LanguageRefKEL.xml new file mode 100644 index 00000000..3c4c94df --- /dev/null +++ b/docs/LanguageRefKEL.xml @@ -0,0 +1,968 @@ + + + + + 120 + 0 + + 1 + ENTITY + ENTITY( filter ) { projection } + + + + + + 1 + MODEL + + + + + + + 1 + ERA + + + + + + + 1 + VISUALIZE + + + + + + + 1 + ASSOCIATION + + + + + + + 1 + USE + + + + + + + 1 + #OPTION + + + + + + + 1 + IMPORT + + + + + + + 1 + PACKAGE + + + + + + + 1 + QUERY + + + + + + + 1 + SHELL + + + + + + + 2 + COUNT + COUNT(entityset) + + + + + + 2 + WEIGHTEDCOUNT + WEIGHTEDCOUNT(entityset) + + + + + + 2 + SUM + SUM(entityset, value) + + + + + + 2 + WEIGHTEDSUM + WEIGHTEDSUM(entityset, value) + + + + + + 2 + MIN + MIN(entityset, value) + + + + + + 2 + MAX + MAX(entityset, value) + + + + + + 2 + RANGE + RANGE(entityset, value) + + + + + + 2 + AVE + AVE(entityset, value) + + + + + + 2 + WEIGHTEDAVE + WEIGHTEDAVE(entityset, value) + + + + + + 2 + AVENZ + AVENZ(entityset, value) + + + + + + 2 + WEIGHTEDAVENZ + WEIGHTEDAVENZ(entityset,value) + + + + + + 2 + STDDEV + STDDEV(entityset, value) + + + + + + 2 + WEIGHTEDSTDDEV + WEIGHTEDSTDDEV(entityset,value) + + + + + + 2 + VARIANCE + VARIANCE(entityset, value) + + + + + + 2 + WEIGHTEDVARIANCE + WEIGHTEDVARIANCE(entityset,value) + + + + + + 2 + RANK + RANK(entityset, value, n) + + + + + + 2 + WEIGHTEDRANK + WEIGHTEDRANK(entityset,value, n) + + + + + + 2 + PERCENTILE + PERCENTILE(entityset, value, n) + + + + + + 2 + WEIGHTEDPERCENTILE + WEIGHTEDPERCENTILE(entityset, value, n) + + + + + + 2 + QUARTILE + QUARTILE(entityset, value, n) + + + + + + 2 + WEIGHTEDQUARTILE + WEIGHTEDQUARTILE(entityset, value, n) + + + + + + 2 + MEDIAN + MEDIAN(entityset, value) + + + + + + 2 + WEIGHTEDMEDIAN + WEIGHTEDMEDIAN(entityset, value) + + + + + + 2 + IQR + IQR(entityset, value) + + + + + + 2 + WEIGHTEDIQR + WEIGHTEDIQR(entityset, value) + + + + + + 3 + CURRENTDATE + CURRENTDATE() + + + + + + 3 + DATESFORMONTHSTART + DATESFORMONTHSTART(date) + + + + + + 3 + DATESFORMONTHEND + DATESFORMONTHEND(date) + + + + + + 3 + DATESFORWEEKSTART + DATESFORWEEKSTART(date) + + + + + + 3 + DATESFORWEEKEND + DATESFORWEEKEND(date) + + + + + + 3 + DATETOSTRING + DATETOSTRING(date, format) + + + + + + 3 + DAY + DAY(date) + + + + + + 3 + DAYOFWEEK + DAYOFWEEK(date) + + + + + + 3 + DAYOFYEAR + DAYOFYEAR(date) + + + + + + 3 + DAYSBETWEEN + DAYSBETWEEN(from, to) + + + + + + 3 + FROMGREGORIANDATE + FROMGREGORIANDATE(date) + + + + + + 3 + FROMSTRINGTODATE + FROMSTRINGTODATE(text, format) + + + + + + 3 + INTEGERFROMDATE + INTEGERFROMDATE(date) + + + + + + 3 + ISDATELEAPYEAR + ISDATELEAPYEAR(date) + + + + + + 3 + ISLEAPYEAR + ISLEAPYEAR(year) + + + + + + 3 + ISJULIANLEAPYEAR + ISJULIANLEAPYEAR(days) + + + + + + 3 + ISVALIDDATE + ISVALIDDATE(date) + + + + + + 3 + MONTH + MONTH(date) + + + + + + 3 + MONTHSBETWEEN + MONTHSBETWEEN(from, to) + + + + + + 3 + TODAY + TODAY() + + + + + + 3 + TOGREGORIANDATE + TOGREGORIANDATE(days) + + + + + + 3 + YEAR + YEAR(date) + + + + + + 3 + YEARSBETWEEN + YEARSBETWEEN(from, to) + + + + + + 4 + ALL + ALL(domain,condition) + + + + + + 4 + BOUNDSCLIP + BOUNDSCLIP(value,low,high) + + + + + + 4 + BOUNDSFOLD + BOUNDSFOLD(value,low,high) + + + + + + 4 + CONTAINS + CONTAINS(source,target) + + + + + + 4 + ENDSWITH + ENDSWITH(source,target) + + + + + + 4 + EXISTS + EXISTS(expression) + + + + + + 4 + ONLY + ONLY(entity_expression) + + + + + + 4 + ONLY + ONLY(set_expression, field) + + + + + + 4 + ONLY + ONLY(Owns(veh.myear = Person.Owns.veh.myear$Max) + + + + + + 4 + STARTSWITH + STARTSWITH(source,target) + + + + + + 4 + SUBSTR + SUBSTR(string,start) + + + + + + 4 + SUBSTR + SUBSTR(string,start,end) + + + + + + 4 + TRIMLEFT + TRIMLEFT(text) + + + + + + 4 + TRIM + TRIM(text,LEFT) + + + + + + 4 + TRIMBOTH + TRIMBOTH(text) + + + + + + 4 + TRIM + TRIM(text,LEFT,RIGHT) + + + + + + 4 + TRIMALL + TRIMALL(text) + + + + + + 4 + UPCASE + UPCASE(text) + + + + + + 4 + WORDCOUNT + WORDCOUNT(text) + + + + + + 4 + WORDCOUNT + WORDCOUNT(text,separator) + + + + + + 4 + WORD + WORD(text,N,[separator]) + + + + + + 5 + ABS + + + + + + + 5 + ACOS + + + + + + + 5 + ATAN + + + + + + + 5 + ATAN2 + + + + + + + 5 + COS + + + + + + + 5 + COSH + + + + + + + 5 + EXP + + + + + + + 5 + IF + + + + + + + 5 + INTFORMAT + + + + + + + 5 + LENGTH + + + + + + + 5 + LN + + + + + + + 5 + LOG + + + + + + + 5 + MAP + + + + + + + 5 + POWER + + + + + + + 5 + REALFORMAT + + + + + + + 5 + ROUND + + + + + + + 5 + ROUNDUP + + + + + + + 5 + SIN + + + + + + + 5 + SINH + + + + + + + 5 + SQRT + + + + + + + 5 + TAN + + + + + + + 5 + TANH + + + + + + + 5 + TOPN + + + + + + + 5 + TRIM + + + + + + + 5 + TRUNCATE + + + + + + + 5 + UID + + + + + + + 5 + FLAT + + + + + + + 5 + XML + + + + + + + 5 + TEXT + + + + + + + 6 + STRING + + + + + + + 6 + INTEGER + + + + + + + 6 + REAL + + + + + + + 6 + BOOLEAN + + + + + + + 6 + DATE + + + + + + + 6 + UID + + + + + + + 6 + UNK + + + + + + + 7 + AND + Boolean AND operator. + + + + + + 7 + OR + Boolean OR operator. + + + + + + 7 + NOT + Boolean NOT operator. + + + + + + 7 + IN + Boolean IN operator. + + + + + + \ No newline at end of file diff --git a/docs/LanguageReference.xml b/docs/LanguageReference.xml index e9e38005..782bcbc2 100644 --- a/docs/LanguageReference.xml +++ b/docs/LanguageReference.xml @@ -1,2913 +1,57 @@ - - 363 - 0 - - 1 - ABS - ABS(expression) - ABS( - ) - - - - 1 - ACOS - ACOS(cosine) - ACOS( - ) - - - - 1 - AGGREGATE - AGGREGATE( recordset, resultrec,maintransform [ , mergetransform (RIGHT1,RIGHT2) ] [, groupingfields ] [, LOCAL | FEW | MANY] ) - AGGREGATE( - ) - - - - 1 - ALLNODES - ALLNODES(operation) - ALLNODES( - ) - - - - 1 - ASCII - ASCII(recordset) - ASCII( - ) - - - - 1 - ASIN - ASIN(sine) - ASIN( - ) - - - - 1 - ASSTRING - ASSTRING( value ) - ASSTRING( - ) - - - - 1 - ATAN - ATAN(tangent) - ATAN( - ) - - - - 1 - ATAN2 - ATAN2( y, x ) - ATAN2( - ) - - - - 1 - AVE - AVE(recordset,field) - AVE( - , ) - - - - 1 - CASE - CASE(expression, caseval => value, [... , caseval => value, ] elsevalue) - CASE( - => , ) - - - - 1 - CATCH - CATCH( recset, action ) - CATCH( - ) - - - - 1 - CHOOSE - CHOOSE(expression, value, ... , value, elsevalue) - CHOOSE( - ) - - - - 1 - CHOOSEN - CHOOSEN(recordset,n) - CHOOSEN( - , ) - - - - 1 - CHOOSESETS - CHOOSESETS( recordset, condition  => n [ ... , condition => n ] ) - CHOOSESETS( - ) - - - - 1 - CLUSTERSIZE - CLUSTERSIZE - CLUSTERSIZE - - - - - 1 - COMBINE - COMBINE(leftrecset,rightrecset [,transform] [,LOCAL]) - COMBINE( - ) - - - - 1 - CORRELATION - CORRELATION(recset, valuex, valuey [,expression ] [,KEYED] ) - CORRELATION( - ) - - - - 1 - COS - COS(angle) - COS( - ) - - - - 1 - COSH - COSH(angle) - COSH( - ) - - - - 1 - COUNT - COUNT(recordset [ , expression ] ) - COUNT( - ) - - - - 1 - COVARIANCE - COVARIANCE(recset, valuex, valuey [,expression ] [,KEYED] ) - COVARIANCE( - ) - - - - 1 - CRON - CRON( time ) - CRON( - ) - - - - 1 - DATASET - DATASET( file, recorddef, mode [ , parentfile [ , linkexpression ] ] [,OPT ] ) - DATASET( - ) - - - - 1 - DEDUP - DEDUP(recordset [, expression [,ALL] [,KEEP n ] [,keeper] ] [, LOCAL ] ) - DEDUP( - ) - - - - 1 - DEFINE - DEFINE(pattern,symbol) - DEFINE( - ) - - - - 1 - DENORMALIZE - DENORMALIZE(parentrecset, childrecset, condition, transform [,LOCAL]) - DENORMALIZE( - ) - - - - 1 - DICTIONARY - DICTIONARY(dataset, structure) - DICTIONARY( - ) - - - - 1 - DISTRIBUTE - DISTRIBUTE(recordset, expression ) - DISTRIBUTE( - ) - - - - 1 - DISTRIBUTED - DISTRIBUTED(recordset, expression ) - DISTRIBUTED( - ) - - - - 1 - DISTRIBUTION - DISTRIBUTION(recordset) - DISTRIBUTION( - ) - - - - 1 - EBCDIC - EBCDIC(recordset) - EBCDIC( - ) - - - - 1 - ENTH - ENTH(recordset, numerator [, denominator [, which ] ] [, LOCAL] ) - ENTH( - ) - - - - 1 - ERROR - ERROR( errorcode, errormessage) - ERROR( - ) - - - - 1 - EVALUATE - EVALUATE(onerecord, value) - EVALUATE( - ) - - - - 1 - EVENT - EVENT( event ) - EVENT( - ) - - - - 1 - EVENTEXTRA - EVENTEXTRA( tag ) - EVENTEXTRA( - ) - - - - 1 - EVENTNAME - EVENTNAME - EVENTNAME - - - - - 1 - EXISTS - EXISTS(recordset) - EXISTS( - ) - - - - 1 - EXP - EXP(n) - EXP( - ) - - - - 1 - FAILCODE - FAILCODE - FAILCODE - - - - - 1 - FAILMESSAGE - FAILMESSAGE [(tag)] - FAILMESSAGE( - ) - - - - 1 - FETCH - FETCH(recordset, index, position, transform [,LOCAL] ) - FETCH( - ) - - - - 1 - FROMUNICODE - FROMUNICODE( unicodestring, encoding ) - FROMUNICODE( - ) - - - - 1 - FROMXML - FROMXML( record, xmlstring ) - FROMXML( - ) - - - - 1 - GETENV - GETENV( name [, default ] ) - GETENV( - ) - - - - 1 - GETISVALID - GETISVALID( expression ) - GETISVALID( - ) - - - - 1 - GLOBAL - GLOBAL( expression ) - GLOBAL( - ) - - - - 1 - GRAPH - GRAPH(recordset,iterations,processor) - GRAPH( - ) - - - - 1 - GROUP - GROUP( recordset [, breakcriteria [, ALL ] ] [, LOCAL ] ) - GROUP( - ) - - - - 1 - HASH - HASH(expressionlist) - HASH( - ) - - - - 1 - HASH32 - HASH32(expresionlist) - HASH32( - ) - - - - 1 - HASH64 - HASH64( expressionlist ) - HASH64( - ) - - - - 1 - HASHCRC - HASHCRC( expressionlist ) - HASHCRC( - ) - - - - 1 - HASHMD5 - HASHMD5(expressionlist) - HASHMD5( - ) - - - - 1 - HAVING - HAVING(groupeddataset,expression) - HAVING( - ) - - - - 1 - HTTPCALL - HTTPCALL( url, httpmethod, responsemimetype, outstructure [, options ] ) - HTTPCALL - ) - - - - 1 - HTTPHEADER - HTTPHEADER( name, value ) - HTTPHEADER - ) - - - - 1 - IF - IF(expression,truevalue,falsevalue) - IF( - ) - - - - 1 - IFF - IFF(expression,truevalue,falsevalue) - IFF( - ) - - - - 1 - INDEX - INDEX( baserecordset, recorddef, indexfile) - INDEX( - ) - - - - 1 - INTFORMAT - INTFORMAT(expression, width, mode) - INTFORMAT( - ) - - - - 1 - ISVALID - ISVALID( field ) - ISVALID( - ) - - - - 1 - ITERATE - ITERATE(recordset, transform [,LOCAL] ) - ITERATE( - ) - - - - 1 - JOIN - JOIN(leftrecset, rightrecset, condition [, transform] [, jointype] [, FIRST] [, LOCAL] [, LOOKUP] [, NOSORT] [, KEYED(index) ] [, SKEW(threshold) ] ) - JOIN( - ) - - - - 1 - KEYUNICODE - KEYUNICODE( string ) - KEYUNICODE( - ) - - - - 1 - LENGTH - LENGTH(expression) - LENGTH( - ) - - - - 1 - LIBRARY - LIBRARY(module,interface [(parameters)]) - LIBRARY( - ) - - - - 1 - LIMIT - LIMIT( recset, maxrecs [, failclause ] ) - LIMIT( - ) - - - - 1 - LN - LN(n) - LN( - ) - - - - 1 - LOCAL - LOCAL(data) - LOCAL( - ) - - - - 1 - LOG - LOG(n) - LOG( - ) - - - - 1 - LOOP - LOOP(dataset,loopcount,loopbody [,PARALLEL(iterations | iterationlist [,default])) - LOOP( - ) - - - - 1 - MAP - MAP(expression => value, [ expression => value, ... , ] elsevalue) - MAP( - => , ) - - - - 1 - MATCHED - MATCHED([pattern]) - MATCHED( - ) - - - - 1 - MATCHLENGTH - MATCHLENGTH([pattern]) - MATCHLENGTH( - ) - - - - 1 - MATCHPOSITION - MATCHPOSITION([pattern]) - MATCHPOSITION( - ) - - - - 1 - MATCHTEXT - MATCHTEXT( [pattern] ) - MATCHTEXT( - ) - - - - 1 - MATCHUNICODE - MATCHUNICODE([pattern]) - MATCHUNICODE( - ) - - - - 1 - MAX - MAX(recordset,field) - MAX( - ) - - - - 1 - MERGE - MERGE( recordlist ) - MERGE( - ) - - - - 1 - MERGEJOIN - MERGEJOIN(setofdatasets,joincondition,SORTED(fields) [,jointype] [,DEDUP]) - MERGEJOIN( - ) - - - - 1 - MIN - MIN(recordset,field) - MIN( - ) - - - - 1 - NOFOLD - NOFOLD( expression ) - NOFOLD( - ) - - - - 1 - NOLOCAL - NOLOCAL(data) - NOLOCAL( - ) - - - - 1 - NONEMPTY - NONEMPTY(recordsetlist) - NONEMPTY( - ) - - - - 1 - NORMALIZE - NORMALIZE(recordset, expression, transform [, LOCAL ]) - NORMALIZE( - ) - - - - 1 - PARSE - PARSE( dataset, data, pattern, resultstructure, flags ) - PARSE( - ) - - - - 1 - PIPE - PIPE( command, recorddef ) or PIPE( recordset, command [, recorddef ] ) - PIPE( - ) - - - - 1 - POWER - POWER(base,exponent) - POWER( - ) - - - - 1 - PRELOAD - PRELOAD( ) - PRELOAD( - ) - - - - 1 - PROCESS - PROCESS(recordset,datarow,dstransfrom,rowtransform) - PROCESS( - ) - - - - 1 - PROJECT - PROJECT(recordset, transform) - PROJECT( - ) - - - - 1 - PULL - PULL(dataset) - PULL( - ) - - - - 1 - RANDOM - RANDOM() - RANDOM() - - - - - 1 - RANGE - RANGE(setofdatasets,setofintegers) - RANGE( - ) - - - - 1 - RANK - RANK(position, set [ ,DESCEND ]) - RANK( - ) - - - - 1 - RANKED - RANKED(position, set [ ,DESCEND ]) - RANKED( - ) - - - - 1 - REALFORMAT - REALFORMAT(value,width,decimals) - REALFORMAT( - ) - - - - 1 - RECORDOF - RECORDOF( dataset) - RECORDOF( - ) - - - - 1 - REGEXFIND - REGEXFIND(regex,parsetext [,flag]) - REGEXFIND( - ) - - - - 1 - REGEXREPLACE - REGEXREPLACE( regexpression, parsetext, replacement ) - REGEXREPLACE( - ) - - - - 1 - REGROUP - REGROUP(recset, ... ,recset) - REGROUP( - ) - - - - 1 - REJECTED - REJECTED(condition, ... ,condition) - REJECTED( - ) - - - - 1 - ROLLUP - ROLLUP(recordset, condition, transform [, LOCAL] ) - ROLLUP( - ) - - - - 1 - ROUND - ROUND(realvalue) - ROUND( - ) - - - - 1 - ROUNDUP - ROUNDUP(realvalue) - ROUNDUP( - ) - - - - 1 - ROW - ROW( { values }, recstruct ) - ROW( { - }, ) - - - - 1 - ROWDIFF - ROWDIFF( left, right [, COUNT] ) - ROWDIFF( - ) - - - - 1 - SAMPLE - SAMPLE(recordset, interval, which) - SAMPLE( - ) - - - - 1 - SET - SET(dataset,field) - SET( - ) - - - - 1 - SIN - SIN(angle) - SIN( - ) - - - - 1 - SINH - SINH(angle) - SINH( - ) - - - - 1 - SIZEOF - SIZEOF(data) - SIZEOF( - ) - - - - 1 - SOAPCALL - SOAPCALL( [ recset, ] url, service, instructure, DATASET(outstructure) | outstructure, options ) - SOAPCALL - ) - - - - 1 - SORT - SORT(recordset,value [, JOINED( joinedset )][, SKEW( threshold )][, LOCAL ]) - SORT( - ) - - - - 1 - SORTED - SORTED(recordset,value1,...,valuen) - SORTED( - ) - - - - 1 - SQRT - SQRT(n) - SQRT( - ) - - - - 1 - STEPPED - STEPPED(index,fields) - STEPPED( - ) - - - - 1 - STORED - STORED(interface) - STORED( - ) - - - - 1 - SUM - SUM(recordset,field) - SUM( - ) - - - - 1 - TABLE - TABLE(recordset,format [,expression [,FEW] ] [, LOCAL ] ) - TABLE( - ) - - - - 1 - TAN - TAN(angle) - TAN( - ) - - - - 1 - TANH - TANH(angle) - TANH( - ) - - - - 1 - THISNODE - THISNODE(operation) - THISNODE( - ) - - - - 1 - TOPN - TOPN(recordset,count,sorts) - TOPN( - ) - - - - 1 - TOUNICODE - TOUNICODE( textstring, encoding ) - TOUNICODE( - ) - - - - 1 - TOXML - TOXML( record ) - TOXML( - ) - - - - 1 - TRANSFER - TRANSFER(value,type) - TRANSFER( - ) - - - - 1 - TRIM - TRIM(string_value [ ,flag ] ) - TRIM( - ) - - - - 1 - TRUNCATE - TRUNCATE(real_value) - TRUNCATE( - ) - - - - 1 - TYPEOF - TYPEOF( attr ) - TYPEOF( - ) - - - - 1 - UNGROUP - UNGROUP( groupedrecset ) - UNGROUP( - ) - - - - 1 - UNICODEORDER - UNICODEORDER(left,right,locale) - UNICODEORDER( - ) - - - - 1 - VARIANCE - VARIANCE(recset,valuex [,expression][,KEYED]) - VARIANCE( - ) - - - - 1 - WHICH - WHICH(condition,...,condition) - WHICH( - ) - - - - 1 - WORKUNIT - WORKUNIT - WORKUNIT - - - - - 1 - XMLDECODE - XMLDECODE( xml ) - XMLDECODE( - ) - - - - 1 - XMLENCODE - XMLENCODE( unicode ) - XMLENCODE( - ) - - - - 1 - XMLTEXT - XMLTEXT( 'xpath' ) - XMLTEXT( - ) - - - - 1 - XMLUNICODE - XMLUNICODE( 'xpath' ) - XMLUNICODE( - ) - - - - 2 - APPLY - [name := ] APPLY(dataset, action [, action]) - APPLY( - ) - - - - 2 - ASSERT - [name := ] ASSERT( condition [,message] [,FAIL]) - ASSERT( - ) - - - - 2 - BUILD - [name := ] BUILD(dataset [, file] ) - BUILD( - ) - - - - 2 - BUILDINDEX - [name := ] BUILDINDEX(baserecordset, [indexdef], indexfile) - BUILDINDEX( - ) - - - - 2 - EVALUATE - [name := ] EVALUATE( function ) - EVALUATE( - ) - - - - 2 - FAIL - [name := ] FAIL( errormessage ) - FAIL( - ) - - - - 2 - KEYDIFF - [name := ] KEYDIFF(index1, index2, file ) - KEYDIFF( - ) - - - - 2 - KEYPATCH - [name := ] KEYPATCH(index, patchfile, newfile ) - KEYPATCH( - ) - - - - 2 - LOADXML - [name := ] LOADXML( xmlstring ) - LOADXML( - ) - - - - 2 - NOTHOR - [name := ] NOTHOR(action) - NOTHOR( - ) - - - - 2 - NOTIFY - [name := ] NOTIFY(event ,subtype ) - NOTIFY( - ) - - - - 2 - OUTPUT - [name := ] OUTPUT(recordset [ ,format ] [ ,file ] ) - OUTPUT( - ,{ }) - - - - 2 - PARALLEL - [name := ] PARALLEL( actionlist ) - PARALLEL( - ) - - - - 2 - SEQUENTIAL - [name := ] SEQUENTIAL( actionlist ) - SEQUENTIAL( - ) - - - - 2 - SOAPCALL - [name := ] SOAPCALL( [ recset, ] url, service, instructure, options ) - SOAPCALL( - ) - - - - 2 - WAIT - [name := ] WAIT( event ) - WAIT( - ) - - - - 3 - ALL - - ALL - - - - - 3 - AND - - AND - - - - - 3 - ANY - - ANY - - - - - 3 - AS - - AS - - - - - 3 - FROM - - FROM - - - - - 3 - ATMOST - ATMOST( n ) - ATMOST( - ) - - - - 3 - BEFORE - - BEFORE - - - - - 3 - BEGINC - - BEGINC - - - - - 3 - BEST - - BEST - - - - - 3 - BETWEEN - - BETWEEN - AND - - - - 3 - CASE - CASE(pattern) - CASE( - ) - - - - 3 - CONST - - CONST - - - - - 3 - COUNTER - - COUNTER - - - - - 3 - CSV - CSV ( options ) - CSV( - ) - - - - 3 - DESCEND - - DESCEND - - - - - 3 - EMBED - EMBED ( language ) - EMBED - - - - - 3 - ENCRYPT - - ENCRYPT - - - - - 3 - END - - END - - - - - 3 - ENDC - - ENDC - - - - - 3 - ENDEMBED - - ENDEMBED - - - - - 3 - ENDMACRO - - ENDMACRO - - - - - 3 - ENUM - ENUM( [ type ,] name [=value] [ , name [=value] ... ] ) - ENUM - - - - - 3 - EXCEPT - - EXCEPT - - - - - 3 - EXCLUSIVE - - EXCLUSIVE - - - - - 3 - EXPIRE - EXPIRE( days ) - EXPIRE( - ) - - - - 3 - EXPORT - - EXPORT - - - - - 3 - EXTEND - - EXTEND - - - - - 3 - FALSE - - FALSE - - - - - 3 - FEW - - FEW - - - - - 3 - FIRST - - FIRST - - - - - 3 - FLAT - - FLAT - - - - - 3 - FULL - - FULL - - - - - 3 - FUNCTION - - FUNCTION - - - - - 3 - FUNCTIONMACRO - - FUNCTIONMACRO - - - - - 3 - GROUP - - GROUP - - - - - 3 - HEADER - HEADER( number of header recs ) - HEADER( - ) - - - - 3 - HEADING - HEADING( headertext [,footertext]) - HEADING( - ) - - - - 3 - HOLE - - HOLE - - - - - 3 - IFBLOCK - IFBLOCK( condition ) ... END; - IFBLOCK( - ) - - - - 3 - IMPORT - IMPORT module - IMPORT - - - - - 3 - IN - value IN set - IN - - - - - 3 - JOINED - JOINED( joinedset ) - JOINED( - ) - - - - 3 - KEEP - KEEP n - KEEP - - - - - 3 - KEYED - keyed JOIN - KEYED( - ) - - - - 3 - LAST - - LAST - - - - - 3 - LEFT - - LEFT - - - - - 3 - LIMIT - LIMIT( value [, SKIP ] ) - LIMIT( - ) - - - - 3 - LOAD - - LOAD - - - - - 3 - LOCAL - - LOCAL - - - - - 3 - LOCALE - LOCALE( localestring ) - LOCALE( - ) - - - - 3 - LOOKUP - - LOOKUP - - - - - 3 - MACRO - - MACRO - - - - - 3 - MANY - - MANY - - - - - 3 - MAXCOUNT - - MAXCOUNT - - - - - 3 - MAXLENGTH - MAXLENGTH( length ) - MAXLENGTH( - ) - - - - 3 - MIN SKEW - - MIN SKEW - - - - - 3 - MODULE - - MODULE - - - - - 3 - INTERFACE - - MODULE - - - - - 3 - NAMED - - NAMED - - - - - 3 - NOCASE( - NOCASE(expression) - NOCASE - ) - - - - 3 - NOROOT - - NOROOT - - - - - 3 - NOSCAN - - NOSCAN - - - - - 3 - NOSORT - - NOSORT - - - - - 3 - NOT - - NOT - - - - - 3 - OF - - OF - - - - - 3 - ONLY - - ONLY - - - - - 3 - OPT - - OPT - - - - - 3 - OR - - OR - - - - - 3 - OUTER - - OUTER - - - - - 3 - OVERWRITE - - OVERWRITE - - - - - 3 - PACKED - - PACKED - - - - - 3 - PARTITION - - PARTITION - - - - - 3 - PENALTY - PENALTY(cost) - PENALTY( - ) - - - - 3 - PHYSICALLENGTH - - PHYSICALLENGTH - - - - - 3 - PIPE - - PIPE( - ) - - - - 3 - QUOTE - QUOTE( [ delimiter ] ) - QUOTE( - ) - - - - 3 - RECORD - - RECORD| - |END; - - - - 3 - REPEAT - - REPEAT - - - - - 3 - RETURN - - RETURN - - - - - 3 - RIGHT - - RIGHT - - - - - 3 - ROWS - ROWS( LEFT | RIGHT ) - ROWS - - - - - 3 - SCAN - - SCAN - - - - - 3 - SELF - - SELF. - - - - - 3 - SEPARATOR - SEPARATOR( delimiters ) - SEPARATOR( - ) - - - - 3 - SERVICE - - SERVICE - - - - - 3 - SHARED - - SHARED - - - - - 3 - SKEW - SKEW( limit [, target ] ) - SKEW( - ) - - - - 3 - SKIP - SKIP [ ( condition ) ] - SKIP - - - - - 3 - SQL - - SQL - - - - - 3 - STORE - - STORE - - - - - 3 - TERMINATOR - TERMINATOR( delimiter ) - TERMINATOR( - ) - - - - 3 - THOR - - THOR - - - - - 3 - THRESHOLD - THRESHOLD( size ) - THRESHOLD( - ) - - - - 3 - TOKEN - TOKEN(pattern) - TOKEN( - ) - - - - 3 - TRANSFORM - - TRANSFORM - - - - - 3 - TRIM - - TRIM - - - - - 3 - TRUE - - TRUE - - - - - 3 - TYPE - - TYPE - - - - - 3 - UNICODEORDER - UNICODEORDER( expr1, expr2, localestring ) - UNICODEORDER( - ) - - - - 3 - UNSORTED - - UNSORTED - - - - - 3 - VALIDATE - - VALIDATE( - ) - - - - 3 - VIRTUAL - - VIRTUAL - - - - - 3 - WHOLE - - WHOLE - - - - - 3 - WILD - - WILD( - ) - - - - 3 - WITHIN - - WITHIN - - - - - 3 - XML - XML [ (xpath) ] - XML( - ) - - - - 3 - XPATH - - XPATH - - - - - 3 - AFTER - - AFTER - - - - - 3 - CLUSTER - - CLUSTER - - - - - 3 - COMPRESSED - - COMPRESSED - - - - - 3 - COMPRESSION - - COMPRESSION - - - - - 3 - DEFAULT - - DEFAULT - - - - - 3 - ENCODING - - ENCODING - - - - - 3 - ESCAPE - - ESCAPE - - - - - 3 - FILEPOSITION - - FILEPOSITION - - - - - 3 - FORWARD - - FORWARD - - - - - 3 - GROUPED - - GROUPED - - - - - 3 - INNER - - INNER - - - - - 3 - INTERNAL - - INTERNAL - - - - - 3 - LINKCOUNTED - - LINKCOUNTED - - - - - 3 - LITERAL - - LITERAL - - - - - 3 - LITTLE_ENDIAN - - LITTLE_ENDIAN - - - - - 3 - LZW - - LZW - - - - - 3 - MOFN - - XPATH - - - - - 3 - MULTIPLE - - MULTIPLE - - - - - 3 - NAMESPACE - - NAMESPACE - - - - - 3 - NOCASE - - NOCASE - - - - - 3 - NOTRIM - - NOTRIM - - - - - 3 - NOXPATH - - NOXPATH - - - - - 3 - ONFAIL - - ONFAIL - - - - - 3 - OVERWRITE - - OVERWRITE - - - - - 3 - PREFETCH - - PREFETCH - - - - - 3 - RETRY - - RETRY - - - - - 3 - RIGHT1 - - RIGHT1 - - - - - 3 - RIGHT2 - - RIGHT2 - - - - - 3 - ROWSET - - ROWSET - - - - - 3 - XPATH - - XPATH - - - - - 3 - SCOPE - - SCOPE - - - - - 3 - SMART - - SMART - - - - - 3 - SOAPACTION - - SOAPACTION - - - - - 3 - STABLE - - STABLE - - - - - 3 - TIMELIMIT - - TIMELIMIT - - - - - 3 - TIMEOUT - - XPATH - - - - - 3 - UNORDERED - - UNORDERED - - - - - 3 - UNSTABLE - - UNSTABLE - - - - - 3 - UPDATE - - UPDATE - - - - - 3 - USE - - USE - - - - - 3 - WIDTH - - WIDTH - - - - - 3 - __COMPRESSED__ - - __COMPRESSED__ - - - - - 4 - ASCII - - ASCII - - - - - 4 - BIG_ENDIAN - - BIG_ENDIAN - - - - - 4 - BOOLEAN - - BOOLEAN - - - - - 4 - DATA - - DATA - - # - - - 4 - DECIMAL - - DECIMAL - - #_# - - - 4 - EBCDIC - - EBCDIC - - - - - 4 - GROUPED - - GROUPED - - + + 6 + 0 + + 1 + Caret + + ( + + - - 4 - INTEGER - - INTEGER - - 1,2,3,4,5,6,7,8,| - - - 4 - LINKCOUNTED - - LINKCOUNTED - - - - - 4 - PATTERN - - PATTERN - - - - - 4 - QSTRING - - QSTRING - - #| - - - 4 - REAL - - REAL - - 4,8,| - - - 4 - RECORD - - RECORD - - - - - 4 - RULE - - RULE - - - - - 4 - SET OF - - SET OF - - - - - 4 - STREAMED - - STREAMED - - - - - 4 - STRING - - STRING - - #| - - - 4 - TOKEN - - TOKEN - - - - - 4 - UDECIMAL - - UDECIMAL - - #_# - - - 4 - UNICODE - - UNICODE - - #| - - - 4 - UNSIGNED - - UNSIGNED - - 1,2,3,4,5,6,7,8,| - - - 4 - VARSTRING - - VARSTRING - - #| - - - 4 - VARUNICODE - - VARUNICODE - - #| - - - 5 - CHECKPOINT - - : CHECKPOINT( - ) - - - - 5 - DEPRECATED - - : DEPRECATED - - - - - 5 - FAILCODE - - FAILCODE - - - - - 5 - FAILMESSAGE - - FAILMESSAGE - - - - - 5 - FAILURE - - : FAILURE( - ) - - - - 5 - GLOBAL - - : GLOBAL - - - - - 5 - INDEPENDENT - - : INDEPENDENT - - - - - 5 - ONWARNING - - : ONWARNING( - ) - - - - 5 - PERSIST - - : PERSIST - - - - - 5 - PRIORITY - - : PRIORITY - - - - - 5 - RECOVERY - - : RECOVERY( - ) - - - - 5 - STORED - - : STORED( - ) - - - - 5 - SUCCESS - - : SUCCESS( - ) - - - - 5 - WAIT - - WAIT( - ) - - - - 5 - WHEN - - : WHEN( - ) - - - - 6 - #APPEND - #APPEND( symbol , expression ) - #APPEND( - ) - - - - 6 - #BREAK - - #BREAK - - - - - 6 - #DECLARE - #DECLARE( symbol ) - #DECLARE( - ) - - - - 6 - #DEMANGLE - #DEMANGLE( identifier ) - #DEMANGLE( - ) - - - - 6 - #END - - #END - - - - - 6 - #FOR - #FOR( tag [ ( filter ) ] ) - #FOR( - ) - - - - 6 - #GETDATATYPE - #GETDATATYPE( field ) - #GETDATATYPE( - ) - - - - 6 - #IF - #IF( condition ) - #IF( - ) - - - - 6 - #INMODULE - #INMODULE( module, attribute ) - #INMODULE( - ) - - - - 6 - #LOOP - - #LOOP - - - - - 6 - #MANGLE - #MANGLE( string ) - #MANGLE( - ) - - - - 6 - #ONWARNING - #ONWARNING(code, action) - #ONWARNING( - ) - - - - 6 - #OPTION - #OPTION('optionname',value) - #OPTION( - ) - - - - 6 - #SET - #SET( symbol, expression ) - #SET( - ) - - - - 6 - #STORED - #STORED( 'name', value ) - #STORED( - ) - - - - 6 - #UNIQUENAME - #UNIQUENAME( namevar [,template]) - #UNIQUENAME( - ) - - - - 6 - #WORKUNIT - #WORKUNIT() - #WORKUNIT( - ) - - - - 6 - Integer Symbol Value - - % - % - - - - 6 - Text Symbol Value - - %' - '% - - - + + 1 + Target + + + + + + + 2 + Thor + + + + + + + 3 + HThor + + + + + + + 4 + Roxie + + + + + + + 5 + Local + + + + + + diff --git a/docs/SyntaxColorSamples.xml b/docs/SyntaxColorSamples.xml new file mode 100644 index 00000000..283c01d3 --- /dev/null +++ b/docs/SyntaxColorSamples.xml @@ -0,0 +1,40 @@ + + + + ECL + + // Click the ECL to select color scheme. + /* Edit the ECL by typing here. */ + import ut; + r := + record + string22 s1 := '123'; + integer4 i1 := 123; + end; + #option('tmp', true); + d := dataset('tmp::qb', r, thor); + output(d); + Compare: Added + Compare: Deleted + Compare: Changed + Compare: Moved + + + + KEL + + // This is a KEL sample file for illustrating color syntax + /* This is a comment between delimiters */ + Person := ENTITY( FLAT(UID=did,STRING fname=name, DATE bdate=birthdate), MODEL(*) ); + Relative := ASSOCIATION( FLAT(Person who,Person whoto) ); + Vehicle := ENTITY(FLAT(UID,make,DATE datepurchased=purchasedate), MODEL(*)); + PerVeh := ASSOCIATION( FLAT(Person per, Vehicle veh) ); + USE fdc.GLUE_fdc.File(FDC, Person, + Persons(Person(UID=uid,fname=name)), + Relatives(Relative(who=Person1,whoto=Person2)), + PerVeh(Person(UID=per), PerVeh), + Vehicles(Vehicle(UID=uid))); + In this example the parent entity is the Person. There are four nested child + + + \ No newline at end of file diff --git a/en_us/en_us.rc b/en_us/en_us.rc index 67437efa..afefd060 100644 --- a/en_us/en_us.rc +++ b/en_us/en_us.rc @@ -383,8 +383,8 @@ STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD FONT 8, "MS Shell Dlg", 0, 0, 0x0 BEGIN LTEXT "&Element:",IDC_STATIC_ELEMENT,5,8,29,8 - COMBOBOX IDC_COMBO_ELEMENT,40,5,185,128,CBS_DROPDOWN | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP - PUSHBUTTON "&Defaults",IDC_BUTTON_DEFAULTS,232,4,50,14 + COMBOBOX IDC_COMBO_ELEMENT,102,5,134,128,CBS_DROPDOWN | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP + PUSHBUTTON "&Defaults",IDC_BUTTON_DEFAULTS,240,4,42,14 LTEXT "Font:",IDC_STATIC_FONT,5,23,18,8 COMBOBOX IDC_COMBO_FONT,40,21,145,128,CBS_DROPDOWN | CBS_AUTOHSCROLL | CBS_SORT | WS_VSCROLL | WS_TABSTOP LTEXT "Size:",IDC_STATIC_SIZE,195,23,16,8 @@ -395,6 +395,7 @@ BEGIN PUSHBUTTON "Button1",IDC_BUTTON_BACKGROUND,155,35,50,14 CONTROL "Bold",IDC_CHECK_BOLD,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,220,38,29,10 GROUPBOX "",IDC_ECL_PLACEHOLDER,0,55,289,101 + COMBOBOX IDC_COMBO_ELEMENT_TYPE,40,5,58,30,CBS_DROPDOWN | WS_VSCROLL | WS_TABSTOP END IDD_ATTRLOOKUP DIALOGEX 0, 0, 243, 193 diff --git a/en_us/resource.h b/en_us/resource.h index 84c1fc23..555e1862 100644 --- a/en_us/resource.h +++ b/en_us/resource.h @@ -537,6 +537,7 @@ #define IDC_STATIC_WUARGUMENTS 524 #define IDC_COMBO1 524 #define IDC_COMBO_MODULES 524 +#define IDC_COMBO_ELEMENT_TYPE 524 #define IDC_EDIT_ARGUMENTS2 525 #define IDC_EDIT_WUARGUMENTS 525 #define IDC_STATIC_COMPILER 525 diff --git a/wlib/LangRef.cpp b/wlib/LangRef.cpp index 58cad482..b23b19a4 100644 --- a/wlib/LangRef.cpp +++ b/wlib/LangRef.cpp @@ -9,12 +9,8 @@ #include "Repository.h" #include -const TCHAR * const LANGREFFILE_XML = _T("LanguageReference.xml"); const TCHAR * const LANGREFFILE_CSV = _T("LanguageReference.csv"); -const TCHAR * const LANGREFFILE_SALT_XML = _T("LanguageRefSalt.xml"); -const TCHAR * const LANGREFFILE_ESDL_XML = _T("LanguageRefESDL.xml"); -const TCHAR * const LANGCOLFILE = _T("LanguageColor.xml"); -const TCHAR * const LANGCOLFILE2 = _T("LanguageColor2.xml"); +const TCHAR * const LANGSYNTAXSAMPLES = _T("SyntaxColorSamples.xml"); struct RowCatStruct { @@ -54,6 +50,67 @@ void restore(T &s, const char * filename) ATLASSERT(false); } } +class CLanguageSample +{ +protected: + // Version 1 --- + std::_tstring name; + std::_tstring sample; + // --- --- --- + +public: + CLanguageSample() + { + } + bool Has(const std::_tstring & item) const + { + return item.length() > 0; + } + template + T Get(const std::_tstring & item, T defaultVal) const + { + try + { + return boost::lexical_cast(item); + } + catch (boost::bad_lexical_cast &) + { + } + return defaultVal; + } + template + void Set(std::_tstring & item, T val) + { + try + { + item = boost::lexical_cast(val); + } + catch (boost::bad_lexical_cast &) + { + } + } + bool HasName() const { return Has(name); } + const TCHAR * GetName() const { return name.c_str(); } + bool HasSample() const { return Has(sample); } + const TCHAR * GetSample() const { return sample.c_str(); } + + bool operator < (const CLanguageSample & other) + { + if (GetName() == other.GetName()) + return name < other.name; + return GetName() < other.GetName(); + } + + friend class boost::serialization::access; + template + void serialize(Archive & ar, const unsigned int version) + { + ar & BOOST_SERIALIZATION_NVP(name); + ar & BOOST_SERIALIZATION_NVP(sample); + } +}; +BOOST_CLASS_VERSION(CLanguageSample, 0) +typedef std::vector CLanguageSampleVector; // =========================================================================== class CLanguageColor { @@ -308,10 +365,11 @@ class CLangRef : public ILangRef, public CUnknown CatNameMap m_langCatNameIndex; CategoryLanguageColorMap m_color; + CLanguageSampleVector m_sample; RowCategoryIDVector m_colorRowToCategoryID; CLanguageColor * m_defaultColor; - std::_tstring m_typeStr; std::_tstring m_emptyStr; + std::_tstring m_elementType; public: BEGIN_CUNKNOWN @@ -320,42 +378,82 @@ class CLangRef : public ILangRef, public CUnknown CLangRef() { m_defaultColor = NULL; - m_typeStr = _T(""); } + m_elementType = _T(""); } ~CLangRef() { } + CString GetSample() + { + CString sampleStr = ""; + if (m_sample.begin() != m_sample.end()) + { + for (CLanguageSampleVector::iterator itr = m_sample.begin(); itr != m_sample.end(); ++itr) + { + std::_tstring name = itr->GetName(); + std::transform(name.begin(), name.end(), name.begin(), ::tolower); + if (name.compare(m_elementType) == 0) + { + std::_tstring sample = itr->GetSample(); + sampleStr = sample.c_str(); + break; + } + } + } + return sampleStr; + } + + bool loadSamples() + { + if (m_sample.size() != 0) + return true; + + m_sample.clear(); + boost::filesystem::path binFolder; + GetProgramFolder(binFolder); + boost::filesystem::path file = binFolder / stringToPath(LANGSYNTAXSAMPLES); + if (!clib::filesystem::exists(file)) + { + ATLASSERT(!(_T("Unable to locate language syntax sample file"))); + } + restore(m_sample, file.string().c_str()); + return true; + } + + void SetElementType(CString elementType) + { + m_elementType = elementType; + } + + CString GetElementType() + { + return m_elementType.c_str(); + } + virtual void init(IAttributeType *type) { bool loaded = false; if (type != NULL) { - m_typeStr = type->GetRepositoryCode(); - if (boost::algorithm::equals(m_typeStr, _T("salt"))) { - loadReference(LANGREFFILE_SALT_XML, m_lang); - loaded = true; - } - else if (boost::algorithm::equals(m_typeStr, _T("esdl"))) { - loadReference(LANGREFFILE_ESDL_XML, m_lang); - loaded = true; - } + m_elementType = type->GetRepositoryCode(); } - if (!loaded) { - m_typeStr = _T("ecl"); - loadReference(LANGREFFILE_XML, m_lang); + else if (m_elementType.length() == 0) + { + m_elementType = _T("ecl"); } + loadReference(); loadMergedColor(); m_emptyStr = _T(""); } void loadMergedColor() { - loadDefaultColor(LANGCOLFILE, m_color); + loadDefaultColor(m_color); m_defaultColor = NULL; m_colorRowToCategoryID.clear(); - for(CategoryLanguageColorMap::iterator itr = m_color.begin(); itr != m_color.end(); ++itr) + for (CategoryLanguageColorMap::iterator itr = m_color.begin(); itr != m_color.end(); ++itr) { m_colorRowToCategoryID.push_back(itr->second.GetCategoryID()); if (m_defaultColor == NULL && boost::algorithm::iequals(_T("Default"), itr->second.GetName())) @@ -364,7 +462,7 @@ class CLangRef : public ILangRef, public CUnknown // Quick Cleanup bool found = false; - for(CategoryLanguageColorMap::iterator itr = m_color.begin(); itr != m_color.end(); ++itr) + for (CategoryLanguageColorMap::iterator itr = m_color.begin(); itr != m_color.end(); ++itr) { if (itr->second.Cleanup(m_defaultColor)) found = true; @@ -375,53 +473,82 @@ class CLangRef : public ILangRef, public CUnknown save(m_color, "c:\\temp\\tmp.xml"); #endif } - - // Check if this user has customized the colors + loadMergedColorFile(); + } + bool loadMergedColorFile() + { boost::filesystem::path appFolder; GetApplicationFolder(appFolder); - boost::filesystem::path file = appFolder / stringToPath(LANGCOLFILE2); + boost::filesystem::path file = appFolder / stringToPath(ColorFileName(true).GetString()); if (clib::filesystem::exists(file)) { CategoryLanguageColorMap userColors; restore(userColors, file.string().c_str()); - for(CategoryLanguageColorMap::iterator itr = userColors.begin(); itr != userColors.end(); ++itr) + for (CategoryLanguageColorMap::iterator itr = userColors.begin(); itr != userColors.end(); ++itr) { m_color[itr->first] = itr->second; } + return true; } + return false; } - - bool loadDefaultColor(const TCHAR * fileName, CategoryLanguageColorMap & t) + bool loadDefaultColor(CategoryLanguageColorMap & t) { t.clear(); // Check if this user has customized the colors boost::filesystem::path binFolder; GetProgramFolder(binFolder); - boost::filesystem::path file = binFolder / stringToPath(fileName); + boost::filesystem::path file = binFolder / stringToPath(ColorFileName().GetString()); if (!clib::filesystem::exists(file)) { return false; } restore(t, file.string().c_str()); + return true; } - void loadReference(const TCHAR * fileName) + CString ReferenceFileName(bool twoFlag = false) { - loadReference(fileName, m_lang); + return FileName(_T("LanguageReference"), "LanguageRef", twoFlag); } - void loadReference(const TCHAR * fileName, CLanguageReferenceVector & t) + CString ColorFileName(bool twoFlag = false) { - t.clear(); + return FileName(_T("LanguageColor"), "LangColor", twoFlag); + } + CString FileName(CString defaultFile, CString filefront, bool twoFlag = false) + { + CString front, type; + if (boost::algorithm::equals(m_elementType, _T("general"))) + { + front = defaultFile; + type = ""; + } + else + { + front = filefront; + type = m_elementType.c_str(); + } + type.MakeUpper(); + CString formatStr = twoFlag ? _T("%s%s2.%s") : _T("%s%s.%s"); + CString filename; + filename.Format(formatStr, front, type, _T("xml")); + return filename; + } + + void loadReference() + { + m_lang.clear(); + CString fileName = ReferenceFileName(); // Check if this user has customized the colors boost::filesystem::path binFolder; GetProgramFolder(binFolder); - boost::filesystem::path file = binFolder / stringToPath(fileName); + boost::filesystem::path file = binFolder / stringToPath(fileName.GetString()); if (!clib::filesystem::exists(file)) { - ATLASSERT(!"Unable to locate LanguageReference.xml"); + ATLASSERT(!(_T("Unable to locate ") + fileName)); } - restore(t, file.string().c_str()); - std::sort(t.begin(), t.end()); + restore(m_lang, file.string().c_str()); + std::sort(m_lang.begin(), m_lang.end()); int row = 0; for(CLanguageReferenceVector::iterator itr = m_lang.begin(); itr != m_lang.end(); ++itr) { @@ -439,20 +566,25 @@ class CLangRef : public ILangRef, public CUnknown { boost::filesystem::path appFolder; GetApplicationFolder(appFolder); - boost::filesystem::path file = appFolder / stringToPath(LANGCOLFILE2); + boost::filesystem::path file = appFolder / stringToPath(ColorFileName(true).GetString()); CategoryLanguageColorMap defaultColors, diffColors; - loadDefaultColor(LANGCOLFILE, defaultColors); - for(CategoryLanguageColorMap::iterator itr = m_color.begin(); itr != m_color.end(); ++itr) + loadDefaultColor(defaultColors); + bool diffFound = false; + for (CategoryLanguageColorMap::iterator itr = m_color.begin(); itr != m_color.end(); ++itr) { if (defaultColors[itr->first] != itr->second) { diffColors[itr->first] = itr->second; diffColors[itr->first].Cleanup(&defaultColors[itr->first]); + diffFound = true; } } - save(diffColors, file.string().c_str()); + if (diffFound) + { + save(diffColors, file.string().c_str()); + } } void Restore() @@ -464,23 +596,37 @@ class CLangRef : public ILangRef, public CUnknown { boost::filesystem::path appFolder; GetApplicationFolder(appFolder); - boost::filesystem::path file = appFolder / stringToPath(LANGCOLFILE2); + boost::filesystem::path file = appFolder / stringToPath(ColorFileName().GetString()); if (clib::filesystem::exists(file)) boost::filesystem::remove(file); loadMergedColor(); } + int GetLexerType() { - if (m_typeStr.length() > 0 && boost::algorithm::equals(m_typeStr, _T("salt"))) + if (m_elementType.length() > 0) { - return SCLEX_SALT; - } - else if (m_typeStr.length() > 0 && boost::algorithm::equals(m_typeStr, _T("esdl"))) - { - return SCLEX_ESDL; + if (boost::algorithm::equals(m_elementType, _T("salt"))) + { + return SCLEX_SALT; + } + else if (boost::algorithm::equals(m_elementType, _T("esdl"))) + { + return SCLEX_ESDL; + } + else if (boost::algorithm::equals(m_elementType, _T("kel"))) + { + return SCLEX_KEL; + } + else if (boost::algorithm::equals(m_elementType, _T("general"))) + { + return SCLEX_GENERAL; + } } + return SCLEX_ECL; } + int GetLangCatCount() { int retVal = 0; @@ -713,7 +859,7 @@ class CLangRef : public ILangRef, public CUnknown boost::filesystem::path binFolder; GetProgramFolder(binFolder); boost::filesystem::path path = binFolder / stringToPath(LANGREFFILE_CSV); - boost::filesystem::path xml_path = binFolder / stringToPath(LANGREFFILE_XML); + boost::filesystem::path xml_path = binFolder / stringToPath(ReferenceFileName().GetString()); CUnicodeFile file; if (file.Open(pathToString(path).c_str())) @@ -740,29 +886,42 @@ class CLangRef : public ILangRef, public CUnknown } }; -boost::recursive_mutex g_langRef_mutex; -std::map > g_langRef; - ILangRef * CreateLangRef(IAttributeType * type) { return CreateLangRef(type->GetRepositoryCode(), type); }; -ILangRef * CreateLangRef(std::_tstring code, IAttributeType * type) +boost::recursive_mutex g_langRef_mutex; +std::map> g_langRef; + +void SaveColorFiles() { - boost::recursive_mutex::scoped_lock proc(g_langRef_mutex); - if (!g_langRef[code]) - { - g_langRef[code] = new CLangRef(); - g_langRef[code]->init(type); + CLangRef *langref = NULL; + for (std::map>::iterator itr = g_langRef.begin(); itr != g_langRef.end(); itr++) { + langref = itr->second; + langref->SetElementType(itr->first.c_str()); + langref->Save(); } - return g_langRef[code]; +} + +ILangRef * CreateLangRef(std::_tstring elementType, IAttributeType * type) +{ + boost::recursive_mutex::scoped_lock proc(g_langRef_mutex); + g_langRef.empty(); + if (!g_langRef[elementType]) + { + g_langRef[elementType] = new CLangRef(); + g_langRef[elementType]->SetElementType(elementType.c_str()); + g_langRef[elementType]->init(type); + } else + g_langRef[elementType]->SetElementType(elementType.c_str()); + return g_langRef[elementType]; }; void ExportLangRef() { CComPtr retVal = new CLangRef(); - retVal->loadReference(LANGREFFILE_XML); + retVal->loadReference(); retVal->ExportLanguageReference(); } diff --git a/wlib/LangRef.h b/wlib/LangRef.h index 9acf8e6c..32fe5a32 100644 --- a/wlib/LangRef.h +++ b/wlib/LangRef.h @@ -10,6 +10,8 @@ __interface ILangRef : public IUnknown void Restore(); void RestoreDefaults(); + void SetElementType(CString elementType); + CString GetElementType(); int GetLexerType(); int GetLangCatCount(); int GetLangNameCount(int cat) const; @@ -20,6 +22,7 @@ __interface ILangRef : public IUnknown bool GetAutoC(const std::_tstring & partialLabel, StdStringVector &set); const TCHAR * GetLangTooltip(const std::_tstring &label); bool IsComment(int cat); + CString GetSample(); int GetColorRowCount() const; int GetColorCatID(int row) const; @@ -36,8 +39,14 @@ __interface ILangRef : public IUnknown void SetFontSize(int catID, int size); bool GetFontBold(int catID) const; void SetFontBold(int catID, bool bold); + + bool loadSamples(); + void loadReference(); + bool loadMergedColorFile(); + void loadMergedColor(); }; +WLIB_API void SaveColorFiles(); WLIB_API ILangRef * CreateLangRef(IAttributeType * type); WLIB_API ILangRef * CreateLangRef(std::_tstring code, IAttributeType * type); // One of usage to upgrade XML file! diff --git a/wlib/PreferenceDlg.cpp b/wlib/PreferenceDlg.cpp index ad9a5874..2f6285fa 100644 --- a/wlib/PreferenceDlg.cpp +++ b/wlib/PreferenceDlg.cpp @@ -1068,6 +1068,8 @@ class CPrefColorDlg : public CDialogImpl, { typedef CPrefColorDlg thisClass; typedef CDialogImpl baseClass; + typedef std::map SampleMap; + protected: IOwner * m_owner; IConfigAdapt m_config; @@ -1080,12 +1082,15 @@ class CPrefColorDlg : public CDialogImpl, CColorButton m_buttForeground; CColorButton m_buttBackground; CComPtr m_langRef; + CComboBox m_comboElementType; CComboBox m_comboElement; - CSourceCtrl m_ecl; + CSourceCtrl m_sourceCtrl; CButton m_checkBold; + CString m_currentElementTypeStr; + CString m_currentElementStr; public: - CPrefColorDlg(IOwner * owner, IConfig * config) : m_config(config), m_owner(owner), m_ecl(this) + CPrefColorDlg(IOwner * owner, IConfig * config) : m_config(config), m_owner(owner), m_sourceCtrl(this) { m_ConfigLabel = m_config->GetLabel(); if (m_ConfigLabel.IsEmpty()) @@ -1158,6 +1163,85 @@ class CPrefColorDlg : public CDialogImpl, return NULL; } + void DoLoadElementType() + { + m_langRef = CreateLangRef(CurrentElementType().GetString(), NULL); + LoadType(); + + m_comboElement.ResetContent(); + m_langRef->SetElementType(CurrentElementType()); + m_langRef->loadReference(); + m_langRef->loadMergedColor(); + LoadComboElement(); + + m_sourceCtrl.DoInit(); + m_comboElement.SetCurSel(0); + + LoadSampleText(); + DoLoadElement(); + m_sourceCtrl.InitColors(m_langRef); + } + + void LoadType() + { + if (ElementTypeEqual("general")) + { + m_sourceCtrl.SetType(CreateIAttributeGENERALType()); + } + else if (ElementTypeEqual("esdl")) + { + m_sourceCtrl.SetType(CreateIAttributeESDLType()); + } + else if (ElementTypeEqual("kel")) + { + m_sourceCtrl.SetType(CreateIAttributeKELType()); + } + else if (ElementTypeEqual("salt")) + { + m_sourceCtrl.SetType(CreateIAttributeSALTType()); + } + else + { + m_sourceCtrl.SetType(CreateIAttributeECLType()); + } + } + + CString CurrentElementType() + { + int row = m_comboElementType.GetCurSel(); + if (row < 0) + return _T(""); + + CString str1; + int n; + n = m_comboElementType.GetLBTextLen(row); + m_comboElementType.GetLBText(row, str1.GetBuffer(n)); + str1.ReleaseBuffer(); + str1.MakeLower(); + + m_currentElementTypeStr = str1; + + return str1; + } + + CString CurrentElement() + { + int row = m_comboElement.GetCurSel(); + if (row < 0) + return _T(""); + + CString str1; + int n; + n = m_comboElement.GetLBTextLen(row); + m_comboElement.GetLBText(row, str1.GetBuffer(n)); + str1.ReleaseBuffer(); + str1.MakeLower(); + + m_currentElementStr = str1; + + return str1; + } + void DoLoadElement() { int row = m_comboElement.GetCurSel(); @@ -1172,9 +1256,17 @@ class CPrefColorDlg : public CDialogImpl, m_comboFontSize.SetWindowText(boost::lexical_cast(m_langRef->GetFontSize(catID)).c_str()); m_checkBold.SetCheck(m_langRef->GetFontBold(catID)); - if (catID == 38) // Caret + if (ElementTypeEqual("general")) { - m_buttBackground.EnableWindow(false); + if (CurrentElement().CompareNoCase(_T("caret")) == 0) + { + m_buttBackground.EnableWindow(false); + } + else + { + m_buttBackground.EnableWindow(true); + } + m_buttForeground.EnableWindow(true); m_comboFont.EnableWindow(false); m_comboFontSize.EnableWindow(false); m_checkBold.EnableWindow(false); @@ -1213,11 +1305,9 @@ class CPrefColorDlg : public CDialogImpl, MSG_WM_DESTROY(OnDestroy) COMMAND_HANDLER(IDC_CHECK_BOLD, BN_CLICKED, OnCheckClicked) - COMMAND_HANDLER(IDC_COMBO_ELEMENT, CBN_SELCHANGE, OnCbnSelchangeComboElement) + COMMAND_HANDLER(IDC_COMBO_ELEMENT_TYPE, CBN_SELENDOK, OnCbnSelendokComboElementType) COMMAND_HANDLER(IDC_COMBO_ELEMENT, CBN_SELENDOK, OnCbnSelendokComboElement) - COMMAND_HANDLER(IDC_COMBO_FONT, CBN_SELCHANGE, OnCbnSelendokComboFont) COMMAND_HANDLER(IDC_COMBO_FONT, CBN_SELENDOK, OnCbnSelendokComboFont) - COMMAND_HANDLER(IDC_COMBO_FONTSIZE, CBN_SELCHANGE, OnCbnSelendokComboFontSize) COMMAND_HANDLER(IDC_COMBO_FONTSIZE, CBN_SELENDOK, OnCbnSelendokComboFontSize) NOTIFY_HANDLER(IDC_BUTTON_FOREGROUND, CPN_SELENDOK, OnBnSelendokForeground) NOTIFY_HANDLER(IDC_BUTTON_BACKGROUND, CPN_SELENDOK, OnBnSelendokBackground) @@ -1265,62 +1355,191 @@ class CPrefColorDlg : public CDialogImpl, m_comboFontSize.AddString(_T("78")); } + std::vector m_elementTypes = { "general", "ecl", "esdl", "kel", "salt" }; + + int GetElementTypeCount() + { + return static_cast(m_elementTypes.size()); + } + + CString GetElementType(int typeID) + { + return m_elementTypes[typeID]; + } + + void InitComboElementType() + { + m_comboElementType = GetDlgItem(IDC_COMBO_ELEMENT_TYPE); + for (int i = 0; i < GetElementTypeCount(); i++) + { + m_comboElementType.AddString(GetElementType(i).MakeUpper()); + } + } + void InitComboElement() { m_comboElement = GetDlgItem(IDC_COMBO_ELEMENT); - for(int row = 0; row < m_langRef->GetColorRowCount(); ++row) + } + + void LoadComboElement() + { + for (int row = 0; row < m_langRef->GetColorRowCount(); ++row) { - int catID = m_langRef->GetColorCatID(row); - m_comboElement.AddString(m_langRef->GetColorName(catID)); + m_comboElement.AddString(m_langRef->GetColorName(m_langRef->GetColorCatID(row))); } } - void InitEditEcl() + void InitEditColors() { CWindow wndPlaceholder = GetDlgItem(IDC_ECL_PLACEHOLDER); CRect rc; wndPlaceholder.GetWindowRect ( rc ); ScreenToClient(rc); wndPlaceholder.DestroyWindow(); - m_ecl.Create(*this, rc, _T(""), WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE, WS_EX_CLIENTEDGE, IDC_ECL_PLACEHOLDER); - m_ecl.DoInit(); - m_ecl.SetText( - _T("// Click the ECL to select color scheme.") _T("\r\n") - _T("/* Edit the ECL by typing here. */") _T("\r\n") - _T("import ut;") _T("\r\n") - _T("r := ") _T("\r\n") - _T(" record") _T("\r\n") - _T(" string22 s1 := '123';") _T("\r\n") - _T(" integer4 i1 := 123;") _T("\r\n") - _T(" end;") _T("\r\n") - _T("#option('tmp', true);") _T("\r\n") - _T("d := dataset('tmp::qb', r, thor);") _T("\r\n") - _T("output(d);") _T("\r\n") - _T("Compare: Added") _T("\r\n") - _T("Compare: Deleted") _T("\r\n") - _T("Compare: Changed") _T("\r\n") - _T("Compare: Moved")); - m_ecl.SetLineState(11, SCE_ECL_ADDED); - m_ecl.SetLineState(12, SCE_ECL_DELETED); - m_ecl.SetLineState(13, SCE_ECL_CHANGED); - m_ecl.SetLineState(14, SCE_ECL_MOVED); + m_sourceCtrl.Create(*this, rc, _T(""), WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE, WS_EX_CLIENTEDGE, IDC_ECL_PLACEHOLDER); + + LoadSampleText(); + } + + bool ElementTypeEqual(CString elementType) + { + return m_currentElementTypeStr.CompareNoCase(elementType) == 0; + } + + void LoadSampleText() + { + std::_tstring textSample = _T(""); + bool filled = false; + + if (m_langRef) + { + //m_langRef->loadSamples(); + textSample = m_langRef->GetSample(); + filled = true; + + if (textSample == _T("")) + { + if (ElementTypeEqual("kel")) + { + textSample = + _T("// KEL sample file illustrating color syntax") _T("\r\n") + _T("/* This is a comment between delimiters */") _T("\r\n") + _T("Person := ENTITY(FLAT(UID = did, STRING fname = name));") _T("\r\n") + _T("USE fdc.GLUE_fdc.File(FDC, Person,") _T("\r\n") + _T("Person: => age := YEARSBETWEEN(bdate, CURRENTDATE());") _T("\r\n") + _T("QUERY: HiMaleInc <= Person(sex = 'M' AND") _T("\r\n") + _T(" income = income$Person(sex = 'M') :Max);") _T("\r\n") + _T("QUERY: IncMoreAveVal <= ") _T("\r\n") + _T(" Person(income > MAX(Vehicle(make = 'TOYOTA'), value));"); + } + else if (ElementTypeEqual("esdl")) + { + textSample = + _T("// ESDL sample for illustrating color syntax") _T("\r\n") + _T("/* This is a comment between delimiters */") _T("\r\n") + _T("ESPInclude(ModThis);") _T("\r\n") + _T("ESPservice MathService{") _T("\r\n") + _T(" ESPmethod DivThis(DivThisRequest, DivThisResponse);") _T("\r\n") + _T("ESPmethod ModThis(ModThisRequest, ModThisResponse);") _T("\r\n") + _T("};") _T("\r\n") + _T("ESPrequest DivThisRequest{") _T("\r\n") + _T(" int FirstNumber;") _T("\r\n") + _T(" int SecondNumber;") _T("\r\n") + _T("};") _T("\r\n") + _T("ESPresponse DivThisResponse{") _T("\r\n") + _T(" int Answer;") _T("\r\n") + _T("};") _T("\r\n") + _T("ESPstruct Date {") _T("\r\n") + _T(" [leading_zero(4)] Year;") _T("\r\n") + _T(" [leading_zero(2)] Month;") _T("\r\n") + _T(" [leading_zero(2)] Day;") _T("\r\n") + _T("}") _T("\r\n") + _T("ESPservice MyService {") _T("\r\n") + _T(" ESPmethod MyMethod1(MyMethod1Req, MyMethod1Resp);") _T("\r\n") + _T(" ESPmethod [") _T("\r\n") + _T(" description(\"MyMethod Two\"),") _T("\r\n") + _T(" help(\"This method does everything...\"),") _T("\r\n") + _T(" min_ver(\"1.2\")") _T("\r\n") + _T(" ]") _T("\r\n") + _T(" MyMethod2(MyMethod2Req, MyMethod2Resp);") _T("\r\n") + _T("};"); + } + else if (ElementTypeEqual("salt")) + { + textSample = + _T("// SALT sample for illustrating color syntax") _T("\r\n") + _T("/* This is a comment between delimiters */") _T("\r\n") + _T("FIELD:dt_first_seen:RECORDDATE(FIRST)") _T("\r\n") + _T("CONCEPT : locale : +: zip : state : 2, 0") _T("\r\n") + _T("ATTRIBUTEFILE : VEHICLES : ") _T("\r\n") + _T(" NAMED(SALT_Examples.File_Vehicle_Matches_S") _T("\r\n"); + } + else if (ElementTypeEqual("ecl")) + { + textSample = + _T("// ECL sample for illustrating color syntax") _T("\r\n") + _T("/* This is a comment between delimiters */") _T("\r\n") + _T("import ut;") _T("\r\n") + _T("r := ") _T("\r\n") + _T(" record") _T("\r\n") + _T(" string22 s1 := '123';") _T("\r\n") + _T(" integer4 i1 := 123;") _T("\r\n") + _T(" end;") _T("\r\n") + _T("#option('tmp', true);") _T("\r\n") + _T("d := dataset('tmp::qb', r, thor);") _T("\r\n") + _T("output(d);") _T("\r\n") + _T("Compare: Added") _T("\r\n") + _T("Compare: Deleted") _T("\r\n") + _T("Compare: Changed") _T("\r\n") + _T("Compare: Moved"); + } + else if (ElementTypeEqual("general")) + { + textSample = + _T("Caret : #") _T("\r\n") + _T("Target: Thor ") _T("\r\n") + _T("Target: HThor ") _T("\r\n") + _T("Target: Roxie ") _T("\r\n") + _T("Target: Local ") _T("\r\n"); + } + else + { + filled = false; + } + } + } + + m_sourceCtrl.SetText(textSample.c_str()); + + if (ElementTypeEqual("ecl")) + { + m_sourceCtrl.SetLineState(11, SCE_ECL_ADDED); + m_sourceCtrl.SetLineState(12, SCE_ECL_DELETED); + m_sourceCtrl.SetLineState(13, SCE_ECL_CHANGED); + m_sourceCtrl.SetLineState(14, SCE_ECL_MOVED); + } + else if (ElementTypeEqual("general")) + { + m_sourceCtrl.SetFocus(true); + m_sourceCtrl.SetSel(9, 9); + } } LRESULT OnInitDialog(HWND /*wParam*/, LPARAM /*lParam*/) { CWaitCursor wait; - boost::filesystem::path iniPath; - m_ini = CreateIConfig(QUERYBUILDER_INI, GetIniPath(iniPath)); - m_langRef = CreateLangRef(_T("ecl"),NULL); - CString regPath(::GetRegPathQB()); regPath += _T("\\Preferences\\"); InitComboFont(); InitComboFontSize(); + InitComboElementType(); InitComboElement(); - InitEditEcl(); + InitEditColors(); + + boost::filesystem::path iniPath; + m_ini = CreateIConfig(QUERYBUILDER_INI, GetIniPath(iniPath)); m_buttForeground.SubclassWindow(GetDlgItem(IDC_BUTTON_FOREGROUND)); m_buttForeground.SetDefaultColor(GetSysColor(COLOR_WINDOWTEXT)); @@ -1330,12 +1549,20 @@ class CPrefColorDlg : public CDialogImpl, m_checkBold = GetDlgItem(IDC_CHECK_BOLD); LoadFromConfig(m_config); - DoLoadElement(); + SelectElementType(_T("ecl")); + DoLoadElementType(); DoChanged(false); return TRUE; } + void SelectElementType(std::_tstring elementTypeStr) + { + m_langRef = CreateLangRef(elementTypeStr, NULL); + int index = m_comboElementType.FindString(0, elementTypeStr.c_str()); + m_comboElementType.SetCurSel(index); + } + void OnDestroy() { SetMsgHandled(false); @@ -1362,7 +1589,7 @@ class CPrefColorDlg : public CDialogImpl, int catID = m_langRef->GetColorCatID(row); m_langRef->SetFontBold(catID, m_checkBold.GetCheck() != 0); - m_ecl.InitColors(m_langRef); + m_sourceCtrl.InitColors(m_langRef); return 0; } @@ -1372,9 +1599,9 @@ class CPrefColorDlg : public CDialogImpl, ctrl.SetRange(lower, upper); } - LRESULT OnCbnSelchangeComboElement(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) + LRESULT OnCbnSelendokComboElementType(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { - DoLoadElement(); + DoLoadElementType(); return 0; } @@ -1392,10 +1619,11 @@ class CPrefColorDlg : public CDialogImpl, int catID = m_langRef->GetColorCatID(row); CString font; - m_comboFont.GetLBText(m_comboFont.GetCurSel(), font); + int fontRow = m_comboFont.GetCurSel(); + m_comboFont.GetLBText(fontRow, font); m_langRef->SetFontName(catID, static_cast(font)); - m_ecl.InitColors(m_langRef); + m_sourceCtrl.InitColors(m_langRef); return 0; } @@ -1417,7 +1645,8 @@ class CPrefColorDlg : public CDialogImpl, return 0; } - m_ecl.InitColors(m_langRef); + m_sourceCtrl.InitColors(m_langRef); + DoChanged(); return 0; } @@ -1430,7 +1659,8 @@ class CPrefColorDlg : public CDialogImpl, m_langRef->SetColorFore(catID, m_buttForeground.GetColor()); - m_ecl.InitColors(m_langRef); + m_sourceCtrl.InitColors(m_langRef); + DoChanged(); return 0; } @@ -1443,14 +1673,15 @@ class CPrefColorDlg : public CDialogImpl, m_langRef->SetColorBack(catID, m_buttBackground.GetColor()); - m_ecl.InitColors(m_langRef); + m_sourceCtrl.InitColors(m_langRef); + DoChanged(); return 0; } // IEclSlot void NewSel() { - int catID = m_ecl.GetStyleAt(m_ecl.GetCurrentPos()); + int catID = m_sourceCtrl.GetStyleAt(m_sourceCtrl.GetCurrentPos()); if (catID == 0) catID = 32; //The true default... int row = m_langRef->GetColorRow(catID); @@ -1463,7 +1694,7 @@ class CPrefColorDlg : public CDialogImpl, if (MessageBox(_T("Restore default color scheme. Are you sure you want to continue?"), CString(MAKEINTRESOURCE(IDR_MAINFRAME)), MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION) == IDYES) { m_langRef->RestoreDefaults(); - m_ecl.InitColors(m_langRef); + m_sourceCtrl.InitColors(m_langRef); } return 0; } @@ -1863,7 +2094,7 @@ class CPrefDlg : public CDialogImpl, public CWinDataExchange IConfigAdapt m_ini; CString m_ConfigLabel; CComboBox m_cbConfig; - int m_ConfigId; + int m_ConfigId; CMyTabView m_tabView; CPrefServerDlg m_serverPref; @@ -1971,6 +2202,9 @@ class CPrefDlg : public CDialogImpl, public CWinDataExchange m_resultPref.DoApply(bMakeGlobal); m_compilerPref.DoApply(bMakeGlobal); m_otherPref.DoApply(bMakeGlobal); + + SaveColorFiles(); + return true; } diff --git a/wlib/SourceView.cpp b/wlib/SourceView.cpp index efc9e3ea..239233e3 100644 --- a/wlib/SourceView.cpp +++ b/wlib/SourceView.cpp @@ -271,7 +271,6 @@ int CSourceCtrl::HandleNotify(Scintilla::SCNotification *notification) } MatchBrace(); UpdateStatusBar(); - m_owner->NewSel(); break; case SCN_MODIFIED: if ( !m_modified && (notification->modificationType&(SC_MOD_INSERTTEXT|SC_MOD_DELETETEXT))) @@ -454,6 +453,8 @@ void CSourceCtrl::DoInit() void CSourceCtrl::InitColors(ILangRef * langRef) { int backID; + bool generalFlag = langRef->GetElementType().CompareNoCase(_T("general")) == 0; + for(int row = 0; row < langRef->GetColorRowCount(); ++row) { ATLTRACE(_T("Row: %i\n"), row); @@ -461,9 +462,13 @@ void CSourceCtrl::InitColors(ILangRef * langRef) if (m_targetType != TARGET_UNKNOWN && static_cast(GetIConfig(QUERYBUILDER_CFG)->Get(GLOBAL_TARGETCOLOR)) == true) { backID = m_targetType; } - unsigned back = langRef->GetColorBack(backID); + langRef->GetElementType(); + if (generalFlag && catID == 1) + { + SetCaretFore(langRef->GetColorFore(catID)); + } - SetStyle(catID, langRef->GetColorFore(catID), back, langRef->GetFontName(catID), langRef->GetFontSize(catID), langRef->GetFontBold(catID)); + SetStyle(catID, langRef->GetColorFore(catID), langRef->GetColorBack(backID), langRef->GetFontName(catID), langRef->GetFontSize(catID), langRef->GetFontBold(catID)); } AnnotationSetVisible(ANNOTATION_BOXED); } @@ -824,22 +829,15 @@ void CSourceCtrl::SetStyle(signed style, unsigned fore, unsigned back, const std face = GetIConfig(QUERYBUILDER_CFG)->Get(GLOBAL_FONT); int size = _size >= 1 ? _size : GetIConfig(QUERYBUILDER_CFG)->Get(GLOBAL_FONTSIZE); - if (style == 38) - { - SetCaretFore(fore); - } - else - { - if (fore) - StyleSetFore(style, fore); - StyleSetBack(style, back); - if (size >= 1) - StyleSetSize(style, size); - if (face) - StyleSetFont(style, face); - StyleSetBold(style, bold); - StyleSetEOLFilled(style, true); - } + if (fore) + StyleSetFore(style, fore); + StyleSetBack(style, back); + if (size >= 1) + StyleSetSize(style, size); + if (face) + StyleSetFont(style, face); + StyleSetBold(style, bold); + StyleSetEOLFilled(style, true); } void CSourceCtrl::SetMarker(int marker, int markerType, COLORREF fore, COLORREF back)