localize compiler messages

src/ob/Code.ob

@@ -13,7 +13,9 @@ IMPORT
     Record,
     String,
     TypeId, 
-    Types;
+    Types,
+    Format,
+    Message;
 
 TYPE
     StringsMap = MAP OF STRING;
@@ -141,8 +143,8 @@ END;
 PROCEDURE checkIndex*(i: INTEGER);
 BEGIN
     IF i < 0 THEN
-        Errors.raise("index is negative: " + String.fromInt(i));
+        Errors.raise(Format.format1(Message.negativeIndex, String.fromInt(i)));
     END;
 END checkIndex;
 
-END Code.
+END Code.

src/ob/ContextAssignment.ob

@@ -1,6 +1,6 @@
 MODULE ContextAssignment;
 IMPORT
-    Chars, ContextHierarchy, Errors;
+    Chars, ContextHierarchy, Errors, Message;
 TYPE
     Check* = RECORD(ContextHierarchy.Node)
     END;
@@ -8,7 +8,7 @@ TYPE
 PROCEDURE Check.handleLiteral(s: STRING);
 BEGIN
     IF s = "=" THEN
-        Errors.raise("did you mean ':=' (statement expected, got expression)?");
+        Errors.raise(Message.didYouMeanAssign);
     END;
 END;
 
@@ -17,4 +17,4 @@ BEGIN
     cx.codeGenerator().write(";" + Chars.ln);
 END;
 
-END ContextAssignment.
+END ContextAssignment.

src/ob/ContextCase.ob

@@ -2,7 +2,8 @@ MODULE ContextCase;
 IMPORT
     Cast, Chars, CodeGenerator, ConstValue, ContextExpression, ContextHierarchy,
     Designator, Errors, Expression, ExpressionTree,
-    Record, Scope, String, Symbols, TypeId, Types, Variable;
+    Record, Scope, String, Symbols, TypeId, Types, Variable,
+    Format, Message;
 TYPE
     Type* = RECORD(ContextExpression.ExpressionHandler)
         PROCEDURE Type(parent: ContextHierarchy.PNode);
@@ -77,15 +78,14 @@ BEGIN
         IF (type IS Types.PRecord) OR (type IS Record.PPointer) THEN
             isReference <- (info IS Types.PVariable) & info.isReference();
             IF (type IS Types.PRecord) & ~isReference THEN
