home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #6 / amigamamagazinepolishissue1998.iso / coders / jËzyki_programowania / oberon / text / oberonerrors.text (.txt) < prev    next >
Oberon Text  |  1994-01-08  |  8KB  |  216 lines

  1. Syntax10b.Scn.Fnt
  2. Syntax10.Scn.Fnt
  3. List of Oberon Error Numbers
  4. N. Wirth / 20.6.87 / 15.2.90 / 24.1.91 / RC, JS 1.4.93 (NOP2 Compiler) / SHML 4.9.92 (Analyzer)
  5. 1. Incorrect use of language Oberon
  6.   0    undeclared identifier
  7.   1    multiply defined identifier
  8.   2    illegal character in number
  9.   3    illegal character in string
  10.   4    identifier does not match procedure name
  11.   5    comment not closed
  12.   9    "=" expected
  13. 10    identifier expected
  14. 12    type definition starts with incorrect symbol
  15. 13    factor starts with incorrect symbol
  16. 14    statement starts with incorrect symbol
  17. 15    declaration followed by incorrect symbol
  18. 16    MODULE expected
  19. 17    number expected
  20. 18    "." missing
  21. 19    "," missing
  22. 20    ":" missing
  23. 22    ")" missing
  24. 23    "]" missing
  25. 24    "}" missing
  26. 25    OF missing
  27. 26    THEN missing
  28. 27    DO missing
  29. 28    TO missing
  30. 29    "(" missing
  31. 30    "(" missing
  32. 33    ":=" missing
  33. 34    "," or OF expected / ":=" missing
  34. 35    "," or OF expected
  35. 37    identifier expected
  36. 38    ";" missing / identifier expected
  37. 39    ";" missing
  38. 40    END missing
  39. 41    END missing
  40. 43    UNTIL missing
  41. 44    UNTIL missing
  42. 45    EXIT not within loop statement
  43. 46    EXIT not within loop statement
  44. 47    illegally marked identifier
  45. 48    unsatisfied forward reference
  46. 49    recursive import not allowed
  47. 50    expression should be constant
  48. 51    constant not an integer
  49. 52    identifier does not denote a type
  50. 53    identifier does not denote a record type
  51. 54    result type of procedure is not a basic type
  52. 55    procedure call of a function
  53. 56    assignment to non-variable
  54. 57    pointer not bound to record or array type (array must not contain pointers)
  55. 58    recursive type definition
  56. 59    illegal open array parameter
  57. 60    wrong type of case label
  58. 61    inadmissible type of case label
  59. 62    case label defined more than once
  60. 63    index out of bounds / illegal value of constant
  61. 64    more actual than formal parameters
  62. 65    fewer actual than formal parameters
  63. 66    element types of actual array and formal open array differ
  64. 67    actual parameter corresponding to open array is not an array
  65. 68    control variable must be integer
  66. 69    parameter must be an integer constant
  67. 70    pointer or VAR record required as formal receiver
  68. 71    pointer expected as actual receiver
  69. 72    procedure must be bound to a record of the same scope
  70. 73    procedure must have level 0
  71. 74    procedure unknown in base type
  72. 75    invalid call of base procedure
  73. 76    this variable (field) is read only
  74. 77    object is not a record
  75. 78    dereferenced object is not a variable
  76. 79    indexed object is not a variable
  77. 80    index expression is not an integer
  78. 81    index out of specified bounds
  79. 82    indexed variable is not an array
  80. 83    undefined record field
  81. 84    dereferenced variable is not a pointer
  82. 85    guard or test type is not an extension of variable type
  83. 86    guard or test type is not a pointer
  84. 87    guarded or tested variable is neither a pointer nor a VAR-parameter record
  85. 88    test type is not an extension of variable type / open array not allowed as variable, record field or array element
  86. 89    test type is not a pointer
  87. 90    tested variable is neither a pointer nor a VAR-parameter record
  88. 92    operand of IN not an integer, or not a set
  89. 93    set element type is not an integer
  90. 94    operand of & is not of type BOOLEAN
  91. 95    operand of OR is not of type BOOLEAN
  92. 96    operand not applicable to (unary) +
  93. 97    operand not applicable to (unary) -
  94. 98    operand of ~ is not of type BOOLEAN
  95. 99    ASSERT fault
  96. 100    incompatible operands of dyadic operator
  97. 101    operand type inapplicable to *
  98. 102    operand type inapplicable to /
  99. 103    operand type inapplicable to DIV
  100. 104    operand type inapplicable to MOD
  101. 105    operand type inapplicable to +
  102. 106    operand type inapplicable to -
  103. 107    operand type inapplicable to = or #
  104. 108    operand type inapplicable to relation
  105. 109    overriding method must be exported
  106. 110    operand is not a type
  107. 111    operand inapplicable to (this) function
  108. 112    operand is not a variable
  109. 113    incompatible assignment
  110. 114    string too long to be assigned
  111. 115    parameter doesn't match
  112. 116    number of parameters doesn't match
  113. 117    number of parameters doesn't match / result type doesn't match
  114. 118    result type doesn't match / export mark doesn't match with forward declaration
  115. 119    assigned procedure is not global / redefinition textually precedes procedure bound to base type
  116. 120    type of expression following IF, WHILE, UNTIL, or ASSERT is not BOOLEAN
  117. 121    called object is not a procedure (or is an interrupt procedure)
  118. 122    actual VAR-parameter is not a variable
  119. 123    type of actual parameter is not identical with that of formal VAR-parameter
  120. 124    type of result expression differs from that of procedure
  121. 125    type of case expression is neither INTEGER nor CHAR
  122. 126    illegal mode of operand / this expression cannot be a type or a procedure
  123. 127    illegal mode of addressed operand / illegal use of object
  124. 128    unsatisfied forward reference
  125. 129    unsatisfied forward procedure
  126. 130    WITH clause does not specify a variable
  127. 131    LEN not applied to array
  128. 132    dimension in LEN too large or negative
  129. 135    SYSTEM not imported
  130. 150    key inconsistency of imported module
  131. 151    incorrect symbol file
  132. 152    symbol file of imported module not found
  133. 153    object or symbol file not opened (disk full?)
  134. 154    recursive import not allowed
  135. 155    generation of new symbol file not allowed
  136. 2. Limitations of implementation
  137. 200    not yet implemented
  138. 201    lower bound of set range greater than higher bound
  139. 202    set element greater than MAX(SET) or less than 0
  140. 203    number too large
  141. 204    product too large
  142. 205    division by zero
  143. 206    sum too large
  144. 207    difference too large
  145. 208    too many variables in procedure / overflow in arithmetic shift
  146. 209    too much variable space needed / case range too large
  147. 210    code too long
  148. 211    jump distance too large
  149. 212    buffer for identifiers and strings full
  150. 213    too many cases in case statement
  151. 214    too many exit statements
  152. 215    not enough registers: simplify expression
  153. 216    not enough floating-point registers: simplify expression
  154. 217    parameter must be an integer constant
  155. 218    illegal value of parameter  (20 <= p < 256)
  156. 219    illegal value of parameter  (0 <= p < 16)
  157. 220    illegal value of parameter
  158. 221    string cannot be exported / too many pointers in a record
  159. 222    too many pointers (either global, or in record)
  160. 223    too many record types
  161. 224    too many pointer types
  162. 225    address of pointer variable too large (move forward in text)
  163. 226    too many exported procedures (>= 40)
  164. 227    too many imported modules
  165. 228    too many exported structures
  166. 229    too many nested records for import
  167. 230    too many constants (strings) in module
  168. 231    too many link table entries (external procedures)
  169. 232    too many commands in module
  170. 233    record extension hierarchy too high
  171. 234    export of recursive type not allowed
  172. 236    address of exported variable too large (move forward in text)
  173. 240    identifier too long
  174. 241    string too long
  175. 242    address overflow
  176. 3. Warnings of Compiler and Analyzer
  177. 301    implicit type cast
  178. 302    guarded variable can be side-effected
  179. 303    open array (or pointer to array) containing pointers
  180. 900    never used
  181. 901    never set
  182. 902    used before set
  183. 903    set but never used
  184. 904    used as varpar, possibly not set
  185. 905    also declared in outer scope
  186. 906    access/assignment to intermediate
  187. 907    redefinition
  188. 4. Run-time Trap Numbers
  189.   0    ASSERT fault
  190.   1    Parity error  (NMI)
  191.   2    Illegal address (NIL-reference, inspect EIA)
  192.   3    FPU error  (inspect FSR)
  193.   4    Illegal instruction
  194.   5    Illegal SVC number
  195.   6    Division by zero
  196.   7    Flag trap, invalid index, integer overflow
  197.   9    Trace trap
  198. 10    Undefined instruction
  199. 11    Restartable bus error
  200. 12    Nonrestartable bus error
  201. 13    Integer overflow trap or invalid index trap
  202. 14    Debug trap
  203. 15    Index out of range / Invalid case in WITH statement
  204. 16    Invalid case in CASE statement
  205. 17    Function procedure without RETURN statement
  206. 18    Type guard check
  207. 19    Implied type guard check in record assignment
  208. 20    Disk drive error (unreadable sector)
  209. 21    Parity error in sector address
  210. 22    Disk full
  211. 23    File too long  (> 2.5 MB)
  212. 24    Abort from keyboard
  213. 25    ReadBytes/WriteBytes(R, a, n):  LEN(a) < n
  214. 27    Illegal function argument (Math or MathL)
  215. 30 - 255    Programmed HALT
  216.