Привет, неизвестный путник!
Добро пожаловать в документацию по языку C#.NStar! Здесь вы найдете информацию о его ошибках, предупреждениях
и других сообщениях. К сожалению, информация доступна только на английском.
0000: unexpected end of code reached
Maybe you have opened a bracket or started some construction and have not closed or completed it?
0001: too large number; long long type cannot be used in this context
There are supported numbers up to near 18 qtln.
0002: unrecognized escape-sequence
There are supported the following escape sequences: \0, \a, \b, \f, \n, \q, \r, \t,
\v, \', \", \!, \x followed with two hex digits (0-9, A-F), \u followed with
four hex digits.
0003: unrecognized sequence of symbols
0004: expected: identifier
0005: incorrect word or order of words in construction declaration
0006: the class "{0}" is the standard root C#.NStar type and cannot be redefined
See
types page for the list of such types.
0007: the class "{0}" is already defined in this region
0008: the class "{0}" is nearest to this outer class
0009: a static class cannot be derived
000A: the static functions are allowed only inside the classes
000B: the function "{0}" is the standard root C#.NStar function and cannot be redefined
See
functions page for the list of such functions.
000C: reserved for future lexer or pre-parser error
000D: the function cannot have same name as its container class
000E: ";" must follow the abstract function declaration, "{" - the non-abstract one
000F: the constructors are allowed only inside the classes
0010: {0} is reserved for next versions of C#.NStar and cannot be used
0011: expected: {
0012: the megaclass cannot be abstract or sealed
0013: the record cannot be derived
0014: the record must have the parameter list, at least empty one
0015: ";" must follow the record declaration
0016: the struct declaration cannot contain the keywords "abstract", "sealed" or "static"
0017: the struct members cannot be abstract
Still empty...
2000: unexpected end of code reached
See description for
error 0000.
2001: expected: identifier
2002: expected: ";"
2003: expected: {
2004: expected: }
2005: expected: methods or }
2006: expected: ":"
2007: unrecognized construction
2008: expected: {0}
2009: reserved for future parser error
This code was present during the original debug enumeration, but has not got into the production list.
200A: expected: (
200B: expected: )
200C: expected: [
200D: expected: ]
200E: expected: expression
200F: expected: "if" or "else"
2010: expected: "loop" or "while" or "repeat" or "for"
2011: expected: "continue" or "break"
2012: expected: identifier or basic expression or expression in round brackets
The list of "basic" expressions is: "true", "false", "this", "null", "Infty", "-Infty", "Uncty", "Pi", "E"
(without the quotes), numbers, characters in single quotes, strings in double quotes,
verbatim strings, "raw" strings.
2013: expected: "in"
2014: expected: "null" or identifier or tuple
2015: expected: non-sealed class or interface
2016: expected: int number; variables and complex expressions at this place
are under development
this expression must be implicitly convertible to the "int" type
2018: expected: comma; chain of indexes is not ended
2019: incorrect construction in parameters list
201A: the parameter with the "params" keyword must be last in the list
201B: the parameters without the default value and without the "params" modifier must appear
before the parameters with the default value{optionally "; expected: identifier"}
201C: at present time the "is" operator can be used only with "null" and the types
201D: only the variables can be assigned
201E: the keyword "{0}" is under development
201F: the division by the integer zero is forbidden
The division by the real zero is still allowed and returns the real infinity (for positive divisible),
minus infinity (for negative divisible) or uncertainty (if divisible is also zero).
2020: incorrect word or order of words in construction declaration
2021: too many nested collections of types
Red-Star-Soft plans to fully exclude recursion from the translation process, but it is the target of the far future,
and now many minor translation methods contain the recursion. The method that parses types is one of them,
and if it crashes with the stack overflow, the error 2021 is thrown.
(The practice shows that if it happens, the translator crashes along with the parser
and the error 2021 is not thrown.)
2022: the keyword "var" is not a type and cannot be used inside the type
2023: cannot create an instance of the abstract type "{0}"
2024: cannot create an instance of the static type "{0}"
2025: incorrect construction after type name
2026: the type "{0}" is not defined in this location
2027: incorrect type with "short" or "long" word
There are supported the following ones: short char, short int, long char (in the future), long int,
long long, long real (in the future), long complex (in the future).
2028: incorrect type with "unsigned" word
There are supported the following ones: unsigned short int, unsigned int, unsigned long int,
unsigned long long (in the future).
2029: only the exception types can be caught - the type "{0}" is not an exception type
202A: the identifier "{0}" is still not implemented, wait for next versions
202B: the end of identifier "{0}" is still not implemented, wait for next versions
202C: the namespace "{0}" is outdated, consider using {1} instead
202D: the type "{0}" is outdated, consider using {1} instead
202E: the end of identifier "{0}" is outdated, consider using {1} instead
202F: the properties can only have the proper access, no public
The "proper" means closed, protected, internal (at present time supported but does nothing)
or no modifier that means access from any type of the assemblies that depend on this.
2030: the "new" keyword is forbidden here
2031: the "new" keyword with implicit type is under development
2032: the function "{0}" with these parameter types is already defined in this region
2033: the switch expression cannot be empty
2034: the switch expression cannot contain cases after "_"
2035: the property cannot be static and required at the same time
2036: the struct can be derived only from the interfaces
2037: the type "{0}" is polymorph and requires the parameters
2038: expected: non-sealed class except "object" or interface
2039: reserved for future parser errors
203A: the identifier "{0}" is reserved for next versions of C#.NStar and cannot be used
203B: the end of identifier "{0}" is reserved for next versions of C#.NStar
and cannot be used
203C: the constants cannot have getters or setters
203D: the constant must have a value
It can be specified with the "=" sign after the constant name.
203E-2047: reserved for future parser errors
2048: goto is a bad operator, it worsens the organization of the code;
C#.NStar refused from its using intentionally
4000: internal compiler error
This error occurs when there already are the compiler errors, and some next operation has failed because of them.
If you see this error, look above in the compiler output.
4001: the identifier "{0}" is not defined in this location
4002: cannot apply this operator to this constant
This error occurs on the operators sin, cos, ln etc. Their operand is of the real type.
If you try to apply these operators to the value that is not real or implicitly convertible to real,
this error will occur.
4003: cannot compute factorial of this constant
This error occurs on the factorial operator. Its operand is of the unsigned int type.
If you try to apply this operator to the value that is not unsigned int or implicitly convertible to unsigned int
(such as a negative or fractional number), this error will occur.
4004: the division by the integer zero is forbidden
See description for
error 201F.
4005: cannot apply the operator "{0}" to the type "{1}"
4006: cannot apply the operator "{0}" to the types "{1}" and "{2}"
4007: the strings cannot be subtracted
In the early versions of C#.NStar this and the following two actions were possible but they have become forbidden
during the strengthening of the typing system of the language in the version Pre-Pre-I-2o2.
4008: the string cannot be multiplied by the string
4009: the strings cannot be divided or give the remainder (%)
400A: the abstract members can be located only inside the abstract classes
400B: at present time the index in the tuple must be a compilation-time constant
400C: incorrect construction is passing with the "{0}" keyword
400D: cannot compute this expression
400E-400F: reserved for future parser errors
4010: the variable "{0}" is not defined in this location;
multiconst functions cannot use variables that are outside of the function
4011: the variable declared with the keyword "var" must be assigned explicitly
and in the same expression
4012: one cannot use the local variable "{0}" before it is declared or inside such declaration
in line {1} at position {2}
4013: the variable "{0}" is already defined in this location or in the location that contains this
in line {1} at position {2}
4014: either "{0}" or "cannot convert from the type "{1}" to the type "{2}"{optionally
" - use an addition of zero-length string for this"}"
4015: there is no implicit conversion between the types "{0}" and "{1}"
4016: incorrect index in the list or the tuple; only the positive indexes are supported
4017: the type "{0}" cannot be created via the constructor
4018: the abstract type "{0}" can be created via the constructor
but only if you explicitly specify the constructing type (which is not abstract)
4019: the source for the switch expression must have a finite-range numeric or a string type
401A-401F: reserved for future parser errors
4020: the function "{0}" cannot be used in the delegate
4021: the function "{0}" is linked with object instance so it cannot be used in delegate
4022: the function "{0}" must have {either "{1}" or "from {2} to {1}"} parameters
4023: the function "{0}" does not have overlaods with parameters
4024: the function "{0}" is not defined in this location;
the multiconst functions cannot call the external non-multiconst functions
4025: the function "{0}" cannot be called from this location;
the static functions cannot call non-static functions
4026: either "{0}" or "incompatibility between the type of the parameter of the call
"{1}" and the type of the parameter of the function "{2}"{optionally
" - use an addition of zero-length string for this"}"
4027: either "{0}" or "the conversion from the type "{1}" to the type "{2}"
is possible only in the function return, not in the direct assignment and not in the call"
4028: incompatibility between the type of the parameter of the call "{0}" and all possible types
of the parameter of the function ({1}){optionally " - use an addition of zero-length string for this"}
4029: the conversion from the type "{0}" to any of the possible target types ({1})
is possible only in the function return, not in the direct assignment and not in the call
402A: this function or lambda must return the value on all execution paths
402B: either "{0}" or "incompatibility between the type of the returning value "{1}"
and the function return type "{2}"{optionally " - use an addition of zero-length string for this"}"
(moved from 4039 in Pre-Pre-I-4 - fixed miscategorizing)
402C-402F: reserved for future parser errors
4030: the property "{0}" is inaccessible from here
4031: the property "{0}" is not defined in this location;
multiconst functions cannot use external properties
4032: the property "{0}" cannot be used from this location;
static functions cannot use non-static properties
4033: the type "{0}" does not contain member "{1}"
4034: the type "{0}" does not have constructors with parameters
4035: reserved for future parser error
4036: reserved for future parser error
4037: reserved for future parser error
4038: this call is forbidden
the property "{0}" cannot be set from here
4039: the property "{0}" cannot be set from here
403A: the property "{0}" is declared with \"init\" modifier so it can be set
only in the initializer or constructor
403B: the property "{0}" is at the same time declared with \"init\" modifier
and static so it can be set only in the initializer
403C: you must set the required properties - it is done with the square brackets
403D: the required property "{0}" must be set during the construction
403E: there must be a constant type here; variables at this place are temporarily unavailable
403F: redundant property initializer - this class does not have so many
open settable properties
4040: no declaration lambda expression is not inside the valid call
4041: there is no overload of this function with the delegate parameter on this place
4042: incorrect list of the parameters of the lambda expression
4043: incorrect parameter #{0} of the lambda expression
4044: incorrect type of the lambda expression
4045: this lambda must have {0} parameters
4046-404F: reserved for future parser errors
4050: this expression must be constant but it isn't
4051: this expression must be constant but it isn't; const functions are under development
4052: cannot assign a value to the constant
4053: the local constant must have a value
4054: the local constant declaration must not contain the other operators than the single assignment
4055: too deep constant definition tree
4056: this expression must be the type but it isn't
4057: this expression must be constant and implicitly convertible to the \"int\" type
This means: byte, short int, unsigned short int, int, unsigned int, long int, unsigned long int, real, string.
4058-405F: reserved for future parser errors
4060: the constructor of the type "{0}" must have {either "{1}" or "from {2} to {1}"} parameters
4061: either "{0}" or "incompatibility between the type of the parameter of the call "{1}" and the
type of the parameter of the constructor "{2}"{optionally " - use an addition of zero-length string for this"}"
4062: incompatibility between the type of the parameter of the call "{0}" and all possible types
of the parameter of the constructor ({1}){optionally " - use an addition of zero-length string for this"}
4063: a loop detected while analyzing if all the required properties are initialized
in the constructor the type "{0}"; consider reordering the class members,
especially placing the properties before the constructors
4064-406F: reserved for future parser errors
4070: the property "{0}" is get-only and cannot be set
4071-407F: reserved for future parser errors
4080: the operator "{0}" cannot be used in this context
4081: the second operand of the operator "{0}" must be of the type, convertible to int
4082: the index operator and the range operator work only with the positive numbers
4083-408F: reserved for future parser errors
4090: the recursive type cannot be value of itself
4091: cannot get type of the type
4092: the recursive type variable, property or constant cannot have the name "typename"
4093: the recursive type in the pattern matching must contain the variable declaration
4094-409F: reserved for future parser errors
40A0: the relational pattern matching can be only applied to the numbers
40A1: the expression of the type "{0}" cannot be matched with the pattern of the type "{1}"
40A2: the declaration patterns cannot be used with the operator "{0}"
40A3: the negative declaration patterns cannot be used with the operator "{0}"
40A4-40AF: reserved for future parser errors
Still empty...
8000: the properties and the methods are static in the static class implicitly;
the word "static" is not necessary
8001: the semicolon in the end of the line with condition or cycle
may easily be unnoticed and lead to hard-catchable errors
8002: the syntax "return;" is deprecated; consider using "return null;" instead
8003: two "list" modifiers in a row; consider using the multi-dimensional list instead
8004: the count of the identical types in the tuple cannot be zero; it has been set to 1
8005: the unreachable code has been detected
8006: at present time the word "internal" does nothing because C#.NStar
does not have multiple assemblies
8007: the variable is assigned to itself - are you sure this is not a mistake?
8008: the method "{0}" has the same parameter types as its base method with the same name
but it also has the other significant differences such as the access modifier or the return type,
so it cannot override that base method and creates a new one; if this is intentional, add the "new" keyword,
otherwise fix the differences
8009: this expression, used with conditional constructions, is constant;
maybe you wanted to check equality of these values? - it is done with the operator "=="
800A: either "{0}" or "the type of the returning value "{1}" and the function return type "{2}"
are badly compatible, you may lost data"
800B: the constants are static implicitly; the word "static" is not necessary
800C: redundant space(s)
800D: missing indent(s) detected
The "missing indent" means that, according to the standard code style rules, there must be indent (tab) here,
but actually it is absent.
800E: redundant indent(s) detected
800F: too long line ({0} characters are supported, actually {1})
8010: too long function ({0} lines are supported, actually {1})
8011: redundant empty line(s) detected
8012: the megaclasses are static implicitly; the word "static" is not necessary
8013: an attempt to create a god class detected (more than {0} functions);
split it or replace the word "Class" with "Megaclass" (note that megaclasses are static)
8014: the name of the local number variable consists of one letter which is not i, j, k, n, x, y or z
8015: the name of the local string variable consists of one letter which is not s, x, y or z
8016: the name of the local type variable consists of one letter which is not T
8017: the name of the local non-number, non-string and non-type variable consists of one letter
which is not x, y or z
8018: the name of the construction which is not type or local variable consists of one letter
8019: the name of the type is neither one capital letter "T", nor letter "T" and digits,
nor letter "T" and an identifier that starts with another capital letter
801A: the name of the non-type construction consists only of one letter and non-letters,
the repetitions of one letter or the repetitions of one letter and non-letters
801B: the name of the namespace, type, function, extent, constant, lambda, list of lambdas,
dictionary of lambdas or non-private and non-protected property starts with lower case letter
801C: type inside the type inside the type detected
801D: complicated, spaghetti-like recursional dependencies detected
For example, some function in the hierarchy contains direct and indirect recursion at the same time.
801E: the previous pattern has already processed all the possible variants of key; this one is redundant
9000: unexpected end of code reached; expected: single quote
9001: there must be a single character or a single escape-sequence in the single quotes
9002: unexpected end of code reached; expected: double quote
9003: classic string (not raw or verbatim) must be single-line; expected: double quote
9004: unexpected end of code reached; expected: {0} pairs "double quote - reverse slash"
(starting with quote)
9005: unclosed comment in the end of code
9006: unclosed {0} nested comments in the end of code
9007: unpaired bracket; expected: }
9008: unpaired closing bracket
9009: using namespace is declared not at the beginning of the code
900A: expected: identifier
900B: namespace "{0}" is still not implemented, wait for next versions
900C: namespace "{0}" is outdated, consider using {1} instead
900D: namespace "{0}" is reserved for next versions of C#.NStar and cannot be used
900E: "{0}" is not a valid namespace
900F: using "{0}" is already declared
9010: expected: ";"
9011: unpaired brackets; expected: {0}
9012: at present time the abstract constructors is forbidden
9013: this parameter must pass with the "{0}" keyword
9014: too many sequential tabs (only 5 are supported)
9015: too many sequential whitespaces
9016: spaces instead of tabs at the line start
9017: too many indentation units (both present and missing indents) (only 5 are supported)
See
here about the "missing indent".
Still empty...
F000: compilation failed because of internal compiler error
F001: main parsing failed because of internal error
F002: memory limit exceeded during compilation, translation or execution;
program has not been executed
F003: a serious error occurred during compilation, translation or execution;
program has not been executed
F010: the NuGet package "{0}" does not exist (see under the "Settings" button)
F011: the NuGet package "{0}" has the wrong signature (see under the "Settings" button)
Still empty...
Назад к индексу документации