-                Errors.raise("only records passed as VAR argument can be used to test type in CASE");
+                Errors.raise(Message.onlyRecordsForCase);
             ELSIF ~(type IS Record.PPointer) OR ~isReference THEN
                 SELF.guardVar := declVar;
             END;
 
             SELF.typeTest := e;
         ELSIF ~Types.isInt(type) & (type # Types.basic.ch) THEN
-            Errors.raise("'RECORD' or 'POINTER' or "
-                         + Types.intsDescription() + " or 'CHAR' expected as CASE expression");
+            Errors.raise(Format.format1(Message.caseExpectations, Types.intsDescription()));
         END;
     END;
 
@@ -114,8 +114,7 @@ END;
 PROCEDURE Type.handleLabelType(type: Types.PType);
 BEGIN
     IF ~Cast.areTypesMatch(type, SELF.type) THEN
-        Errors.raise("label must be '" + SELF.type.description() + "' (the same as case expression), got '"
-                     + type.description() + "'");
+        Errors.raise(Format.format2(Message.caseHandleLabelType, SELF.type.description(), type.description()));                    
     END;
 END;
 
@@ -215,13 +214,13 @@ VAR
     c: CHAR;
 BEGIN
     IF caseContext(SELF).typeTest # NIL THEN
-        Errors.raise("type's name expected in label, got expression: " + e.code());
+        Errors.raise(Format.format1(Message.typeNameExpectedInLabel, e.code()));
     END;
 
     type <- e.type();
     IF type IS Types.PString THEN
         IF ~Types.stringAsChar(type^, c) THEN
-            Errors.raise("single-character string expected");
+            Errors.raise(Message.singleCharStringExpected);
         END;
         handleLabel(SELF, Types.basic.ch, NEW ConstValue.Int(ORD(c)));
     ELSE
@@ -232,7 +231,7 @@ END;
 PROCEDURE Range.handleQIdent(q: ContextHierarchy.QIdent);
 BEGIN
     IF SELF.typeGuardHandled THEN
-        Errors.raise("cannot use diapason (..) with type guard");
+        Errors.raise(Message.canNotUseDiapason);
     END;
 
     found <- ContextHierarchy.getQIdSymbolAndScope(SELF.root()^, q);
@@ -243,10 +242,10 @@ BEGIN
             labelContext(SELF).handleTypeGuard(typeTest, info);
             SELF.typeGuardHandled := TRUE;
         ELSE
-            Errors.raise("'" + q.code + "' is not a type");
+            Errors.raise(Format.format1(Message.isNotAType, q.code));
         END;
     ELSIF ~(info IS Types.PConst) THEN
-        Errors.raise("'" + q.code + "' is not a constant");
+        Errors.raise(Format.format1(Message.isNotAConstant, q.code));
     ELSE
         type <- info.type;
         IF type IS Types.PString THEN
@@ -286,4 +285,4 @@ PROCEDURE GuardedVariable.id(): STRING;
     RETURN SELF.caseVariable.id();
 END;
 
-END ContextCase.
+END ContextCase.

src/ob/ContextConst.ob

@@ -1,7 +1,7 @@
 MODULE ContextConst;
 IMPORT
     Chars, ConstValue, Context, ContextExpression, 
-    Errors, Expression, Symbols, Types;
+    Errors, Expression, Symbols, Types, Message;
 TYPE
     Type* = RECORD(ContextExpression.ExpressionHandler)
         PROCEDURE handleIdentdef*(id: Context.PIdentdefInfo);
@@ -21,7 +21,7 @@ PROCEDURE Type.handleExpression(e: Expression.PType);
 BEGIN
     value <- e.constValue();
     IF value = NIL THEN
-        Errors.raise("constant expression expected");
+        Errors.raise(Message.constExpressionExpected);
     END;
     SELF.type := e.type();
     SELF.value := value;
@@ -35,4 +35,4 @@ BEGIN
     RETURN TRUE;
 END;
 
-END ContextConst.
+END ContextConst.

src/ob/ContextDesignator.ob

@@ -2,7 +2,7 @@ MODULE ContextDesignator;
 IMPORT
     Code, ConstValue, ContextExpression, ContextHierarchy, 
     Designator, Errors, Expression, ExpressionTree,
-    Record, String, TypeId, Types, Variable;
+    Record, String, TypeId, Types, Variable, Format, Message;
 TYPE
     Index* = RECORD
         PROCEDURE Index*(length: INTEGER; type: Types.PType; info: Types.PId; code, asProperty: STRING);
@@ -97,7 +97,7 @@ BEGIN
     IF info IS Types.PVariable THEN
         ExpressionTree.checkTypeCast(info, SELF.currentType, type, "type cast");
     ELSE
-        Errors.raise("cannot apply type cast to " + info.idType());
+        Errors.raise(Format.format1(Message.canNotApplyTypecast, info.idType()));
     END;
 
     code <- SELF.root().language().rtl.typeGuard(SELF.code, ExpressionTree.castCode(type, SELF));
@@ -121,7 +121,7 @@ BEGIN
     IF t IS Record.PPointer THEN
         base <- Record.pointerBase(t^);
         IF base.finalizedAsNonExported THEN
-            Errors.raise("POINTER TO non-exported RECORD type cannot be dereferenced");
+            Errors.raise(Message.pointerCantBeDereferenced);
         END;
         designator.currentType := base;
 
@@ -130,8 +130,7 @@ BEGIN
             designator.code := Expression.derefCode(designator.code);
         END;
     ELSE
-        Errors.raise("POINTER TO type expected, got '"
-                     + designator.currentType.description() + "'");
+        Errors.raise(Format.format1(Message.pointerTypeExpected, designator.currentType.description()));
     END;
 END;
 
@@ -194,8 +193,7 @@ END;
 PROCEDURE Type.doCheckIndexType(type: Types.PType);
 BEGIN
     IF ~Types.isInt(type) THEN
-        Errors.raise(Types.intsDescription() + " expression expected, got '" 
-                     + type.description() + "'");
+        Errors.raise(Format.format2(Message.expressionExpected, Types.intsDescription(), type.description()));
     END;
 END;
 
@@ -208,9 +206,7 @@ BEGIN
         length <- index.length;
         IF (((SELF.currentType IS Types.PStaticArray) OR (SELF.currentType IS Types.PString))
           & (value >= length)) THEN
-            Errors.raise("index out of bounds: maximum possible index is "
-                         + String.fromInt(length - 1)
-                         + ", got " + String.fromInt(value));
+            Errors.raise(Format.format2(Message.indexOutOfBonds, String.fromInt(length - 1), String.fromInt(value)));
         END;
     END;
 END;
@@ -226,7 +222,7 @@ BEGIN
     ELSIF type IS Types.PString THEN
         indexType := Types.basic.ch;
     ELSE
-        Errors.raise("ARRAY or string expected, got '" + type.description() + "'");
+        Errors.raise(Format.format1(Message.arrayOrStringExpected, type.description()));
     END;
 
     IF type IS Types.PStaticArray THEN
@@ -234,7 +230,7 @@ BEGIN
     ELSIF type IS Types.PString THEN
         length := Types.stringLen(type^);
         IF length = 0 THEN
-            Errors.raise("cannot index empty string" );
+            Errors.raise(Message.cantIndexEmptString);
         END;
     END;
 
@@ -299,4 +295,4 @@ BEGIN
     RETURN TRUE;
 END;
 
-END ContextDesignator.
+END ContextDesignator.

src/ob/ContextExpression.ob

@@ -2,7 +2,7 @@ MODULE ContextExpression;
 IMPORT 
     Chars, CodeGenerator, ConstValue, ContextHierarchy, 
     Designator, Errors, Expression, ExpressionTree, 
-    Scope, String, Types;
+    Scope, String, Types, Format, Message;
 TYPE
     ExpressionHandler* = RECORD(ContextHierarchy.Node)
         PROCEDURE handleExpression*(e: Expression.PType);
@@ -335,7 +335,7 @@ BEGIN
 
     IF info IS Types.PProcedureId THEN
         IF ~info.canBeReferenced() THEN
-            Errors.raise(info.idType() + " cannot be referenced");
+            Errors.raise(Format.format1(Message.cantBeReferenced, info.idType()));
         END;
     ELSIF info IS Types.PConst THEN
         value := info.value;
@@ -345,4 +345,4 @@ END;
 
 BEGIN
     NEW(globalOps);
-END ContextExpression.
+END ContextExpression.

src/ob/ContextHierarchy.ob

@@ -1,7 +1,7 @@
 MODULE ContextHierarchy;
 IMPORT 
     CodeGenerator, Context, Designator, Errors, LanguageContext, Module, 
-    OberonRtl, Object, Scope, ScopeBase, Symbols, String, Types;
+    OberonRtl, Object, Scope, ScopeBase, Symbols, String, Types, Format, LocMessage:=Message;
 TYPE
     PRoot* = POINTER TO Root;
     PNode* = POINTER TO Node;
@@ -172,7 +172,7 @@ PROCEDURE getSymbolAndScope*(cx: Root; id: STRING): Symbols.PFoundSymbol;
 BEGIN
     s <- cx.findSymbol(id);
     IF s = NIL THEN
-        Errors.raise("undeclared identifier: '" + id + "'");
+        Errors.raise(Format.format1(LocMessage.undeclaredId, id));
     END;
     RETURN s;
 END;
@@ -181,7 +181,7 @@ PROCEDURE getModuleSymbolAndScope*(m: Module.Type; id: STRING): Symbols.PFoundSy
 BEGIN
     s <- m.findSymbol(id);
     IF s = NIL THEN
-        Errors.raise("identifier '" + id + "' is not exported by module '" + m.name + "'");
+        Errors.raise(Format.format2(LocMessage.idIsNotExported, id, m.name));
     END;
     RETURN s;
 END;
@@ -206,4 +206,4 @@ PROCEDURE makeLanguageContext*(cx: PNode): LanguageContext.PType;
     RETURN NEW LanguageContext.Type(cx.root().language(), cx);
 END;
 
-END ContextHierarchy.
+END ContextHierarchy.

src/ob/ContextIf.ob

@@ -1,6 +1,6 @@
 MODULE ContextIf;
 IMPORT
-    ContextExpression, ContextHierarchy, Errors, Expression, Types;
+    ContextExpression, ContextHierarchy, Errors, Expression, Types, Message, Format;
 TYPE
     Type* = RECORD(ContextExpression.ExpressionHandler)
         PROCEDURE Type*(parent: ContextHierarchy.PNode);
@@ -10,7 +10,7 @@ PROCEDURE handleIfExpression*(e: Expression.PType);
 BEGIN
     type <- e.type();
     IF type # Types.basic.bool THEN
-        Errors.raise("'BOOLEAN' expression expected, got '" + type.description() + "'");
+        Errors.raise(Format.format1(Message.boolExpressionExpected, type.description()));
     END;
 END;
 
@@ -47,4 +47,4 @@ BEGIN
     RETURN TRUE;
 END;
 
-END ContextIf.
+END ContextIf.

src/ob/ContextLoop.ob

@@ -1,7 +1,7 @@
 MODULE ContextLoop;
 IMPORT
     Chars, CodeGenerator, ConstValue, Context, ContextExpression, ContextIf, ContextHierarchy, 
-    Errors, Expression, Operator, String, Types;
+    Errors, Expression, Operator, String, Types, Format, Message;
 TYPE
     While* = RECORD(ContextExpression.ExpressionHandler)
         PROCEDURE While*(parent: ContextHierarchy.PNode);
@@ -110,12 +110,11 @@ BEGIN
     s <- ContextHierarchy.getSymbol(SELF.root()^, id);
     info <- s.info();
     IF ~(info IS Types.PVariable) THEN
-        Errors.raise("'" + s.id() + "' is not a variable");
+        Errors.raise(Format.format1(Message.isNotAVar, s.id()));
     ELSE
         type <- info.type();
         IF type # Types.basic.integer THEN
-            Errors.raise("'" + s.id() + "' is a '" + type.description() 
-                         + "' variable, 'FOR' control variable must be 'INTEGER'");
+            Errors.raise(Format.format2(Message.varMustBeInteger, s.id(), type.description()));
         END;
         SELF.doHandleInitCode(id, "for (" + id + " = ");
     END;
@@ -130,9 +129,7 @@ END;
 PROCEDURE For.doHandleInitExpression(type: Types.PType);
 BEGIN
     IF type # Types.basic.integer THEN
-        Errors.raise(
-            "'INTEGER' expression expected to assign '" + SELF.var
-            + "', got '" + type.description() + "'");
+        Errors.raise(Format.format2(Message.intExpect, SELF.var, type.description()));
     END;
     SELF.initExprParsed := TRUE;
 END;
@@ -144,18 +141,16 @@ BEGIN
         SELF.doHandleInitExpression(type);
     ELSIF ~SELF.toParsed THEN
         IF type # Types.basic.integer THEN
-            Errors.raise("'INTEGER' expression expected as 'TO' parameter, got '" 
-                         + type.description() + "'");
+            Errors.raise(Format.format1(Message.intExpectedAsTo, type.description()));
         END;
         SELF.toParsed := TRUE;
     ELSE
         IF type # Types.basic.integer THEN
-            Errors.raise("'INTEGER' expression expected as 'BY' parameter, got '" 
-                         + type.description() + "'");
+            Errors.raise(Format.format1(Message.intExpectedAsBy, type.description()));
         END;
         value <- e.constValue();
         IF value = NIL THEN
-            Errors.raise("constant expression expected as 'BY' parameter");
+            Errors.raise(Message.constExpectedAsBy);
         END;
         SELF.by := value(ConstValue.PInt).value;
     END;
@@ -209,4 +204,4 @@ BEGIN
     gen.openScope();
 END;
 
-END ContextLoop.
+END ContextLoop.

src/ob/ContextModule.ob

@@ -1,7 +1,7 @@
 MODULE ContextModule;
 IMPORT
     CodeGenerator, ContextHierarchy, ContextType, Errors, LanguageContext, 
-    Object, Scope, ScopeBase, String, Symbols, Types;
+    Object, Scope, ScopeBase, String, Symbols, Types, Format, Message;
 TYPE
     Declaration* = RECORD(ContextHierarchy.Node)
         PROCEDURE findModule(name: STRING): Types.PModule;
@@ -33,14 +33,14 @@ BEGIN
         Scope.defineExports(scope^);
         SELF.codeGenerator().write(SELF.moduleGen.epilog(scope.exports));
     ELSE
-        Errors.raise("original module name '" + SELF.name + "' expected, got '" + id + "'" );
+        Errors.raise(Format.format2(Message.moduleName, SELF.name, id));
     END;
 END;
 
 PROCEDURE Declaration.findModule(name: STRING): Types.PModule;
 BEGIN
     IF name = SELF.name THEN
-        Errors.raise("module '" + SELF.name + "' cannot import itself");
+        Errors.raise(Format.format1(Message.moduleCantImportItself, SELF.name));
     END;
     RETURN SELF.root().findModule(name);
 END;
@@ -109,9 +109,9 @@ BEGIN
     
     FOR a, m IN import.import DO
         IF a = alias THEN
-            Errors.raise("duplicated alias: '" + alias +"'");
+            Errors.raise(Format.format1(Message.duplicateAlias, alias));
         ELSIF m = import.currentModule THEN
-            Errors.raise("module already imported: '" + import.currentModule + "'");
+            Errors.raise(Format.format1(Message.moduleAlreadyImported, import.currentModule));
         END;
     END;
     import.import[alias] := import.currentModule;
@@ -144,12 +144,14 @@ BEGIN
             modules.add(NEW Symbols.Symbol(alias, module));
         END;
     END;
-    IF LEN(unresolved) # 0 THEN
-        Errors.raise("module(s) not found: " + String.join(unresolved, ", "));
+    IF LEN(unresolved) = 1 THEN
+        Errors.raise(Format.format1(Message.moduleNotFound1, String.join(unresolved, ", ")));
+    ELSIF LEN(unresolved) > 1 THEN
+        Errors.raise(Format.format1(Message.moduleNotFound2, String.join(unresolved, ", ")));
     END;
     
     parent.handleImport(modules);
     RETURN TRUE;
 END;
 
-END ContextModule.
+END ContextModule.

src/ob/ContextProcedure.ob

@@ -3,7 +3,7 @@ IMPORT
     Cast, Chars, CodeGenerator, Context, ContextExpression, 
     ContextHierarchy, ContextType, 
     Errors, Expression, ExpressionTree, LanguageContext,
-    Object, Procedure, Scope, Symbols, TypeId, Types, Variable;
+    Object, Procedure, Scope, Symbols, TypeId, Types, Variable, Format, Message;
 TYPE
     Declaration* = RECORD(ContextType.DeclarationAndIdentHandle)
         PROCEDURE Declaration*(parent: ContextHierarchy.PNode);
@@ -82,8 +82,7 @@ PROCEDURE Declaration.handleIdent(id: STRING);
 BEGIN
     expectId <- SELF.id.id();
     IF expectId # id THEN
-        Errors.raise("mismatched procedure names: '" + expectId
-                     + "' at the begining and '" + id + "' at the end");
+        Errors.raise(Format.format2(Message.mismatchedProcName, expectId, id));
     END;
 END;
 
@@ -119,7 +118,7 @@ END;
 PROCEDURE addArgument(VAR declaration: Declaration; name: STRING; arg: Types.ProcedureArgument);
 BEGIN
     IF name = declaration.id.id() THEN
-        Errors.raise("argument '" + name + "' has the same name as procedure");
+        Errors.raise(Format.format1(Message.argSameAsName, name));
     END;
     v <- declaration.doMakeArgumentVariable(arg, name);
     s <- NEW Symbols.Symbol(name, v);
@@ -166,14 +165,12 @@ BEGIN
     type <- e.type();
     result <- SELF.type.result();
     IF result = NIL THEN
-        Errors.raise("unexpected RETURN in PROCEDURE declared with no result type");
+        Errors.raise(Message.unexpectedReturn);
     END;
     
     language <- SELF.root().language();
     IF language.types.implicitCast(type, result, FALSE, op) # Cast.errNo THEN
-        Errors.raise(
-            "RETURN '" + result.description() + "' expected, got '"
-            + type.description() + "'");
+        Errors.raise(Format.format2(Message.returnTypeMismatch, result.description(), type.description()));
     END;
 
     SELF.codeGenerator().write("return " + SELF.doMakeReturnCode(e, op^) + ";" + Chars.ln);
@@ -188,8 +185,7 @@ BEGIN
 
     result <- SELF.type.result();
     IF (result # NIL) & ~SELF.returnParsed THEN
-        Errors.raise("RETURN expected at the end of PROCEDURE declared with '"
-                     + result.description() + "' result type");
+        Errors.raise(Format.format1(Message.returnExpectedAtEnd, result.description()));
     END;
     RETURN TRUE;
 END;
@@ -224,7 +220,7 @@ END;
 PROCEDURE FormalParameters.doCheckResultType(type: Types.PStorageType);
 BEGIN
     IF ~type.isScalar() THEN
-        Errors.raise("procedure cannot return " + type.description());
+        Errors.raise(Format.format1(Message.procedureCantReturn, type.description()));
     END;
 END;
 
@@ -311,7 +307,7 @@ BEGIN
     END;
     
     IF result = NIL THEN
-        Errors.raise("PROCEDURE expected, got '" + unexpected + "'");
+        Errors.raise(Format.format1(Message.procedureExpected, unexpected));
     END;
     
     RETURN result;
@@ -324,4 +320,4 @@ BEGIN
                             : assertProcType(type, info).callGenerator(l);
 END;
 
-END ContextProcedure.
+END ContextProcedure.

src/ob/ContextType.ob

@@ -2,7 +2,7 @@ MODULE ContextType;
 IMPORT
     Chars, CodeGenerator, ConstValue, Context, ContextExpression, ContextHierarchy, 
     Errors, Expression, ExpressionTree, Object, R := Record, 
-    Scope, ScopeBase, String, Symbols, TypeId, Types;
+    Scope, ScopeBase, String, Symbols, TypeId, Types, Format, Message;
 TYPE
     HandleSymbolAsType* = RECORD(ContextHierarchy.Node)
         PROCEDURE handleQIdent*(q: ContextHierarchy.QIdent);
@@ -199,15 +199,15 @@ PROCEDURE ArrayDimensions.handleExpression(e: Expression.PType);
 BEGIN
     type <- e.type();
     IF type # Types.basic.integer THEN
-        Errors.raise("'INTEGER' constant expression expected, got '" + type.description() + "'");
+        Errors.raise(Format.format1(Message.intContExprExpected, type.description()));
     END;
     value <- e.constValue();
     IF value = NIL THEN
-        Errors.raise("constant expression expected as ARRAY size");
+        Errors.raise(Message.constExprExpected);
     END;
     dimension <- value(ConstValue.PInt).value;
     IF dimension <= 0 THEN
-        Errors.raise("array size must be greater than 0, got " + String.fromInt(dimension));
+        Errors.raise(Format.format1(Message.arraySizeMustBeGrater, String.fromInt(dimension)));
     END;
     SELF.doAddDimension(dimension);
 END;
@@ -258,9 +258,7 @@ PROCEDURE checkIfFieldCanBeExported*(name: STRING; idents: ARRAY OF Context.PIde
 BEGIN
     FOR id IN idents DO
         IF ~id.exported() THEN
-            Errors.raise(
-                "field '" + name + "' can be exported only if " + hint + " '" +
-                id.id() + "' itself is exported too");
+            Errors.raise(Format.format3(Message.fieldExpOnlyIfExported, name, hint, id.id()));
         END;
     END;
 END;
@@ -321,7 +319,7 @@ END;
 PROCEDURE Record.addField(field: Context.PIdentdefInfo; type: Types.PStorageType);
 BEGIN
     IF SELF.root().language().types.isRecursive(type, SELF.type) THEN
-        Errors.raise("recursive field definition: '" + field.id() + "'");
+        Errors.raise(Format.format1(Message.recursiveFieldDef, field.id()));
     END;
     SELF.type.addField(SELF.doMakeField(field, type));
     IF field.exported() THEN
@@ -332,14 +330,10 @@ END;
 PROCEDURE Record.setBaseType(type: Types.PType);
 BEGIN
     IF ~(type IS R.PType) THEN
-        Errors.raise(
-            "RECORD type is expected as a base type, got '"
-            + type.description()
-            + "'");
+        Errors.raise(Format.format1(Message.recTypeExpected, type.description()));
     ELSE
         IF type = SELF.type THEN
-            Errors.raise("recursive inheritance: '"
-                         + SELF.type.description() + "'");
+            Errors.raise(Format.format1(Message.recursiveInheritance, SELF.type.description()));
         END;
 
         SELF.type.setBase(type);
@@ -475,7 +469,7 @@ BEGIN
             IF type # NIL THEN
                 typeDesc := ", got '" + type.description() + "'";
             END;
-            Errors.raise("RECORD is expected as a POINTER base type" + typeDesc);
+            Errors.raise(Format.format1(Message.recExpectedAsPtrBaseType, typeDesc));
         END;
     END;
     
@@ -520,7 +514,7 @@ END;
 
 PROCEDURE Pointer.exportField(field: STRING);
 BEGIN
-    Errors.raise("cannot export anonymous RECORD field: '" + field + "'");
+    Errors.raise(Format.format1(Message.cantExportAnonRecField, field));
 END;
 
 PROCEDURE ResolveClosure.ResolveClosure(root: ContextHierarchy.PRoot; id: STRING)
@@ -609,4 +603,4 @@ BEGIN
     RETURN result;
 END;
 
-END ContextType.
+END ContextType.

src/ob/ContextVar.ob

@@ -1,7 +1,7 @@
 MODULE ContextVar;
 IMPORT
     Chars, CodeGenerator, Context, ContextHierarchy, ContextType, Errors, 
-    Object, Symbols, Types, Variable;
+    Object, Symbols, Types, Variable, Format, Message;
 TYPE
     Declaration* = RECORD(ContextType.DeclarationAndIdentHandle)
         PROCEDURE doInitCode*(): STRING;
@@ -40,7 +40,7 @@ END;
 PROCEDURE Declaration.handleMessage(VAR msg: ContextHierarchy.Message): Object.PType;
 BEGIN
     IF msg IS ContextType.ForwardTypeMsg THEN
-        Errors.raise("type '" + msg.id + "' was not declared");
+        Errors.raise(Format.format1(Message.typeWasntDeclared, msg.id));
     END;
     RETURN SUPER(msg);
 END;
@@ -65,4 +65,4 @@ BEGIN
     RETURN TRUE;
 END;
 
-END ContextVar.
+END ContextVar.

src/ob/ExpressionTree.ob

@@ -1,7 +1,7 @@
 MODULE ExpressionTree;
 IMPORT
 	Cast, Context, ContextHierarchy,
-	JS, 
+	JS, Format, Message,
 	Errors, Expression, LanguageContext, Operator, Record, String, Types, TypeId;
 TYPE
     BinaryOperator* = PROCEDURE(l, r: Expression.PType): Expression.PType;
@@ -120,7 +120,7 @@ VAR
 
 PROCEDURE throwTypeNameExpected*();
 BEGIN
-    Errors.raise("type name expected");
+    Errors.raise(Message.typeNameExpected);
 END;
 
 PROCEDURE castCode*(type: Types.PType; cx: Context.Type): STRING;
@@ -161,8 +161,7 @@ VAR
             t := t.base;
         END;
         IF t = NIL THEN
-            Errors.raise(prefix + ": '" + to.description()
-                       + "' is not an extension of '" + from.description() + "'");
+            Errors.raise(Format.format3(Message.isNotAnExtencion, prefix, to.description(), from.description()));
         END;
     END;
 
@@ -171,24 +170,17 @@ BEGIN
 
     pointerExpected <- fromType IS Record.PPointer;
     IF ~pointerExpected & ~(fromType IS Record.PType) THEN
-        Errors.raise(
-            prefix + ": POINTER to type or RECORD expected, got '"
-            + fromType.description() + "'");
+        Errors.raise(Format.format2(Message.ptrToTypeExpected, prefix, fromType.description()));
     END;
 
     IF ~pointerExpected THEN
         IF (fromInfo # NIL) & ~fromInfo.isReference() THEN
-            Errors.raise(
-                prefix + ": a value variable cannot be used");
+            Errors.raise(Format.format1(Message.valueVarCantBeUsed, prefix));
         ELSIF ~(toType IS Record.PType) THEN
-            Errors.raise(
-                prefix + ": RECORD type expected as an argument of RECORD " + msg + ", got '"
-              + toType.description() + "'");
+            Errors.raise(Format.format3(Message.recTypeExpectedAsArg, prefix, msg, toType.description()));
         END;
     ELSIF ~(toType IS Record.PPointer) THEN
-        Errors.raise(
-            prefix + ": POINTER type expected as an argument of POINTER " + msg + ", got '"
-          + toType.description() + "'");
+        Errors.raise(Format.format3(Message.ptrTypeExpectedAsArg, prefix, msg, toType.description()));
     END;
 
     IF pointerExpected THEN
@@ -225,16 +217,12 @@ BEGIN
     ELSE
         fromDescription := "no type (proper procedure call)";
     END;
-    Errors.raise("type mismatch: expected '" + to.description() 
-               + "', got " + fromDescription);
+    Errors.raise(Format.format2(Message.typeMismatch, to.description(), fromDescription));
 END;
 
 PROCEDURE throwOperatorTypeMismatch(op, expect: STRING; type: Types.PType);
 BEGIN
-    Errors.raise(
-        "operator '" + op +
-        "' type mismatch: " + expect + " expected, got '" +
-        type.description() + "'");
+    Errors.raise(Format.format3(Message.opTypeMismatch, op, expect, type.description()));
 END;
 
 PROCEDURE checkTypeMatch(from, to: Types.PType);
@@ -298,7 +286,7 @@ PROCEDURE notTypeId(e: Expression.PType);
 BEGIN
     info <- e.info();
     IF info IS TypeId.PType THEN
-        Errors.raise("type name '" + info.type().description() + "' cannot be used as an expression");
+        Errors.raise(Format.format1(Message.typeNameCantBeExpr, info.type().description()));
     END;
 END;
 
@@ -381,7 +369,7 @@ BEGIN
         o := assertNumericOrSetOp(type, s, Operator.mulReal, Operator.mulInt, Operator.setIntersection);
     ELSIF s = "/" THEN
         IF Types.isInt(type) THEN
-            Errors.raise("operator DIV expected for integer division");
+            Errors.raise(Message.opDivExpected);
         END;
         o := assertNumericOrSetOp(type, s, Operator.divReal, NIL, Operator.setSymmetricDiff);
     ELSIF s = "DIV" THEN
@@ -390,8 +378,7 @@ BEGIN
         o := assertIntOp(type, s, Operator.mod);
     ELSIF s = "&" THEN
         IF type # Types.basic.bool THEN
-            Errors.raise("BOOLEAN expected as operand of '&', got '"
-                                 + type.description() + "'");
+            Errors.raise(Format.format1(Message.boolExpectedAsOperand, type.description()));
         END;
         o := Operator.and;
     ELSE
@@ -466,8 +453,7 @@ BEGIN
         result := assertNumericOrSetOp(type, s, Operator.subReal, Operator.subInt, Operator.setDiff);
     ELSIF s = "OR" THEN
         IF type # Types.basic.bool THEN
-            Errors.raise("BOOLEAN expected as operand of 'OR', got '"
-                         + type.description() + "'");
+        	Errors.raise(Format.format1(Message.boolExpectedAsOperandOfOr, type.description()));
         END;
         result := Operator.or;
     END;
@@ -509,7 +495,7 @@ BEGIN
 
     type <- result.type();
     IF type = NIL THEN
-        Errors.raise("procedure returning no result cannot be used in an expression");
+        Errors.raise(Message.procReturningNoResult);
     END;
     RETURN result;
 END;
@@ -539,8 +525,7 @@ END;
 PROCEDURE Ops.in(left, right: Types.PType; cx: ContextHierarchy.Node): BinaryOperatorCx;
 BEGIN
     IF ~Types.isInt(left) THEN
-        Errors.raise(Types.intsDescription() 
-                     + " expected as an element of SET, got '" + left.description() + "'");
+        Errors.raise(Format.format2(Message.expectedAsElemOfSet, Types.intsDescription(), left.description()));
     END;
     checkImplicitCast(cx.root()^, right, Types.basic.set);
 
@@ -808,4 +793,4 @@ PROCEDURE NumericOrSetOpTypeCheck.check(t: Types.PType): BOOLEAN;
     RETURN SUPER(t) OR (t = Types.basic.set);
 END;
 
-END ExpressionTree.
+END ExpressionTree.

src/ob/LanguageContext.ob

@@ -1,5 +1,6 @@
 MODULE LanguageContext;
-IMPORT Chars, CodeGenerator, Context, Designator, Errors, Expression, OberonRtl, Record, Symbols, T := Types, Variable;
+IMPORT Chars, CodeGenerator, Context, Designator, Errors, Expression, OberonRtl, Record, Symbols, T := Types, Variable,
+	Format, Message;
 
 TYPE
     PType* = POINTER TO Type;
@@ -133,7 +134,7 @@ BEGIN
             result := info.leadCode + "." + codeId;
         END;
     ELSE
-        Errors.raise("cannot reference " + info.idType());
+        Errors.raise(Format.format1(Message.cannotReference, info.idType()));
     END;
     RETURN result;
 END;
@@ -158,4 +159,4 @@ BEGIN
     RETURN result;
 END;
 
-END LanguageContext.
+END LanguageContext.

src/ob/Lexer.ob

@@ -1,6 +1,6 @@
 MODULE Lexer;
 IMPORT 
-    Chars, ContextExpression, ContextHierarchy, Errors, Stream, String;
+    Chars, ContextExpression, ContextHierarchy, Errors, Stream, String, Message;
 CONST
     doubleQuote = Chars.doubleQuote;
     commentBegin = "(*";
@@ -68,7 +68,7 @@ BEGIN
             hexDetected := TRUE;
             Stream.next(stream, 1);
         ELSIF hexDetected THEN
-            Errors.raise("integer constant looks like having hexadecimal format but 'H' suffix is missing");
+            Errors.raise(Message.intLooksLikeHex);
         END;
 
         IF peekSeparator(stream) THEN
@@ -208,7 +208,7 @@ PROCEDURE string*(VAR stream: Stream.Type; VAR cx: ContextExpression.Str): BOOLE
         END;
         
         IF c # doubleQuote THEN
-            Errors.raise("unexpected end of string");
+            Errors.raise(Message.unexpectedEndOfString);
         END;
         
         cx.handleStr(s);
@@ -280,7 +280,7 @@ BEGIN
             IF ~skipComment(stream, context) THEN
                 Stream.next(stream, 1);
                 IF Stream.eof(stream) THEN
-                    Errors.raise("comment was not closed");
+                    Errors.raise(Message.commentWasNotClosed);
                 END
             END
         END;

src/ob/Module.ob

@@ -1,6 +1,7 @@
 MODULE Module;
 IMPORT 
-    Context, Errors, Expression, LanguageContext, Procedure, Symbols, TypeId, Types, Variable;
+    Context, Errors, Expression, LanguageContext, Procedure, Symbols, TypeId, Types, Variable,
+    Format, Message;
 CONST
     doProcId = "do";
     varTypeId = "var";
@@ -46,8 +47,7 @@ VAR
         arg := Procedure.checkSingleArgument(args, SELF, cx.language.types, NIL);
         type := arg.type();
         IF ~(type IS Types.PString) THEN
-            Errors.raise("string is expected as an argument of "
-                       + description + ", got " + type.description());
+            Errors.raise(Format.format2(Message.strExpected, description, type.description()));
         END;
         RETURN Expression.makeSimple(Types.stringValue(type(Types.PString)^), NIL)
     END Call.make;
@@ -70,11 +70,11 @@ END;
 PROCEDURE assertProcStatementResult*(type: Types.PType);
 BEGIN
     IF (type # NIL) & ~(type^ IS Types.Any) THEN
-        Errors.raise("procedure returning a result cannot be used as a statement");
+        Errors.raise(Message.procRetResCantBeStatement);
     END;
 END;
 
 BEGIN
     doProcSymbol := makeDoProcSymbol();
     varTypeSymbol := NEW Symbols.Symbol(varTypeId, NEW TypeId.Type(Types.any));
-END Module.
+END Module.

src/ob/Operator.ob

@@ -10,7 +10,9 @@ IMPORT
     OberonRtl, 
     Precedence := CodePrecedence,
     String,
-    Types;
+    Types,
+    Format,
+    Message;
 CONST
     equalCode* = " == ";
     notEqualCode* = " != ";
@@ -460,12 +462,9 @@ VAR
     PROCEDURE assignArrayFromString(VAR a: Types.Array; s: Types.String): STRING;
     BEGIN
         IF ~(a IS Types.StaticArray) THEN
-            Errors.raise("string cannot be assigned to open " + a.description());
+            Errors.raise(Format.format1(Message.strCantBeAssign, a.description()));
         ELSIF Types.stringLen(s) > a.length() THEN
-            Errors.raise(String.fromInt(a.length()) 
-                         + "-character ARRAY is too small for "
-                         + String.fromInt(Types.stringLen(s))
-                         + "-character string");
+            Errors.raise(Format.format2(Message.arrIsTooSmall, String.fromInt(a.length()), String.fromInt(Types.stringLen(s))));
         END;
 
         l <- cx.language;
@@ -473,7 +472,7 @@ VAR
     END assignArrayFromString;
 BEGIN
     IF ~(info IS Types.PVariable) OR info.isReadOnly() THEN
-        Errors.raise("cannot assign to " + info.idType());
+        Errors.raise(Format.format1(Message.cantAssignTo, info.idType()));
     ELSE 
         rightCode := right.code();
         leftType <- info.type();
@@ -487,11 +486,10 @@ BEGIN
         ELSE
             IF cx.language.types.implicitCast(rightType, leftType, FALSE, castOperation)
                 # Cast.errNo THEN
-                Errors.raise("type mismatch: '" + leftType.description()
-                             + "' cannot be assigned to '" + rightType.description() + "' expression");
+                Errors.raise(Format.format2(Message.typeMismatchExpr, leftType.description(), rightType.description()));
             END;
             IF (leftType IS Types.POpenArray) & (rightType IS Types.PArray) THEN
-                Errors.raise("open '" + leftType.description() + "' cannot be assigned");
+                Errors.raise(Format.format1(Message.openCantBeAssigned, leftType.description()));
             END;
                 
             result := castOperation.assign(cx, info, right);
@@ -769,4 +767,4 @@ BEGIN
     openArrayChar := NEW Types.OpenArray(Types.basic.ch);
     castOperations.castToUint8 := NEW CastToUint8();
     castOperations.castToRecord := NEW Cast.CastOpRecord();
-END Operator.
+END Operator.

src/ob/Procedure.ob

@@ -16,7 +16,9 @@ IMPORT
     String,
     Symbols, 
     TypeId,
-    Types;
+    Types,
+    Format,
+    Message;
 TYPE
     Call* = RECORD
         PROCEDURE make*(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType
@@ -112,22 +114,18 @@ BEGIN
         actualType <- actual.type();
         castErr := types.implicitCast(actualType, expectType, expected.isVar, result);
         IF castErr = Cast.errVarParameter THEN
-            Errors.raise("type mismatch for argument " + String.fromInt(pos + 1)
-                         + ": cannot pass '" + actualType.description()
-                         + "' as VAR parameter of type '" + expectType.description() + "'");
+            Errors.raise(Format.format3(Message.typeMismatchForArgPass, String.fromInt(pos + 1), actualType.description(), expectType.description()));
         ELSIF castErr # Cast.errNo THEN
-            Errors.raise("type mismatch for argument " + String.fromInt(pos + 1)
-                         + ": '" + actualType.description() + "' cannot be converted to '"
-                         + expectType.description() + "'");
+            Errors.raise(Format.format3(Message.typeMismatchForArgConv, String.fromInt(pos + 1), actualType.description(), expectType.description()));
         END;
     END;
     IF expected.isVar THEN
         info <- actual.info();
         IF info = NIL THEN
-            Errors.raise("expression cannot be used as VAR parameter");
+            Errors.raise(Message.expCannotUsedAsVar);
         END;
         IF ~(info IS Types.PVariable) OR info.isReadOnly() THEN
-            Errors.raise(info.idType() + " cannot be passed as VAR actual parameter");
+            Errors.raise(Format.format1(Message.cannotBePassedAsVar, info.idType()));
         END;
     END;
     IF code # NIL THEN
@@ -150,9 +148,7 @@ END;
 PROCEDURE checkArgumentsCount*(actual, expected: INTEGER);
 BEGIN
     IF actual # expected THEN
-        Errors.raise(
-            String.fromInt(expected) + " argument(s) expected, got " 
-            + String.fromInt(actual));
+        Errors.raise(Format.format2(Message.argsExpected, String.fromInt(expected), String.fromInt(actual)));
     END;
 END;
 
@@ -366,12 +362,11 @@ PROCEDURE makeNew(): Symbols.PSymbol;
         arg <- checkSingleArgument(args, SELF, cx.language.types, NIL);
         argType <- arg.type();
         IF ~(argType IS Record.PPointer) THEN
-            Errors.raise("POINTER variable expected, got '" 
-                         + argType.description() + "'");
+            Errors.raise(Format.format1(Message.procVarExpected, argType.description()));
         ELSE
             baseType <- Record.pointerBase(argType^);
             IF baseType.finalizedAsNonExported THEN
-                Errors.raise("non-exported RECORD type cannot be used in NEW");
+                Errors.raise(Message.nonExpRecCantUsedInNew);
             END;
             right <- Expression.makeSimple(baseType.codeForNew(cx.cx^), argType);
             result := Expression.makeSimple(Operator.assign(arg.info(), right, cx), NIL);
@@ -396,8 +391,7 @@ BEGIN
     arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
     argType := arg.type();
     IF ~SELF.check(argType) THEN
-        Errors.raise("ARRAY or string is expected as an argument of LEN, got '"
-                     + argType.description() + "'");
+        Errors.raise(Format.format1(Message.arrExpectedForLen, argType.description()));
     END;
     RETURN Expression.makeSimple(
         arg.code() + ".length",
@@ -498,8 +492,7 @@ PROCEDURE setBitImpl(name: STRING; bitOp: BinaryOpStr): Symbols.PSymbol;
         ELSE
             yValue := value^(ConstValue.Int).value;
             IF (yValue < 0) OR (yValue > 31) THEN
-                Errors.raise("value (0..31) expected as a second argument of " 
-                             + SELF.name + ", got " + String.fromInt(yValue));
+                Errors.raise(Format.format2(Message.val31expected, SELF.name, String.fromInt(yValue)));
             END;
             comment := "bit: ";
             IF y.isTerm() THEN
@@ -528,11 +521,9 @@ PROCEDURE checkVariableArgumentsCount(min, max: INTEGER; actual: ARRAY OF Expres
 BEGIN
     len <- LEN(actual);
     IF len < min THEN
-        Errors.raise("at least " + String.fromInt(min) + " argument expected, got " 
-                     + String.fromInt(len));
+        Errors.raise(Format.format2(Message.atLeastArgExpected, String.fromInt(min), String.fromInt(len)));
     ELSIF len > max THEN
-        Errors.raise("at most " + String.fromInt(max) + " arguments expected, got "
-                     + String.fromInt(len));
+        Errors.raise(Format.format2(Message.atMostArgExpected, String.fromInt(max), String.fromInt(len)));
     END;
 END checkVariableArgumentsCount;
 
@@ -620,8 +611,7 @@ PROCEDURE makeAbs(): Symbols.PSymbol;
         arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
         argType := arg.type();
         IF Types.numeric.indexOf(argType) = -1 THEN
-            Errors.raise("type mismatch: expected numeric type, got '"
-                         + argType.description() + "'");
+            Errors.raise(Format.format1(Message.typeMismatchNumExpected, argType.description()));
         END;
         RETURN Expression.makeSimple("Math.abs(" + arg.code() + ")", argType)
     END CallImpl.make;
@@ -745,9 +735,7 @@ PROCEDURE makeOrd(): Symbols.PSymbol;
                 NIL,
                 NEW ConstValue.Int(ORD(ch)));
         ELSE
-            Errors.raise(
-                "ORD function expects CHAR or BOOLEAN or SET as an argument, got '"
-                + argType.description() + "'");
+            Errors.raise(Format.format1(Message.ordExpectCharBoolSet, argType.description()));
         END;
         RETURN result
     END CallImpl.make;
@@ -898,4 +886,4 @@ BEGIN
     predefined.add(makeChr());
     predefined.add(makePack());
     predefined.add(makeUnpk());
-END Procedure.
+END Procedure.

src/ob/Record.ob

@@ -1,6 +1,6 @@
 MODULE Record;
 IMPORT
-    Chars, Context, Errors, Object, ScopeBase, TypeId, Types;
+    Chars, Context, Errors, Object, ScopeBase, TypeId, Types, Format, Message;
 TYPE
     FieldsMap = MAP OF Types.PField;
 
@@ -107,10 +107,10 @@ END;
 PROCEDURE Type.addField(f: Types.PField);
 BEGIN
     IF f.id() IN SELF.fields THEN
-        Errors.raise("duplicated field: '" + f.id() + "'");
+        Errors.raise(Format.format1(Message.dupField, f.id()));
     END;
     IF (SELF.base # NIL) & (SELF.base.findSymbol(f.id()) # NIL) THEN
-        Errors.raise("base record already has field: '" + f.id() + "'");
+        Errors.raise(Format.format1(Message.baseRecHasField, f.id()));
     END;
     SELF.fields[f.id()] := f;
     IF ~f.exported() THEN
@@ -134,7 +134,7 @@ PROCEDURE existingField(r: Type; id: STRING; d: Types.NamedType): Types.PField;
 BEGIN
     result <- r.findSymbol(id);
     IF result = NIL THEN
-        Errors.raise("type '" + d.description() + "' has no '" + id + "' field");
+        Errors.raise(Format.format2(Message.typeHasNoField, d.description(), id));
     END;
     RETURN result
 END;
@@ -309,4 +309,4 @@ END;
 
 BEGIN
     pGenerateTypeInfo := generateTypeInfo;
-END Record.
+END Record.

src/ob/Scope.ob

@@ -10,7 +10,9 @@ IMPORT
     Symbols, 
     TypeId,
     Types,
-    Variable;
+    Variable,
+    Format,
+    Message;
 TYPE
     Unresolved = ARRAY * OF STRING;
 
@@ -112,10 +114,7 @@ BEGIN
         info := symbol.info();
         type := info(TypeId.PType).type();
         IF (type # NIL) & ~(type IS Record.PType) THEN
-            Errors.raise(
-                "'" 
-                + id
-                + "' must be of RECORD type because it was used before in the declation of POINTER");
+            Errors.raise(Format.format1(Message.mustBeRecordType, id));
         END;
         s.unresolved.remove(i);
     END;
@@ -124,8 +123,7 @@ END;
 PROCEDURE checkAllResolved*(s: Type);
 BEGIN
     IF LEN(s.unresolved) # 0 THEN
-        Errors.raise("no declaration found for '" 
-                     + String.join(s.unresolved, "', '") + "'");
+        Errors.raise(Format.format1(Message.noDeclarationFound, String.join(s.unresolved, "', '")));
     END;
 END;
 
@@ -157,7 +155,7 @@ PROCEDURE Type.addSymbol(s: Symbols.PSymbol; exported: BOOLEAN);
 BEGIN
     id <- s.id();
     IF SELF.findSymbol(id) # NIL THEN
-        Errors.raise("'" + id + "' already declared");
+        Errors.raise(Format.format1(Message.alreadyDeclared, id));
     END;
     SELF.symbols[id] := s;
 END;
@@ -188,8 +186,7 @@ VAR
 BEGIN
     IF exported THEN
         info := s.info();
-        Errors.raise("cannot export from within procedure: "
-                     + info.idType() + " '" + s.id() + "'");
+        Errors.raise(Format.format2(Message.cannotExport, info.idType(), s.id()));
     END;
     SUPER(s, exported);
 END;
@@ -247,4 +244,4 @@ PROCEDURE moduleSymbol*(m: Module): Symbols.PSymbol;
     RETURN m.symbol
 END;
 
-END Scope.
+END Scope.

src/ob/Types.ob

@@ -1,6 +1,6 @@
 MODULE Types;
 IMPORT
-    Chars, ConstValue, Context, Errors, OberonRtl, Object, Str := String;
+    Chars, ConstValue, Context, Errors, OberonRtl, Object, Str := String, Format, Message;
 TYPE
     Id* = RECORD(Object.Type)
         PROCEDURE idType*(): STRING
@@ -350,7 +350,7 @@ END;
 
 PROCEDURE raiseUnexpectedSelector*(id: STRING; obj: STRING);
 BEGIN
-    Errors.raise("selector '." + id + "' cannot be applied to '" + obj + "'");
+    Errors.raise(Format.format2(Message.selectorCantBeApplied, id, obj));
 END;
 
 PROCEDURE StorageType.denote(id: STRING; isReadOnly: BOOLEAN): PField;

src/ob/en/Message.ob

@@ -2,5 +2,146 @@ MODULE Message;
 CONST
     methodAnonRec* = "cannot declare methods for anonymous records (POINTER TO RECORD)";
     methodExport* = "{0} '{1}' cannot be exported because record itself is not exported";
+    
+    (* Code.ob *)
+    negativeIndex* = "index is negative: {0}";
+    
+    (* ContextAssignment.ob *)
+    didYouMeanAssign* = "did you mean ':=' (statement expected, got expression)?";
+    
+    (* ContextCase.ob *)
+    onlyRecordsForCase* = "only records passed as VAR argument can be used to test type in CASE";
+    caseExpectations* = "'RECORD' or 'POINTER' or {0} or 'CHAR' expected as CASE expression";
+    caseHandleLabelType* = "label must be '{0}' (the same as case expression), got '{1}'";
+    typeNameExpectedInLabel* = "type's name expected in label, got expression: {0}";
+    singleCharStringExpected* = "single-character string expected";
+    canNotUseDiapason* = "cannot use diapason (..) with type guard";
+    isNotAType* = "'{0}' is not a type";
+    isNotAConstant* = "'{0}' is not a constant";
+    
+    (* ContextConst.ob *)
+    constExpressionExpected* = "constant expression expected";
+    
+    (* ContextDesignator.ob *)
+    canNotApplyTypecast* = "cannot apply type cast to {0}";
+    pointerCantBeDereferenced* = "POINTER TO non-exported RECORD type cannot be dereferenced";
+    pointerTypeExpected* = "POINTER TO type expected, got '{0}'";
+    expressionExpected* = "{0} expression expected, got '{1}'";
+    indexOutOfBonds* = "index out of bounds: maximum possible index is {0}, got {1}";
+    arrayOrStringExpected* = "ARRAY or string expected, got '{0}'";
+    cantIndexEmptString* = "cannot index empty string";
+    
+    (* ContextExpression.ob *)
+    cantBeReferenced* = "{0} cannot be referenced";
+    
+    (* ContextHierarchy.ob *)
+    undeclaredId* = "undeclared identifier: '{0}'";
+    idIsNotExported* = "identifier '{0}' is not exported by module '{1}'";
+    
+    (* ContextIf.ob *)
+    boolExpressionExpected* = "'BOOLEAN' expression expected, got '{0}'";
+    
+    (* ContextLoop.ob *)
+    isNotAVar* = "'{0}' is not a variable";
+    varMustBeInteger* = "'{0}' is a '{1}' variable, 'FOR' control variable must be 'INTEGER'";
+    intExpect* = "'INTEGER' expression expected to assign '{0}', got '{1}'";
+    intExpectedAsTo* = "'INTEGER' expression expected as 'TO' parameter, got '{0}'";
+    intExpectedAsBy* = "'INTEGER' expression expected as 'BY' parameter, got '{0}'";
+    constExpectedAsBy* = "constant expression expected as 'BY' parameter";
+    
+    (* ContextModule.ob *)
+    moduleName* = "original module name '{0}' expected, got '{1}'";
+    moduleCantImportItself* = "module '{0}' cannot import itself";
+    duplicateAlias* = "duplicated alias: '{0}'";
+    moduleAlreadyImported* = "module already imported: '{0}'";
+    moduleNotFound1* = "module not found: {0}";
+    moduleNotFound2* = "modules not found: {0}";
+    
+    (* ContextProcedure.ob *)
+    mismatchedProcName* = "mismatched procedure names: '{0}' at the begining and '{1}' at the end";
+    argSameAsName* = "argument '{0}' has the same name as procedure";
+    unexpectedReturn* = "unexpected RETURN in PROCEDURE declared with no result type";
+    returnTypeMismatch* = "RETURN '{0}' expected, got '{1}'";
+    returnExpectedAtEnd* = "RETURN expected at the end of PROCEDURE declared with '{0}' result type";
+    procedureCantReturn* = "procedure cannot return {0}";
+    procedureExpected* = "PROCEDURE expected, got '{0}'";
+    
+    (* ContextType.ob *)
+    intContExprExpected* = "'INTEGER' constant expression expected, got '{0}'";
+    constExprExpected* = "constant expression expected as ARRAY size";
+    arraySizeMustBeGrater* = "array size must be greater than 0, got {0}";
+    fieldExpOnlyIfExported* = "field '{0}' can be exported only if {1} '{2}' itself is exported too";
+    recursiveFieldDef* = "recursive field definition: '{0}'";
+    recTypeExpected* = "RECORD type is expected as a base type, got '{0}'";
+    recursiveInheritance* = "recursive inheritance: '{0}'";
+    recExpectedAsPtrBaseType* = "RECORD is expected as a POINTER base type{0}";
+    cantExportAnonRecField* = "cannot export anonymous RECORD field: '{0}'";
+    
+    (* ContextVar.ob *)
+    typeWasntDeclared* = "type '{0}' was not declared";
+    
+    (* ExpressionTree.ob *)
+    typeNameExpected* = "type name expected";
+    isNotAnExtencion* = "{0}: '{1}' is not an extension of '{2}'";
+    ptrToTypeExpected* = "{0}: POINTER to type or RECORD expected, got '{1}'";
+    valueVarCantBeUsed* = "{0}: a value variable cannot be used";
+    recTypeExpectedAsArg* = "{0}: RECORD type expected as an argument of RECORD {1}, got '{2}'";
+    ptrTypeExpectedAsArg* = "{0}: POINTER type expected as an argument of POINTER {1}, got '{2}'";
+    typeMismatch* = "type mismatch: expected '{0}', got {1}";
+    opTypeMismatch* = "operator '{0}' type mismatch: {1} expected, got '{2}'";
+    typeNameCantBeExpr* = "type name '{0}' cannot be used as an expression";
+    opDivExpected* = "operator DIV expected for integer division";
+    boolExpectedAsOperand* = "BOOLEAN expected as operand of '&', got '{0}'";
+    boolExpectedAsOperandOfOr* = "BOOLEAN expected as operand of 'OR', got '{0}'";
+    procReturningNoResult* = "procedure returning no result cannot be used in an expression";
+    expectedAsElemOfSet* = "{0} expected as an element of SET, got '{1}'";
+    
+    (* LanguageContext.ob *)
+    cannotReference* = "cannot reference {0}";
+    
+    (* Lexer.ob *)
+    intLooksLikeHex* = "integer constant looks like having hexadecimal format but 'H' suffix is missing";
+    unexpectedEndOfString* = "unexpected end of string";
+    commentWasNotClosed* = "comment was not closed";
+    
+    (* Module.ob *)
+    strExpected* = "string is expected as an argument of {0}, got {1}";
+    procRetResCantBeStatement* = "procedure returning a result cannot be used as a statement";
+    
+    (* Operator.ob *)
+    strCantBeAssign* = "string cannot be assigned to open {0}";
+    arrIsTooSmall* = "{0}-character ARRAY is too small for {1}-character string";
+    cantAssignTo* = "cannot assign to {0}";
+    typeMismatchExpr* = "type mismatch: '{0}' cannot be assigned to '{1}' expression";
+    openCantBeAssigned* = "open '{0}' cannot be assigned";
+    
+    (* Procedure.ob *)
+    typeMismatchForArgPass* = "type mismatch for argument {0}: cannot pass '{1}' as VAR parameter of type '{2}'";
+    typeMismatchForArgConv* = "type mismatch for argument {0}: '{1}' cannot be converted to '{2}'";
+    expCannotUsedAsVar* = "expression cannot be used as VAR parameter";
+    cannotBePassedAsVar* = "{0} cannot be passed as VAR actual parameter";
+    argsExpected* = "{0} argument(s) expected, got {1}";
+    procVarExpected* = "POINTER variable expected, got '{0}'";
+    nonExpRecCantUsedInNew* = "non-exported RECORD type cannot be used in NEW";
+    arrExpectedForLen* = "ARRAY or string is expected as an argument of LEN, got '{0}'";
+    val31expected* = "value (0..31) expected as a second argument of {0}, got {1}";
+    atLeastArgExpected* = "at least {0} argument expected, got {1}";
+    atMostArgExpected* = "at most {0} arguments expected, got {1}";
+    typeMismatchNumExpected* = "type mismatch: expected numeric type, got '{0}'";
+    ordExpectCharBoolSet* = "ORD function expects CHAR or BOOLEAN or SET as an argument, got '{0}'";
+    
+    (* Record.ob *)
+    dupField* = "duplicated field: '{0}'";
+    baseRecHasField* = "base record already has field: '{0}'";
+    typeHasNoField* = "type '{0}' has no '{1}' field";
+    
+    (* Scope.ob *)
+    mustBeRecordType* = "'{0}' must be of RECORD type because it was used before in the declation of POINTER";
+    noDeclarationFound* = "no declaration found for '{0}'";
+    alreadyDeclared* = "'{0}' already declared";
+    cannotExport* = "cannot export from within procedure: {0} '{1}'";
+    
+    (* Types.ob *)
+    selectorCantBeApplied* = "selector '.{0}' cannot be applied to '{1}'";
 
-END Message.
+END Message.

src/ob/ru/Message.ob

@@ -1,6 +1,147 @@
 MODULE Message;
 CONST
     methodAnonRec* = "объявление методов для анонимных записей невозможно (POINTER TO RECORD)";
-    methodExport* = "{0} '{1}' не может быть экспротитрован, потому что сама запись не экспортирована";
+    methodExport* = "{0} '{1}' не может быть экспортирован, потому что сама запись не экспортирована";
+    
+    (* Code.ob *)
+    negativeIndex* = "отрицательный индекс: {0}";
+    
+    (* ContextAssignment.ob *)
+    didYouMeanAssign* = "имели в виду ':=' (ожидается оператор, но указано выражение)?";
+    
+    (* ContextCase.ob *)
+    onlyRecordsForCase* = "только записи переданные в виде VAR аргумента могут быть использованы в качестве тестирующего выражения CASE";
+    caseExpectations* = "в выражении CASE ожидается 'RECORD' или 'POINTER' или {0} или 'CHAR'";
+    caseHandleLabelType* = "вариант должен быть '{0}' (такого же типа, что и выражение в CASE), но имеем '{1}'";
+    typeNameExpectedInLabel* = "имя типа ожидается в варианте, но указано выражение: {0}";
+    singleCharStringExpected* = "ожидается строка из одного символа";
+    canNotUseDiapason* = "не могу использовать диапазон (..) с охраной типа";
+    isNotAType* = "'{0}' не является типом";
+    isNotAConstant* = "'{0}' не является константой";
+    
+    (* ContextConst.ob *)
+    constExpressionExpected* = "ожидается выражение из констант";
+    
+    (* ContextDesignator.ob *)
+    canNotApplyTypecast* = "не могу выполнить приведение типа для {0}";
+    pointerCantBeDereferenced* = "тип указателя на неэкспортированную запись (POINTER TO RECORD) не может быть разыменован";
+    pointerTypeExpected* = "POINTER TO тип ожидается, но имеем '{0}'";
+    expressionExpected* = "{0} выражение ожидается, но имеем '{1}'";
+    indexOutOfBonds* = "индекс за границей: максимальный возможный индекс {0}, но имеем {1}";
+    arrayOrStringExpected* = "ARRAY или строка ожидается, но имеем '{0}'";
+    cantIndexEmptString* = "не могу индексировать пустую строку";
+    
+	(* ContextExpression.ob *)
+    cantBeReferenced* = "нельзя получить ссылку на {0}";
+    
+    (* ContextHierarchy.ob *)
+    undeclaredId* = "неизвестный идентификатор: '{0}'";
+    idIsNotExported* = "идентификатор '{0}' не экспортирован модулем '{1}'";
+    
+    (* ContextIf.ob *)
+    boolExpressionExpected* = "'BOOLEAN' выражение ожидается, но имеем '{0}'";
+    
+    (* ContextLoop.ob *)
+    isNotAVar* = "'{0}' не переменная";
+    varMustBeInteger* = "переменной '{0}' имеет тип '{1}', но управляющая переменная в 'FOR' должна иметь тип 'INTEGER'";
+    intExpect* = "ожидается выражение с результатом 'INTEGER' для присваивания к '{0}', но имеем '{1}'";
+    intExpectedAsTo* = "'INTEGER' выражение ожидается в качестве 'TO' параметра, но имеем '{0}'";
+    intExpectedAsBy* = "'INTEGER' выражение ожидается в качестве 'BY' параметра, но имеем '{0}'";
+    constExpectedAsBy* = "константное выражение ожидается в качестве 'BY' параметра";
+    
+    (* ContextModule.ob *)
+    moduleName* = "ожидается заявленное в начале название модуля '{0}', но имеем '{1}'";
+    moduleCantImportItself* = "модуль '{0}' не может импортировать сам себя";
+    duplicateAlias* = "такая замена имени модуля уже занята: '{0}'";
+    moduleAlreadyImported* = "модуль уже импортирован: '{0}'";
+    moduleNotFound1* = "модуль не найден: {0}";
+    moduleNotFound2* = "модули не найдены: {0}";
+    
+    (* ContextProcedure.ob *)
+    mismatchedProcName* = "имя процедуры в начале '{0}' не совпадает с именем в конце '{1}'";
+    argSameAsName* = "аргумент '{0}' имеет такое же имя как и имя процедуры";
+    unexpectedReturn* = "неожиданный RETURN в процедуре без объявленного результирующего типа";
+    returnTypeMismatch* = "RETURN типа '{0}' ожидается, но имеем '{1}'";
+    returnExpectedAtEnd* = "RETURN ожидается в конце процедуры объявленной с результирующем типом '{0}'";
+    procedureCantReturn* = "процедура не может возвращать результат типа {0}";
+    procedureExpected* = "PROCEDURE ожидается, но имеем '{0}'";
+    
+    (* ContextType.ob *)
+    intContExprExpected* = "ожидается выражение с результатом 'INTEGER', но имеем '{0}'";
+    constExprExpected* = "константное выражение ожидается для указания размера массива";
+    arraySizeMustBeGrater* = "размер ARRAY должен быть больше нуля, но имеем {0}";
+    fieldExpOnlyIfExported* = "поле '{0}' может быть экспортировано только если {1} '{2}' также экспортируется";
+    recursiveFieldDef* = "рекурсивное определение поля: '{0}'";
+    recTypeExpected* = "ожидается тип RECORD в качестве базового типа, но имеем '{0}'";
+    recursiveInheritance* = "рекурсивное наследование: '{0}'";
+    recExpectedAsPtrBaseType* = "ожидается RECORD в качестве базового типа для POINTER {0}";
+    cantExportAnonRecField* = "невозможно экспортировать анонимное поле RECORD: '{0}'";
+    
+    (* ContextVar.ob *)
+    typeWasntDeclared* = "тип '{0}' не был объявлен";
+    
+    (* ExpressionTree.ob *)
+    typeNameExpected* = "ожидается имя типа";
+    isNotAnExtencion* = "{0}: '{1}' не является расширением '{2}'";
+    ptrToTypeExpected* = "{0}: ожидается указатель на тип или запись, но имеем '{1}'";
+    valueVarCantBeUsed* = "{0}: параметр-значение не может быть использован";
+    recTypeExpectedAsArg* = "{0}: тип RECORD ожидается в качестве аргумента RECORD {1}, но имеем '{2}'";
+    ptrTypeExpectedAsArg* = "{0}: тип POINTER ожидается в качестве аргумента POINTER {1}, но имеем '{2}'";
+    typeMismatch* = "несовпадение типов: ожидается '{0}', но имеем {1}";
+    opTypeMismatch* = "в операции '{0}' несовпадение типов: {1} ожидается, но имеем '{2}'";
+    typeNameCantBeExpr* = "имя типа '{0}' не может быть использовано как выражение";
+    opDivExpected* = "операция DIV ожидается для целочисленного деления";
+    boolExpectedAsOperand* = "BOOLEAN ожидается в качестве операнда для '&', но имеем '{0}'";
+    boolExpectedAsOperandOfOr* = "BOOLEAN ожидается в качестве операнда для 'OR', но имеем '{0}'";
+    procReturningNoResult* = "процедура, не возвращающая результат, не может быть использована в выражении";
+    expectedAsElemOfSet* = "{0} ожидается как элемент SET, но имеем '{1}'";
+    
+    (* LanguageContext.ob *)
+    cannotReference* = "нельзя получить ссылку на {0}";
+    
+    (* Lexer.ob *)
+    intLooksLikeHex* = "целая константа похоже в шестнадцатеричном формате, но суффикс 'H' отсутствует";
+    unexpectedEndOfString* = "неожиданный конец строки";
+    commentWasNotClosed* = "комментарий не закрыт";
+    
+    (* Module.ob *)
+    strExpected* = "строка ожидается в качестве аргумента {0}, но имеем {1}";
+    procRetResCantBeStatement* = "процедура, возвращающая результат, не может быть использована как оператор";
+    
+    (* Operator.ob *)
+    strCantBeAssign* = "строка не может быть присвоена к открытому {0}";
+    arrIsTooSmall* = "{0}-символьный ARRAY слишком мал для {1}-символьной строки";
+    cantAssignTo* = "не могу присвоить к {0}";
+    typeMismatchExpr* = "несовпадение типа: '{0}' не может быть присвоен к '{1}' выражению";
+    openCantBeAssigned* = "открытый '{0}' не может быть присвоен";
+    
+    (* Procedure.ob *)
+    typeMismatchForArgPass* = "несовпадение типа для аргумента {0}: не могу передать '{1}' как VAR параметр типа '{2}'";
+    typeMismatchForArgConv* = "несовпадение типа для аргумента {0}: '{1}' не может быть преобразован к '{2}'";
+    expCannotUsedAsVar* = "выражение не может быть использовано в качестве VAR параметра";
+    cannotBePassedAsVar* = "{0} не может быть передано в качестве VAR формального параметра";
+    argsExpected* = "ожидаем аргументов — {0}, но имеем {1}";
+    procVarExpected* = "ожидается переменная типа POINTER, но имеем '{0}'";
+    nonExpRecCantUsedInNew* = "неэкспортируемая запись не может быть использована в NEW";
+    arrExpectedForLen* = "ARRAY или строка ожидается в качестве аргумента LEN, но имеем '{0}'";
+    val31expected* = "ожидается значение (0..31) в качестве второго аргумента {0}, но имеем {1}";
+    atLeastArgExpected* = "минимальное число аргументов — {0}, но имеем {1}";
+    atMostArgExpected* = "максимальное число аргументов — {0}, но имеем {1}";
+    typeMismatchNumExpected* = "несовпадение типа, ожидается целое, но имеем '{0}'";
+    ordExpectCharBoolSet* = "функция ORD ожидает аргументы типа CHAR, BOOLEAN или SET, но имеем '{0}'";
+    
+    (* Record.ob *)
+    dupField* = "дублирование поля: '{0}'";
+    baseRecHasField* = "базовая запись уже имеет поле: '{0}'";
+    typeHasNoField* = "тип '{0}' не имеет поля '{1}'";
+    
+    (* Scope.ob *)
+    mustBeRecordType* = "'{0}' должен быть типа RECORD, поскольку был использован в объявлении POINTER";
+    noDeclarationFound* = "не найдено объявления для '{0}'";
+    alreadyDeclared* = "'{0}' уже объявлен";
+    cannotExport* = "не может быть экспортирован внутри процедуры: {0} '{1}'";
+    
+    (* Types.ob *)
+    selectorCantBeApplied* = "селектор '.{0}' не может быть применён к '{1}'";
 
-END Message.
+END Message.

test/test_unit.js

@@ -1569,8 +1569,8 @@ return {
 "import unknown module": testWithGrammar(
     grammar.module,
     pass(),
-    fail(["MODULE m; IMPORT unknown; END m.", "module(s) not found: unknown"],
-         ["MODULE m; IMPORT unknown1, unknown2; END m.", "module(s) not found: unknown1, unknown2"]
+    fail(["MODULE m; IMPORT unknown; END m.", "module not found: unknown"],
+         ["MODULE m; IMPORT unknown1, unknown2; END m.", "modules not found: unknown1, unknown2"]
          )
     ),
 "self import is failed": testWithGrammar(
@@ -1582,7 +1582,7 @@ return {
     grammar.module,
     pass("MODULE m; IMPORT J := JS; END m.",
          "MODULE m; IMPORT J := JS; BEGIN J.alert(\"test\") END m."),
-    fail(["MODULE m; IMPORT u1 := unknown1, unknown2; END m.", "module(s) not found: unknown1, unknown2"],
+    fail(["MODULE m; IMPORT u1 := unknown1, unknown2; END m.", "modules not found: unknown1, unknown2"],
          ["MODULE m; IMPORT a1 := m1, a2 := m1; END m.", "module already imported: 'm1'"],
          ["MODULE m; IMPORT a1 := u1, a1 := u2; END m.", "duplicated alias: 'a1'"],
          ["MODULE m; IMPORT J := JS; BEGIN JS.alert(\"test\") END m.", "undeclared identifier: 'JS'"]
@@ -1623,4 +1623,4 @@ function run(){
     });
 }
 
-exports.run = run;
+exports.run = run;