texts
stringlengths 0
715k
| names
stringlengths 8
91
|
|---|---|
Map to the Dev Subsystem
UserManual
DevAlienTool display infos on aliens
DevAnalyzer source code analyzer
DevBrowser symbol file browser
DevCmds miscellaneous commands
DevComInterfaceGen generate Automation
interfaces
DevCommanders command interpreters
DevCompiler Component Pascal
compiler
DevDebug symbolic debugger
DevDependencies display module graph
DevHeapSpy visual heap display
DevInspector control property inspector
DevLinkChk check hyperlinks
DevLinker linker
DevMarkers error markers
DevMsgSpy log messages to a view
DevPacker pack files into an EXE file
DevProfiler statistical profiler
DevRBrowser repository browser
DevReferences source/docu symbol lookup
DevSearch global search tool
DevSubTool template generator
| Dev/Docu/Sys-Map.odc |
DevTypeLibs
Module DevTypeLibs deals with information provided by COM type libraries. This module has a private interface, it is only used internally.
| Dev/Docu/TypeLibs.odc |
Dev Subsystem
User Manual
Contents
1CompilingComponentPascalmodules
2Browsingtools
3Loadingandunloadingmodules
4Executingcommands
5Debugging
6Deployment
7Cross-Platformissues
1 Compiling ComponentPascal modules
Besides consuming stored text documents, the Component Pascal compiler can compile modules from anywhere in any displayed text document. If the beginning of a displayed text is also the beginning of a module, the command Dev->Compile is used to compile the module. If the module begins somewhere in the middle of a displayed text, its beginning can be selected, e.g., by doubleђclicking on the keyword MODULE, and then the command Dev->CompileSelection is used.
To compile a list of modules at once, a list of module names needs to appear in some displayed text, e.g.,
FormModels FormViews FormControllers FormCmds
By selecting the part of the list that should be considered by the compiler, and by invoking the command Dev->CompileModuleList, the list of modules is compiled consecutively. The process stops as soon as an erroneous module has been encountered. The compiler reports on the success or failure of compilations by writing into the system log. The log is a special text displayed in an auxiliary window. It can be opened using Info->OpenLog and cleared using Info->ClearLog.
The log is a development tool, i.e., it is mainly used for debugging purposes and for development tools. End-user applications are not expected to display a log. Whether or not a log window is opened upon startup of BlackBox is determined by the configuration's Config module (in directory System/Mod). This module can be changed by the programmer as desired; by default its Setup procedure only contains a statement which opens the log.
Dev->OpenModuleList is a convenient command which opens the module sources of one or several modules: select a module name, e.g., FormCmds, and then execute Dev->OpenModuleList. This command can save you much time when you work with multiple subsystems (-> 7.2 Modules and Subsystems) at the same time.
When compiling a newly created or a modified module, direct compilation of the displayed program text with Dev->Compile is recommended. In addition to writing to the system log, the compiler then also inserts error markers into the source text and places the caret after the first marker, if some syntax error was encountered. Each marker represents an error flagged by the compiler in the source text. Normally, a marker is displayed as a crossedђout box. However, simply by clicking into it, a marker expands to display the corresponding error message. If the insertion point is directly behind a marker, it can be expanded via the command Dev->ToggleErrorMark (or more likely via its keyboard shortcut).
Windows:
At the bottom of a window there is a status bar. If the user clicks into an error marker, the error message is written into the status bar instead of expanding the error marker. The error marker can be forced to expand by a modifier-click or a double-click on the marker.
The command Dev->NextError can be used to skip forward to the next marker. Dev->UnmarkErrors removes all remaining markers from a text. However, this command is rarely required: The compiler automatically removes all old markers when recompiling a text; and when storing a text, contained markers are filtered out, i.e., do not appear anymore when the text is opened again.
If a compiled module contains one or several errors, the text is scrolled to the first one. If this doesn't happen, the module was successfully compiled. In addition to this feedback, the compiler writes the number of errors found to the log, if there are errors. If the module interface has changed compared to a previous version, the changes are listed in the log as well.
The successful compilation of a module yields two files: a symbol file and a code file. A symbol file contains the information about a module's interface, and is used by the compiler to check imported modules for consistency. The code file represents the generated code (Intel 386 code on Windows, Motorola 68020 code on Macintosh). The contents of a code file is linked and loaded dynamically when needed, thus there is no need for a separate linker.
Symbol files are only needed during development (used by the compiler and the interface browser), they are not needed to run modules. A symbol file is a special encoding of a module's interface, i.e. of its exported constants, variables, types, and procedures. If the interface of a module is changed and the module recompiled, a new symbol file is written to disk. When compiling a module, the compiler reads the symbol files of all imported modules. This information is used to generate code, but also to type-check the correct use of imported identifiers.
After the interface of a module has been modified, all modules importing it (i.e., all its clients) must be recompiled. Only those modules need to be recompiled which actually use a feature that has been changed. A mere addition of features does not invalidate the clients of a module: if you export a further procedure, for example, no clients need to be recompiled. This also holds for constants, variables, and types, but not for methods. Addition of a method is not considered an extension, but rather a modification of an interface, and thus may invalidate clients.
Code files are produced, but never read during compilation. They are necessary to run modules, i.e. the dynamic (linking) loader must be able to read them. They can be regarded as special very light-weight DLLs (dynamic link libraries).
See also modules DevCompiler, DevCmds, and DevMarkers.
2 Browsing tools
A common cause of compileђtime errors is the wrong use of interfaces. To quickly retrieve the actual definitions of items exported by modules, the browser may be used. The interface of a whole module is displayed when selecting the name of a module and executing Info->Client Interface. To display the definition of an individual item, e.g., a type or procedure, the qualified name of that item, i.e., module.item should be selected with the same command. The browser displays its output in a form that can directly be used as input for further browsing actions. Command Info->Client Interface only shows the part of a module's interface which is relevant for clients, i.e., it leaves out implement-only methods and similar items that are only relevant for implementers of object types. For implementers, the command Info->Extension Interface shows the full interface.
Two related commands, Info->Source and Info->Documentation, allow to look up an item's definition in a source file, or in an on-line documentation, respectively. They both work on selected module names as well as on names in the form module.item, just as the Info->Interface command.
The general text search commands Info->SearchinSources and Info->SearchinDocu search a selected string in the available source files, respectively documentation files. For source files, this means in the global Mod directory and in each subsystems' Mod directory. For documentation files, this means in the global Docu directory and in each subsystem's Docu directory. As a result of these commands, a new text is opened which contains a hyperlink for each file where the string occurs, and the count of how many times it occurs there. When the user clicks on the hyperlink, the corresponding file is opened and first instance of the string is selected. With Text->FindAgain, the next instance can be found. Note that these commands may take up to several minutes to complete.
See also modules DevBrowser, DevReferences, DevSearch, and DevDependencies.
3 Loading and unloading modules
Once a module successfully passes the compiler it can be loaded to the system and used.
The BlackBox loader can dynamically link and load a module at run-time. A code file basically is a language-specific light-weight DLL (dynamic link library). The loader can be invoked from within a program by calling the procedure Dialog.Call. This procedure takes a command name as parameter. It loads the command's module, if it isn't loaded yet. Afterwards, it executes the command's procedure. For example,
Dialog.Call("DevDebug.ShowLoadedModules", "", res)
causes the loading of module DevDebug (if necessary) and the execution of its ShowLoadedModules procedure.
A loading attempt may cause the following errors:
Code file not found
The code file of a module has not been found.
For example, loading of module FormCmds requires the code file Form/Code/Cmds.
Corrupted code file
The module's code file exists, but its internal format is not correct.
Object not found
The module imports some object (constant, type, variable, procedure) from another module, where this object is not exported.
Obect j inconsistently imported
The modulee imports some object (constant, type, variable, procedure) from another module, where this object is exported, but with a different signature.
Such inconsistencies typically occur if a module's interface was changed (e.g., a procedure got an additional parameter), but not all client modules were recompiled afterwards. Another possibility is that the module whose interface was changed has not been reloaded after compilation. In this case, everything will work fine after it has been unloaded (e.g., after a restart of BlackBox).
Cyclic import
Modules may not import each other cyclically. For example, it is not alllowed that module A imports module B, and module B imports module C, and module C imports module A.
Not enough memory
There is not enough memory left for loading the module.
Once loaded, a module remains loaded if it isn't unloaded explicitly. The list of all currently loaded modules is displayed by Info->LoadedModules.
In order to use a new version of a module that is already loaded, the module needs to be unloaded first.
Command Dev->Unload takes a focused module source as input and tries to unload the corresponding module. Dev->Unload fails if the module is still in use, i.e., if it is imported by at least one other module that is still loaded. (In general, modules can only be released top down.) The command Dev->UnloadModuleList takes a selection as input, which must consist of a sequence of module names. You may directly use a selection in the text produced by Info->LoadedModules as input.
See also module DevDebug.
4 Executing commands
There are several ways to execute commands (i.e., procedures exported by Component Pascal modules, intended for direct invocation by the user) within BlackBox. A command name can be written to a text, as a string of the form "module.procedure", selected, and executed using Dev->Execute. An easier way is to insert a commander in front of the command name, using Tools->InsertCommander. Clicking on a commander interprets the string following it as a sequence of commands, e.g.
"Dialog.Beep; DevDebug.ShowLoadedModules"
If the string consists of only one parameterless command, the string delimiters may be omitted, e.g.,
Dialog.Beep
With such simple commands, it is possible to combine the unloading of an old version with the execution of a new version of a command (resp. of its module): modifier-click on the commander causes the command's module to be unloaded, and then the new module version is loaded and the procedure executed. Note that this "unload shortcut" only works for top-level modules, i.e. for modules which are not imported by any other modules.
The allowed parameter lists for commands are documented with module StdInterpreter.
The BlackBox Component Framework tries to call the command Config.Setup when it is starting up. You can change Config in order to customize your configuration upon startup.
See also modules DevDebug and Config.
5 Debugging
When a run-time error occurs, e.g., a division by zero or some assertion trap, a trap window is opened. Such a window contains a text which shows the stack contents at the time when the trap occurred. An extract of such a trap text is shown below:
index out of range
ObxTrap.Do [00000049H]
i INTEGER 777
str Dialog.String "String"
v Views.View [85D29730H]
StdInterpreter.CallProc [00000BC1H]
i Meta.Item
.obj SHORTINT 4
.typ SHORTINT 20
.vis SHORTINT 4
.adr LONGINT -2034827097
.mod undefined: 86B60000H
.desc undefined: 00000004H
.ptr Meta.ArrayPtr [85CDF4B0H]
mn Meta.Name "ObxTrap"
mod StdInterpreter.Ident "ObxTrap"
ok BOOLEAN TRUE
parType INTEGER 0
pn Meta.Name "Do"
proc StdInterpreter.Ident "Do"
StdInterpreter.Command [0000187EH]
left StdInterpreter.Ident "ObxTrap"
ptype INTEGER 0
right StdInterpreter.Ident "Do"
In the first line, the exception or trap number is given, e.g., "Index out of range" or "TRAP 0". Further below, a sequence of procedure activations is given, e.g., the last active procedure (where the trap occurred) was ObxTrap.Do, which had been called by StdInterpreter.CallProc, which had been called by StdInterpreter.Command, etc. Each procedure is marked with a small diamond mark to the left of its name. Clicking on this diamond mark produces a new window which shows the global variables of the module in which this procedure is defined, e.g.,
ObxTrap
global INTEGER 13
The diamond mark to the right of a procedure opens the source of the module in which this procedure is defined, selects the statement which has been interrupted, and scrolls to this selection. Of course, this is only possible for modules whose source code is available.
But now let us go back to the stack display. The lines below a procedure's name show the parameters and local variables of the procedure, sorted alphabetically. The following example
str Dialog.String "String"
means that a local variable str of type Dialog.String had the value "String" when the trap occurred. If the variable name is displayed in italics, this means that it is a variable parameter (i.e., representing another variable).
After a pointer variable, a diamond mark allows to follow the pointer to the record to which it points, e.g. the pointer v
v Views.View [85D29730H]
can be followed (by clicking on the diamond mark) to the record
ObxTrap.Do:v^
[85D29730H] TextViews.StdViewDesc
.context Models.Context [85D29CC0H]
.era LONGINT 3
.guard LONGINT 0
.bad SET {}
.model Containers.Model [85D29780H]
.controller Containers.Controller [85D29A20H]
.alienCtrl Stores.Store NIL
.text TextModels.Model [85D29780H]
.org LONGINT 0
.dy LONGINT 0
.defRuler TextRulers.Ruler [85D29AD0H]
.defAttr TextModels.Attributes [85D29BD0H]
.hideMarks BOOLEAN TRUE
.cachedRd TextSetters.Reader [85D1A470H]
.trailer TextViews.Line [85D20390H]
.bot LONGINT 2339975
.setter TextSetters.Setter [85D29BF0H]
.setter0 TextSetters.Setter [85D29BF0H]
Such a display is opened in another window. The fields of a record are indicated by the preceding ".". On the first line, the path you have followed is indicated. If you have followed more than one dereferencing step, a diamond mark at the right end of this line lets you trace back again step by step.
Array elements and record fields are wrapped into folds (-> StdFolds), which can be opened or closed by clicking on the fold views. Folding of structured data types makes it easier to get an overview in complex situations.
Note that the debugger only finds source text files if they are located at their correct places and under their correct names, according to their subsystems. For example, for module "FormViews", the debugger looks for file Form/Mod/Views. If the file is stored somewhere else, or under another name, the debugger will look for an open window with the appropriate module source in it. It this also fails, it opens a dialog box so that the user can show the debugger where to find the correct file.
When a trap occurs in a view implementation, e.g., in the view's Restore procedure, the error which caused it might later lead to another trap again, e.g., when the view becomes uncovered, its Restore procedure is called again. In the worst case, this may lead to a never-ending sequence of traps. BlackBox prevents this by partially disabling a trapped view. Such a view is overlaid with a light grey pattern; its contents won't be restored again. However, the view's remaining behavior is still intact, i.e., it may be saved to a file. If saving leads to a trap, the view is turned into an alien; this is indicated by a cross overlaid over the view. The rest of the container document could still be saved, however.
BlackBox distinguishes three categories of view traps:
refresh: a trap in the view's Restore or RestoreMarks procedures
save: a trap in the view's Internalize or Externalize procedures
other: a trap in any other of the view procedures
If a trap in one of those categories occurs, this behavior will be disabled (i.e., the system won't call the procedures in this category anymore), behavior of the other categories remains intact. In the worst case, a view can lead to three traps, one for each category.
This means that erroneous views "degrade gracefully", by freezing only those behaviors that already have led to traps. If for some reason a view should be "unfrozen" again, the command Dev->RevalidateView can be used.
An endless loop can be interrupted by pressing ctrl-break (Windows 95/NT) / command-option-. (Mac OS).
The following standard traps may occur at run-time (depending on the platform, some of these errors don't occur):
invalid WITH
invalid CASE
function without return
type guard
value out of range
index out of range
string too long
stack overflow
integer overflow
division by zero
infinite real result
real underflow
real overflow
undefined real result
not a number
keyboard interrupt
NIL dereference
illegal instruction
NIL dereference (read)
illegal memory read
NIL dereference (write)
illegal memory write
NIL procedure call
illegal execution
out of memory
bus error
address error
fpu error
exception
Besides these standard traps, there are custom traps. Each custom trap has a trap number associated with it. The following conventions are used:
Free ЏЏ0 .. Џ19
Preconditions Џ20 .. Џ59
Postconditions Џ60 .. Џ99
Invariants 100 .. 120
Reserved 121 .. 125
Not Yet Implemented 126
Reserved 127
You can use trap codes 0..19 freely in your programs, typically as temporary breakpoints during debugging. By convention, the other trap codes are generated by various assertions, i.e., statements which check a certain condition, and terminate the command if the condition is violated. Conditions which must be fulfilled upon entry of a procedure are called preconditions, conditions which must be fulfilled upon exit of a procedure are called postconditions, and conditions which must be fulfilled in between are called invariants. Most procedures in the BlackBox Component Framework check some preconditions. Typically, trap numbers are kept unique inside of a procedure. Thus, if a trap occurs, consult the documentation (or source, if available) of the trapped procedure. There you should get more information about the cause of the trap.
The developer may even provide a plain-text description of the trap's cause, by providing suitable resources in the subsystem's string resource file: module name without subsystem prefix, followed by ".", followed by the procedure name, followed by ".", followed by the trap number. The following are examples:
Math.Power.23 Pre: x # 1.0 OR ABS(y) # INF
Views.View.CopyFrom.20 Views.CopyFrom and Views.CopyFromModelView must not both
be overwritten
If such a resource exists, the corresponding text is shown in the trap display.
It should be noted that at no time during debugging the normal BlackBox Component Builder environment is left, there is no special "debugging mode" or "debugging environment"; everything is integrated instead!
Example: ObxTrapdocu
The BlackBox debugger is a cross between a "post-mortem" debugger and a "run-time" debugger. It is invoked after a command has trapped (post-mortem), but it doesn't cause a termination of the BlackBox environment (run-time). Some features, such as the Info->ViewState command, which makes it possible to follow data structures starting from a selected view, are usually associated with run-time debuggers only.
It is typical for object-oriented programs that their control flows can become extremely convoluted and hard to follow. Thus following a program statement for statement (single step), by message sends, or by procedure calls in practice turns out to be unpractical for debugging large systems. Instead, BlackBox uses a more effective debugging strategy:
Let errors become manifest as soon as possible.
Instead of waiting for some error to occur, and then trying to find one's way backward to the cause of the error, it was attempted to flag errors as closely to their cause as possible. This is the only way to truly save debugging time. The language implementation follows the same strategy, by checking index overflows when accessing arrays, by checking NIL accesses when dereferencing a pointer, etc. In addition to these built-in checks, Component Pascal provides the standard procedure ASSERT, which allows to test for an arbitrary condition. If the condition is violated, a trap window is opened. Procedures of the BlackBox Component Framework consequently use assertions e.g. at the beginning of a procedure to check whether its input is valid. This prevents that a procedure with illegal input may perform any damage to the rest of the system.
This defensive programming strategy has proven itself again and again during the development of BlackBox, and is strongly recommended for serious development work.
See also module DevDebug.
6 Deployment
If you develop add-on components (i.e., new subsystems) for BlackBox, deployment simply means to distribute copies of your subsystem directory. You may not want to distribute the source texts, in order to protect your intellectual property rights. In this case you should not put them into the distribution copies. You may not want to make one or several of your module interfaces public, or none at all if your application is not meant to be extensible. In this case, you should not put the corresponding symbol files into the distribution copies. However, for each public module you should put a documentation file into the subsystem's Docu directory. For example, for module FormCmds there is a docu file Form/Docu/Cmds.
It is customary to put a Sys-Map file in the Docu directory. This map text contains a list of all public modules; the elements of the list are hyperlinks.
If the subsystem implements user interface elements such as views or commands, a user manual should be made available. This document is called User-Man and also resides in the Docu directory.
If the subsystem is meant for use by programmers, and if the individual modules' documentation files are not sufficient, the Docu directory should contain an overview text called Dev-Man.
The previous paragraph has shown everything you need to do to distribute an add-on component, i.e., an extension in the form of a subystem. On the other hand, if you want to distribute a stand-alone application for some reason, you have three possibilities:
1) This approach is suited for applications where updates and extensions are frequent: you provide the unlinked code files of your application and of BlackBox, together with a minimal linked application to boot the whole software system.
To make an unpacked and unlinked stand-alone version you need to copy some files and directories from the BlackBox directory to a new directory. BlackBox.exe may be renamed to the name of your new application.
2) This approach is suitable for applications that are closed or where incremental updates and extensions are relatively rare: you pack the BlackBox directory's contents into one large executable file. In contrast to the linker (see below), the packer is not limited to code files; it can also pack resources and documentation and any other kind of files into the application. In contrast to approach 1), the end user cannot easily destroy the applications just by deleting some code or resource file. See the packerЏdocumentation for details.
3) This approach is most relevant for native applications (i.e., Component Pascal applications which don't use the BlackBox framework) and for linked libraries (DLLs under Windows): you use the linker tool to combine several code files into one application file.
For a linked version you need to use the linker to pack your code files together with the BlackBox code files into a single application. See the linkerdocumentation for details. After linking, you need to copy the new application to a new directory. You also need to copy the Rsrc subdirectories of the Form, Host, Std, System, Text, and of your own subsystems. If the resource files are missing, the application would still operate (kind of), but lose all string mappings, all dialog box layouts, and all custom menus.
All approaches:
In addition, you need to create your own versions of the menu definition file and of the About... dialog box (System/Rsrc/Menus and System/Rsrc/About). If your application is meant to be extensible, you also need to copy the symbol files (Sym/Xyz) of all modules whose interfaces should be public. This may or may not encompass the standard BlackBox modules. Make sure the structure of your new directories matches the subdirectory structure in the original BlackBox directory!
Windows:
Adapt the Help menu command, and the corresponding help text in an appropriate way.
Mac OS:
Edit the Help text in the System/Rsrc directory in an appropriate way.
To distribute software electronically over a medium which doesn't support binary distribution, e.g., over e-mail, a standardASCIIencoder is available.
7 Cross-Platform issues
If you use BlackBox both on Mac OS and on Windows, you'll regularly transfer documents between the two platforms. Code files cannot be transferred, since their formats are non-portable. To simplify the transfer of documents, you should configure the available tools (e.g., Apple's PC Exchange software) such that they map the Mac OS file type ("oODC") and file creator ("obnF") to the Windows file name suffix ".odc" and vice versa.
Furthermore, you may want to use fonts which are available on both platforms, either TrueType fonts or PostScript fonts if you have Adobe's Type Manager available. If you don't have equivalent fonts on both platforms, you can still read the text, with another font substituted for the correct one. This will likely result in visually unsatisfactory results.
Use the default font for cross-platform documents, if you have no preference for a specific font. Typically, the default font is used for on-line documentation. The default font automatically adapts to the reader's system configuration, so that he or she can select their preferred font.
Like any other document, a dialog box can be transferred between the two platforms. However, for best results you may want to fine-tune a dialog box layout for the platform's controls before distributing it.
In order to minimize installation problems, it is recommended to limit module names to at most eight characters (not counting the subsystem prefix, which itself may be up to eight characters), and not to use module names which only differ in their use of small or capital letters.
| Dev/Docu/User-Man.odc |
DevAlienTool
DEFINITION DevAlienTool;
PROCEDURE Analyze;
END DevAlienTool.
Нелегальными называются отображения, которые по каким-либо причинам не могут быть корректно загружены. Причиной может быть программная ошибка, например, число прочитанных байт отличается от того, сколько было записано, или это может быть проблема версий (была обнаружена неизвестная версия). Однако обычно проблема в том, что некоторый код для отображения не может быть загружен, поскольку он поврежден или противоречив. Инструмент Alien помогает в анализе таких проблем.
PROCEDURE Analyze
Охрана: StdCmds.SingletonGuard
Эта команда выполняет анализ нелегального отображения, выделенного монолитно, и открывает окно с текстовым отчетом. | Dev/Docu/ru/AlienTool.odc |
DevAnalyzer
ENGLISH
Stefan H.-M. Ludwig
Обзор
Щелкните на одной из синих ссылок, чтобы перейти прямо к соответствующему разделу руководства. Для технической поддержки перейдите в раздел контактнаяинформация.
Предупреждение Номер Объяснение: элемент ... ОпцияInfo>Analyzeroptions...
neverused 900 нигде не используется по умолчанию
neverset 901 нигде не присваивается значение по умолчанию
usedbeforeset 902 используется до инициализации по умолчанию
setbutneverused 903 присвоенное значение не используется по умолчанию
usedasvarpar,possiblynotset 904 пар-р-ссылка передается до иниц-ии VAR Par
alsodeclaredinouterscope 905 также объявлен во внешней области Levels
access/assignmenttointermediate 906 используется из другой области Intermed.
statementafterRETURN/EXIT 909 излишний оператор по умолчанию
forloopvariableset 910 изменен, хотя явл. перем. цикла по умолчанию
evaluationsequenceofparams 913 вызов функции внутри выз. процедуры Side Effects
superfluoussemicolon 930 точка с запятой перед END, и т. п. Semicolons
Введение
В процессе разработки программы делается много итераций проектирования. Исходный текст вновь и вновь изменяется и расширяется, исправляются ошибки, операторы вывода вставляются и удаляются снова и снова. Программист изменяет тела процедур и при этом вставляет переменные, которые потом становятся больше не нужны. Для временных задач импортируются модули, которы позже никогда не используются.
Для очистки таких, постоянно изменяющихся, модулей был разработан DevAnalyzer. Это "обычный" компилятор Компонентного Паскаля, который выполняет полный синтаксический и семантический анализ с проверкой на ошибки, но не создаёт символьного файла или объектного кода. Вместо этого он иследует программу на наличие проблем в исходном коде. Анализ выполняется помодульно. Межмодульные зависимости в рассчёт не принимаются.
DevAnalyzer может быть использован как обычный компилятор Компонентного Паскаля для проверки синтаксической и семантической корректности программы (он даже использует при работе основные модули компилятора Компонентного Паскаля). В привёденных ниже фрагментах кода, Вы, например, можете убрать где-нибудь точку с запятой, и DevAnalyzer сообщит о появившейся ошибке.
Руководство
В последующиех разделах подробно рассказывается о различных предупреждениях, выдаваемых анализатором. В качестве демонстрации приводятся небольшие модули-примеры. Чтобы проверить работу анализатора достаточно щёлкнуть по внедрённому тексту с примером и выбрать AnalyzeЏModule из меню Info. Также можно использовать диалог AnalyzerЏOptions... Кнопка Analyze диалога равносильна пункту меню Info>AnalyzeModule; в обоих случаях выполняется анализ сфокусированного текста.
Определения
Обозначим за элемент программы (просто элемент для краткости) любую конструкцию Компонентного Паскаля, встречающуюся в последовательности описаний. Это, в частности: константы, типы, переменные, принимающие параметры, параметры, процедуры, и модули. Термины переменная, поле, и параметр используются в их обычном значении.
Предупреждения по умолчанию, выдаются всегда
Never Used
Элемент, который только описан в исходном коде и нигде не используется, помечается как "never used". Чаще всего такими элементами являются переменные в описаниях, которые скопированы из других описаний, или модули. Если элемент не является модулем, он может быть удалён.
Внимание: Некоторые модули в BlackBox Component Builder импортируются только ради выполнения их секций инициализации, и в коде не используются. Будьте внимательны, когда удаляете имена модулей из списка импорта. Типичные примеры - модули, устанавливающие новый фабричный объект в некоторый базовый модуль.
При анализе последующего примера, Вы увидите следующие элементы, помеченные "never used": StdLog, Size, поле y записи Rec, SameRec, Dont, и j в процедуре Dont.
MODULE NeverUsed;
IMPORT StdLog;
CONST N = 16; Size = 2*N;
TYPE
Rec = RECORD x, y: INTEGER END;
SameRec = Rec;
PROCEDURE Do;
VAR r: Rec;
BEGIN
r.x := N; r.x := 2*r.x
END Do;
PROCEDURE Dont;
VAR i, j, k: INTEGER;
BEGIN
k := 0;
FOR i := 0 TO N-1 DO k := k+i END
END Dont;
BEGIN Do
END NeverUsed.
Set But Never Used
Элемент, который инициализирован и далее не используется, помечается как "set but never used". Примерами таких элементов являются параметры процедуры, которые инициализированы по определению, но могут быть не использованы в теле процедуры, т. к. программист изменил её реализацию. Другие примеры - переменные, использование которых планировалось в цикле или незначащие переменные, которым присваиваются значения процедур-функций. Иногда эти элементы избыточны и могут быть удалены.
В следующем примере, поле y записи Rec, параметр k и переменная val процедуры Proc помечаются "set but never used".
MODULE SetButNeverUsed;
TYPE Rec = RECORD x, y: INTEGER END;
PROCEDURE Log2(u: INTEGER): INTEGER;
VAR i: INTEGER;
BEGIN
ASSERT(u > 0, 20);
i := 0;
WHILE u > 0 DO u := u DIV 2; INC(i) END;
RETURN i
END Log2;
PROCEDURE Proc(i, j, k: INTEGER);
VAR r: Rec; val: INTEGER;
BEGIN
r.x := i; r.y := j;
val := Log2(r.x)
END Proc;
BEGIN Proc(5, 5, 5)
END SetButNeverUsed.
Used Before Set
Переменные и поля записи, которые используются до присвоения им зачения, сигнализируют о возможных ошибках в программе и помечаются "used before set". Более того, помечается место первого использования таких переменных (за исключением записей и массивов). Не все предупреждения указывают на ошибки, однако: Переменная, которая задаётся в одной из веток оператора IF внутри цикла и используется до этого присваивания, помечается анализатором, хотя код может быть правильным.
В следующем примере, переменные r, i и k помечаются "used before set" (для i и k - их первое использование). В зависимости от начального значения j использование и инициализация k могут быть корректны. DevAnalyzer не в состоянии отслеживать эти зависимости, но помечает сомнительные части программы, чтобы программист более внимательно взглянул на них.
MODULE UsedBeforeSet;
TYPE Rec = RECORD x, y: INTEGER END;
PROCEDURE Proc;
VAR r: Rec; i, j, k: INTEGER;
BEGIN
r.x := r.y; j := i+1; r.y := i*r.x;
LOOP
IF j > 10 THEN i := 2*k; DEC(j)
ELSIF j > 5 THEN i := 3*k; DEC(j)
ELSIF j = 0 THEN k := 1
ELSE EXIT
END
END
END Proc;
BEGIN Proc
END UsedBeforeSet.
Never Set
Переменная или поле записи, которое никогда не оказывалось с левой стороны оператора присваивания, помечается как "never set". Это предупреждение о реальной ошибке в программе. Оно значит, что используется неопределённое (т.Џк. не было присваивания) значение переменной или поля записи.
В следующем примере, поле y записи Rec и переменная i процедуры Proc будут помечены "never set". К тому же, первое использование переменной i будет помечено "used before set".
MODULE NeverSet;
TYPE Rec = RECORD x, y: INTEGER END;
PROCEDURE Proc;
VAR r: Rec; i, j: INTEGER;
BEGIN
r.x := i; j := r.x+r.y; j := 2*j
END Proc;
BEGIN Proc
END NeverSet.
For Loop Variable Set
Значение управляющей переменной цикла FOR не должно изменяться другими операторами. Если управляющая переменая изменяется или передаётся в качестве VAR-параметра процедуры (что означает возможное изменения значения параметра), выдаётся предупреждение "for loop variable set". Первый случай, как правило, говорит об ошибке в программе. Второй - требует внимательного изучения.
В следующем примере, локальная переменная i изменяется процедурой INC, а локальная переменная j передаётся в качестве VAR-параметра процедуры.
MODULE LoopVariables;
IMPORT StdLog;
PROCEDURE Init(VAR k: INTEGER);
BEGIN k := 0
END Init;
PROCEDURE Do;
VAR i, j: INTEGER;
BEGIN
FOR i := 0 TO 9 DO StdLog.Int(i); INC(i) END;
StdLog.Ln;
FOR j := 0 TO 9 DO Init(j) END
END Do;
BEGIN Do
END LoopVariables.
Statement After RETURN/EXIT
Операторы, идущие за EXIT или RETURN, никогда не выполнятся, и, поэтому, могут быть удалены. Это явная ошибка, но и она может быть не замечена при больших объёмах изменений после многочисленных итераций проектирования. Избыточные операторы помечаются "statement after RETURN/EXIT".
В следующем примере, операторы x := 0 в процедуре Sgn и i := i DIV 2 в Do излишни.
MODULE ReturnExit;
PROCEDURE Sgn(x: INTEGER): INTEGER;
BEGIN
IF x < 0 THEN RETURN -1; x := 0 ELSIF x = 0 THEN RETURN 0 ELSE RETURN 1 END
END Sgn;
PROCEDURE Do;
VAR i: INTEGER;
BEGIN
i := 15;
LOOP
IF Sgn(i) = -1 THEN EXIT; i := i DIV 2
ELSIF ODD(i) THEN i := 3*i+1
ELSE i := 2*i; EXIT
END
END
END Do;
BEGIN Do
END ReturnExit.
Выборочные предупреждения, диалог AnalyzeЏOptions...
Последующие предупреждения выдаются, если соответствующий переключатель в диалоге AnalyzeЏOptions... включён. Кнопки диалога позволяют сохранить (Save Options) и загрузить (Load Options) настройки, а также сбросить их к значениям по-умолчанию (Reset Options). При запуске DevAnalyzer использует последние сохранённые настройке.
Дополнительно в диалоге показывается количество операторов в модуле, которое считает DevAnalyzer. Это очень хорошая мера сложности модуля, т.Џк. она не зависит от стиля оформления. Один оператор - одна из возможных альтернатив продукции "оператор" [Statement] грамматики Компонентного Паскаля (см. сообщение о языке).
Used as Varpar, Possibly Not Set (переключатель VAR Parameter)
Элемент, который до инициализации передан в качестве фактического VAR-параметра процедуре, может оказаться вообще не инициализирован. Т.Џе., ничто вне процедуры не может гарантировать, что внутри процедуры элемент получит осмысленное значение до его использования. Поскольку подробный анализ (внутри процедуры) не выполняется, предупреждение не всегда говорит об ошибке и выдаётся только когда включён переключатель VAR parameter диалога AnalyzeЏOptions... Текст предупреждения - "used as varpar, possibly not set".
В следующем примере, j помечается "used as varpar, possibly not set", в то время как i, получающая в Do начальное значение, - нет.
MODULE VarPar;
PROCEDURE Varpars(VAR i: INTEGER; VAR j: INTEGER; k: INTEGER);
BEGIN
i := 5; j := 6; k := 7*k
END Varpars;
PROCEDURE Do;
VAR i, j, k: INTEGER;
BEGIN
i := 1; k := 2;
Varpars(i, j, k)
END Do;
BEGIN Do
END VarPar.
Анализ экспортированных и промежуточных элементов (переключатели Exported Items и Levels)
Экспортированные элементы исключаются из анализа (предупреждения "used before set", "never used" и т.Џд.). Если их нужно подвергнуть рассмотрению, включите переключатель Exported items.
Локальные элементы, описанные в другой области видимости также исключаются из анализа. Например, не возможно эффективно определить факт инициализации элемента в локальной процедуре. Включите переключатель Levels диалога AnalyzeЏOptions... чтобы анализ таких элементов выполнялся.
Если эти переключатели выключены, при анализе следующего примера предупреждения не будут выданы. Однако, при их включении, экспортированная процедура Do помечается как "never used", локальная переменная k как "never set", и её использование в Local как "used before set".
MODULE ExportLevel;
CONST Local = 5;
VAR i: LONGINT;
PROCEDURE Do*;
VAR i, j, k: INTEGER;
PROCEDURE Local(i: INTEGER);
BEGIN j := i+k
END Local;
BEGIN
j := 0;
FOR i := 0 TO 7 DO j := j+i END;
Local(j)
END Do;
BEGIN i := 0; i := i+Local
END ExportLevel.
Also Declared in Outer Scope, Access/Assignment to Intermediate (переключатель Intermediate Items)
Повторное использование имён элементов, описанных вне текущей области видимости, ведёт к замешательству при чтении кода, особенно по прошествии некоторого времени. При обнаружении, такие элементы помечаются как "also declared in outer scope".
Также, присвоения или использование элементов из другой области видимости может быть причиной ошибок, т.Џк. может быть воспринято, как изменение/использование глобального элемента. Поэтому, такие присваивания/использования помечаются как "access/assignment to intermediate".
Выдачу этих предупреждений определяет переключатель Intermediate items диалога AnalyzeЏOptions...
В следующем примере, локальная переменная i, локальная процедура Local, и параметр i процедуры Local помечаются как "also declared in outer scope". Присвоение j и использование k в Local помечаются как "access/assignment to intermediate".
MODULE Intermediates;
CONST Local = 5;
VAR i: LONGINT;
PROCEDURE Do;
VAR i, j, k: INTEGER;
PROCEDURE Local(i: INTEGER);
BEGIN j := i+k
END Local;
BEGIN
j := 0;
FOR i := 0 TO 7 DO j := j+i END;
Local(j)
END Do;
BEGIN i := 0; i := i+Local; Do
END Intermediates.
Evaluation Sequence of Params. (переключатель Side Effects)
Последовательность вычисления параметров при вызове процедуры в Компонентном Паскале не определена. Т.Џо. вызов функций с побочными эффектами (изменяющих глобальное состояние) в списке параметров проблематичен. Поэтому (и по другим причнам), следует избегать функций с побочными эффектами (как минимум - их вызовов в списке параметров).
Например, если фактическими параметрами выступают некая глобальная переменная и значение функции, побочный эффект которой заключается в изменении этой переменной, то итоговое значение фактических параметров сильно зависит от последовательности их вычисления. DevAnalyzer отмечает такой проблемный код пометкой "evaluation sequence of params".
Для выполнения этого анализа нужно включить переключатель Side Effects диалога AnalyzeЏOptions...
В примере функция F изменяет глобальную переменную x. Значение F и x формируют фактические параметры процедуры, печатающей их. Попробуйте выполнить этот код на разных машинных архитектурах или с использованием разных компиляторов Комонентного Паскаля и сравните результаты.
MODULE Evaluation;
IMPORT StdLog;
VAR x: INTEGER;
PROCEDURE F(): INTEGER;
BEGIN
INC(x); RETURN x
END F;
PROCEDURE Write(a, b: INTEGER);
BEGIN
StdLog.Int(a); StdLog.Int(b); StdLog.Ln
END Write;
BEGIN x := 5; Write(x, F())
END Evaluation.
Superfluous Semicolon (переключатель Semicolons)
Это предупреждение для программистов-эстетов (или просто придирчивых людей). В коде помечаются лишние точки с запятой - предшествующие END или другим терминальным лексемам, которые могут идти после нетерминала оператор [Statement]. Пометка - "superfluous semicolon".
Включите переключатель Semicolons диалога AnalyzeЏOptions....
Попробуйте и убедитесь лично.
MODULE Semicolons;
TYPE R = RECORD x: INTEGER; END;
PROCEDURE Do(i: INTEGER);
VAR j: INTEGER; r: R;
BEGIN
IF i < 0 THEN j := -1; ELSIF i = 0 THEN j := 0; ELSE j := 1; END;
REPEAT DEC(i); UNTIL i = 0;
CASE j OF
| -1: r.x := 17;
| 0: r.x := 3; r.x := 2*r.x;
ELSE i := 0
END;
END Do;
BEGIN Do(28);
END Semicolons.
Контактная информация
Вы можете связаться со мной напрямую или через Oberon microsystems. Если Вы обнаружите ошибки или захотите увидеть новые возможности в новой версии DevAnalyzer, дайте мне знать. Также, если пожелаете, сообщите о Вашем (позитивном или негативном) опыте использования данного продукта ([email protected]).
Stefan H.-M. Ludwig 24 марта 1998
| Dev/Docu/ru/Analyzer.odc |
DevBrowser
DEFINITION DevBrowser;
PROCEDURE ImportSymFile (f: Files.File; OUT s: Stores.Store);
PROCEDURE ShowInterface (opts: ARRAY OF CHAR);
PROCEDURE ImportCodeFile (f: Files.File; OUT s: Stores.Store);
PROCEDURE ShowCodeFile;
END DevBrowser.
Браузер показывает интерфейс модуля или элемента в модуле. Он извлекает необходимую информацию из символьных файлов модуля. Символьный файл содержит лишь минимальную информацию, он не содержит ни комментариев, ни информации о том, в каком порядке элементы модуля располагались в исходном тексте (они показываются в алфавитном порядке). Для записей браузер показывает лишь заново добавленные поля и процедуры (или процедуры, переопределенные с covariant function results - <возвращающие результат расширенного типа>). Вы можете проследовать по иерархии типов записей к базовому типу, применяя команду браузера к имени базового типа в объявлении записи. Браузер также может декодировать файл кода и показать важную информацию о нем. В частности, показываются импортируемые элементы (типы, процедуры, и т.п.), от которых данный модуль зависит (этот набор иногда называют "требуемый интерфейс", в противоположность "предоставляемому интерфейсу", то есть, экспортируемой функциональности модуля).
Все функции браузера доступны также в качестве импортера (-> Converters), который может быть установлен в Config.Setup следующим образом:
Windows:
Converters.Register("DevBrowser.ImportSymFile", "", "TextViews.View", "OSF", {});
Converters.Register("DevBrowser.ImportCodeFile", "", "TextViews.View", "OCF", {});
Mac OS:
Converters.Register("DevBrowser.ImportSymFile", "", "TextViews.View", "oSYM", {});
Converters.Register("DevBrowser.ImportCodeFile", "", "TextViews.View", "oOBJ", {});
Возможные меню:
MENU
"&Interface" "" "DevBrowser.ShowInterface('')" "TextCmds.SelectionGuard"
"&Flat Interface" "" "DevBrowser.ShowInterface('!')" "TextCmds.SelectionGuard"
"Import Interface" "" "DevBrowser.ShowCodeFile" "TextCmds.SelectionGuard"
END
PROCEDURE ImportSymFile (f: Files.File; OUT s: Stores.Store)
Эта процедура устанавливается при запуске BlackBox как импортер символьных файлов (-> Converters). Импортер преобразует символьный файл в текстовый вид.
PROCEDURE ShowInterface (opts: ARRAY OF CHAR)
Охрана: TextCmds.SelectionGuard
Если выделено имя модуля, эта команда покажет полное описание модуля. Если выбрано полное имя, будет показано определение только соответствующего элемента.
opts = "" в случае типов записей выводит только заново введенные расширения.
opts = "!" выводит для типов записей также элементы, унаследованные от базового типа ("плоский интерфейс").
opts = "+" показывает некоторую дополнительную низкоуровневую информацию, полезную для разработчиков компиляторов (не документировано).
opts = "/" форматирует вывод особым образом. Неофициально называется "опция Дейкстры".
opts = "&" показывает также ловушки в интерфейсе.
opts = "@" использует настройки из диалога настроек браузера.
opts = "c" показываются только элементы, которые можно использовать в клиентских модулях.
opts = "e" показываются только те элементы, которые могут быть расширены.
Несколько параметров могут сочетаться.
PROCEDURE ImportCodeFile (f: Files.File; OUT s: Stores.Store)
Эта процедура устанавливается при запуске BlackBox как импортер кодовых файлов (-> Converters). Импортер преобразует кодовый файл в текстовый вид.
PROCEDURE ShowCodeFile
Охрана: TextCmds.SelectionGuard
Если выделено имя модуля, эта команда покажет некоторую информацию о кодовом файле откомпилированного модуля. Если выбрано полное имя, будет показано определение только соответствующего элемента. | Dev/Docu/ru/Browser.odc |
DevCmds
DEFINITION DevCmds;
IMPORT Dialog;
PROCEDURE FlushResources;
PROCEDURE OpenModuleList;
PROCEDURE OpenFileList;
PROCEDURE RevalidateViewGuard (VAR par: Dialog.Par);
PROCEDURE RevalidateView;
PROCEDURE SetCancelButton;
PROCEDURE SetDefaultButton;
PROCEDURE ShowControlList;
END DevCmds.
Возможное меню:
MENU
"&Open Module List" "" "DevCmds.OpenModuleList" "TextCmds.SelectionGuard"
"Open &File List" "" "DevCmds.OpenFileList" "TextCmds.SelectionGuard"
"Flus&h Resources" "" "DevCmds.FlushResources" ""
"Re&validate View" "" "DevCmds.RevalidateView" "DevCmds.RevalidateViewGuard"
SEPARATOR
"&Control List" "" "DevCmds.ShowControlList" "StdCmds.ContainerGuard"
"Set &Default Button" "" "DevCmds.SetDefaultButton" "StdCmds.ContainerGuard"
"Set Canc&el Button" "" "DevCmds.SetCancelButton" "StdCmds.ContainerGuard"
END
PROCEDURE FlushResources
Сбрасывает стражи меню и ресурсы отображения строк. Эта команда необходима, когда элемент меню отключается из-за того, что его код не может быть выполнен, но когда код стал исполняемым (например, при перекомпиляции модуля и возможной выгрузки старой версии модуля). Это также необходимо, если тексты строковых ресурсов были изменены и сохранены, и следует получить эффект от изменений немедленно, а не тогда, когда BlackBox будет запущен в следующий раз.
PROCEDURE OpenModuleList
Охрана: TextCmds.SelectionGuard
Открывает модуль, имя которого выделена, например,
"FormModels FormViews".
PROCEDURE OpenFileList
Охрана: TextCmds.SelectionGuard
Открывает файлы, имена которых выделены. Имена должны использовать портируемый синтакисис имен путей, например,
"Form/Mod/Models Form/Mod/Views".
PROCEDURE RevalidateViewGuard (VAR par: Dialog.Par)
Охрана меню для RevalidateView.
PROCEDURE RevalidateView
Охрана: RevalidateViewGuard
Отображение может становиться некорректным после сбоя. В результате отображение затеняется и становится пассивным (так что тот же сбой не может произойти снова, таким образом предотвращается цепь ошибок). Однако иногда полезно восстановить отображение и продолжить работу с ним.
PROCEDURE SetCancelButton
Охрана: StdCmds.ContainerGuard
Делает выделенное отображение в фокусированном контейнере кнопкой "отмена", то есть, в режиме маски (см. Containers) оно становится нажатым, когда пользователь вводит символ escape.
PROCEDURE SetDefaultButton
Охрана: StdCmds.ContainerGuard
Делает выделенное отображение в фокусированном контейнере кнопкой "по умолчанию", то есть, в режиме маски (см. Containers) оно становится нажатым, когда пользователь вводит символ return.
PROCEDURE ShowControlList
Охрана: StdCmds.ContainerGuard
Создает список свойств всех отображений в фокусированном контейнере, который возвращает свойства элементов управления (см. Controls).
| Dev/Docu/ru/Cmds.odc |
DevComInterfaceGen
DEFINITION DevComInterfaceGen;
IMPORT Dialog;
VAR
dialog: RECORD
library: Dialog.List;
fileName: ARRAY 256 OF CHAR;
modName: ARRAY 64 OF CHAR
END;
PROCEDURE Browse;
PROCEDURE GenAutomationInterface;
PROCEDURE InitDialog;
PROCEDURE ListBoxNotifier (op, from, to: INTEGER);
PROCEDURE TextFieldNotifier (op, from, to: INTEGER);
... plus some private items ...
END DevComInterfaceGen.
Модуль DevComInterfaceGen предоставляет службы для автоматического создания модулей для COM-интерфейсов. Модули интерфейсов используются BlackBox для доступа к компонентам COM несколькими различными способами.
Один из них - это Автоматизация (Automation). Некоторое приложение (сервер), поддерживающее Автоматизацию, может управляться из другого приложения (диспетчер). Интерфейс приложения-сервера, то есть, объекты, предоставляемые приложением, и операции на этих объектах, описываются в библиотеке типов COM. Для написания диспетчера на BlackBox используется модуль интерфейса, который содержат объект Компонентного Паскаля для каждого объекта COM из библиотеки типов. Эти объекты могут быть доступны таким образом, как и другие объекты Компонентного Паскаля, с удобством и безопасностью типов. Они скрывают детали стандарта Автоматизации. Подсистема Ctl включает в себя такие модули интерфейсов Автоматизации. (В основном для серверов автоматизации MS Office.)
Модуль DevComInterfaceGen предоставляет службы для автоматического создания интерфейсов Автоматизации из соответствующих библиотек типов. В определенных ситуациях, однако, автоматически созданные модули интерфейсов не компилируется без ошибок. Тогда требуется немного ручной работы. Мы столкнулись с тремя видами сложностей, которые могут возникать:
1. Имена формального параметра совпадают с именем типа параметра. Решение: Измените имя формального параметра в списке параметров и теле процедуры.
2. Имя формального параметра совпадает с именем возвращаемого типа. Решение: Измените имя формального параметра в списке параметров и теле процедуры.
3. Имя константы совпадает с именем некоторого типа. Решение: Измените имя константы.
Возможное меню, использующее команды из этого модуля:
MENU "Automation"
"Generate Automation Interface" "" "DevComInterfaceGen.InitDialog; StdCmds.OpenToolDialog('Dev/Rsrc/ComInterfaceGen', 'Generate Automation Interface')" ""
END
VAR dialog: RECORD
Интерактор для диалога Generate Automation Interface.
library: Dialog.List
Список, представляющий все библиотеки типов, которые зарегистрированы в системной регистрационной базе данных.
fileName: ARRAY 256 OF CHAR
Полное имя пути для библиотеки типов.
modName: ARRAY 64 OF CHAR
Имя модуля интерфейса Автоматизации, который будет создан из соответствующей библиотеки типов.
PROCEDURE Browse
Открывает стандартный диалог открытия файла, позволяющий пользователю выбрать библиотеку типов или файл DLL.
PROCEDURE GenAutomationInterface
Создает модуль интерфейса, соответствующий параметрам в dialog.
PROCEDURE InitDialog
Вызывайте эту команду перед открытием диалога Genetate Automation Interface. Она инициализирует интерактор dialog.
PROCEDURE ListBoxNotifier (op, from, to: INTEGER)
PROCEDURE TextFieldNotifier (op, from, to: INTEGER)
Обработчики, которые используются диалогом Generate Automation Dialog.
| Dev/Docu/ru/ComInterfaceGen.odc |
DevCommanders
DEFINITION DevCommanders;
TYPE
Par = POINTER TO RECORD
text: TextModels.Model;
beg, end: INTEGER
END;
VAR
par: Par;
PROCEDURE Deposit;
PROCEDURE DepositEnd;
... plus some private items ...
END DevCommanders.
Коммандер представляет собой отображение, которое может интерпретировать и выполнять команду или последовательность команд, записанных после коммандера. Он работает только, когда внедрен в текст.
Коммандеры могут быть полезны при разработке; например, они могут внедряться прямо в исходный текст программы. Они не предназначены для использования конечными пользователями, из-за своего непривычного интерфейса.
Команды меню:
"Insert Commander" "" "DevCommanders.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Insert EndCommander" "" "DevCommanders.DepositEnd; StdCmds.PasteView" "StdCmds.PasteViewGuard"
TYPE Par
Контекстные параметры выполнения команды. Используется в командах типа
DevCompiler.CompileThis ObxViews1 ObxViews2
text: TextModels.Model
Текст, содержащий активируемый коммандер и команду.
beg: INTEGER
Начало параметров команды, то есть, позиция в тексте сразу за последним символом собственно команды.
end: INTEGER
Конец параметров команды. Это либо конец текста, либо позиция следующего командера, или EndView в тексте.
VAR par-: Par par # NIL точно в течение текущей выполняемой команды
Через эту переменную команда во время выполнения может получить доступ к тексту, и следовательно, к своему контексту.
PROCEDURE Deposit
Команда размещения в буфер обмена для коммандеров.
PROCEDURE DepositEnd
Команда размещения в буфер обмена для DevCommanders.EndView .Помечает конец команды для предыдущего коммандера. Если конечного отображения нет, то коммандер считывает до следующего коммандера или до конца текста.
Модуль включает в себя несколько других элементов, которые используются внутри.
| Dev/Docu/ru/Commanders.odc |
DevCompiler
DEFINITION DevCompiler;
PROCEDURE Compile;
PROCEDURE CompileAndUnload;
PROCEDURE CompileModuleList;
PROCEDURE CompileSelection;
PROCEDURE CompileThis;
... плюс некоторые закрытые команды ...
END DevCompiler.
Пакет команд для компилятора Компонентного Паскаля. Компилятор не имеет опций компиляции. Критичные для безопасности проверки времени выполнения проводятся всегда (охрана типов, проверки границ массивов, и т.п.), в то время как не критичные проверки не могут генерироваться вообще (SHORT, переполнение целых, проверка вхождения во множества). "Критичные" означает, что может быть повреждена нелокальная память, с неизвестными глобальными эффектами.
Типичное меню:
MENU
"&Компилировать" "" "DevCompiler.Compile" "TextCmds.FocusGuard"
"Компилировать и выгрузить" "" "DevCompiler.CompileAndUnload" "TextCmds.FocusGuard"
"Компилировать выделенное" "" "DevCompiler.CompileSelection" "TextCmds.SelectionGuard"
"Компилировать список модулей" "" "DevCompiler.CompileModuleList" "TextCmds.SelectionGuard"
END
PROCEDURE Compile
Охрана: TextCmds.FocusGuard
Компилирует модуль Компонентного Паскаля, исходный текст которого находится в фокусированном отображении.
PROCEDURE CompileAndUnload
Охрана: TextCmds.FocusGuard
Компилирует модуль, исходный текст которого находится в фокусированном отображении. Если компиляция проходит успешно, то старая версия этого модуля выгружается. CompileAndUnload полезна при разработке модулей верхнего уровня, то есть таких, которые не импортируются другими модулями и поэтому могут быть отдельно выгружены.
PROCEDURE CompileModuleList
Охрана: TextCmds.SelectionGuard
Компилирует список модулей, имена которых выделены. Когда обнаруживается первая ошибка, содержащий ее исходный код открывается, показывая ошибку.
PROCEDURE CompileSelection
Охрана: TextCmds.SelectionGuard
Компилирует модуль, начало которого выделено.
PROCEDURE CompileThis
Используется в тексте с DevCommanders.View. Эта команда берет текст, следующий за ним, и интерпретирует его как список модулей, которые следует откомпилировать. Похожа на CompileModuleList за исключением того, что не нужно выделение.
... плюс некоторые закрытые команды ...
| Dev/Docu/ru/Compiler.odc |
DevDebug
ENGLISH
DEFINITION DevDebug;
IMPORT Views, Kernel;
PROCEDURE Execute;
PROCEDURE ShowGlobalVariables;
PROCEDURE ShowLoadedModules;
PROCEDURE ShowViewState;
PROCEDURE Unload;
PROCEDURE UnloadModuleList;
PROCEDURE UnloadThis;
PROCEDURE HeapRefView (adr: INTEGER; name: ARRAY OF CHAR): Views.View;
PROCEDURE ShowHeapObject (adr: INTEGER; title: ARRAY OF CHAR);
PROCEDURE SourcePos (mod: Kernel.Module; codePos: INTEGER): INTEGER;
PROCEDURE UpdateGlobals (name: ARRAY OF CHAR);
PROCEDURE UpdateModules;
END DevDebug.
Когда происходит ошибка времени выполнения, например, деление на нуль, открывается "текст ловушки", который показывает цепочку вызовов процедур. Этот текст можно использовать для навигации по структурам данных. Некоторые другие команды полезны для анализа состояния системы.
Заметим, что отладка происходит полностью через BlackBox, нет никакой отдельной отладочной среды. Отладка происходит "посмертно" относительно команд, то есть, команда, вызвавшая ошибку, прерывается, и затем отлаживается. Однако, обычно ошибка времени выполнения не затрагивает ни загруженных модулей, ни структур данных, привязанных к ним, ни открытых документов. Другими словами, отладка происходит "во время выполнения", по отношению к приложению в целом.
Возможные меню:
MENU
"&Loaded Modules" "" "DevDebug.ShowLoadedModules" ""
"&Global Variables" "" "DevDebug.ShowGlobalVariables" "TextCmds.SelectionGuard"
"&View State" "" "DevDebug.ShowViewState" "StdCmds.SingletonGuard"
"E&xecute" "" "DevDebug.Execute" "TextCmds.SelectionGuard"
"&Unload" "" "DevDebug.Unload" "TextCmds.FocusGuard"
"Unloa&d Module List" "" "DevDebug.UnloadModuleList" "TextCmds.SelectionGuard"
END
PROCEDURE Execute
Охрана: TextCmds.SelectionGuard
Выполняет строку (между кавычками), которая должна иметь форму последовательности команд Компонентного Паскаля, например, "Dialog.Beep; Dialog.Beep". Для простых команд кавычки могут быть опущены, например, Dialog.Beep (-> StdInterpreter).
PROCEDURE ShowGlobalVariables
Охрана: TextCmds.SelectionGuard
Показывает глобальные переменные модуля, имя которого выделено.
PROCEDURE ShowLoadedModules
Показывает список загруженных модулей. Эта команда может быть полезна для модулей, которые следует скомпоновать вместе при построении приложения.
PROCEDURE ShowViewState
Охрана: TextCmds.FocusGuard
Показывает состояние текущего фокусированного отображения.
PROCEDURE Unload
Охрана: TextCmds.FocusGuard
Пытается выгрузить модуль, исходник которого находится в фокусе. Выгрузка срывается, если модуль еще не загружен, или он не является верхним модулем (от которого не зависят другие).
PROCEDURE UnloadModuleList
Охрана: TextCmds.SelectionGuard
Пытается выгрузить список модулей, имена которых выделены. Выгрузка может сорваться полностью или частично, если один из указанных модулей еще не загружен, или импортирован хотя бы одним клиентским модулем. Модули следует выгружать сверху вниз.
PROCEDURE UnloadThis
Используется в текстах с коммандером DevCommanders.View. Эта команда берет текст, следующий за коммандером, и трактует его как список выгружаемых модулей. Подобна UnloadModuleList за исключением того, что не требует выделять список модулей.
PROCEDURE HeapRefView (adr: INTEGER; name: ARRAY OF CHAR): Views.View
PROCEDURE ShowHeapObject (adr: INTEGER; title: ARRAY OF CHAR)
PROCEDURE SourcePos (mod: Kernel.Module; codePos: INTEGER): INTEGER
PROCEDURE UpdateGlobals (name: ARRAY OF CHAR)
PROCEDURE UpdateModules
Эти процедуры используются внутренне.
| Dev/Docu/ru/Debug.odc |
DevDependencies
DEFINITION DevDependencies;
IMPORT Dialog;
PROCEDURE ArrangeClick;
PROCEDURE CollapseAllClick;
PROCEDURE CollapseClick;
PROCEDURE CreateTool;
PROCEDURE CreateToolClick;
PROCEDURE Deposit;
PROCEDURE ExpandAllClick;
PROCEDURE ExpandClick;
PROCEDURE HideClick;
PROCEDURE ModsGuard (VAR par: Dialog.Par);
PROCEDURE NewAnalysisClick;
PROCEDURE SelGuard (VAR par: Dialog.Par);
PROCEDURE ShowAllClick;
PROCEDURE ShowBasicGuard (VAR par: Dialog.Par);
PROCEDURE SubsGuard (VAR par: Dialog.Par);
PROCEDURE ToggleBasicSystemsClick;
END DevDependencies.
Этот инструмент анализирует кодовые файлы заданного списка модулей. Зависимости от данных модулей к другим модулям показываются в виде графа. По умолчанию показываются все выделенные модули, а все другие модули показываются как подсистемы. По щелчку правой кнопкой мыши открывается контекстное меню. Это меню содержит несколько команд, манипулирующих графом.
Подсистема может быть развернута двойным щелчком на ней. Таким же образом все модули, принадлежащие к определенной подсистеме, могут быть свернуты в подистему - двойным щелчком на имени любого модуля.
Щелчком на вершине графа эта вершина становится выделенной. Можно выделить более одной вершины, щелкая с Ctrl на других вершинах, или "рисуя" прямоугольник выделения вокруг нескольких вершин. После выделения вершины можно передвинуть мышью или стрелками на клавиатуре. Можно использовать Ctrl-A для выделения всех вершин.
Чтобы избежать беспорядка на графе, по умолчанию базовые подсистемы BlackBox скрываются. Однако можно включить этот параметр и показать системные модули.
В системе имеются неявные зависимости (например, через Dialog.Call). Эти зависимости нельзя найти, используя кодовые файлы. Чтобы учесть эти зависимости, хотя бы в статическом виде, они могут быть заданы в файле строковых ресурсов подсистемы Dev. Синтаксис для задания неявных зависимостей следующий:
Implicit.<modName> <modname>{, <modname>}
DevDependencies читает этот ресурс и добавляет зависимости в граф. Такие зависимости показываются серыми стрелками.
Можно также создать инструментальный документ командой CreateTool. Она создает документ, который содержит команды компиляции, выгрузки, компоновки и упаковки для заданных модулей. Команды компиляции и выгрузки создаются только для тех подсистем, которые развернуты на графе. Команда компоновки включает стандартные значки BlackBox, а команда упаковки всегда включает все модули, независимо от того, развернуты они или скрыты.
В созданном документе все модули, которые включаются только через неявные зависимости, прописываются серым цветом.
В конце инструментального документа выводится список всех корневых модулей. Это модули, которые не импортируются из других модулей, то есть, модули верхнего уровня.
Обычное меню:
MENU
"&Dependencies" "" "DevDependencies.Deposit;StdCmds.Open" "TextCmds.SelectionGuard"
"&Create Tool" "" "DevDependencies.CreateTool" "TextCmds.SelectionGuard"
END
При щелчке правой кнопкой мыши показывается контекстное меню. Обычно оно имеет следующие пункты:
MENU "*" ("DevDependencies.View")
"Expand" "" "DevDependencies.ExpandClick" "DevDependencies.SubsGuard"
"Collapse" "" "DevDependencies.CollapseClick" "DevDependencies.ModsGuard"
"New Analysis" "" "DevDependencies.NewAnalysisClick" "DevDependencies.ModsGuard"
"Hide" "" "DevDependencies.HideClick" "DevDependencies.SelGuard"
SEPARATOR
"Show All Items" "" "DevDependencies.ShowAllClick" ""
"Show Basic System" "" "DevDependencies.ToggleBasicSystemsClick" "DevDependencies.ShowBasicGuard"
"Expand All" "" "DevDependencies.ExpandAllClick" ""
"Collapse All" "" "DevDependencies.CollapseAllClick" ""
"Arrange Items" "" "DevDependencies.ArrangeClick" ""
SEPARATOR
"Create tool..." "" "DevDependencies.CreateToolClick" ""
SEPARATOR
"P&roperties..." "" "StdCmds.ShowProp" "StdCmds.ShowPropGuard"
END
Пункт Properties открывает стандартный шрифтовой диалог и позволяет пользователю выбрать шрифт для отображения. Начертание и стиль выбранного шрифта влияет на текст, показывающий имена модулей. Размер шрифта влияет на текст и ширину линий и стрелок.
PROCEDURE Deposit
Анализирует зависимости для каждого модуля в выделенном списке модулей. Затем создается и размещается в буфере обмена отображение, показывающее граф зависимостей.
PROCEDURE CreateTool
Анализирует зависимости для каждого модуля в выделенном списке модулей. Затем для данных модулей создается инструментальный документ. Документ содержит команды компиляции, выгрузки, компоновки и упаковки для заданных модулей. Команды компиляции и выгрузки создаются только для тех подсистем, которые развернуты на графе. Команда компоновки включает стандартные значки BlackBox, а команда упаковки всегда включает все модули, независимо от того, развернуты они или скрыты.
Следующие команды используются только для манипуляции отображением (обычно они вызываются через меню, описанное выше):
PROCEDURE CollapseClick
Вызывается, когда в меню выбирается Collapse. Эта процедура сворачивает выделенные модули в графе.
PROCEDURE ExpandClick
Вызывается, когда в меню выбирается Expand. Эта процедура разворачивает выделенные подсистемы в графе.
PROCEDURE NewAnalysisClick
Вызывается, когда в меню выбирается New Analysis. Начинает новый анализ, принимая за корень выделенную вершину, то есть, создает подграф исходного графа.
PROCEDURE HideClick
Вызывается, когда в меню выбирается Hide. Процедура скрывает выделенные вершины в графе.
PROCEDURE ShowAllClick
Вызывается, когда в меню выбирается Show All items. Эта процедура гарантирует, что в се вершины графа видимы.
PROCEDURE ToggleBasicSystemsClick
Вызывается, когда в меню выбирается Show Basic System. Эта процедура показывает или скрывает модули, принадлежащие к базовой системе BlackBox.
PROCEDURE ExpandAllClick
Вызывается, когда в меню выбирается Expand All. Эта процедура раскрывает все подсистемы.
PROCEDURE CollapseAllClick
Вызывается, когда в меню выбирается Collapse All. Эта процедура сворачивает все модули в подсистемы.
PROCEDURE ArrangeClick
Вызывается, когда в меню выбирается Arrange Items. Эта процедура упорядочивает вершины в графе структурированным образом, помещая модули из исходного списка наверх.
PROCEDURE CreateToolClick
Вызывается, когда в меню выбирается Create tool. Вызывает CreateTool.
PROCEDURE SelGuard (VAR par: Dialog.Par)
Охрана, проверяющая, что в графе есть выделенные вершины.
PROCEDURE ModsGuard (VAR par: Dialog.Par)
Охрана, которая проверяет, что в графе есть выделенные модули.
PROCEDURE SubsGuard (VAR par: Dialog.Par)
Охрана, которая проверяет, что в графе есть выделенные подсистемы.
PROCEDURE ShowBasicGuard (VAR par: Dialog.Par)
Охрана для пункта меню Show Basic System. | Dev/Docu/ru/Dependencies.odc |
DevHeapSpy
Редактирование: Ф.В.Ткачев, 2009
DEFINITION DevHeapSpy;
VAR
par-: RECORD
allocated-, clusters-, heapsize-: INTEGER
END;
PROCEDURE GetAnchor (adr: INTEGER; OUT anchor: ARRAY OF CHAR);
PROCEDURE ShowAnchor (adr: INTEGER);
PROCEDURE ShowHeap;
END DevHeapSpy.
DevHeapSpy инструмент, который наглядно показывает содержимое динамической памяти (кучи). Динамически размещаемые блоки памяти показываются в виде "интерактивной карты памяти", которая периодически обновляется. DevHeapSpy показывает символическую информацию о каждом блоке памяти, который вы указываете мышью. Он позволяет проверять значения полей записей в объектах и просматривать сложные структуры данных.
Куча Блэкбокса делится на кластеры. Кластеры - это непрерывные блоки памяти. Каждый кластер содержит несколько объектов кучи. DevHeapSpy показывает кластеры как длинные серые блоки. Динамически размещенные объекты показываются в кластерах красными и синими областями. Красные области соответствуют фрагментам памяти, отведенным под переменные некоторого типа записей. Синие отведенным под динамические массивы.
Чтобы увидеть информацию по куче, выполните команду HeapSpy... из меню Info. Откроется маленькое диалоговое окно, показывающее суммарную информацию о куче.
Чтобы открыть окно DevHeapSpy, нажмите кнопку Show Heap в этом диалоговом окне. Откроется окно с картой динамической памяти. Когда вы нажмете левую кнопку мыши над областью кластера, DevHeapSpy даст информацию об объекте, на который указывала мышь. Если мышь указывает на динамически размещенный объект, то есть на красную или синию область, объект подсвечивается. При отпускании кнопки мыши открывается окно отладчика, которое показывает детальную символьную информацию об объекте.
В меню можно использовать следующую команду:
"Heap Spy..." "" "StdCmds.OpenAuxDialog('Dev/Rsrc/HeapSpy', 'Heap Spy')" ""
VAR par-: RECORD
Интерактор для диалога.
allocated-: INTEGER
Объем памяти, занятой размещенными на куче объектами (в байтах).
clusters-: INTEGER
Количество размещенных кластеров.
heapsize-: INTEGER
Полный объем кучи в байтах (количество кластеров, умноженное на размер одного кластера).
PROCEDURE GetAnchor (adr: INTEGER; OUT anchor: ARRAY OF CHAR)
PROCEDURE ShowAnchor (adr: INTEGER)
PROCEDURE ShowHeap
Разлчиные процедуры, используемые в диалоге.
| Dev/Docu/ru/HeapSpy.odc |
DevInspector
DEFINITION DevInspector;
IMPORT Dialog;
VAR
inspect: RECORD
control-: Dialog.String;
label: ARRAY 40 OF CHAR;
link, guard, notifier: Dialog.String;
level: INTEGER;
opt0, opt1, opt2, opt3, opt4: BOOLEAN
END;
PROCEDURE GetNext;
PROCEDURE Set;
PROCEDURE InitDialog;
PROCEDURE ControlGuard (VAR par: Dialog.Par);
PROCEDURE GuardGuard (VAR par: Dialog.Par);
PROCEDURE LabelGuard (VAR par: Dialog.Par);
PROCEDURE LevelGuard (VAR par: Dialog.Par);
PROCEDURE LinkGuard (VAR par: Dialog.Par);
PROCEDURE OptGuard (opt: INTEGER; VAR par: Dialog.Par);
PROCEDURE NotifierGuard (VAR par: Dialog.Par);
PROCEDURE Notifier (idx, op, from, to: INTEGER);
END DevInspector.
Инспектор позволяет просматривать и изменять свойства элементов управления. В настоящий момент поддерживаются различные типы элементов управления: командные кнопки, флажки, переключатели, поля ввода, поля даты, поля времени, инкрементные поля, списки, списки выбора, выпадающие списки и группы.
Инспектор открывается командой Edit->Object Properties... (Windows) / Edit->PartInfo (MacOS). Она принимает на входе монолитно выделенный элемент управления (-> Controls). Запуск инспектора можно сделать напрямую в среде, командой StdCmds.ShowProp.
VAR inspect: RECORD
Интерактор для диалога свойств.
control-: Dialog.String
Имя элемента управления. Это (возможно, проецированное) имя типа элемента.
label: ARRAY 40 OF CHAR
Текстовая метка элемента управления.
link: Dialog.String
Связь с полем интерактора, в форме module.variable.field.
guard: Dialog.String
Имя команды охраны для элемента управления.
notifier: Dialog.String
Имя команды уведомления для элемента управления.
level: INTEGER
Только если значение переключателя равно level, он "включен".
opt0, opt1, opt2, opt3, opt3: BOOLEAN
Различные свойства, которые зависят от текущего выделенного элемента управления. Например, командная кнопка использует opt0 и opt1 для показа свойств "default" и "cancel".
PROCEDURE GetNext
Показывает следующий элемент управления в этом контейнере. После последнего элемента GetNext возвращается по кругу к первому.
PROCEDURE Set
Set the control's properties to the currently displayed values.
Устанавливает свойствам элемента управления текущие показываемые значения.
PROCEDURE InitDialog
Устанавливает интерактор в соответствие с текущим выделенным элементом управления.
PROCEDURE ControlGuard (VAR par: Dialog.Par)
PROCEDURE GuardGuard (VAR par: Dialog.Par)
PROCEDURE LabelGuard (VAR par: Dialog.Par)
PROCEDURE LevelGuard (VAR par: Dialog.Par)
PROCEDURE LinkGuard (VAR par: Dialog.Par)
PROCEDURE OptGuard (opt: INTEGER; VAR par: Dialog.Par)
PROCEDURE NotifierGuard (VAR par: Dialog.Par)
PROCEDURE Notifier (idx, op, from, to: INTEGER)
Различные стражи и уведомители, используемые диалогом инспектора.
| Dev/Docu/ru/Inspector.odc |
DevLinkChk
DEFINITION DevLinkChk;
IMPORT Dialog;
CONST oneSubsystem = 0; globalSubsystem = 1; allSubsystems = 2;
VAR
par: RECORD
scope: INTEGER;
subsystem: ARRAY 9 OF CHAR
END;
PROCEDURE Check (subsystem: ARRAY OF CHAR; scope: INTEGER; check: BOOLEAN);
PROCEDURE CheckLinks;
PROCEDURE ListLinks;
PROCEDURE Open (path, file: ARRAY OF CHAR; pos: INTEGER);
PROCEDURE SubsystemGuard (VAR p: Dialog.Par);
PROCEDURE CommandGuard (VAR p: Dialog.Par);
PROCEDURE SubsystemNotifier (op, from, to: INTEGER);
END DevLinkChk.
Этот инструментальный модуль позволяет проверять, указывает ли гиперссылка (-> StdLinks) на существующий документ BlackBox. Это позволяет найти большинство "висячих" ссылок, то есть, ссылок на несуществующие файлы.
Команда меню:
"Check Links..." "" "StdCmds.OpenAuxDialog('Dev/Rsrc/LinkChk', 'Check Links')" ""
CONST oneSubsystem , globalSubsystem, allSubsystems
Проверка может вестись в одной конкретной подсистеме (точнее, в файлах, находящихся в директориях Docu и Mod); в глобальных директориях Docu и Mod, или в этих директориях и директориях Docu и Mod всех подсистем.
VAR par: RECORD
Интерактор для CheckLinks и ListLinks. Определяется, с какими документами будут работать эти команды.
scope: INTEGER scope IN {oneSubsystem, globalSubsyste, allSubsystems}
Область, в которой ведется проверка, то есть, директория или директории, в поддиректориях Docu и Mod которых будут просматриваться файлы со ссылками.
subsystem: ARRAY 9 OF CHAR valid iff scope = oneSubsystem
Имя подсистемы. Допустимо, только если scope = oneSubsystem.
PROCEDURE Check (subsystem: ARRAY OF CHAR; scope: INTEGER; check: BOOLEAN)
Для внутреннего использования.
PROCEDURE CheckLinks
Охрана: CommandGuard
Проверяет все ссылки в области, заданной интерактором par. Проверка означает, что проверяется существование целевых файлов для следующих команд:
StdCmds.OpenMask
StdCmds.OpenBrowser
StdCmds.OpenDoc
StdCmds.OpenAuxDialog
"Висячие" ссылки будут перечислены в тексте отчета. Для каждой висячей ссылки отчет содержит одну ссылку, которая напрямую открывает виновный текст и прокручивает его к проблемной ссылке (используя команду Open).
PROCEDURE ListLinks
Охрана: CommandGuard
Перечисляет все ссылки в области, заданной интерактором par. Ссылки перечисляются в тексте отчета. Для каждой ссылки отчет влючает в себя ссылку, которая открывает содержащий ее текст и прокручивает его к этой ссылке (используя команду Open).
PROCEDURE Open (path, file: ARRAY OF CHAR; pos: INTEGER)
Для внутреннего использования. Процедура открывает файл в расположении path с именем file; прокручивает его до позиции pos; и выделяет промежуток [pos...pos+1].
PROCEDURE SubsystemGuard (VAR p: Dialog.Par)
PROCEDURE CommandGuard (VAR p: Dialog.Par)
PROCEDURE SubsystemNotifier (op, from, to: INTEGER)
Различные стражи и уведомители, используемые для диалога Dev/Rsrc/LinkChk.
| Dev/Docu/ru/LinkChk.odc |
DevLinker
DevLinker - это компоновщик BlackBox. Он используется для упаковки вместе нескольких файлов BlackBox в один исполняемый файл (.dll или .exe). Это может быть использовано для создания независимых версий приложений, основанных на BlackBox Component Framework. Также это можно использовать для создания исполняемых файлов, написанных на Компонентном Паскале, которые не относятся к среде BlackBox или используют только несколько модулей BlackBox, подобных Kernel.
Компоновщик может быть запущен одной из команд, описанных ниже. Каждая из команд нуждается в текстовых параметрах с синтаксисом:
<destFile> := {<module> {option}} {idNumber <resourceFile>}.
destFile - это имя исполняемого файла, который будет создан.
module - это модуль Компонентного Паскаля, кодовый файл загружается из соответствующей директории.
option - это один из следующих символов:
$ главный модуль: тело этого модуля вызывается при запуске программы.
+ идентифицирует ядро. Ядро должно быть представлено, если в каком-либо из модулей используется стандартная функция NEW. Ядро должно экспортировать процедуры NewRec и NewArr.
# модуль интерфейса: экспортируемые процедуры этого модуля будут добавлены в список экспорта.
См. описания отдельных команд, где приведены списки допустимых настроек.
resourceFile - это имя файла ресурсов. В настоящий момент поддерживаются значки (.ico), курсоры (.cur), растры (.bmp), файлы ресурсов Windows (.res) и библиотеки типов (.tlb). Файлы ресурсов загружаются из директорий Rsrc или Win/Rsrc.
idNumber - это целое число, используемое при обращении к ресурсу из программы.
Список модулей должен быть отсортирован так, чтобы импортируемый модуль в тексте предшествовал модулю, его импортирующему. Это правило также применимо к подразумеваемому импорту ядра при использовании NEW.
DevLinker.Link
Компонует набор модулей, содержащий динамический загрузчик модулей, в exe-файл.
При запуске вызывается тело главного модуля.
Инициализация и прерывание всех остальных модулей не выполняется загрузчиком, это должно быть сделано подсистемой времени выполнения (обычно динамическим загрузчиком).
Сам BlackBox компонуется этой командой.
Допустимые настройки: $ +
DevLinker.LinkExe
Компонует нерасширяемый набор модулей в exe-файл (то есть, загрузчик не включается).
При запуске тела всех модулей вызываются в правильном порядке.
Когда последнее тело завершается, окончания (секции CLOSE) всех модулей вызываются в обратном порядке.
Никакой подсистемы времени выполнения не требуется для инициализации и завершения.
Допустимые настройки: +
DevLinker.LinkDll
Компонует нерасширяемый набор модулей в dll-файл.
Когда dll подключается к процессу, тела всех модулей вызываются в правильном порядке.
Когда dll освобождается процессом, окончания (секции CLOSE) всех модулей вызываются в обратном порядке.
Никакой подсистемы времени выполнения не требуется для инициализации и завершения.
Допустимые настройки: + #
DevLinker.LinkDynDll
(редко используется, представлено для полноты)
Компонует набор модулей, включающий динамический загрузчик модулей, в dll-файл.
Когда dll подключается к процессу, вызывается тело главного модуля.
Когда dll освобождается процессом, вызывается окончание (секция CLOSE) главного модуля.
Инициализация и прерывание всех остальных модулей должны выполняться подсистемой времени выполнения.
Допустимые настройки: $ + #
Причина различных команд для статических и динамических систем заключается в том, что отсутсвует статически определенная последовательность инициализации в системах, которые содержат динамический загрузчик. В BlackBox Kernel (который является самым низким модулем в иерархии) определен как главный модуль. Тело ядра затем динамически вызывает тела всех связанных модулей в правильном порядке. Если в телах модулей нет вызовов к динамическому загрузчику (через Dialog.Call), модули инициализируются в том порядке, в каком они присутсвуют в тексте параметров.
Примеры
Стандартный BlackBox:
DevLinker.Link
BlackBox.exe := Kernel$+ Files HostFiles StdLoader
1 Applogo.ico 2 Doclogo.ico 3 SFLogo.ico 4 CFLogo.ico 5 DtyLogo.ico
1 Move.cur 2 Copy.cur 3 Link.cur 4 Pick.cur 5 Stop.cur 6 Hand.cur 7 Table.cur
Полностью скомпонованная часть BlackBox, доступная для распространения:
DevLinker.Link MyBlackBox.exe :=
Kernel$+ Files HostFiles StdLoader Math Strings Dates Meta Dialog Services
Fonts Ports Stores Log Converters Sequencers Models Printers Views
Controllers Properties Printing Mechanisms Containers
Documents Windows StdCFrames Controls StdDialog StdApi StdCmds StdInterpreter
HostRegistry HostFonts HostPorts OleData HostMechanisms HostWindows
HostPrinters HostClipboard HostCFrames HostDialog HostCmds
HostMenus HostPictures TextModels TextRulers TextSetters TextViews
TextControllers TextMappers StdLog TextCmds
FormModels FormViews FormControllers FormGen FormCmds
StdFolds StdLinks StdDebug HostTextConv HostMail
StdMenuTool StdClocks StdStamps StdLogos StdCoder StdScrollers
OleStorage OleServer OleClient StdETHConv In Out XYplane Init
1 applogo.Ico 2 doclogo.Ico 3 SFLogo.ico 4 CFLogo.ico 5 DtyLogo.ico
1 Move.cur 2 Copy.cur 3 Link.cur 4 Pick.cur 5 Stop.cur 6 Hand.cur 7 Table.cur
Простое независимое приложение:
DevLinker.LinkExe
Simple.exe := Simple 1 applogo.Ico ~
Простая DLL:
DevLinker.LinkDll
Mydll.dll := Mydll# ~
MODULE Simple;
(* простое приложение Windows *)
IMPORT S := SYSTEM, WinApi;
CONST
message = "Hello World";
iconId = 1;
VAR
instance: WinApi.HINSTANCE;
mainWnd: WinApi.HWND;
PROCEDURE WndHandler (wnd, msg, wParam, lParam: INTEGER): INTEGER;
VAR res: INTEGER; ps: WinApi.PAINTSTRUCT; dc: WinApi.HDC;
BEGIN
IF msg = WinApi.WM_DESTROY THEN
WinApi.PostQuitMessage(0)
ELSIF msg = WinApi.WM_PAINT THEN
dc := WinApi.BeginPaint(wnd, ps);
res := WinApi.TextOut(dc, 50, 50, message, LEN(message));
res := WinApi.EndPaint(wnd, ps)
ELSIF msg = WinApi.WM_CHAR THEN
res := WinApi.Beep(800, 200)
ELSE
RETURN WinApi.DefWindowProc(wnd, msg, wParam, lParam)
END;
RETURN 0
END WndHandler;
PROCEDURE OpenWindow;
VAR class: WinApi.WNDCLASS; res: INTEGER;
BEGIN
class.hCursor := WinApi.LoadCursor(0, S.VAL(WinApi.PtrSTR,
WinApi.IDC_ARROW));
class.hIcon := WinApi.LoadIcon(instance, S.VAL(WinApi.PtrSTR, iconId));
class.lpszMenuName := NIL;
class.lpszClassName := "Simple";
class.hbrBackground := WinApi.GetStockObject(WinApi.WHITE_BRUSH);
class.style := WinApi.CS_VREDRAW + WinApi.CS_HREDRAW
(* + WinApi.CS_OWNDC + WinApi.CS_PARENTDC *);
class.hInstance := instance;
class.lpfnWndProc := WndHandler;
class.cbClsExtra := 0;
class.cbWndExtra := 0;
res := WinApi.RegisterClass(class);
mainWnd := WinApi.CreateWindowEx({}, "Simple", "Simple Application",
WinApi.WS_OVERLAPPEDWINDOW,
WinApi.CW_USEDEFAULT, WinApi.CW_USEDEFAULT,
WinApi.CW_USEDEFAULT, WinApi.CW_USEDEFAULT,
0, 0, instance, 0);
res := WinApi.ShowWindow(mainWnd, WinApi.SW_SHOWDEFAULT);
res := WinApi.UpdateWindow(mainWnd);
END OpenWindow;
PROCEDURE MainLoop;
VAR msg: WinApi.MSG; res: INTEGER;
BEGIN
WHILE WinApi.GetMessage(msg, 0, 0, 0) # 0 DO
res := WinApi.TranslateMessage(msg);
res := WinApi.DispatchMessage(msg);
END;
WinApi.ExitProcess(msg.wParam)
END MainLoop;
BEGIN
instance := WinApi.GetModuleHandle(NIL);
OpenWindow;
MainLoop
END Simple.
MODULE Mydll;
(* простой модуль, компонуемый в dll *)
PROCEDURE Gcd* (a, b: INTEGER): INTEGER;
BEGIN
WHILE a # b DO
IF a > b THEN a := a - b ELSE b := b - a END
END;
RETURN a
END Gcd;
PROCEDURE Lcm* (a, b: INTEGER): INTEGER;
BEGIN
RETURN a * b DIV Gcd(a, b)
END Lcm;
END Mydll.
| Dev/Docu/ru/Linker.odc |
DevMarkers
DEFINITION DevMarkers;
PROCEDURE NextError;
PROCEDURE ToggleCurrent;
PROCEDURE UnmarkErrors;
... плюс несколько служебных элементов ...
END DevMarkers.
Метки ошибок показывают места ошибок компиляции в исходном тексте.
Этом модуль содержит несколько других элементом, предназначенных для внутреннего использования.
Возможное меню:
MENU
"Unmar&k Errors" "" "DevMarkers.UnmarkErrors" "TextCmds.FocusGuard"
"Next E&rror" "" "DevMarkers.NextError" "TextCmds.FocusGuard"
"To&ggle Error Mark" "" "DevMarkers.ToggleCurrent" "TextCmds.FocusGuard"
END
PROCEDURE NextError
Охрана: TextCmds.FocusGuard
Помещает каретку после следующей метки ошибки. Если их нет, текст прокручивается на начало.
PROCEDURE ToggleCurrent
Охрана: TextCmds.FocusGuard
Переключает состояние метки перед кареткой.
PROCEDURE UnmarkErrors
Охрана: TextCmds.FocusGuard
Удаляет все метки ошибок.
| Dev/Docu/ru/Markers.odc |
DevMsgSpy
Инструмент, который позволяет отслеживать все сообщения, которые посылаются отображению.
О протоколе сообщений
Message Spy - это инструмент, который протоколирует сообщения, послаемые отображению через один из методов HandleCtrlMsg, HandleModelMsg, HandlePropMsg, или HandleViewMsg. Протокол сообщений показывает тип всех сообщений и, по запросу, полностью записи сообщений.
Этот инструмент может помочь, если ваше отображение ведет себя не так, как вы ожидаете. С его помощью вы можете изучить, какие сообщения среда посылает вашему отображению и следовательно, на какие сообщения вам следует отвечать.
Как отслеживать отображения
Чтобы открыть Message Spy, выберите Message Spy... из меню Info. Откроется диалоговое окно, подобное тому, которое изображено на Рисунке 1. Если вы хотите наблюдать за отображением, выделите его монолитом и нажмите кнопку Add View. Если вы хотите удалить снять наблюдение с отображения, выделите его как монолит и нажмите ту же кнопку, на которой теперь будет написано Remove View.
Рисунок 1: Инструментальное окно Message Spy
Инструментальное окно разделено на две части. В верхней части показываются все распознанные сообщения. Этот список растет со временем. Всякий раз, когда шпион встречает сообщение нового типа, прошедшее через одно из инспектируемых отображений, этот тип добавляется в список распознанных типов. Поскольку вы можете потерять обзор над типами сообщений, MarkNewMessagesinList выделяет все заново добавленные типы сообщений. Таким образом вы легко узнаете о сообщениях, вызванных конкретным действием. Список типов сообщений может быть очищен кнопкой ClearList.
Если выбрана настройка ShowMessagesInLog, то все сообщения, посылаемые всем инспектируемым отображениям, типы которых выделены на панели выбора типов, показываются нижней части диалогового окна сообщений. Для каждого сообщения имя типа сопровождается синим ромбиком. При щелчке на ромбике все переменные записи сообщения показываются в отдельном окне. Протокол является нормальным текстом, который можно прокручивать и редактировать.
Дополнительная информация
Так как записи сообщений являются статическими переменными (размещаются в стеке), они копируются при вызове обработчика сообщений. Последствиями этого является то, что можно отследить только содержимое сообщения при передаче, но не ответ на сообщение от конкретного отображения.
Заметим, что журнал сообщений показывает сообщения любого типа, посылаемые к перехватываемому отображению, он также включает сообщения типов, которые не экспортированы.
Чтобы перехватить сообщение, шпион сообщений добаляет обертку вокруг исходного отображения. Это обертка показывает сообщения и затем передает их далее к обернутому отображению. При замене отображение его оберткой тип отображения изменяется, и следовательно, некоторые инструменты, которые зависят от типа отображения, не смогут работать с ним.
Команда меню:
"Message Spy..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/MsgSpy', 'Message Spy')" ""
| Dev/Docu/ru/MsgSpy.odc |
Особенности, зависящие от платформы (Windows)
ENGLISH
МодульSYSTEM
ИспользованиеDLLвмодуляхсистемыБлэкбокс
ИспользованиеCOMбезспециальногокомпилятораDirect-To-COM
ПрограммныеинтерфейсыWindows
АвтоматизацияOLE
Информация,специфичнаядляWindows,всистемеБлэкбокс
ОтличиямеждуразнымиверсиямиWindows
КомпоновщиксистемыБлэкбокс
КомпоновкаприложенийсистемыБлэкбокс
ПроцессзагрузкисистемыБлэкбокс
Модуль SYSTEM
Модуль SYSTEM содержит некоторые процедуры, которые необходимы для реализации низкоуровневых операций. Настойчиво рекомендуется ограничить использование этих средств специфичными низкоуровневыми модулями, так как такие модули по сути не переносимы и обычно небезопасны. SYSTEM не считается частью языка Компонентный Паскаль.
Процедуры модуля SYSTEM перечислены в следующей таблице. v обозначает переменную. x, y и n обозначают выражения. T обозначает тип. P обозначает процедуру. M[a] обозначает значение памяти по адресу a.
Процедуры-функции
Имя Типы аргументов Тип результата Описание
ADR(v) любой INTEGER адрес переменной v
ADR(P) P: PROCEDURE INTEGER адрес процедуры P
ADR(T) T: записевый тип INTEGER адрес дескриптора T
LSH(x, n) x, n: целый тип* тип x логический сдвиг
(n > 0: влево, n < 0: вправо)
ROT(x, n) x, n: целый тип* тип x вращение (n > 0: влево, n < 0: вправо)
TYP(v) записевый тип INTEGER тег записевого типа переменной v
VAL(T, x) T, x: любой тип T значение x интерпретируется как
имеющее тип T
* целые типы кроме LONGINT
Процедуры
Имя Типы аргументов Описание
GET(a, v) a: INTEGER; v: любой элементарный, v := M[a]
указательный или процедурный тип
PUT(a, x) a: INTEGER; x: любой элементарный, M[a] := x
указательный или процедурный тип
GETREG(n, v) n: целая константа, v: любой элементарный, v := регистр n
указательный или процедурный тип
PUTREG(n, x) n: целая константа , x: любой элементарный, Register n := x
указательный или процедурный тип
MOVE(a0, a1, n) a0, a1: INTEGER; n: целый тип M[a1..a1+n-1] :=
M[a0..a0+n-1]
Номера регистров для PUTREG и GETREG таковы:
0: EAX, 1: ECX, 2: EDX, 3: EBX, 4: ESP, 5: EBP, 6: ESI, 7: EDI.
Внимание
При неправильном использовании VAL, PUT, PUTREG и MOVE могут вызвать крах системы Блэкбокс и/или Windows.
Никогда не используйте VAL (или PUT, или MOVE), чтобы присвоить значение указателю в системе Блэкбокс. Это может нарушить работу сборщика мусора, с фатальными последствиями.
Системные флаги
Импорт модуля SYSTEM позволяет изменять некоторые аспекты поведения компилятора с помощью системных флагов. Системные флаги используются для настройки объявлений процедур или типов. Расширенный синтаксис приведен ниже.
Type = Qualident
| ARRAY ["[" SysFlag "]"] [ConstExpr {"," ConstExpr}]
OF Type
| RECORD ["[" SysFlag "]"] ["("Qualident")"] FieldList
{";" FieldList} END
| POINTER ["[" SysFlag "]"] TO Type
| PROCEDURE [FormalPars].
ProcDecl = PROCEDURE ["[" SysFlag "]"] [Receiver] IdentDef
[FormalPars] ";"
DeclSeq [BEGIN StatementSeq] END ident.
FPSection = [VAR ["[" SysFlag "]"]] ident {"," ident} ":" Type.
SysFlag = ConstExpr | ident.
Для системных флагов может использоваться либо имя, либо соответствующее численное значение.
Системные флаги для записевых типов
Имя Значение Описание
untagged 1 Тег и дескриптор типа не будут размещаться.
(без тега) Сборщик мусора игнорирует переменные без тега.
NEW не применимо к указателям на переменные без тега.
С записью нельзя связать процедуры.
Указатели на записевые типы без тегов или расширения этих
записевых типов наследуют атрибут untagged.
Смещения полей выравниваются по
MIN(4-байта, size), где size - это размер поля.
Размер записи и смещения полей
выравниваются по 32-битным границам.
noalign 3 То же, что untagged, но без выравнивания.
align2 4 То же, что untagged, но с
выравниванием по MIN(2-байта, size).
align8 6 То же, что untagged, но с
выравниванием по MIN(8-байт, size).
union 7 Запись без тега, у которой все поля имеют смещение 0.
Размер записи равен размеру самого большого поля.
Используется для эмуляции типов union языка Си.
Системные флаги для массивовых типов
Имя Значение Описание
untagged 1 Тег и дескриптор типа не будут размещаться.
Сборщик мусора игнорирует переменные без тега.
NEW не применимо к указателям на переменные без тега.
Указатели на такой масивовый тип наследуют атрибут untagged.
Допускаются только одномерные открытые массива без тега.
Для открытых массивов без тега границы индексации
не проверяются.
Системные флаги для указательных типов
Имя Значение Описание
untagged 1 Не отслеживается сборщиком мусора.
С типом нельзя связать процедуры.
Должен указывать на запись без тега.
Системные флаги для VAR-параметров
Имя Значение Описание
nil 1 NIL допускается в качестве фактического параметра.
Используется в интерфейсах к функциям Си
с параметрами указательных типов.
Системные флаги для процедур
Имя Значение Описание
code 1 Объявление процедуры в машинных кодах (см. далее).
ccall -10 Процедура использует соглашение вызова CCall.
Процедуры в машинных кодах
Процедуры в машинных кодах позволяют использовать специальные последовательности машинных команд, которые не генерируются компилятором. Для их объявления используется следующий специальный синтаксис:
ProcDecl = PROCEDURE "[" SysFlag "]" IdentDef [FormalPars]
[ConstExpr {"," ConstExpr}] ";".
Список констант, объявленный с процедурой, интерпретируется как строка байт и вставляется непосредственно в код (in-line), из которого вызвана процедура. Если присутствует список параметров, фактические параметры загружаются в стек справа налево. Однако первый параметр записывается в регистр. Если тип первого параметра REAL или SHORTREAL, то он записывается в верхний регистр для чисел с плавающей точкой. Иначе параметр (или в случае VAR/IN/OUT-параметра его адрес) записывается в EAX. Для процедур-функций ожидается, что и результат сохраняется в верхнем регистре с плавающей точкой или в EAX, в зависимости от его типа. Будьте осторожны, когда используете регистры в кодовых процедурах. В общем, можно использовать регистры ECX, EDC, ESI и EDI. Параметры должны удаляться со стека процедурой.
Примеры
PROCEDURE [code] Sqrt (x: REAL): REAL (* Math.Sqrt *)
0D9H, 0FAH; (* FSQRT *)
PROCEDURE [code] Erase (adr, words: INTEGER) (* erase memory area *)
089H, 0C7H, (* MOV EDI, EAX *)
031H, 0C0H, (* XOR EAX, EAX *)
059H, (* POP ECX *)
0F2H, 0ABH; (* REP STOS *)
Использование DLL в модулях системы Блэкбокс
Любая 32-разрядная DLL может быть импортирована в Компонентный Паскаль подобно обычному модулю. Это справедливо как для системных модулей Windows (kernel, user, gdi, ...) так и для любой другой DLL, написанной на любом языке программирования. Следует помнить, что свойства безопасности программ на Компонентном Паскале (отсутствие висячих ссылок, строгая проверка типов и т.п.) теряются, если вы подключаетесь к DLL, написанной на другом языке программирования.
Модули интерфейсов
Информация о типах объектов, импортируемых из DLL, должна быть представлена в символьном файле, чтобы компилятор мог правильно работать. Такие специальные символьные файлы могут быть сгенерированы из так называемых интерфейсных модулей. Интерфейсный модуль является модулем Компонентного Паскаля, помеченным специальным системным флагом после имени модуля. Такой системный флаг состоит из имени соответствующей DLL, заключенного в квадратные скобки. Модуль интерфейса может содержать лишь объявления констант, типов и заголовков процедур. При компиляции интерфейсного модуля кодовый файл не создается.
Совмещение имен (aliasing)
Имя в Компонентном Паскале для объекта, импортированного из DLL, может отличаться от соответствующего имени в таблице экспорта библиотеки. Для этого к имени в Компонентном Паскале нужно добавить библиотечное имя как системный флаг. Кроме того, в системном флаге может быть указана другая библиотека DLL, чем та, которая объявлена в заголовке модуля. Это позволяет использовать один интерфейсный модуль для целого набора связанных DLL. Но можно иметь несколько интерфейсных модулей, ссылающихся на одну DLL. Интерфейсные процедуры не могут иметь ни тела, ни части END идентификатор, они являются лишь сигнатурами.
Расширенный синтаксис для интерфейсных модулей дан ниже:
Module = MODULE ident ["[" SysString "]"] ";"
[ImportList] DeclSeq [BEGIN StatementSeq] END ident ".".
ProcDecl = PROCEDURE ["[" SysFlag "]"] [Receiver]
IdentDef ["[" [SysString ","] SysString "]"] [FormalPars] ";"
DeclSeq [[BEGIN StatementSeq] END ident].
SysString = string.
Совмещения имен нет для типов и констант, поскольку они не представлены в списках экспорта и поэтому могут иметь произвольные имена.
Следующий пример демонстрирует возможности совмещения:
MODULE MyInterface ["MyDll"];
PROCEDURE Proc1*; (* Proc1 из MyDll *)
PROCEDURE Proc2* ["BlaBla"]; (* BlaBla из MyDll *)
PROCEDURE Proc3* ["OtherDll", ""]; (* Proc3 из OtherDll *)
PROCEDURE Proc4* ["OtherDll", "DoIt"]; (* DoIt из OtherDll *)
END MyInterface.
SysString для DLL не может содержать имени пути. Это должно быть просто имя DLL, без суффикса ".dll". Используются следующие правила поиска:
- папка BlackBox
- папка Windows\System
- папка Windows
Типы данных в интерфейсных модулях
Всегда используйте записи без тега (untagged records) в качестве аналогов структур Си, чтобы избежать размещения тега типа для сборщика мусора. Системный флаг [untagged] помечает тип как безтеговый (никакой информации о типе во время выполнения не будет доступно) со стандартными правилами выравнивания (2-байтовые поля будут выровнены по 2-байтовым границам, 4-байтовые или большие поля - по 4-байтовым границам). Системные флаги [noalign], [align2] и [align8] также описывают типы как безтеговые, но с различным выравниванием для полей записи.
Как и для всех системных флагов, для использования untagged нужно импортировать модуль SYSTEM.
Пример:
RECORD [noalign] (* без тега, размер = 7 байт *)
c: SHORTCHAR; (* смещение 0, размер = 1 byte *)
x: INTEGER; (* смещение 1 , размер = 4 bytes *)
i: SHORTINT (* смещение 5, размер = 2 bytes *)
END
Процедуры
Вызовы процедур Компонентного Паскаля следуют соглашениям вызова StdCall (параметры загружаются в стек справа налево, и удаляются вызываемой процедурой). Если какие-то процедуры DLL используют соглашение CCall (параметры удаляются вызывающей процедурой), то соответствующие объявления процедур в интерфейсном модуле должны быть сделаны с системным флагом [ccall].
Процедуры обратного вызова (callback) особого объявления не требуют.
Для параметров типа POINTER TO T часто лучше использовать параметр-переменную типа T, нежели объявлять соответствующий тип указателя. Объявляйте VAR-параметр с системным флагом [nil], если NIL является допустимым фактическим параметром.
Пример:
Си:
BOOL MoveToEx(HDC hdc, int X, int Y, LPPOINT lpPoint)
Компонентный Паскаль:
PROCEDURE MoveToEx* (dc: Handle; x, y: INTEGER; VAR [nil] old: Point): Bool
Соответствие между типами данным Компонентного Паскаля и Си
unsigned char = SHORTCHAR (1 байт)
WCHAR = CHAR (2 байта)
signed char = BYTE (1 байт)
short = SHORTINT (2 байта)
int = INTEGER (4 байта)
long = INTEGER (4 байта)
LARGE_INTEGER = LONGINT (8 байт)
float = SHORTREAL (4 байта)
double = REAL (8 байт)
Заметим, что Bool не является типом данных в C, поскольку он определен как целое (= INTEGER). Для присваивания значений FALSE и TRUE нужно использовать 0 и 1, а в условных операторах нужно использовать сравнение с 0 (IF b # 0 THEN ... END вместо IF b THEN ... END).
Заметим также, что выгрузить DLL из Блэкбокса невозможно. Чтобы избежать многократных выходов и перезапусков среды, удобно запустить второй экземпляр системы Блэкбокс и оттуда тестировать DLL, которую вы разрабатываете.
<На самом деле можно динамически загружать-выгружать DLL, причем находящиеся где угодно. Примеры можно найти через здесь прим. ред.>
Использование COM без специального Direct-To-COM-компилятора
Microsoft Component Object Model (COM) поддерживается специальным компилятором для Компонентного Паскаля, который доступен как добавочный продукт к BlackBox. Этот компилятор делает использование COM безопаснее и удобнее. Однако для эпизодического использования COM можно использовать подход, описанный в данном разделе. Для этого не требуется специальной версии компилятора. Для создания таблиц методов в стиле COM ("vtbl") используются обычные записи без тегов и процедурные переменные. Следующий пример показывает, как это работает:
MODULE Ddraw ["DDRAW.DLL"];
TYPE
GUID = ARRAY 4 OF INTEGER;
PtrIUnknown = POINTER TO RECORD [untagged]
vtbl: POINTER TO RECORD [untagged]
QueryInterface: PROCEDURE (this: PtrIUnknown; IN iid: GUID; OUT obj: PtrIUnknown): INTEGER;
AddRef: PROCEDURE (this: PtrIUnknown): INTEGER;
Release: PROCEDURE (this: PtrIUnknown): INTEGER;
END
END;
PtrDirectDraw = POINTER TO RECORD [untagged]
vtbl: POINTER TO RECORD [untagged]
QueryInterface: PROCEDURE (this: PtrDirectDraw; IN iid: GUID; OUT obj: PtrIUnknown): INTEGER;
AddRef: PROCEDURE (this: PtrDirectDraw): INTEGER;
Release: PROCEDURE (this: PtrDirectDraw): INTEGER;
Compact: PROCEDURE (this: PtrDirectDraw): INTEGER;
...
SetCooperativeLevel: PROCEDURE (this: PtrDirectDraw; w, x: INTEGER): INTEGER;
...
END
END;
PROCEDURE DirectDrawCreate* (IN guid: GUID; OUT PDD: PtrDirectDraw; outer: PtrIUnknown) : INTEGER;
END Ddraw.
MODULE Directone;
IMPORT Type, Util, Out, Ddraw, KERNEL32, SYSTEM;
CONST
ModuleName = "Directone";
DDSCL_EXCLUSIVE = 00000010H;
DDSCL_FULLSCREEN = 00000001H;
PROCEDURE Initialize;
VAR
Handle, Addr, Res: INTEGER;
PDD: PtrDirectDraw;
nul: GUID;
BEGIN
PDD := NIL;
nul[0] := 0; nul[1] := 0; nul[2] := 0; nul[3] := 0;
Res := Ddraw.DirectDrawCreate( nul, PDD, 0 );
Out.String( "Res" ); Out.Int( Res, 8 ); Out.Ln();
Res := SYSTEM.VAL( INTEGER, PDD );
Out.String( "Res" ); Out.Int( Res, 8 ); Out.Ln();
Res := PDD.vtbl.SetCooperativeLevel( PDD, 0, DDSCL_EXCLUSIVE + DDSCL_FULLSCREEN );
Out.String( "Res" ); Out.Int( Res, 8 ); Out.Ln();
Res := PDD.Release()
END Initialize;
BEGIN
Initialize
END Directone.
Несколько необходимых замечаний:
COM GUIDs представляют собой 128-битные сущности, а не целые.
НЕ ИСПОЛЬЗУЙТЕ ANYPTR или другие указатели Блэкбокса для указателей на интерфейсы COM. (Указатели Блэкбокса обрабатываются сборщиком мусора, указатели COM счетчиком ссылок.)
Вместо этого используйте указатели на записи с атрибутом [untagged] или целые.
Будьте внимательны: объявляйте все методы в таблице методов в правильном порядке с правильными списками параметров.
Программные интерфейсы Windows
См. документацию ПрограммныеинтерфейсыWindows.
Автоматизация OLE
См. документацию ДиспетчерАвтоматизацииOLE.
Информация, специфичная для Windows, в системе Блэкбокс
Курсоры, специфичные для Windows
Модуль HostPorts экспортирует константы для Windows-курсоров, которые могут быть использованы наряду со стандартными курсорами, определенными в модуле Ports:
CONST
resizeHCursor = 16; (* курсоры для изменения размера *)
resizeVCursor = 17;
resizeLCursor = 18;
resizeRCursor = 19;
resizeCursor = 20;
busyCursor = 21; (* курсор занятости *)
stopCursor = 22; (* курсоры перетаскивания *)
moveCursor = 23;
copyCursor = 24;
linkCursor = 25;
pickCursor = 26; (* курсор перетаскивания с указанием *)
Модификаторы мыши и клавиатуры, специфичные для Windows
Наборы модификаторов используются в процедурах Controllers.TrackMsg, Controllers.EditMsg и Ports.Frame.Input. В дополнение к независящим от платформы модификаторам Controllers.doubleClick, Controllers.extend и Controllers.modify они содержат специфичные для платформы модификаторы, определенные в модуле HostPorts:
CONST
left = 16; (* нажата левая кнопка мыши *)
middle = 17; (* нажата средняя кнопка мыши *)
right = 18; (* нажата правая кнопка мыши *)
shift = 24; (* нажат клавиша Shift *)
ctrl = 25; (* нажата клавиша Control *)
alt = 28; (* нажата клавиша Alt *)
Контексты окон и устройств
Многие функции в Windows API ссылаются на контексты окна или устройства. В реализации Блэкбокса для Windows, и те, и другие хранятся в записях HostPorts.Port:
TYPE
Port = POINTER TO RECORD (Ports.PortDesc)
dc: WinApi.Handle;
wnd: WinApi.Handle
END;
В обычном случае, когда дан фрейм (Ports.Frame или Views.Frame), контексты могут быть получены одним из следующих селекторов:
frame.rider(HostPorts.Rider).port.dc
или
frame.rider(HostPorts.Rider).port.wnd
Если контекст окна нулевой, то порт является портом принтера.
Примеры
Следующее определение простой DLL является подмножеством стандартной библиотеки Windows GDI32:
MODULE GDI ["GDI32"];
CONST
WhiteBrush* = 0; BlackBrush* = 4; NullBrush* = 5;
WhitePen* = 6; BlackPen* = 7; NullPen* = 8;
PSSolid* = 0; PSDash* = 1; PSDot* = 2;
TYPE
Bool* = INTEGER;
Handle* = INTEGER;
ColorRef* = INTEGER;
Point* = RECORD [untagged] x*, y*: INTEGER END;
Rect* = RECORD [untagged] left*, top*, right*, bottom*: INTEGER END;
PROCEDURE CreatePen* (style, width: INTEGER; color: ColorRef): Handle;
PROCEDURE CreateSolidBrush* (color: ColorRef): Handle;
PROCEDURE GetStockObject* (object: INTEGER): Handle;
PROCEDURE SelectObject* (dc, obj: Handle): Handle;
PROCEDURE DeleteObject* (obj: Handle): Bool;
PROCEDURE Rectangle* (dc: Handle; left, top, right, bottom: INTEGER): Bool;
PROCEDURE SelectClipRgn* (dc, rgn: Handle): INTEGER;
PROCEDURE IntersectClipRect* (dc: Handle; left, top, right, bottom: INTEGER): INTEGER;
PROCEDURE SaveDC* (dc: Handle): INTEGER;
PROCEDURE RestoreDC* (dc: Handle; saved: INTEGER): Bool;
END GDI.
Следующий пример - это упрощенная версия стандартного средства Блэкбокса DrawRect, реализованного в Ports и HostPorts. Здесь используется интерфейс GDI, представленный выше.
MODULE Ex;
IMPORT Ports, HostPorts, GDI;
PROCEDURE DrawRect (f: Ports.Frame; l, t, r, b, s: INTEGER; col: Ports.Color);
VAR res, h, rl, rt, rr, rb: INTEGER; p: HostPorts.Port; dc, oldb, oldp: GDI.Handle;
BEGIN
(* преобразование локальных универсальных координат в пиксельные оконные координаты *)
l := (f.gx + l) DIV f.unit; t := (f.gy + t) DIV f.unit;
r := (f.gx + r) DIV f.unit; b := (f.gy + b) DIV f.unit;
s := s DIV f.unit;
(* получение контекста устройства *)
p := f.rider(HostPorts.Rider).port; dc := p.dc;
(* установка области отсечения *)
IF p.wnd = 0 THEN res := GDI.SaveDC(dc)
ELSE res := GDI.SelectClipRgn(dc, 0)
END;
f.rider.GetRect(rl, rt, rr, rb);
res := GDI.IntersectClipRect(dc, rl, rt, rr, rb);
(* по умолчанию используется черный цвет *)
IF col = Ports.defaultColor THEN col := Ports.black END;
IF s = 0 THEN s := 1 END;
IF (s < 0) OR (r-l < 2*s) OR (b-t < 2*s) THEN (* закрашенный прямоугольник *)
INC(r); INC(b);
oldb := GDI.SelectObject(dc, GDI.CreateSolidBrush(col));
oldp := GDI.SelectObject(dc, GDI.GetStockObject(GDI.NullPen));
res := GDI.Rectangle(dc, l, t, r, b);
res := GDI.DeleteObject(GDI.SelectObject(dc, oldb));
res := GDI.SelectObject(dc, oldp)
ELSE (* каркасный прямоугольник *)
h := s DIV 2; INC(l, h); INC(t, h); h := (s-1) DIV 2; DEC(r, h); DEC(b, h);
oldb := GDI.SelectObject(dc, GDI.GetStockObject(GDI.NullBrush));
oldp := GDI.SelectObject(dc, GDI.CreatePen(GDI.PSSolid, s, col));
res := GDI.Rectangle(dc, l, t, r, b);
res := GDI.SelectObject(dc, oldb);
res := GDI.DeleteObject(GDI.SelectObject(dc, oldp))
END;
IF p.wnd = 0 THEN res := GDI.RestoreDC(dc, -1) END
END DrawRect;
END Ex.
Система типов времени выполнения
Все динамически размещаемые записи Компонентного Паскаля содержат скрытое поле, которое называется тегом типа. Тег типа указывает на описатель типа, который содержит всю иформацию о типе, необходимую во время выполнения. Вызовы связанных с типом процедур, проверки типов и сборка мусора используют информацию, которая хранится в описателе типа. Описатель типа размещается только один раз для каждого записевого типа в системе.
Динамаически размещаемые массивы используют описатель размера для проверки границ индексов. Описатель размера также содержит тег для типа элементов. Отдельный описатель размера нужен для каждого динамического массива.
Различия между разными версиями Windows
Элементы управления дерево в Windows NT выглядят по-иному, чем в других версиях Windows. В Windows NT процедура рисования фона таких элементов содержит ошибку. Поэтому Блэкбокс при работе под WindowsNT не изменяет цвет фона для отключенных деревьев или доступных только для чтения, хотя под другими версиями Windows в этих случаях фон становится серым.
Компоновщик системы Блэкбокс
См. документацию DevLinker.
Компоновка приложений в системе Блэкбокс
Если нужно распространять приложение, созданное в Блэкбоксе, то может возникнуть желание скомпоновать все модули для распространения в один файл. В этом случае вместе с приложением нужно скомпоновать среду. Чтобы показать необходимые действия, приведем пример. Сначала сделайте в Проводнике копию всей системы Блэкбокс и переменуйте ее соответственно, в нашем случае Patterns. Подправьте модуль Config под свои нужды, например, удалите вызов, который автоматически открывает рабочий журнал. Затем скомпонуйте среду вместе с вашими модулями в новое приложение. Вам может понадобиться распространять вместе с приложением некоторые дополнительные файлы, такие как формы и тексты меню.
MODULE Config;
IMPORT Dialog;
PROCEDURE Setup*;
VAR res: INTEGER;
BEGIN
Dialog.Call("ObxPatterns.Deposit; StdCmds.Open", "", res)
END Setup;
END Config.
DevLinker.Link Patterns.exe :=
Kernel$+ Files HostFiles StdLoader Math Sub Strings Dates Meta Dialog Services
Fonts Ports Stores Converters Sequencers Models Printers Views
Controllers Properties Printing Mechanisms Containers
Documents Windows StdCFrames Controls StdDialog StdCmds StdInterpreter
HostRegistry HostFonts HostPorts OleData HostMechanisms HostWindows
HostPrinters HostClipboard HostCFrames HostDialog HostCmds
HostMenus HostPictures TextModels TextRulers TextSetters TextViews
TextControllers TextMappers StdLog TextCmds
FormModels FormViews FormControllers FormGen FormCmds
StdFolds StdLinks StdDebug HostTextConv HostMail
StdMenuTool StdClocks StdStamps StdLogos StdCoder StdScrollers
OleStorage OleServer OleClient StdETHConv Init ObxPatterns Config
1 applogo.Ico 2 doclogo.Ico 3 SFLogo.ico 4 CFLogo.ico 5 DtyLogo.ico
1 Move.cur 2 Copy.cur 3 Link.cur 4 Pick.cur 5 Stop.cur 6 Hand.cur 7 Table.cur ~
Процесс загрузки системы Блэкбокс
Запуск Блэкбокса происходит в несколько шагов.
Шаг 1: Операционная система загружает приложение
Блэкбокс состоит из одного маленького скомпонованного приложения и множества нескомпонованных кодовых файлов (по одному на каждый модуль). Скомпонованное приложение состоит по крайней мере из модуля Kernel. Когда операционная система загружает BlackBox, она передает управление телу модуля Kernel.
Шаг 2: Ядро загружает все прикомпонованные модули
Ядро инициализирует свои структуры данных, в частности, для управления памятью и обработки исключений. Затем оно выполняет тела других модулей, которые скомпонованы в приложении, в правильном порядке. Обычно среди прикомпонованных модулей есть StdLoader и несколько модулей, необходимых ему, в частности, Files и HostFiles. Модуль StdLoader реализует динамический загрузчик, который динамически связывает и загружает кодовые файлы модулей.
Шаг 3: Init загружает библиотеку Блэкбокса и ядро среды
Стандартная реализация модуля StdLoader вызывает из своего тела модуль Init. Если Init не прикомпонован, загрузчик пытается загрузить кодовый файл System/Code/Init. Если загрузка возможна, сначала загружаются модули, импортируемые из Init, а затем инициализируется собственно Init, то есть выполняется тело модуля.
Стандартная реализация Init импортирует все модули ядра среды и их стандартные реализации, но не подсистемы расширения, такие как Text или Form. Эти модули загружаются перед тем, как тело Init выполнит следующие действия:
Пытается вызвать Startup.Setup.
Обычно модуль Startup не существует. Он может быть использован для установки некоторых служб до того, как откроется главное окно и загрузятся текстовая и другие подсистемы.
Пытается загрузить модуль DevDebug.
DevDebug представляет собой более удобную замену для рудиментарных возможностей ядра по обработке исключений. Заметим, что стандартная реализация DevDebug использует текстовую подсистему, которая поэтому тоже загружается. Если загрузить DevDebug не удается, делается попытка загрузить модуль StdDebug. Это усеченная версия модуля DevDebug, которая может распространяться вместе с приложением.
Регистрирует конвертер файлов документов (импортер/экспортер).
Это позволяет Блэкбоксу открывать и сохранять стандартные документы в формате системы Блэкбокс.
Пытается вызвать StdMenuTool.UpdateAllMenus.
Эта команда читает и интерпретирует текст System/Rsrc/Menus и строит соответствующие меню. Заметим, что стандартная реализация StdMenuTool использует текстовую подсистему.
Пытается вызвать Config.Setup.
Это обычный способ настроить BlackBox. Стандартная реализация Config.Setup устанавливает стандартные файловые и OLE конверторы и открывает окно рабочего журнала.
Запускается главный цикл обработки событий (HostMenus.Run).
После завершения главного цикла (когда пользователь хочет выйти из приложения), ядро вызывается для очистки перед тем, как приложение будет выгружено полностью.
Использование NEW и сборщика мусора в ваших приложениях
Если в приложении вызывается NEW и тем самым неявно предполагается использование сборщика мусора, то нужно связать Kernel с приложением. Процедура NEW реализована в ядре, и компилятор генерирует соответствующий код для вызова этой процедуры. Таким образом, каждый модуль, использующий NEW, производит скрытый импорт ядра.
Если импортировано ядро, не вызывайте WinApi.ExitProcess напрямую, вместо этого вызывайте Kernel.Quit с параметром 0, чтобы гарантировать, что все занятые системные ресурсы будут правильно освобождены перед остановкой приложения.
Программам нет нужды вызывать сборщик мусора напрямую. Если процедура NEW не может удовлетворить запрос на выделение памяти в куче, она сама вызовет сборщик мусора перед тем, как запросить новый блок кучи у Диспетчера памяти Windows. Сборщик мусора учитывает указатели в процедурных фреймах на стеке и способен работать в любой момент.
Сборщик мусора очищает все объекты кучи (динамические записи или переменные-массивы), которые больше не используются. Не используются означает, что объект не доступен ни напрямую из некоторого корневого указателя, ни косвенно через цепочку указателей, начинающуюся с корневого указателя. Любая глобальная переменная, содержащая указатель, является таким корнем. Если корневой указатель не NIL, тогда он является якорем для структуры данных. Объект в куче, который уже не имеет якоря, будет в конце концов зачищен сборщиком мусора.
Чтобы позволить сборщику мусора отслеживать цепочки указателей, должна присутствовать некоторая информация о просматриваемых объектах в куче. В частности, должно быть известно, где есть указатели на объект, если они есть. Все объекты одного типа имеют один общий описатель типа, который создается, когда загружается модуль, в котором этот тип определен.
Все динамически размещаемые записи Компонентного Паскаля содержат скрытое поле, которое называется тегом типа. Тег типа указывает на описатель типа, который содержит всю иформацию о типе, необходимую во время выполнения. Вызовы связанных с типом процедур, проверки типов и сборка мусора используют информацию, которая хранится в описателе типа. Описатель типа размещается только один раз для каждого записевого типа в системе.
Динамаически размещаемые массивы используют описатель размера для проверки границ индексов. Описатель размера также содержит тег для типа элементов. Для каждого динамического массива необходим свой описатель размера.
Дополнительная память, нужная для тегов объектов, делает их (объектов) расположение в памяти отличным от записей без тега, предоставляемых операционной системой или какими-либо разделяемыми библиотеками процедур. Наличие тегов типа критично; они не должны повреждаться, иначе сборщик мусора в какой-то момент времени обрушит систему.
| Dev/Docu/ru/P-S-I.odc |
DevPacker
DEFINITION DevPacker;
PROCEDURE ListFromSub (sdir: ARRAY OF CHAR);
PROCEDURE ListLoadedModules;
PROCEDURE PackThis;
END DevPacker.
Модуль DevPacker используется для упаковки файлов любого типа в существующий exe-файл. Эти файлы могут быть прочитаны с помощью HostPackedFiles. Нет прямой зависимости между DevPacker и HostPackedFiles, но поскольку один записывает в exe-файл, а другой читает оттуда, существует подразумеваемая зависимость, с форматом exe-файла.
DevDependencies.CreateTool может использоваться для создания команд упаковки для множества модулей.
PROCEDURE PackThis;
Используется вместе с DevCommander. Читает список имен файлов и пакует эти файлы в exe-файл. Имя exe-файла находится в начале списка перед символом ":=". Также возможно упаковать файл под другим именем, чем то, под которым он находится в текущей файловой системе. Для задания другого имени файла используется специальный символ "=>".
Таким образом, синтакс в расширенной НФБ-нотации таков:
<exeFileName> := <filename> [=> <filename>] {<filename> [=> <filename>]}
Как exeFileName, так и fileName могут быть заданы абсолютным путем (включая имя диска) или относительно директории BlackBox. Если какой-либо файл содержит в имени специальные символы, такие как пробелы, то имя следует заключать в кавычки ("filename"), чтобы оно было правильно разобрано. Разбор останавливается, как только он встретит любой нераспознанный символ, такой как запятую или тильду.
Перед тем, как начнется упаковка, список файлов проверяется. Если какие-то файлы не найдены, то команда упаковки останавливается и exe-файл остается нетронутым. Если имя файла встречается в списке более одного раза, выводится сообщение об этом, но упаковка продолжается, и файл упаковывается в exe-файл только один раз.
Необходимо, чтобы exe-файл не присутствовал в списке файлов для упаковки. Это может привести к тому, что exe-файл будет упакован сам в себя с непредсказуемыми результатами. Поэтому упаковка отменяется, если exe-файл присутствует в списке.
Пример:
DevPacker.PackThis exefilename.exe :=
Tour.odc "C:\Program files\BlackBox\License.txt" Test/Code/MyConfig.ocf => Code/Config.ocf
PROCEDURE ListFromSub (sdir: ARRAY OF CHAR);
Просматривает директорию sdir и все ее поддиректории. Если она находит файлы, то открывает новый документ и записывает команду упаковки для всех найденных файлов. sdir может быть абсолютным путем, включающим имя диска, или путем относительно директории BlackBox. Параметр также может быть пустой строкой, в таком случае будет обработана корневая директория BlackBox.
Пример: "DevPacker.ListFromSub('Text')"
PROCEDURE ListLoadedModules;
Просматривает текущие загруженные модули и создает текст с командой упаковки для них. Это может быть использовано для быстрого поиска тех модулей, которые нужны запущенному приложению. Проблема может быть в том, что будут упакованы лишние модули и не будут включены такие файлы, как ресурсы и документация.
Пример: DevPacker.ListLoadedModules
Абсолютные и относительные пути в именах файлов
Предположим, что BlackBox установлен в директории D:\BlackBox. Тогда, с точки зрения упаковщика, имя файла D:\BlackBox\Std\Code\Log.ocf (абсолютный путь) задает тот же файл, что и Std\Code\Log.ocf (относительный путь). Однако, упаковщик пакует файл в exe-файл c путем, заданным в команде. Это критично для модуля HostPackedFiles, который читает exe-файл. Если exe-файл, например, запускается в директории C:\temp, и программа делает вызов к StdLog, то эта команда будет работать, если файл упакован с использованием относительного пути, но не будет работать, если был использован абсолютный путь. С другой стороны, если файл упакован с использованием абсолютного пути, вызов на открытие D:\BlackBox\Std\Code\Log.ocf будет работать даже если на машине нет диска с именем D:.
Касательно exe-файлов
Упаковщик не может создать exe-файл, он может лишь упаковать файлы в существующий exe-файл. Это значит, что придется использовать компоновщик для создания минимального exe-файла для упаковки. Минимальный exe-файл должен иметь скомпонованный HostPackedFiles, так как это модуль, который позволяет извлекать файлы. Минимальная команда для компоновщика такова:
DevLinker.Link exefilename.exe := Kernel$+ Files HostFiles HostPackedFiles StdLoader
Чтобы HostPackedFiles имел возможность найти файлы в exe-файле, он должен иметь тот же формат, какой был при упаковке файлов в него. Это значит, что после упаковки файлов в exe-файл невозможно добавить в него ресурсы, такие как значки или курсоры. Все подобные операции должны быть совершены до начала упаковки. (см. документациюDevLinker для подробностей о том, как добавлять значки сразу при компоновке). Однако можно изменять имя exe-файла после окончания упаковки.
Другое ограничение заключается в том, что упаковщик не может добавлять файлы. Он пакует целый список файлов и записывает таблицу этих файлов. Если PackThis вызывается вновь, это разрушает информацию о прежних файлах в exe-файле.
| Dev/Docu/ru/Packer.odc |
DevProfiler
DEFINITION DevProfiler;
PROCEDURE SetProfileList;
PROCEDURE SetModuleList (list: ARRAY OF CHAR);
PROCEDURE Start;
PROCEDURE Stop;
PROCEDURE ShowProfile;
PROCEDURE Reset;
PROCEDURE Execute;
PROCEDURE StartGuard (VAR par: Dialog.Par);
PROCEDURE StopGuard (VAR par: Dialog.Par);
END DevProfiler.
DevProfiler - это статистический профилировщик для программ на Компонентном Паскале. Профилировщик измеряет, как много процессорного времени проходит в отдельных процедурах программы. Статистический профилировщик определяет через регулярные промежутки времени (управляемые прерываниями), в какой процедуре какого модуля программа в настоящий момент выполняется. Эти измерения сохраняются и могут потом использоваться при показе профиля.
Профили могут быть взяты для всех модулей, или для выделенного списка конкретных интересующих модулей. Профилировка может быть начата и остановлена интерактивно, или через программный интерфейс. Последнее часто делает возможным более точное измерение.
Возможное меню:
MENUS
"Set Profile List" "" "DevProfiler.SetProfileList" "DevProfiler.StartGuard"
"Start Profiler" "" "DevProfiler.Start" "DevProfiler.StartGuard"
"Stop Profiler" "" "DevProfiler.Stop; DevProfiler.ShowProfile" "DevProfiler.StopGuard"
"Execute" "" "DevProfiler.Execute" "TextCmds.SelectionGuard"
END
Программный пример
Следующий пример показывает, как можно использовать программный интерфейс профилировщика. Здесь профилируется компиляция модуля, то есть, команда DevCompiler.Compile.
PROCEDURE ProfiledCompile*;
VAR res: INTEGER;
BEGIN
DevProfiler.SetModuleList("DevCPM DevCPS DevCPT DevCPB DevCPP DevHostCPL
DevHostCPC DevHostCPV");
DevProfiler.Start;
Dialog.Call("DevCompiler.Compile", "", res);
DevProfiler.Stop;
DevProfiler.ShowProfile;
DevProfiler.Reset
END ProfiledCompile;
Эта процедура порождает нечто подобное следующему выводу:
Module % per module
Procedure % per procedure
DevCPT 37
InsertImport Џ7
Find Џ4
InName Џ4
InStruct Џ4
FPrintName Џ3
FPrintSign Џ1
IdFPrint Џ1
FPrintObj Џ1
DevCPM 16
ReadNum Џ4
Get Џ3
FPrint Џ2
SymRCh Џ2
SymRInt Џ2
DevHostCPL 10
GenByte Џ1
GenCExt Џ1
GenMove Џ1
DevHostCPC Џ7
GetReg Џ1
Free Џ1
DevCPS Џ7
Identifier Џ4
Get Џ1
DevCPB Џ6
DevCPP Џ6
selector Џ1
DevHostCPV Џ5
Check Џ1
samples: 782 100%
in profiled modules 306 39%
other 476 61%
В этом примере около 37% замеренного периода времени было проведено в различных процедурах модуля DevCPT. Только процедура InsertImport отняла около 7% времени. Заметим, что процедуры, которые используют менее чем 1% времени, не показываются, поэтому сумма всех процедур DevCPT не составляет 37%.
Некоторое время может проводиться в неизмеренных модулях, или вообще не в модулях Компонентного Паскаля, а, например, в реализации файловой системы базовой операционной системы. По этим причинам, а также поскольку модули, использующие менее 1% времени, не показываются, сумма по всем модулям не составит 100%.
PROCEDURE SetProfileList
Эта процедура берет список выделенных имен модулей и регистрирует его. Список модулей будет профилироваться при вызове Start. Если нет выделения, будут профилироваться все модули из списка.
PROCEDURE SetModuleList (list: ARRAY OF CHAR)
Похожа на SetProfileList, но с явным параметром вместо неявного параметра - выделения. Эта процедура полезна, когда профилировщик вызывается из программы, а не интерактивно.
PROCEDURE Start
Начинает профилировку.
PROCEDURE Stop
Прекращает профилировку.
PROCEDURE ShowProfile
Показывает самый последний измеренный профиль в новом окне.
PROCEDURE Reset
Освобождает память, использованную профилировщиком, включая последний измеренный профиль и список модулей.
PROCEDURE Execute
Похожа на DevDebug.Execute. Время выполнения (в милисекундах) записывается в рабочий журнал.
| Dev/Docu/ru/Profiler.odc |
DevRBrowser
DEFINITION DevRBrowser;
PROCEDURE ShowRepository;
PROCEDURE Update;
PROCEDURE OpenFile (path, name: ARRAY OF CHAR);
PROCEDURE ShowFiles (path: ARRAY OF CHAR);
END DevRBrowser.
Этот инструментальный модуль позволяет перечислить все подсистемы в виде текстовых складок (-> StdFolds). Складка содержит ссылки на символьные, кодовые, исходные и документирующие файлы. Это облегчает обзор элементов больших приложений BlackBox, или самого BlackBox.
Для ресурсов подсистем создаются ссылки Rsrc. При щелчке на этой ссылке открывается список всех документов в поддиректории Rsrc.
For the documentation files, those which contain one or several dashes ("-") in their names are not treated as module documentations, but rather as auxiliary documentation files which are listed at the beginning. In particular, files with name Sys-Map, User-Man, and Dev-Man are extracted this way. They are the standard names for a map document which contains hyperlinks to the relevant files of the subsystems; the user manual for the subsystem (user in this context means a programmer); and the programmer's reference.
Файлы документации, имена которых содержат одно или несколько тире ("-"), трактуются не как документация модулей, но как вспомогательные файлы документации, и перечисляются вначале. В частности, файлы с именами Sys-Map, User-Man и Dev-Man извлекаются таким образом. Это стандартные имена для документа - карты, который содержит гиперссылки на основные файлы подсистем; руководство пользователя к подсистеме (пользователь в данном контексте понимается как программист); и описание программного интерфейса.
Команда меню:
"Repository" "" "DevRBrowser.ShowRepository" ""
PROCEDURE ShowRepository
Создает отчет со списком всех подсистем.
PROCEDURE Update
Обновляет отчет (использется как команда в ссылке update в начале генерируемого отчета).
PROCEDURE OpenFile (path, name: ARRAY OF CHAR)
Для внутреннего использования. Открывает файл в расположении path с именем name.
PROCEDURE ShowFiles (path: ARRAY OF CHAR)
Для внутреннего пользования. Перечисляет все документы ресурсоы в расположении path.
| Dev/Docu/ru/RBrowser.odc |
DevReferences
Редакция перевода: Ф.В.Ткачев, 2009-10-17
DEFINITION DevReferences;
IMPORT TextMappers, Files;
PROCEDURE ShowDocu;
PROCEDURE ShowDocuLang (lang: ARRAY OF CHAR);
PROCEDURE ShowSource;
PROCEDURE ShowText (module, ident: TextMappers.String; category: Files.Name);
END DevReferences.
Модуль предоставляет две команды, которые получают имена модулей или полные идентификаторы, ищут соответствующую документацию или исходный код.
Обычное меню:
MENU
"&Source" "" "DevReferences.ShowSource" "TextCmds.SelectionGuard"
"&Documentation" "" "DevReferences.ShowDocu" "TextCmds.SelectionGuard"
"Документация" "" "DevReferences.ShowDocuLang('ru')" "TextCmds.SelectionGuard"
END
PROCEDURE ShowDocu
Охрана: TextCmds.SelectionGuard
Ищет и показывает документацию для модуля, имя которого выделено. Если выделен полный идентификатор, то есть "module.ident", то в документации ищется пункт для "ident". "ident" должен быть записан там жирным шрифтом, меньшим, чем 14 пунктов. Документ должен быть расположен в папке Docu подсистемы, частью которой является модуль.
PROCEDURE ShowDocuLang (lang: ARRAY OF CHAR)
Guard: TextCmds.SelectionGuard
То же, что и ShowDocu, но поиск производится в подпапке lang папки Docu (например, в папке с именем lang='ru', т.е. в папке 'Docu/ru' хранятся переводы документации на русский язык).
PROCEDURE ShowSource
Охрана: TextCmds.SelectionGuard
Ищет и показывает исходник модуля, имя которого выделено. Если выделен полный идентификатор, то есть module.ident, то ищется соответствующий пункт документации. Он должен быть записан жирным шрифтом, меньшим, чем 14 пунктов. Документ должен быть расположен в папке Mod подсистемы модуля.
PROCEDURE ShowText (module, ident: TextMappers.String; category: Files.Name)
Для внутреннего использования.
| Dev/Docu/ru/References.odc |
DevSearch
Редакция перевода: Ф.В.Ткачев, 2009-10-17
DEFINITION DevSearch;
PROCEDURE Compare;
PROCEDURE SearchInDocu (opts: ARRAY OF CHAR);
PROCEDURE SearchInDocuLang (opts, lang: ARRAY OF CHAR);
PROCEDURE SearchInSources;
PROCEDURE SelectCaseInSens (pat: ARRAY OF CHAR);
PROCEDURE SelectCaseSens (pat: ARRAY OF CHAR);
END DevSearch.
Модуль предоставляет средства глобального поиска (в папках Docu или Mod), а также возможности сравнения текстов. Механизм поиска взаимодействует с модуле TextCmds и, в частности, использует его интерактор поиска и замены. Это означает, что если строка была найдена одной их команд поиска, то сразу после этого можно использовать текстовую команду "Find Again" (найти снова) для поиска других вхождений той же строки в том же тексте.
Типичное меню:
MENU
"Искать в исходниках" "" "TextCmds.InitFindDialog; DevSearch.SearchInSources" "TextCmds.SelectionGuard"
"Искать в документации (с учетом регистра)" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocu('s')" "TextCmds.SelectionGuard"
"Искать в руссой документации (с учетом регистра)" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocuLang('s','ru')" "TextCmds.SelectionGuard"
"Искать в документации (без учета регистра)" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocu('i')" "TextCmds.SelectionGuard"
"Сравнить тексты" "" "DevSearch.Compare" "TextCmds.FocusGuard"
END
PROCEDURE Compare
Охрана: два верхних окна содержат текстовые документы
Выполняет текстовое сравнение содержимого двух самых верхних окон.
Сравнение начинается в каждом окне с текущей позиции курсора или с конца выделенного фрагмента.
Очередное найденное отличие показывается курсором или выделением отличающихся фрагментов.
При сравнении игнорируются пробельные литеры (пробелы, табуляции, символы новой строки).
PROCEDURE SearchInSources
Охрана: TextCmds.SelectionGuard
Ищет выделенный текстовый фрагмент во всех доступных исходниках (во всех подсистемах). Поиск учитывает регистр.
PROCEDURE SearchInDocu (opts: ARRAY OF CHAR)
Охрана: TextCmds.SelectionGuard
Ищет выделенный текстовый фрагмент во всех доступных текстах документации (в папках Docu всех подсистем и в Руководствах).
Если строка opts начинается с 's' или 'S', то регистр при поиске не учитывается, если она начинается с 'i' или 'I', то учитывается, а во всех остальных случаях используется значение из диалога Find.
PROCEDURE SearchInDocu (opts, lang: ARRAY OF CHAR)
Охрана: TextCmds.SelectionGuard
То же, что SearchInDocu, но поиск производится в подпапках lang всех папок Docu (например, имя lang = 'ru' зарезервировано для папок с переводами документации на русский язык).
PROCEDURE SelectCaseInSens (pat: ARRAY OF CHAR)
Устанавливает TextCmds.find.find в pat, вызывает TextCmds.FindFirst и открывает диалог поиска. Эта процедура используется вьюшками-ссылками, созданными вышеописанной процедурой SearchInDocu, когда поиск был выполнен без учета регистра.
PROCEDURE SelectCaseSens (pat: ARRAY OF CHAR)
Устанавливает TextCmds.find.find в pat и вызывает TextCmds.FindFirst. Эта процедура используется ссылочными вьюшками-ссылками, созданными вышеописанными процедурами SearchInDocu и SearchInSource, когда поиск был выполнен с учетом регистра.
| Dev/Docu/ru/Search.odc |
DevSubTool
DEFINITION DevSubTool;
CONST
textCmds = 0; formCmds = 1; otherCmds = 2;
simpleView = 3; standardView = 4; complexView = 5;
wrapper = 6; specialContainer = 7; generalContainer = 8;
VAR
create: RECORD
subsystem: ARRAY 9 OF CHAR;
kind: INTEGER;
Create: PROCEDURE
END;
END DevSubTool.
Модуль DevSubTool предоставляет генератор кода (в виде "мастера"), который создает каркас исходного кода для типичной реализации отображения. Эти каркасы расширяются вашими собственными кусками кода и затем компилируются.
DevSubTool поддерживает несколько типов проектов, от простых текстовых команд до обобщенных контейнеров. Исходный документ(ы) всегда создается в виде новой подсистемы, то есть, поддиректории со структурой подсистемы (поддиректории Sym, Code, Docu, Mod).
Заметим, что инструмент использует шаблонные тексты, которые хранятся в директории Dev/Rsrc/New. Изучая эти тексты, в частности, более многосторонние шаблоны модель/отображение/команды, можно узнать многое о принятых в BlackBox принципах разработки и написания кода.
Обычная команда:
"Create Subsystem..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/SubTool', 'Create Subsystem')" ""
CONST textCmds
Это значение может быть присвоено create.kind, чтобы создать пакет команд для работы с текстом, то есть, модуль, который импортирует стандартную подсистему Text и расширяет ее своими собственным командами или интеракторами.
CONST formCmds
Это значение может быть присвоено create.kind, чтобы создать пакет команд для работы с формами, то есть, модуль, который импортирует стандартную подсистему Form и расширяет ее своими собственным командами или интеракторами.
CONST otherCmds
Это значение может быть присвоено create.kind, чтобы создать пакет произвольных команд, то есть, модуль, который расширяет BlackBox своими собственным командами или интеракторами.
CONST simpleView
Это значение может быть присвоено create.kind, чтобы создать реализацию простого отображения, которое не имеет модели. Отображение и его команды помещаются в один модуль. Отображение не экспортируется.
CONST standardView
Это значение может быть присвоено create.kind, чтобы создать реализацию отображения с моделью. Модель, отображение и его команды помещаются в один модуль. Модель и отображение не экспортируются.
CONST complexView
Это значение может быть присвоено trans.kind, чтобы создать реализацию отображения с моделью. Модель, отображение и его команды помещаются в отдельные модули. Модель и отображение экпортируются как описания типов, конкретные реализации создаются через объекты директорий.
Эта категория пока не поддерживается.
CONST wrapper
Это значение может быть присвоено trans.kind, чтобы создать реализацию обертки для обертывания произвольного отображения. Отображение-обертка и его команды помещаются в один модуль. Отображение не экспортируется.
Эта категория пока не поддерживается.
CONST specialContainer
Создает контейнер со статическим размещением и без собственного содержания, возможно, для помещения отображений только конкретного типа. Контейнерное отображение и его команды помещаются в один модуль. Контейнерное отображение не экспортируется.
CONST generalContainer
Создает контейнерное отображение с динамическим размещением, возможно, с некоторым собственным содержанием, и, возможно, для помещения отображений только конкретного типа. Модель, отображение и его команды помещаются в отдельные модули. Модель и отображение экспортируются как определения типов, конкретные реализации создаются через объекты директорий. Модель, отображение и диспетчер являются расширениями базовых типов в модуле Containers.
Эта категория пока не поддерживается.
VAR trans
Интерактор для переводного диалога.
subsystem: ARRAY 9 OF CHAR
Имя подсистемы, в которую надо перевести. Имя должно быть допустимым именем подсистемы, от 3 до 8 символов длиной, и начинаться с заглавной буквы.
kind: INTEGER kind IN {textCmds..generalContainer}
Тип программы, которую надо генерировать.
Create: PROCEDURE
Команда создания. На входе должно быть введено допустимое имя подсистемы. В результате создается новая подсистема.
Директория Dev/Rsrc/New содержит некоторое количество шаблонных документов. Create переводит некоторые из этих документов (в зависимости от kind), заменяя строки с атрибутом зачеркивания (как то: strikeout) именем подсистемы. Шаблонные файлы затем удаляются. | Dev/Docu/ru/SubTool.odc |
Карта подсистемы Dev
ENGLISH
Руководствопользователя
DevAlienTool показ информации о нелегалах
DevAnalyzer анализатор исходного кода
DevBrowser просмотр символьных файлов
DevCmds различные команды
DevComInterfaceGen создание интерфейсов
Автоматизации
DevCommanders интерпретаторы команд
DevCompiler компилятор с
Компонентного Паскаля
DevDebug символьный отладчик
DevDependencies показ графа модулей
DevHeapSpy визуальный показ кучи
DevInspector инспектор свойств элементов
управления
DevLinkChk проверка гиперссылок
DevLinker компоновщик
DevMarkers метки ошибок
DevMsgSpy журнал сообщений отображения
DevPacker упаковка файлов в EXE
DevProfiler статистический профилировщик
DevRBrowser просмотр хранилища компонентов
DevReferences символьный поиск
исходных текстов/документации
DevSearch глобальный инструмент поиска
DevSubTool генератор шаблонов
| Dev/Docu/ru/Sys-Map.odc |
Подсистема Dev
ENGLISH
Руководство пользователя
Содержание
1КомпиляциямодулейнаКомпонентномПаскале
2Инструментыдляпросмотра
3Загрузкаивыгрузкамодулей
4Выполнениекоманд
5Отладка
6Развертывание
7Кросс-платформенныевопросы
1 Компиляция модулей на Компонентном Паскале
Кроме поглощения сохраненных текстовых документов, компилятор Компонентного Паскаля может компилировать модули из любого места любого открытого текстового документа. Если начало модуля совпадает с началом текста, используйте команду Разработка->Компилировать (Dev>Compile). Если модуль начинается где-либо в середине текста, можно выделить его начало, например, двойным щелчком по ключевому слову MODULE, и затем применить команду Разработка->Компилировать выделенное (Dev->Compile Selection).
Чтобы откомпилировать сразу несколько модулей, необходимо создать список имен модулей в каком-либо документе, например:
FormModels FormViews FormControllers FormCmds
Выделяя часть списка, которую должен просмотреть компилятор и выполняя команду Разработка->Компилировать список модулей (Dev->Compile Module List), можно последовательно откомпилировать список модулей. Процесс компиляции прервется в случае, если будет встречен модуль с ошибкой. Компилятор докладывает об успехе или неудаче компиляции, выводя сообщения в системный рабочий журнал. Рабочий журнал - это специальный текст, отображаемый во вспомогательном окне. Он может быть открыт командой Инфо->Открыть журнал (Info->Open Log) и очищен командой Инфо->Очистить журнал (Info->Clear Log).
Рабочий журнал является инструментом разработки, так как в основном используется для задач программирования и отладки. Законченные приложения обычно его не отображают. Открывается журнал или нет при запуске BlackBox, определяет конфигурационный модуль Config (в директории System/Mod). Этот модуль может быть изменен программистом по желанию; по умолчанию его процедура Setup содержит только один оператор, который открывает окно журнала.
Разработка->Открыть список модулей (Dev->OpenModuleList) - удобная команда, которая открывает исходные тексты одного или нескольких модулей: выделите имя модуля, например, FormCmds и затем выполните Открыть список модулей. Эта команда может сэкономить вам уйму времени, если вы работаете со многими подсистемами одновременно.
При компиляции заново созданного или измененного модуля рекомендуется прямая компиляция текста программы через Разработка->Компилировать. В добавок к выводу в рабочий журнал, компилятор также вставляет маркеры ошибок в исходный текст и помещает каретку за первым из них, если будут обнаружены синтаксические ошибки. Каждый маркер представляет ошибку, найденную компилятором в исходном тексте. Обычно маркеры показываются в виде накрест перечеркнутых квадратиков. При двойном щелчке на нем маркер раскрывается в соответствующее сообщение об ошибке. Если каретка находится непосредственно за маркером, он может быть раскрыт командой Разработка->Раскрыть маркер ошибки (Dev->Toogle Error Mark), или ее клавиатурным эквивалентом.
Windows:
Внизу окна находится строка состояния. Когда пользователь щелкает на маркере ошибка, в эту строку выводится сообщение об ошибке. Маркер может быть раскрыт щелком с нажатой клавишей модификатора или двойным щелчком мышью на нем.
Команда Разработка->Следующая ошибка (Dev->Next Error) может использоваться для перехода к следующему маркеру. Разработка->Убрать маркеры ошибок (Dev->Unmark Errors) убирает из текста все выставленные маркеры. Однако эта команда требуется редко: компилятор автоматически убирает все старые маркеры после перекомпиляции текста; и при сохранении текста содержащиеся в нем маркеры отфильтровываются, то есть, они их не будет, когда текст будет открыт в следующий раз.
Если компилируемый модуль содержит одну или несколько ошибок, текст прокручивается к первой из них. Если этого не произошло, значит модуль успешно откомпилирован. В дополнение к такой обратной связи компилятор пишет число найденных ошибок в рабочий журнал. Если интерфейс модуля изменился по сравнению с предыдущей версией, то список изменений также заносится в журнал.
Успешная компиляция модуля порождает два файла: символьный и кодовый. Символьный файл содержит информацию об интерфейсе модуля, он используется компилятором для проверки содержимого импортируемых модулей. Кодовый файл содержит генерированный код (Intel386 под Windows, Motorola68020 на Macintosh). Содержимое кодового файла компонуется и загружается динамически при необходимости, таким образом, отпадает надобность в отдельном компоновщике.
Символьные файла нужны только в процессе разработки (используются компилятором и браузером интерфейса), но не нужны для запуска модулей. Символьный файл содержит в специальной кодировке интерфейс модуля, то есть, экспортированные константы, переменные, типы и процедуры. Если интерфейс модуля изменился и модуль перекомпилирован, то на диск записывается новый символьный файл. При компиляции модуля компилятор считывает символьные файлы всех импортируемых модулей. Эта информация используется для генерации кода, а также для проверки типов импортируемых идентификаторов.
После того, как интерфейс модуля изменен, все модули, которые его импортируют (то есть, его клиенты) должны быть перекомпилированы. Нужно перекомпилировать только те модули, которые действительно используют изменившиеся характеристики. Простое добавление новых элементов не мешает клиентам модуля: если вы экспортируете, например, еще одну процедуру, клиенты не нуждаются в перекомпиляции. Это также касается констант, переменных, типов, но не методов. Добавление метода считается не расширением, а модификацией интерфейса и требует перекомпиляции клиентов.
Кодовые файлы порождаются, но никогда не считываются при компиляции. Они необходимы для запуска модулей, то есть, динамический (редактирующий связи) загрузчик может их считывать. К ним можно относиться как к специальным облегченным DLL (библиотека динамической загрузки, dynamic link library).
См. также модули DevCompiler, DevCmds и DevMarkers.
2 Инструменты для просмотра
Основная причина ошибок времени компиляции - это неправильное использование интерфейсов. Для быстрого извлечения действительных объявлений элементов, экспортируемых модулями, можно использовать браузер. Интерфейс модуля показывается при выделении его имени и выполнении Инфо->Клиентский интерфейс (Info->Client Interface). Чтобы увидеть объявление отдельного элемента, например тип процедуры, следует выделить квалифицированное имя этого элемента, например, module.item, и выполнить ту же команду. Браузер покажет результат в окне, которое может быть использовано для дальнейшего просмотра. Команда Инфо->Клиентский интерфейс показывает только часть интерфейса модуля, которая имеет значение для клиентов, то есть, она не затрагивает методы, экспортированные только для реализации, и аналогичные элементы, которые имеют значение только при реализации объектных типов. Для этого существует команда Инфо->Расширяемый интерфейс (Info->Client Interface), которая показывает полный интерфейс.
Две связанных команды, Инфо->Исходный текст и Инфо->Документация (Info->Source и Info->Documentation), позволяют просматривать определения элементов в исходном файле или в сопроводительной документации, соответственно. Обе команды работают с выделенными именами модулей и с именами вида module.item так же, как команда Инфо->Интерфейс.
Основные команды текстового поиска - Инфо->Поиск в исходных текстах и Инфо->Поиск в документации (Info->SearchinSources и Info->SearchinDocu) ищут выделенную строку в доступных исходных файлах и, соответственно, файлах документации. Для исходных файлов это - глобальная директория Mod и директория Mod каждой подсистемы. Для файлов документации - глобальная директория Docu и директория Docu каждой подсистемы. Результатом этих команд является новый текст, который содержит гиперссылки на каждый файл, где была найдена строка, и количество вхождений для этого файла. Когда пользователь щелкает по ссылке, открывается соответствующий файл и выделяется первое вхождение искомой строки. Командой Текст->Искать снова (Text->Find Again) ищется следующее вхождение. Эти команды могут занять несколько минут.
См. также модули DevBrowser, DevReferences, DevSearch и DevDependencies.
3 Загрузка и выгрузка модулей
После того, как модуль успешно пройдет компиляцию, он может быть загружен в систему и использован. Загрузчик BlackBox динамически компонует и загружает модуль во время выполнения. Кодовый файл в основном представляет собой специфичную для языка облегченную DLL (dynamic link library). Загрузчик может быть запущен из программы вызовом процедуры Dialog.Call. Эта процедура принимает параметром имя команды. Она загружает модуль команды, если он еще не загружен. После этого она выполняет процедуру команды. Например,
Dialog.Call("DevDebug.ShowLoadedModules", "", res)
приводит к загрузке модуля DevDebug (если необходимо) и выполнению его процедуры ShowLoadedModules.
При попытке загрузки могут произойти следующие ошибки:
Кодовый файл не найден (Code file not found)
Не найден кодовый файл модуля.
Например, для загрузки модуля FormCmds требуется кодовый файл Form/Code/Cmds.
Поврежденный кодовый файл (Corrupted code file)
Кодовый файл модуля существует, но его внутренний формат неверен.
Объект не найден (Object not found)
Модуль пытается импортировать некоторый объект (константу, тип, переменную, процедуру) из другого модуля, в котором этот объект не экспортирован.
Противоречивый импорт объекта (Obect is inconsistently imported)
Модуль импортирует некоторый объект (константу, тип, переменную, процедуру) из другого модуля, где этот объект экспортирован, но с другой сигнатурой.
Такие противоречия обычно происходят, если интерфейс модуля изменяется (например, процедура приобретает дополнительный параметр), но после этого не все клиентские модули перекомпилируются. Другой причиной может быть то, что модуль, интерфейс которого изменился, не был перезагружен после компиляции. В этом случае все должно работать нормально, после того как он будет выгружен (или после перезапуска BlackBox).
Циклический импорт (Cyclic import)
Модули не могут импортировать друг друга циклически. Например, недопустимо, чтобы модуль А импортировал модуль В, модуль В импортировал модуль С, а модуль С импортировал модуль А.
Недостаточно памяти (Not enough memory)
Не хватает памяти для загрузки модуля.
Однажды загружен, модуль остается в системе, если не будет выгружен явно. Список загруженных в настоящий момент модулей выводит команда Инфо->Загруженные модули (Info->Loaded Modules).
Для использования новой версии модуля, который сейчас загружен, его следует сначала выгрузить.
Команда Разработка->Выгрузить (Dev->Unload) воспринимает имеющий фокус исходный текст модуля и пытается выгрузить соответствующий кодовый файл. Команда прерывается, если модуль в настоящий момент используется, то есть, если он импортирован по меньшей мере одним другим модулем, который тоже загружен. (В общем, модули могут освобождаться только сверху вниз.) Команда Разработка->Выгрузить список модулей (Dev->Unload Module List) воспринимает выделение, которое должно содержать последовательность имен модулей. Вы можете непосредственно использовать текст, созданный командой Загруженный модули.
См. также модуль DevDebug.
4 Выполнение команд
Есть несколько способов выполнить команды (то есть, процедуры, экспортированные модулями на Компонентном Паскале и предназначенные для прямого исполнения пользователями) из BlackBox. Имя команды может быть записано как текст, в форме "module.procedure", выделено и выполнено командой Разработка->Выполнить. Проще вставить коммандер перед именем команды, используя Инструменты->Вставить коммандер. При щелчке на коммандере строка, следующая за ним, интерпретируется как последовательность команд, например:
"Dialog.Beep; DevDebug.ShowLoadedModules"
Если строка содержит только одну команду, не имеющую параметров, ограничители строки могут быть опущены, как здесь:
Dialog.Beep
Используя подобные простые команды, возможно комбинировать выгрузку старой версии с выполнением новой версии команды (предоставленной ее модулем): щелчок с нажатой клавишей модификатора приводит к выгрузке модуля команды, загрузке его новой версии и исполнению процедуры. Однако такой "ярлык для выгрузки" работает только для модулей верхнего уровня, то есть, для модулей, которые не импортированы никакими другими модулями.
Список допустимых параметров для команд документирован в модуле StdInterpreter.
BlackBox Component Framework пытается вызывать команду Config.Setup при запуске. Вы можете изменить Config, чтобы создать вашу собственную загрузочную конфигурацию.
См. также модули DevDebug и Config.
5 Отладка
Когда случаются ошибки времени выполнения, например, деление на нуль или нарушение некоторого утверждения, открывается окно ловушки (trap window). Такое окно содержит текст, который показывает содержимое стека в момент сбоя. Извлечение из такого текста показано ниже:
index out of range
ObxTrap.Do [00000049H]
i INTEGER 777
str Dialog.String "String"
v Views.View [85D29730H]
StdInterpreter.CallProc [00000BC1H]
i Meta.Item
.obj SHORTINT 4
.typ SHORTINT 20
.vis SHORTINT 4
.adr LONGINT -2034827097
.mod undefined: 86B60000H
.desc undefined: 00000004H
.ptr Meta.ArrayPtr [85CDF4B0H]
mn Meta.Name "ObxTrap"
mod StdInterpreter.Ident "ObxTrap"
ok BOOLEAN TRUE
parType INTEGER 0
pn Meta.Name "Do"
proc StdInterpreter.Ident "Do"
StdInterpreter.Command [0000187EH]
left StdInterpreter.Ident "ObxTrap"
ptype INTEGER 0
right StdInterpreter.Ident "Do"
В первой строке приводится исключение или номер ловушки, например, "Индекс вышел за границы" или "TRAP 0". Ниже выводится последовательность активаций процедур, например, последней активной процедурой (где произошла ошибка) была ObxTrap.Do, которая была вызвана из StdInterperetter.CallProc, которая вызвана из StdInterpretter.Command и т.д. Каждая процедура помечается маленьким ромбиком слева от ее имени. Щелчок на ромбике дает новое окно, которое показывает глобальные переменные модуля, в котором объявлена процедура, например:
ObxTrap
global INTEGER 13
Метка ромбика справа от процедуры открывает исходный текст модуля, в котором объявлена процедура, выделяет инструкцию, которая была прервана, и прокручивает документ к этому месту. Конечно, это возможно только для модулей, исходный тексты которых доступны.
А теперь вернемся к дисплею стека. Строка под именем процедуры показывает параметры и локальные переменные процедуры, упорядоченные по алфавиту. Следующий пример
str Dialog.String "String"
означает, что локальная переменная str типа Dialog.String имеет значение "String" в момент сбоя. Если имя переменной показано курсивом, это означает параметр-переменную (то есть, представляющий другую переменную).
После переменной-указателя, значок ромбика позволяет проследовать по указателю к записи, на которую он указывает, например, указатель v
v Views.View [85D29730H]
может быть отслежен до записи
ObxTrap.Do:v^
[85D29730H] TextViews.StdViewDesc
.context Models.Context [85D29CC0H]
.era LONGINT 3
.guard LONGINT 0
.bad SET {}
.model Containers.Model [85D29780H]
.controller Containers.Controller [85D29A20H]
.alienCtrl Stores.Store NIL
.text TextModels.Model [85D29780H]
.org LONGINT 0
.dy LONGINT 0
.defRuler TextRulers.Ruler [85D29AD0H]
.defAttr TextModels.Attributes [85D29BD0H]
.hideMarks BOOLEAN TRUE
.cachedRd TextSetters.Reader [85D1A470H]
.trailer TextViews.Line [85D20390H]
.bot LONGINT 2339975
.setter TextSetters.Setter [85D29BF0H]
.setter0 TextSetters.Setter [85D29BF0H]
Такие дисплеи открываются в новом окне. Поля записи предваряются ".". В первой строке показан путь, которым вы пришли к записи. Если сделано более одного шага по ссылке, то ромбик на правом краю позволяет шаг за шагом вернуться назад.
Элементы массивов и поля записей скрыты в складках (см. StdFolds), которые могут открываться или закрываться щелчком мыши. Свертывание структурных типов данных позволяет легче ориентироваться в сложных ситуациях.
Заметьте, что отладчик находит исходные тексты только в том случае, если они расположены в правильном месте и имеют правильные имена, в соответствии с их подсистемами. Например, для модуля "FormViews", отладчик ищет файл Form/Mod/Views. Если файл находится где-либо еще, или имеет другое название, отладчик будет искать открытое окно с исходным текстом модуля. Если и это не удастся, будет выведено диалоговое окно, в котором пользователь сможет указать отладчику, где искать необходимый файл.
Когда сбой происходит в реализации отображения, например, в его процедуре Restore, произошедшая ошибка может привести позже к новой ошибке, например, из-за того, что процедура Restore при развертывании отображения будет вызвана снова. В худшем случае это может привести к нескончаемому потоку ошибок. BlackBox предупреждает такие ситуации, частично отключая сбойное отображение. Такое отображение накрывается светло-серым прямоугольником; его содержимое не будет обновляться. Однако в остальном поведение отображения остается в целости, то есть, оно может быть сохранено в файл. Если сохранение вызовет сбой, то отображение будет превращено в нелегальное (alien); при этом оно крест накрест перечеркивается. Однако остальная часть контейнерного документа все еще может быть сохранена.
BlackBox различает три категории сбоев в отображении:
при обновлении: сбой в процедурах Restore или RestoreMarks
при сохранении: сбой процедурах Internalize или Externalize
другие: сбой в какой-либо другой процедуре отображения.
Если происходит сбой в одной из этих категорий, такое поведение отключается (то есть, система не будет вызывать снова процедуры из этой категории), поведение из других категорий остается в целости. В худшем случае отображение может вызвать три сбоя, по одному из каждой категории.
Это значит, что сбойные отображения "изящно деградируют", замораживая только то поведение, которое виновато в сбое. Если имеются причины, чтобы "разморозить" отображение, можно использовать команду Dev->Revalidate View.
Бесконечный цикл можно прервать нажатием ctrl-break (Windows 95/NT) / command-option-. (Mac OS).
The following standard traps may occur at run-time (depending on the platform, some of these errors don't occur):
Во время выполнения могут происходить следующие стандартные ошибки:
недопустимый WITH invalid WITH
недопустимый CASE invalid CASE
функция без возврата значения function without return
охрана типа type guard
значение вне допустимых границ value out of range
индекс вне допустимых границ index out of range
строка слишком длинная string too long
переполнение стека stack overflow
переполнение целого типа integer overflow
деление на нуль division by zero
бесконечный действительный результат infinite real result
потеря значимости действительного типа real underflow
переполнение действительного типа real overflow
неопределенный действительный результат undefined real result
не является числом not a number
прерывание с клавиатуры keyboard interrupt
разыменование NIL NIL dereference
недопустимая инструкция illegal instruction
разыменование NIL (чтение) NIL dereference (read)
недопустимое чтение памяти illegal memory read
разыменование NIL (запись) NIL dereference (write)
недопустимая запись в память illegal memory write
вызов процедуры по NIL NIL procedure call
недопустимое выполнение illegal execution
недостаточно памяти out of memory
ошибка шины bus error
ошибка адреса address error
ошибка сопроцессора fpu error
исключение exception
Кроме этих стадартных сбоев, существуют заказные сбои. Каждый заказной сбой имеет номер, ассоциированный с ним. Используются следующие соглашения:
Не занято ЏЏ0 .. Џ19
Предусловия Џ20 .. Џ59
Постусловия Џ60 .. Џ99
Инварианты 100 .. 120
Зарезервировано 121 .. 125
Пока не реализовано 126
Зарезервировано 127
Вы можете свободно использовать коды 0..19 в ваших программах, обычно в качестве временных точек останова при отладке. По соглашению, остальные коды сбоев генерируются различными проверками условий (assertions), то есть, операторами, которые проверяют определенное условие и прерывают выполнение, если условия нарушены. Условия, которые должны быть соблюдены при входе в процедуру, называются предусловиями, условия, которые должны быть соблюдены при выходу из процедуры - постусловия, а условия, которые должны соблюдаться во время выполнения, называются инвариантами. Большинство процедур в BlackBox Component Framework проверяют некоторые предусловия. Номер заказного сбоя уникален внутри процедуры. Таким образом, в случае сбоя обратитесь к документации (или исходному тексту, если он доступен) сбойной процедуры. Там вы сможете получить больше информации о причине сбоя.
Разработчик может также предоставить текстовое описание причины сбоя в файле ресурсов подсистемы: имя модуля без префикса подсистемы, затем "." затем имя процедуры, ".", номер сбоя. Например:
Math.Power.23 Pre: x # 1.0 OR ABS(y) # INF
Views.View.CopyFrom.20 Views.CopyFrom and Views.CopyFromModelView must not both
be overwritten
Если существует такой ресурс, то соответствующий текст выводится в окне сбоя.
Следует заметить, что никогда во время отладки нет нужды покидать обычную среду BlackBox Component Builder, нет никакого специального "режима отладки" или "отладочной среды", все интегрировано вместе!
Пример: ObxTrapdocu
Отладчик BlackBox - это нечто среднее между "посмертным отладчиком" и отладчиком "времени выполнения". Он срабатывает после того, как команда вызвала сбой (посмертно), но не прерывает работу окружения BlackBox (время выполнения). Некоторые средства, такие как Инфо->Показать состояние (Info->View State), которые позволяют отслеживать структуры данных, начиная с выделенного отображения, обычно ассоциируются только с отладчиками времени выполнения.
Это типично для объектно-ориентированных программ, когда их управляющие потоки внезапно сворачиваются и становятся сложными для исследования. Следовательно, выполнение программ шаг за шагом (пошаговое), по сообщениям или по вызовам процедур на практике становится непрактичным при отладке сложных систем. Вместо этого BlackBox предлагает более эффективную стратегию отладки:
Пусть ошибка сообщит о себе как можно больше.
Вместо ожидания какой-либо ошибки и дальнейших попыток найти путь назад - к ее причине, позволим ошибке сигнализировать о своей причине, насколько это возможно. Только этот путь действительно экономит время отладки. Реализация языка следует этой стратегии, проверяя индексы и границы при доступе к массивам, разыменование указателей со значением NIL, и т.д. В дополнение к таким встроенным проверкам, Компнентный Паскаль предоставляет стандартную процедуру ASSERT, которая позволяет проверить соблюдение любых условий. Если условие нарушено, открывается окно сбоя. Процедуры BlackBox Component Framework последовательно применяют проверки условий (assertions), например, в начале процедуры для проверки, верны ли переданные значения параметров. Это предпочительнее, чем позволить процедуре, получившей неверные значения, поставить под угрозу работу системы.
Такое оборонительная стратегия программирования оправдывала себя снова и снова при разработке BlackBox, и она сильно рекомендуется для серьезных разработок.
См. также модуль DevDebug.
6 Развертывание
Если вы разрабатываете добавочные компоненты (например, новые подсистемы) для BlackBox, развертывание сводится к простому распространению копии директории вашей подсистемы. Вы можете не желать распространять исходные тексты, в целях защиты ваших прав на интелектуальную собственность. В этом случае вам не следует помещать исходные тексты в распространяемые копии. Вы можете не желать делать один или несколько ваших интерфейсов модулей открытыми, или никаких вообще, если ваше приложение не предусматривает расширяемости. В этом случае вам не следует помещать соответствующие символьные файлы в распроняемые копии. Однако для каждого открытого модуля вам следует поместить файл документации в директории Docu подсистемы. Например, для модуля FormCmds файл будет называться Form/Docu/Cmds.
Традиционно в директорию Docu помещается файл Sys-Map. Этот текст-карта содержит список всех открытых модулей; элементы списка являются гиперссылками.
Если подсистема реализует элементы пользовательского интерфейса, такие как отображения или команды, должно быть предоставлено руководство пользователя. Этот документ называется User-Man и тоже размещается в директории Docu.
Если подсистема задумана для использования программистами и если не достаточно документации к отдельным модулям, директория Docu должна содержать обзорный текст, называемый Dev-Man.
В предыдущем объекте рассказано все, что касается распространения добавочных компонентов, то есть расширений в форме подсистем. С другой стороны, если вы хотите по некоторым причинам распространять отдельное приложение, для вас открываются три возможности:
1) Этот метод предназначен для приложений, которые часто расширяются и обновляются: вы предоставляете нескомпонованные кодовые файлы вашего приложения и среды BlackBox, вместе с минимальным компонованным приложением для загрузки полной программной системы.
Чтобы сделать неупакованную и некомпонованную отдельную версию, вам необходимо скопировать некоторые файлы и директории из BlackBox в новую директорию. Вот что вам нужно (и позволено) скопировать:
все стандартные директории BlackBox с их поддиректориями Code и Rsrc, за исключением Obx и Dev, директории ваших собственных подсистем; и файл BlackBox.exe, который можно переименовать в соответствии с названием вашего нового приложения.
2) Этот метод предназначен для приложений, которые закрыты или постепенные обновления и расширения относительно редки: вы упаковываете содержимое директории BlackBox в один большой исполняемый файл. В отличие от компоновщика (linker), упаковщик не ограничен только кодовыми файлами; им также можно упаковывать ресурсы, документацию и любой другой вид файлов в приложении. В отличие от метода 1), пользователь не может легко повредить приложения удалением части кода или ресурсных файлов. См. подробности в документацииупаковщика.
3) Этот метод больше всего подходит для традиционных приложений (то есть, приложений на Компонентном Паскале, которые не используют среду BlackBox) и для компонованных библиотек (DLL под Windows): вы используете компоновщик, чтобы собрать несколько кодовых файлов в один файл приложения.
Для компонованной версии вам необходимо использовать компоновщик, чтобы запаковать ваши кодовые файлы вместе с кодовыми файлами BlackBox в единое приложение. См. детали в документациикомпоновщика. После компоновки вам нужно копировать новое приложение в новую директорию. Вам также нужно скопировать поддиректори Rsrc подсистем Form, Host, Std, System, Text и ваших собственных подсистем. Если отсутствуют файлы ресурсов, приложение все же будет работать, но утратит все связи строк, все разметки диалоговых окон и все собственные меню.
Для всех методов:
В дополнение вы можете создать вашу собственную версию файла описания меню и диалогового окна О программе... / About... (System/Rsrc/Menus System/Rsrc/About). Если для ваше приложение задумано расширяемым, вам также следует копировать символьные файлы (Sym/Abc) всех модулей, интерфейсы которых должны быть открытыми. Это может касаться или не касаться стандартных модулей BlackBox. Убедитесь, что структура ваших новых директорий соответствует структуре поддиректорий в исходной директории BlackBox!
Windows:
Адаптируйте подходящим образом меню Помощь и соответствующий текст.
Mac OS:
Отредактируйте текст Help в директории System/Rsrc подходящим образом.
Windows:
В тексте readme в директории Dev/Install описывается коммерческая установочная программа, которая используется дистрибутивом BlackBox. Вы можете захотеть использовать установочный скрипт BlackBox как основу для вашего собственного. Когда вы используете этот инструмент, большинство ручных копирований, описанных выше, становится ненужными.
Заметим, что все равно имеет смысл создавать упрощенную копию вашей рабочей среды (для испытания в реалистичных условиях), даже если вы используете инструмент компилятора.
Для распространения программного обеспечения в электронном виде по каналам, которые не поддерживают двоичные данные, например, по e-mail, доступен стандартныйASCII-кодировщик.
7 Кросс-платформенные вопросы
Если вы используете BlackBox и на Mac OS, и на Windows, вы будете постоянно переносить документы между двумя платформами. Кодовые файлы не могут быть перенесены, так как их форматы непортируемы. Чтобы упростить перенос документов, вам следует настроить доступные инструменты (например, программу Apple PCExchange), чтобы они могли переводить тип файла MacOS ("oODC") и конструктор файла ("obnF") в расширение имени файла Windows ".odc" и наоборот.
Кроме того, вы можете захотеть использовать шрифты, которые доступны на обоих платформах, шрифты TrueType или PostScript, если имеется Adobe Type Manager. Если эквивалентных шрифтов на обоих платформах нет, вы все же сможете прочитать текст с другим, корректно замененным шрифтом. Вероятно, это приведет к неудовлетворительным результатам.
Используйте шрифт по умолчанию для кросс-платформенных документов, если вы не имеете предпочтений к особому шрифту. Обычно для сопроводительной документации используется шрифт по умолчанию. Такой шрифт автоматически адаптируется к конфигурации системы, кроме того, им может быть назначен любой препочитаемый шрифт.
Подобно любому другому документу, диалоговые окна могут переноситься между двумя платформами. Однако для лучшего результата вы должны хорошо подобрать размещение элементов управления в диалоговых окнах перед тем, как их распространять.
Чтобы минимизировать проблемы с установкой, рекомендуется ограничивать имена модулей максимум восемью символами (без учета префикса подсистемы, который сам может состоять из восьми символов) и не использовать имена модулей, которые отличаются только прописными и строчными буквами.
| Dev/Docu/ru/User-Man.odc |
MODULE DevAlienTool;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Services, Ports, Stores, Models, Views, Controllers, Properties, Dialog, Containers, Documents,
TextModels, TextMappers, TextViews, StdFolds;
PROCEDURE Indent (VAR f: TextMappers.Formatter; level: INTEGER);
BEGIN
WHILE level > 0 DO f.WriteTab; DEC(level) END
END Indent;
PROCEDURE WriteCause (VAR f: TextMappers.Formatter; cause: INTEGER);
BEGIN
f.rider.SetAttr(TextModels.NewColor(f.rider.attr, Ports.red));
CASE cause OF
| Stores.typeNotFound: f.WriteString("type in module not found")
| Stores.inconsModuleVersion: f.WriteString("inconsistent module version")
| Stores.invalidModuleFile: f.WriteString("invalid module file")
| Stores.moduleFileNotFound: f.WriteString("module not found")
| Stores.inconsistentType: f.WriteString("type path in module inconsistent with stored version")
| Stores.inconsistentVersion: f.WriteString("inconsistent version / program error")
| Stores.alienVersion: f.WriteString("alien version - outdated program")
| Stores.alienComponent: f.WriteString("alien component - required sub-part failed to internalize")
ELSE f.WriteString("unknown (code"); f.WriteInt(cause); f.WriteChar(")")
END;
f.rider.SetAttr(TextModels.NewColor(f.rider.attr, Ports.black));
END WriteCause;
PROCEDURE Out (VAR f: TextMappers.Formatter; level: INTEGER; st: Stores.Store);
VAR t: Stores.TypeName;
PROCEDURE OutAlien (VAR f: TextMappers.Formatter;
path: Stores.TypePath; cause: INTEGER; c: Stores.AlienComp);
VAR i: INTEGER; t: TextModels.Model; form: TextMappers.Formatter;
BEGIN
f.WriteString(" ");
t := TextModels.dir.New(); form.ConnectTo(t);
form.rider.SetAttr(TextModels.NewColor(form.rider.attr, Ports.blue));
form.WriteString(path[0]);
form.rider.SetAttr(TextModels.NewColor(form.rider.attr, Ports.black));
form.WriteLn;
INC(level);
IF path[1] # "" THEN
Indent(form, level); form.WriteString("path: (");
i := 1;
WHILE path[i] # "" DO
form.WriteString(path[i]);
INC(i);
IF path[i] # "" THEN form.WriteString(", ") END
END;
form.WriteChar(")"); form.WriteLn
END;
Indent(form, level); form.WriteString("cause: "); WriteCause(form, cause); form.WriteLn;
Indent(form, level); form.WriteString("comps: "); form.WriteLn;
INC(level);
WHILE c # NIL DO
WITH c: Stores.AlienPiece DO
Indent(form, level); form.WriteInt(c.len); form.WriteString(" bytes data"); form.WriteLn
| c: Stores.AlienPart DO
IF c.store # NIL THEN
Out(form, level, c.store)
ELSE Indent(form, level); form.WriteString("NIL reference"); form.WriteLn
END
END;
c := c.next
END;
DEC(level, 2);
Indent(form, level);
f.WriteView(StdFolds.dir.New(StdFolds.collapsed, "", t));
f.rider.SetAttr(TextModels.NewColor(f.rider.attr, Ports.blue));
f.WriteString(path[0]);
f.rider.SetAttr(TextModels.NewColor(f.rider.attr, Ports.black));
f.WriteView(StdFolds.dir.New(StdFolds.collapsed, "", NIL));
f.WriteLn;
END OutAlien;
BEGIN
Indent(f, level);
WITH st: Stores.Alien DO
f.WriteString("Alien Store"); OutAlien(f, st.path, st.cause, st.comps)
ELSE
Services.GetTypeName(st, t);
WITH st: Documents.Document DO f.WriteString("Document")
| st: Containers.Controller DO f.WriteString("Container Controller")
| st: Containers.View DO f.WriteString("Container View")
| st: Containers.Model DO f.WriteString("Container Model")
| st: Controllers.Controller DO f.WriteString("Controller")
| st: Views.View DO f.WriteString("View")
| st: Models.Model DO f.WriteString("Model")
ELSE f.WriteString("Store")
END;
f.WriteString(' "'); f.WriteString(t); f.WriteChar('"'); f.WriteLn
END
END Out;
PROCEDURE Analyze*;
VAR v: Views.View; f: TextMappers.Formatter; d: Documents.Document;
ops: Controllers.PollOpsMsg; bp: Properties.BoundsPref; t: TextModels.Model;
BEGIN
Controllers.PollOps(ops); v := ops.singleton;
IF v # NIL THEN
IF v IS Views.Alien THEN
t := TextModels.dir.New();
f.ConnectTo(t);
Out(f, 0, v(Views.Alien).store);
StdFolds.ExpandFolds(t, FALSE, "");
v := TextViews.dir.New(t);
Views.OpenAux(v, "Alien Info");
(*
bp.w := Views.undefined; bp.h := Views.undefined;
Views.HandlePropMsg(v, bp);
d := Documents.dir.New(v, bp.w, bp.h);
Views.OpenAux(d, "Alien Info")
*)
ELSE Dialog.ShowMsg("#Dev:NoAlienView")
END
ELSE Dialog.ShowMsg("#Dev:NoSingletonFound")
END
END Analyze;
END DevAlienTool.
Strings
NoAlienView no alien view
NoSingletonFound no singleton found
Info
SEPARATOR
"&Aliens" "" "DevAlienTool.Analyze" "DevAlienTool.SingletonGuard"
END
C | Dev/Mod/AlienTool.odc |
MODULE DevAnalyzer;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
TextMappers, TextModels, TextViews, DevMarkers, Stores, Models, Kernel, Dialog, StdLog, Files,
CPT := DevCPT, CPS := DevCPS, CPM := DevCPM, CPB := DevCPB, HostRegistry;
CONST
(* numtyp values *)
char = 1; integer = 2; real = 4; int64 = 5; real32 = 6; real64 = 7;
(*symbol values*)
null = 0; times = 1;
and = 5; plus = 6; minus = 7; or = 8; eql = 9;
leq = 12; geq = 14;
in = 15; is = 16; arrow = 17; dollar = 18; period = 19;
comma = 20; colon = 21; upto = 22; rparen = 23; rbrak = 24;
rbrace = 25; of = 26; then = 27; do = 28; to = 29;
by = 30; not = 33;
lparen = 40; lbrak = 41; lbrace = 42; becomes = 44;
number = 45; nil = 46; string = 47; ident = 48; semicolon = 49;
bar = 50; end = 51; else = 52; elsif = 53; until = 54;
if = 55; case = 56; while = 57; repeat = 58; for = 59;
loop = 60; with = 61; exit = 62; return = 63; array = 64;
record = 65; pointer = 66; begin = 67; const = 68; type = 69;
var = 70; out = 71; procedure = 72; close = 73; import = 74;
module = 75; eof = 76;
(* object modes *)
Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7;
SProc = 8; CProc = 9; IProc = 10; Mod = 11; TProc = 13; Attr = 20;
(* Structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Set = 9;
Pointer = 13; ProcTyp = 14; Comp = 15;
Char16 = 16; Int64 = 18;
intSet = {Int8..Int32, Int64}; charSet = {Char8, Char16};
(* composite structure forms *)
Basic = 1; Array = 2; DynArr = 3; Record = 4;
(*function number*)
newfn = 1; incfn = 13; sysnewfn = 30;
(*<< function number*)
ordfn = 4;
minfn = 7; maxfn = 8; chrfn = 9;
sizefn = 12; decfn = 14;
inclfn = 15; exclfn = 16; lenfn = 17; bitsfn = 37;
(*<< SYSTEM function number*)
adrfn = 20;
getfn = 24; getrfn = 26;
valfn = 29;
(* nodes classes *)
Nvar = 0; Nvarpar = 1; Nfield = 2; Nderef = 3; Nindex = 4;
Nconst = 7; Ntype = 8; Nproc = 9; Ncall = 13;
Nif = 15; Ncaselse = 16; Ncasedo = 17;
Nifelse = 20; Ncase = 21; Nwhile = 22; Nrepeat = 23; Nloop = 24; Nexit = 25;
Nwith = 27; Ncomp = 30;
(* node subclasses *)
super = 1;
(* module visibility of objects *)
internal = 0; external = 1; externalR = 2; inPar = 3; outPar = 4;
(* procedure flags (conval.setval) *)
hasBody = 1; isRedef = 2;
(* attribute flags (attr.adr, struct.attribute, proc.conval.setval)*)
newAttr = 16; absAttr = 17; limAttr = 18; empAttr = 19; extAttr = 20;
(* case statement flags (conval.setval) *)
useTable = 1; useTree = 2;
(* sysflags *)
inBit = 2; outBit = 4; newBit = 8; iidBit = 16; interface = 10;
clean = CPM.ConstNotAlloc; (*<< values for obj.linkadr: untouched *)
used = clean+1; usedSet = clean+2; set = clean+3; (*<< used, used then set, set *)
setUsed = clean+4; setUsedP = clean+5; (*<< set then used, possibly set and used (var par) *)
noChange = (setUsedP+15) DIV 16 * 16; (*<< for loop variables shouldn't be changed *)
(*<< error messages *)
neverUsed = 900; neverSet = 901; usedBSet = 902; setBNUsed = 903; usedVarPar = 904;
outerScope = 905; interAcc = 906; (*redefinition = 907; newdefinition = 908;*)
statAfterRetEx = 909; loopVarSet = 910; (*impliedTypeGuard = 911;*)
superfluousTypeGuard = 912; evaluationSeq = 913; superfluousShort = 914;
semicolons = 930; (*<< special stuff *)
(*<< selector flags for Selector *)
SelAssign = TRUE; SelNoAssign = FALSE;
SelVarPar = TRUE; SelNoVarPar = FALSE;
SelUseBSet = TRUE; SelNoUseBSet = FALSE;
Version = "DevAnalyzer for Component Pascal (c) SHML 24 Mar 1998";
OptionsFile = "AnaOpt"; OptionsType = "opt"; OptionsPath = "Dev/Rsrc"; (*<<O/F*)
regKey = "Dev\Analyzer\";
TYPE
Elem = POINTER TO RECORD
next: Elem;
struct: CPT.Struct;
obj, base: CPT.Object;
pos: INTEGER;
name: CPT.String
END;
Warning = POINTER TO RECORD (*<< list of warning positions *)
next: Warning;
n: SHORTINT;
pos: INTEGER
END;
VAR
options*: RECORD (*<<O/F*)
varpar*, exported*, intermediate*, levels*, tbProcs*,
sideEffects*, semicolons*: BOOLEAN;
statements-: INTEGER; fileName-: TextMappers.String
END;
errHead: Warning; (*<< root for warning position list *)
nofStats: INTEGER; (*<< number of statements in module *)
sourceR: TextModels.Reader;
str: Dialog.String;
sym, level: BYTE;
LoopLevel: SHORTINT;
TDinit, lastTDinit: CPT.Node;
userList: Elem;
recList: Elem;
hasReturn: BOOLEAN;
PROCEDURE^ Type(VAR typ: CPT.Struct; VAR name: CPT.String);
PROCEDURE^ Expression(VAR x: CPT.Node);
PROCEDURE^ Block(VAR procdec, statseq: CPT.Node);
(* forward type handling *)
PROCEDURE IncompleteType (typ: CPT.Struct): BOOLEAN;
BEGIN
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
RETURN (typ = CPT.undftyp) OR (typ.comp = Record) & (typ.BaseTyp = CPT.undftyp)
END IncompleteType;
PROCEDURE SetType (struct: CPT.Struct; obj: CPT.Object; typ: CPT.Struct; name: CPT.String);
VAR u: Elem;
BEGIN
IF obj # NIL THEN obj.typ := typ ELSE struct.BaseTyp := typ END;
IF name # NIL THEN
NEW(u); u.struct := struct; u.obj := obj; u.pos := CPM.errpos; u.name := name;
u.next := userList; userList := u
END
END SetType;
PROCEDURE CheckAlloc (VAR typ: CPT.Struct; dynAllowed: BOOLEAN; pos: INTEGER);
BEGIN
typ.pvused := TRUE;
IF typ.comp = DynArr THEN
IF ~dynAllowed THEN CPM.Mark(88, pos); typ := CPT.undftyp END
ELSIF typ.comp = Record THEN
IF (typ.attribute = absAttr) OR (typ.attribute = limAttr) & (typ.mno # 0) THEN
CPM.Mark(193, pos); typ := CPT.undftyp
END
END
END CheckAlloc;
PROCEDURE CheckRecursiveType (outer, inner: CPT.Struct; pos: INTEGER);
VAR fld: CPT.Object;
BEGIN
IF outer = inner THEN CPM.Mark(58, pos)
ELSIF inner.comp IN {Array, DynArr} THEN CheckRecursiveType(outer, inner.BaseTyp, pos)
ELSIF inner.comp = Record THEN
fld := inner.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
CheckRecursiveType(outer, fld.typ, pos);
fld := fld.link
END;
IF inner.BaseTyp # NIL THEN CheckRecursiveType(outer, inner.BaseTyp, pos) END
END
END CheckRecursiveType;
PROCEDURE FixType (struct: CPT.Struct; obj: CPT.Object; typ: CPT.Struct; pos: INTEGER); (* fix forward reference *)
VAR t: CPT.Struct; f, bf: CPT.Object; i: SHORTINT;
BEGIN
IF obj # NIL THEN
IF obj.mode = Var THEN (* variable type *)
IF struct # NIL THEN (* receiver type *)
IF (typ.form # Pointer) OR (typ.BaseTyp # struct) THEN CPM.Mark(180, pos) END
ELSE CheckAlloc(typ, obj.mnolev > level, pos) (* TRUE for parameters *)
END
ELSIF obj.mode = VarPar THEN (* varpar type *)
IF struct # NIL THEN (* varpar receiver type *)
IF typ # struct THEN CPM.Mark(180, pos) END
END
ELSIF obj.mode = Fld THEN (* field type *)
CheckAlloc(typ, FALSE, pos);
CheckRecursiveType(struct, typ, pos)
ELSIF obj.mode = TProc THEN (* proc return type *)
IF typ.form = Comp THEN typ := CPT.undftyp; CPM.Mark(54, pos) END
ELSIF obj.mode = Typ THEN (* alias type *)
IF typ.form IN {Byte..Set, Char16, Int64} THEN (* make alias structure *)
t := CPT.NewStr(typ.form, Basic); i := t.ref;
t^ := typ^; t.ref := i; t.strobj := obj; t.mno := 0;
t.BaseTyp := typ; typ := t
END;
IF obj.vis # internal THEN
IF typ.comp = Record THEN typ.exp := TRUE
ELSIF typ.form = Pointer THEN typ.BaseTyp.exp := TRUE
END
END
ELSE HALT(100)
END;
obj.typ := typ
ELSE
IF struct.form = Pointer THEN (* pointer base type *)
IF typ.comp = Record THEN CPM.PropagateRecPtrSysFlag(typ.sysflag, struct.sysflag)
ELSIF typ.comp IN {Array, DynArr} THEN CPM.PropagateArrPtrSysFlag(typ.sysflag, struct.sysflag)
ELSE typ := CPT.undftyp; CPM.Mark(57, pos)
END;
struct.untagged := struct.sysflag # 0;
IF (struct.strobj # NIL) & (struct.strobj.vis # internal) THEN typ.exp := TRUE END
ELSIF struct.comp = Array THEN (* array base type *)
CheckAlloc(typ, FALSE, pos);
CheckRecursiveType(struct, typ, pos)
ELSIF struct.comp = DynArr THEN (* array base type *)
CheckAlloc(typ, TRUE, pos);
CheckRecursiveType(struct, typ, pos)
ELSIF struct.comp = Record THEN (* record base type *)
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
typ.pvused := TRUE; struct.extlev := SHORT(SHORT(typ.extlev + 1));
CPM.PropagateRecordSysFlag(typ.sysflag, struct.sysflag);
IF (typ.attribute = 0) OR (typ.attribute = limAttr) & (typ.mno # 0) THEN CPM.Mark(181, pos)
ELSIF (struct.attribute = absAttr) & (typ.attribute # absAttr) THEN CPM.Mark(191, pos)
ELSIF (typ.attribute = limAttr) & (struct.attribute # limAttr) THEN CPM.Mark(197, pos)
END;
f := struct.link;
WHILE f # NIL DO (* check for field name conflicts *)
CPT.FindField(f.name, typ, bf);
IF bf # NIL THEN CPM.Mark(1, pos) END;
f := f.link
END;
CheckRecursiveType(struct, typ, pos);
struct.untagged := struct.sysflag # 0
ELSIF struct.form = ProcTyp THEN (* proc type return type *)
IF typ.form = Comp THEN typ := CPT.undftyp; CPM.Mark(54, pos) END;
ELSE HALT(100)
END;
struct.BaseTyp := typ
END
END FixType;
PROCEDURE CheckForwardTypes;
VAR u, next: Elem; progress: BOOLEAN;
BEGIN
u := userList; userList := NIL;
WHILE u # NIL DO
next := u.next; CPS.name := u.name^$; CPT.Find(CPS.name, u.base);
IF u.base = NIL THEN CPM.Mark(0, u.pos)
ELSIF u.base.mode # Typ THEN CPM.Mark(72, u.pos)
ELSE u.next := userList; userList := u; (* reinsert *)
IF u.base.num < set THEN (* BJ: If already also used, don't reset *)
u.base.num := set (*<< forward types are set by default *)
END
END;
u := next
END;
REPEAT (* iteration for multy level alias *)
u := userList; userList := NIL; progress := FALSE;
WHILE u # NIL DO
next := u.next;
IF IncompleteType(u.base.typ) THEN
u.next := userList; userList := u (* reinsert *)
ELSE
progress := TRUE;
FixType(u.struct, u.obj, u.base.typ, u.pos)
END;
u := next
END
UNTIL (userList = NIL) OR ~progress;
u := userList; (* remaining type relations are cyclic *)
WHILE u # NIL DO
IF (u.obj = NIL) OR (u.obj.mode = Typ) THEN CPM.Mark(58, u.pos) END;
u := u.next
END
END CheckForwardTypes;
PROCEDURE CheckUnimpl (m: CPT.Object; typ: CPT.Struct; pos: INTEGER);
VAR obj: CPT.Object;
BEGIN
IF m # NIL THEN
IF (m.mode = TProc) & (absAttr IN m.conval.setval) THEN
CPT.FindField(m.name^, typ, obj);
IF (obj = NIL) OR (obj.mode # TProc) OR (absAttr IN obj.conval.setval) THEN
CPM.Mark(192, pos);
CPM.LogWLn; CPM.LogWStr(" "); CPM.LogWStr(m.name^);
CPM.LogWStr(" not implemented in "); CPM.LogWStr(typ.strobj.name^)
END
END;
CheckUnimpl(m.left, typ, pos);
CheckUnimpl(m.right, typ, pos)
END
END CheckUnimpl;
PROCEDURE CheckRecords (rec: Elem);
VAR b: CPT.Struct;
BEGIN
WHILE rec # NIL DO (* check for unimplemented methods in base type *)
b := rec.struct.BaseTyp;
WHILE (b # NIL) & (b # CPT.undftyp) DO
CheckUnimpl(b.link, rec.struct, rec.pos);
b := b.BaseTyp
END;
rec := rec.next
END
END CheckRecords;
PROCEDURE err(n: SHORTINT);
BEGIN CPM.err(n)
END err;
PROCEDURE CheckSym(s: SHORTINT);
BEGIN
IF sym = s THEN CPS.Get(sym) ELSE CPM.err(s) END
END CheckSym;
PROCEDURE err2(n: SHORTINT; pos: INTEGER); (*<<*)
VAR e, h: Warning;
BEGIN
e := errHead;
WHILE (e.next # NIL) & (e.next.pos < pos) DO e := e.next END;
IF e.next = NIL THEN
NEW(e.next); h := e.next (* end of list *)
ELSIF (e.next.pos = pos) & (e.next.n = n) THEN
RETURN (* don't allow duplicates *)
ELSE
NEW(h); h.next := e.next; e.next := h
END;
h.n := n; h.pos := pos
END err2;
PROCEDURE DumpObj(obj: CPT.Object);
(* BEGIN
CPM.LogWStr("message for object: "); CPM.LogWStr(obj.name); CPM.LogWLn
*) END DumpObj;
PROCEDURE CheckScope(scope: CPT.Object); (*<<*)
PROCEDURE^ Check(obj: CPT.Object);
PROCEDURE CheckTyp(typ: CPT.Struct);
BEGIN
IF (typ.form = Pointer) & (typ.BaseTyp.strobj = NIL) THEN (* only if PTR TO RECORD END *)
typ := typ.BaseTyp
END;
IF (typ.form = Comp) & (typ.comp = Record) THEN Check(typ.link) END
END CheckTyp;
PROCEDURE Check(obj: CPT.Object);
BEGIN
IF obj # NIL THEN
Check(obj.left);
IF (obj.num # setUsed) & (options.exported OR (obj.vis = internal) OR (obj.mode = Mod)) THEN
CASE obj.mode OF
| Var, VarPar, Fld:
CASE obj.num OF
| clean: DumpObj(obj); err2(neverUsed, obj.adr)
(* | used: DumpObj(obj); err2(neverSet, obj.adr) *)
| used: IF obj.name[0] # "@" THEN DumpObj(obj); err2(neverSet, obj.adr) END
| usedSet: IF obj.mode # Fld THEN DumpObj(obj); err2(usedBSet, obj.adr) END
| set: DumpObj(obj); err2(setBNUsed, obj.adr);
| setUsedP: IF options.varpar & (obj.mode # Fld) THEN DumpObj(obj); err2(usedVarPar, obj.adr); END
END;
IF obj.typ.strobj = NIL THEN CheckTyp(obj.typ) END (*x: RECORD ... END*)
| Con, Typ: CASE obj.num OF set: DumpObj(obj); err2(neverUsed, obj.adr) END
| LProc, XProc, CProc, IProc: CASE obj.num OF set: DumpObj(obj); err2(neverUsed, obj.adr) END
| TProc: (* neverUsed not determinable for redefined methods because of dynamic binding *)
(* IF ((obj.link.typ.form = Pointer) & (obj.link.typ.BaseTyp.BaseTyp = NIL) OR
(* (obj.link.typ.comp = Record) & *) (obj.link.typ.BaseTyp = NIL)) & (obj.num = set) THEN*)
(* BJ: Changed this IF to correct ABSTRACT and EMPTY procedures*)
IF ~(absAttr IN obj.conval.setval) & ~(empAttr IN obj.conval.setval) &
((obj.link.typ.form = Pointer) & (obj.link.typ.BaseTyp.BaseTyp = NIL) OR
(obj.link.typ.BaseTyp = NIL)) & (obj.num = set) THEN
DumpObj(obj); err2(neverUsed, obj.adr)
END
| Mod: DumpObj(obj); err2(neverUsed, obj.adr)
ELSE
END
END; (*IF*)
CASE obj.mode OF
| LProc, XProc, IProc, TProc: CheckScope(obj.scope)
| Typ:
IF obj.typ.mno = 0 THEN
CheckTyp(obj.typ) (* checking of fields and type bound procedures, only if not imported type! *)
END
ELSE
END;
Check(obj.right)
END
END Check;
BEGIN Check(scope.right)
END CheckScope;
PROCEDURE CheckOuter; (*<< check outer scopes for obj with OPS.name*)
VAR o: CPT.Object;
BEGIN
IF options.intermediate THEN
CPT.Find(CPS.name, o);
IF o # NIL THEN DumpObj(o); err2(outerScope, CPM.curpos) END
END
END CheckOuter;
PROCEDURE UseType(obj: CPT.Object; pos: INTEGER); (*<< type obj gets used*)
BEGIN
IF (obj # NIL) & ((obj.vis = internal) OR options.exported) THEN
IF options.intermediate & (obj.mnolev # level) & (obj.mnolev > 0) THEN (*mnolev > 0 -> intermediate*)
DumpObj(obj); err2(interAcc, pos)
END;
CASE obj.num OF clean, set: obj.num := setUsed
| used, setUsed: (* used only for non-declarded type *)
END
END
END UseType;
PROCEDURE UseObj(obj: CPT.Object; markUseBSet: BOOLEAN; pos: INTEGER); (*<< obj gets used *)
BEGIN
IF (obj # NIL) & (obj.mnolev >= 0) THEN
IF options.intermediate & (obj.mnolev # level) & (obj.mnolev > 0) & (obj.mode < LProc) THEN
DumpObj(obj); err2(interAcc, pos)
END;
CASE obj.num OF
| clean:
IF (obj.mode = Con) OR (obj.mode # Fld) & (obj.mnolev # level) & ~options.levels THEN
obj.num := setUsed
ELSE
obj.num := used;
IF markUseBSet & (obj.mode # SProc) & (obj.mode # Fld) & (obj.typ.form # Comp) THEN
DumpObj(obj); err2(usedBSet, pos)
END
END
| set: obj.num := setUsed
| used, usedSet, setUsed, setUsedP, setUsed+noChange, setUsedP+noChange:
END
END
END UseObj;
PROCEDURE SetObj(obj: CPT.Object; varPar: BOOLEAN; pos: INTEGER); (*<< var/proc/const/field obj gets set*)
BEGIN
IF (obj # NIL) & (obj.mnolev >= 0) THEN
CASE obj.num OF
| clean: IF varPar THEN obj.num := setUsedP ELSE obj.num := set END
| used:
IF varPar THEN obj.num := setUsedP
ELSIF (obj.mnolev = level) OR options.levels THEN obj.num := usedSet
ELSIF ~options.levels THEN obj.num := setUsed
END
| usedSet, setUsed, setUsedP:
| set: IF varPar THEN obj.num := setUsed END
| setUsed+noChange, setUsedP+noChange: DumpObj(obj); err2(loopVarSet, pos) (* for loop variable gets set!*)
END
END
END SetObj;
PROCEDURE Selector(x: CPT.Node; assignment, varPar, markUseBSet: BOOLEAN; pos: INTEGER); (*<<*)
BEGIN
IF assignment THEN
CASE x.class OF
| Nvar, Nvarpar, Nfield:
IF (x.class # Nfield) & options.intermediate & (x.obj.mnolev # level) & (x.obj.mnolev > 0) THEN
DumpObj(x.obj); err2(interAcc, pos) (* assignment to intermediate *)
END;
SetObj(x.obj, varPar, pos); x := x.left; (* assignment to b in {a.}b := ... *)
| Nindex: (* assignment to b in {a.}b{[i]} := ... *)
REPEAT x := x.left UNTIL x.class # Nindex;
IF x.class IN {Nvar, Nvarpar, Nfield} THEN SetObj(x.obj, varPar, pos); x := x.left END
ELSE
END;
WHILE (x # NIL) & (x.class IN {Nvar, Nvarpar, Nfield}) DO SetObj(x.obj, varPar, pos); x := x.left END
END;
WHILE x # NIL DO
IF x.class IN {Nvar, Nvarpar, Nfield, Nconst, Nproc} THEN UseObj(x.obj, markUseBSet, pos); END;
x := x.left
END
END Selector;
PROCEDURE qualident(VAR id: CPT.Object);
VAR obj: CPT.Object; lev: BYTE; m: BOOLEAN;
BEGIN (*sym = ident*)
CPT.Find(CPS.name, obj); CPS.Get(sym);
m := FALSE; (*<<*)
IF (sym = period) & (obj # NIL) & (obj.mode = Mod) THEN
obj.num := setUsed; (*<< module gets used (set by default) *)
m := TRUE; (*<< it's a module! *)
CPS.Get(sym);
IF sym = ident THEN
CPT.FindImport(CPS.name, obj, obj); CPS.Get(sym)
ELSE err(ident); obj := NIL
END
END ;
IF obj = NIL THEN err(0);
obj := CPT.NewObj(); obj.mode := Var; obj.typ := CPT.undftyp; obj.adr := 0
ELSE lev := obj.mnolev;
IF (obj.mode IN {Var, VarPar}) & (lev # level) THEN
obj.leaf := FALSE;
IF lev > 0 THEN CPB.StaticLink(SHORT(SHORT(level-lev)), TRUE) END (* !!! *)
END
END ;
IF m & (obj # NIL) THEN obj.num := setUsed END; (*<< imported obj get used always! *)
id := obj
END qualident;
PROCEDURE ConstExpression(VAR x: CPT.Node);
BEGIN Expression(x);
IF x.class # Nconst THEN
err(50); x := CPB.NewIntConst(1)
END
END ConstExpression;
PROCEDURE CheckMark(obj: CPT.Object); (* !!! *)
BEGIN
CPS.Get(sym);
IF (sym = times) OR (sym = minus) THEN
IF (level > 0) OR ~(obj.mode IN {Var, Fld, TProc}) & (sym = minus) THEN err(41) END ;
IF sym = times THEN obj.vis := external ELSE obj.vis := externalR END ;
CPS.Get(sym)
ELSE obj.vis := internal
END;
IF (obj.mode IN {LProc, XProc, Var, Typ}) & (sym = lbrak) THEN
CPS.Get(sym);
IF sym = string THEN
IF obj.conval = NIL THEN obj.conval := CPT.NewConst() END;
IF CPS.str^ # "" THEN obj.conval.ext := CPS.str END;
CPS.Get(sym);
IF sym = comma THEN
CPS.Get(sym);
IF sym = string THEN
IF obj.conval.ext # NIL THEN
obj.conval.link := CPT.NewConst(); obj.conval.link.ext := obj.conval.ext
END;
obj.conval.ext := NIL;
IF CPS.str^ # "" THEN obj.conval.ext := CPS.str END;
CPS.Get(sym)
ELSE err(string)
END
END
ELSE err(string)
END;
CheckSym(rbrak);
IF ~(CPM.interface IN CPM.options) THEN err(225) END
END
END CheckMark;
PROCEDURE CheckSysFlag (VAR sysflag: SHORTINT;
GetSF: PROCEDURE(id: ARRAY OF SHORTCHAR; num: SHORTINT; VAR flag: SHORTINT));
VAR x: CPT.Object; i: SHORTINT;
BEGIN
sysflag := 0;
IF sym = lbrak THEN
CPS.Get(sym);
WHILE (sym = number) OR (sym = ident) OR (sym = string) DO
IF sym = number THEN
IF CPS.numtyp = integer THEN
i := SHORT(CPS.intval); GetSF("", i, sysflag)
ELSE err(225)
END
ELSIF sym = ident THEN
CPT.Find(CPS.name, x);
IF (x # NIL) & (x.mode = Con) & (x.typ.form IN {Int8, Int16, Int32}) THEN
i := SHORT(x.conval.intval); GetSF("", i, sysflag)
ELSE
GetSF(CPS.name, 0, sysflag)
END
ELSE
GetSF(CPS.str^, 0, sysflag)
END;
CPS.Get(sym);
IF (sym = comma) OR (sym = plus) THEN CPS.Get(sym) END
END;
CheckSym(rbrak)
END
END CheckSysFlag;
PROCEDURE Receiver(VAR mode, vis: BYTE; VAR name: CPT.Name; VAR typ, rec: CPT.Struct);
VAR obj: CPT.Object;tname: CPT.String;
BEGIN
typ := CPT.undftyp; rec := NIL; vis := 0;
IF sym = var THEN CPS.Get(sym); mode := VarPar
ELSIF sym = in THEN CPS.Get(sym); mode := VarPar; vis := inPar (* ??? *)
ELSE mode := Var
END ;
name := CPS.name; CheckSym(ident); CheckSym(colon);
IF sym # ident THEN err(ident) END;
Type(typ, tname);
IF tname = NIL THEN
IF typ.form = Pointer THEN rec := typ.BaseTyp ELSE rec := typ END;
IF ~((mode = Var) & (typ.form = Pointer) & (rec.comp = Record) OR
(mode = VarPar) & (typ.comp = Record)) THEN err(70); rec := NIL END;
IF (rec # NIL) & (rec.mno # level) THEN err(72); rec := NIL END
ELSE err(0)
END;
CheckSym(rparen);
IF rec = NIL THEN rec := CPT.NewStr(Comp, Record); rec.BaseTyp := NIL END
END Receiver;
PROCEDURE FormalParameters(VAR firstPar: CPT.Object; VAR resTyp: CPT.Struct; VAR name: CPT.String);
VAR mode, vis: BYTE; sys: SHORTINT;
par, first, last, newPar, iidPar: CPT.Object; typ: CPT.Struct;
BEGIN
first := NIL; last := firstPar;
newPar := NIL; iidPar := NIL;
IF (sym = ident) OR (sym = var) OR (sym = in) OR (sym = out) THEN
LOOP
sys := 0; vis := 0;
IF sym = var THEN CPS.Get(sym); mode := VarPar
ELSIF sym = in THEN CPS.Get(sym); mode := VarPar; vis := inPar
ELSIF sym = out THEN CPS.Get(sym); mode := VarPar; vis := outPar
ELSE mode := Var
END ;
IF mode = VarPar THEN CheckSysFlag(sys, CPM.GetVarParSysFlag) END;
IF ODD(sys DIV inBit) THEN vis := inPar
ELSIF ODD(sys DIV outBit) THEN vis := outPar
END;
IF ODD(sys DIV newBit) & (vis # outPar) THEN err(225)
ELSIF ODD(sys DIV iidBit) & (vis # inPar) THEN err(225)
END;
LOOP
IF sym = ident THEN
CheckOuter; (*<<*)
CPT.Insert(CPS.name, par); CPS.Get(sym);
par.adr := CPM.errpos; (*<<*)
par.mode := mode; par.link := NIL; par.vis := vis; par.sysflag := SHORT(sys);
IF mode = VarPar THEN (*<< parameters are set, except for out parameters *)
IF vis = inPar THEN par.num := setUsedP
ELSIF vis = outPar THEN
(* out parameters are not initialized, except for pointers and procedure variables *)
par.num := clean
ELSE par.num := setUsed
END
ELSE
par.num := set
END;
IF first = NIL THEN first := par END ;
IF firstPar = NIL THEN firstPar := par ELSE last.link := par END ;
last := par;
ELSE err(ident)
END;
IF sym = comma THEN CPS.Get(sym)
ELSIF sym = ident THEN err(comma)
ELSIF sym = var THEN err(comma); CPS.Get(sym)
ELSE EXIT
END
END ;
CheckSym(colon); Type(typ, name);
IF mode # VarPar THEN CheckAlloc(typ, TRUE, CPM.errpos) END;
IF (mode = VarPar) & (vis = inPar) & (typ.form # Undef) & (typ.form # Comp) & (typ.sysflag = 0) THEN
err(177)
END;
(* typ.pbused is set when parameter type name is parsed *)
WHILE first # NIL DO
SetType (NIL, first, typ, name);
IF ODD(sys DIV newBit) THEN
IF (newPar # NIL) OR (typ.form # Pointer) OR (typ.sysflag # interface) THEN err(168) END;
newPar := first
ELSIF ODD(sys DIV iidBit) THEN
IF (iidPar # NIL) OR (typ # CPT.guidtyp) THEN err(168) END;
iidPar := first
END;
first := first.link
END;
IF sym = semicolon THEN CPS.Get(sym)
ELSIF sym = ident THEN err(semicolon)
ELSE EXIT
END
END
END;
CheckSym(rparen);
IF (newPar = NIL) # (iidPar = NIL) THEN err(168) END;
name := NIL;
IF sym = colon THEN
CPS.Get(sym);
Type(resTyp, name);
IF resTyp.form = Comp THEN resTyp := CPT.undftyp; err(54) END
ELSE resTyp := CPT.notyp
END
END FormalParameters;
PROCEDURE CheckOverwrite (proc, base: CPT.Object; rec: CPT.Struct);
VAR o, bo: CPT.Object;
BEGIN
IF base # NIL THEN
IF base.conval.setval * {absAttr, empAttr, extAttr} = {} THEN err(182) END;
IF (proc.link.mode # base.link.mode) OR (proc.link.vis # base.link.vis)
OR ~CPT.Extends(proc.link.typ, base.link.typ) THEN err(115) END;
o := proc.link; bo := base.link;
WHILE (o # NIL) & (bo # NIL) DO
IF (bo.sysflag # 0) & (o.sysflag = 0) THEN (* propagate sysflags *)
o.sysflag := bo.sysflag
END;
o := o.link; bo := bo.link
END;
CPB.CheckParameters(proc.link.link, base.link.link, FALSE);
IF ~CPT.Extends(proc.typ, base.typ) THEN err(117) END;
IF (base.vis # proc.vis) & ((proc.vis # internal) OR rec.exp) THEN err(183) END;
INCL(proc.conval.setval, isRedef)
END
END CheckOverwrite;
PROCEDURE GetAttributes (proc, base: CPT.Object; owner: CPT.Struct); (* read method attributes *)
VAR attr, battr: SET; o: CPT.Object;
BEGIN
attr := {};
IF sym = comma THEN (* read attributes *)
CPS.Get(sym);
IF sym = ident THEN
CPT.Find(CPS.name, o);
IF (o # NIL) & (o.mode = SProc) & (o.adr = newfn) THEN
IF ~(CPM.oberon IN CPM.options) THEN INCL(attr, newAttr) ELSE err(178) END;
CPS.Get(sym);
IF sym = comma THEN
CPS.Get(sym);
IF sym = ident THEN CPT.Find(CPS.name, o) ELSE o := NIL; err(ident) END
ELSE o := NIL
END
END;
IF o # NIL THEN
IF (o.mode # Attr) OR (o.adr = limAttr) OR (CPM.oberon IN CPM.options) THEN err(178)
ELSE INCL(attr, o.adr)
END;
CPS.Get(sym)
END
ELSE err(ident)
END
END;
IF (base = NIL) & ~(newAttr IN attr) THEN err(185); INCL(attr, newAttr)
ELSIF (base # NIL) & (newAttr IN attr) THEN err(186)
END;
IF (owner.attribute # absAttr) & (absAttr IN attr) THEN err(190) END;
IF (owner.attribute = 0) OR (owner.attribute = limAttr) THEN
IF (empAttr IN attr) & (newAttr IN attr) THEN err(187)
ELSIF extAttr IN attr THEN err(188)
END
END;
IF base # NIL THEN
battr := base.conval.setval;
IF empAttr IN battr THEN
IF absAttr IN attr THEN err(189) END
ELSIF ~(absAttr IN battr) THEN
IF (absAttr IN attr) OR (empAttr IN attr) THEN err(189) END
END
END;
IF empAttr IN attr THEN
IF proc.typ # CPT.notyp THEN err(195)
ELSE
o := proc.link; WHILE (o # NIL) & (o.vis # outPar) DO o := o.link END;
IF o # NIL THEN err(195) END
END
END;
IF (owner.sysflag = interface) & ~(absAttr IN attr) THEN err(162) END;
proc.conval.setval := attr
END GetAttributes;
PROCEDURE RecordType(VAR typ: CPT.Struct; attr: CPT.Object);
VAR fld, first, last: CPT.Object; r: Elem; ftyp: CPT.Struct; name: CPT.String;
BEGIN typ := CPT.NewStr(Comp, Record); typ.BaseTyp := NIL;
CheckSysFlag(typ.sysflag, CPM.GetRecordSysFlag);
IF attr # NIL THEN
IF ~(CPM.oberon IN CPM.options) & (attr.adr # empAttr) THEN typ.attribute := SHORT(SHORT(attr.adr))
ELSE err(178)
END
END;
IF typ.sysflag = interface THEN
IF (CPS.str # NIL) & (CPS.str[0] = "{") THEN typ.ext := CPS.str END;
IF typ.attribute # absAttr THEN err(163) END;
IF sym # lparen THEN err(160) END
END;
IF sym = lparen THEN
CPS.Get(sym); (*record extension*)
IF sym = ident THEN
Type(ftyp, name);
IF ftyp.form = Pointer THEN ftyp := ftyp.BaseTyp END;
SetType(typ, NIL, ftyp, name);
IF (ftyp.comp = Record) & (ftyp # CPT.anytyp) THEN
ftyp.pvused := TRUE; typ.extlev := SHORT(SHORT(ftyp.extlev + 1));
CPM.PropagateRecordSysFlag(ftyp.sysflag, typ.sysflag);
IF (ftyp.attribute = 0) OR (ftyp.attribute = limAttr) & (ftyp.mno # 0) THEN err(181)
ELSIF (typ.attribute = absAttr) & (ftyp.attribute # absAttr) THEN err(191)
ELSIF (ftyp.attribute = limAttr) & (typ.attribute # limAttr) THEN err(197)
END
ELSIF ftyp # CPT.undftyp THEN err(53)
END
ELSE err(ident)
END ;
IF typ.attribute # absAttr THEN (* save typ for unimplemented method check *)
NEW(r); r.struct := typ; r.pos := CPM.errpos; r.next := recList; recList := r
END;
CheckSym(rparen)
END;
(*
CPT.OpenScope(0, NIL);
*)
first := NIL; last := NIL;
LOOP
IF sym = ident THEN
LOOP
IF sym = ident THEN
IF (typ.BaseTyp # NIL) & (typ.BaseTyp # CPT.undftyp) THEN
CPT.FindBaseField(CPS.name, typ, fld);
IF fld # NIL THEN err(1) END
END ;
CPT.FindField(CPS.name, typ, fld); (* not needed with actual CPT *)
IF fld # NIL THEN err(1) END;
CPT.InsertField(CPS.name, typ, fld);
fld.mode := Fld; fld.link := NIL; fld.typ := CPT.undftyp;
CheckMark(fld);
fld.adr := CPM.errpos; fld.num := clean; (*<<*)
IF first = NIL THEN first := fld END ;
IF last = NIL THEN typ.link := fld ELSE last.link := fld END ;
last := fld
ELSE err(ident)
END ;
IF sym = comma THEN CPS.Get(sym)
ELSIF sym = ident THEN err(comma)
ELSE EXIT
END
END ;
CheckSym(colon); Type(ftyp, name);
CheckAlloc(ftyp, FALSE, CPM.errpos);
WHILE first # NIL DO
SetType(typ, first, ftyp, name); first := first.link
END;
IF typ.sysflag = interface THEN err(161) END
END;
IF sym = semicolon THEN CPS.Get(sym);
IF ((sym = end) OR (sym = semicolon)) & options.semicolons THEN (*<< superfluous semicolon *)
err2(semicolons, CPM.errpos)
END
ELSIF sym = ident THEN err(semicolon)
ELSE EXIT
END
END;
(*
IF typ.link # NIL THEN ASSERT(typ.link = CPT.topScope.right) END;
typ.link := CPT.topScope.right; CPT.CloseScope;
*)
typ.untagged := typ.sysflag # 0;
CPB.Inittd(TDinit, lastTDinit, typ); CheckSym(end)
END RecordType;
PROCEDURE ArrayType(VAR typ: CPT.Struct);
VAR x: CPT.Node; n: INTEGER; sysflag: SHORTINT; name: CPT.String;
BEGIN CheckSysFlag(sysflag, CPM.GetArraySysFlag);
IF sym = of THEN (*dynamic array*)
typ := CPT.NewStr(Comp, DynArr); typ.mno := 0; typ.sysflag := sysflag;
CPS.Get(sym); Type(typ.BaseTyp, name); SetType(typ, NIL, typ.BaseTyp, name);
CheckAlloc(typ.BaseTyp, TRUE, CPM.errpos);
IF typ.BaseTyp.comp = DynArr THEN typ.n := typ.BaseTyp.n + 1 ELSE typ.n := 0 END
ELSE
typ := CPT.NewStr(Comp, Array); typ.sysflag := sysflag; ConstExpression(x);
IF x.typ.form IN {Int8, Int16, Int32} THEN n := x.conval.intval;
IF (n <= 0) OR (n > CPM.MaxIndex) THEN err(63); n := 1 END
ELSE err(42); n := 1
END ;
typ.n := n;
IF sym = of THEN
CPS.Get(sym); Type(typ.BaseTyp, name); SetType(typ, NIL, typ.BaseTyp, name);
CheckAlloc(typ.BaseTyp, FALSE, CPM.errpos)
ELSIF sym = comma THEN
CPS.Get(sym);
IF sym # of THEN ArrayType(typ.BaseTyp) END
ELSE err(35)
END
END;
typ.untagged := typ.sysflag # 0
END ArrayType;
PROCEDURE PointerType(VAR typ: CPT.Struct);
VAR name: CPT.String;
BEGIN typ := CPT.NewStr(Pointer, Basic); CheckSysFlag(typ.sysflag, CPM.GetPointerSysFlag);
CheckSym(to);
Type(typ.BaseTyp, name);
SetType(typ, NIL, typ.BaseTyp, name);
IF (typ.BaseTyp # CPT.undftyp) & (typ.BaseTyp.comp = Basic) THEN
typ.BaseTyp := CPT.undftyp; err(57)
END;
IF typ.BaseTyp.comp = Record THEN CPM.PropagateRecPtrSysFlag(typ.BaseTyp.sysflag, typ.sysflag)
ELSIF typ.BaseTyp.comp IN {Array, DynArr} THEN CPM.PropagateArrPtrSysFlag(typ.BaseTyp.sysflag, typ.sysflag)
END;
typ.untagged := typ.sysflag # 0
END PointerType;
PROCEDURE Type (VAR typ: CPT.Struct; VAR name: CPT.String); (* name # NIL => forward reference *)
VAR id: CPT.Object; tname: CPT.String;
BEGIN
typ := CPT.undftyp; name := NIL;
IF sym < lparen THEN err(12);
REPEAT CPS.Get(sym) UNTIL sym >= lparen
END ;
IF sym = ident THEN
CPT.Find(CPS.name, id);
IF (id = NIL) OR (id.mode = -1) OR (id.mode = Typ) & IncompleteType(id.typ) THEN (* forward type definition *)
name := CPT.NewName(CPS.name); CPS.Get(sym);
IF (id = NIL) & (sym = period) THEN (* missing module *)
err(0); CPS.Get(sym); name := NIL;
IF sym = ident THEN CPS.Get(sym) END
ELSIF sym = record THEN (* wrong attribute *)
err(178); CPS.Get(sym); name := NIL; RecordType(typ, NIL)
END
ELSE
qualident(id);
UseType(id, CPM.errpos); (*<< type gets used*)
IF id.mode = Typ THEN
IF ~(CPM.oberon IN CPM.options)
& ((id.typ = CPT.lreal64typ) OR (id.typ = CPT.lint64typ) OR (id.typ = CPT.lchar16typ)) THEN err(198) END;
typ := id.typ
ELSIF id.mode = Attr THEN
IF sym = record THEN
CPS.Get(sym); RecordType(typ, id)
ELSE err(12)
END
ELSE err(52)
END
END
ELSIF sym = array THEN
CPS.Get(sym); ArrayType(typ)
ELSIF sym = record THEN
CPS.Get(sym); RecordType(typ, NIL)
ELSIF sym = pointer THEN
CPS.Get(sym); PointerType(typ)
ELSIF sym = procedure THEN
CPS.Get(sym); typ := CPT.NewStr(ProcTyp, Basic);
(*
CheckSysFlag(typ.sysflag, CPM.GetProcTypSysFlag);
typ.untagged := typ.sysflag # 0;
*)
IF sym = lparen THEN
CPS.Get(sym); CPT.OpenScope(level, NIL);
FormalParameters(typ.link, typ.BaseTyp, tname); SetType(typ, NIL, typ.BaseTyp, tname); CPT.CloseScope
ELSE typ.BaseTyp := CPT.notyp; typ.link := NIL
END
ELSE err(12)
END ;
LOOP
IF (sym >= semicolon) & (sym <= else) OR (sym = rparen) OR (sym = eof)
OR (sym = number) OR (sym = comma) THEN EXIT END;
err(15); IF sym = ident THEN EXIT END;
CPS.Get(sym)
END
END Type;
PROCEDURE ^ selector(VAR x: CPT.Node);
PROCEDURE ^ StandProcCall(VAR x: CPT.Node);
PROCEDURE ActualParameters(VAR aparlist: CPT.Node; fpar: CPT.Object; VAR pre, lastp: CPT.Node);
VAR apar, last, newPar, iidPar, n: CPT.Node; id: CPT.Object; moreThan1: BOOLEAN; (*<< id, moreThan1 *)
BEGIN
aparlist := NIL; last := NIL;
IF sym # rparen THEN
moreThan1 := (fpar # NIL) & (fpar.link # NIL); (*<<*)
newPar := NIL; iidPar := NIL;
LOOP
(*<< Expression(apar) old code *)
IF sym # nil THEN
IF (fpar # NIL) & (fpar.mode = VarPar) & (fpar.vis # inPar) THEN (*<<*)
qualident(id); apar := CPB.NewLeaf(id); selector(apar);
IF (apar.class = Nproc) & (apar.obj.mode = SProc) & (apar.obj.adr = valfn) THEN
StandProcCall(apar)
END;
Selector(apar, SelAssign, SelVarPar, SelUseBSet, CPM.errpos)
ELSE (*<<*)
Expression(apar);
IF options.sideEffects & moreThan1 & (apar.class = Ncall) THEN
(*<< proc-calls in param-list: code might depend on evaluation sequence (if more than one param.) *)
err2(evaluationSeq, CPM.errpos)
END
END;
IF fpar # NIL THEN
IF (apar.typ.form = Pointer) & (fpar.typ.form = Comp) THEN CPB.DeRef(apar) END;
CPB.Param(apar, fpar);
IF fpar.mode = Var THEN CPB.CheckBuffering(apar, NIL, fpar, pre, lastp) END;
CPB.Link(aparlist, last, apar);
IF ODD(fpar.sysflag DIV newBit) THEN newPar := apar
ELSIF ODD(fpar.sysflag DIV iidBit) THEN iidPar := apar
END;
IF (newPar # NIL) & (iidPar # NIL) THEN CPB.CheckNewParamPair(newPar, iidPar) END;
fpar := fpar.link
ELSE err(64)
END;
ELSE
fpar := fpar.link; CPS.Get(sym)
END;
IF sym = comma THEN CPS.Get(sym)
ELSIF (lparen <= sym) & (sym <= ident) THEN err(comma)
ELSE EXIT
END
END
END;
IF fpar # NIL THEN err(65) END
END ActualParameters;
PROCEDURE selector(VAR x: CPT.Node);
VAR obj, proc, fpar: CPT.Object; y, apar, pre, lastp: CPT.Node; typ: CPT.Struct; name: CPT.Name;
BEGIN
LOOP
IF sym = lbrak THEN CPS.Get(sym);
LOOP
IF (x.typ # NIL) & (x.typ.form = Pointer) THEN CPB.DeRef(x) END ;
Expression(y); CPB.Index(x, y);
IF sym = comma THEN CPS.Get(sym) ELSE EXIT END
END ;
CheckSym(rbrak)
ELSIF sym = period THEN
CPS.Get(sym);
IF sym = ident THEN name := CPS.name; CPS.Get(sym);
IF x.typ # NIL THEN
IF x.typ.form = Pointer THEN
IF x.obj # NIL THEN UseObj(x.obj, TRUE, x.obj.adr) END;
CPB.DeRef(x)
END ;
IF x.typ.comp = Record THEN
typ := x.typ; CPT.FindField(name, typ, obj); CPB.Field(x, obj);
IF (obj # NIL) & (obj.mode = TProc) THEN
IF sym = arrow THEN (* super call *) CPS.Get(sym);
y := x.left;
IF y.class = Nderef THEN y := y.left END ; (* y = record variable *)
IF y.obj # NIL THEN
proc := CPT.topScope; (* find innermost scope which owner is a TProc *)
WHILE (proc.link # NIL) & (proc.link.mode # TProc) DO proc := proc.left END ;
IF (proc.link = NIL) OR (proc.link.link # y.obj) THEN err(75) END ;
typ := y.obj.typ;
IF typ.form = Pointer THEN typ := typ.BaseTyp END ;
CPT.FindBaseField(x.obj.name^, typ, proc);
IF proc # NIL THEN x.subcl := super;
UseObj(proc, TRUE, proc.adr); (*<< touch super proc*)
IF proc.conval.setval * {absAttr, empAttr} # {} THEN err(194) END
ELSE err(74)
END
ELSE err(75)
END
ELSE
UseObj(obj, TRUE, obj.adr); (*<< touch obj only if not super call! *)
proc := obj;
WHILE (proc.mnolev >= 0) & ~(newAttr IN proc.conval.setval) & (typ.BaseTyp # NIL) DO
(* find base method *)
typ := typ.BaseTyp; CPT.FindField(name, typ, proc);
END;
IF (proc.vis = externalR) & (proc.mnolev < 0) THEN err(196) END;
END ;
IF (obj.typ # CPT.notyp) & (sym # lparen) THEN err(lparen) END
END
ELSE err(53)
END
ELSE err(52)
END
ELSE err(ident)
END
ELSIF sym = arrow THEN CPS.Get(sym); CPB.DeRef(x)
ELSIF sym = dollar THEN
IF x.typ.form = Pointer THEN CPB.DeRef(x) END;
CPS.Get(sym); CPB.StrDeref(x)
ELSIF sym = lparen THEN
IF (x.obj # NIL) & (x.obj.mode IN {XProc, LProc, CProc, TProc}) THEN typ := x.obj.typ
ELSIF x.typ.form = ProcTyp THEN typ := x.typ.BaseTyp
ELSIF x.class = Nproc THEN EXIT (* standard procedure *)
ELSE typ := NIL
END;
IF typ # CPT.notyp THEN
CPS.Get(sym);
IF typ = NIL THEN (* type guard *)
IF sym = ident THEN
qualident(obj);
IF obj.mode = Typ THEN CPB.TypTest(x, obj, TRUE);
UseType(obj, CPM.errpos) (*<< type gets used*)
ELSE err(52)
END
ELSE err(ident)
END
ELSE (* function call *)
pre := NIL; lastp := NIL;
CPB.PrepCall(x, fpar);
IF (x.obj # NIL) & (x.obj.mode = TProc) THEN CPB.CheckBuffering(x.left, NIL, x.obj.link, pre, lastp) END;
ActualParameters(apar, fpar, pre, lastp);
CPB.Call(x, apar, fpar);
IF pre # NIL THEN CPB.Construct(Ncomp, pre, x); pre.typ := x.typ; x := pre END;
IF level > 0 THEN CPT.topScope.link.leaf := FALSE END
END;
CheckSym(rparen)
ELSE EXIT
END
(*
ELSIF (sym = lparen) & (x.class # Nproc) & (x.typ.form # ProcTyp) &
((x.obj = NIL) OR (x.obj.mode # TProc)) THEN
CPS.Get(sym);
IF sym = ident THEN
qualident(obj);
IF obj.mode = Typ THEN CPB.TypTest(x, obj, TRUE)
ELSE err(52)
END
ELSE err(ident)
END ;
CheckSym(rparen)
*)
ELSE EXIT
END
END
END selector;
PROCEDURE StandProcCall(VAR x: CPT.Node);
VAR y: CPT.Node; m: BYTE; n: SHORTINT; id: CPT.Object; (*<< id *)
BEGIN
m := SHORT(SHORT(x.obj.adr)); n := 0;
IF sym = lparen THEN CPS.Get(sym);
IF sym # rparen THEN
LOOP
IF n = 0 THEN
(*<< Expression(x); old code *)
CASE m OF (*<<*)
| newfn, sysnewfn: (* id will be set by NEW => varPar = FALSE *)
qualident(id); x := CPB.NewLeaf(id); selector(x);
IF (x.class = Nproc) & (x.obj.mode = SProc) & (x.obj.adr = valfn) THEN StandProcCall(x) END;
Selector(x, SelAssign, SelNoVarPar, SelUseBSet, CPM.errpos)
| incfn, decfn, inclfn, exclfn: (* id will be used and then set *)
qualident(id); x := CPB.NewLeaf(id); selector(x);
IF (x.class = Nproc) & (x.obj.mode = SProc) & (x.obj.adr = valfn) THEN StandProcCall(x) END;
Selector(x, SelNoAssign, SelNoVarPar, SelUseBSet, CPM.errpos); (* use *)
Selector(x, SelAssign, SelNoVarPar, SelUseBSet, CPM.errpos) (* set *)
| adrfn:
IF sym = ident THEN (* no usedBSet message if ADR(id) *)
qualident(id); x := CPB.NewLeaf(id); selector(x);
Selector(x, SelNoAssign, SelNoVarPar, SelNoUseBSet, CPM.errpos)
ELSE
Expression(x);
END
| lenfn:
qualident(id); x := CPB.NewLeaf(id); selector(x);
(* no usedBSet message if LEN(id) *)
Selector(x, SelNoAssign, SelNoVarPar, SelNoUseBSet, CPM.errpos)
ELSE Expression(x)
END;
CPB.StPar0(x, m); n := 1
ELSIF n = 1 THEN
(*<< Expression(y); old code *)
IF m IN {getfn, getrfn} THEN (*<< id will be set by GET, GETREG => varPar = FALSE *)
qualident(id); y := CPB.NewLeaf(id); selector(y);
IF (y.class = Nproc) & (y.obj.mode = SProc) & (y.obj.adr = valfn) THEN StandProcCall(y) END;
Selector(y, SelAssign, SelNoVarPar, SelUseBSet, CPM.errpos)
ELSE Expression(y)
END;
CPB.StPar1(x, y, m); n := 2
ELSE Expression(y); CPB.StParN(x, y, m, n); INC(n)
END ;
IF sym = comma THEN CPS.Get(sym)
ELSIF (lparen <= sym) & (sym <= ident) THEN err(comma)
ELSE EXIT
END
END ;
CheckSym(rparen)
ELSE CPS.Get(sym)
END ;
CPB.StFct(x, m, n)
ELSE err(lparen)
END ;
IF (level > 0) & ((m = newfn) OR (m = sysnewfn)) THEN CPT.topScope.link.leaf := FALSE END
END StandProcCall;
PROCEDURE Element(VAR x: CPT.Node);
VAR y: CPT.Node;
BEGIN Expression(x);
IF sym = upto THEN
CPS.Get(sym); Expression(y); CPB.SetRange(x, y)
ELSE CPB.SetElem(x)
END
END Element;
PROCEDURE Sets(VAR x: CPT.Node);
VAR y: CPT.Node;
BEGIN
IF sym # rbrace THEN
Element(x);
LOOP
IF sym = comma THEN CPS.Get(sym)
ELSIF (lparen <= sym) & (sym <= ident) THEN err(comma)
ELSE EXIT
END ;
Element(y); CPB.Op(plus, x, y)
END
ELSE x := CPB.EmptySet()
END ;
CheckSym(rbrace)
END Sets;
PROCEDURE Factor(VAR x: CPT.Node);
VAR id: CPT.Object; pos: INTEGER; (*<< pos *)
BEGIN
IF sym < not THEN err(13);
REPEAT CPS.Get(sym) UNTIL sym >= lparen
END ;
IF sym = ident THEN
qualident(id);
pos := CPM.curpos; (*<<*)
x := CPB.NewLeaf(id);
UseObj(x.obj, SelUseBSet, pos);
selector(x);
IF (x.class = Nfield) & (x.obj.mode = TProc) & (x.obj.link.mode = VarPar) & (x.obj.link.typ.comp = Record) THEN
(*<< receiver is var parameter and record *)
Selector(x.left, SelAssign, SelVarPar, SelUseBSet, pos)
END;
Selector(x, SelNoAssign, SelNoVarPar, SelUseBSet, pos); (*<<*)
IF (x.class = Nproc) & (x.obj.mode = SProc) THEN
IF ~((x.obj.adr IN {ordfn, minfn, maxfn, chrfn, sizefn, adrfn, valfn}) OR (x.obj.adr = bitsfn)) THEN
INC(nofStats) (*<<*)
END;
StandProcCall(x) (* x may be NIL *)
(*
ELSIF sym = lparen THEN
CPS.Get(sym); CPB.PrepCall(x, fpar);
ActualParameters(apar, fpar);
INC(nofStats); (*<<*)
CPB.Call(x, apar, fpar);
CheckSym(rparen);
IF level > 0 THEN CPT.topScope.link.leaf := FALSE END
ELSIF id.mode = Typ THEN UseType(id, CPM.errpos) (*<< type gets used, e.g. SIZE(Node) *)
*)
END;
ELSIF sym = number THEN
CASE CPS.numtyp OF
char:
x := CPB.NewIntConst(CPS.intval); x.typ := CPT.char8typ;
IF CPS.intval > 255 THEN x.typ := CPT.char16typ END
| integer: x := CPB.NewIntConst(CPS.intval)
| int64: x := CPB.NewLargeIntConst(CPS.intval, CPS.realval)
| real: x := CPB.NewRealConst(CPS.realval, NIL)
| real32: x := CPB.NewRealConst(CPS.realval, CPT.real32typ)
| real64: x := CPB.NewRealConst(CPS.realval, CPT.real64typ)
END ;
CPS.Get(sym)
ELSIF sym = string THEN
x := CPB.NewString(CPS.str, CPS.intval);
CPS.Get(sym)
ELSIF sym = nil THEN
x := CPB.Nil(); CPS.Get(sym)
ELSIF sym = lparen THEN
CPS.Get(sym); Expression(x); CheckSym(rparen)
ELSIF sym = lbrak THEN
CPS.Get(sym); err(lparen); Expression(x); CheckSym(rparen)
ELSIF sym = lbrace THEN CPS.Get(sym); Sets(x)
ELSIF sym = not THEN
CPS.Get(sym); Factor(x); CPB.MOp(not, x)
ELSE err(13); CPS.Get(sym); x := NIL
END ;
IF x = NIL THEN x := CPB.NewIntConst(1); x.typ := CPT.undftyp END
END Factor;
PROCEDURE Term(VAR x: CPT.Node);
VAR y: CPT.Node; mulop: BYTE;
BEGIN Factor(x);
WHILE (times <= sym) & (sym <= and) DO
mulop := sym; CPS.Get(sym);
Factor(y); CPB.Op(mulop, x, y)
END
END Term;
PROCEDURE SimpleExpression(VAR x: CPT.Node);
VAR y: CPT.Node; addop: BYTE;
BEGIN
IF sym = minus THEN CPS.Get(sym); Term(x); CPB.MOp(minus, x)
ELSIF sym = plus THEN CPS.Get(sym); Term(x); CPB.MOp(plus, x)
ELSE Term(x)
END ;
WHILE (plus <= sym) & (sym <= or) DO
addop := sym; CPS.Get(sym); Term(y);
IF x.typ.form = Pointer THEN CPB.DeRef(x) END;
IF (x.typ.comp IN {Array, DynArr}) & (x.typ.BaseTyp.form IN charSet) THEN CPB.StrDeref(x) END;
IF y.typ.form = Pointer THEN CPB.DeRef(y) END;
IF (y.typ.comp IN {Array, DynArr}) & (y.typ.BaseTyp.form IN charSet) THEN CPB.StrDeref(y) END;
CPB.Op(addop, x, y)
END
END SimpleExpression;
PROCEDURE Expression(VAR x: CPT.Node);
VAR y, pre, last: CPT.Node; obj: CPT.Object; relation: BYTE;
BEGIN SimpleExpression(x);
IF (eql <= sym) & (sym <= geq) THEN
relation := sym; CPS.Get(sym); SimpleExpression(y);
pre := NIL; last := NIL;
IF (x.typ.comp IN {Array, DynArr}) & (x.typ.BaseTyp.form IN charSet) THEN CPB.StrDeref(x) END;
IF (y.typ.comp IN {Array, DynArr}) & (y.typ.BaseTyp.form IN charSet) THEN CPB.StrDeref(y) END;
CPB.CheckBuffering(x, NIL, NIL, pre, last);
CPB.CheckBuffering(y, NIL, NIL, pre, last);
CPB.Op(relation, x, y);
IF pre # NIL THEN CPB.Construct(Ncomp, pre, x); pre.typ := x.typ; x := pre END;
ELSIF sym = in THEN
CPS.Get(sym); SimpleExpression(y); CPB.In(x, y)
ELSIF sym = is THEN
CPS.Get(sym);
IF sym = ident THEN
qualident(obj);
UseType(obj, CPM.errpos); (*<< type gets used*)
IF obj.mode = Typ THEN CPB.TypTest(x, obj, FALSE)
ELSE err(52)
END
ELSE err(ident)
END
END
END Expression;
PROCEDURE ProcedureDeclaration(VAR x: CPT.Node);
VAR proc, fwd: CPT.Object;
name: CPT.Name;
mode: BYTE;
forward: BOOLEAN;
sys: SHORTINT;
pos: INTEGER; (*<< *)
PROCEDURE GetCode;
VAR ext: CPT.ConstExt; i, n, c: INTEGER; s: ARRAY 256 OF SHORTCHAR;
BEGIN
n := 0;
LOOP
IF sym = number THEN c := CPS.intval; INC(n);
IF (c < 0) OR (c > 255) OR (n = 255) THEN
err(64); c := 1; n := 1
END ;
CPS.Get(sym); s[n] := SHORT(CHR(c))
END ;
IF sym = comma THEN CPS.Get(sym)
ELSIF sym = number THEN err(comma)
ELSE s[0] := SHORT(CHR(n)); EXIT
END
END;
NEW(ext, n + 1); proc.conval.ext := ext; i := 0;
WHILE i <= n DO ext[i] := s[i]; INC(i) END;
INCL(proc.conval.setval, hasBody)
END GetCode;
PROCEDURE GetParams;
VAR name: CPT.String;
BEGIN
proc.mode := mode; proc.typ := CPT.notyp;
proc.sysflag := SHORT(sys);
proc.conval.setval := {};
IF sym = lparen THEN
CPS.Get(sym); FormalParameters(proc.link, proc.typ, name);
IF name # NIL THEN err(0) END
END;
CheckForwardTypes; userList := NIL;
IF fwd # NIL THEN
CPB.CheckParameters(proc.link, fwd.link, TRUE);
IF ~CPT.EqualType(proc.typ, fwd.typ) THEN err(117) END ;
proc := fwd; CPT.topScope := proc.scope;
IF mode = IProc THEN proc.mode := IProc END
END
END GetParams;
PROCEDURE Body;
VAR procdec, statseq: CPT.Node; c: INTEGER;
BEGIN
c := CPM.errpos;
INCL(proc.conval.setval, hasBody);
CheckSym(semicolon); Block(procdec, statseq);
CPB.Enter(procdec, statseq, proc); x := procdec;
x.conval := CPT.NewConst(); x.conval.intval := c; x.conval.intval2 := CPM.startpos;
CheckSym(end);
IF sym = ident THEN
IF CPS.name # proc.name^ THEN err(4) END ;
CPS.Get(sym)
ELSE err(ident)
END
END Body;
PROCEDURE TProcDecl;
VAR baseProc, o: CPT.Object;
objTyp, recTyp: CPT.Struct;
objMode, objVis: BYTE;
objName: CPT.Name;
pnode: CPT.Node;
pos1, pos2: INTEGER; (*<<*)
BEGIN
CPS.Get(sym); mode := TProc;
IF level > 0 THEN err(73) END;
pos1 := CPM.errpos; (*<<*)
Receiver(objMode, objVis, objName, objTyp, recTyp);
IF sym = ident THEN
name := CPS.name;
CPT.FindField(name, recTyp, fwd);
CPT.FindBaseField(name, recTyp, baseProc);
IF (baseProc # NIL) & (baseProc.mode # TProc) THEN baseProc := NIL END ;
IF fwd = baseProc THEN fwd := NIL END ;
IF (fwd # NIL) & (fwd.mnolev # level) THEN fwd := NIL END ;
IF (fwd # NIL) & (fwd.mode = TProc) & (fwd.conval.setval * {hasBody, absAttr, empAttr} = {}) THEN
(* there exists a corresponding forward declaration *)
proc := CPT.NewObj(); proc.leaf := TRUE;
proc.mode := TProc; proc.conval := CPT.NewConst();
CheckMark(proc);
IF fwd.vis # proc.vis THEN err(118) END
ELSE
IF fwd # NIL THEN err(1); fwd := NIL END ;
CPT.InsertField(name, recTyp, proc);
proc.mode := TProc; proc.conval := CPT.NewConst();
CheckMark(proc);
IF recTyp.strobj # NIL THEN (* preserve declaration order *)
o := recTyp.strobj.link;
IF o = NIL THEN recTyp.strobj.link := proc
ELSE
WHILE o.nlink # NIL DO o := o.nlink END;
o.nlink := proc
END
END
END;
pos2 := CPM.errpos; proc.num := set; (*<< methods are set*)
INC(level); CPT.OpenScope(level, proc);
CPT.Insert(objName, proc.link); proc.link.mode := objMode; proc.link.vis := objVis; proc.link.typ := objTyp;
proc^.link.adr := pos1; (*<< *)
(*
(*<< receiver is set/setUsed *)
IF objMode = VarPar THEN proc^.link.num := setUsed ELSE proc^.link.num := set END;
*)
proc.link.num := setUsed; (* BJ: No point in warning about recievers. (commented out the line above...)*)
ASSERT(CPT.topScope # NIL);
GetParams;
ASSERT(CPT.topScope # NIL);
GetAttributes(proc, baseProc, recTyp);
IF ((absAttr IN proc.conval.setval) OR (empAttr IN proc.conval.setval)) & (proc.link.link # NIL) THEN
o := proc.link.link;
WHILE o # NIL DO o.num := setUsed; o := o.link END;
END;
IF (fwd # NIL) & (fwd.conval.setval / proc.conval.setval * {absAttr, empAttr, extAttr} # {}) THEN err(184) END;
CheckOverwrite(proc, baseProc, recTyp);
IF ~forward THEN
IF empAttr IN proc.conval.setval THEN (* insert empty procedure *)
pnode := NIL; CPB.Enter(pnode, NIL, proc);
pnode.conval := CPT.NewConst();
pnode.conval.intval := CPM.errpos;
pnode.conval.intval2 := CPM.errpos;
x := pnode
ELSIF ~(absAttr IN proc.conval.setval) THEN Body
END;
proc.adr := 0
ELSE proc.adr := CPM.errpos
END;
proc.adr := pos2; (*<< *)
DEC(level); CPT.CloseScope
ELSE err(ident)
END
END TProcDecl;
BEGIN proc := NIL; forward := FALSE; x := NIL; mode := LProc; sys := 0;
IF (sym # ident) & (sym # lparen) THEN
CheckSysFlag(sys, CPM.GetProcSysFlag);
IF sys # 0 THEN
(*
IF ~CPT.SYSimported THEN err(135) END;
*)
IF sys = CPM.CProcFlag THEN mode := CProc END
ELSE
IF sym = times THEN (* mode set later in CPB.CheckAssign *)
ELSIF sym = arrow THEN forward := TRUE
ELSE err(ident)
END;
CPS.Get(sym)
END
END ;
IF sym = lparen THEN TProcDecl
ELSIF sym = ident THEN CPT.Find(CPS.name, fwd);
name := CPS.name;
IF (fwd # NIL) & ((fwd.mnolev # level) OR (fwd.mode = SProc)) THEN fwd := NIL END ;
IF (fwd # NIL) & (fwd.mode IN {LProc, XProc}) & ~(hasBody IN fwd.conval.setval) THEN
(* there exists a corresponding forward declaration *)
proc := CPT.NewObj(); proc.leaf := TRUE;
proc.mode := mode; proc.conval := CPT.NewConst();
CheckMark(proc);
IF fwd.vis # proc.vis THEN err(118) END
ELSE
IF fwd # NIL THEN err(1); fwd := NIL END ;
CheckOuter; (*<<*)
CPT.Insert(name, proc);
proc.mode := mode; proc.conval := CPT.NewConst();
CheckMark(proc)
END ;
pos := CPM.errpos; proc.num := set; (*<< procedures are set *)
IF (proc.vis # internal) & (mode = LProc) THEN mode := XProc END ;
IF (mode # LProc) & (level > 0) THEN err(73) END ;
INC(level); CPT.OpenScope(level, proc);
proc.link := NIL; GetParams;
IF mode = CProc THEN GetCode
ELSIF CPM.interface IN CPM.options THEN INCL(proc.conval.setval, hasBody)
ELSIF ~forward THEN Body; proc.adr := 0
ELSE proc.adr := CPM.errpos
END ;
proc.adr := pos; (*<< *)
DEC(level); CPT.CloseScope
ELSE err(ident)
END
END ProcedureDeclaration;
PROCEDURE CaseLabelList(VAR lab, root: CPT.Node; LabelForm: SHORTINT; VAR min, max: INTEGER);
VAR x, y: CPT.Node; f: SHORTINT; xval, yval: INTEGER;
PROCEDURE Insert(VAR n: CPT.Node); (* build binary tree of label ranges *) (* !!! *)
BEGIN
IF n = NIL THEN
IF x.hint # 1 THEN n := x END
ELSIF yval < n.conval.intval THEN Insert(n.left)
ELSIF xval > n.conval.intval2 THEN Insert(n.right)
ELSE err(63)
END
END Insert;
BEGIN lab := NIL;
LOOP ConstExpression(x); f := x.typ.form;
IF f IN intSet + charSet THEN xval := x.conval.intval
ELSE err(61); xval := 1
END ;
IF (f IN intSet) # (LabelForm IN intSet) THEN err(60) END;
IF sym = upto THEN
CPS.Get(sym); ConstExpression(y); yval := y.conval.intval;
IF (y.typ.form IN intSet) # (LabelForm IN intSet) THEN err(60) END;
IF yval < xval THEN err(63); yval := xval END
ELSE yval := xval
END ;
x.conval.intval2 := yval;
IF xval < min THEN min := xval END;
IF yval > max THEN max := yval END;
IF lab = NIL THEN lab := x; Insert(root)
ELSIF yval < lab.conval.intval - 1 THEN x.link := lab; lab := x; Insert(root)
ELSIF yval = lab.conval.intval - 1 THEN x.hint := 1; Insert(root); lab.conval.intval := xval
ELSIF xval = lab.conval.intval2 + 1 THEN x.hint := 1; Insert(root); lab.conval.intval2 := yval
ELSE
y := lab;
WHILE (y.link # NIL) & (xval > y.link.conval.intval2 + 1) DO y := y.link END;
IF y.link = NIL THEN y.link := x; Insert(root)
ELSIF yval < y.link.conval.intval - 1 THEN x.link := y.link; y.link := x; Insert(root)
ELSIF yval = y.link.conval.intval - 1 THEN x.hint := 1; Insert(root); y.link.conval.intval := xval
ELSIF xval = y.link.conval.intval2 + 1 THEN x.hint := 1; Insert(root); y.link.conval.intval2 := yval
END
END;
IF sym = comma THEN CPS.Get(sym)
ELSIF (sym = number) OR (sym = ident) THEN err(comma)
ELSE EXIT
END
END
END CaseLabelList;
PROCEDURE Evaluate (n: CPT.Node; VAR min, max, num, dist: INTEGER; VAR head: CPT.Node);
VAR a: INTEGER;
BEGIN
a := MIN(INTEGER);
IF n.left # NIL THEN
a := MIN(INTEGER); Evaluate(n.left, min, a, num, dist, head);
IF n.conval.intval - a > dist THEN dist := n.conval.intval - a; head := n END
ELSIF n.conval.intval < min THEN
min := n.conval.intval
END;
IF n.right # NIL THEN
a := MAX(INTEGER); Evaluate(n.right, a, max, num, dist, head);
IF a - n.conval.intval2 > dist THEN dist := a - n.conval.intval2; head := n END
ELSIF n.conval.intval2 > max THEN
max := n.conval.intval2
END;
INC(num);
IF n.conval.intval < n.conval.intval2 THEN
INC(num);
IF n.conval.intval2 - n.conval.intval > dist THEN dist := n.conval.intval2 - n.conval.intval; head := n END
END
END Evaluate;
PROCEDURE Rebuild (VAR root: CPT.Node; head: CPT.Node);
VAR n: CPT.Node;
BEGIN
IF root # head THEN
IF head.conval.intval2 < root.conval.intval THEN
Rebuild(root.left, head);
n := head; WHILE n.right # NIL DO n := n.right END;
n.right := root; root.left := NIL; root := head
ELSE
Rebuild(root.right, head);
n := head; WHILE n.left # NIL DO n := n.left END;
n.left := root; root.right := NIL; root := head
END
END
END Rebuild;
PROCEDURE Optimize (VAR n: CPT.Node);
VAR min, max, num, dist, limit: INTEGER; head: CPT.Node;
BEGIN
IF n # NIL THEN
min := MAX(INTEGER); max := MIN(INTEGER); num := 0; dist := 0; head := n;
Evaluate(n, min, max, num, dist, head);
limit := 6 * num;
IF limit < 100 THEN limit := 100 END;
IF (num > 4) & ((min > MAX(INTEGER) - limit) OR (max < min + limit)) THEN
INCL(n.conval.setval, useTable)
ELSE
IF num > 4 THEN Rebuild(n, head) END;
INCL(n.conval.setval, useTree);
Optimize(n.left);
Optimize(n.right)
END
END
END Optimize;
(*
PROCEDURE ShowTree (n: CPT.Node; opts: SET);
BEGIN
IF n # NIL THEN
IF opts = {} THEN opts := n.conval.setval END;
IF useTable IN opts THEN
IF n.left # NIL THEN ShowTree(n.left, opts); CPM.LogW(",") END;
CPM.LogWNum(n.conval.intval, 1);
IF n.conval.intval2 > n.conval.intval THEN CPM.LogW("-"); CPM.LogWNum(n.conval.intval2, 1) END;
IF n.right # NIL THEN CPM.LogW(","); ShowTree(n.right, opts) END
ELSIF useTree IN opts THEN
CPM.LogW("("); ShowTree(n.left, {}); CPM.LogW("|"); CPM.LogWNum(n.conval.intval, 1);
IF n.conval.intval2 > n.conval.intval THEN CPM.LogW("-"); CPM.LogWNum(n.conval.intval2, 1) END;
CPM.LogW("|"); ShowTree(n.right, {}); CPM.LogW(")")
ELSE
ShowTree(n.left, opts); CPM.LogW(" "); CPM.LogWNum(n.conval.intval, 1);
IF n.conval.intval2 > n.conval.intval THEN CPM.LogW("-"); CPM.LogWNum(n.conval.intval2, 1) END;
CPM.LogW(" "); ShowTree(n.right, opts)
END
END
END ShowTree;
*)
PROCEDURE StatSeq(VAR stat: CPT.Node);
VAR fpar, id, t: CPT.Object; idtyp: CPT.Struct; e: BOOLEAN; oldSym: BYTE; (*<< oldSym*)
s, x, y, z, apar, last, lastif, pre, lastp: CPT.Node; pos, p: INTEGER; pos1, lastSemiPos: INTEGER;
(*<< pos1, pos2, oldPos *)
lastSemi: BOOLEAN; (*<<*)
PROCEDURE CasePart(VAR x: CPT.Node);
VAR low, high: INTEGER; e: BOOLEAN; cases, lab, y, lastcase, root: CPT.Node;
BEGIN
Expression(x);
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF x.typ.form = Int64 THEN err(260)
ELSIF ~(x.typ.form IN intSet + charSet) THEN err(125)
END ;
CheckSym(of); cases := NIL; lastcase := NIL; root := NIL;
low := MAX(INTEGER); high := MIN(INTEGER);
LOOP
IF sym < bar THEN
CaseLabelList(lab, root, x.typ.form, low, high);
CheckSym(colon); StatSeq(y);
CPB.Construct(Ncasedo, lab, y); CPB.Link(cases, lastcase, lab)
END ;
IF sym = bar THEN CPS.Get(sym) ELSE EXIT END
END;
e := sym = else;
IF e THEN CPS.Get(sym); StatSeq(y) ELSE y := NIL END ;
CPB.Construct(Ncaselse, cases, y); CPB.Construct(Ncase, x, cases);
cases.conval := CPT.NewConst();
cases.conval.intval := low; cases.conval.intval2 := high;
IF e THEN cases.conval.setval := {1} ELSE cases.conval.setval := {} END;
Optimize(root); cases.link := root (* !!! *)
END CasePart;
PROCEDURE SetPos(x: CPT.Node);
BEGIN
x.conval := CPT.NewConst(); x.conval.intval := pos
END SetPos;
PROCEDURE CheckBool(VAR x: CPT.Node);
BEGIN
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126); x := CPB.NewBoolConst(FALSE)
ELSIF x.typ.form # Bool THEN err(120); x := CPB.NewBoolConst(FALSE)
END
END CheckBool;
BEGIN stat := NIL; last := NIL;
lastSemi := FALSE; lastSemiPos := 0; (*<<*)
LOOP x := NIL;
IF sym < ident THEN err(14);
REPEAT CPS.Get(sym) UNTIL sym >= ident
END ;
INC(nofStats); oldSym := null; (*<<*)
pos := CPM.startpos;
IF sym = ident THEN
pos1 := CPM.curpos; (*<<*)
qualident(id); x := CPB.NewLeaf(id); selector(x);
IF sym = becomes THEN
(*<<
pos2 := CPM.curpos; (*<<*)
*)
CPS.Get(sym); Expression(y);
Selector(x, SelAssign, SelNoVarPar, SelUseBSet, pos1); (*<< id gets set for the first time *)
IF (y.typ.form = Pointer) & (x.typ.form = Comp) THEN CPB.DeRef(y) END;
pre := NIL; lastp := NIL;
CPB.CheckBuffering(y, x, NIL, pre, lastp);
CPB.Assign(x, y);
(*<< fixed in CP
IF (x.left.class = Neguard) & (x.right.typ.comp = Record) THEN (*<< record assignment to varpar *)
err2(impliedTypeGuard, pos2)
END;
*)
IF pre # NIL THEN SetPos(x); CPB.Construct(Ncomp, pre, x); x := pre END
ELSIF sym = eql THEN
err(becomes); CPS.Get(sym); Expression(y); CPB.Assign(x, y)
ELSIF (x.class = Nproc) & (x.obj.mode = SProc) THEN
StandProcCall(x);
IF (x # NIL) & (x.typ # CPT.notyp) THEN err(55) END;
IF (x # NIL) & (x.class = Nifelse) THEN (* error pos for ASSERT *)
SetPos(x.left); SetPos(x.left.right)
END;
ELSIF x.class = Ncall THEN err(55)
ELSE
pre := NIL; lastp := NIL;
IF (x.class = Nfield) & (x.obj.mode = TProc)
& (x.obj.link.mode = VarPar) & (x.obj.link.typ.comp = Record) THEN
Selector(x.left, SelAssign, SelVarPar, SelUseBSet, pos1) (*<< receiver is var parameter and record *)
END;
Selector(x, SelNoAssign, SelNoVarPar, SelUseBSet, pos1); (*<< proc in node x gets called *)
CPB.PrepCall(x, fpar);
IF (x.obj # NIL) & (x.obj.mode = TProc) THEN CPB.CheckBuffering(x.left, NIL, x.obj.link, pre, lastp) END;
IF sym = lparen THEN
CPS.Get(sym); ActualParameters(apar, fpar, pre, lastp); CheckSym(rparen)
ELSE apar := NIL;
IF fpar # NIL THEN err(65) END
END ;
CPB.Call(x, apar, fpar);
IF x.typ # CPT.notyp THEN err(55) END;
IF pre # NIL THEN SetPos(x); CPB.Construct(Ncomp, pre, x); x := pre END;
IF level > 0 THEN CPT.topScope.link.leaf := FALSE END
END
ELSIF sym = if THEN
CPS.Get(sym); pos := CPM.startpos; Expression(x); CheckBool(x); CheckSym(then); StatSeq(y);
CPB.Construct(Nif, x, y); SetPos(x); lastif := x;
WHILE sym = elsif DO
CPS.Get(sym); pos := CPM.startpos; Expression(y); CheckBool(y); CheckSym(then); StatSeq(z);
CPB.Construct(Nif, y, z); SetPos(y); CPB.Link(x, lastif, y)
END ;
pos := CPM.startpos;
IF sym = else THEN CPS.Get(sym); StatSeq(y) ELSE y := NIL END ;
CPB.Construct(Nifelse, x, y); CheckSym(end); CPB.OptIf(x)
ELSIF sym = case THEN
CPS.Get(sym); pos := CPM.startpos; CasePart(x); CheckSym(end)
ELSIF sym = while THEN
CPS.Get(sym); pos := CPM.startpos; Expression(x); CheckBool(x); CheckSym(do); StatSeq(y);
CPB.Construct(Nwhile, x, y); CheckSym(end)
ELSIF sym = repeat THEN
CPS.Get(sym); StatSeq(x);
IF sym = until THEN CPS.Get(sym); pos := CPM.startpos; Expression(y); CheckBool(y)
ELSE err(43)
END ;
CPB.Construct(Nrepeat, x, y)
ELSIF sym = for THEN
CPS.Get(sym); pos := CPM.startpos;
IF sym = ident THEN qualident(id);
SetObj(id, FALSE, CPM.errpos); UseObj(id, TRUE, CPM.errpos); (*<< for variable gets set & used*)
INC(id.num, noChange); (*<< loop variable shouldn't be changed!*)
IF ~(id.typ.form IN intSet) THEN err(68) END ;
CheckSym(becomes); Expression(y);
x := CPB.NewLeaf(id); CPB.Assign(x, y); SetPos(x);
CheckSym(to); pos := CPM.startpos; Expression(y);
IF y.class # Nconst THEN
CPB.GetTempVar("@for", x.left.typ, t);
t.num := setUsed; (*<< temporary var gets set and used*)
z := CPB.NewLeaf(t); CPB.Assign(z, y); SetPos(z); CPB.Link(stat, last, z);
y := CPB.NewLeaf(t)
ELSE
CPB.CheckAssign(x.left.typ, y)
END ;
CPB.Link(stat, last, x);
p := CPM.startpos;
IF sym = by THEN CPS.Get(sym); ConstExpression(z) ELSE z := CPB.NewIntConst(1) END ;
x := CPB.NewLeaf(id);
IF z.conval.intval > 0 THEN CPB.Op(leq, x, y)
ELSIF z.conval.intval < 0 THEN CPB.Op(geq, x, y)
ELSE err(63); CPB.Op(geq, x, y)
END ;
CheckSym(do); StatSeq(s);
y := CPB.NewLeaf(id); CPB.StPar1(y, z, incfn); pos := CPM.startpos; SetPos(y);
IF s = NIL THEN s := y
ELSE z := s;
WHILE z.link # NIL DO z := z.link END ;
z.link := y
END ;
CheckSym(end); CPB.Construct(Nwhile, x, s); pos := p;
DEC(id.num, noChange) (*<< reset noChange attribute for loopvariable*)
ELSE err(ident)
END
ELSIF sym = loop THEN
CPS.Get(sym); INC(LoopLevel); StatSeq(x); DEC(LoopLevel);
CPB.Construct(Nloop, x, NIL); CheckSym(end)
ELSIF sym = with THEN
CPS.Get(sym); idtyp := NIL; x := NIL;
LOOP
IF sym < bar THEN (* bj: added to be compliant with DevCPP.StatSeq *)
pos := CPM.startpos;
IF sym = ident THEN
qualident(id);
UseObj(id, TRUE, CPM.errpos); (*<<*)
y := CPB.NewLeaf(id);
IF (id # NIL) & (id.typ.form = Pointer) & ((id.mode = VarPar) OR ~id.leaf) THEN
err(-302) (* warning 302 *)
END ;
CheckSym(colon);
IF sym = ident THEN qualident(t);
UseType(t, CPM.errpos); (*<< type gets used*)
IF t.mode = Typ THEN
IF id # NIL THEN
idtyp := id.typ; CPB.TypTest(y, t, FALSE); id.typ := t.typ;
IF id.ptyp = NIL THEN id.ptyp := idtyp END
ELSE err(130)
END
ELSE err(52)
END
ELSE err(ident)
END
ELSE err(ident)
END ;
pos1 := CPM.errpos; (* << *)
CheckSym(do); StatSeq(s); CPB.Construct(Nif, y, s); SetPos(y);
IF idtyp # NIL THEN
IF id.ptyp = idtyp THEN id.ptyp := NIL END;
id.typ := idtyp; idtyp := NIL
END ;
IF x = NIL THEN x := y; lastif := x ELSE CPB.Link(x, lastif, y) END
END;
IF sym = bar THEN CPS.Get(sym) ELSE EXIT END
END;
e := sym = else; pos := CPM.startpos;
IF e THEN CPS.Get(sym); StatSeq(s) ELSE s := NIL END ;
CPB.Construct(Nwith, x, s); CheckSym(end);
IF e THEN x.subcl := 1 END
ELSIF sym = exit THEN
CPS.Get(sym);
IF LoopLevel = 0 THEN err(46) END ;
CPB.Construct(Nexit, x, NIL);
oldSym := exit (*<<*)
ELSIF sym = return THEN CPS.Get(sym);
IF sym < semicolon THEN Expression(x) END ;
IF level > 0 THEN CPB.Return(x, CPT.topScope.link)
ELSE (* not standard Oberon *) CPB.Return(x, NIL)
END;
hasReturn := TRUE;
oldSym := return (*<<*)
ELSE (*<< empty statement*)
IF options.semicolons THEN
IF sym = semicolon THEN err2(semicolons, CPM.errpos)
ELSIF lastSemi THEN err2(semicolons, lastSemiPos)
END
END;
DEC(nofStats)
END ;
IF x # NIL THEN SetPos(x); CPB.Link(stat, last, x) END ;
IF sym = semicolon THEN (*<<*)
lastSemi := TRUE; lastSemiPos := CPM.errpos
ELSE lastSemi := FALSE (*<<*)
END;
IF sym = semicolon THEN CPS.Get(sym)
ELSIF (sym <= ident) OR (if <= sym) & (sym <= return) THEN err(semicolon)
ELSE EXIT
END;
IF (exit <= oldSym) & (oldSym <= return) & ((sym < bar) OR (until < sym)) THEN (*<< statement after return/exit*)
err2(statAfterRetEx, CPM.errpos)
END
END
END StatSeq;
PROCEDURE Block(VAR procdec, statseq: CPT.Node);
VAR typ: CPT.Struct;
obj, first, last, o: CPT.Object;
x, lastdec: CPT.Node;
i: SHORTINT;
rname: CPT.Name;
name: CPT.String;
rec: Elem;
pos, save: INTEGER; (*<<*)
BEGIN
first := NIL; last := NIL; userList := NIL; recList := NIL;
save := nofStats; (*<<*)
LOOP
IF sym = const THEN
CPS.Get(sym);
WHILE sym = ident DO
CheckOuter; (*<<*)
CPT.Insert(CPS.name, obj);
obj.mode := Con; CheckMark(obj);
obj.typ := CPT.int8typ; obj.mode := Var; (* Var to avoid recursive definition *)
pos := CPM.errpos; (*<<*)
IF sym = eql THEN
CPS.Get(sym); ConstExpression(x)
ELSIF sym = becomes THEN
err(eql); CPS.Get(sym); ConstExpression(x)
ELSE err(eql); x := CPB.NewIntConst(1)
END ;
obj.mode := Con; obj.typ := x.typ; obj.conval := x.conval; (* ConstDesc ist not copied *)
obj.adr := pos; obj.num := set; (*<< constants are set by default*)
CheckSym(semicolon)
END
END ;
IF sym = type THEN
CPS.Get(sym);
WHILE sym = ident DO
CheckOuter; (*<<*)
CPT.Find(CPS.name, obj); (* could have been used as a forward type definition *)
IF obj = NIL THEN CPT.Insert(CPS.name, obj) END;
obj.mode := -1; obj.typ := CPT.undftyp;
CheckMark(obj);
obj.adr := CPM.errpos;
IF obj.num > clean THEN obj.num := setUsed ELSE obj.num := set END; (*<< types are set by default*)
IF sym # eql THEN err(eql) END;
IF (sym = eql) OR (sym = becomes) OR (sym = colon) THEN
CPS.Get(sym); Type(obj.typ, name); SetType(NIL, obj, obj.typ, name)
END;
obj.mode := Typ;
IF obj.typ.form IN {Byte..Set, Char16, Int64} THEN (* make alias structure *)
typ := CPT.NewStr(obj.typ.form, Basic); i := typ.ref;
typ^ := obj.typ^; typ.ref := i; typ.strobj := NIL; typ.mno := 0;
typ.BaseTyp := obj.typ; obj.typ := typ
END;
IF obj.typ.strobj = NIL THEN obj.typ.strobj := obj END ;
IF obj.typ.form = Pointer THEN (* !!! *)
typ := obj.typ.BaseTyp;
IF (typ # NIL) & (typ.comp = Record) & (typ.strobj = NIL) THEN
(* pointer to unnamed record: name record as "pointerName^" *)
rname := obj.name^$; i := 0;
WHILE rname[i] # 0X DO INC(i) END;
rname[i] := "^"; rname[i+1] := 0X;
CPT.Insert(rname, o); o.mode := Typ; o.typ := typ; typ.strobj := o;
o.adr := CPM.errpos; o.num := setUsed (*<< anonymous record types are set and used by default*)
END
END;
IF obj.vis # internal THEN
typ := obj.typ;
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
IF typ.comp = Record THEN typ.exp := TRUE END
END;
CheckSym(semicolon)
END
END ;
IF sym = var THEN
CPS.Get(sym);
WHILE sym = ident DO
LOOP
IF sym = ident THEN
CheckOuter; (*<<*)
CPT.Insert(CPS.name, obj);
obj.mode := Var; obj.link := NIL; obj.leaf := obj.vis = internal; obj.typ := CPT.undftyp;
CheckMark(obj);
obj.adr := CPM.errpos; obj.num := clean; (*<<*)
IF first = NIL THEN first := obj END ;
IF last = NIL THEN CPT.topScope.scope := obj ELSE last.link := obj END;
last := obj
ELSE err(ident)
END;
IF sym = comma THEN CPS.Get(sym)
ELSIF sym = ident THEN err(comma);
ELSE EXIT
END
END ;
CheckSym(colon); Type(typ, name);
CheckAlloc(typ, FALSE, CPM.errpos);
WHILE first # NIL DO SetType(NIL, first, typ, name); first := first.link END ;
CheckSym(semicolon)
END
END ;
IF (sym < const) OR (sym > var) THEN EXIT END
END ;
nofStats := save; (*<<*)
CheckForwardTypes;
userList := NIL; rec := recList; recList := NIL;
CPT.topScope.adr := CPM.errpos;
procdec := NIL; lastdec := NIL;
WHILE sym = procedure DO
CPS.Get(sym); ProcedureDeclaration(x);
IF x # NIL THEN
IF lastdec = NIL THEN procdec := x ELSE lastdec.link := x END ;
lastdec := x
END ;
CheckSym(semicolon)
END ;
IF CPM.noerr & ~(CPM.oberon IN CPM.options) THEN CheckRecords(rec) END;
hasReturn := FALSE;
IF sym = begin THEN CPS.Get(sym); StatSeq(statseq)
ELSE statseq := NIL
END ;
IF (CPT.topScope.link # NIL) & (CPT.topScope.link.typ # CPT.notyp)
& ~hasReturn & (CPT.topScope.link.sysflag = 0) THEN err(133) END;
IF (level = 0) & (TDinit # NIL) THEN
lastTDinit.link := statseq; statseq := TDinit
END
END Block;
PROCEDURE Module*(VAR prog: CPT.Node);
VAR impName, aliasName: CPT.Name; obj: CPT.Object; (*<< obj *)
procdec, statseq: CPT.Node;
c: INTEGER; done: BOOLEAN;
BEGIN
CPS.Init; LoopLevel := 0; level := 0; CPS.Get(sym);
NEW(errHead); nofStats := 0; (*<<*)
IF sym = module THEN CPS.Get(sym) ELSE err(16) END ;
IF sym = ident THEN
CPT.Open(CPS.name); CPS.Get(sym);
CPT.libName := "";
IF sym = lbrak THEN
INCL(CPM.options, CPM.interface); CPS.Get(sym);
IF sym = string THEN CPT.libName := CPS.str^$; CPS.Get(sym)
ELSE err(string)
END;
CheckSym(rbrak)
END;
CheckSym(semicolon);
IF sym = import THEN CPS.Get(sym);
INCL(CPM.options, CPM.comAware); (* BJ: to avoid error when importing COM *)
LOOP
IF sym = ident THEN
aliasName := CPS.name$; impName := aliasName$; CPS.Get(sym);
IF sym = becomes THEN CPS.Get(sym);
IF sym = ident THEN impName := CPS.name$; CPS.Get(sym) ELSE err(ident) END
END ;
CPT.Import(aliasName, impName, done);
CPS.name := aliasName$; (*<<*)
CPT.Find(CPS.name, obj);
IF obj # NIL THEN obj.adr := CPM.errpos; obj.num := set END (*<< modules are set by default *)
ELSE err(ident)
END ;
IF sym = comma THEN CPS.Get(sym)
ELSIF sym = ident THEN err(comma)
ELSE EXIT
END
END ;
CheckSym(semicolon)
END ;
IF CPM.noerr THEN
TDinit := NIL; lastTDinit := NIL; c := CPM.errpos;
Block(procdec, statseq); CPB.Enter(procdec, statseq, NIL); prog := procdec;
prog.conval := CPT.NewConst(); prog.conval.intval := c; prog.conval.intval2 := CPM.startpos;
IF sym = close THEN CPS.Get(sym); StatSeq(prog.link) END;
prog.conval.realval := CPM.startpos;
CheckSym(end);
IF sym = ident THEN
IF CPS.name # CPT.SelfName THEN err(4) END ;
CPS.Get(sym)
ELSE err(ident)
END;
IF sym # period THEN err(period) END;
CheckScope(CPT.topScope) (*<<*)
END
ELSE err(ident)
END ;
TDinit := NIL; lastTDinit := NIL
END Module;
PROCEDURE WriteWarnings(text: TextModels.Model; VAR warning: BOOLEAN); (*<<O/F*)
VAR e: Warning; inserted: SHORTINT;
BEGIN
IF errHead.next = NIL THEN warning := FALSE; CPM.LogWStr(" done")
ELSE
warning := TRUE;
e := errHead.next; inserted := 0;
WHILE e # NIL DO
DevMarkers.Insert(text, e.pos+inserted, DevMarkers.dir.New(e.n)); (*<<*)
e := e.next; INC(inserted)
END
END;
errHead := NIL
END WriteWarnings;
(*<<OP2 procedures *)
PROCEDURE TypeSize(typ: CPT.Struct);
END TypeSize;
PROCEDURE ProcessModule (source: TextModels.Reader; log: TextModels.Model; VAR error, warning: BOOLEAN);
VAR p: CPT.Node; script: Stores.Operation; text: TextModels.Model;
BEGIN
text := source.Base();
Models.BeginModification(Models.clean, text);
Models.BeginScript(text, "#Dev:InsertMarkers", script);
CPM.Init(source, log);
CPT.Init({});
CPB.typSize := (*<<OPV.*)TypeSize;
(*<<CPT.processor := OPL.processor;*)
Module(p);
(*<<
IF CPM.noerr THEN
OPV.Init(opt, DevDebug.breakPos); OPV.Allocate; CPT.Export(ext, new);
IF CPM.noerr THEN
OPV.Module(p);
IF CPM.noerr THEN
IF new OR ext THEN CPM.RegisterNewSym END ;
CPM.LogWStr(" "); CPM.LogWNum(OPL.pc, 8);
CPM.LogWStr(" "); CPM.LogWNum(OPL.dsize, 8)
ELSE CPM.DeleteNewSym
END
END ;
OPL.Close
END ;
*)
CPT.Close;
error := ~CPM.noerr;
CPM.Close;
p := NIL;
Kernel.FastCollect;
IF error THEN
CPM.InsertMarks(source.Base());
CPM.LogWLn; CPM.LogWStr(" ");
IF CPM.errors = 1 THEN
Dialog.MapString("#Dev:OneErrorDetected", str)
ELSE
CPM.LogWNum(CPM.errors, 0); Dialog.MapString("#Dev:ErrorsDetected", str)
END;
StdLog.String(str)
ELSE (*<<*)
options.statements := nofStats;
WriteWarnings(text, warning);
CPM.LogWLn; CPM.LogWNum(nofStats, 0); CPM.LogWStr(" statements")
END;
CPM.LogWLn; CPM.Close;
Models.EndScript(source.Base(), script);
Models.EndModification(Models.clean, text)
END ProcessModule;
PROCEDURE Do (source, log: TextModels.Model; beg: INTEGER; VAR error, warning: BOOLEAN);
VAR r: TextMappers.Scanner;
BEGIN
Dialog.MapString("#Dev:Analyzing", str);
StdLog.String(str); StdLog.Char(" ");
options.fileName := "";
r.ConnectTo(source); r.SetPos(beg); r.Scan;
IF (r.type = TextMappers.string) & (r.string = "MODULE") THEN
r.Scan;
IF r.type = TextMappers.string THEN
StdLog.Char('"'); StdLog.String(r.string); StdLog.Char('"');
options.fileName := r.string
END
END;
sourceR := source.NewReader(NIL); sourceR.SetPos(beg);
ProcessModule(sourceR, log, error, warning); Dialog.Update(options)
END Do;
PROCEDURE Open;
BEGIN
Dialog.ShowStatus("#Dev:Analyzing");
StdLog.buf.Delete(0, StdLog.buf.Length())
END Open;
PROCEDURE Close (noerr: BOOLEAN);
BEGIN
StdLog.text.Append(StdLog.buf);
IF noerr & CPM.noerr THEN Dialog.ShowStatus("#Dev:Ok")
END;
sourceR := NIL;
Kernel.Cleanup
END Close;
PROCEDURE Analyze*;
VAR t: TextModels.Model; error, warning: BOOLEAN;
BEGIN
Open;
t := TextViews.FocusText();
IF t # NIL THEN
Do(t, StdLog.text, 0, error, warning);
IF error OR warning THEN DevMarkers.ShowFirstError(t, TextViews.focusOnly) END
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
Close(~error & ~warning)
END Analyze;
PROCEDURE ResetOptions*;
BEGIN
options.varpar := FALSE; options.exported := FALSE;
options.intermediate := FALSE; options.levels := FALSE;
options.tbProcs := FALSE; options.semicolons := FALSE;
options.sideEffects := FALSE;
options.statements := 0; options.fileName := "";
Dialog.Update(options)
END ResetOptions;
PROCEDURE SaveOptions*;
BEGIN
HostRegistry.WriteBool(regKey + 'varPar', options.varpar);
HostRegistry.WriteBool(regKey + 'exported', options.exported);
HostRegistry.WriteBool(regKey + 'intermediate', options.intermediate);
HostRegistry.WriteBool(regKey + 'levels', options.levels);
HostRegistry.WriteBool(regKey + 'tbProcs', options.tbProcs);
HostRegistry.WriteBool(regKey + 'semicolons', options.semicolons);
HostRegistry.WriteBool(regKey + 'sideEffects', options.sideEffects);
END SaveOptions;
PROCEDURE LoadOptions*;
VAR res: INTEGER;
BEGIN
HostRegistry.ReadBool(regKey + 'varPar', options.varpar, res);
IF res # 0 THEN options.varpar := FALSE END;
HostRegistry.ReadBool(regKey + 'exported', options.exported, res);
IF res # 0 THEN options.exported := FALSE END;
HostRegistry.ReadBool(regKey + 'intermediate', options.intermediate,res);
IF res # 0 THEN options.intermediate := FALSE END;
HostRegistry.ReadBool(regKey + 'levels', options.levels, res);
IF res # 0 THEN options.levels := FALSE END;
HostRegistry.ReadBool(regKey + 'tbProcs', options.tbProcs, res);
IF res # 0 THEN options.tbProcs := FALSE END;
HostRegistry.ReadBool(regKey + 'semicolons', options.semicolons, res);
IF res # 0 THEN options.semicolons := FALSE END;
HostRegistry.ReadBool(regKey + 'sideEffects', options.sideEffects, res);
IF res # 0 THEN options.sideEffects := FALSE END;
Dialog.Update(options)
END LoadOptions;
BEGIN ResetOptions; LoadOptions
END DevAnalyzer.
Warnings:
900 never used
901 never set
902 used before set
903 set but never used
904 used as varpar, possibly not set
905 also declared in outer scope
906 access/assignment to intermediate
907 redefinition
908 new definition
909 statement after RETURN/EXIT
910 for loop variable set
911 implied type guard
912 superfluous type guard
913 call might depend on evaluation sequence of params.
930 superfluous semicolon
Menu entry:
SEPARATOR
"Analyze" "=" "DevAnalyzer.Analyze" "TextCmds.FocusGuard"
"Analyze Selection" "" "DevAnalyzer.AnalyzeSelection" "TextCmds.SelectionGuard"
"Analyze..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/Analyzer', 'Analyze')" ""
| Dev/Mod/Analyzer.odc |
MODULE DevBrowser;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
- 20121021, Fyodor Tkachov, Scan uses i21sysVocabulary IsModule, IsImport (to correctly open module documentation from short name)
"
issues = "
- ...
"
**)
IMPORT
Kernel, Files, Fonts, Dates, Ports, Stores, Views, Properties, Dialog, Documents,
TextModels, TextMappers, TextRulers, TextViews, TextControllers, StdDialog, StdFolds,
DevCPM, DevCPT, HostRegistry, i21sysVocabulary;
CONST
width = 170 * Ports.mm; (* view width *)
height = 300 * Ports.mm;
(* visibility *)
internal = 0; external = 1; externalR = 2; inPar = 3; outPar = 4;
(* object modes *)
var = 1; varPar = 2; const = 3; field = 4; type = 5; lProc = 6; xProc = 7; cProc = 9; iProc = 10;
mod = 11; head = 12; tProc = 13; ptrType = 31;
(* structure forms *)
undef = 0; bool = 2; sChar = 3; byte = 4; sInt = 5; int = 6; sReal = 7; real = 8;
set = 9; sString = 10; nilTyp = 11; noTyp = 12; pointer = 13; procTyp = 14; comp = 15;
char = 16; string = 17; lInt = 18;
(* composite structure forms *)
basic = 1; array = 2; dynArray = 3; record = 4;
(* attribute flags (attr.adr, struct.attribute, proc.conval.setval) *)
newAttr = 16; absAttr = 17; limAttr = 18; empAttr = 19; extAttr = 20;
(* additional scanner types *)
import = 100; module = 101; semicolon = 102; becomes = 103; comEnd = 104;
modNotFoundKey = "#Dev:ModuleNotFound";
noSuchItemExportedKey = "#Dev:NoSuchItemExported";
noSuchExtItemExportedKey = "#Dev:NoSuchExtItemExported";
noModuleNameSelectedKey = "#Dev:NoModuleNameSelected";
noItemNameSelectedKey = "#Dev:NoItemNameSelected";
regKey = "Dev\Browser\";
TYPE
TProcList = POINTER TO RECORD
fld: DevCPT.Object;
attr: SET; (* newAttr *)
next: TProcList
END;
VAR
global: RECORD
hints: BOOLEAN; (* display low-level hints such as field offsets *)
flatten: BOOLEAN; (* include fields/bound procs of base types as well *)
hideHooks: BOOLEAN; (* hide hook procedures and interfaces *)
clientinterface, extensioninterface: BOOLEAN;
sectAttr, keyAttr: TextModels.Attributes; (* formatting of section and other keywords *)
level: SHORTINT; (* current indentation level *)
gap: BOOLEAN; (* request for lazy Ln, issued with next Indent *)
singleton: BOOLEAN; (* selectively display one object's definition *)
thisObj: DevCPT.Name; (* singleton => selected object *)
out: TextMappers.Formatter; (* formatter used to produce definition text *)
systemUsed: BOOLEAN;
comUsed: BOOLEAN;
modUsed: ARRAY 127 OF BOOLEAN;
pos: INTEGER
END;
inp: Files.Reader;
imp: ARRAY 256 OF Kernel.Name;
num, lev, max: INTEGER;
options*: RECORD
hints*: BOOLEAN; (* display low-level hints such as field offsets *)
flatten*: BOOLEAN; (* include fields/bound procs of base types as well *)
formatted*: BOOLEAN;
shints, sflatten, sformatted: BOOLEAN (* saved values *)
END;
PROCEDURE IsHook(typ: DevCPT.Struct): BOOLEAN;
BEGIN
WHILE ((typ.form = pointer) OR (typ.form = comp)) & (typ.BaseTyp # NIL) DO typ := typ.BaseTyp END;
RETURN (DevCPT.GlbMod[typ.mno].name^ = "Kernel") & (typ.strobj.name^ = "Hook^")
END IsHook;
(* auxilliary *)
PROCEDURE GetSelection (VAR text: TextModels.Model; VAR beg, end: INTEGER);
VAR c: TextControllers.Controller;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
text := c.text; c.GetSelection(beg, end)
ELSE
text := NIL
END
END GetSelection;
PROCEDURE GetQualIdent (VAR mod, ident: DevCPT.Name; VAR t: TextModels.Model);
VAR s: TextMappers.Scanner; beg, end: INTEGER;
BEGIN
GetSelection(t, beg, end);
IF t # NIL THEN
s.ConnectTo(t); s.SetOpts({7}); (* acceptUnderscores *)
s.SetPos(beg); s.Scan;
IF (s.type = TextMappers.string) & (s.len < LEN(mod)) THEN
mod := SHORT(s.string$); s.Scan;
IF (s.type = TextMappers.char) & (s.char = ".") & (s.Pos() <= end) THEN
s.Scan;
IF (s.type = TextMappers.string) & (s.len < LEN(ident)) THEN
ident := SHORT(s.string$)
ELSE mod[0] := 0X; ident[0] := 0X
END
ELSE ident[0] := 0X
END
ELSE mod[0] := 0X; ident[0] := 0X
END
ELSE mod[0] := 0X; ident[0] := 0X
END
END GetQualIdent;
PROCEDURE Scan (VAR s: TextMappers.Scanner);
BEGIN
s.Scan;
IF s.type = TextMappers.string THEN
IF i21sysVocabulary.IsImport( s.string ) THEN s.type := import
ELSIF i21sysVocabulary.IsModule( s.string ) THEN s.type := module
(*
IF s.string = 'IMPORT' THEN s.type := import
ELSIF s.string = 'MODULE' THEN s.type := module
*)
END
ELSIF s.type = TextMappers.char THEN
IF s.char = ";" THEN s.type := semicolon
ELSIF s.char = ":" THEN
IF s.rider.char = "=" THEN s.rider.Read; s.type := becomes END
ELSIF s.char = "(" THEN
IF s.rider.char = "*" THEN
s.rider.Read;
REPEAT Scan(s) UNTIL (s.type = TextMappers.eot) OR (s.type = comEnd);
Scan(s)
END
ELSIF s.char = "*" THEN
IF s.rider.char = ")" THEN s.rider.Read; s.type := comEnd END
END
END
END Scan;
PROCEDURE CheckModName (VAR mod: DevCPT.Name; t: TextModels.Model);
VAR s: TextMappers.Scanner;
BEGIN
s.ConnectTo(t); s.SetPos(0); Scan(s);
IF s.type = module THEN
Scan(s);
WHILE (s.type # TextMappers.eot) & (s.type # import) DO Scan(s) END;
WHILE (s.type # TextMappers.eot) & (s.type # semicolon)
& ((s.type # TextMappers.string) OR (s.string # mod)) DO Scan(s) END;
IF s.type = TextMappers.string THEN
Scan(s);
IF s.type = becomes THEN
Scan(s);
IF s.type = TextMappers.string THEN
mod := SHORT(s.string$)
END
END
END
END
END CheckModName;
PROCEDURE NewRuler (): TextRulers.Ruler;
VAR ra: TextRulers.Attributes; p: TextRulers.Prop;
BEGIN
NEW(p); p.valid := {TextRulers.right, TextRulers.opts};
p.opts.val := {(*TextRulers.rightFixed*)}; p.opts.mask := p.opts.val;
p.right := width;
NEW(ra); ra.InitFromProp(p);
RETURN TextRulers.dir.New(TextRulers.dir.NewStyle(ra))
END NewRuler;
PROCEDURE Append (VAR d: ARRAY OF CHAR; s: ARRAY OF SHORTCHAR);
VAR l, ld, ls: INTEGER;
BEGIN
l := LEN(d); ld := LEN(d$); ls := LEN(s$);
IF ld + ls >= l THEN
s[l - ld - 1] := 0X; d := d + s;
d[l - 2] := "."; d[l - 3] := "."; d[l - 4] := "."
ELSE
d := d + s
END
END Append;
PROCEDURE IsLegal (name: POINTER TO ARRAY OF SHORTCHAR): BOOLEAN;
VAR i: SHORTINT;
BEGIN
IF name^ = "" THEN RETURN FALSE END;
IF name[0] = "@" THEN RETURN global.hints END;
i := 0;
WHILE name[i] # 0X DO INC(i) END;
RETURN name[i-1] # "^"
END IsLegal;
(* output formatting *)
PROCEDURE Char (ch: SHORTCHAR);
BEGIN
global.out.WriteChar(ch)
END Char;
PROCEDURE String (s: ARRAY OF SHORTCHAR);
BEGIN
global.out.WriteSString(s)
END String;
PROCEDURE StringConst (s: ARRAY OF SHORTCHAR; long: BOOLEAN);
VAR i, x, y: INTEGER; quoted, first: BOOLEAN;
BEGIN
IF long THEN
i := 0; REPEAT DevCPM.GetUtf8(s, y, i) UNTIL (y = 0) OR (y >= 100H);
IF y = 0 THEN global.out.WriteString("LONG(") END
END;
i := 0; quoted := FALSE; first := TRUE;
IF long THEN DevCPM.GetUtf8(s, x, i) ELSE x := ORD(s[i]); INC(i) END;
WHILE x # 0 DO
IF (x < ORD(" ")) OR (x >= 100H) THEN
IF quoted THEN global.out.WriteChar('"') END;
IF ~first THEN global.out.WriteString(" + ") END;
IF x >= 0A00H THEN global.out.WriteIntForm(x, TextMappers.hexadecimal, 4, "0", FALSE)
ELSIF x >= 0A0H THEN global.out.WriteIntForm(x, TextMappers.hexadecimal, 3, "0", FALSE)
ELSE global.out.WriteIntForm(x, TextMappers.hexadecimal, 2, "0", FALSE)
END;
global.out.WriteChar("X");
quoted := FALSE
ELSE
IF ~quoted THEN
IF ~first THEN global.out.WriteString(" + ") END;
global.out.WriteChar('"')
END;
global.out.WriteChar(CHR(x));
quoted := TRUE
END;
IF long THEN DevCPM.GetUtf8(s, x, i) ELSE x := ORD(s[i]); INC(i) END;
first := FALSE
END;
IF first THEN global.out.WriteString('""') END;
IF quoted THEN global.out.WriteChar('"') END;
IF long & (y = 0) THEN global.out.WriteChar(")") END
END StringConst;
PROCEDURE ProperString (s: ARRAY OF SHORTCHAR);
VAR i: SHORTINT;
BEGIN
IF s # "" THEN
i := 0; WHILE (s[i] # 0X) & (s[i] # "^") DO global.out.WriteChar(s[i]); INC(i) END
END
END ProperString;
PROCEDURE Keyword (s: ARRAY OF SHORTCHAR);
VAR a: TextModels.Attributes;
BEGIN
IF global.keyAttr # NIL THEN a := global.out.rider.attr; global.out.rider.SetAttr(global.keyAttr) END;
global.out.WriteSString(s);
IF global.keyAttr # NIL THEN global.out.rider.SetAttr(a) END
END Keyword;
PROCEDURE Section (VAR out: TextMappers.Formatter; s: ARRAY OF SHORTCHAR);
VAR a: TextModels.Attributes;
BEGIN
IF global.sectAttr # NIL THEN a := out.rider.attr; out.rider.SetAttr(global.sectAttr) END;
out.WriteSString(s);
IF global.sectAttr # NIL THEN out.rider.SetAttr(a) END
END Section;
PROCEDURE Int (i: INTEGER);
BEGIN
global.out.WriteInt(i)
END Int;
PROCEDURE Hex (x, n: INTEGER);
BEGIN
IF n > 1 THEN Hex(x DIV 16, n - 1) END;
x := x MOD 16;
IF x >= 10 THEN global.out.WriteChar(SHORT(CHR(x + ORD("A") - 10)))
ELSE global.out.WriteChar(SHORT(CHR(x + ORD("0"))))
END
END Hex;
PROCEDURE Ln;
BEGIN
global.out.WriteLn
END Ln;
PROCEDURE Indent;
VAR i: SHORTINT;
BEGIN
IF global.gap THEN global.gap := FALSE; Ln END;
i := global.level; WHILE i > 0 DO global.out.WriteTab; DEC(i) END
END Indent;
PROCEDURE Guid (ext: DevCPT.ConstExt);
BEGIN
Char("{");
Hex(ORD(ext[2]) + 256 * ORD(ext[3]), 4);
Hex(ORD(ext[0]) + 256 * ORD(ext[1]), 4);
Char("-");
Hex(ORD(ext[4]) + 256 * ORD(ext[5]), 4);
Char("-");
Hex(ORD(ext[6]) + 256 * ORD(ext[7]), 4);
Char("-");
Hex(ORD(ext[8]), 2);
Hex(ORD(ext[9]), 2);
Char("-");
Hex(ORD(ext[10]), 2);
Hex(ORD(ext[11]), 2);
Hex(ORD(ext[12]), 2);
Hex(ORD(ext[13]), 2);
Hex(ORD(ext[14]), 2);
Hex(ORD(ext[15]), 2);
Char("}")
END Guid;
(* special marks *)
PROCEDURE Hint (label: ARRAY OF SHORTCHAR; i: INTEGER; adj: BOOLEAN);
BEGIN
IF global.hints THEN
Char("["); String(label);
IF adj & (0 <= i) & (i < 10) THEN Char(TextModels.digitspace) END;
Int(i);
String("] ")
END
END Hint;
PROCEDURE Hint3 (label1, label2, label3: ARRAY OF SHORTCHAR; i1, i2, i3: INTEGER);
BEGIN
IF global.hints THEN
Char("["); String(label1); Int(i1); String(label2); Int(i2); String(label3); Int(i3); String("] ")
END
END Hint3;
PROCEDURE Vis (i: INTEGER);
BEGIN
IF i # external THEN Char("-") END
END Vis;
PROCEDURE ProcSysFlag (flag: SHORTINT);
BEGIN
IF flag # 0 THEN
String(" [");
IF flag = -10 THEN String("ccall")
ELSE Int(flag)
END;
Char("]")
END
END ProcSysFlag;
PROCEDURE ParSysFlag (flag: SHORTINT);
VAR pos: INTEGER;
BEGIN
IF flag # 0 THEN
String(" [");
pos := global.out.Pos();
IF ODD(flag) THEN String("nil") END;
(*
IF ODD(flag DIV 2) & (flag # 18) THEN
IF global.out.Pos() # pos THEN String(", ") END;
String("in")
END;
IF ODD(flag DIV 4) & (flag # 12) THEN
IF global.out.Pos() # pos THEN String(", ") END;
String("out")
END;
*)
IF flag DIV 8 = 1 THEN
IF global.out.Pos() # pos THEN String(", ") END;
String("new")
ELSIF flag DIV 8 = 2 THEN
IF global.out.Pos() # pos THEN String(", ") END;
String("iid")
ELSIF flag DIV 8 # 0 THEN
IF global.out.Pos() # pos THEN String(", ") END;
Int(flag DIV 8 * 8)
END;
Char("]")
END
END ParSysFlag;
PROCEDURE StructSysFlag (typ: DevCPT.Struct);
VAR flag: SHORTINT;
BEGIN
flag := typ.sysflag;
IF (flag # 0) & ((typ.form # pointer) OR (flag = 2)) THEN
String(" [");
IF flag = 1 THEN String("untagged")
ELSIF flag = 2 THEN String("handle")
ELSIF flag = 3 THEN String("noalign")
ELSIF flag = 4 THEN String("align2")
ELSIF flag = 5 THEN String("align4")
ELSIF flag = 6 THEN String("align8")
ELSIF flag = 7 THEN String("union")
ELSIF flag = 10 THEN
IF typ.ext # NIL THEN Char('"'); String(typ.ext^); Char('"')
ELSE String("interface")
END
ELSIF flag = 20 THEN String("som")
ELSE Int(flag)
END;
Char("]")
END
END StructSysFlag;
PROCEDURE SysStrings (obj: DevCPT.Object);
BEGIN
IF global.hints & ((obj.entry # NIL) OR (obj.library # NIL)) THEN
String(' ["');
IF obj.library # NIL THEN String(obj.library^); String('", "') END;
IF obj.entry # NIL THEN String(obj.entry^) END;
String('"]')
END
END SysStrings;
(* non-terminals *)
PROCEDURE ^ Structure (typ: DevCPT.Struct);
PROCEDURE Qualifier (mno: SHORTINT);
BEGIN
IF (mno > 1) OR (mno = 1) & global.singleton THEN
global.modUsed[mno] := TRUE;
String(DevCPT.GlbMod[mno].name^); Char(".")
END
END Qualifier;
PROCEDURE LocalName (obj: DevCPT.Object);
BEGIN
Qualifier(0); String(obj.name^)
END LocalName;
PROCEDURE TypName (typ: DevCPT.Struct; force: BOOLEAN);
BEGIN
IF force OR IsLegal(typ.strobj.name) THEN
IF (typ.mno > 1) OR (typ.mno = 1)
& ((typ.form >= pointer) OR (typ.BaseTyp # DevCPT.undftyp)) & global.singleton
THEN
Qualifier(typ.mno)
ELSIF typ = DevCPT.sysptrtyp THEN (* PTR is in SYSTEM *)
String("SYSTEM.");
global.systemUsed := TRUE
ELSIF
(typ = DevCPT.guidtyp) OR (typ = DevCPT.restyp) OR (typ = DevCPT.iunktyp) OR (typ = DevCPT.punktyp)
THEN
String("COM.");
global.comUsed := TRUE
END;
IF force THEN ProperString(typ.strobj.name^) ELSE String(typ.strobj.name^) END
ELSE
Structure(typ)
END
END TypName;
PROCEDURE ParList (VAR par: DevCPT.Object);
BEGIN
IF par.mode = varPar THEN
IF par.vis = inPar THEN Keyword("IN")
ELSIF par.vis = outPar THEN Keyword("OUT")
ELSE Keyword("VAR")
END;
ParSysFlag(par.sysflag); Char(" ")
END;
String(par.name^);
WHILE (par.link # NIL) & (par.link.typ = par.typ) & (par.link.mode = par.mode)
& (par.link.vis = par.vis) & (par.link.sysflag = par.sysflag) DO
par := par.link; String(", "); String(par.name^)
END;
String(": "); TypName(par.typ, FALSE)
END ParList;
PROCEDURE Signature (result: DevCPT.Struct; par: DevCPT.Object);
VAR paren, res: BOOLEAN;
BEGIN
res := result # DevCPT.notyp; paren := res OR (par # NIL);
IF paren THEN String(" (") END;
IF par # NIL THEN
ParList(par); par := par.link;
WHILE par # NIL DO String("; "); ParList(par); par := par.link END
END;
IF paren THEN Char(")") END;
IF res THEN String(": "); TypName(result, FALSE) END
END Signature;
PROCEDURE TProcs (rec: DevCPT.Struct; fld: DevCPT.Object; oldProcs: TProcList; VAR newProcs: TProcList);
VAR old: DevCPT.Object; p, elem: TProcList;
BEGIN
IF fld # NIL THEN
TProcs(rec, fld.left, oldProcs, newProcs);
IF (fld.mode = tProc) & IsLegal(fld.name) THEN
DevCPT.FindBaseField(fld.name^, rec, old);
IF (old = NIL) OR (fld.typ # old.typ) OR (* (rec.attribute # 0) & *) (fld.conval.setval # old.conval.setval)
THEN
IF global.extensioninterface OR global.clientinterface THEN
(* do not show methods with equal name *)
p := oldProcs;
WHILE (p # NIL) & (p.fld.name^ # fld.name^) DO p := p.next END
END;
IF p = NIL THEN
NEW(elem); elem.next := newProcs; newProcs := elem;
elem.fld := fld;
IF old = NIL THEN INCL(elem.attr, newAttr) END;
IF absAttr IN fld.conval.setval THEN INCL(elem.attr, absAttr)
ELSIF empAttr IN fld.conval.setval THEN INCL(elem.attr, empAttr)
ELSIF extAttr IN fld.conval.setval THEN INCL(elem.attr, extAttr)
END
END
END
END;
TProcs(rec, fld.right, oldProcs, newProcs)
END
END TProcs;
(*
PROCEDURE AdjustTProcs (typ: DevCPT.Struct; fld: DevCPT.Object);
VAR receiver, old: DevCPT.Object; base: DevCPT.Struct;
BEGIN
IF fld # NIL THEN
AdjustTProcs(typ, fld.left);
IF (fld.mode = tProc) & IsLegal(fld.name) THEN
DevCPT.FindBaseField(fld.name^, typ, old);
IF old # NIL THEN
IF fld.conval.setval * {absAttr, empAttr, extAttr} = {} THEN
old.conval.setval := old.conval.setval - {absAttr, empAttr, extAttr}
ELSIF (extAttr IN fld.conval.setval) & (empAttr IN old.conval.setval) THEN
(* do not list methods which only change attribute from empty to extensible *)
old.conval.setval := old.conval.setval + {extAttr} - {empAttr}
END;
IF fld.typ # old.typ THEN (* do not show base methods of covariant overwritten methods *)
old.typ := fld.typ; old.conval.setval := {}
END;
END
END;
AdjustTProcs(typ, fld.right)
END;
IF (typ.BaseTyp # NIL) & (typ.BaseTyp # DevCPT.iunktyp) THEN
AdjustTProcs(typ.BaseTyp, typ.BaseTyp.link)
END
END AdjustTProcs;
*)
PROCEDURE TypeboundProcs (typ: DevCPT.Struct; VAR cont: BOOLEAN; top: BOOLEAN;
VAR list: TProcList; recAttr: INTEGER);
VAR receiver: DevCPT.Object; new, p, q: TProcList;
BEGIN
IF (typ # NIL) & (typ # DevCPT.iunktyp) THEN
TProcs(typ, typ.link, list, new);
p := list;
WHILE new # NIL DO
q := new.next; new.next := p; p := new; new := q
END;
list := p;
IF global.flatten THEN
TypeboundProcs(typ.BaseTyp, cont, FALSE, list, recAttr);
IF (typ.BaseTyp = NIL) OR (typ.BaseTyp = DevCPT.iunktyp) THEN
(*
IF global.extensioninterface & (recAttr IN {absAttr, extAttr}) THEN
IF cont THEN Char(";") END;
Ln; Indent;
String("(a: ANYPTR) FINALIZE-, "); Keyword("NEW"); String(", "); Keyword("EMPTY");
cont := TRUE
END
*)
END
END;
IF top THEN (* writeList *)
WHILE list # NIL DO
IF ~global.clientinterface & ~global.extensioninterface (* default *)
OR global.clientinterface & (list.fld.vis = external)
OR global.extensioninterface & (recAttr IN {absAttr, extAttr}) & (list.attr * {absAttr, empAttr, extAttr} # {})
THEN
IF cont THEN Char(";") END;
Ln;
receiver := list.fld.link;
Indent; Hint("entry ", list.fld.num, TRUE);
(*
Keyword("PROCEDURE"); String(" (");
*)
Char("(");
IF receiver.mode = varPar THEN
IF receiver.vis = inPar THEN Keyword("IN") ELSE Keyword("VAR") END;
Char(" ")
END;
String(receiver.name^); String(": ");
IF IsLegal(receiver.typ.strobj.name) & (receiver.typ.mno = 1) THEN
String(receiver.typ.strobj.name^)
ELSE TypName(receiver.typ, FALSE)
END;
String(") "); String(list.fld.name^); Vis(list.fld.vis);
SysStrings(list.fld);
Signature(list.fld.typ, receiver.link);
IF newAttr IN list.attr THEN String(", "); Keyword("NEW") END;
IF absAttr IN list.attr THEN String(", "); Keyword("ABSTRACT")
ELSIF empAttr IN list.attr THEN String(", "); Keyword("EMPTY")
ELSIF extAttr IN list.attr THEN String(", "); Keyword("EXTENSIBLE")
END;
cont := TRUE
END;
list := list.next
END
END
END
END TypeboundProcs;
PROCEDURE Flds (typ: DevCPT.Struct; VAR cont: BOOLEAN);
VAR fld: DevCPT.Object;
BEGIN
fld := typ.link;
WHILE (fld # NIL) & (fld.mode = field) DO
IF IsLegal(fld.name) THEN
IF cont THEN Char(";") END;
Ln;
Indent; Hint("offset ", fld.adr, TRUE);
IF typ.mno > 1 THEN String("(* "); TypName(typ, TRUE); String(" *) ") END;
String(fld.name^);
WHILE (fld.link # NIL) & (fld.link.typ = fld.typ) & (fld.link.name # NIL) DO
Vis(fld.vis); fld := fld.link; String(", "); String(fld.name^)
END;
Vis(fld.vis); String(": "); TypName(fld.typ, FALSE);
cont := TRUE
END;
fld := fld.link
END
END Flds;
PROCEDURE Fields (typ: DevCPT.Struct; VAR cont: BOOLEAN);
BEGIN
IF typ # NIL THEN
IF global.flatten THEN Fields(typ.BaseTyp, cont) END;
Flds(typ, cont)
END
END Fields;
PROCEDURE BaseTypes (typ: DevCPT.Struct);
BEGIN
IF typ.BaseTyp # NIL THEN
Char("("); TypName(typ.BaseTyp, TRUE);
IF global.flatten THEN BaseTypes(typ.BaseTyp) END;
Char(")")
END
END BaseTypes;
PROCEDURE Structure (typ: DevCPT.Struct);
VAR cont: BOOLEAN; p: TProcList;
BEGIN
INC(global.level);
CASE typ.form OF
pointer:
Keyword("POINTER"); StructSysFlag(typ); Char(" ");
Keyword("TO"); Char(" "); DEC(global.level); TypName(typ.BaseTyp, FALSE); INC(global.level)
| procTyp:
Keyword("PROCEDURE"); Signature(typ.BaseTyp, typ.link)
| comp:
CASE typ.comp OF
array:
Keyword("ARRAY"); StructSysFlag(typ); Char(" "); Int(typ.n); Char(" ");
Keyword("OF"); Char(" "); TypName(typ.BaseTyp, FALSE)
| dynArray:
Keyword("ARRAY"); StructSysFlag(typ); Char(" ");
Keyword("OF"); Char(" "); TypName(typ.BaseTyp, FALSE)
| record:
IF typ.attribute = absAttr THEN Keyword("ABSTRACT ")
ELSIF typ.attribute = limAttr THEN Keyword("LIMITED ")
ELSIF typ.attribute = extAttr THEN Keyword("EXTENSIBLE ")
END;
Keyword("RECORD"); StructSysFlag(typ);
Char(" "); Hint3("tprocs ", ", size ", ", align ", typ.n, typ.size, typ.align);
cont := FALSE;
BaseTypes(typ); Fields(typ, cont); TypeboundProcs(typ, cont, TRUE, p, typ.attribute);
IF cont THEN Ln; DEC(global.level); Indent; INC(global.level) ELSE Char (" ") END;
Keyword("END")
END
ELSE
IF (typ.BaseTyp # DevCPT.undftyp) THEN TypName(typ.BaseTyp, FALSE) END (* alias structures *)
END;
DEC(global.level)
END Structure;
PROCEDURE Const (obj: DevCPT.Object);
VAR con: DevCPT.Const; s: SET; i: SHORTINT; x, y: INTEGER; r: REAL;
BEGIN
Indent; LocalName(obj); SysStrings(obj); String(" = ");
con := obj.conval;
CASE obj.typ.form OF
bool:
IF con.intval = 1 THEN String("TRUE") ELSE String("FALSE") END
| sChar, char:
IF con.intval >= 0A000H THEN
Hex(con.intval, 5); Char("X")
ELSIF con.intval >= 0100H THEN
Hex(con.intval, 4); Char("X")
ELSIF con.intval >= 0A0H THEN
Hex(con.intval, 3); Char("X")
ELSIF (con.intval >= 32) & (con.intval <= 126) THEN
Char(22X); Char(SHORT(CHR(con.intval))); Char(22X)
ELSE
Hex(con.intval, 2); Char("X")
END
| byte, sInt, int:
Int(con.intval)
| lInt:
y := SHORT(ENTIER((con.realval + con.intval) / 4294967296.0));
r := con.realval + con.intval - y * 4294967296.0;
IF r > MAX(INTEGER) THEN r := r - 4294967296.0 END;
x := SHORT(ENTIER(r));
Hex(y, 8); Hex(x, 8); Char("L")
| set:
Char("{"); i := 0; s := con.setval;
WHILE i <= MAX(SET) DO
IF i IN s THEN Int(i); EXCL(s, i);
IF s # {} THEN String(", ") END
END;
INC(i)
END;
Char("}")
| sReal, real:
global.out.WriteReal(con.realval)
| sString:
StringConst(con.ext^, FALSE)
| string:
StringConst(con.ext^, TRUE)
| nilTyp:
Keyword("NIL")
| comp: (* guid *)
Char("{"); Guid(con.ext); Char("}")
END;
Char(";"); Ln
END Const;
PROCEDURE AliasType (typ: DevCPT.Struct);
BEGIN
IF global.singleton & IsLegal(typ.strobj.name) THEN
WHILE typ.BaseTyp # DevCPT.undftyp DO
Char(";"); Ln; Indent;
String(typ.strobj.name^); SysStrings(typ.strobj); String(" = ");
IF typ.form >= pointer THEN
Structure(typ); typ := DevCPT.int16typ
ELSE
typ := typ.BaseTyp;
TypName(typ, FALSE)
END
END
END
END AliasType;
PROCEDURE NotExtRec(typ: DevCPT.Struct): BOOLEAN;
BEGIN
RETURN (typ.form = comp) & ((typ.comp # record) OR ~(typ.attribute IN {absAttr, extAttr}))
OR (typ.form = procTyp)
END NotExtRec;
PROCEDURE Type (obj: DevCPT.Object);
BEGIN
IF global.hideHooks & IsHook(obj.typ) THEN RETURN END;
IF global.extensioninterface
(*
& (obj.typ.strobj = obj) & ~((obj.typ.form < pointer) & (obj.typ.BaseTyp # DevCPT.undftyp))
*)
& (NotExtRec(obj.typ)
OR
(obj.typ.form = pointer) & ~IsLegal(obj.typ.BaseTyp.strobj.name) &
NotExtRec(obj.typ.BaseTyp)
)
THEN
IF global.singleton THEN RETURN END;
global.out.rider.SetAttr(TextModels.NewColor(global.out.rider.attr, Ports.grey50));
IF global.pos < global.out.rider.Pos() THEN
global.out.rider.Base().SetAttr(global.pos, global.out.rider.Pos()-1, global.out.rider.attr)
END
END;
Indent; LocalName(obj); SysStrings(obj); String(" = ");
IF obj.typ.strobj # obj THEN
TypName(obj.typ, FALSE);
AliasType(obj.typ)
ELSIF (obj.typ.form < pointer) & (obj.typ.BaseTyp # DevCPT.undftyp) THEN
TypName(obj.typ.BaseTyp, FALSE);
AliasType(obj.typ.BaseTyp)
ELSE
Structure(obj.typ)
END;
Char(";"); Ln;
global.gap := TRUE
END Type;
PROCEDURE PtrType (obj: DevCPT.Object);
VAR base: DevCPT.Object;
BEGIN
Type(obj);
base := obj.typ.BaseTyp.strobj;
IF (base # NIL) & (base # DevCPT.anytyp.strobj) & (base # DevCPT.iunktyp.strobj)
& (base.vis # internal) & (base.typ.strobj # NIL) & ~(global.hideHooks & IsHook(base.typ)) THEN
(* show named record with pointer; avoid repetition *)
IF global.extensioninterface
& (base.typ.strobj = base) & ~((obj.typ.form < pointer) & (obj.typ.BaseTyp # DevCPT.undftyp))
& (NotExtRec(base.typ)
OR
(base.typ.form = pointer) & ~IsLegal(base.typ.BaseTyp.strobj.name) &
NotExtRec(base.typ.BaseTyp)
)
THEN
IF global.singleton THEN
IF global.pos < global.out.rider.Pos() THEN
global.out.rider.Base().Delete(global.pos, global.out.rider.Pos());
global.out.rider.SetPos(global.pos)
END;
RETURN
END;
global.out.rider.SetAttr(TextModels.NewColor(global.out.rider.attr, Ports.grey50));
IF global.pos < global.out.rider.Pos() THEN
global.out.rider.Base().SetAttr(global.pos, global.out.rider.Pos()-1, global.out.rider.attr)
END
END;
global.gap := FALSE;
Indent;
String(base.name^); SysStrings(base); String(" = ");
IF base.typ.strobj # base THEN
TypName(base.typ, FALSE);
AliasType(obj.typ)
ELSIF (obj.typ.form < pointer) & (obj.typ.BaseTyp # DevCPT.undftyp) THEN
TypName(obj.typ.BaseTyp, FALSE);
AliasType(obj.typ.BaseTyp)
ELSE
Structure(base.typ)
END;
Char(";"); Ln;
base.vis := internal;
global.gap := TRUE
END
END PtrType;
PROCEDURE Var (obj: DevCPT.Object);
BEGIN
IF global.hideHooks & IsHook(obj.typ) THEN RETURN END;
Indent; LocalName(obj); Vis(obj.vis); SysStrings(obj); String(": ");
TypName(obj.typ, FALSE); Char(";"); Ln
END Var;
PROCEDURE Proc (obj: DevCPT.Object);
VAR ext: DevCPT.ConstExt; i, m: SHORTINT;
BEGIN
IF global.hideHooks & (obj.link # NIL) & (obj.link.link = NIL) & IsHook(obj.link.typ) THEN RETURN END;
IF global.extensioninterface THEN RETURN END;
Indent; Keyword("PROCEDURE"); (* Char(" "); *)
IF obj.mode = cProc THEN String(" [code]")
ELSIF obj.mode = iProc THEN String(" [callback]")
ELSE ProcSysFlag(obj.sysflag)
END;
Char(" "); LocalName(obj);
(*IF obj.mode # cProc THEN SysStrings(obj) END;*)
SysStrings(obj);
Signature(obj.typ, obj.link);
IF (obj.mode = cProc) & global.hints THEN
Ln;
INC(global.level); Indent;
ext := obj.conval.ext; m := ORD(ext^[0]); i := 1;
WHILE i <= m DO
global.out.WriteIntForm(ORD(ext^[i]), TextMappers.hexadecimal, 3, "0", TextMappers.showBase);
IF i < m THEN String(", ") END;
INC(i)
END;
DEC(global.level)
END;
Char(";"); Ln
END Proc;
(* tree traversal *)
PROCEDURE Objects (obj: DevCPT.Object; mode: SET);
VAR m: BYTE; a: TextModels.Attributes;
BEGIN
IF obj # NIL THEN
INC(lev); INC(num); max := MAX(max, lev);
Objects(obj.left, mode);
m := obj.mode; IF (m = type) & (obj.typ.form = pointer) THEN m := ptrType END;
IF (m IN mode) & (obj.vis # internal) & (obj.name # NIL) &
(~global.singleton OR (obj.name^ = global.thisObj)) THEN
global.pos := global.out.rider.Pos(); a := global.out.rider.attr;
CASE m OF
const: Const(obj)
| type: Type(obj)
| ptrType: PtrType(obj)
| var: Var(obj)
| xProc, cProc, iProc: Proc(obj)
END;
global.out.rider.SetAttr(a)
END;
Objects(obj.right, mode);
DEC(lev)
END
END Objects;
(* definition formatting *)
PROCEDURE PutSection (VAR out: TextMappers.Formatter; s: ARRAY OF SHORTCHAR);
VAR buf, def: TextModels.Model; i: INTEGER;
BEGIN
buf := global.out.rider.Base();
IF buf.Length() > 0 THEN
IF ~global.singleton THEN Ln END;
def := out.rider.Base(); out.SetPos(def.Length());
IF s # "" THEN (* prepend section keyword *)
i := global.level - 1; WHILE i > 0 DO out.WriteTab; DEC(i) END;
Section(out, s); out.WriteLn
END;
def.Append(buf);
global.pos := 0;
global.out.rider.SetPos(0)
END;
global.gap := FALSE
END PutSection;
PROCEDURE Scope (def: TextModels.Model; this: DevCPT.Name);
VAR out: TextMappers.Formatter; i: SHORTINT; a: TextModels.Attributes;
BEGIN
global.gap := FALSE; global.thisObj := this; global.singleton := (this # "");
global.systemUsed := FALSE; global.comUsed := FALSE;
i := 1; WHILE i < LEN(global.modUsed) DO global.modUsed[i] := FALSE; INC(i) END;
out.ConnectTo(def);
INC(global.level);
IF ~(global.extensioninterface & global.singleton) THEN
IF global.extensioninterface THEN
a := global.out.rider.attr; global.out.rider.SetAttr(TextModels.NewColor(a, Ports.grey50))
END;
Objects(DevCPT.GlbMod[1].right, {const});
IF global.extensioninterface THEN global.out.rider.SetAttr(a) END;
PutSection(out, "CONST")
END;
Objects(DevCPT.GlbMod[1].right, {ptrType});
Objects(DevCPT.GlbMod[1].right, {type}); PutSection(out, "TYPE");
IF ~global.extensioninterface THEN
Objects(DevCPT.GlbMod[1].right, {var}); PutSection(out, "VAR")
END;
DEC(global.level);
num := 0; lev := 0; max := 0;
Objects(DevCPT.GlbMod[1].right, {xProc, cProc}); PutSection(out, "")
END Scope;
PROCEDURE Modules;
VAR i, j, n: SHORTINT;
BEGIN
n := 0; j := 2;
IF global.systemUsed THEN INC(n) END;
IF global.comUsed THEN INC(n) END;
WHILE j < DevCPT.nofGmod DO
IF global.modUsed[j] THEN INC(n) END;
INC(j)
END;
IF n > 0 THEN
Indent; Section(global.out, "IMPORT"); INC(global.level);
IF n < 10 THEN Char(" ") ELSE Ln; Indent END;
i := 0; j := 2;
IF global.systemUsed THEN
String("SYSTEM"); INC(i);
IF i < n THEN String(", ") END
END;
IF global.comUsed THEN
String("COM"); INC(i);
IF i < n THEN String(", ") END
END;
WHILE i < n DO
IF global.modUsed[j] THEN
String(DevCPT.GlbMod[j].name^); INC(i);
(*
IF (DevCPT.GlbMod[j].strings # NIL) & (DevCPT.GlbMod[j].strings.ext # NIL) THEN
String(' ["'); String(DevCPT.GlbMod[j].strings.ext^); String('"]')
END;
*)
IF i < n THEN
Char(",");
IF i MOD 10 = 0 THEN Ln; Indent ELSE Char(" ") END
END
END;
INC(j)
END;
Char(";"); Ln; Ln
END
END Modules;
(* compiler interfacing *)
PROCEDURE OpenCompiler (mod: DevCPT.Name; VAR noerr: BOOLEAN);
VAR null: TextModels.Model; main: DevCPT.Name;
BEGIN
null := TextModels.dir.New();
DevCPM.Init(null.NewReader(NIL), null);
(*
DevCPT.Init({}); DevCPT.Open(mod); DevCPT.SelfName := "AvoidErr154";
*)
DevCPT.Init({}); main := "@mainMod"; DevCPT.Open(main);
DevCPT.processor := 0; (* accept all sym files *)
DevCPT.Import("@notself", mod, noerr);
IF ~DevCPM.noerr THEN noerr := FALSE END
END OpenCompiler;
PROCEDURE CloseCompiler;
BEGIN
DevCPT.Close;
DevCPM.Close
END CloseCompiler;
PROCEDURE Browse (
ident: DevCPT.Name; opts: ARRAY OF CHAR; VAR view: Views.View; VAR title: Views.Title
);
VAR def, buf: TextModels.Model; v: TextViews.View; h: BOOLEAN;
p: Properties.BoundsPref; mod: DevCPT.Name; i: SHORTINT; str, str1: ARRAY 256 OF CHAR;
BEGIN
mod := DevCPT.GlbMod[1].name^$;
i := 0;
global.hints := FALSE; global.flatten := FALSE; global.hideHooks := TRUE;
global.clientinterface := FALSE; global.extensioninterface := FALSE;
global.keyAttr := NIL; global.sectAttr := NIL;
IF opts[0] = '@' THEN
IF options.hints THEN opts := opts + "+" END;
IF options.flatten THEN opts := opts + "!" END;
IF options.formatted THEN opts := opts + "/" END
END;
WHILE opts[i] # 0X DO
CASE opts[i] OF
| '+': global.hints := TRUE
| '!': global.flatten := TRUE
| '&': global.hideHooks := FALSE
| '/':
(* global.keyAttr := TextModels.NewStyle(TextModels.dir.attr, {Fonts.underline}); *)
global.keyAttr := TextModels.NewWeight(TextModels.dir.attr, Fonts.bold);
global.sectAttr := TextModels.NewWeight(TextModels.dir.attr, Fonts.bold)
| 'c': global.clientinterface := TRUE
| 'e' : global.extensioninterface := TRUE
ELSE
END;
INC(i)
END;
IF global.clientinterface & global.extensioninterface THEN
global.clientinterface := FALSE; global.extensioninterface := FALSE
END;
IF global.extensioninterface THEN global.hideHooks := FALSE END;
def := TextModels.dir.New();
buf := TextModels.dir.New(); global.out.ConnectTo(buf);
IF ident # "" THEN
h := global.hideHooks; global.hideHooks := FALSE;
global.level := 0; Scope(def, ident);
global.hideHooks := h;
def.Append(buf);
IF def.Length() > 0 THEN
v := TextViews.dir.New(def);
v.SetDefaults(NewRuler(), TextViews.dir.defAttr);
p.w := Views.undefined; p.h := Views.undefined; Views.HandlePropMsg(v, p);
title := mod$; Append(title, "."); Append(title, ident);
view := Documents.dir.New(v, p.w, p.h)
ELSE str := mod$; str1 := ident$; title := "";
IF global.extensioninterface THEN
Dialog.ShowParamMsg(noSuchExtItemExportedKey, str, str1, "")
ELSE
Dialog.ShowParamMsg(noSuchItemExportedKey, str, str1, "")
END
END
ELSE
global.level := 1; Scope(def, "");
Section(global.out, "END"); Char(" "); String(mod); Char("."); Ln;
def.Append(buf);
Section(global.out, "DEFINITION"); Char(" "); String(mod);
IF (DevCPT.GlbMod[1].library # NIL) THEN
String(' ["'); String(DevCPT.GlbMod[1].library^); String('"]')
ELSIF DevCPT.impProc # 0 THEN
global.out.WriteTab; String("(* nonportable");
IF DevCPT.impProc = 10 THEN String(" (i386)")
ELSIF DevCPT.impProc = 20 THEN String(" (68k)")
END;
String(" *)")
END;
Char(";"); Ln; Ln;
Modules;
buf.Append(def);
v := TextViews.dir.New(buf);
v.SetDefaults(NewRuler(), TextViews.dir.defAttr);
title := mod$;
view := Documents.dir.New(v, width, height)
END;
global.out.ConnectTo(NIL);
global.keyAttr := NIL; global.sectAttr := NIL
END Browse;
PROCEDURE ShowInterface* (opts: ARRAY OF CHAR);
VAR noerr: BOOLEAN; mod, ident: DevCPT.Name; v: Views.View; title: Views.Title; t: TextModels.Model;
str: ARRAY 256 OF CHAR;
BEGIN
GetQualIdent(mod, ident, t);
CheckModName(mod, t);
IF mod # "" THEN
OpenCompiler(mod, noerr);
IF noerr & (DevCPT.GlbMod[1] # NIL) & (DevCPT.GlbMod[1].name^ = mod) THEN
Browse(ident, opts, v, title);
IF v # NIL THEN
IF global.clientinterface THEN Append(title, " (client interface)")
ELSIF global.extensioninterface THEN Append(title, " (extension interface)")
END;
Views.OpenAux(v, title)
END
ELSE str := mod$; Dialog.ShowParamMsg(modNotFoundKey, str, "", "")
END;
CloseCompiler
ELSE Dialog.ShowMsg(noModuleNameSelectedKey)
END;
Kernel.Cleanup
END ShowInterface;
PROCEDURE ImportSymFile* (f: Files.File; OUT s: Stores.Store);
VAR v: Views.View; title: Views.Title; noerr: BOOLEAN;
BEGIN
ASSERT(f # NIL, 20);
DevCPM.file := f;
OpenCompiler("@file", noerr);
IF noerr THEN
Browse("", "", v, title);
s := v
END;
CloseCompiler;
DevCPM.file := NIL;
Kernel.Cleanup
END ImportSymFile;
(* codefile browser *)
PROCEDURE RWord (VAR x: INTEGER);
VAR b: BYTE; y: INTEGER;
BEGIN
inp.ReadByte(b); y := b MOD 256;
inp.ReadByte(b); y := y + 100H * (b MOD 256);
inp.ReadByte(b); y := y + 10000H * (b MOD 256);
inp.ReadByte(b); x := y + 1000000H * b
END RWord;
PROCEDURE RNum (VAR x: INTEGER);
VAR b: BYTE; s, y: INTEGER;
BEGIN
s := 0; y := 0; inp.ReadByte(b);
WHILE b < 0 DO INC(y, ASH(b + 128, s)); INC(s, 7); inp.ReadByte(b) END;
x := ASH((b + 64) MOD 128 - 64, s) + y
END RNum;
PROCEDURE RName (VAR name: ARRAY OF SHORTCHAR);
VAR b: BYTE; i, n: INTEGER;
BEGIN
i := 0; n := LEN(name) - 1; inp.ReadByte(b);
WHILE (i < n) & (b # 0) DO name[i] := SHORT(CHR(b)); INC(i); inp.ReadByte(b) END;
WHILE b # 0 DO inp.ReadByte(b) END;
name[i] := 0X
END RName;
PROCEDURE RLink;
VAR x: INTEGER;
BEGIN
RNum(x);
WHILE x # 0 DO RNum(x); RNum(x) END
END RLink;
PROCEDURE RShort (p: INTEGER; OUT x: INTEGER);
VAR b0, b1: BYTE;
BEGIN
inp.ReadByte(b0); inp.ReadByte(b1);
IF p = 10 THEN x := b0 MOD 256 + b1 * 256 (* little endian *)
ELSE x := b1 MOD 256 + b0 * 256 (* big endian *)
END
END RShort;
PROCEDURE ReadHeader (file: Files.File; VAR view: Views.View; VAR title: Views.Title);
VAR n, i, p, fp, hs, ms, ds, cs, vs, m: INTEGER; name: Kernel.Name; first: BOOLEAN;
text: TextModels.Model; v: TextViews.View; fold: StdFolds.Fold; d: Dates.Date; t: Dates.Time;
str: ARRAY 64 OF CHAR;
BEGIN
text := TextModels.dir.New(); global.out.ConnectTo(text);
inp := file.NewReader(NIL);
inp.SetPos(0); RWord(n);
IF n = 6F4F4346H THEN
RWord(p); RWord(hs); RWord(ms); RWord(ds); RWord(cs); RWord(vs);
RNum(n); RName(name); title := name$; i := 0;
WHILE i < n DO RName(imp[i]); INC(i) END;
String("MODULE "); String(name); Ln;
String("processor: ");
IF p = 10 THEN String("80x86")
ELSIF p = 20 THEN String("68000")
ELSIF p = 30 THEN String("PPC")
ELSIF p = 40 THEN String("SH3")
ELSE Int(p)
END;
Ln;
String("meta size: "); Int(ms); Ln;
String("desc size: "); Int(ds); Ln;
String("code size: "); Int(cs); Ln;
String("data size: "); Int(vs); Ln;
inp.SetPos(hs + ms + 12);
RShort(p, d.year); RShort(p, d.month); RShort(p, d.day);
RShort(p, t.hour); RShort(p, t.minute); RShort(p, t.second);
String("compiled: ");
Dates.DateToString(d, Dates.short, str); global.out.WriteString(str); String(" ");
Dates.TimeToString(t, str); global.out.WriteString(str); Ln;
Int(n); String(" imports:"); Ln;
inp.SetPos(hs + ms + ds + cs);
RLink; RLink; RLink; RLink; RLink; RLink; i := 0;
WHILE i < n DO
global.out.WriteTab; String(imp[i]); global.out.WriteTab;
RNum(p);
IF p # 0 THEN
fold := StdFolds.dir.New(StdFolds.expanded, "", TextModels.dir.New());
global.out.WriteView(fold); Char(" "); first := TRUE;
WHILE p # 0 DO
RName(name); RNum(fp);
IF p = 2 THEN RNum(m) END;
IF p # 1 THEN RLink END;
IF name # "" THEN
IF ~first THEN String(", ") END;
first := FALSE; String(name)
END;
RNum(p)
END;
Char(" ");
fold := StdFolds.dir.New(StdFolds.expanded, "", NIL);
global.out.WriteView(fold);
fold.Flip(); global.out.SetPos(text.Length())
END;
INC(i); Ln
END
ELSE String("wrong file tag: "); Hex(n, 8)
END;
v := TextViews.dir.New(text);
v.SetDefaults(NewRuler(), TextViews.dir.defAttr);
view := Documents.dir.New(v, width, height);
global.out.ConnectTo(NIL);
inp := NIL
END ReadHeader;
PROCEDURE ShowCodeFile*;
VAR t: TextModels.Model; f: Files.File; v: Views.View; title: Views.Title; mod, ident: DevCPT.Name;
name: Files.Name; loc: Files.Locator; str: ARRAY 256 OF CHAR;
BEGIN
GetQualIdent(mod, ident, t);
IF mod # "" THEN
str := mod$;
StdDialog.GetSubLoc(str, "Code", loc, name);
f := Files.dir.Old(loc, name, Files.shared);
IF f # NIL THEN
ReadHeader(f, v, title);
IF v # NIL THEN Views.OpenAux(v, title) END
ELSE Dialog.ShowParamMsg(modNotFoundKey, str, "", "")
END
ELSE Dialog.ShowMsg(noModuleNameSelectedKey)
END
END ShowCodeFile;
PROCEDURE ImportCodeFile* (f: Files.File; OUT s: Stores.Store);
VAR v: Views.View; title: Views.Title;
BEGIN
ASSERT(f # NIL, 20);
ReadHeader(f, v, title);
s := v
END ImportCodeFile;
PROCEDURE SaveOptions*;
BEGIN
HostRegistry.WriteBool(regKey + 'hints', options.hints);
HostRegistry.WriteBool(regKey + 'flatten', options.flatten);
HostRegistry.WriteBool(regKey + 'formatted', options.formatted);
options.sflatten := options.flatten;
options.shints := options.hints;
options.sformatted := options.formatted
END SaveOptions;
PROCEDURE SaveGuard*(VAR par: Dialog.Par);
BEGIN
par.disabled := (options.sflatten = options.flatten)
& (options.shints = options.hints)
& (options.sformatted = options.formatted)
END SaveGuard;
PROCEDURE Init*;
VAR res: INTEGER;
BEGIN
HostRegistry.ReadBool(regKey + 'hints', options.hints, res);
IF res # 0 THEN options.hints := FALSE END;
HostRegistry.ReadBool(regKey + 'flatten', options.flatten, res);
IF res # 0 THEN options.flatten := TRUE END;
HostRegistry.ReadBool(regKey + 'formatted', options.formatted, res);
IF res # 0 THEN options.formatted := FALSE END;
Dialog.Update(options);
options.sflatten := options.flatten;
options.shints := options.hints;
options.sformatted := options.formatted
END Init;
BEGIN
Init
END DevBrowser.
| Dev/Mod/Browser.odc |
MODULE DevCmds;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Services, Files, Fonts, Ports, Stores, Models, Views, Controllers, Dialog,
Containers, Controls, Properties, Documents,
TextModels, TextMappers, TextRulers, TextViews, TextControllers,
StdDialog, StdCmds,
HostMenus;
PROCEDURE OpenModuleList*;
VAR v: Views.View;
c: TextControllers.Controller; s: TextMappers.Scanner;
loc: Files.Locator; name: Files.Name;
beg, end: INTEGER; error, one: BOOLEAN;
BEGIN
c := TextControllers.Focus();
IF c # NIL THEN
s.ConnectTo(c.text);
IF c.HasSelection() THEN c.GetSelection(beg, end)
ELSE beg := 0; end := c.text.Length()
END;
s.SetPos(beg); s.Scan; one := FALSE;
WHILE (s.start < end) & (s.type = TextMappers.string) & (s.len < LEN(name)) DO
s.Scan; one := TRUE
END;
IF one & ((s.start >= end) OR (s.type = TextMappers.eot)) THEN
s.SetPos(beg); s.Scan; error := FALSE;
WHILE (s.start < end) & (s.type = TextMappers.string) & ~error DO
StdDialog.GetSubLoc(s.string, "Mod", loc, name);
IF loc # NIL THEN
v := Views.OldView(loc, name);
IF v # NIL THEN
Views.Open(v, loc, name, NIL)
ELSE
Dialog.ShowParamMsg("#System:CannotOpenFile", name, "", "");
error := TRUE
END
ELSE
Dialog.ShowParamMsg("#Dev:ModuleNotFound", s.string, "", "");
error := TRUE
END;
s.Scan
END
ELSE Dialog.ShowMsg("#Dev:NotOnlyModNames")
END;
s.ConnectTo(NIL)
ELSE Dialog.ShowMsg("#Text:FocusShouldBeText")
END
END OpenModuleList;
PROCEDURE Scan (VAR s: TextMappers.Scanner);
VAR ch: CHAR; i, max: INTEGER;
BEGIN
s.Skip(ch);
IF s.type # TextMappers.eot THEN
IF ch = '"' THEN s.Scan;
ELSE i := 0; max := LEN(s.string)-1;
WHILE (i < max) & ~s.rider.eot & (ch > " ") DO
s.string[i] := ch; s.rider.ReadChar(ch); INC(i);
END;
s.string[i] := 0X; s.len := SHORT(i);
IF s.len > 0 THEN s.type := TextMappers.string
ELSE s.type := TextMappers.invalid
END
END
END
END Scan;
PROCEDURE OpenFileList*; (* Pre: focus is text and has a selection *)
VAR c: TextControllers.Controller; s: TextMappers.Scanner; beg, end: INTEGER;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
s.ConnectTo(c.text);
s.SetPos(beg); Scan(s);
WHILE (s.type # TextMappers.eot) & (s.start < end) DO
IF s.type = TextMappers.string THEN StdCmds.OpenDoc(s.string) END;
Scan(s);
END
ELSE Dialog.ShowMsg("#Text:FocusShouldBeText")
END
END OpenFileList;
PROCEDURE FlushResources*;
VAR m: HostMenus.Menu; i: StdDialog.Item;
BEGIN
(* flush menu guards *)
m := HostMenus.FirstMenu();
WHILE m # NIL DO
i := m.firstItem; WHILE i # NIL DO StdDialog.ClearGuards(i); i := i.next END;
m := m.next
END;
(* flush string cache *)
Dialog.FlushMappings
END FlushResources;
PROCEDURE RevalidateView*;
VAR ops: Controllers.PollOpsMsg; v: Views.View;
BEGIN
Controllers.PollOps(ops);
IF ops.singleton # NIL THEN v := ops.singleton
ELSE v := Controllers.FocusView();
END;
IF v # NIL THEN Views.RevalidateView(v) END
END RevalidateView;
PROCEDURE RevalidateViewGuard* (VAR par: Dialog.Par);
VAR ops: Controllers.PollOpsMsg; v: Views.View;
BEGIN
Controllers.PollOps(ops);
IF ops.singleton # NIL THEN v := ops.singleton
ELSE v := Controllers.FocusView();
END;
IF (v = NIL) OR ~Views.IsInvalid(v) THEN par.disabled := TRUE END
END RevalidateViewGuard;
PROCEDURE SetDefault (c: Views.View; default: BOOLEAN);
VAR p: Controls.Prop; msg: Properties.SetMsg;
BEGIN
NEW(p); p.valid := {Controls.opt0}; p.opt[Controls.default] := default;
msg.prop := p; Views.HandlePropMsg(c, msg)
END SetDefault;
PROCEDURE SetDefaultButton*;
VAR s, v: Views.View; c: Containers.Controller; script: Stores.Operation;
BEGIN
c := Containers.Focus();
IF c # NIL THEN
s := c.Singleton();
c.SelectAll(FALSE);
Views.BeginScript(c.ThisView(), "#Dev:SetDefault", script);
c.GetFirstView(Containers.any, v);
WHILE v # NIL DO SetDefault(v, FALSE); c.GetNextView(Containers.any, v) END;
IF s # NIL THEN SetDefault(s, TRUE); c.SetSingleton(s) END;
Views.EndScript(c.ThisView(), script)
ELSE Dialog.Beep
END
END SetDefaultButton;
PROCEDURE SetCancel (c: Views.View; cancel: BOOLEAN);
VAR p: Controls.Prop; msg: Properties.SetMsg;
BEGIN
NEW(p); p.valid := {Controls.opt1}; p.opt[Controls.cancel] := cancel;
msg.prop := p; Views.HandlePropMsg(c, msg)
END SetCancel;
PROCEDURE SetCancelButton*;
VAR s, v: Views.View; c: Containers.Controller; script: Stores.Operation;
BEGIN
c := Containers.Focus();
IF c # NIL THEN
s := c.Singleton();
c.SelectAll(FALSE);
Views.BeginScript(c.ThisView(), "#Dev:SetCancel", script);
c.GetFirstView(Containers.any, v);
WHILE v # NIL DO SetCancel(v, FALSE); c.GetNextView(Containers.any, v) END;
IF s # NIL THEN SetCancel(s, TRUE); c.SetSingleton(s) END;
Views.EndScript(c.ThisView(), script)
ELSE Dialog.Beep
END
END SetCancelButton;
PROCEDURE NewRuler (): TextRulers.Ruler;
CONST mm = Ports.mm; pt = Ports.point;
VAR p: TextRulers.Prop;
BEGIN
NEW(p);
p.valid := {TextRulers.right, TextRulers.tabs, TextRulers.opts};
p.opts.val := {TextRulers.rightFixed}; p.opts.mask := p.opts.val;
p.tabs.len := 7;
p.right := 200 * mm;
p.tabs.tab[0].stop := 40 * mm; p.tabs.tab[0].type := {TextRulers.rightTab};
p.tabs.tab[1].stop := 50 * mm; p.tabs.tab[1].type := {TextRulers.rightTab};
p.tabs.tab[2].stop := 55 * mm;
p.tabs.tab[3].stop := 90 * mm;
p.tabs.tab[4].stop := 100 * mm;
p.tabs.tab[5].stop := 140 * mm;
p.tabs.tab[6].stop := 180 * mm; p.tabs.tab[6].type := {TextRulers.rightTab};
RETURN TextRulers.dir.NewFromProp(p)
END NewRuler;
PROCEDURE ShowControlList*;
(** Guard: StdCmds.ContainerGuard **)
VAR c: Containers.Controller; v: Views.View; s, t: Stores.TypeName;
msg: Properties.PollMsg; p: Properties.Property;
out: TextMappers.Formatter; str: Dialog.String; w, h: INTEGER;
PROCEDURE WriteEntry(name, value: Dialog.String);
BEGIN
out.WriteTab; out.WriteString(name); out.WriteTab; out.WriteString(value); out.WriteLn
END WriteEntry;
BEGIN
c := Containers.Focus();
IF c # NIL THEN
out.ConnectTo(TextModels.dir.New());out.WriteView(NewRuler());
out.rider.SetAttr(TextModels.NewStyle(out.rider.attr, {Fonts.italic}));
out.WriteString("type"); out.WriteTab;
out.WriteString("width"); out.WriteTab;
out.WriteString("height"); out.WriteTab;
out.WriteString("label"); out.WriteTab;
out.WriteString("link"); out.WriteTab;
out.WriteString("guard"); out.WriteTab;
out.WriteString("notifier"); out.WriteTab;
out.WriteString("level"); out.WriteTab;
out.WriteLn; out.WriteLn;
out.rider.SetAttr(TextModels.NewStyle(out.rider.attr, {}));
c.GetFirstView(Containers.any, v);
WHILE v # NIL DO
Services.GetTypeName(v, t);
s := "#Dev:"; s := s + t;
Dialog.MapString(s, s);
out.WriteString(s); out.WriteTab;
v.context.GetSize(w, h);
out.WriteInt(w DIV Ports.point); out.WriteTab;
out.WriteInt(h DIV Ports.point); out.WriteTab;
msg.prop := NIL; Views.HandlePropMsg(v, msg);
p := msg.prop; WHILE (p # NIL) & ~(p IS Controls.Prop) DO p := p.next END;
IF p # NIL THEN
WITH p: Controls.Prop DO
IF Controls.label IN p.valid THEN out.WriteString(p.label) END; out.WriteTab;
IF Controls.link IN p.valid THEN out.WriteString(p.link) END; out.WriteTab;
IF Controls.level IN p.valid THEN out.WriteTab; out.WriteTab; out.WriteInt(p.level) END;
IF (Controls.guard IN p.valid) & (p.guard # "") OR
(Controls.notifier IN p.valid) & (p.notifier # "") THEN
out.WriteLn; out.WriteTab; out.WriteTab; out.WriteTab; out.WriteTab; out.WriteTab;
IF Controls.guard IN p.valid THEN out.WriteString(p.guard) END; out.WriteTab;
IF Controls.notifier IN p.valid THEN out.WriteString(p.notifier) END
END
END
END;
out.WriteLn;
c.GetNextView(Containers.any, v)
END;
Views.OpenAux(Documents.dir.New(TextViews.dir.New(out.rider.Base()), 200*Ports.mm, -1), "Controls");
END
END ShowControlList;
END DevCmds.
| Dev/Mod/Cmds.odc |
MODULE DevComDebug;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
SYSTEM, COM, WinApi, WinOle,
Kernel, Strings, Dialog, Fonts, Ports, Stores, Models, Views, Properties, Containers,
Documents, Windows, Sequencers,
TextModels, TextRulers, TextViews, TextControllers, TextMappers,
DevDebug, DevHeapSpy, StdLog, StdLinks;
TYPE
Block = POINTER TO RECORD [untagged]
tag: Kernel.Type;
size: INTEGER; (* size of free blocks *)
ref: INTEGER;
unk: INTEGER
END;
Cluster = POINTER TO RECORD [untagged]
size: INTEGER; (* total size *)
next: Cluster;
END;
VAR
all: BOOLEAN;
headerLen: INTEGER;
PROCEDURE NewRuler (): TextRulers.Ruler;
CONST mm = Ports.mm; pt = Ports.point;
VAR p: TextRulers.Prop;
BEGIN
NEW(p);
p.valid := {TextRulers.right, TextRulers.tabs, TextRulers.opts};
p.opts.val := {TextRulers.rightFixed}; p.opts.mask := p.opts.val;
p.right := 130 * mm;
p.tabs.len := 4;
p.tabs.tab[0].stop := 15 * mm; p.tabs.tab[1].stop := 70 * mm;
p.tabs.tab[2].stop := 85 * mm; p.tabs.tab[3].stop := 95 * mm;
RETURN TextRulers.dir.NewFromProp(p)
END NewRuler;
PROCEDURE OpenViewer (t: TextModels.Model; title: Views.Title; ruler:TextRulers.Ruler);
VAR v: TextViews.View; c: Containers.Controller;
BEGIN
Dialog.MapString(title, title);
v := TextViews.dir.New(t);
IF ruler # NIL THEN v.SetDefaults(ruler, TextViews.dir.defAttr) END;
c := v.ThisController();
IF c # NIL THEN
c.SetOpts(c.opts - {Containers.noFocus, Containers.noSelection} + {Containers.noCaret})
END;
Views.OpenAux(v, title)
END OpenViewer;
PROCEDURE OpenInfoViewer (t: TextModels.Model; title: Views.Title);
VAR v: TextViews.View; c: Containers.Controller; p: Properties.BoundsPref;
BEGIN
Dialog.MapString(title, title);
v := TextViews.dir.New(t);
c := v.ThisController();
IF c # NIL THEN
c.SetOpts(c.opts - {Containers.noFocus, Containers.noSelection} + {Containers.noCaret})
END;
p.w := Views.undefined; p.h := Views.undefined; Views.HandlePropMsg(v, p);
Views.OpenAux(Documents.dir.New(v, p.w, p.h), title)
END OpenInfoViewer;
PROCEDURE Next (b: Block): Block; (* next block in same cluster *)
VAR size: INTEGER; tag: Kernel.Type;
BEGIN
tag := SYSTEM.VAL(Kernel.Type, SYSTEM.VAL(INTEGER, b.tag) DIV 4 * 4);
size := tag.size + 4;
IF ODD(SYSTEM.VAL(INTEGER, b.tag) DIV 2) THEN size := b.size - SYSTEM.ADR(b.size) + size END;
size := (size + 15) DIV 16 * 16;
RETURN SYSTEM.VAL(Block, SYSTEM.VAL(INTEGER, b) + size)
END Next;
PROCEDURE ShowInterfaces (showHeader: BOOLEAN; VAR out: TextMappers.Formatter);
VAR adr, end: INTEGER; name: Kernel.Name; anchor: ARRAY 256 OF CHAR;
a0: TextModels.Attributes; cluster: Cluster; blk: Block;
BEGIN
IF showHeader THEN
out.WriteSString("Referenced Interface Records:");
out.WriteTab; out.WriteTab;
a0 := out.rider.attr;
out.rider.SetAttr(TextModels.NewStyle(out.rider.attr, {Fonts.underline}));
out.rider.SetAttr(TextModels.NewColor(out.rider.attr, Ports.blue));
out.WriteView(StdLinks.dir.NewLink("DevComDebug.ToggleAllInterfaces"));
IF all THEN out.WriteSString("New") ELSE out.WriteSString("All") END;
out.WriteView(StdLinks.dir.NewLink(""));
out.WriteTab;
out.WriteView(StdLinks.dir.NewLink("DevComDebug.UpdateInterfaceRecords"));
out.WriteSString("Update");
out.WriteView(StdLinks.dir.NewLink(""));
out.rider.SetAttr(a0);
out.WriteLn; out.WriteLn;
headerLen := out.Pos()
END;
cluster := SYSTEM.VAL(Cluster, Kernel.Root());
WHILE cluster # NIL DO
blk := SYSTEM.VAL(Block, SYSTEM.VAL(INTEGER, cluster) + 12);
end := SYSTEM.VAL(INTEGER, blk) + (cluster.size - 12) DIV 16 * 16;
WHILE SYSTEM.VAL(INTEGER, blk) < end DO
IF ~(1 IN SYSTEM.VAL(SET, blk.tag))
& (SYSTEM.VAL(INTEGER, blk.tag) # SYSTEM.ADR(blk.size))
& (blk.tag.base[0] = NIL)
& (all OR (blk.tag.mod.name # "HostMechanisms")
& (blk.tag.mod.name # "OleServer")
& (blk.tag.mod.name # "OleClient")
& (blk.tag.mod.name # "OleStorage")
& (blk.tag.mod.name # "OleData")) THEN
adr := SYSTEM.ADR(blk.size);
out.WriteSString("ref: ");
out.WriteInt(blk.ref); out.WriteTab;
out.WriteSString(blk.tag.mod.name); out.WriteChar(".");
IF (blk.tag.id DIV 256 # 0) & (blk.tag.mod.refcnt >= 0) THEN
Kernel.GetTypeName(blk.tag, name); out.WriteSString(name)
ELSE
out.WriteSString("RECORD");
END;
out.WriteTab;
out.WriteChar("["); out.WriteIntForm(adr, TextMappers.hexadecimal, 9, "0", TextMappers.showBase);
out.WriteChar("]"); out.WriteChar(" ");
out.WriteView(DevDebug.HeapRefView(adr, "Interface"));
DevHeapSpy.GetAnchor(adr, anchor);
IF anchor # "" THEN
out.WriteTab; out.WriteTab; out.WriteChar("(");
out.WriteString(anchor); out.WriteChar(")")
END;
out.WriteLn
END;
blk := Next(blk)
END;
cluster := cluster.next
END
END ShowInterfaces;
PROCEDURE ShowInterfaceRecords*;
VAR out: TextMappers.Formatter;
BEGIN
out.ConnectTo(TextModels.CloneOf(StdLog.buf));
ShowInterfaces(TRUE, out);
OpenViewer(out.rider.Base(), "Interfaces", NewRuler());
out.ConnectTo(NIL)
END ShowInterfaceRecords;
PROCEDURE UpdateInterfaceRecords*;
VAR t, t0: TextModels.Model; out: TextMappers.Formatter;
BEGIN
t0 := TextViews.FocusText();
Models.BeginModification(Models.notUndoable, t0);
t0.Delete(headerLen, t0.Length()); (* removes old object references from text *)
Views.Update(TextViews.Focus(), Views.rebuildFrames);
Windows.dir.Update(Windows.dir.First()); (* remove frame references *)
Kernel.Collect;
t := TextModels.CloneOf(t0); (*Stores.InitDomain(t, t0.domain);*) Stores.Join(t, t0);
out.ConnectTo(t);
ShowInterfaces(FALSE, out);
t0.Insert(headerLen, t, 0, t.Length());
Models.EndModification(Models.notUndoable, t0);
out.ConnectTo(NIL)
END UpdateInterfaceRecords;
PROCEDURE ToggleAllInterfaces*;
BEGIN
all := ~all;
UpdateInterfaceRecords
END ToggleAllInterfaces;
PROCEDURE ShowError*;
VAR res: INTEGER; c: TextControllers.Controller; r: TextModels.Reader; f: TextMappers.Formatter;
beg, end, i: INTEGER; str: ARRAY 1024 OF SHORTCHAR; ch: CHAR; s: ARRAY 64 OF CHAR;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
r := c.text.NewReader(NIL);
r.SetPos(beg); i := 0; r.ReadChar(ch);
WHILE (beg + i < end) & (i < LEN(s) - 1) & (ch >= " ") DO s[i] := ch; INC(i); r.ReadChar(ch) END;
s[i] := 0X;
Strings.StringToInt(s, i, res);
IF res = 0 THEN
f.ConnectTo(TextModels.CloneOf(StdLog.buf));
f.WriteSString("Error Code: ");
f.WriteIntForm(i, TextMappers.hexadecimal, 9, "0", TRUE);
f.WriteLn;
f.WriteSString("(Facility: ");
CASE i DIV 10000H MOD 2000H OF
| 0: f.WriteSString("NULL, ")
| 1: f.WriteSString("RPC, ")
| 2: f.WriteSString("DISPATCH, ")
| 3: f.WriteSString("STORAGE, ")
| 4: f.WriteSString("ITF, ")
| 7: f.WriteSString("WIN32, ")
| 8: f.WriteSString("WINDOWS, ")
| 10: f.WriteSString("CONTROL, ")
ELSE f.WriteSString("unknown, ")
END;
f.WriteSString("Severity: ");
IF i < 0 THEN f.WriteSString("Error, ") ELSE f.WriteSString("Success, ") END;
f.WriteSString("Code: ");
f.WriteInt(i MOD 10000H);
f.WriteChar(")"); f.WriteLn;
f.WriteSString("Description:");
f.WriteLn;
i := WinApi.FormatMessage({12}, 0, i, 0, str, LEN(str), NIL);
IF i > 0 THEN
REPEAT DEC(i) UNTIL (i < 0) OR (str[i] >= " ");
str[i + 1] := 0X;
ELSE str := ""
END;
f.WriteSString(str);
f.WriteLn;
OpenInfoViewer(f.rider.Base(), "Show Error");
f.ConnectTo(NIL)
END
END
END ShowError;
PROCEDURE Hex (VAR f: TextMappers.Formatter; x, n: INTEGER);
BEGIN
IF n > 1 THEN Hex(f, x DIV 16, n - 1) END;
x := x MOD 16;
IF x >= 10 THEN f.WriteChar(SHORT(CHR(x + ORD("A") - 10)))
ELSE f.WriteChar(SHORT(CHR(x + ORD("0"))))
END
END Hex;
PROCEDURE NewGuid*;
VAR f: TextMappers.Formatter; g: COM.GUID; res: COM.RESULT; n: SHORTINT;
BEGIN
f.ConnectTo(TextModels.CloneOf(StdLog.buf)); n := 10;
WHILE n > 0 DO
res := WinOle.CoCreateGuid(g);
f.WriteChar("{");
Hex(f, g[2] MOD 256 + 256 * g[3] MOD 256, 4);
Hex(f, g[0] MOD 256 + 256 * g[1] MOD 256, 4);
f.WriteChar("-");
Hex(f, g[4] MOD 256 + 256 * g[5] MOD 256, 4);
f.WriteChar("-");
Hex(f, g[6] MOD 256 + 256 * g[7] MOD 256, 4);
f.WriteChar("-");
Hex(f, g[8] MOD 256, 2);
Hex(f, g[9] MOD 256, 2);
f.WriteChar("-");
Hex(f, g[10] MOD 256, 2);
Hex(f, g[11] MOD 256, 2);
Hex(f, g[12] MOD 256, 2);
Hex(f, g[13] MOD 256, 2);
Hex(f, g[14] MOD 256, 2);
Hex(f, g[15] MOD 256, 2);
f.WriteChar("}");
f.WriteLn; DEC(n)
END;
OpenInfoViewer(f.rider.Base(), "Guids");
f.ConnectTo(NIL)
END NewGuid;
END DevComDebug.
S_OK* = 0;
S_FALSE* = 1;
E_UNEXPECTED* = 8000FFFFH;
E_NOTIMPL* = 80004001H;
E_OUTOFMEMORY* = 8007000EH;
E_INVALIDARG* = 80070057H;
E_NOINTERFACE* = 80004002H;
E_POINTER* = 80004003H;
E_HANDLE* = 80070006H;
E_ABORT* = 80004004H;
E_FAIL* = 80004005H;
E_ACCESSDENIED* = 80070005H;
CO_E_INIT_TLS* = 80004006H;
CO_E_INIT_SHARED_ALLOCATOR* = 80004007H;
CO_E_INIT_MEMORY_ALLOCATOR* = 80004008H;
CO_E_INIT_CLASS_CACHE* = 80004009H;
CO_E_INIT_RPC_CHANNEL* = 8000400AH;
CO_E_INIT_TLS_SET_CHANNEL_CONTROL* = 8000400BH;
CO_E_INIT_TLS_CHANNEL_CONTROL* = 8000400CH;
CO_E_INIT_UNACCEPTED_USER_ALLOCATOR* = 8000400DH;
CO_E_INIT_SCM_MUTEX_EXISTS* = 8000400EH;
CO_E_INIT_SCM_FILE_MAPPING_EXISTS* = 8000400FH;
CO_E_INIT_SCM_MAP_VIEW_OF_FILE* = 80004010H;
CO_E_INIT_SCM_EXEC_FAILURE* = 80004011H;
CO_E_INIT_ONLY_SINGLE_THREADED* = 80004012H;
OLE_E_OLEVERB* = 80040000H;
OLE_E_ADVF* = 80040001H;
OLE_E_ENUM_NOMORE* = 80040002H;
OLE_E_ADVISENOTSUPPORTED* = 80040003H;
OLE_E_NOCONNECTION* = 80040004H;
OLE_E_NOTRUNNING* = 80040005H;
OLE_E_NOCACHE* = 80040006H;
OLE_E_BLANK* = 80040007H;
OLE_E_CLASSDIFF* = 80040008H;
OLE_E_CANT_GETMONIKER* = 80040009H;
OLE_E_CANT_BINDTOSOURCE* = 8004000AH;
OLE_E_STATIC* = 8004000BH;
OLE_E_PROMPTSAVECANCELLED* = 8004000CH;
OLE_E_INVALIDRECT* = 8004000DH;
OLE_E_WRONGCOMPOBJ* = 8004000EH;
OLE_E_INVALIDHWND* = 8004000FH;
OLE_E_NOT_INPLACEACTIVE* = 80040010H;
OLE_E_CANTCONVERT* = 80040011H;
OLE_E_NOSTORAGE* = 80040012H;
DV_E_FORMATETC* = 80040064H;
DV_E_DVTARGETDEVICE* = 80040065H;
DV_E_STGMEDIUM* = 80040066H;
DV_E_STATDATA* = 80040067H;
DV_E_LINDEX* = 80040068H;
DV_E_TYMED* = 80040069H;
DV_E_CLIPFORMAT* = 8004006AH;
DV_E_DVASPECT* = 8004006BH;
DV_E_DVTARGETDEVICE_SIZE* = 8004006CH;
DV_E_NOIVIEWOBJECT* = 8004006DH;
DRAGDROP_E_NOTREGISTERED* = 80040100H;
DRAGDROP_E_ALREADYREGISTERED* = 80040101H;
DRAGDROP_E_INVALIDHWND* = 80040102H;
CLASS_E_NOAGGREGATION* = 80040110H;
CLASS_E_CLASSNOTAVAILABLE* = 80040111H;
VIEW_E_DRAW* = 80040140H;
REGDB_E_READREGDB* = 80040150H;
REGDB_E_WRITEREGDB* = 80040151H;
REGDB_E_KEYMISSING* = 80040152H;
REGDB_E_INVALIDVALUE* = 80040153H;
REGDB_E_CLASSNOTREG* = 80040154H;
REGDB_E_IIDNOTREG* = 80040155H;
CACHE_E_NOCACHE_UPDATED* = 80040170H;
OLEOBJ_E_NOVERBS* = 80040180H;
OLEOBJ_E_INVALIDVERB* = 80040181H;
INPLACE_E_NOTUNDOABLE* = 800401A0H;
INPLACE_E_NOTOOLSPACE* = 800401A1H;
CONVERT10_E_OLESTREAM_GET* = 800401C0H;
CONVERT10_E_OLESTREAM_PUT* = 800401C1H;
CONVERT10_E_OLESTREAM_FMT* = 800401C2H;
CONVERT10_E_OLESTREAM_BITMAP_TO_DIB* = 800401C3H;
CONVERT10_E_STG_FMT* = 800401C4H;
CONVERT10_E_STG_NO_STD_STREAM* = 800401C5H;
CONVERT10_E_STG_DIB_TO_BITMAP* = 800401C6H;
CLIPBRD_E_CANT_OPEN* = 800401D0H;
CLIPBRD_E_CANT_EMPTY* = 800401D1H;
CLIPBRD_E_CANT_SET* = 800401D2H;
CLIPBRD_E_BAD_DATA* = 800401D3H;
CLIPBRD_E_CANT_CLOSE* = 800401D4H;
MK_E_CONNECTMANUALLY* = 800401E0H;
MK_E_EXCEEDEDDEADLINE* = 800401E1H;
MK_E_NEEDGENERIC* = 800401E2H;
MK_E_UNAVAILABLE* = 800401E3H;
MK_E_SYNTAX* = 800401E4H;
MK_E_NOOBJECT* = 800401E5H;
MK_E_INVALIDEXTENSION* = 800401E6H;
MK_E_INTERMEDIATEINTERFACENOTSUPPORTED* = 800401E7H;
MK_E_NOTBINDABLE* = 800401E8H;
MK_E_NOTBOUND* = 800401E9H;
MK_E_CANTOPENFILE* = 800401EAH;
MK_E_MUSTBOTHERUSER* = 800401EBH;
MK_E_NOINVERSE* = 800401ECH;
MK_E_NOSTORAGE* = 800401EDH;
MK_E_NOPREFIX* = 800401EEH;
MK_E_ENUMERATION_FAILED* = 800401EFH;
CO_E_NOTINITIALIZED* = 800401F0H;
CO_E_ALREADYINITIALIZED* = 800401F1H;
CO_E_CANTDETERMINECLASS* = 800401F2H;
CO_E_CLASSSTRING* = 800401F3H;
CO_E_IIDSTRING* = 800401F4H;
CO_E_APPNOTFOUND* = 800401F5H;
CO_E_APPSINGLEUSE* = 800401F6H;
CO_E_ERRORINAPP* = 800401F7H;
CO_E_DLLNOTFOUND* = 800401F8H;
CO_E_ERRORINDLL* = 800401F9H;
CO_E_WRONGOSFORAPP* = 800401FAH;
CO_E_OBJNOTREG* = 800401FBH;
CO_E_OBJISREG* = 800401FCH;
CO_E_OBJNOTCONNECTED* = 800401FDH;
CO_E_APPDIDNTREG* = 800401FEH;
CO_E_RELEASED* = 800401FFH;
OLE_S_USEREG* = 00040000H;
OLE_S_STATIC* = 00040001H;
OLE_S_MAC_CLIPFORMAT* = 00040002H;
DRAGDROP_S_DROP* = 00040100H;
DRAGDROP_S_CANCEL* = 00040101H;
DRAGDROP_S_USEDEFAULTCURSORS* = 00040102H;
DATA_S_SAMEFORMATETC* = 00040130H;
VIEW_S_ALREADY_FROZEN* = 00040140H;
CACHE_S_FORMATETC_NOTSUPPORTED* = 00040170H;
CACHE_S_SAMECACHE* = 00040171H;
CACHE_S_SOMECACHES_NOTUPDATED* = 00040172H;
OLEOBJ_S_INVALIDVERB* = 00040180H;
OLEOBJ_S_CANNOT_DOVERB_NOW* = 00040181H;
OLEOBJ_S_INVALIDHWND* = 00040182H;
INPLACE_S_TRUNCATED* = 000401A0H;
CONVERT10_S_NO_PRESENTATION* = 000401C0H;
MK_S_REDUCED_TO_SELF* = 000401E2H;
MK_S_ME* = 000401E4H;
MK_S_HIM* = 000401E5H;
MK_S_US* = 000401E6H;
MK_S_MONIKERALREADYREGISTERED* = 000401E7H;
CO_E_CLASS_CREATE_FAILED* = 80080001H;
CO_E_SCM_ERROR* = 80080002H;
CO_E_SCM_RPC_FAILURE* = 80080003H;
CO_E_BAD_PATH* = 80080004H;
CO_E_SERVER_EXEC_FAILURE* = 80080005H;
CO_E_OBJSRV_RPC_FAILURE* = 80080006H;
MK_E_NO_NORMALIZED* = 80080007H;
CO_E_SERVER_STOPPING* = 80080008H;
MEM_E_INVALID_ROOT* = 80080009H;
MEM_E_INVALID_LINK* = 80080010H;
MEM_E_INVALID_SIZE* = 80080011H;
DISP_E_UNKNOWNINTERFACE* = 80020001H;
DISP_E_MEMBERNOTFOUND* = 80020003H;
DISP_E_PARAMNOTFOUND* = 80020004H;
DISP_E_TYPEMISMATCH* = 80020005H;
DISP_E_UNKNOWNNAME* = 80020006H;
DISP_E_NONAMEDARGS* = 80020007H;
DISP_E_BADVARTYPE* = 80020008H;
DISP_E_EXCEPTION* = 80020009H;
DISP_E_OVERFLOW* = 8002000AH;
DISP_E_BADINDEX* = 8002000BH;
DISP_E_UNKNOWNLCID* = 8002000CH;
DISP_E_ARRAYISLOCKED* = 8002000DH;
DISP_E_BADPARAMCOUNT* = 8002000EH;
DISP_E_PARAMNOTOPTIONAL* = 8002000FH;
DISP_E_BADCALLEE* = 80020010H;
DISP_E_NOTACOLLECTION* = 80020011H;
TYPE_E_BUFFERTOOSMALL* = 80028016H;
TYPE_E_INVDATAREAD* = 80028018H;
TYPE_E_UNSUPFORMAT* = 80028019H;
TYPE_E_REGISTRYACCESS* = 8002801CH;
TYPE_E_LIBNOTREGISTERED* = 8002801DH;
TYPE_E_UNDEFINEDTYPE* = 80028027H;
TYPE_E_QUALIFIEDNAMEDISALLOWED* = 80028028H;
TYPE_E_INVALIDSTATE* = 80028029H;
TYPE_E_WRONGTYPEKIND* = 8002802AH;
TYPE_E_ELEMENTNOTFOUND* = 8002802BH;
TYPE_E_AMBIGUOUSNAME* = 8002802CH;
TYPE_E_NAMECONFLICT* = 8002802DH;
TYPE_E_UNKNOWNLCID* = 8002802EH;
TYPE_E_DLLFUNCTIONNOTFOUND* = 8002802FH;
TYPE_E_BADMODULEKIND* = 800288BDH;
TYPE_E_SIZETOOBIG* = 800288C5H;
TYPE_E_DUPLICATEID* = 800288C6H;
TYPE_E_INVALIDID* = 800288CFH;
TYPE_E_TYPEMISMATCH* = 80028CA0H;
TYPE_E_OUTOFBOUNDS* = 80028CA1H;
TYPE_E_IOERROR* = 80028CA2H;
TYPE_E_CANTCREATETMPFILE* = 80028CA3H;
TYPE_E_CANTLOADLIBRARY* = 80029C4AH;
TYPE_E_INCONSISTENTPROPFUNCS* = 80029C83H;
TYPE_E_CIRCULARTYPE* = 80029C84H;
STG_E_INVALIDFUNCTION* = 80030001H;
STG_E_FILENOTFOUND* = 80030002H;
STG_E_PATHNOTFOUND* = 80030003H;
STG_E_TOOMANYOPENFILES* = 80030004H;
STG_E_ACCESSDENIED* = 80030005H;
STG_E_INVALIDHANDLE* = 80030006H;
STG_E_INSUFFICIENTMEMORY* = 80030008H;
STG_E_INVALIDPOINTER* = 80030009H;
STG_E_NOMOREFILES* = 80030012H;
STG_E_DISKISWRITEPROTECTED* = 80030013H;
STG_E_SEEKERROR* = 80030019H;
STG_E_WRITEFAULT* = 8003001DH;
STG_E_READFAULT* = 8003001EH;
STG_E_SHAREVIOLATION* = 80030020H;
STG_E_LOCKVIOLATION* = 80030021H;
STG_E_FILEALREADYEXISTS* = 80030050H;
STG_E_INVALIDPARAMETER* = 80030057H;
STG_E_MEDIUMFULL* = 80030070H;
STG_E_ABNORMALAPIEXIT* = 800300FAH;
STG_E_INVALIDHEADER* = 800300FBH;
STG_E_INVALIDNAME* = 800300FCH;
STG_E_UNKNOWN* = 800300FDH;
STG_E_UNIMPLEMENTEDFUNCTION* = 800300FEH;
STG_E_INVALIDFLAG* = 800300FFH;
STG_E_INUSE* = 80030100H;
STG_E_NOTCURRENT* = 80030101H;
STG_E_REVERTED* = 80030102H;
STG_E_CANTSAVE* = 80030103H;
STG_E_OLDFORMAT* = 80030104H;
STG_E_OLDDLL* = 80030105H;
STG_E_SHAREREQUIRED* = 80030106H;
STG_E_NOTFILEBASEDSTORAGE* = 80030107H;
STG_E_EXTANTMARSHALLINGS* = 80030108H;
STG_S_CONVERTED* = 00030200H;
RPC_E_CALL_REJECTED* = 80010001H;
RPC_E_CALL_CANCELED* = 80010002H;
RPC_E_CANTPOST_INSENDCALL* = 80010003H;
RPC_E_CANTCALLOUT_INASYNCCALL* = 80010004H;
RPC_E_CANTCALLOUT_INEXTERNALCALL* = 80010005H;
RPC_E_CONNECTION_TERMINATED* = 80010006H;
RPC_E_SERVER_DIED* = 80010007H;
RPC_E_CLIENT_DIED* = 80010008H;
RPC_E_INVALID_DATAPACKET* = 80010009H;
RPC_E_CANTTRANSMIT_CALL* = 8001000AH;
RPC_E_CLIENT_CANTMARSHAL_DATA* = 8001000BH;
RPC_E_CLIENT_CANTUNMARSHAL_DATA* = 8001000CH;
RPC_E_SERVER_CANTMARSHAL_DATA* = 8001000DH;
RPC_E_SERVER_CANTUNMARSHAL_DATA* = 8001000EH;
RPC_E_INVALID_DATA* = 8001000FH;
RPC_E_INVALID_PARAMETER* = 80010010H;
RPC_E_CANTCALLOUT_AGAIN* = 80010011H;
RPC_E_SERVER_DIED_DNE* = 80010012H;
RPC_E_SYS_CALL_FAILED* = 80010100H;
RPC_E_OUT_OF_RESOURCES* = 80010101H;
RPC_E_ATTEMPTED_MULTITHREAD* = 80010102H;
RPC_E_NOT_REGISTERED* = 80010103H;
RPC_E_FAULT* = 80010104H;
RPC_E_SERVERFAULT* = 80010105H;
RPC_E_CHANGED_MODE* = 80010106H;
RPC_E_INVALIDMETHOD* = 80010107H;
RPC_E_DISCONNECTED* = 80010108H;
RPC_E_RETRY* = 80010109H;
RPC_E_SERVERCALL_RETRYLATER* = 8001010AH;
RPC_E_SERVERCALL_REJECTED* = 8001010BH;
RPC_E_INVALID_CALLDATA* = 8001010CH;
RPC_E_CANTCALLOUT_ININPUTSYNCCALL* = 8001010DH;
RPC_E_WRONG_THREAD* = 8001010EH;
RPC_E_THREAD_NOT_INIT* = 8001010FH;
RPC_E_UNEXPECTED* = 8001FFFFH;
| Dev/Mod/ComDebug.odc |
MODULE DevComInterfaceGen;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT COM, WinApi, WinOle, WinOleAut,
Files, HostFiles, Strings, Dialog, StdDialog, Views, TextModels, TextViews, DevTypeLibs;
TYPE
Entry = POINTER TO RECORD (* registry typelib entry *)
next: Entry;
index: INTEGER;
guid: COM.GUID;
major, minor: SHORTINT;
lcid: WinApi.LCID;
title: ARRAY 256 OF CHAR;
file: ARRAY 256 OF CHAR
END;
VAR
dialog*: RECORD
library*: Dialog.List;
fileName*: ARRAY 256 OF CHAR;
modName*: ARRAY 64 OF CHAR;
list, current: Entry
END;
PROCEDURE GetName (tlib: WinOleAut.ITypeLib; VAR name: ARRAY OF CHAR);
VAR res: INTEGER; s: WinOle.BSTR;
BEGIN
res := tlib.GetDocumentation(-1, s, NIL, NIL, NIL);
name := s$;
IF (name[0] >= "a") & (name[0] <= "z") THEN name[0] := CAP(name[0]) END;
name := "Ctl" + name;
WinOleAut.SysFreeString(s)
END GetName;
PROCEDURE GenAutomationInterface*;
VAR fn: Files.Name; loc: Files.Locator; t: TextModels.Model;
BEGIN
t := DevTypeLibs.AutomationInterface(dialog.fileName$, dialog.modName$);
StdDialog.GetSubLoc(dialog.modName, "Mod", loc, fn); loc.res := 77;
Views.Open(TextViews.dir.New(t), loc, fn, NIL)
END GenAutomationInterface;
PROCEDURE GenCustomInterface*;
VAR fn: Files.Name; loc: Files.Locator; t: TextModels.Model;
BEGIN
t := DevTypeLibs.CustomInterface(dialog.fileName$, dialog.modName$);
StdDialog.GetSubLoc(dialog.modName, "Mod", loc, fn); loc.res := 77;
Views.Open(TextViews.dir.New(t), loc, fn, NIL)
END GenCustomInterface;
PROCEDURE Browse*;
VAR loc: Files.Locator; name: Files.Name;
res: INTEGER; tlib: WinOleAut.ITypeLib; n: ARRAY 256 OF CHAR;
BEGIN
Dialog.GetIntSpec("*", loc, name);
IF loc # NIL THEN
dialog.fileName := loc(HostFiles.Locator).path$ + "\" + name$;
res := WinOleAut.LoadTypeLib(dialog.fileName, tlib);
IF res >= 0 THEN
GetName(tlib, n);
dialog.modName := n$
ELSE
dialog.modName := ""
END;
dialog.library.index := 0;
Dialog.Update(dialog)
END
END Browse;
PROCEDURE TextFieldNotifier* (op, from, to: INTEGER);
VAR res: INTEGER; tlib: WinOleAut.ITypeLib; n: ARRAY 256 OF CHAR;
BEGIN
res := WinOleAut.LoadTypeLib(dialog.fileName, tlib);
IF res >= 0 THEN
GetName(tlib, n);
dialog.modName := n$
ELSE
dialog.modName := ""
END;
dialog.library.index := 0;
Dialog.Update(dialog)
END TextFieldNotifier;
PROCEDURE ListBoxNotifier* (op, from, to: INTEGER);
VAR name: ARRAY 260 OF CHAR; res: INTEGER; e: Entry;
tlib: WinOleAut.ITypeLib; n: ARRAY 256 OF CHAR;
BEGIN
IF op = Dialog.changed THEN
IF dialog.library.index # dialog.current.index THEN
e := dialog.list; WHILE e.index # dialog.library.index DO e := e.next END;
dialog.current := e; dialog.fileName := e.file$
END;
res := WinOleAut.LoadTypeLib(dialog.fileName, tlib);
IF res >= 0 THEN
GetName(tlib, n);
dialog.modName := n$
ELSE
dialog.modName := "";
dialog.library.index := 0
END;
Dialog.Update(dialog)
END
END ListBoxNotifier;
PROCEDURE InitDialog*;
VAR tlKey, gKey, vKey, lidKey, fKey: WinApi.HKEY; guid: COM.GUID; e: Entry;
i, j, k, res, idx, lcid, len: INTEGER; ver: REAL;
name: ARRAY 256 OF SHORTCHAR; wstr: ARRAY 256 OF CHAR; nstr: ARRAY 16 OF CHAR;
BEGIN
NEW(dialog.list); dialog.list.next := NIL;
dialog.list.index := 0;
dialog.list.title := " "; dialog.list.file := "";
dialog.current := dialog.list;
res := WinApi.RegOpenKey(WinApi.HKEY_CLASSES_ROOT, "TypeLib", tlKey);
idx := 1;
i := 0; res := WinApi.RegEnumKey(tlKey, i, name, LEN(name)); wstr := name$;
WHILE res = 0 DO
res := WinOle.CLSIDFromString(wstr, guid);
IF res = 0 THEN
res := WinApi.RegOpenKey(tlKey, name, gKey);
j := 0; res := WinApi.RegEnumKey(gKey, j, name, LEN(name)); wstr := name$;
WHILE res = 0 DO
Strings.StringToReal(wstr, ver, res);
IF res = 0 THEN
res := WinApi.RegOpenKey(gKey, name, vKey);
k := 0; res := WinApi.RegEnumKey(vKey, k, name, LEN(name)); wstr := name$;
WHILE res = 0 DO
Strings.StringToInt(wstr, lcid, res);
IF res = 0 THEN
res := WinApi.RegOpenKey(vKey, name, lidKey);
res := WinApi.RegOpenKey(lidKey, "Win32", fKey);
IF res # 0 THEN res := WinApi.RegOpenKey(lidKey, "Win16", fKey) END;
IF res = 0 THEN
NEW(e); e.next := dialog.list; dialog.list := e;
e.index := idx; INC(idx);
e.guid := guid;
e.major := SHORT(SHORT(ENTIER(ver)));
e.minor := SHORT(SHORT(ENTIER(ver * 100)) MOD 100);
e.lcid := lcid;
len := LEN(e.title);
res := WinApi.RegQueryValue(vKey, NIL, name, len); e.title := name$;
Strings.RealToString(ver, wstr);
Strings.IntToString(lcid, nstr);
e.title := e.title + " (" + wstr + ", " + nstr + ")";
len := LEN(e.file);
res := WinApi.RegQueryValue(fKey, NIL, name, len); e.file := name$
END
END;
INC(k); res := WinApi.RegEnumKey(vKey, k, name, LEN(name)); wstr := name$
END
END;
INC(j); res := WinApi.RegEnumKey(gKey, j, name, LEN(name)); wstr := name$
END
END;
INC(i); res := WinApi.RegEnumKey(tlKey, i, name, LEN(name)); wstr := name$
END;
dialog.library.SetLen(idx); e := dialog.list;
WHILE e # NIL DO dialog.library.SetItem(e.index, e.title); e := e.next END;
IF dialog.list.next # NIL THEN dialog.library.index := 1 ELSE dialog.library.index := 0 END;
ListBoxNotifier(Dialog.changed, 0, 0)
END InitDialog;
END DevComInterfaceGen.
"DevComInterfaceGen.InitDialog; StdCmds.OpenToolDialog('Dev/Rsrc/ComInterfaceGen', 'Generate Automation Interface')" | Dev/Mod/ComInterfaceGen.odc |
MODULE DevCommanders; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20070717, Alexander Iljin
- 20050626, Fyodor Tkachov, russification edited
- 20050430, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Kernel, Fonts, Ports, Stores, Models, Views, Controllers, Properties, Dialog, Controls,
TextModels, TextSetters, TextMappers, Services, StdLog, i21sysCharacters;
CONST
(* additional Scan types *)
ident = 19; qualident = 20; execMark = 21;
point = Ports.point;
minVersion = 0; maxVersion = 0; maxStdVersion = 0;
TYPE
View* = POINTER TO ABSTRACT RECORD (Views.View)
END;
EndView* = POINTER TO ABSTRACT RECORD (Views.View)
END;
Par* = POINTER TO RECORD
text*: TextModels.Model;
beg*, end*: INTEGER
END;
Directory* = POINTER TO ABSTRACT RECORD END;
StdView = POINTER TO RECORD (View) END;
StdEndView = POINTER TO RECORD (EndView) END;
StdDirectory = POINTER TO RECORD (Directory) END;
Scanner = RECORD
s: TextMappers.Scanner;
ident: ARRAY LEN(Kernel.Name) OF CHAR;
qualident: ARRAY LEN(Kernel.Name) * 2 - 1 OF CHAR
END;
TrapCleaner = POINTER TO RECORD (Kernel.TrapCleaner) END;
VAR
par*: Par;
dir-, stdDir-: Directory;
cleaner: TrapCleaner;
cleanerInstalled: BOOLEAN;
(** Cleaner **)
PROCEDURE (c: TrapCleaner) Cleanup;
BEGIN
par := NIL;
cleanerInstalled := FALSE;
END Cleanup;
(** View **)
PROCEDURE (v: View) Externalize- (VAR wr: Stores.Writer), EXTENSIBLE;
BEGIN
v.Externalize^(wr);
wr.WriteVersion(maxVersion);
wr.WriteXInt(execMark)
END Externalize;
PROCEDURE (v: View) Internalize- (VAR rd: Stores.Reader), EXTENSIBLE;
VAR thisVersion, type: INTEGER;
BEGIN
v.Internalize^(rd);
IF rd.cancelled THEN RETURN END;
rd.ReadVersion(minVersion, maxVersion, thisVersion);
IF rd.cancelled THEN RETURN END;
rd.ReadXInt(type)
END Internalize;
(** Directory **)
PROCEDURE (d: Directory) New* (): View, NEW, ABSTRACT;
PROCEDURE (d: Directory) NewEnd* (): EndView, NEW, ABSTRACT;
(* auxilliary procedures *)
PROCEDURE IsIdent (VAR s: ARRAY OF CHAR): BOOLEAN;
VAR i: INTEGER; ch: CHAR;
BEGIN
ch := s[0]; i := 1;
IF i21sysCharacters.IsFirstIdentChar(ch) THEN
REPEAT
ch := s[i]; INC(i)
UNTIL ~i21sysCharacters.IsIdentChar(ch);
RETURN (ch = 0X) & (i <= LEN(Kernel.Name))
ELSE
RETURN FALSE
END
END IsIdent;
PROCEDURE Scan (VAR s: Scanner);
VAR done: BOOLEAN;
BEGIN
s.s.Scan;
IF (s.s.type = TextMappers.view) THEN
IF Properties.ThisType(s.s.view, "DevCommanders.View") # NIL THEN s.s.type := execMark END
ELSIF (s.s.type = TextMappers.string) & TextMappers.IsQualIdent(s.s.string) THEN
s.s.type := qualident; s.qualident := s.s.string$
ELSIF (s.s.type = TextMappers.string) & IsIdent(s.s.string) THEN
s.ident := s.s.string$;
TextMappers.ScanQualIdent(s.s, s.qualident, done);
IF done THEN s.s.type := qualident ELSE s.s.type := ident END
END
END Scan;
PROCEDURE GetParExtend (r: TextModels.Reader; VAR end: INTEGER);
VAR v, v1: Views.View;
BEGIN
REPEAT r.ReadView(v);
IF v # NIL THEN
v1 := v;
v := Properties.ThisType(v1, "DevCommanders.View") ;
IF v = NIL THEN v := Properties.ThisType(v1, "DevCommanders.EndView") END
END
UNTIL r.eot OR (v # NIL);
end := r.Pos(); IF ~r.eot THEN DEC(end) END
END GetParExtend;
PROCEDURE Unload (cmd: Dialog.String);
VAR modname: Kernel.Name; str: Dialog.String; i: INTEGER; ch: CHAR; mod: Kernel.Module;
BEGIN
i := 0; ch := cmd[0];
WHILE (ch # 0X) & (ch # ".") DO modname[i] := SHORT(ch); INC(i); ch := cmd[i] END;
modname[i] := 0X;
mod := Kernel.ThisLoadedMod(modname);
IF mod # NIL THEN
Kernel.UnloadMod(mod);
IF mod.refcnt < 0 THEN
str := modname$;
Dialog.MapParamString("#Dev:Unloaded", str, "", "", str);
StdLog.String(str); StdLog.Ln;
Controls.Relink
ELSE
str := modname$;
Dialog.ShowParamMsg("#Dev:UnloadingFailed", str, "", "")
END
END
END Unload;
PROCEDURE Execute (t: TextModels.Model; pos: INTEGER; VAR end: INTEGER; unload: BOOLEAN);
VAR s: Scanner; beg, res: INTEGER; cmd: Dialog.String;
BEGIN
end := t.Length();
s.s.ConnectTo(t); s.s.SetPos(pos); s.s.SetOpts({TextMappers.returnViews});
Scan(s); ASSERT(s.s.type = execMark, 100);
Scan(s);
IF s.s.type IN {qualident, TextMappers.string} THEN
beg := s.s.Pos() - 1; GetParExtend(s.s.rider, end);
ASSERT(~cleanerInstalled, 101);
Kernel.PushTrapCleaner(cleaner); cleanerInstalled := TRUE;
NEW(par); par.text := t; par.beg := beg; par.end := end;
IF s.s.type = qualident THEN cmd := s.qualident$ ELSE cmd := s.s.string$ END;
IF unload (* & (s.s.type = qualident)*) THEN Unload(cmd) END;
Dialog.Call(cmd, " ", res);
par := NIL;
Kernel.PopTrapCleaner(cleaner); cleanerInstalled := FALSE;
END
END Execute;
PROCEDURE Track (v: View; f: Views.Frame; x, y: INTEGER; buttons: SET);
VAR c: Models.Context; w, h, end: INTEGER; isDown, in, in0: BOOLEAN; m: SET;
BEGIN
c := v.context; c.GetSize(w, h); in0 := FALSE; in := TRUE;
REPEAT
IF in # in0 THEN
f.MarkRect(0, 0, w, h, Ports.fill, Ports.invert, Ports.show); in0 := in
END;
f.Input(x, y, m, isDown);
in := (0 <= x) & (x < w) & (0 <= y) & (y < h)
UNTIL ~isDown;
IF in0 THEN
f.MarkRect(0, 0, w, h, Ports.fill, Ports.invert, Ports.hide);
WITH c:TextModels.Context DO
Execute(c.ThisModel(), c.Pos(), end,Controllers.modify IN buttons)
ELSE Dialog.Beep
END
END
END Track;
(* StdView *)
PROCEDURE (v: StdView) Externalize (VAR wr: Stores.Writer);
BEGIN
v.Externalize^(wr);
wr.WriteVersion(maxStdVersion)
END Externalize;
PROCEDURE (v: StdView) Internalize (VAR rd: Stores.Reader);
VAR thisVersion: INTEGER;
BEGIN
v.Internalize^(rd);
IF rd.cancelled THEN RETURN END;
rd.ReadVersion(minVersion, maxStdVersion, thisVersion)
END Internalize;
PROCEDURE (v: StdView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
CONST u = point;
VAR c: Models.Context; a: TextModels.Attributes; font: Fonts.Font; color: Ports.Color;
size, d, w, asc, dsc, fw: INTEGER; s: ARRAY 2 OF CHAR;
BEGIN
ASSERT(v.context # NIL, 20);
c := v.context;
WITH c: TextModels.Context DO a := c.Attr(); font := a.font; color := a.color
ELSE font := Fonts.dir.Default(); color := Ports.defaultColor
END;
font.GetBounds(asc, dsc, fw);
size := asc + dsc; d := size DIV 2;
f.DrawOval(u, 0, u + size, size, Ports.fill, color);
s := "!";
w := font.StringWidth(s);
f.DrawString(u + d - w DIV 2, size - dsc, Ports.background, s, font)
END Restore;
PROCEDURE (v: StdView) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.TrackMsg DO
Track(v, f, msg.x, msg.y, msg.modifiers)
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.refCursor
ELSE
END
END HandleCtrlMsg;
PROCEDURE (v: StdView) HandlePropMsg (VAR msg: Properties.Message);
VAR c: Models.Context; a: TextModels.Attributes; font: Fonts.Font; asc, dsc, fw: INTEGER;
BEGIN
WITH msg: Properties.Preference DO
WITH msg: Properties.SizePref DO
c := v.context;
IF (c # NIL) & (c IS TextModels.Context) THEN
a := c(TextModels.Context).Attr(); font := a.font
ELSE font := Fonts.dir.Default()
END;
font.GetBounds(asc, dsc, fw);
msg.h := asc + dsc; msg.w := msg.h + 2 * point
| msg: Properties.ResizePref DO
msg.fixed := TRUE
| msg: Properties.FocusPref DO
msg.hotFocus := TRUE
| msg: TextSetters.Pref DO
c := v.context;
IF (c # NIL) & (c IS TextModels.Context) THEN
a := c(TextModels.Context).Attr(); font := a.font
ELSE font := Fonts.dir.Default()
END;
font.GetBounds(asc, msg.dsc, fw)
| msg: Properties.TypePref DO
IF Services.Is(v, msg.type) THEN msg.view := v END
ELSE
END
ELSE
END
END HandlePropMsg;
(* StdEndView *)
PROCEDURE (v: StdEndView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
CONST u = point;
VAR c: Models.Context; a: TextModels.Attributes; font: Fonts.Font; color: Ports.Color;
size, w, asc, dsc, fw: INTEGER; s: ARRAY 2 OF CHAR;
points: ARRAY 3 OF Ports.Point;
BEGIN
ASSERT(v.context # NIL, 20);
c := v.context;
WITH c: TextModels.Context DO a := c.Attr(); font := a.font; color := a.color
ELSE font := Fonts.dir.Default(); color := Ports.defaultColor
END;
font.GetBounds(asc, dsc, fw);
size := asc + dsc;
points[0].x := 0; points[0].y := size;
points[1].x := u + (size DIV 2); points[1].y := size DIV 2;
points[2].x := u + (size DIV 2); points[2].y := size;
f.DrawPath(points, 3, Ports.fill, color, Ports.closedPoly)
END Restore;
PROCEDURE (v: StdEndView) HandlePropMsg (VAR msg: Properties.Message);
VAR c: Models.Context; a: TextModels.Attributes; font: Fonts.Font; asc, dsc, fw: INTEGER;
BEGIN
WITH msg: Properties.Preference DO
WITH msg: Properties.SizePref DO
c := v.context;
IF (c # NIL) & (c IS TextModels.Context) THEN
a := c(TextModels.Context).Attr(); font := a.font
ELSE font := Fonts.dir.Default()
END;
font.GetBounds(asc, dsc, fw);
msg.h := asc + dsc; msg.w := (msg.h + 2 * point) DIV 2
| msg: Properties.ResizePref DO
msg.fixed := TRUE
| msg: Properties.FocusPref DO
msg.hotFocus := TRUE
| msg: TextSetters.Pref DO
c := v.context;
IF (c # NIL) & (c IS TextModels.Context) THEN
a := c(TextModels.Context).Attr(); font := a.font
ELSE font := Fonts.dir.Default()
END;
font.GetBounds(asc, msg.dsc, fw)
| msg: Properties.TypePref DO
IF Services.Is(v, msg.type) THEN msg.view := v END
ELSE
END
ELSE
END
END HandlePropMsg;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) New (): View;
VAR v: StdView;
BEGIN
NEW(v); RETURN v
END New;
PROCEDURE (d: StdDirectory) NewEnd (): EndView;
VAR v: StdEndView;
BEGIN
NEW(v); RETURN v
END NewEnd;
PROCEDURE Deposit*;
BEGIN
Views.Deposit(dir.New())
END Deposit;
PROCEDURE DepositEnd*;
BEGIN
Views.Deposit(dir.NewEnd())
END DepositEnd;
PROCEDURE SetDir* (d: Directory);
BEGIN
dir := d
END SetDir;
PROCEDURE Init;
VAR d: StdDirectory;
BEGIN
NEW(d); dir := d; stdDir := d;
NEW(cleaner); cleanerInstalled := FALSE;
END Init;
BEGIN
Init
END DevCommanders.
| Dev/Mod/Commanders.odc |
MODULE DevCompiler;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Kernel,
Files, Views, Dialog, Controls,
TextModels, TextMappers, TextViews, TextControllers,
StdLog, StdDialog,
DevMarkers, DevCommanders, DevSelectors,
DevCPM, DevCPT, DevCPB, DevCPP, DevCPE, DevCPV := DevCPV486;
CONST
(* compiler options: *)
checks = 0; allchecks = 1; assert = 2; obj = 3; ref = 4; allref = 5; srcpos = 6; reallib = 7; signatures = 8;
hint = 29; oberon = 30; errorTrap = 31;
defopt = {checks, assert, obj, ref, allref, srcpos (*, signatures *)};
(* additional scanner types *)
import = 100; module = 101; semicolon = 102; becomes = 103; comEnd = 104;
VAR
sourceR: TextModels.Reader;
s: TextMappers.Scanner;
str: Dialog.String;
found: BOOLEAN; (* DevComDebug was found -> DTC *)
PROCEDURE Module (source: TextModels.Reader; opt: SET; log: TextModels.Model; VAR error: BOOLEAN);
VAR ext, new: BOOLEAN; p: DevCPT.Node;
BEGIN
DevCPM.Init(source, log);
IF found THEN INCL(DevCPM.options, DevCPM.comAware) END;
IF errorTrap IN opt THEN INCL(DevCPM.options, DevCPM.trap) END;
IF oberon IN opt THEN INCL(DevCPM.options, DevCPM.oberon) END;
DevCPT.Init(opt);
DevCPB.typSize := DevCPV.TypeSize;
DevCPT.processor := DevCPV.processor;
DevCPP.Module(p);
IF DevCPM.noerr THEN
IF DevCPT.libName # "" THEN EXCL(opt, obj) END;
(*
IF errorTrap IN opt THEN DevCPDump.DumpTree(p) END;
*)
DevCPV.Init(opt); DevCPV.Allocate; DevCPT.Export(ext, new);
IF DevCPM.noerr & (obj IN opt) THEN
DevCPV.Module(p)
END;
DevCPV.Close
END;
IF DevCPM.noerr & (new OR ext) THEN DevCPM.RegisterNewSym
ELSE DevCPM.DeleteNewSym
END;
DevCPT.Close;
error := ~DevCPM.noerr;
DevCPM.Close;
p := NIL;
Kernel.FastCollect;
IF error THEN
DevCPM.InsertMarks(source.Base());
DevCPM.LogWLn; DevCPM.LogWStr(" ");
IF DevCPM.errors = 1 THEN
Dialog.MapString("#Dev:OneErrorDetected", str)
ELSE
DevCPM.LogWNum(DevCPM.errors, 0); Dialog.MapString("#Dev:ErrorsDetected", str)
END;
StdLog.String(str)
ELSE
IF hint IN opt THEN DevCPM.InsertMarks(source.Base()) END;
DevCPM.LogWStr(" "); DevCPM.LogWNum(DevCPE.pc, 8);
DevCPM.LogWStr(" "); DevCPM.LogWNum(DevCPE.dsize, 8)
END;
DevCPM.LogWLn
END Module;
PROCEDURE Scan (VAR s: TextMappers.Scanner);
BEGIN
s.Scan;
IF s.type = TextMappers.string THEN
IF s.string = "MODULE" THEN s.type := module END
ELSIF s.type = TextMappers.char THEN
IF s.char = "(" THEN
IF s.rider.char = "*" THEN
s.rider.Read;
REPEAT Scan(s) UNTIL (s.type = TextMappers.eot) OR (s.type = comEnd);
Scan(s)
END
ELSIF s.char = "*" THEN
IF s.rider.char = ")" THEN s.rider.Read; s.type := comEnd END
END
END
END Scan;
PROCEDURE Do (source, log: TextModels.Model; beg: INTEGER; opt: SET; VAR error: BOOLEAN);
VAR s: TextMappers.Scanner;
BEGIN
Dialog.MapString("#Dev:Compiling", str);
StdLog.String(str); StdLog.Char(" ");
s.ConnectTo(source); s.SetPos(beg);
Scan(s);
WHILE (s.type # TextMappers.eot) & (s.type # module) DO Scan(s) END;
IF s.type = module THEN
Scan(s);
IF s.type = TextMappers.string THEN
StdLog.Char('"'); StdLog.String(s.string); StdLog.Char('"')
END
END;
sourceR := source.NewReader(NIL); sourceR.SetPos(beg);
Module(sourceR, opt, log, error)
END Do;
PROCEDURE Open;
BEGIN
Dialog.ShowStatus("#Dev:Compiling");
StdLog.buf.Delete(0, StdLog.buf.Length())
END Open;
PROCEDURE Close;
BEGIN
StdLog.text.Append(StdLog.buf);
IF DevCPM.noerr THEN Dialog.ShowStatus("#Dev:Ok")
END;
sourceR := NIL;
Kernel.Cleanup
END Close;
PROCEDURE Compile*;
VAR t: TextModels.Model; error: BOOLEAN;
BEGIN
Open;
t := TextViews.FocusText();
IF t # NIL THEN
Do(t, StdLog.text, 0, defopt, error);
IF error THEN DevMarkers.ShowFirstError(t, TextViews.focusOnly) END
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
Close
END Compile;
PROCEDURE CompileOpt* (opt: ARRAY OF CHAR);
VAR t: TextModels.Model; error: BOOLEAN; i: INTEGER; opts: SET;
BEGIN
i := 0; opts := defopt;
WHILE opt[i] # 0X DO
IF opt[i] = "-" THEN
IF srcpos IN opts THEN EXCL(opts, srcpos)
ELSIF allref IN opts THEN EXCL(opts, allref)
ELSIF ref IN opts THEN EXCL(opts, ref)
ELSE EXCL(opts, obj)
END
ELSIF opt[i] = "!" THEN
IF assert IN opts THEN EXCL(opts, assert)
ELSE EXCL(opts, checks)
END
ELSIF opt[i] = "+" THEN INCL(opts, allchecks)
ELSIF opt[i] = "?" THEN INCL(opts, hint)
ELSIF opt[i] = "@" THEN INCL(opts, errorTrap)
ELSIF opt[i] = "$" THEN INCL(opts, oberon)
END;
INC(i)
END;
Open;
t := TextViews.FocusText();
IF t # NIL THEN
Do(t, StdLog.text, 0, opts, error);
IF error THEN DevMarkers.ShowFirstError(t, TextViews.focusOnly) END
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
Close
END CompileOpt;
PROCEDURE CompileText* (text: TextModels.Model; beg: INTEGER; OUT error: BOOLEAN);
BEGIN
ASSERT(text # NIL, 20); ASSERT((beg >= 0) & (beg < text.Length()), 21);
Open;
Do(text, StdLog.text, beg, defopt, error);
IF error THEN DevMarkers.ShowFirstError(text, TextViews.focusOnly) END;
Close
END CompileText;
PROCEDURE CompileAndUnload*;
VAR t: TextModels.Model; error: BOOLEAN; mod: Kernel.Module; n: ARRAY 256 OF CHAR;
BEGIN
Open;
t := TextViews.FocusText();
IF t # NIL THEN
Do(t, StdLog.text, 0, defopt, error);
IF error THEN DevMarkers.ShowFirstError(t, TextViews.focusOnly)
ELSE
mod := Kernel.ThisLoadedMod(DevCPT.SelfName);
IF mod # NIL THEN
Kernel.UnloadMod(mod);
n := DevCPT.SelfName$;
IF mod.refcnt < 0 THEN
Dialog.MapParamString("#Dev:Unloaded", n, "", "", str);
StdLog.String(str); StdLog.Ln;
Controls.Relink
ELSE
Dialog.MapParamString("#Dev:UnloadingFailed", n, "", "", str);
StdLog.String(str); StdLog.Ln
END
END
END
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
Close
END CompileAndUnload;
PROCEDURE CompileSelection*;
VAR c: TextControllers.Controller; t: TextModels.Model; beg, end: INTEGER; error: BOOLEAN;
BEGIN
Open;
c := TextControllers.Focus();
IF c # NIL THEN
t := c.text;
IF c.HasSelection() THEN
c.GetSelection(beg, end); Do(t, StdLog.text, beg, defopt, error);
IF error THEN DevMarkers.ShowFirstError(t, TextViews.focusOnly) END
ELSE Dialog.ShowMsg("#Dev:NoSelectionFound")
END
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
Close
END CompileSelection;
PROCEDURE CompileList (beg, end: INTEGER; c: TextControllers.Controller);
VAR v: Views.View; i: INTEGER; error, one: BOOLEAN; name: Files.Name; loc: Files.Locator;
t: TextModels.Model; opts: SET; title, entry: ARRAY 64 OF CHAR;
BEGIN
s.SetPos(beg); s.Scan; one := FALSE;
WHILE (s.start < end) & (s.type = TextMappers.string) & (s.len < LEN(name)) DO
s.Scan; one := TRUE;
WHILE (s.start < end) & (s.type = TextMappers.char) &
((s.char = "-") OR (s.char = "+") OR
(s.char = "!") OR (s.char = "*") OR (s.char = "?") OR (s.char = "^") OR (s.char = "("))
DO
IF s.char = "(" THEN
WHILE (s.start < end) & ((s.type # TextMappers.char) OR (s.char # ")")) DO s.Scan END
END;
s.Scan
END
END;
IF one & (s.start >= end) THEN
s.SetPos(beg); s.Scan; error := FALSE;
WHILE (s.start < end) & (s.type = TextMappers.string) & ~error DO
i := 0; WHILE i < LEN(name) DO name[i] := 0X; INC(i) END;
StdDialog.GetSubLoc(s.string, "Mod", loc, name);
t := NIL;
IF loc # NIL THEN
v := Views.OldView(loc, name);
IF v # NIL THEN
WITH v: TextViews.View DO t := v.ThisModel()
ELSE Dialog.ShowParamMsg("#Dev:NoTextFileFound", name, "", ""); error := TRUE
END
ELSE Dialog.ShowParamMsg("#Dev:CannotOpenFile", name, "", ""); error := TRUE
END
ELSE Dialog.ShowParamMsg("#System:FileNotFound", name, "", ""); error := TRUE
END;
s.Scan; opts := defopt;
WHILE (s.start < end) & (s.type = TextMappers.char) DO
IF s.char = "-" THEN
IF srcpos IN opts THEN EXCL(opts, srcpos)
ELSIF allref IN opts THEN EXCL(opts, allref)
ELSIF ref IN opts THEN EXCL(opts, ref)
ELSE EXCL(opts, obj)
END
ELSIF s.char = "!" THEN
IF assert IN opts THEN EXCL(opts, assert)
ELSE EXCL(opts, checks)
END
ELSIF s.char = "+" THEN INCL(opts, allchecks)
ELSIF s.char = "?" THEN INCL(opts, hint)
ELSIF s.char = "@" THEN INCL(opts, errorTrap)
ELSIF s.char = "$" THEN INCL(opts, oberon)
ELSIF s.char = "(" THEN
s.Scan;
WHILE (s.start < end) & (s.type = TextMappers.string) DO
title := s.string$; s.Scan;
IF (s.start < end) & (s.type = TextMappers.char) & (s.char = ":") THEN
s.Scan;
IF (s.start < end) & (s.type = TextMappers.string) THEN
entry := s.string$; s.Scan;
IF t # NIL THEN DevSelectors.ChangeTo(t, title, entry) END
END
END;
IF (s.start < end) & (s.type = TextMappers.char) & (s.char = ",") THEN s.Scan END
END
END;
s.Scan
END;
IF t # NIL THEN
Do(t, StdLog.text, 0, opts, error)
END
END
ELSE Dialog.ShowMsg("#Dev:NotOnlyFileNames")
END;
s.ConnectTo(NIL);
IF error & (c # NIL) & c.HasSelection() & (s.start < end) THEN
c.SetSelection(s.start, end)
END;
IF error & (v # NIL) THEN
Views.Open(v, loc, name, NIL);
DevMarkers.ShowFirstError(t, TextViews.any)
END
END CompileList;
PROCEDURE CompileModuleList*;
VAR c: TextControllers.Controller; beg, end: INTEGER;
BEGIN
Open;
c := TextControllers.Focus();
IF c # NIL THEN
s.ConnectTo(c.text);
IF c.HasSelection() THEN c.GetSelection(beg, end)
ELSE beg := 0; end := c.text.Length()
END;
CompileList(beg, end, c)
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
Close
END CompileModuleList;
PROCEDURE CompileThis*;
VAR p: DevCommanders.Par; beg, end: INTEGER;
BEGIN
Open;
p := DevCommanders.par;
IF p # NIL THEN
DevCommanders.par := NIL;
s.ConnectTo(p.text); beg := p.beg; end := p.end;
CompileList(beg, end, NIL)
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
Close
END CompileThis;
PROCEDURE Init;
VAR loc: Files.Locator; f: Files.File;
BEGIN
loc := Files.dir.This("Dev"); loc := loc.This("Code");
f := Files.dir.Old(loc, "ComDebug.ocf", TRUE);
found := f # NIL;
IF f # NIL THEN f.Close END
END Init;
BEGIN
Init
END DevCompiler.
| Dev/Mod/Compiler.odc |
MODULE DevCPB;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT DevCPT, DevCPM;
CONST
(* symbol values or ops *)
times = 1; slash = 2; div = 3; mod = 4;
and = 5; plus = 6; minus = 7; or = 8; eql = 9;
neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14;
in = 15; is = 16; ash = 17; msk = 18; len = 19;
conv = 20; abs = 21; cap = 22; odd = 23; not = 33;
(*SYSTEM*)
adr = 24; cc = 25; bit = 26; lsh = 27; rot = 28; val = 29;
min = 34; max = 35; typfn = 36; size = 37;
(* object modes *)
Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7;
SProc = 8; CProc = 9; IProc = 10; Mod = 11; Head = 12; TProc = 13;
(* Structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Real32 = 7; Real64 = 8; Set = 9; String8 = 10; NilTyp = 11; NoTyp = 12;
Pointer = 13; ProcTyp = 14; Comp = 15;
Char16 = 16; String16 = 17; Int64 = 18;
intSet = {Int8..Int32, Int64}; realSet = {Real32, Real64}; charSet = {Char8, Char16};
(* composite structure forms *)
Basic = 1; Array = 2; DynArr = 3; Record = 4;
(* nodes classes *)
Nvar = 0; Nvarpar = 1; Nfield = 2; Nderef = 3; Nindex = 4; Nguard = 5; Neguard = 6;
Nconst = 7; Ntype = 8; Nproc = 9; Nupto = 10; Nmop = 11; Ndop = 12; Ncall = 13;
Ninittd = 14; Nif = 15; Ncaselse = 16; Ncasedo = 17; Nenter = 18; Nassign = 19;
Nifelse = 20; Ncase = 21; Nwhile = 22; Nrepeat = 23; Nloop = 24; Nexit = 25;
Nreturn = 26; Nwith = 27; Ntrap = 28;
(*function number*)
assign = 0;
haltfn = 0; newfn = 1; absfn = 2; capfn = 3; ordfn = 4;
entierfn = 5; oddfn = 6; minfn = 7; maxfn = 8; chrfn = 9;
shortfn = 10; longfn = 11; sizefn = 12; incfn = 13; decfn = 14;
inclfn = 15; exclfn = 16; lenfn = 17; copyfn = 18; ashfn = 19; assertfn = 32;
lchrfn = 33; lentierfcn = 34; bitsfn = 37; bytesfn = 38;
(*SYSTEM function number*)
adrfn = 20; ccfn = 21; lshfn = 22; rotfn = 23;
getfn = 24; putfn = 25; getrfn = 26; putrfn = 27;
bitfn = 28; valfn = 29; sysnewfn = 30; movefn = 31;
thisrecfn = 45; thisarrfn = 46;
(* COM function number *)
validfn = 40; iidfn = 41; queryfn = 42;
(* module visibility of objects *)
internal = 0; external = 1; externalR = 2; inPar = 3; outPar = 4;
(* procedure flags (conval.setval) *)
hasBody = 1; isRedef = 2; slNeeded = 3; imVar = 4;
(* attribute flags (attr.adr, struct.attribute, proc.conval.setval)*)
newAttr = 16; absAttr = 17; limAttr = 18; empAttr = 19; extAttr = 20;
(* case statement flags (conval.setval) *)
useTable = 1; useTree = 2;
(* sysflags *)
nilBit = 1; inBit = 2; outBit = 4; newBit = 8; iidBit = 16; interface = 10; jint = -11; jstr = -13;
AssertTrap = 0; (* default trap number *)
covarOut = FALSE;
VAR
typSize*: PROCEDURE(typ: DevCPT.Struct);
zero, one, two, dummy, quot: DevCPT.Const;
PROCEDURE err(n: SHORTINT);
BEGIN DevCPM.err(n)
END err;
PROCEDURE NewLeaf*(obj: DevCPT.Object): DevCPT.Node;
VAR node: DevCPT.Node; typ: DevCPT.Struct;
BEGIN
typ := obj.typ;
CASE obj.mode OF
Var:
node := DevCPT.NewNode(Nvar); node.readonly := (obj.vis = externalR) & (obj.mnolev < 0)
| VarPar:
node := DevCPT.NewNode(Nvarpar); node.readonly := obj.vis = inPar;
| Con:
node := DevCPT.NewNode(Nconst); node.conval := DevCPT.NewConst();
node.conval^ := obj.conval^ (* string is not copied, only its ref *)
| Typ:
node := DevCPT.NewNode(Ntype)
| LProc..IProc, TProc:
node := DevCPT.NewNode(Nproc)
ELSE err(127); node := DevCPT.NewNode(Nvar); typ := DevCPT.notyp
END ;
node.obj := obj; node.typ := typ;
RETURN node
END NewLeaf;
PROCEDURE Construct*(class: BYTE; VAR x: DevCPT.Node; y: DevCPT.Node);
VAR node: DevCPT.Node;
BEGIN
node := DevCPT.NewNode(class); node.typ := DevCPT.notyp;
node.left := x; node.right := y; x := node
END Construct;
PROCEDURE Link*(VAR x, last: DevCPT.Node; y: DevCPT.Node);
BEGIN
IF x = NIL THEN x := y ELSE last.link := y END ;
WHILE y.link # NIL DO y := y.link END ;
last := y
END Link;
PROCEDURE BoolToInt(b: BOOLEAN): INTEGER;
BEGIN
IF b THEN RETURN 1 ELSE RETURN 0 END
END BoolToInt;
PROCEDURE IntToBool(i: INTEGER): BOOLEAN;
BEGIN
IF i = 0 THEN RETURN FALSE ELSE RETURN TRUE END
END IntToBool;
PROCEDURE NewBoolConst*(boolval: BOOLEAN): DevCPT.Node;
VAR x: DevCPT.Node;
BEGIN
x := DevCPT.NewNode(Nconst); x.typ := DevCPT.booltyp;
x.conval := DevCPT.NewConst(); x.conval.intval := BoolToInt(boolval); RETURN x
END NewBoolConst;
PROCEDURE OptIf*(VAR x: DevCPT.Node); (* x.link = NIL *)
VAR if, pred: DevCPT.Node;
BEGIN
if := x.left;
WHILE if.left.class = Nconst DO
IF IntToBool(if.left.conval.intval) THEN x := if.right; RETURN
ELSIF if.link = NIL THEN x := x.right; RETURN
ELSE if := if.link; x.left := if
END
END ;
pred := if; if := if.link;
WHILE if # NIL DO
IF if.left.class = Nconst THEN
IF IntToBool(if.left.conval.intval) THEN
pred.link := NIL; x.right := if.right; RETURN
ELSE if := if.link; pred.link := if
END
ELSE pred := if; if := if.link
END
END
END OptIf;
PROCEDURE Nil*(): DevCPT.Node;
VAR x: DevCPT.Node;
BEGIN
x := DevCPT.NewNode(Nconst); x.typ := DevCPT.niltyp;
x.conval := DevCPT.NewConst(); x.conval.intval := 0; RETURN x
END Nil;
PROCEDURE EmptySet*(): DevCPT.Node;
VAR x: DevCPT.Node;
BEGIN
x := DevCPT.NewNode(Nconst); x.typ := DevCPT.settyp;
x.conval := DevCPT.NewConst(); x.conval.setval := {}; RETURN x
END EmptySet;
PROCEDURE MarkAsUsed (node: DevCPT.Node);
VAR c: BYTE;
BEGIN
c := node.class;
WHILE (c = Nfield) OR (c = Nindex) OR (c = Nguard) OR (c = Neguard) DO node := node.left; c := node.class END;
IF (c = Nvar) & (node.obj.mnolev > 0) THEN node.obj.used := TRUE END
END MarkAsUsed;
PROCEDURE GetTempVar* (name: ARRAY OF SHORTCHAR; typ: DevCPT.Struct; VAR obj: DevCPT.Object);
VAR n: DevCPT.Name; o: DevCPT.Object;
BEGIN
n := "@@ "; DevCPT.Insert(n, obj); obj.name^ := name$; (* avoid err 1 *)
obj.mode := Var; obj.typ := typ;
o := DevCPT.topScope.scope;
IF o = NIL THEN DevCPT.topScope.scope := obj
ELSE
WHILE o.link # NIL DO o := o.link END;
o.link := obj
END
END GetTempVar;
(* ---------- constant operations ---------- *)
PROCEDURE Log (x: DevCPT.Node): INTEGER;
VAR val, exp: INTEGER;
BEGIN
exp := 0;
IF x.typ.form = Int64 THEN
RETURN -1
ELSE
val := x.conval.intval;
IF val > 0 THEN
WHILE ~ODD(val) DO val := val DIV 2; INC(exp) END
END;
IF val # 1 THEN exp := -1 END
END;
RETURN exp
END Log;
PROCEDURE Floor (x: REAL): REAL;
VAR y: REAL;
BEGIN
IF ABS(x) > 9007199254740992.0 (* 2^53 *) THEN RETURN x
ELSIF (x >= MAX(INTEGER) + 1.0) OR (x < MIN(INTEGER)) THEN
y := Floor(x / (MAX(INTEGER) + 1.0)) * (MAX(INTEGER) + 1.0);
RETURN SHORT(ENTIER(x - y)) + y
ELSE RETURN SHORT(ENTIER(x))
END
END Floor;
PROCEDURE SetToInt (s: SET): INTEGER;
VAR x, i: INTEGER;
BEGIN
i := 31; x := 0;
IF 31 IN s THEN x := -1 END;
WHILE i > 0 DO
x := x * 2; DEC(i);
IF i IN s THEN INC(x) END
END;
RETURN x
END SetToInt;
PROCEDURE IntToSet (x: INTEGER): SET;
VAR i: INTEGER; s: SET;
BEGIN
i := 0; s := {};
WHILE i < 32 DO
IF ODD(x) THEN INCL(s, i) END;
x := x DIV 2; INC(i)
END;
RETURN s
END IntToSet;
PROCEDURE GetConstType (x: DevCPT.Const; form: INTEGER; errno: SHORTINT; VAR typ: DevCPT.Struct);
CONST MAXL = 9223372036854775808.0; (* 2^63 *)
BEGIN
IF (form IN intSet + charSet) & (x.realval + x.intval >= MIN(INTEGER))
& (x.realval + x.intval <= MAX(INTEGER)) THEN
x.intval := SHORT(ENTIER(x.realval + x.intval)); x.realval := 0
END;
IF form IN intSet THEN
IF x.realval = 0 THEN typ := DevCPT.int32typ
ELSIF (x.intval >= -MAXL - x.realval) & (x.intval < MAXL - x.realval) THEN typ := DevCPT.int64typ
ELSE err(errno); x.intval := 1; x.realval := 0; typ := DevCPT.int32typ
END
ELSIF form IN realSet THEN (* SR *)
typ := DevCPT.real64typ
ELSIF form IN charSet THEN
IF x.intval <= 255 THEN typ := DevCPT.char8typ
ELSE typ := DevCPT.char16typ
END
ELSE typ := DevCPT.undftyp
END
END GetConstType;
PROCEDURE CheckConstType (x: DevCPT.Const; form: INTEGER; errno: SHORTINT);
VAR type: DevCPT.Struct;
BEGIN
GetConstType(x, form, errno, type);
IF ~DevCPT.Includes(form, type.form)
& ((form # Int8) OR (x.realval # 0) OR (x.intval < -128) OR (x.intval > 127))
& ((form # Int16) OR (x.realval # 0) OR (x.intval < -32768) OR (x.intval > 32767))
& ((form # Real32) OR (ABS(x.realval) > DevCPM.MaxReal32) & (ABS(x.realval) # DevCPM.InfReal)) THEN
err(errno); x.intval := 1; x.realval := 0
END
(*
IF (form IN intSet + charSet) & (x.realval + x.intval >= MIN(INTEGER))
& (x.realval + x.intval <= MAX(INTEGER)) THEN
x.intval := SHORT(ENTIER(x.realval + x.intval)); x.realval := 0
END;
IF (form = Int64) & ((x.intval < -MAXL - x.realval) OR (x.intval >= MAXL - x.realval))
OR (form = Int32) & (x.realval # 0)
OR (form = Int16) & ((x.realval # 0) OR (x.intval < -32768) OR (x.intval > 32767))
OR (form = Int8) & ((x.realval # 0) OR (x.intval < -128) OR (x.intval > 127))
OR (form = Char16) & ((x.realval # 0) OR (x.intval < 0) OR (x.intval > 65535))
OR (form = Char8) & ((x.realval # 0) OR (x.intval < 0) OR (x.intval > 255))
OR (form = Real32) & (ABS(x.realval) > DevCPM.MaxReal32) & (ABS(x.realval) # DevCPM.InfReal) THEN
err(errno); x.intval := 1; x.realval := 0
END
*)
END CheckConstType;
PROCEDURE ConvConst (x: DevCPT.Const; from, to: INTEGER);
VAR sr: SHORTREAL;
BEGIN
IF from = Set THEN
x.intval := SetToInt(x.setval); x.realval := 0; x.setval := {};
ELSIF from IN intSet + charSet THEN
IF to = Set THEN CheckConstType(x, Int32, 203); x.setval := IntToSet(x.intval)
ELSIF to IN intSet THEN CheckConstType(x, to, 203)
ELSIF to IN realSet THEN x.realval := x.realval + x.intval; x.intval := DevCPM.ConstNotAlloc
ELSE (*to IN charSet*) CheckConstType(x, to, 220)
END
ELSIF from IN realSet THEN
IF to IN realSet THEN CheckConstType(x, to, 203);
IF to = Real32 THEN sr := SHORT(x.realval); x.realval := sr END (* reduce precision *)
ELSE x.realval := Floor(x.realval); x.intval := 0; CheckConstType(x, to, 203)
END
END
END ConvConst;
PROCEDURE Prepare (x: DevCPT.Const);
VAR r: REAL;
BEGIN
x.realval := x.realval + x.intval DIV 32768 * 32768;
x.intval := x.intval MOD 32768;
r := Floor(x.realval / 4096) * 4096;
x.intval := x.intval + SHORT(ENTIER(x.realval - r));
x.realval := r
(* ABS(x.intval) < 2^15 & ABS(x.realval) MOD 2^12 = 0 *)
END Prepare;
PROCEDURE AddConst (x, y, z: DevCPT.Const; VAR type: DevCPT.Struct); (* z := x + y *)
BEGIN
IF type.form IN intSet THEN
Prepare(x); Prepare(y);
z.intval := x.intval + y.intval; z.realval := x.realval + y.realval
ELSIF type.form IN realSet THEN
IF ABS(x.realval) = DevCPM.InfReal THEN
IF y.realval # -x.realval THEN z.realval := x.realval ELSE err(212) END
ELSIF ABS(y.realval) = DevCPM.InfReal THEN z.realval := y.realval
ELSIF (y.realval >= 0) & (x.realval <= MAX(REAL) - y.realval)
OR (y.realval < 0) & (x.realval >= -MAX(REAL) - y.realval) THEN
z.realval := x.realval + y.realval
ELSE err(206)
END
ELSE HALT(100)
END;
GetConstType(z, type.form, 206, type)
END AddConst;
PROCEDURE SubConst (x, y, z: DevCPT.Const; VAR type: DevCPT.Struct); (* z := x - y *)
BEGIN
IF type.form IN intSet THEN
Prepare(x); Prepare(y);
z.intval := x.intval - y.intval; z.realval := x.realval - y.realval
ELSIF type.form IN realSet THEN
IF ABS(x.realval) = DevCPM.InfReal THEN
IF y.realval # x.realval THEN z.realval := x.realval ELSE err(212) END
ELSIF ABS(y.realval) = DevCPM.InfReal THEN z.realval := -y.realval
ELSIF (y.realval >= 0) & (x.realval >= -MAX(REAL) + y.realval)
OR (y.realval < 0) & (x.realval <= MAX(REAL) + y.realval) THEN
z.realval := x.realval - y.realval
ELSE err(207)
END
ELSE HALT(100)
END;
GetConstType(z, type.form, 207, type)
END SubConst;
PROCEDURE MulConst (x, y, z: DevCPT.Const; VAR type: DevCPT.Struct); (* z := x * y *)
BEGIN
IF type.form IN intSet THEN
Prepare(x); Prepare(y);
z.realval := x.realval * y.realval + x.intval * y.realval + x.realval * y.intval;
z.intval := x.intval * y.intval
ELSIF type.form IN realSet THEN
IF ABS(x.realval) = DevCPM.InfReal THEN
IF y.realval > 0 THEN z.realval := x.realval
ELSIF y.realval < 0 THEN z.realval := -x.realval
ELSE err(212)
END
ELSIF ABS(y.realval) = DevCPM.InfReal THEN
IF x.realval > 0 THEN z.realval := y.realval
ELSIF x.realval < 0 THEN z.realval := -y.realval
ELSE err(212)
END
ELSIF (ABS(y.realval) <= 1) OR (ABS(x.realval) <= MAX(REAL) / ABS(y.realval)) THEN
z.realval := x.realval * y.realval
ELSE err(204)
END
ELSE HALT(100)
END;
GetConstType(z, type.form, 204, type)
END MulConst;
PROCEDURE DivConst (x, y, z: DevCPT.Const; VAR type: DevCPT.Struct); (* z := x / y *)
BEGIN
IF type.form IN realSet THEN
IF y.realval # 0.0 THEN
IF ABS(x.realval) = DevCPM.InfReal THEN
IF ABS(y.realval) = DevCPM.InfReal THEN err(212)
ELSIF y.realval >= 0 THEN z.realval := x.realval
ELSE z.realval := -x.realval
END
ELSIF ABS(y.realval) = DevCPM.InfReal THEN z.realval := 0
ELSIF (ABS(y.realval) >= 1) OR (ABS(x.realval) <= MAX(REAL) * ABS(y.realval)) THEN
z.realval := x.realval / y.realval
ELSE err(204)
END
ELSE err(205)
END
ELSE HALT(100)
END;
GetConstType(z, type.form, 204, type)
END DivConst;
PROCEDURE DivModConst (x, y: DevCPT.Const; div: BOOLEAN; VAR type: DevCPT.Struct);
(* x := x DIV y | x MOD y *)
BEGIN
IF type.form IN intSet THEN
IF y.realval + y.intval # 0 THEN
Prepare(x); Prepare(y);
quot.realval := Floor((x.realval + x.intval) / (y.realval + y.intval));
quot.intval := 0; Prepare(quot);
x.realval := x.realval - quot.realval * y.realval - quot.realval * y.intval - quot.intval * y.realval;
x.intval := x.intval - quot.intval * y.intval;
IF y.realval + y.intval > 0 THEN
WHILE x.realval + x.intval > 0 DO SubConst(x, y, x, type); INC(quot.intval) END;
WHILE x.realval + x.intval < 0 DO AddConst(x, y, x, type); DEC(quot.intval) END
ELSE
WHILE x.realval + x.intval < 0 DO SubConst(x, y, x, type); INC(quot.intval) END;
WHILE x.realval + x.intval > 0 DO AddConst(x, y, x, type); DEC(quot.intval) END
END;
IF div THEN x.realval := quot.realval; x.intval := quot.intval END;
GetConstType(x, type.form, 204, type)
ELSE err(205)
END
ELSE HALT(100)
END
END DivModConst;
PROCEDURE EqualConst (x, y: DevCPT.Const; form: INTEGER): BOOLEAN; (* x = y *)
VAR res: BOOLEAN;
BEGIN
CASE form OF
| Undef: res := TRUE
| Bool, Byte, Char8..Int32, Char16: res := x.intval = y.intval
| Int64: Prepare(x); Prepare(y); res := (x.realval - y.realval) + (x.intval - y.intval) = 0
| Real32, Real64: res := x.realval = y.realval
| Set: res := x.setval = y.setval
| String8, String16, Comp (* guid *): res := x.ext^ = y.ext^
| NilTyp, Pointer, ProcTyp: res := x.intval = y.intval
END;
RETURN res
END EqualConst;
PROCEDURE LessConst (x, y: DevCPT.Const; form: INTEGER): BOOLEAN; (* x < y *)
VAR res: BOOLEAN;
BEGIN
CASE form OF
| Undef: res := TRUE
| Byte, Char8..Int32, Char16: res := x.intval < y.intval
| Int64: Prepare(x); Prepare(y); res := (x.realval - y.realval) + (x.intval - y.intval) < 0
| Real32, Real64: res := x.realval < y.realval
| String8, String16: res := x.ext^ < y.ext^
| Bool, Set, NilTyp, Pointer, ProcTyp, Comp: err(108)
END;
RETURN res
END LessConst;
PROCEDURE NewIntConst*(intval: INTEGER): DevCPT.Node;
VAR x: DevCPT.Node;
BEGIN
x := DevCPT.NewNode(Nconst); x.conval := DevCPT.NewConst();
x.conval.intval := intval; x.conval.realval := 0; x.typ := DevCPT.int32typ; RETURN x
END NewIntConst;
PROCEDURE NewLargeIntConst* (intval: INTEGER; realval: REAL): DevCPT.Node;
VAR x: DevCPT.Node;
BEGIN
x := DevCPT.NewNode(Nconst); x.conval := DevCPT.NewConst();
x.conval.intval := intval; x.conval.realval := realval; x.typ := DevCPT.int64typ; RETURN x
END NewLargeIntConst;
PROCEDURE NewRealConst*(realval: REAL; typ: DevCPT.Struct): DevCPT.Node;
VAR x: DevCPT.Node;
BEGIN
x := DevCPT.NewNode(Nconst); x.conval := DevCPT.NewConst();
x.conval.realval := realval; x.conval.intval := DevCPM.ConstNotAlloc;
IF typ = NIL THEN typ := DevCPT.real64typ END;
x.typ := typ;
RETURN x
END NewRealConst;
PROCEDURE NewString*(str: DevCPT.String; len: INTEGER): DevCPT.Node;
VAR x: DevCPT.Node;
BEGIN
x := DevCPT.NewNode(Nconst); x.conval := DevCPT.NewConst(); x.typ := DevCPT.string8typ;
x.conval.intval := DevCPM.ConstNotAlloc; x.conval.intval2 := len; x.conval.ext := str;
RETURN x
END NewString;
PROCEDURE CharToString8(n: DevCPT.Node);
VAR ch: SHORTCHAR;
BEGIN
n.typ := DevCPT.string8typ; ch := SHORT(CHR(n.conval.intval)); NEW(n.conval.ext, 2);
IF ch = 0X THEN n.conval.intval2 := 1 ELSE n.conval.intval2 := 2; n.conval.ext[1] := 0X END ;
n.conval.ext[0] := ch; n.conval.intval := DevCPM.ConstNotAlloc; n.obj := NIL
END CharToString8;
PROCEDURE CharToString16 (n: DevCPT.Node);
VAR ch, ch1: SHORTCHAR; i: INTEGER;
BEGIN
n.typ := DevCPT.string16typ; NEW(n.conval.ext, 4);
IF n.conval.intval = 0 THEN
n.conval.ext[0] := 0X; n.conval.intval2 := 1
ELSE
i := 0; DevCPM.PutUtf8(n.conval.ext^, n.conval.intval, i);
n.conval.ext[i] := 0X; n.conval.intval2 := 2
END;
n.conval.intval := DevCPM.ConstNotAlloc; n.obj := NIL
END CharToString16;
PROCEDURE String8ToString16 (n: DevCPT.Node);
VAR i, j, x: INTEGER; ext, new: DevCPT.ConstExt;
BEGIN
n.typ := DevCPT.string16typ; ext := n.conval.ext;
NEW(new, 2 * n.conval.intval2); i := 0; j := 0;
REPEAT x := ORD(ext[i]); INC(i); DevCPM.PutUtf8(new^, x, j) UNTIL x = 0;
n.conval.ext := new; n.obj := NIL
END String8ToString16;
PROCEDURE String16ToString8 (n: DevCPT.Node);
VAR i, j, x: INTEGER; ext, new: DevCPT.ConstExt;
BEGIN
n.typ := DevCPT.string8typ; ext := n.conval.ext;
NEW(new, n.conval.intval2); i := 0; j := 0;
REPEAT DevCPM.GetUtf8(ext^, x, i); new[j] := SHORT(CHR(x MOD 256)); INC(j) UNTIL x = 0;
n.conval.ext := new; n.obj := NIL
END String16ToString8;
PROCEDURE StringToGuid (VAR n: DevCPT.Node);
BEGIN
ASSERT((n.class = Nconst) & (n.typ.form = String8));
IF ~DevCPM.ValidGuid(n.conval.ext^) THEN err(165) END;
n.typ := DevCPT.guidtyp
END StringToGuid;
PROCEDURE CheckString (n: DevCPT.Node; typ: DevCPT.Struct; e: SHORTINT);
VAR ntyp: DevCPT.Struct;
BEGIN
ntyp := n.typ;
IF (typ = DevCPT.guidtyp) & (n.class = Nconst) & (ntyp.form = String8) THEN StringToGuid(n)
ELSIF (typ.comp IN {Array, DynArr}) & (typ.BaseTyp.form = Char8) OR (typ.form = String8) THEN
IF (n.class = Nconst) & (ntyp.form = Char8) THEN CharToString8(n)
ELSIF (ntyp.comp IN {Array, DynArr}) & (ntyp.BaseTyp.form = Char8) OR (ntyp.form = String8) THEN (* ok *)
ELSE err(e)
END
ELSIF (typ.comp IN {Array, DynArr}) & (typ.BaseTyp.form = Char16) OR (typ.form = String16) THEN
IF (n.class = Nconst) & (ntyp.form IN charSet) THEN CharToString16(n)
ELSIF (n.class = Nconst) & (ntyp.form = String8) THEN String8ToString16(n)
ELSIF (ntyp.comp IN {Array, DynArr}) & (ntyp.BaseTyp.form = Char16) OR (ntyp.form = String16) THEN
(* ok *)
ELSE err(e)
END
ELSE err(e)
END
END CheckString;
PROCEDURE BindNodes(class: BYTE; typ: DevCPT.Struct; VAR x: DevCPT.Node; y: DevCPT.Node);
VAR node: DevCPT.Node;
BEGIN
node := DevCPT.NewNode(class); node.typ := typ;
node.left := x; node.right := y; x := node
END BindNodes;
PROCEDURE NotVar(x: DevCPT.Node): BOOLEAN;
BEGIN
RETURN (x.class >= Nconst) & ((x.class # Nmop) OR (x.subcl # val) OR (x.left.class >= Nconst))
OR (x.typ.form IN {String8, String16})
END NotVar;
PROCEDURE Convert(VAR x: DevCPT.Node; typ: DevCPT.Struct);
VAR node: DevCPT.Node; f, g: SHORTINT; k: INTEGER; r: REAL;
BEGIN f := x.typ.form; g := typ.form;
IF x.class = Nconst THEN
IF g = String8 THEN
IF f = String16 THEN String16ToString8(x)
ELSIF f IN charSet THEN CharToString8(x)
ELSE typ := DevCPT.undftyp
END
ELSIF g = String16 THEN
IF f = String8 THEN String8ToString16(x)
ELSIF f IN charSet THEN CharToString16(x)
ELSE typ := DevCPT.undftyp
END
ELSE ConvConst(x.conval, f, g)
END;
x.obj := NIL
ELSIF (x.class = Nmop) & (x.subcl = conv) & (DevCPT.Includes(f, x.left.typ.form) OR DevCPT.Includes(f, g))
THEN
(* don't create new node *)
IF x.left.typ.form = typ.form THEN (* and suppress existing node *) x := x.left END
ELSE
IF (x.class = Ndop) & (x.typ.form IN {String8, String16}) THEN (* propagate to leaf nodes *)
Convert(x.left, typ); Convert(x.right, typ)
ELSE
node := DevCPT.NewNode(Nmop); node.subcl := conv; node.left := x; x := node;
END
END;
x.typ := typ
END Convert;
PROCEDURE Promote (VAR left, right: DevCPT.Node; op: INTEGER); (* check expression compatibility *)
VAR f, g: INTEGER; new: DevCPT.Struct;
BEGIN
f := left.typ.form; g := right.typ.form; new := left.typ;
IF f IN intSet + realSet THEN
IF g IN intSet + realSet THEN
IF (f = Real32) & (right.class = Nconst) & (g IN realSet) & (left.class # Nconst)
(* & ((ABS(right.conval.realval) <= DevCPM.MaxReal32)
OR (ABS(right.conval.realval) = DevCPM.InfReal)) *)
OR (g = Real32) & (left.class = Nconst) & (f IN realSet) & (right.class # Nconst)
(* & ((ABS(left.conval.realval) <= DevCPM.MaxReal32)
OR (ABS(left.conval.realval) = DevCPM.InfReal)) *) THEN
new := DevCPT.real32typ (* SR *)
ELSIF (f = Real64) OR (g = Real64) THEN new := DevCPT.real64typ
ELSIF (f = Real32) OR (g = Real32) THEN new := DevCPT.real32typ (* SR *)
ELSIF op = slash THEN new := DevCPT.real64typ
ELSIF (f = Int64) OR (g = Int64) THEN new := DevCPT.int64typ
ELSE new := DevCPT.int32typ
END
ELSE err(100)
END
ELSIF (left.typ = DevCPT.guidtyp) OR (right.typ = DevCPT.guidtyp) THEN
IF f = String8 THEN StringToGuid(left) END;
IF g = String8 THEN StringToGuid(right) END;
IF left.typ # right.typ THEN err(100) END;
f := Comp
ELSIF f IN charSet + {String8, String16} THEN
IF g IN charSet + {String8, String16} THEN
IF (f = String16) OR (g = String16) OR (f = Char16) & (g = String8) OR (f = String8) & (g = Char16) THEN
new := DevCPT.string16typ
ELSIF (f = Char16) OR (g = Char16) THEN new := DevCPT.char16typ
ELSIF (f = String8) OR (g = String8) THEN new := DevCPT.string8typ
ELSIF op = plus THEN
IF (f = Char16) OR (g = Char16) THEN new := DevCPT.string16typ
ELSE new := DevCPT.string8typ
END
END;
IF (new.form IN {String8, String16})
& ((f IN charSet) & (left.class # Nconst) OR (g IN charSet) & (right.class # Nconst))
THEN
err(100)
END
ELSE err(100)
END
ELSIF (f IN {NilTyp, Pointer, ProcTyp}) & (g IN {NilTyp, Pointer, ProcTyp}) THEN
IF ~DevCPT.SameType(left.typ, right.typ) & (f # NilTyp) & (g # NilTyp)
& ~((f = Pointer) & (g = Pointer)
& (DevCPT.Extends(left.typ, right.typ) OR DevCPT.Extends(right.typ, left.typ))) THEN err(100) END
ELSIF f # g THEN err(100)
END;
IF ~(f IN {NilTyp, Pointer, ProcTyp, Comp}) THEN
IF g # new.form THEN Convert(right, new) END;
IF f # new.form THEN Convert(left, new) END
END
END Promote;
PROCEDURE CheckParameters* (fp, ap: DevCPT.Object; checkNames: BOOLEAN); (* checks par list match *)
VAR ft, at: DevCPT.Struct;
BEGIN
WHILE fp # NIL DO
IF ap # NIL THEN
ft := fp.typ; at := ap.typ;
IF fp.ptyp # NIL THEN ft := fp.ptyp END; (* get original formal type *)
IF ap.ptyp # NIL THEN at := ap.ptyp END; (* get original formal type *)
IF ~DevCPT.EqualType(ft, at)
OR (fp.mode # ap.mode) OR (fp.sysflag # ap.sysflag) OR (fp.vis # ap.vis)
OR checkNames & (fp.name^ # ap.name^) THEN err(115) END ;
ap := ap.link
ELSE err(116)
END;
fp := fp.link
END;
IF ap # NIL THEN err(116) END
END CheckParameters;
PROCEDURE CheckNewParamPair* (newPar, iidPar: DevCPT.Node);
VAR ityp, ntyp: DevCPT.Struct;
BEGIN
ntyp := newPar.typ.BaseTyp;
IF (newPar.class = Nvarpar) & ODD(newPar.obj.sysflag DIV newBit) THEN
IF (iidPar.class = Nvarpar) & ODD(iidPar.obj.sysflag DIV iidBit) & (iidPar.obj.mnolev = newPar.obj.mnolev)
THEN (* ok *)
ELSE err(168)
END
ELSIF ntyp.extlev = 0 THEN (* ok *)
ELSIF (iidPar.class = Nconst) & (iidPar.obj # NIL) & (iidPar.obj.mode = Typ) THEN
IF ~DevCPT.Extends(iidPar.obj.typ, ntyp) THEN err(168) END
ELSE err(168)
END
END CheckNewParamPair;
PROCEDURE DeRef*(VAR x: DevCPT.Node);
VAR strobj, bstrobj: DevCPT.Object; typ, btyp: DevCPT.Struct;
BEGIN
typ := x.typ;
IF (x.class = Nconst) OR (x.class = Ntype) OR (x.class = Nproc) THEN err(78)
ELSIF typ.form = Pointer THEN
btyp := typ.BaseTyp; strobj := typ.strobj; bstrobj := btyp.strobj;
IF (strobj # NIL) & (strobj.name # DevCPT.null) & (bstrobj # NIL) & (bstrobj.name # DevCPT.null) THEN
btyp.pbused := TRUE
END ;
BindNodes(Nderef, btyp, x, NIL); x.subcl := 0
ELSE err(84)
END
END DeRef;
PROCEDURE StrDeref*(VAR x: DevCPT.Node);
VAR typ, btyp: DevCPT.Struct;
BEGIN
typ := x.typ;
IF (x.class = Nconst) OR (x.class = Ntype) OR (x.class = Nproc) THEN err(78)
ELSIF ((typ.comp IN {Array, DynArr}) & (typ.BaseTyp.form IN charSet)) OR (typ.sysflag = jstr) THEN
IF (typ.BaseTyp # NIL) & (typ.BaseTyp.form = Char8) THEN btyp := DevCPT.string8typ
ELSE btyp := DevCPT.string16typ
END;
BindNodes(Nderef, btyp, x, NIL); x.subcl := 1
ELSE err(90)
END
END StrDeref;
PROCEDURE Index*(VAR x: DevCPT.Node; y: DevCPT.Node);
VAR f: SHORTINT; typ: DevCPT.Struct;
BEGIN
f := y.typ.form;
IF (x.class = Nconst) OR (x.class = Ntype) OR (x.class = Nproc) THEN err(79)
ELSIF ~(f IN intSet) OR (y.class IN {Nproc, Ntype}) THEN err(80); y.typ := DevCPT.int32typ END ;
IF f = Int64 THEN Convert(y, DevCPT.int32typ) END;
IF x.typ.comp = Array THEN typ := x.typ.BaseTyp;
IF (y.class = Nconst) & ((y.conval.intval < 0) OR (y.conval.intval >= x.typ.n)) THEN err(81) END
ELSIF x.typ.comp = DynArr THEN typ := x.typ.BaseTyp;
IF (y.class = Nconst) & (y.conval.intval < 0) THEN err(81) END
ELSE err(82); typ := DevCPT.undftyp
END ;
BindNodes(Nindex, typ, x, y); x.readonly := x.left.readonly
END Index;
PROCEDURE Field*(VAR x: DevCPT.Node; y: DevCPT.Object);
BEGIN (*x.typ.comp = Record*)
IF (x.class = Nconst) OR (x.class = Ntype) OR (x.class = Nproc) THEN err(77) END ;
IF (y # NIL) & (y.mode IN {Fld, TProc}) THEN
BindNodes(Nfield, y.typ, x, NIL); x.obj := y;
x.readonly := x.left.readonly OR ((y.vis = externalR) & (y.mnolev < 0))
ELSE err(83); x.typ := DevCPT.undftyp
END
END Field;
PROCEDURE TypTest*(VAR x: DevCPT.Node; obj: DevCPT.Object; guard: BOOLEAN);
PROCEDURE GTT(t0, t1: DevCPT.Struct);
VAR node: DevCPT.Node;
BEGIN
IF (t0 # NIL) & DevCPT.SameType(t0, t1) & (guard OR (x.class # Nguard)) THEN
IF ~guard THEN x := NewBoolConst(TRUE) END
ELSIF (t0 = NIL) OR DevCPT.Extends(t1, t0) OR (t0.sysflag = jint) OR (t1.sysflag = jint)
OR (t1.comp = DynArr) & (DevCPM.java IN DevCPM.options) THEN
IF guard THEN BindNodes(Nguard, NIL, x, NIL); x.readonly := x.left.readonly
ELSE node := DevCPT.NewNode(Nmop); node.subcl := is; node.left := x; node.obj := obj; x := node
END
ELSE err(85)
END
END GTT;
BEGIN
IF (x.class = Nconst) OR (x.class = Ntype) OR (x.class = Nproc) THEN err(112)
ELSIF x.typ.form = Pointer THEN
IF x.typ = DevCPT.sysptrtyp THEN
IF obj.typ.form = Pointer THEN GTT(NIL, obj.typ.BaseTyp)
ELSE err(86)
END
ELSIF x.typ.BaseTyp.comp # Record THEN err(85)
ELSIF obj.typ.form = Pointer THEN GTT(x.typ.BaseTyp, obj.typ.BaseTyp)
ELSE err(86)
END
ELSIF (x.typ.comp = Record) & (x.class = Nvarpar) & (x.obj.vis # outPar) & (obj.typ.comp = Record) THEN
GTT(x.typ, obj.typ)
ELSE err(87)
END ;
IF guard THEN x.typ := obj.typ ELSE x.typ := DevCPT.booltyp END
END TypTest;
PROCEDURE In*(VAR x: DevCPT.Node; y: DevCPT.Node);
VAR f: SHORTINT; k: INTEGER;
BEGIN f := x.typ.form;
IF (x.class = Ntype) OR (x.class = Nproc) OR (y.class = Ntype) OR (y.class = Nproc) THEN err(126)
ELSIF (f IN intSet) & (y.typ.form = Set) THEN
IF f = Int64 THEN Convert(x, DevCPT.int32typ) END;
IF x.class = Nconst THEN
k := x.conval.intval;
IF (k < 0) OR (k > DevCPM.MaxSet) THEN err(202)
ELSIF y.class = Nconst THEN x.conval.intval := BoolToInt(k IN y.conval.setval); x.obj := NIL
ELSE BindNodes(Ndop, DevCPT.booltyp, x, y); x.subcl := in
END
ELSE BindNodes(Ndop, DevCPT.booltyp, x, y); x.subcl := in
END
ELSE err(92)
END ;
x.typ := DevCPT.booltyp
END In;
PROCEDURE MOp*(op: BYTE; VAR x: DevCPT.Node);
VAR f: SHORTINT; typ: DevCPT.Struct; z: DevCPT.Node;
PROCEDURE NewOp(op: BYTE; typ: DevCPT.Struct; z: DevCPT.Node): DevCPT.Node;
VAR node: DevCPT.Node;
BEGIN
node := DevCPT.NewNode(Nmop); node.subcl := op; node.typ := typ;
node.left := z; RETURN node
END NewOp;
BEGIN z := x;
IF ((z.class = Ntype) OR (z.class = Nproc)) & (op # adr) & (op # typfn) & (op # size) THEN err(126) (* !!! *)
ELSE
typ := z.typ; f := typ.form;
CASE op OF
| not:
IF f = Bool THEN
IF z.class = Nconst THEN
z.conval.intval := BoolToInt(~IntToBool(z.conval.intval)); z.obj := NIL
ELSE z := NewOp(op, typ, z)
END
ELSE err(98)
END
| plus:
IF ~(f IN intSet + realSet) THEN err(96) END
| minus:
IF f IN intSet + realSet + {Set} THEN
IF z.class = Nconst THEN
IF f = Set THEN z.conval.setval := -z.conval.setval
ELSE SubConst(zero, z.conval, z.conval, z.typ)
END;
z.obj := NIL
ELSE
IF f < Int32 THEN Convert(z, DevCPT.int32typ) END;
z := NewOp(op, z.typ, z)
END
ELSE err(97)
END
| abs:
IF f IN intSet + realSet THEN
IF z.class = Nconst THEN
IF LessConst(z.conval, zero, f) THEN SubConst(zero, z.conval, z.conval, z.typ) END;
z.obj := NIL
ELSE
IF f < Int32 THEN Convert(z, DevCPT.int32typ) END;
z := NewOp(op, z.typ, z)
END
ELSE err(111)
END
| cap:
IF f IN charSet THEN
IF z.class = Nconst THEN
IF ODD(z.conval.intval DIV 32) THEN DEC(z.conval.intval, 32) END;
z.obj := NIL
ELSE z := NewOp(op, typ, z)
END
ELSE err(111); z.typ := DevCPT.char8typ
END
| odd:
IF f IN intSet THEN
IF z.class = Nconst THEN
DivModConst(z.conval, two, FALSE, z.typ); (* z MOD 2 *)
z.obj := NIL
ELSE z := NewOp(op, typ, z)
END
ELSE err(111)
END ;
z.typ := DevCPT.booltyp
| adr: (*ADR*)
IF z.class = Nproc THEN
IF z.obj.mnolev > 0 THEN err(73)
ELSIF z.obj.mode = LProc THEN z.obj.mode := XProc
END;
z := NewOp(op, typ, z)
ELSIF z.class = Ntype THEN
IF z.obj.typ.untagged THEN err(111) END;
z := NewOp(op, typ, z)
ELSIF (z.class < Nconst) OR (z.class = Nconst) & (f IN {String8, String16}) THEN
z := NewOp(op, typ, z)
ELSE err(127)
END ;
z.typ := DevCPT.int32typ
| typfn, size: (*TYP, SIZE*)
z := NewOp(op, typ, z);
z.typ := DevCPT.int32typ
| cc: (*SYSTEM.CC*)
IF (f IN intSet) & (z.class = Nconst) THEN
IF (0 <= z.conval.intval) & (z.conval.intval <= DevCPM.MaxCC) & (z.conval.realval = 0) THEN
z := NewOp(op, typ, z)
ELSE err(219)
END
ELSE err(69)
END;
z.typ := DevCPT.booltyp
END
END;
x := z
END MOp;
PROCEDURE ConstOp(op: SHORTINT; x, y: DevCPT.Node);
VAR f: SHORTINT; i, j: INTEGER; xval, yval: DevCPT.Const; ext: DevCPT.ConstExt; t: DevCPT.Struct;
BEGIN
f := x.typ.form;
IF f = y.typ.form THEN
xval := x.conval; yval := y.conval;
CASE op OF
| times:
IF f IN intSet + realSet THEN MulConst(xval, yval, xval, x.typ)
ELSIF f = Set THEN xval.setval := xval.setval * yval.setval
ELSIF f # Undef THEN err(101)
END
| slash:
IF f IN realSet THEN DivConst(xval, yval, xval, x.typ)
ELSIF f = Set THEN xval.setval := xval.setval / yval.setval
ELSIF f # Undef THEN err(102)
END
| div:
IF f IN intSet THEN DivModConst(xval, yval, TRUE, x.typ)
ELSIF f # Undef THEN err(103)
END
| mod:
IF f IN intSet THEN DivModConst(xval, yval, FALSE, x.typ)
ELSIF f # Undef THEN err(104)
END
| and:
IF f = Bool THEN xval.intval := BoolToInt(IntToBool(xval.intval) & IntToBool(yval.intval))
ELSE err(94)
END
| plus:
IF f IN intSet + realSet THEN AddConst(xval, yval, xval, x.typ)
ELSIF f = Set THEN xval.setval := xval.setval + yval.setval
ELSIF (f IN {String8, String16}) & (xval.ext # NIL) & (yval.ext # NIL) THEN
NEW(ext, LEN(xval.ext^) + LEN(yval.ext^));
i := 0; WHILE xval.ext[i] # 0X DO ext[i] := xval.ext[i]; INC(i) END;
j := 0; WHILE yval.ext[j] # 0X DO ext[i] := yval.ext[j]; INC(i); INC(j) END;
ext[i] := 0X; xval.ext := ext; INC(xval.intval2, yval.intval2 - 1)
ELSIF f # Undef THEN err(105)
END
| minus:
IF f IN intSet + realSet THEN SubConst(xval, yval, xval, x.typ)
ELSIF f = Set THEN xval.setval := xval.setval - yval.setval
ELSIF f # Undef THEN err(106)
END
| min:
IF f IN intSet + realSet THEN
IF LessConst(yval, xval, f) THEN xval^ := yval^ END
ELSIF f # Undef THEN err(111)
END
| max:
IF f IN intSet + realSet THEN
IF LessConst(xval, yval, f) THEN xval^ := yval^ END
ELSIF f # Undef THEN err(111)
END
| or:
IF f = Bool THEN xval.intval := BoolToInt(IntToBool(xval.intval) OR IntToBool(yval.intval))
ELSE err(95)
END
| eql: xval.intval := BoolToInt(EqualConst(xval, yval, f)); x.typ := DevCPT.booltyp
| neq: xval.intval := BoolToInt(~EqualConst(xval, yval, f)); x.typ := DevCPT.booltyp
| lss: xval.intval := BoolToInt(LessConst(xval, yval, f)); x.typ := DevCPT.booltyp
| leq: xval.intval := BoolToInt(~LessConst(yval, xval, f)); x.typ := DevCPT.booltyp
| gtr: xval.intval := BoolToInt(LessConst(yval, xval, f)); x.typ := DevCPT.booltyp
| geq: xval.intval := BoolToInt(~LessConst(xval, yval, f)); x.typ := DevCPT.booltyp
END
ELSE err(100)
END
END ConstOp;
PROCEDURE Op*(op: BYTE; VAR x: DevCPT.Node; y: DevCPT.Node);
VAR f, g: SHORTINT; t, z: DevCPT.Node; typ: DevCPT.Struct; do: BOOLEAN; val: INTEGER;
PROCEDURE NewOp(op: BYTE; typ: DevCPT.Struct; VAR x: DevCPT.Node; y: DevCPT.Node);
VAR node: DevCPT.Node;
BEGIN
node := DevCPT.NewNode(Ndop); node.subcl := op; node.typ := typ;
node.left := x; node.right := y; x := node
END NewOp;
BEGIN z := x;
IF (z.class = Ntype) OR (z.class = Nproc) OR (y.class = Ntype) OR (y.class = Nproc) THEN err(126)
ELSE
Promote(z, y, op);
IF (z.class = Nconst) & (y.class = Nconst) THEN ConstOp(op, z, y); z.obj := NIL
ELSE
typ := z.typ; f := typ.form; g := y.typ.form;
CASE op OF
| times:
do := TRUE;
IF f IN intSet THEN
IF z.class = Nconst THEN
IF EqualConst(z.conval, one, f) THEN do := FALSE; z := y
ELSIF EqualConst(z.conval, zero, f) THEN do := FALSE
ELSE val := Log(z);
IF val >= 0 THEN
t := y; y := z; z := t;
op := ash; y.typ := DevCPT.int32typ; y.conval.intval := val; y.obj := NIL
END
END
ELSIF y.class = Nconst THEN
IF EqualConst(y.conval, one, f) THEN do := FALSE
ELSIF EqualConst(y.conval, zero, f) THEN do := FALSE; z := y
ELSE val := Log(y);
IF val >= 0 THEN
op := ash; y.typ := DevCPT.int32typ; y.conval.intval := val; y.obj := NIL
END
END
END
ELSIF ~(f IN {Undef, Real32..Set}) THEN err(105); typ := DevCPT.undftyp
END ;
IF do THEN NewOp(op, typ, z, y) END;
| slash:
IF f IN realSet THEN
IF (y.class = Nconst) & (y.conval.realval = 0) THEN err(205) END
ELSIF (f # Set) & (f # Undef) THEN err(102); typ := DevCPT.undftyp
END ;
NewOp(op, typ, z, y)
| div:
do := TRUE;
IF f IN intSet THEN
IF y.class = Nconst THEN
IF EqualConst(y.conval, zero, f) THEN err(205)
ELSIF EqualConst(y.conval, one, f) THEN do := FALSE
ELSE val := Log(y);
IF val >= 0 THEN
op := ash; y.typ := DevCPT.int32typ; y.conval.intval := -val; y.obj := NIL
END
END
END
ELSIF f # Undef THEN err(103); typ := DevCPT.undftyp
END ;
IF do THEN NewOp(op, typ, z, y) END;
| mod:
IF f IN intSet THEN
IF y.class = Nconst THEN
IF EqualConst(y.conval, zero, f) THEN err(205)
ELSE val := Log(y);
IF val >= 0 THEN
op := msk; y.conval.intval := ASH(-1, val); y.obj := NIL
END
END
END
ELSIF f # Undef THEN err(104); typ := DevCPT.undftyp
END ;
NewOp(op, typ, z, y);
| and:
IF f = Bool THEN
IF z.class = Nconst THEN
IF IntToBool(z.conval.intval) THEN z := y END
ELSIF (y.class = Nconst) & IntToBool(y.conval.intval) THEN (* optimize z & TRUE -> z *)
ELSE NewOp(op, typ, z, y)
END
ELSIF f # Undef THEN err(94); z.typ := DevCPT.undftyp
END
| plus:
IF ~(f IN {Undef, Int8..Set, Int64, String8, String16}) THEN err(105); typ := DevCPT.undftyp END;
do := TRUE;
IF f IN intSet THEN
IF (z.class = Nconst) & EqualConst(z.conval, zero, f) THEN do := FALSE; z := y END ;
IF (y.class = Nconst) & EqualConst(y.conval, zero, f) THEN do := FALSE END
ELSIF f IN {String8, String16} THEN
IF (z.class = Nconst) & (z.conval.intval2 = 1) THEN do := FALSE; z := y END ;
IF (y.class = Nconst) & (y.conval.intval2 = 1) THEN do := FALSE END;
IF do THEN
IF z.class = Ndop THEN
t := z; WHILE t.right.class = Ndop DO t := t.right END;
IF (t.right.class = Nconst) & (y.class = Nconst) THEN
ConstOp(op, t.right, y); do := FALSE
ELSIF (t.right.class = Nconst) & (y.class = Ndop) & (y.left.class = Nconst) THEN
ConstOp(op, t.right, y.left); y.left := t.right; t.right := y; do := FALSE
ELSE
NewOp(op, typ, t.right, y); do := FALSE
END
ELSE
IF (z.class = Nconst) & (y.class = Ndop) & (y.left.class = Nconst) THEN
ConstOp(op, z, y.left); y.left := z; z := y; do := FALSE
END
END
END
END ;
IF do THEN NewOp(op, typ, z, y) END;
| minus:
IF ~(f IN {Undef, Int8..Set, Int64}) THEN err(106); typ := DevCPT.undftyp END;
IF ~(f IN intSet) OR (y.class # Nconst) OR ~EqualConst(y.conval, zero, f) THEN NewOp(op, typ, z, y)
END;
| min, max:
IF ~(f IN {Undef} + intSet + realSet + charSet) THEN err(111); typ := DevCPT.undftyp END;
NewOp(op, typ, z, y);
| or:
IF f = Bool THEN
IF z.class = Nconst THEN
IF ~IntToBool(z.conval.intval) THEN z := y END
ELSIF (y.class = Nconst) & ~IntToBool(y.conval.intval) THEN (* optimize z OR FALSE -> z *)
ELSE NewOp(op, typ, z, y)
END
ELSIF f # Undef THEN err(95); z.typ := DevCPT.undftyp
END
| eql, neq, lss, leq, gtr, geq:
IF f IN {String8, String16} THEN
IF (f = String16) & (z.class = Nmop) & (z.subcl = conv) & (y.class = Nmop) & (y.subcl = conv) THEN
z := z.left; y := y.left (* remove LONG on both sides *)
ELSIF (z.class = Nconst) & (z.conval.intval2 = 1) & (y.class = Nderef) THEN (* y$ = "" -> y[0] = 0X *)
y := y.left; Index(y, NewIntConst(0)); z.typ := y.typ; z.conval.intval := 0
ELSIF (y.class = Nconst) & (y.conval.intval2 = 1) & (z.class = Nderef) THEN (* z$ = "" -> z[0] = 0X *)
z := z.left; Index(z, NewIntConst(0)); y.typ := z.typ; y.conval.intval := 0
END;
typ := DevCPT.booltyp
ELSIF (f IN {Undef, Char8..Real64, Char16, Int64})
OR (op <= neq) & ((f IN {Bool, Set, NilTyp, Pointer, ProcTyp}) OR (typ = DevCPT.guidtyp)) THEN
typ := DevCPT.booltyp
ELSE err(107); typ := DevCPT.undftyp
END;
NewOp(op, typ, z, y)
END
END
END;
x := z
END Op;
PROCEDURE SetRange*(VAR x: DevCPT.Node; y: DevCPT.Node);
VAR k, l: INTEGER;
BEGIN
IF (x.class = Ntype) OR (x.class = Nproc) OR (y.class = Ntype) OR (y.class = Nproc) THEN err(126)
ELSIF (x.typ.form IN intSet) & (y.typ.form IN intSet) THEN
IF x.typ.form = Int64 THEN Convert(x, DevCPT.int32typ) END;
IF y.typ.form = Int64 THEN Convert(y, DevCPT.int32typ) END;
IF x.class = Nconst THEN
k := x.conval.intval;
IF (0 > k) OR (k > DevCPM.MaxSet) OR (x.conval.realval # 0) THEN err(202) END
END ;
IF y.class = Nconst THEN
l := y.conval.intval;
IF (0 > l) OR (l > DevCPM.MaxSet) OR (y.conval.realval # 0) THEN err(202) END
END ;
IF (x.class = Nconst) & (y.class = Nconst) THEN
IF k <= l THEN
x.conval.setval := {k..l}
ELSE err(201); x.conval.setval := {l..k}
END ;
x.obj := NIL
ELSE BindNodes(Nupto, DevCPT.settyp, x, y)
END
ELSE err(93)
END ;
x.typ := DevCPT.settyp
END SetRange;
PROCEDURE SetElem*(VAR x: DevCPT.Node);
VAR k: INTEGER;
BEGIN
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126) END;
IF x.typ.form IN intSet THEN
IF x.typ.form = Int64 THEN Convert(x, DevCPT.int32typ) END;
IF x.class = Nconst THEN
k := x.conval.intval;
IF (0 <= k) & (k <= DevCPM.MaxSet) & (x.conval.realval = 0) THEN x.conval.setval := {k}
ELSE err(202)
END ;
x.obj := NIL
ELSE BindNodes(Nmop, DevCPT.settyp, x, NIL); x.subcl := bit
END ;
ELSE err(93)
END;
x.typ := DevCPT.settyp
END SetElem;
PROCEDURE CheckAssign* (x: DevCPT.Struct; VAR ynode: DevCPT.Node);
(* x := y, checks assignment compatibility *)
VAR f, g: SHORTINT; y, b: DevCPT.Struct;
BEGIN
y := ynode.typ; f := x.form; g := y.form;
IF (ynode.class = Ntype) OR (ynode.class = Nproc) & (f # ProcTyp) THEN err(126) END ;
CASE f OF
| Undef, String8, String16, Byte:
| Bool, Set:
IF g # f THEN err(113) END
| Int8, Int16, Int32, Int64, Real32, Real64: (* SR *)
IF (g IN intSet) OR (g IN realSet) & (f IN realSet) THEN
IF ynode.class = Nconst THEN Convert(ynode, x)
ELSIF ~DevCPT.Includes(f, g) THEN err(113)
END
ELSE err(113)
END
(*
IF ~(g IN intSet + realSet) OR ~DevCPT.Includes(f, g) & (~(g IN intSet) OR (ynode.class # Nconst)) THEN
err(113)
ELSIF ynode.class = Nconst THEN Convert(ynode, x)
END
*)
| Char8, Char16:
IF ~(g IN charSet) OR ~DevCPT.Includes(f, g) THEN err(113)
ELSIF ynode.class = Nconst THEN Convert(ynode, x)
END
| Pointer:
b := x.BaseTyp;
IF DevCPT.Extends(y, x)
OR (g = NilTyp)
OR (g = Pointer)
& ((x = DevCPT.sysptrtyp) OR (DevCPM.java IN DevCPM.options) & (x = DevCPT.anyptrtyp))
THEN (* ok *)
ELSIF (b.comp = DynArr) & b.untagged THEN (* pointer to untagged open array *)
IF ynode.class = Nconst THEN CheckString(ynode, b, 113)
ELSIF ~(y.comp IN {Array, DynArr}) OR ~DevCPT.EqualType(b.BaseTyp, y.BaseTyp) THEN err(113)
END
ELSIF b.untagged & (ynode.class = Nmop) & (ynode.subcl = adr) THEN (* p := ADR(r) *)
IF (b.comp = DynArr) & (ynode.left.class = Nconst) THEN CheckString(ynode.left, b, 113)
ELSIF ~DevCPT.Extends(ynode.left.typ, b) THEN err(113)
END
ELSIF (b.sysflag = jstr) & ((g = String16) OR (ynode.class = Nconst) & (g IN {Char8, Char16, String8}))
THEN
IF g # String16 THEN Convert(ynode, DevCPT.string16typ) END
ELSE err(113)
END
| ProcTyp:
IF DevCPT.EqualType(x, y) OR (g = NilTyp) THEN (* ok *)
ELSIF (ynode.class = Nproc) & (ynode.obj.mode IN {XProc, IProc, LProc}) THEN
IF ynode.obj.mode = LProc THEN
IF ynode.obj.mnolev = 0 THEN ynode.obj.mode := XProc ELSE err(73) END
END;
IF DevCPT.EqualType(x.BaseTyp, ynode.obj.typ) THEN CheckParameters(x.link, ynode.obj.link, FALSE)
ELSE err(117)
END
ELSE err(113)
END
| NoTyp, NilTyp: err(113)
| Comp:
x.pvused := TRUE; (* idfp of y guarantees assignment compatibility with x *)
IF x.comp = Record THEN
IF ~DevCPT.EqualType(x, y) OR (x.attribute # 0) THEN err(113) END
ELSIF g IN {Char8, Char16, String8, String16} THEN
IF (x.BaseTyp.form = Char16) & (g = String8) THEN Convert(ynode, DevCPT.string16typ)
ELSE CheckString(ynode, x, 113);
END;
IF (x # DevCPT.guidtyp) & (x.comp = Array) & (ynode.class = Nconst) & (ynode.conval.intval2 > x.n) THEN
err(114)
END
ELSIF (x.comp = Array) & DevCPT.EqualType(x, y) THEN (* ok *)
ELSE err(113)
END
END
END CheckAssign;
PROCEDURE AssignString (VAR x: DevCPT.Node; str: DevCPT.Node); (* x := str or x[0] := 0X *)
BEGIN
ASSERT((str.class = Nconst) & (str.typ.form IN {String8, String16}));
IF (x.typ.comp IN {Array, DynArr}) & (str.conval.intval2 = 1) THEN (* x := "" -> x[0] := 0X *)
Index(x, NewIntConst(0));
str.typ := x.typ; str.conval.intval := 0;
END;
BindNodes(Nassign, DevCPT.notyp, x, str); x.subcl := assign
END AssignString;
PROCEDURE CheckLeaf(x: DevCPT.Node; dynArrToo: BOOLEAN);
BEGIN
IF (x.class = Nmop) & (x.subcl = val) THEN x := x.left END ;
IF x.class = Nguard THEN x := x.left END ; (* skip last (and unique) guard *)
IF (x.class = Nvar) & (dynArrToo OR (x.typ.comp # DynArr)) THEN x.obj.leaf := FALSE END
END CheckLeaf;
PROCEDURE CheckOldType (x: DevCPT.Node);
BEGIN
IF ~(DevCPM.oberon IN DevCPM.options)
& ((x.typ = DevCPT.lreal64typ) OR (x.typ = DevCPT.lint64typ) OR (x.typ = DevCPT.lchar16typ)) THEN
err(198)
END
END CheckOldType;
PROCEDURE StPar0*(VAR par0: DevCPT.Node; fctno: SHORTINT); (* par0: first param of standard proc *)
VAR f: SHORTINT; typ: DevCPT.Struct; x, t: DevCPT.Node;
BEGIN x := par0; f := x.typ.form;
CASE fctno OF
haltfn: (*HALT*)
IF (f IN intSet - {Int64}) & (x.class = Nconst) THEN
IF (DevCPM.MinHaltNr <= x.conval.intval) & (x.conval.intval <= DevCPM.MaxHaltNr) THEN
BindNodes(Ntrap, DevCPT.notyp, x, x)
ELSE err(218)
END
ELSIF (DevCPM.java IN DevCPM.options)
& ((x.class = Ntype) OR (x.class = Nvar))
& (x.typ.form = Pointer)
THEN
BindNodes(Ntrap, DevCPT.notyp, x, x)
ELSE err(69)
END ;
x.typ := DevCPT.notyp
| newfn: (*NEW*)
typ := DevCPT.notyp;
IF NotVar(x) THEN err(112)
ELSIF f = Pointer THEN
IF DevCPM.NEWusingAdr THEN CheckLeaf(x, TRUE) END ;
IF x.readonly THEN err(76)
ELSIF (x.typ.BaseTyp.attribute = absAttr)
OR (x.typ.BaseTyp.attribute = limAttr) & (x.typ.BaseTyp.mno # 0) THEN err(193)
ELSIF (x.obj # NIL) & ODD(x.obj.sysflag DIV newBit) THEN err(167)
END ;
MarkAsUsed(x);
f := x.typ.BaseTyp.comp;
IF f IN {Record, DynArr, Array} THEN
IF f = DynArr THEN typ := x.typ.BaseTyp END ;
BindNodes(Nassign, DevCPT.notyp, x, NIL); x.subcl := newfn
ELSE err(111)
END
ELSE err(111)
END ;
x.typ := typ
| absfn: (*ABS*)
MOp(abs, x)
| capfn: (*CAP*)
MOp(cap, x)
| ordfn: (*ORD*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f = Char8 THEN Convert(x, DevCPT.int16typ)
ELSIF f = Char16 THEN Convert(x, DevCPT.int32typ)
ELSIF f = Set THEN Convert(x, DevCPT.int32typ)
ELSE err(111)
END
| bitsfn: (*BITS*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN {Int8, Int16, Int32} THEN Convert(x, DevCPT.settyp)
ELSE err(111)
END
| entierfn: (*ENTIER*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN realSet THEN Convert(x, DevCPT.int64typ)
ELSE err(111)
END ;
x.typ := DevCPT.int64typ
| lentierfcn: (* LENTIER *)
IF ~(DevCPM.oberon IN DevCPM.options) THEN err(199) END;
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN realSet THEN Convert(x, DevCPT.int64typ)
ELSE err(111)
END ;
x.typ := DevCPT.int64typ
| oddfn: (*ODD*)
MOp(odd, x)
| minfn: (*MIN*)
IF x.class = Ntype THEN
CheckOldType(x);
CASE f OF
Bool: x := NewBoolConst(FALSE)
| Char8: x := NewIntConst(0); x.typ := DevCPT.char8typ
| Char16: x := NewIntConst(0); x.typ := DevCPT.char8typ
| Int8: x := NewIntConst(-128)
| Int16: x := NewIntConst(-32768)
| Int32: x := NewIntConst(-2147483648)
| Int64: x := NewLargeIntConst(0, -9223372036854775808.0E0) (* -2^63 *)
| Set: x := NewIntConst(0) (*; x.typ := DevCPT.int16typ *)
| Real32: x := NewRealConst(DevCPM.MinReal32, DevCPT.real64typ)
| Real64: x := NewRealConst(DevCPM.MinReal64, DevCPT.real64typ)
ELSE err(111)
END;
x.hint := 1
ELSIF ~(f IN intSet + realSet + charSet) THEN err(111)
END
| maxfn: (*MAX*)
IF x.class = Ntype THEN
CheckOldType(x);
CASE f OF
Bool: x := NewBoolConst(TRUE)
| Char8: x := NewIntConst(0FFH); x.typ := DevCPT.char8typ
| Char16: x := NewIntConst(0FFFFH); x.typ := DevCPT.char16typ
| Int8: x := NewIntConst(127)
| Int16: x := NewIntConst(32767)
| Int32: x := NewIntConst(2147483647)
| Int64: x := NewLargeIntConst(-1, 9223372036854775808.0E0) (* 2^63 - 1 *)
| Set: x := NewIntConst(31) (*; x.typ := DevCPT.int16typ *)
| Real32: x := NewRealConst(DevCPM.MaxReal32, DevCPT.real64typ)
| Real64: x := NewRealConst(DevCPM.MaxReal64, DevCPT.real64typ)
ELSE err(111)
END;
x.hint := 1
ELSIF ~(f IN intSet + realSet + charSet) THEN err(111)
END
| chrfn: (*CHR*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN {Undef, Int8..Int32, Int64} THEN Convert(x, DevCPT.char16typ)
ELSE err(111); x.typ := DevCPT.char16typ
END
| lchrfn: (* LCHR *)
IF ~(DevCPM.oberon IN DevCPM.options) THEN err(199) END;
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN {Undef, Int8..Int32, Int64} THEN Convert(x, DevCPT.char16typ)
ELSE err(111); x.typ := DevCPT.char16typ
END
| shortfn: (*SHORT*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSE
IF (x.typ.comp IN {Array, DynArr}) & (x.typ.BaseTyp.form IN charSet) THEN StrDeref(x); f := x.typ.form
END;
IF f = Int16 THEN Convert(x, DevCPT.int8typ)
ELSIF f = Int32 THEN Convert(x, DevCPT.int16typ)
ELSIF f = Int64 THEN Convert(x, DevCPT.int32typ)
ELSIF f = Real64 THEN Convert(x, DevCPT.real32typ)
ELSIF f = Char16 THEN Convert(x, DevCPT.char8typ)
ELSIF f = String16 THEN Convert(x, DevCPT.string8typ)
ELSE err(111)
END
END
| longfn: (*LONG*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSE
IF (x.typ.comp IN {Array, DynArr}) & (x.typ.BaseTyp.form IN charSet) THEN StrDeref(x); f := x.typ.form
END;
IF f = Int8 THEN Convert(x, DevCPT.int16typ)
ELSIF f = Int16 THEN Convert(x, DevCPT.int32typ)
ELSIF f = Int32 THEN Convert(x, DevCPT.int64typ)
ELSIF f = Real32 THEN Convert(x, DevCPT.real64typ)
ELSIF f = Char8 THEN Convert(x, DevCPT.char16typ)
ELSIF f = String8 THEN Convert(x, DevCPT.string16typ)
ELSE err(111)
END
END
| incfn, decfn: (*INC, DEC*)
IF NotVar(x) THEN err(112)
ELSIF ~(f IN intSet) THEN err(111)
ELSIF x.readonly THEN err(76)
END;
MarkAsUsed(x)
| inclfn, exclfn: (*INCL, EXCL*)
IF NotVar(x) THEN err(112)
ELSIF f # Set THEN err(111); x.typ := DevCPT.settyp
ELSIF x.readonly THEN err(76)
END;
MarkAsUsed(x)
| lenfn: (*LEN*)
IF (* (x.class = Ntype) OR *) (x.class = Nproc) THEN err(126) (* !!! *)
(* ELSIF x.typ.sysflag = jstr THEN StrDeref(x) *)
ELSE
IF x.typ.form = Pointer THEN DeRef(x) END;
IF ~(x.typ.comp IN {DynArr, Array}) & ~(x.typ.form IN {String8, String16}) THEN err(131) END
END
| copyfn: (*COPY*)
IF ~(DevCPM.oberon IN DevCPM.options) THEN err(199) END;
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126) END
| ashfn: (*ASH*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN intSet THEN
IF f < Int32 THEN Convert(x, DevCPT.int32typ) END
ELSE err(111); x.typ := DevCPT.int32typ
END
| adrfn: (*ADR*)
IF x.class = Ntype THEN CheckOldType(x) END;
CheckLeaf(x, FALSE); MOp(adr, x)
| typfn: (*TYP*)
CheckLeaf(x, FALSE);
IF x.class = Ntype THEN
CheckOldType(x);
IF x.typ.form = Pointer THEN x := NewLeaf(x.typ.BaseTyp.strobj) END;
IF x.typ.comp # Record THEN err(111) END;
MOp(adr, x)
ELSE
IF x.typ.form = Pointer THEN DeRef(x) END;
IF x.typ.comp # Record THEN err(111) END;
MOp(typfn, x)
END
| sizefn: (*SIZE*)
IF x.class # Ntype THEN err(110); x := NewIntConst(1)
ELSIF (f IN {Byte..Set, Pointer, ProcTyp, Char16, Int64}) OR (x.typ.comp IN {Array, Record}) THEN
CheckOldType(x); x.typ.pvused := TRUE;
IF typSize # NIL THEN
typSize(x.typ); x := NewIntConst(x.typ.size)
ELSE
MOp(size, x)
END
ELSE err(111); x := NewIntConst(1)
END
| thisrecfn, (*THISRECORD*)
thisarrfn: (*THISARRAY*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN {Int8, Int16} THEN Convert(x, DevCPT.int32typ)
ELSIF f # Int32 THEN err(111)
END
| ccfn: (*SYSTEM.CC*)
MOp(cc, x)
| lshfn, rotfn: (*SYSTEM.LSH, SYSTEM.ROT*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF ~(f IN intSet + charSet + {Byte, Set}) THEN err(111)
END
| getfn, putfn, bitfn, movefn: (*SYSTEM.GET, SYSTEM.PUT, SYSTEM.BIT, SYSTEM.MOVE*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF (x.class = Nconst) & (f IN {Int8, Int16}) THEN Convert(x, DevCPT.int32typ)
ELSIF ~(f IN {Int32, Pointer}) THEN err(111); x.typ := DevCPT.int32typ
END
| getrfn, putrfn: (*SYSTEM.GETREG, SYSTEM.PUTREG*)
IF (f IN intSet) & (x.class = Nconst) THEN
IF (x.conval.intval < DevCPM.MinRegNr) OR (x.conval.intval > DevCPM.MaxRegNr) THEN err(220)
END
ELSE err(69)
END
| valfn: (*SYSTEM.VAL*)
IF x.class # Ntype THEN err(110)
ELSIF (f IN {Undef, String8, String16, NoTyp, NilTyp}) (* OR (x.typ.comp = DynArr) *) THEN err(111)
ELSE CheckOldType(x)
END
| assertfn: (*ASSERT*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126); x := NewBoolConst(FALSE)
ELSIF f # Bool THEN err(120); x := NewBoolConst(FALSE)
ELSE MOp(not, x)
END
| validfn: (* VALID *)
IF (x.class = Nvarpar) & ODD(x.obj.sysflag DIV nilBit) THEN
MOp(adr, x); x.typ := DevCPT.sysptrtyp; Op(neq, x, Nil())
ELSE err(111)
END;
x.typ := DevCPT.booltyp
| iidfn: (* COM.IID *)
IF (x.class = Nconst) & (f = String8) THEN StringToGuid(x)
ELSE
typ := x.typ;
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
IF (typ.sysflag = interface) & (typ.ext # NIL) & (typ.strobj # NIL) THEN
IF x.obj # typ.strobj THEN x := NewLeaf(typ.strobj) END
ELSE err(111)
END;
x.class := Nconst; x.typ := DevCPT.guidtyp
END
| queryfn: (* COM.QUERY *)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f # Pointer THEN err(111)
END
END ;
par0 := x
END StPar0;
PROCEDURE StPar1*(VAR par0: DevCPT.Node; x: DevCPT.Node; fctno: BYTE);
(* x: second parameter of standard proc *)
VAR f, n, L, i: INTEGER; typ, tp1: DevCPT.Struct; p, t: DevCPT.Node;
PROCEDURE NewOp(class, subcl: BYTE; left, right: DevCPT.Node): DevCPT.Node;
VAR node: DevCPT.Node;
BEGIN
node := DevCPT.NewNode(class); node.subcl := subcl;
node.left := left; node.right := right; RETURN node
END NewOp;
BEGIN p := par0; f := x.typ.form;
CASE fctno OF
incfn, decfn: (*INC DEC*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126); p.typ := DevCPT.notyp
ELSE
IF f # p.typ.form THEN
IF f IN intSet THEN Convert(x, p.typ)
ELSE err(111)
END
END ;
p := NewOp(Nassign, fctno, p, x);
p.typ := DevCPT.notyp
END
| inclfn, exclfn: (*INCL, EXCL*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN intSet THEN
IF f = Int64 THEN Convert(x, DevCPT.int32typ) END;
IF (x.class = Nconst) & ((0 > x.conval.intval) OR (x.conval.intval > DevCPM.MaxSet)) THEN err(202)
END ;
p := NewOp(Nassign, fctno, p, x)
ELSE err(111)
END ;
p.typ := DevCPT.notyp
| lenfn: (*LEN*)
IF ~(f IN intSet) OR (x.class # Nconst) THEN err(69)
ELSE
IF f = Int64 THEN Convert(x, DevCPT.int32typ) END;
L := SHORT(x.conval.intval); typ := p.typ;
WHILE (L > 0) & (typ.comp IN {DynArr, Array}) DO typ := typ.BaseTyp; DEC(L) END ;
IF (L # 0) OR ~(typ.comp IN {DynArr, Array}) THEN err(132)
ELSE x.obj := NIL;
IF typ.comp = DynArr THEN
WHILE p.class = Nindex DO
p := p.left; INC(x.conval.intval) (* possible side effect ignored *)
END;
p := NewOp(Ndop, len, p, x); p.typ := DevCPT.int32typ
ELSE p := x; p.conval.intval := typ.n; p.typ := DevCPT.int32typ
END
END
END
| copyfn: (*COPY*)
IF NotVar(x) THEN err(112)
ELSIF x.readonly THEN err(76)
ELSE
CheckString(p, x.typ, 111); t := x; x := p; p := t;
IF (x.class = Nconst) & (x.typ.form IN {String8, String16}) THEN AssignString(p, x)
ELSE p := NewOp(Nassign, copyfn, p, x)
END
END ;
p.typ := DevCPT.notyp; MarkAsUsed(x)
| ashfn: (*ASH*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN intSet THEN
IF (x.class = Nconst) & ((x.conval.intval > 64) OR (x.conval.intval < -64)) THEN err(208)
ELSIF (p.class = Nconst) & (x.class = Nconst) THEN
n := x.conval.intval;
IF n > 0 THEN
WHILE n > 0 DO MulConst(p.conval, two, p.conval, p.typ); DEC(n) END
ELSE
WHILE n < 0 DO DivModConst(p.conval, two, TRUE, p.typ); INC(n) END
END;
p.obj := NIL
ELSE
IF f = Int64 THEN Convert(x, DevCPT.int32typ) END;
typ := p.typ; p := NewOp(Ndop, ash, p, x); p.typ := typ
END
ELSE err(111)
END
| minfn: (*MIN*)
IF p.class # Ntype THEN Op(min, p, x) ELSE err(64) END
| maxfn: (*MAX*)
IF p.class # Ntype THEN Op(max, p, x) ELSE err(64) END
| newfn: (*NEW(p, x...)*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF p.typ.comp = DynArr THEN
IF f IN intSet THEN
IF f = Int64 THEN Convert(x, DevCPT.int32typ) END;
IF (x.class = Nconst) & (x.conval.intval <= 0)
& (~(DevCPM.java IN DevCPM.options) OR (x.conval.intval < 0))THEN err(63) END
ELSE err(111)
END ;
p.right := x; p.typ := p.typ.BaseTyp
ELSIF (p.left # NIL) & (p.left.typ.form = Pointer) THEN
typ := p.left.typ;
WHILE (typ # DevCPT.undftyp) & (typ.BaseTyp # NIL) DO typ := typ.BaseTyp END;
IF typ.sysflag = interface THEN
typ := x.typ;
WHILE (typ # DevCPT.undftyp) & (typ.BaseTyp # NIL) DO typ := typ.BaseTyp END;
IF (f = Pointer) & (typ.sysflag = interface) THEN
p.right := x
ELSE err(169)
END
ELSE err(64)
END
ELSE err(111)
END
| thisrecfn, (*THISRECORD*)
thisarrfn: (*THISARRAY*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN {Int8, Int16, Int32} THEN
IF f < Int32 THEN Convert(x, DevCPT.int32typ) END;
p := NewOp(Ndop, fctno, p, x); p.typ := DevCPT.undftyp
ELSE err(111)
END
| lshfn, rotfn: (*SYSTEM.LSH, SYSTEM.ROT*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF ~(f IN intSet) THEN err(111)
ELSE
IF fctno = lshfn THEN p := NewOp(Ndop, lsh, p, x) ELSE p := NewOp(Ndop, rot, p, x) END ;
p.typ := p.left.typ
END
| getfn, putfn, getrfn, putrfn: (*SYSTEM.GET, SYSTEM.PUT, SYSTEM.GETREG, SYSTEM.PUTREG*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN {Undef..Set, NilTyp, Pointer, ProcTyp, Char16, Int64} THEN
IF (fctno = getfn) OR (fctno = getrfn) THEN
IF NotVar(x) THEN err(112) END ;
t := x; x := p; p := t
END ;
p := NewOp(Nassign, fctno, p, x)
ELSE err(111)
END ;
p.typ := DevCPT.notyp
| bitfn: (*SYSTEM.BIT*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN intSet THEN
p := NewOp(Ndop, bit, p, x)
ELSE err(111)
END ;
p.typ := DevCPT.booltyp
| valfn: (*SYSTEM.VAL*) (* type is changed without considering the byte ordering on the target machine *)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF x.typ.comp = DynArr THEN
IF x.typ.untagged & ((p.typ.comp # DynArr) OR p.typ.untagged) THEN (* ok *)
ELSIF (p.typ.comp = DynArr) & (x.typ.n = p.typ.n) THEN
typ := x.typ;
WHILE typ.comp = DynArr DO typ := typ.BaseTyp END;
tp1 := p.typ;
WHILE tp1.comp = DynArr DO tp1 := tp1.BaseTyp END;
IF typ.size # tp1.size THEN err(115) END
ELSE err(115)
END
ELSIF p.typ.comp = DynArr THEN err(115)
ELSIF (x.class = Nconst) & (f = String8) & (p.typ.form = Int32) & (x.conval.intval2 <= 5) THEN
i := 0; n := 0;
WHILE i < x.conval.intval2 - 1 DO n := 256 * n + ORD(x.conval.ext[i]); INC(i) END;
x := NewIntConst(n)
ELSIF (f IN {Undef, NoTyp, NilTyp}) OR (f IN {String8, String16}) & ~(DevCPM.java IN DevCPM.options) THEN err(111)
END ;
IF (x.class = Nconst) & (x.typ = p.typ) THEN (* ok *)
ELSIF (x.class >= Nconst) OR ((f IN realSet) # (p.typ.form IN realSet))
OR (DevCPM.options * {DevCPM.java, DevCPM.allSysVal} # {}) THEN
t := DevCPT.NewNode(Nmop); t.subcl := val; t.left := x; x := t
ELSE x.readonly := FALSE
END ;
x.typ := p.typ; p := x
| movefn: (*SYSTEM.MOVE*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF (x.class = Nconst) & (f IN {Int8, Int16}) THEN Convert(x, DevCPT.int32typ)
ELSIF ~(f IN {Int32, Pointer}) THEN err(111); x.typ := DevCPT.int32typ
END ;
p.link := x
| assertfn: (*ASSERT*)
IF (f IN intSet - {Int64}) & (x.class = Nconst) THEN
IF (DevCPM.MinHaltNr <= x.conval.intval) & (x.conval.intval <= DevCPM.MaxHaltNr) THEN
BindNodes(Ntrap, DevCPT.notyp, x, x);
Construct(Nif, p, x); Construct(Nifelse, p, NIL); OptIf(p);
ELSE err(218)
END
ELSIF
(DevCPM.java IN DevCPM.options) & ((x.class = Ntype) OR (x.class = Nvar)) & (x.typ.form = Pointer)
THEN
BindNodes(Ntrap, DevCPT.notyp, x, x);
Construct(Nif, p, x); Construct(Nifelse, p, NIL); OptIf(p);
ELSE err(69)
END;
IF p = NIL THEN (* ASSERT(TRUE) *)
ELSIF p.class = Ntrap THEN err(99)
ELSE p.subcl := assertfn
END
| queryfn: (* COM.QUERY *)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF x.typ # DevCPT.guidtyp THEN err(111); x.typ := DevCPT.guidtyp
END;
p.link := x
ELSE err(64)
END ;
par0 := p
END StPar1;
PROCEDURE StParN*(VAR par0: DevCPT.Node; x: DevCPT.Node; fctno, n: SHORTINT);
(* x: n+1-th param of standard proc *)
VAR node: DevCPT.Node; f: SHORTINT; p: DevCPT.Node; typ: DevCPT.Struct;
BEGIN p := par0; f := x.typ.form;
IF fctno = newfn THEN (*NEW(p, ..., x...*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF p.typ.comp # DynArr THEN err(64)
ELSIF f IN intSet THEN
IF f = Int64 THEN Convert(x, DevCPT.int32typ) END;
IF (x.class = Nconst) & (x.conval.intval <= 0) THEN err(63) END;
node := p.right; WHILE node.link # NIL DO node := node.link END;
node.link := x; p.typ := p.typ.BaseTyp
ELSE err(111)
END
ELSIF (fctno = movefn) & (n = 2) THEN (*SYSTEM.MOVE*)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF f IN intSet THEN
node := DevCPT.NewNode(Nassign); node.subcl := movefn; node.right := p;
node.left := p.link; p.link := x; p := node
ELSE err(111)
END ;
p.typ := DevCPT.notyp
ELSIF (fctno = queryfn) & (n = 2) THEN (* COM.QUERY *)
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF (x.class < Nconst) & (f = Pointer) & (x.typ.sysflag = interface) THEN
IF ~DevCPT.Extends(p.typ, x.typ) THEN err(164) END;
IF x.readonly THEN err(76) END;
CheckNewParamPair(x, p.link);
MarkAsUsed(x);
node := DevCPT.NewNode(Ndop); node.subcl := queryfn;
node.left := p; node.right := p.link; p.link := NIL; node.right.link := x; p := node
ELSE err(111)
END;
p.typ := DevCPT.booltyp
ELSE err(64)
END ;
par0 := p
END StParN;
PROCEDURE StFct*(VAR par0: DevCPT.Node; fctno: BYTE; parno: SHORTINT);
VAR dim: SHORTINT; x, p: DevCPT.Node;
BEGIN p := par0;
IF fctno <= ashfn THEN
IF (fctno = newfn) & (p.typ # DevCPT.notyp) THEN
IF p.typ.comp = DynArr THEN err(65) END ;
p.typ := DevCPT.notyp
ELSIF (fctno = minfn) OR (fctno = maxfn) THEN
IF (parno < 1) OR (parno = 1) & (p.hint # 1) THEN err(65) END;
p.hint := 0
ELSIF fctno <= sizefn THEN (* 1 param *)
IF parno < 1 THEN err(65) END
ELSE (* more than 1 param *)
IF ((fctno = incfn) OR (fctno = decfn)) & (parno = 1) THEN (*INC, DEC*)
BindNodes(Nassign, DevCPT.notyp, p, NewIntConst(1)); p.subcl := fctno; p.right.typ := p.left.typ
ELSIF (fctno = lenfn) & (parno = 1) THEN (*LEN*)
IF p.typ.form IN {String8, String16} THEN
IF p.class = Nconst THEN p := NewIntConst(p.conval.intval2 - 1)
ELSIF (p.class = Ndop) & (p.subcl = plus) THEN (* propagate to leaf nodes *)
StFct(p.left, lenfn, 1); StFct(p.right, lenfn, 1); p.typ := DevCPT.int32typ
ELSE
WHILE (p.class = Nmop) & (p.subcl = conv) DO p := p.left END;
IF DevCPM.errors = 0 THEN ASSERT(p.class = Nderef) END;
BindNodes(Ndop, DevCPT.int32typ, p, NewIntConst(0)); p.subcl := len
END
ELSIF p.typ.comp = DynArr THEN dim := 0;
WHILE p.class = Nindex DO p := p.left; INC(dim) END ; (* possible side effect ignored *)
BindNodes(Ndop, DevCPT.int32typ, p, NewIntConst(dim)); p.subcl := len
ELSE
p := NewIntConst(p.typ.n)
END
ELSIF parno < 2 THEN err(65)
END
END
ELSIF fctno = assertfn THEN
IF parno = 1 THEN x := NIL;
BindNodes(Ntrap, DevCPT.notyp, x, NewIntConst(AssertTrap));
Construct(Nif, p, x); Construct(Nifelse, p, NIL); OptIf(p);
IF p = NIL THEN (* ASSERT(TRUE) *)
ELSIF p.class = Ntrap THEN err(99)
ELSE p.subcl := assertfn
END
ELSIF parno < 1 THEN err(65)
END
ELSIF (fctno >= lchrfn) & (fctno <= bytesfn) THEN
IF parno < 1 THEN err(65) END
ELSIF fctno < validfn THEN (*SYSTEM*)
IF (parno < 1) OR
(fctno > ccfn) & (parno < 2) OR
(fctno = movefn) & (parno < 3) THEN err(65)
END
ELSIF (fctno = thisrecfn) OR (fctno = thisarrfn) THEN
IF parno < 2 THEN err(65) END
ELSE (* COM *)
IF fctno = queryfn THEN
IF parno < 3 THEN err(65) END
ELSE
IF parno < 1 THEN err(65) END
END
END ;
par0 := p
END StFct;
PROCEDURE DynArrParCheck (ftyp: DevCPT.Struct; VAR ap: DevCPT.Node; fvarpar: BOOLEAN);
(* check array compatibility *)
VAR atyp: DevCPT.Struct;
BEGIN (* ftyp.comp = DynArr *)
atyp := ap.typ;
IF atyp.form IN {Char8, Char16, String8, String16} THEN
IF ~fvarpar & (ftyp.BaseTyp.form = Char16) & (atyp.form = String8) THEN Convert(ap, DevCPT.string16typ)
ELSE CheckString(ap, ftyp, 67)
END
ELSE
WHILE (ftyp.comp = DynArr) & ((atyp.comp IN {Array, DynArr}) OR (atyp.form IN {String8, String16})) DO
ftyp := ftyp.BaseTyp; atyp := atyp.BaseTyp
END;
IF ftyp.comp = DynArr THEN err(67)
ELSIF ~fvarpar & (ftyp.form = Pointer) & DevCPT.Extends(atyp, ftyp) THEN (* ok *)
ELSIF ~DevCPT.EqualType(ftyp, atyp) THEN err(66)
END
END
END DynArrParCheck;
PROCEDURE PrepCall*(VAR x: DevCPT.Node; VAR fpar: DevCPT.Object);
BEGIN
IF (x.obj # NIL) & (x.obj.mode IN {LProc, XProc, TProc, CProc}) THEN
fpar := x.obj.link;
IF x.obj.mode = TProc THEN
IF fpar.typ.form = Pointer THEN
IF x.left.class = Nderef THEN x.left := x.left.left (*undo DeRef*) ELSE err(71) END
END;
fpar := fpar.link
END
ELSIF (x.class # Ntype) & (x.typ # NIL) & (x.typ.form = ProcTyp) THEN
fpar := x.typ.link
ELSE err(121); fpar := NIL; x.typ := DevCPT.undftyp
END
END PrepCall;
PROCEDURE Param* (VAR ap: DevCPT.Node; fp: DevCPT.Object); (* checks parameter compatibilty *)
VAR at, ft: DevCPT.Struct;
BEGIN
at := ap.typ; ft := fp.typ;
IF fp.ptyp # NIL THEN ft := fp.ptyp END; (* get original formal type *)
IF ft.form # Undef THEN
IF (ap.class = Ntype) OR (ap.class = Nproc) & (ft.form # ProcTyp) THEN err(126) END;
IF fp.mode = VarPar THEN
IF ODD(fp.sysflag DIV nilBit) & (at = DevCPT.niltyp) THEN (* ok *)
ELSIF (ft.comp = Record) & ~ft.untagged & (ap.class = Ndop) & (ap.subcl = thisrecfn) THEN (* ok *)
ELSIF (ft.comp = DynArr) & ~ft.untagged & (ft.n = 0) & (ap.class = Ndop) & (ap.subcl = thisarrfn) THEN
(* ok *)
ELSE
IF fp.vis = inPar THEN
IF (ft = DevCPT.guidtyp) & (ap.class = Nconst) & (at.form = String8) THEN
StringToGuid(ap); at := ap.typ
(*
ELSIF ((at.form IN charSet + {String8, String16}) OR (at = DevCPT.guidtyp))
& ((ap.class = Nderef) OR (ap.class = Nconst)) THEN (* ok *)
ELSIF NotVar(ap) THEN err(122)
*)
END;
IF ~NotVar(ap) THEN CheckLeaf(ap, FALSE) END
ELSE
IF NotVar(ap) THEN err(122)
ELSIF ap.readonly THEN err(76)
ELSIF (ap.obj # NIL) & ODD(ap.obj.sysflag DIV newBit) & ~ODD(fp.sysflag DIV newBit) THEN
err(167)
ELSE MarkAsUsed(ap); CheckLeaf(ap, FALSE)
END
END;
IF ft.comp = DynArr THEN DynArrParCheck(ft, ap, fp.vis # inPar)
ELSIF ODD(fp.sysflag DIV newBit) THEN
IF ~DevCPT.Extends(at, ft) THEN err(123) END
ELSIF (ft = DevCPT.sysptrtyp) & (at.form = Pointer) THEN (* ok *)
ELSIF (fp.vis # outPar) & (ft.comp = Record) & DevCPT.Extends(at, ft) THEN (* ok *)
ELSIF covarOut & (fp.vis = outPar) & (ft.form = Pointer) & DevCPT.Extends(ft, at) THEN (* ok *)
ELSIF fp.vis = inPar THEN CheckAssign(ft, ap)
ELSIF ~DevCPT.EqualType(ft, at) THEN err(123)
END
END
ELSIF ft.comp = DynArr THEN DynArrParCheck(ft, ap, FALSE)
ELSE CheckAssign(ft, ap)
END
END
END Param;
PROCEDURE StaticLink*(dlev: BYTE; var: BOOLEAN);
VAR scope: DevCPT.Object;
BEGIN
scope := DevCPT.topScope;
WHILE dlev > 0 DO DEC(dlev);
INCL(scope.link.conval.setval, slNeeded);
scope := scope.left
END;
IF var THEN INCL(scope.link.conval.setval, imVar) END (* !!! *)
END StaticLink;
PROCEDURE Call*(VAR x: DevCPT.Node; apar: DevCPT.Node; fp: DevCPT.Object);
VAR typ: DevCPT.Struct; p: DevCPT.Node; lev: BYTE;
BEGIN
IF x.class = Nproc THEN typ := x.typ;
lev := x.obj.mnolev;
IF lev > 0 THEN StaticLink(SHORT(SHORT(DevCPT.topScope.mnolev-lev)), FALSE) END ; (* !!! *)
IF x.obj.mode = IProc THEN err(121) END
ELSIF (x.class = Nfield) & (x.obj.mode = TProc) THEN typ := x.typ;
x.class := Nproc; p := x.left; x.left := NIL; p.link := apar; apar := p; fp := x.obj.link
ELSE typ := x.typ.BaseTyp
END ;
BindNodes(Ncall, typ, x, apar); x.obj := fp
END Call;
PROCEDURE Enter*(VAR procdec: DevCPT.Node; stat: DevCPT.Node; proc: DevCPT.Object);
VAR x: DevCPT.Node;
BEGIN
x := DevCPT.NewNode(Nenter); x.typ := DevCPT.notyp; x.obj := proc;
x.left := procdec; x.right := stat; procdec := x
END Enter;
PROCEDURE Return*(VAR x: DevCPT.Node; proc: DevCPT.Object);
VAR node: DevCPT.Node;
BEGIN
IF proc = NIL THEN (* return from module *)
IF x # NIL THEN err(124) END
ELSE
IF x # NIL THEN CheckAssign(proc.typ, x)
ELSIF proc.typ # DevCPT.notyp THEN err(124)
END
END ;
node := DevCPT.NewNode(Nreturn); node.typ := DevCPT.notyp; node.obj := proc; node.left := x; x := node
END Return;
PROCEDURE Assign*(VAR x: DevCPT.Node; y: DevCPT.Node);
VAR z: DevCPT.Node;
BEGIN
IF (x.class >= Nconst) OR (x.typ.form IN {String8, String16}) THEN err(56) END ;
CheckAssign(x.typ, y);
IF x.readonly THEN err(76)
ELSIF (x.obj # NIL) & ODD(x.obj.sysflag DIV newBit) THEN err(167)
END ;
MarkAsUsed(x);
IF (y.class = Nconst) & (y.typ.form IN {String8, String16}) & (x.typ.form # Pointer) THEN AssignString(x, y)
ELSE BindNodes(Nassign, DevCPT.notyp, x, y); x.subcl := assign
END
END Assign;
PROCEDURE Inittd*(VAR inittd, last: DevCPT.Node; typ: DevCPT.Struct);
VAR node: DevCPT.Node;
BEGIN
node := DevCPT.NewNode(Ninittd); node.typ := typ;
node.conval := DevCPT.NewConst(); node.conval.intval := typ.txtpos;
IF inittd = NIL THEN inittd := node ELSE last.link := node END ;
last := node
END Inittd;
(* handling of temporary variables for string operations *)
PROCEDURE Overlap (left, right: DevCPT.Node): BOOLEAN;
BEGIN
IF right.class = Nconst THEN
RETURN FALSE
ELSIF (right.class = Ndop) & (right.subcl = plus) THEN
RETURN Overlap(left, right.left) OR Overlap(left, right.right)
ELSE
WHILE right.class = Nmop DO right := right.left END;
IF right.class = Nderef THEN right := right.left END;
IF left.typ.BaseTyp # right.typ.BaseTyp THEN RETURN FALSE END;
LOOP
IF left.class = Nvarpar THEN
WHILE (right.class = Nindex) OR (right.class = Nfield) OR (right.class = Nguard) DO
right := right.left
END;
RETURN (right.class # Nvar) OR (right.obj.mnolev < left.obj.mnolev)
ELSIF right.class = Nvarpar THEN
WHILE (left.class = Nindex) OR (left.class = Nfield) OR (left.class = Nguard) DO left := left.left END;
RETURN (left.class # Nvar) OR (left.obj.mnolev < right.obj.mnolev)
ELSIF (left.class = Nvar) & (right.class = Nvar) THEN
RETURN left.obj = right.obj
ELSIF (left.class = Nderef) & (right.class = Nderef) THEN
RETURN TRUE
ELSIF (left.class = Nindex) & (right.class = Nindex) THEN
IF (left.right.class = Nconst) & (right.right.class = Nconst)
& (left.right.conval.intval # right.right.conval.intval) THEN RETURN FALSE END;
left := left.left; right := right.left
ELSIF (left.class = Nfield) & (right.class = Nfield) THEN
IF left.obj # right.obj THEN RETURN FALSE END;
left := left.left; right := right.left;
WHILE left.class = Nguard DO left := left.left END;
WHILE right.class = Nguard DO right := right.left END
ELSE
RETURN FALSE
END
END
END
END Overlap;
PROCEDURE GetStaticLength (n: DevCPT.Node; OUT length: INTEGER);
VAR x: INTEGER;
BEGIN
IF n.class = Nconst THEN
length := n.conval.intval2 - 1
ELSIF (n.class = Ndop) & (n.subcl = plus) THEN
GetStaticLength(n.left, length); GetStaticLength(n.right, x);
IF (length >= 0) & (x >= 0) THEN length := length + x ELSE length := -1 END
ELSE
WHILE (n.class = Nmop) & (n.subcl = conv) DO n := n.left END;
IF (n.class = Nderef) & (n.subcl = 1) THEN n := n.left END;
IF n.typ.comp = Array THEN
length := n.typ.n - 1
ELSIF n.typ.comp = DynArr THEN
length := -1
ELSE (* error case *)
length := 4
END
END
END GetStaticLength;
PROCEDURE GetMaxLength (n: DevCPT.Node; VAR stat, last: DevCPT.Node; OUT length: DevCPT.Node);
VAR x: DevCPT.Node; d: INTEGER; obj: DevCPT.Object;
BEGIN
IF n.class = Nconst THEN
length := NewIntConst(n.conval.intval2 - 1)
ELSIF (n.class = Ndop) & (n.subcl = plus) THEN
GetMaxLength(n.left, stat, last, length); GetMaxLength(n.right, stat, last, x);
IF (length.class = Nconst) & (x.class = Nconst) THEN ConstOp(plus, length, x)
ELSE BindNodes(Ndop, length.typ, length, x); length.subcl := plus
END
ELSE
WHILE (n.class = Nmop) & (n.subcl = conv) DO n := n.left END;
IF (n.class = Nderef) & (n.subcl = 1) THEN n := n.left END;
IF n.typ.comp = Array THEN
length := NewIntConst(n.typ.n - 1)
ELSIF n.typ.comp = DynArr THEN
d := 0;
WHILE n.class = Nindex DO n := n.left; INC(d) END;
ASSERT((n.class = Nderef) OR (n.class = Nvar) OR (n.class = Nvarpar));
IF (n.class = Nderef) & (n.left.class # Nvar) & (n.left.class # Nvarpar) THEN
GetTempVar("@tmp", n.left.typ, obj);
x := NewLeaf(obj); Assign(x, n.left); Link(stat, last, x);
n.left := NewLeaf(obj); (* tree is manipulated here *)
n := NewLeaf(obj); DeRef(n)
END;
IF n.typ.untagged & (n.typ.comp = DynArr) & (n.typ.BaseTyp.form IN {Char8, Char16}) THEN
StrDeref(n);
BindNodes(Ndop, DevCPT.int32typ, n, NewIntConst(d)); n.subcl := len;
BindNodes(Ndop, DevCPT.int32typ, n, NewIntConst(1)); n.subcl := plus
ELSE
BindNodes(Ndop, DevCPT.int32typ, n, NewIntConst(d)); n.subcl := len;
END;
length := n
ELSE (* error case *)
length := NewIntConst(4)
END
END
END GetMaxLength;
PROCEDURE CheckBuffering* (
VAR n: DevCPT.Node; left: DevCPT.Node; par: DevCPT.Object; VAR stat, last: DevCPT.Node
);
VAR length, x: DevCPT.Node; obj: DevCPT.Object; typ: DevCPT.Struct; len, xlen: INTEGER;
BEGIN
IF (n.typ.form IN {String8, String16}) & ~(DevCPM.java IN DevCPM.options)
& ((n.class = Ndop) & (n.subcl = plus) & ((left = NIL) OR Overlap(left, n.right))
OR (n.class = Nmop) & (n.subcl = conv) & (left = NIL)
OR (par # NIL) & (par.vis = inPar) & (par.typ.comp = Array)) THEN
IF (par # NIL) & (par.typ.comp = Array) THEN
len := par.typ.n - 1
ELSE
IF left # NIL THEN GetStaticLength(left, len) ELSE len := -1 END;
GetStaticLength(n, xlen);
IF (len = -1) OR (xlen # -1) & (xlen < len) THEN len := xlen END
END;
IF len # -1 THEN
typ := DevCPT.NewStr(Comp, Array); typ.n := len + 1; typ.BaseTyp := n.typ.BaseTyp;
GetTempVar("@str", typ, obj);
x := NewLeaf(obj); Assign(x, n); Link(stat, last, x);
n := NewLeaf(obj)
ELSE
IF left # NIL THEN GetMaxLength(left, stat, last, length)
ELSE GetMaxLength(n, stat, last, length)
END;
typ := DevCPT.NewStr(Pointer, Basic);
typ.BaseTyp := DevCPT.NewStr(Comp, DynArr); typ.BaseTyp.BaseTyp := n.typ.BaseTyp;
GetTempVar("@ptr", typ, obj);
x := NewLeaf(obj); Construct(Nassign, x, length); x.subcl := newfn; Link(stat, last, x);
x := NewLeaf(obj); DeRef(x); Assign(x, n); Link(stat, last, x);
n := NewLeaf(obj); DeRef(n)
END;
StrDeref(n)
ELSIF (n.typ.form = Pointer) & (n.typ.sysflag = interface) & (left = NIL)
& ((par # NIL) OR (n.class = Ncall))
& ((n.class # Nvar) OR (n.obj.mnolev <= 0)) THEN
GetTempVar("@cip", DevCPT.punktyp, obj);
x := NewLeaf(obj); Assign(x, n); Link(stat, last, x);
n := NewLeaf(obj)
END
END CheckBuffering;
PROCEDURE CheckVarParBuffering* (VAR n: DevCPT.Node; VAR stat, last: DevCPT.Node);
VAR x: DevCPT.Node; obj: DevCPT.Object;
BEGIN
IF (n.class # Nvar) OR (n.obj.mnolev <= 0) THEN
GetTempVar("@ptr", n.typ, obj);
x := NewLeaf(obj); Assign(x, n); Link(stat, last, x);
n := NewLeaf(obj)
END
END CheckVarParBuffering;
(* case optimization *)
PROCEDURE Evaluate (n: DevCPT.Node; VAR min, max, num, dist: INTEGER; VAR head: DevCPT.Node);
VAR a: INTEGER;
BEGIN
IF n.left # NIL THEN
a := MIN(INTEGER); Evaluate(n.left, min, a, num, dist, head);
IF n.conval.intval - a > dist THEN dist := n.conval.intval - a; head := n END
ELSIF n.conval.intval < min THEN
min := n.conval.intval
END;
IF n.right # NIL THEN
a := MAX(INTEGER); Evaluate(n.right, a, max, num, dist, head);
IF a - n.conval.intval2 > dist THEN dist := a - n.conval.intval2; head := n END
ELSIF n.conval.intval2 > max THEN
max := n.conval.intval2
END;
INC(num);
IF n.conval.intval < n.conval.intval2 THEN
INC(num);
IF n.conval.intval2 - n.conval.intval > dist THEN dist := n.conval.intval2 - n.conval.intval; head := n END
END
END Evaluate;
PROCEDURE Rebuild (VAR root: DevCPT.Node; head: DevCPT.Node);
VAR n: DevCPT.Node;
BEGIN
IF root # head THEN
IF head.conval.intval2 < root.conval.intval THEN
Rebuild(root.left, head);
root.left := head.right; head.right := root; root := head
ELSE
Rebuild(root.right, head);
root.right := head.left; head.left := root; root := head
END
END
END Rebuild;
PROCEDURE OptimizeCase* (VAR n: DevCPT.Node);
VAR min, max, num, dist, limit: INTEGER; head: DevCPT.Node;
BEGIN
IF n # NIL THEN
min := MAX(INTEGER); max := MIN(INTEGER); num := 0; dist := 0; head := n;
Evaluate(n, min, max, num, dist, head);
limit := 6 * num;
IF limit < 100 THEN limit := 100 END;
IF (num > 4) & ((min > MAX(INTEGER) - limit) OR (max < min + limit)) THEN
INCL(n.conval.setval, useTable)
ELSE
IF num > 4 THEN Rebuild(n, head) END;
INCL(n.conval.setval, useTree);
OptimizeCase(n.left);
OptimizeCase(n.right)
END
END
END OptimizeCase;
(*
PROCEDURE ShowTree (n: DevCPT.Node; opts: SET);
BEGIN
IF n # NIL THEN
IF opts = {} THEN opts := n.conval.setval END;
IF useTable IN opts THEN
IF n.left # NIL THEN ShowTree(n.left, opts); DevCPM.LogW(",") END;
DevCPM.LogWNum(n.conval.intval, 1);
IF n.conval.intval2 > n.conval.intval THEN DevCPM.LogW("-"); DevCPM.LogWNum(n.conval.intval2, 1)
END;
IF n.right # NIL THEN DevCPM.LogW(","); ShowTree(n.right, opts) END
ELSIF useTree IN opts THEN
DevCPM.LogW("("); ShowTree(n.left, {}); DevCPM.LogW("|"); DevCPM.LogWNum(n.conval.intval, 1);
IF n.conval.intval2 > n.conval.intval THEN DevCPM.LogW("-"); DevCPM.LogWNum(n.conval.intval2, 1)
END;
DevCPM.LogW("|"); ShowTree(n.right, {}); DevCPM.LogW(")")
ELSE
ShowTree(n.left, opts); DevCPM.LogW(" "); DevCPM.LogWNum(n.conval.intval, 1);
IF n.conval.intval2 > n.conval.intval THEN DevCPM.LogW("-"); DevCPM.LogWNum(n.conval.intval2, 1)
END;
DevCPM.LogW(" "); ShowTree(n.right, opts)
END
END
END ShowTree;
*)
BEGIN
zero := DevCPT.NewConst(); zero.intval := 0; zero.realval := 0;
one := DevCPT.NewConst(); one.intval := 1; one.realval := 0;
two := DevCPT.NewConst(); two.intval := 2; two.realval := 0;
dummy := DevCPT.NewConst();
quot := DevCPT.NewConst()
END DevCPB.
| Dev/Mod/CPB.odc |
MODULE DevCPC486;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT SYSTEM, DevCPM, DevCPT, DevCPE, DevCPL486;
CONST
initializeAll = FALSE; (* initialize all local variable to zero *)
initializeOut = FALSE; (* initialize all OUT parameters to zero *)
initializeDyn = FALSE; (* initialize all open array OUT parameters to zero *)
initializeStr = FALSE; (* initialize rest of string value parameters to zero *)
FpuControlRegister = 33EH; (* value for fpu control register initialization *)
(* structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Real32 = 7; Real64 = 8; Set = 9; String8 = 10; NilTyp = 11; NoTyp = 12;
Pointer = 13; ProcTyp = 14; Comp = 15;
Char16 = 16; String16 = 17; Int64 = 18; Guid = 23;
VString16to8 = 29; VString8 = 30; VString16 = 31;
intSet = {Int8..Int32, Int64}; realSet = {Real32, Real64};
(* composite structure forms *)
Basic = 1; Array = 2; DynArr = 3; Record = 4;
(* item base modes (=object modes) *)
Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7; CProc = 9; IProc = 10; TProc = 13;
(* item modes for i386 *)
Ind = 14; Abs = 15; Stk = 16; Cond = 17; Reg = 18; DInd = 19;
(* symbol values and ops *)
times = 1; slash = 2; div = 3; mod = 4;
and = 5; plus = 6; minus = 7; or = 8; eql = 9;
neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14;
in = 15; is = 16; ash = 17; msk = 18; len = 19;
conv = 20; abs = 21; cap = 22; odd = 23; not = 33;
adr = 24; cc = 25; bit = 26; lsh = 27; rot = 28; val = 29;
getrfn = 26; putrfn = 27;
min = 34; max = 35; typ = 36;
(* procedure flags (conval.setval) *)
hasBody = 1; isRedef = 2; slNeeded = 3; imVar = 4; isGuarded = 30; isCallback = 31;
(* attribute flags (attr.adr, struct.attribute, proc.conval.setval) *)
newAttr = 16; absAttr = 17; limAttr = 18; empAttr = 19; extAttr = 20;
false = 0; true = 1; nil = 0;
(* registers *)
AX = 0; CX = 1; DX = 2; BX = 3; SP = 4; BP = 5; SI = 6; DI = 7; AH = 4; CH = 5; DH = 6; BH = 7;
stk = 31; mem = 30; con = 29; float = 28; high = 27; short = 26; deref = 25; wreg = {AX, BX, CX, DX, SI, DI};
(* GenShiftOp *)
ROL = 0; ROR = 8H; SHL = 20H; SHR = 28H; SAR = 38H;
(* GenBitOp *)
BT = 20H; BTS = 28H; BTR = 30H;
(* GenFDOp *)
FADD = 0; FMUL = 8H; FCOM = 10H; FCOMP = 18H; FSUB = 20H; FSUBR = 28H; FDIV = 30H; FDIVR = 38H;
(* GenFMOp *)
FABS = 1E1H; FCHS = 1E0H; FTST = 1E4H; FSTSW = 7E0H; FUCOM = 2E9H;
(* GenCode *)
SAHF = 9EH; WAIT = 9BH;
(* condition codes *)
ccB = 2; ccAE = 3; ccBE = 6; ccA = 7; (* unsigned *)
ccL = 12; ccGE = 13; ccLE = 14; ccG = 15; (* signed *)
ccE = 4; ccNE = 5; ccS = 8; ccNS = 9; ccO = 0; ccNO = 1;
ccAlways = -1; ccNever = -2; ccCall = -3;
(* sysflag *)
untagged = 1; callback = 2; noAlign = 3; union = 7;
interface = 10; ccall = -10; guarded = 10; noframe = 16;
nilBit = 1; enumBits = 8; new = 1; iid = 2;
stackArray = 120;
(* system trap numbers *)
withTrap = -1; caseTrap = -2; funcTrap = -3; typTrap = -4;
recTrap = -5; ranTrap = -6; inxTrap = -7; copyTrap = -8;
(* module visibility of objects *)
internal = 0; external = 1; externalR = 2; inPar = 3; outPar = 4;
(* pointer init limits *)
MaxPtrs = 10; MaxPush = 4;
Tag0Offset = 12;
Mth0Offset = -4;
ArrDOffs = 8;
numPreIntProc = 2;
stackAllocLimit = 2048;
VAR
imLevel*: ARRAY 64 OF BYTE;
intHandler*: DevCPT.Object;
inxchk, ovflchk, ranchk, typchk, ptrinit, hints: BOOLEAN;
WReg, BReg, AllReg: SET; FReg: INTEGER;
ptrTab: ARRAY MaxPtrs OF INTEGER;
stkAllocLbl: DevCPL486.Label;
procedureUsesFpu: BOOLEAN;
PROCEDURE Init* (opt: SET);
CONST chk = 0; achk = 1; hint = 29;
BEGIN
inxchk := chk IN opt; ovflchk := achk IN opt; ranchk := achk IN opt; typchk := chk IN opt; ptrinit := chk IN opt;
hints := hint IN opt;
stkAllocLbl := DevCPL486.NewLbl
END Init;
PROCEDURE Reversed (cond: BYTE): BYTE; (* reversed condition *)
BEGIN
IF cond = lss THEN RETURN gtr
ELSIF cond = gtr THEN RETURN lss
ELSIF cond = leq THEN RETURN geq
ELSIF cond = geq THEN RETURN leq
ELSE RETURN cond
END
END Reversed;
PROCEDURE Inverted (cc: INTEGER): INTEGER; (* inverted sense of condition code *)
BEGIN
IF ODD(cc) THEN RETURN cc-1 ELSE RETURN cc+1 END
END Inverted;
PROCEDURE setCC* (VAR x: DevCPL486.Item; rel: BYTE; reversed, signed: BOOLEAN);
BEGIN
IF reversed THEN rel := Reversed(rel) END;
CASE rel OF
false: x.offset := ccNever
| true: x.offset := ccAlways
| eql: x.offset := ccE
| neq: x.offset := ccNE
| lss: IF signed THEN x.offset := ccL ELSE x.offset := ccB END
| leq: IF signed THEN x.offset := ccLE ELSE x.offset := ccBE END
| gtr: IF signed THEN x.offset := ccG ELSE x.offset := ccA END
| geq: IF signed THEN x.offset := ccGE ELSE x.offset := ccAE END
END;
x.mode := Cond; x.form := Bool; x.reg := 0;
IF reversed THEN x.reg := 1 END;
IF signed THEN INC(x.reg, 2) END
END setCC;
PROCEDURE StackAlloc*; (* pre: len = CX bytes; post: len = CX words *)
BEGIN
DevCPL486.GenJump(ccCall, stkAllocLbl, FALSE)
END StackAlloc;
PROCEDURE^ CheckAv* (reg: INTEGER);
PROCEDURE AdjustStack (val: INTEGER);
VAR c, sp: DevCPL486.Item;
BEGIN
IF val < -stackAllocLimit THEN
CheckAv(CX);
DevCPL486.MakeConst(c, -val, Int32); DevCPL486.MakeReg(sp, CX, Int32); DevCPL486.GenMove(c, sp);
StackAlloc
ELSIF val # 0 THEN
DevCPL486.MakeConst(c, val, Int32); DevCPL486.MakeReg(sp, SP, Int32); DevCPL486.GenAdd(c, sp, FALSE)
END
END AdjustStack;
PROCEDURE DecStack (form: INTEGER);
BEGIN
IF form IN {Real64, Int64} THEN AdjustStack(-8) ELSE AdjustStack(-4) END
END DecStack;
PROCEDURE IncStack (form: INTEGER);
BEGIN
IF form IN {Real64, Int64} THEN AdjustStack(8) ELSE AdjustStack(4) END
END IncStack;
(*-----------------register handling------------------*)
PROCEDURE SetReg* (reg: SET);
BEGIN
AllReg := reg; WReg := reg; BReg := reg * {0..3} + SYSTEM.LSH(reg * {0..3}, 4); FReg := 8
END SetReg;
PROCEDURE CheckReg*;
VAR reg: SET;
BEGIN
reg := AllReg - WReg;
IF reg # {} THEN
DevCPM.err(-777); (* register not released *)
IF AX IN reg THEN DevCPM.LogWStr(" AX") END;
IF BX IN reg THEN DevCPM.LogWStr(" BX") END;
IF CX IN reg THEN DevCPM.LogWStr(" CX") END;
IF DX IN reg THEN DevCPM.LogWStr(" DX") END;
IF SI IN reg THEN DevCPM.LogWStr(" SI") END;
IF DI IN reg THEN DevCPM.LogWStr(" DI") END;
WReg := AllReg; BReg := AllReg * {0..3} + SYSTEM.LSH(AllReg * {0..3}, 4)
END;
IF FReg < 8 THEN DevCPM.err(-778); FReg := 8 (* float register not released *)
ELSIF FReg > 8 THEN DevCPM.err(-779); FReg := 8
END
END CheckReg;
PROCEDURE CheckAv* (reg: INTEGER);
BEGIN
ASSERT(reg IN WReg)
END CheckAv;
PROCEDURE GetReg (VAR x: DevCPL486.Item; f: BYTE; hint, stop: SET);
VAR n: INTEGER; s, s1: SET;
BEGIN
CASE f OF
| Byte, Bool, Char8, Int8:
s := BReg * {0..3} - stop;
IF (high IN stop) OR (high IN hint) & (s - hint # {}) THEN n := 0;
IF s = {} THEN DevCPM.err(215); WReg := wreg; BReg := {0..7}; s := {0..7} END;
IF s - hint # {} THEN s := s - hint END;
WHILE ~(n IN s) DO INC(n) END
ELSE
s := BReg - (stop * {0..3}) - SYSTEM.LSH(stop * {0..3}, 4); n := 0;
IF s = {} THEN DevCPM.err(215); WReg := wreg; BReg := {0..7}; s := {0..7} END;
s1 := s - (hint * {0..3}) - SYSTEM.LSH(hint * {0..3}, 4);
IF s1 # {} THEN s := s1 END;
WHILE ~(n IN s) & ~(n + 4 IN s) DO INC(n) END;
IF ~(n IN s) THEN n := n + 4 END
END;
EXCL(BReg, n); EXCL(WReg, n MOD 4)
| Int16, Int32, Set, String8, NilTyp, Pointer, ProcTyp, Comp, Char16, String16:
s := WReg - stop;
IF high IN stop THEN s := s * {0..3} END;
IF s = {} THEN DevCPM.err(215); WReg := wreg; BReg := {0..7}; s := wreg END;
s1 := s - hint;
IF high IN hint THEN s1 := s1 * {0..3} END;
IF s1 # {} THEN s := s1 END;
IF 0 IN s THEN n := 0
ELSIF 2 IN s THEN n := 2
ELSIF 6 IN s THEN n := 6
ELSIF 7 IN s THEN n := 7
ELSIF 1 IN s THEN n := 1
ELSE n := 3
END;
EXCL(WReg, n);
IF n < 4 THEN EXCL(BReg, n); EXCL(BReg, n + 4) END
| Real32, Real64:
IF (FReg = 0) OR (float IN stop) THEN DevCPM.err(216); FReg := 99 END;
DEC(FReg); n := 0
END;
DevCPL486.MakeReg(x, n, f);
END GetReg;
PROCEDURE FreeReg (n, f: INTEGER);
BEGIN
IF f <= Int8 THEN
INCL(BReg, n);
IF (n + 4) MOD 8 IN BReg THEN INCL(WReg, n MOD 4) END
ELSIF f IN realSet THEN
INC(FReg)
ELSIF n IN AllReg THEN
INCL(WReg, n);
IF n < 4 THEN INCL(BReg, n); INCL(BReg, n + 4) END
END
END FreeReg;
PROCEDURE FreeWReg (n: INTEGER);
BEGIN
IF n IN AllReg THEN
INCL(WReg, n);
IF n < 4 THEN INCL(BReg, n); INCL(BReg, n + 4) END
END
END FreeWReg;
PROCEDURE Free* (VAR x: DevCPL486.Item);
BEGIN
CASE x.mode OF
| Var, VarPar, Abs: IF x.scale # 0 THEN FreeWReg(x.index) END
| Ind: FreeWReg(x.reg);
IF x.scale # 0 THEN FreeWReg(x.index) END
| Reg: FreeReg(x.reg, x.form);
IF x.form = Int64 THEN FreeWReg(x.index) END
ELSE
END
END Free;
PROCEDURE FreeHi (VAR x: DevCPL486.Item); (* free hi byte of word reg *)
BEGIN
IF x.mode = Reg THEN
IF x.form = Int64 THEN FreeWReg(x.index)
ELSIF x.reg < 4 THEN INCL(BReg, x.reg + 4)
END
END
END FreeHi;
PROCEDURE Fits* (VAR x: DevCPL486.Item; stop: SET): BOOLEAN; (* x.mode = Reg *)
BEGIN
IF (short IN stop) & (x.form <= Int8) THEN RETURN FALSE END;
IF x.form <= Int8 THEN RETURN ~(x.reg MOD 4 IN stop) & ((x.reg < 4) OR ~(high IN stop))
ELSIF x.form IN realSet THEN RETURN ~(float IN stop)
ELSIF x.form = Int64 THEN RETURN ~(x.reg IN stop) & ~(x.index IN stop)
ELSE RETURN ~(x.reg IN stop) & ((x.reg < 4) OR ~(high IN stop))
END
END Fits;
PROCEDURE Pop* (VAR r: DevCPL486.Item; f: BYTE; hint, stop: SET);
VAR rh: DevCPL486.Item;
BEGIN
IF f = Int64 THEN
GetReg(r, Int32, hint, stop); DevCPL486.GenPop(r);
GetReg(rh, Int32, hint, stop); DevCPL486.GenPop(rh);
r.form := Int64; r.index := rh.reg
ELSE
IF f < Int16 THEN INCL(stop, high) END;
GetReg(r, f, hint, stop); DevCPL486.GenPop(r)
END
END Pop;
PROCEDURE^ LoadLong (VAR x: DevCPL486.Item; hint, stop: SET);
PROCEDURE Load* (VAR x: DevCPL486.Item; hint, stop: SET); (* = Assert(x, hint, stop + {mem, stk}) *)
VAR r: DevCPL486.Item; f: BYTE;
BEGIN
f := x.typ.form;
IF x.mode = Con THEN
IF (short IN stop) & (x.form IN {Int8, Int16, Bool, Char8, Char16}) THEN f := Int32; x.form := Int32 END;
IF con IN stop THEN
IF f = Int64 THEN LoadLong(x, hint, stop)
ELSE
GetReg(r, f, hint, stop); DevCPL486.GenMove(x, r);
x.mode := Reg; x.reg := r.reg; x.form := f
END
END
ELSIF x.mode = Stk THEN
IF f IN realSet THEN
GetReg(r, f, hint, stop); DevCPL486.GenFLoad(x); IncStack(x.form)
ELSE
Pop(r, f, hint, stop)
END;
x.mode := Reg; x.reg := r.reg; x.index := r.index; x.form := f
ELSIF (short IN stop) & (x.form IN {Int8, Int16, Bool, Char8, Char16}) THEN
Free(x); GetReg(r, Int32, hint, stop); DevCPL486.GenExtMove(x, r);
x.mode := Reg; x.reg := r.reg; x.form := Int32
ELSIF (x.mode # Reg) OR ~Fits(x, stop) THEN
IF f = Int64 THEN LoadLong(x, hint, stop)
ELSE
Free(x); GetReg(r, f, hint, stop);
IF f IN realSet THEN DevCPL486.GenFLoad(x) ELSE DevCPL486.GenMove(x, r) END;
x.mode := Reg; x.reg := r.reg; x.form := f
END
END
END Load;
PROCEDURE Push* (VAR x: DevCPL486.Item);
VAR y: DevCPL486.Item;
BEGIN
IF x.form IN realSet THEN
Load(x, {}, {}); DecStack(x.form);
Free(x); x.mode := Stk;
IF x.typ = DevCPT.intrealtyp THEN x.form := Int64 END;
DevCPL486.GenFStore(x, TRUE)
ELSIF x.form = Int64 THEN
Free(x); x.form := Int32; y := x;
IF x.mode = Reg THEN y.reg := x.index ELSE INC(y.offset, 4) END;
DevCPL486.GenPush(y); DevCPL486.GenPush(x);
x.mode := Stk; x.form := Int64
ELSE
IF x.form < Int16 THEN Load(x, {}, {high})
ELSIF x.form = Int16 THEN Load(x, {}, {})
END;
Free(x); DevCPL486.GenPush(x); x.mode := Stk
END
END Push;
PROCEDURE Assert* (VAR x: DevCPL486.Item; hint, stop: SET);
VAR r: DevCPL486.Item;
BEGIN
IF (short IN stop) & (x.form IN {Int8, Int16, Bool, Char8, Char16}) & (x.mode # Con) THEN
IF (wreg - stop = {}) & ~(stk IN stop) THEN Load(x, {}, {short}); Push(x)
ELSE Load(x, hint, stop);
END
ELSE
CASE x.mode OF
| Var, VarPar: IF ~(mem IN stop) THEN RETURN END
| Con: IF ~(con IN stop) THEN RETURN END
| Ind: IF ~(mem IN stop) & ~(x.reg IN stop) & ((x.scale = 0) OR ~(x.index IN stop)) THEN RETURN END
| Abs: IF ~(mem IN stop) & ((x.scale = 0) OR ~(x.index IN stop)) THEN RETURN END
| Stk: IF ~(stk IN stop) THEN RETURN END
| Reg: IF Fits(x, stop) THEN RETURN END
ELSE RETURN
END;
IF ((float IN stop) OR ~(x.typ.form IN realSet) & (wreg - stop = {})) & ~(stk IN stop) THEN Push(x)
ELSE Load(x, hint, stop)
END
END
END Assert;
(*------------------------------------------------*)
PROCEDURE LoadR (VAR x: DevCPL486.Item);
BEGIN
IF x.mode # Reg THEN
Free(x); DevCPL486.GenFLoad(x);
IF x.mode = Stk THEN IncStack(x.form) END;
GetReg(x, Real32, {}, {})
END
END LoadR;
PROCEDURE PushR (VAR x: DevCPL486.Item);
BEGIN
IF x.mode # Reg THEN LoadR(x) END;
DecStack(x.form);
Free(x); x.mode := Stk; DevCPL486.GenFStore(x, TRUE)
END PushR;
PROCEDURE LoadW (VAR x: DevCPL486.Item; hint, stop: SET);
VAR r: DevCPL486.Item;
BEGIN
IF x.mode = Stk THEN
Pop(x, x.form, hint, stop)
ELSE
Free(x); GetReg(r, x.form, hint, stop);
DevCPL486.GenMove(x, r);
x.mode := Reg; x.reg := r.reg
END
END LoadW;
PROCEDURE LoadL (VAR x: DevCPL486.Item; hint, stop: SET);
VAR r: DevCPL486.Item;
BEGIN
IF x.mode = Stk THEN
Pop(x, x.form, hint, stop);
IF (x.form < Int32) OR (x.form = Char16) THEN
r := x; x.form := Int32; DevCPL486.GenExtMove(r, x)
END
ELSE
Free(x);
IF (x.form < Int32) OR (x.form = Char16) THEN GetReg(r, Int32, hint, stop) ELSE GetReg(r, x.form, hint, stop) END;
IF x.mode = Con THEN x.form := r.form END;
IF x.form # r.form THEN DevCPL486.GenExtMove(x, r) ELSE DevCPL486.GenMove(x, r) END;
x.mode := Reg; x.reg := r.reg; x.form := r.form
END
END LoadL;
PROCEDURE LoadLong (VAR x: DevCPL486.Item; hint, stop: SET);
VAR r, rh, c: DevCPL486.Item; offs: INTEGER;
BEGIN
IF x.form = Int64 THEN
IF x.mode = Stk THEN
Pop(x, x.form, hint, stop)
ELSIF x.mode = Reg THEN
FreeReg(x.reg, Int32); GetReg(r, Int32, hint, stop);
FreeReg(x.index, Int32); GetReg(rh, Int32, hint, stop);
x.form := Int32; DevCPL486.GenMove(x, r);
x.reg := x.index; DevCPL486.GenMove(x, rh);
x.reg := r.reg; x.index := rh.reg
ELSE
GetReg(rh, Int32, hint, stop + {AX});
Free(x);
GetReg(r, Int32, hint, stop);
x.form := Int32; offs := x.offset;
IF x.mode = Con THEN x.offset := x.scale ELSE INC(x.offset, 4) END;
DevCPL486.GenMove(x, rh);
x.offset := offs;
DevCPL486.GenMove(x, r);
x.mode := Reg; x.reg := r.reg; x.index := rh.reg
END
ELSE
LoadL(x, hint, stop); GetReg(rh, Int32, hint, stop); DevCPL486.GenSignExt(x, rh);
x.index := rh.reg
END;
x.form := Int64
END LoadLong;
(*------------------------------------------------*)
PROCEDURE CopyReg* (VAR x, y: DevCPL486.Item; hint, stop: SET);
BEGIN
ASSERT(x.mode = Reg);
GetReg(y, x.form, hint, stop);
DevCPL486.GenMove(x, y)
END CopyReg;
PROCEDURE GetAdr* (VAR x: DevCPL486.Item; hint, stop: SET);
VAR r: DevCPL486.Item;
BEGIN
IF x.mode = DInd THEN
x.mode := Ind
ELSIF (x.mode = Ind) & (x.offset = 0) & (x.scale = 0) & (x.reg IN wreg) THEN
x.mode := Reg
ELSE
Free(x); GetReg(r, Pointer, hint, stop);
IF x.mode = Con THEN DevCPL486.GenMove(x, r) ELSE DevCPL486.GenLoadAdr(x, r) END;
x.mode := Reg; x.reg := r.reg; x.form := Pointer
END;
x.form := Pointer; x.typ := DevCPT.anyptrtyp;
Assert(x, hint, stop)
END GetAdr;
PROCEDURE PushAdr (VAR x: DevCPL486.Item; niltest: BOOLEAN);
VAR r, v: DevCPL486.Item;
BEGIN
IF (x.mode = Abs) & (x.scale = 0) THEN x.mode := Con; x.form := Pointer
ELSIF niltest THEN
GetAdr(x, {}, {mem, stk});
DevCPL486.MakeReg(r, AX, Int32);
v.mode := Ind; v.form := Int32; v.offset := 0; v.scale := 0; v.reg := x.reg;
DevCPL486.GenTest(r, v)
ELSIF x.mode = DInd THEN x.mode := Ind; x.form := Pointer
ELSE GetAdr(x, {}, {})
END;
Free(x); DevCPL486.GenPush(x)
END PushAdr;
PROCEDURE LevelBase (VAR a: DevCPL486.Item; lev: INTEGER; hint, stop: SET);
VAR n: BYTE;
BEGIN
a.mode := Ind; a.scale := 0; a.form := Int32; a.typ := DevCPT.int32typ;
IF lev = DevCPL486.level THEN a.reg := BP
ELSE
a.reg := BX; n := SHORT(SHORT(imLevel[DevCPL486.level] - imLevel[lev]));
WHILE n > 0 DO
a.offset := -4; LoadL(a, hint, stop); a.mode := Ind; DEC(n)
END
END
END LevelBase;
PROCEDURE LenDesc (VAR x, len: DevCPL486.Item; typ: DevCPT.Struct); (* set len to LEN(x, -typ.n) *)
BEGIN
IF x.tmode = VarPar THEN
LevelBase(len, x.obj.mnolev, {}, {}); len.offset := x.obj.adr;
ELSE ASSERT((x.tmode = Ind) & (x.mode = Ind));
len := x; len.offset := ArrDOffs; len.scale := 0; len.form := Int32
END;
INC(len.offset, typ.n * 4 + 4);
IF typ.sysflag = stackArray THEN len.offset := -4 END
END LenDesc;
PROCEDURE Tag* (VAR x, tag: DevCPL486.Item);
VAR typ: DevCPT.Struct;
BEGIN
typ := x.typ;
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
IF (x.typ # DevCPT.sysptrtyp) & (typ.attribute = 0) & ~(DevCPM.oberon IN DevCPM.options) THEN (* final type *)
DevCPL486.MakeConst(tag, 0, Pointer); tag.obj := DevCPE.TypeObj(typ)
ELSIF x.typ.form = Pointer THEN
ASSERT(x.mode = Reg);
tag.mode := Ind; tag.reg := x.reg; tag.offset := -4;
IF x.typ.sysflag = interface THEN tag.offset := 0 END
ELSIF x.tmode = VarPar THEN
LevelBase(tag, x.obj.mnolev, {}, {}); tag.offset := x.obj.adr + 4;
Free(tag) (* ??? *)
ELSIF x.tmode = Ind THEN
ASSERT(x.mode = Ind);
tag := x; tag.offset := -4
ELSE
DevCPL486.MakeConst(tag, 0, Pointer); tag.obj := DevCPE.TypeObj(x.typ)
END;
tag.scale := 0; tag.form := Pointer; tag.typ := DevCPT.sysptrtyp
END Tag;
PROCEDURE NumOfIntProc (typ: DevCPT.Struct): INTEGER;
BEGIN
WHILE (typ # NIL) & (typ.sysflag # interface) DO typ := typ.BaseTyp END;
IF typ # NIL THEN RETURN typ.n
ELSE RETURN 0
END
END NumOfIntProc;
PROCEDURE ContainsIPtrs* (typ: DevCPT.Struct): BOOLEAN;
VAR fld: DevCPT.Object;
BEGIN
WHILE typ.comp IN {DynArr, Array} DO typ := typ.BaseTyp END;
IF (typ.form = Pointer) & (typ.sysflag = interface) THEN RETURN TRUE
ELSIF (typ.comp = Record) & (typ.sysflag # union) THEN
REPEAT
fld := typ.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
IF (fld.sysflag = interface) & (fld.name^ = DevCPM.HdUtPtrName)
OR ContainsIPtrs(fld.typ) THEN RETURN TRUE END;
fld := fld.link
END;
typ := typ.BaseTyp
UNTIL typ = NIL
END;
RETURN FALSE
END ContainsIPtrs;
PROCEDURE GuidFromString* (str: DevCPT.ConstExt; VAR x: DevCPL486.Item);
VAR cv: DevCPT.Const;
BEGIN
IF ~DevCPM.ValidGuid(str^) THEN DevCPM.err(165) END;
cv := DevCPT.NewConst();
cv.intval := DevCPM.ConstNotAlloc; cv.intval2 := 16; cv.ext := str;
DevCPL486.AllocConst(x, cv, Guid); x.typ := DevCPT.guidtyp
END GuidFromString;
PROCEDURE IPAddRef* (VAR x: DevCPL486.Item; offset: INTEGER; nilTest: BOOLEAN);
VAR r, p, c: DevCPL486.Item; lbl: DevCPL486.Label;
BEGIN
ASSERT(x.mode IN {Reg, Ind, Abs});
ASSERT({AX, CX, DX} - WReg = {});
IF hints THEN
IF nilTest THEN DevCPM.err(-701) ELSE DevCPM.err(-700) END
END;
IF x.mode # Reg THEN
GetReg(r, Pointer, {}, {});
p := x; INC(p.offset, offset); p.form := Pointer; DevCPL486.GenMove(p, r);
ELSE r := x
END;
IF nilTest THEN
DevCPL486.MakeConst(c, 0, Pointer); DevCPL486.GenComp(c, r);
lbl := DevCPL486.NewLbl; DevCPL486.GenJump(ccE, lbl, TRUE)
END;
DevCPL486.GenPush(r); p := r;
IF x.mode # Reg THEN Free(r) END;
GetReg(r, Pointer, {}, {});
p.mode := Ind; p.offset := 0; p.scale := 0; p.form := Pointer; DevCPL486.GenMove(p, r);
p.offset := 4; p.reg := r.reg; Free(r); DevCPL486.GenCall(p);
IF nilTest THEN DevCPL486.SetLabel(lbl) END;
END IPAddRef;
PROCEDURE IPRelease* (VAR x: DevCPL486.Item; offset: INTEGER; nilTest, nilSet: BOOLEAN);
VAR r, p, c: DevCPL486.Item; lbl: DevCPL486.Label;
BEGIN
ASSERT(x.mode IN {Ind, Abs});
ASSERT({AX, CX, DX} - WReg = {});
IF hints THEN
IF nilTest THEN DevCPM.err(-703) ELSE DevCPM.err(-702) END
END;
GetReg(r, Pointer, {}, {});
p := x; INC(p.offset, offset); p.form := Pointer; DevCPL486.GenMove(p, r);
DevCPL486.MakeConst(c, 0, Pointer);
IF nilTest THEN
DevCPL486.GenComp(c, r);
lbl := DevCPL486.NewLbl; DevCPL486.GenJump(ccE, lbl, TRUE)
END;
IF nilSet THEN DevCPL486.GenMove(c, p) END;
DevCPL486.GenPush(r);
p.mode := Ind; p.reg := r.reg; p.offset := 0; p.scale := 0; DevCPL486.GenMove(p, r);
p.offset := 8; Free(r); DevCPL486.GenCall(p);
IF nilTest THEN DevCPL486.SetLabel(lbl) END;
END IPRelease;
PROCEDURE Prepare* (VAR x: DevCPL486.Item; hint, stop: SET);
VAR n, i, lev: INTEGER; len, y: DevCPL486.Item; typ: DevCPT.Struct;
BEGIN
IF (x.mode IN {Var, VarPar, Ind, Abs}) & (x.scale # 0) THEN
DevCPL486.MakeReg(y, x.index, Int32); typ := x.typ;
WHILE typ.comp = DynArr DO (* complete dynamic array iterations *)
LenDesc(x, len, typ); DevCPL486.GenMul(len, y, FALSE); typ := typ.BaseTyp;
IF x.tmode = VarPar THEN Free(len) END; (* ??? *)
END;
n := x.scale; i := 0;
WHILE (n MOD 2 = 0) & (i < 3) DO n := n DIV 2; INC(i) END;
IF n > 1 THEN (* assure scale factor in {1, 2, 4, 8} *)
DevCPL486.MakeConst(len, n, Int32); DevCPL486.GenMul(len, y, FALSE); x.scale := x.scale DIV n
END
END;
CASE x.mode OF
Var, VarPar:
lev := x.obj.mnolev;
IF lev <= 0 THEN
x.mode := Abs
ELSE
LevelBase(y, lev, hint, stop);
IF x.mode # VarPar THEN
x.mode := Ind
ELSIF (deref IN hint) & (x.offset = 0) & (x.scale = 0) THEN
x.mode := DInd; x.offset := x.obj.adr
ELSE
y.offset := x.obj.adr; Load(y, hint, stop); x.mode := Ind
END;
x.reg := y.reg
END;
x.form := x.typ.form
| LProc, XProc, IProc:
x.mode := Con; x.offset := 0; x.form := ProcTyp
| TProc, CProc:
x.form := ProcTyp
| Ind, Abs, Stk, Reg:
IF ~(x.typ.form IN {String8, String16}) THEN x.form := x.typ.form END
END
END Prepare;
PROCEDURE Field* (VAR x: DevCPL486.Item; field: DevCPT.Object);
BEGIN
INC(x.offset, field.adr); x.tmode := Con
END Field;
PROCEDURE DeRef* (VAR x: DevCPL486.Item);
VAR btyp: DevCPT.Struct;
BEGIN
x.mode := Ind; x.tmode := Ind; x.scale := 0;
btyp := x.typ.BaseTyp;
IF btyp.untagged OR (btyp.sysflag = stackArray) THEN x.offset := 0
ELSIF btyp.comp = DynArr THEN x.offset := ArrDOffs + btyp.size
ELSIF btyp.comp = Array THEN x.offset := ArrDOffs + 4
ELSE x.offset := 0
END
END DeRef;
PROCEDURE Index* (VAR x, y: DevCPL486.Item; hint, stop: SET); (* x[y] *)
VAR idx, len: DevCPL486.Item; btyp: DevCPT.Struct; elsize: INTEGER;
BEGIN
btyp := x.typ.BaseTyp; elsize := btyp.size;
IF elsize = 0 THEN Free(y)
ELSIF x.typ.comp = Array THEN
len.mode := Con; len.obj := NIL;
IF y.mode = Con THEN
INC(x.offset, y.offset * elsize)
ELSE
Load(y, hint, stop + {mem, stk, short});
IF inxchk THEN
DevCPL486.MakeConst(len, x.typ.n, Int32);
DevCPL486.GenComp(len, y); DevCPL486.GenAssert(ccB, inxTrap)
END;
IF x.scale = 0 THEN x.index := y.reg
ELSE
IF x.scale MOD elsize # 0 THEN
IF (x.scale MOD 4 = 0) & (elsize MOD 4 = 0) THEN elsize := 4
ELSIF (x.scale MOD 2 = 0) & (elsize MOD 2 = 0) THEN elsize := 2
ELSE elsize := 1
END;
DevCPL486.MakeConst(len, btyp.size DIV elsize, Int32);
DevCPL486.GenMul(len, y, FALSE)
END;
DevCPL486.MakeConst(len, x.scale DIV elsize, Int32);
DevCPL486.MakeReg(idx, x.index, Int32);
DevCPL486.GenMul(len, idx, FALSE); DevCPL486.GenAdd(y, idx, FALSE); Free(y)
END;
x.scale := elsize
END;
x.tmode := Con
ELSE (* x.typ.comp = DynArr *)
IF (btyp.comp = DynArr) & x.typ.untagged THEN DevCPM.err(137) END;
LenDesc(x, len, x.typ);
IF x.scale # 0 THEN
DevCPL486.MakeReg(idx, x.index, Int32);
DevCPL486.GenMul(len, idx, FALSE)
END;
IF (y.mode # Con) OR (y.offset # 0) THEN
IF (y.mode # Con) OR (btyp.comp = DynArr) & (x.scale = 0) THEN
Load(y, hint, stop + {mem, stk, con, short})
ELSE y.form := Int32
END;
IF inxchk & ~x.typ.untagged THEN
DevCPL486.GenComp(y, len); DevCPL486.GenAssert(ccA, inxTrap)
END;
IF (y.mode = Con) & (btyp.comp # DynArr) THEN
INC(x.offset, y.offset * elsize)
ELSIF x.scale = 0 THEN
WHILE btyp.comp = DynArr DO btyp := btyp.BaseTyp END;
x.index := y.reg; x.scale := btyp.size
ELSE
DevCPL486.GenAdd(y, idx, FALSE); Free(y)
END
END;
IF x.tmode = VarPar THEN Free(len) END; (* ??? *)
IF x.typ.BaseTyp.comp # DynArr THEN x.tmode := Con END
END
END Index;
PROCEDURE TypTest* (VAR x: DevCPL486.Item; testtyp: DevCPT.Struct; guard, equal: BOOLEAN);
VAR tag, tdes, r: DevCPL486.Item; typ: DevCPT.Struct;
BEGIN
typ := x.typ;
IF typ.form = Pointer THEN testtyp := testtyp.BaseTyp; typ := typ.BaseTyp END;
IF ~guard & typ.untagged THEN DevCPM.err(139)
ELSIF ~guard OR typchk & ~typ.untagged THEN
IF testtyp.untagged THEN DevCPM.err(139)
ELSE
IF (x.typ.form = Pointer) & (x.mode # Reg) THEN
GetReg(r, Pointer, {}, {}); DevCPL486.GenMove(x, r); Free(r); r.typ := x.typ; Tag(r, tag)
ELSE Tag(x, tag)
END;
IF ~guard THEN Free(x) END;
IF ~equal THEN
GetReg(r, Pointer, {}, {}); DevCPL486.GenMove(tag, r); Free(r);
tag.mode := Ind; tag.reg := r.reg; tag.scale := 0; tag.offset := Tag0Offset + 4 * testtyp.extlev
END;
DevCPL486.MakeConst(tdes, 0, Pointer); tdes.obj := DevCPE.TypeObj(testtyp);
DevCPL486.GenComp(tdes, tag);
IF guard THEN
IF equal THEN DevCPL486.GenAssert(ccE, recTrap) ELSE DevCPL486.GenAssert(ccE, typTrap) END
ELSE setCC(x, eql, FALSE, FALSE)
END
END
END
END TypTest;
PROCEDURE ShortTypTest* (VAR x: DevCPL486.Item; testtyp: DevCPT.Struct);
VAR tag, tdes: DevCPL486.Item;
BEGIN
(* tag must be in AX ! *)
IF testtyp.form = Pointer THEN testtyp := testtyp.BaseTyp END;
IF testtyp.untagged THEN DevCPM.err(139)
ELSE
tag.mode := Ind; tag.reg := AX; tag.scale := 0; tag.offset := Tag0Offset + 4 * testtyp.extlev; tag.form := Pointer;
DevCPL486.MakeConst(tdes, 0, Pointer); tdes.obj := DevCPE.TypeObj(testtyp);
DevCPL486.GenComp(tdes, tag);
setCC(x, eql, FALSE, FALSE)
END
END ShortTypTest;
PROCEDURE Check (VAR x: DevCPL486.Item; min, max: INTEGER);
VAR c: DevCPL486.Item;
BEGIN
ASSERT((x.mode # Reg) OR (max > 255) OR (max = 31) OR (x.reg < 4));
IF ranchk & (x.mode # Con) THEN
DevCPL486.MakeConst(c, max, x.form); DevCPL486.GenComp(c, x);
IF min # 0 THEN
DevCPL486.GenAssert(ccLE, ranTrap);
c.offset := min; DevCPL486.GenComp(c, x);
DevCPL486.GenAssert(ccGE, ranTrap)
ELSIF max # 0 THEN
DevCPL486.GenAssert(ccBE, ranTrap)
ELSE
DevCPL486.GenAssert(ccNS, ranTrap)
END
END
END Check;
PROCEDURE Floor (VAR x: DevCPL486.Item; useSt1: BOOLEAN);
VAR c: DevCPL486.Item; local: DevCPL486.Label;
BEGIN
IF useSt1 THEN DevCPL486.GenFMOp(5D1H); (* FST ST1 *)
ELSE DevCPL486.GenFMOp(1C0H); (* FLD ST0 *)
END;
DevCPL486.GenFMOp(1FCH); (* FRNDINT *)
DevCPL486.GenFMOp(0D1H); (* FCOM *)
CheckAv(AX);
DevCPL486.GenFMOp(FSTSW);
DevCPL486.GenFMOp(5D9H); (* FSTP ST1 *)
(* DevCPL486.GenCode(WAIT); *) DevCPL486.GenCode(SAHF);
local := DevCPL486.NewLbl; DevCPL486.GenJump(ccBE, local, TRUE);
DevCPL486.AllocConst(c, DevCPL486.one, Real32);
DevCPL486.GenFDOp(FSUB, c);
DevCPL486.SetLabel(local);
END Floor;
PROCEDURE Entier(VAR x: DevCPL486.Item; typ: DevCPT.Struct; hint, stop: SET);
BEGIN
IF typ # DevCPT.intrealtyp THEN Floor(x, FALSE) END;
DevCPL486.GenFStore(x, TRUE);
IF (x.mode = Stk) & (stk IN stop) THEN Pop(x, x.form, hint, stop) END
END Entier;
PROCEDURE ConvMove (VAR x, y: DevCPL486.Item; sysval: BOOLEAN; hint, stop: SET); (* x := y *)
(* scalar values only, y.mode # Con, all kinds of conversions, x.mode = Undef => convert y only *)
VAR f, m: BYTE; s: INTEGER; z: DevCPL486.Item;
BEGIN
f := x.form; m := x.mode; ASSERT(m IN {Undef, Reg, Abs, Ind, Stk});
IF y.form IN {Real32, Real64} THEN
IF f IN {Real32, Real64} THEN
IF m = Undef THEN
IF (y.form = Real64) & (f = Real32) THEN
IF y.mode # Reg THEN LoadR(y) END;
Free(y); DecStack(Real32); y.mode := Stk; y.form := Real32; DevCPL486.GenFStore(y, TRUE)
END
ELSE
IF y.mode # Reg THEN LoadR(y) END;
IF m = Stk THEN DecStack(f) END;
IF m # Reg THEN Free(y); DevCPL486.GenFStore(x, TRUE) END;
END
ELSE (* x not real *)
IF sysval THEN
IF y.mode = Reg THEN Free(y);
IF (m # Stk) & (m # Undef) & (m # Reg) & (f >= Int32) THEN
x.form := y.form; DevCPL486.GenFStore(x, TRUE); x.form := f
ELSE
ASSERT(y.form # Real64);
DecStack(y.form); y.mode := Stk; DevCPL486.GenFStore(y, TRUE); y.form := Int32;
IF m # Stk THEN
Pop(y, y.form, hint, stop);
IF f < Int16 THEN ASSERT(y.reg < 4) END;
y.form := f;
IF m # Undef THEN Free(y); DevCPL486.GenMove(y, x) END
END
END
ELSE (* y.mode # Reg *)
y.form := f;
IF m # Undef THEN LoadW(y, hint, stop); Free(y);
IF m = Stk THEN DevCPL486.GenPush(y) ELSE DevCPL486.GenMove(y, x) END
END
END
ELSE (* not sysval *)
IF y.mode # Reg THEN LoadR(y) END;
Free(y);
IF (m # Stk) & (m # Undef) & (m # Reg) & (f >= Int16) & (f # Char16) THEN
Entier(x, y.typ, hint, stop);
ELSE
DecStack(f); y.mode := Stk;
IF (f < Int16) OR (f = Char16) THEN y.form := Int32 ELSE y.form := f END;
IF m = Stk THEN Entier(y, y.typ, {}, {})
ELSIF m = Undef THEN Entier(y, y.typ, hint, stop)
ELSE Entier(y, y.typ, hint, stop + {stk})
END;
IF f = Int8 THEN Check(y, -128, 127); FreeHi(y)
ELSIF f = Char8 THEN Check(y, 0, 255); FreeHi(y)
ELSIF f = Char16 THEN Check(y, 0, 65536); FreeHi(y)
END;
y.form := f;
IF (m # Undef) & (m # Stk) THEN
IF f = Int64 THEN
Free(y); y.form := Int32; z := x; z.form := Int32; DevCPL486.GenMove(y, z);
IF z.mode = Reg THEN z.reg := z.index ELSE INC(z.offset, 4) END;
y.reg := y.index; DevCPL486.GenMove(y, z);
ELSE
Free(y); DevCPL486.GenMove(y, x);
END
END
END
END
END
ELSE (* y not real *)
IF sysval THEN
IF (y.form < Int16) & (f >= Int16) OR (y.form IN {Int16, Char16}) & (f >= Int32) & (f < Char16) THEN LoadL(y, hint, stop) END;
IF (y.form >= Int16) & (f < Int16) THEN FreeHi(y) END
ELSE
CASE y.form OF
| Byte, Bool:
IF f = Int64 THEN LoadLong(y, hint, stop)
ELSIF f >= Int16 THEN LoadL(y, hint, stop)
END
| Char8:
IF f = Int8 THEN Check(y, 0, 0)
ELSIF f = Int64 THEN LoadLong(y, hint, stop)
ELSIF f >= Int16 THEN LoadL(y, hint, stop)
END
| Char16:
IF f = Char8 THEN Check(y, 0, 255); FreeHi(y)
ELSIF f = Int8 THEN Check(y, -128, 127); FreeHi(y)
ELSIF f = Int16 THEN Check(y, 0, 0)
ELSIF f = Char16 THEN (* ok *)
ELSIF f = Int64 THEN LoadLong(y, hint, stop)
ELSIF f >= Int32 THEN LoadL(y, hint, stop)
END
| Int8:
IF f = Char8 THEN Check(y, 0, 0)
ELSIF f = Int64 THEN LoadLong(y, hint, stop)
ELSIF f >= Int16 THEN LoadL(y, hint, stop)
END
| Int16:
IF f = Char8 THEN Check(y, 0, 255); FreeHi(y)
ELSIF f = Char16 THEN Check(y, 0, 0)
ELSIF f = Int8 THEN Check(y, -128, 127); FreeHi(y)
ELSIF f = Int64 THEN LoadLong(y, hint, stop)
ELSIF (f = Int32) OR (f = Set) THEN LoadL(y, hint, stop)
END
| Int32, Set, Pointer, ProcTyp:
IF f = Char8 THEN Check(y, 0, 255); FreeHi(y)
ELSIF f = Char16 THEN Check(y, 0, 65536)
ELSIF f = Int8 THEN Check(y, -128, 127); FreeHi(y)
ELSIF f = Int16 THEN Check(y, -32768, 32767)
ELSIF f = Int64 THEN LoadLong(y, hint, stop)
END
| Int64:
IF f IN {Bool..Int32, Char16} THEN
(* make range checks !!! *)
FreeHi(y)
END
END
END;
IF f IN {Real32, Real64} THEN
IF sysval THEN
IF (m # Undef) & (m # Reg) THEN
IF y.mode # Reg THEN LoadW(y, hint, stop) END;
Free(y);
IF m = Stk THEN DevCPL486.GenPush(y)
ELSE x.form := Int32; DevCPL486.GenMove(y, x); x.form := f
END
ELSE
IF y.mode = Reg THEN Push(y) END;
y.form := f;
IF m = Reg THEN LoadR(y) END
END
ELSE (* not sysval *) (* int -> float *)
IF y.mode = Reg THEN Push(y) END;
IF m = Stk THEN
Free(y); DevCPL486.GenFLoad(y); s := -4;
IF f = Real64 THEN DEC(s, 4) END;
IF y.mode = Stk THEN
IF y.form = Int64 THEN INC(s, 8) ELSE INC(s, 4) END
END;
IF s # 0 THEN AdjustStack(s) END;
GetReg(y, Real32, {}, {});
Free(y); DevCPL486.GenFStore(x, TRUE)
ELSIF m = Reg THEN
LoadR(y)
ELSIF m # Undef THEN
LoadR(y); Free(y); DevCPL486.GenFStore(x, TRUE)
END
END
ELSE
y.form := f;
IF m = Stk THEN
IF ((f < Int32) OR (f = Char16)) & (y.mode # Reg) THEN LoadW(y, hint, stop) END;
Push(y)
ELSIF m # Undef THEN
IF f = Int64 THEN
IF y.mode # Reg THEN LoadLong(y, hint, stop) END;
Free(y); y.form := Int32; z := x; z.form := Int32; DevCPL486.GenMove(y, z);
IF z.mode = Reg THEN ASSERT(z.reg # y.index); z.reg := z.index ELSE INC(z.offset, 4) END;
y.reg := y.index; DevCPL486.GenMove(y, z);
ELSE
IF y.mode # Reg THEN LoadW(y, hint, stop) END;
Free(y); DevCPL486.GenMove(y, x)
END
END
END
END
END ConvMove;
PROCEDURE Convert* (VAR x: DevCPL486.Item; f: BYTE; size: INTEGER; hint, stop: SET); (* size >= 0: sysval *)
VAR y: DevCPL486.Item;
BEGIN
ASSERT(x.mode # Con);
IF (size >= 0)
& ((size # x.typ.size) & ((size > 4) OR (x.typ.size > 4))
OR (f IN {Comp, Real64, Int64}) & (x.mode IN {Reg, Stk})) THEN DevCPM.err(220) END;
(*
IF sysval & ((x.form = Real64) & ~(f IN {Comp, Int64}) OR (f = Real64) & ~(x.form IN {Comp, Int64})) THEN DevCPM.err(220) END;
*)
y.mode := Undef; y.form := f; ConvMove(y, x, size >= 0, hint, stop)
END Convert;
PROCEDURE LoadCond* (VAR x, y: DevCPL486.Item; F, T: DevCPL486.Label; hint, stop: SET);
VAR end, T1: DevCPL486.Label; c, r: DevCPL486.Item;
BEGIN
IF mem IN stop THEN GetReg(x, Bool, hint, stop) END;
IF (F = DevCPL486.NewLbl) & (T = DevCPL486.NewLbl) THEN (* no label used *)
DevCPL486.GenSetCC(y.offset, x)
ELSE
end := DevCPL486.NewLbl; T1 := DevCPL486.NewLbl;
DevCPL486.GenJump(y.offset, T1, TRUE); (* T1 to enable short jump *)
DevCPL486.SetLabel(F);
DevCPL486.MakeConst(c, 0, Bool); DevCPL486.GenMove(c, x);
DevCPL486.GenJump(ccAlways, end, TRUE);
DevCPL486.SetLabel(T); DevCPL486.SetLabel(T1);
DevCPL486.MakeConst(c, 1, Bool); DevCPL486.GenMove(c, x);
DevCPL486.SetLabel(end)
END;
IF x.mode # Reg THEN Free(x) END
END LoadCond;
PROCEDURE IntDOp* (VAR x, y: DevCPL486.Item; subcl: BYTE; rev: BOOLEAN);
VAR local: DevCPL486.Label;
BEGIN
ASSERT((x.mode = Reg) OR (y.mode = Reg) OR (y.mode = Con));
CASE subcl OF
| eql..geq:
DevCPL486.GenComp(y, x); Free(x);
setCC(x, subcl, rev, x.typ.form IN {Int8..Int32})
| times:
IF x.form = Set THEN DevCPL486.GenAnd(y, x) ELSE DevCPL486.GenMul(y, x, ovflchk) END
| slash:
DevCPL486.GenXor(y, x)
| plus:
IF x.form = Set THEN DevCPL486.GenOr(y, x) ELSE DevCPL486.GenAdd(y, x, ovflchk) END
| minus, msk:
IF (x.form = Set) OR (subcl = msk) THEN (* and not *)
IF rev THEN DevCPL486.GenNot(x); DevCPL486.GenAnd(y, x) (* y and not x *)
ELSIF y.mode = Con THEN y.offset := -1 - y.offset; DevCPL486.GenAnd(y, x) (* x and y' *)
ELSIF y.mode = Reg THEN DevCPL486.GenNot(y); DevCPL486.GenAnd(y, x) (* x and not y *)
ELSE DevCPL486.GenNot(x); DevCPL486.GenOr(y, x); DevCPL486.GenNot(x) (* not (not x or y) *)
END
ELSE (* minus *)
IF rev THEN (* y - x *)
IF (y.mode = Con) & (y.offset = -1) THEN DevCPL486.GenNot(x)
ELSE DevCPL486.GenNeg(x, ovflchk); DevCPL486.GenAdd(y, x, ovflchk) (* ??? *)
END
ELSE (* x - y *)
DevCPL486.GenSub(y, x, ovflchk)
END
END
| min, max:
local := DevCPL486.NewLbl;
DevCPL486.GenComp(y, x);
IF subcl = min THEN
IF x.typ.form IN {Char8, Char16} THEN DevCPL486.GenJump(ccBE, local, TRUE)
ELSE DevCPL486.GenJump(ccLE, local, TRUE)
END
ELSE
IF x.typ.form IN {Char8, Char16} THEN DevCPL486.GenJump(ccAE, local, TRUE)
ELSE DevCPL486.GenJump(ccGE, local, TRUE)
END
END;
DevCPL486.GenMove(y, x);
DevCPL486.SetLabel(local)
END;
Free(y);
IF x.mode # Reg THEN Free(x) END
END IntDOp;
PROCEDURE LargeInc* (VAR x, y: DevCPL486.Item; dec: BOOLEAN); (* INC(x, y) or DEC(x, y) *)
BEGIN
ASSERT(x.form = Int64);
IF ~(y.mode IN {Reg, Con}) THEN LoadLong(y, {}, {}) END;
Free(x); Free(y); x.form := Int32; y.form := Int32;
IF dec THEN DevCPL486.GenSubC(y, x, TRUE, FALSE) ELSE DevCPL486.GenAddC(y, x, TRUE, FALSE) END;
INC(x.offset, 4);
IF y.mode = Reg THEN y.reg := y.index ELSE y.offset := y.scale END;
IF dec THEN DevCPL486.GenSubC(y, x, FALSE, ovflchk) ELSE DevCPL486.GenAddC(y, x, FALSE, ovflchk) END;
END LargeInc;
PROCEDURE FloatDOp* (VAR x, y: DevCPL486.Item; subcl: BYTE; rev: BOOLEAN);
VAR local: DevCPL486.Label; a, b: DevCPL486.Item;
BEGIN
ASSERT(x.mode = Reg);
IF y.form = Int64 THEN LoadR(y) END;
IF y.mode = Reg THEN rev := ~rev END;
CASE subcl OF
| eql..geq: DevCPL486.GenFDOp(FCOMP, y)
| times: DevCPL486.GenFDOp(FMUL, y)
| slash: IF rev THEN DevCPL486.GenFDOp(FDIVR, y) ELSE DevCPL486.GenFDOp(FDIV, y) END
| plus: DevCPL486.GenFDOp(FADD, y)
| minus: IF rev THEN DevCPL486.GenFDOp(FSUBR, y) ELSE DevCPL486.GenFDOp(FSUB, y) END
| min, max:
IF y.mode = Reg THEN
DevCPL486.GenFMOp(0D1H); (* FCOM ST1 *)
CheckAv(AX); DevCPL486.GenFMOp(FSTSW); (* DevCPL486.GenCode(WAIT); *) DevCPL486.GenCode(SAHF);
local := DevCPL486.NewLbl;
IF subcl = min THEN DevCPL486.GenJump(ccAE, local, TRUE) ELSE DevCPL486.GenJump(ccBE, local, TRUE) END;
DevCPL486.GenFMOp(5D1H); (* FST ST1 *)
DevCPL486.SetLabel(local);
DevCPL486.GenFMOp(5D8H) (* FSTP ST0 *)
ELSE
DevCPL486.GenFDOp(FCOM, y);
CheckAv(AX); DevCPL486.GenFMOp(FSTSW); (* DevCPL486.GenCode(WAIT); *) DevCPL486.GenCode(SAHF);
local := DevCPL486.NewLbl;
IF subcl = min THEN DevCPL486.GenJump(ccBE, local, TRUE) ELSE DevCPL486.GenJump(ccAE, local, TRUE) END;
DevCPL486.GenFMOp(5D8H); (* FSTP ST0 *)
DevCPL486.GenFLoad(y);
DevCPL486.SetLabel(local)
END
(* largeint support *)
| div:
IF rev THEN DevCPL486.GenFDOp(FDIVR, y) ELSE DevCPL486.GenFDOp(FDIV, y) END;
Floor(y, FALSE)
| mod:
IF y.mode # Reg THEN LoadR(y); rev := ~rev END;
IF rev THEN DevCPL486.GenFMOp(1C9H); (* FXCH ST1 *) END;
DevCPL486.GenFMOp(1F8H); (* FPREM *)
DevCPL486.GenFMOp(1E4H); (* FTST *)
CheckAv(AX);
DevCPL486.GenFMOp(FSTSW);
DevCPL486.MakeReg(a, AX, Int32); GetReg(b, Int32, {}, {AX});
DevCPL486.GenMove(a, b);
DevCPL486.GenFMOp(0D1H); (* FCOM *)
DevCPL486.GenFMOp(FSTSW);
DevCPL486.GenXor(b, a); Free(b);
(* DevCPL486.GenCode(WAIT); *) DevCPL486.GenCode(SAHF);
local := DevCPL486.NewLbl; DevCPL486.GenJump(ccBE, local, TRUE);
DevCPL486.GenFMOp(0C1H); (* FADD ST1 *)
DevCPL486.SetLabel(local);
DevCPL486.GenFMOp(5D9H); (* FSTP ST1 *)
| ash:
IF y.mode # Reg THEN LoadR(y); rev := ~rev END;
IF rev THEN DevCPL486.GenFMOp(1C9H); (* FXCH ST1 *) END;
DevCPL486.GenFMOp(1FDH); (* FSCALE *)
Floor(y, TRUE)
END;
IF y.mode = Stk THEN IncStack(y.form) END;
Free(y);
IF (subcl >= eql) & (subcl <= geq) THEN
Free(x); CheckAv(AX);
DevCPL486.GenFMOp(FSTSW);
(* DevCPL486.GenCode(WAIT); *) DevCPL486.GenCode(SAHF);
setCC(x, subcl, rev, FALSE)
END
END FloatDOp;
PROCEDURE IntMOp* (VAR x: DevCPL486.Item; subcl: BYTE);
VAR L: DevCPL486.Label; c: DevCPL486.Item;
BEGIN
CASE subcl OF
| minus:
IF x.form = Set THEN DevCPL486.GenNot(x) ELSE DevCPL486.GenNeg(x, ovflchk) END
| abs:
L := DevCPL486.NewLbl; DevCPL486.MakeConst(c, 0, x.form);
DevCPL486.GenComp(c, x);
DevCPL486.GenJump(ccNS, L, TRUE);
DevCPL486.GenNeg(x, ovflchk);
DevCPL486.SetLabel(L)
| cap:
DevCPL486.MakeConst(c, -1 - 20H, x.form);
DevCPL486.GenAnd(c, x)
| not:
DevCPL486.MakeConst(c, 1, x.form);
DevCPL486.GenXor(c, x)
END;
IF x.mode # Reg THEN Free(x) END
END IntMOp;
PROCEDURE FloatMOp* (VAR x: DevCPL486.Item; subcl: BYTE);
BEGIN
ASSERT(x.mode = Reg);
IF subcl = minus THEN DevCPL486.GenFMOp(FCHS)
ELSE ASSERT(subcl = abs); DevCPL486.GenFMOp(FABS)
END
END FloatMOp;
PROCEDURE MakeSet* (VAR x: DevCPL486.Item; range, neg: BOOLEAN; hint, stop: SET);
(* range neg result
F F {x}
F T -{x}
T F {x..31}
T T -{0..x} *)
VAR c, r: DevCPL486.Item; val: INTEGER;
BEGIN
IF x.mode = Con THEN
IF range THEN
IF neg THEN val := -2 ELSE val := -1 END;
x.offset := SYSTEM.LSH(val, x.offset)
ELSE
val := 1; x.offset := SYSTEM.LSH(val, x.offset);
IF neg THEN x.offset := -1 - x.offset END
END
ELSE
Check(x, 0, 31);
IF neg THEN val := -2
ELSIF range THEN val := -1
ELSE val := 1
END;
DevCPL486.MakeConst(c, val, Set); GetReg(r, Set, hint, stop); DevCPL486.GenMove(c, r);
IF range THEN DevCPL486.GenShiftOp(SHL, x, r) ELSE DevCPL486.GenShiftOp(ROL, x, r) END;
Free(x); x.reg := r.reg
END;
x.typ := DevCPT.settyp; x.form := Set
END MakeSet;
PROCEDURE MakeCond* (VAR x: DevCPL486.Item);
VAR c: DevCPL486.Item;
BEGIN
IF x.mode = Con THEN
setCC(x, SHORT(SHORT(x.offset)), FALSE, FALSE)
ELSE
DevCPL486.MakeConst(c, 0, x.form);
DevCPL486.GenComp(c, x); Free(x);
setCC(x, neq, FALSE, FALSE)
END
END MakeCond;
PROCEDURE Not* (VAR x: DevCPL486.Item);
VAR a: INTEGER;
BEGIN
x.offset := Inverted(x.offset); (* invert cc *)
END Not;
PROCEDURE Odd* (VAR x: DevCPL486.Item);
VAR c: DevCPL486.Item;
BEGIN
IF x.mode = Stk THEN Pop(x, x.form, {}, {}) END;
Free(x); DevCPL486.MakeConst(c, 1, x.form);
IF x.mode = Reg THEN
IF x.form IN {Int16, Int64} THEN x.form := Int32; c.form := Int32 END;
DevCPL486.GenAnd(c, x)
ELSE
c.form := Int8; x.form := Int8; DevCPL486.GenTest(c, x)
END;
setCC(x, neq, FALSE, FALSE)
END Odd;
PROCEDURE In* (VAR x, y: DevCPL486.Item);
BEGIN
IF y.form = Set THEN Check(x, 0, 31) END;
DevCPL486.GenBitOp(BT, x, y); Free(x); Free(y);
setCC(x, lss, FALSE, FALSE); (* carry set *)
END In;
PROCEDURE Shift* (VAR x, y: DevCPL486.Item; subcl: BYTE); (* ASH, LSH, ROT *)
VAR L1, L2: DevCPL486.Label; c: DevCPL486.Item; opl, opr: INTEGER;
BEGIN
IF subcl = ash THEN opl := SHL; opr := SAR
ELSIF subcl = lsh THEN opl := SHL; opr := SHR
ELSE opl := ROL; opr := ROR
END;
IF y.mode = Con THEN
IF y.offset > 0 THEN
DevCPL486.GenShiftOp(opl, y, x)
ELSIF y.offset < 0 THEN
y.offset := -y.offset;
DevCPL486.GenShiftOp(opr, y, x)
END
ELSE
ASSERT(y.mode = Reg);
Check(y, -31, 31);
L1 := DevCPL486.NewLbl; L2 := DevCPL486.NewLbl;
DevCPL486.MakeConst(c, 0, y.form); DevCPL486.GenComp(c, y);
DevCPL486.GenJump(ccNS, L1, TRUE);
DevCPL486.GenNeg(y, FALSE);
DevCPL486.GenShiftOp(opr, y, x);
DevCPL486.GenJump(ccAlways, L2, TRUE);
DevCPL486.SetLabel(L1);
DevCPL486.GenShiftOp(opl, y, x);
DevCPL486.SetLabel(L2);
Free(y)
END;
IF x.mode # Reg THEN Free(x) END
END Shift;
PROCEDURE DivMod* (VAR x, y: DevCPL486.Item; mod: BOOLEAN);
VAR s: SET; r: DevCPL486.Item; pos: BOOLEAN;
BEGIN
ASSERT((x.mode = Reg) & (x.reg = AX)); pos := FALSE;
IF y.mode = Con THEN pos := (y.offset > 0) & (y.obj = NIL); Load(y, {}, {AX, DX, con}) END;
DevCPL486.GenDiv(y, mod, pos); Free(y);
IF mod THEN
r := x; GetReg(x, x.form, {}, wreg - {AX, DX}); Free(r) (* ax -> dx; al -> ah *) (* ??? *)
END
END DivMod;
PROCEDURE Mem* (VAR x: DevCPL486.Item; offset: INTEGER; typ: DevCPT.Struct); (* x := Mem[x+offset] *)
BEGIN
IF x.mode = Con THEN x.mode := Abs; x.obj := NIL; INC(x.offset, offset)
ELSE ASSERT(x.mode = Reg); x.mode := Ind; x.offset := offset
END;
x.scale := 0; x.typ := typ; x.form := typ.form
END Mem;
PROCEDURE SysMove* (VAR len: DevCPL486.Item); (* implementation of SYSTEM.MOVE *)
BEGIN
IF len.mode = Con THEN
IF len.offset > 0 THEN DevCPL486.GenBlockMove(1, len.offset) END
ELSE
Load(len, {}, wreg - {CX} + {short, mem, stk}); DevCPL486.GenBlockMove(1, 0); Free(len)
END;
FreeWReg(SI); FreeWReg(DI)
END SysMove;
PROCEDURE Len* (VAR x, y: DevCPL486.Item);
VAR typ: DevCPT.Struct; dim: INTEGER;
BEGIN
dim := y.offset; typ := x.typ;
IF typ.untagged THEN DevCPM.err(136) END;
WHILE dim > 0 DO typ := typ.BaseTyp; DEC(dim) END;
LenDesc(x, x, typ);
END Len;
PROCEDURE StringWSize (VAR x: DevCPL486.Item): INTEGER;
BEGIN
CASE x.form OF
| String8, VString8: RETURN 1
| String16, VString16: RETURN 2
| VString16to8: RETURN 0
| Comp: RETURN x.typ.BaseTyp.size
END
END StringWSize;
PROCEDURE CmpString* (VAR x, y: DevCPL486.Item; rel: BYTE; rev: BOOLEAN);
VAR sw, dw: INTEGER;
BEGIN
CheckAv(CX);
IF (x.typ = DevCPT.guidtyp) OR (y.typ = DevCPT.guidtyp) THEN
DevCPL486.GenBlockComp(4, 4)
ELSIF x.form = String8 THEN DevCPL486.GenBlockComp(1, x.index)
ELSIF y.form = String8 THEN DevCPL486.GenBlockComp(1, y.index)
ELSIF x.form = String16 THEN DevCPL486.GenBlockComp(2, x.index)
ELSIF y.form = String16 THEN DevCPL486.GenBlockComp(2, y.index)
ELSE DevCPL486.GenStringComp(StringWSize(y), StringWSize(x))
END;
FreeWReg(SI); FreeWReg(DI); setCC(x, rel, ~rev, FALSE);
END CmpString;
PROCEDURE VarParDynArr (ftyp: DevCPT.Struct; VAR y: DevCPL486.Item);
VAR len, z: DevCPL486.Item; atyp: DevCPT.Struct;
BEGIN
atyp := y.typ;
WHILE ftyp.comp = DynArr DO
IF ftyp.BaseTyp = DevCPT.bytetyp THEN
IF atyp.comp = DynArr THEN
IF atyp.untagged THEN DevCPM.err(137) END;
LenDesc(y, len, atyp);
IF y.tmode = VarPar THEN Free(len) END; (* ??? *)
GetReg(z, Int32, {}, {}); DevCPL486.GenMove(len, z);
len.mode := Reg; len.reg := z.reg; atyp := atyp.BaseTyp;
WHILE atyp.comp = DynArr DO
LenDesc(y, z, atyp); DevCPL486.GenMul(z, len, FALSE);
IF y.tmode = VarPar THEN Free(z) END; (* ??? *)
atyp := atyp.BaseTyp
END;
DevCPL486.MakeConst(z, atyp.size, Int32); DevCPL486.GenMul(z, len, FALSE);
Free(len)
ELSE
DevCPL486.MakeConst(len, atyp.size, Int32)
END
ELSE
IF atyp.comp = DynArr THEN LenDesc(y, len, atyp);
IF atyp.untagged THEN DevCPM.err(137) END;
IF y.tmode = VarPar THEN Free(len) END; (* ??? *)
ELSE DevCPL486.MakeConst(len, atyp.n, Int32)
END
END;
DevCPL486.GenPush(len);
ftyp := ftyp.BaseTyp; atyp := atyp.BaseTyp
END
END VarParDynArr;
PROCEDURE Assign* (VAR x, y: DevCPL486.Item); (* x := y *)
BEGIN
IF y.mode = Con THEN
IF y.form IN {Real32, Real64} THEN
DevCPL486.GenFLoad(y); GetReg(y, Real32, {}, {});
IF x.mode # Reg THEN Free(y); DevCPL486.GenFStore(x, TRUE) END (* ??? move const *)
ELSIF x.form = Int64 THEN
ASSERT(x.mode IN {Ind, Abs});
y.form := Int32; x.form := Int32; DevCPL486.GenMove(y, x);
y.offset := y.scale; INC(x.offset, 4); DevCPL486.GenMove(y, x);
DEC(x.offset, 4); x.form := Int64
ELSE
DevCPL486.GenMove(y, x)
END
ELSE
IF y.form IN {Comp, String8, String16, VString8, VString16} THEN (* convert to pointer *)
ASSERT(x.form = Pointer);
GetAdr(y, {}, {}); y.typ := x.typ; y.form := Pointer
END;
IF ~(x.form IN realSet) OR ~(y.form IN intSet) THEN Assert(y, {}, {stk}) END;
ConvMove(x, y, FALSE, {}, {})
END;
Free(x)
END Assign;
PROCEDURE ArrayLen* (VAR x, len: DevCPL486.Item; hint, stop: SET);
VAR c: DevCPL486.Item;
BEGIN
IF x.typ.comp = Array THEN DevCPL486.MakeConst(c, x.typ.n, Int32); GetReg(len, Int32, hint, stop); DevCPL486.GenMove(c, len)
ELSIF ~x.typ.untagged THEN LenDesc(x, c, x.typ); GetReg(len, Int32, hint, stop); DevCPL486.GenMove(c, len)
ELSE len.mode := Con
END;
len.typ := DevCPT.int32typ
END ArrayLen;
(*
src dest zero
sx = sy x b y b
SHORT(lx) = sy x b+ x w y b
SHORT(lx) = SHORT(ly) x b+ x w y b+
lx = ly x w y w
LONG(sx) = ly x b y w *
LONG(SHORT(lx)) = ly x b+ x w* y w *
sx := sy y b x b
sx := SHORT(ly) y b+ y w x b
lx := ly y w x w
lx := LONG(sy) y b x w *
lx := LONG(SHORT(ly)) y b+ y w* x w *
*)
PROCEDURE AddCopy* (VAR x, y: DevCPL486.Item; last: BOOLEAN); (* x := .. + y + .. *)
BEGIN
IF (x.typ.comp = DynArr) & x.typ.untagged THEN
DevCPL486.GenStringMove(~last, StringWSize(y), StringWSize(x), -1)
ELSE
DevCPL486.GenStringMove(~last, StringWSize(y), StringWSize(x), 0)
END;
FreeWReg(SI); FreeWReg(DI)
END AddCopy;
PROCEDURE Copy* (VAR x, y: DevCPL486.Item; short: BOOLEAN); (* x := y *)
VAR sx, sy, sy2, sy4: INTEGER; c, r: DevCPL486.Item;
BEGIN
sx := x.typ.size; CheckAv(CX);
IF y.form IN {String8, String16} THEN
sy := y.index * y.typ.BaseTyp.size;
IF x.typ.comp = Array THEN (* adjust size for optimal performance *)
sy2 := sy + sy MOD 2; sy4 := sy2 + sy2 MOD 4;
IF sy4 <= sx THEN sy := sy4
ELSIF sy2 <= sx THEN sy := sy2
ELSIF sy > sx THEN DevCPM.err(114); sy := 1
END
ELSIF inxchk & ~x.typ.untagged THEN (* check array length *)
Free(x); LenDesc(x, c, x.typ);
DevCPL486.MakeConst(y, y.index, Int32);
DevCPL486.GenComp(y, c); DevCPL486.GenAssert(ccAE, copyTrap);
Free(c)
END;
DevCPL486.GenBlockMove(1, sy)
ELSIF x.typ.comp = DynArr THEN
IF x.typ.untagged THEN
DevCPL486.GenStringMove(FALSE, StringWSize(y), StringWSize(x), -1)
ELSE
Free(x); LenDesc(x, c, x.typ); DevCPL486.MakeReg(r, CX, Int32); DevCPL486.GenMove(c, r); Free(c);
DevCPL486.GenStringMove(FALSE, StringWSize(y), StringWSize(x), 0)
END
ELSIF y.form IN {VString16to8, VString8, VString16} THEN
DevCPL486.GenStringMove(FALSE, StringWSize(y), StringWSize(x), x.typ.n);
ASSERT(y.mode # Stk)
ELSIF short THEN (* COPY *)
sy := y.typ.size;
IF (y.typ.comp # DynArr) & (sy < sx) THEN sx := sy END;
DevCPL486.GenStringMove(FALSE, StringWSize(y), StringWSize(x), x.typ.n);
IF y.mode = Stk THEN AdjustStack(sy) END
ELSE (* := *)
IF sx > 0 THEN DevCPL486.GenBlockMove(1, sx) END;
IF y.mode = Stk THEN AdjustStack(sy) END
END;
FreeWReg(SI); FreeWReg(DI)
END Copy;
PROCEDURE StrLen* (VAR x: DevCPL486.Item; typ: DevCPT.Struct; incl0x: BOOLEAN);
VAR c: DevCPL486.Item;
BEGIN
CheckAv(AX); CheckAv(CX);
DevCPL486.GenStringLength(typ.BaseTyp.size, -1);
Free(x); GetReg(x, Int32, {}, wreg - {CX});
DevCPL486.GenNot(x);
IF ~incl0x THEN DevCPL486.MakeConst(c, 1, Int32); DevCPL486.GenSub(c, x, FALSE) END;
FreeWReg(DI)
END StrLen;
PROCEDURE MulDim* (VAR y, z: DevCPL486.Item; VAR fact: INTEGER; dimtyp: DevCPT.Struct); (* z := z * y *)
VAR c: DevCPL486.Item;
BEGIN
IF y.mode = Con THEN fact := fact * y.offset
ELSE
IF ranchk OR inxchk THEN
DevCPL486.MakeConst(c, 0, Int32); DevCPL486.GenComp(c, y); DevCPL486.GenAssert(ccG, ranTrap)
END;
DevCPL486.GenPush(y);
IF z.mode = Con THEN z := y
ELSE DevCPL486.GenMul(y, z, ovflchk OR inxchk); Free(y)
END
END
END MulDim;
PROCEDURE SetDim* (VAR x, y: DevCPL486.Item; dimtyp: DevCPT.Struct); (* set LEN(x^, -dimtyp.n) *)
(* y const or on stack *)
VAR z: DevCPL486.Item; end: DevCPL486.Label;
BEGIN
ASSERT((x.mode = Reg) & (x.form = Pointer));
z.mode := Ind; z.reg := x.reg; z.offset := ArrDOffs + 4 + dimtyp.n * 4; z.scale := 0; z.form := Int32;
IF y.mode = Con THEN y.form := Int32
ELSE Pop(y, Int32, {}, {})
END;
end := DevCPL486.NewLbl; DevCPL486.GenJump(ccE, end, TRUE); (* flags set in New *)
DevCPL486.GenMove(y, z);
DevCPL486.SetLabel(end);
IF y.mode = Reg THEN Free(y) END
END SetDim;
PROCEDURE SysNew* (VAR x: DevCPL486.Item);
BEGIN
DevCPM.err(141)
END SysNew;
PROCEDURE New* (VAR x, nofel: DevCPL486.Item; fact: INTEGER);
(* x.typ.BaseTyp.comp IN {Record, Array, DynArr} *)
VAR p, tag, c: DevCPL486.Item; nofdim, dlen, n: INTEGER; typ, eltyp: DevCPT.Struct; lbl: DevCPL486.Label;
BEGIN
typ := x.typ.BaseTyp;
IF typ.untagged THEN DevCPM.err(138) END;
IF typ.comp = Record THEN (* call to Kernel.NewRec(tag: Tag): ADDRESS *)
DevCPL486.MakeConst(tag, 0, Pointer); tag.obj := DevCPE.TypeObj(typ);
IF ContainsIPtrs(typ) THEN INC(tag.offset) END;
DevCPL486.GenPush(tag);
p.mode := XProc; p.obj := DevCPE.KNewRec;
ELSE eltyp := typ.BaseTyp;
IF typ.comp = Array THEN
nofdim := 0; nofel.mode := Con; nofel.form := Int32; fact := typ.n
ELSE (* DynArr *)
nofdim := typ.n+1;
WHILE eltyp.comp = DynArr DO eltyp := eltyp.BaseTyp END
END ;
WHILE eltyp.comp = Array DO fact := fact * eltyp.n; eltyp := eltyp.BaseTyp END;
IF eltyp.comp = Record THEN
IF eltyp.untagged THEN DevCPM.err(138) END;
DevCPL486.MakeConst(tag, 0, Pointer); tag.obj := DevCPE.TypeObj(eltyp);
IF ContainsIPtrs(eltyp) THEN INC(tag.offset) END;
ELSIF eltyp.form = Pointer THEN
IF ~eltyp.untagged THEN
DevCPL486.MakeConst(tag, 0, Pointer) (* special TDesc in Kernel for ARRAY OF pointer *)
ELSIF eltyp.sysflag = interface THEN
DevCPL486.MakeConst(tag, -1, Pointer) (* special TDesc in Kernel for ARRAY OF interface pointer *)
ELSE
DevCPL486.MakeConst(tag, 12, Pointer)
END
ELSE (* eltyp is pointerless basic type *)
CASE eltyp.form OF
| Undef, Byte, Char8: n := 1;
| Int16: n := 2;
| Int8: n := 3;
| Int32: n := 4;
| Bool: n := 5;
| Set: n := 6;
| Real32: n := 7;
| Real64: n := 8;
| Char16: n := 9;
| Int64: n := 10;
| ProcTyp: n := 11;
END;
DevCPL486.MakeConst(tag, n, Pointer)
(*
DevCPL486.MakeConst(tag, eltyp.size, Pointer)
*)
END;
IF nofel.mode = Con THEN nofel.offset := fact; nofel.obj := NIL
ELSE DevCPL486.MakeConst(p, fact, Int32); DevCPL486.GenMul(p, nofel, ovflchk OR inxchk)
END;
DevCPL486.MakeConst(p, nofdim, Int32); DevCPL486.GenPush(p);
DevCPL486.GenPush(nofel); Free(nofel); DevCPL486.GenPush(tag);
p.mode := XProc; p.obj := DevCPE.KNewArr;
END;
DevCPL486.GenCall(p); GetReg(x, Pointer, {}, wreg - {AX});
IF typ.comp = DynArr THEN (* set flags for nil test *)
DevCPL486.MakeConst(c, 0, Pointer); DevCPL486.GenComp(c, x)
ELSIF typ.comp = Record THEN
n := NumOfIntProc(typ);
IF n > 0 THEN (* interface method table pointer setup *)
DevCPL486.MakeConst(c, 0, Pointer); DevCPL486.GenComp(c, x);
lbl := DevCPL486.NewLbl; DevCPL486.GenJump(ccE, lbl, TRUE);
tag.offset := - 4 * (n + numPreIntProc);
p.mode := Ind; p.reg := AX; p.offset := 0; p.scale := 0; p.form := Pointer;
DevCPL486.GenMove(tag, p);
IF nofel.mode # Con THEN (* unk pointer setup *)
p.offset := 8;
DevCPL486.GenMove(nofel, p);
Free(nofel)
END;
DevCPL486.SetLabel(lbl);
END
END
END New;
PROCEDURE Param* (fp: DevCPT.Object; rec, niltest: BOOLEAN; VAR ap, tag: DevCPL486.Item); (* returns tag if rec *)
VAR f: BYTE; s, ss: INTEGER; par, a, c: DevCPL486.Item; recTyp: DevCPT.Struct;
BEGIN
par.mode := Stk; par.typ := fp.typ; par.form := par.typ.form;
IF ODD(fp.sysflag DIV nilBit) THEN niltest := FALSE END;
IF ap.typ = DevCPT.niltyp THEN
IF ((par.typ.comp = Record) OR (par.typ.comp = DynArr)) & ~par.typ.untagged THEN
DevCPM.err(142)
END;
DevCPL486.GenPush(ap)
ELSIF par.typ.comp = DynArr THEN
IF ap.form IN {String8, String16} THEN
IF ~par.typ.untagged THEN
DevCPL486.MakeConst(c, ap.index (* * ap.typ.BaseTyp.size *), Int32); DevCPL486.GenPush(c)
END;
ap.mode := Con; DevCPL486.GenPush(ap);
ELSIF ap.form IN {VString8, VString16} THEN
DevCPL486.MakeReg(a, DX, Pointer); DevCPL486.GenLoadAdr(ap, a);
IF ~par.typ.untagged THEN
DevCPL486.MakeReg(c, DI, Pointer); DevCPL486.GenMove(a, c);
Free(ap); StrLen(c, ap.typ, TRUE);
DevCPL486.GenPush(c); Free(c)
END;
DevCPL486.GenPush(a)
ELSE
IF ~par.typ.untagged THEN
IF ap.typ.comp = DynArr THEN niltest := FALSE END; (* ap dereferenced for length descriptor *)
VarParDynArr(par.typ, ap)
END;
PushAdr(ap, niltest)
END
ELSIF fp.mode = VarPar THEN
recTyp := ap.typ;
IF recTyp.form = Pointer THEN recTyp := recTyp.BaseTyp END;
IF (par.typ.comp = Record) & (~fp.typ.untagged) THEN
Tag(ap, tag);
IF rec & (tag.mode # Con) THEN
GetReg(c, Pointer, {}, {}); DevCPL486.GenMove(tag, c); tag := c
END;
DevCPL486.GenPush(tag);
IF tag.mode # Con THEN niltest := FALSE END;
PushAdr(ap, niltest);
IF rec THEN Free(tag) END
ELSE PushAdr(ap, niltest)
END;
tag.typ := recTyp
ELSIF par.form = Comp THEN
s := par.typ.size;
IF initializeStr & (ap.form IN {String8, String16, VString8, VString16, VString16to8}) THEN
s := (s + 3) DIV 4 * 4; AdjustStack(-s);
IF ap.form IN {String8, String16} THEN
IF ap.index > 1 THEN (* nonempty string *)
ss := (ap.index * ap.typ.BaseTyp.size + 3) DIV 4 * 4;
DevCPL486.MakeReg(c, SI, Pointer); DevCPL486.GenLoadAdr(ap, c); Free(ap);
DevCPL486.MakeReg(c, DI, Pointer); DevCPL486.GenLoadAdr(par, c);
DevCPL486.GenBlockMove(1, ss);
ELSE
ss := 0;
DevCPL486.MakeReg(c, DI, Pointer); DevCPL486.GenLoadAdr(par, c)
END;
IF s > ss THEN
DevCPL486.MakeReg(a, AX, Int32); DevCPL486.MakeConst(c, 0, Int32); DevCPL486.GenMove(c, a);
DevCPL486.GenBlockStore(1, s - ss)
END;
ELSE
DevCPL486.MakeReg(c, SI, Pointer); DevCPL486.GenLoadAdr(ap, c); Free(ap);
DevCPL486.MakeReg(c, DI, Pointer); DevCPL486.GenLoadAdr(par, c);
DevCPL486.GenStringMove(TRUE, StringWSize(ap), StringWSize(par), par.typ.n);
DevCPL486.MakeReg(a, AX, Int32); DevCPL486.MakeConst(c, 0, Int32); DevCPL486.GenMove(c, a);
DevCPL486.GenBlockStore(StringWSize(par), 0)
END
ELSE
IF (ap.form IN {String8, String16}) & (ap.index = 1) THEN (* empty string *)
AdjustStack((4 - s) DIV 4 * 4);
DevCPL486.MakeConst(c, 0, Int32); DevCPL486.GenPush(c)
ELSE
AdjustStack((-s) DIV 4 * 4);
DevCPL486.MakeReg(c, SI, Pointer); DevCPL486.GenLoadAdr(ap, c); Free(ap);
DevCPL486.MakeReg(c, DI, Pointer); DevCPL486.GenLoadAdr(par, c);
IF ap.form IN {String8, String16} THEN
DevCPL486.GenBlockMove(1, (ap.index * ap.typ.BaseTyp.size + 3) DIV 4 * 4)
ELSIF ap.form IN {VString8, VString16, VString16to8} THEN
DevCPL486.GenStringMove(FALSE, StringWSize(ap), StringWSize(par), par.typ.n)
ELSE
DevCPL486.GenBlockMove(1, (s + 3) DIV 4 * 4)
END
END
END
ELSIF ap.mode = Con THEN
IF ap.form IN {Real32, Real64} THEN (* ??? push const *)
DevCPL486.GenFLoad(ap); DecStack(par.typ.form); DevCPL486.GenFStore(par, TRUE)
ELSE
ap.form := Int32;
IF par.form = Int64 THEN DevCPL486.MakeConst(c, ap.scale, Int32); DevCPL486.GenPush(c) END;
DevCPL486.GenPush(ap)
END
ELSIF ap.typ.form = Pointer THEN
recTyp := ap.typ.BaseTyp;
IF rec THEN
Load(ap, {}, {}); Tag(ap, tag);
IF tag.mode = Con THEN (* explicit nil test needed *)
DevCPL486.MakeReg(a, AX, Int32);
c.mode := Ind; c.form := Int32; c.offset := 0; c.scale := 0; c.reg := ap.reg;
DevCPL486.GenTest(a, c)
END
END;
DevCPL486.GenPush(ap); Free(ap);
tag.typ := recTyp
ELSIF ap.form IN {Comp, String8, String16, VString8, VString16} THEN (* convert to pointer *)
ASSERT(par.form = Pointer);
PushAdr(ap, FALSE)
ELSE
ConvMove(par, ap, FALSE, {}, {high});
END
END Param;
PROCEDURE Result* (proc: DevCPT.Object; VAR res: DevCPL486.Item);
VAR r: DevCPL486.Item;
BEGIN
DevCPL486.MakeReg(r, AX, proc.typ.form); (* don't allocate AX ! *)
IF res.mode = Con THEN
IF r.form IN {Real32, Real64} THEN DevCPL486.GenFLoad(res);
ELSIF r.form = Int64 THEN
r.form := Int32; res.form := Int32; DevCPL486.GenMove(res, r);
r.reg := DX; res.offset := res.scale; DevCPL486.GenMove(res, r)
ELSE DevCPL486.GenMove(res, r);
END
ELSIF res.form IN {Comp, String8, String16, VString8, VString16} THEN (* convert to pointer *)
ASSERT(r.form = Pointer);
GetAdr(res, {}, wreg - {AX})
ELSE
r.index := DX; (* for int64 *)
ConvMove(r, res, FALSE, wreg - {AX} + {high}, {});
END;
Free(res)
END Result;
PROCEDURE InitFpu;
VAR x: DevCPL486.Item;
BEGIN
DevCPL486.MakeConst(x, FpuControlRegister, Int32); DevCPL486.GenPush(x);
DevCPL486.GenFMOp(12CH); DevCPL486.GenCode(24H); (* FLDCW 0(SP) *)
DevCPL486.MakeReg(x, CX, Int32); DevCPL486.GenPop(x); (* reset stack *)
END InitFpu;
PROCEDURE PrepCall* (proc: DevCPT.Object);
VAR lev: BYTE; r: DevCPL486.Item;
BEGIN
lev := proc.mnolev;
IF (slNeeded IN proc.conval.setval) & (imLevel[lev] > 0) & (imLevel[DevCPL486.level] > imLevel[lev]) THEN
DevCPL486.MakeReg(r, BX, Pointer); DevCPL486.GenPush(r)
END
END PrepCall;
PROCEDURE Call* (VAR x, tag: DevCPL486.Item); (* TProc: tag.typ = actual receiver type *)
VAR i, n: INTEGER; r, y: DevCPL486.Item; typ: DevCPT.Struct; lev: BYTE; saved: BOOLEAN; p: DevCPT.Object;
BEGIN
IF x.mode IN {LProc, XProc, IProc} THEN
lev := x.obj.mnolev; saved := FALSE;
IF (slNeeded IN x.obj.conval.setval) & (imLevel[lev] > 0) THEN (* pass static link *)
n := imLevel[DevCPL486.level] - imLevel[lev];
IF n > 0 THEN
saved := TRUE;
y.mode := Ind; y.scale := 0; y.form := Pointer; y.reg := BX; y.offset := -4;
DevCPL486.MakeReg(r, BX, Pointer);
WHILE n > 0 DO DevCPL486.GenMove(y, r); DEC(n) END
END
END;
DevCPL486.GenCall(x);
IF x.obj.sysflag = ccall THEN (* remove parameters *)
p := x.obj.link; n := 0;
WHILE p # NIL DO
IF p.mode = VarPar THEN INC(n, 4)
ELSE INC(n, (p.typ.size + 3) DIV 4 * 4)
END;
p := p.link
END;
AdjustStack(n)
END;
IF saved THEN DevCPL486.GenPop(r) END;
ELSIF x.mode = TProc THEN
IF x.scale = 1 THEN (* super *)
DevCPL486.MakeConst(tag, 0, Pointer); tag.obj := DevCPE.TypeObj(tag.typ.BaseTyp)
ELSIF x.scale = 2 THEN (* static call *)
DevCPL486.MakeConst(tag, 0, Pointer); typ := x.obj.link.typ;
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
tag.obj := DevCPE.TypeObj(typ)
ELSIF x.scale = 3 THEN (* interface method call *)
DevCPM.err(200)
END;
IF tag.mode = Con THEN
y.mode := Abs; y.offset := tag.offset; y.obj := tag.obj; y.scale := 0
ELSIF (x.obj.conval.setval * {absAttr, empAttr, extAttr} = {}) & ~(DevCPM.oberon IN DevCPM.options) THEN (* final method *)
y.mode := Abs; y.offset := 0; y.obj := DevCPE.TypeObj(tag.typ); y.scale := 0;
IF tag.mode = Ind THEN (* nil test *)
DevCPL486.MakeReg(r, AX, Int32); tag.offset := 0; DevCPL486.GenTest(r, tag)
END
ELSE
IF tag.mode = Reg THEN y.reg := tag.reg
ELSE GetReg(y, Pointer, {}, {}); DevCPL486.GenMove(tag, y)
END;
y.mode := Ind; y.offset := 0; y.scale := 0
END;
IF (tag.typ.sysflag = interface) & (y.mode = Ind) THEN y.offset := 4 * x.offset
ELSIF tag.typ.untagged THEN DevCPM.err(140)
ELSE
IF x.obj.link.typ.sysflag = interface THEN (* correct method number *)
x.offset := numPreIntProc + NumOfIntProc(tag.typ) - 1 - x.offset
END;
INC(y.offset, Mth0Offset - 4 * x.offset)
END;
DevCPL486.GenCall(y); Free(y)
ELSIF x.mode = CProc THEN
IF x.obj.link # NIL THEN (* tag = first param *)
IF x.obj.link.mode = VarPar THEN
GetAdr(tag, {}, wreg - {AX} + {stk, mem, con}); Free(tag)
ELSE
(* Load(tag, {}, wreg - {AX} + {con}); Free(tag) *)
Result(x.obj.link, tag) (* use result load for first parameter *)
END
END;
i := 1; n := ORD(x.obj.conval.ext^[0]);
WHILE i <= n DO DevCPL486.GenCode(ORD(x.obj.conval.ext^[i])); INC(i) END
ELSE (* proc var *)
DevCPL486.GenCall(x); Free(x);
x.typ := x.typ.BaseTyp
END;
IF procedureUsesFpu & (x.mode = XProc) & (x.obj.mnolev < 0) & (x.obj.mnolev > -128)
& ((x.obj.library # NIL) OR (DevCPT.GlbMod[-x.obj.mnolev].library # NIL)) THEN (* restore fpu *)
InitFpu
END;
CheckReg;
IF x.typ.form = Int64 THEN
GetReg(x, Int32, {}, wreg - {AX}); GetReg(y, Int32, {}, wreg - {DX});
x.index := y.reg; x.form := Int64
ELSIF x.typ.form # NoTyp THEN GetReg(x, x.typ.form, {}, wreg - {AX} + {high})
END
END Call;
PROCEDURE CopyDynArray* (adr: INTEGER; typ: DevCPT.Struct); (* needs CX, SI, DI *)
VAR len, ptr, c, sp, src, dst: DevCPL486.Item; bt: DevCPT.Struct;
BEGIN
IF typ.untagged THEN DevCPM.err(-137) END;
ptr.mode := Ind; ptr.reg := BP; ptr.offset := adr+4; ptr.scale := 0; ptr.form := Pointer;
DevCPL486.MakeReg(len, CX, Int32); DevCPL486.MakeReg(sp, SP, Int32);
DevCPL486.MakeReg(src, SI, Int32); DevCPL486.MakeReg(dst, DI, Int32);
DevCPL486.GenMove(ptr, len); bt := typ.BaseTyp;
WHILE bt.comp = DynArr DO
INC(ptr.offset, 4); DevCPL486.GenMul(ptr, len, FALSE); bt := bt.BaseTyp
END;
ptr.offset := adr; DevCPL486.GenMove(ptr, src);
DevCPL486.MakeConst(c, bt.size, Int32); DevCPL486.GenMul(c, len, FALSE);
(* CX = length in bytes *)
StackAlloc;
(* CX = length in 32bit words *)
DevCPL486.GenMove(sp, dst); DevCPL486.GenMove(dst, ptr);
DevCPL486.GenBlockMove(4, 0) (* 32bit moves *)
END CopyDynArray;
PROCEDURE Sort (VAR tab: ARRAY OF INTEGER; VAR n: INTEGER);
VAR i, j, x: INTEGER;
BEGIN
(* align *)
i := 1;
WHILE i < n DO
x := tab[i]; j := i-1;
WHILE (j >= 0) & (tab[j] < x) DO tab[j+1] := tab[j]; DEC(j) END;
tab[j+1] := x; INC(i)
END;
(* eliminate equals *)
i := 1; j := 1;
WHILE i < n DO
IF tab[i] # tab[i-1] THEN tab[j] := tab[i]; INC(j) END;
INC(i)
END;
n := j
END Sort;
PROCEDURE FindPtrs (typ: DevCPT.Struct; adr: INTEGER; VAR num: INTEGER);
VAR fld: DevCPT.Object; btyp: DevCPT.Struct; i, n: INTEGER;
BEGIN
IF typ.form IN {Pointer, ProcTyp} THEN
IF num < MaxPtrs THEN ptrTab[num] := adr DIV 4 * 4 END;
INC(num);
IF adr MOD 4 # 0 THEN
IF num < MaxPtrs THEN ptrTab[num] := adr DIV 4 * 4 + 4 END;
INC(num)
END
ELSIF typ.comp = Record THEN
btyp := typ.BaseTyp;
IF btyp # NIL THEN FindPtrs(btyp, adr, num) END ;
fld := typ.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
IF (fld.name^ = DevCPM.HdPtrName) OR
(fld.name^ = DevCPM.HdUtPtrName) OR
(fld.name^ = DevCPM.HdProcName) THEN
FindPtrs(DevCPT.sysptrtyp, fld.adr + adr, num)
ELSE FindPtrs(fld.typ, fld.adr + adr, num)
END;
fld := fld.link
END
ELSIF typ.comp = Array THEN
btyp := typ.BaseTyp; n := typ.n;
WHILE btyp.comp = Array DO n := btyp.n * n; btyp := btyp.BaseTyp END ;
IF (btyp.form = Pointer) OR (btyp.comp = Record) THEN
i := num; FindPtrs(btyp, adr, num);
IF num # i THEN i := 1;
WHILE (i < n) & (num <= MaxPtrs) DO
INC(adr, btyp.size); FindPtrs(btyp, adr, num); INC(i)
END
END
END
END
END FindPtrs;
PROCEDURE InitOutPar (par: DevCPT.Object; VAR zreg: DevCPL486.Item);
VAR x, y, c, len: DevCPL486.Item; lbl: DevCPL486.Label; size, s: INTEGER; bt: DevCPT.Struct;
BEGIN
x.mode := Ind; x.reg := BP; x.scale := 0; x.form := Pointer; x.offset := par.adr;
DevCPL486.MakeReg(y, DI, Int32);
IF par.typ.comp # DynArr THEN
DevCPL486.GenMove(x, y);
lbl := DevCPL486.NewLbl;
IF ODD(par.sysflag DIV nilBit) THEN
DevCPL486.GenComp(zreg, y);
DevCPL486.GenJump(ccE, lbl, TRUE)
END;
size := par.typ.size;
IF size <= 16 THEN
x.mode := Ind; x.reg := DI; x.form := Int32; x.offset := 0;
WHILE size > 0 DO
IF size = 1 THEN x.form := Int8; s := 1
ELSIF size = 2 THEN x.form := Int16; s := 2
ELSE x.form := Int32; s := 4
END;
zreg.form := x.form; DevCPL486.GenMove(zreg, x); INC(x.offset, s); DEC(size, s)
END;
zreg.form := Int32
ELSE
DevCPL486.GenBlockStore(1, size)
END;
DevCPL486.SetLabel(lbl)
ELSIF initializeDyn & ~par.typ.untagged THEN (* untagged open arrays not initialized !!! *)
DevCPL486.GenMove(x, y);
DevCPL486.MakeReg(len, CX, Int32);
INC(x.offset, 4); DevCPL486.GenMove(x, len); (* first len *)
bt := par.typ.BaseTyp;
WHILE bt.comp = DynArr DO
INC(x.offset, 4); DevCPL486.GenMul(x, len, FALSE); bt := bt.BaseTyp
END;
size := bt.size;
IF size MOD 4 = 0 THEN size := size DIV 4; s := 4
ELSIF size MOD 2 = 0 THEN size := size DIV 2; s := 2
ELSE s := 1
END;
DevCPL486.MakeConst(c, size, Int32); DevCPL486.GenMul(c, len, FALSE);
DevCPL486.GenBlockStore(s, 0)
END
END InitOutPar;
PROCEDURE AllocAndInitAll (proc: DevCPT.Object; adr, size: INTEGER; VAR nofptrs: INTEGER);
VAR x, y, z, zero: DevCPL486.Item; par: DevCPT.Object; op: INTEGER;
BEGIN
op := 0; par := proc.link;
WHILE par # NIL DO (* count out parameters [with COM pointers] *)
IF (par.mode = VarPar) & (par.vis = outPar) & (initializeOut OR ContainsIPtrs(par.typ)) THEN INC(op) END;
par := par.link
END;
DevCPL486.MakeConst(zero, 0, Int32);
IF (op = 0) & (size <= 8) THEN (* use PUSH 0 *)
WHILE size > 0 DO DevCPL486.GenPush(zero); DEC(size, 4) END
ELSE
DevCPL486.MakeReg(z, AX, Int32); DevCPL486.GenMove(zero, z);
IF size <= 32 THEN (* use PUSH reg *)
WHILE size > 0 DO DevCPL486.GenPush(z); DEC(size, 4) END
ELSE (* use string store *)
AdjustStack(-size);
DevCPL486.MakeReg(x, SP, Int32); DevCPL486.MakeReg(y, DI, Int32); DevCPL486.GenMove(x, y);
DevCPL486.GenBlockStore(1, size)
END;
IF op > 0 THEN
par := proc.link;
WHILE par # NIL DO (* init out parameters [with COM pointers] *)
IF (par.mode = VarPar) & (par.vis = outPar) & (initializeOut OR ContainsIPtrs(par.typ)) THEN InitOutPar(par, z) END;
par := par.link
END
END
END
END AllocAndInitAll;
PROCEDURE AllocAndInitPtrs1 (proc: DevCPT.Object; adr, size: INTEGER; VAR nofptrs: INTEGER); (* needs AX *)
VAR i, base, a, gaps: INTEGER; x, z: DevCPL486.Item; obj: DevCPT.Object;
BEGIN
IF ptrinit & (proc.scope # NIL) THEN
nofptrs := 0; obj := proc.scope.scope; (* local variables *)
WHILE (obj # NIL) & (nofptrs <= MaxPtrs) DO
FindPtrs(obj.typ, obj.adr, nofptrs);
obj := obj.link
END;
IF (nofptrs > 0) & (nofptrs <= MaxPtrs) THEN
base := proc.conval.intval2;
Sort(ptrTab, nofptrs); i := 0; a := size + base; gaps := 0;
WHILE i < nofptrs DO
DEC(a, 4);
IF a # ptrTab[i] THEN a := ptrTab[i]; INC(gaps) END;
INC(i)
END;
IF a # base THEN INC(gaps) END;
IF (gaps <= (nofptrs + 1) DIV 2) & (size < stackAllocLimit) THEN
DevCPL486.MakeConst(z, 0, Pointer);
IF (nofptrs > 4) THEN x := z; DevCPL486.MakeReg(z, AX, Int32); DevCPL486.GenMove(x, z) END;
i := 0; a := size + base;
WHILE i < nofptrs DO
DEC(a, 4);
IF a # ptrTab[i] THEN AdjustStack(ptrTab[i] - a); a := ptrTab[i] END;
DevCPL486.GenPush(z); INC(i)
END;
IF a # base THEN AdjustStack(base - a) END
ELSE
AdjustStack(-size);
DevCPL486.MakeConst(x, 0, Pointer); DevCPL486.MakeReg(z, AX, Int32); DevCPL486.GenMove(x, z);
x.mode := Ind; x.reg := BP; x.scale := 0; x.form := Pointer; i := 0;
WHILE i < nofptrs DO
x.offset := ptrTab[i]; DevCPL486.GenMove(z, x); INC(i)
END
END
ELSE
AdjustStack(-size)
END
ELSE
nofptrs := 0;
AdjustStack(-size)
END
END AllocAndInitPtrs1;
PROCEDURE InitPtrs2 (proc: DevCPT.Object; adr, size, nofptrs: INTEGER); (* needs AX, CX, DI *)
VAR x, y, z, zero: DevCPL486.Item; obj: DevCPT.Object; zeroed: BOOLEAN; i: INTEGER; lbl: DevCPL486.Label;
BEGIN
IF ptrinit THEN
zeroed := FALSE; DevCPL486.MakeConst(zero, 0, Pointer);
IF nofptrs > MaxPtrs THEN
DevCPL486.MakeReg(z, AX, Int32); DevCPL486.GenMove(zero, z); zeroed := TRUE;
x.mode := Ind; x.reg := BP; x.scale := 0; x.form := Pointer; x.offset := adr;
DevCPL486.MakeReg(y, DI, Int32); DevCPL486.GenLoadAdr(x, y);
DevCPL486.GenStrStore(size)
END;
obj := proc.link; (* parameters *)
WHILE obj # NIL DO
IF (obj.mode = VarPar) & (obj.vis = outPar) THEN
nofptrs := 0;
IF obj.typ.comp = DynArr THEN (* currently not initialized *)
ELSE FindPtrs(obj.typ, 0, nofptrs)
END;
IF nofptrs > 0 THEN
IF ~zeroed THEN
DevCPL486.MakeReg(z, AX, Int32); DevCPL486.GenMove(zero, z); zeroed := TRUE
END;
x.mode := Ind; x.reg := BP; x.scale := 0; x.form := Pointer; x.offset := obj.adr;
DevCPL486.MakeReg(y, DI, Int32); DevCPL486.GenMove(x, y);
IF ODD(obj.sysflag DIV nilBit) THEN
DevCPL486.GenComp(zero, y);
lbl := DevCPL486.NewLbl; DevCPL486.GenJump(ccE, lbl, TRUE)
END;
IF nofptrs > MaxPtrs THEN
DevCPL486.GenStrStore(obj.typ.size)
ELSE
Sort(ptrTab, nofptrs);
x.reg := DI; i := 0;
WHILE i < nofptrs DO
x.offset := ptrTab[i]; DevCPL486.GenMove(z, x); INC(i)
END
END;
IF ODD(obj.sysflag DIV nilBit) THEN DevCPL486.SetLabel(lbl) END
END
END;
obj := obj.link
END
END
END InitPtrs2;
PROCEDURE Enter* (proc: DevCPT.Object; empty, useFpu: BOOLEAN);
VAR sp, fp, r, r1: DevCPL486.Item; par: DevCPT.Object; adr, size, np: INTEGER;
BEGIN
procedureUsesFpu := useFpu;
SetReg({AX, CX, DX, SI, DI});
DevCPL486.MakeReg(fp, BP, Pointer); DevCPL486.MakeReg(sp, SP, Pointer);
IF proc # NIL THEN (* enter proc *)
DevCPL486.SetLabel(proc.adr);
IF ~empty & (proc.sysflag # noframe) THEN
DevCPL486.GenPush(fp);
DevCPL486.GenMove(sp, fp);
adr := proc.conval.intval2; size := -adr;
IF isGuarded IN proc.conval.setval THEN
DevCPL486.MakeReg(r, BX, Pointer); DevCPL486.GenPush(r);
DevCPL486.MakeReg(r, DI, Pointer); DevCPL486.GenPush(r);
DevCPL486.MakeReg(r, SI, Pointer); DevCPL486.GenPush(r);
r1.mode := Con; r1.form := Int32; r1.offset := proc.conval.intval - 8; r1.obj := NIL;
DevCPL486.GenPush(r1);
intHandler.used := TRUE;
r1.mode := Con; r1.form := Int32; r1.offset := 0; r1.obj := intHandler;
DevCPL486.GenPush(r1);
r1.mode := Abs; r1.form := Int32; r1.offset := 0; r1.scale := 0; r1.obj := NIL;
DevCPL486.GenCode(64H); DevCPL486.GenPush(r1);
DevCPL486.GenCode(64H); DevCPL486.GenMove(sp, r1);
DEC(size, 24)
ELSE
IF imVar IN proc.conval.setval THEN (* set down pointer *)
DevCPL486.MakeReg(r, BX, Pointer); DevCPL486.GenPush(r); DEC(size, 4)
END;
IF isCallback IN proc.conval.setval THEN
DevCPL486.MakeReg(r, DI, Pointer); DevCPL486.GenPush(r);
DevCPL486.MakeReg(r, SI, Pointer); DevCPL486.GenPush(r); DEC(size, 8)
END
END;
ASSERT(size >= 0);
IF initializeAll THEN
AllocAndInitAll(proc, adr, size, np)
ELSE
AllocAndInitPtrs1(proc, adr, size, np); (* needs AX *)
InitPtrs2(proc, adr, size, np); (* needs AX, CX, DI *)
END;
par := proc.link; (* parameters *)
WHILE par # NIL DO
IF (par.mode = Var) & (par.typ.comp = DynArr) THEN
CopyDynArray(par.adr, par.typ)
END;
par := par.link
END;
IF imVar IN proc.conval.setval THEN
DevCPL486.MakeReg(r, BX, Pointer); DevCPL486.GenMove(fp, r)
END
END
ELSIF ~empty THEN (* enter module *)
DevCPL486.GenPush(fp);
DevCPL486.GenMove(sp, fp);
DevCPL486.MakeReg(r, DI, Int32); DevCPL486.GenPush(r);
DevCPL486.MakeReg(r, SI, Int32); DevCPL486.GenPush(r)
END;
IF useFpu THEN InitFpu END
END Enter;
PROCEDURE Exit* (proc: DevCPT.Object; empty: BOOLEAN);
VAR sp, fp, r, x: DevCPL486.Item; mode: SHORTINT; size: INTEGER;
BEGIN
DevCPL486.MakeReg(sp, SP, Pointer); DevCPL486.MakeReg(fp, BP, Pointer);
IF proc # NIL THEN (* exit proc *)
IF proc.sysflag # noframe THEN
IF ~empty THEN
IF isGuarded IN proc.conval.setval THEN (* remove exception frame *)
x.mode := Ind; x.reg := BP; x.offset := -24; x.scale := 0; x.form := Int32;
DevCPL486.MakeReg(r, CX, Int32); DevCPL486.GenMove(x, r);
x.mode := Abs; x.offset := 0; x.scale := 0; x.form := Int32; x.obj := NIL;
DevCPL486.GenCode(64H); DevCPL486.GenMove(r, x);
size := 12
ELSE
size := 0;
IF imVar IN proc.conval.setval THEN INC(size, 4) END;
IF isCallback IN proc.conval.setval THEN INC(size, 8) END
END;
IF size > 0 THEN
x.mode := Ind; x.reg := BP; x.offset := -size; x.scale := 0; x.form := Int32;
DevCPL486.GenLoadAdr(x, sp);
IF size > 4 THEN
DevCPL486.MakeReg(r, SI, Int32); DevCPL486.GenPop(r);
DevCPL486.MakeReg(r, DI, Int32); DevCPL486.GenPop(r)
END;
IF size # 8 THEN
DevCPL486.MakeReg(r, BX, Int32); DevCPL486.GenPop(r)
END
ELSE
DevCPL486.GenMove(fp, sp)
END;
DevCPL486.GenPop(fp)
END;
IF proc.sysflag = ccall THEN DevCPL486.GenReturn(0)
ELSE DevCPL486.GenReturn(proc.conval.intval - 8)
END
END
ELSE (* exit module *)
IF ~empty THEN
DevCPL486.MakeReg(r, SI, Int32); DevCPL486.GenPop(r);
DevCPL486.MakeReg(r, DI, Int32); DevCPL486.GenPop(r);
DevCPL486.GenMove(fp, sp); DevCPL486.GenPop(fp)
END;
DevCPL486.GenReturn(0)
END
END Exit;
PROCEDURE InstallStackAlloc*;
VAR name: ARRAY 32 OF SHORTCHAR; ax, cx, sp, c, x: DevCPL486.Item; l1, l2: DevCPL486.Label;
BEGIN
IF stkAllocLbl # DevCPL486.NewLbl THEN
DevCPL486.SetLabel(stkAllocLbl);
DevCPL486.MakeReg(ax, AX, Int32);
DevCPL486.MakeReg(cx, CX, Int32);
DevCPL486.MakeReg(sp, SP, Int32);
DevCPL486.GenPush(ax);
DevCPL486.MakeConst(c, -5, Int32); DevCPL486.GenAdd(c, cx, FALSE);
l1 := DevCPL486.NewLbl; DevCPL486.GenJump(ccNS, l1, TRUE);
DevCPL486.MakeConst(c, 0, Int32); DevCPL486.GenMove(c, cx);
DevCPL486.SetLabel(l1);
DevCPL486.MakeConst(c, -4, Int32); DevCPL486.GenAnd(c, cx);
DevCPL486.GenMove(cx, ax);
DevCPL486.MakeConst(c, 4095, Int32); DevCPL486.GenAnd(c, ax);
DevCPL486.GenSub(ax, sp, FALSE);
DevCPL486.GenMove(cx, ax);
DevCPL486.MakeConst(c, 12, Int32); DevCPL486.GenShiftOp(SHR, c, ax);
l2 := DevCPL486.NewLbl; DevCPL486.GenJump(ccE, l2, TRUE);
l1 := DevCPL486.NewLbl; DevCPL486.SetLabel(l1);
DevCPL486.MakeConst(c, 0, Int32); DevCPL486.GenPush(c);
DevCPL486.MakeConst(c, 4092, Int32); DevCPL486.GenSub(c, sp, FALSE);
DevCPL486.MakeConst(c, -1, Int32); DevCPL486.GenAdd(c, ax, FALSE);
DevCPL486.GenJump(ccNE, l1, TRUE);
DevCPL486.SetLabel(l2);
DevCPL486.MakeConst(c, 8, Int32); DevCPL486.GenAdd(c, cx, FALSE);
x.mode := Ind; x.form := Int32; x.offset := -4; x.index := CX; x.reg := SP; x.scale := 1;
DevCPL486.GenMove(x, ax);
DevCPL486.GenPush(ax);
DevCPL486.GenMove(x, ax);
DevCPL486.MakeConst(c, 2, Int32); DevCPL486.GenShiftOp(SHR, c, cx);
DevCPL486.GenReturn(0);
name := "$StackAlloc"; DevCPE.OutRefName(name);
END
END InstallStackAlloc;
PROCEDURE Trap* (n: INTEGER);
BEGIN
DevCPL486.GenAssert(ccNever, n)
END Trap;
PROCEDURE Jump* (VAR L: DevCPL486.Label);
BEGIN
DevCPL486.GenJump(ccAlways, L, FALSE)
END Jump;
PROCEDURE JumpT* (VAR x: DevCPL486.Item; VAR L: DevCPL486.Label);
BEGIN
DevCPL486.GenJump(x.offset, L, FALSE);
END JumpT;
PROCEDURE JumpF* (VAR x: DevCPL486.Item; VAR L: DevCPL486.Label);
BEGIN
DevCPL486.GenJump(Inverted(x.offset), L, FALSE);
END JumpF;
PROCEDURE CaseTableJump* (VAR x: DevCPL486.Item; low, high: INTEGER; VAR else: DevCPL486.Label);
VAR c: DevCPL486.Item; n: INTEGER;
BEGIN
n := high - low + 1;
DevCPL486.MakeConst(c, low, Int32); DevCPL486.GenSub(c, x, FALSE);
DevCPL486.MakeConst(c, n, Int32); DevCPL486.GenComp(c, x);
DevCPL486.GenJump(ccAE, else, FALSE);
DevCPL486.GenCaseJump(x)
END CaseTableJump;
PROCEDURE CaseJump* (VAR x: DevCPL486.Item; low, high: INTEGER; VAR this, else: DevCPL486.Label; tree, first: BOOLEAN);
VAR c: DevCPL486.Item;
BEGIN
IF high = low THEN
DevCPL486.MakeConst(c, low, Int32); DevCPL486.GenComp(c, x);
IF tree THEN DevCPL486.GenJump(ccG, else, FALSE) END;
DevCPL486.GenJump(ccE, this, FALSE)
ELSIF first THEN
DevCPL486.MakeConst(c, low, Int32); DevCPL486.GenComp(c, x);
DevCPL486.GenJump(ccL, else, FALSE);
DevCPL486.MakeConst(c, high, Int32); DevCPL486.GenComp(c, x);
DevCPL486.GenJump(ccLE, this, FALSE);
ELSE
DevCPL486.MakeConst(c, high, Int32); DevCPL486.GenComp(c, x);
DevCPL486.GenJump(ccG, else, FALSE);
DevCPL486.MakeConst(c, low, Int32); DevCPL486.GenComp(c, x);
DevCPL486.GenJump(ccGE, this, FALSE);
END
END CaseJump;
BEGIN
imLevel[0] := 0
END DevCPC486.
| Dev/Mod/CPC486.odc |
MODULE DevCPE;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT SYSTEM, Dates, DevCPM, DevCPT;
CONST
(* item base modes (=object modes) *)
Var = 1; VarPar = 2; Con = 3; LProc = 6; XProc = 7; CProc = 9; IProc = 10; TProc = 13;
(* structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Real32 = 7; Real64 = 8; Set = 9; String8 = 10; NilTyp = 11; NoTyp = 12;
Pointer = 13; ProcTyp = 14; Comp = 15;
Char16 = 16; String16 = 17; Int64 = 18; Guid = 23;
(* composite structure forms *)
Basic = 1; Array = 2; DynArr = 3; Record = 4;
(* object modes *)
Fld = 4; Typ = 5; Head = 12;
(* module visibility of objects *)
internal = 0; external = 1; externalR = 2;
(* history of imported objects *)
inserted = 0; same = 1; pbmodified = 2; pvmodified = 3; removed = 4; inconsistent = 5;
(* attribute flags (attr.adr, struct.attribute, proc.conval.setval)*)
newAttr = 16; absAttr = 17; limAttr = 18; empAttr = 19; extAttr = 20;
(* meta interface consts *)
mConst = 1; mTyp = 2; mVar = 3; mProc = 4; mField = 5;
mBool = 1; mChar8 = 2; mChar16 = 3; mInt8 = 4; mInt16 = 5; mInt32 = 6;
mReal32 = 7; mReal64 = 8; mSet = 9; mInt64 = 10; mAnyRec = 11; mAnyPtr = 12; mSysPtr = 13;
mProctyp = 0; mRecord = 1; mArray = 2; mPointer = 3;
mInternal = 1; mReadonly = 2; mPrivate = 3; mExported = 4;
mInterface = 32; mGuid = 33; mResult = 34;
(* sysflag *)
untagged = 1; noAlign = 3; union = 7; interface = 10;
(* fixup types *)
absolute = 100; relative = 101; copy = 102; table = 103; tableend = 104; short = 105;
(* kernel flags *)
iptrs = 30;
expAllFields = TRUE;
(* implementation restrictions *)
CodeBlocks = 512;
CodeLength = 16384;
MaxNameTab = 800000H;
useAllRef = FALSE;
TYPE
CodeBlock = POINTER TO ARRAY CodeLength OF SHORTCHAR;
VAR
pc*: INTEGER;
dsize*: INTEGER; (* global data size *)
KNewRec*, KNewArr*: DevCPT.Object;
closeLbl*: INTEGER;
CaseLinks*: DevCPT.LinkList;
processor: INTEGER;
bigEndian: BOOLEAN;
procVarIndirect: BOOLEAN;
idx8, idx16, idx32, idx64, namex, nofptrs, headSize: INTEGER;
Const8, Const16, Const32, Const64, Code, Data, Meta, Mod, Proc, nameList, descList, untgd: DevCPT.Object;
outRef, outAllRef, outURef, outSrc, outObj: BOOLEAN;
codePos, srcPos: INTEGER;
options: SET;
code: ARRAY CodeBlocks OF CodeBlock;
actual: CodeBlock;
actIdx, blkIdx: INTEGER;
CodeOvF: BOOLEAN;
zero: ARRAY 16 OF SHORTCHAR; (* all 0X *)
imports: INTEGER;
dllList, dllLast: DevCPT.Object;
PROCEDURE GetLongWords* (con: DevCPT.Const; OUT hi, low: INTEGER);
CONST N = 4294967296.0; (* 2^32 *)
VAR rh, rl: REAL;
BEGIN
rl := con.intval; rh := con.realval / N;
IF rh >= MAX(INTEGER) + 1.0 THEN rh := rh - 1; rl := rl + N
ELSIF rh < MIN(INTEGER) THEN rh := rh + 1; rl := rl - N
END;
hi := SHORT(ENTIER(rh));
rl := rl + (rh - hi) * N;
IF rl < 0 THEN hi := hi - 1; rl := rl + N
ELSIF rl >= N THEN hi := hi + 1; rl := rl - N
END;
IF rl >= MAX(INTEGER) + 1.0 THEN rl := rl - N END;
low := SHORT(ENTIER(rl))
(*
hi := SHORT(ENTIER((con.realval + con.intval) / 4294967296.0));
r := con.realval + con.intval - hi * 4294967296.0;
IF r > MAX(INTEGER) THEN r := r - 4294967296.0 END;
low := SHORT(ENTIER(r))
*)
END GetLongWords;
PROCEDURE GetRealWord* (con: DevCPT.Const; OUT x: INTEGER);
VAR r: SHORTREAL;
BEGIN
r := SHORT(con.realval); x := SYSTEM.VAL(INTEGER, r)
END GetRealWord;
PROCEDURE GetRealWords* (con: DevCPT.Const; OUT hi, low: INTEGER);
TYPE A = ARRAY 2 OF INTEGER;
VAR a: A;
BEGIN
a := SYSTEM.VAL(A, con.realval);
IF DevCPM.LEHost THEN hi := a[1]; low := a[0] ELSE hi := a[0]; low := a[1] END
END GetRealWords;
PROCEDURE AllocConst* (con: DevCPT.Const; form: BYTE; VAR obj: DevCPT.Object; VAR adr: INTEGER);
VAR c: DevCPT.Const;
BEGIN
INCL(con.setval, form);
CASE form OF
| String8:
obj := Const8; c := obj.conval;
WHILE (c # NIL) & ((con.setval # c.setval) OR (con.intval2 # c.intval2) OR (con.ext^ # c.ext^)) DO c := c.link END;
IF c = NIL THEN adr := idx8; INC(idx8, (con.intval2 + 3) DIV 4 * 4) END
| String16:
obj := Const16; c := obj.conval;
WHILE (c # NIL) & ((con.setval # c.setval) OR (con.intval2 # c.intval2) OR (con.ext^ # c.ext^)) DO c := c.link END;
IF c = NIL THEN adr := idx16; INC(idx16, (con.intval2 + 1) DIV 2 * 4) END
| Int64:
obj := Const64; c := obj.conval;
WHILE (c # NIL) & ((con.setval # c.setval) OR (con.intval # c.intval2) OR (con.realval # c.realval)) DO
c := c.link
END;
IF c = NIL THEN con.intval2 := con.intval; adr := idx64; INC(idx64, 8) END
| Real32:
obj := Const32; c := obj.conval;
WHILE (c # NIL) & ((con.setval # c.setval) OR (con.realval # c.realval)) DO c := c.link END;
IF c = NIL THEN adr := idx32; INC(idx32, 4) END
| Real64:
obj := Const64; c := obj.conval;
WHILE (c # NIL) & ((con.setval # c.setval) OR (con.realval # c.realval)) DO c := c.link END;
IF c = NIL THEN adr := idx64; INC(idx64, 8) END
| Guid:
obj := Const32; c := obj.conval;
WHILE (c # NIL) & ((con.setval # c.setval) OR (con.intval2 # c.intval2) OR (con.ext^ # c.ext^)) DO c := c.link END;
IF c = NIL THEN adr := idx32; INC(idx32, 16) END
END;
IF c = NIL THEN con.link := obj.conval; obj.conval := con ELSE adr := c.intval END;
con.intval := adr
END AllocConst;
PROCEDURE AllocTypDesc* (typ: DevCPT.Struct); (* typ.comp = Record *)
VAR obj: DevCPT.Object; name: DevCPT.Name;
BEGIN
IF typ.strobj = NIL THEN
name := "@"; DevCPT.Insert(name, obj); obj.name := DevCPT.null; (* avoid err 1 *)
obj.mode := Typ; obj.typ := typ; typ.strobj := obj
END
END AllocTypDesc;
PROCEDURE PutByte* (a, x: INTEGER);
BEGIN
code[a DIV CodeLength]^[a MOD CodeLength] := SHORT(CHR(x MOD 256))
END PutByte;
PROCEDURE PutShort* (a, x: INTEGER);
BEGIN
IF bigEndian THEN
PutByte(a, x DIV 256); PutByte(a + 1, x)
ELSE
PutByte(a, x); PutByte(a + 1, x DIV 256)
END
END PutShort;
PROCEDURE PutWord* (a, x: INTEGER);
BEGIN
IF bigEndian THEN
PutByte(a, x DIV 1000000H); PutByte(a + 1, x DIV 10000H);
PutByte(a + 2, x DIV 256); PutByte(a + 3, x)
ELSE
PutByte(a, x); PutByte(a + 1, x DIV 256);
PutByte(a + 2, x DIV 10000H); PutByte(a + 3, x DIV 1000000H)
END
END PutWord;
PROCEDURE ThisByte* (a: INTEGER): INTEGER;
BEGIN
RETURN ORD(code[a DIV CodeLength]^[a MOD CodeLength])
END ThisByte;
PROCEDURE ThisShort* (a: INTEGER): INTEGER;
BEGIN
IF bigEndian THEN
RETURN ThisByte(a) * 256 + ThisByte(a+1)
ELSE
RETURN ThisByte(a+1) * 256 + ThisByte(a)
END
END ThisShort;
PROCEDURE ThisWord* (a: INTEGER): INTEGER;
BEGIN
IF bigEndian THEN
RETURN ((ThisByte(a) * 256 + ThisByte(a+1)) * 256 + ThisByte(a+2)) * 256 + ThisByte(a+3)
ELSE
RETURN ((ThisByte(a+3) * 256 + ThisByte(a+2)) * 256 + ThisByte(a+1)) * 256 + ThisByte(a)
END
END ThisWord;
PROCEDURE GenByte* (x: INTEGER);
BEGIN
IF actIdx >= CodeLength THEN
IF blkIdx < CodeBlocks THEN
NEW(actual); code[blkIdx] := actual; INC(blkIdx); actIdx := 0
ELSE
IF ~CodeOvF THEN DevCPM.err(210); CodeOvF := TRUE END;
actIdx := 0; pc := 0
END
END;
actual^[actIdx] := SHORT(CHR(x MOD 256)); INC(actIdx); INC(pc)
END GenByte;
PROCEDURE GenShort* (x: INTEGER);
BEGIN
IF bigEndian THEN
GenByte(x DIV 256); GenByte(x)
ELSE
GenByte(x); GenByte(x DIV 256)
END
END GenShort;
PROCEDURE GenWord* (x: INTEGER);
BEGIN
IF bigEndian THEN
GenByte(x DIV 1000000H); GenByte(x DIV 10000H); GenByte(x DIV 256); GenByte(x)
ELSE
GenByte(x); GenByte(x DIV 256); GenByte(x DIV 10000H); GenByte(x DIV 1000000H)
END
END GenWord;
PROCEDURE WriteCode;
VAR i, j, k, n: INTEGER; b: CodeBlock;
BEGIN
j := 0; k := 0;
WHILE j < pc DO
n := pc - j; i := 0; b := code[k];
IF n > CodeLength THEN n := CodeLength END;
WHILE i < n DO DevCPM.ObjW(b^[i]); INC(i) END;
INC(j, n); INC(k)
END
END WriteCode;
PROCEDURE OffsetLink* (obj: DevCPT.Object; offs: INTEGER): DevCPT.LinkList;
VAR link: DevCPT.LinkList; m: DevCPT.Object;
BEGIN
ASSERT((obj.mode # Typ) OR (obj.typ # DevCPT.int32typ));
ASSERT((obj.mode # Typ) OR (obj.typ # DevCPT.iunktyp) & (obj.typ # DevCPT.guidtyp));
IF obj.mnolev >= 0 THEN (* not imported *)
CASE obj.mode OF
| Typ: IF obj.links = NIL THEN obj.link := descList; descList := obj END
| TProc: IF obj.adr = -1 THEN obj := obj.nlink ELSE offs := offs + obj.adr; obj := Code END
| Var: offs := offs + dsize; obj := Data
| Con, IProc, XProc, LProc:
END
ELSIF obj.mode = Typ THEN
IF obj.typ.untagged THEN (* add desc for imported untagged types *)
IF obj.links = NIL THEN obj.link := descList; descList := obj END
ELSE
m := DevCPT.GlbMod[-obj.mnolev];
IF m.library # NIL THEN RETURN NIL END (* type import from dll *)
END
END;
link := obj.links;
WHILE (link # NIL) & (link.offset # offs) DO link := link.next END;
IF link = NIL THEN
NEW(link); link.offset := offs; link.linkadr := 0;
link.next := obj.links; obj.links := link
END;
RETURN link
END OffsetLink;
PROCEDURE TypeObj* (typ: DevCPT.Struct): DevCPT.Object;
VAR obj: DevCPT.Object;
BEGIN
obj := typ.strobj;
IF obj = NIL THEN
obj := DevCPT.NewObj(); obj.leaf := TRUE; obj.mnolev := 0;
obj.name := DevCPT.null; obj.mode := Typ; obj.typ := typ; typ.strobj := obj
END;
RETURN obj
END TypeObj;
PROCEDURE Align (n: INTEGER);
VAR p: INTEGER;
BEGIN
p := DevCPM.ObjLen();
DevCPM.ObjWBytes(zero, (-p) MOD n)
END Align;
PROCEDURE OutName (VAR name: ARRAY OF SHORTCHAR);
VAR ch: SHORTCHAR; i: SHORTINT;
BEGIN i := 0;
REPEAT ch := name[i]; DevCPM.ObjW(ch); INC(i) UNTIL ch = 0X
END OutName;
PROCEDURE Out2 (x: INTEGER); (* byte ordering must correspond to target machine *)
BEGIN
IF bigEndian THEN
DevCPM.ObjW(SHORT(CHR(x DIV 256))); DevCPM.ObjW(SHORT(CHR(x)))
ELSE
DevCPM.ObjW(SHORT(CHR(x))); DevCPM.ObjW(SHORT(CHR(x DIV 256)))
END
END Out2;
PROCEDURE Out4 (x: INTEGER); (* byte ordering must correspond to target machine *)
BEGIN
IF bigEndian THEN
DevCPM.ObjW(SHORT(CHR(x DIV 1000000H))); DevCPM.ObjW(SHORT(CHR(x DIV 10000H)));
DevCPM.ObjW(SHORT(CHR(x DIV 256))); DevCPM.ObjW(SHORT(CHR(x)))
ELSE
DevCPM.ObjWLInt(x)
END
END Out4;
PROCEDURE OutReference (obj: DevCPT.Object; offs, typ: INTEGER);
VAR link: DevCPT.LinkList;
BEGIN
link := OffsetLink(obj, offs);
IF link # NIL THEN
Out4(typ * 1000000H + link.linkadr MOD 1000000H);
link.linkadr := -(DevCPM.ObjLen() - headSize - 4)
ELSE Out4(0)
END
END OutReference;
PROCEDURE FindPtrs (typ: DevCPT.Struct; adr: INTEGER; ip: BOOLEAN; VAR num: INTEGER);
VAR fld: DevCPT.Object; btyp: DevCPT.Struct; i, n: INTEGER;
BEGIN
IF typ.form = Pointer THEN
IF ip & (typ.sysflag = interface)
OR ~ip & ~typ.untagged THEN Out4(adr); INC(num) END
ELSIF (typ.comp = Record) & (typ.sysflag # union) THEN
btyp := typ.BaseTyp;
IF btyp # NIL THEN FindPtrs(btyp, adr, ip, num) END ;
fld := typ.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
IF ip & (fld.name^ = DevCPM.HdUtPtrName) & (fld.sysflag = interface)
OR ~ip & (fld.name^ = DevCPM.HdPtrName) THEN Out4(fld.adr + adr); INC(num)
ELSE FindPtrs(fld.typ, fld.adr + adr, ip, num)
END;
fld := fld.link
END
ELSIF typ.comp = Array THEN
btyp := typ.BaseTyp; n := typ.n;
WHILE btyp.comp = Array DO n := btyp.n * n; btyp := btyp.BaseTyp END ;
IF (btyp.form = Pointer) OR (btyp.comp = Record) THEN
i := num; FindPtrs(btyp, adr, ip, num);
IF num # i THEN i := 1;
WHILE i < n DO
INC(adr, btyp.size); FindPtrs(btyp, adr, ip, num); INC(i)
END
END
END
END
END FindPtrs;
PROCEDURE OutRefName* (VAR name: ARRAY OF SHORTCHAR);
BEGIN
DevCPM.ObjW(0FCX); DevCPM.ObjWNum(pc); OutName(name)
END OutRefName;
PROCEDURE OutRefs* (obj: DevCPT.Object);
VAR f: BYTE;
BEGIN
IF outRef & (obj # NIL) THEN
OutRefs(obj.left);
IF ((obj.mode = Var) OR (obj.mode = VarPar)) & (obj.history # removed) & (obj.name[0] # "@") THEN
f := obj.typ.form;
IF (f IN {Byte .. Set, Pointer, ProcTyp, Char16, Int64})
OR outURef & (obj.typ.comp # DynArr)
OR outAllRef & ~obj.typ.untagged
OR (obj.typ.comp = Array) & (obj.typ.BaseTyp.form = Char8) THEN
IF obj.mode = Var THEN DevCPM.ObjW(0FDX) ELSE DevCPM.ObjW(0FFX) END;
IF obj.typ = DevCPT.anyptrtyp THEN DevCPM.ObjW(SHORT(CHR(mAnyPtr)))
ELSIF obj.typ = DevCPT.anytyp THEN DevCPM.ObjW(SHORT(CHR(mAnyRec)))
ELSIF obj.typ = DevCPT.sysptrtyp THEN DevCPM.ObjW(SHORT(CHR(mSysPtr)))
ELSIF f = Char16 THEN DevCPM.ObjW(SHORT(CHR(mChar16)))
ELSIF f = Int64 THEN DevCPM.ObjW(SHORT(CHR(mInt64)))
ELSIF obj.typ = DevCPT.guidtyp THEN DevCPM.ObjW(SHORT(CHR(mGuid)))
ELSIF obj.typ = DevCPT.restyp THEN DevCPM.ObjW(SHORT(CHR(mResult)))
ELSIF f = Pointer THEN
IF obj.typ.sysflag = interface THEN DevCPM.ObjW(SHORT(CHR(mInterface)))
ELSIF obj.typ.untagged THEN DevCPM.ObjW(SHORT(CHR(mSysPtr)))
ELSE DevCPM.ObjW(10X); OutReference(TypeObj(obj.typ), 0, absolute)
END
ELSIF (f = Comp) & outAllRef & (~obj.typ.untagged OR outURef & (obj.typ.comp # DynArr)) THEN
DevCPM.ObjW(10X); OutReference(TypeObj(obj.typ), 0, absolute)
ELSIF f < Int8 THEN DevCPM.ObjW(SHORT(CHR(f - 1)))
ELSE DevCPM.ObjW(SHORT(CHR(f)))
END;
IF obj.mnolev = 0 THEN DevCPM.ObjWNum(obj.adr + dsize) ELSE DevCPM.ObjWNum(obj.adr) END;
OutName(obj.name^)
END
END ;
OutRefs(obj.right)
END
END OutRefs;
PROCEDURE OutSourceRef* (pos: INTEGER);
BEGIN
IF outSrc & (pos # 0) & (pos # srcPos) & (pc > codePos) THEN
WHILE pc > codePos + 250 DO
DevCPM.ObjW(SHORT(CHR(250)));
INC(codePos, 250);
DevCPM.ObjWNum(0)
END;
DevCPM.ObjW(SHORT(CHR(pc - codePos)));
codePos := pc;
DevCPM.ObjWNum(pos - srcPos);
srcPos := pos
END
END OutSourceRef;
PROCEDURE OutPLink (link: DevCPT.LinkList; adr: INTEGER);
BEGIN
WHILE link # NIL DO
ASSERT(link.linkadr # 0);
DevCPM.ObjWNum(link.linkadr);
DevCPM.ObjWNum(adr + link.offset);
link := link.next
END
END OutPLink;
PROCEDURE OutLink (link: DevCPT.LinkList);
BEGIN
OutPLink(link, 0); DevCPM.ObjW(0X)
END OutLink;
PROCEDURE OutNames;
VAR a, b, c: DevCPT.Object;
BEGIN
a := nameList; b := NIL;
WHILE a # NIL DO c := a; a := c.nlink; c.nlink := b; b := c END;
DevCPM.ObjW(0X); (* names[0] = 0X *)
WHILE b # NIL DO
OutName(b.name^);
b := b.nlink
END;
END OutNames;
PROCEDURE OutGuid* (VAR str: ARRAY OF SHORTCHAR);
PROCEDURE Copy (n: INTEGER);
VAR x, y: INTEGER;
BEGIN
x := ORD(str[n]); y := ORD(str[n + 1]);
IF x >= ORD("a") THEN DEC(x, ORD("a") - 10)
ELSIF x >= ORD("A") THEN DEC(x, ORD("A") - 10)
ELSE DEC(x, ORD("0"))
END;
IF y >= ORD("a") THEN DEC(y, ORD("a") - 10)
ELSIF y >= ORD("A") THEN DEC(y, ORD("A") - 10)
ELSE DEC(y, ORD("0"))
END;
DevCPM.ObjW(SHORT(CHR(x * 16 + y)))
END Copy;
BEGIN
IF bigEndian THEN
Copy(1); Copy(3); Copy(5); Copy(7); Copy(10); Copy(12); Copy(15); Copy(17)
ELSE
Copy(7); Copy(5); Copy(3); Copy(1); Copy(12); Copy(10); Copy(17); Copy(15)
END;
Copy(20); Copy(22); Copy(25); Copy(27); Copy(29); Copy(31); Copy(33); Copy(35)
END OutGuid;
PROCEDURE OutConst (obj: DevCPT.Object);
TYPE A4 = ARRAY 4 OF SHORTCHAR; A8 = ARRAY 8 OF SHORTCHAR;
VAR a, b, c: DevCPT.Const; r: SHORTREAL; lr: REAL; a4: A4; a8: A8; ch: SHORTCHAR; i, x, hi, low: INTEGER;
BEGIN
a := obj.conval; b := NIL;
WHILE a # NIL DO c := a; a := c.link; c.link := b; b := c END;
WHILE b # NIL DO
IF String8 IN b.setval THEN
DevCPM.ObjWBytes(b.ext^, b.intval2);
Align(4)
ELSIF String16 IN b.setval THEN
i := 0; REPEAT DevCPM.GetUtf8(b.ext^, x, i); Out2(x) UNTIL x = 0;
Align(4)
ELSIF Real32 IN b.setval THEN
r := SHORT(b.realval); a4 := SYSTEM.VAL(A4, r);
IF DevCPM.LEHost = bigEndian THEN
ch := a4[0]; a4[0] := a4[3]; a4[3] := ch;
ch := a4[1]; a4[1] := a4[2]; a4[2] := ch
END;
DevCPM.ObjWBytes(a4, 4)
ELSIF Real64 IN b.setval THEN
a8 := SYSTEM.VAL(A8, b.realval);
IF DevCPM.LEHost = bigEndian THEN
ch := a8[0]; a8[0] := a8[7]; a8[7] := ch;
ch := a8[1]; a8[1] := a8[6]; a8[6] := ch;
ch := a8[2]; a8[2] := a8[5]; a8[5] := ch;
ch := a8[3]; a8[3] := a8[4]; a8[4] := ch
END;
DevCPM.ObjWBytes(a8, 8)
ELSIF Int64 IN b.setval THEN
(* intval moved to intval2 by AllocConst *)
x := b.intval; b.intval := b.intval2; GetLongWords(b, hi, low); b.intval := x;
IF bigEndian THEN Out4(hi); Out4(low) ELSE Out4(low); Out4(hi) END
ELSIF Guid IN b.setval THEN
OutGuid(b.ext^)
END;
b := b.link
END
END OutConst;
PROCEDURE OutStruct (typ: DevCPT.Struct; unt: BOOLEAN);
BEGIN
IF typ = NIL THEN Out4(0)
ELSIF typ = DevCPT.sysptrtyp THEN Out4(mSysPtr)
ELSIF typ = DevCPT.anytyp THEN Out4(mAnyRec)
ELSIF typ = DevCPT.anyptrtyp THEN Out4(mAnyPtr)
ELSIF typ = DevCPT.guidtyp THEN Out4(mGuid)
ELSIF typ = DevCPT.restyp THEN Out4(mResult)
ELSE
CASE typ.form OF
| Undef, Byte, String8, NilTyp, NoTyp, String16: Out4(0)
| Bool, Char8: Out4(typ.form - 1)
| Int8..Set: Out4(typ.form)
| Char16: Out4(mChar16)
| Int64: Out4(mInt64)
| ProcTyp: OutReference(TypeObj(typ), 0, absolute)
| Pointer:
IF typ.sysflag = interface THEN Out4(mInterface)
ELSIF typ.untagged THEN Out4(mSysPtr)
ELSE OutReference(TypeObj(typ), 0, absolute)
END
| Comp:
IF ~typ.untagged OR (outURef & unt) THEN OutReference(TypeObj(typ), 0, absolute)
ELSE Out4(0)
END
END
END
END OutStruct;
PROCEDURE NameIdx (obj: DevCPT.Object): INTEGER;
VAR n: INTEGER;
BEGIN
n := 0;
IF obj.name # DevCPT.null THEN
IF obj.num = 0 THEN
obj.num := namex;
WHILE obj.name[n] # 0X DO INC(n) END;
INC(namex, n + 1);
obj.nlink := nameList; nameList := obj
END;
n := obj.num;
END;
RETURN n
END NameIdx;
PROCEDURE OutObject (mode, fprint, offs: INTEGER; typ: DevCPT.Struct; obj: DevCPT.Object);
VAR vis: INTEGER;
BEGIN
Out4(fprint);
Out4(offs);
IF obj.vis = internal THEN vis := mInternal
ELSIF obj.vis = externalR THEN vis := mReadonly
ELSIF obj.vis = external THEN vis := mExported
END;
Out4(mode + vis * 16 + NameIdx(obj) * 256);
OutStruct(typ, mode = mField)
END OutObject;
PROCEDURE PrepDesc (desc: DevCPT.Struct);
VAR fld: DevCPT.Object; n: INTEGER; l: DevCPT.LinkList; b: DevCPT.Struct;
BEGIN
IF desc.comp = Record THEN (* write field list *)
desc.strobj.adr := DevCPM.ObjLen() - headSize;
n := 0; fld := desc.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
IF expAllFields OR (fld.vis # internal) THEN INC(n) END;
fld := fld.link
END;
Out4(n); fld := desc.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
IF expAllFields OR (fld.vis # internal) THEN
OutObject(mField, 0, fld.adr, fld.typ, fld)
END;
fld := fld.link
END
END;
(* assert name and base type are included *)
IF desc.untagged THEN n := NameIdx(untgd)
ELSE n := NameIdx(desc.strobj)
END;
IF desc.form # ProcTyp THEN b := desc.BaseTyp;
IF (b # NIL) & (b # DevCPT.anytyp) & (b # DevCPT.anyptrtyp) & (b.form IN {Pointer, Comp})
& (b.sysflag # interface) & (b # DevCPT.guidtyp)
& (~b.untagged OR outURef & (b.form = Comp)) THEN
l := OffsetLink(TypeObj(b), 0)
END
END
END PrepDesc;
PROCEDURE NumMeth (root: DevCPT.Object; num: INTEGER): DevCPT.Object;
VAR obj: DevCPT.Object;
BEGIN
IF (root = NIL) OR (root.mode = TProc) & (root.num = num) THEN RETURN root END;
obj := NumMeth(root.left, num);
IF obj = NIL THEN obj := NumMeth(root.right, num) END;
RETURN obj
END NumMeth;
PROCEDURE OutDesc (desc: DevCPT.Struct);
VAR m: DevCPT.Object; i, nofptr, flddir, size: INTEGER; t, xb: DevCPT.Struct; form, lev, attr: BYTE;
name: DevCPT.Name;
BEGIN
ASSERT(~desc.untagged);
IF desc.comp = Record THEN
xb := desc; flddir := desc.strobj.adr;
REPEAT xb := xb.BaseTyp UNTIL (xb = NIL) OR (xb.mno # 0) OR xb.untagged;
Out4(-1); i := desc.n;
WHILE i > 0 DO DEC(i); t := desc;
REPEAT
m := NumMeth(t.link, i); t := t.BaseTyp
UNTIL (m # NIL) OR (t = xb);
IF m # NIL THEN
IF absAttr IN m.conval.setval THEN Out4(0)
ELSE OutReference(m, 0, absolute)
END
ELSIF (xb = NIL) OR xb.untagged THEN Out4(0) (* unimplemented ANYREC method *)
ELSE OutReference(xb.strobj, -4 - 4 * i, copy)
END
END;
desc.strobj.adr := DevCPM.ObjLen() - headSize; (* desc adr *)
Out4(desc.size);
OutReference(Mod, 0, absolute);
IF desc.untagged THEN m := untgd ELSE m := desc.strobj END;
IF desc.attribute = extAttr THEN attr := 1
ELSIF desc.attribute = limAttr THEN attr := 2
ELSIF desc.attribute = absAttr THEN attr := 3
ELSE attr := 0
END;
Out4(mRecord + attr * 4 + desc.extlev * 16 + NameIdx(m) * 256); i := 0;
WHILE i <= desc.extlev DO
t := desc;
WHILE t.extlev > i DO t := t.BaseTyp END;
IF t.sysflag = interface THEN Out4(0)
ELSIF t.untagged THEN OutReference(TypeObj(t), 0, absolute)
ELSIF (t.mno = 0) THEN OutReference(t.strobj, 0, absolute)
ELSIF t = xb THEN OutReference(xb.strobj, 0, absolute)
ELSE OutReference(xb.strobj, 12 + 4 * i, copy)
END;
INC(i)
END;
WHILE i <= DevCPM.MaxExts DO Out4(0); INC(i) END;
OutReference(Meta, flddir, absolute); (* ref to field list *)
nofptr := 0; FindPtrs(desc, 0, FALSE, nofptr);
Out4(-(4 * nofptr + 4));
nofptr := 0; FindPtrs(desc, 0, TRUE, nofptr);
Out4(-1)
ELSE
desc.strobj.adr := DevCPM.ObjLen() - headSize;
lev := 0; size := 0;
IF desc.comp = Array THEN
size := desc.n; form := mArray
ELSIF desc.comp = DynArr THEN
form := mArray; lev := SHORT(SHORT(desc.n + 1))
ELSIF desc.form = Pointer THEN
form := mPointer
ELSE ASSERT(desc.form = ProcTyp);
DevCPM.FPrint(size, XProc); DevCPT.FPrintSign(size, desc.BaseTyp, desc.link); form := mProctyp
END;
Out4(size);
OutReference(Mod, 0, absolute);
IF desc.untagged THEN m := untgd ELSE m := desc.strobj END;
Out4(form + lev * 16 + NameIdx(m) * 256);
IF desc.form # ProcTyp THEN OutStruct(desc.BaseTyp, TRUE) END
END
END OutDesc;
PROCEDURE OutModDesc (nofptr, refSize, namePos, ptrPos, expPos, impPos: INTEGER);
VAR i: INTEGER; t: Dates.Time; d: Dates.Date;
BEGIN
Out4(0); (* link *)
Out4(ORD(options)); (* opts *)
Out4(0); (* refcnt *)
Dates.GetDate(d); Dates.GetTime(t); (* compile time *)
Out2(d.year); Out2(d.month); Out2(d.day);
Out2(t.hour); Out2(t.minute); Out2(t.second);
Out4(0); Out4(0); Out4(0); (* load time *)
Out4(0); (* ext *)
IF closeLbl # 0 THEN OutReference(Code, closeLbl, absolute); (* terminator *)
ELSE Out4(0)
END;
Out4(imports); (* nofimps *)
Out4(nofptr); (* nofptrs *)
Out4(pc); (* csize *)
Out4(dsize); (* dsize *)
Out4(refSize); (* rsize *)
OutReference(Code, 0, absolute); (* code *)
OutReference(Data, 0, absolute); (* data *)
OutReference(Meta, 0, absolute); (* refs *)
IF procVarIndirect THEN
OutReference(Proc, 0, absolute); (* procBase *)
ELSE
OutReference(Code, 0, absolute); (* procBase *)
END;
OutReference(Data, 0, absolute); (* varBase *)
OutReference(Meta, namePos, absolute); (* names *)
OutReference(Meta, ptrPos, absolute); (* ptrs *)
OutReference(Meta, impPos, absolute); (* imports *)
OutReference(Meta, expPos, absolute); (* export *)
i := 0; (* name *)
WHILE DevCPT.SelfName[i] # 0X DO DevCPM.ObjW(DevCPT.SelfName[i]); INC(i) END;
DevCPM.ObjW(0X);
Align(4)
END OutModDesc;
PROCEDURE OutProcTable (obj: DevCPT.Object); (* 68000 *)
BEGIN
IF obj # NIL THEN
OutProcTable(obj.left);
IF obj.mode IN {XProc, IProc} THEN
Out2(4EF9H); OutReference(Code, obj.adr, absolute); Out2(0);
END;
OutProcTable(obj.right);
END;
END OutProcTable;
PROCEDURE OutExport (obj: DevCPT.Object);
VAR num: INTEGER;
BEGIN
IF obj # NIL THEN
OutExport(obj.left);
IF (obj.history # removed) & ((obj.vis # internal) OR
(obj.mode = Typ) & (obj.typ.strobj = obj) & (obj.typ.form = Comp)) THEN
DevCPT.FPrintObj(obj);
IF obj.mode IN {LProc, XProc, IProc} THEN
IF procVarIndirect THEN
ASSERT(obj.nlink = NIL);
num := obj.num; obj.num := 0;
OutObject(mProc, obj.fprint, num, NIL, obj);
obj.num := num
ELSE
OutObject(mProc, obj.fprint, obj.adr, NIL, obj)
END
ELSIF obj.mode = Var THEN
OutObject(mVar, obj.fprint, dsize + obj.adr, obj.typ, obj)
ELSIF obj.mode = Typ THEN
OutObject(mTyp, obj.typ.pbfp, obj.typ.pvfp, obj.typ, obj)
ELSE ASSERT(obj.mode IN {Con, CProc});
OutObject(mConst, obj.fprint, 0, NIL, obj)
END
END;
OutExport(obj.right)
END
END OutExport;
PROCEDURE OutCLinks (obj: DevCPT.Object);
BEGIN
IF obj # NIL THEN
OutCLinks(obj.left);
IF obj.mode IN {LProc, XProc, IProc} THEN OutPLink(obj.links, obj.adr) END;
OutCLinks(obj.right)
END
END OutCLinks;
PROCEDURE OutCPLinks (obj: DevCPT.Object; base: INTEGER);
BEGIN
IF obj # NIL THEN
OutCPLinks(obj.left, base);
IF obj.mode IN {LProc, XProc, IProc} THEN OutPLink(obj.links, obj.num + base) END;
OutCPLinks(obj.right, base)
END
END OutCPLinks;
PROCEDURE OutImport (obj: DevCPT.Object);
VAR typ: DevCPT.Struct; strobj: DevCPT.Object; opt: INTEGER;
BEGIN
IF obj # NIL THEN
OutImport(obj.left);
IF obj.mode = Typ THEN typ := obj.typ;
IF obj.used OR
(typ.form IN {Pointer, Comp}) & (typ.strobj = obj) &
((obj.links # NIL) OR (obj.name # DevCPT.null) & (typ.pvused OR typ.pbused)) THEN
DevCPT.FPrintStr(typ);
DevCPM.ObjW(SHORT(CHR(mTyp))); OutName(obj.name^);
IF obj.used THEN opt := 2 ELSE opt := 0 END;
IF (typ.form = Comp) & ((typ.pvused) OR (obj.name = DevCPT.null)) THEN
DevCPM.ObjWNum(typ.pvfp); DevCPM.ObjW(SHORT(CHR(opt + 1)));
IF obj.history = inconsistent THEN DevCPT.FPrintErr(obj, 249) END
ELSE DevCPM.ObjWNum(typ.pbfp); DevCPM.ObjW(SHORT(CHR(opt)))
END;
OutLink(obj.links)
END
ELSIF obj.used THEN
DevCPT.FPrintObj(obj);
IF obj.mode = Var THEN
DevCPM.ObjW(SHORT(CHR(mVar))); OutName(obj.name^);
DevCPM.ObjWNum(obj.fprint); OutLink(obj.links)
ELSIF obj.mode IN {XProc, IProc} THEN
DevCPM.ObjW(SHORT(CHR(mProc))); OutName(obj.name^);
DevCPM.ObjWNum(obj.fprint); OutLink(obj.links)
ELSE ASSERT(obj.mode IN {Con, CProc});
DevCPM.ObjW(SHORT(CHR(mConst))); OutName(obj.name^); DevCPM.ObjWNum(obj.fprint)
END
END;
OutImport(obj.right)
END
END OutImport;
PROCEDURE OutUseBlock;
VAR m, obj: DevCPT.Object; i: INTEGER;
BEGIN
m := dllList;
WHILE m # NIL DO
obj := m.nlink;
WHILE obj # NIL DO
IF obj.mode = Var THEN DevCPM.ObjW(SHORT(CHR(mVar)))
ELSE DevCPM.ObjW(SHORT(CHR(mProc)))
END;
IF obj.entry # NIL THEN OutName(obj.entry^)
ELSE OutName(obj.name^);
END;
DevCPT.FPrintObj(obj); DevCPM.ObjWNum(obj.fprint); OutLink(obj.links);
obj := obj.nlink
END;
DevCPM.ObjW(0X); m := m.link
END;
i := 1;
WHILE i < DevCPT.nofGmod DO
obj := DevCPT.GlbMod[i];
IF obj.library = NIL THEN OutImport(obj.right); DevCPM.ObjW(0X) END;
INC(i)
END;
END OutUseBlock;
PROCEDURE CollectDll (obj: DevCPT.Object; mod: DevCPT.String);
VAR name: DevCPT.String; dll: DevCPT.Object;
BEGIN
IF obj # NIL THEN
CollectDll(obj.left, mod);
IF obj.used & (obj.mode IN {Var, XProc, IProc}) THEN
IF obj.library # NIL THEN name := obj.library
ELSE name := mod
END;
dll := dllList;
WHILE (dll # NIL) & (dll.library^ # name^) DO dll := dll.link END;
IF dll = NIL THEN
NEW(dll); dll.library := name; INC(imports);
IF dllList = NIL THEN dllList := dll ELSE dllLast.link := dll END;
dllLast := dll; dll.left := dll;
END;
dll.left.nlink := obj; dll.left := obj
END;
CollectDll(obj.right, mod)
END
END CollectDll;
PROCEDURE EnumXProc(obj: DevCPT.Object; VAR num: INTEGER);
BEGIN
IF obj # NIL THEN
EnumXProc(obj.left, num);
IF obj.mode IN {XProc, IProc} THEN
obj.num := num; INC(num, 8);
END;
EnumXProc(obj.right, num)
END;
END EnumXProc;
PROCEDURE OutHeader*;
VAR i: INTEGER; m: DevCPT.Object;
BEGIN
DevCPM.ObjWLInt(processor); (* processor type *)
DevCPM.ObjWLInt(0); DevCPM.ObjWLInt(0); DevCPM.ObjWLInt(0);
DevCPM.ObjWLInt(0); DevCPM.ObjWLInt(0); (* sizes *)
imports := 0; i := 1;
WHILE i < DevCPT.nofGmod DO
m := DevCPT.GlbMod[i];
IF m.library # NIL THEN (* dll import *)
CollectDll(m.right, m.library);
ELSE INC(imports) (* module import *)
END;
INC(i)
END;
DevCPM.ObjWNum(imports); (* num of import *)
OutName(DevCPT.SelfName);
m := dllList;
WHILE m # NIL DO DevCPM.ObjW("$"); OutName(m.library^); m := m.link END;
i := 1;
WHILE i < DevCPT.nofGmod DO
m := DevCPT.GlbMod[i];
IF m.library = NIL THEN OutName(m.name^) END;
INC(i)
END;
Align(16); headSize := DevCPM.ObjLen();
IF procVarIndirect THEN
i := 0; EnumXProc(DevCPT.topScope.right, i)
END
END OutHeader;
PROCEDURE OutCode*;
VAR i, j, refSize, expPos, ptrPos, impPos, namePos, procPos,
con8Pos, con16Pos, con32Pos, con64Pos, modPos, codePos: INTEGER;
m, obj, dlist: DevCPT.Object;
BEGIN
(* Ref *)
DevCPM.ObjW(0X); (* end mark *)
refSize := DevCPM.ObjLen() - headSize;
(* Export *)
Align(8); expPos := DevCPM.ObjLen();
Out4(0);
OutExport(DevCPT.topScope.right); (* export objects *)
i := DevCPM.ObjLen(); DevCPM.ObjSet(expPos); Out4((i - expPos - 4) DIV 16); DevCPM.ObjSet(i);
(* Pointers *)
ptrPos := DevCPM.ObjLen();
obj := DevCPT.topScope.scope; nofptrs := 0;
WHILE obj # NIL DO FindPtrs(obj.typ, dsize + obj.adr, FALSE, nofptrs); obj := obj.link END;
obj := DevCPT.topScope.scope; i := 0;
WHILE obj # NIL DO FindPtrs(obj.typ, dsize + obj.adr, TRUE, i); obj := obj.link END;
IF i > 0 THEN Out4(-1); INCL(options, iptrs) END;
(* Prepare Type Descriptors *)
dlist := NIL;
WHILE descList # NIL DO
obj := descList; descList := descList.link;
PrepDesc(obj.typ);
obj.link := dlist; dlist := obj
END;
(* Import List *)
impPos := DevCPM.ObjLen(); i := 0;
WHILE i < imports DO Out4(0); INC(i) END;
(* Names *)
namePos := DevCPM.ObjLen(); OutNames;
(* Const *)
Align(4); con8Pos := DevCPM.ObjLen();
OutConst(Const8); con16Pos := DevCPM.ObjLen();
ASSERT(con16Pos MOD 4 = 0); ASSERT(con16Pos - con8Pos = idx8);
OutConst(Const16); con32Pos := DevCPM.ObjLen();
ASSERT(con32Pos MOD 4 = 0); ASSERT(con32Pos - con16Pos = idx16);
OutConst(Const32); con64Pos := DevCPM.ObjLen();
ASSERT(con64Pos MOD 4 = 0); ASSERT(con64Pos - con32Pos = idx32);
IF ODD(con64Pos DIV 4) THEN Out4(0); INC(con64Pos, 4) END;
OutConst(Const64); ASSERT(DevCPM.ObjLen() - con64Pos = idx64);
(* Module Descriptor *)
Align(16); modPos := DevCPM.ObjLen();
OutModDesc(nofptrs, refSize, namePos - headSize, ptrPos - headSize, expPos - headSize, impPos - headSize);
(* Procedure Table *)
procPos := DevCPM.ObjLen();
OutProcTable(DevCPT.topScope.right);
Out4(0); Out4(0); (* at least one entry in ProcTable *)
Out4(0); (* sentinel *)
(* Type Descriptors *)
obj := dlist;
WHILE obj # NIL DO OutDesc(obj.typ); obj := obj.link END;
(* Code *)
codePos := DevCPM.ObjLen(); WriteCode;
WHILE pc MOD 4 # 0 DO DevCPM.ObjW(90X); INC(pc) END;
(* Fixups *)
OutLink(KNewRec.links); OutLink(KNewArr.links);
(* metalink *)
OutPLink(Const8.links, con8Pos - headSize);
OutPLink(Const16.links, con16Pos - headSize);
OutPLink(Const32.links, con32Pos - headSize);
OutPLink(Const64.links, con64Pos - headSize);
OutLink(Meta.links);
(* desclink *)
obj := dlist; i := modPos - headSize;
WHILE obj # NIL DO OutPLink(obj.links, obj.adr - i); obj.links := NIL; obj := obj.link END;
IF procVarIndirect THEN
OutPLink(Proc.links, procPos - modPos);
OutCPLinks(DevCPT.topScope.right, procPos - modPos)
END;
OutLink(Mod.links);
(* codelink *)
IF ~procVarIndirect THEN OutCLinks(DevCPT.topScope.right) END;
OutPLink(CaseLinks, 0); OutLink(Code.links);
(* datalink *)
OutLink(Data.links);
(* Use *)
OutUseBlock;
(* Header Fixups *)
DevCPM.ObjSet(8);
DevCPM.ObjWLInt(headSize);
DevCPM.ObjWLInt(modPos - headSize);
DevCPM.ObjWLInt(codePos - modPos);
DevCPM.ObjWLInt(pc);
DevCPM.ObjWLInt(dsize);
IF namex > MaxNameTab THEN DevCPM.err(242) END;
IF DevCPM.noerr & outObj THEN DevCPM.RegisterObj END
END OutCode;
PROCEDURE Init* (proc: INTEGER; opt: SET);
CONST obj = 3; ref = 4; allref = 5; srcpos = 6; bigEnd = 15; pVarInd = 14;
BEGIN
processor := proc;
bigEndian := bigEnd IN opt; procVarIndirect := pVarInd IN opt;
outRef := ref IN opt; outAllRef := allref IN opt; outObj := obj IN opt;
outURef := useAllRef & outAllRef & (DevCPM.comAware IN DevCPM.options);
outSrc := srcpos IN opt;
pc := 0; actIdx := CodeLength; blkIdx := 0;
idx8 := 0; idx16 := 0; idx32 := 0; idx64 := 0; namex := 1;
options := opt * {0..15}; CodeOvF := FALSE;
KNewRec.links := NIL; KNewArr.links := NIL; CaseLinks := NIL;
Const8.links := NIL; Const8.conval := NIL; Const16.links := NIL; Const16.conval := NIL;
Const32.links := NIL; Const32.conval := NIL; Const64.links := NIL; Const64.conval := NIL;
Code.links := NIL; Data.links := NIL; Mod.links := NIL; Proc.links := NIL; Meta.links := NIL;
nameList := NIL; descList := NIL; dllList := NIL; dllLast := NIL;
codePos := 0; srcPos := 0;
NEW(untgd); untgd.name := DevCPT.NewName("!");
closeLbl := 0
END Init;
PROCEDURE Close*;
BEGIN
KNewRec.links := NIL; KNewArr.links := NIL; CaseLinks := NIL;
Const8.links := NIL; Const8.conval := NIL; Const16.links := NIL; Const16.conval := NIL;
Const32.links := NIL; Const32.conval := NIL; Const64.links := NIL; Const64.conval := NIL;
Code.links := NIL; Data.links := NIL; Mod.links := NIL; Proc.links := NIL; Meta.links := NIL;
nameList := NIL; descList := NIL; dllList := NIL; dllLast := NIL;
WHILE blkIdx > 0 DO DEC(blkIdx); code[blkIdx] := NIL END;
actual := NIL; untgd := NIL;
END Close;
BEGIN
NEW(KNewRec); KNewRec.mnolev := -128;
NEW(KNewArr); KNewArr.mnolev := -128;
NEW(Const8); Const8.mode := Con; Const8.mnolev := 0;
NEW(Const16); Const16.mode := Con; Const16.mnolev := 0;
NEW(Const32); Const32.mode := Con; Const32.mnolev := 0;
NEW(Const64); Const64.mode := Con; Const64.mnolev := 0;
NEW(Code); Code.mode := Con; Code.mnolev := 0;
NEW(Data); Data.mode := Con; Data.mnolev := 0;
NEW(Mod); Mod.mode := Con; Mod.mnolev := 0;
NEW(Proc); Proc.mode := Con; Proc.mnolev := 0;
NEW(Meta); Meta.mode := Con; Mod.mnolev := 0;
END DevCPE.
| Dev/Mod/CPE.odc |
MODULE DevCPH;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT DevCPT;
CONST
(* UseCalls options *)
longMop* = 0; longDop* = 1; longConv* = 2; longOdd* = 3;
realMop* = 8; realDop* = 9; realConv* = 10;
intMulDiv* = 11;
force = 16; hide = 17;
(* nodes classes *)
Nvar = 0; Nvarpar = 1; Nfield = 2; Nderef = 3; Nindex = 4; Nguard = 5; Neguard = 6;
Nconst = 7; Ntype = 8; Nproc = 9; Nupto = 10; Nmop = 11; Ndop = 12; Ncall = 13;
Ninittd = 14; Nif = 15; Ncaselse = 16; Ncasedo = 17; Nenter = 18; Nassign = 19;
Nifelse =20; Ncase = 21; Nwhile = 22; Nrepeat = 23; Nloop = 24; Nexit = 25;
Nreturn = 26; Nwith = 27; Ntrap = 28; Ncomp = 30;
Ndrop = 50; Nlabel = 51; Ngoto = 52; Njsr = 53; Nret = 54; Ncmp = 55;
(*function number*)
assign = 0; newfn = 1; incfn = 13; decfn = 14;
inclfn = 15; exclfn = 16; copyfn = 18; assertfn = 32;
getfn = 24; putfn = 25; getrfn = 26; putrfn = 27; sysnewfn = 30; movefn = 31;
(* symbol values and ops *)
times = 1; slash = 2; div = 3; mod = 4;
and = 5; plus = 6; minus = 7; or = 8; eql = 9;
neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14;
in = 15; is = 16; ash = 17; msk = 18; len = 19;
conv = 20; abs = 21; cap = 22; odd = 23; not = 33;
adr = 24; cc = 25; bit = 26; lsh = 27; rot = 28; val = 29;
min = 34; max = 35; typfn = 36;
thisrecfn = 45; thisarrfn = 46;
shl = 50; shr = 51; lshr = 52; xor = 53;
(* structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Real32 = 7; Real64 = 8; Set = 9; String8 = 10; NilTyp = 11; NoTyp = 12;
Pointer = 13; ProcTyp = 14; Comp = 15;
Char16 = 16; String16 = 17; Int64 = 18;
VString16to8 = 29; VString8 = 30; VString16 = 31;
realSet = {Real32, Real64};
Basic = 1; Array = 2; DynArr = 3; Record = 4;
PROCEDURE UseThisCall (n: DevCPT.Node; IN name: ARRAY OF SHORTCHAR);
VAR mod, nm, moda: DevCPT.Name; mobj, obj: DevCPT.Object; done: BOOLEAN;
BEGIN
IF (n.typ.form = Real64) OR (n.left.typ.form = Real64) THEN mod := "Real"
ELSIF (n.typ.form = Real32) OR (n.left.typ.form = Real32) THEN mod := "SReal"
ELSIF (n.typ.form = Int64) OR (n.left.typ.form = Int64) THEN mod := "Long"
ELSE mod := "Int"
END;
moda := mod + "%";
DevCPT.Find(moda, mobj);
IF mobj = NIL THEN
DevCPT.Import(moda, mod, done);
IF done THEN DevCPT.Find(moda, mobj) END
END;
nm := name$; DevCPT.FindImport(nm, mobj, obj);
n.class := Ncall; n.subcl := 0; n.obj := obj.link;
n.left.link := n.right; n.right := n.left;
n.left := DevCPT.NewNode(Nproc);
n.left.obj := obj; n.left.typ := obj.typ;
ASSERT(n.typ.form = obj.typ.form)
END UseThisCall;
PROCEDURE Convert (n: DevCPT.Node; typ: DevCPT.Struct);
VAR new: DevCPT.Node; r: REAL;
BEGIN
IF n.class = Nconst THEN
ASSERT((n.typ.form IN {Int32, Int64}) & (typ = DevCPT.intrealtyp));
r := n.conval.realval + n.conval.intval;
IF r = n.conval.realval + n.conval.intval THEN
n.conval.realval := r; n.conval.intval := -1; n.typ := typ; n.obj := NIL
END
END;
IF (n.typ # typ)
& ((n.class # Nmop) OR (n.subcl # conv)
OR ~DevCPT.Includes(n.typ.form, n.left.typ.form) & ~DevCPT.Includes(n.typ.form, typ.form)) THEN
new := DevCPT.NewNode(0); new^ := n^;
n.class := Nmop; n.subcl := conv; n.left := new; n.right := NIL; n.obj := NIL
END;
n.typ := typ
END Convert;
PROCEDURE UseCallForComp (n: DevCPT.Node);
VAR new: DevCPT.Node;
BEGIN
new := DevCPT.NewNode(0);
new.left := n.left; new.right := n.right;
new.typ := DevCPT.int32typ;
UseThisCall(new, "Comp");
n.left := new;
n.right := DevCPT.NewNode(Nconst); n.right.conval := DevCPT.NewConst();
n.right.conval.intval := 0; n.right.conval.realval := 0; n.right.typ := DevCPT.int32typ;
END UseCallForComp;
PROCEDURE UseCallForConv (n: DevCPT.Node; opts: SET);
VAR f, g: INTEGER; typ: DevCPT.Struct;
BEGIN
typ := n.typ; f := typ.form; g := n.left.typ.form;
IF realConv IN opts THEN
IF f IN realSet THEN
IF g = Real32 THEN UseThisCall(n, "Long")
ELSIF g = Real64 THEN UseThisCall(n, "Short")
ELSIF g = Int64 THEN UseThisCall(n, "LFloat")
ELSIF g = Int32 THEN UseThisCall(n, "Float")
ELSE Convert(n.left, DevCPT.int32typ); UseThisCall(n, "Float")
END
ELSIF g IN realSet THEN
IF f = Int64 THEN UseThisCall(n, "LFloor")
ELSIF f = Int32 THEN UseThisCall(n, "Floor")
ELSE n.typ := DevCPT.int32typ; UseThisCall(n, "Floor"); Convert(n, typ)
END
END
END;
IF longConv IN opts THEN
IF f = Int64 THEN
IF g = Int32 THEN UseThisCall(n, "Long")
ELSIF ~(g IN realSet) THEN Convert(n.left, DevCPT.int32typ); UseThisCall(n, "IntToLong")
END
ELSIF g = Int64 THEN
IF f = Int32 THEN UseThisCall(n, "Short")
ELSIF ~(f IN realSet) THEN n.typ := DevCPT.int32typ; UseThisCall(n, "LongToInt"); Convert(n, typ)
END
END
END
END UseCallForConv;
PROCEDURE UseCallForMop (n: DevCPT.Node; opts: SET);
BEGIN
CASE n.subcl OF
| minus:
IF (realMop IN opts) & (n.typ.form IN realSet) OR (longMop IN opts) & (n.typ.form = Int64) THEN
UseThisCall(n, "Neg")
END
| abs:
IF (realMop IN opts) & (n.typ.form IN realSet) OR (longMop IN opts) & (n.typ.form = Int64) THEN
UseThisCall(n, "Abs")
END
| odd:
IF (longOdd IN opts) & (n.left.typ.form = Int64) THEN UseThisCall(n, "Odd") END
| conv:
UseCallForConv(n, opts)
ELSE
END
END UseCallForMop;
PROCEDURE UseCallForDop (n: DevCPT.Node; opts: SET);
BEGIN
IF (realDop IN opts) & (n.left.typ.form IN realSet)
OR (longDop IN opts) & (n.left.typ.form = Int64)
OR (intMulDiv IN opts) & (n.subcl IN {times, div, mod}) & (n.typ.form = Int32) THEN
CASE n.subcl OF
| times: UseThisCall(n, "Mul")
| slash: UseThisCall(n, "Div")
| div: UseThisCall(n, "Div")
| mod: UseThisCall(n, "Mod")
| plus: UseThisCall(n, "Add")
| minus: UseThisCall(n, "Sub")
| ash: UseThisCall(n, "Ash")
| min: UseThisCall(n, "Min")
| max: UseThisCall(n, "Max")
| eql..geq: UseCallForComp(n)
ELSE
END
END
END UseCallForDop;
PROCEDURE UseCallForMove (n: DevCPT.Node; typ: DevCPT.Struct; opts: SET);
VAR f, g: INTEGER;
BEGIN
f := n.typ.form; g := typ.form;
IF f # g THEN
IF (realConv IN opts) & ((f IN realSet) OR (g IN realSet))
OR (longConv IN opts) & ((f = Int64) OR (g = Int64)) THEN
Convert(n, typ);
UseCallForConv(n, opts)
END
END
END UseCallForMove;
PROCEDURE UseCallForAssign (n: DevCPT.Node; opts: SET);
BEGIN
IF n.subcl = assign THEN UseCallForMove(n.right, n.left.typ, opts) END
END UseCallForAssign;
PROCEDURE UseCallForReturn (n: DevCPT.Node; opts: SET);
BEGIN
IF (n.left # NIL) & (n.obj # NIL) THEN UseCallForMove(n.left, n.obj.typ, opts) END
END UseCallForReturn;
PROCEDURE UseCallForParam (n: DevCPT.Node; fp: DevCPT.Object; opts: SET);
BEGIN
WHILE n # NIL DO
UseCallForMove(n, fp.typ, opts);
n := n.link; fp := fp.link
END
END UseCallForParam;
PROCEDURE UseCalls* (n: DevCPT.Node; opts: SET);
BEGIN
WHILE n # NIL DO
CASE n.class OF
| Nmop:
UseCalls(n.left, opts); UseCallForMop(n, opts)
| Ndop:
UseCalls(n.left, opts); UseCalls(n.right, opts); UseCallForDop(n, opts)
| Ncase:
UseCalls(n.left, opts); UseCalls(n.right.left, opts); UseCalls(n.right.right, opts)
| Nassign:
UseCalls(n.left, opts); UseCalls(n.right, opts); UseCallForAssign(n, opts)
| Ncall:
UseCalls(n.left, opts); UseCalls(n.right, opts); UseCallForParam(n.right, n.obj, opts)
| Nreturn:
UseCalls(n.left, opts); UseCallForReturn(n, opts)
| Ncasedo:
UseCalls(n.right, opts)
| Ngoto, Ndrop, Nloop, Nfield, Nderef, Nguard:
UseCalls(n.left, opts)
| Nenter, Nifelse, Nif, Nwhile, Nrepeat, Nwith, Ncomp, Nupto, Nindex:
UseCalls(n.left, opts); UseCalls(n.right, opts)
| Njsr, Nret, Nlabel, Ntrap, Nexit, Ninittd, Ntype, Nproc, Nconst, Nvar, Nvarpar:
END;
n := n.link
END
END UseCalls;
PROCEDURE UseReals* (n: DevCPT.Node; opts: SET);
BEGIN
WHILE n # NIL DO
CASE n.class OF
| Nmop:
IF (longMop IN opts) & (n.typ.form = Int64) & ((n.subcl = abs) OR (n.subcl = minus)) THEN
UseReals(n.left, opts - {hide} + {force}); n.typ := DevCPT.intrealtyp
ELSIF n.subcl = conv THEN UseReals(n.left, opts - {force} + {hide})
ELSE UseReals(n.left, opts - {force, hide})
END
| Ndop:
IF (longDop IN opts) & (n.left.typ.form = Int64) THEN
UseReals(n.left, opts - {hide} + {force}); UseReals(n.right, opts - {hide} + {force});
IF n.typ.form = Int64 THEN n.typ := DevCPT.intrealtyp END
ELSE UseReals(n.left, opts - {force, hide}); UseReals(n.right, opts - {force, hide})
END
| Ncase:
UseReals(n.left, opts - {force, hide}); UseReals(n.right.left, opts - {force, hide});
UseReals(n.right.right, opts - {force, hide})
| Ncasedo:
UseReals(n.right, opts - {force, hide})
| Ngoto, Ndrop, Nloop, Nreturn, Nfield, Nderef, Nguard:
UseReals(n.left, opts - {force, hide})
| Nenter, Nassign, Ncall, Nifelse, Nif, Nwhile, Nrepeat, Nwith, Ncomp, Nupto, Nindex:
UseReals(n.left, opts - {force, hide}); UseReals(n.right, opts - {force, hide})
| Njsr, Nret, Nlabel, Ntrap, Nexit, Ninittd, Ntype, Nproc, Nconst, Nvar, Nvarpar:
END;
IF force IN opts THEN Convert(n, DevCPT.intrealtyp)
ELSIF ~(hide IN opts) & (n.typ = DevCPT.intrealtyp) THEN Convert(n, DevCPT.int64typ)
END;
n := n.link
END
END UseReals;
END DevCPH.
PROCEDURE Traverse (n: DevCPT.Node; opts: SET);
BEGIN
WHILE n # NIL DO
CASE n.class OF
| Ncase:
Traverse(n.left, opts); Traverse(n.right.left, opts); Traverse(n.right.right, opts)
| Ncasedo:
Traverse(n.right, opts)
| Ngoto, Ndrop, Nloop, Nreturn, Nmop, Nfield, Nderef, Nguard:
Traverse(n.left, opts)
| Nenter, Nassign, Ncall, Nifelse, Nif, Nwhile, Nrepeat, Nwith, Ncomp, Ndop, Nupto, Nindex:
Traverse(n.left, opts); Traverse(n.right, opts)
| Njsr, Nret, Nlabel, Ntrap, Nexit, Ninittd, Ntype, Nproc, Nconst, Nvar, Nvarpar:
END;
n := n.link
END
END Traverse;
| Dev/Mod/CPH.odc |
MODULE DevCPL486;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT DevCPM, DevCPT, DevCPE;
TYPE
Item* = RECORD
mode*, tmode*, form*: BYTE;
offset*, index*, reg*, scale*: INTEGER; (* adr = offset + index * scale *)
typ*: DevCPT.Struct;
obj*: DevCPT.Object
END ;
(* Items:
mode | offset index scale reg obj
------------------------------------------------
1 Var | adr xreg scale obj (ea = FP + adr + xreg * scale)
2 VarPar| off xreg scale obj (ea = [FP + obj.adr] + off + xreg * scale)
3 Con | val (val2) NIL
Con | off obj (val = adr(obj) + off)
Con | id NIL (for predefined reals)
6 LProc | obj
7 XProc | obj
9 CProc | obj
10 IProc | obj
13 TProc | mthno 0/1 obj (0 = normal / 1 = super call)
14 Ind | off xreg scale Reg (ea = Reg + off + xreg * scale)
15 Abs | adr xreg scale NIL (ea = adr + xreg * scale)
Abs | off xreg scale obj (ea = adr(obj) + off + xreg * scale)
Abs | off len 0 obj (for constant strings and reals)
16 Stk | (ea = ESP)
17 Cond | CC
18 Reg | (Reg2) Reg
19 DInd | off xreg scale Reg (ea = [Reg + off + xreg * scale])
tmode | record tag array desc
-------------------------------------
VarPar | [FP + obj.adr + 4] [FP + obj.adr]
Ind | [Reg - 4] [Reg + 8]
Con | Adr(typ.strobj)
*)
CONST
processor* = 10; (* for i386 *)
NewLbl* = 0;
TYPE
Label* = INTEGER; (* 0: unassigned, > 0: address, < 0: - (linkadr + linktype * 2^24) *)
VAR
level*: BYTE;
one*: DevCPT.Const;
CONST
(* item base modes (=object modes) *)
Var = 1; VarPar = 2; Con = 3; LProc = 6; XProc = 7; CProc = 9; IProc = 10; TProc = 13;
(* item modes for i386 (must not overlap item basemodes, > 13) *)
Ind = 14; Abs = 15; Stk = 16; Cond = 17; Reg = 18; DInd = 19;
(* structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Real32 = 7; Real64 = 8; Set = 9; String8 = 10; NilTyp = 11; NoTyp = 12;
Pointer = 13; ProcTyp = 14; Comp = 15;
Char16 = 16; String16 = 17; Int64 = 18; Guid = 23;
(* composite structure forms *)
Basic = 1; Array = 2; DynArr = 3; Record = 4;
(* condition codes *)
ccB = 2; ccAE = 3; ccBE = 6; ccA = 7; (* unsigned *)
ccL = 12; ccGE = 13; ccLE = 14; ccG = 15; (* signed *)
ccE = 4; ccNE = 5; ccS = 8; ccNS = 9; ccO = 0; ccNO = 1;
ccAlways = -1; ccNever = -2; ccCall = -3;
(* registers *)
AX = 0; CX = 1; DX = 2; BX = 3; SP = 4; BP = 5; SI = 6; DI = 7; AH = 4; CH = 5; DH = 6; BH = 7;
(* fixup types *)
absolute = 100; relative = 101; copy = 102; table = 103; tableend = 104; short = 105;
(* system trap numbers *)
withTrap = -1; caseTrap = -2; funcTrap = -3; typTrap = -4;
recTrap = -5; ranTrap = -6; inxTrap = -7; copyTrap = -8;
VAR
Size: ARRAY 32 OF INTEGER; (* Size[typ.form] == +/- typ.size *)
a1, a2: Item;
PROCEDURE MakeReg* (VAR x: Item; reg: INTEGER; form: BYTE);
BEGIN
ASSERT((reg >= 0) & (reg < 8));
x.mode := Reg; x.reg := reg; x.form := form
END MakeReg;
PROCEDURE MakeConst* (VAR x: Item; val: INTEGER; form: BYTE);
BEGIN
x.mode := Con; x.offset := val; x.form := form; x.obj := NIL;
END MakeConst;
PROCEDURE AllocConst* (VAR x: Item; con: DevCPT.Const; form: BYTE);
VAR r: REAL; short: SHORTREAL; c: DevCPT.Const; i: INTEGER;
BEGIN
IF form IN {Real32, Real64} THEN
r := con.realval;
IF ABS(r) <= MAX(SHORTREAL) THEN
short := SHORT(r);
IF short = r THEN form := Real32 (* a shortreal can represent the exact value *)
ELSE form := Real64 (* use a real *)
END
ELSE form := Real64 (* use a real *)
END
ELSIF form IN {String8, String16, Guid} THEN
x.index := con.intval2 (* string length *)
END;
DevCPE.AllocConst(con, form, x.obj, x.offset);
x.form := form; x.mode := Abs; x.scale := 0
END AllocConst;
(*******************************************************)
PROCEDURE BegStat*; (* general-purpose procedure which is called before each statement *)
BEGIN
END BegStat;
PROCEDURE EndStat*; (* general-purpose procedure which is called after each statement *)
BEGIN
END EndStat;
(*******************************************************)
PROCEDURE SetLabel* (VAR L: Label);
VAR link, typ, disp, x: INTEGER; c: SHORTCHAR;
BEGIN
ASSERT(L <= 0); link := -L;
WHILE link # 0 DO
typ := link DIV 1000000H; link := link MOD 1000000H;
IF typ = short THEN
disp := DevCPE.pc - link - 1; ASSERT(disp < 128);
DevCPE.PutByte(link, disp); link := 0
ELSIF typ = relative THEN
x := DevCPE.ThisWord(link); DevCPE.PutWord(link, DevCPE.pc - link - 4); link := x
ELSE
x := DevCPE.ThisWord(link); DevCPE.PutWord(link, DevCPE.pc + typ * 1000000H); link := x
END
END;
L := DevCPE.pc;
a1.mode := 0; a2.mode := 0
END SetLabel;
(*******************************************************)
PROCEDURE GenWord (x: INTEGER);
BEGIN
DevCPE.GenByte(x); DevCPE.GenByte(x DIV 256)
END GenWord;
PROCEDURE GenDbl (x: INTEGER);
BEGIN
DevCPE.GenByte(x); DevCPE.GenByte(x DIV 256); DevCPE.GenByte(x DIV 10000H); DevCPE.GenByte(x DIV 1000000H)
END GenDbl;
PROCEDURE CaseEntry* (tab, from, to: INTEGER);
VAR a, e: INTEGER;
BEGIN
a := tab + 4 * from; e := tab + 4 * to;
WHILE a <= e DO
DevCPE.PutByte(a, DevCPE.pc);
DevCPE.PutByte(a + 1, DevCPE.pc DIV 256);
DevCPE.PutByte(a + 2, DevCPE.pc DIV 65536);
INC(a, 4)
END;
a1.mode := 0; a2.mode := 0
END CaseEntry;
PROCEDURE GenLinked (VAR x: Item; type: BYTE);
VAR link: DevCPT.LinkList;
BEGIN
IF x.obj = NIL THEN GenDbl(x.offset)
ELSE
link := DevCPE.OffsetLink(x.obj, x.offset);
IF link # NIL THEN
GenDbl(type * 1000000H + link.linkadr MOD 1000000H);
link.linkadr := DevCPE.pc - 4
ELSE GenDbl(0)
END
END
END GenLinked;
PROCEDURE CheckSize (form: BYTE; VAR w: INTEGER);
BEGIN
IF form IN {Int16, Char16} THEN DevCPE.GenByte(66H); w := 1
ELSIF form >= Int32 THEN ASSERT(form IN {Int32, Set, NilTyp, Pointer, ProcTyp}); w := 1
ELSE w := 0
END
END CheckSize;
PROCEDURE CheckForm (form: BYTE; VAR mf: INTEGER);
BEGIN
IF form = Real32 THEN mf := 0
ELSIF form = Real64 THEN mf := 4
ELSIF form = Int32 THEN mf := 2
ELSE ASSERT(form = Int16); mf := 6
END
END CheckForm;
PROCEDURE CheckConst (VAR x: Item; VAR s: INTEGER);
BEGIN
IF (x.form > Int8) & (x.offset >= -128) & (x.offset < 128) & (x.obj = NIL) THEN s := 2
ELSE s := 0
END
END CheckConst;
PROCEDURE GenConst (VAR x: Item; short: BOOLEAN);
BEGIN
IF x.obj # NIL THEN GenLinked(x, absolute)
ELSIF x.form <= Int8 THEN DevCPE.GenByte(x.offset)
ELSIF short & (x.offset >= -128) & (x.offset < 128) THEN DevCPE.GenByte(x.offset)
ELSIF x.form IN {Int16, Char16} THEN GenWord(x.offset)
ELSE GenDbl(x.offset)
END
END GenConst;
PROCEDURE GenCExt (code: INTEGER; VAR x: Item);
VAR disp, mod, base, scale: INTEGER;
BEGIN
ASSERT(x.mode IN {Reg, Ind, Abs, Stk});
ASSERT((code MOD 8 = 0) & (code < 64));
disp := x.offset; base := x.reg; scale := x.scale;
IF x.mode = Reg THEN mod := 0C0H; scale := 0
ELSIF x.mode = Stk THEN base := SP; mod := 0; disp := 0; scale := 0
ELSIF x.mode = Abs THEN
IF scale = 1 THEN base := x.index; mod := 80H; scale := 0
ELSE base := BP; mod := 0
END
ELSIF (disp = 0) & (base # BP) THEN mod := 0
ELSIF (disp >= -128) & (disp < 128) THEN mod := 40H
ELSE mod := 80H
END;
IF scale # 0 THEN
DevCPE.GenByte(mod + code + 4); base := base + x.index * 8;
IF scale = 8 THEN DevCPE.GenByte(0C0H + base);
ELSIF scale = 4 THEN DevCPE.GenByte(80H + base);
ELSIF scale = 2 THEN DevCPE.GenByte(40H + base);
ELSE ASSERT(scale = 1); DevCPE.GenByte(base);
END;
ELSE
DevCPE.GenByte(mod + code + base);
IF (base = SP) & (mod <= 80H) THEN DevCPE.GenByte(24H) END
END;
IF x.mode = Abs THEN GenLinked(x, absolute)
ELSIF mod = 80H THEN GenDbl(disp)
ELSIF mod = 40H THEN DevCPE.GenByte(disp)
END
END GenCExt;
PROCEDURE GenDExt (VAR r, x: Item);
BEGIN
ASSERT(r.mode = Reg);
GenCExt(r.reg * 8, x)
END GenDExt;
(*******************************************************)
PROCEDURE GenMove* (VAR from, to: Item);
VAR w: INTEGER;
BEGIN
ASSERT(Size[from.form] = Size[to.form]);
IF to.mode = Reg THEN
IF from.mode = Con THEN
IF to.reg = AX THEN
IF (a1.mode = Con) & (from.offset = a1.offset) & (from.obj = a1.obj) & (from.form = a1.form) THEN
RETURN
END;
a1 := from; a2.mode := 0
END;
CheckSize(from.form, w);
IF (from.offset = 0) & (from.obj = NIL) THEN
DevCPE.GenByte(30H + w); DevCPE.GenByte(0C0H + 9 * to.reg) (* XOR r,r *)
ELSE
DevCPE.GenByte(0B0H + w * 8 + to.reg); GenConst(from, FALSE)
END;
ELSIF (to.reg = AX) & (from.mode = Abs) & (from.scale = 0) THEN
IF (a1.mode = Abs) & (from.offset = a1.offset) & (from.obj = a1.obj) & (from.form = a1.form)
OR (a2.mode = Abs) & (from.offset = a2.offset) & (from.obj = a2.obj) & (from.form = a2.form) THEN
RETURN
END;
a1 := from; a2.mode := 0;
CheckSize(from.form, w);
DevCPE.GenByte(0A0H + w); GenLinked(from, absolute);
ELSIF (from.mode # Reg) OR (from.reg # to.reg) THEN
IF to.reg = AX THEN
IF (from.mode = Ind) & (from.scale = 0) & ((from.reg = BP) OR (from.reg = BX)) THEN
IF (a1.mode = Ind) & (from.offset = a1.offset) & (from.reg = a1.reg) & (from.form = a1.form)
OR (a2.mode = Ind) & (from.offset = a2.offset) & (from.reg = a2.reg) & (from.form = a2.form) THEN
RETURN
END;
a1 := from
ELSE a1.mode := 0
END;
a2.mode := 0
END;
CheckSize(from.form, w);
DevCPE.GenByte(8AH + w); GenDExt(to, from)
END
ELSE
CheckSize(from.form, w);
IF from.mode = Con THEN
DevCPE.GenByte(0C6H + w); GenCExt(0, to); GenConst(from, FALSE);
a1.mode := 0; a2.mode := 0
ELSIF (from.reg = AX) & (to.mode = Abs) & (to.scale = 0) THEN
DevCPE.GenByte(0A2H + w); GenLinked(to, absolute);
a2 := to
ELSE
DevCPE.GenByte(88H + w); GenDExt(from, to);
IF from.reg = AX THEN
IF (to.mode = Ind) & (to.scale = 0) & ((to.reg = BP) OR (to.reg = BX)) THEN a2 := to END
ELSE a1.mode := 0; a2.mode := 0
END
END
END
END GenMove;
PROCEDURE GenExtMove* (VAR from, to: Item);
VAR w, op: INTEGER;
BEGIN
ASSERT(from.mode # Con);
IF from.form IN {Byte, Char8, Char16} THEN op := 0B6H (* MOVZX *)
ELSE op := 0BEH (* MOVSX *)
END;
IF from.form IN {Int16, Char16} THEN INC(op) END;
DevCPE.GenByte(0FH); DevCPE.GenByte(op); GenDExt(to, from);
IF to.reg = AX THEN a1.mode := 0; a2.mode := 0 END
END GenExtMove;
PROCEDURE GenSignExt* (VAR from, to: Item);
BEGIN
ASSERT(to.mode = Reg);
IF (from.mode = Reg) & (from.reg = AX) & (to.reg = DX) THEN
DevCPE.GenByte(99H) (* cdq *)
ELSE
GenMove(from, to); (* mov to, from *)
DevCPE.GenByte(0C1H); GenCExt(38H, to); DevCPE.GenByte(31) (* sar to, 31 *)
END
END GenSignExt;
PROCEDURE GenLoadAdr* (VAR from, to: Item);
BEGIN
ASSERT(to.form IN {Int32, Pointer, ProcTyp});
IF (from.mode = Abs) & (from.scale = 0) THEN
DevCPE.GenByte(0B8H + to.reg); GenLinked(from, absolute)
ELSIF from.mode = Stk THEN
DevCPE.GenByte(89H); GenCExt(SP * 8, to)
ELSIF (from.mode # Ind) OR (from.offset # 0) OR (from.scale # 0) THEN
DevCPE.GenByte(8DH); GenDExt(to, from)
ELSIF from.reg # to.reg THEN
DevCPE.GenByte(89H); GenCExt(from.reg * 8, to)
ELSE RETURN
END;
IF to.reg = AX THEN a1.mode := 0; a2.mode := 0 END
END GenLoadAdr;
PROCEDURE GenPush* (VAR src: Item);
VAR s: INTEGER;
BEGIN
IF src.mode = Con THEN
ASSERT(src.form >= Int32);
CheckConst(src, s); DevCPE.GenByte(68H + s); GenConst(src, TRUE)
ELSIF src.mode = Reg THEN
ASSERT((src.form >= Int16) OR (src.reg < 4));
DevCPE.GenByte(50H + src.reg)
ELSE
ASSERT(src.form >= Int32);
DevCPE.GenByte(0FFH); GenCExt(30H, src)
END
END GenPush;
PROCEDURE GenPop* (VAR dst: Item);
BEGIN
IF dst.mode = Reg THEN
ASSERT((dst.form >= Int16) OR (dst.reg < 4));
DevCPE.GenByte(58H + dst.reg);
IF dst.reg = AX THEN a1.mode := 0; a2.mode := 0 END
ELSE
DevCPE.GenByte(08FH); GenCExt(0, dst)
END
END GenPop;
PROCEDURE GenConOp (op: INTEGER; VAR src, dst: Item);
VAR w, s: INTEGER;
BEGIN
ASSERT(Size[src.form] = Size[dst.form]);
CheckSize(src.form, w);
CheckConst(src, s);
IF (dst.mode = Reg) & (dst.reg = AX) & (s = 0) THEN
DevCPE.GenByte(op + 4 + w); GenConst(src, FALSE)
ELSE
DevCPE.GenByte(80H + s + w); GenCExt(op, dst); GenConst(src, TRUE)
END
END GenConOp;
PROCEDURE GenDirOp (op: INTEGER; VAR src, dst: Item);
VAR w: INTEGER;
BEGIN
ASSERT(Size[src.form] = Size[dst.form]);
CheckSize(src.form, w);
IF dst.mode = Reg THEN
DevCPE.GenByte(op + 2 + w); GenDExt(dst, src)
ELSE
DevCPE.GenByte(op + w); GenDExt(src, dst)
END
END GenDirOp;
PROCEDURE GenAdd* (VAR src, dst: Item; ovflchk: BOOLEAN);
VAR w: INTEGER;
BEGIN
ASSERT(Size[src.form] = Size[dst.form]);
IF src.mode = Con THEN
IF src.obj = NIL THEN
IF src.offset = 1 THEN
IF (dst.mode = Reg) & (dst.form >= Int32) THEN DevCPE.GenByte(40H + dst.reg) (* inc *)
ELSE CheckSize(dst.form, w); DevCPE.GenByte(0FEH + w); GenCExt(0, dst)
END
ELSIF src.offset = -1 THEN
IF (dst.mode = Reg) & (dst.form >= Int32) THEN DevCPE.GenByte(48H + dst.reg) (* dec *)
ELSE CheckSize(dst.form, w); DevCPE.GenByte(0FEH + w); GenCExt(8, dst)
END
ELSIF src.offset # 0 THEN
GenConOp(0, src, dst)
ELSE RETURN
END
ELSE
GenConOp(0, src, dst)
END
ELSE
GenDirOp(0, src, dst)
END;
IF ovflchk THEN DevCPE.GenByte(0CEH) END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenAdd;
PROCEDURE GenAddC* (VAR src, dst: Item; first, ovflchk: BOOLEAN);
VAR op: INTEGER;
BEGIN
ASSERT(Size[src.form] = Size[dst.form]);
IF first THEN op := 0 ELSE op := 10H END;
IF src.mode = Con THEN GenConOp(op, src, dst)
ELSE GenDirOp(op, src, dst)
END;
IF ovflchk THEN DevCPE.GenByte(0CEH) END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenAddC;
PROCEDURE GenSub* (VAR src, dst: Item; ovflchk: BOOLEAN);
VAR w: INTEGER;
BEGIN
ASSERT(Size[src.form] = Size[dst.form]);
IF src.mode = Con THEN
IF src.obj = NIL THEN
IF src.offset = 1 THEN
IF (dst.mode = Reg) & (dst.form >= Int32) THEN DevCPE.GenByte(48H + dst.reg) (* dec *)
ELSE CheckSize(dst.form, w); DevCPE.GenByte(0FEH + w); GenCExt(8, dst)
END
ELSIF src.offset = -1 THEN
IF (dst.mode = Reg) & (dst.form >= Int32) THEN DevCPE.GenByte(40H + dst.reg) (* inc *)
ELSE CheckSize(dst.form, w); DevCPE.GenByte(0FEH + w); GenCExt(0, dst)
END
ELSIF src.offset # 0 THEN
GenConOp(28H, src, dst)
ELSE RETURN
END
ELSE
GenConOp(28H, src, dst)
END
ELSE
GenDirOp(28H, src, dst)
END;
IF ovflchk THEN DevCPE.GenByte(0CEH) END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenSub;
PROCEDURE GenSubC* (VAR src, dst: Item; first, ovflchk: BOOLEAN);
VAR op: INTEGER;
BEGIN
ASSERT(Size[src.form] = Size[dst.form]);
IF first THEN op := 28H ELSE op := 18H END;
IF src.mode = Con THEN GenConOp(op, src, dst)
ELSE GenDirOp(op, src, dst)
END;
IF ovflchk THEN DevCPE.GenByte(0CEH) END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenSubC;
PROCEDURE GenComp* (VAR src, dst: Item);
VAR w: INTEGER;
BEGIN
IF src.mode = Con THEN
IF (src.offset = 0) & (src.obj = NIL) & (dst.mode = Reg) THEN
CheckSize(dst.form, w); DevCPE.GenByte(8 + w); DevCPE.GenByte(0C0H + 9 * dst.reg) (* or r,r *)
ELSE GenConOp(38H, src, dst)
END
ELSE
GenDirOp(38H, src, dst)
END
END GenComp;
PROCEDURE GenAnd* (VAR src, dst: Item);
BEGIN
IF src.mode = Con THEN
IF (src.obj # NIL) OR (src.offset # -1) THEN GenConOp(20H, src, dst) END
ELSE GenDirOp(20H, src, dst)
END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenAnd;
PROCEDURE GenOr* (VAR src, dst: Item);
BEGIN
IF src.mode = Con THEN
IF (src.obj # NIL) OR (src.offset # 0) THEN GenConOp(8H, src, dst) END
ELSE GenDirOp(8H, src, dst)
END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenOr;
PROCEDURE GenXor* (VAR src, dst: Item);
BEGIN
IF src.mode = Con THEN
IF (src.obj # NIL) OR (src.offset # 0) THEN GenConOp(30H, src, dst) END
ELSE GenDirOp(30H, src, dst)
END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenXor;
PROCEDURE GenTest* (VAR x, y: Item);
VAR w: INTEGER;
BEGIN
ASSERT(Size[x.form] = Size[y.form]);
CheckSize(x.form, w);
IF x.mode = Con THEN
IF (x.mode = Reg) & (x.reg = AX) THEN
DevCPE.GenByte(0A8H + w); GenConst(x, FALSE)
ELSE
DevCPE.GenByte(0F6H + w); GenCExt(0, y); GenConst(x, FALSE)
END
ELSE
DevCPE.GenByte(84H + w);
IF y.mode = Reg THEN GenDExt(y, x) ELSE GenDExt(x, y) END
END
END GenTest;
PROCEDURE GenNeg* (VAR dst: Item; ovflchk: BOOLEAN);
VAR w: INTEGER;
BEGIN
CheckSize(dst.form, w); DevCPE.GenByte(0F6H + w); GenCExt(18H, dst);
IF ovflchk THEN DevCPE.GenByte(0CEH) END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenNeg;
PROCEDURE GenNot* (VAR dst: Item);
VAR w: INTEGER;
BEGIN
CheckSize(dst.form, w); DevCPE.GenByte(0F6H + w); GenCExt(10H, dst);
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenNot;
PROCEDURE GenMul* (VAR src, dst: Item; ovflchk: BOOLEAN);
VAR w, s, val, f2, f5, f9: INTEGER;
BEGIN
ASSERT((dst.mode = Reg) & (Size[src.form] = Size[dst.form]));
IF (src.mode = Con) & (src.offset = 1) THEN RETURN END;
IF src.form <= Int8 THEN
ASSERT(dst.reg = 0);
DevCPE.GenByte(0F6H); GenCExt(28H, src)
ELSIF src.mode = Con THEN
val := src.offset;
IF (src.obj = NIL) & (val # 0) & ~ovflchk THEN
f2 := 0; f5 := 0; f9 := 0;
WHILE ~ODD(val) DO val := val DIV 2; INC(f2) END;
WHILE val MOD 9 = 0 DO val := val DIV 9; INC(f9) END;
WHILE val MOD 5 = 0 DO val := val DIV 5; INC(f5) END;
IF ABS(val) <= 3 THEN
WHILE f9 > 0 DO
DevCPE.GenByte(8DH);
DevCPE.GenByte(dst.reg * 8 + 4);
DevCPE.GenByte(0C0H + dst.reg * 9);
DEC(f9)
END;
WHILE f5 > 0 DO
DevCPE.GenByte(8DH);
DevCPE.GenByte(dst.reg * 8 + 4);
DevCPE.GenByte(80H + dst.reg * 9);
DEC(f5)
END;
IF ABS(val) = 3 THEN
DevCPE.GenByte(8DH); DevCPE.GenByte(dst.reg * 8 + 4); DevCPE.GenByte(40H + dst.reg * 9)
END;
IF f2 > 1 THEN DevCPE.GenByte(0C1H); DevCPE.GenByte(0E0H + dst.reg); DevCPE.GenByte(f2)
ELSIF f2 = 1 THEN DevCPE.GenByte(1); DevCPE.GenByte(0C0H + dst.reg * 9)
END;
IF val < 0 THEN DevCPE.GenByte(0F7H); GenCExt(18H, dst) END;
IF dst.reg = AX THEN a1.mode := 0; a2.mode := 0 END;
RETURN
END
END;
CheckSize(src.form, w); CheckConst(src, s);
DevCPE.GenByte(69H + s); GenDExt(dst, dst); GenConst(src, TRUE)
ELSE
CheckSize(src.form, w);
DevCPE.GenByte(0FH); DevCPE.GenByte(0AFH); GenDExt(dst, src)
END;
IF ovflchk THEN DevCPE.GenByte(0CEH) END;
IF dst.reg = AX THEN a1.mode := 0; a2.mode := 0 END
END GenMul;
PROCEDURE GenDiv* (VAR src: Item; mod, pos: BOOLEAN);
VAR w, rem: INTEGER;
BEGIN
ASSERT(src.mode = Reg);
IF src.form >= Int32 THEN DevCPE.GenByte(99H) (* cdq *)
ELSIF src.form = Int16 THEN DevCPE.GenByte(66H); DevCPE.GenByte(99H) (* cwd *)
ELSE DevCPE.GenByte(66H); DevCPE.GenByte(98H) (* cbw *)
END;
CheckSize(src.form, w); DevCPE.GenByte(0F6H + w); GenCExt(38H, src); (* idiv src *)
IF src.form > Int8 THEN rem := 2 (* edx *) ELSE rem := 4 (* ah *) END;
IF pos THEN (* src > 0 *)
CheckSize(src.form, w); DevCPE.GenByte(8 + w); DevCPE.GenByte(0C0H + 9 * rem); (* or rem,rem *)
IF mod THEN
DevCPE.GenByte(79H); DevCPE.GenByte(2); (* jns end *)
DevCPE.GenByte(2 + w); GenCExt(8 * rem, src); (* add rem,src *)
ELSE
DevCPE.GenByte(79H); DevCPE.GenByte(1); (* jns end *)
DevCPE.GenByte(48H); (* dec eax *)
END
ELSE
CheckSize(src.form, w); DevCPE.GenByte(30H + w); GenCExt(8 * rem, src); (* xor src,rem *)
IF mod THEN
DevCPE.GenByte(79H); (* jns end *)
IF src.form = Int16 THEN DevCPE.GenByte(9); DevCPE.GenByte(66H) ELSE DevCPE.GenByte(8) END;
DevCPE.GenByte(8 + w); DevCPE.GenByte(0C0H + 9 * rem); (* or rem,rem *)
DevCPE.GenByte(74H); DevCPE.GenByte(4); (* je end *)
DevCPE.GenByte(30H + w); GenCExt(8 * rem, src); (* xor src,rem *)
DevCPE.GenByte(2 + w); GenCExt(8 * rem, src); (* add rem,src *)
ELSE
DevCPE.GenByte(79H); (* jns end *)
IF src.form = Int16 THEN DevCPE.GenByte(6); DevCPE.GenByte(66H) ELSE DevCPE.GenByte(5) END;
DevCPE.GenByte(8 + w); DevCPE.GenByte(0C0H + 9 * rem); (* or rem,rem *)
DevCPE.GenByte(74H); DevCPE.GenByte(1); (* je end *)
DevCPE.GenByte(48H); (* dec eax *)
END
(*
CheckSize(src.form, w); DevCPE.GenByte(3AH + w); GenCExt(8 * rem, src); (* cmp rem,src *)
IF mod THEN
DevCPE.GenByte(72H); DevCPE.GenByte(4); (* jb end *)
DevCPE.GenByte(7FH); DevCPE.GenByte(2); (* jg end *)
DevCPE.GenByte(2 + w); GenCExt(8 * rem, src); (* add rem,src *)
ELSE
DevCPE.GenByte(72H); DevCPE.GenByte(3); (* jb end *)
DevCPE.GenByte(7FH); DevCPE.GenByte(1); (* jg end *)
DevCPE.GenByte(48H); (* dec eax *)
END
*)
END;
a1.mode := 0; a2.mode := 0
END GenDiv;
PROCEDURE GenShiftOp* (op: INTEGER; VAR cnt, dst: Item);
VAR w: INTEGER;
BEGIN
CheckSize(dst.form, w);
IF cnt.mode = Con THEN
ASSERT(cnt.offset >= 0); ASSERT(cnt.obj = NIL);
IF cnt.offset = 1 THEN
IF (op = 10H) & (dst.mode = Reg) THEN (* shl r *)
DevCPE.GenByte(w); GenDExt(dst, dst) (* add r, r *)
ELSE
DevCPE.GenByte(0D0H + w); GenCExt(op, dst)
END
ELSIF cnt.offset > 1 THEN
DevCPE.GenByte(0C0H + w); GenCExt(op, dst); DevCPE.GenByte(cnt.offset)
END
ELSE
ASSERT((cnt.mode = Reg) & (cnt.reg = CX));
DevCPE.GenByte(0D2H + w); GenCExt(op, dst)
END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenShiftOp;
PROCEDURE GenBitOp* (op: INTEGER; VAR num, dst: Item);
BEGIN
DevCPE.GenByte(0FH);
IF num.mode = Con THEN
ASSERT(num.obj = NIL);
DevCPE.GenByte(0BAH); GenCExt(op, dst); DevCPE.GenByte(num.offset)
ELSE
ASSERT((num.mode = Reg) & (num.form = Int32));
DevCPE.GenByte(83H + op); GenDExt(num, dst)
END;
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenBitOp;
PROCEDURE GenSetCC* (cc: INTEGER; VAR dst: Item);
BEGIN
ASSERT((dst.form = Bool) & (cc >= 0));
DevCPE.GenByte(0FH); DevCPE.GenByte(90H + cc); GenCExt(0, dst);
IF (dst.mode # Reg) OR (dst.reg = AX) THEN a1.mode := 0; a2.mode := 0 END
END GenSetCC;
PROCEDURE GenFLoad* (VAR src: Item);
VAR mf: INTEGER;
BEGIN
IF src.mode = Con THEN (* predefined constants *)
DevCPE.GenByte(0D9H); DevCPE.GenByte(0E8H + src.offset)
ELSIF src.form = Int64 THEN
DevCPE.GenByte(0DFH); GenCExt(28H, src)
ELSE
CheckForm(src.form, mf);
DevCPE.GenByte(0D9H + mf); GenCExt(0, src)
END
END GenFLoad;
PROCEDURE GenFStore* (VAR dst: Item; pop: BOOLEAN);
VAR mf: INTEGER;
BEGIN
IF dst.form = Int64 THEN ASSERT(pop);
DevCPE.GenByte(0DFH); GenCExt(38H, dst); DevCPE.GenByte(9BH) (* wait *)
ELSE
CheckForm(dst.form, mf); DevCPE.GenByte(0D9H + mf);
IF pop THEN GenCExt(18H, dst); DevCPE.GenByte(9BH) (* wait *)
ELSE GenCExt(10H, dst)
END
END;
a1.mode := 0; a2.mode := 0
END GenFStore;
PROCEDURE GenFDOp* (op: INTEGER; VAR src: Item);
VAR mf: INTEGER;
BEGIN
IF src.mode = Reg THEN
DevCPE.GenByte(0DEH); DevCPE.GenByte(0C1H + op)
ELSE
CheckForm(src.form, mf);
DevCPE.GenByte(0D8H + mf); GenCExt(op, src)
END
END GenFDOp;
PROCEDURE GenFMOp* (op: INTEGER);
BEGIN
DevCPE.GenByte(0D8H + op DIV 256);
DevCPE.GenByte(op MOD 256);
IF op = 07E0H THEN a1.mode := 0; a2.mode := 0 END (* FSTSW AX *)
END GenFMOp;
PROCEDURE GenJump* (cc: INTEGER; VAR L: Label; shortjmp: BOOLEAN);
BEGIN
IF cc # ccNever THEN
IF shortjmp OR (L > 0) & (DevCPE.pc + 2 - L <= 128) & (cc # ccCall) THEN
IF cc = ccAlways THEN DevCPE.GenByte(0EBH)
ELSE DevCPE.GenByte(70H + cc)
END;
IF L > 0 THEN DevCPE.GenByte(L - DevCPE.pc - 1)
ELSE ASSERT(L = 0); L := -(DevCPE.pc + short * 1000000H); DevCPE.GenByte(0)
END
ELSE
IF cc = ccAlways THEN DevCPE.GenByte(0E9H)
ELSIF cc = ccCall THEN DevCPE.GenByte(0E8H)
ELSE DevCPE.GenByte(0FH); DevCPE.GenByte(80H + cc)
END;
IF L > 0 THEN GenDbl(L - DevCPE.pc - 4)
ELSE GenDbl(-L); L := -(DevCPE.pc - 4 + relative * 1000000H)
END
END
END
END GenJump;
PROCEDURE GenExtJump* (cc: INTEGER; VAR dst: Item);
BEGIN
IF cc = ccAlways THEN DevCPE.GenByte(0E9H)
ELSE DevCPE.GenByte(0FH); DevCPE.GenByte(80H + cc)
END;
dst.offset := 0; GenLinked(dst, relative)
END GenExtJump;
PROCEDURE GenIndJump* (VAR dst: Item);
BEGIN
DevCPE.GenByte(0FFH); GenCExt(20H, dst)
END GenIndJump;
PROCEDURE GenCaseJump* (VAR src: Item);
VAR link: DevCPT.LinkList; tab: INTEGER;
BEGIN
ASSERT((src.form = Int32) & (src.mode = Reg));
DevCPE.GenByte(0FFH); DevCPE.GenByte(24H); DevCPE.GenByte(85H + 8 * src.reg);
tab := (DevCPE.pc + 7) DIV 4 * 4;
NEW(link); link.offset := tab; link.linkadr := DevCPE.pc;
link.next := DevCPE.CaseLinks; DevCPE.CaseLinks := link;
GenDbl(absolute * 1000000H + tab);
WHILE DevCPE.pc < tab DO DevCPE.GenByte(90H) END;
END GenCaseJump;
(*
PROCEDURE GenCaseJump* (VAR src: Item; num: LONGINT; VAR tab: LONGINT);
VAR link: DevCPT.LinkList; else, last: LONGINT;
BEGIN
ASSERT((src.form = Int32) & (src.mode = Reg));
DevCPE.GenByte(0FFH); DevCPE.GenByte(24H); DevCPE.GenByte(85H + 8 * src.reg);
tab := (DevCPE.pc + 7) DIV 4 * 4;
else := tab + num * 4; last := else - 4;
NEW(link); link.offset := tab; link.linkadr := DevCPE.pc;
link.next := CaseLinks; CaseLinks := link;
GenDbl(absolute * 1000000H + tab);
WHILE DevCPE.pc < tab DO DevCPE.GenByte(90H) END;
WHILE DevCPE.pc < last DO GenDbl(table * 1000000H + else) END;
GenDbl(tableend * 1000000H + else)
END GenCaseJump;
*)
PROCEDURE GenCaseEntry* (VAR L: Label; last: BOOLEAN);
VAR typ: INTEGER;
BEGIN
IF last THEN typ := tableend * 1000000H ELSE typ := table * 1000000H END;
IF L > 0 THEN GenDbl(L + typ) ELSE GenDbl(-L); L := -(DevCPE.pc - 4 + typ) END
END GenCaseEntry;
PROCEDURE GenCall* (VAR dst: Item);
BEGIN
IF dst.mode IN {LProc, XProc, IProc} THEN
DevCPE.GenByte(0E8H);
IF dst.obj.mnolev >= 0 THEN (* local *)
IF dst.obj.adr > 0 THEN GenDbl(dst.obj.adr - DevCPE.pc - 4)
ELSE GenDbl(-dst.obj.adr); dst.obj.adr := -(DevCPE.pc - 4 + relative * 1000000H)
END
ELSE (* imported *)
dst.offset := 0; GenLinked(dst, relative)
END
ELSE DevCPE.GenByte(0FFH); GenCExt(10H, dst)
END;
a1.mode := 0; a2.mode := 0
END GenCall;
PROCEDURE GenAssert* (cc, no: INTEGER);
BEGIN
IF cc # ccAlways THEN
IF cc >= 0 THEN
DevCPE.GenByte(70H + cc); (* jcc end *)
IF no < 0 THEN DevCPE.GenByte(2) ELSE DevCPE.GenByte(3) END
END;
IF no < 0 THEN
DevCPE.GenByte(8DH); DevCPE.GenByte(0E0H - no)
ELSE
DevCPE.GenByte(8DH); DevCPE.GenByte(0F0H); DevCPE.GenByte(no)
END
END
END GenAssert;
PROCEDURE GenReturn* (val: INTEGER);
BEGIN
IF val = 0 THEN DevCPE.GenByte(0C3H)
ELSE DevCPE.GenByte(0C2H); GenWord(val)
END;
a1.mode := 0; a2.mode := 0
END GenReturn;
PROCEDURE LoadStr (size: INTEGER);
BEGIN
IF size = 2 THEN DevCPE.GenByte(66H) END;
IF size <= 1 THEN DevCPE.GenByte(0ACH) ELSE DevCPE.GenByte(0ADH) END (* lods *)
END LoadStr;
PROCEDURE StoreStr (size: INTEGER);
BEGIN
IF size = 2 THEN DevCPE.GenByte(66H) END;
IF size <= 1 THEN DevCPE.GenByte(0AAH) ELSE DevCPE.GenByte(0ABH) END (* stos *)
END StoreStr;
PROCEDURE ScanStr (size: INTEGER; rep: BOOLEAN);
BEGIN
IF size = 2 THEN DevCPE.GenByte(66H) END;
IF rep THEN DevCPE.GenByte(0F2H) END;
IF size <= 1 THEN DevCPE.GenByte(0AEH) ELSE DevCPE.GenByte(0AFH) END (* scas *)
END ScanStr;
PROCEDURE TestNull (size: INTEGER);
BEGIN
IF size = 2 THEN DevCPE.GenByte(66H) END;
IF size <= 1 THEN DevCPE.GenByte(8); DevCPE.GenByte(0C0H); (* or al,al *)
ELSE DevCPE.GenByte(9); DevCPE.GenByte(0C0H); (* or ax,ax *)
END
END TestNull;
PROCEDURE GenBlockMove* (wsize, len: INTEGER); (* len = 0: len in ECX *)
VAR w: INTEGER;
BEGIN
IF len = 0 THEN (* variable size move *)
IF wsize = 4 THEN w := 1 ELSIF wsize = 2 THEN w := 1; DevCPE.GenByte(66H) ELSE w := 0 END;
DevCPE.GenByte(0F3H); DevCPE.GenByte(0A4H + w); (* rep:movs *)
ELSE (* fixed size move *)
len := len * wsize;
IF len >= 16 THEN
DevCPE.GenByte(0B9H); GenDbl(len DIV 4); (* ld ecx,len/4 *)
DevCPE.GenByte(0F3H); DevCPE.GenByte(0A5H); (* rep:movs long*)
len := len MOD 4
END;
WHILE len >= 4 DO DevCPE.GenByte(0A5H); DEC(len, 4) END; (* movs long *);
IF len >= 2 THEN DevCPE.GenByte(66H); DevCPE.GenByte(0A5H) END; (* movs word *);
IF ODD(len) THEN DevCPE.GenByte(0A4H) END; (* movs byte *)
END
END GenBlockMove;
PROCEDURE GenBlockStore* (wsize, len: INTEGER); (* len = 0: len in ECX *)
VAR w: INTEGER;
BEGIN
IF len = 0 THEN (* variable size move *)
IF wsize = 4 THEN w := 1 ELSIF wsize = 2 THEN w := 1; DevCPE.GenByte(66H) ELSE w := 0 END;
DevCPE.GenByte(0F3H); DevCPE.GenByte(0AAH + w); (* rep:stos *)
ELSE (* fixed size move *)
len := len * wsize;
IF len >= 16 THEN
DevCPE.GenByte(0B9H); GenDbl(len DIV 4); (* ld ecx,len/4 *)
DevCPE.GenByte(0F3H); DevCPE.GenByte(0ABH); (* rep:stos long*)
len := len MOD 4
END;
WHILE len >= 4 DO DevCPE.GenByte(0ABH); DEC(len, 4) END; (* stos long *);
IF len >= 2 THEN DevCPE.GenByte(66H); DevCPE.GenByte(0ABH) END; (* stos word *);
IF ODD(len) THEN DevCPE.GenByte(0ABH) END; (* stos byte *)
END
END GenBlockStore;
PROCEDURE GenBlockComp* (wsize, len: INTEGER); (* len = 0: len in ECX *)
VAR w: INTEGER;
BEGIN
ASSERT(len >= 0);
IF len > 0 THEN DevCPE.GenByte(0B9H); GenDbl(len) END; (* ld ecx,len *)
IF wsize = 4 THEN w := 1 ELSIF wsize = 2 THEN w := 1; DevCPE.GenByte(66H) ELSE w := 0 END;
DevCPE.GenByte(0F3H); DevCPE.GenByte(0A6H + w) (* repe:cmps *)
END GenBlockComp;
PROCEDURE GenStringMove* (excl: BOOLEAN; wsize, dsize, len: INTEGER);
(*
len = 0: len in ECX, len = -1: len undefined; wsize # dsize -> convert; size = 0: opsize = 1, incsize = 2; excl: don't move 0X
*)
VAR loop, end: Label;
BEGIN
IF len > 0 THEN DevCPE.GenByte(0B9H); GenDbl(len) END; (* ld ecx,len *)
(* len >= 0: len IN ECX *)
IF (dsize = 2) & (wsize < 2) THEN DevCPE.GenByte(31H); DevCPE.GenByte(0C0H) END; (* xor eax,eax *)
loop := NewLbl; end := NewLbl;
SetLabel(loop); LoadStr(wsize);
IF wsize = 0 THEN DevCPE.GenByte(46H) END; (* inc esi *)
IF len < 0 THEN (* no limit *)
StoreStr(dsize); TestNull(wsize); GenJump(ccNE, loop, TRUE);
IF excl THEN (* dec edi *)
DevCPE.GenByte(4FH);
IF dsize # 1 THEN DevCPE.GenByte(4FH) END
END;
ELSE (* cx limit *)
IF excl THEN TestNull(wsize); GenJump(ccE, end, TRUE); StoreStr(dsize)
ELSE StoreStr(dsize); TestNull(wsize); GenJump(ccE, end, TRUE)
END;
DevCPE.GenByte(49H); (* dec ecx *)
GenJump(ccNE, loop, TRUE);
GenAssert(ccNever, copyTrap); (* trap *)
SetLabel(end)
END;
a1.mode := 0; a2.mode := 0
END GenStringMove;
PROCEDURE GenStringComp* (wsize, dsize: INTEGER);
(* wsize # dsize -> convert; size = 0: opsize = 1, incsize = 2; *)
VAR loop, end: Label;
BEGIN
IF (dsize = 2) & (wsize < 2) THEN DevCPE.GenByte(31H); DevCPE.GenByte(0C0H); (* xor eax,eax *) END;
loop := NewLbl; end := NewLbl;
SetLabel(loop); LoadStr(wsize);
IF wsize = 0 THEN DevCPE.GenByte(46H) END; (* inc esi *)
ScanStr(dsize, FALSE); GenJump(ccNE, end, TRUE);
IF dsize = 0 THEN DevCPE.GenByte(47H) END; (* inc edi *)
TestNull(wsize); GenJump(ccNE, loop, TRUE);
SetLabel(end);
a1.mode := 0; a2.mode := 0
END GenStringComp;
PROCEDURE GenStringLength* (wsize, len: INTEGER); (* len = 0: len in ECX, len = -1: len undefined *)
BEGIN
DevCPE.GenByte(31H); DevCPE.GenByte(0C0H); (* xor eax,eax *)
IF len # 0 THEN DevCPE.GenByte(0B9H); GenDbl(len) END; (* ld ecx,len *)
ScanStr(wsize, TRUE);
a1.mode := 0; a2.mode := 0
END GenStringLength;
PROCEDURE GenStrStore* (size: INTEGER);
VAR w: INTEGER;
BEGIN
IF size # 0 THEN
IF size MOD 4 = 0 THEN w := 1; size := size DIV 4
ELSIF size MOD 2 = 0 THEN w := 2; size := size DIV 2
ELSE w := 0
END;
DevCPE.GenByte(0B9H); GenDbl(size); (* ld ecx,size *)
IF w = 2 THEN DevCPE.GenByte(66H); w := 1 END
ELSE w := 0
END;
DevCPE.GenByte(0F3H); DevCPE.GenByte(0AAH + w); (* rep:stos *)
a1.mode := 0; a2.mode := 0
END GenStrStore;
PROCEDURE GenCode* (op: INTEGER);
BEGIN
DevCPE.GenByte(op);
a1.mode := 0; a2.mode := 0
END GenCode;
PROCEDURE Init*(opt: SET);
BEGIN
DevCPE.Init(processor, opt);
level := 0;
NEW(one); one.realval := 1.0; one.intval := DevCPM.ConstNotAlloc;
END Init;
PROCEDURE Close*;
BEGIN
a1.obj := NIL; a1.typ := NIL; a2.obj := NIL; a2.typ := NIL; one := NIL;
DevCPE.Close
END Close;
BEGIN
Size[Undef] := 0;
Size[Byte] := 1;
Size[Bool] := 1;
Size[Char8] := 1;
Size[Int8] := 1;
Size[Int16] := 2;
Size[Int32] := 4;
Size[Real32] := -4;
Size[Real64] := -8;
Size[Set] := 4;
Size[String8] := 0;
Size[NilTyp] := 4;
Size[NoTyp] := 0;
Size[Pointer] := 4;
Size[ProcTyp] := 4;
Size[Comp] := 0;
Size[Char16] := 2;
Size[Int64] := 8;
Size[String16] := 0
END DevCPL486.
| Dev/Mod/CPL486.odc |
MODULE DevCPM;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT SYSTEM, Kernel, Files, Stores, Models, Views, TextModels, TextMappers, StdLog, DevMarkers;
CONST
ProcSize* = 4; (* PROCEDURE type *)
PointerSize* = 4; (* POINTER type *)
DArrSizeA* = 8; (* dyn array descriptor *)
DArrSizeB* = 4; (* size = A + B * typ.n *)
MaxSet* = 31;
MaxIndex* = 7FFFFFFFH; (* maximal index value for array declaration *)
MinReal32Pat = 0FF7FFFFFH; (* most positive, 32-bit pattern *)
MinReal64PatL = 0FFFFFFFFH; (* most negative, lower 32-bit pattern *)
MinReal64PatH = 0FFEFFFFFH; (* most negative, higher 32-bit pattern *)
MaxReal32Pat = 07F7FFFFFH; (* most positive, 32-bit pattern *)
MaxReal64PatL = 0FFFFFFFFH; (* most positive, lower 32-bit pattern *)
MaxReal64PatH = 07FEFFFFFH; (* most positive, higher 32-bit pattern *)
InfRealPat = 07F800000H; (* real infinity pattern *)
(* inclusive range of parameter of standard procedure HALT *)
MinHaltNr* = 0;
MaxHaltNr* = 128;
(* inclusive range of register number of procedures SYSTEM.GETREG and SYSTEM.PUTREG *)
MinRegNr* = 0;
MaxRegNr* = 31;
(* maximal value of flag used to mark interface structures *)
MaxSysFlag* = 127; (* shortint *)
CProcFlag* = 1; (* code procedures *)
(* maximal condition value of parameter of SYSTEM.CC *)
MaxCC* = 15;
(* initialization of constant address, must be different from any valid constant address *)
ConstNotAlloc* = -1;
(* whether hidden pointer fields have to be nevertheless exported *)
ExpHdPtrFld* = TRUE;
HdPtrName* = "@ptr";
(* whether hidden untagged pointer fields have to be nevertheless exported *)
ExpHdUtPtrFld* = TRUE;
HdUtPtrName* = "@utptr";
(* whether hidden procedure fields have to be nevertheless exported (may be used for System.Free) *)
ExpHdProcFld* = TRUE;
HdProcName* = "@proc";
(* whether hidden bound procedures have to be nevertheless exported *)
ExpHdTProc* = FALSE;
HdTProcName* = "@tproc";
(* maximal number of exported stuctures: *)
MaxStruct* = 4096; (* must be < MAX(INTEGER) DIV 2 in object model *)
(* maximal number of record extensions: *)
MaxExts* = 15; (* defined by type descriptor layout *)
(* whether field leaf of pointer variable p has to be set to FALSE, when NEW(p) or SYSTEM.NEW(p, n) is used *)
NEWusingAdr* = FALSE;
(* special character (< " ") returned by procedure Get, if end of text reached *)
Eot* = 0X;
(* warnings *)
longreal* = 0; largeint* = 1; realConst* = 2; copy* = 3; lchr* = 4; lentier* = 5; invar* = 6; outvar* = 7;
(* language options *)
interface* = 1;
com* = 2; comAware* = 3;
som* = 4; somAware* = 5;
oberon* = 6;
java* = 7; javaAware* = 8;
noCode* = 9;
allSysVal* = 14;
sysImp* = 15;
trap* = 31;
sys386 = 10; sys68k = 20; (* processor type in options if system imported *)
CONST
SFdir = "Sym";
OFdir = "Code";
SYSdir = "System";
SFtag = 6F4F5346H; (* symbol file tag *)
OFtag = 6F4F4346H; (* object file tag *)
maxErrors = 64;
TYPE
File = POINTER TO RECORD next: File; f: Files.File END;
VAR
LEHost*: BOOLEAN; (* little or big endian host *)
MinReal32*, MaxReal32*, InfReal*,
MinReal64*, MaxReal64*: REAL;
noerr*: BOOLEAN; (* no error found until now *)
curpos*, startpos*, errpos*: INTEGER; (* character, start, and error position in source file *)
searchpos*: INTEGER; (* search position in source file *)
errors*: INTEGER;
breakpc*: INTEGER; (* set by OPV.Init *)
options*: SET; (* language options *)
file*: Files.File; (* used for sym file import *)
codeDir*: ARRAY 16 OF CHAR;
symDir*: ARRAY 16 OF CHAR;
lastpos: INTEGER;
realpat: INTEGER;
lrealpat: RECORD H, L: INTEGER END;
fpi, fpj: SHORTINT; fp: ARRAY 4 OF SHORTCHAR;
ObjFName: Files.Name;
in: TextModels.Reader;
oldSymFile, symFile, objFile: Files.File;
inSym: Files.Reader;
outSym, outObj: Files.Writer;
errNo, errPos: ARRAY maxErrors OF INTEGER;
lineReader: TextModels.Reader;
lineNum: INTEGER;
PROCEDURE^ err* (n: INTEGER);
PROCEDURE Init* (source: TextModels.Reader; logtext: TextModels.Model);
BEGIN
in := source;
DevMarkers.Unmark(in.Base());
noerr := TRUE; options := {};
curpos := in.Pos(); errpos := curpos; lastpos := curpos - 11; errors := 0;
codeDir := OFdir; symDir := SFdir
END Init;
PROCEDURE Close*;
BEGIN
oldSymFile := NIL; inSym := NIL;
symFile := NIL; outSym := NIL;
objFile := NIL; outObj := NIL;
in := NIL; lineReader := NIL
END Close;
PROCEDURE Get* (VAR ch: SHORTCHAR);
VAR ch1: CHAR;
BEGIN
REPEAT in.ReadChar(ch1); INC(curpos) UNTIL (ch1 < 100X) & (ch1 # TextModels.viewcode);
ch := SHORT(ch1)
END Get;
PROCEDURE LineOf* (pos: INTEGER): INTEGER;
VAR ch: CHAR;
BEGIN
IF lineReader = NIL THEN lineReader := in.Base().NewReader(NIL); lineReader.SetPos(0); lineNum := 0 END;
IF lineReader.Pos() > pos THEN lineReader.SetPos(0); lineNum := 0 END;
WHILE lineReader.Pos() < pos DO
lineReader.ReadChar(ch);
IF ch = 0DX THEN INC(lineNum) END
END;
RETURN lineNum
END LineOf;
PROCEDURE LoWord (r: REAL): INTEGER;
VAR x: INTEGER;
BEGIN
x := SYSTEM.ADR(r);
IF ~LEHost THEN INC(x, 4) END;
SYSTEM.GET(x, x);
RETURN x
END LoWord;
PROCEDURE HiWord (r: REAL): INTEGER;
VAR x: INTEGER;
BEGIN
x := SYSTEM.ADR(r);
IF LEHost THEN INC(x, 4) END;
SYSTEM.GET(x, x);
RETURN x
END HiWord;
PROCEDURE Compound (lo, hi: INTEGER): REAL;
VAR r: REAL;
BEGIN
IF LEHost THEN
SYSTEM.PUT(SYSTEM.ADR(r), lo); SYSTEM.PUT(SYSTEM.ADR(r) + 4, hi)
ELSE
SYSTEM.PUT(SYSTEM.ADR(r) + 4, lo); SYSTEM.PUT(SYSTEM.ADR(r), hi)
END;
RETURN r
END Compound;
(* sysflag control *)
PROCEDURE ValidGuid* (VAR str: ARRAY OF SHORTCHAR): BOOLEAN;
VAR i: SHORTINT; ch: SHORTCHAR;
BEGIN
IF (LEN(str$) # 38) OR (str[0] # "{") & (str[37] # "}") THEN RETURN FALSE END;
i := 1;
WHILE i < 37 DO
ch := str[i];
IF (i = 9) OR (i = 14) OR (i = 19) OR (i = 24) THEN
IF ch # "-" THEN RETURN FALSE END
ELSE
IF (ch < "0") OR (ch > "9") & (CAP(ch) < "A") OR (CAP(ch) > "Z") THEN RETURN FALSE END
END;
INC(i)
END;
RETURN TRUE
END ValidGuid;
PROCEDURE GetProcSysFlag* (id: ARRAY OF SHORTCHAR; num: SHORTINT; VAR flag: SHORTINT);
BEGIN
IF id # "" THEN
IF id = "code" THEN num := 1
ELSIF id = "callback" THEN num := 2
ELSIF id = "nostkchk" THEN num := 4
ELSIF id = "ccall" THEN num := -10
ELSIF id = "guarded" THEN num := 8
ELSIF id = "noframe" THEN num := 16
ELSIF id = "native" THEN num := -33
ELSIF id = "bytecode" THEN num := -35
END
END;
IF (options * {sysImp, sys386, sys68k} # {}) & ((num = 1) OR (num = 2)) THEN INC(flag, num)
ELSIF (sys68k IN options) & (num = 4) THEN INC(flag, num)
ELSIF (sys386 IN options) & (num = -10) & (flag = 0) THEN flag := -10
ELSIF (options * {sys386, com} # {}) & (num = 8) & (flag = 0) THEN flag := 8
ELSIF (options * {sysImp, sys386} # {}) & (num = 16) & (flag = 0) THEN flag := 16
ELSIF ({sysImp, java} - options = {}) & ((num= -33) OR (num = -35)) & (flag = 0) THEN flag := num
ELSE err(225); flag := 0
END
END GetProcSysFlag;
PROCEDURE GetVarParSysFlag* (id: ARRAY OF SHORTCHAR; num: SHORTINT; VAR flag: SHORTINT);
VAR old: SHORTINT;
BEGIN
old := flag; flag := 0;
IF (options * {sys386, sys68k, interface, com} # {}) THEN
IF (num = 1) OR (id = "nil") THEN
IF ~ODD(old) THEN flag := SHORT(old + 1) END
ELSIF ((num = 2) OR (id = "in")) & (oberon IN options) THEN
IF old <= 1 THEN flag := SHORT(old + 2) END
ELSIF ((num = 4) OR (id = "out")) & (oberon IN options) THEN
IF old <= 1 THEN flag := SHORT(old + 4) END
ELSIF ((num = 8) OR (id = "new")) & (com IN options) THEN
IF old <= 1 THEN flag := SHORT(old + 8) END
ELSIF ((num = 16) OR (id = "iid")) & (com IN options) THEN
IF old <= 1 THEN flag := SHORT(old + 16) END
END
END;
IF flag = 0 THEN err(225) END
END GetVarParSysFlag;
PROCEDURE GetRecordSysFlag* (id: ARRAY OF SHORTCHAR; num: SHORTINT; VAR flag: SHORTINT);
VAR old: SHORTINT;
BEGIN
old := flag; flag := 0;
IF (num = 1) OR (id = "untagged") THEN
IF (options * {sysImp, sys386, sys68k, interface, com, som} # {}) & (old = 0) THEN flag := 1 END
ELSIF (num = 3) OR (id = "noalign") THEN
IF (options * {sys386, sys68k, interface, com, som} # {}) & (old = 0) THEN flag := 3 END
ELSIF (num = 4) OR (id = "align2") THEN
IF (options * {sys386, interface, com} # {}) & (old = 0) THEN flag := 4 END
ELSIF (num = 5) OR (id = "align4") THEN
IF (options * {sys386, interface, com} # {}) & (old = 0) THEN flag := 5 END
ELSIF (num = 6) OR (id = "align8") THEN
IF (options * {sys386, interface, com} # {}) & (old = 0) THEN flag := 6 END
ELSIF (num = 7) OR (id = "union") THEN
IF (options * {sys386, sys68k, interface, com} # {}) & (old = 0) THEN flag := 7 END
ELSIF (num = 10) OR (id = "interface") OR ValidGuid(id) THEN
IF (com IN options) & (old = 0) THEN flag := 10 END
ELSIF (num = -11) OR (id = "jint") THEN
IF (java IN options) & (old = 0) THEN flag := -11 END
ELSIF (num = -13) OR (id = "jstr") THEN
IF (java IN options) & (old = 0) THEN flag := -13 END
ELSIF (num = 20) OR (id = "som") THEN
IF (som IN options) & (old = 0) THEN flag := 20 END
END;
IF flag = 0 THEN err(225) END
END GetRecordSysFlag;
PROCEDURE GetArraySysFlag* (id: ARRAY OF SHORTCHAR; num: SHORTINT; VAR flag: SHORTINT);
VAR old: SHORTINT;
BEGIN
old := flag; flag := 0;
IF (num = 1) OR (id = "untagged") THEN
IF (options * {sysImp, sys386, sys68k, interface, com, som} # {}) & (old = 0) THEN flag := 1 END
ELSIF (num = -12) OR (id = "jarr") THEN
IF (java IN options) & (old = 0) THEN flag := -12 END
ELSIF (num = -13) OR (id = "jstr") THEN
IF (java IN options) & (old = 0) THEN flag := -13 END
END;
IF flag = 0 THEN err(225) END
END GetArraySysFlag;
PROCEDURE GetPointerSysFlag* (id: ARRAY OF SHORTCHAR; num: SHORTINT; VAR flag: SHORTINT);
VAR old: SHORTINT;
BEGIN
old := flag; flag := 0;
IF (num = 1) OR (id = "untagged") THEN
IF (options * {sys386, sys68k, interface, com, som} # {}) & (old = 0) THEN flag := 1 END
ELSIF (num = 2) OR (id = "handle") THEN
IF (sys68k IN options) & (old = 0) THEN flag := 2 END
ELSIF (num = 10) OR (id = "interface") THEN
IF (com IN options) & (old = 0) THEN flag := 10 END
ELSIF (num = 20) OR (id = "som") THEN
IF (som IN options) & (old = 0) THEN flag := 20 END
END;
IF flag = 0 THEN err(225) END
END GetPointerSysFlag;
PROCEDURE PropagateRecordSysFlag* (baseFlag: SHORTINT; VAR flag: SHORTINT);
BEGIN
IF (baseFlag = 1) OR (baseFlag >= 3) & (baseFlag <= 7) THEN (* propagate untagged .. union *)
IF flag = 0 THEN flag := baseFlag
ELSIF flag # baseFlag THEN err(225); flag := 0
END
ELSIF (baseFlag # 10) & (flag = 10) THEN err(225)
END
END PropagateRecordSysFlag;
PROCEDURE PropagateRecPtrSysFlag* (baseFlag: SHORTINT; VAR flag: SHORTINT);
BEGIN
IF (baseFlag = 1) OR (baseFlag >= 3) & (baseFlag <= 7) THEN (* pointer to untagged .. union is untagged *)
IF flag = 0 THEN flag := 1
ELSIF (flag # 1) & (flag # 2) THEN err(225); flag := 0
END
ELSIF baseFlag = 10 THEN (* pointer to interface is interface *)
IF flag = 0 THEN flag := 10
ELSIF flag # 10 THEN err(225); flag := 0
END
ELSIF baseFlag = -11 THEN (* pointer to java interface is java interface *)
IF flag # 0 THEN err(225) END;
flag := -11
ELSIF baseFlag = -13 THEN (* pointer to java string is java string *)
IF flag # 0 THEN err(225) END;
flag := -13
END
END PropagateRecPtrSysFlag;
PROCEDURE PropagateArrPtrSysFlag* (baseFlag: SHORTINT; VAR flag: SHORTINT);
BEGIN
IF baseFlag = 1 THEN (* pointer to untagged or guid is untagged *)
IF flag = 0 THEN flag := 1
ELSIF (flag # 1) & (flag # 2) THEN err(225); flag := 0
END
ELSIF baseFlag = -12 THEN (* pointer to java array is java array *)
IF flag # 0 THEN err(225) END;
flag := -12
ELSIF baseFlag = -13 THEN (* pointer to java string is java string *)
IF flag # 0 THEN err(225) END;
flag := -13
END
END PropagateArrPtrSysFlag;
(* utf8 strings *)
PROCEDURE PutUtf8* (VAR str: ARRAY OF SHORTCHAR; val: INTEGER; VAR idx: INTEGER);
BEGIN
ASSERT((val >= 0) & (val < 65536));
IF val < 128 THEN
str[idx] := SHORT(CHR(val)); INC(idx)
ELSIF val < 2048 THEN
str[idx] := SHORT(CHR(val DIV 64 + 192)); INC(idx);
str[idx] := SHORT(CHR(val MOD 64 + 128)); INC(idx)
ELSE
str[idx] := SHORT(CHR(val DIV 4096 + 224)); INC(idx);
str[idx] := SHORT(CHR(val DIV 64 MOD 64 + 128)); INC(idx);
str[idx] := SHORT(CHR(val MOD 64 + 128)); INC(idx)
END
END PutUtf8;
PROCEDURE GetUtf8* (VAR str: ARRAY OF SHORTCHAR; VAR val, idx: INTEGER);
VAR ch: SHORTCHAR;
BEGIN
ch := str[idx]; INC(idx);
IF ch < 80X THEN
val := ORD(ch)
ELSIF ch < 0E0X THEN
val := ORD(ch) - 192;
ch := str[idx]; INC(idx); val := val * 64 + ORD(ch) - 128
ELSE
val := ORD(ch) - 224;
ch := str[idx]; INC(idx); val := val * 64 + ORD(ch) - 128;
ch := str[idx]; INC(idx); val := val * 64 + ORD(ch) - 128
END
END GetUtf8;
(* log output *)
PROCEDURE LogW* (ch: SHORTCHAR);
BEGIN
StdLog.Char(ch)
END LogW;
PROCEDURE LogWStr* (s: ARRAY OF SHORTCHAR);
VAR str: ARRAY 256 OF CHAR;
BEGIN
str := s$; StdLog.String(str)
END LogWStr;
PROCEDURE LogWNum* (i, len: INTEGER);
BEGIN
StdLog.Int(i)
END LogWNum;
PROCEDURE LogWLn*;
BEGIN
StdLog.Ln
END LogWLn;
(*
PROCEDURE LogW* (ch: CHAR);
BEGIN
out.WriteChar(ch);
END LogW;
PROCEDURE LogWStr* (s: ARRAY OF CHAR);
BEGIN
out.WriteString(s);
END LogWStr;
PROCEDURE LogWNum* (i, len: LONGINT);
BEGIN
out.WriteChar(" "); out.WriteInt(i);
END LogWNum;
PROCEDURE LogWLn*;
BEGIN
out.WriteLn;
Views.RestoreDomain(logbuf.Domain())
END LogWLn;
*)
PROCEDURE Mark* (n, pos: INTEGER);
BEGIN
IF (n >= 0) & ~((oberon IN options) & (n >= 181) & (n <= 190)) THEN
noerr := FALSE;
IF pos < 0 THEN pos := 0 END;
IF (pos < lastpos) OR (lastpos + 9 < pos) THEN
lastpos := pos;
IF errors < maxErrors THEN
errNo[errors] := n; errPos[errors] := pos
END;
INC(errors)
END;
IF trap IN options THEN HALT(100) END;
ELSIF (n <= -700) & (errors < maxErrors) THEN
errNo[errors] := -n; errPos[errors] := pos; INC(errors)
END
END Mark;
PROCEDURE err* (n: INTEGER);
BEGIN
Mark(n, errpos)
END err;
PROCEDURE InsertMarks* (text: TextModels.Model);
VAR i, j, x, y, n: INTEGER; script: Stores.Operation;
BEGIN
n := errors;
IF n > maxErrors THEN n := maxErrors END;
(* sort *)
i := 1;
WHILE i < n DO
x := errPos[i]; y := errNo[i]; j := i-1;
WHILE (j >= 0) & (errPos[j] > x) DO errPos[j+1] := errPos[j]; errNo[j+1] := errNo[j]; DEC(j) END;
errPos[j+1] := x; errNo[j+1] := y; INC(i)
END;
(* insert *)
Models.BeginModification(Models.clean, text);
Models.BeginScript(text, "#Dev:InsertMarkers", script);
WHILE n > 0 DO DEC(n);
DevMarkers.Insert(text, errPos[n], DevMarkers.dir.New(errNo[n]))
END;
Models.EndScript(text, script);
Models.EndModification(Models.clean, text);
END InsertMarks;
(* fingerprinting *)
PROCEDURE FPrint* (VAR fp: INTEGER; val: INTEGER);
BEGIN
fp := SYSTEM.ROT(ORD(BITS(fp) / BITS(val)), 1)
END FPrint;
PROCEDURE FPrintSet* (VAR fp: INTEGER; set: SET);
BEGIN FPrint(fp, ORD(set))
END FPrintSet;
PROCEDURE FPrintReal* (VAR fp: INTEGER; real: SHORTREAL);
BEGIN FPrint(fp, SYSTEM.VAL(INTEGER, real))
END FPrintReal;
PROCEDURE FPrintLReal* (VAR fp: INTEGER; lr: REAL);
VAR l, h: INTEGER;
BEGIN
FPrint(fp, LoWord(lr)); FPrint(fp, HiWord(lr))
END FPrintLReal;
(* compact format *)
PROCEDURE WriteLInt (w: Files.Writer; i: INTEGER);
BEGIN
w.WriteByte(SHORT(SHORT(i MOD 256))); i := i DIV 256;
w.WriteByte(SHORT(SHORT(i MOD 256))); i := i DIV 256;
w.WriteByte(SHORT(SHORT(i MOD 256))); i := i DIV 256;
w.WriteByte(SHORT(SHORT(i MOD 256)))
END WriteLInt;
PROCEDURE ReadLInt (r: Files.Reader; VAR i: INTEGER);
VAR b: BYTE; x: INTEGER;
BEGIN
r.ReadByte(b); x := b MOD 256;
r.ReadByte(b); x := x + 100H * (b MOD 256);
r.ReadByte(b); x := x + 10000H * (b MOD 256);
r.ReadByte(b); i := x + 1000000H * b
END ReadLInt;
PROCEDURE WriteNum (w: Files.Writer; i: INTEGER);
BEGIN (* old format of Oberon *)
WHILE (i < -64) OR (i > 63) DO w.WriteByte(SHORT(SHORT(i MOD 128 - 128))); i := i DIV 128 END;
w.WriteByte(SHORT(SHORT(i MOD 128)))
END WriteNum;
PROCEDURE ReadNum (r: Files.Reader; VAR i: INTEGER);
VAR b: BYTE; s, y: INTEGER;
BEGIN
s := 0; y := 0; r.ReadByte(b);
WHILE b < 0 DO INC(y, ASH(b + 128, s)); INC(s, 7); r.ReadByte(b) END;
i := ASH((b + 64) MOD 128 - 64, s) + y
END ReadNum;
PROCEDURE WriteNumSet (w: Files.Writer; x: SET);
BEGIN
WriteNum(w, ORD(x))
END WriteNumSet;
PROCEDURE ReadNumSet (r: Files.Reader; VAR x: SET);
VAR i: INTEGER;
BEGIN
ReadNum(r, i); x := BITS(i)
END ReadNumSet;
PROCEDURE WriteReal (w: Files.Writer; x: SHORTREAL);
BEGIN
WriteLInt(w, SYSTEM.VAL(INTEGER, x))
END WriteReal;
PROCEDURE ReadReal (r: Files.Reader; VAR x: SHORTREAL);
VAR i: INTEGER;
BEGIN
ReadLInt(r, i); x := SYSTEM.VAL(SHORTREAL, i)
END ReadReal;
PROCEDURE WriteLReal (w: Files.Writer; x: REAL);
BEGIN
WriteLInt(w, LoWord(x)); WriteLInt(w, HiWord(x))
END WriteLReal;
PROCEDURE ReadLReal (r: Files.Reader; VAR x: REAL);
VAR h, l: INTEGER;
BEGIN
ReadLInt(r, l); ReadLInt(r, h); x := Compound(l, h)
END ReadLReal;
(* read symbol file *)
PROCEDURE SymRCh* (VAR ch: SHORTCHAR);
VAR b: BYTE;
BEGIN
inSym.ReadByte(b); ch := SHORT(CHR(b))
END SymRCh;
PROCEDURE SymRInt* (): INTEGER;
VAR k: INTEGER;
BEGIN
ReadNum(inSym, k); RETURN k
END SymRInt;
PROCEDURE SymRSet* (VAR s: SET);
BEGIN
ReadNumSet(inSym, s)
END SymRSet;
PROCEDURE SymRReal* (VAR r: SHORTREAL);
BEGIN
ReadReal(inSym, r)
END SymRReal;
PROCEDURE SymRLReal* (VAR lr: REAL);
BEGIN
ReadLReal(inSym, lr)
END SymRLReal;
PROCEDURE eofSF* (): BOOLEAN;
BEGIN
RETURN inSym.eof
END eofSF;
PROCEDURE OldSym* (VAR modName: ARRAY OF SHORTCHAR; VAR done: BOOLEAN);
VAR tag: INTEGER; loc: Files.Locator; dir, name: Files.Name;
BEGIN
done := FALSE;
IF modName = "@file" THEN
oldSymFile := file
ELSE
name := modName$; Kernel.SplitName(name, dir, name);
Kernel.MakeFileName(name, Kernel.symType);
loc := Files.dir.This(dir); loc := loc.This(symDir);
oldSymFile := Files.dir.Old(loc, name, Files.shared);
IF (oldSymFile = NIL) & (dir = "") THEN
loc := Files.dir.This(SYSdir); loc := loc.This(symDir);
oldSymFile := Files.dir.Old(loc, name, Files.shared)
END
END;
IF oldSymFile # NIL THEN
inSym := oldSymFile.NewReader(inSym);
IF inSym # NIL THEN
ReadLInt(inSym, tag);
IF tag = SFtag THEN done := TRUE ELSE err(151) END
END
END
END OldSym;
PROCEDURE CloseOldSym*;
BEGIN
IF oldSymFile # NIL THEN oldSymFile.Close; oldSymFile := NIL END
END CloseOldSym;
(* write symbol file *)
PROCEDURE SymWCh* (ch: SHORTCHAR);
BEGIN
outSym.WriteByte(SHORT(ORD(ch)))
END SymWCh;
PROCEDURE SymWInt* (i: INTEGER);
BEGIN
WriteNum(outSym, i)
END SymWInt;
PROCEDURE SymWSet* (s: SET);
BEGIN
WriteNumSet(outSym, s)
END SymWSet;
PROCEDURE SymWReal* (VAR r: SHORTREAL);
BEGIN
WriteReal(outSym, r)
END SymWReal;
PROCEDURE SymWLReal* (VAR r: REAL);
BEGIN
WriteLReal(outSym, r)
END SymWLReal;
PROCEDURE SymReset*;
BEGIN
outSym.SetPos(4)
END SymReset;
PROCEDURE NewSym* (VAR modName: ARRAY OF SHORTCHAR);
VAR loc: Files.Locator; dir: Files.Name;
BEGIN
ObjFName := modName$; Kernel.SplitName(ObjFName, dir, ObjFName);
loc := Files.dir.This(dir); loc := loc.This(symDir);
symFile := Files.dir.New(loc, Files.ask);
IF symFile # NIL THEN
outSym := symFile.NewWriter(NIL);
WriteLInt(outSym, SFtag)
ELSE
err(153)
END
END NewSym;
PROCEDURE RegisterNewSym*;
VAR res: INTEGER; name: Files.Name;
BEGIN
IF symFile # NIL THEN
name := ObjFName$;
Kernel.MakeFileName(name, Kernel.symType);
symFile.Register(name, Kernel.symType, Files.ask, res);
symFile := NIL
END
END RegisterNewSym;
PROCEDURE DeleteNewSym*;
BEGIN
IF symFile # NIL THEN symFile.Close; symFile := NIL END
END DeleteNewSym;
(* write object file *)
PROCEDURE ObjW* (ch: SHORTCHAR);
BEGIN
outObj.WriteByte(SHORT(ORD(ch)))
END ObjW;
PROCEDURE ObjWNum* (i: INTEGER);
BEGIN
WriteNum(outObj, i)
END ObjWNum;
PROCEDURE ObjWInt (i: SHORTINT);
BEGIN
outObj.WriteByte(SHORT(SHORT(i MOD 256)));
outObj.WriteByte(SHORT(SHORT(i DIV 256)))
END ObjWInt;
PROCEDURE ObjWLInt* (i: INTEGER);
BEGIN
ObjWInt(SHORT(i MOD 65536));
ObjWInt(SHORT(i DIV 65536))
END ObjWLInt;
PROCEDURE ObjWBytes* (VAR bytes: ARRAY OF SHORTCHAR; n: INTEGER);
TYPE P = POINTER TO ARRAY [untagged] 100000H OF BYTE;
VAR p: P;
BEGIN
p := SYSTEM.VAL(P, SYSTEM.ADR(bytes));
outObj.WriteBytes(p^, 0, n)
END ObjWBytes;
PROCEDURE ObjLen* (): INTEGER;
BEGIN
RETURN outObj.Pos()
END ObjLen;
PROCEDURE ObjSet* (pos: INTEGER);
BEGIN
outObj.SetPos(pos)
END ObjSet;
PROCEDURE NewObj* (VAR modName: ARRAY OF SHORTCHAR);
VAR loc: Files.Locator; dir: Files.Name;
BEGIN
errpos := 0;
ObjFName := modName$; Kernel.SplitName(ObjFName, dir, ObjFName);
loc := Files.dir.This(dir); loc := loc.This(codeDir);
objFile := Files.dir.New(loc, Files.ask);
IF objFile # NIL THEN
outObj := objFile.NewWriter(NIL);
WriteLInt(outObj, OFtag)
ELSE
err(153)
END
END NewObj;
PROCEDURE RegisterObj*;
VAR res: INTEGER; name: Files.Name;
BEGIN
IF objFile # NIL THEN
name := ObjFName$;
Kernel.MakeFileName(name, Kernel.objType);
objFile.Register(name, Kernel.objType, Files.ask, res);
objFile := NIL; outObj := NIL
END
END RegisterObj;
PROCEDURE DeleteObj*;
BEGIN
IF objFile # NIL THEN objFile.Close; objFile := NIL END
END DeleteObj;
PROCEDURE InitHost;
VAR test: SHORTINT; lo: SHORTCHAR;
BEGIN
test := 1; SYSTEM.GET(SYSTEM.ADR(test), lo); LEHost := lo = 1X;
InfReal := SYSTEM.VAL(SHORTREAL, InfRealPat);
MinReal32 := SYSTEM.VAL(SHORTREAL, MinReal32Pat);
MaxReal32 := SYSTEM.VAL(SHORTREAL, MaxReal32Pat);
MinReal64 := Compound(MinReal64PatL, MinReal64PatH);
MaxReal64 := Compound(MaxReal64PatL, MaxReal64PatH)
END InitHost;
BEGIN
InitHost
END DevCPM.
| Dev/Mod/CPM.odc |
MODULE DevCPP;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- 20111212, F.V.Tkachov reports a successful testing by a bunch of kids for more than a year
- 20100402, E.E.Temirgaleev, automatic indent checks
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
DevCPM, DevCPT, DevCPB, DevCPS;
CONST
anchorVarPar = TRUE;
(* numtyp values *)
char = 1; integer = 2; real = 4; int64 = 5; real32 = 6; real64 = 7;
(*symbol values*)
null = 0; times = 1; slash = 2; div = 3; mod = 4;
and = 5; plus = 6; minus = 7; or = 8; eql = 9;
neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14;
in = 15; is = 16; arrow = 17; dollar = 18; period = 19;
comma = 20; colon = 21; upto = 22; rparen = 23; rbrak = 24;
rbrace = 25; of = 26; then = 27; do = 28; to = 29;
by = 30; not = 33;
lparen = 40; lbrak = 41; lbrace = 42; becomes = 44;
number = 45; nil = 46; string = 47; ident = 48; semicolon = 49;
bar = 50; end = 51; else = 52; elsif = 53; until = 54;
if = 55; case = 56; while = 57; repeat = 58; for = 59;
loop = 60; with = 61; exit = 62; return = 63; array = 64;
record = 65; pointer = 66; begin = 67; const = 68; type = 69;
var = 70; out = 71; procedure = 72; close = 73; import = 74;
module = 75; eof = 76;
(* object modes *)
Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7;
SProc = 8; CProc = 9; IProc = 10; Mod = 11; Head = 12; TProc = 13; Attr = 20;
(* Structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Real32 = 7; Real64 = 8; Set = 9; String8 = 10; NilTyp = 11; NoTyp = 12;
Pointer = 13; ProcTyp = 14; Comp = 15;
Char16 = 16; String16 = 17; Int64 = 18;
intSet = {Int8..Int32, Int64}; charSet = {Char8, Char16};
(* composite structure forms *)
Basic = 1; Array = 2; DynArr = 3; Record = 4;
(*function number*)
haltfn = 0; newfn = 1; incfn = 13; sysnewfn = 30;
(* nodes classes *)
Nvar = 0; Nvarpar = 1; Nfield = 2; Nderef = 3; Nindex = 4; Nguard = 5; Neguard = 6;
Nconst = 7; Ntype = 8; Nproc = 9; Nupto = 10; Nmop = 11; Ndop = 12; Ncall = 13;
Ninittd = 14; Nif = 15; Ncaselse = 16; Ncasedo = 17; Nenter = 18; Nassign = 19;
Nifelse = 20; Ncase = 21; Nwhile = 22; Nrepeat = 23; Nloop = 24; Nexit = 25;
Nreturn = 26; Nwith = 27; Ntrap = 28; Ncomp = 30;
(* node subclasses *)
super = 1;
(* module visibility of objects *)
internal = 0; external = 1; externalR = 2; inPar = 3; outPar = 4;
(* procedure flags (conval.setval) *)
hasBody = 1; isRedef = 2; slNeeded = 3; imVar = 4;
(* attribute flags (attr.adr, struct.attribute, proc.conval.setval)*)
newAttr = 16; absAttr = 17; limAttr = 18; empAttr = 19; extAttr = 20;
(* case statement flags (conval.setval) *)
useTable = 1; useTree = 2;
(* sysflags *)
nilBit = 1; inBit = 2; outBit = 4; newBit = 8; iidBit = 16; interface = 10; som = 20; jstr = -13;
TYPE
Elem = POINTER TO RECORD
next: Elem;
struct: DevCPT.Struct;
obj, base: DevCPT.Object;
pos: INTEGER;
name: DevCPT.String
END;
VAR
sym, level: BYTE;
LoopLevel: SHORTINT;
TDinit, lastTDinit: DevCPT.Node;
userList: Elem;
recList: Elem;
hasReturn: BOOLEAN;
numUsafeVarPar, numFuncVarPar: INTEGER;
PROCEDURE^ Type(VAR typ: DevCPT.Struct; VAR name: DevCPT.String);
PROCEDURE^ Expression(VAR x: DevCPT.Node);
PROCEDURE^ Block(VAR procdec, statseq: DevCPT.Node);
(* forward type handling *)
PROCEDURE IncompleteType (typ: DevCPT.Struct): BOOLEAN;
BEGIN
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
RETURN (typ = DevCPT.undftyp) OR (typ.comp = Record) & (typ.BaseTyp = DevCPT.undftyp)
END IncompleteType;
PROCEDURE SetType (struct: DevCPT.Struct; obj: DevCPT.Object; typ: DevCPT.Struct; name: DevCPT.String);
VAR u: Elem;
BEGIN
IF obj # NIL THEN obj.typ := typ ELSE struct.BaseTyp := typ END;
IF name # NIL THEN
NEW(u); u.struct := struct; u.obj := obj; u.pos := DevCPM.errpos; u.name := name;
u.next := userList; userList := u
END
END SetType;
PROCEDURE CheckAlloc (VAR typ: DevCPT.Struct; dynAllowed: BOOLEAN; pos: INTEGER);
BEGIN
typ.pvused := TRUE;
IF typ.comp = DynArr THEN
IF ~dynAllowed THEN DevCPM.Mark(88, pos); typ := DevCPT.undftyp END
ELSIF typ.comp = Record THEN
IF (typ.attribute = absAttr) OR (typ.attribute = limAttr) & (typ.mno # 0) THEN
DevCPM.Mark(193, pos); typ := DevCPT.undftyp
END
END
END CheckAlloc;
PROCEDURE CheckRecursiveType (outer, inner: DevCPT.Struct; pos: INTEGER);
VAR fld: DevCPT.Object;
BEGIN
IF outer = inner THEN DevCPM.Mark(58, pos)
ELSIF inner.comp IN {Array, DynArr} THEN CheckRecursiveType(outer, inner.BaseTyp, pos)
ELSIF inner.comp = Record THEN
fld := inner.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
CheckRecursiveType(outer, fld.typ, pos);
fld := fld.link
END;
IF inner.BaseTyp # NIL THEN CheckRecursiveType(outer, inner.BaseTyp, pos) END
END
END CheckRecursiveType;
PROCEDURE FixType (struct: DevCPT.Struct; obj: DevCPT.Object; typ: DevCPT.Struct; pos: INTEGER);
(* fix forward reference *)
VAR t: DevCPT.Struct; f, bf: DevCPT.Object; i: SHORTINT;
BEGIN
IF obj # NIL THEN
IF obj.mode = Var THEN (* variable type *)
IF struct # NIL THEN (* receiver type *)
IF (typ.form # Pointer) OR (typ.BaseTyp # struct) THEN DevCPM.Mark(180, pos) END;
ELSE CheckAlloc(typ, obj.mnolev > level, pos) (* TRUE for parameters *)
END
ELSIF obj.mode = VarPar THEN (* varpar type *)
IF struct # NIL THEN (* varpar receiver type *)
IF typ # struct THEN DevCPM.Mark(180, pos) END
END
ELSIF obj.mode = Fld THEN (* field type *)
CheckAlloc(typ, FALSE, pos);
CheckRecursiveType(struct, typ, pos)
ELSIF obj.mode = TProc THEN (* proc return type *)
IF typ.form = Comp THEN typ := DevCPT.undftyp; DevCPM.Mark(54, pos) END
ELSIF obj.mode = Typ THEN (* alias type *)
IF typ.form IN {Byte..Set, Char16, Int64} THEN (* make alias structure *)
t := DevCPT.NewStr(typ.form, Basic); i := t.ref;
t^ := typ^; t.ref := i; t.strobj := obj; t.mno := 0;
t.BaseTyp := typ; typ := t
END;
IF obj.vis # internal THEN
IF typ.comp = Record THEN typ.exp := TRUE
ELSIF typ.form = Pointer THEN typ.BaseTyp.exp := TRUE
END
END
ELSE HALT(100)
END;
obj.typ := typ
ELSE
IF struct.form = Pointer THEN (* pointer base type *)
IF typ.comp = Record THEN DevCPM.PropagateRecPtrSysFlag(typ.sysflag, struct.sysflag)
ELSIF typ.comp IN {Array, DynArr} THEN DevCPM.PropagateArrPtrSysFlag(typ.sysflag, struct.sysflag)
ELSE typ := DevCPT.undftyp; DevCPM.Mark(57, pos)
END;
struct.untagged := struct.sysflag > 0;
IF (struct.strobj # NIL) & (struct.strobj.vis # internal) THEN typ.exp := TRUE END;
ELSIF struct.comp = Array THEN (* array base type *)
CheckAlloc(typ, FALSE, pos);
CheckRecursiveType(struct, typ, pos)
ELSIF struct.comp = DynArr THEN (* array base type *)
CheckAlloc(typ, TRUE, pos);
CheckRecursiveType(struct, typ, pos)
ELSIF struct.comp = Record THEN (* record base type *)
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
typ.pvused := TRUE; struct.extlev := SHORT(SHORT(typ.extlev + 1));
DevCPM.PropagateRecordSysFlag(typ.sysflag, struct.sysflag);
IF (typ.attribute = 0) OR (typ.attribute = limAttr) & (typ.mno # 0) THEN DevCPM.Mark(181, pos)
ELSIF (struct.attribute = absAttr) & (typ.attribute # absAttr) THEN DevCPM.Mark(191, pos)
ELSIF (typ.attribute = limAttr) & (struct.attribute # limAttr) THEN DevCPM.Mark(197, pos)
END;
f := struct.link;
WHILE f # NIL DO (* check for field name conflicts *)
DevCPT.FindField(f.name, typ, bf);
IF bf # NIL THEN DevCPM.Mark(1, pos) END;
f := f.link
END;
CheckRecursiveType(struct, typ, pos);
struct.untagged := struct.sysflag > 0;
ELSIF struct.form = ProcTyp THEN (* proc type return type *)
IF typ.form = Comp THEN typ := DevCPT.undftyp; DevCPM.Mark(54, pos) END;
ELSE HALT(100)
END;
struct.BaseTyp := typ
END
END FixType;
PROCEDURE CheckForwardTypes;
VAR u, next: Elem; progress: BOOLEAN;
BEGIN
u := userList; userList := NIL;
WHILE u # NIL DO
next := u.next; DevCPS.name := u.name^$; DevCPT.Find(DevCPS.name, u.base);
IF u.base = NIL THEN DevCPM.Mark(0, u.pos)
ELSIF u.base.mode # Typ THEN DevCPM.Mark(72, u.pos)
ELSE u.next := userList; userList := u (* reinsert *)
END;
u := next
END;
REPEAT (* iteration for multy level alias *)
u := userList; userList := NIL; progress := FALSE;
WHILE u # NIL DO
next := u.next;
IF IncompleteType(u.base.typ) THEN
u.next := userList; userList := u (* reinsert *)
ELSE
progress := TRUE;
FixType(u.struct, u.obj, u.base.typ, u.pos)
END;
u := next
END
UNTIL (userList = NIL) OR ~progress;
u := userList; (* remaining type relations are cyclic *)
WHILE u # NIL DO
IF (u.obj = NIL) OR (u.obj.mode = Typ) THEN DevCPM.Mark(58, u.pos) END;
u := u.next
END;
END CheckForwardTypes;
PROCEDURE CheckUnimpl (m: DevCPT.Object; typ: DevCPT.Struct; pos: INTEGER);
VAR obj: DevCPT.Object;
BEGIN
IF m # NIL THEN
IF (m.mode = TProc) & (absAttr IN m.conval.setval) THEN
DevCPT.FindField(m.name^, typ, obj);
IF (obj = NIL) OR (obj.mode # TProc) OR (absAttr IN obj.conval.setval) THEN
DevCPM.Mark(192, pos);
DevCPM.LogWLn; DevCPM.LogWStr(" "); DevCPM.LogWStr(m.name^);
DevCPM.LogWStr(" not implemented");
IF typ.strobj # NIL THEN
DevCPM.LogWStr(" in "); DevCPM.LogWStr(typ.strobj.name^)
END
END
END;
CheckUnimpl(m.left, typ, pos);
CheckUnimpl(m.right, typ, pos)
END
END CheckUnimpl;
PROCEDURE CheckRecords (rec: Elem);
VAR b: DevCPT.Struct;
BEGIN
WHILE rec # NIL DO (* check for unimplemented methods in base type *)
b := rec.struct.BaseTyp;
WHILE (b # NIL) & (b # DevCPT.undftyp) DO
CheckUnimpl(b.link, rec.struct, rec.pos);
b := b.BaseTyp
END;
rec := rec.next
END
END CheckRecords;
PROCEDURE err(n: SHORTINT);
BEGIN DevCPM.err(n)
END err;
PROCEDURE CheckSym(s: SHORTINT);
BEGIN
IF sym = s THEN DevCPS.Get(sym) ELSE DevCPM.err(s) END
END CheckSym;
PROCEDURE CheckIndentSym (ops: INTEGER; s: SHORTINT);
BEGIN
IF sym = s THEN
DevCPS.Indent(ops); DevCPS.Get(sym)
ELSE
(* ,
( - ) *)
DevCPM.err(s); DevCPS.Indent(ops)
END
END CheckIndentSym;
PROCEDURE qualident(VAR id: DevCPT.Object);
VAR obj: DevCPT.Object; lev: BYTE;
BEGIN (*sym = ident*)
DevCPT.Find(DevCPS.name, obj); DevCPS.Get(sym);
IF (sym = period) & (obj # NIL) & (obj.mode = Mod) THEN
DevCPS.Get(sym);
IF sym = ident THEN
DevCPT.FindImport(DevCPS.name, obj, obj); DevCPS.Get(sym)
ELSE err(ident); obj := NIL
END
END ;
IF obj = NIL THEN err(0);
obj := DevCPT.NewObj(); obj.mode := Var; obj.typ := DevCPT.undftyp; obj.adr := 0
ELSE lev := obj.mnolev;
IF (obj.mode IN {Var, VarPar}) & (lev # level) THEN
obj.leaf := FALSE;
IF lev > 0 THEN DevCPB.StaticLink(SHORT(SHORT(level-lev)), TRUE) END (* !!! *)
END
END ;
id := obj
END qualident;
PROCEDURE ConstExpression(VAR x: DevCPT.Node);
BEGIN Expression(x);
IF x.class # Nconst THEN
err(50); x := DevCPB.NewIntConst(1)
END
END ConstExpression;
PROCEDURE CheckMark(obj: DevCPT.Object); (* !!! *)
VAR n: INTEGER; mod: ARRAY 256 OF DevCPT.String;
BEGIN DevCPS.Get(sym);
IF (sym = times) OR (sym = minus) THEN
IF (level > 0) OR ~(obj.mode IN {Var, Fld, TProc}) & (sym = minus) THEN err(41) END ;
IF sym = times THEN obj.vis := external ELSE obj.vis := externalR END ;
DevCPS.Get(sym)
ELSE obj.vis := internal
END;
IF (obj.mode IN {TProc, LProc, XProc, CProc, Var, Typ, Con, Fld}) & (sym = lbrak) THEN
DevCPS.Get(sym);
IF (sym = number) & (DevCPS.numtyp = char) THEN
NEW(DevCPS.str, 2); DevCPS.str[0] := SHORT(CHR(DevCPS.intval)); DevCPS.str[1] := 0X; sym := string
END;
IF sym = string THEN
IF DevCPS.str^ # "" THEN obj.entry := DevCPS.str END;
DevCPS.Get(sym); n := 0;
IF (sym = comma) & (obj.mode IN {LProc, XProc, CProc, Var, Con}) THEN
DevCPS.Get(sym);
IF (sym = number) & (DevCPS.numtyp = char) THEN
NEW(DevCPS.str, 2); DevCPS.str[0] := SHORT(CHR(DevCPS.intval)); DevCPS.str[1] := 0X; sym := string
END;
IF sym = string THEN
obj.library := obj.entry; obj.entry := NIL;
IF DevCPS.str^ # "" THEN obj.entry := DevCPS.str END;
DevCPS.Get(sym);
ELSE err(string)
END
END;
WHILE sym = comma DO
DevCPS.Get(sym);
IF (sym = number) & (DevCPS.numtyp = char) THEN
NEW(DevCPS.str, 2); DevCPS.str[0] := SHORT(CHR(DevCPS.intval)); DevCPS.str[1] := 0X; sym := string
END;
IF sym = string THEN
IF n < LEN(mod) THEN mod[n] := DevCPS.str; INC(n)
ELSE err(235)
END;
DevCPS.Get(sym)
ELSE err(string)
END
END;
IF n > 0 THEN
NEW(obj.modifiers, n);
WHILE n > 0 DO DEC(n); obj.modifiers[n] := mod[n] END
END
ELSE err(string)
END;
CheckSym(rbrak);
IF DevCPM.options * {DevCPM.interface, DevCPM.java} = {} THEN err(225) END
END
END CheckMark;
PROCEDURE CheckSysFlag (VAR sysflag: SHORTINT;
GetSF: PROCEDURE(id: ARRAY OF SHORTCHAR; num: SHORTINT; VAR flag: SHORTINT));
VAR x: DevCPT.Object; i: SHORTINT;
BEGIN
sysflag := 0;
IF sym = lbrak THEN
DevCPS.Get(sym);
WHILE (sym = number) OR (sym = ident) OR (sym = string) DO
IF sym = number THEN
IF DevCPS.numtyp = integer THEN
i := SHORT(DevCPS.intval); GetSF("", i, sysflag)
ELSE err(225)
END
ELSIF sym = ident THEN
DevCPT.Find(DevCPS.name, x);
IF (x # NIL) & (x.mode = Con) & (x.typ.form IN {Int8, Int16, Int32}) THEN
i := SHORT(x.conval.intval); GetSF("", i, sysflag)
ELSE
GetSF(DevCPS.name, 0, sysflag)
END
ELSE
GetSF(DevCPS.str^, 0, sysflag)
END;
DevCPS.Get(sym);
IF (sym = comma) OR (sym = plus) THEN DevCPS.Get(sym) END
END;
CheckSym(rbrak)
END
END CheckSysFlag;
PROCEDURE Receiver(VAR mode, vis: BYTE; VAR name: DevCPT.Name; VAR typ, rec: DevCPT.Struct);
VAR obj: DevCPT.Object; tname: DevCPT.String;
BEGIN typ := DevCPT.undftyp; rec := NIL; vis := 0;
IF sym = var THEN DevCPS.Get(sym); mode := VarPar;
ELSIF sym = in THEN DevCPS.Get(sym); mode := VarPar; vis := inPar (* ??? *)
ELSE mode := Var
END ;
name := DevCPS.name; CheckSym(ident); CheckSym(colon);
IF sym # ident THEN err(ident) END;
Type(typ, tname);
IF tname = NIL THEN
IF typ.form = Pointer THEN rec := typ.BaseTyp ELSE rec := typ END;
IF ~((mode = Var) & (typ.form = Pointer) & (rec.comp = Record) OR
(mode = VarPar) & (typ.comp = Record)) THEN err(70); rec := NIL END;
IF (rec # NIL) & (rec.mno # level) THEN err(72); rec := NIL END
ELSE err(0)
END;
CheckSym(rparen);
IF rec = NIL THEN rec := DevCPT.NewStr(Comp, Record); rec.BaseTyp := NIL END
END Receiver;
PROCEDURE FormalParameters(
VAR firstPar: DevCPT.Object; VAR resTyp: DevCPT.Struct; VAR name: DevCPT.String
);
VAR mode, vis: BYTE; sys: SHORTINT;
par, first, last, res, newPar, iidPar: DevCPT.Object; typ: DevCPT.Struct;
BEGIN
first := NIL; last := firstPar;
newPar := NIL; iidPar := NIL;
IF (sym = ident) OR (sym = var) OR (sym = in) OR (sym = out) THEN
LOOP
sys := 0; vis := 0;
IF sym = var THEN DevCPS.Get(sym); mode := VarPar
ELSIF sym = in THEN DevCPS.Get(sym); mode := VarPar; vis := inPar
ELSIF sym = out THEN DevCPS.Get(sym); mode := VarPar; vis := outPar
ELSE mode := Var
END ;
IF mode = VarPar THEN CheckSysFlag(sys, DevCPM.GetVarParSysFlag) END;
IF ODD(sys DIV inBit) THEN vis := inPar
ELSIF ODD(sys DIV outBit) THEN vis := outPar
END;
IF ODD(sys DIV newBit) & (vis # outPar) THEN err(225)
ELSIF ODD(sys DIV iidBit) & (vis # inPar) THEN err(225)
END;
LOOP
IF sym = ident THEN
DevCPT.Insert(DevCPS.name, par); DevCPS.Get(sym);
par.mode := mode; par.link := NIL; par.vis := vis; par.sysflag := SHORT(sys);
IF first = NIL THEN first := par END ;
IF firstPar = NIL THEN firstPar := par ELSE last.link := par END ;
last := par
ELSE err(ident)
END;
IF sym = comma THEN DevCPS.Get(sym)
ELSIF sym = ident THEN err(comma)
ELSIF sym = var THEN err(comma); DevCPS.Get(sym)
ELSE EXIT
END
END ;
CheckSym(colon); Type(typ, name);
IF mode # VarPar THEN CheckAlloc(typ, TRUE, DevCPM.errpos) END;
IF (mode = VarPar) & (vis = inPar) & (typ.form # Undef) & (typ.form # Comp) & (typ.sysflag = 0) THEN err(177)
END;
(* typ.pbused is set when parameter type name is parsed *)
WHILE first # NIL DO
SetType (NIL, first, typ, name);
IF ODD(sys DIV newBit) THEN
IF (newPar # NIL) OR (typ.form # Pointer) OR (typ.sysflag # interface) THEN err(168) END;
newPar := first
ELSIF ODD(sys DIV iidBit) THEN
IF (iidPar # NIL) OR (typ # DevCPT.guidtyp) THEN err(168) END;
iidPar := first
END;
first := first.link
END;
IF sym = semicolon THEN DevCPS.Get(sym)
ELSIF sym = ident THEN err(semicolon)
ELSE EXIT
END
END
END;
CheckSym(rparen);
IF (newPar = NIL) # (iidPar = NIL) THEN err(168) END;
name := NIL;
IF sym = colon THEN
DevCPS.Get(sym);
Type(resTyp, name);
IF resTyp.form = Comp THEN resTyp := DevCPT.undftyp; err(54) END
ELSE resTyp := DevCPT.notyp
END
END FormalParameters;
PROCEDURE CheckOverwrite (proc, base: DevCPT.Object; rec: DevCPT.Struct);
VAR o, bo: DevCPT.Object;
BEGIN
IF base # NIL THEN
IF base.conval.setval * {absAttr, empAttr, extAttr} = {} THEN err(182) END;
IF (proc.link.mode # base.link.mode) OR (proc.link.vis # base.link.vis)
OR ~DevCPT.Extends(proc.link.typ, base.link.typ) THEN err(115) END;
o := proc.link; bo := base.link;
WHILE (o # NIL) & (bo # NIL) DO
IF (bo.sysflag # 0) & (o.sysflag = 0) THEN (* propagate sysflags *)
o.sysflag := bo.sysflag
END;
o := o.link; bo := bo.link
END;
DevCPB.CheckParameters(proc.link.link, base.link.link, FALSE);
IF ~DevCPT.Extends(proc.typ, base.typ) THEN err(117) END;
IF (base.vis # proc.vis) & ((proc.vis # internal) OR rec.exp) THEN err(183) END;
INCL(proc.conval.setval, isRedef)
END;
END CheckOverwrite;
PROCEDURE GetAttributes (proc, base: DevCPT.Object; owner: DevCPT.Struct); (* read method attributes *)
VAR attr, battr: SET; o: DevCPT.Object;
BEGIN
attr := {};
IF sym = comma THEN (* read attributes *)
DevCPS.Get(sym);
IF sym = ident THEN
DevCPT.Find(DevCPS.name, o);
IF (o # NIL) & (o.mode = SProc) & (o.adr = newfn) THEN
IF ~(DevCPM.oberon IN DevCPM.options) THEN INCL(attr, newAttr) ELSE err(178) END;
DevCPS.Get(sym);
IF sym = comma THEN
DevCPS.Get(sym);
IF sym = ident THEN DevCPT.Find(DevCPS.name, o) ELSE o := NIL; err(ident) END
ELSE o := NIL
END
END;
IF o # NIL THEN
IF (o.mode # Attr) OR (o.adr = limAttr) OR (DevCPM.oberon IN DevCPM.options) THEN err(178)
ELSE INCL(attr, o.adr)
END;
DevCPS.Get(sym)
END
ELSE err(ident)
END
END;
IF (base = NIL) & ~(newAttr IN attr) THEN err(185); INCL(attr, newAttr)
ELSIF (base # NIL) & (newAttr IN attr) THEN err(186)
END;
IF absAttr IN attr THEN
IF owner.attribute # absAttr THEN err(190) END;
IF (proc.vis = internal) & owner.exp THEN err(179) END
END;
IF (owner.attribute = 0) OR (owner.attribute = limAttr) THEN
IF (empAttr IN attr) & (newAttr IN attr) THEN err(187)
(*
ELSIF extAttr IN attr THEN err(188)
*)
END
END;
IF base # NIL THEN
battr := base.conval.setval;
IF empAttr IN battr THEN
IF absAttr IN attr THEN err(189) END
ELSIF ~(absAttr IN battr) THEN
IF (absAttr IN attr) OR (empAttr IN attr) THEN err(189) END
END
END;
IF empAttr IN attr THEN
IF proc.typ # DevCPT.notyp THEN err(195)
ELSE
o := proc.link; WHILE (o # NIL) & (o.vis # outPar) DO o := o.link END;
IF o # NIL THEN err(195) END
END
END;
IF (owner.sysflag = interface) & ~(absAttr IN attr) THEN err(162) END;
proc.conval.setval := attr
END GetAttributes;
PROCEDURE RecordType(VAR typ: DevCPT.Struct; attr: DevCPT.Object);
VAR fld, first, last, base: DevCPT.Object; r: Elem; ftyp: DevCPT.Struct; name: DevCPT.String;
BEGIN typ := DevCPT.NewStr(Comp, Record); typ.BaseTyp := NIL;
CheckSysFlag(typ.sysflag, DevCPM.GetRecordSysFlag);
IF attr # NIL THEN
IF ~(DevCPM.oberon IN DevCPM.options) & (attr.adr # empAttr) THEN typ.attribute := SHORT(SHORT(attr.adr))
ELSE err(178)
END
END;
IF typ.sysflag = interface THEN
IF (DevCPS.str # NIL) & (DevCPS.str[0] = "{") THEN typ.ext := DevCPS.str END;
IF typ.attribute # absAttr THEN err(163) END;
IF sym # lparen THEN err(160) END
END;
IF sym = lparen THEN
DevCPS.Get(sym); (*record extension*)
IF sym = ident THEN
Type(ftyp, name);
IF ftyp.form = Pointer THEN ftyp := ftyp.BaseTyp END;
SetType(typ, NIL, ftyp, name);
IF (ftyp.comp = Record) & (ftyp # DevCPT.anytyp) THEN
ftyp.pvused := TRUE; typ.extlev := SHORT(SHORT(ftyp.extlev + 1));
DevCPM.PropagateRecordSysFlag(ftyp.sysflag, typ.sysflag);
IF (ftyp.attribute = 0) OR (ftyp.attribute = limAttr) & (ftyp.mno # 0) THEN err(181)
ELSIF (typ.attribute = absAttr) & (ftyp.attribute # absAttr) & ~(DevCPM.java IN DevCPM.options) THEN err(191)
ELSIF (ftyp.attribute = limAttr) & (typ.attribute # limAttr) THEN err(197)
END
ELSIF ftyp # DevCPT.undftyp THEN err(53)
END
ELSE err(ident)
END ;
IF typ.attribute # absAttr THEN (* save typ for unimplemented method check *)
NEW(r); r.struct := typ; r.pos := DevCPM.errpos; r.next := recList; recList := r
END;
CheckSym(rparen)
END;
(*
DevCPT.OpenScope(0, NIL);
*)
first := NIL; last := NIL;
LOOP
IF sym = ident THEN
DevCPS.Indent(1);
LOOP
IF sym = ident THEN
IF (typ.BaseTyp # NIL) & (typ.BaseTyp # DevCPT.undftyp) THEN
DevCPT.FindBaseField(DevCPS.name, typ, fld);
IF fld # NIL THEN err(1) END
END ;
DevCPT.InsertField(DevCPS.name, typ, fld);
fld.mode := Fld; fld.link := NIL; fld.typ := DevCPT.undftyp;
CheckMark(fld);
IF first = NIL THEN first := fld END ;
IF last = NIL THEN typ.link := fld ELSE last.link := fld END ;
last := fld
ELSE err(ident)
END ;
IF sym = comma THEN DevCPS.Get(sym)
ELSIF sym = ident THEN err(comma)
ELSE EXIT
END
END ;
CheckSym(colon); Type(ftyp, name);
CheckAlloc(ftyp, FALSE, DevCPM.errpos);
WHILE first # NIL DO
SetType(typ, first, ftyp, name); first := first.link
END;
IF typ.sysflag = interface THEN err(161) END
END;
IF sym = semicolon THEN DevCPS.Get(sym)
ELSIF sym = ident THEN err(semicolon)
ELSE EXIT
END
END;
(*
IF typ.link # NIL THEN ASSERT(typ.link = DevCPT.topScope.right) END;
typ.link := DevCPT.topScope.right; DevCPT.CloseScope;
*)
typ.untagged := typ.sysflag > 0;
DevCPB.Inittd(TDinit, lastTDinit, typ); CheckIndentSym(3+1*8, end)
END RecordType;
PROCEDURE ArrayType(VAR typ: DevCPT.Struct);
VAR x: DevCPT.Node; n: INTEGER; sysflag: SHORTINT; name: DevCPT.String;
BEGIN CheckSysFlag(sysflag, DevCPM.GetArraySysFlag);
IF sym = of THEN (*dynamic array*)
typ := DevCPT.NewStr(Comp, DynArr); typ.mno := 0; typ.sysflag := sysflag;
DevCPS.Get(sym); Type(typ.BaseTyp, name); SetType(typ, NIL, typ.BaseTyp, name);
CheckAlloc(typ.BaseTyp, TRUE, DevCPM.errpos);
IF typ.BaseTyp.comp = DynArr THEN typ.n := typ.BaseTyp.n + 1 ELSE typ.n := 0 END
ELSE
typ := DevCPT.NewStr(Comp, Array); typ.sysflag := sysflag; ConstExpression(x);
IF x.typ.form IN {Int8, Int16, Int32} THEN n := x.conval.intval;
IF (n <= 0) OR (n > DevCPM.MaxIndex) THEN err(63); n := 1 END
ELSE err(42); n := 1
END ;
typ.n := n;
IF sym = of THEN
DevCPS.Get(sym); Type(typ.BaseTyp, name); SetType(typ, NIL, typ.BaseTyp, name);
CheckAlloc(typ.BaseTyp, FALSE, DevCPM.errpos)
ELSIF sym = comma THEN
DevCPS.Get(sym);
IF sym # of THEN ArrayType(typ.BaseTyp) END
ELSE err(35)
END
END;
typ.untagged := typ.sysflag > 0
END ArrayType;
PROCEDURE PointerType(VAR typ: DevCPT.Struct);
VAR id: DevCPT.Object; name: DevCPT.String;
BEGIN typ := DevCPT.NewStr(Pointer, Basic); CheckSysFlag(typ.sysflag, DevCPM.GetPointerSysFlag);
CheckSym(to);
Type(typ.BaseTyp, name);
SetType(typ, NIL, typ.BaseTyp, name);
IF (typ.BaseTyp # DevCPT.undftyp) & (typ.BaseTyp.comp = Basic) THEN
typ.BaseTyp := DevCPT.undftyp; err(57)
END;
IF typ.BaseTyp.comp = Record THEN DevCPM.PropagateRecPtrSysFlag(typ.BaseTyp.sysflag, typ.sysflag)
ELSIF typ.BaseTyp.comp IN {Array, DynArr} THEN DevCPM.PropagateArrPtrSysFlag(typ.BaseTyp.sysflag, typ.sysflag)
END;
typ.untagged := typ.sysflag > 0
END PointerType;
PROCEDURE Type (VAR typ: DevCPT.Struct; VAR name: DevCPT.String); (* name # NIL => forward reference *)
VAR id: DevCPT.Object; tname: DevCPT.String;
BEGIN
typ := DevCPT.undftyp; name := NIL;
IF sym < lparen THEN err(12);
REPEAT DevCPS.Get(sym) UNTIL sym >= lparen
END ;
IF sym = ident THEN
DevCPT.Find(DevCPS.name, id);
IF (id = NIL) OR (id.mode = -1) OR (id.mode = Typ) & IncompleteType(id.typ) THEN (* forward type definition *)
name := DevCPT.NewName(DevCPS.name); DevCPS.Get(sym);
IF (id = NIL) & (sym = period) THEN (* missing module *)
err(0); DevCPS.Get(sym); name := NIL;
IF sym = ident THEN DevCPS.Get(sym) END
ELSIF sym = record THEN (* wrong attribute *)
err(178); DevCPS.Indent(2); DevCPS.Get(sym); name := NIL; RecordType(typ, NIL)
END
ELSE
qualident(id);
IF id.mode = Typ THEN
IF ~(DevCPM.oberon IN DevCPM.options)
& ((id.typ = DevCPT.lreal64typ) OR (id.typ = DevCPT.lint64typ) OR (id.typ = DevCPT.lchar16typ)) THEN
err(198)
END;
typ := id.typ
ELSIF id.mode = Attr THEN
IF sym = record THEN
DevCPS.Indent(2); DevCPS.Get(sym); RecordType(typ, id)
ELSE err(12)
END
ELSE err(52)
END
END
ELSIF sym = array THEN
DevCPS.Get(sym); ArrayType(typ)
ELSIF sym = record THEN
DevCPS.Indent(2); DevCPS.Get(sym); RecordType(typ, NIL)
ELSIF sym = pointer THEN
DevCPS.Get(sym); PointerType(typ)
ELSIF sym = procedure THEN
DevCPS.Get(sym); typ := DevCPT.NewStr(ProcTyp, Basic);
(*
CheckSysFlag(typ.sysflag, DevCPM.GetProcTypSysFlag);
typ.untagged := typ.sysflag > 0;
*)
IF sym = lparen THEN
DevCPS.Get(sym); DevCPT.OpenScope(level, NIL);
FormalParameters(typ.link, typ.BaseTyp, tname); SetType(typ, NIL, typ.BaseTyp, tname); DevCPT.CloseScope
ELSE typ.BaseTyp := DevCPT.notyp; typ.link := NIL
END
ELSE err(12)
END ;
LOOP
IF (sym >= semicolon) & (sym <= else) OR (sym = rparen) OR (sym = eof)
OR (sym = number) OR (sym = comma) OR (sym = string) THEN EXIT END;
err(15); IF sym = ident THEN EXIT END;
DevCPS.Get(sym)
END
END Type;
PROCEDURE ActualParameters(VAR aparlist: DevCPT.Node; fpar: DevCPT.Object; VAR pre, lastp: DevCPT.Node);
VAR apar, last, newPar, iidPar, n: DevCPT.Node;
BEGIN
aparlist := NIL; last := NIL;
IF sym # rparen THEN
newPar := NIL; iidPar := NIL;
LOOP Expression(apar);
IF fpar # NIL THEN
IF (apar.typ.form = Pointer) & (fpar.typ.form = Comp) THEN DevCPB.DeRef(apar) END;
DevCPB.Param(apar, fpar);
IF (fpar.mode = Var) OR (fpar.vis = inPar) THEN DevCPB.CheckBuffering(apar, NIL, fpar, pre, lastp) END;
DevCPB.Link(aparlist, last, apar);
IF ODD(fpar.sysflag DIV newBit) THEN newPar := apar
ELSIF ODD(fpar.sysflag DIV iidBit) THEN iidPar := apar
END;
IF (newPar # NIL) & (iidPar # NIL) THEN DevCPB.CheckNewParamPair(newPar, iidPar) END;
IF anchorVarPar & (fpar.mode = VarPar) & ~(DevCPM.java IN DevCPM.options)
OR (DevCPM.allSysVal IN DevCPM.options) (* source output: avoid double evaluation *)
& ((fpar.mode = VarPar) & (fpar.typ.comp = Record) & ~fpar.typ.untagged
OR (fpar.typ.comp = DynArr) & ~fpar.typ.untagged) THEN
n := apar;
WHILE n.class IN {Nfield, Nindex, Nguard} DO n := n.left END;
IF (n.class = Nderef) & (n.subcl = 0) THEN
IF n.left.class = Nguard THEN n := n.left END;
DevCPB.CheckVarParBuffering(n.left, pre, lastp)
END
END;
fpar := fpar.link
ELSE err(64)
END;
IF sym = comma THEN DevCPS.Get(sym)
ELSIF (lparen <= sym) & (sym <= ident) THEN err(comma)
ELSE EXIT
END
END
END;
IF fpar # NIL THEN err(65) END
END ActualParameters;
PROCEDURE selector(VAR x: DevCPT.Node);
VAR obj, proc, p, fpar: DevCPT.Object; y, apar, pre, lastp: DevCPT.Node; typ: DevCPT.Struct; name: DevCPT.Name;
BEGIN
LOOP
IF sym = lbrak THEN DevCPS.Get(sym);
LOOP
IF (x.typ # NIL) & (x.typ.form = Pointer) THEN DevCPB.DeRef(x) END ;
Expression(y); DevCPB.Index(x, y);
IF sym = comma THEN DevCPS.Get(sym) ELSE EXIT END
END ;
CheckSym(rbrak)
ELSIF sym = period THEN DevCPS.Get(sym);
IF sym = ident THEN name := DevCPS.name; DevCPS.Get(sym);
IF x.typ # NIL THEN
IF x.typ.form = Pointer THEN DevCPB.DeRef(x) END ;
IF x.typ.comp = Record THEN
typ := x.typ; DevCPT.FindField(name, typ, obj); DevCPB.Field(x, obj);
IF (obj # NIL) & (obj.mode = TProc) THEN
IF sym = arrow THEN (* super call *) DevCPS.Get(sym);
y := x.left;
IF y.class = Nderef THEN y := y.left END ; (* y = record variable *)
IF y.obj # NIL THEN
proc := DevCPT.topScope; (* find innermost scope which owner is a TProc *)
WHILE (proc.link # NIL) & (proc.link.mode # TProc) DO proc := proc.left END ;
IF (proc.link = NIL) OR (proc.link.link # y.obj) (* OR (proc.link.name^ # name) *) THEN err(75)
END ;
typ := y.obj.typ;
IF typ.form = Pointer THEN typ := typ.BaseTyp END ;
DevCPT.FindBaseField(x.obj.name^, typ, p);
IF p # NIL THEN
x.subcl := super; x.typ := p.typ; (* correct result type *)
IF p.conval.setval * {absAttr, empAttr} # {} THEN err(194) END;
IF (p.vis = externalR) & (p.mnolev < 0) & (proc.link.name^ # name) THEN err(196) END;
ELSE err(74)
END
ELSE err(75)
END
ELSE
proc := obj;
WHILE (proc.mnolev >= 0) & ~(newAttr IN proc.conval.setval) & (typ.BaseTyp # NIL) DO
(* find base method *)
typ := typ.BaseTyp; DevCPT.FindField(name, typ, proc);
END;
IF (proc.vis = externalR) & (proc.mnolev < 0) THEN err(196) END;
END ;
IF (obj.typ # DevCPT.notyp) & (sym # lparen) THEN err(lparen) END
END
ELSE err(53)
END
ELSE err(52)
END
ELSE err(ident)
END
ELSIF sym = arrow THEN DevCPS.Get(sym); DevCPB.DeRef(x)
ELSIF sym = dollar THEN
IF x.typ.form = Pointer THEN DevCPB.DeRef(x) END;
DevCPS.Get(sym); DevCPB.StrDeref(x)
ELSIF sym = lparen THEN
IF (x.obj # NIL) & (x.obj.mode IN {XProc, LProc, CProc, TProc}) THEN typ := x.obj.typ
ELSIF x.typ.form = ProcTyp THEN typ := x.typ.BaseTyp
ELSIF x.class = Nproc THEN EXIT (* standard procedure *)
ELSE typ := NIL
END;
IF typ # DevCPT.notyp THEN
DevCPS.Get(sym);
IF typ = NIL THEN (* type guard *)
IF sym = ident THEN
qualident(obj);
IF obj.mode = Typ THEN DevCPB.TypTest(x, obj, TRUE)
ELSE err(52)
END
ELSE err(ident)
END
ELSE (* function call *)
pre := NIL; lastp := NIL;
DevCPB.PrepCall(x, fpar);
IF (x.obj # NIL) & (x.obj.mode = TProc) THEN DevCPB.CheckBuffering(x.left, NIL, x.obj.link, pre, lastp)
END;
ActualParameters(apar, fpar, pre, lastp);
DevCPB.Call(x, apar, fpar);
IF pre # NIL THEN DevCPB.Construct(Ncomp, pre, x); pre.typ := x.typ; x := pre END;
IF level > 0 THEN DevCPT.topScope.link.leaf := FALSE END
END;
CheckSym(rparen)
ELSE EXIT
END
(*
ELSIF (sym = lparen) & (x.class # Nproc) & (x.typ.form # ProcTyp) &
((x.obj = NIL) OR (x.obj.mode # TProc)) THEN
DevCPS.Get(sym);
IF sym = ident THEN
qualident(obj);
IF obj.mode = Typ THEN DevCPB.TypTest(x, obj, TRUE)
ELSE err(52)
END
ELSE err(ident)
END ;
CheckSym(rparen)
*)
ELSE EXIT
END
END
END selector;
PROCEDURE StandProcCall(VAR x: DevCPT.Node);
VAR y: DevCPT.Node; m: BYTE; n: SHORTINT;
BEGIN m := SHORT(SHORT(x.obj.adr)); n := 0;
IF sym = lparen THEN DevCPS.Get(sym);
IF sym # rparen THEN
LOOP
IF n = 0 THEN Expression(x); DevCPB.StPar0(x, m); n := 1
ELSIF n = 1 THEN Expression(y); DevCPB.StPar1(x, y, m); n := 2
ELSE Expression(y); DevCPB.StParN(x, y, m, n); INC(n)
END ;
IF sym = comma THEN DevCPS.Get(sym)
ELSIF (lparen <= sym) & (sym <= ident) THEN err(comma)
ELSE EXIT
END
END ;
CheckSym(rparen)
ELSE DevCPS.Get(sym)
END ;
DevCPB.StFct(x, m, n)
ELSE err(lparen)
END ;
IF (level > 0) & ((m = newfn) OR (m = sysnewfn)) THEN DevCPT.topScope.link.leaf := FALSE END
END StandProcCall;
PROCEDURE Element(VAR x: DevCPT.Node);
VAR y: DevCPT.Node;
BEGIN Expression(x);
IF sym = upto THEN
DevCPS.Get(sym); Expression(y); DevCPB.SetRange(x, y)
ELSE DevCPB.SetElem(x)
END
END Element;
PROCEDURE Sets(VAR x: DevCPT.Node);
VAR y: DevCPT.Node;
BEGIN
IF sym # rbrace THEN
Element(x);
LOOP
IF sym = comma THEN DevCPS.Get(sym)
ELSIF (lparen <= sym) & (sym <= ident) THEN err(comma)
ELSE EXIT
END ;
Element(y); DevCPB.Op(plus, x, y)
END
ELSE x := DevCPB.EmptySet()
END ;
CheckSym(rbrace)
END Sets;
PROCEDURE Factor(VAR x: DevCPT.Node);
VAR fpar, id: DevCPT.Object; apar: DevCPT.Node;
BEGIN
IF sym < not THEN err(13);
REPEAT DevCPS.Get(sym) UNTIL sym >= lparen
END ;
IF sym = ident THEN
qualident(id); x := DevCPB.NewLeaf(id); selector(x);
IF (x.class = Nproc) & (x.obj.mode = SProc) THEN StandProcCall(x) (* x may be NIL *)
(*
ELSIF sym = lparen THEN
DevCPS.Get(sym); DevCPB.PrepCall(x, fpar);
ActualParameters(apar, fpar);
DevCPB.Call(x, apar, fpar);
CheckSym(rparen);
IF level > 0 THEN DevCPT.topScope.link.leaf := FALSE END
*)
END
ELSIF sym = number THEN
CASE DevCPS.numtyp OF
char:
x := DevCPB.NewIntConst(DevCPS.intval); x.typ := DevCPT.char8typ;
IF DevCPS.intval > 255 THEN x.typ := DevCPT.char16typ END
| integer: x := DevCPB.NewIntConst(DevCPS.intval)
| int64: x := DevCPB.NewLargeIntConst(DevCPS.intval, DevCPS.realval)
| real: x := DevCPB.NewRealConst(DevCPS.realval, NIL)
| real32: x := DevCPB.NewRealConst(DevCPS.realval, DevCPT.real32typ)
| real64: x := DevCPB.NewRealConst(DevCPS.realval, DevCPT.real64typ)
END ;
DevCPS.Get(sym)
ELSIF sym = string THEN
x := DevCPB.NewString(DevCPS.str, DevCPS.intval);
DevCPS.Get(sym)
ELSIF sym = nil THEN
x := DevCPB.Nil(); DevCPS.Get(sym)
ELSIF sym = lparen THEN
DevCPS.Get(sym); Expression(x); CheckSym(rparen)
ELSIF sym = lbrak THEN
DevCPS.Get(sym); err(lparen); Expression(x); CheckSym(rparen)
ELSIF sym = lbrace THEN DevCPS.Get(sym); Sets(x)
ELSIF sym = not THEN
DevCPS.Get(sym); Factor(x); DevCPB.MOp(not, x)
ELSE err(13); DevCPS.Get(sym); x := NIL
END ;
IF x = NIL THEN x := DevCPB.NewIntConst(1); x.typ := DevCPT.undftyp END
END Factor;
PROCEDURE Term(VAR x: DevCPT.Node);
VAR y: DevCPT.Node; mulop: BYTE;
BEGIN Factor(x);
WHILE (times <= sym) & (sym <= and) DO
mulop := sym; DevCPS.Get(sym);
Factor(y); DevCPB.Op(mulop, x, y)
END
END Term;
PROCEDURE SimpleExpression(VAR x: DevCPT.Node);
VAR y: DevCPT.Node; addop: BYTE;
BEGIN
IF sym = minus THEN DevCPS.Get(sym); Term(x); DevCPB.MOp(minus, x)
ELSIF sym = plus THEN DevCPS.Get(sym); Term(x); DevCPB.MOp(plus, x)
ELSE Term(x)
END ;
WHILE (plus <= sym) & (sym <= or) DO
addop := sym; DevCPS.Get(sym); Term(y);
IF x.typ.form = Pointer THEN DevCPB.DeRef(x) END;
IF (x.typ.comp IN {Array, DynArr}) & (x.typ.BaseTyp.form IN charSet) (* OR (x.typ.sysflag = jstr) *) THEN
DevCPB.StrDeref(x)
END;
IF y.typ.form = Pointer THEN DevCPB.DeRef(y) END;
IF (y.typ.comp IN {Array, DynArr}) & (y.typ.BaseTyp.form IN charSet) (* OR (y.typ.sysflag = jstr) *) THEN
DevCPB.StrDeref(y)
END;
DevCPB.Op(addop, x, y)
END
END SimpleExpression;
PROCEDURE Expression(VAR x: DevCPT.Node);
VAR y, pre, last: DevCPT.Node; obj: DevCPT.Object; relation: BYTE;
BEGIN SimpleExpression(x);
IF (eql <= sym) & (sym <= geq) THEN
relation := sym; DevCPS.Get(sym); SimpleExpression(y);
pre := NIL; last := NIL;
IF (x.typ.comp IN {Array, DynArr}) & (x.typ.BaseTyp.form IN charSet) THEN
DevCPB.StrDeref(x)
END;
IF (y.typ.comp IN {Array, DynArr}) & (y.typ.BaseTyp.form IN charSet) THEN
DevCPB.StrDeref(y)
END;
DevCPB.CheckBuffering(x, NIL, NIL, pre, last);
DevCPB.CheckBuffering(y, NIL, NIL, pre, last);
DevCPB.Op(relation, x, y);
IF pre # NIL THEN DevCPB.Construct(Ncomp, pre, x); pre.typ := x.typ; x := pre END
ELSIF sym = in THEN
DevCPS.Get(sym); SimpleExpression(y); DevCPB.In(x, y)
ELSIF sym = is THEN
DevCPS.Get(sym);
IF sym = ident THEN
qualident(obj);
IF obj.mode = Typ THEN DevCPB.TypTest(x, obj, FALSE)
ELSE err(52)
END
ELSE err(ident)
END
END
END Expression;
PROCEDURE ProcedureDeclaration(VAR x: DevCPT.Node);
VAR proc, fwd: DevCPT.Object;
name: DevCPT.Name;
mode: BYTE;
forward: BOOLEAN;
sys: SHORTINT;
PROCEDURE GetCode;
VAR ext: DevCPT.ConstExt; i, n, c: INTEGER; s: ARRAY 256 OF SHORTCHAR;
BEGIN
n := 0;
IF sym = string THEN
NEW(ext, DevCPS.intval);
WHILE DevCPS.str[n] # 0X DO ext[n+1] := DevCPS.str[n]; INC(n) END ;
ext^[0] := SHORT(CHR(n)); DevCPS.Get(sym);
ELSE
LOOP
IF sym = number THEN c := DevCPS.intval; INC(n);
IF (c < 0) OR (c > 255) OR (n = 255) THEN
err(64); c := 1; n := 1
END ;
DevCPS.Get(sym); s[n] := SHORT(CHR(c))
END ;
IF sym = comma THEN DevCPS.Get(sym)
ELSIF sym = number THEN err(comma)
ELSE s[0] := SHORT(CHR(n)); EXIT
END
END;
NEW(ext, n + 1); i := 0;
WHILE i <= n DO ext[i] := s[i]; INC(i) END;
END;
proc.conval.ext := ext;
INCL(proc.conval.setval, hasBody)
END GetCode;
PROCEDURE GetParams;
VAR name: DevCPT.String;
BEGIN
proc.mode := mode; proc.typ := DevCPT.notyp;
proc.sysflag := SHORT(sys);
proc.conval.setval := {};
IF sym = lparen THEN
DevCPS.Get(sym); FormalParameters(proc.link, proc.typ, name);
IF name # NIL THEN err(0) END
END;
CheckForwardTypes; userList := NIL;
IF fwd # NIL THEN
DevCPB.CheckParameters(proc.link, fwd.link, TRUE);
IF ~DevCPT.EqualType(proc.typ, fwd.typ) THEN err(117) END ;
proc := fwd; DevCPT.topScope := proc.scope;
IF mode = IProc THEN proc.mode := IProc END
END
END GetParams;
PROCEDURE Body;
VAR procdec, statseq: DevCPT.Node; c: INTEGER;
BEGIN
c := DevCPM.errpos;
INCL(proc.conval.setval, hasBody);
CheckIndentSym(2, semicolon); Block(procdec, statseq);
DevCPB.Enter(procdec, statseq, proc); x := procdec;
x.conval := DevCPT.NewConst(); x.conval.intval := c; x.conval.intval2 := DevCPM.startpos;
CheckIndentSym(3+1*8, end);
IF sym = ident THEN
IF DevCPS.name # proc.name^ THEN err(4) END ;
DevCPS.Get(sym)
ELSE err(ident)
END
END Body;
PROCEDURE TProcDecl;
VAR baseProc, o, bo: DevCPT.Object;
objTyp, recTyp: DevCPT.Struct;
objMode, objVis: BYTE;
objName: DevCPT.Name;
pnode: DevCPT.Node;
fwdAttr: SET;
BEGIN
DevCPS.Get(sym); mode := TProc;
IF level > 0 THEN err(73) END;
Receiver(objMode, objVis, objName, objTyp, recTyp);
IF sym = ident THEN
name := DevCPS.name;
DevCPT.FindField(name, recTyp, fwd);
DevCPT.FindBaseField(name, recTyp, baseProc);
IF (baseProc # NIL) & (baseProc.mode # TProc) THEN baseProc := NIL; err(1) END ;
IF fwd = baseProc THEN fwd := NIL END ;
IF (fwd # NIL) & (fwd.mnolev # level) THEN fwd := NIL END ;
IF (fwd # NIL) & (fwd.mode = TProc) & (fwd.conval.setval * {hasBody, absAttr, empAttr} = {}) THEN
(* there exists a corresponding forward declaration *)
proc := DevCPT.NewObj(); proc.leaf := TRUE;
proc.mode := TProc; proc.conval := DevCPT.NewConst();
CheckMark(proc);
IF fwd.vis # proc.vis THEN err(118) END;
fwdAttr := fwd.conval.setval
ELSE
IF fwd # NIL THEN err(1); fwd := NIL END ;
DevCPT.InsertField(name, recTyp, proc);
proc.mode := TProc; proc.conval := DevCPT.NewConst();
CheckMark(proc);
IF recTyp.strobj # NIL THEN (* preserve declaration order *)
o := recTyp.strobj.link;
IF o = NIL THEN recTyp.strobj.link := proc
ELSE
WHILE o.nlink # NIL DO o := o.nlink END;
o.nlink := proc
END
END
END;
INC(level); DevCPT.OpenScope(level, proc);
DevCPT.Insert(objName, proc.link); proc.link.mode := objMode; proc.link.vis := objVis; proc.link.typ := objTyp;
ASSERT(DevCPT.topScope # NIL);
GetParams; (* may change proc := fwd !!! *)
ASSERT(DevCPT.topScope # NIL);
GetAttributes(proc, baseProc, recTyp);
IF (fwd # NIL) & (fwdAttr / proc.conval.setval * {absAttr, empAttr, extAttr} # {}) THEN err(184) END;
CheckOverwrite(proc, baseProc, recTyp);
IF ~forward THEN
IF empAttr IN proc.conval.setval THEN (* insert empty procedure *)
pnode := NIL; DevCPB.Enter(pnode, NIL, proc);
pnode.conval := DevCPT.NewConst();
pnode.conval.intval := DevCPM.errpos;
pnode.conval.intval2 := DevCPM.errpos;
x := pnode;
ELSIF DevCPM.noCode IN DevCPM.options THEN INCL(proc.conval.setval, hasBody)
ELSIF ~(absAttr IN proc.conval.setval) THEN Body
END;
proc.adr := 0
ELSE
proc.adr := DevCPM.errpos;
IF proc.conval.setval * {empAttr, absAttr} # {} THEN err(184) END
END;
DEC(level); DevCPT.CloseScope;
ELSE err(ident)
END;
END TProcDecl;
BEGIN proc := NIL; forward := FALSE; x := NIL; mode := LProc; sys := 0;
IF (sym # ident) & (sym # lparen) THEN
CheckSysFlag(sys, DevCPM.GetProcSysFlag);
IF sys # 0 THEN
IF ODD(sys DIV DevCPM.CProcFlag) THEN mode := CProc END
ELSE
IF sym = times THEN (* mode set later in DevCPB.CheckAssign *)
ELSIF sym = arrow THEN forward := TRUE
ELSE err(ident)
END;
DevCPS.Get(sym)
END
END ;
IF sym = lparen THEN TProcDecl
ELSIF sym = ident THEN DevCPT.Find(DevCPS.name, fwd);
name := DevCPS.name;
IF (fwd # NIL) & ((fwd.mnolev # level) OR (fwd.mode = SProc)) THEN fwd := NIL END ;
IF (fwd # NIL) & (fwd.mode IN {LProc, XProc}) & ~(hasBody IN fwd.conval.setval) THEN
(* there exists a corresponding forward declaration *)
proc := DevCPT.NewObj(); proc.leaf := TRUE;
proc.mode := mode; proc.conval := DevCPT.NewConst();
CheckMark(proc);
IF fwd.vis # proc.vis THEN err(118) END
ELSE
IF fwd # NIL THEN err(1); fwd := NIL END ;
DevCPT.Insert(name, proc);
proc.mode := mode; proc.conval := DevCPT.NewConst();
CheckMark(proc);
END ;
IF (proc.vis # internal) & (mode = LProc) THEN mode := XProc END ;
IF (mode # LProc) & (level > 0) THEN err(73) END ;
INC(level); DevCPT.OpenScope(level, proc);
proc.link := NIL; GetParams; (* may change proc := fwd !!! *)
IF mode = CProc THEN GetCode
ELSIF DevCPM.noCode IN DevCPM.options THEN INCL(proc.conval.setval, hasBody)
ELSIF ~forward THEN Body; proc.adr := 0
ELSE proc.adr := DevCPM.errpos
END ;
DEC(level); DevCPT.CloseScope
ELSE err(ident)
END
END ProcedureDeclaration;
PROCEDURE CaseLabelList(VAR lab, root: DevCPT.Node; LabelForm: SHORTINT; VAR min, max: INTEGER);
VAR x, y, lastlab: DevCPT.Node; i, f: SHORTINT; xval, yval: INTEGER;
PROCEDURE Insert(VAR n: DevCPT.Node); (* build binary tree of label ranges *) (* !!! *)
BEGIN
IF n = NIL THEN
IF x.hint # 1 THEN n := x END
ELSIF yval < n.conval.intval THEN Insert(n.left)
ELSIF xval > n.conval.intval2 THEN Insert(n.right)
ELSE err(63)
END
END Insert;
BEGIN lab := NIL; lastlab := NIL;
LOOP ConstExpression(x); f := x.typ.form;
IF f IN intSet + charSet THEN xval := x.conval.intval
ELSE err(61); xval := 1
END ;
IF (f IN intSet) # (LabelForm IN intSet) THEN err(60) END;
IF sym = upto THEN
DevCPS.Get(sym); ConstExpression(y); yval := y.conval.intval;
IF (y.typ.form IN intSet) # (LabelForm IN intSet) THEN err(60) END;
IF yval < xval THEN err(63); yval := xval END
ELSE yval := xval
END ;
x.conval.intval2 := yval;
IF xval < min THEN min := xval END;
IF yval > max THEN max := yval END;
IF lab = NIL THEN lab := x; Insert(root)
ELSIF yval < lab.conval.intval - 1 THEN x.link := lab; lab := x; Insert(root)
ELSIF yval = lab.conval.intval - 1 THEN x.hint := 1; Insert(root); lab.conval.intval := xval
ELSIF xval = lab.conval.intval2 + 1 THEN x.hint := 1; Insert(root); lab.conval.intval2 := yval
ELSE
y := lab;
WHILE (y.link # NIL) & (xval > y.link.conval.intval2 + 1) DO y := y.link END;
IF y.link = NIL THEN y.link := x; Insert(root)
ELSIF yval < y.link.conval.intval - 1 THEN x.link := y.link; y.link := x; Insert(root)
ELSIF yval = y.link.conval.intval - 1 THEN x.hint := 1; Insert(root); y.link.conval.intval := xval
ELSIF xval = y.link.conval.intval2 + 1 THEN x.hint := 1; Insert(root); y.link.conval.intval2 := yval
END
END;
IF sym = comma THEN DevCPS.Get(sym)
ELSIF (sym = number) OR (sym = ident) THEN err(comma)
ELSE EXIT
END
END
END CaseLabelList;
PROCEDURE StatSeq(VAR stat: DevCPT.Node);
VAR fpar, id, t, obj: DevCPT.Object; idtyp: DevCPT.Struct; e: BOOLEAN;
s, x, y, z, apar, last, lastif, pre, lastp: DevCPT.Node; pos, p: INTEGER; name: DevCPT.Name;
PROCEDURE CasePart(VAR x: DevCPT.Node);
VAR low, high: INTEGER; e: BOOLEAN; cases, lab, y, lastcase, root: DevCPT.Node;
BEGIN
Expression(x);
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126)
ELSIF x.typ.form = Int64 THEN err(260)
ELSIF ~(x.typ.form IN intSet + charSet) THEN err(125)
END ;
CheckIndentSym(1+2*8, of); cases := NIL; lastcase := NIL; root := NIL;
low := MAX(INTEGER); high := MIN(INTEGER);
LOOP
IF sym < bar THEN
CaseLabelList(lab, root, x.typ.form, low, high);
CheckSym(colon); DevCPS.Indent(2); StatSeq(y);
DevCPB.Construct(Ncasedo, lab, y); DevCPB.Link(cases, lastcase, lab)
END ;
IF sym = bar THEN DevCPS.Indent(3+1*8); DevCPS.Get(sym) ELSE EXIT END
END;
e := sym = else;
IF e THEN DevCPS.Indent(3+1*8+2*64); DevCPS.Get(sym); StatSeq(y) ELSE y := NIL END ;
DevCPB.Construct(Ncaselse, cases, y); DevCPB.Construct(Ncase, x, cases);
cases.conval := DevCPT.NewConst();
cases.conval.intval := low; cases.conval.intval2 := high;
IF e THEN cases.conval.setval := {1} ELSE cases.conval.setval := {} END;
DevCPB.OptimizeCase(root); cases.link := root (* !!! *)
END CasePart;
PROCEDURE SetPos(x: DevCPT.Node);
BEGIN
x.conval := DevCPT.NewConst(); x.conval.intval := pos
END SetPos;
PROCEDURE CheckBool(VAR x: DevCPT.Node);
BEGIN
IF (x.class = Ntype) OR (x.class = Nproc) THEN err(126); x := DevCPB.NewBoolConst(FALSE)
ELSIF x.typ.form # Bool THEN err(120); x := DevCPB.NewBoolConst(FALSE)
END
END CheckBool;
BEGIN stat := NIL; last := NIL;
LOOP x := NIL;
IF sym < ident THEN err(14);
REPEAT DevCPS.Get(sym) UNTIL sym >= ident
END ;
pos := DevCPM.startpos;
IF sym = ident THEN
DevCPS.Indent(1);
qualident(id); x := DevCPB.NewLeaf(id); selector(x);
IF sym = becomes THEN
DevCPS.Get(sym); Expression(y);
IF (y.typ.form = Pointer) & (x.typ.form = Comp) THEN DevCPB.DeRef(y) END;
pre := NIL; lastp := NIL;
DevCPB.CheckBuffering(y, x, NIL, pre, lastp);
DevCPB.Assign(x, y);
IF pre # NIL THEN SetPos(x); DevCPB.Construct(Ncomp, pre, x); x := pre END;
ELSIF sym = eql THEN
err(becomes); DevCPS.Get(sym); Expression(y); DevCPB.Assign(x, y)
ELSIF (x.class = Nproc) & (x.obj.mode = SProc) THEN
StandProcCall(x);
IF (x # NIL) & (x.typ # DevCPT.notyp) THEN err(55) END;
IF (x # NIL) & (x.class = Nifelse) THEN (* error pos for ASSERT *)
SetPos(x.left); SetPos(x.left.right)
END
ELSIF x.class = Ncall THEN err(55)
ELSE
pre := NIL; lastp := NIL;
DevCPB.PrepCall(x, fpar);
IF (x.obj # NIL) & (x.obj.mode = TProc) THEN DevCPB.CheckBuffering(x.left, NIL, x.obj.link, pre, lastp) END;
IF sym = lparen THEN
DevCPS.Get(sym); ActualParameters(apar, fpar, pre, lastp); CheckSym(rparen)
ELSE apar := NIL;
IF fpar # NIL THEN err(65) END
END ;
DevCPB.Call(x, apar, fpar);
IF x.typ # DevCPT.notyp THEN err(55) END;
IF pre # NIL THEN SetPos(x); DevCPB.Construct(Ncomp, pre, x); x := pre END;
IF level > 0 THEN DevCPT.topScope.link.leaf := FALSE END
END
ELSIF sym = if THEN
DevCPS.Indent(1);
DevCPS.Get(sym); pos := DevCPM.startpos; Expression(x); CheckBool(x); CheckIndentSym(1+2*8, then); StatSeq(y);
DevCPB.Construct(Nif, x, y); SetPos(x); lastif := x;
WHILE sym = elsif DO
DevCPS.Indent(3+1*8);
DevCPS.Get(sym); pos := DevCPM.startpos; Expression(y); CheckBool(y); CheckIndentSym(1+2*8, then); StatSeq(z);
DevCPB.Construct(Nif, y, z); SetPos(y); DevCPB.Link(x, lastif, y)
END ;
pos := DevCPM.startpos;
IF sym = else THEN DevCPS.Indent(3+1*8+2*64); DevCPS.Get(sym); StatSeq(y) ELSE y := NIL END ;
DevCPB.Construct(Nifelse, x, y); CheckIndentSym(3+1*8, end); DevCPB.OptIf(x);
ELSIF sym = case THEN
DevCPS.Indent(1);
DevCPS.Get(sym); pos := DevCPM.startpos; CasePart(x); CheckIndentSym(3+1*8, end)
ELSIF sym = while THEN
DevCPS.Indent(1);
DevCPS.Get(sym); pos := DevCPM.startpos; Expression(x); CheckBool(x); CheckIndentSym(1+2*8, do); StatSeq(y);
DevCPB.Construct(Nwhile, x, y); CheckIndentSym(3+1*8, end)
ELSIF sym = repeat THEN
DevCPS.Indent(1+2*8);
DevCPS.Get(sym); StatSeq(x);
IF sym = until THEN DevCPS.Indent(3+1*8); DevCPS.Get(sym); pos := DevCPM.startpos; Expression(y); CheckBool(y)
ELSE err(43)
END ;
DevCPB.Construct(Nrepeat, x, y)
ELSIF sym = for THEN
DevCPS.Indent(1);
DevCPS.Get(sym); pos := DevCPM.startpos;
IF sym = ident THEN qualident(id);
IF ~(id.typ.form IN intSet) THEN err(68) END ;
CheckSym(becomes); Expression(y);
x := DevCPB.NewLeaf(id); DevCPB.Assign(x, y); SetPos(x);
CheckSym(to); pos := DevCPM.startpos; Expression(y);
IF y.class # Nconst THEN
DevCPB.GetTempVar("@for", x.left.typ, t);
z := DevCPB.NewLeaf(t); DevCPB.Assign(z, y); SetPos(z); DevCPB.Link(stat, last, z);
y := DevCPB.NewLeaf(t)
ELSE
DevCPB.CheckAssign(x.left.typ, y)
END ;
DevCPB.Link(stat, last, x);
p := DevCPM.startpos;
IF sym = by THEN DevCPS.Get(sym); ConstExpression(z) ELSE z := DevCPB.NewIntConst(1) END ;
x := DevCPB.NewLeaf(id);
IF z.conval.intval > 0 THEN DevCPB.Op(leq, x, y)
ELSIF z.conval.intval < 0 THEN DevCPB.Op(geq, x, y)
ELSE err(63); DevCPB.Op(geq, x, y)
END ;
CheckIndentSym(1+2*8, do); StatSeq(s);
y := DevCPB.NewLeaf(id); DevCPB.StPar1(y, z, incfn); pos := DevCPM.startpos; SetPos(y);
IF s = NIL THEN s := y
ELSE z := s;
WHILE z.link # NIL DO z := z.link END ;
z.link := y
END ;
CheckIndentSym(3+1*8, end); DevCPB.Construct(Nwhile, x, s); pos := p
ELSE err(ident)
END
ELSIF sym = loop THEN
DevCPS.Indent(1+2*8);
DevCPS.Get(sym); INC(LoopLevel); StatSeq(x); DEC(LoopLevel);
DevCPB.Construct(Nloop, x, NIL); CheckIndentSym(3+1*8, end)
ELSIF sym = with THEN
DevCPS.Indent(1);
DevCPS.Get(sym); idtyp := NIL; x := NIL;
LOOP
IF sym < bar THEN
pos := DevCPM.startpos;
IF sym = ident THEN
qualident(id); y := DevCPB.NewLeaf(id);
IF (id # NIL) & (id.typ.form = Pointer) & ((id.mode = VarPar) OR ~id.leaf) THEN
err(-302) (* warning 302 *)
END ;
CheckSym(colon);
IF sym = ident THEN qualident(t);
IF t.mode = Typ THEN
IF id # NIL THEN
idtyp := id.typ; DevCPB.TypTest(y, t, FALSE); id.typ := t.typ;
IF id.ptyp = NIL THEN id.ptyp := idtyp END
ELSE err(130)
END
ELSE err(52)
END
ELSE err(ident)
END
ELSE err(ident)
END ;
CheckIndentSym(1+2*8, do); StatSeq(s); DevCPB.Construct(Nif, y, s); SetPos(y);
IF idtyp # NIL THEN
IF id.ptyp = idtyp THEN id.ptyp := NIL END;
id.typ := idtyp; idtyp := NIL
END ;
IF x = NIL THEN x := y; lastif := x ELSE DevCPB.Link(x, lastif, y) END
END;
IF sym = bar THEN DevCPS.Indent(3+1*8); DevCPS.Get(sym) ELSE EXIT END
END;
e := sym = else; pos := DevCPM.startpos;
IF e THEN DevCPS.Indent(3+1*8+2*64); DevCPS.Get(sym); StatSeq(s) ELSE s := NIL END ;
DevCPB.Construct(Nwith, x, s); CheckIndentSym(3+1*8, end);
IF e THEN x.subcl := 1 END
ELSIF sym = exit THEN
DevCPS.Get(sym);
IF LoopLevel = 0 THEN err(46) END ;
DevCPB.Construct(Nexit, x, NIL)
ELSIF sym = return THEN DevCPS.Get(sym);
IF sym < semicolon THEN Expression(x) END ;
IF level > 0 THEN DevCPB.Return(x, DevCPT.topScope.link)
ELSE (* not standard Oberon *) DevCPB.Return(x, NIL)
END;
hasReturn := TRUE
END ;
IF x # NIL THEN SetPos(x); DevCPB.Link(stat, last, x) END ;
IF sym = semicolon THEN DevCPS.Get(sym)
ELSIF (sym <= ident) OR (if <= sym) & (sym <= return) THEN err(semicolon)
ELSE EXIT
END
END
END StatSeq;
PROCEDURE Block(VAR procdec, statseq: DevCPT.Node);
VAR typ: DevCPT.Struct;
obj, first, last, o: DevCPT.Object;
x, lastdec: DevCPT.Node;
i: SHORTINT;
rname: DevCPT.Name;
name: DevCPT.String;
rec: Elem;
BEGIN
IF ((sym < begin) OR (sym > var)) & (sym # procedure) & (sym # end) & (sym # close) THEN err(36) END;
first := NIL; last := NIL; userList := NIL; recList := NIL;
LOOP
IF sym = const THEN
DevCPS.Indent(1+5*8);
DevCPS.Get(sym);
WHILE sym = ident DO
DevCPS.Indent(2+4*8);
DevCPT.Insert(DevCPS.name, obj);
obj.mode := Con; CheckMark(obj);
obj.typ := DevCPT.int8typ; obj.mode := Var; (* Var to avoid recursive definition *)
IF sym = eql THEN
DevCPS.Get(sym); ConstExpression(x)
ELSIF sym = becomes THEN
err(eql); DevCPS.Get(sym); ConstExpression(x)
ELSE err(eql); x := DevCPB.NewIntConst(1)
END ;
obj.mode := Con; obj.typ := x.typ; obj.conval := x.conval; (* ConstDesc ist not copied *)
CheckIndentSym(3, semicolon)
END
END ;
IF sym = type THEN
DevCPS.Indent(1+5*8);
DevCPS.Get(sym);
WHILE sym = ident DO
DevCPS.Indent(2+4*8);
DevCPT.Insert(DevCPS.name, obj); obj.mode := Typ; obj.typ := DevCPT.undftyp;
CheckMark(obj); obj.mode := -1;
IF sym # eql THEN err(eql) END;
IF (sym = eql) OR (sym = becomes) OR (sym = colon) THEN
DevCPS.Get(sym); Type(obj.typ, name); SetType(NIL, obj, obj.typ, name);
END;
obj.mode := Typ;
IF obj.typ.form IN {Byte..Set, Char16, Int64} THEN (* make alias structure *)
typ := DevCPT.NewStr(obj.typ.form, Basic); i := typ.ref;
typ^ := obj.typ^; typ.ref := i; typ.strobj := NIL; typ.mno := 0; typ.txtpos := DevCPM.errpos;
typ.BaseTyp := obj.typ; obj.typ := typ;
END;
IF obj.typ.strobj = NIL THEN obj.typ.strobj := obj END ;
IF obj.typ.form = Pointer THEN (* !!! *)
typ := obj.typ.BaseTyp;
IF (typ # NIL) & (typ.comp = Record) & (typ.strobj = NIL) THEN
(* pointer to unnamed record: name record as "pointerName^" *)
rname := obj.name^$; i := 0;
WHILE rname[i] # 0X DO INC(i) END;
rname[i] := "^"; rname[i+1] := 0X;
DevCPT.Insert(rname, o); o.mode := Typ; o.typ := typ; typ.strobj := o
END
END;
IF obj.vis # internal THEN
typ := obj.typ;
IF typ.form = Pointer THEN typ := typ.BaseTyp END;
IF typ.comp = Record THEN typ.exp := TRUE END
END;
CheckIndentSym(3, semicolon)
END
END ;
IF sym = var THEN
DevCPS.Indent(1+5*8);
DevCPS.Get(sym);
WHILE sym = ident DO
DevCPS.Indent(2+4*8);
LOOP
IF sym = ident THEN
DevCPT.Insert(DevCPS.name, obj);
obj.mode := Var; obj.link := NIL; obj.leaf := obj.vis = internal; obj.typ := DevCPT.undftyp;
CheckMark(obj);
IF first = NIL THEN first := obj END ;
IF last = NIL THEN DevCPT.topScope.scope := obj ELSE last.link := obj END ;
last := obj
ELSE err(ident)
END ;
IF sym = comma THEN DevCPS.Get(sym)
ELSIF sym = ident THEN err(comma)
ELSE EXIT
END
END ;
CheckSym(colon); Type(typ, name);
CheckAlloc(typ, FALSE, DevCPM.errpos);
WHILE first # NIL DO SetType(NIL, first, typ, name); first := first.link END ;
CheckIndentSym(3, semicolon)
END
END ;
IF (sym < const) OR (sym > var) THEN EXIT END ;
END ;
CheckForwardTypes;
userList := NIL; rec := recList; recList := NIL;
DevCPT.topScope.adr := DevCPM.errpos;
procdec := NIL; lastdec := NIL;
IF (sym # procedure) & (sym # begin) & (sym # end) & (sym # close) THEN err(37) END;
WHILE sym = procedure DO
DevCPS.Indent(1);
DevCPS.Get(sym); ProcedureDeclaration(x);
IF x # NIL THEN
IF lastdec = NIL THEN procdec := x ELSE lastdec.link := x END ;
lastdec := x
END ;
CheckSym(semicolon)
END ;
IF DevCPM.noerr & ~(DevCPM.oberon IN DevCPM.options) THEN CheckRecords(rec) END;
hasReturn := FALSE;
IF (sym # begin) & (sym # end) & (sym # close) THEN err(38) END;
IF sym = begin THEN DevCPS.Indent(3+1*8+2*64); DevCPS.Get(sym); StatSeq(statseq)
ELSE statseq := NIL
END ;
IF (DevCPT.topScope.link # NIL) & (DevCPT.topScope.link.typ # DevCPT.notyp)
& ~hasReturn & (DevCPT.topScope.link.sysflag = 0) THEN err(133) END;
IF (level = 0) & (TDinit # NIL) THEN
lastTDinit.link := statseq; statseq := TDinit
END
END Block;
PROCEDURE Module*(VAR prog: DevCPT.Node);
VAR impName, aliasName: DevCPT.Name;
procdec, statseq: DevCPT.Node;
c, sf: INTEGER; done: BOOLEAN;
BEGIN
DevCPS.Init; LoopLevel := 0; level := 0; DevCPS.Get(sym);
IF sym = module THEN DevCPS.Indent(1); DevCPS.Get(sym) ELSE err(16) END ;
IF sym = ident THEN
DevCPT.Open(DevCPS.name); DevCPS.Get(sym);
DevCPT.libName := "";
IF sym = lbrak THEN
INCL(DevCPM.options, DevCPM.interface); DevCPS.Get(sym);
IF sym = eql THEN DevCPS.Get(sym)
ELSE INCL(DevCPM.options, DevCPM.noCode)
END;
IF sym = string THEN DevCPT.libName := DevCPS.str^$; DevCPS.Get(sym)
ELSE err(string)
END;
CheckSym(rbrak)
END;
CheckIndentSym(2, semicolon);
IF sym = import THEN DevCPS.Indent(1+2*8+5*64); DevCPS.Get(sym);
LOOP
IF sym = ident THEN
DevCPS.Indent(4);
aliasName := DevCPS.name$; impName := aliasName$; DevCPS.Get(sym);
IF sym = becomes THEN DevCPS.Get(sym);
IF sym = ident THEN impName := DevCPS.name$; DevCPS.Get(sym) ELSE err(ident) END
END ;
DevCPT.Import(aliasName, impName, done)
ELSE err(ident)
END ;
IF sym = comma THEN DevCPS.Get(sym)
ELSIF sym = ident THEN err(comma)
ELSE EXIT
END
END ;
CheckIndentSym(3, semicolon)
END ;
IF DevCPM.noerr THEN TDinit := NIL; lastTDinit := NIL; c := DevCPM.errpos;
Block(procdec, statseq); DevCPB.Enter(procdec, statseq, NIL); prog := procdec;
prog.conval := DevCPT.NewConst(); prog.conval.intval := c; prog.conval.intval2 := DevCPM.startpos;
IF sym = close THEN DevCPS.Indent(3+1*8+2*64); DevCPS.Get(sym); StatSeq(prog.link) END;
prog.conval.realval := DevCPM.startpos;
CheckIndentSym(3+1*8, end);
IF sym = ident THEN
IF DevCPS.name # DevCPT.SelfName THEN err(4) END ;
DevCPS.Get(sym)
ELSE err(ident)
END;
IF sym # period THEN err(period) END
END
ELSE err(ident)
END ;
TDinit := NIL; lastTDinit := NIL;
DevCPS.str := NIL
END Module;
END DevCPP.
| Dev/Mod/CPP.odc |
MODULE DevCPS; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20100407, Fyodor Tkachov, minor fine-tuning
- 20100402, E.E.Temirgaleev, automatic indent checks
- 20080215, Fyodor Tkachov, reviewed
- 20050626, Fyodor Tkachov, russification edited
- 20050430, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT SYSTEM, Math, DevCPM, DevCPT, i21sysCharacters;
CONST
MaxIdLen = 256;
TYPE
(*
Name* = ARRAY MaxIdLen OF SHORTCHAR;
String* = POINTER TO ARRAY OF SHORTCHAR;
*)
(* name, str, numtyp, intval, realval, realval are implicit results of Get *)
VAR
name*: DevCPT.Name;
str*: DevCPT.String;
numtyp*: SHORTINT; (* 1 = char, 2 = integer, 4 = real, 5 = int64, 6 = real32, 7 = real64 *)
intval*: INTEGER; (* integer value or string length (incl. 0X) *)
realval*: REAL;
checkIndent*: BOOLEAN;
indentLevel: INTEGER;
newLine: BOOLEAN; (* . *)
tabs: INTEGER; (* *)
CONST
(* numtyp values *)
char = 1; integer = 2; real = 4; int64 = 5; real32 = 6; real64 = 7;
(*symbol values*)
null = 0; times = 1; slash = 2; div = 3; mod = 4;
and = 5; plus = 6; minus = 7; or = 8; eql = 9;
neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14;
in = 15; is = 16; arrow = 17; dollar = 18; period = 19;
comma = 20; colon = 21; upto = 22; rparen = 23; rbrak = 24;
rbrace = 25; of = 26; then = 27; do = 28; to = 29;
by = 30; not = 33;
lparen = 40; lbrak = 41; lbrace = 42; becomes = 44;
number = 45; nil = 46; string = 47; ident = 48; semicolon = 49;
bar = 50; end = 51; else = 52; elsif = 53; until = 54;
if = 55; case = 56; while = 57; repeat = 58; for = 59;
loop = 60; with = 61; exit = 62; return = 63; array = 64;
record = 65; pointer = 66; begin = 67; const = 68; type = 69;
var = 70; out = 71; procedure = 72; close = 73; import = 74;
module = 75; eof = 76;
VAR
ch: SHORTCHAR; (*current character*)
PROCEDURE err(n: SHORTINT);
BEGIN DevCPM.err(n)
END err;
PROCEDURE Str(VAR sym: BYTE);
VAR i: SHORTINT; och: SHORTCHAR; s: DevCPT.Name; t: DevCPT.String;
BEGIN i := 0; och := ch;
LOOP DevCPM.Get(ch);
IF ch = och THEN EXIT END ;
IF (ch < " ") & (ch # 9X) THEN err(3); EXIT END ;
IF i < LEN(s) - 1 THEN s[i] := ch
ELSIF i = LEN(s) - 1 THEN s[i] := 0X; NEW(str, 2 * LEN(s)); str^ := s$; str[i] := ch
ELSIF i < LEN(str^) - 1 THEN str[i] := ch
ELSE t := str; t[i] := 0X; NEW(str, 2 * LEN(t^)); str^ := t^$; str[i] := ch
END;
INC(i)
END ;
IF i = 1 THEN sym := number; numtyp := 1; intval := ORD(s[0])
ELSE
sym := string; numtyp := 0; intval := i + 1;
IF i < LEN(s) THEN s[i] := 0X; NEW(str, intval); str^ := s$
ELSE str[i] := 0X
END
END;
DevCPM.Get(ch)
END Str;
PROCEDURE Identifier(VAR sym: BYTE);
VAR i: SHORTINT;
BEGIN i := 0;
REPEAT
name[i] := ch; INC(i); DevCPM.Get(ch)
UNTIL ~i21sysCharacters.IsIdentChar(ch) OR (i = MaxIdLen);
IF i = MaxIdLen THEN err(240); DEC(i) END ;
name[i] := 0X; sym := ident
END Identifier;
PROCEDURE Number;
VAR i, j, m, n, d, e, a: INTEGER; f, g, x: REAL; expCh, tch: SHORTCHAR; neg: BOOLEAN; r: SHORTREAL;
dig: ARRAY 30 OF SHORTCHAR; arr: ARRAY 2 OF INTEGER;
PROCEDURE Ord(ch: SHORTCHAR; hex: BOOLEAN): SHORTINT;
BEGIN (* ("0" <= ch) & (ch <= "9") OR ("A" <= ch) & (ch <= "F") *)
IF ch <= "9" THEN RETURN SHORT(ORD(ch) - ORD("0"))
ELSIF hex THEN RETURN SHORT(ORD(ch) - ORD("A") + 10)
ELSE err(2); RETURN 0
END
END Ord;
BEGIN (* ("0" <= ch) & (ch <= "9") *)
i := 0; m := 0; n := 0; d := 0;
LOOP (* read mantissa *)
IF ("0" <= ch) & (ch <= "9") OR (d = 0) & ("A" <= ch) & (ch <= "F") THEN
IF (m > 0) OR (ch # "0") THEN (* ignore leading zeros *)
IF n < LEN(dig) THEN dig[n] := ch; INC(n) END;
INC(m)
END;
DevCPM.Get(ch); INC(i)
ELSIF ch = "." THEN DevCPM.Get(ch);
IF ch = "." THEN (* ellipsis *) ch := 7FX; EXIT
ELSIF d = 0 THEN (* i > 0 *) d := i
ELSE err(2)
END
ELSE EXIT
END
END; (* 0 <= n <= m <= i, 0 <= d <= i *)
IF d = 0 THEN (* integer *) realval := 0; numtyp := integer;
IF n = m THEN intval := 0; i := 0;
IF ch = "X" THEN (* character *) DevCPM.Get(ch); numtyp := char;
IF n <= 4 THEN
WHILE i < n DO intval := intval*10H + Ord(dig[i], TRUE); INC(i) END
ELSE err(203)
END
ELSIF (ch = "H") OR (ch = "S") THEN (* hex 32bit *)
tch := ch; DevCPM.Get(ch);
IF (ch = "L") & (DevCPM.oberon IN DevCPM.options) THEN (* old syntax: hex 64bit *)
DevCPM.searchpos := DevCPM.curpos - 2; DevCPM.Get(ch);
IF n <= 16 THEN
IF (n = 16) & (dig[0] > "7") THEN realval := -1 END;
WHILE (i < n) & (i < 10) DO realval := realval * 10H + Ord(dig[i], TRUE); INC(i) END;
WHILE i < n DO realval := realval * 10H; intval := intval * 10H + Ord(dig[i], TRUE); INC(i) END;
numtyp := int64
ELSE err(203)
END
ELSIF n <= 8 THEN
IF (n = 8) & (dig[0] > "7") THEN (* prevent overflow *) intval := -1 END;
WHILE i < n DO intval := intval*10H + Ord(dig[i], TRUE); INC(i) END;
IF tch = "S" THEN (* 32 bit hex float *)
r := SYSTEM.VAL(SHORTREAL, intval);
realval := r; intval := 0; numtyp := real32
END
ELSE err(203)
END
ELSIF ch = "L" THEN (* hex 64bit *)
DevCPM.searchpos := DevCPM.curpos - 1; DevCPM.Get(ch);
IF n <= 16 THEN
IF (n = 16) & (dig[0] > "7") THEN realval := -1 END;
WHILE (i < n) & (i < 10) DO realval := realval * 10H + Ord(dig[i], TRUE); INC(i) END;
WHILE i < n DO realval := realval * 10H; intval := intval * 10H + Ord(dig[i], TRUE); INC(i) END;
numtyp := int64
ELSE err(203)
END
ELSIF ch = "R" THEN (* hex float 64bit *)
DevCPM.searchpos := DevCPM.curpos - 1; DevCPM.Get(ch);
IF n <= 16 THEN
a := 0; IF (n = 16) & (dig[0] > "7") THEN (* prevent overflow *) a := -1 END;
WHILE i < n-8 DO a := a*10H + Ord(dig[i], TRUE); INC(i) END;
IF DevCPM.LEHost THEN arr[1] := a ELSE arr[0] := a END;
a := 0; IF (n >= 8) & (dig[i] > "7") THEN (* prevent overflow *) a := -1 END;
WHILE i < n DO a := a*10H + Ord(dig[i], TRUE); INC(i) END;
IF DevCPM.LEHost THEN arr[0] := a ELSE arr[1] := a END;
realval := SYSTEM.VAL(REAL, arr);
intval := 0; numtyp := real64
ELSE err(203)
END
ELSE (* decimal *)
WHILE i < n DO d := Ord(dig[i], FALSE); INC(i);
a := (MAX(INTEGER) - d) DIV 10;
IF intval > a THEN
a := (intval - a + 65535) DIV 65536 * 65536;
realval := realval + a; intval := intval - a
END;
realval := realval * 10; intval := intval * 10 + d
END;
IF realval = 0 THEN numtyp := integer
ELSIF intval < 9223372036854775808.0E0 - realval THEN numtyp := int64 (* 2^63 *)
ELSE intval := 0; err(203)
END
END
ELSE err(203)
END
ELSE (* fraction *)
f := 0; g := 0; e := 0; j := 0; expCh := "E";
WHILE (j < 15) & (j < n) DO g := g * 10 + Ord(dig[j], FALSE); INC(j) END; (* !!! *)
WHILE n > j DO (* 0 <= f < 1 *) DEC(n); f := (Ord(dig[n], FALSE) + f)/10 END;
IF (ch = "E") OR (ch = "D") & (DevCPM.oberon IN DevCPM.options) THEN
expCh := ch; DevCPM.searchpos := DevCPM.curpos - 1; DevCPM.Get(ch); neg := FALSE;
IF ch = "-" THEN neg := TRUE; DevCPM.Get(ch)
ELSIF ch = "+" THEN DevCPM.Get(ch)
END;
IF ("0" <= ch) & (ch <= "9") THEN
REPEAT n := Ord(ch, FALSE); DevCPM.Get(ch);
IF e <= (MAX(SHORTINT) - n) DIV 10 THEN e := SHORT(e*10 + n)
ELSE err(203)
END
UNTIL (ch < "0") OR ("9" < ch);
IF neg THEN e := -e END
ELSE err(2)
END
END;
DEC(e, i-d-m); (* decimal point shift *)
IF e < -308 - 16 THEN
realval := 0.0
ELSIF e < -308 + 14 THEN
realval := (f + g) / Math.IntPower(10, j-e-30) / 1.0E15 / 1.0E15
ELSIF e < j THEN
realval := (f + g) / Math.IntPower(10, j-e) (* Ten(j-e) *)
ELSIF e <= 308 THEN
realval := (f + g) * Math.IntPower(10, e-j) (* Ten(e-j) *)
ELSIF e = 308 + 1 THEN
realval := (f + g) * (Math.IntPower(10, e-j) / 16);
IF realval <= DevCPM.MaxReal64 / 16 THEN realval := realval * 16
ELSE err(203)
END
ELSE err(203)
END;
numtyp := real
END
END Number;
PROCEDURE IndentErr (n: INTEGER);
VAR p: INTEGER;
BEGIN
p := DevCPM.errpos;
DevCPM.errpos := DevCPM.curpos - 1;
err(SHORT(1000 + n));
DevCPM.errpos := p
END IndentErr;
PROCEDURE Indent* (ops: INTEGER);
VAR i: INTEGER;
BEGIN
IF checkIndent THEN
i := 0;
WHILE i < 3 DO
CASE ops MOD 8 OF
| 0: (* *)
| 1: (* *)
IF indentLevel # tabs THEN
IndentErr(1) (* *)
END
| 2: (* *)
INC(indentLevel)
| 3: (* *)
DEC(indentLevel)
| 4: (* *)
IF newLine & (indentLevel # tabs) OR ~newLine & (indentLevel - 1 # tabs) THEN
IndentErr(1) (* *)
END
| 5: (* . *)
newLine := FALSE
END;
ops := ops DIV 8; INC(i)
END;
ASSERT(ops = 0, 100)
END
END Indent;
PROCEDURE Get*(VAR sym: BYTE);
VAR s: BYTE; old: INTEGER; t: INTEGER;
PROCEDURE Comment; (* do not read after end of file *)
BEGIN DevCPM.Get(ch);
LOOP
LOOP
WHILE ch = "(" DO DevCPM.Get(ch);
IF ch = "*" THEN Comment END
END ;
IF ch = "*" THEN DevCPM.Get(ch); EXIT END ;
IF ch = DevCPM.Eot THEN EXIT END ;
DevCPM.Get(ch)
END ;
IF ch = ")" THEN DevCPM.Get(ch); EXIT END ;
IF ch = DevCPM.Eot THEN err(5); EXIT END
END
END Comment;
BEGIN
DevCPM.errpos := DevCPM.curpos-1;
WHILE (ch <= " ") OR (ch = 0A0X) DO (*ignore control characters*)
IF checkIndent & ((ch = 0DX) OR (ch = 0EX)) THEN
newLine := TRUE;
tabs := 0; DevCPM.Get(ch);
WHILE ch = 9X DO
INC(tabs); DevCPM.Get(ch)
END;
t := 0;
WHILE (ch # DevCPM.Eot) & ~((ch = 0DX) OR (ch = 0EX)) & ((ch <= " ") OR (ch = 0A0X)) DO
INC(t); DevCPM.Get(ch)
END;
IF ch = DevCPM.Eot THEN
sym := eof; RETURN
ELSIF (ch = 0DX) OR (ch = 0EX) THEN (* *)
newLine := TRUE
ELSIF (* & *) t # 0 THEN
IndentErr(0) (* т *)
END
ELSE
IF ch = DevCPM.Eot THEN sym := eof; RETURN
ELSE DevCPM.Get(ch)
END
END
END ;
DevCPM.startpos := DevCPM.curpos - 1;
CASE ch OF (* ch > " " *)
| 22X, 27X : Str(s)
| "#" : s := neq; DevCPM.Get(ch)
| "&" : s := and; DevCPM.Get(ch)
| "(" : DevCPM.Get(ch);
IF ch = "*" THEN Comment; old := DevCPM.errpos; Get(s); DevCPM.errpos := old;
ELSE s := lparen
END
| ")" : s := rparen; DevCPM.Get(ch)
| "*" : s := times; DevCPM.Get(ch)
| "+" : s := plus; DevCPM.Get(ch)
| "," : s := comma; DevCPM.Get(ch)
| "-" : s := minus; DevCPM.Get(ch)
| "." : DevCPM.Get(ch);
IF ch = "." THEN DevCPM.Get(ch); s := upto ELSE s := period END
| "/" : s := slash; DevCPM.Get(ch)
| "0".."9": Number; s := number
| ":" : DevCPM.Get(ch);
IF ch = "=" THEN DevCPM.Get(ch); s := becomes ELSE s := colon END
| ";" : s := semicolon; DevCPM.Get(ch)
| "<" : DevCPM.Get(ch);
IF ch = "=" THEN DevCPM.Get(ch); s := leq ELSE s := lss END
| "=" : s := eql; DevCPM.Get(ch)
| ">" : DevCPM.Get(ch);
IF ch = "=" THEN DevCPM.Get(ch); s := geq ELSE s := gtr END
| "A": Identifier(s); IF name = "ARRAY" THEN s := array END
| "B": Identifier(s);
IF name = "BEGIN" THEN s := begin
ELSIF name = "BY" THEN s := by
END
| "C": Identifier(s);
IF name = "CASE" THEN s := case
ELSIF name = "CONST" THEN s := const
ELSIF name = "CLOSE" THEN s := close
END
| "D": Identifier(s);
IF name = "DO" THEN s := do
ELSIF name = "DIV" THEN s := div
END
| "E": Identifier(s);
IF name = "END" THEN s := end
ELSIF name = "ELSE" THEN s := else
ELSIF name = "ELSIF" THEN s := elsif
ELSIF name = "EXIT" THEN s := exit
END
| "F": Identifier(s); IF name = "FOR" THEN s := for END
| "I": Identifier(s);
IF name = "IF" THEN s := if
ELSIF name = "IN" THEN s := in
ELSIF name = "IS" THEN s := is
ELSIF name = "IMPORT" THEN s := import
END
| "L": Identifier(s); IF name = "LOOP" THEN s := loop END
| "M": Identifier(s);
IF name = "MOD" THEN s := mod
ELSIF name = "MODULE" THEN s := module
END
| "N": Identifier(s); IF name = "NIL" THEN s := nil END
| "O": Identifier(s);
IF name = "OR" THEN s := or
ELSIF name = "OF" THEN s := of
ELSIF name = "OUT" THEN s := out
END
| "P": Identifier(s);
IF name = "PROCEDURE" THEN s := procedure
ELSIF name = "POINTER" THEN s := pointer
END
| "R": Identifier(s);
IF name = "RECORD" THEN s := record
ELSIF name = "REPEAT" THEN s := repeat
ELSIF name = "RETURN" THEN s := return
END
| "T": Identifier(s);
IF name = "THEN" THEN s := then
ELSIF name = "TO" THEN s := to
ELSIF name = "TYPE" THEN s := type
END
| "U": Identifier(s); IF name = "UNTIL" THEN s := until END
| "V": Identifier(s); IF name = "VAR" THEN s := var END
| "W": Identifier(s);
IF name = "WHILE" THEN s := while
ELSIF name = "WITH" THEN s := with
END
(*
| "G".."H", "J", "K", "Q", "S", "X".."Z", "a".."z", "_", "А".."я", "ё", "Ё": Identifier(s) (*-> ELSE IF*)
*)
| "[" : s := lbrak; DevCPM.Get(ch)
| "]" : s := rbrak; DevCPM.Get(ch)
| "^" : s := arrow; DevCPM.Get(ch)
| "$" : s := dollar; DevCPM.Get(ch)
| "{" : s := lbrace; DevCPM.Get(ch);
| "|" : s := bar; DevCPM.Get(ch)
| "}" : s := rbrace; DevCPM.Get(ch)
| "~" : s := not; DevCPM.Get(ch)
| 7FX : s := upto; DevCPM.Get(ch)
ELSE
IF i21sysCharacters.IsFirstIdentChar(ch) THEN
Identifier(s)
ELSE
s := null; DevCPM.Get(ch)
END;
END ;
sym := s
END Get;
PROCEDURE Init*;
BEGIN (* ch := " " *)ch := 0DX;
indentLevel := 0
END Init;
(* (* как трудно сделать просто :) *)
PROCEDURE SetIndentCheck* (check: INTEGER);
BEGIN
ASSERT(check IN {0,1}, 20);
checkIndent := check = 1
END SetIndentCheck;
*)
PROCEDURE IndentChecksOn*;
BEGIN
checkIndent := TRUE
END IndentChecksOn;
PROCEDURE IndentChecksOff*;
BEGIN
checkIndent := FALSE
END IndentChecksOff;
END DevCPS. | Dev/Mod/CPS.odc |
MODULE DevCPT;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT DevCPM;
CONST
MaxIdLen = 256;
TYPE
Name* = ARRAY MaxIdLen OF SHORTCHAR;
String* = POINTER TO ARRAY OF SHORTCHAR;
Const* = POINTER TO ConstDesc;
Object* = POINTER TO ObjDesc;
Struct* = POINTER TO StrDesc;
Node* = POINTER TO NodeDesc;
ConstExt* = String;
LinkList* = POINTER TO LinkDesc;
ConstDesc* = RECORD
ext*: ConstExt; (* string or code for code proc (longstring in utf8) *)
intval*: INTEGER; (* constant value or adr, proc par size, text position or least case label *)
intval2*: INTEGER; (* string length (#char, incl 0X), proc var size or larger case label *)
setval*: SET; (* constant value, procedure body present or "ELSE" present in case *)
realval*: REAL; (* real or longreal constant value *)
link*: Const (* chain of constants present in obj file *)
END ;
LinkDesc* = RECORD
offset*, linkadr*: INTEGER;
next*: LinkList;
END;
ObjDesc* = RECORD
left*, right*, link*, scope*: Object;
name*: String; (* name = null OR name^ # "" *)
leaf*: BOOLEAN;
sysflag*: BYTE;
mode*, mnolev*: BYTE; (* mnolev < 0 -> mno = -mnolev *)
vis*: BYTE; (* internal, external, externalR, inPar, outPar *)
history*: BYTE; (* relevant if name # "" *)
used*, fpdone*: BOOLEAN;
fprint*: INTEGER;
typ*: Struct; (* actual type, changed in with statements *)
ptyp*: Struct; (* original type if typ is changed *)
conval*: Const;
adr*, num*: INTEGER; (* mthno *)
links*: LinkList;
nlink*: Object; (* link for name list, declaration order for methods, library link for imp obj *)
library*, entry*: String; (* library name, entry name *)
modifiers*: POINTER TO ARRAY OF String; (* additional interface strings *)
linkadr*: INTEGER; (* used in ofront *)
red: BOOLEAN;
END ;
StrDesc* = RECORD
form*, comp*, mno*, extlev*: BYTE;
ref*, sysflag*: SHORTINT;
n*, size*, align*, txtpos*: INTEGER; (* align is alignment for records and len offset for dynarrs *)
untagged*, allocated*, pbused*, pvused*, exp*, fpdone, idfpdone: BOOLEAN;
attribute*: BYTE;
idfp, pbfp*, pvfp*:INTEGER;
BaseTyp*: Struct;
link*, strobj*: Object;
ext*: ConstExt (* id string for interface records *)
END ;
NodeDesc* = RECORD
left*, right*, link*: Node;
class*, subcl*, hint*: BYTE;
readonly*: BOOLEAN;
typ*: Struct;
obj*: Object;
conval*: Const
END ;
CONST
maxImps = 127; (* must be <= MAX(SHORTINT) *)
maxStruct = DevCPM.MaxStruct; (* must be < MAX(INTEGER) DIV 2 *)
FirstRef = 32;
FirstRef0 = 16; (* correction for version 0 *)
actVersion = 1;
VAR
topScope*: Object;
undftyp*, bytetyp*, booltyp*, char8typ*, int8typ*, int16typ*, int32typ*,
real32typ*, real64typ*, settyp*, string8typ*, niltyp*, notyp*, sysptrtyp*,
anytyp*, anyptrtyp*, char16typ*, string16typ*, int64typ*,
restyp*, iunktyp*, punktyp*, guidtyp*,
intrealtyp*, lreal64typ*, lint64typ*, lchar16typ*: Struct;
nofGmod*: BYTE; (*nof imports*)
GlbMod*: ARRAY maxImps OF Object; (* .right = first object, .name = module import name (not alias) *)
SelfName*: Name; (* name of module being compiled *)
SYSimported*: BOOLEAN;
processor*, impProc*: SHORTINT;
libName*: Name; (* library alias of module being compiled *)
null*: String; (* "" *)
CONST
(* object modes *)
Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7;
SProc = 8; CProc = 9; IProc = 10; Mod = 11; Head = 12; TProc = 13; Attr = 20;
(* structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Real32 = 7; Real64 = 8; Set = 9; String8 = 10; NilTyp = 11; NoTyp = 12;
Pointer = 13; ProcTyp = 14; Comp = 15;
AnyPtr = 14; AnyRec = 15; (* sym file only *)
Char16 = 16; String16 = 17; Int64 = 18;
Res = 20; IUnk = 21; PUnk = 22; Guid = 23;
(* composite structure forms *)
Basic = 1; Array = 2; DynArr = 3; Record = 4;
(*function number*)
assign = 0;
haltfn = 0; newfn = 1; absfn = 2; capfn = 3; ordfn = 4;
entierfn = 5; oddfn = 6; minfn = 7; maxfn = 8; chrfn = 9;
shortfn = 10; longfn = 11; sizefn = 12; incfn = 13; decfn = 14;
inclfn = 15; exclfn = 16; lenfn = 17; copyfn = 18; ashfn = 19; assertfn = 32;
lchrfn = 33; lentierfcn = 34; typfn = 36; bitsfn = 37; bytesfn = 38;
(*SYSTEM function number*)
adrfn = 20; ccfn = 21; lshfn = 22; rotfn = 23;
getfn = 24; putfn = 25; getrfn = 26; putrfn = 27;
bitfn = 28; valfn = 29; sysnewfn = 30; movefn = 31;
thisrecfn = 45; thisarrfn = 46;
(* COM function number *)
validfn = 40; iidfn = 41; queryfn = 42;
(* attribute flags (attr.adr, struct.attribute, proc.conval.setval) *)
newAttr = 16; absAttr = 17; limAttr = 18; empAttr = 19; extAttr = 20;
(* procedure flags (conval.setval) *)
isHidden = 29;
(* module visibility of objects *)
internal = 0; external = 1; externalR = 2; inPar = 3; outPar = 4;
(* history of imported objects *)
inserted = 0; same = 1; pbmodified = 2; pvmodified = 3; removed = 4; inconsistent = 5;
(* sysflags *)
inBit = 2; outBit = 4; interface = 10;
(* symbol file items *)
Smname = 16; Send = 18; Stype = 19; Salias = 20; Svar = 21; Srvar = 22;
Svalpar = 23; Svarpar = 24; Sfld = 25; Srfld = 26; Shdptr = 27; Shdpro = 28; Stpro = 29; Shdtpro = 30;
Sxpro = 31; Sipro = 32; Scpro = 33; Sstruct = 34; Ssys = 35; Sptr = 36; Sarr = 37; Sdarr = 38; Srec = 39; Spro = 40;
Shdutptr = 41; Slib = 42; Sentry = 43; Sinpar = 25; Soutpar = 26;
Slimrec = 25; Sabsrec = 26; Sextrec = 27; Slimpro = 31; Sabspro = 32; Semppro = 33; Sextpro = 34; Simpo = 22;
TYPE
ImpCtxt = RECORD
nextTag, reffp: INTEGER;
nofr, minr, nofm: SHORTINT;
self: BOOLEAN;
ref: ARRAY maxStruct OF Struct;
old: ARRAY maxStruct OF Object;
pvfp: ARRAY maxStruct OF INTEGER; (* set only if old # NIL *)
glbmno: ARRAY maxImps OF BYTE (* index is local mno *)
END ;
ExpCtxt = RECORD
reffp: INTEGER;
ref: SHORTINT;
nofm: BYTE;
locmno: ARRAY maxImps OF BYTE (* index is global mno *)
END ;
VAR
universe, syslink, comlink, infinity: Object;
impCtxt: ImpCtxt;
expCtxt: ExpCtxt;
nofhdfld: INTEGER;
sfpresent, symExtended, symNew: BOOLEAN;
version: INTEGER;
symChanges: INTEGER;
portable: BOOLEAN;
depth: INTEGER;
PROCEDURE err(n: SHORTINT);
BEGIN DevCPM.err(n)
END err;
PROCEDURE NewConst*(): Const;
VAR const: Const;
BEGIN NEW(const); RETURN const
END NewConst;
PROCEDURE NewObj*(): Object;
VAR obj: Object;
BEGIN NEW(obj); obj.name := null; RETURN obj
END NewObj;
PROCEDURE NewStr*(form, comp: BYTE): Struct;
VAR typ: Struct;
BEGIN NEW(typ); typ.form := form; typ.comp := comp; typ.ref := maxStruct; (* ref >= maxStruct: not exported yet *)
typ.txtpos := DevCPM.errpos; typ.size := -1; typ.BaseTyp := undftyp; RETURN typ
END NewStr;
PROCEDURE NewNode*(class: BYTE): Node;
VAR node: Node;
BEGIN
NEW(node); node.class := class; RETURN node
END NewNode;
(*
PROCEDURE NewExt*(): ConstExt;
VAR ext: ConstExt;
BEGIN NEW(ext); RETURN ext
END NewExt;
*)
PROCEDURE NewName* ((*IN*) name: ARRAY OF SHORTCHAR): String;
VAR i: INTEGER; p: String;
BEGIN
i := 0; WHILE name[i] # 0X DO INC(i) END;
IF i > 0 THEN NEW(p, i + 1); p^ := name$; RETURN p
ELSE RETURN null
END
END NewName;
PROCEDURE OpenScope*(level: BYTE; owner: Object);
VAR head: Object;
BEGIN head := NewObj();
head.mode := Head; head.mnolev := level; head.link := owner;
IF owner # NIL THEN owner.scope := head END ;
head.left := topScope; head.right := NIL; head.scope := NIL; topScope := head
END OpenScope;
PROCEDURE CloseScope*;
BEGIN topScope := topScope.left
END CloseScope;
PROCEDURE Init*(opt: SET);
BEGIN
topScope := universe; OpenScope(0, NIL); SYSimported := FALSE;
GlbMod[0] := topScope; nofGmod := 1;
sfpresent := TRUE; (* !!! *)
symChanges := 0;
infinity.conval.intval := DevCPM.ConstNotAlloc;
depth := 0
END Init;
PROCEDURE Open* (name: Name);
BEGIN
SelfName := name$; topScope.name := NewName(name);
END Open;
PROCEDURE Close*;
VAR i: SHORTINT;
BEGIN (* garbage collection *)
CloseScope;
i := 0; WHILE i < maxImps DO GlbMod[i] := NIL; INC(i) END ;
i := FirstRef; WHILE i < maxStruct DO impCtxt.ref[i] := NIL; impCtxt.old[i] := NIL; INC(i) END
END Close;
PROCEDURE SameType* (x, y: Struct): BOOLEAN;
BEGIN
RETURN (x = y) OR (x.form = y.form) & ~(x.form IN {Pointer, ProcTyp, Comp}) OR (x = undftyp) OR (y = undftyp)
END SameType;
PROCEDURE EqualType* (x, y: Struct): BOOLEAN;
VAR xp, yp: Object; n: INTEGER;
BEGIN
n := 0;
WHILE (n < 100) & (x # y)
& (((x.comp = DynArr) & (y.comp = DynArr) & (x.sysflag = y.sysflag))
OR ((x.form = Pointer) & (y.form = Pointer))
OR ((x.form = ProcTyp) & (y.form = ProcTyp))) DO
IF x.form = ProcTyp THEN
xp := x.link; yp := y.link;
INC(depth);
WHILE (xp # NIL) & (yp # NIL) & (xp.mode = yp.mode) & (xp.sysflag = yp.sysflag)
& (xp.vis = yp.vis) & (depth < 100) & EqualType(xp.typ, yp.typ) DO
xp := xp.link; yp := yp.link
END;
DEC(depth);
IF (xp # NIL) OR (yp # NIL) THEN RETURN FALSE END
END;
x := x.BaseTyp; y := y.BaseTyp; INC(n)
END;
RETURN SameType(x, y)
END EqualType;
PROCEDURE Extends* (x, y: Struct): BOOLEAN;
BEGIN
IF (x.form = Pointer) & (y.form = Pointer) THEN x := x.BaseTyp; y := y.BaseTyp END;
IF (x.comp = Record) & (y.comp = Record) THEN
IF y = anytyp THEN RETURN TRUE END;
WHILE (x # NIL) & (x # undftyp) & (x # y) DO x := x.BaseTyp END
END;
RETURN (x # NIL) & EqualType(x, y)
END Extends;
PROCEDURE Includes* (xform, yform: INTEGER): BOOLEAN;
BEGIN
CASE xform OF
| Char16: RETURN yform IN {Char8, Char16, Int8}
| Int16: RETURN yform IN {Char8, Int8, Int16}
| Int32: RETURN yform IN {Char8, Char16, Int8, Int16, Int32}
| Int64: RETURN yform IN {Char8, Char16, Int8, Int16, Int32, Int64}
| Real32: RETURN yform IN {Char8, Char16, Int8, Int16, Int32, Int64, Real32}
| Real64: RETURN yform IN {Char8, Char16, Int8, Int16, Int32, Int64, Real32, Real64}
| String16: RETURN yform IN {String8, String16}
ELSE RETURN xform = yform
END
END Includes;
PROCEDURE FindImport*(VAR name: Name; mod: Object; VAR res: Object);
VAR obj: Object;
BEGIN obj := mod.scope.right;
LOOP
IF obj = NIL THEN EXIT END ;
IF name < obj.name^ THEN obj := obj.left
ELSIF name > obj.name^ THEN obj := obj.right
ELSE (*found*)
IF (obj.mode = Typ) & (obj.vis = internal) THEN obj := NIL
ELSE obj.used := TRUE
END ;
EXIT
END
END ;
res := obj
END FindImport;
PROCEDURE Find*(VAR name: Name; VAR res: Object);
VAR obj, head: Object;
BEGIN head := topScope;
LOOP obj := head.right;
LOOP
IF obj = NIL THEN EXIT END ;
IF name < obj.name^ THEN obj := obj.left
ELSIF name > obj.name^ THEN obj := obj.right
ELSE (* found, obj.used not set for local objects *) EXIT
END
END ;
IF obj # NIL THEN EXIT END ;
head := head.left;
IF head = NIL THEN EXIT END
END ;
res := obj
END Find;
PROCEDURE FindFld (VAR name: ARRAY OF SHORTCHAR; typ: Struct; VAR res: Object);
VAR obj: Object;
BEGIN
WHILE (typ # NIL) & (typ # undftyp) DO obj := typ.link;
WHILE obj # NIL DO
IF name < obj.name^ THEN obj := obj.left
ELSIF name > obj.name^ THEN obj := obj.right
ELSE (*found*) res := obj; RETURN
END
END ;
typ := typ.BaseTyp
END;
res := NIL
END FindFld;
PROCEDURE FindField* (VAR name: ARRAY OF SHORTCHAR; typ: Struct; VAR res: Object);
BEGIN
FindFld(name, typ, res);
IF (res = NIL) & ~typ.untagged THEN FindFld(name, anytyp, res) END
END FindField;
PROCEDURE FindBaseField* (VAR name: ARRAY OF SHORTCHAR; typ: Struct; VAR res: Object);
BEGIN
FindFld(name, typ.BaseTyp, res);
IF (res = NIL) & ~typ.untagged THEN FindFld(name, anytyp, res) END
END FindBaseField;
(*
PROCEDURE Rotated (y: Object; name: String): Object;
VAR c, gc: Object;
BEGIN
IF name^ < y.name^ THEN
c := y.left;
IF name^ < c.name^ THEN gc := c.left; c.left := gc.right; gc.right := c
ELSE gc := c.right; c.right := gc.left; gc.left := c
END;
y.left := gc
ELSE
c := y.right;
IF name^ < c.name^ THEN gc := c.left; c.left := gc.right; gc.right := c
ELSE gc := c.right; c.right := gc.left; gc.left := c
END;
y.right := gc
END;
RETURN gc
END Rotated;
PROCEDURE InsertIn (obj, scope: Object; VAR old: Object);
VAR gg, g, p, x: Object; name, sname: String;
BEGIN
sname := scope.name; scope.name := null;
gg := scope; g := gg; p := g; x := p.right; name := obj.name;
WHILE x # NIL DO
IF (x.left # NIL) & (x.right # NIL) & x.left.red & x.right.red THEN
x.red := TRUE; x.left.red := FALSE; x.right.red := FALSE;
IF p.red THEN
g.red := TRUE;
IF (name^ < g.name^) # (name^ < p.name^) THEN p := Rotated(g, name) END;
x := Rotated(gg, name); x.red := FALSE
END
END;
gg := g; g := p; p := x;
IF name^ < x.name^ THEN x := x.left
ELSIF name^ > x.name^ THEN x := x.right
ELSE old := x; scope.right.red := FALSE; scope.name := sname; RETURN
END
END;
x := obj; old := NIL;
IF name^ < p.name^ THEN p.left := x ELSE p.right := x END;
x.red := TRUE;
IF p.red THEN
g.red := TRUE;
IF (name^ < g.name^) # (name^ < p.name^) THEN p := Rotated(g, name) END;
x := Rotated(gg, name);
x.red := FALSE
END;
scope.right.red := FALSE; scope.name := sname
END InsertIn;
*)
PROCEDURE InsertIn (obj, scope: Object; VAR old: Object);
VAR ob0, ob1: Object; left: BOOLEAN; name: String;
BEGIN
ASSERT((scope # NIL) & (scope.mode = Head), 100);
ob0 := scope; ob1 := scope.right; left := FALSE; name := obj.name;
WHILE ob1 # NIL DO
IF name^ < ob1.name^ THEN ob0 := ob1; ob1 := ob1.left; left := TRUE
ELSIF name^ > ob1.name^ THEN ob0 := ob1; ob1 := ob1.right; left := FALSE
ELSE old := ob1; RETURN
END
END;
IF left THEN ob0.left := obj ELSE ob0.right := obj END ;
obj.left := NIL; obj.right := NIL; old := NIL
END InsertIn;
PROCEDURE Insert* (VAR name: Name; VAR obj: Object);
VAR old: Object;
BEGIN
obj := NewObj(); obj.leaf := TRUE;
obj.name := NewName(name);
obj.mnolev := topScope.mnolev;
InsertIn(obj, topScope, old);
IF old # NIL THEN err(1) END (*double def*)
END Insert;
PROCEDURE InsertThisField (obj: Object; typ: Struct; VAR old: Object);
VAR ob0, ob1: Object; left: BOOLEAN; name: String;
BEGIN
IF typ.link = NIL THEN typ.link := obj
ELSE
ob1 := typ.link; name := obj.name;
REPEAT
IF name^ < ob1.name^ THEN ob0 := ob1; ob1 := ob1.left; left := TRUE
ELSIF name^ > ob1.name^ THEN ob0 := ob1; ob1 := ob1.right; left := FALSE
ELSE old := ob1; RETURN
END
UNTIL ob1 = NIL;
IF left THEN ob0.left := obj ELSE ob0.right := obj END
END
END InsertThisField;
PROCEDURE InsertField* (VAR name: Name; typ: Struct; VAR obj: Object);
VAR old: Object;
BEGIN
obj := NewObj(); obj.leaf := TRUE;
obj.name := NewName(name);
InsertThisField(obj, typ, old);
IF old # NIL THEN err(1) END (*double def*)
END InsertField;
(*-------------------------- Fingerprinting --------------------------*)
PROCEDURE FPrintName(VAR fp: INTEGER; VAR name: ARRAY OF SHORTCHAR);
VAR i: SHORTINT; ch: SHORTCHAR;
BEGIN i := 0;
REPEAT ch := name[i]; DevCPM.FPrint(fp, ORD(ch)); INC(i) UNTIL ch = 0X
END FPrintName;
PROCEDURE ^IdFPrint*(typ: Struct);
PROCEDURE FPrintSign*(VAR fp: INTEGER; result: Struct; par: Object);
(* depends on assignment compatibility of params only *)
BEGIN
IdFPrint(result); DevCPM.FPrint(fp, result.idfp);
WHILE par # NIL DO
DevCPM.FPrint(fp, par.mode); IdFPrint(par.typ); DevCPM.FPrint(fp, par.typ.idfp);
IF (par.mode = VarPar) & (par.vis # 0) THEN DevCPM.FPrint(fp, par.vis) END; (* IN / OUT *)
IF par.sysflag # 0 THEN DevCPM.FPrint(fp, par.sysflag) END;
(* par.name and par.adr not considered *)
par := par.link
END
END FPrintSign;
PROCEDURE IdFPrint*(typ: Struct); (* idfp codifies assignment compatibility *)
VAR btyp: Struct; strobj: Object; idfp: INTEGER; f, c: SHORTINT;
BEGIN
IF ~typ.idfpdone THEN
typ.idfpdone := TRUE; (* may be recursive, temporary idfp is 0 in that case *)
idfp := 0; f := typ.form; c := typ.comp; DevCPM.FPrint(idfp, f); DevCPM.FPrint(idfp, c);
btyp := typ.BaseTyp; strobj := typ.strobj;
IF (strobj # NIL) & (strobj.name # null) THEN
FPrintName(idfp, GlbMod[typ.mno].name^); FPrintName(idfp, strobj.name^)
END ;
IF (f = Pointer) OR (c = Record) & (btyp # NIL) OR (c = DynArr) THEN
IdFPrint(btyp); DevCPM.FPrint(idfp, btyp.idfp)
ELSIF c = Array THEN IdFPrint(btyp); DevCPM.FPrint(idfp, btyp.idfp); DevCPM.FPrint(idfp, typ.n)
ELSIF f = ProcTyp THEN FPrintSign(idfp, btyp, typ.link)
END ;
typ.idfp := idfp
END
END IdFPrint;
PROCEDURE FPrintStr*(typ: Struct);
VAR f, c: SHORTINT; btyp: Struct; strobj, bstrobj: Object; pbfp, pvfp: INTEGER;
PROCEDURE ^FPrintFlds(fld: Object; adr: INTEGER; visible: BOOLEAN);
PROCEDURE FPrintHdFld(typ: Struct; fld: Object; adr: INTEGER); (* modifies pvfp only *)
VAR i, j, n: INTEGER; btyp: Struct;
BEGIN
IF typ.comp = Record THEN FPrintFlds(typ.link, adr, FALSE)
ELSIF typ.comp = Array THEN btyp := typ.BaseTyp; n := typ.n;
WHILE btyp.comp = Array DO n := btyp.n * n; btyp := btyp.BaseTyp END ;
IF (btyp.form = Pointer) OR (btyp.comp = Record) THEN
j := nofhdfld; FPrintHdFld(btyp, fld, adr);
IF j # nofhdfld THEN i := 1;
WHILE (i < n) (* & (nofhdfld <= DevCPM.MaxHdFld) *) DO (* !!! *)
INC(adr, btyp.size); FPrintHdFld(btyp, fld, adr); INC(i)
END
END
END
ELSIF DevCPM.ExpHdPtrFld &
((typ.form = Pointer) & ~typ.untagged OR (fld.name^ = DevCPM.HdPtrName)) THEN (* !!! *)
DevCPM.FPrint(pvfp, Pointer); DevCPM.FPrint(pvfp, adr); INC(nofhdfld)
ELSIF DevCPM.ExpHdUtPtrFld &
((typ.form = Pointer) & typ.untagged OR (fld.name^ = DevCPM.HdUtPtrName)) THEN (* !!! *)
DevCPM.FPrint(pvfp, Pointer); DevCPM.FPrint(pvfp, adr); INC(nofhdfld);
IF typ.form = Pointer THEN DevCPM.FPrint(pvfp, typ.sysflag) ELSE DevCPM.FPrint(pvfp, fld.sysflag) END
ELSIF DevCPM.ExpHdProcFld & ((typ.form = ProcTyp) OR (fld.name^ = DevCPM.HdProcName)) THEN
DevCPM.FPrint(pvfp, ProcTyp); DevCPM.FPrint(pvfp, adr); INC(nofhdfld)
END
END FPrintHdFld;
PROCEDURE FPrintFlds(fld: Object; adr: INTEGER; visible: BOOLEAN); (* modifies pbfp and pvfp *)
BEGIN
WHILE (fld # NIL) & (fld.mode = Fld) DO
IF (fld.vis # internal) & visible THEN
DevCPM.FPrint(pbfp, fld.vis); FPrintName(pbfp, fld.name^); DevCPM.FPrint(pbfp, fld.adr);
FPrintStr(fld.typ); DevCPM.FPrint(pbfp, fld.typ.pbfp); DevCPM.FPrint(pvfp, fld.typ.pvfp)
ELSE FPrintHdFld(fld.typ, fld, fld.adr + adr)
END ;
fld := fld.link
END
END FPrintFlds;
PROCEDURE FPrintTProcs(obj: Object); (* modifies pbfp and pvfp *)
BEGIN
IF obj # NIL THEN
FPrintTProcs(obj.left);
IF obj.mode = TProc THEN
IF obj.vis # internal THEN
IF obj.vis = externalR THEN DevCPM.FPrint(pbfp, externalR) END;
IF limAttr IN obj.conval.setval THEN DevCPM.FPrint(pbfp, limAttr)
ELSIF absAttr IN obj.conval.setval THEN DevCPM.FPrint(pbfp, absAttr)
ELSIF empAttr IN obj.conval.setval THEN DevCPM.FPrint(pbfp, empAttr)
ELSIF extAttr IN obj.conval.setval THEN DevCPM.FPrint(pbfp, extAttr)
END;
DevCPM.FPrint(pbfp, TProc); DevCPM.FPrint(pbfp, obj.num);
FPrintSign(pbfp, obj.typ, obj.link); FPrintName(pbfp, obj.name^);
IF obj.entry # NIL THEN FPrintName(pbfp, obj.entry^) END
ELSIF DevCPM.ExpHdTProc THEN
DevCPM.FPrint(pvfp, TProc); DevCPM.FPrint(pvfp, obj.num)
END
END;
FPrintTProcs(obj.right)
END
END FPrintTProcs;
BEGIN
IF ~typ.fpdone THEN
IdFPrint(typ); pbfp := typ.idfp;
IF typ.sysflag # 0 THEN DevCPM.FPrint(pbfp, typ.sysflag) END;
IF typ.ext # NIL THEN FPrintName(pbfp, typ.ext^) END;
IF typ.attribute # 0 THEN DevCPM.FPrint(pbfp, typ.attribute) END;
pvfp := pbfp; typ.pbfp := pbfp; typ.pvfp := pvfp; (* initial fprints may be used recursively *)
typ.fpdone := TRUE;
f := typ.form; c := typ.comp; btyp := typ.BaseTyp;
IF f = Pointer THEN
strobj := typ.strobj; bstrobj := btyp.strobj;
IF (strobj = NIL) OR (strobj.name = null) OR (bstrobj = NIL) OR (bstrobj.name = null) THEN
FPrintStr(btyp); DevCPM.FPrint(pbfp, btyp.pbfp); pvfp := pbfp
(* else use idfp as pbfp and as pvfp, do not call FPrintStr(btyp) here, else cycle not broken *)
END
ELSIF f = ProcTyp THEN (* use idfp as pbfp and as pvfp *)
ELSIF c IN {Array, DynArr} THEN FPrintStr(btyp); DevCPM.FPrint(pbfp, btyp.pvfp); pvfp := pbfp
ELSE (* c = Record *)
IF btyp # NIL THEN FPrintStr(btyp); DevCPM.FPrint(pbfp, btyp.pbfp); DevCPM.FPrint(pvfp, btyp.pvfp) END ;
DevCPM.FPrint(pvfp, typ.size); DevCPM.FPrint(pvfp, typ.align); DevCPM.FPrint(pvfp, typ.n);
nofhdfld := 0; FPrintFlds(typ.link, 0, TRUE);
(*
IF nofhdfld > DevCPM.MaxHdFld THEN DevCPM.Mark(225, typ.txtpos) END ;
*)
FPrintTProcs(typ.link); DevCPM.FPrint(pvfp, pbfp); strobj := typ.strobj;
IF (strobj = NIL) OR (strobj.name = null) THEN pbfp := pvfp END
END ;
typ.pbfp := pbfp; typ.pvfp := pvfp
END
END FPrintStr;
PROCEDURE FPrintObj*(obj: Object);
VAR fprint: INTEGER; f, m: SHORTINT; rval: SHORTREAL; ext: ConstExt; mod: Object; r: REAL; x: INTEGER;
BEGIN
IF ~obj.fpdone THEN
fprint := 0; obj.fpdone := TRUE;
DevCPM.FPrint(fprint, obj.mode);
IF obj.mode = Con THEN
f := obj.typ.form; DevCPM.FPrint(fprint, f);
CASE f OF
| Bool, Char8, Char16, Int8, Int16, Int32:
DevCPM.FPrint(fprint, obj.conval.intval)
| Int64:
x := SHORT(ENTIER((obj.conval.realval + obj.conval.intval) / 4294967296.0));
r := obj.conval.realval + obj.conval.intval - x * 4294967296.0;
IF r > MAX(INTEGER) THEN r := r - 4294967296.0 END;
DevCPM.FPrint(fprint, SHORT(ENTIER(r)));
DevCPM.FPrint(fprint, x)
| Set:
DevCPM.FPrintSet(fprint, obj.conval.setval)
| Real32:
rval := SHORT(obj.conval.realval); DevCPM.FPrintReal(fprint, rval)
| Real64:
DevCPM.FPrintLReal(fprint, obj.conval.realval)
| String8, String16:
FPrintName(fprint, obj.conval.ext^)
| NilTyp:
ELSE err(127)
END
ELSIF obj.mode = Var THEN
DevCPM.FPrint(fprint, obj.vis); FPrintStr(obj.typ); DevCPM.FPrint(fprint, obj.typ.pbfp)
ELSIF obj.mode IN {XProc, IProc} THEN
FPrintSign(fprint, obj.typ, obj.link)
ELSIF obj.mode = CProc THEN
FPrintSign(fprint, obj.typ, obj.link); ext := obj.conval.ext;
m := ORD(ext^[0]); f := 1; DevCPM.FPrint(fprint, m);
WHILE f <= m DO DevCPM.FPrint(fprint, ORD(ext^[f])); INC(f) END
ELSIF obj.mode = Typ THEN
FPrintStr(obj.typ); DevCPM.FPrint(fprint, obj.typ.pbfp)
END ;
IF obj.sysflag < 0 THEN DevCPM.FPrint(fprint, obj.sysflag) END;
IF obj.mode IN {LProc, XProc, CProc, Var, Typ, Con} THEN
IF obj.library # NIL THEN
FPrintName(fprint, obj.library^)
ELSIF obj.mnolev < 0 THEN
mod := GlbMod[-obj.mnolev];
IF (mod.library # NIL) THEN
FPrintName(fprint, mod.library^)
END
ELSIF obj.mnolev = 0 THEN
IF libName # "" THEN FPrintName(fprint, libName) END
END;
IF obj.entry # NIL THEN FPrintName(fprint, obj.entry^) END
END;
obj.fprint := fprint
END
END FPrintObj;
PROCEDURE FPrintErr* (obj: Object; errno: SHORTINT); (* !!! *)
BEGIN
IF errno = 249 THEN
DevCPM.LogWLn; DevCPM.LogWStr(" ");
DevCPM.LogWStr(GlbMod[-obj.mnolev].name^);
DevCPM.LogW("."); DevCPM.LogWStr(obj.name^);
DevCPM.LogWStr(" is not consistently imported");
err(249)
ELSIF obj = NIL THEN (* changed module sys flags *)
IF ~symNew & sfpresent THEN
DevCPM.LogWLn; DevCPM.LogWStr(" changed library flag")
END
ELSIF obj.mnolev = 0 THEN (* don't report changes in imported modules *)
IF sfpresent THEN
IF symChanges < 20 THEN
DevCPM.LogWLn; DevCPM.LogWStr(" "); DevCPM.LogWStr(obj.name^);
IF errno = 250 THEN DevCPM.LogWStr(" is no longer in symbol file")
ELSIF errno = 251 THEN DevCPM.LogWStr(" is redefined internally ")
ELSIF errno = 252 THEN DevCPM.LogWStr(" is redefined")
ELSIF errno = 253 THEN DevCPM.LogWStr(" is new in symbol file")
END
ELSIF symChanges = 20 THEN
DevCPM.LogWLn; DevCPM.LogWStr(" ...")
END;
INC(symChanges)
ELSIF (errno = 253) & ~symExtended THEN
DevCPM.LogWLn;
DevCPM.LogWStr(" new symbol file")
END
END;
IF errno = 253 THEN symExtended := TRUE ELSE symNew := TRUE END
END FPrintErr;
(*-------------------------- Import --------------------------*)
PROCEDURE InName(VAR name: String);
VAR i: SHORTINT; ch: SHORTCHAR; n: Name;
BEGIN i := 0;
REPEAT
DevCPM.SymRCh(ch); n[i] := ch; INC(i)
UNTIL ch = 0X;
IF i > 1 THEN NEW(name, i); name^ := n$ ELSE name := null END
END InName;
PROCEDURE InMod(tag: INTEGER; VAR mno: BYTE); (* mno is global *)
VAR head: Object; name: String; mn: INTEGER; i: BYTE; lib: String;
BEGIN
IF tag = 0 THEN mno := impCtxt.glbmno[0]
ELSIF tag > 0 THEN
lib := NIL;
IF tag = Slib THEN InName(lib); tag := DevCPM.SymRInt() END;
ASSERT(tag = Smname);
InName(name);
IF (name^ = SelfName) & ~impCtxt.self & ~(DevCPM.interface IN DevCPM.options) THEN err(154) END ;
i := 0;
WHILE (i < nofGmod) & (name^ # GlbMod[i].name^) DO INC(i) END ;
IF i < nofGmod THEN mno := i (*module already present*)
ELSE
head := NewObj(); head.mode := Head; head.name := name;
mno := nofGmod; head.mnolev := SHORT(SHORT(-mno));
head.library := lib;
IF nofGmod < maxImps THEN
GlbMod[mno] := head; INC(nofGmod)
ELSE err(227)
END
END ;
impCtxt.glbmno[impCtxt.nofm] := mno; INC(impCtxt.nofm)
ELSE
mno := impCtxt.glbmno[-tag]
END
END InMod;
PROCEDURE InConstant(f: INTEGER; conval: Const);
VAR ch, ch1: SHORTCHAR; ext, t: ConstExt; rval: SHORTREAL; r, s: REAL; i, x, y: INTEGER; str: Name;
BEGIN
CASE f OF
| Byte, Char8, Bool:
DevCPM.SymRCh(ch); conval.intval := ORD(ch)
| Char16:
DevCPM.SymRCh(ch); conval.intval := ORD(ch);
DevCPM.SymRCh(ch); conval.intval := conval.intval + ORD(ch) * 256
| Int8, Int16, Int32:
conval.intval := DevCPM.SymRInt()
| Int64:
DevCPM.SymRCh(ch); x := 0; y := 1; r := 0; s := 268435456 (*2^28*);
WHILE (y < 268435456 (*2^28*)) & (ch >= 80X) DO
x := x + (ORD(ch) - 128) * y; y := y * 128; DevCPM.SymRCh(ch)
END;
WHILE ch >= 80X DO r := r + (ORD(ch) - 128) * s; s := s * 128; DevCPM.SymRCh(ch) END;
conval.realval := r + x + ((LONG(ORD(ch)) + 64) MOD 128 - 64) * s;
conval.intval := SHORT(ENTIER(r + x + ((LONG(ORD(ch)) + 64) MOD 128 - 64) * s - conval.realval))
| Set:
DevCPM.SymRSet(conval.setval)
| Real32:
DevCPM.SymRReal(rval); conval.realval := rval;
conval.intval := DevCPM.ConstNotAlloc
| Real64:
DevCPM.SymRLReal(conval.realval);
conval.intval := DevCPM.ConstNotAlloc
| String8, String16:
i := 0;
REPEAT
DevCPM.SymRCh(ch);
IF i < LEN(str) - 1 THEN str[i] := ch
ELSIF i = LEN(str) - 1 THEN str[i] := 0X; NEW(ext, 2 * LEN(str)); ext^ := str$; ext[i] := ch
ELSIF i < LEN(ext^) - 1 THEN ext[i] := ch
ELSE t := ext; t[i] := 0X; NEW(ext, 2 * LEN(t^)); ext^ := t^$; ext[i] := ch
END;
INC(i)
UNTIL ch = 0X;
IF i < LEN(str) THEN NEW(ext, i); ext^ := str$ END;
conval.ext := ext; conval.intval := DevCPM.ConstNotAlloc;
IF f = String8 THEN conval.intval2 := i
ELSE
i := 0; y := 0;
REPEAT DevCPM.GetUtf8(ext^, x, i); INC(y) UNTIL x = 0;
conval.intval2 := y
END
(*
ext := NewExt(); conval.ext := ext; i := 0;
REPEAT
DevCPM.SymRCh(ch); ext^[i] := ch; INC(i)
UNTIL ch = 0X;
conval.intval2 := i;
conval.intval := DevCPM.ConstNotAlloc
| String16:
ext := NewExt(); conval.ext := ext; i := 0;
REPEAT
DevCPM.SymRCh(ch); ext^[i] := ch; INC(i);
DevCPM.SymRCh(ch1); ext^[i] := ch1; INC(i)
UNTIL (ch = 0X) & (ch1 = 0X);
conval.intval2 := i;
conval.intval := DevCPM.ConstNotAlloc
*)
| NilTyp:
conval.intval := 0
(*
| Guid:
ext := NewExt(); conval.ext := ext; i := 0;
WHILE i < 16 DO
DevCPM.SymRCh(ch); ext^[i] := ch; INC(i)
END;
ext[16] := 0X;
conval.intval2 := 16;
conval.intval := DevCPM.ConstNotAlloc;
*)
END
END InConstant;
PROCEDURE ^InStruct(VAR typ: Struct);
PROCEDURE InSign(mno: BYTE; VAR res: Struct; VAR par: Object);
VAR last, new: Object; tag: INTEGER;
BEGIN
InStruct(res);
tag := DevCPM.SymRInt(); last := NIL;
WHILE tag # Send DO
new := NewObj(); new.mnolev := SHORT(SHORT(-mno));
IF last = NIL THEN par := new ELSE last.link := new END ;
IF tag = Ssys THEN
new.sysflag := SHORT(SHORT(DevCPM.SymRInt())); tag := DevCPM.SymRInt();
IF ODD(new.sysflag DIV inBit) THEN new.vis := inPar
ELSIF ODD(new.sysflag DIV inBit) THEN new.vis := outPar
END
END;
IF tag = Svalpar THEN new.mode := Var
ELSE new.mode := VarPar;
IF tag = Sinpar THEN new.vis := inPar
ELSIF tag = Soutpar THEN new.vis := outPar
END
END ;
InStruct(new.typ); new.adr := DevCPM.SymRInt(); InName(new.name);
last := new; tag := DevCPM.SymRInt()
END
END InSign;
PROCEDURE InFld(): Object; (* first number in impCtxt.nextTag, mno set outside *)
VAR tag: INTEGER; obj: Object;
BEGIN
tag := impCtxt.nextTag; obj := NewObj();
IF tag <= Srfld THEN
obj.mode := Fld;
IF tag = Srfld THEN obj.vis := externalR ELSE obj.vis := external END ;
InStruct(obj.typ); InName(obj.name);
obj.adr := DevCPM.SymRInt()
ELSE
obj.mode := Fld;
IF tag = Shdptr THEN obj.name := NewName(DevCPM.HdPtrName)
ELSIF tag = Shdutptr THEN obj.name := NewName(DevCPM.HdUtPtrName); (* !!! *)
obj.sysflag := 1
ELSIF tag = Ssys THEN
obj.name := NewName(DevCPM.HdUtPtrName); obj.sysflag := SHORT(SHORT(DevCPM.SymRInt()))
ELSE obj.name := NewName(DevCPM.HdProcName)
END;
obj.typ := undftyp; obj.vis := internal;
obj.adr := DevCPM.SymRInt()
END;
RETURN obj
END InFld;
PROCEDURE InTProc(mno: BYTE): Object; (* first number in impCtxt.nextTag *)
VAR tag: INTEGER; obj: Object;
BEGIN
tag := impCtxt.nextTag;
obj := NewObj(); obj.mnolev := SHORT(SHORT(-mno));
IF tag = Shdtpro THEN
obj.mode := TProc; obj.name := NewName(DevCPM.HdTProcName);
obj.link := NewObj(); (* dummy, easier in Browser *)
obj.typ := undftyp; obj.vis := internal;
obj.num := DevCPM.SymRInt()
ELSE
obj.vis := external;
IF tag = Simpo THEN obj.vis := externalR; tag := DevCPM.SymRInt() END;
obj.mode := TProc; obj.conval := NewConst(); obj.conval.intval := -1;
IF tag = Sentry THEN InName(obj.entry); tag := DevCPM.SymRInt() END;
InSign(mno, obj.typ, obj.link); InName(obj.name);
obj.num := DevCPM.SymRInt();
IF tag = Slimpro THEN INCL(obj.conval.setval, limAttr)
ELSIF tag = Sabspro THEN INCL(obj.conval.setval, absAttr)
ELSIF tag = Semppro THEN INCL(obj.conval.setval, empAttr)
ELSIF tag = Sextpro THEN INCL(obj.conval.setval, extAttr)
END
END ;
RETURN obj
END InTProc;
PROCEDURE InStruct(VAR typ: Struct);
VAR mno: BYTE; ref: SHORTINT; tag: INTEGER; name: String;
t: Struct; obj, last, fld, old, dummy: Object;
BEGIN
tag := DevCPM.SymRInt();
IF tag # Sstruct THEN
tag := -tag;
IF (version = 0) & (tag >= FirstRef0) THEN tag := tag + FirstRef - FirstRef0 END; (* correction for new FirstRef *)
typ := impCtxt.ref[tag]
ELSE
ref := impCtxt.nofr; INC(impCtxt.nofr);
IF ref < impCtxt.minr THEN impCtxt.minr := ref END ;
tag := DevCPM.SymRInt();
InMod(tag, mno); InName(name); obj := NewObj();
IF name = null THEN
IF impCtxt.self THEN old := NIL (* do not insert type desc anchor here, but in OPL *)
ELSE obj.name := NewName("@"); InsertIn(obj, GlbMod[mno], old(*=NIL*)); obj.name := null
END ;
typ := NewStr(Undef, Basic)
ELSE obj.name := name; InsertIn(obj, GlbMod[mno], old);
IF old # NIL THEN (* recalculate fprints to compare with old fprints *)
FPrintObj(old); impCtxt.pvfp[ref] := old.typ.pvfp;
IF impCtxt.self THEN (* do not overwrite old typ *)
typ := NewStr(Undef, Basic)
ELSE (* overwrite old typ for compatibility reason *)
typ := old.typ; typ.link := NIL; typ.sysflag := 0; typ.ext := NIL;
typ.fpdone := FALSE; typ.idfpdone := FALSE
END
ELSE typ := NewStr(Undef, Basic)
END
END ;
impCtxt.ref[ref] := typ; impCtxt.old[ref] := old; typ.ref := SHORT(ref + maxStruct);
(* ref >= maxStruct: not exported yet, ref used for err 155 *)
typ.mno := mno; typ.allocated := TRUE;
typ.strobj := obj; obj.mode := Typ; obj.typ := typ;
obj.mnolev := SHORT(SHORT(-mno)); obj.vis := internal; (* name not visible here *)
tag := DevCPM.SymRInt();
IF tag = Ssys THEN
typ.sysflag := SHORT(DevCPM.SymRInt()); tag := DevCPM.SymRInt()
END;
typ.untagged := typ.sysflag > 0;
IF tag = Slib THEN
InName(obj.library); tag := DevCPM.SymRInt()
END;
IF tag = Sentry THEN
InName(obj.entry); tag := DevCPM.SymRInt()
END;
IF tag = String8 THEN
InName(typ.ext); tag := DevCPM.SymRInt()
END;
CASE tag OF
| Sptr:
typ.form := Pointer; typ.size := DevCPM.PointerSize; typ.n := 0; InStruct(typ.BaseTyp)
| Sarr:
typ.form := Comp; typ.comp := Array; InStruct(typ.BaseTyp); typ.n := DevCPM.SymRInt();
typ.size := typ.n * typ.BaseTyp.size (* !!! *)
| Sdarr:
typ.form := Comp; typ.comp := DynArr; InStruct(typ.BaseTyp);
IF typ.BaseTyp.comp = DynArr THEN typ.n := typ.BaseTyp.n + 1
ELSE typ.n := 0
END ;
typ.size := DevCPM.DArrSizeA + DevCPM.DArrSizeB * typ.n; (* !!! *)
IF typ.untagged THEN typ.size := DevCPM.PointerSize END
| Srec, Sabsrec, Slimrec, Sextrec:
typ.form := Comp; typ.comp := Record; InStruct(typ.BaseTyp);
(* correction by ETH 18.1.96 *)
IF typ.BaseTyp = notyp THEN typ.BaseTyp := NIL END;
typ.extlev := 0; t := typ.BaseTyp;
WHILE (t # NIL) & (t.comp = Record) DO INC(typ.extlev); t := t.BaseTyp END;
typ.size := DevCPM.SymRInt(); typ.align := DevCPM.SymRInt();
typ.n := DevCPM.SymRInt();
IF tag = Sabsrec THEN typ.attribute := absAttr
ELSIF tag = Slimrec THEN typ.attribute := limAttr
ELSIF tag = Sextrec THEN typ.attribute := extAttr
END;
impCtxt.nextTag := DevCPM.SymRInt(); last := NIL;
WHILE (impCtxt.nextTag >= Sfld) & (impCtxt.nextTag <= Shdpro)
OR (impCtxt.nextTag = Shdutptr) OR (impCtxt.nextTag = Ssys) DO
fld := InFld(); fld.mnolev := SHORT(SHORT(-mno));
IF last # NIL THEN last.link := fld END ;
last := fld;
InsertThisField(fld, typ, dummy);
impCtxt.nextTag := DevCPM.SymRInt()
END ;
WHILE impCtxt.nextTag # Send DO fld := InTProc(mno);
InsertThisField(fld, typ, dummy);
impCtxt.nextTag := DevCPM.SymRInt()
END
| Spro:
typ.form := ProcTyp; typ.size := DevCPM.ProcSize; InSign(mno, typ.BaseTyp, typ.link)
| Salias:
InStruct(t);
typ.form := t.form; typ.comp := Basic; typ.size := t.size;
typ.pbfp := t.pbfp; typ.pvfp := t.pvfp; typ.fpdone := TRUE;
typ.idfp := t.idfp; typ.idfpdone := TRUE; typ.BaseTyp := t
END ;
IF ref = impCtxt.minr THEN
WHILE ref < impCtxt.nofr DO
t := impCtxt.ref[ref]; FPrintStr(t);
obj := t.strobj; (* obj.typ.strobj = obj, else obj.fprint differs (alias) *)
IF obj.name # null THEN FPrintObj(obj) END ;
old := impCtxt.old[ref];
IF old # NIL THEN t.strobj := old; (* restore strobj *)
IF impCtxt.self THEN
IF old.mnolev < 0 THEN
IF old.history # inconsistent THEN
IF old.fprint # obj.fprint THEN old.history := pbmodified
ELSIF impCtxt.pvfp[ref] # t.pvfp THEN old.history := pvmodified
END
(* ELSE remain inconsistent *)
END
ELSIF old.fprint # obj.fprint THEN old.history := pbmodified
ELSIF impCtxt.pvfp[ref] # t.pvfp THEN old.history := pvmodified
ELSIF old.vis = internal THEN old.history := same (* may be changed to "removed" in InObj *)
ELSE old.history := inserted (* may be changed to "same" in InObj *)
END
ELSE
(* check private part, delay error message until really used *)
IF impCtxt.pvfp[ref] # t.pvfp THEN old.history := inconsistent END ;
IF old.fprint # obj.fprint THEN FPrintErr(old, 249) END
END
ELSIF impCtxt.self THEN obj.history := removed
ELSE obj.history := same
END ;
INC(ref)
END ;
impCtxt.minr := maxStruct
END
END
END InStruct;
PROCEDURE InObj(mno: BYTE): Object; (* first number in impCtxt.nextTag *)
VAR ch: SHORTCHAR; obj, old: Object; typ: Struct;
tag, i, s: INTEGER; ext: ConstExt;
BEGIN
tag := impCtxt.nextTag;
IF tag = Stype THEN
InStruct(typ); obj := typ.strobj;
IF ~impCtxt.self THEN obj.vis := external END (* type name visible now, obj.fprint already done *)
ELSE
obj := NewObj(); obj.mnolev := SHORT(SHORT(-mno)); obj.vis := external;
IF tag = Ssys THEN obj.sysflag := SHORT(SHORT(DevCPM.SymRInt())); tag := DevCPM.SymRInt() END;
IF tag = Slib THEN
InName(obj.library); tag := DevCPM.SymRInt()
END;
IF tag = Sentry THEN
InName(obj.entry); tag := DevCPM.SymRInt()
END;
IF tag >= Sxpro THEN
IF obj.conval = NIL THEN obj.conval := NewConst() END;
obj.conval.intval := -1;
InSign(mno, obj.typ, obj.link);
CASE tag OF
| Sxpro: obj.mode := XProc
| Sipro: obj.mode := IProc
| Scpro: obj.mode := CProc;
s := DevCPM.SymRInt();
NEW(ext, s + 1); obj.conval.ext := ext;
ext^[0] := SHORT(CHR(s)); i := 1;
WHILE i <= s DO DevCPM.SymRCh(ext^[i]); INC(i) END
END
ELSIF tag = Salias THEN
obj.mode := Typ; InStruct(obj.typ)
ELSIF (tag = Svar) OR (tag = Srvar) THEN
obj.mode := Var;
IF tag = Srvar THEN obj.vis := externalR END ;
InStruct(obj.typ)
ELSE (* Constant *)
obj.conval := NewConst(); InConstant(tag, obj.conval);
IF (tag = Int8) OR (tag = Int16) THEN tag := Int32 END;
obj.mode := Con; obj.typ := impCtxt.ref[tag];
END ;
InName(obj.name)
END ;
FPrintObj(obj);
IF (obj.mode = Var) & ((obj.typ.strobj = NIL) OR (obj.typ.strobj.name = null)) THEN
(* compute a global fingerprint to avoid structural type equivalence for anonymous types *)
DevCPM.FPrint(impCtxt.reffp, obj.typ.ref - maxStruct)
END ;
IF tag # Stype THEN
InsertIn(obj, GlbMod[mno], old);
IF impCtxt.self THEN
IF old # NIL THEN
(* obj is from old symbol file, old is new declaration *)
IF old.vis = internal THEN old.history := removed
ELSE FPrintObj(old); FPrintStr(old.typ); (* FPrint(obj) already called *)
IF obj.fprint # old.fprint THEN old.history := pbmodified
ELSIF obj.typ.pvfp # old.typ.pvfp THEN old.history := pvmodified
ELSE old.history := same
END
END
ELSE obj.history := removed (* OutObj not called if mnolev < 0 *)
END
(* ELSE old = NIL, or file read twice, consistent, OutObj not called *)
END
ELSE (* obj already inserted in InStruct *)
IF impCtxt.self THEN (* obj.mnolev = 0 *)
IF obj.vis = internal THEN obj.history := removed
ELSIF obj.history = inserted THEN obj.history := same
END
(* ELSE OutObj not called for obj with mnolev < 0 *)
END
END ;
RETURN obj
END InObj;
PROCEDURE Import*(aliasName: Name; VAR name: Name; VAR done: BOOLEAN);
VAR obj, h: Object; mno: BYTE; tag, p: INTEGER; lib: String; (* done used in Browser *)
BEGIN
IF name = "SYSTEM" THEN
SYSimported := TRUE;
p := processor;
IF (p < 10) OR (p > 30) THEN p := DevCPM.sysImp END;
INCL(DevCPM.options, p); (* for sysflag handling *)
Insert(aliasName, obj); obj.mode := Mod; obj.mnolev := 0; obj.scope := syslink; obj.typ := notyp;
h := NewObj(); h.mode := Head; h.right := syslink; obj.scope := h
ELSIF name = "COM" THEN
IF DevCPM.comAware IN DevCPM.options THEN
INCL(DevCPM.options, DevCPM.com); (* for sysflag handling *)
Insert(aliasName, obj); obj.mode := Mod; obj.mnolev := 0; obj.scope := comlink; obj.typ := notyp;
h := NewObj(); h.mode := Head; h.right := comlink; obj.scope := h;
ELSE err(151)
END;
ELSIF name = "JAVA" THEN
INCL(DevCPM.options, DevCPM.java)
ELSE
impCtxt.nofr := FirstRef; impCtxt.minr := maxStruct; impCtxt.nofm := 0;
impCtxt.self := aliasName = "@self"; impCtxt.reffp := 0;
DevCPM.OldSym(name, done);
IF done THEN
lib := NIL;
impProc := SHORT(DevCPM.SymRInt());
IF (impProc # 0) & (processor # 0) & (impProc # processor) THEN err(151) END;
tag := DevCPM.SymRInt();
IF tag < Smname THEN version := tag; tag := DevCPM.SymRInt()
ELSE version := 0
END;
IF tag = Slib THEN InName(lib); tag := DevCPM.SymRInt() END;
InMod(tag, mno);
IF (name[0] # "@") & (GlbMod[mno].name^ # name) THEN (* symbol file name conflict *)
GlbMod[mno] := NIL; nofGmod := mno; DEC(impCtxt.nofm);
DevCPM.CloseOldSym; done := FALSE
END;
END;
IF done THEN
GlbMod[mno].library := lib;
impCtxt.nextTag := DevCPM.SymRInt();
WHILE ~DevCPM.eofSF() DO
obj := InObj(mno); impCtxt.nextTag := DevCPM.SymRInt()
END ;
Insert(aliasName, obj);
obj.mode := Mod; obj.scope := GlbMod[mno](*.right*);
GlbMod[mno].link := obj;
obj.mnolev := SHORT(SHORT(-mno)); obj.typ := notyp;
DevCPM.CloseOldSym
ELSIF impCtxt.self THEN
sfpresent := FALSE
ELSE err(152) (*sym file not found*)
END
END
END Import;
(*-------------------------- Export --------------------------*)
PROCEDURE OutName(VAR name: ARRAY OF SHORTCHAR);
VAR i: SHORTINT; ch: SHORTCHAR;
BEGIN i := 0;
REPEAT ch := name[i]; DevCPM.SymWCh(ch); INC(i) UNTIL ch = 0X
END OutName;
PROCEDURE OutMod(mno: SHORTINT);
VAR mod: Object;
BEGIN
IF expCtxt.locmno[mno] < 0 THEN (* new mod *)
mod := GlbMod[mno];
IF mod.library # NIL THEN
DevCPM.SymWInt(Slib); OutName(mod.library^)
END;
DevCPM.SymWInt(Smname);
expCtxt.locmno[mno] := expCtxt.nofm; INC(expCtxt.nofm);
OutName(mod.name^)
ELSE DevCPM.SymWInt(-expCtxt.locmno[mno])
END
END OutMod;
PROCEDURE ^OutStr(typ: Struct);
PROCEDURE ^OutFlds(fld: Object; adr: INTEGER; visible: BOOLEAN);
PROCEDURE OutHdFld(typ: Struct; fld: Object; adr: INTEGER);
VAR i, j, n: INTEGER; btyp: Struct;
BEGIN
IF typ.comp = Record THEN OutFlds(typ.link, adr, FALSE)
ELSIF typ.comp = Array THEN btyp := typ.BaseTyp; n := typ.n;
WHILE btyp.comp = Array DO n := btyp.n * n; btyp := btyp.BaseTyp END ;
IF (btyp.form = Pointer) OR (btyp.comp = Record) THEN
j := nofhdfld; OutHdFld(btyp, fld, adr);
IF j # nofhdfld THEN i := 1;
WHILE (i < n) (* & (nofhdfld <= DevCPM.MaxHdFld) *) DO (* !!! *)
INC(adr, btyp.size); OutHdFld(btyp, fld, adr); INC(i)
END
END
END
ELSIF DevCPM.ExpHdPtrFld &
((typ.form = Pointer) & ~typ.untagged OR (fld.name^ = DevCPM.HdPtrName)) THEN (* !!! *)
DevCPM.SymWInt(Shdptr); DevCPM.SymWInt(adr); INC(nofhdfld)
ELSIF DevCPM.ExpHdUtPtrFld &
((typ.form = Pointer) & typ.untagged OR (fld.name^ = DevCPM.HdUtPtrName)) THEN (* !!! *)
DevCPM.SymWInt(Ssys); (* DevCPM.SymWInt(Shdutptr); *)
IF typ.form = Pointer THEN n := typ.sysflag ELSE n := fld.sysflag END;
DevCPM.SymWInt(n);
DevCPM.SymWInt(adr); INC(nofhdfld);
IF n > 1 THEN portable := FALSE END (* hidden untagged pointer are portable *)
ELSIF DevCPM.ExpHdProcFld & ((typ.form = ProcTyp) OR (fld.name^ = DevCPM.HdProcName)) THEN
DevCPM.SymWInt(Shdpro); DevCPM.SymWInt(adr); INC(nofhdfld)
END
END OutHdFld;
PROCEDURE OutFlds(fld: Object; adr: INTEGER; visible: BOOLEAN);
BEGIN
WHILE (fld # NIL) & (fld.mode = Fld) DO
IF (fld.vis # internal) & visible THEN
IF fld.vis = externalR THEN DevCPM.SymWInt(Srfld) ELSE DevCPM.SymWInt(Sfld) END ;
OutStr(fld.typ); OutName(fld.name^); DevCPM.SymWInt(fld.adr)
ELSE OutHdFld(fld.typ, fld, fld.adr + adr)
END ;
fld := fld.link
END
END OutFlds;
PROCEDURE OutSign(result: Struct; par: Object);
BEGIN
OutStr(result);
WHILE par # NIL DO
IF par.sysflag # 0 THEN DevCPM.SymWInt(Ssys); DevCPM.SymWInt(par.sysflag) END;
IF par.mode = Var THEN DevCPM.SymWInt(Svalpar)
ELSIF par.vis = inPar THEN DevCPM.SymWInt(Sinpar)
ELSIF par.vis = outPar THEN DevCPM.SymWInt(Soutpar)
ELSE DevCPM.SymWInt(Svarpar)
END ;
OutStr(par.typ);
DevCPM.SymWInt(par.adr);
OutName(par.name^); par := par.link
END ;
DevCPM.SymWInt(Send)
END OutSign;
PROCEDURE OutTProcs(typ: Struct; obj: Object);
VAR bObj: Object;
BEGIN
IF obj # NIL THEN
IF obj.mode = TProc THEN
(*
IF (typ.BaseTyp # NIL) & (obj.num < typ.BaseTyp.n) & (obj.vis = internal) & (obj.scope # NIL) THEN
FindBaseField(obj.name^, typ, bObj);
ASSERT((bObj # NIL) & (bObj.num = obj.num));
IF bObj.vis # internal THEN DevCPM.Mark(109, typ.txtpos) END
(* hidden and overriding, not detected in OPP because record exported indirectly or via aliasing *)
END;
*)
IF obj.vis # internal THEN
IF obj.vis = externalR THEN DevCPM.SymWInt(Simpo) END;
IF obj.entry # NIL THEN
DevCPM.SymWInt(Sentry); OutName(obj.entry^); portable := FALSE
END;
IF limAttr IN obj.conval.setval THEN DevCPM.SymWInt(Slimpro)
ELSIF absAttr IN obj.conval.setval THEN DevCPM.SymWInt(Sabspro)
ELSIF empAttr IN obj.conval.setval THEN DevCPM.SymWInt(Semppro)
ELSIF extAttr IN obj.conval.setval THEN DevCPM.SymWInt(Sextpro)
ELSE DevCPM.SymWInt(Stpro)
END;
OutSign(obj.typ, obj.link); OutName(obj.name^);
DevCPM.SymWInt(obj.num)
ELSIF DevCPM.ExpHdTProc THEN
DevCPM.SymWInt(Shdtpro);
DevCPM.SymWInt(obj.num)
END
END;
OutTProcs(typ, obj.left);
OutTProcs(typ, obj.right)
END
END OutTProcs;
PROCEDURE OutStr(typ: Struct); (* OPV.TypeAlloc already applied *)
VAR strobj: Object;
BEGIN
IF typ.ref < expCtxt.ref THEN DevCPM.SymWInt(-typ.ref)
ELSE
DevCPM.SymWInt(Sstruct);
typ.ref := expCtxt.ref; INC(expCtxt.ref);
IF expCtxt.ref >= maxStruct THEN err(228) END ;
OutMod(typ.mno); strobj := typ.strobj;
IF (strobj # NIL) & (strobj.name # null) THEN OutName(strobj.name^);
CASE strobj.history OF
| pbmodified: FPrintErr(strobj, 252)
| pvmodified: FPrintErr(strobj, 251)
| inconsistent: FPrintErr(strobj, 249)
ELSE (* checked in OutObj or correct indirect export *)
END
ELSE DevCPM.SymWCh(0X) (* anonymous => never inconsistent, pvfp influences the client fp *)
END;
IF typ.sysflag # 0 THEN (* !!! *)
DevCPM.SymWInt(Ssys); DevCPM.SymWInt(typ.sysflag);
IF typ.sysflag > 0 THEN portable := FALSE END
END;
IF strobj # NIL THEN
IF strobj.library # NIL THEN
DevCPM.SymWInt(Slib); OutName(strobj.library^); portable := FALSE
END;
IF strobj.entry # NIL THEN
DevCPM.SymWInt(Sentry); OutName(strobj.entry^); portable := FALSE
END
END;
IF typ.ext # NIL THEN
DevCPM.SymWInt(String8); OutName(typ.ext^); portable := FALSE
END;
CASE typ.form OF
| Pointer:
DevCPM.SymWInt(Sptr); OutStr(typ.BaseTyp)
| ProcTyp:
DevCPM.SymWInt(Spro); OutSign(typ.BaseTyp, typ.link)
| Comp:
CASE typ.comp OF
| Array:
DevCPM.SymWInt(Sarr); OutStr(typ.BaseTyp); DevCPM.SymWInt(typ.n)
| DynArr:
DevCPM.SymWInt(Sdarr); OutStr(typ.BaseTyp)
| Record:
IF typ.attribute = limAttr THEN DevCPM.SymWInt(Slimrec)
ELSIF typ.attribute = absAttr THEN DevCPM.SymWInt(Sabsrec)
ELSIF typ.attribute = extAttr THEN DevCPM.SymWInt(Sextrec)
ELSE DevCPM.SymWInt(Srec)
END;
IF typ.BaseTyp = NIL THEN OutStr(notyp) ELSE OutStr(typ.BaseTyp) END ;
(* BaseTyp should be Notyp, too late to change *)
DevCPM.SymWInt(typ.size); DevCPM.SymWInt(typ.align); DevCPM.SymWInt(typ.n);
nofhdfld := 0; OutFlds(typ.link, 0, TRUE);
(*
IF nofhdfld > DevCPM.MaxHdFld THEN DevCPM.Mark(223, typ.txtpos) END ; (* !!! *)
*)
OutTProcs(typ, typ.link); DevCPM.SymWInt(Send)
END
ELSE (* alias structure *)
DevCPM.SymWInt(Salias); OutStr(typ.BaseTyp)
END
END
END OutStr;
PROCEDURE OutConstant(obj: Object);
VAR f, i: SHORTINT; rval: SHORTREAL; a, b, c: INTEGER; r: REAL;
BEGIN
f := obj.typ.form;
(*
IF obj.typ = guidtyp THEN f := Guid END;
*)
IF f = Int32 THEN
IF (obj.conval.intval >= -128) & (obj.conval.intval <= -127) THEN f := Int8
ELSIF (obj.conval.intval >= -32768) & (obj.conval.intval <= -32767) THEN f := Int16
END
END;
DevCPM.SymWInt(f);
CASE f OF
| Bool, Char8:
DevCPM.SymWCh(SHORT(CHR(obj.conval.intval)))
| Char16:
DevCPM.SymWCh(SHORT(CHR(obj.conval.intval MOD 256)));
DevCPM.SymWCh(SHORT(CHR(obj.conval.intval DIV 256)))
| Int8, Int16, Int32:
DevCPM.SymWInt(obj.conval.intval)
| Int64:
IF ABS(obj.conval.realval + obj.conval.intval) <= MAX(INTEGER) THEN
a := SHORT(ENTIER(obj.conval.realval + obj.conval.intval)); b := -1; c := -1
ELSIF ABS(obj.conval.realval + obj.conval.intval) <= 1125899906842624.0 (*2^50*) THEN
a := SHORT(ENTIER((obj.conval.realval + obj.conval.intval) / 2097152.0 (*2^21*)));
b := SHORT(ENTIER(obj.conval.realval + obj.conval.intval - a * 2097152.0 (*2^21*))); c := -1
ELSE
a := SHORT(ENTIER((obj.conval.realval + obj.conval.intval) / 4398046511104.0 (*2^42*)));
r := obj.conval.realval + obj.conval.intval - a * 4398046511104.0 (*2^42*);
b := SHORT(ENTIER(r / 2097152.0 (*2^21*)));
c := SHORT(ENTIER(r - b * 2097152.0 (*2^21*)))
END;
IF c >= 0 THEN
DevCPM.SymWCh(SHORT(CHR(c MOD 128 + 128))); c := c DIV 128;
DevCPM.SymWCh(SHORT(CHR(c MOD 128 + 128))); c := c DIV 128;
DevCPM.SymWCh(SHORT(CHR(c MOD 128 + 128)))
END;
IF b >= 0 THEN
DevCPM.SymWCh(SHORT(CHR(b MOD 128 + 128))); b := b DIV 128;
DevCPM.SymWCh(SHORT(CHR(b MOD 128 + 128))); b := b DIV 128;
DevCPM.SymWCh(SHORT(CHR(b MOD 128 + 128)))
END;
DevCPM.SymWInt(a)
| Set:
DevCPM.SymWSet(obj.conval.setval)
| Real32:
rval := SHORT(obj.conval.realval); DevCPM.SymWReal(rval)
| Real64:
DevCPM.SymWLReal(obj.conval.realval)
| String8, String16:
OutName(obj.conval.ext^)
| NilTyp:
(*
| Guid:
i := 0;
WHILE i < 16 DO DevCPM.SymWCh(obj.conval.ext[i]); INC(i) END
*)
ELSE err(127)
END
END OutConstant;
PROCEDURE OutObj(obj: Object);
VAR i, j: SHORTINT; ext: ConstExt;
BEGIN
IF obj # NIL THEN
OutObj(obj.left);
IF obj.mode IN {Con, Typ, Var, LProc, XProc, CProc, IProc} THEN
IF obj.history = removed THEN FPrintErr(obj, 250)
ELSIF obj.vis # internal THEN
CASE obj.history OF
| inserted: FPrintErr(obj, 253)
| same: (* ok *)
| pbmodified:
IF (obj.mode # Typ) OR (obj.typ.strobj # obj) THEN FPrintErr(obj, 252) END
| pvmodified:
IF (obj.mode # Typ) OR (obj.typ.strobj # obj) THEN FPrintErr(obj, 251) END
END ;
IF obj.sysflag < 0 THEN DevCPM.SymWInt(Ssys); DevCPM.SymWInt(obj.sysflag); portable := FALSE END;
IF obj.mode IN {LProc, XProc, CProc, Var, Con} THEN
(* name alias for types handled in OutStr *)
IF obj.library # NIL THEN
DevCPM.SymWInt(Slib); OutName(obj.library^); portable := FALSE
END;
IF obj.entry # NIL THEN
DevCPM.SymWInt(Sentry); OutName(obj.entry^); portable := FALSE
END
END;
CASE obj.mode OF
| Con:
OutConstant(obj); OutName(obj.name^)
| Typ:
IF obj.typ.strobj = obj THEN DevCPM.SymWInt(Stype); OutStr(obj.typ)
ELSE DevCPM.SymWInt(Salias); OutStr(obj.typ); OutName(obj.name^)
END
| Var:
IF obj.vis = externalR THEN DevCPM.SymWInt(Srvar) ELSE DevCPM.SymWInt(Svar) END ;
OutStr(obj.typ); OutName(obj.name^);
IF (obj.typ.strobj = NIL) OR (obj.typ.strobj.name = null) THEN
(* compute fingerprint to avoid structural type equivalence *)
DevCPM.FPrint(expCtxt.reffp, obj.typ.ref)
END
| XProc:
DevCPM.SymWInt(Sxpro); OutSign(obj.typ, obj.link); OutName(obj.name^)
| IProc:
DevCPM.SymWInt(Sipro); OutSign(obj.typ, obj.link); OutName(obj.name^)
| CProc:
DevCPM.SymWInt(Scpro); OutSign(obj.typ, obj.link); ext := obj.conval.ext;
j := ORD(ext^[0]); i := 1; DevCPM.SymWInt(j);
WHILE i <= j DO DevCPM.SymWCh(ext^[i]); INC(i) END ;
OutName(obj.name^); portable := FALSE
END
END
END ;
OutObj(obj.right)
END
END OutObj;
PROCEDURE Export*(VAR ext, new: BOOLEAN);
VAR i: SHORTINT; nofmod: BYTE; done: BOOLEAN; old: Object;
BEGIN
symExtended := FALSE; symNew := FALSE; nofmod := nofGmod;
Import("@self", SelfName, done); nofGmod := nofmod;
ASSERT(GlbMod[0].name^ = SelfName);
IF DevCPM.noerr THEN (* ~DevCPM.noerr => ~done *)
DevCPM.NewSym(SelfName);
IF DevCPM.noerr THEN
DevCPM.SymWInt(0); (* portable symfile *)
DevCPM.SymWInt(actVersion);
old := GlbMod[0]; portable := TRUE;
IF libName # "" THEN
DevCPM.SymWInt(Slib); OutName(libName); portable := FALSE;
IF done & ((old.library = NIL) OR (old.library^ # libName)) THEN
FPrintErr(NIL, 252)
END
ELSIF done & (old.library # NIL) THEN FPrintErr(NIL, 252)
END;
DevCPM.SymWInt(Smname); OutName(SelfName);
expCtxt.reffp := 0; expCtxt.ref := FirstRef;
expCtxt.nofm := 1; expCtxt.locmno[0] := 0;
i := 1; WHILE i < maxImps DO expCtxt.locmno[i] := -1; INC(i) END ;
OutObj(topScope.right);
ext := sfpresent & symExtended; new := ~sfpresent OR symNew;
IF DevCPM.noerr & ~portable THEN
DevCPM.SymReset;
DevCPM.SymWInt(processor) (* nonportable symfile *)
END;
IF DevCPM.noerr & sfpresent & (impCtxt.reffp # expCtxt.reffp) THEN
new := TRUE
END ;
IF ~DevCPM.noerr THEN DevCPM.DeleteNewSym END
(* DevCPM.RegisterNewSym is called in OP2 after writing the object file *)
END
END
END Export; (* no new symbol file if ~DevCPM.noerr *)
PROCEDURE InitStruct(VAR typ: Struct; form: BYTE);
BEGIN
typ := NewStr(form, Basic); typ.ref := form; typ.size := 1; typ.allocated := TRUE;
typ.strobj := NewObj(); typ.pbfp := form; typ.pvfp := form; typ.fpdone := TRUE;
typ.idfp := form; typ.idfpdone := TRUE
END InitStruct;
PROCEDURE EnterBoolConst(name: Name; val: INTEGER);
VAR obj: Object;
BEGIN
Insert(name, obj); obj.conval := NewConst();
obj.mode := Con; obj.typ := booltyp; obj.conval.intval := val
END EnterBoolConst;
PROCEDURE EnterRealConst(name: Name; val: REAL; VAR obj: Object);
BEGIN
Insert(name, obj); obj.conval := NewConst();
obj.mode := Con; obj.typ := real32typ; obj.conval.realval := val
END EnterRealConst;
PROCEDURE EnterTyp(name: Name; form: BYTE; size: SHORTINT; VAR res: Struct);
VAR obj: Object; typ: Struct;
BEGIN
Insert(name, obj);
typ := NewStr(form, Basic); obj.mode := Typ; obj.typ := typ; obj.vis := external;
typ.strobj := obj; typ.size := size; typ.ref := form; typ.allocated := TRUE;
typ.pbfp := form; typ.pvfp := form; typ.fpdone := TRUE;
typ.idfp := form; typ.idfpdone := TRUE; res := typ
END EnterTyp;
PROCEDURE EnterProc(name: Name; num: SHORTINT);
VAR obj: Object;
BEGIN Insert(name, obj);
obj.mode := SProc; obj.typ := notyp; obj.adr := num
END EnterProc;
PROCEDURE EnterAttr(name: Name; num: SHORTINT);
VAR obj: Object;
BEGIN Insert(name, obj);
obj.mode := Attr; obj.adr := num
END EnterAttr;
PROCEDURE EnterTProc(ptr, rec: Struct; name: Name; num, typ: SHORTINT);
VAR obj, par: Object;
BEGIN
InsertField(name, rec, obj);
obj.mnolev := -128; (* for correct implement only behaviour *)
obj.mode := TProc; obj.num := num; obj.conval := NewConst();
obj.conval.setval := obj.conval.setval + {newAttr};
IF typ = 0 THEN (* FINALIZE, RELEASE *)
obj.typ := notyp; obj.vis := externalR;
INCL(obj.conval.setval, empAttr)
ELSIF typ = 1 THEN (* QueryInterface *)
par := NewObj(); par.name := NewName("int"); par.mode := VarPar; par.vis := outPar;
par.sysflag := 8; par.adr := 16; par.typ := punktyp;
par.link := obj.link; obj.link := par;
par := NewObj(); par.name := NewName("iid"); par.mode := VarPar; par.vis := inPar;
par.sysflag := 16; par.adr := 12; par.typ := guidtyp;
par.link := obj.link; obj.link := par;
obj.typ := restyp; obj.vis := external;
INCL(obj.conval.setval, extAttr)
ELSIF typ = 2 THEN (* AddRef, Release *)
obj.typ := notyp; obj.vis := externalR;
INCL(obj.conval.setval, isHidden);
INCL(obj.conval.setval, extAttr)
END;
par := NewObj(); par.name := NewName("this"); par.mode := Var;
par.adr := 8; par.typ := ptr;
par.link := obj.link; obj.link := par;
END EnterTProc;
PROCEDURE EnterHdField(VAR root: Object; offs: SHORTINT);
VAR obj: Object;
BEGIN
obj := NewObj(); obj.mode := Fld;
obj.name := NewName(DevCPM.HdPtrName); obj.typ := undftyp; obj.adr := offs;
obj.link := root; root := obj
END EnterHdField;
BEGIN
NEW(null, 1); null^ := "";
topScope := NIL; OpenScope(0, NIL); DevCPM.errpos := 0;
InitStruct(undftyp, Undef); InitStruct(notyp, NoTyp);
InitStruct(string8typ, String8); InitStruct(niltyp, NilTyp); niltyp.size := DevCPM.PointerSize;
InitStruct(string16typ, String16);
undftyp.BaseTyp := undftyp;
(*initialization of module SYSTEM*)
(*
EnterTyp("BYTE", Byte, 1, bytetyp);
EnterProc("NEW", sysnewfn);
*)
EnterTyp("PTR", Pointer, DevCPM.PointerSize, sysptrtyp);
EnterProc("ADR", adrfn);
EnterProc("TYP", typfn);
EnterProc("CC", ccfn);
EnterProc("LSH", lshfn);
EnterProc("ROT", rotfn);
EnterProc("GET", getfn);
EnterProc("PUT", putfn);
EnterProc("GETREG", getrfn);
EnterProc("PUTREG", putrfn);
EnterProc("BIT", bitfn);
EnterProc("VAL", valfn);
EnterProc("MOVE", movefn);
EnterProc("THISRECORD", thisrecfn);
EnterProc("THISARRAY", thisarrfn);
syslink := topScope.right; topScope.right := NIL;
(* initialization of module COM *)
EnterProc("ID", iidfn);
EnterProc("QUERY", queryfn);
EnterTyp("RESULT", Int32, 4, restyp);
restyp.ref := Res;
EnterTyp("GUID", Guid, 16, guidtyp);
guidtyp.form := Comp; guidtyp.comp := Array; guidtyp.n := 16;
EnterTyp("IUnknown^", IUnk, 12, iunktyp);
iunktyp.form := Comp; iunktyp.comp := Record; iunktyp.n := 3;
iunktyp.attribute := absAttr;
(*
EnterHdField(iunktyp.link, 12);
*)
iunktyp.BaseTyp := NIL; iunktyp.align := 4;
iunktyp.sysflag := interface; iunktyp.untagged := TRUE;
NEW(iunktyp.ext, 40); iunktyp.ext^ := "{00000000-0000-0000-C000-000000000046}";
EnterTyp("IUnknown", PUnk, DevCPM.PointerSize, punktyp);
punktyp.form := Pointer; punktyp.BaseTyp := iunktyp;
punktyp.sysflag := interface; punktyp.untagged := TRUE;
EnterTProc(punktyp, iunktyp, "QueryInterface", 0, 1);
EnterTProc(punktyp, iunktyp, "AddRef", 1, 2);
EnterTProc(punktyp, iunktyp, "Release", 2, 2);
comlink := topScope.right; topScope.right := NIL;
universe := topScope;
EnterProc("LCHR", lchrfn);
EnterProc("LENTIER", lentierfcn);
EnterTyp("ANYREC", AnyRec, 0, anytyp);
anytyp.form := Comp; anytyp.comp := Record; anytyp.n := 1;
anytyp.BaseTyp := NIL; anytyp.extlev := -1; (* !!! *)
anytyp.attribute := absAttr;
EnterTyp("ANYPTR", AnyPtr, DevCPM.PointerSize, anyptrtyp);
anyptrtyp.form := Pointer; anyptrtyp.BaseTyp := anytyp;
EnterTProc(anyptrtyp, anytyp, "FINALIZE", 0, 0);
EnterTProc(anyptrtyp, iunktyp, "RELEASE", 1, 0);
EnterProc("VALID", validfn);
EnterTyp("SHORTCHAR", Char8, 1, char8typ);
string8typ.BaseTyp := char8typ;
EnterTyp("CHAR", Char16, 2, char16typ);
EnterTyp("LONGCHAR", Char16, 2, lchar16typ);
string16typ.BaseTyp := char16typ;
EnterTyp("SET", Set, 4, settyp);
EnterTyp("BYTE", Int8, 1, int8typ);
guidtyp.BaseTyp := int8typ;
EnterTyp("SHORTINT", Int16, 2, int16typ);
EnterTyp("INTEGER", Int32, 4, int32typ);
EnterTyp("LONGINT", Int64, 8, int64typ);
EnterTyp("LARGEINT", Int64, 8, lint64typ);
EnterTyp("SHORTREAL", Real32, 4, real32typ);
EnterTyp("REAL", Real64, 8, real64typ);
EnterTyp("LONGREAL", Real64, 8, lreal64typ);
EnterTyp("BOOLEAN", Bool, 1, booltyp);
EnterBoolConst("FALSE", 0); (* 0 and 1 are compiler internal representation only *)
EnterBoolConst("TRUE", 1);
EnterRealConst("INF", DevCPM.InfReal, infinity);
EnterProc("HALT", haltfn);
EnterProc("NEW", newfn);
EnterProc("ABS", absfn);
EnterProc("CAP", capfn);
EnterProc("ORD", ordfn);
EnterProc("ENTIER", entierfn);
EnterProc("ODD", oddfn);
EnterProc("MIN", minfn);
EnterProc("MAX", maxfn);
EnterProc("CHR", chrfn);
EnterProc("SHORT", shortfn);
EnterProc("LONG", longfn);
EnterProc("SIZE", sizefn);
EnterProc("INC", incfn);
EnterProc("DEC", decfn);
EnterProc("INCL", inclfn);
EnterProc("EXCL", exclfn);
EnterProc("LEN", lenfn);
EnterProc("COPY", copyfn);
EnterProc("ASH", ashfn);
EnterProc("ASSERT", assertfn);
(*
EnterProc("ADR", adrfn);
EnterProc("TYP", typfn);
*)
EnterProc("BITS", bitsfn);
EnterAttr("ABSTRACT", absAttr);
EnterAttr("LIMITED", limAttr);
EnterAttr("EMPTY", empAttr);
EnterAttr("EXTENSIBLE", extAttr);
NEW(intrealtyp); intrealtyp^ := real64typ^;
impCtxt.ref[Undef] := undftyp; impCtxt.ref[Byte] := bytetyp;
impCtxt.ref[Bool] := booltyp; impCtxt.ref[Char8] := char8typ;
impCtxt.ref[Int8] := int8typ; impCtxt.ref[Int16] := int16typ;
impCtxt.ref[Int32] := int32typ; impCtxt.ref[Real32] := real32typ;
impCtxt.ref[Real64] := real64typ; impCtxt.ref[Set] := settyp;
impCtxt.ref[String8] := string8typ; impCtxt.ref[NilTyp] := niltyp;
impCtxt.ref[NoTyp] := notyp; impCtxt.ref[Pointer] := sysptrtyp;
impCtxt.ref[AnyPtr] := anyptrtyp; impCtxt.ref[AnyRec] := anytyp;
impCtxt.ref[Char16] := char16typ; impCtxt.ref[String16] := string16typ;
impCtxt.ref[Int64] := int64typ;
impCtxt.ref[IUnk] := iunktyp; impCtxt.ref[PUnk] := punktyp;
impCtxt.ref[Guid] := guidtyp; impCtxt.ref[Res] := restyp;
END DevCPT.
Objects:
mode | adr conval link scope leaf
------------------------------------------------
Undef | Not used
Var | vadr next regopt Glob or loc var or proc value parameter
VarPar| vadr next regopt Var parameter (vis = 0 | inPar | outPar)
Con | val Constant
Fld | off next Record field
Typ | Named type
LProc | entry sizes firstpar scope leaf Local procedure, entry adr set in back-end
XProc | entry sizes firstpar scope leaf External procedure, entry adr set in back-end
SProc | fno sizes Standard procedure
CProc | code firstpar scope Code procedure
IProc | entry sizes scope leaf Interrupt procedure, entry adr set in back-end
Mod | scope Module
Head | txtpos owner firstvar Scope anchor
TProc | entry sizes firstpar scope leaf Bound procedure, mthno = obj.num
Structures:
form comp | n BaseTyp link mno txtpos sysflag
----------------------------------------------------------------------------------
Undef Basic |
Byte Basic |
Bool Basic |
Char8 Basic |
Int8 Basic |
Int16 Basic |
Int32 Basic |
Real32 Basic |
Real64 Basic |
Set Basic |
String8 Basic |
NilTyp Basic |
NoTyp Basic |
Pointer Basic | PBaseTyp mno txtpos sysflag
ProcTyp Basic | ResTyp params mno txtpos sysflag
Comp Array | nofel ElemTyp mno txtpos sysflag
Comp DynArr| dim ElemTyp mno txtpos sysflag
Comp Record| nofmth RBaseTyp fields mno txtpos sysflag
Char16 Basic |
String16Basic |
Int64 Basic |
Nodes:
design = Nvar|Nvarpar|Nfield|Nderef|Nindex|Nguard|Neguard|Ntype|Nproc.
expr = design|Nconst|Nupto|Nmop|Ndop|Ncall.
nextexpr = NIL|expr.
ifstat = NIL|Nif.
casestat = Ncaselse.
sglcase = NIL|Ncasedo.
stat = NIL|Ninittd|Nenter|Nassign|Ncall|Nifelse|Ncase|Nwhile|Nrepeat|
Nloop|Nexit|Nreturn|Nwith|Ntrap.
class subcl obj left right link
---------------------------------------------------------
design Nvar var nextexpr
Nvarpar varpar nextexpr
Nfield field design nextexpr
Nderef ptr/str design nextexpr
Nindex design expr nextexpr
Nguard design nextexpr (typ = guard type)
Neguard design nextexpr (typ = guard type)
Ntype type nextexpr
Nproc normal proc nextexpr
super proc nextexpr
expr design
Nconst const (val = node.conval)
Nupto expr expr nextexpr
Nmop not expr nextexpr
minus expr nextexpr
is tsttype expr nextexpr
conv expr nextexpr
abs expr nextexpr
cap expr nextexpr
odd expr nextexpr
bit expr nextexpr {x}
adr expr nextexpr SYSTEM.ADR
typ expr nextexpr SYSTEM.TYP
cc Nconst nextexpr SYSTEM.CC
val expr nextexpr SYSTEM.VAL
Ndop times expr expr nextexpr
slash expr expr nextexpr
div expr expr nextexpr
mod expr expr nextexpr
and expr expr nextexpr
plus expr expr nextexpr
minus expr expr nextexpr
or expr expr nextexpr
eql expr expr nextexpr
neq expr expr nextexpr
lss expr expr nextexpr
leq expr expr nextexpr
grt expr expr nextexpr
geq expr expr nextexpr
in expr expr nextexpr
ash expr expr nextexpr
msk expr Nconst nextexpr
len design Nconst nextexpr
min expr expr nextexpr MIN
max expr expr nextexpr MAX
bit expr expr nextexpr SYSTEM.BIT
lsh expr expr nextexpr SYSTEM.LSH
rot expr expr nextexpr SYSTEM.ROT
Ncall fpar design nextexpr nextexpr
Ncomp stat expr nextexpr
nextexpr NIL
expr
ifstat NIL
Nif expr stat ifstat
casestat Ncaselse sglcase stat (minmax = node.conval)
sglcase NIL
Ncasedo Nconst stat sglcase
stat NIL
Ninittd stat (of node.typ)
Nenter proc stat stat stat (proc=NIL for mod)
Nassign assign design expr stat
newfn design nextexp stat
incfn design expr stat
decfn design expr stat
inclfn design expr stat
exclfn design expr stat
copyfn design expr stat
getfn design expr stat SYSTEM.GET
putfn expr expr stat SYSTEM.PUT
getrfn design Nconst stat SYSTEM.GETREG
putrfn Nconst expr stat SYSTEM.PUTREG
sysnewfn design expr stat SYSTEM.NEW
movefn expr expr stat SYSTEM.MOVE
(right.link = 3rd par)
Ncall fpar design nextexpr stat
Nifelse ifstat stat stat
Ncase expr casestat stat
Nwhile expr stat stat
Nrepeat stat expr stat
Nloop stat stat
Nexit stat
Nreturn proc nextexpr stat (proc = NIL for mod)
Nwith ifstat stat stat
Ntrap expr stat
Ncomp stat stat stat
| Dev/Mod/CPT.odc |
MODULE DevCPV486;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
references = "ftp://ftp.inf.ethz.ch/pub/software/Oberon/OberonV4/Docu/OP2.Paper.ps"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT SYSTEM, DevCPM, DevCPT, DevCPE, DevCPH, DevCPL486, DevCPC486;
CONST
processor* = 10; (* for i386 *)
(* object modes *)
Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7;
SProc = 8; CProc = 9; IProc = 10; Mod = 11; Head = 12; TProc = 13;
(* item modes for i386 *)
Ind = 14; Abs = 15; Stk = 16; Cond = 17; Reg = 18; DInd = 19;
(* symbol values and ops *)
times = 1; slash = 2; div = 3; mod = 4;
and = 5; plus = 6; minus = 7; or = 8; eql = 9;
neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14;
in = 15; is = 16; ash = 17; msk = 18; len = 19;
conv = 20; abs = 21; cap = 22; odd = 23; not = 33;
(*SYSTEM*)
adr = 24; cc = 25; bit = 26; lsh = 27; rot = 28; val = 29;
min = 34; max = 35; typfn = 36;
thisrecfn = 45; thisarrfn = 46;
shl = 50; shr = 51; lshr = 52; xor = 53;
(* structure forms *)
Undef = 0; Byte = 1; Bool = 2; Char8 = 3; Int8 = 4; Int16 = 5; Int32 = 6;
Real32 = 7; Real64 = 8; Set = 9; String8 = 10; NilTyp = 11; NoTyp = 12;
Pointer = 13; ProcTyp = 14; Comp = 15;
Char16 = 16; String16 = 17; Int64 = 18;
VString16to8 = 29; VString8 = 30; VString16 = 31;
realSet = {Real32, Real64};
(* composite structure forms *)
Basic = 1; Array = 2; DynArr = 3; Record = 4;
(* nodes classes *)
Nvar = 0; Nvarpar = 1; Nfield = 2; Nderef = 3; Nindex = 4; Nguard = 5; Neguard = 6;
Nconst = 7; Ntype = 8; Nproc = 9; Nupto = 10; Nmop = 11; Ndop = 12; Ncall = 13;
Ninittd = 14; Nif = 15; Ncaselse = 16; Ncasedo = 17; Nenter = 18; Nassign = 19;
Nifelse =20; Ncase = 21; Nwhile = 22; Nrepeat = 23; Nloop = 24; Nexit = 25;
Nreturn = 26; Nwith = 27; Ntrap = 28; Ncomp = 30;
Ndrop = 50; Nlabel = 51; Ngoto = 52; Njsr = 53; Nret = 54; Ncmp = 55;
(*function number*)
assign = 0; newfn = 1; incfn = 13; decfn = 14;
inclfn = 15; exclfn = 16; copyfn = 18; assertfn = 32;
(*SYSTEM function number*)
getfn = 24; putfn = 25; getrfn = 26; putrfn = 27; sysnewfn = 30; movefn = 31;
(* COM function number *)
validfn = 40; queryfn = 42;
(* procedure flags (conval.setval) *)
hasBody = 1; isRedef = 2; slNeeded = 3; imVar = 4; isHidden = 29; isGuarded = 30; isCallback = 31;
(* attribute flags (attr.adr, struct.attribute, proc.conval.setval) *)
newAttr = 16; absAttr = 17; limAttr = 18; empAttr = 19; extAttr = 20;
(* case statement flags (conval.setval) *)
useTable = 1; useTree = 2;
(* registers *)
AX = 0; CX = 1; DX = 2; BX = 3; SP = 4; BP = 5; SI = 6; DI = 7; AH = 4; CH = 5; DH = 6; BH = 7;
stk = 31; mem = 30; con = 29; float = 28; high = 27; short = 26; deref = 25; loaded = 24;
wreg = {AX, BX, CX, DX, SI, DI};
(* module visibility of objects *)
internal = 0; external = 1; externalR = 2; inPar = 3; outPar = 4;
(* sysflag *)
untagged = 1; noAlign = 3; align2 = 4; align8 = 6; union = 7;
interface = 10; guarded = 8; noframe = 16;
nilBit = 1; enumBits = 8; new = 1; iid = 2;
stackArray = 120;
(* system trap numbers *)
withTrap = -1; caseTrap = -2; funcTrap = -3; typTrap = -4;
recTrap = -5; ranTrap = -6; inxTrap = -7; copyTrap = -8;
ParOff = 8;
interfaceSize = 16; (* SIZE(Kernel.Interface) *)
addRefFP = 48H; (* fingerprint of AddRef and Release procedures *)
intHandlerFP = 12A8H; (* fingerprint of InterfaceTrapHandler *)
numPreIntProc = 2;
VAR
Exit, Return: DevCPL486.Label;
assert, sequential: BOOLEAN;
nesting, actual: INTEGER;
query, addRef, release, release2: DevCPT.Object;
PROCEDURE Init*(opt: SET);
CONST ass = 2;
BEGIN
DevCPL486.Init(opt); DevCPC486.Init(opt);
assert := ass IN opt;
DevCPM.breakpc := MAX(INTEGER);
query := NIL; addRef := NIL; release := NIL; release2 := NIL; DevCPC486.intHandler := NIL;
END Init;
PROCEDURE Close*;
BEGIN
DevCPL486.Close
END Close;
PROCEDURE Align(VAR offset: INTEGER; align: INTEGER);
BEGIN
CASE align OF
1: (* ok *)
| 2: INC(offset, offset MOD 2)
| 4: INC(offset, (-offset) MOD 4)
| 8: INC(offset, (-offset) MOD 8)
END
END Align;
PROCEDURE NegAlign(VAR offset: INTEGER; align: INTEGER);
BEGIN
CASE align OF
1: (* ok *)
| 2: DEC(offset, offset MOD 2)
| 4: DEC(offset, offset MOD 4)
| 8: DEC(offset, offset MOD 8)
END
END NegAlign;
PROCEDURE Base(typ: DevCPT.Struct; limit: INTEGER): INTEGER; (* typ.comp # DynArr *)
VAR align: INTEGER;
BEGIN
WHILE typ.comp = Array DO typ := typ.BaseTyp END ;
IF typ.comp = Record THEN
align := typ.align
ELSE
align := typ.size;
END;
IF align > limit THEN RETURN limit ELSE RETURN align END
END Base;
(* -----------------------------------------------------
reference implementation of TypeSize for portable symbol files
mandatory for all non-system structures
PROCEDURE TypeSize (typ: DevCPT.Struct);
VAR f, c: SHORTINT; offset: LONGINT; fld: DevCPT.Object; btyp: DevCPT.Struct;
BEGIN
IF typ.size = -1 THEN
f := typ.form; c := typ.comp; btyp := typ.BaseTyp;
IF c = Record THEN
IF btyp = NIL THEN offset := 0 ELSE TypeSize(btyp); offset := btyp.size END;
fld := typ.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
btyp := fld.typ; TypeSize(btyp);
IF btyp.size >= 4 THEN INC(offset, (-offset) MOD 4)
ELSIF btyp.size >= 2 THEN INC(offset, offset MOD 2)
END;
fld.adr := offset; INC(offset, btyp.size);
fld := fld.link
END;
IF offset > 2 THEN INC(offset, (-offset) MOD 4) END;
typ.size := offset; typ.align := 4;
typ.n := -1 (* methods not counted yet *)
ELSIF c = Array THEN
TypeSize(btyp);
typ.size := typ.n * btyp.size
ELSIF f = Pointer THEN
typ.size := DevCPM.PointerSize
ELSIF f = ProcTyp THEN
typ.size := DevCPM.ProcSize
ELSE (* c = DynArr *)
TypeSize(btyp);
IF btyp.comp = DynArr THEN typ.size := btyp.size + 4
ELSE typ.size := 8
END
END
END
END TypeSize;
----------------------------------------------------- *)
PROCEDURE GTypeSize (typ: DevCPT.Struct; guarded: BOOLEAN);
VAR f, c: BYTE; offset, align, falign, alignLimit: INTEGER;
fld: DevCPT.Object; btyp: DevCPT.Struct; name: DevCPT.Name;
BEGIN
IF typ.untagged THEN guarded := TRUE END;
IF typ = DevCPT.undftyp THEN DevCPM.err(58)
ELSIF typ.size = -1 THEN
f := typ.form; c := typ.comp; btyp := typ.BaseTyp;
IF c = Record THEN
IF btyp = NIL THEN offset := 0; align := 1;
ELSE GTypeSize(btyp, guarded); offset := btyp.size; align := btyp.align
END ;
IF typ.sysflag = noAlign THEN alignLimit := 1
ELSIF typ.sysflag = align2 THEN alignLimit := 2
ELSIF typ.sysflag = align8 THEN alignLimit := 8
ELSE alignLimit := 4
END;
fld := typ.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
btyp := fld.typ; GTypeSize(btyp, guarded);
IF typ.sysflag > 0 THEN falign := Base(btyp, alignLimit)
ELSIF btyp.size >= 4 THEN falign := 4
ELSIF btyp.size >= 2 THEN falign := 2
ELSE falign := 1
END;
IF typ.sysflag = union THEN
fld.adr := 0;
IF btyp.size > offset THEN offset := btyp.size END;
ELSE
Align(offset, falign);
fld.adr := offset;
IF offset <= MAX(INTEGER) - 4 - btyp.size THEN INC(offset, btyp.size)
ELSE offset := 4; DevCPM.Mark(214, typ.txtpos)
END
END;
IF falign > align THEN align := falign END ;
fld := fld.link
END;
(*
IF (typ.sysflag = interface) & (typ.BaseTyp = NIL) THEN
fld := DevCPT.NewObj(); fld.name^ := DevCPM.HdPtrName; fld.mode := Fld;
fld.typ := DevCPT.undftyp; fld.adr := 8;
fld.right := typ.link; typ.link := fld;
fld := DevCPT.NewObj(); fld.name^ := DevCPM.HdPtrName; fld.mode := Fld;
fld.typ := DevCPT.undftyp; fld.adr := 12;
typ.link.link := fld; typ.link.left := fld;
offset := interfaceSize; align := 4
END;
*)
IF typ.sysflag <= 0 THEN align := 4 END;
typ.align := align;
IF (typ.sysflag > 0) OR (offset > 2) THEN Align(offset, align) END;
typ.size := offset;
typ.n := -1 (* methods not counted yet *)
ELSIF c = Array THEN
GTypeSize(btyp, guarded);
IF (btyp.size = 0) OR (typ.n <= MAX(INTEGER) DIV btyp.size) THEN typ.size := typ.n * btyp.size
ELSE typ.size := 4; DevCPM.Mark(214, typ.txtpos)
END
ELSIF f = Pointer THEN
typ.size := DevCPM.PointerSize;
IF guarded & ~typ.untagged THEN DevCPM.Mark(143, typ.txtpos) END
ELSIF f = ProcTyp THEN
typ.size := DevCPM.ProcSize
ELSE (* c = DynArr *)
GTypeSize(btyp, guarded);
IF (typ.sysflag = untagged) OR typ.untagged THEN typ.size := 4
ELSE
IF btyp.comp = DynArr THEN typ.size := btyp.size + 4
ELSE typ.size := 8
END
END
END
END
END GTypeSize;
PROCEDURE TypeSize*(typ: DevCPT.Struct); (* also called from DevCPT.InStruct for arrays *)
BEGIN
GTypeSize(typ, FALSE)
END TypeSize;
PROCEDURE GetComKernel;
VAR name: DevCPT.Name; mod: DevCPT.Object;
BEGIN
IF addRef = NIL THEN
DevCPT.OpenScope(SHORT(SHORT(-DevCPT.nofGmod)), NIL);
DevCPT.topScope.name := DevCPT.NewName("$$");
name := "AddRef"; DevCPT.Insert(name, addRef);
addRef.mode := XProc;
addRef.fprint := addRefFP;
addRef.fpdone := TRUE;
name := "Release"; DevCPT.Insert(name, release);
release.mode := XProc;
release.fprint := addRefFP;
release.fpdone := TRUE;
name := "Release2"; DevCPT.Insert(name, release2);
release2.mode := XProc;
release2.fprint := addRefFP;
release2.fpdone := TRUE;
name := "InterfaceTrapHandler"; DevCPT.Insert(name, DevCPC486.intHandler);
DevCPC486.intHandler.mode := XProc;
DevCPC486.intHandler.fprint := intHandlerFP;
DevCPC486.intHandler.fpdone := TRUE;
DevCPT.GlbMod[DevCPT.nofGmod] := DevCPT.topScope;
INC(DevCPT.nofGmod);
DevCPT.CloseScope;
END
END GetComKernel;
PROCEDURE EnumTProcs(rec: DevCPT.Struct); (* method numbers in declaration order *)
VAR btyp: DevCPT.Struct; obj, redef: DevCPT.Object;
BEGIN
IF rec.n = -1 THEN
rec.n := 0; btyp := rec.BaseTyp;
IF btyp # NIL THEN
EnumTProcs(btyp); rec.n := btyp.n;
END;
obj := rec.strobj.link;
WHILE obj # NIL DO
DevCPT.FindBaseField(obj.name^, rec, redef);
IF redef # NIL THEN obj.num := redef.num (*mthno*);
IF ~(isRedef IN obj.conval.setval) OR (redef.conval.setval * {extAttr, absAttr, empAttr} = {}) THEN
DevCPM.Mark(119, rec.txtpos)
END
ELSE obj.num := rec.n; INC(rec.n)
END ;
IF obj.conval.setval * {hasBody, absAttr, empAttr} = {} THEN DevCPM.Mark(129, obj.adr) END;
obj := obj.nlink
END
END
END EnumTProcs;
PROCEDURE CountTProcs(rec: DevCPT.Struct);
VAR btyp: DevCPT.Struct; comProc: INTEGER; m, rel: DevCPT.Object; name: DevCPT.Name;
PROCEDURE TProcs(obj: DevCPT.Object); (* obj.mnolev = 0, TProcs of base type already counted *)
VAR redef: DevCPT.Object;
BEGIN
IF obj # NIL THEN
TProcs(obj.left);
IF obj.mode = TProc THEN
DevCPT.FindBaseField(obj.name^, rec, redef);
(* obj.adr := 0 *)
IF redef # NIL THEN
obj.num := redef.num (*mthno*);
IF (redef.link # NIL) & (redef.link.typ.sysflag = interface) THEN
obj.num := numPreIntProc + comProc - 1 - obj.num
END;
IF ~(isRedef IN obj.conval.setval) OR (redef.conval.setval * {extAttr, absAttr, empAttr} = {}) THEN
DevCPM.Mark(119, rec.txtpos)
END
ELSE obj.num := rec.n; INC(rec.n)
END ;
IF obj.conval.setval * {hasBody, absAttr, empAttr} = {} THEN DevCPM.Mark(129, obj.adr) END
END ;
TProcs(obj.right)
END
END TProcs;
BEGIN
IF rec.n = -1 THEN
comProc := 0;
IF rec.untagged THEN rec.n := 0 ELSE rec.n := DevCPT.anytyp.n END;
btyp := rec.BaseTyp;
IF btyp # NIL THEN
IF btyp.sysflag = interface THEN
EnumTProcs(btyp); rec.n := btyp.n + numPreIntProc; comProc := btyp.n;
ELSE
CountTProcs(btyp); rec.n := btyp.n
END
END;
WHILE (btyp # NIL) & (btyp # DevCPT.undftyp) & (btyp.sysflag # interface) DO btyp := btyp.BaseTyp END;
IF (btyp # NIL) & (btyp.sysflag = interface) THEN
IF comProc > 0 THEN
name := "QueryInterface"; DevCPT.FindField(name, rec, m);
IF m.link.typ.sysflag = interface THEN
DevCPT.InsertField(name, rec, m); m.mode := TProc; m.typ := rec;
m.conval := DevCPT.NewConst(); m.conval.setval := {isRedef, hasBody, isCallback, extAttr};
m.nlink := query; query := m
END;
name := "AddRef";
DevCPT.InsertField(name, rec, m); m.mode := TProc; m.mnolev := 0;
m.conval := DevCPT.NewConst(); m.conval.setval := {isRedef, hasBody, isCallback, isHidden, extAttr};
GetComKernel; addRef.used := TRUE; m.adr := -1; m.nlink := addRef;
END;
name := "RELEASE";
DevCPT.FindField(name, rec, rel);
IF (rel # NIL) & (rel.link.typ = DevCPT.anyptrtyp) THEN rel := NIL END;
IF (comProc > 0) OR (rel # NIL) THEN
name := "Release";
DevCPT.InsertField(name, rec, m); m.mode := TProc; m.mnolev := 0;
m.conval := DevCPT.NewConst(); m.conval.setval := {isRedef, hasBody, isCallback, isHidden, extAttr};
GetComKernel; m.adr := -1;
IF rel # NIL THEN release2.used := TRUE; m.nlink := release2
ELSE release.used := TRUE; m.nlink := release
END
END
END;
TProcs(rec.link);
END
END CountTProcs;
PROCEDURE ^Parameters(firstPar, proc: DevCPT.Object);
PROCEDURE ^TProcedures(obj: DevCPT.Object);
PROCEDURE TypeAlloc(typ: DevCPT.Struct);
VAR f, c: SHORTINT; fld: DevCPT.Object; btyp: DevCPT.Struct;
BEGIN
IF ~typ.allocated THEN (* not imported, not predefined, not allocated yet *)
typ.allocated := TRUE;
TypeSize(typ);
f := typ.form; c := typ.comp; btyp := typ.BaseTyp;
IF c = Record THEN
IF typ.sysflag = interface THEN
EnumTProcs(typ);
ELSE
CountTProcs(typ)
END;
IF typ.extlev > 14 THEN DevCPM.Mark(233, typ.txtpos) END;
IF btyp # NIL THEN TypeAlloc(btyp) END;
IF ~typ.untagged THEN DevCPE.AllocTypDesc(typ) END;
fld := typ.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
TypeAlloc(fld.typ); fld := fld.link
END;
TProcedures(typ.link)
ELSIF f = Pointer THEN
IF btyp = DevCPT.undftyp THEN DevCPM.Mark(128, typ.txtpos)
ELSE TypeAlloc(btyp);
END
ELSIF f = ProcTyp THEN
TypeAlloc(btyp);
Parameters(typ.link, NIL)
ELSE (* c IN {Array, DynArr} *)
TypeAlloc(btyp);
IF (btyp.comp = DynArr) & btyp.untagged & ~typ.untagged THEN DevCPM.Mark(225, typ.txtpos) END;
END
END
END TypeAlloc;
PROCEDURE NumOfIntProc (typ: DevCPT.Struct): INTEGER;
BEGIN
WHILE (typ # NIL) & (typ.sysflag # interface) DO typ := typ.BaseTyp END;
IF typ # NIL THEN RETURN typ.n
ELSE RETURN 0
END
END NumOfIntProc;
PROCEDURE Parameters(firstPar, proc: DevCPT.Object);
(* firstPar.mnolev = 0 *)
VAR par: DevCPT.Object; typ: DevCPT.Struct; padr, vadr: INTEGER;
BEGIN
padr := ParOff; par := firstPar;
WHILE par # NIL DO
typ := par.typ; TypeAlloc(typ);
par.adr := padr;
IF (par.mode = VarPar) & (typ.comp # DynArr) THEN
IF (typ.comp = Record) & ~typ.untagged THEN INC(padr, 8)
ELSE INC(padr, 4)
END
ELSE
IF (par.mode = Var) & (typ.comp = DynArr) & typ.untagged THEN DevCPM.err(145) END;
INC(padr, typ.size); Align(padr, 4)
END;
par := par.link
END;
IF proc # NIL THEN
IF proc.mode = XProc THEN
INCL(proc.conval.setval, isCallback)
ELSIF (proc.mode = TProc)
& (proc.num >= numPreIntProc)
& (proc.num < numPreIntProc + NumOfIntProc(proc.link.typ))
THEN
INCL(proc.conval.setval, isCallback);
INCL(proc.conval.setval, isGuarded)
END;
IF proc.sysflag = guarded THEN INCL(proc.conval.setval, isGuarded) END;
IF isGuarded IN proc.conval.setval THEN
GetComKernel; vadr := -24
ELSE
vadr := 0;
IF imVar IN proc.conval.setval THEN DEC(vadr, 4) END;
IF isCallback IN proc.conval.setval THEN DEC(vadr, 8) END
END;
proc.conval.intval := padr; proc.conval.intval2 := vadr;
END
END Parameters;
PROCEDURE Variables(var: DevCPT.Object; VAR varSize: INTEGER);
(* allocates only offsets, regs allocated in DevCPC486.Enter *)
VAR adr: INTEGER; typ: DevCPT.Struct;
BEGIN
adr := varSize;
WHILE var # NIL DO
typ := var.typ; TypeAlloc(typ);
DEC(adr, typ.size); NegAlign(adr, Base(typ, 4));
var.adr := adr;
var := var.link
END;
NegAlign(adr, 4); varSize := adr
END Variables;
PROCEDURE ^Objects(obj: DevCPT.Object);
PROCEDURE Procedure(obj: DevCPT.Object);
(* obj.mnolev = 0 *)
VAR oldPos: INTEGER;
BEGIN
oldPos := DevCPM.errpos; DevCPM.errpos := obj.scope.adr;
TypeAlloc(obj.typ);
Parameters(obj.link, obj);
IF ~(hasBody IN obj.conval.setval) THEN DevCPM.Mark(129, obj.adr) END ;
Variables(obj.scope.scope, obj.conval.intval2); (* local variables *)
Objects(obj.scope.right);
DevCPM.errpos := oldPos
END Procedure;
PROCEDURE TProcedures(obj: DevCPT.Object);
(* obj.mnolev = 0 *)
VAR par: DevCPT.Object; psize: INTEGER;
BEGIN
IF obj # NIL THEN
TProcedures(obj.left);
IF (obj.mode = TProc) & (obj.scope # NIL) THEN
TypeAlloc(obj.typ);
Parameters(obj.link, obj);
Variables(obj.scope.scope, obj.conval.intval2); (* local variables *)
Objects(obj.scope.right);
END ;
TProcedures(obj.right)
END
END TProcedures;
PROCEDURE Objects(obj: DevCPT.Object);
BEGIN
IF obj # NIL THEN
Objects(obj.left);
IF obj.mode IN {Con, Typ, LProc, XProc, CProc, IProc} THEN
IF (obj.mode IN {Con, Typ}) THEN TypeAlloc(obj.typ);
ELSE Procedure(obj)
END
END ;
Objects(obj.right)
END
END Objects;
PROCEDURE Allocate*;
VAR gvarSize: INTEGER; name: DevCPT.Name;
BEGIN
DevCPM.errpos := DevCPT.topScope.adr; (* text position of scope used if error *)
gvarSize := 0;
Variables(DevCPT.topScope.scope, gvarSize); DevCPE.dsize := -gvarSize;
Objects(DevCPT.topScope.right)
END Allocate;
(************************)
PROCEDURE SameExp (n1, n2: DevCPT.Node): BOOLEAN;
BEGIN
WHILE (n1.class = n2.class) & (n1.typ = n2.typ) DO
CASE n1.class OF
| Nvar, Nvarpar, Nproc: RETURN n1.obj = n2.obj
| Nconst: RETURN (n1.typ.form IN {Int8..Int32}) & (n1.conval.intval = n2.conval.intval)
| Nfield: IF n1.obj # n2.obj THEN RETURN FALSE END
| Nderef, Nguard:
| Nindex: IF ~SameExp(n1.right, n2.right) THEN RETURN FALSE END
| Nmop: IF (n1.subcl # n2.subcl) OR (n1.subcl = is) THEN RETURN FALSE END
| Ndop: IF (n1.subcl # n2.subcl) OR ~SameExp(n1.right, n2.right) THEN RETURN FALSE END
ELSE RETURN FALSE
END ;
n1 := n1.left; n2 := n2.left
END;
RETURN FALSE
END SameExp;
PROCEDURE Check (n: DevCPT.Node; VAR used: SET; VAR size: INTEGER);
VAR ux, uy: SET; sx, sy, sf: INTEGER; f: BYTE;
BEGIN
used := {}; size := 0;
WHILE n # NIL DO
IF n.class # Ncomp THEN
Check(n.left, ux, sx);
Check(n.right, uy, sy)
END;
ux := ux + uy; sf := 0;
CASE n.class OF
| Nvar, Nvarpar:
IF (n.class = Nvarpar) OR (n.typ.comp = DynArr) OR
(n.obj.mnolev > 0) &
(DevCPC486.imLevel[n.obj.mnolev] < DevCPC486.imLevel[DevCPL486.level]) THEN sf := 1 END
| Nguard: sf := 2
| Neguard, Nderef: sf := 1
| Nindex:
IF (n.right.class # Nconst) OR (n.left.typ.comp = DynArr) THEN sf := 1 END;
IF sx > 0 THEN INC(sy) END
| Nmop:
CASE n.subcl OF
| is, adr, typfn, minus, abs, cap, val: sf := 1
| bit: sf := 2; INCL(ux, CX)
| conv:
IF n.typ.form = Int64 THEN sf := 2
ELSIF ~(n.typ.form IN realSet) THEN sf := 1;
IF n.left.typ.form IN realSet THEN INCL(ux, AX) END
END
| odd, cc, not:
END
| Ndop:
f := n.left.typ.form;
IF f # Bool THEN
CASE n.subcl OF
| times:
sf := 1;
IF f = Int8 THEN INCL(ux, AX) END
| div, mod:
sf := 3; INCL(ux, AX);
IF f > Int8 THEN INCL(ux, DX) END
| eql..geq:
IF f IN {String8, String16, Comp} THEN ux := ux + {AX, CX, SI, DI}; sf := 4
ELSIF f IN realSet THEN INCL(ux, AX); sf := 1
ELSE sf := 1
END
| ash, lsh, rot:
IF n.right.class = Nconst THEN sf := 1 ELSE sf := 2; INCL(ux, CX) END
| slash, plus, minus, msk, in, bit:
sf := 1
| len:
IF f IN {String8, String16} THEN ux := ux + {AX, CX, DI}; sf := 3
ELSE sf := 1
END
| min, max:
sf := 1;
IF f IN realSet THEN INCL(ux, AX) END
| queryfn:
ux := ux + {CX, SI, DI}; sf := 4
END;
IF sy > sx THEN INC(sx) ELSE INC(sy) END
END
| Nupto:
IF (n.right.class = Nconst) OR (n.left.class = Nconst) THEN sf := 2
ELSE sf := 3
END;
INCL(ux, CX); INC(sx)
| Ncall, Ncomp:
sf := 10; ux := wreg + {float}
| Nfield, Nconst, Nproc, Ntype:
END;
used := used + ux;
IF sx > size THEN size := sx END;
IF sy > size THEN size := sy END;
IF sf > size THEN size := sf END;
n := n.link
END;
IF size > 10 THEN size := 10 END
END Check;
PROCEDURE^ expr (n: DevCPT.Node; VAR x: DevCPL486.Item; hint, stop: SET);
PROCEDURE DualExp (left, right: DevCPT.Node; VAR x, y: DevCPL486.Item; hx, hy, stpx, stpy: SET);
VAR ux, uy: SET; sx, sy: INTEGER;
BEGIN
Check(left, ux, sx); Check(right, uy, sy);
IF sy > sx THEN
expr(right, y, hy + stpy, ux + stpy * {AX, CX});
expr(left, x, hx, stpx);
DevCPC486.Assert(y, hy, stpy)
ELSE
expr(left, x, hx + stpx, uy);
expr(right, y, hy, stpy);
DevCPC486.Assert(x, hx, stpx)
END;
END DualExp;
PROCEDURE IntDOp (n: DevCPT.Node; VAR x: DevCPL486.Item; hint: SET);
VAR y: DevCPL486.Item; rev: BOOLEAN;
BEGIN
DualExp(n.left, n.right, x, y, hint, hint, {stk}, {stk});
IF (x.mode = Reg) & DevCPC486.Fits(x, hint) THEN
DevCPC486.IntDOp(x, y, n.subcl, FALSE)
ELSIF (y.mode = Reg) & DevCPC486.Fits(y, hint) THEN
DevCPC486.IntDOp(y, x, n.subcl, TRUE); x := y
ELSIF x.mode # Reg THEN
DevCPC486.Load(x, hint, {con}); DevCPC486.IntDOp(x, y, n.subcl, FALSE)
ELSIF y.mode # Reg THEN
DevCPC486.Load(y, hint, {con}); DevCPC486.IntDOp(y, x, n.subcl, TRUE); x := y
ELSE
DevCPC486.IntDOp(x, y, n.subcl, FALSE)
END
END IntDOp;
PROCEDURE FloatDOp (n: DevCPT.Node; VAR x: DevCPL486.Item);
VAR y: DevCPL486.Item; ux, uy, uf: SET; sx, sy: INTEGER;
BEGIN
Check(n.left, ux, sx); Check(n.right, uy, sy);
IF (n.subcl = min) OR (n.subcl = max) THEN uf := {AX} ELSE uf := {} END;
IF (sy > sx) OR (sy = sx) & ((n.subcl = mod) OR (n.subcl = ash)) THEN
expr(n.right, x, {}, ux + {mem, stk});
expr(n.left, y, {}, uf);
DevCPC486.FloatDOp(x, y, n.subcl, TRUE)
ELSIF float IN uy THEN (* function calls in both operands *)
expr(n.left, y, {}, uy + {mem});
expr(n.right, x, {}, {mem, stk});
DevCPC486.FloatDOp(x, y, n.subcl, TRUE)
ELSE
expr(n.left, x, {}, uy + {mem, stk});
expr(n.right, y, {}, uf);
DevCPC486.FloatDOp(x, y, n.subcl, FALSE)
END
END FloatDOp;
PROCEDURE design (n: DevCPT.Node; VAR x: DevCPL486.Item; hint, stop: SET);
VAR obj: DevCPT.Object; y: DevCPL486.Item; ux, uy: SET; sx, sy: INTEGER;
BEGIN
CASE n.class OF
Nvar, Nvarpar:
obj := n.obj; x.mode := obj.mode; x.obj := obj; x.scale := 0;
IF obj.typ.comp = DynArr THEN x.mode := VarPar END;
IF obj.mnolev < 0 THEN x.offset := 0; x.tmode := Con
ELSIF x.mode = Var THEN x.offset := obj.adr; x.tmode := Con
ELSE x.offset := 0; x.tmode := VarPar
END
| Nfield:
design(n.left, x, hint, stop); DevCPC486.Field(x, n.obj)
| Nderef:
IF n.subcl # 0 THEN
expr(n.left, x, hint, stop);
IF n.typ.form = String8 THEN x.form := VString8 ELSE x.form := VString16 END
ELSE
expr(n.left, x, hint, stop + {mem} - {loaded}); DevCPC486.DeRef(x)
END
| Nindex:
Check(n.left, ux, sx); Check(n.right, uy, sy);
IF wreg - uy = {} THEN
expr(n.right, y, hint + stop, ux);
design(n.left, x, hint, stop);
IF x.scale # 0 THEN DevCPC486.Index(x, y, {}, {}) ELSE DevCPC486.Index(x, y, hint, stop) END
ELSE
design(n.left, x, hint, stop + uy);
IF x.scale # 0 THEN expr(n.right, y, {}, {}); DevCPC486.Index(x, y, {}, {})
ELSE expr(n.right, y, hint, stop); DevCPC486.Index(x, y, hint, stop)
END
END
| Nguard, Neguard:
IF n.typ.form = Pointer THEN
IF loaded IN stop THEN expr(n.left, x, hint, stop) ELSE expr(n.left, x, hint, stop + {mem}) END
ELSE design(n.left, x, hint, stop)
END;
DevCPC486.TypTest(x, n.typ, TRUE, n.class = Neguard)
| Nproc:
obj := n.obj; x.mode := obj.mode; x.obj := obj;
IF x.mode = TProc THEN x.offset := obj.num; (*mthno*) x.scale := n.subcl (* super *) END
END;
x.typ := n.typ
END design;
PROCEDURE IsAllocDynArr (x: DevCPT.Node): BOOLEAN;
BEGIN
IF (x.typ.comp = DynArr) & ~x.typ.untagged THEN
WHILE x.class = Nindex DO x := x.left END;
IF x.class = Nderef THEN RETURN TRUE END
END;
RETURN FALSE
END IsAllocDynArr;
PROCEDURE StringOp (left, right: DevCPT.Node; VAR x, y: DevCPL486.Item; useLen: BOOLEAN);
VAR ax, ay: DevCPL486.Item; ux: SET; sx: INTEGER;
BEGIN
Check(left, ux, sx);
expr(right, y, wreg - {SI} + ux, {});
ay := y; DevCPC486.GetAdr(ay, wreg - {SI} + ux, {}); DevCPC486.Assert(ay, wreg - {SI}, ux);
IF useLen & IsAllocDynArr(left) THEN (* keep len descriptor *)
design(left, x, wreg - {CX}, {loaded});
DevCPC486.Prepare(x, wreg - {CX} + {deref}, {DI})
ELSE
expr(left, x, wreg - {DI}, {})
END;
ax := x; DevCPC486.GetAdr(ax, {}, wreg - {DI} + {stk, con});
DevCPC486.Load(ay, {}, wreg - {SI} + {con});
DevCPC486.Free(ax); DevCPC486.Free(ay)
END StringOp;
PROCEDURE AdrExpr (n: DevCPT.Node; VAR x: DevCPL486.Item; hint, stop: SET);
BEGIN
IF n.class < Nconst THEN
design(n, x, hint + stop, {loaded}); DevCPC486.Prepare(x, hint + {deref}, stop)
ELSE expr(n, x, hint, stop)
END
END AdrExpr;
(* ---------- interface pointer reference counting ---------- *)
PROCEDURE HandleIPtrs (typ: DevCPT.Struct; VAR x, y: DevCPL486.Item; add, rel, init: BOOLEAN);
PROCEDURE FindPtrs (typ: DevCPT.Struct; adr: INTEGER);
VAR fld: DevCPT.Object; btyp: DevCPT.Struct; i, n: INTEGER;
BEGIN
IF (typ.form = Pointer) & (typ.sysflag = interface) THEN
IF add THEN DevCPC486.IPAddRef(y, adr, TRUE) END;
IF rel THEN DevCPC486.IPRelease(x, adr, TRUE, init) END
ELSIF (typ.comp = Record) & (typ.sysflag # union) THEN
btyp := typ.BaseTyp;
IF btyp # NIL THEN FindPtrs(btyp, adr) END ;
fld := typ.link;
WHILE (fld # NIL) & (fld.mode = Fld) DO
IF (fld.sysflag = interface) & (fld.name^ = DevCPM.HdUtPtrName) THEN
IF add THEN DevCPC486.IPAddRef(y, fld.adr + adr, TRUE) END;
IF rel THEN DevCPC486.IPRelease(x, fld.adr + adr, TRUE, init) END
ELSE FindPtrs(fld.typ, fld.adr + adr)
END;
fld := fld.link
END
ELSIF typ.comp = Array THEN
btyp := typ.BaseTyp; n := typ.n;
WHILE btyp.comp = Array DO n := btyp.n * n; btyp := btyp.BaseTyp END ;
IF DevCPC486.ContainsIPtrs(btyp) THEN
i := 0;
WHILE i < n DO FindPtrs(btyp, adr); INC(adr, btyp.size); INC(i) END
END
ELSIF typ.comp = DynArr THEN
IF DevCPC486.ContainsIPtrs(typ) THEN DevCPM.err(221) END
END
END FindPtrs;
BEGIN
FindPtrs(typ, 0)
END HandleIPtrs;
PROCEDURE CountedPtr (n: DevCPT.Node): BOOLEAN;
BEGIN
RETURN (n.typ.form = Pointer) & (n.typ.sysflag = interface)
& ((n.class = Ncall) OR (n.class = Ncomp) & (n.right.class = Ncall))
END CountedPtr;
PROCEDURE IPAssign (nx, ny: DevCPT.Node; VAR x, y: DevCPL486.Item; ux: SET);
(* nx.typ.form = Pointer & nx.typ.sysflag = interface *)
BEGIN
expr(ny, y, {}, wreg - {SI} + {mem, stk});
IF (ny.class # Nconst) & ~CountedPtr(ny) THEN
DevCPC486.IPAddRef(y, 0, TRUE)
END;
IF nx # NIL THEN
DevCPC486.Assert(y, {}, wreg - {SI} + ux);
expr(nx, x, wreg - {DI}, {loaded});
IF (x.mode = Ind) & (x.reg IN wreg - {SI, DI}) OR (x.scale # 0) THEN
DevCPC486.GetAdr(x, {}, wreg - {DI} + {con});
x.mode := Ind; x.offset := 0; x.scale := 0
END;
DevCPC486.IPRelease(x, 0, TRUE, FALSE);
END
END IPAssign;
PROCEDURE IPStructAssign (typ: DevCPT.Struct);
VAR x, y: DevCPL486.Item;
BEGIN
IF typ.comp = DynArr THEN DevCPM.err(270) END;
(* addresses in SI and DI *)
x.mode := Ind; x.reg := DI; x.offset := 0; x.scale := 0;
y.mode := Ind; y.reg := SI; y.offset := 0; y.scale := 0;
HandleIPtrs(typ, x, y, TRUE, TRUE, FALSE)
END IPStructAssign;
PROCEDURE IPFree (nx: DevCPT.Node; VAR x: DevCPL486.Item);
BEGIN
expr(nx, x, wreg - {DI}, {loaded}); DevCPC486.GetAdr(x, {}, wreg - {DI} + {con});
x.mode := Ind; x.offset := 0; x.scale := 0;
IF nx.typ.form = Comp THEN
HandleIPtrs(nx.typ, x, x, FALSE, TRUE, TRUE)
ELSE (* nx.typ.form = Pointer & nx.typ.sysflag = interface *)
DevCPC486.IPRelease(x, 0, TRUE, TRUE);
END
END IPFree;
(* unchanged val parameters allways counted because of aliasing problems REMOVED! *)
PROCEDURE InitializeIPVars (proc: DevCPT.Object);
VAR x: DevCPL486.Item; obj: DevCPT.Object;
BEGIN
x.mode := Ind; x.reg := BP; x.scale := 0; x.form := Pointer;
obj := proc.link;
WHILE obj # NIL DO
IF (obj.mode = Var) & obj.used THEN (* changed value parameters *)
x.offset := obj.adr;
HandleIPtrs(obj.typ, x, x, TRUE, FALSE, FALSE)
END;
obj := obj.link
END
END InitializeIPVars;
PROCEDURE ReleaseIPVars (proc: DevCPT.Object);
VAR x, ax, dx, si, di: DevCPL486.Item; obj: DevCPT.Object;
BEGIN
obj := proc.link;
WHILE (obj # NIL) & ((obj.mode # Var) OR ~obj.used OR ~DevCPC486.ContainsIPtrs(obj.typ)) DO
obj := obj.link
END;
IF obj = NIL THEN
obj := proc.scope.scope;
WHILE (obj # NIL) & ~DevCPC486.ContainsIPtrs(obj.typ) DO obj := obj.link END;
IF obj = NIL THEN RETURN END
END;
DevCPL486.MakeReg(ax, AX, Int32); DevCPL486.MakeReg(si, SI, Int32);
DevCPL486.MakeReg(dx, DX, Int32); DevCPL486.MakeReg(di, DI, Int32);
IF ~(proc.typ.form IN {Real32, Real64, NoTyp}) THEN DevCPL486.GenMove(ax, si) END;
IF proc.typ.form = Int64 THEN DevCPL486.GenMove(dx, di) END;
x.mode := Ind; x.reg := BP; x.scale := 0; x.form := Pointer;
obj := proc.link;
WHILE obj # NIL DO
IF (obj.mode = Var) & obj.used THEN (* value parameters *)
x.offset := obj.adr;
HandleIPtrs(obj.typ, x, x, FALSE, TRUE, FALSE)
END;
obj := obj.link
END;
obj := proc.scope.scope;
WHILE obj # NIL DO (* local variables *)
IF obj.used THEN
x.offset := obj.adr;
HandleIPtrs(obj.typ, x, x, FALSE, TRUE, FALSE);
END;
obj := obj.link
END;
IF ~(proc.typ.form IN {Real32, Real64, NoTyp}) THEN DevCPL486.GenMove(si, ax) END;
IF proc.typ.form = Int64 THEN DevCPL486.GenMove(di, dx) END
END ReleaseIPVars;
PROCEDURE CompareIntTypes (
typ: DevCPT.Struct; VAR id: DevCPL486.Item; VAR exit: DevCPL486.Label; VAR num: INTEGER
);
VAR x, y: DevCPL486.Item; local: DevCPL486.Label;
BEGIN
local := DevCPL486.NewLbl;
typ := typ.BaseTyp; num := 0;
WHILE (typ # NIL) & (typ # DevCPT.undftyp) DO
IF (typ.sysflag = interface) & (typ.ext # NIL) THEN
IF num > 0 THEN DevCPC486.JumpT(x, local) END;
DevCPC486.GuidFromString(typ.ext, y);
x := id; DevCPC486.GetAdr(x, wreg - {SI}, {mem});
x := y; DevCPC486.GetAdr(x, wreg - {DI}, {});
x := id; DevCPC486.CmpString(x, y, eql, FALSE);
INC(num)
END;
typ := typ.BaseTyp
END;
IF num > 0 THEN DevCPC486.JumpF(x, exit) END;
IF num > 1 THEN DevCPL486.SetLabel(local) END
END CompareIntTypes;
PROCEDURE InstallQueryInterface (typ: DevCPT.Struct; proc: DevCPT.Object);
VAR this, id, int, unk, c: DevCPL486.Item; nil, end: DevCPL486.Label; num: INTEGER;
BEGIN
nil := DevCPL486.NewLbl; end := DevCPL486.NewLbl;
this.mode := Ind; this.reg := BP; this.offset := 8; this.scale := 0; this.form := Pointer; this.typ := DevCPT.anyptrtyp;
id.mode := DInd; id.reg := BP; id.offset := 12; id.scale := 0; id.form := Pointer;
int.mode := DInd; int.reg := BP; int.offset := 16; int.scale := 0; int.form := Pointer;
DevCPC486.GetAdr(int, {}, {AX, CX, SI, DI, mem}); int.mode := Ind; int.offset := 0;
DevCPL486.MakeConst(c, 0, Pointer); DevCPC486.Assign(int, c);
unk.mode := Ind; unk.reg := BP; unk.offset := 8; unk.scale := 0; unk.form := Pointer; unk.typ := DevCPT.punktyp;
DevCPC486.Load(unk, {}, {});
unk.mode := Ind; unk.offset := 8;
DevCPC486.Load(unk, {}, {});
DevCPL486.GenComp(c, unk);
DevCPL486.GenJump(4, nil, TRUE);
DevCPL486.MakeReg(c, int.reg, Pointer);
DevCPL486.GenPush(c);
c.mode := Ind; c.reg := BP; c.offset := 12; c.scale := 0; c.form := Pointer;
DevCPL486.GenPush(c);
DevCPL486.GenPush(unk);
c.mode := Ind; c.reg := unk.reg; c.offset := 0; c.scale := 0; c.form := Pointer;
DevCPL486.GenMove(c, unk);
unk.mode := Ind; unk.offset := 0; unk.scale := 0; unk.form := Pointer;
DevCPL486.GenCall(unk);
DevCPC486.Free(unk);
DevCPL486.GenJump(-1, end, FALSE);
DevCPL486.SetLabel(nil);
DevCPL486.MakeConst(c, 80004002H, Int32); (* E_NOINTERFACE *)
DevCPC486.Result(proc, c);
CompareIntTypes(typ, id, end, num);
IF num > 0 THEN
DevCPC486.Load(this, {}, {});
DevCPC486.Assign(int, this);
DevCPC486.IPAddRef(this, 0, FALSE);
DevCPL486.MakeConst(c, 0, Int32); (* S_OK *)
DevCPC486.Result(proc, c);
END;
DevCPL486.SetLabel(end)
END InstallQueryInterface;
(* -------------------- *)
PROCEDURE ActualPar (n: DevCPT.Node; fp: DevCPT.Object; rec: BOOLEAN; VAR tag: DevCPL486.Item);
VAR ap: DevCPL486.Item; x: DevCPT.Node; niltest: BOOLEAN;
BEGIN
IF n # NIL THEN
ActualPar(n.link, fp.link, FALSE, ap);
niltest := FALSE;
IF fp.mode = VarPar THEN
IF (n.class = Ndop) & ((n.subcl = thisarrfn) OR (n.subcl = thisrecfn)) THEN
expr(n.right, ap, {}, {}); DevCPC486.Push(ap); (* push type/length *)
expr(n.left, ap, {}, {}); DevCPC486.Push(ap); (* push adr *)
RETURN
ELSIF (fp.vis = outPar) & DevCPC486.ContainsIPtrs(fp.typ) & (ap.typ # DevCPT.niltyp) THEN
IPFree(n, ap)
ELSE
x := n;
WHILE (x.class = Nfield) OR (x.class = Nindex) DO x := x.left END;
niltest := x.class = Nderef; (* explicit nil test needed *)
AdrExpr(n, ap, {}, {})
END
ELSIF (n.class = Nmop) & (n.subcl = conv) THEN
IF n.typ.form IN {String8, String16} THEN expr(n, ap, {}, {}); DevCPM.err(265)
ELSIF (DevCPT.Includes(n.typ.form, n.left.typ.form) OR DevCPT.Includes(n.typ.form, fp.typ.form))
& (n.typ.form # Set) & (fp.typ # DevCPT.bytetyp) THEN expr(n.left, ap, {}, {high});
ELSE expr(n, ap, {}, {high});
END
ELSE expr(n, ap, {}, {high});
IF CountedPtr(n) THEN DevCPM.err(270) END
END;
DevCPC486.Param(fp, rec, niltest, ap, tag)
END
END ActualPar;
PROCEDURE Call (n: DevCPT.Node; VAR x: DevCPL486.Item);
VAR tag: DevCPL486.Item; proc: DevCPT.Object; m: BYTE;
BEGIN
IF n.left.class = Nproc THEN
proc := n.left.obj; m := proc.mode;
ELSE proc := NIL; m := 0
END;
IF (m = CProc) & (n.right # NIL) THEN
ActualPar(n.right.link, n.obj.link, FALSE, tag);
expr(n.right, tag, wreg - {AX}, {}); (* tag = first param *)
ELSE
IF proc # NIL THEN DevCPC486.PrepCall(proc) END;
ActualPar(n.right, n.obj, (m = TProc) & (n.left.subcl = 0), tag);
END;
IF proc # NIL THEN design(n.left, x, {}, {}) ELSE expr(n.left, x, {}, {}) END;
DevCPC486.Call(x, tag)
END Call;
PROCEDURE Mem (n: DevCPT.Node; VAR x: DevCPL486.Item; typ: DevCPT.Struct; hint, stop: SET);
VAR offset: INTEGER;
BEGIN
IF (n.class = Ndop) & (n.subcl IN {plus, minus}) & (n.right.class = Nconst) THEN
expr(n.left, x, hint, stop + {mem}); offset := n.right.conval.intval;
IF n.subcl = minus THEN offset := -offset END
ELSE
expr(n, x, hint, stop + {mem}); offset := 0
END;
DevCPC486.Mem(x, offset, typ)
END Mem;
PROCEDURE^ CompStat (n: DevCPT.Node);
PROCEDURE^ CompRelease (n: DevCPT.Node; VAR res: DevCPL486.Item);
PROCEDURE condition (n: DevCPT.Node; VAR x: DevCPL486.Item; VAR false, true: DevCPL486.Label);
VAR local: DevCPL486.Label; y, z: DevCPL486.Item; ux: SET; sx, num: INTEGER; f: BYTE; typ: DevCPT.Struct;
BEGIN
IF n.class = Nmop THEN
CASE n.subcl OF
not: condition(n.left, x, true, false); DevCPC486.Not(x)
| is: IF n.left.typ.form = Pointer THEN expr(n.left, x, {}, {mem})
ELSE design(n.left, x, {}, {})
END;
DevCPC486.TypTest(x, n.obj.typ, FALSE, FALSE)
| odd: expr(n.left, x, {}, {}); DevCPC486.Odd(x)
| cc: expr(n.left, x, {}, {}); x.mode := Cond; x.form := Bool
| val: DevCPM.err(220)
END
ELSIF n.class = Ndop THEN
CASE n.subcl OF
and: local := DevCPL486.NewLbl; condition(n.left, y, false, local);
DevCPC486.JumpF(y, false);
IF local # DevCPL486.NewLbl THEN DevCPL486.SetLabel(local) END;
condition(n.right, x, false, true)
| or: local := DevCPL486.NewLbl; condition(n.left, y, local, true);
DevCPC486.JumpT(y, true);
IF local # DevCPL486.NewLbl THEN DevCPL486.SetLabel(local) END;
condition(n.right, x, false, true)
| eql..geq:
f := n.left.typ.form;
IF f = Int64 THEN DevCPM.err(260)
ELSIF f IN {String8, String16, Comp} THEN
IF (n.left.class = Nmop) & (n.left.subcl = conv) THEN (* converted must be source *)
StringOp(n.right, n.left, x, y, FALSE); DevCPC486.CmpString(x, y, n.subcl, TRUE)
ELSE
StringOp(n.left, n.right, x, y, FALSE); DevCPC486.CmpString(x, y, n.subcl, FALSE)
END
ELSIF f IN {Real32, Real64} THEN FloatDOp(n, x)
ELSE
IF CountedPtr(n.left) OR CountedPtr(n.right) THEN DevCPM.err(270) END;
DualExp(n.left, n.right, x, y, {}, {}, {stk}, {stk});
IF (x.mode = Reg) OR (y.mode = Con) THEN DevCPC486.IntDOp(x, y, n.subcl, FALSE)
ELSIF (y.mode = Reg) OR (x.mode = Con) THEN DevCPC486.IntDOp(y, x, n.subcl, TRUE); x := y
ELSE DevCPC486.Load(x, {}, {}); DevCPC486.IntDOp(x, y, n.subcl, FALSE)
END
END
| in: DualExp(n.left, n.right, x, y, {}, {}, {short, mem, stk}, {con, stk});
DevCPC486.In(x, y)
| bit: Check(n.left, ux, sx);
expr(n.right, x, {}, ux + {short});
Mem(n.left, y, DevCPT.notyp, {}, {});
DevCPC486.Load(x, {}, {short});
DevCPC486.In(x, y)
| queryfn:
AdrExpr(n.right, x, {}, {CX, SI, DI});
CompareIntTypes(n.left.typ, x, false, num);
IF num > 0 THEN
Check(n.right.link, ux, sx); IPAssign(n.right.link, n.left, x, y, ux); DevCPC486.Assign(x, y);
x.offset := 1 (* true *)
ELSE x.offset := 0 (* false *)
END;
x.mode := Con; DevCPC486.MakeCond(x)
END
ELSIF n.class = Ncomp THEN
CompStat(n.left); condition(n.right, x, false, true); CompRelease(n.left, x);
IF x.mode = Stk THEN DevCPL486.GenCode(9DH); (* pop flags *) x.mode := Cond END
ELSE expr(n, x, {}, {}); DevCPC486.MakeCond(x) (* const, var, or call *)
END
END condition;
PROCEDURE expr(n: DevCPT.Node; VAR x: DevCPL486.Item; hint, stop: SET);
VAR y, z: DevCPL486.Item; f, g: BYTE; cval: DevCPT.Const; false, true: DevCPL486.Label;
uy: SET; sy: INTEGER; r: REAL;
BEGIN
f := n.typ.form;
IF (f = Bool) & (n.class IN {Ndop, Nmop}) THEN
false := DevCPL486.NewLbl; true := DevCPL486.NewLbl;
condition(n, y, false, true);
DevCPC486.LoadCond(x, y, false, true, hint, stop + {mem})
ELSE
CASE n.class OF
Nconst:
IF n.obj = NIL THEN cval := n.conval ELSE cval := n.obj.conval END;
CASE f OF
Byte..Int32, NilTyp, Pointer, Char16: DevCPL486.MakeConst(x, cval.intval, f)
| Int64:
DevCPL486.MakeConst(x, cval.intval, f);
DevCPE.GetLongWords(cval, x.scale, x.offset)
| Set: DevCPL486.MakeConst(x, SYSTEM.VAL(INTEGER, cval.setval), Set)
| String8, String16, Real32, Real64: DevCPL486.AllocConst(x, cval, f)
| Comp:
ASSERT(n.typ = DevCPT.guidtyp);
IF n.conval # NIL THEN DevCPC486.GuidFromString(n.conval.ext, x)
ELSE DevCPC486.GuidFromString(n.obj.typ.ext, x)
END
END
| Nupto: (* n.typ = DevCPT.settyp *)
Check(n.right, uy, sy);
expr(n.left, x, {}, wreg - {CX} + {high, mem, stk});
DevCPC486.MakeSet(x, TRUE, FALSE, hint + stop + uy, {});
DevCPC486.Assert(x, {}, uy);
expr(n.right, y, {}, wreg - {CX} + {high, mem, stk});
DevCPC486.MakeSet(y, TRUE, TRUE, hint + stop, {});
DevCPC486.Load(x, hint + stop, {});
IF x.mode = Con THEN DevCPC486.IntDOp(y, x, msk, TRUE); x := y
ELSE DevCPC486.IntDOp(x, y, msk, FALSE)
END
| Nmop:
CASE n.subcl OF
| bit:
expr(n.left, x, {}, wreg - {CX} + {high, mem, stk});
DevCPC486.MakeSet(x, FALSE, FALSE, hint + stop, {})
| conv:
IF f IN {String8, String16} THEN
expr(n.left, x, hint, stop);
IF f = String8 THEN x.form := VString16to8 END (* SHORT *)
ELSE
IF n.left.class = Nconst THEN (* largeint -> longreal *)
ASSERT((n.left.typ.form = Int64) & (f = Real64));
DevCPL486.AllocConst(x, n.left.conval, n.left.typ.form);
ELSE
expr(n.left, x, hint + stop, {high});
END;
DevCPC486.Convert(x, f, -1, hint + stop, {}) (* ??? *)
END
| val:
expr(n.left, x, hint + stop, {high, con}); DevCPC486.Convert(x, f, n.typ.size, hint, stop) (* ??? *)
| adr:
IF n.left.class = Ntype THEN
x.mode := Con; x.offset := 0; x.obj := n.left.obj; x.form := Int32; x.typ := n.left.typ;
ELSE
AdrExpr(n.left, x, hint + stop, {});
END;
DevCPC486.GetAdr(x, hint + stop, {})
| typfn:
IF n.left.class = Ntype THEN
x.mode := Con; x.offset := 0; x.obj := n.left.obj; x.form := Int32; x.typ := n.left.typ;
IF x.obj.typ.untagged THEN DevCPM.err(111) END
ELSE
expr(n.left, x, hint + stop, {});
DevCPC486.Tag(x, y); DevCPC486.Free(x); x := y
END;
DevCPC486.Load(x, hint + stop, {})
| minus, abs, cap:
expr(n.left, x, hint + stop, {mem, stk});
IF f = Int64 THEN DevCPM.err(260)
ELSIF f IN realSet THEN DevCPC486.FloatMOp(x, n.subcl)
ELSE DevCPC486.IntMOp(x, n.subcl)
END
END
| Ndop:
IF (f IN realSet) & (n.subcl # lsh) & (n.subcl # rot) THEN
IF (n.subcl = ash) & (n.right.class = Nconst) & (n.right.conval.realval >= 0) THEN
expr(n.left, x, {}, {mem, stk});
cval := n.right.conval; sy := SHORT(ENTIER(cval.realval)); cval.realval := 1;
WHILE sy > 0 DO cval.realval := cval.realval * 2; DEC(sy) END;
DevCPL486.AllocConst(y, cval, Real32);
DevCPC486.FloatDOp(x, y, times, FALSE)
ELSE FloatDOp(n, x)
END
ELSIF (f = Int64) OR (n.typ = DevCPT.intrealtyp) THEN DevCPM.err(260); expr(n.left, x, {}, {})
ELSE
CASE n.subcl OF
times:
IF f = Int8 THEN
DualExp(n.left, n.right, x, y, {}, {}, wreg - {AX} + {high, mem, stk, con}, {AX, con, stk});
DevCPC486.IntDOp(x, y, times, FALSE)
ELSE IntDOp(n, x, hint + stop)
END
| div, mod:
DualExp(n.left, n.right, x, y, {}, {}, wreg - {AX} + {high, mem, stk, con}, {AX, DX, mem, stk});
DevCPC486.DivMod(x, y, n.subcl = mod)
| plus:
IF n.typ.form IN {String8, String16} THEN DevCPM.err(265); expr(n.left, x, {}, {})
ELSE IntDOp(n, x, hint + stop)
END
| slash, minus, msk, min, max:
IntDOp(n, x, hint + stop)
| ash, lsh, rot:
uy := {}; IF n.right.class # Nconst THEN uy := {CX} END;
DualExp(n^.right, n^.left, y, x, {}, hint + stop, wreg - {CX} + {high, mem, stk}, uy + {con, mem, stk});
DevCPC486.Shift(x, y, n^.subcl)
| len:
IF n.left.typ.form IN {String8, String16} THEN
expr(n.left, x, wreg - {DI} , {}); DevCPC486.GetAdr(x, {}, wreg - {DI} + {con});
DevCPC486.StrLen(x, n.left.typ, FALSE)
ELSE
design(n.left, x, hint + stop, {}); expr(n.right, y, {}, {}); DevCPC486.Len(x, y)
END
END
END
| Ncall:
Call(n, x)
| Ncomp:
CompStat(n.left); expr(n.right, x, hint, stop); CompRelease(n.left, x);
IF x.mode = Stk THEN DevCPC486.Pop(x, x.form, hint, stop) END
ELSE
design(n, x, hint + stop, stop * {loaded}); DevCPC486.Prepare(x, hint + stop, {}) (* ??? *)
END
END;
x.typ := n.typ;
DevCPC486.Assert(x, hint, stop)
END expr;
PROCEDURE AddCopy (n: DevCPT.Node; VAR dest, dadr, len: DevCPL486.Item; last: BOOLEAN);
VAR adr, src: DevCPL486.Item; u: SET; s: INTEGER;
BEGIN
Check(n, u, s);
DevCPC486.Assert(dadr, wreg - {DI}, u + {SI, CX});
IF len.mode # Con THEN DevCPC486.Assert(len, wreg - {CX}, u + {SI, DI}) END;
expr(n, src, wreg - {SI}, {});
adr := src; DevCPC486.GetAdr(adr, {}, wreg - {SI} + {con});
IF len.mode # Con THEN DevCPC486.Load(len, {}, wreg - {CX} + {con}) END;
DevCPC486.Load(dadr, {}, wreg - {DI} + {con});
DevCPC486.AddCopy(dest, src, last)
END AddCopy;
PROCEDURE StringCopy (left, right: DevCPT.Node);
VAR x, y, ax, ay, len: DevCPL486.Item;
BEGIN
IF IsAllocDynArr(left) THEN expr(left, x, wreg - {CX}, {DI}) (* keep len descriptor *)
ELSE expr(left, x, wreg - {DI}, {})
END;
ax := x; DevCPC486.GetAdr(ax, {}, wreg - {DI});
DevCPC486.Free(x); DevCPC486.ArrayLen(x, len, wreg - {CX}, {});
WHILE right.class = Ndop DO
ASSERT(right.subcl = plus);
AddCopy(right.left, x, ax, len, FALSE);
right := right.right
END;
AddCopy(right, x, ax, len, TRUE);
DevCPC486.Free(len)
END StringCopy;
PROCEDURE Checkpc;
BEGIN
DevCPE.OutSourceRef(DevCPM.errpos)
END Checkpc;
PROCEDURE^ stat (n: DevCPT.Node; VAR end: DevCPL486.Label);
PROCEDURE CondStat (if, last: DevCPT.Node; VAR hint: INTEGER; VAR else, end: DevCPL486.Label);
VAR local: DevCPL486.Label; x: DevCPL486.Item; cond, lcond: DevCPT.Node;
BEGIN
local := DevCPL486.NewLbl;
DevCPM.errpos := if.conval.intval; Checkpc; cond := if.left;
IF (last # NIL) & (cond.class = Ndop) & (cond.subcl >= eql) & (cond.subcl <= geq)
& (last.class = Ndop) & (last.subcl >= eql) & (last.subcl <= geq)
& SameExp(cond.left, last.left) & SameExp(cond.right, last.right) THEN (* reuse comparison *)
DevCPC486.setCC(x, cond.subcl, ODD(hint), hint >= 2)
ELSIF (last # NIL) & (cond.class = Nmop) & (cond.subcl = is) & (last.class = Nmop) & (last.subcl = is)
& SameExp(cond.left, last.left) THEN
DevCPC486.ShortTypTest(x, cond.obj.typ) (* !!! *)
ELSE condition(cond, x, else, local)
END;
hint := x.reg;
DevCPC486.JumpF(x, else);
IF local # DevCPL486.NewLbl THEN DevCPL486.SetLabel(local) END;
stat(if.right, end);
END CondStat;
PROCEDURE IfStat (n: DevCPT.Node; withtrap: BOOLEAN; VAR end: DevCPL486.Label);
VAR else, local: DevCPL486.Label; if, last: DevCPT.Node; hint: INTEGER;
BEGIN (* n.class = Nifelse *)
if := n.left; last := NIL;
WHILE (if # NIL) & ((if.link # NIL) OR (n.right # NIL) OR withtrap) DO
else := DevCPL486.NewLbl;
CondStat(if, last, hint, else, end);
IF sequential THEN DevCPC486.Jump(end) END;
DevCPL486.SetLabel(else); last := if.left; if := if.link
END;
IF n.right # NIL THEN stat(n.right, end)
ELSIF withtrap THEN DevCPM.errpos := n.conval.intval; Checkpc; DevCPC486.Trap(withTrap); sequential := FALSE
ELSE CondStat(if, last, hint, end, end)
END
END IfStat;
PROCEDURE CasePart (n: DevCPT.Node; VAR x: DevCPL486.Item; VAR else: DevCPL486.Label; last: BOOLEAN);
VAR this, higher: DevCPL486.Label; m: DevCPT.Node; low, high: INTEGER;
BEGIN
IF n # NIL THEN
this := SHORT(ENTIER(n.conval.realval));
IF useTree IN n.conval.setval THEN
IF n.left # NIL THEN
IF n.right # NIL THEN
higher := DevCPL486.NewLbl;
DevCPC486.CaseJump(x, n.conval.intval, n.conval.intval2, this, higher, TRUE, FALSE);
CasePart(n.left, x, else, FALSE);
DevCPL486.SetLabel(higher);
CasePart(n.right, x, else, last)
ELSE
DevCPC486.CaseJump(x, n.conval.intval, n.conval.intval2, this, else, FALSE, FALSE);
CasePart(n.left, x, else, last);
END
ELSE
DevCPC486.CaseJump(x, n.conval.intval, n.conval.intval2, this, else, FALSE, TRUE);
IF n.right # NIL THEN CasePart(n.right, x, else, last)
ELSIF ~last THEN DevCPC486.Jump(else)
END
END
ELSE
IF useTable IN n.conval.setval THEN
m := n; WHILE m.left # NIL DO m := m.left END; low := m.conval.intval;
m := n; WHILE m.right # NIL DO m := m.right END; high := m.conval.intval2;
DevCPC486.CaseTableJump(x, low, high, else);
actual := low; last := TRUE
END;
CasePart(n.left, x, else, FALSE);
WHILE actual < n.conval.intval DO
DevCPL486.GenCaseEntry(else, FALSE); INC(actual)
END;
WHILE actual < n.conval.intval2 DO
DevCPL486.GenCaseEntry(this, FALSE); INC(actual)
END;
DevCPL486.GenCaseEntry(this, last & (n.right = NIL)); INC(actual);
CasePart(n.right, x, else, last)
END;
n.conval.realval := this
END
END CasePart;
PROCEDURE CaseStat (n: DevCPT.Node; VAR end: DevCPL486.Label);
VAR x: DevCPL486.Item; case, lab: DevCPT.Node; low, high, tab: INTEGER; else, this: DevCPL486.Label;
BEGIN
expr(n.left, x, {}, {mem, con, short}); else := DevCPL486.NewLbl;
IF (n.right.right # NIL) & (n.right.right.class = Ngoto) THEN (* jump to goto optimization *)
CasePart(n.right.link, x, else, FALSE); DevCPC486.Free(x);
n.right.right.right.conval.intval2 := else; sequential := FALSE
ELSE
CasePart(n.right.link, x, else, TRUE); DevCPC486.Free(x);
DevCPL486.SetLabel(else);
IF n.right.conval.setval # {} THEN stat(n.right.right, end)
ELSE DevCPC486.Trap(caseTrap); sequential := FALSE
END
END;
case := n.right.left;
WHILE case # NIL DO (* case.class = Ncasedo *)
IF sequential THEN DevCPC486.Jump(end) END;
lab := case.left;
IF (case.right # NIL) & (case.right.class = Ngoto) THEN (* jump to goto optimization *)
case.right.right.conval.intval2 := SHORT(ENTIER(lab.conval.realval));
ASSERT(lab.link = NIL); sequential := FALSE
ELSE
WHILE lab # NIL DO
this := SHORT(ENTIER(lab.conval.realval)); DevCPL486.SetLabel(this); lab := lab.link
END;
stat(case.right, end)
END;
case := case.link
END
END CaseStat;
PROCEDURE Dim(n: DevCPT.Node; VAR x, nofel: DevCPL486.Item; VAR fact: INTEGER; dimtyp: DevCPT.Struct);
VAR len: DevCPL486.Item; u: SET; s: INTEGER;
BEGIN
Check(n, u, s);
IF (nofel.mode = Reg) & (nofel.reg IN u) THEN DevCPC486.Push(nofel) END;
IF nofel.mode = Stk THEN DevCPC486.Pop(nofel, Int32, {}, {}) END;
expr(n, len, {}, {mem, short});
IF len.mode = Stk THEN DevCPC486.Pop(len, Int32, {}, {}) END;
DevCPC486.MulDim(len, nofel, fact, dimtyp);
IF n.link # NIL THEN
Dim(n.link, x, nofel, fact, dimtyp.BaseTyp);
ELSE
DevCPC486.New(x, nofel, fact)
END;
DevCPC486.SetDim(x, len, dimtyp)
END Dim;
PROCEDURE CompStat (n: DevCPT.Node);
VAR x, y, sp, old, len, nofel: DevCPL486.Item; fact: INTEGER; typ: DevCPT.Struct;
BEGIN
Checkpc;
WHILE (n # NIL) & DevCPM.noerr DO
ASSERT(n.class = Nassign);
IF n.subcl = assign THEN
IF n.right.typ.form IN {String8, String16} THEN
StringCopy(n.left, n.right)
ELSE
IF (n.left.typ.sysflag = interface) & ~CountedPtr(n.right) THEN
IPAssign(NIL, n.right, x, y, {}); (* no Release *)
ELSE expr(n.right, y, {}, {})
END;
expr(n.left, x, {}, {});
DevCPC486.Assign(x, y)
END
ELSE ASSERT(n.subcl = newfn);
typ := n.left.typ.BaseTyp;
ASSERT(typ.comp = DynArr);
ASSERT(n.right.link = NIL);
expr(n.right, y, {}, wreg - {CX} + {mem, stk});
DevCPL486.MakeReg(sp, SP, Int32);
DevCPC486.CopyReg(sp, old, {}, {CX});
DevCPC486.CopyReg(y, len, {}, {CX});
IF typ.BaseTyp.form = Char16 THEN
DevCPL486.MakeConst(x, 2, Int32); DevCPL486.GenMul(x, y, FALSE)
END;
DevCPC486.StackAlloc;
DevCPC486.Free(y);
expr(n.left, x, {}, {}); DevCPC486.Assign(x, sp);
DevCPC486.Push(len);
DevCPC486.Push(old);
typ.sysflag := stackArray
END;
n := n.link
END
END CompStat;
PROCEDURE CompRelease (n: DevCPT.Node; VAR res: DevCPL486.Item);
VAR x, y, sp: DevCPL486.Item;
BEGIN
IF n.link # NIL THEN CompRelease(n.link, res) END;
ASSERT(n.class = Nassign);
IF n.subcl = assign THEN
IF (n.left.typ.form = Pointer) & (n.left.typ.sysflag = interface) THEN
IF res.mode = Cond THEN
DevCPL486.GenCode(9CH); (* push flags *)
res.mode := Stk
ELSIF res.mode = Reg THEN
IF res.form < Int16 THEN DevCPC486.Push(res)
ELSE DevCPC486.Assert(res, {}, {AX, CX, DX})
END
END;
expr(n.left, x, wreg - {DI}, {loaded});
DevCPC486.IPRelease(x, 0, TRUE, TRUE);
n.left.obj.used := FALSE
END
ELSE ASSERT(n.subcl = newfn);
DevCPL486.MakeReg(sp, SP, Int32); DevCPL486.GenPop(sp);
DevCPL486.MakeConst(y, 0, Pointer);
expr(n.left, x, {}, {}); DevCPC486.Assign(x, y)
END
END CompRelease;
PROCEDURE Assign(n: DevCPT.Node; ux: SET);
VAR r: DevCPT.Node; f: BYTE; false, true: DevCPL486.Label; x, y, z: DevCPL486.Item; uf, uy: SET; s: INTEGER;
BEGIN
r := n.right; f := r.typ.form; uf := {};
IF (r.class IN {Nmop, Ndop}) THEN
IF (r.subcl = conv) & (f # Set) &
(*
(DevCPT.Includes(f, r.left.typ.form) OR DevCPT.Includes(f, n.left.typ.form)) THEN r := r.left;
IF ~(f IN realSet) & (r.typ.form IN realSet) & (r.typ # DevCPT.intrealtyp) THEN uf := {AX} END (* entier *)
*)
(DevCPT.Includes(f, r.left.typ.form) OR DevCPT.Includes(f, n.left.typ.form)) &
((f IN realSet) OR ~(r.left.typ.form IN realSet)) THEN r := r.left
ELSIF (f IN {Char8..Int32, Set, Char16, String8, String16}) & SameExp(n.left, r.left) THEN
IF r.class = Ndop THEN
IF (r.subcl IN {slash, plus, minus, msk}) OR (r.subcl = times) & (f = Set) THEN
expr(r.right, y, {}, ux); expr(n.left, x, {}, {});
DevCPC486.Load(y, {}, {}); DevCPC486.IntDOp(x, y, r.subcl, FALSE);
RETURN
ELSIF r.subcl IN {ash, lsh, rot} THEN
expr(r.right, y, wreg - {CX} + {high, mem}, ux); expr(n.left, x, {}, {});
DevCPC486.Load(y, {}, wreg - {CX} + {high}); DevCPC486.Shift(x, y, r.subcl);
RETURN
END
ELSE
IF r.subcl IN {minus, abs, cap} THEN
expr(n.left, x, {}, {}); DevCPC486.IntMOp(x, r.subcl); RETURN
END
END
ELSIF f = Bool THEN
IF (r.subcl = not) & SameExp(n.left, r.left) THEN
expr(n.left, x, {}, {}); DevCPC486.IntMOp(x, not); RETURN
END
END
END;
IF (n.left.typ.sysflag = interface) & (n.left.typ.form = Pointer) THEN IPAssign(n.left, r, x, y, ux)
ELSE expr(r, y, {high}, ux); expr(n.left, x, {}, uf + {loaded}); (* high ??? *)
END;
DevCPC486.Assign(x, y)
END Assign;
PROCEDURE stat (n: DevCPT.Node; VAR end: DevCPL486.Label);
VAR x, y, nofel: DevCPL486.Item; local, next, loop, prevExit: DevCPL486.Label; fact, sx, sz: INTEGER; ux, uz: SET;
BEGIN
sequential := TRUE; INC(nesting);
WHILE (n # NIL) & DevCPM.noerr DO
IF n.link = NIL THEN next := end ELSE next := DevCPL486.NewLbl END;
DevCPM.errpos := n.conval.intval; DevCPL486.BegStat;
CASE n.class OF
| Ninittd:
(* done at load-time *)
| Nassign:
Checkpc;
Check(n.left, ux, sx);
CASE n.subcl OF
assign:
IF n.left.typ.form = Comp THEN
IF (n.right.class = Ndop) & (n.right.typ.form IN {String8, String16}) THEN
StringCopy(n.left, n.right)
ELSE
StringOp(n.left, n.right, x, y, TRUE);
IF DevCPC486.ContainsIPtrs(n.left.typ) THEN IPStructAssign(n.left.typ) END;
DevCPC486.Copy(x, y, FALSE)
END
ELSE Assign(n, ux)
END
| getfn:
Mem(n.right, y, n.left.typ, {}, ux);
expr(n.left, x, {}, {loaded});
DevCPC486.Assign(x, y)
| putfn:
expr(n.right, y, {}, ux);
Mem(n.left, x, n.right.typ, {}, {});
DevCPC486.Assign(x, y)
| incfn, decfn:
expr(n.right, y, {}, ux); expr(n.left, x, {}, {});
IF n.left.typ.form = Int64 THEN
DevCPC486.LargeInc(x, y, n.subcl = decfn)
ELSE
DevCPC486.Load(y, {}, {}); DevCPC486.IntDOp(x, y, SHORT(SHORT(plus - incfn + n.subcl)), FALSE)
END
| inclfn:
expr(n.right, y, {}, wreg - {CX} + {high, mem, stk}); DevCPC486.MakeSet(y, FALSE, FALSE, ux, {});
DevCPC486.Assert(y, {}, ux); expr(n.left, x, {}, {});
DevCPC486.Load(y, {}, {}); DevCPC486.IntDOp(x, y, plus, FALSE)
| exclfn:
expr(n.right, y, {}, wreg - {CX} + {high, mem, stk}); DevCPC486.MakeSet(y, FALSE, TRUE, ux, {});
DevCPC486.Assert(y, {}, ux); expr(n.left, x, {}, {});
DevCPC486.Load(y, {}, {}); DevCPC486.IntDOp(x, y, times, FALSE)
| getrfn:
expr(n.right, y, {}, {});
IF y.offset < 8 THEN
DevCPL486.MakeReg(y, y.offset, n.left.typ.form); (* ??? *)
expr(n.left, x, {}, {loaded}); DevCPC486.Assign(x, y)
ELSE DevCPM.err(220)
END
| putrfn:
expr(n.left, x, {}, {});
IF x.offset < 8 THEN
DevCPL486.MakeReg(x, x.offset, n.right.typ.form); (* ??? *)
expr(n.right, y, wreg - {x.reg}, {}); DevCPC486.Assign(x, y)
ELSE DevCPM.err(220)
END
| newfn:
y.typ := n.left.typ;
IF n.right # NIL THEN
IF y.typ.BaseTyp.comp = Record THEN
expr(n.right, nofel, {}, {AX, CX, DX, mem, stk});
DevCPC486.New(y, nofel, 1);
ELSE (*open array*)
nofel.mode := Con; nofel.form := Int32; fact := 1;
Dim(n.right, y, nofel, fact, y.typ.BaseTyp)
END
ELSE
DevCPL486.MakeConst(nofel, 0, Int32);
DevCPC486.New(y, nofel, 1);
END;
DevCPC486.Assert(y, {}, ux); expr(n.left, x, {}, {loaded}); DevCPC486.Assign(x, y)
| sysnewfn:
expr(n.right, y, {}, {mem, short}); DevCPC486.SysNew(y);
DevCPC486.Assert(y, {}, ux); expr(n.left, x, {}, {}); DevCPC486.Assign(x, y)
| copyfn:
StringOp(n.left, n.right, x, y, TRUE);
DevCPC486.Copy(x, y, TRUE)
| movefn:
Check(n.right.link, uz, sz);
expr(n.right, y, {}, wreg - {SI} + {short} + ux + uz);
expr(n.left, x, {}, wreg - {DI} + {short} + uz);
expr(n.right.link, nofel, {}, wreg - {CX} + {mem, stk, short});
DevCPC486.Load(x, {}, wreg - {DI} + {con});
DevCPC486.Load(y, {}, wreg - {SI} + {con});
DevCPC486.SysMove(nofel)
END;
sequential := TRUE
| Ncall:
Checkpc;
Call(n, x); sequential := TRUE
| Nifelse:
IF (n.subcl # assertfn) OR assert THEN IfStat(n, FALSE, next) END
| Ncase:
Checkpc;
CaseStat(n, next)
| Nwhile:
local := DevCPL486.NewLbl;
IF n.right # NIL THEN DevCPC486.Jump(local) END;
loop := DevCPL486.NewLbl; DevCPL486.SetLabel(loop);
stat(n.right, local); DevCPL486.SetLabel(local);
DevCPM.errpos := n.conval.intval; Checkpc;
condition(n.left, x, next, loop); DevCPC486.JumpT(x, loop); sequential := TRUE
| Nrepeat:
loop := DevCPL486.NewLbl; DevCPL486.SetLabel(loop);
local := DevCPL486.NewLbl; stat(n.left, local); DevCPL486.SetLabel(local);
DevCPM.errpos := n.conval.intval; Checkpc;
condition(n.right, x, loop, next); DevCPC486.JumpF(x, loop); sequential := TRUE
| Nloop:
prevExit := Exit; Exit := next;
loop := DevCPL486.NewLbl; DevCPL486.SetLabel(loop); stat(n.left, loop);
IF sequential THEN DevCPC486.Jump(loop) END;
next := Exit; Exit := prevExit; sequential := FALSE
| Nexit:
Checkpc;
DevCPC486.Jump(Exit); sequential := FALSE
| Nreturn:
IF n.left # NIL THEN
Checkpc;
IF (n.obj.typ.sysflag = interface) & (n.obj.typ.form = Pointer)
& (n.left.class # Nconst) & ~CountedPtr(n.left) THEN IPAssign(NIL, n.left, y, x, {})
ELSE expr(n.left, x, wreg - {AX}, {})
END;
DevCPC486.Result(n.obj, x)
END;
IF (nesting > 1) OR (n.link # NIL) THEN DevCPC486.Jump(Return) END;
sequential := FALSE
| Nwith:
IfStat(n, n.subcl = 0, next)
| Ntrap:
Checkpc;
DevCPC486.Trap(n.right.conval.intval); sequential := TRUE
| Ncomp:
CompStat(n.left); stat(n.right, next); x.mode := 0; CompRelease(n.left, x)
| Ndrop:
Checkpc;
expr(n.left, x, {}, {}); DevCPC486.Free(x)
| Ngoto:
IF n.left # NIL THEN
Checkpc;
condition(n.left, x, next, n.right.conval.intval2);
DevCPC486.JumpT(x, n.right.conval.intval2)
ELSE
DevCPC486.Jump(n.right.conval.intval2);
sequential := FALSE
END
| Njsr:
DevCPL486.GenJump(-3, n.right.conval.intval2, FALSE) (* call n.right *)
| Nret:
DevCPL486.GenReturn(0); sequential := FALSE (* ret 0 *)
| Nlabel:
DevCPL486.SetLabel(n.conval.intval2)
END;
DevCPC486.CheckReg; DevCPL486.EndStat; n := n.link;
IF n = NIL THEN end := next
ELSIF next # DevCPL486.NewLbl THEN DevCPL486.SetLabel(next)
END
END;
DEC(nesting)
END stat;
PROCEDURE CheckFpu (n: DevCPT.Node; VAR useFpu: BOOLEAN);
BEGIN
WHILE n # NIL DO
IF n.typ.form IN {Real32, Real64} THEN useFpu := TRUE END;
CASE n.class OF
| Ncase:
CheckFpu(n.left, useFpu); CheckFpu(n.right.left, useFpu); CheckFpu(n.right.right, useFpu)
| Ncasedo:
CheckFpu(n.right, useFpu)
| Ngoto, Ndrop, Nloop, Nreturn, Nmop, Nfield, Nderef, Nguard:
CheckFpu(n.left, useFpu)
| Nassign, Ncall, Nifelse, Nif, Nwhile, Nrepeat, Nwith, Ncomp, Ndop, Nupto, Nindex:
CheckFpu(n.left, useFpu); CheckFpu(n.right, useFpu)
| Njsr, Nret, Nlabel, Ntrap, Nexit, Ninittd, Ntype, Nproc, Nconst, Nvar, Nvarpar:
END;
n := n.link
END
END CheckFpu;
PROCEDURE procs(n: DevCPT.Node);
VAR proc, obj: DevCPT.Object; i, j: INTEGER; end: DevCPL486.Label;
ch: SHORTCHAR; name: DevCPT.Name; useFpu: BOOLEAN;
BEGIN
INC(DevCPL486.level); nesting := 0;
WHILE (n # NIL) & DevCPM.noerr DO
DevCPC486.imLevel[DevCPL486.level] := DevCPC486.imLevel[DevCPL486.level - 1]; proc := n.obj;
IF imVar IN proc.conval.setval THEN INC(DevCPC486.imLevel[DevCPL486.level]) END;
procs(n.left);
DevCPM.errpos := n.conval.intval;
useFpu := FALSE; CheckFpu(n.right, useFpu);
DevCPC486.Enter(proc, n.right = NIL, useFpu);
InitializeIPVars(proc);
end := DevCPL486.NewLbl; Return := DevCPL486.NewLbl; stat(n.right, end);
DevCPM.errpos := n.conval.intval2; Checkpc;
IF sequential OR (end # DevCPL486.NewLbl) THEN
DevCPL486.SetLabel(end);
IF (proc.typ # DevCPT.notyp) & (proc.sysflag # noframe) THEN DevCPC486.Trap(funcTrap) END
END;
DevCPL486.SetLabel(Return);
ReleaseIPVars(proc);
DevCPC486.Exit(proc, n.right = NIL);
IF proc.mode = TProc THEN
name := proc.link.typ.strobj.name^$; i := 0;
WHILE name[i] # 0X DO INC(i) END;
name[i] := "."; INC(i); j := 0; ch := proc.name[0];
WHILE (ch # 0X) & (i < LEN(name)-1) DO name[i] := ch; INC(i); INC(j); ch := proc.name[j] END ;
name[i] := 0X;
ELSE name := proc.name^$
END;
DevCPE.OutRefName(name); DevCPE.OutRefs(proc.scope.right);
n := n.link
END;
DEC(DevCPL486.level)
END procs;
PROCEDURE Module*(prog: DevCPT.Node);
VAR end: DevCPL486.Label; name: DevCPT.Name; obj, p: DevCPT.Object; n: DevCPT.Node;
aAd, rAd: INTEGER; typ: DevCPT.Struct; useFpu: BOOLEAN;
BEGIN
DevCPH.UseReals(prog, {DevCPH.longDop, DevCPH.longMop});
DevCPM.NewObj(DevCPT.SelfName);
IF DevCPM.noerr THEN
DevCPE.OutHeader; n := prog.right;
WHILE (n # NIL) & (n.class = Ninittd) DO n := n.link END;
useFpu := FALSE; CheckFpu(n, useFpu);
DevCPC486.Enter(NIL, n = NIL, useFpu);
end := DevCPL486.NewLbl; stat(n, end); DevCPL486.SetLabel(end);
DevCPM.errpos := prog.conval.intval2; Checkpc;
DevCPC486.Exit(NIL, n = NIL);
IF prog.link # NIL THEN (* close section *)
DevCPL486.SetLabel(DevCPE.closeLbl);
useFpu := FALSE; CheckFpu(prog.link, useFpu);
DevCPC486.Enter(NIL, FALSE, useFpu);
end := DevCPL486.NewLbl; stat(prog.link, end); DevCPL486.SetLabel(end);
DevCPM.errpos := SHORT(ENTIER(prog.conval.realval)); Checkpc;
DevCPC486.Exit(NIL, FALSE)
END;
name := "$$"; DevCPE.OutRefName(name); DevCPE.OutRefs(DevCPT.topScope.right);
DevCPM.errpos := prog.conval.intval;
WHILE query # NIL DO
typ := query.typ; query.typ := DevCPT.int32typ;
query.conval.intval := 20; (* parameters *)
query.conval.intval2 := -8; (* saved registers *)
DevCPC486.Enter(query, FALSE, FALSE);
InstallQueryInterface(typ, query);
DevCPC486.Exit(query, FALSE);
name := "QueryInterface"; DevCPE.OutRefName(name);
query := query.nlink
END;
procs(prog.left);
DevCPC486.InstallStackAlloc;
addRef := NIL; release := NIL; release2 := NIL;
DevCPC486.intHandler := NIL;
IF DevCPM.noerr THEN DevCPE.OutCode END;
IF ~DevCPM.noerr THEN DevCPM.DeleteObj END
END
END Module;
END DevCPV486.
| Dev/Mod/CPV486.odc |
MODULE DevDebug; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, L.import; switched from National to i21sysCharacters
- 20100331, Fyodor Tkachov, Trap window content is now formed using remappings via Dev/Rsrc/Strings.odc, whereas hyperlinks in the Trap window correctly show the instruction that caused the trap even if keyword conversions were used
- 20080215, Fyodor Tkachov, reviewed
- 20050626, Fyodor Tkachov, russification edited
- 20050430, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT SYSTEM,
Kernel, Strings, Dates, Files, Fonts, Services, Ports, Stores, Converters,
Models, Views, Controllers, Properties, Dialog, Containers, Controls,
HostFonts, Windows, HostFiles, StdDialog, StdFolds, StdLinks,
TextModels, TextMappers, TextControllers, TextViews, TextRulers, StdLog,
DevCommanders, i21sysCharacters, i21sysVocabulary;
CONST
mm = Ports.mm; pt = Ports.point;
mProc = 4;
refViewSize = 9 * Ports.point;
heap = 1; source = 2; module = 3; modules = 4; (* RefView types *)
open = 1; undo = 2; update = 3; (* RefView commands *)
(* additional scanner types *)
import = 100; smodule = 101; semicolon = 102; becomes = 103; stop = 104; comEnd = 105;
TYPE
Name = Kernel.Name;
ArrayPtr = POINTER TO EXTENSIBLE RECORD
last, t, first: INTEGER; (* gc header *)
len: ARRAY 16 OF INTEGER (* dynamic array length table *)
END;
RefView = POINTER TO RECORD (Views.View)
type: SHORTINT;
command: SHORTINT;
back: RefView;
adr: INTEGER;
desc: Kernel.Type;
ptr: ArrayPtr;
name: Name
END;
Action = POINTER TO RECORD (Services.Action)
text: TextModels.Model
END;
Cluster = POINTER TO RECORD [untagged] (* must correspond to Kernel.Cluster *)
size: INTEGER;
next: Cluster
END;
VAR
out: TextMappers.Formatter;
loadErrors: ARRAY 10, 64 OF SHORTCHAR;
path: ARRAY 4 OF Ports.Point;
empty: Name;
PROCEDURE NewRuler (): TextRulers.Ruler;
CONST mm = Ports.mm; pt = Ports.point;
VAR r: TextRulers.Ruler;
BEGIN
r := TextRulers.dir.New(NIL);
TextRulers.SetRight(r, 140 * mm);
TextRulers.AddTab(r, 4 * mm); TextRulers.AddTab(r, 34 * mm); TextRulers.AddTab(r, 80 * mm);
RETURN r
END NewRuler;
PROCEDURE NewModRuler (): TextRulers.Ruler;
CONST mm = Ports.mm; pt = Ports.point;
VAR r: TextRulers.Ruler;
BEGIN
r := TextRulers.dir.New(NIL);
IF Dialog.platform DIV 10 = 2 THEN (* mac *)
TextRulers.SetRight(r, 154 * mm);
TextRulers.AddTab(r, 48 * mm); TextRulers.MakeRightTab(r);
TextRulers.AddTab(r, 64 * mm); TextRulers.MakeRightTab(r);
TextRulers.AddTab(r, 76 * mm); TextRulers.AddTab(r, 115 * mm)
ELSE
TextRulers.SetRight(r, 144 * mm);
TextRulers.AddTab(r, 48 * mm); TextRulers.MakeRightTab(r);
TextRulers.AddTab(r, 64 * mm); TextRulers.MakeRightTab(r);
TextRulers.AddTab(r, 76 * mm); TextRulers.AddTab(r, 110 * mm)
END;
RETURN r
END NewModRuler;
PROCEDURE OpenViewer (t: TextModels.Model; title: Views.Title; ruler:TextRulers.Ruler);
VAR v: TextViews.View; c: Containers.Controller;
BEGIN
Dialog.MapString(title, title);
v := TextViews.dir.New(t);
v.SetDefaults(ruler, TextViews.dir.defAttr);
c := v.ThisController();
IF c # NIL THEN
c.SetOpts(c.opts - {Containers.noFocus, Containers.noSelection} + {Containers.noCaret})
END;
Views.OpenAux(v, title)
END OpenViewer;
PROCEDURE OpenFold (hidden: ARRAY OF CHAR);
VAR fold: StdFolds.Fold; t: TextModels.Model; w: TextMappers.Formatter;
BEGIN
Dialog.MapString(hidden, hidden);
t := TextModels.CloneOf(StdLog.buf);
w.ConnectTo(t); w.WriteString(hidden);
fold := StdFolds.dir.New(StdFolds.expanded, "", t);
out.WriteView(fold)
END OpenFold;
PROCEDURE CloseFold (collaps: BOOLEAN);
VAR fold: StdFolds.Fold; m: TextModels.Model;
BEGIN
fold := StdFolds.dir.New(StdFolds.expanded, "", NIL);
out.WriteView(fold);
IF collaps THEN fold.Flip(); m := out.rider.Base(); out.SetPos(m.Length()) END
END CloseFold;
PROCEDURE WriteHex (n: INTEGER);
BEGIN
out.WriteIntForm(n, TextMappers.hexadecimal, 9, "0", TextMappers.showBase)
END WriteHex;
PROCEDURE WriteString (adr, len, base: INTEGER; zterm: BOOLEAN);
CONST beg = 0; char = 1; code = 2;
VAR ch: SHORTCHAR; val, mode: SHORTINT; str: ARRAY 16 OF CHAR;
BEGIN
mode := beg;
IF base = 2 THEN SYSTEM.GET(adr, val) ELSE SYSTEM.GET(adr, ch); val := ORD(ch) END;
IF zterm & (val = 0) THEN out.WriteSString('""')
ELSE
REPEAT
IF (val >= ORD(" ")) & (val < 7FH) OR (val > 0A0H) & (val < 256) THEN
IF mode # char THEN
IF mode = code THEN out.WriteSString(", ") END;
out.WriteChar(22X); mode := char
END;
out.WriteChar(SHORT(CHR(val)))
ELSE
IF mode = char THEN out.WriteChar(22X) END;
IF mode # beg THEN out.WriteSString(", ") END;
mode := code; Strings.IntToStringForm(val, Strings.hexadecimal, 1, "0", FALSE, str);
IF str[0] > "9" THEN out.WriteChar("0") END;
out.WriteString(str); out.WriteChar("X")
END;
INC(adr, base); DEC(len);
IF base = 2 THEN SYSTEM.GET(adr, val) ELSE SYSTEM.GET(adr, ch); val := ORD(ch) END
UNTIL (len = 0) OR zterm & (val = 0)
END;
IF mode = char THEN out.WriteChar(22X) END
END WriteString;
PROCEDURE IsIdent (s: ARRAY OF CHAR): BOOLEAN;
VAR i: SHORTINT; ch: CHAR;
BEGIN
ch := s[0];
IF i21sysCharacters.IsFirstIdentChar(ch) THEN
i := 1; ch := s[1];
WHILE i21sysCharacters.IsIdentChar(ch) DO (* все вызовы под охраной: строка оканчивается на 0X *)
INC(i); ch := s[i]
END;
RETURN (s[i] = 0X) & (i < 256)
ELSE RETURN FALSE
END
END IsIdent;
PROCEDURE OutString (s: ARRAY OF CHAR);
VAR str: Dialog.String;
BEGIN
Dialog.MapString(s, str);
out.WriteString(str);
END OutString;
(* ------------------- variable display ------------------- *)
PROCEDURE FormOf (t: Kernel.Type): SHORTCHAR;
BEGIN
IF SYSTEM.VAL(INTEGER, t) DIV 256 = 0 THEN
RETURN SHORT(CHR(SYSTEM.VAL(INTEGER, t)))
ELSE
RETURN SHORT(CHR(16 + t.id MOD 4))
END
END FormOf;
PROCEDURE LenOf (t: Kernel.Type; ptr: ArrayPtr): INTEGER;
BEGIN
IF t.size # 0 THEN RETURN t.size
ELSIF ptr # NIL THEN RETURN ptr.len[t.id DIV 16 MOD 16 - 1]
ELSE RETURN 0
END
END LenOf;
PROCEDURE SizeOf (t: Kernel.Type; ptr: ArrayPtr): INTEGER;
BEGIN
CASE FormOf(t) OF
| 0BX: RETURN 0
| 1X, 2X, 4X: RETURN 1
| 3X, 5X: RETURN 2
| 8X, 0AX: RETURN 8
| 11X: RETURN t.size
| 12X: RETURN LenOf(t, ptr) * SizeOf(t.base[0], ptr)
ELSE RETURN 4
END
END SizeOf;
PROCEDURE WriteName (t: Kernel.Type; ptr: ArrayPtr);
VAR name: Kernel.Name; f: SHORTCHAR;
BEGIN
f := FormOf(t);
CASE f OF
| 0X: OutString("#Dev:Unknown")
| 1X: out.WriteSString("BOOLEAN")
| 2X: out.WriteSString("SHORTCHAR")
| 3X: out.WriteSString("CHAR")
| 4X: out.WriteSString("BYTE")
| 5X: out.WriteSString("SHORTINT")
| 6X: out.WriteSString("INTEGER")
| 7X: out.WriteSString("SHORTREAL")
| 8X: out.WriteSString("REAL")
| 9X: out.WriteSString("SET")
| 0AX: out.WriteSString("LONGINT")
| 0BX: out.WriteSString("ANYREC")
| 0CX: out.WriteSString("ANYPTR")
| 0DX: out.WriteSString("POINTER")
| 0EX: out.WriteSString("PROCEDURE")
| 0FX: out.WriteSString("STRING")
| 10X..13X:
IF (t.mod # NIL) & (t.id DIV 256 # 0) & (t.mod.refcnt >= 0) THEN
Kernel.GetTypeName(t, name);
IF name = "!" THEN
IF f = 11X THEN out.WriteSString("RECORD")
ELSIF f = 12X THEN out.WriteSString("ARRAY")
ELSE OutString("#Dev:Unknown")
END
ELSE
out.WriteSString(t.mod.name); out.WriteChar("."); out.WriteSString(name)
END
ELSIF f = 11X THEN
IF t.mod # NIL THEN out.WriteSString(t.mod.name); out.WriteChar(".") END;
out.WriteSString("RECORD");
ELSIF f = 12X THEN
out.WriteSString("ARRAY "); out.WriteInt(LenOf(t, ptr)); t := t.base[0];
WHILE (FormOf(t) = 12X) & ((t.id DIV 256 = 0) OR (t.mod = NIL) OR (t.mod.refcnt < 0)) DO
out.WriteSString(", "); out.WriteInt(LenOf(t, ptr)); t := t.base[0]
END;
out.WriteSString(" OF "); WriteName(t, ptr)
ELSIF f = 13X THEN
out.WriteSString("POINTER")
ELSE
out.WriteSString("PROCEDURE")
END
| 20X: out.WriteSString("COM.IUnknown")
| 21X: out.WriteSString("COM.GUID")
| 22X: out.WriteSString("COM.RESULT")
ELSE OutString("#Dev:UnknownFormat"); out.WriteInt(ORD(f))
END
END WriteName;
PROCEDURE WriteGuid (a: INTEGER);
PROCEDURE Hex (a: INTEGER);
VAR x: SHORTCHAR;
BEGIN
SYSTEM.GET(a, x);
out.WriteIntForm(ORD(x), TextMappers.hexadecimal, 2, "0", FALSE)
END Hex;
BEGIN
out.WriteChar("{");
Hex(a + 3); Hex(a + 2); Hex(a + 1); Hex(a);
out.WriteChar("-");
Hex(a + 5); Hex(a + 4);
out.WriteChar("-");
Hex(a + 7); Hex(a + 6);
out.WriteChar("-");
Hex(a + 8);
Hex(a + 9);
out.WriteChar("-");
Hex(a + 10);
Hex(a + 11);
Hex(a + 12);
Hex(a + 13);
Hex(a + 14);
Hex(a + 15);
out.WriteChar("}")
END WriteGuid;
PROCEDURE^ ShowVar (
ad, ind: INTEGER; f, c: SHORTCHAR; desc: Kernel.Type; ptr: ArrayPtr; back: RefView; VAR name, sel: Name);
PROCEDURE^ NewRefView (type, command: SHORTINT; adr: INTEGER; back: RefView;
desc: Kernel.Type; ptr: ArrayPtr; name: Name): RefView;
PROCEDURE^ InsertRefView (type, command: SHORTINT; adr: INTEGER; back: RefView;
desc: Kernel.Type; ptr: ArrayPtr; name: Name);
PROCEDURE ShowRecord (a, ind: INTEGER; desc: Kernel.Type; back: RefView; VAR sel: Name);
VAR dir: Kernel.Directory; obj: Kernel.Object; name: Kernel.Name; i, j, n: INTEGER; base: Kernel.Type;
BEGIN
WriteName(desc, NIL); out.WriteTab;
IF desc.mod.refcnt >= 0 THEN
OpenFold("#Dev:Fields");
n := desc.id DIV 16 MOD 16; j := 0;
WHILE j <= n DO
base := desc.base[j];
IF base # NIL THEN
dir := base.fields; i := 0;
WHILE i < dir.num DO
obj := SYSTEM.VAL(Kernel.Object, SYSTEM.ADR(dir.obj[i]));
Kernel.GetObjName(base.mod, obj, name);
ShowVar(a + obj.offs, ind, FormOf(obj.struct), 1X, obj.struct, NIL, back, name, sel);
INC(i)
END
END;
INC(j)
END;
out.WriteSString(" "); CloseFold((ind > 1) OR (sel # ""))
ELSE
OutString("#Dev:Unloaded")
END
END ShowRecord;
PROCEDURE ShowArray (a, ind: INTEGER; desc: Kernel.Type; ptr: ArrayPtr; back: RefView; VAR sel: Name);
VAR f: SHORTCHAR; i, n, m, size, len: INTEGER; name: Kernel.Name; eltyp, t: Kernel.Type;
vi: SHORTINT; vs: BYTE; str: Dialog.String;
BEGIN
WriteName(desc, ptr); out.WriteTab;
len := LenOf(desc, ptr); eltyp := desc.base[0]; f := FormOf(eltyp); size := SizeOf(eltyp, ptr);
IF (f = 2X) OR (f = 3X) THEN (* string *)
n := 0; m := len;
IF f = 2X THEN
REPEAT SYSTEM.GET(a + n, vs); INC(n) UNTIL (n = 32) OR (n = len) OR (vs = 0);
REPEAT DEC(m); SYSTEM.GET(a + m, vs) UNTIL (m = 0) OR (vs # 0)
ELSE
REPEAT SYSTEM.GET(a + n * 2, vi); INC(n) UNTIL (n = 32) OR (n = len) OR (vi = 0);
REPEAT DEC(m); SYSTEM.GET(a + m * 2, vi) UNTIL (m = 0) OR (vi # 0)
END;
WriteString(a, n, size, TRUE);
INC(m, 2);
IF m > len THEN m := len END;
IF m > n THEN
out.WriteSString(" "); OpenFold("...");
out.WriteLn;
WriteString(a, m, size, FALSE);
IF m < len THEN out.WriteSString(", ..., 0X") END;
out.WriteSString(" "); CloseFold(TRUE)
END
ELSE
t := eltyp;
WHILE FormOf(t) = 12X DO t := t.base[0] END;
IF FormOf(t) # 0X THEN
OpenFold("#Dev:Elements");
i := 0;
WHILE i < len DO
Strings.IntToString(i, str);
name := "[" + SHORT(str$) + "]";
ShowVar(a, ind, f, 1X, eltyp, ptr, back, name, sel);
INC(i); INC(a, size)
END;
out.WriteSString(" "); CloseFold(TRUE)
END
END
END ShowArray;
PROCEDURE ShowProcVar (a: INTEGER);
VAR vli, n, ref: INTEGER; m: Kernel.Module; name: Kernel.Name;
BEGIN
SYSTEM.GET(a, vli);
Kernel.SearchProcVar(vli, m, vli);
IF m = NIL THEN
IF vli = 0 THEN out.WriteSString("NIL")
ELSE WriteHex(vli)
END
ELSE
IF m.refcnt >= 0 THEN
out.WriteSString(m.name); ref := m.refs;
REPEAT Kernel.GetRefProc(ref, n, name) UNTIL (n = 0) OR (vli < n);
IF vli < n THEN out.WriteChar("."); out.WriteSString(name) END
ELSE
OutString("#Dev:ProcInUnloadedMod");
out.WriteSString(m.name); out.WriteSString(" !!!")
END
END
END ShowProcVar;
PROCEDURE ShowPointer (a: INTEGER; f: SHORTCHAR; desc: Kernel.Type; back: RefView; VAR sel: Name);
VAR adr, x: INTEGER; ptr: ArrayPtr; c: Cluster; btyp: Kernel.Type;
BEGIN
SYSTEM.GET(a, adr);
IF f = 13X THEN btyp := desc.base[0] ELSE btyp := NIL END;
IF adr = 0 THEN out.WriteSString("NIL")
ELSIF f = 20X THEN
out.WriteChar("["); WriteHex(adr); out.WriteChar("]");
out.WriteChar(" "); c := SYSTEM.VAL(Cluster, Kernel.Root());
WHILE (c # NIL) & ((adr < SYSTEM.VAL(INTEGER, c)) OR (adr >= SYSTEM.VAL(INTEGER, c) + c.size)) DO c := c.next END;
IF c # NIL THEN
ptr := SYSTEM.VAL(ArrayPtr, adr);
InsertRefView(heap, open, adr, back, btyp, ptr, sel)
END
ELSE
IF (f = 13X) OR (f = 0CX) THEN x := adr - 4 ELSE x := adr END;
IF ((adr < -4) OR (adr >= 65536)) & Kernel.IsReadable(x, adr + 16) THEN
out.WriteChar("["); WriteHex(adr); out.WriteChar("]");
IF (f = 13X) OR (f = 0CX) THEN
out.WriteChar(" "); c := SYSTEM.VAL(Cluster, Kernel.Root());
WHILE (c # NIL) & ((adr < SYSTEM.VAL(INTEGER, c)) OR (adr >= SYSTEM.VAL(INTEGER, c) + c.size)) DO
c := c.next
END;
IF c # NIL THEN
ptr := SYSTEM.VAL(ArrayPtr, adr);
IF (f = 13X) & (FormOf(btyp) = 12X) THEN (* array *)
adr := SYSTEM.ADR(ptr.len[btyp.id DIV 16 MOD 16])
END;
InsertRefView(heap, open, adr, back, btyp, ptr, sel)
ELSE OutString("#Dev:IllegalPointer");
END
END
ELSE OutString("#Dev:IllegalAddress"); WriteHex(adr)
END
END
END ShowPointer;
PROCEDURE ShowSelector (ref: RefView);
VAR b: RefView; n: SHORTINT; a, a0: TextModels.Attributes;
BEGIN
b := ref.back; n := 1;
IF b # NIL THEN
WHILE (b.name = ref.name) & (b.back # NIL) DO INC(n); b := b.back END;
ShowSelector(b);
IF n > 1 THEN out.WriteChar("(") END;
out.WriteChar(".")
END;
out.WriteSString(ref.name);
IF ref.type = heap THEN out.WriteChar("^") END;
IF n > 1 THEN
out.WriteChar(")");
a0 := out.rider.attr; a := TextModels.NewOffset(a0, 2 * Ports.point);
out.rider.SetAttr(a);
out.WriteInt(n); out.rider.SetAttr(a0)
END;
END ShowSelector;
PROCEDURE ShowVar (
ad, ind: INTEGER; f, c: SHORTCHAR; desc: Kernel.Type; ptr: ArrayPtr; back: RefView; VAR name, sel: Name
);
VAR i, j, vli, a, ref: INTEGER; tsel: Name; a0: TextModels.Attributes;
vc: SHORTCHAR; vsi: BYTE; vi: SHORTINT; vr: SHORTREAL; vlr: REAL; vs: SET;
BEGIN
out.WriteLn; out.WriteTab; i := 0;
WHILE i < ind DO out.WriteSString(" "); INC(i) END;
a := ad; i := 0; j := 0;
IF sel # "" THEN
WHILE sel[i] # 0X DO tsel[i] := sel[i]; INC(i) END;
IF (tsel[i-1] # ":") & (name[0] # "[") THEN tsel[i] := "."; INC(i) END
END;
WHILE name[j] # 0X DO tsel[i] := name[j]; INC(i); INC(j) END;
tsel[i] := 0X;
a0 := out.rider.attr;
IF c = 3X THEN (* varpar *)
SYSTEM.GET(ad, a);
out.rider.SetAttr(TextModels.NewStyle(a0, {Fonts.italic}))
END;
IF name[0] # "[" THEN out.WriteChar(".") END;
out.WriteSString(name);
out.rider.SetAttr(a0);
out.WriteTab;
IF (c = 3X) & (a >= 0) & (a < 65536) THEN
out.WriteTab; out.WriteSString("NIL VARPAR");
ELSIF f = 11X THEN
Kernel.GetTypeName(desc, name);
IF (c = 3X) & (name[0] # "!") THEN SYSTEM.GET(ad + 4, desc) END; (* dynamic type *)
ShowRecord(a, ind + 1, desc, back, tsel)
ELSIF (c = 3X) & (f = 0BX) THEN (* VAR anyrecord *)
SYSTEM.GET(ad + 4, desc);
ShowRecord(a, ind + 1, desc, back, tsel)
ELSIF f = 12X THEN
IF (desc.size = 0) & (ptr = NIL) THEN SYSTEM.GET(ad, a) END; (* dyn array val par *)
IF ptr = NIL THEN ptr := SYSTEM.VAL(ArrayPtr, ad - 8) END;
ShowArray(a, ind + 1, desc, ptr, back, tsel)
ELSE
IF desc = NIL THEN desc := SYSTEM.VAL(Kernel.Type, ORD(f)) END;
WriteName(desc, NIL); out.WriteTab;
CASE f OF
| 0X: (* SYSTEM.GET(a, vli); WriteHex(vli) *)
| 1X: SYSTEM.GET(a, vc);
IF vc = 0X THEN out.WriteSString("FALSE")
ELSIF vc = 1X THEN out.WriteSString("TRUE")
ELSE OutString("#Dev:Undefined"); out.WriteInt(ORD(vc))
END
| 2X: WriteString(a, 1, 1, FALSE)
| 3X: WriteString(a, 1, 2, FALSE)
| 4X: SYSTEM.GET(a, vsi); out.WriteInt(vsi)
| 5X: SYSTEM.GET(a, vi); out.WriteInt(vi)
| 6X: SYSTEM.GET(a, vli); out.WriteInt(vli)
| 7X: SYSTEM.GET(a, vli);
IF BITS(vli) * {23..30} = {23..30} THEN
IF BITS(vli) = {23..30} THEN out.WriteString("inf")
ELSIF BITS(vli) = {23..31} THEN out.WriteString("-inf")
ELSE out.WriteString("nan ("); WriteHex(vli); out.WriteString(")")
END
ELSE
SYSTEM.GET(a, vr); out.WriteReal(vr)
END
| 8X: IF Kernel.littleEndian THEN SYSTEM.GET(a, vli); SYSTEM.GET(a + 4, i)
ELSE SYSTEM.GET(a + 4, vli); SYSTEM.GET(a, i)
END;
IF BITS(i) * {20..30} = {20..30} THEN
IF (BITS(i) = {20..30}) & (vli = 0) THEN out.WriteString("inf")
ELSIF (BITS(i) = {20..31}) & (vli = 0) THEN out.WriteString("-inf")
ELSE out.WriteString("nan ("); out.WriteIntForm(i, TextMappers.hexadecimal, 8, "0", TextMappers.hideBase);
WriteHex(vli); out.WriteString(")")
END
ELSE
SYSTEM.GET(a, vlr); out.WriteReal(vlr)
END
| 9X: SYSTEM.GET(a, vs); out.WriteSet(vs)
| 0AX: IF Kernel.littleEndian THEN SYSTEM.GET(a, vli); SYSTEM.GET(a + 4, i)
ELSE SYSTEM.GET(a + 4, vli); SYSTEM.GET(a, i)
END;
IF (vli >= 0) & (i = 0) OR (vli < 0) & (i = -1) THEN out.WriteInt(vli)
ELSE out.WriteIntForm(i, TextMappers.hexadecimal, 8, "0", TextMappers.hideBase); WriteHex(vli)
END
| 0CX, 0DX, 13X, 20X: ShowPointer(a, f, desc, back, tsel)
| 0EX, 10X: ShowProcVar(a)
| 0FX: WriteString(a, 256, 1, TRUE)
| 21X: WriteGuid(a)
| 22X: SYSTEM.GET(a, vli); WriteHex(vli)
ELSE
END
END
END ShowVar;
PROCEDURE WriteTimeStamp (ts: ARRAY OF SHORTINT);
VAR d: Dates.Date; t: Dates.Time; str: ARRAY 64 OF CHAR;
BEGIN
IF ts[0] = 0 THEN
out.WriteSString(" "); OutString("#Dev:Linked")
ELSE
d.year := ts[0]; d.month := ts[1]; d.day := ts[2];
t.hour := ts[3]; t.minute := ts[4]; t.second := ts[5];
Dates.DateToString(d, Dates.short, str);
out.WriteString(str); out.WriteString(" ");
Dates.TimeToString(t, str);
out.WriteString(str);
END
END WriteTimeStamp;
PROCEDURE ShowModules;
VAR m, m1: Kernel.Module; a0: TextModels.Attributes; n, h, t, h1: ARRAY 256 OF CHAR;
BEGIN
a0 := out.rider.attr;
out.rider.SetAttr(TextModels.NewStyle(a0, {Fonts.italic}));
OutString("#Dev:ModuleName"); out.WriteTab;
OutString("#Dev:BytesUsed"); out.WriteTab;
OutString("#Dev:Clients"); out.WriteTab;
OutString("#Dev:Compiled"); out.WriteTab;
OutString("#Dev:Loaded");
out.rider.SetAttr(a0); out.WriteTab; out.WriteTab;
out.rider.SetAttr(TextModels.NewStyle(out.rider.attr, {Fonts.underline}));
out.rider.SetAttr(TextModels.NewColor(out.rider.attr, Ports.blue));
out.WriteView(StdLinks.dir.NewLink("DevDebug.UpdateModules"));
OutString("#Dev:Update");
out.WriteView(StdLinks.dir.NewLink(""));
out.rider.SetAttr(a0); out.WriteLn;
m := Kernel.modList;
WHILE m # NIL DO
IF m.refcnt >= 0 THEN
n := m.name$; Kernel.SplitName(n, h, t);
m1 := Kernel.modList; h1 := "*";
WHILE (m1 # m) & (h1 # h) DO
IF m1.refcnt >= 0 THEN n := m1.name$; Kernel.SplitName(n, h1, t) END;
m1 := m1.next
END;
IF h1 # h THEN
out.WriteLn;
m1 := m;
WHILE m1 # NIL DO
n := m1.name$; Kernel.SplitName(n, h1, t);
IF (h1 = h) & (m1.refcnt >= 0) THEN
out.WriteSString(m1.name); out.WriteTab;
out.WriteIntForm(m1.csize + m1.dsize + m1.rsize, 10, 6, TextModels.digitspace, TextMappers.hideBase);
out.WriteTab;
out.WriteIntForm(m1.refcnt, 10, 3, TextModels.digitspace, TextMappers.hideBase);
out.WriteTab;
WriteTimeStamp(m1.compTime);
out.WriteTab;
WriteTimeStamp(m1.loadTime);
out.WriteLn
END;
m1 := m1.next
END
END
END;
m := m.next
END
END ShowModules;
PROCEDURE ShowGlobals (mod: Kernel.Module);
VAR ref, x: INTEGER; m, f: SHORTCHAR; name: ARRAY 256 OF CHAR; mname: Kernel.Name;
d: Kernel.Type; v: RefView; a0: TextModels.Attributes;
BEGIN
IF mod # NIL THEN
out.WriteSString(mod.name);
out.WriteTab; out.WriteTab; out.WriteTab;
a0 := out.rider.attr;
out.rider.SetAttr(TextModels.NewStyle(out.rider.attr, {Fonts.underline}));
out.rider.SetAttr(TextModels.NewColor(out.rider.attr, Ports.blue));
name := "DevDebug.UpdateGlobals('" + mod.name + "')";
out.WriteView(StdLinks.dir.NewLink(name));
OutString("#Dev:Update");
out.WriteView(StdLinks.dir.NewLink(""));
out.rider.SetAttr(a0); out.WriteLn;
ref := mod.refs; Kernel.GetRefProc(ref, x, mname); (* get body *)
IF x # 0 THEN
v := NewRefView (module, open, 0, NIL, NIL, NIL, mod.name);
Kernel.GetRefVar(ref, m, f, d, x, mname);
WHILE m = 1X DO
ShowVar(mod.data + x, 0, f, m, d, NIL, v, mname, empty);
Kernel.GetRefVar(ref, m, f, d, x, mname)
END
END;
out.WriteLn
END
END ShowGlobals;
PROCEDURE ShowObject (adr: INTEGER);
VAR eltyp: Kernel.Type; ptr: ArrayPtr; desc: ARRAY 64 OF INTEGER; i, n, lev, elsize: INTEGER;
BEGIN
SYSTEM.GET(adr - 4, eltyp);
IF ODD(SYSTEM.VAL(INTEGER, eltyp) DIV 2) THEN
DEC(SYSTEM.VAL(INTEGER, eltyp), 2);
ptr := SYSTEM.VAL(ArrayPtr, adr);
elsize := eltyp.size;
IF (eltyp.mod.name = "Kernel") & (eltyp.fields.num = 1) THEN
eltyp := eltyp.fields.obj[0].struct
END;
n := (ptr.last - ptr.first) DIV elsize + 1;
lev := (ptr.first - adr - 12) DIV 4; i := 0;
WHILE lev > 0 DO (* dynamic levels *)
DEC(lev);
desc[i] := ptr.len[lev]; n := n DIV desc[i]; INC(i); (* size *)
desc[i] := 0; INC(i); (* module *)
desc[i] := 2; INC(i); (* id *)
desc[i] := SYSTEM.ADR(desc[i+1]); INC(i) (* desc *)
END;
IF n > 1 THEN (* static level *)
desc[i] := n; INC(i); (* size *)
desc[i] := 0; INC(i); (* module *)
desc[i] := 2; INC(i); (* id *)
ELSE DEC(i)
END;
desc[i] := SYSTEM.VAL(INTEGER, eltyp); (* desc *)
ShowArray(ptr.first, 1, SYSTEM.VAL(Kernel.Type, SYSTEM.ADR(desc)), ptr, NIL, empty);
out.WriteLn
ELSE ShowRecord(adr, 1, eltyp, NIL, empty)
END;
END ShowObject;
PROCEDURE ShowPtrDeref (ref: RefView);
VAR b: RefView;
BEGIN
ShowSelector(ref); b := ref.back;
IF b # NIL THEN
out.WriteChar(" ");
InsertRefView(b.type, undo, b.adr, b.back, b.desc, b.ptr, b.name)
END;
out.WriteLn; out.WriteLn;
out.WriteChar("["); WriteHex(ref.adr); out.WriteChar("]"); out.WriteTab;
IF ref.desc = NIL THEN
ShowObject(ref.adr)
ELSIF FormOf(ref.desc) = 12X THEN
ShowArray(ref.adr, 1, ref.desc, ref.ptr, ref, empty)
ELSE
ShowRecord(ref.adr, 1, Kernel.TypeOf(SYSTEM.VAL(ANYPTR, ref.ptr)), ref, empty)
END;
out.WriteLn
END ShowPtrDeref;
PROCEDURE RefCh (VAR ref: INTEGER; VAR ch: SHORTCHAR);
BEGIN
SYSTEM.GET(ref, ch); INC(ref)
END RefCh;
PROCEDURE RefNum (VAR ref: INTEGER; VAR x: INTEGER);
VAR s, n: INTEGER; ch: SHORTCHAR;
BEGIN
s := 0; n := 0; RefCh(ref, ch);
WHILE ORD(ch) >= 128 DO INC(n, ASH(ORD(ch) - 128, s) ); INC(s, 7); RefCh(ref, ch) END;
x := n + ASH(ORD(ch) MOD 64 - ORD(ch) DIV 64 * 64, s)
END RefNum;
PROCEDURE RefName (VAR ref: INTEGER; VAR n: Kernel.Name);
VAR i: INTEGER; ch: SHORTCHAR;
BEGIN
i := 0; RefCh(ref, ch);
WHILE ch # 0X DO n[i] := ch; INC(i); RefCh(ref, ch) END;
n[i] := 0X
END RefName;
PROCEDURE SourcePos* ( mod: Kernel.Module; codePos: INTEGER ): INTEGER;
VAR ref, pos, ad, d: INTEGER; ch: SHORTCHAR; name: Kernel.Name;
BEGIN
IF mod # NIL THEN (* mf, 12.02.04 *)
ref := mod.refs; pos := 0; ad := 0; SYSTEM.GET( ref, ch );
WHILE ch # 0X DO
WHILE (ch > 0X) & (ch < 0FCX) DO
INC( ad, LONG( ORD( ch ) ) ); INC( ref ); RefNum( ref, d );
IF ad > codePos THEN RETURN pos END;
INC(pos, d); SYSTEM.GET( ref, ch )
END;
IF ch = 0FCX THEN
INC(ref); RefNum(ref, d); RefName(ref, name); SYSTEM.GET(ref, ch);
IF (d > codePos) & (pos > 0) THEN RETURN pos END
END;
WHILE ch >= 0FDX DO (* skip variables *)
INC(ref); RefCh(ref, ch);
IF ch = 10X THEN INC(ref, 4) END;
RefNum(ref, d); RefName(ref, name); SYSTEM.GET(ref, ch)
END
END
END;
RETURN -1
END SourcePos;
PROCEDURE Scan (VAR s: TextMappers.Scanner);
BEGIN
s.Scan;
IF s.type = TextMappers.string THEN
IF i21sysVocabulary.IsImport( s.string ) THEN s.type := import
ELSIF i21sysVocabulary.IsModule( s.string ) THEN s.type := smodule
ELSIF s.string = "THEN" THEN s.type := stop
ELSIF s.string = "OF" THEN s.type := stop
ELSIF s.string = "DO" THEN s.type := stop
ELSIF s.string = "END" THEN s.type := stop
ELSIF s.string = "ELSE" THEN s.type := stop
ELSIF s.string = "ELSIF" THEN s.type := stop
ELSIF s.string = "UNTIL" THEN s.type := stop
ELSIF s.string = "TO" THEN s.type := stop
ELSIF s.string = "BY" THEN s.type := stop
END
ELSIF s.type = TextMappers.char THEN
IF s.char = ";" THEN s.type := semicolon
ELSIF s.char = "|" THEN s.type := stop
ELSIF s.char = ":" THEN
IF s.rider.char = "=" THEN s.rider.Read; s.type := becomes END
ELSIF s.char = "(" THEN
IF s.rider.char = "*" THEN
s.rider.Read;
REPEAT Scan(s) UNTIL (s.type = TextMappers.eot) OR (s.type = comEnd);
Scan(s)
END
ELSIF s.char = "*" THEN
IF s.rider.char = ")" THEN s.rider.Read; s.type := comEnd END
END
END
END Scan;
PROCEDURE ShowSourcePos (name: Name; adr: INTEGER);
VAR loc: Files.Locator; fname: Files.Name; v: Views.View; m: Models.Model; conv: Converters.Converter;
c: Containers.Controller; beg, end, p: INTEGER; s: TextMappers.Scanner; w: Windows.Window;
n: ARRAY 256 OF CHAR;
BEGIN
(* search source by name heuristic *)
n := name$; StdDialog.GetSubLoc(n, "Mod", loc, fname);
v := Views.OldView(loc, fname); m := NIL;
IF v # NIL THEN
Views.Open(v, loc, fname, NIL);
m := v.ThisModel();
IF ~(m IS TextModels.Model) THEN m := NIL END
END;
IF m = NIL THEN
(* search in open windows *)
w := Windows.dir.First();
WHILE (w # NIL) & (m = NIL) DO
v := w.doc.ThisView();
m := v.ThisModel();
IF m # NIL THEN
WITH m: TextModels.Model DO
s.ConnectTo(m); s.SetPos(0);
REPEAT
REPEAT s.Scan;
UNTIL s.rider.eot OR (s.type = TextMappers.string) & i21sysVocabulary.IsModule( s.string );
s.Scan;
UNTIL s.rider.eot OR (s.type = TextMappers.string) & (s.string = name);
IF ~s.rider.eot THEN Windows.dir.Select(w, Windows.eager)
ELSE m := NIL
END
ELSE m := NIL
END
END;
w := Windows.dir.Next(w)
END
END;
IF m = NIL THEN
(* ask user for source file *)
conv := NIL; v := Views.Old( Views.ask, loc, fname, conv );
IF v # NIL THEN
Views.Open( v, loc, fname, conv );
m := v.ThisModel();
IF ~( m IS TextModels.Model ) THEN m := NIL END
END
END;
IF m # NIL THEN
(* mark error position in text *)
WITH m: TextModels.Model DO
IF i21sysVocabulary.language # '' THEN
i21sysVocabulary.ConvertText( m, m ); (* now m is the compiled English version *)
END;
beg := SourcePos ( Kernel.ThisMod( n ), adr ); (* in the English version *)
IF beg >= 0 THEN
IF beg > m.Length () THEN beg := m.Length () - 10 END;
s.ConnectTo( m ); s.SetPos( beg );
Scan( s ); beg := s.start; end := beg + 3;
IF s.type = stop THEN end := s.Pos() - 1
ELSE
WHILE ( s.type # TextMappers.eot ) & ( s.type # stop ) & ( s.type # semicolon ) DO
end := s.Pos() - 1; Scan(s)
END
END;
IF i21sysVocabulary.language # '' THEN
beg := i21sysVocabulary.OriginalPos( beg );
end := i21sysVocabulary.OriginalPos( end );
END;
v( TextViews.View ).ShowRange( beg, end, TextViews.any );
c := v( TextViews.View ).ThisController();
c( TextControllers.Controller ).SetSelection( beg, end )
END
END
ELSE Dialog.ShowParamMsg("#Dev:SourcefileNotFound", n, "", "")
END
END ShowSourcePos;
(* ------------------- RefView ------------------- *)
PROCEDURE (v: RefView) Internalize (VAR rd: Stores.Reader);
VAR s: Stores.Store; thisVersion: INTEGER;
BEGIN
v.Internalize^(rd); IF rd.cancelled THEN RETURN END;
rd.ReadVersion(0, 0, thisVersion); IF rd.cancelled THEN RETURN END;
v.command := open;
rd.ReadSInt(v.type);
IF v.type = source THEN
rd.ReadInt(v.adr);
rd.ReadSString(v.name)
ELSIF v.type = module THEN
rd.ReadSString(v.name)
ELSIF v.type # modules THEN
v.type := 0
END
END Internalize;
PROCEDURE (v: RefView) Externalize (VAR wr: Stores.Writer);
VAR t: SHORTINT;
BEGIN
v.Externalize^(wr);
wr.WriteVersion(0);
t := v.type;
IF v.command # open THEN t := 0 END;
wr.WriteSInt(t);
IF t = source THEN
wr.WriteInt(v.adr);
wr.WriteSString(v.name)
ELSIF t = module THEN
wr.WriteSString(v.name)
END
END Externalize;
PROCEDURE (v: RefView) CopyFromSimpleView (source: Views.View);
BEGIN
(* v.CopyFrom^(source); *)
WITH source: RefView DO
v.type := source.type; v.command := source.command; v.adr := source.adr; v.back := source.back;
v.desc := source.desc; v.ptr := source.ptr; v.name := source.name$;
END
END CopyFromSimpleView;
PROCEDURE (v: RefView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawPath(path, 4, Ports.fill, Ports.blue, Ports.closedPoly)
END Restore;
PROCEDURE (v: RefView) GetBackground (VAR color: Ports.Color);
BEGIN
color := Ports.background
END GetBackground;
PROCEDURE (v: RefView) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message; VAR focus: Views.View);
VAR t, t0: TextModels.Model; m: Models.Model; x, y: INTEGER;
isDown, new: BOOLEAN; mo: SET; script: Stores.Operation;
BEGIN
WITH msg: Controllers.TrackMsg DO
IF v.type > 0 THEN
REPEAT
f.MarkRect( 0, 0, refViewSize, refViewSize, Ports.fill, Ports.hilite, Ports.show );
IF v.command = undo THEN Dialog.ShowStatus("#Dev:ShowPrecedingObject")
ELSIF v.command = update THEN Dialog.ShowStatus("#Dev:UpdateWindow")
ELSIF v.type = module THEN Dialog.ShowStatus("#Dev:ShowGlobalVariables")
ELSIF v.type = source THEN Dialog.ShowStatus("#Dev:ShowSourcePosition")
ELSIF v.type = heap THEN Dialog.ShowStatus("#Dev:ShowReferencedObject")
END;
REPEAT
f.Input(x, y, mo, isDown)
UNTIL (x < 0) OR (x > refViewSize) OR (y < 0) OR (y > refViewSize) OR ~isDown;
f.MarkRect(0, 0, refViewSize, refViewSize, Ports.fill, Ports.hilite, Ports.hide);
Dialog.ShowStatus("");
WHILE isDown & ((x < 0) OR (x > refViewSize) OR (y < 0) OR (y > refViewSize)) DO
f.Input(x, y, mo, isDown)
END
UNTIL ~isDown;
IF (x >= 0) & (x <= refViewSize) & (y >= 0) & (y <= refViewSize) THEN
IF v.type = source THEN ShowSourcePos(v.name, v.adr)
ELSE
m := v.context.ThisModel();
new := (v.command = open) & (v.back = NIL)
OR (Controllers.modify IN msg.modifiers) & (v.command # update)
OR ~(m IS TextModels.Model) ;
IF new THEN
t := TextModels.CloneOf(StdLog.buf); t0 := NIL
ELSE
t0 := m(TextModels.Model); t := TextModels.CloneOf(t0);
END;
out.ConnectTo(t);
IF v.type = heap THEN ShowPtrDeref(v)
ELSIF v.type = module THEN ShowGlobals(Kernel.ThisLoadedMod(v.name))
ELSIF v.type = modules THEN ShowModules
END;
out.ConnectTo(NIL);
IF new THEN
OpenViewer(t, "#Dev:Variables", NewRuler())
ELSE
Models.BeginScript(t0, "#Dev:Change", script);
t0.Delete(0, t0.Length()); t0.Insert(0, t, 0, t.Length());
Models.EndScript(t0, script)
END
END
END
END
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.refCursor
ELSE
END
END HandleCtrlMsg;
PROCEDURE (v: RefView) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.Preference DO
WITH msg: Properties.ResizePref DO msg.fixed := TRUE
| msg: Properties.SizePref DO msg.w := refViewSize; msg.h := refViewSize
| msg: Properties.FocusPref DO msg.hotFocus := TRUE
ELSE
END
ELSE
END
END HandlePropMsg;
PROCEDURE NewRefView (type, command: SHORTINT; adr: INTEGER; back: RefView;
desc: Kernel.Type; ptr: ArrayPtr; name: Name): RefView;
VAR v: RefView;
BEGIN
NEW(v); v.type := type; v.command := command; v.adr := adr; v.back := back;
v.desc := desc; v.ptr := ptr; v.name := name$;
RETURN v
END NewRefView;
PROCEDURE InsertRefView (type, command: SHORTINT; adr: INTEGER; back: RefView;
desc: Kernel.Type; ptr: ArrayPtr; name: Name);
VAR v: RefView; a0: TextModels.Attributes;
BEGIN
v := NewRefView(type, command, adr, back, desc, ptr, name);
a0 := out.rider.attr;
out.rider.SetAttr(TextModels.NewOffset(a0, Ports.point));
out.WriteView(v);
out.rider.SetAttr(a0)
END InsertRefView;
PROCEDURE HeapRefView* (adr: INTEGER; name: ARRAY OF CHAR): Views.View;
VAR n: Name; ptr: ArrayPtr;
BEGIN
n := SHORT(name$);
ptr := SYSTEM.VAL(ArrayPtr, adr);
RETURN NewRefView(heap, open, adr, NIL, NIL, ptr, n)
END HeapRefView;
(* ----------------------------------------- *)
PROCEDURE GetMod (VAR mod: Kernel.Module);
VAR c: TextControllers.Controller; s: TextMappers.Scanner; beg, end: INTEGER;
BEGIN
mod := NIL;
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
s.ConnectTo(c.text); s.SetPos(beg); s.Scan;
IF s.type = TextMappers.string THEN
mod := Kernel.ThisMod(s.string);
IF mod = NIL THEN
Dialog.ShowParamMsg("#Dev:ModuleNotFound", s.string, "", "")
END
ELSE Dialog.ShowMsg("#Dev:NoModuleNameSelected")
END
ELSE Dialog.ShowMsg("#Dev:NoSelectionFound")
END
END GetMod;
PROCEDURE ShowLoadedModules*;
BEGIN
out.ConnectTo(TextModels.CloneOf(StdLog.buf));
ShowModules;
OpenViewer(out.rider.Base(), "#Dev:LoadedModules", NewModRuler());
out.ConnectTo(NIL)
END ShowLoadedModules;
PROCEDURE UpdateModules*;
VAR t, t0: TextModels.Model; script: Stores.Operation;
BEGIN
t0 := TextViews.FocusText();
Models.BeginScript(t0, "#Dev:Change", script);
t := TextModels.CloneOf(t0);
out.ConnectTo(t);
ShowModules;
(*Stores.InitDomain(t, t0.domain);*) Stores.Join(t, t0); (* not efficient to init domain before writing *)
t0.Delete(0, t0.Length()); t0.Insert(0, t, 0, t.Length());
Models.EndScript(t0, script);
out.ConnectTo(NIL)
END UpdateModules;
PROCEDURE ShowGlobalVariables*;
VAR mod: Kernel.Module;
BEGIN
GetMod(mod);
IF mod # NIL THEN
out.ConnectTo(TextModels.CloneOf(StdLog.buf));
ShowGlobals(mod);
OpenViewer(out.rider.Base(), "#Dev:Variables", NewRuler());
out.ConnectTo(NIL)
END
END ShowGlobalVariables;
PROCEDURE UpdateGlobals* (name: ARRAY OF CHAR);
VAR t, t0: TextModels.Model; script: Stores.Operation; mod: Kernel.Module; n: Kernel.Name;
BEGIN
n := SHORT(name$); mod := Kernel.ThisLoadedMod(n);
IF mod # NIL THEN
t0 := TextViews.FocusText();
Models.BeginScript(t0, "#Dev:Change", script);
t := TextModels.CloneOf(t0);
out.ConnectTo(t);
ShowGlobals(mod);
(*Stores.InitDomain(t, t0.domain);*) Stores.Join(t, t0); (* not efficient to init domain before writing *)
t0.Delete(0, t0.Length()); t0.Insert(0, t, 0, t.Length());
Models.EndScript(t0, script);
out.ConnectTo(NIL)
END
END UpdateGlobals;
PROCEDURE ShowHeapObject* (adr: INTEGER; title: ARRAY OF CHAR);
BEGIN
out.ConnectTo(TextModels.CloneOf(StdLog.buf));
IF title # "" THEN
out.WriteString(title); out.WriteLn; out.WriteLn
END;
out.WriteChar("["); WriteHex(adr); out.WriteChar("]"); out.WriteTab;
ShowObject(adr);
out.WriteLn;
OpenViewer(out.rider.Base(), "#Dev:HeapObject", NewRuler());
out.ConnectTo(NIL)
END ShowHeapObject;
PROCEDURE ShowViewState*;
VAR ops: Controllers.PollOpsMsg;
BEGIN
Controllers.PollOps(ops);
IF ops.singleton # NIL THEN
ShowHeapObject(SYSTEM.VAL(INTEGER, ops.singleton), "")
END
END ShowViewState;
PROCEDURE UnloadMod (name: TextMappers.String; VAR ok: BOOLEAN);
VAR mod: Kernel.Module; str: Dialog.String; n: Kernel.Name;
BEGIN
n := SHORT(name$); mod := Kernel.ThisLoadedMod(n);
IF mod # NIL THEN
Dialog.ShowParamStatus("#Dev:Unloading", name, "", "");
Kernel.UnloadMod(mod);
IF mod.refcnt < 0 THEN
Dialog.MapParamString("#Dev:Unloaded", name, "", "", str);
StdLog.String(str); StdLog.Ln
ELSE
Dialog.ShowParamMsg("#Dev:UnloadingFailed", name, "", "");
ok := FALSE
END
ELSE
Dialog.ShowParamMsg("#Dev:NotFound", name, "", "");
ok := FALSE;
END
END UnloadMod;
PROCEDURE Unload*;
VAR t: TextModels.Model; s: TextMappers.Scanner; ok: BOOLEAN;
BEGIN
t := TextViews.FocusText();
IF t # NIL THEN
s.ConnectTo(t); s.SetPos(0);
REPEAT Scan(s) UNTIL (s.type = smodule) OR s.rider.eot;
IF (s.type = smodule) THEN
Scan(s);
IF (s.type = TextMappers.string) & IsIdent(s.string) THEN
ok := TRUE; UnloadMod(s.string, ok);
IF ok THEN
Dialog.ShowStatus("#Dev:Ok");
END;
Controls.Relink
ELSE
Dialog.ShowMsg("#Dev:NoModNameFound");
END
ELSE
Dialog.ShowMsg("#Dev:NoModNameFound");
END
END
END Unload;
PROCEDURE UnloadList(beg, end: INTEGER; c: TextControllers.Controller);
VAR s: TextMappers.Scanner; res: INTEGER; ok, num: BOOLEAN; linked: ARRAY 16 OF CHAR;
BEGIN
s.ConnectTo(c.text); s.SetPos(beg); s.Scan; ok := TRUE; num := FALSE;
WHILE (s.start < end) & (s.type # TextMappers.invalid) DO
Dialog.MapString("#Dev:Linked", linked);
IF (s.type = TextMappers.string) & (s.string # linked) THEN
IF num & ((s.string = "AM") OR (s.string = "PM")) THEN s.Scan (* skip am & pm *)
ELSIF IsIdent(s.string) THEN UnloadMod(s.string, ok); s.Scan
ELSE s.type := TextMappers.invalid
END
ELSE
(* skip numbers to allow selection of list of loaded modules *)
num := TRUE; s.Scan
END
END;
IF ok THEN Dialog.ShowStatus("#Dev:Ok") END;
Controls.Relink
END UnloadList;
PROCEDURE UnloadModuleList*;
VAR c: TextControllers.Controller; s: TextMappers.Scanner; res, beg, end: INTEGER;
ok, num: BOOLEAN; linked: ARRAY 16 OF CHAR;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
UnloadList(beg, end, c)
END
END UnloadModuleList;
PROCEDURE UnloadThis*;
VAR p: DevCommanders.Par; beg, end: INTEGER; c: TextControllers.Controller;
BEGIN
p := DevCommanders.par;
IF p # NIL THEN
DevCommanders.par := NIL;
beg := p.beg; end := p.end;
c := TextControllers.Focus();
IF c # NIL THEN UnloadList(beg, end, c) END
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END
END UnloadThis;
PROCEDURE Execute*;
VAR beg, end, start, res, i: INTEGER; done: BOOLEAN;
c: TextControllers.Controller; s: TextMappers.Scanner; cmd: Dialog.String;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
s.ConnectTo(c.text); s.SetPos(beg); s.Scan; TextMappers.ScanQualIdent(s, cmd, done);
IF done THEN
Dialog.Call(cmd, " ", res)
ELSIF s.type = TextMappers.string THEN
Dialog.Call(s.string, " ", res)
ELSE
Dialog.ShowMsg("#Dev:StringExpected")
END
ELSE Dialog.ShowMsg("#Dev:NoSelectionFound")
END
END Execute;
PROCEDURE ShowStack;
VAR ref, end, i, j, x, a, b, c: INTEGER; m, f: SHORTCHAR; mod: Kernel.Module; name, sel: Kernel.Name;
d: Kernel.Type;
BEGIN
a := Kernel.pc; b := Kernel.fp; c := 100;
REPEAT
mod := Kernel.modList;
WHILE (mod # NIL) & ((a < mod.code) OR (a >= mod.code + mod.csize)) DO mod := mod.next END;
IF mod # NIL THEN
DEC(a, mod.code);
IF mod.refcnt >= 0 THEN
InsertRefView(module, open, 0, NIL, NIL, NIL, mod.name);
out.WriteChar(" "); out.WriteSString(mod.name);
ref := mod.refs;
REPEAT Kernel.GetRefProc(ref, end, name) UNTIL (end = 0) OR (a < end);
IF a < end THEN
out.WriteChar("."); out.WriteSString(name);
sel := mod.name$; i := 0;
WHILE sel[i] # 0X DO INC(i) END;
sel[i] := "."; INC(i); j := 0;
WHILE name[j] # 0X DO sel[i] := name[j]; INC(i); INC(j) END;
sel[i] := ":"; sel[i+1] := 0X;
out.WriteSString(" ["); WriteHex(a); out.WriteSString("] ");
i := SourcePos(mod, 0);
IF i >= 0 THEN
InsertRefView( source, open, a, NIL, NIL, NIL, mod.name );
END;
IF name # "$$" THEN
Kernel.GetRefVar(ref, m, f, d, x, name);
WHILE m # 0X DO
ShowVar(b + x, 0, f, m, d, NIL, NIL, name, sel);
Kernel.GetRefVar(ref, m, f, d, x, name);
END
END;
out.WriteLn
ELSE out.WriteSString(".???"); out.WriteLn
END
ELSE
out.WriteChar("("); out.WriteSString(mod.name);
out.WriteSString(") (pc="); WriteHex(a);
out.WriteSString(", fp="); WriteHex(b); out.WriteChar(")");
out.WriteLn
END
ELSE
out.WriteSString("<system> (pc="); WriteHex(a);
out.WriteSString(", fp="); WriteHex(b); out.WriteChar(")");
out.WriteLn
END;
IF (b >= Kernel.fp) & (b < Kernel.stack) THEN
SYSTEM.GET(b+4, a); (* stacked pc *)
SYSTEM.GET(b, b); (* dynamic link *)
DEC(a); DEC(c)
ELSE c := 0
END
UNTIL c = 0
END ShowStack;
PROCEDURE (a: Action) Do; (* delayed trap window open *)
BEGIN
Kernel.SetTrapGuard(TRUE);
OpenViewer(a.text, "#Dev:Trap", NewRuler());
Kernel.SetTrapGuard(FALSE);
END Do;
PROCEDURE GetTrapMsg(OUT msg: ARRAY OF CHAR);
VAR ref, end, a: INTEGER; mod: Kernel.Module; name: Kernel.Name; head, tail, errstr: ARRAY 32 OF CHAR;
key: ARRAY 128 OF CHAR;
BEGIN
a := Kernel.pc; mod := Kernel.modList;
WHILE (mod # NIL) & ((a < mod.code) OR (a >= mod.code + mod.csize)) DO mod := mod.next END;
IF mod # NIL THEN
DEC(a, mod.code); ref := mod.refs;
REPEAT Kernel.GetRefProc(ref, end, name) UNTIL (end = 0) OR (a < end);
IF a < end THEN
Kernel.SplitName (mod.name$, head, tail);
IF head = "" THEN head := "System" END;
Strings.IntToString(Kernel.err, errstr);
key := tail + "." + name + "." + errstr;
Dialog.MapString("#" + head + ":" + key, msg);
(* IF key # msg THEN out.WriteString(" " + msg) END; *)
IF key = msg THEN msg := "" END;
END
END
END GetTrapMsg;
PROCEDURE Trap;
VAR a0: TextModels.Attributes; prop: Properties.StdProp; action: Action;
msg: ARRAY 512 OF CHAR;
PROCEDURE Write ( msg: ARRAY OF CHAR );
VAR msg1: ARRAY 512 OF CHAR;
BEGIN
Dialog.MapString( "#Dev:"+msg, msg1 );
out.WriteString( msg1 )
END Write;
BEGIN
out.ConnectTo(TextModels.CloneOf(StdLog.buf));
a0 := out.rider.attr;
out.rider.SetAttr(TextModels.NewWeight(a0, Fonts.bold));
IF Kernel.err = 129 THEN Write("invalid WITH")
ELSIF Kernel.err = 130 THEN Write("invalid CASE")
ELSIF Kernel.err = 131 THEN Write("function without RETURN")
ELSIF Kernel.err = 132 THEN Write("type guard")
ELSIF Kernel.err = 133 THEN Write("implied type guard")
ELSIF Kernel.err = 134 THEN Write("value out of range")
ELSIF Kernel.err = 135 THEN Write("index out of range")
ELSIF Kernel.err = 136 THEN Write("string too long")
ELSIF Kernel.err = 137 THEN Write("stack overflow")
ELSIF Kernel.err = 138 THEN Write("integer overflow")
ELSIF Kernel.err = 139 THEN Write("division by zero")
ELSIF Kernel.err = 140 THEN Write("infinite real result")
ELSIF Kernel.err = 141 THEN Write("real underflow")
ELSIF Kernel.err = 142 THEN Write("real overflow")
ELSIF Kernel.err = 143 THEN
Write("undefined real result (");
out.WriteIntForm(Kernel.val MOD 10000H, TextMappers.hexadecimal, 4, "0", TextMappers.hideBase); out.WriteSString(", ");
out.WriteIntForm(Kernel.val DIV 10000H, TextMappers.hexadecimal, 3, "0", TextMappers.hideBase); out.WriteChar(")")
ELSIF Kernel.err = 144 THEN Write("not a number")
ELSIF Kernel.err = 200 THEN Write("keyboard interrupt")
ELSIF Kernel.err = 201 THEN Write("NIL dereference")
ELSIF Kernel.err = 202 THEN
out.WriteSString("illegal instruction: ");
out.WriteIntForm(Kernel.val, TextMappers.hexadecimal, 5, "0", TextMappers.showBase)
ELSIF Kernel.err = 203 THEN
IF (Kernel.val >= -4) & (Kernel.val < 65536) THEN out.WriteSString("NIL dereference (read)")
ELSE out.WriteSString("illegal memory read (ad = "); WriteHex(Kernel.val); out.WriteChar(")")
END
ELSIF Kernel.err = 204 THEN
IF (Kernel.val >= -4) & (Kernel.val < 65536) THEN out.WriteSString("NIL dereference (write)")
ELSE out.WriteSString("illegal memory write (ad = "); WriteHex(Kernel.val); out.WriteChar(")")
END
ELSIF Kernel.err = 205 THEN
IF (Kernel.val >= -4) & (Kernel.val < 65536) THEN out.WriteSString("NIL procedure call")
ELSE out.WriteSString("illegal execution (ad = "); WriteHex(Kernel.val); out.WriteChar(")")
END
ELSIF Kernel.err = 257 THEN out.WriteSString("out of memory")
ELSIF Kernel.err = 10001H THEN out.WriteSString("bus error")
ELSIF Kernel.err = 10002H THEN out.WriteSString("address error")
ELSIF Kernel.err = 10007H THEN out.WriteSString("fpu error")
ELSIF Kernel.err < 0 THEN
out.WriteSString("Exception "); out.WriteIntForm(-Kernel.err, TextMappers.hexadecimal, 3, "0", TextMappers.showBase)
ELSE
Write("TRAP "); out.WriteInt(Kernel.err);
IF Kernel.err = 126 THEN Write(" (not yet implemented)")
ELSIF Kernel.err = 125 THEN Write(" (call of obsolete procedure)")
ELSIF Kernel.err >= 100 THEN Write(" (invariant violated)")
ELSIF Kernel.err >= 60 THEN Write(" (postcondition violated)")
ELSIF Kernel.err >= 20 THEN Write(" (precondition violated)")
END
END;
GetTrapMsg(msg);
IF msg # "" THEN out.WriteLn; out.WriteString(msg) END;
out.WriteLn; out.rider.SetAttr(a0);
out.WriteLn; ShowStack;
NEW(action); action.text := out.rider.Base();
Services.DoLater(action, Services.now);
out.ConnectTo(NIL)
END Trap;
BEGIN
Kernel.InstallTrapViewer(Trap);
empty := "";
path[0].x := refViewSize DIV 2; path[0].y := 0;
path[1].x := refViewSize; path[1].y := refViewSize DIV 2;
path[2].x := refViewSize DIV 2; path[2].y := refViewSize;
path[3].x := 0; path[3].y := refViewSize DIV 2
END DevDebug. | Dev/Mod/Debug.odc |
MODULE DevDependencies;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Kernel, Files, Dialog, TextMappers, TextControllers, StdDialog, StdFolds, Strings, Views, Ports,
Fonts, Properties, Controllers, Stores, HostMenus, HostPorts, StdCmds, Math,
TextModels, TextViews, Dates, DevCommanders;
CONST
bold = 0; italic = 1; (* used with SetStyle *)
full = TRUE; (* used with DependencyList *)
implicit = TRUE; (* used with GetNode *)
TYPE
String = ARRAY 256 OF CHAR;
(** Data structure types **)
Subgraph = POINTER TO RECORD (Stores.Store)
node: List;
isImplicit: BOOLEAN;
next: Subgraph
END;
SubsystemList = POINTER TO RECORD (Stores.Store)
name: String;
isExpanded, isLayedout, isHidden, isBasic, isStart, isSelected: BOOLEAN;
l, b, w, h, level: INTEGER;
next: SubsystemList
END;
List = POINTER TO RECORD (Stores.Store)
name: String;
imports: Subgraph;
subsystem: SubsystemList;
l, b, w, h: INTEGER;
isLayedout, isHidden, isStart, isSelected, isImported, onlyImplicit: BOOLEAN;
next: List
END;
NameList = POINTER TO RECORD (Stores.Store)
name: String;
next: NameList
END;
(** View type **)
View = POINTER TO RECORD (Views.View)
list: List;
startList: NameList;
subsystems: SubsystemList;
maxLevel, nofMods: INTEGER;
selfont, normfont: Fonts.Font;
showBasic: BOOLEAN
END;
(** Meta types **)
MetaList = POINTER TO RECORD list: List; next: MetaList END;
MetaSSList = POINTER TO RECORD sslist: SubsystemList; next: MetaSSList END;
(** Operation types **)
DepOp = POINTER TO ABSTRACT RECORD (Stores.Operation)
view: View;
mods: MetaList; subs: MetaSSList
END;
ExpandOp = POINTER TO RECORD (DepOp) expand: BOOLEAN END;
MoveOp = POINTER TO RECORD (DepOp) dx, dy, l, t, r, b: INTEGER END;
HideOp = POINTER TO RECORD (DepOp) END;
HideBasicOp = POINTER TO RECORD (Stores.Operation) view: View END;
ShowAllOp = POINTER TO RECORD (DepOp) END;
ExpandAllOp = POINTER TO RECORD (DepOp) expand: BOOLEAN END;
(** Forward declaragions **)
PROCEDURE^ StartAnalysis (startList: NameList; font: Fonts.Font; incImpl: BOOLEAN; OUT v: View);
(** Auxiliary procedures **)
PROCEDURE RWord (reader: Files.Reader; OUT x: INTEGER);
VAR b: BYTE; y: INTEGER;
BEGIN
reader.ReadByte(b); y := b MOD 256;
reader.ReadByte(b); y := y + 100H * (b MOD 256);
reader.ReadByte(b); y := y + 10000H * (b MOD 256);
reader.ReadByte(b); x := y + 1000000H * b
END RWord;
PROCEDURE RNum (reader: Files.Reader; OUT x: INTEGER);
VAR b: BYTE; s, y: INTEGER;
BEGIN
s := 0; y := 0; reader.ReadByte(b);
WHILE b < 0 DO INC(y, ASH(b + 128, s)); INC(s, 7); reader.ReadByte(b) END;
x := ASH((b + 64) MOD 128 - 64, s) + y
END RNum;
PROCEDURE RName (reader: Files.Reader; OUT name: ARRAY OF CHAR);
VAR b: BYTE; i, n: INTEGER;
BEGIN
i := 0; n := LEN(name) - 1; reader.ReadByte(b);
WHILE (i < n) & (b # 0) DO name[i] := SHORT(CHR(b)); INC(i); reader.ReadByte(b) END;
WHILE b # 0 DO reader.ReadByte(b) END;
name[i] := 0X
END RName;
PROCEDURE GetImports(IN name: String;
OUT imps: POINTER TO ARRAY OF String; OUT nofImps: INTEGER; OUT found: BOOLEAN);
VAR
file: Files.File; loc: Files.Locator; fileName: Files.Name; reader: Files.Reader;
n, i, j, tmpWord: INTEGER;
impName, dollarStr: String; tmpImps: POINTER TO ARRAY OF String;
BEGIN
found := TRUE;
StdDialog.GetSubLoc(name, "Code", loc, fileName);
file := Files.dir.Old(loc, fileName, Files.shared);
IF file # NIL THEN
reader := file.NewReader(NIL); reader.SetPos(0); RWord(reader, n);
IF n = 6F4F4346H THEN
RWord(reader, tmpWord); RWord(reader, tmpWord); RWord(reader, tmpWord); RWord(reader, tmpWord);
RWord(reader, tmpWord); RWord(reader, tmpWord); RNum(reader, n); RName(reader, impName);
i := 0; nofImps := n; IF nofImps > 0 THEN NEW(imps, nofImps) END;
FOR i :=0 TO n - 1 DO
RName(reader, impName); Strings.Extract(impName$, 0, 1, dollarStr);
IF dollarStr = "$" THEN (* To avoid analysis of windows platform imports *)
imps[i] := ""; DEC(nofImps)
ELSE
imps[i] := impName$
END
END;
IF nofImps # n THEN (* some names are empty, delete them *)
IF nofImps = 0 THEN
imps := NIL
ELSE
NEW(tmpImps, nofImps); j := 0;
FOR i := 0 TO n-1 DO IF imps[i] # "" THEN tmpImps[j] := imps[i]; INC(j) END END;
imps := tmpImps
END
END
END
ELSE
found := FALSE
END
END GetImports;
PROCEDURE GetImplicitDependencies(
IN name: String; OUT imps: POINTER TO ARRAY OF String; OUT nofImps: INTEGER
);
VAR deps: String; t: TextModels.Model; s: TextMappers.Scanner; i: INTEGER;
BEGIN
Dialog.MapString("#Dev:Implicit." + name, deps);
IF deps # "Implicit." + name THEN
t := TextModels.dir.NewFromString(deps); s.ConnectTo(t); s.SetPos(0); s.Scan; i := 0;
WHILE s.type # TextMappers.eot DO
IF s.type = TextMappers.string THEN INC(i) END;
s.Scan
END;
nofImps := i; NEW(imps, nofImps);
s.SetPos(0); s.Scan; i := 0;
WHILE s.type # TextMappers.eot DO
IF s.type = TextMappers.string THEN imps[i] := s.string$; INC(i) END;
s.Scan
END
ELSE
imps := NIL; nofImps := 0
END
END GetImplicitDependencies;
PROCEDURE GetModuleList (OUT modList: NameList);
VAR c: TextControllers.Controller; s: TextMappers.Scanner; beg, end: INTEGER; l: NameList;
BEGIN
modList := NIL;
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
s.ConnectTo(c.text); s.SetPos(beg); s.Scan;
WHILE (s.start < end) & (s.type # TextMappers.invalid) DO
IF (s.type = TextMappers.string) THEN
NEW(l); IF modList # NIL THEN Stores.Join(modList, l) END;
l.next := modList; l.name := s.string$; modList := l; s.Scan
ELSE
s.Scan
END
END
END
END GetModuleList;
(** List **)
PROCEDURE (l: List) GetExtent(OUT w, h: INTEGER), NEW;
BEGIN
IF l.subsystem.isExpanded THEN w := l.w; h:= l.h
ELSE w := l.subsystem.w; h := l.subsystem.h END
END GetExtent;
PROCEDURE (l: List) GetPosition(OUT x, y: INTEGER), NEW;
BEGIN
IF l.subsystem.isExpanded THEN x := l.l; y:= l.b
ELSE x := l.subsystem.l; y := l.subsystem.b END
END GetPosition;
PROCEDURE (l: List) SetPosition(x, y: INTEGER), NEW;
BEGIN
IF x < 1 THEN x := 1 END; IF y < 1 THEN y := 1 END; (* To keep objects in the second quadrant *)
IF l.subsystem.isExpanded THEN l.l := x; l.b:= y
ELSE l.subsystem.l := x; l.subsystem.b := y END
END SetPosition;
PROCEDURE (l: List) Selected(): BOOLEAN, NEW;
BEGIN
RETURN l.subsystem.isExpanded & l.isSelected
END Selected;
PROCEDURE (l: List) Visible(showBasic: BOOLEAN): BOOLEAN, NEW;
BEGIN
RETURN l.subsystem.isExpanded
& ~l.isHidden & ~l.subsystem.isHidden & (~l.subsystem.isBasic OR showBasic)
END Visible;
(** SubsystemList **)
PROCEDURE (s: SubsystemList) Selected(): BOOLEAN, NEW;
BEGIN
RETURN ~s.isExpanded & s.isSelected
END Selected;
PROCEDURE (s: SubsystemList) Visible(showBasic: BOOLEAN): BOOLEAN, NEW;
BEGIN
RETURN ~s.isExpanded & ~s.isHidden & (~s.isBasic OR showBasic)
END Visible;
(** View **)
PROCEDURE (v: View) GetNode (name: String; incImpl: BOOLEAN; VAR node: List), NEW;
VAR
tmpList, tmpNode: List; sl: NameList;
tmpGraph, prevGraph: Subgraph;
nofImps, i: INTEGER; found: BOOLEAN;
head, tail: String;
sslist: SubsystemList;
imps: POINTER TO ARRAY OF String;
BEGIN
(* First check if a node with the sought name exists in the nodeList.
Otherwise build a new subgraph from objectfiles. *)
tmpList := v.list;
WHILE (tmpList # NIL) & (tmpList.name # name) DO tmpList := tmpList.next END;
IF tmpList # NIL THEN
node := tmpList
ELSE
(* Create a new node from an objectfile. *)
GetImports(name, imps, nofImps, found);
IF found THEN
NEW(tmpList); Stores.Join(v, tmpList); INC(v.nofMods);
tmpList.name := name;
(* if subsystem exists then use it otherwise create a new one *)
Kernel.SplitName(name, head, tail); IF head = "" THEN head := "System" END;
sslist := v.subsystems;
WHILE (sslist # NIL) & (sslist.name # head) DO sslist := sslist.next END;
IF sslist = NIL THEN
NEW (sslist); Stores.Join(v, sslist); sslist.name := head; sslist.next := v.subsystems;
sslist.level := v.maxLevel; sslist.isExpanded := FALSE;
v.subsystems := sslist
END;
sl := v.startList; (* If it is one of the start modules it should be expanded *)
WHILE (sl # NIL) & (sl.name # name) DO sl := sl.next END;
IF sl # NIL THEN
sslist.isExpanded := TRUE; sslist.level := 1; sslist.isStart := TRUE; tmpList.isStart := TRUE
END;
tmpList.subsystem := sslist; tmpList.imports := NIL;
tmpList.next := v.list; v.list := tmpList; tmpGraph := NIL;
FOR i := 0 TO nofImps - 1 DO
prevGraph := tmpGraph; NEW(tmpGraph); tmpGraph.isImplicit := FALSE; Stores.Join(v, tmpGraph);
v.GetNode(imps[i], incImpl, tmpNode);
tmpNode.isImported := TRUE; (* to be able to identify root modules *)
tmpGraph.node := tmpNode; tmpGraph.next := prevGraph
END;
IF incImpl THEN
GetImplicitDependencies(name, imps, nofImps);
FOR i := 0 TO nofImps - 1 DO
prevGraph := tmpGraph; NEW(tmpGraph); tmpGraph.isImplicit := TRUE; Stores.Join(v, tmpGraph);
v.GetNode(imps[i], incImpl, tmpNode);
tmpGraph.node := tmpNode; tmpGraph.next := prevGraph
END
END;
tmpList.imports := tmpGraph; node := tmpList
ELSE
Dialog.ShowParamMsg("#Dev:ModuleNotFound", name, "", "")
END
END
END GetNode;
PROCEDURE (v: View) OnSelectedObject(x, y: INTEGER): BOOLEAN, NEW;
VAR
l: List; s: SubsystemList;
BEGIN
l := v.list;
WHILE l # NIL DO
IF l.Visible(v.showBasic) & l.Selected() & (x > l.l) & (x < l.l + l.w) & (y < l.b) & (y > l.b - l.h) THEN
RETURN TRUE
END;
l := l.next
END;
s := v.subsystems;
WHILE s # NIL DO
IF s.Visible(v.showBasic) & s.Selected() & (x > s.l) & (x < s.l + s.w) & (y < s.b) & (y > s.b - s.h) THEN
RETURN TRUE
END;
s := s.next
END;
RETURN FALSE
END OnSelectedObject;
PROCEDURE (v: View) OnObject(x, y: INTEGER): BOOLEAN, NEW;
VAR
l: List; s: SubsystemList;
BEGIN
l := v.list;
WHILE l # NIL DO
IF l.Visible(v.showBasic) & (x > l.l) & (x < l.l + l.w) & (y < l.b) & (y > l.b - l.h) THEN
RETURN TRUE
END;
l := l.next
END;
s := v.subsystems;
WHILE s # NIL DO
IF s.Visible(v.showBasic) & (x > s.l) & (x < s.l + s.w) & (y < s.b) & (y > s.b - s.h) THEN
RETURN TRUE
END;
s := s.next
END;
RETURN FALSE
END OnObject;
PROCEDURE OverLap(l1, t1, r1, b1, l2, t2, r2, b2: INTEGER): BOOLEAN;
BEGIN
RETURN ~((l1 > r2) OR (l2 > r1) OR (t1 > b2) OR (t2 > b1))
END OverLap;
PROCEDURE (v: View) Select(x1, y1, x2, y2: INTEGER; modifiers: SET), NEW;
VAR l: List; s: SubsystemList;
BEGIN
l := v.list;
WHILE l # NIL DO
IF l.Visible(v.showBasic) & OverLap(l.l, l.b - l.h, l.l + l.w, l.b, x1, y1, x2, y2) THEN
IF (Controllers.extend IN modifiers) OR (Controllers.modify IN modifiers) THEN
l.isSelected := ~l.isSelected
ELSE
l.isSelected := TRUE
END
ELSE
IF ~(Controllers.extend IN modifiers) & ~(Controllers.modify IN modifiers) THEN l.isSelected := FALSE END
END;
l := l.next
END;
s := v.subsystems;
WHILE s # NIL DO
IF s.Visible(v.showBasic) & OverLap(s.l, s.b - s.h, s.l + s.w, s.b, x1, y1, x2, y2) THEN
IF (Controllers.extend IN modifiers) OR (Controllers.modify IN modifiers) THEN
s.isSelected := ~s.isSelected
ELSE
s.isSelected := TRUE
END
ELSE
IF ~(Controllers.extend IN modifiers) & ~(Controllers.modify IN modifiers) THEN
s.isSelected := FALSE
END
END;
s := s.next
END
END Select;
PROCEDURE (v: View) SelectAll(set: BOOLEAN), NEW;
VAR l: List; s: SubsystemList;
BEGIN
l := v.list;
WHILE l # NIL DO l.isSelected := set & l.Visible(v.showBasic); l := l.next END;
s := v.subsystems;
WHILE s # NIL DO s.isSelected := set & s.Visible(v.showBasic); s := s.next END;
Views.Update(v, Views.keepFrames)
END SelectAll;
(** Operations on the View **)
PROCEDURE (dop: DepOp) AddSelection(), NEW;
VAR ml: MetaList; ms: MetaSSList; l: List; s: SubsystemList;
BEGIN
ASSERT(dop.view # NIL, 20);
l := dop.view.list;
WHILE l # NIL DO
IF l.Selected() THEN NEW(ml); ml.list := l; ml.next := dop.mods; dop.mods := ml END; l := l.next
END;
s := dop.view.subsystems;
WHILE s # NIL DO
IF s.Selected() THEN NEW(ms); ms.sslist := s; ms.next := dop.subs; dop.subs := ms END; s := s.next
END
END AddSelection;
PROCEDURE (e: ExpandOp) Do;
VAR l: MetaList; s: MetaSSList;
BEGIN
l := e.mods;
WHILE l # NIL DO l.list.subsystem.isExpanded := e.expand; l := l.next END;
s := e.subs;
WHILE s # NIL DO s.sslist.isExpanded := e.expand; s := s.next END;
e.expand := ~e.expand;
Views.Update(e.view, Views.keepFrames)
END Do;
PROCEDURE (m: MoveOp) BoundingBox, NEW;
VAR l: MetaList; s: MetaSSList; h, d, w: INTEGER;
BEGIN
m.l := MAX(INTEGER); m.t := m.l; m.b := 0; m.r := 0;
l := m.mods;
WHILE l # NIL DO
IF (l.list.l < m.l) THEN m.l := l.list.l END;
IF (l.list.b - l.list.h < m.t) THEN m.t := l.list.b - l.list.h END;
IF (l.list.l + l.list.w > m.r) THEN m.r := l.list.l + l.list.w END;
IF (l.list.b > m.b) THEN m.b := l.list.b END;
l := l.next
END;
s := m.subs;
WHILE s # NIL DO
IF (s.sslist.l < m.l) THEN m.l := s.sslist.l END;
IF (s.sslist.b - s.sslist.h < m.t) THEN m.t := s.sslist.b - s.sslist.h END;
IF (s.sslist.l + s.sslist.w > m.r) THEN m.r := s.sslist.l + s.sslist.w END;
IF (s.sslist.b > m.b) THEN m.b := s.sslist.b END;
s := s.next
END;
m.view.selfont.GetBounds(h, d, w);
m.b := m.b + d; (* correction for descent *)
m.r := m.r + w; m.l := m.l - w (* correction for incorrect values by italic fonts *)
END BoundingBox;
PROCEDURE (m: MoveOp) Do;
VAR l: MetaList; s: MetaSSList;
BEGIN
l := m.mods;
WHILE l # NIL DO l.list.l := l.list.l + m.dx; l.list.b := l.list.b + m.dy; l := l.next END;
s := m.subs;
WHILE s # NIL DO s.sslist.l := s.sslist.l + m.dx; s.sslist.b := s.sslist.b + m.dy; s := s.next END;
m.dx := -m.dx; m.dy := -m.dy;
Views.Update(m.view, Views.keepFrames)
END Do;
PROCEDURE (h: HideOp) Do;
VAR l: MetaList; s: MetaSSList;
BEGIN
l := h.mods;
WHILE l # NIL DO l.list.isHidden := ~l.list.isHidden; l := l.next END;
s := h.subs;
WHILE s # NIL DO s.sslist.isHidden := ~s.sslist.isHidden; s := s.next END;
Views.Update(h.view, Views.keepFrames)
END Do;
PROCEDURE (h: HideBasicOp) Do;
BEGIN
h.view.showBasic := ~h.view.showBasic;
Views.Update(h.view, Views.keepFrames)
END Do;
PROCEDURE (s: ShowAllOp) Do;
VAR ml: MetaList; mssl: MetaSSList;
BEGIN
ml := s.mods; mssl := s.subs;
WHILE ml # NIL DO ml.list.isHidden := ~ml.list.isHidden; ml := ml.next END;
WHILE mssl # NIL DO mssl.sslist.isHidden := ~mssl.sslist.isHidden; mssl := mssl.next END;
Views.Update(s.view, Views.keepFrames)
END Do;
PROCEDURE (e: ExpandAllOp) Do;
VAR mssl: MetaSSList;
BEGIN
mssl := e.subs;
WHILE mssl # NIL DO mssl.sslist.isExpanded := e.expand; mssl := mssl.next END;
e.expand := ~e.expand;
Views.Update(e.view, Views.keepFrames)
END Do;
PROCEDURE (v: View) ExpandCollapse(expand: BOOLEAN), NEW;
VAR e: ExpandOp;
BEGIN
NEW(e); e.view := v; e.AddSelection; e.expand := expand;
IF e.expand THEN e.mods := NIL ELSE e.subs := NIL END;
Views.Do(v, "Toggle Expand/Collapse", e)
END ExpandCollapse;
(** Redrawing the view **)
PROCEDURE (v: View) SetExtents, NEW;
VAR tmpList: List; ssList: SubsystemList; h, d, w: INTEGER;
BEGIN
tmpList := v.list; v.selfont.GetBounds(h, d, w);
WHILE tmpList # NIL DO
tmpList.w := v.selfont.StringWidth(tmpList.name); tmpList.h := h; tmpList := tmpList.next
END;
ssList := v.subsystems;
WHILE ssList # NIL DO
ssList.w := v.selfont.StringWidth("[" + ssList.name + "]"); ssList.h := h; ssList := ssList.next
END
END SetExtents;
PROCEDURE (v: View) Layout, NEW;
CONST space = 5 * Ports.mm;
VAR
width, height, xindent, yindent, level: INTEGER;
levelIndent: POINTER TO ARRAY OF INTEGER;
tmpList: List;
BEGIN
NEW(levelIndent, v.maxLevel + 1); v.context.GetSize(width, height);
tmpList := v.list;
WHILE tmpList # NIL DO
IF tmpList.isStart THEN
yindent := space; level := 0
ELSE
level := tmpList.subsystem.level;
yindent := space + (15 * Ports.mm * level)
END;
xindent := space + levelIndent[level];
WHILE xindent + v.normfont.StringWidth(tmpList.name) > width DO
xindent := xindent - width;
yindent := yindent + (4 * Ports.mm)
END;
IF ~tmpList.subsystem.isBasic OR v.showBasic THEN
IF tmpList.subsystem.isExpanded THEN
IF ~tmpList.isHidden & ~tmpList.isLayedout THEN
levelIndent[level] := levelIndent[level] + tmpList.w + space;
tmpList.SetPosition(xindent, yindent); tmpList.isLayedout := TRUE
END
ELSIF ~ tmpList.subsystem.isHidden & ~tmpList.subsystem.isLayedout THEN
levelIndent[level] := levelIndent[level] + tmpList.subsystem.w + space;
tmpList.SetPosition(xindent, yindent); tmpList.subsystem.isLayedout := TRUE
END
END;
tmpList := tmpList.next
END
END Layout;
PROCEDURE (v: View) DrawArrow(f: Views.Frame; ax, ay, bx, by, s: INTEGER), NEW;
CONST ArrowLen = 1 * Ports.mm;
TYPE Vector = RECORD x, y: REAL END;
VAR a, b, c, d, e, v1, v2: Vector; lenc, m, x, y: REAL; p: ARRAY 3 OF Ports.Point;
BEGIN
a.x := ax; a.y := ay; b.x := bx; b.y := by; c.x := b.x - a.x; c.y := b.y - a.y;
m := MAX(ABS(c.x), ABS(c.y)); x := c.x / m; y := c.y / m;
lenc := m * Math.Sqrt(x * x + y * y); s := MAX(1, SHORT(ENTIER(1.5 * s)) DIV Ports.point); (* scaling factor *)
e.x := c.x * s / lenc; e.y := c.y * s / lenc;
d.x := e.y; d.y := - e.x; (* first orthogonal vector *)
v1.x := (e.x + d.x) * ArrowLen; v1.y := (e.y + d.y) * ArrowLen;
v1.x := -v1.x; v1.y := -v1.y; (* mirror vector *)
d.x := -d.x; d.y := -d.y; (* second orthogonal vector *)
v2.x := (e.x + d.x) * ArrowLen; v2.y := (e.y + d.y) * ArrowLen;
v2.x := -v2.x; v2.y := -v2.y; (* mirror vector *)
p[0].x := SHORT(ENTIER(b.x));p[0].y := SHORT(ENTIER(b.y));
p[1].x := SHORT(ENTIER(b.x + v1.x)); p[1].y := SHORT(ENTIER(b.y + v1.y));
p[2].x := SHORT(ENTIER(b.x + v2.x)); p[2].y := SHORT(ENTIER(b.y + v2.y));
f.DrawPath(p, 3, Ports.fill, Ports.black, Ports.closedPoly)
END DrawArrow;
PROCEDURE (v: View) DrawDependencies (f: Views.Frame; l, t, r, b: INTEGER), NEW;
VAR
xindent, yindent, startx, starty, middlex, middley, sx, sy, thickness: INTEGER;
subgraph: Subgraph; tmpList: List; s: SubsystemList;
BEGIN
thickness := MAX(2, (v.normfont.size DIV 8));
f.DrawRect(l, t, r, b, Ports.fill, Ports.white);
tmpList := v.list;
WHILE tmpList # NIL DO
IF tmpList.Visible(v.showBasic) OR tmpList.subsystem.Visible(v.showBasic) THEN
subgraph := tmpList.imports;
tmpList.GetPosition(startx, starty);
WHILE subgraph # NIL DO
IF subgraph.node.Visible(v.showBasic) OR subgraph.node.subsystem.Visible(v.showBasic) THEN
subgraph.node.GetPosition(sx, sy);
middlex := ABS(startx - ((startx - sx) DIV 2));
middley := ABS(starty - ((starty - sy) DIV 2));
IF ~subgraph.isImplicit THEN
f.DrawLine(startx, starty, middlex, middley, thickness, Ports.red);
f.DrawLine(middlex, middley, sx, sy, thickness, Ports.blue)
ELSE
f.DrawLine(startx, starty, middlex, middley, thickness, Ports.grey25);
f.DrawLine(middlex, middley, sx, sy, thickness, Ports.grey25)
END;
IF (middlex # startx) OR (middley # starty) THEN
v.DrawArrow(f, startx, starty, middlex, middley, thickness)
END
END;
subgraph := subgraph.next
END
END;
tmpList := tmpList.next
END;
(* Draw the names of the modules last, so they end up on top *)
tmpList := v.list;
WHILE tmpList # NIL DO
IF tmpList.Visible(v.showBasic) THEN
tmpList.GetPosition(xindent, yindent);
IF tmpList.Selected() THEN
f.DrawString(xindent, yindent, Ports.black, tmpList.name, v.selfont)
ELSE
f.DrawString(xindent, yindent, Ports.black, tmpList.name, v.normfont)
END;
f.DrawOval(xindent - (Ports.mm DIV 2), yindent - (Ports.mm DIV 2), xindent + (Ports.mm DIV 2), yindent +
(Ports.mm DIV 2), Ports.fill, Ports.black)
END;
tmpList := tmpList.next
END;
s := v.subsystems;
WHILE s # NIL DO
IF s.Visible(v.showBasic) THEN
xindent := s.l; yindent := s.b;
IF s.Selected() THEN
f.DrawString(xindent, yindent, Ports.black, "[" + s.name + "]", v.selfont)
ELSE
f.DrawString(xindent, yindent, Ports.black, "[" + s.name + "]", v.normfont)
END;
f.DrawOval(xindent - (Ports.mm DIV 2), yindent - (Ports.mm DIV 2), xindent + (Ports.mm DIV 2), yindent +
(Ports.mm DIV 2), Ports.fill, Ports.black)
END;
s := s.next
END
END DrawDependencies;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
v.Layout();
v.DrawDependencies(f, l, t, r, b)
END Restore;
(** Handle view messages **)
PROCEDURE (v: View) SetProps(p: Properties.Property), NEW;
VAR
size: INTEGER;
typeface: Fonts.Typeface;
prop: Properties.StdProp;
style: SET;
BEGIN
WHILE (p # NIL) & ~(p IS Properties.StdProp) DO p := p.next END;
IF p # NIL THEN
prop := p(Properties.StdProp); size := v.normfont.size;
typeface := v.normfont.typeface; style := v.normfont.style;
IF Properties.size IN prop.valid THEN size := prop.size END;
IF Properties.typeface IN prop.valid THEN typeface := prop.typeface END;
IF Properties.style IN prop.valid THEN
IF Fonts.underline IN prop.style.mask THEN
IF Fonts.underline IN prop.style.val THEN style := style + {Fonts.underline}
ELSE style := style - {Fonts.underline} END
END;
IF Fonts.italic IN prop.style.mask THEN
IF Fonts.italic IN prop.style.val THEN style := style + {Fonts.italic}
ELSE style := style - {Fonts.italic} END
END;
IF Fonts.strikeout IN prop.style.mask THEN
IF Fonts.strikeout IN prop.style.val THEN style := style + {Fonts.strikeout}
ELSE style := style - {Fonts.strikeout} END
END
END;
v.normfont := Fonts.dir.This(typeface, size, style, Fonts.normal);
v.selfont := Fonts.dir.This(typeface, size, style, Fonts.bold); v.SetExtents();
Views.Update(v, Views.keepFrames)
END
END SetProps;
PROCEDURE (v: View) GetProps(OUT p: Properties.Property), NEW;
VAR
prop: Properties.StdProp;
BEGIN
NEW(prop); prop.known := {Properties.weight, Properties.size, Properties.typeface, Properties.style};
prop.valid := {Properties.weight, Properties.size, Properties.typeface, Properties.style};
prop.typeface := v.normfont.typeface; prop.size := v.normfont.size; prop.weight := v.normfont.weight;
prop.style.val := v.normfont.style; prop.style.mask := v.normfont.style;
p := prop
END GetProps;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 50 * Ports.mm; max = 500 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 200 * Ports.mm; msg.h := 100 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
| msg: Properties.PollMsg DO
v.GetProps(msg.prop)
| msg: Properties.SetMsg DO
v.SetProps(msg.prop)
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleMultiSelect (f: Views.Frame; VAR msg: Controllers.TrackMsg), NEW;
VAR
x, y, x1, y1: INTEGER;
isDown, first: BOOLEAN; m: SET;
BEGIN
first := TRUE; x1 := -1; y1 := -1;
REPEAT
f.Input(x, y, m, isDown);
IF (x1 # x) OR (y1 # y) THEN
IF first THEN
first := FALSE
ELSE
f.MarkRect(MIN(x1, msg.x), MIN(y1, msg.y), MAX(x1, msg.x), MAX(y1, msg.y), 0, Ports.dim50, FALSE)
END;
x1 := x; y1 := y;
f.MarkRect(MIN(x1, msg.x), MIN(y1, msg.y), MAX(x1, msg.x), MAX(y1, msg.y), 0, Ports.dim50, TRUE)
END
UNTIL ~isDown;
f.MarkRect(MIN(x1, msg.x), MIN(y1, msg.y), MAX(x1, msg.x), MAX(y1, msg.y), 0, Ports.dim50, FALSE);
v.Select(MIN(x1, msg.x), MIN(y1, msg.y), MAX(x1, msg.x), MAX(y1, msg.y), msg.modifiers);
Views.Update(v, Views.keepFrames)
END HandleMultiSelect;
PROCEDURE (v: View) HandleMove (f: Views.Frame; VAR msg: Controllers.TrackMsg), NEW;
VAR
x1, y1, x, y, res: INTEGER; mo: MoveOp; m: SET; isDown: BOOLEAN;
ml: MetaList; ms: MetaSSList;
BEGIN
NEW(mo); mo.view := v; mo.AddSelection; mo.BoundingBox;
x1 := msg.x; y1 := msg.y;
f.SaveRect(f.l, f.t, f.r, f.b, res);
REPEAT
f.Input(x, y, m, isDown);
IF (res = 0) & ((x # x1) OR (y # y1)) THEN
x1 := x; y1 := y;
f.RestoreRect(mo.l + mo.dx, mo.t + mo.dy, mo.r + mo.dx, mo.b + mo.dy, Ports.keepBuffer);
mo.dx := x - msg.x; mo.dy := y - msg.y;
IF mo.l + mo.dx < f.l THEN mo.dx := f.l - mo.l END; IF mo.r + mo.dx > f.r THEN mo.dx := f.r - mo.r END;
IF mo.t + mo.dy < f.t THEN mo.dy := f.t - mo.t END; IF mo.b + mo.dy > f.b THEN mo.dy := f.b - mo.b END;
ml := mo.mods;
WHILE ml # NIL DO
f.DrawString(ml.list.l + mo.dx, ml.list.b + mo.dy, Ports.grey50, ml.list.name, v.selfont); ml := ml.next
END;
ms := mo.subs;
WHILE ms # NIL DO
f.DrawString(ms.sslist.l + mo.dx, ms.sslist.b + mo.dy, Ports.grey50, '[' + ms.sslist.name + ']', v.selfont);
ms := ms.next
END
END
UNTIL ~isDown;
f.RestoreRect(f.l, f.t, f.r, f.b, Ports.disposeBuffer);
Views.Do(v, "Move", mo)
END HandleMove;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message; VAR focus: Views.View);
CONST movedist = Ports.mm * Ports.mm; arrowdist = Ports.mm;
VAR
w, h, x, y, delta: INTEGER; m: SET;
isDown, isMove: BOOLEAN;
mo: MoveOp; e: ExpandOp;
BEGIN
WITH msg: Controllers.TrackMsg DO
IF HostPorts.right IN msg.modifiers THEN
HostMenus.PopupMenu
ELSIF (Controllers.doubleClick IN msg.modifiers) THEN
IF v.OnSelectedObject(msg.x, msg.y) THEN
NEW(e); e.view := v; e.AddSelection;
IF (e.mods # NIL) & (e.subs = NIL) & (e.mods.next = NIL) THEN
e.expand := FALSE; Views.Do(v, "Collapse " + e.mods.list.name, e)
ELSIF (e.mods = NIL) & (e.subs # NIL) & (e.subs.next = NIL) THEN
e.expand := TRUE; Views.Do(v, "Expand " + e.subs.sslist.name, e)
END
END
ELSE
isMove := FALSE;
REPEAT
f.Input(x, y, m, isDown);
IF ~isMove & ((ABS(x - msg.x) * ABS(x - msg.x) + ABS(y - msg.y) * ABS(y - msg.y)) > movedist) THEN
isMove := TRUE
END
UNTIL ~isDown OR isMove;
IF isMove THEN
IF v.OnSelectedObject(msg.x, msg.y) THEN
v.HandleMove(f, msg)
ELSIF v.OnObject(msg.x, msg.y) THEN
v.Select(msg.x, msg.y, msg.x, msg.y, {}); v.HandleMove(f, msg)
ELSE v.HandleMultiSelect(f, msg) END
ELSE
v.Select(msg.x, msg.y, msg.x, msg.y, msg.modifiers); Views.Update(v, Views.keepFrames)
END
END
| msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.copy}; msg.selectable := TRUE; msg.type := "DevDependencies.View"
| msg: Properties.CollectMsg DO
v.GetProps(msg.poll.prop)
| msg: Properties.EmitMsg DO
v.SetProps(msg.set.prop); v.context.GetSize(w, h); v.Restore(f, 0, 0, w, h)
| msg: Controllers.SelectMsg DO
v.SelectAll(msg.set)
| msg: Controllers.EditMsg DO
IF (msg.op = Controllers.pasteChar) & (ORD(msg.char) >= 28) & (ORD(msg.char) <= 31) THEN
NEW(mo); mo.view := v; mo.AddSelection; mo.BoundingBox; mo.dx := 0; mo.dy := 0;
IF Controllers.modify IN msg.modifiers THEN delta := f.unit ELSE delta := arrowdist END;
CASE msg.char OF
| CHR(28): mo.dx := -delta | CHR(29): mo.dx := delta
| CHR(30): mo.dy := -delta | CHR(31): mo.dy := delta
END;
IF mo.l + mo.dx < f.l THEN mo.dx := f.l - mo.l END; IF mo.r + mo.dx > f.r THEN mo.dx := f.r - mo.r END;
IF mo.t + mo.dy < f.t THEN mo.dy := f.t - mo.t END; IF mo.b + mo.dy > f.b THEN mo.dy := f.b - mo.b END;
IF (mo.dy # 0) OR (mo.dx # 0) THEN Views.Do(v, "Move", mo) END
END
ELSE (* Ignore other messages *)
END
END HandleCtrlMsg;
(** Internalize/Externalize and Copy **)
PROCEDURE (s: SubsystemList) Internalize (VAR rd: Stores.Reader);
VAR
store: Stores.Store;
BEGIN
rd.ReadString(s.name); rd.ReadBool(s.isExpanded);
rd.ReadBool(s.isLayedout); rd.ReadBool(s.isHidden); rd.ReadBool(s.isBasic); rd.ReadBool(s.isStart);
rd.ReadInt(s.l); rd.ReadInt(s.b); rd.ReadInt(s.w); rd.ReadInt(s.h); rd.ReadInt(s.level);
rd.ReadStore(store);
IF store # NIL THEN
s.next := store(SubsystemList)
ELSE
s.next := NIL
END
END Internalize;
PROCEDURE (s: SubsystemList) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteString(s.name); wr.WriteBool(s.isExpanded);
wr.WriteBool(s.isLayedout);wr.WriteBool(s.isHidden); wr.WriteBool(s.isBasic); wr.WriteBool(s.isStart);
wr.WriteInt(s.l); wr.WriteInt(s.b); wr.WriteInt(s.w); wr.WriteInt(s.h); wr.WriteInt(s.level);
wr.WriteStore(s.next)
END Externalize;
PROCEDURE (l: List) Internalize (VAR rd: Stores.Reader);
VAR
store: Stores.Store;
BEGIN
rd.ReadString(l.name); rd.ReadInt(l.l); rd.ReadInt(l.b); rd.ReadInt(l.w); rd.ReadInt(l.h);
rd.ReadBool(l.isLayedout); rd.ReadBool(l.isHidden); rd.ReadBool(l.isStart);
rd.ReadStore(store); l.subsystem := store(SubsystemList);
rd.ReadStore(store);
IF store # NIL THEN l.imports := store(Subgraph) ELSE l.imports := NIL END;
rd.ReadStore(store);
IF store # NIL THEN l.next := store(List) ELSE l.next := NIL END
END Internalize;
PROCEDURE (l: List) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteString(l.name); wr.WriteInt(l.l); wr.WriteInt(l.b); wr.WriteInt(l.w); wr.WriteInt(l.h);
wr.WriteBool(l.isLayedout);wr.WriteBool(l.isHidden); wr.WriteBool(l.isStart);
wr.WriteStore(l.subsystem); wr.WriteStore(l.imports);
wr.WriteStore(l.next)
END Externalize;
PROCEDURE (l: NameList) Internalize (VAR rd: Stores.Reader);
VAR
store: Stores.Store;
BEGIN
rd.ReadString(l.name);
rd.ReadStore(store);
IF store # NIL THEN l.next := store(NameList) ELSE l.next := NIL END
END Internalize;
PROCEDURE (l: NameList) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteString(l.name); wr.WriteStore(l.next)
END Externalize;
PROCEDURE (g: Subgraph) Internalize (VAR rd: Stores.Reader);
VAR
store: Stores.Store;
BEGIN
rd.ReadBool(g.isImplicit);
rd.ReadStore(store); g.node := store(List);
rd.ReadStore(store);
IF store # NIL THEN g.next := store(Subgraph) ELSE g.next := NIL END
END Internalize;
PROCEDURE (g: Subgraph) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteBool(g.isImplicit); wr.WriteStore(g.node); wr.WriteStore(g.next)
END Externalize;
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR
version, size: INTEGER;
store: Stores.Store;
typeface: Fonts.Typeface;
style: SET;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(v.maxLevel); rd.ReadBool(v.showBasic);
rd.ReadString(typeface); rd.ReadInt(size); rd.ReadSet(style);
v.normfont := Fonts.dir.This(typeface, size, style, Fonts.normal);
v.selfont := Fonts.dir.This(typeface, size, style, Fonts.bold);
rd.ReadStore(store); v.startList := store(NameList);
rd.ReadStore(store); v.subsystems := store(SubsystemList);
rd.ReadStore(store); v.list := store(List)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(v.maxLevel); wr.WriteBool(v.showBasic);
wr.WriteString(v.normfont.typeface); wr.WriteInt(v.normfont.size); wr.WriteSet(v.normfont.style);
wr.WriteStore(v.startList); wr.WriteStore(v.subsystems); wr.WriteStore(v.list)
END Externalize;
PROCEDURE (s: SubsystemList) CopyFrom(source: Stores.Store);
BEGIN
WITH source: SubsystemList DO
s.name := source.name;
s.isExpanded := source.isExpanded;
s.isLayedout := source.isLayedout;
s.isHidden := source.isHidden;
s.isBasic := source.isBasic;
s.isStart := source.isStart;
s.l := source.l; s.b := source.b; s.w := source.w; s.h := source.h; s.level := source.level;
IF source.next # NIL THEN s.next := Stores.CopyOf(source.next)(SubsystemList) END
END
END CopyFrom;
PROCEDURE (l: List) CopyFrom(source: Stores.Store);
BEGIN
WITH source: List DO
l.name := source.name; l.l := source.l; l.b := source.b; l.w := source.w; l.h := source.h;
l.isLayedout := source.isLayedout; l.isHidden := source.isHidden; l.isStart := source.isStart;
IF source.imports # NIL THEN l.imports := Stores.CopyOf(source.imports)(Subgraph) END;
IF source.subsystem # NIL THEN
l.subsystem := Stores.CopyOf(source.subsystem)(SubsystemList)
END;
IF source.next # NIL THEN l.next := Stores.CopyOf(source.next)(List) END
END
END CopyFrom;
PROCEDURE (l: NameList) CopyFrom(source: Stores.Store);
BEGIN
WITH source: NameList DO
l.name := source.name;
IF source.next # NIL THEN l.next := Stores.CopyOf(source.next)(NameList) END
END
END CopyFrom;
PROCEDURE (g: Subgraph) CopyFrom(source: Stores.Store);
BEGIN
WITH source: Subgraph DO
g.isImplicit := source.isImplicit;
IF source.node # NIL THEN g.node := Stores.CopyOf(source.node)(List) END;
IF source.next # NIL THEN g.next := Stores.CopyOf(source.next)(Subgraph) END
END
END CopyFrom;
PROCEDURE (v: View) CopyFromSimpleView (source: Views.View);
BEGIN
WITH source: View DO
v.maxLevel := source.maxLevel;
v.normfont := source.normfont;
v.selfont := source.selfont;
v.showBasic := source.showBasic;
v.startList := Stores.CopyOf(source.startList)(NameList);
v.subsystems := Stores.CopyOf(source.subsystems)(SubsystemList);
v.list := Stores.CopyOf(source.list)(List)
END
END CopyFromSimpleView;
(** Guards and Interactors **)
PROCEDURE ExpandClick*;
VAR v: View;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN v.ExpandCollapse(TRUE) END
END ExpandClick;
PROCEDURE CollapseClick*;
VAR v: View;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN v.ExpandCollapse(FALSE) END
END CollapseClick;
PROCEDURE HideClick*;
VAR v: View; hop: HideOp;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN
NEW(hop); hop.view := v; hop.AddSelection;
Views.Do(v, "Hide Item", hop)
END
END HideClick;
PROCEDURE ToggleBasicSystemsClick*;
VAR v: View; hbop: HideBasicOp;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN
NEW(hbop); hbop.view := v;
IF v.showBasic THEN Views.Do(v, "Hide Basic Systems", hbop)
ELSE Views.Do(v, "Show Basic Systems", hbop)
END
END
END ToggleBasicSystemsClick;
PROCEDURE ShowAllClick*;
VAR v: View; l: List; sl: SubsystemList;
so: ShowAllOp; ml: MetaList; ssl: MetaSSList;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN
NEW(so); l := v.list;
WHILE l # NIL DO
IF l.isHidden THEN NEW(ml); ml.list := l; ml.next := so.mods; so.mods := ml END;
l := l.next
END;
sl := v.subsystems;
WHILE sl # NIL DO
IF sl.isHidden THEN NEW(ssl); ssl.sslist := sl; ssl.next := so.subs; so.subs := ssl END;
sl := sl.next
END;
IF (so.mods # NIL) OR (so.subs # NIL) THEN so.view := v; Views.Do(v, "Show All", so) END
END
END ShowAllClick;
PROCEDURE ECAll(eo: ExpandAllOp);
VAR v: View; sl: SubsystemList; ssl: MetaSSList;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN
sl := v.subsystems;
WHILE sl # NIL DO
IF (sl.isExpanded # eo.expand) & ~sl.isHidden & (~sl.isBasic OR v.showBasic) THEN
NEW(ssl); ssl.sslist := sl; ssl.next := eo.subs; eo.subs := ssl
END;
sl := sl.next
END;
IF eo.subs # NIL THEN eo.view := v; Views.Do(v, "Show All", eo) END
END
END ECAll;
PROCEDURE ExpandAllClick*;
VAR eo: ExpandAllOp;
BEGIN
NEW(eo); eo.expand := TRUE; ECAll(eo)
END ExpandAllClick;
PROCEDURE CollapseAllClick*;
VAR eo: ExpandAllOp;
BEGIN
NEW(eo); eo.expand := FALSE; ECAll(eo)
END CollapseAllClick;
PROCEDURE ArrangeClick*; (* Not undoable *)
VAR v: View; l: List; sl: SubsystemList;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN
Views.BeginModification(Views.notUndoable, v);
l := v.list;
WHILE l # NIL DO l.isLayedout := FALSE; l := l.next END;
sl := v.subsystems;
WHILE sl # NIL DO sl.isLayedout := FALSE; sl := sl.next END;
Views.Update(v, Views.keepFrames);
Views.EndModification(Views.notUndoable, v)
END
END ArrangeClick;
PROCEDURE DependencyList(v: View; full: BOOLEAN; VAR clist: MetaList);
VAR l: List;
PROCEDURE RecursiveList(node: List; VAR clist: MetaList);
VAR imports: Subgraph; ml, prev: MetaList;
BEGIN
IF full OR node.subsystem.isExpanded THEN
ml := clist;
WHILE (ml # NIL) & (ml.list # node) DO ml := ml.next END;
IF ml = NIL THEN
imports := node.imports;
WHILE imports # NIL DO
IF ~imports.isImplicit THEN RecursiveList(imports.node, clist) END;
imports := imports.next
END;
ml := clist; prev := ml;
WHILE (ml # NIL) & (ml.list # node) DO
(* could have been implicitly imported *)
prev := ml; ml := ml.next
END;
IF ml = NIL THEN
NEW(ml); ml.list := node;
IF prev # NIL THEN prev.next := ml END
END;
IF clist = NIL THEN clist := ml END;
imports := node.imports;
WHILE imports # NIL DO
IF imports.isImplicit THEN RecursiveList(imports.node, clist) END;
imports := imports.next
END
END
END
END RecursiveList;
BEGIN
l := v.list;
WHILE l # NIL DO
RecursiveList(l, clist);
l := l.next
END
END DependencyList;
PROCEDURE SortMetaList(VAR ml: MetaList);
VAR l, p, cur, pcur: MetaList;
BEGIN
ASSERT(ml # NIL, 20);
cur := ml.next; pcur := ml;
WHILE cur # NIL DO
p := NIL; l := ml;
WHILE (l # cur) & (cur.list.name$ > l.list.name$) DO p := l; l := l.next END;
IF l = cur THEN
pcur := cur; cur := cur.next
ELSE
pcur.next := cur.next; cur.next := l;
IF p = NIL THEN ml := cur ELSE p.next := cur END;
cur := pcur.next
END
END
END SortMetaList;
PROCEDURE MarkImplicitModules(v: View);
VAR
fullList, nonImplList: MetaList; v2: View;
BEGIN
IF v.nofMods <= 0 THEN RETURN END;
DependencyList(v, full, fullList);
SortMetaList(fullList);
StartAnalysis(v.startList, NIL, ~implicit, v2);
DependencyList(v2, full, nonImplList);
SortMetaList(nonImplList);
WHILE nonImplList # NIL DO
IF nonImplList.list.name$ = fullList.list.name$ THEN
fullList.list.onlyImplicit := FALSE
ELSE
WHILE nonImplList.list.name$ # fullList.list.name$ DO
fullList.list.onlyImplicit := TRUE; fullList := fullList.next
END
END;
fullList := fullList.next;
nonImplList := nonImplList.next
END;
WHILE fullList # NIL DO fullList.list.onlyImplicit := TRUE; fullList := fullList.next END
END MarkImplicitModules;
PROCEDURE SetStyle(f: TextMappers.Formatter; style: SET);
VAR prop: Properties.StdProp;
BEGIN
prop := f.rider.attr.Prop()(Properties.StdProp);
IF bold IN style THEN prop.weight := Fonts.bold ELSE prop.weight := Fonts.normal END;
IF italic IN style THEN INCL(prop.style.val, Fonts.italic); prop.style.mask := prop.style.val
ELSE EXCL(prop.style.val, Fonts.italic) END;
f.rider.SetAttr(TextModels.ModifiedAttr(f.rider.attr, prop))
END SetStyle;
PROCEDURE SetGray(f: TextMappers.Formatter);
VAR prop: Properties.StdProp;
BEGIN
prop := f.rider.attr.Prop()(Properties.StdProp);
prop.color.val := Ports.grey25;
f.rider.SetAttr(TextModels.ModifiedAttr(f.rider.attr, prop))
END SetGray;
PROCEDURE SetDefColor(f: TextMappers.Formatter);
VAR prop: Properties.StdProp;
BEGIN
prop := f.rider.attr.Prop()(Properties.StdProp);
prop.color.val := Ports.defaultColor;
f.rider.SetAttr(TextModels.ModifiedAttr(f.rider.attr, prop))
END SetDefColor;
PROCEDURE WritePackList(f: TextMappers.Formatter; v: View);
CONST colsPerRow = 3;
VAR head, tail: Files.Name; l: List; col: INTEGER;
BEGIN
l := v.list; col := 0;
WHILE l # NIL DO
IF l.onlyImplicit THEN SetGray(f) ELSE SetDefColor(f) END;
Kernel.SplitName(l.name, head, tail); IF head = "" THEN head := "System" END;
f.WriteString(head + "/Code/" + tail + ".ocf ");
INC(col); IF col >= colsPerRow THEN f.WriteLn; col := 0 END;
l := l.next
END;
SetGray(f); f.WriteString("System/Rsrc/Menus.odc")
END WritePackList;
PROCEDURE WriteCommand (IN f: TextMappers.Formatter; title: Dialog.String; cmd: TextModels.Model);
BEGIN
SetStyle(f, {bold}); f.WriteString(title); f.WriteLn;
SetStyle(f, {});
f.WriteView(StdFolds.dir.New(StdFolds.collapsed, "", cmd));
f.WriteString('command');
f.WriteView(StdFolds.dir.New(StdFolds.collapsed, "", NIL));
f.WriteLn; f.WriteLn
END WriteCommand;
PROCEDURE AddHeader (IN f: TextMappers.Formatter; v: View);
VAR sl: NameList; date: Dates.Date; time: Dates.Time; ds, ts: String;
BEGIN
Dates.GetDate(date); Dates.DateToString(date, Dates.plainLong, ds);
Dates.GetTime(time); Dates.TimeToString(time, ts);
SetStyle(f, {bold});
f.WriteString('Tool for: '); sl := v.startList;
WHILE sl # NIL DO f.WriteString(sl.name + ' '); sl := sl.next END; f.WriteLn;
SetStyle(f, {italic});f.WriteString('Created: ' + ds + ', ' + ts); f.WriteLn; f.WriteLn
END AddHeader;
PROCEDURE AddCompileList (IN f: TextMappers.Formatter; v: View);
VAR l: MetaList; m: TextModels.Model; hf:TextMappers.Formatter;
BEGIN
m := TextModels.dir.New(); hf.ConnectTo(m);
SetStyle(hf, {}); hf.WriteLn;
hf.WriteView(DevCommanders.dir.New()); hf.WriteString(' DevCompiler.CompileThis '); hf.WriteLn;
DependencyList(v, ~full, l);
WHILE l # NIL DO
IF l.list.onlyImplicit THEN SetGray(hf) ELSE SetDefColor(hf) END;
hf.WriteString(l.list.name + ' ');
l := l.next
END;
hf.WriteView(DevCommanders.dir.NewEnd()); hf.WriteLn;
WriteCommand(f, 'To compile:', m)
END AddCompileList;
PROCEDURE WriteUnloadList(f: TextMappers.Formatter; l: MetaList);
BEGIN
IF l # NIL THEN
WriteUnloadList(f, l.next);
IF l.list.onlyImplicit THEN SetGray(f) ELSE SetDefColor(f) END;
f.WriteString(l.list.name + ' ')
END
END WriteUnloadList;
PROCEDURE AddUnloadList (IN f: TextMappers.Formatter; v: View);
VAR l: MetaList; m: TextModels.Model; hf:TextMappers.Formatter;
BEGIN
m := TextModels.dir.New(); hf.ConnectTo(m);
SetStyle(hf, {}); hf.WriteLn;
hf.WriteView(DevCommanders.dir.New()); hf.WriteString(' DevDebug.UnloadThis '); hf.WriteLn;
DependencyList(v, ~full, l);
WriteUnloadList(hf, l); hf.WriteView(DevCommanders.dir.NewEnd()); hf.WriteLn;
WriteCommand(f, 'To unload:', m)
END AddUnloadList;
PROCEDURE AddLinkList (IN f: TextMappers.Formatter);
VAR m: TextModels.Model; hf:TextMappers.Formatter;
BEGIN
m := TextModels.dir.New(); hf.ConnectTo(m);
SetStyle(hf, {}); hf.WriteLn;
hf.WriteView(DevCommanders.dir.New()); hf.WriteString(' DevLinker.Link exefilename.exe := '); hf.WriteLn;
hf.WriteString('Kernel$+ Files HostFiles HostPackedFiles StdLoader'); hf.WriteLn;
hf.WriteString('1 Applogo.ico 2 Doclogo.ico 3 SFLogo.ico 4 CFLogo.ico 5 DtyLogo.ico'); hf.WriteLn;
hf.WriteString('6 folderimg.ico 7 openimg.ico 8 leafimg.ico'); hf.WriteLn;
hf.WriteString('1 Move.cur 2 Copy.cur 3 Link.cur 4 Pick.cur 5 Stop.cur 6 Hand.cur 7 Table.cur');
hf.WriteView(DevCommanders.dir.NewEnd()); hf.WriteLn;
WriteCommand(f, 'To link (executable to which files can be packed):', m)
END AddLinkList;
PROCEDURE AddPackList (IN f: TextMappers.Formatter; v: View);
VAR m: TextModels.Model; hf:TextMappers.Formatter;
BEGIN
m := TextModels.dir.New(); hf.ConnectTo(m);
SetStyle(hf, {}); hf.WriteLn;
hf.WriteView(DevCommanders.dir.New()); hf.WriteString(' DevPacker.PackThis exefilename.exe :='); hf.WriteLn;
WritePackList(hf, v);
hf.WriteView(DevCommanders.dir.NewEnd()); hf.WriteLn;
WriteCommand(f, 'To pack:', m)
END AddPackList;
PROCEDURE AddRootList (IN f: TextMappers.Formatter; v: View);
VAR m: TextModels.Model; hf:TextMappers.Formatter; l: List;
BEGIN
m := TextModels.dir.New(); hf.ConnectTo(m);
SetStyle(hf, {italic}); hf.WriteLn;
hf.WriteString('(modules which are not imported from any other modules)'); hf.WriteLn;
SetStyle(hf, {});
l := v.list;
WHILE l # NIL DO
IF ~l.isImported THEN
IF l.onlyImplicit THEN SetGray(hf) ELSE SetDefColor(hf) END;
hf.WriteString(l.name + ' ')
END;
l := l.next
END;
hf.WriteLn;
WriteCommand(f, 'Root modules:', m)
END AddRootList;
PROCEDURE (v: View) CreateTool, NEW;
VAR t: TextModels.Model; f: TextMappers.Formatter; tv: TextViews.View;
BEGIN
MarkImplicitModules(v);
t := TextModels.dir.New(); f.ConnectTo(t); f.SetPos(0); SetStyle(f, {bold});
AddHeader(f, v);
AddCompileList(f, v);
AddUnloadList(f, v);
AddLinkList(f);
AddPackList(f, v);
AddRootList(f, v);
tv := TextViews.dir.New(t); Views.OpenView(tv)
END CreateTool;
PROCEDURE CreateToolClick*;
VAR v: View;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN v.CreateTool END
END CreateToolClick;
PROCEDURE SelGuard* (VAR par: Dialog.Par);
VAR e: ExpandOp; v: View;
BEGIN
v := Controllers.FocusView()(View);
IF v = NIL THEN
par.disabled := TRUE
ELSE
NEW(e); e.view := v; e.AddSelection;
par.disabled := (e.mods = NIL) & (e.subs = NIL)
END
END SelGuard;
PROCEDURE ModsGuard* (VAR par: Dialog.Par);
VAR e: ExpandOp; v: View;
BEGIN
v := Controllers.FocusView()(View);
IF v = NIL THEN
par.disabled := TRUE
ELSE
NEW(e); e.view := v; e.AddSelection;
par.disabled := e.mods = NIL
END
END ModsGuard;
PROCEDURE SubsGuard* (VAR par: Dialog.Par);
VAR e: ExpandOp; v: View;
BEGIN
v := Controllers.FocusView()(View);
IF v = NIL THEN
par.disabled := TRUE
ELSE
NEW(e); e.view := v; e.AddSelection;
par.disabled := e.subs = NIL
END
END SubsGuard;
PROCEDURE ShowBasicGuard* (VAR par: Dialog.Par);
VAR v: View;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN
par.checked := v.showBasic
ELSE
par.disabled := TRUE
END
END ShowBasicGuard;
(** Initialization **)
PROCEDURE SetBasic(v: View);
VAR str: String; t: TextModels.Model; s: TextMappers.Scanner; l, n, sl: NameList; sslist: SubsystemList;
sub, mod: String;
BEGIN
Dialog.MapString("#Dev:BasicSystems", str);
l := NIL;
IF str # "BasicSystems" THEN
t := TextModels.dir.NewFromString(str); s.ConnectTo(t); s.SetPos(0); s.Scan;
WHILE s.type # TextMappers.eot DO
IF s.type = TextMappers.string THEN
sl := v.startList;
Kernel.SplitName(sl.name, sub, mod); IF sub = "" THEN sub := "System" END;
WHILE (sl # NIL) & (sub # s.string) DO
Kernel.SplitName(sl.name, sub, mod); IF sub = "" THEN sub := "System" END;
sl := sl.next
END;
IF sl = NIL THEN NEW(n); n.name := s.string$; n.next := l; l := n END
END;
s.Scan
END;
sslist := v.subsystems; INC(v.maxLevel);
WHILE sslist # NIL DO
n := l;
WHILE (n # NIL) & (sslist.name # n.name) DO n := n.next END;
IF n # NIL THEN
sslist.isBasic := TRUE; INC(sslist.level)
END;
sslist := sslist.next
END
END
END SetBasic;
PROCEDURE StartAnalysis(startList: NameList; font: Fonts.Font; incImpl: BOOLEAN; OUT v: View);
VAR rootNode: List; sl: NameList;
BEGIN
NEW(v); Stores.Join(v, startList);
v.showBasic := FALSE;
IF font = NIL THEN font := Fonts.dir.Default() END;
v.normfont := Fonts.dir.This(font.typeface, font.size, font.style, Fonts.normal);
v.selfont := Fonts.dir.This(font.typeface, font.size, font.style, Fonts.bold);
v.startList := startList; v.subsystems := NIL; v.list := NIL; v.maxLevel := 2; v.nofMods := 0;
sl := startList;
WHILE sl # NIL DO
v.GetNode(sl.name, incImpl, rootNode);
sl := sl.next
END;
SetBasic(v); v.SetExtents()
END StartAnalysis;
PROCEDURE NewAnalysisClick*;
VAR
v, nv: View;
l: List; nl, start: NameList;
BEGIN
v := Controllers.FocusView()(View);
IF v # NIL THEN
l := v.list; start := NIL;
WHILE l # NIL DO
IF l.Selected() THEN NEW(nl); nl.name := l.name; nl.next := start; start := nl END;
l := l.next
END;
IF start # NIL THEN
StartAnalysis(start, v.normfont, implicit, nv);
IF nv.list # NIL THEN Views.Deposit(nv); StdCmds.Open END
END
END
END NewAnalysisClick;
PROCEDURE Analyze (OUT v: View);
VAR startList: NameList;
BEGIN
GetModuleList(startList);
IF startList # NIL THEN StartAnalysis(startList, NIL, implicit, v)
ELSE Dialog.ShowMsg("#Dev:NoModuleNameSelected")
END
END Analyze;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
Analyze(v); Views.Deposit(v)
END Deposit;
PROCEDURE CreateTool*;
VAR v: View;
BEGIN
Analyze(v); IF v.list # NIL THEN v.CreateTool END
END CreateTool;
END DevDependencies.
"DevDependencies.Deposit;StdCmds.Open"
DevDependencies.CreateTool
| Dev/Mod/Dependencies.odc |
MODULE DevHeapSpy;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
S := SYSTEM, Kernel, Strings,
Ports, Models, Views, Services, Stores, Properties, Dialog, Controllers, Documents, DevDebug;
CONST
resolution = 8; (* one pixel represents resolution bytes *)
lineW = 512; (* one line is 512 pixels long, i.e. represents 512 * resolution bytes *)
lineH = 5; (* one line is lineH pixels high *)
lineVertM = 3; (* margin between two lines *)
lineHorM = 2; (* margin between vertical cluster edge and lines *)
cluW = lineW + 2*lineHorM;
cluHorM = 4; (* cluHorM pixels between left view edge and vertical cluster edge *)
cluTopM = 8; (* cluTopM pixels between clusters *)
W = (2*cluHorM + cluW) * Ports.point;
TYPE
Block = POINTER TO RECORD [untagged]
tag: Kernel.Type;
size: INTEGER; (* size of free blocks *)
actual: INTEGER;
first: INTEGER
END;
Cluster = POINTER TO RECORD [untagged]
size: INTEGER; (* total size *)
next: Cluster;
END;
View = POINTER TO RECORD (Views.View)
height: INTEGER
END;
Model = POINTER TO RECORD (Models.Model)
alloc: INTEGER
END;
Action = POINTER TO RECORD (Services.Action) END;
Msg = RECORD (Models.Message) END;
VAR
mem: Model;
par-: RECORD
allocated-: INTEGER; (* number of bytes currently allocated *)
clusters-: INTEGER; (* number of clusters currently allocated *)
heapsize-: INTEGER (* total bytes currently allocated for heap *)
END;
PROCEDURE Append (VAR s: ARRAY OF CHAR; t: ARRAY OF CHAR);
VAR len, i, j: INTEGER; ch: CHAR;
BEGIN
len := LEN(s);
i := 0; WHILE s[i] # 0X DO INC(i) END;
j := 0; REPEAT ch := t[j]; s[i] := ch; INC(j); INC(i) UNTIL (ch = 0X) OR (i = len);
s[len - 1] := 0X
END Append;
PROCEDURE SAppend (VAR s: ARRAY OF CHAR; t: ARRAY OF SHORTCHAR);
VAR str: ARRAY 256 OF CHAR;
BEGIN
str := t$; Append(s, str)
END SAppend;
PROCEDURE SizeOf (f: SHORTCHAR; t: Kernel.Type): INTEGER;
VAR x: INTEGER;
BEGIN
CASE f OF
| 0BX: RETURN 0
| 1X, 2X, 4X: RETURN 1
| 3X, 5X: RETURN 2
| 8X, 0AX: RETURN 8
| 11X: RETURN t.size
| 12X:
x := S.VAL(INTEGER, t.base[0]);
IF x DIV 256 # 0 THEN x := t.base[0].id MOD 4 + 16 END;
RETURN t.size * SizeOf(SHORT(CHR(x)), t.base[0])
ELSE RETURN 4
END
END SizeOf;
PROCEDURE FormOf (t: Kernel.Type): SHORTCHAR;
BEGIN
IF S.VAL(INTEGER, t) DIV 256 = 0 THEN
RETURN SHORT(CHR(S.VAL(INTEGER, t)))
ELSE
RETURN SHORT(CHR(16 + t.id MOD 4))
END
END FormOf;
PROCEDURE WriteName (t: Kernel.Type; VAR s: ARRAY OF CHAR);
VAR name: Kernel.Name; f: SHORTCHAR;
BEGIN
f := FormOf(t);
CASE f OF
| 0X: Dialog.MapString("#Dev:Undefined", s)
| 1X: s := "BOOLEAN"
| 2X: s := "SHORTCHAR"
| 3X: s := "CHAR"
| 4X: s := "BYTE"
| 5X: s := "SHORTINT"
| 6X: s := "INTEGER"
| 7X: s := "SHORTREAL"
| 8X: s := "REAL"
| 9X: s := "SET"
| 0AX: s := "LONGINT"
| 0BX: s := "ANYREC"
| 0CX: s := "ANYPTR"
| 0DX: s := "POINTER"
| 0EX: s := "PROCEDURE"
| 0FX: s := "STRING"
| 10X, 11X, 13X:
IF (t.id DIV 256 # 0) & (t.mod.refcnt >= 0) THEN
s := t.mod.name$; Append(s, ".");
Kernel.GetTypeName(t, name); SAppend(s, name)
ELSIF f = 11X THEN
s := t.mod.name$; Append(s, ".RECORD");
ELSIF f = 13X THEN
s := "POINTER"
ELSE
s := "PROCEDURE"
END
| 20X: s := "COM.IUnknown"
| 21X: s := "COM.GUID"
| 22X: s := "COM.RESULT"
ELSE Dialog.MapString("#Dev:UnknownFormat", s)
END
END WriteName;
PROCEDURE Next (b: Block): Block; (* next block in same cluster *)
VAR size: INTEGER; tag: Kernel.Type;
BEGIN
tag := S.VAL(Kernel.Type, S.VAL(INTEGER, b.tag) DIV 4 * 4);
size := tag.size + 4;
IF ODD(S.VAL(INTEGER, b.tag) DIV 2) THEN size := b.size - S.ADR(b.size) + size END;
size := (size + 15) DIV 16 * 16;
RETURN S.VAL(Block, S.VAL(INTEGER, b) + size)
END Next;
PROCEDURE ClusterHeight (size: INTEGER): INTEGER;
(* height of a cluster in pixels *)
VAR noflines: INTEGER;
BEGIN
noflines := ((size DIV resolution) + (lineW-1)) DIV lineW;
RETURN noflines * (lineH + lineVertM) + lineVertM;
END ClusterHeight;
PROCEDURE ViewHeight(): INTEGER;
(* height of view in universal units *)
VAR cluster: Cluster; h: INTEGER;
BEGIN
cluster := S.VAL(Cluster, Kernel.Root()); h := 0;
WHILE cluster # NIL DO
INC(h, (cluTopM + ClusterHeight(cluster.size)) * Ports.point);
cluster := cluster.next;
END;
INC(h, cluTopM * Ports.point);
RETURN h;
END ViewHeight;
PROCEDURE PaintMem (f: Views.Frame; top, bottom: INTEGER);
VAR cluster: Cluster; b0, blk, next: Block; end: INTEGER;
clusterTop, clusterH, x, x1, y: INTEGER; (* units *)
dot, painted, runlen: INTEGER;
c, c0: INTEGER;
BEGIN
dot := (Ports.point DIV f.dot) * f.dot;
IF dot = 0 THEN dot := f.dot END;
clusterTop := 0;
cluster := S.VAL(Cluster, Kernel.Root());
WHILE cluster # NIL DO
INC(clusterTop, cluTopM*dot);
clusterH := ClusterHeight(cluster.size) * dot;
IF (clusterTop - cluTopM < bottom) OR (clusterTop + clusterH > top) THEN
f.DrawRect(cluHorM*dot, clusterTop, (cluHorM+cluW)*dot, clusterTop + clusterH,
Ports.fill, Ports.grey25);
(* scan cluster and draw blocks *)
blk := S.VAL(Block, S.VAL(INTEGER, cluster) + 12);
end := S.VAL(INTEGER, blk) + (cluster.size - 12) DIV 16 * 16;
b0 := blk; c0 := -1;
y := clusterTop + lineVertM*dot;
painted := 16 DIV resolution; (* nof pixels already painted on current line *)
x := (cluHorM+lineHorM+painted)*dot;
WHILE S.VAL(INTEGER, blk) < end DO
IF S.VAL(INTEGER, blk.tag) = S.ADR(blk.size) THEN (* free block *)
c := -1; next := S.VAL(Block, S.VAL(INTEGER, blk) + blk.size + 4)
ELSIF 1 IN S.VAL(SET, blk.tag) THEN (* array *)
c := Ports.blue; next := Next(blk)
ELSE (* record *)
c := Ports.red; next := S.VAL(Block, S.VAL(INTEGER, blk) + (blk.tag.size + 19) DIV 16 * 16)
END;
IF c # c0 THEN
runlen := (S.VAL(INTEGER, blk) - S.VAL(INTEGER, b0)) DIV resolution;
WHILE runlen > lineW-painted DO
x1 := (cluHorM+lineHorM+lineW)*dot;
IF (c0 # -1) & (x < x1) THEN
f.DrawRect(x, y, x1, y + lineH * dot, Ports.fill, c0)
END;
DEC(runlen, lineW-painted); painted := 0;
x := (cluHorM+lineHorM)*dot; INC(y, (lineH+lineVertM) * dot);
END;
IF runlen > 0 THEN
IF c0 # -1 THEN f.DrawRect(x, y, x + runlen*dot, y + lineH * dot, Ports.fill, c0) END;
INC(painted, runlen); INC(x, runlen*dot);
END;
b0 := blk; c0 := c
END;
blk := next
END;
IF c0 # -1 THEN
runlen := (S.VAL(INTEGER, end) - S.VAL(INTEGER, b0)) DIV resolution;
WHILE runlen > lineW-painted DO
f.DrawRect(x, y, (cluHorM+lineHorM+lineW)*dot, y + lineH * dot, Ports.fill, c0);
DEC(runlen, lineW-painted); painted := 0;
x := (cluHorM+lineHorM)*dot; INC(y, (lineH+lineVertM) * dot);
END;
IF runlen > 0 THEN f.DrawRect(x, y, x + runlen*dot, y + lineH * dot, Ports.fill, c0) END;
END
END;
cluster := cluster.next;
INC(clusterTop, clusterH);
END
END PaintMem;
PROCEDURE MarkBlock (f: Views.Frame; sel: Block; on: BOOLEAN);
VAR cluster: Cluster; next: Block; end, offs, dot, col: INTEGER; found: BOOLEAN;
clusterTop, x, y, r, e: INTEGER; (* units *)
BEGIN
dot := (Ports.point DIV f.dot) * f.dot;
IF dot = 0 THEN dot := f.dot END;
clusterTop := 0;
cluster := S.VAL(Cluster, Kernel.Root()); found := FALSE;
WHILE (cluster # NIL) & ~found DO
end := S.VAL(INTEGER, cluster) + 12 + (cluster.size - 12) DIV 16 * 16;
INC(clusterTop, cluTopM * dot);
IF (S.VAL(INTEGER, cluster) <= S.VAL(INTEGER, sel)) & (S.VAL(INTEGER, sel) < end) THEN
found := TRUE;
ELSE
INC(clusterTop, ClusterHeight(cluster.size) * dot);
cluster := cluster.next;
END
END;
IF found THEN (* sel is contained in cluster *)
IF on THEN col := Ports.green
ELSIF 1 IN S.VAL(SET, sel.tag) THEN col := Ports.blue
ELSE col := Ports.red
END;
next := Next(sel);
r := (cluHorM + lineHorM + lineW) * dot;
offs := (S.VAL(INTEGER, sel) + 4 (* tag *) - S.VAL(INTEGER, cluster)) DIV resolution;
y := clusterTop + ((offs DIV lineW) * (lineH+lineVertM) + lineVertM) * dot;
x := (cluHorM + lineHorM + (offs MOD lineW)) * dot;
e := x + (S.VAL(INTEGER, next) - S.VAL(INTEGER, sel)) DIV resolution * dot;
WHILE e >= r DO
f.DrawRect(x, y, r, y + lineH * dot, Ports.fill, col);
INC(y, (lineH + lineVertM) * dot);
x := (cluHorM + lineHorM) * dot;
e := x + e - r;
END;
IF e > x THEN f.DrawRect(x, y, e, y + lineH * dot, Ports.fill, col) END;
END
END MarkBlock;
PROCEDURE ThisCluster (f: Views.Frame; sx, sy: INTEGER): Cluster;
VAR cluster: Cluster; dot, clusterTop, clusterH: INTEGER;
BEGIN
dot := (Ports.point DIV f.dot) * f.dot;
IF dot = 0 THEN dot := f.dot END;
cluster := NIL;
IF (cluHorM * dot <= sx) & (sx < (cluHorM + 2*lineHorM + lineW) * dot) THEN
cluster := S.VAL(Cluster, Kernel.Root());
clusterTop := 0;
WHILE cluster # NIL DO
INC(clusterTop, cluTopM * dot);
clusterH := ClusterHeight(cluster.size) * dot;
IF (clusterTop <= sy) & (sy < clusterTop + clusterH) THEN RETURN cluster
ELSE INC(clusterTop, clusterH); cluster := cluster.next;
END
END
END;
RETURN cluster;
END ThisCluster;
PROCEDURE ThisBlock (f: Views.Frame; sx, sy: INTEGER): Block;
VAR cluster: Cluster; blk, next: Block; found: BOOLEAN;
dot, lineno, offs, end, adr: INTEGER;
clusterTop, clusterH: INTEGER;
BEGIN
dot := (Ports.point DIV f.dot) * f.dot;
IF dot = 0 THEN dot := f.dot END;
IF (sx < (cluHorM + lineHorM) * dot) OR ((cluHorM + lineHorM + lineW) * dot <= sx) THEN
RETURN NIL
END;
cluster := S.VAL(Cluster, Kernel.Root());
clusterTop :=0; found := FALSE;
WHILE (cluster # NIL) & ~found DO
INC(clusterTop, cluTopM * dot);
clusterH := ClusterHeight(cluster.size) * dot;
IF (clusterTop <= sy) & (sy < clusterTop + clusterH) THEN found := TRUE
ELSE INC(clusterTop, clusterH); cluster := cluster.next;
END
END;
IF found THEN (* (sx, sy) points into cluster *)
lineno := ((sy - clusterTop) DIV dot) DIV (lineH + lineVertM);
offs := ((sy - clusterTop) DIV dot) MOD (lineH + lineVertM); (* vertical offset in line *)
IF (lineVertM <= offs) & (offs < lineH + lineVertM) THEN
offs := (sx DIV dot) - cluHorM - lineHorM; (* hor offset from left into line *)
adr := S.VAL(INTEGER, cluster) + (lineno * lineW + offs) * resolution;
(* we're looking for the block that contains address adr *)
blk := S.VAL(Block, S.VAL(INTEGER, cluster) + 12);
end := S.VAL(INTEGER, blk) + (cluster.size - 12) DIV 16 * 16;
WHILE S.VAL(INTEGER, blk) < end DO
next := Next(blk);
IF adr < S.VAL(INTEGER, next) THEN
IF S.VAL(INTEGER, blk.tag) # S.ADR(blk.size) THEN RETURN blk
ELSE RETURN NIL (* blk is a free block *)
END
ELSE blk := next
END
END;
RETURN NIL
ELSE (* (sx, sy) points between two lines *) RETURN NIL
END
ELSE RETURN NIL
END
END ThisBlock;
PROCEDURE SearchPath (this, that: Block; VAR path: ARRAY OF INTEGER; VAR len: INTEGER);
VAR father, son: Block; tag: Kernel.Type; flag, offset, actual, i: INTEGER; found: BOOLEAN;
BEGIN
i := 1; len := 0; found := FALSE;
IF ~ODD(S.VAL(INTEGER, this.tag)) THEN
father := NIL;
LOOP
INC(S.VAL(INTEGER, this.tag));
flag := S.VAL(INTEGER, this.tag) MOD 4;
tag := S.VAL(Kernel.Type, S.VAL(INTEGER, this.tag) - flag);
IF flag >= 2 THEN actual := this.first; this.actual := actual
ELSE actual := S.ADR(this.size)
END;
LOOP
IF (this = that) & ~found THEN len := i; found := TRUE END;
offset := tag.ptroffs[0];
IF offset < 0 THEN
INC(S.VAL(INTEGER, tag), offset + 4); (* restore tag *)
IF (flag >= 2) & (actual < this.size) & (offset < -4) THEN (* next array element *)
INC(actual, tag.size); this.actual := actual
ELSE (* up *)
this.tag := S.VAL(Kernel.Type, S.VAL(INTEGER, tag) + flag);
IF father = NIL THEN RETURN END;
son := this; this := father; DEC(i);
flag := S.VAL(INTEGER, this.tag) MOD 4;
tag := S.VAL(Kernel.Type, S.VAL(INTEGER, this.tag) - flag);
offset := tag.ptroffs[0];
IF flag >= 2 THEN actual := this.actual ELSE actual := S.ADR(this.size) END;
S.GET(actual + offset, father); S.PUT(actual + offset, S.ADR(son.size));
INC(S.VAL(INTEGER, tag), 4)
END
ELSE
S.GET(actual + offset, son);
IF (son # NIL) & ~found THEN
DEC(S.VAL(INTEGER, son), 4);
IF ~ODD(S.VAL(INTEGER, son.tag)) THEN (* down *)
IF i < LEN(path) THEN
IF flag < 2 THEN path[i] := offset
ELSE path[i] := actual - S.ADR(this.size) + offset
END
END;
INC(i);
this.tag := S.VAL(Kernel.Type, S.VAL(INTEGER, tag) + flag);
S.PUT(actual + offset, father); father := this; this := son;
EXIT
END
END;
INC(S.VAL(INTEGER, tag), 4)
END
END
END
END
END SearchPath;
PROCEDURE ResetMarks;
VAR cluster: Cluster; blk: Block; end: INTEGER;
BEGIN
cluster := S.VAL(Cluster, Kernel.Root());
WHILE cluster # NIL DO
blk := S.VAL(Block, S.VAL(INTEGER, cluster) + 12);
end := S.VAL(INTEGER, blk) + (cluster.size - 12) DIV 16 * 16;
WHILE S.VAL(INTEGER, blk) < end DO EXCL(S.VAL(SET, blk.tag), 0); blk := Next(blk) END;
cluster := cluster.next
END
END ResetMarks;
PROCEDURE SearchAnchor (blk: Block; VAR path: ARRAY OF CHAR);
VAR m, mod: Kernel.Module; ref, offs, i, j, k, p, x, a, n: INTEGER; offsets: ARRAY 1 OF INTEGER;
t, f: SHORTCHAR; desc: Kernel.Type; name, title: Kernel.Name; tag, typ: Kernel.Type;
BEGIN
mod := NIL; offs := 0;
m := Kernel.ThisLoadedMod("HostWindows");
IF m # NIL THEN
ref := m.refs; Kernel.GetRefProc(ref, x, name);
IF x # 0 THEN
REPEAT
Kernel.GetRefVar(ref, t, f, desc, a, name)
UNTIL (t # 1X) OR (name = "winAnchor");
IF t = 1X THEN
S.GET(m.data + a, p);
IF p # 0 THEN
SearchPath(S.VAL(Block, p - 4), blk, offsets, n);
IF n > 0 THEN offs := 1 END
END
END
END
END;
m := Kernel.modList;
WHILE (mod = NIL) & (offs = 0) & (m # NIL) DO
IF m.refcnt >= 0 THEN
i := 0;
WHILE (mod = NIL) & (i < m.nofptrs) DO
S.GET(m.data + m.ptrs[i], p);
IF p # 0 THEN
SearchPath(S.VAL(Block, p - 4), blk, offsets, n);
IF n > 0 THEN mod := m; offs := m.ptrs[i] END
END;
INC(i)
END
END;
m := m.next
END;
ResetMarks;
IF offs # 0 THEN
IF mod # NIL THEN
path := mod.name$; Append(path, ".");
ref := mod.refs; Kernel.GetRefProc(ref, x, name);
IF x # 0 THEN
REPEAT
Kernel.GetRefVar(ref, t, f, desc, a, name)
UNTIL (t # 1X) OR (offs >= a) & (offs < a + SizeOf(f, desc));
IF t = 1X THEN SAppend(path, name)
ELSE Append(path, "???")
END
END
ELSE path := "window list"
END;
i := 1;
WHILE (i < n) & (i < LEN(offsets)) DO
S.GET(p - 4, tag);
IF 1 IN S.VAL(SET, tag) THEN Append(path, "[]")
ELSE
k := 0;
REPEAT
typ := tag.base[k]; INC(k); j := 0;
WHILE (j < typ.fields.num) & (typ.fields.obj[j].offs # offsets[i]) DO INC(j) END;
UNTIL (j < typ.fields.num) OR (k > tag.id DIV 16 MOD 16);
IF j < typ.fields.num THEN
Kernel.GetObjName(typ.mod, S.ADR(typ.fields.obj[j]), name);
Append(path, "."); SAppend(path, name)
ELSE
Append(path, ".?")
END
END;
S.GET(p + offsets[i], p); INC(i)
END
ELSE path := ""
END
END SearchAnchor;
PROCEDURE ShowBlock (blk: Block);
VAR title: ARRAY 1024 OF CHAR; path: ARRAY 1024 OF CHAR;
BEGIN
SearchAnchor(blk, path);
IF path # "" THEN
title := "Object anchored in ";
Append(title, path);
ELSE title := "Object not globally anchored"
END;
DevDebug.ShowHeapObject(S.ADR(blk.size), title)
END ShowBlock;
PROCEDURE BlockInfo (blk: Block; VAR s: ARRAY OF CHAR);
VAR tag: Kernel.Type; str: ARRAY 256 OF CHAR;
BEGIN
tag := blk.tag;
IF ODD(S.VAL(INTEGER, tag) DIV 2) THEN (* array *)
DEC(S.VAL(INTEGER, tag), 2);
IF (tag.mod.name = "Kernel") & (tag.fields.num = 1) THEN
tag := tag.fields.obj[0].struct
END;
WriteName(tag, str);
s := "ARRAY OF "; Append(s, str)
ELSE (* record *)
WriteName(tag, s)
END
END BlockInfo;
PROCEDURE HeapInfo (VAR size, nofclusters: INTEGER);
VAR cluster: Cluster;
BEGIN
nofclusters := 0; size := 0; cluster := S.VAL(Cluster, Kernel.Root());
WHILE cluster # NIL DO
INC(nofclusters); INC(size, cluster.size);
cluster := cluster.next
END;
END HeapInfo;
PROCEDURE (v: View) ThisModel (): Models.Model;
BEGIN
RETURN mem
END ThisModel;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
VAR h: INTEGER;
BEGIN
PaintMem(f, t, b);
h := ViewHeight();
IF h # v.height THEN v.context.SetSize(W, h) END;
END Restore;
PROCEDURE (v: View) HandleCtrlMsg (
f: Views.Frame; VAR msg: Controllers.Message; VAR focus: Views.View
);
VAR x, y: INTEGER; isDown: BOOLEAN; blk, b: Block; m: SET; c, lastC: Cluster;
s: ARRAY 100 OF CHAR; num: ARRAY 16 OF CHAR;
BEGIN
WITH msg: Controllers.TrackMsg DO
blk := NIL; lastC := NIL;
REPEAT
f.Input(x, y, m, isDown);
c := ThisCluster(f, x, y); b := ThisBlock(f, x, y);
IF (b # blk) OR (c # lastC) THEN
IF b # NIL THEN BlockInfo(b, s);
ELSIF c # NIL THEN s := "cluster of length ";
IF c.size MOD 1024 = 0 THEN
Strings.IntToString(c.size DIV 1024, num); Append(s, num); Append(s, " KB")
ELSE Strings.IntToString(c.size, num); Append(s, num); Append(s, " bytes")
END;
Append(s, " at address ");
Strings.IntToStringForm(S.VAL(INTEGER, c), Strings.hexadecimal, 9, "0", TRUE, num);
Append(s, num)
ELSE s := ""
END;
Dialog.ShowStatus(s)
END;
lastC := c;
IF b # blk THEN
IF blk # NIL THEN MarkBlock(f, blk, FALSE) END;
blk := b;
IF blk # NIL THEN MarkBlock(f, blk, TRUE) END
END
UNTIL ~isDown;
(* IF ~Dialog.showsStatus & (s # "") THEN Dialog.ShowMsg(s) END; *)
IF blk # NIL THEN
MarkBlock(f, blk, FALSE);
ShowBlock(blk)
END;
Dialog.ShowStatus("");
ELSE
END
END HandleCtrlMsg;
PROCEDURE (v: View) HandleModelMsg (VAR msg: Models.Message);
BEGIN
WITH msg: Msg DO Views.Update(v, Views.keepFrames)
ELSE
END
END HandleModelMsg;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.Preference DO
WITH msg: Properties.ResizePref DO msg.fixed := TRUE
| msg: Properties.FocusPref DO msg.hotFocus := TRUE
| msg: Properties.SizePref DO msg.w := W; msg.h := ViewHeight();
ELSE
END
ELSE
END
END HandlePropMsg;
PROCEDURE (m: Model) CopyFrom (source: Stores.Store), EMPTY;
PROCEDURE (a: Action) Do;
VAR alloc, size, nofclusters: INTEGER; msg: Msg;
BEGIN
alloc := Kernel.Allocated();
IF mem.alloc # alloc THEN
mem.alloc := alloc;
Models.Broadcast(mem, msg);
par.allocated := alloc;
HeapInfo(size, nofclusters);
IF nofclusters # par.clusters THEN par.clusters := nofclusters END;
IF size # par.heapsize THEN par.heapsize := size END;
Dialog.Update(par)
END;
Services.DoLater(a, Services.Ticks() + Services.resolution)
END Do;
PROCEDURE ShowHeap*;
VAR v: View; action: Action; d: Documents.Document;
BEGIN
NEW(v); v.height := ViewHeight();
d := Documents.dir.New(v, W, v.height);
Views.OpenAux(d, "Heap Layout")
END ShowHeap;
PROCEDURE GetAnchor* (adr: INTEGER; OUT anchor: ARRAY OF CHAR);
BEGIN
SearchAnchor(S.VAL(Block, adr - 4), anchor);
END GetAnchor;
PROCEDURE ShowAnchor* (adr: INTEGER);
BEGIN
ShowBlock(S.VAL(Block, adr - 4))
END ShowAnchor;
PROCEDURE Init;
VAR action: Action;
BEGIN
NEW(mem); mem.alloc := 0;
Stores.InitDomain(mem);
NEW(action); Services.DoLater(action, Services.now)
END Init;
BEGIN Init
END DevHeapSpy.
| Dev/Mod/HeapSpy.odc |
MODULE DevInspector;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Kernel, Services, Stores, Views, Controllers, Properties, Containers, Dialog, Controls;
CONST
multiView = TRUE;
TYPE
Action = POINTER TO RECORD (Services.Action) END;
VAR
inspect*: RECORD
control-: Dialog.String;
label*: Dialog.String; (* ARRAY 40 OF CHAR; *)
link*, guard*, notifier*: Dialog.String;
level*: INTEGER;
opt0*, opt1*, opt2*, opt3*, opt4*: BOOLEAN;
known, valid: SET;
type: Stores.TypeName
END;
fingerprint: INTEGER;
action: Action;
PROCEDURE GetTypeName (v: Views.View; VAR t, s: ARRAY OF CHAR);
VAR c: Containers.Controller; w: Views.View; subs, cntr: Dialog.String;
BEGIN
s := ""; t := "";
IF multiView THEN
c := Containers.Focus();
IF c # NIL THEN
c.GetFirstView(Containers.selection, v); w := v;
WHILE (w # NIL) & Services.SameType(w, v) DO c.GetNextView(Containers.selection, w) END;
IF w # NIL THEN v := NIL END
END
END;
IF v # NIL THEN
Services.GetTypeName(v, t); Kernel.SplitName(t, subs, cntr);
Dialog.MapString("#" + subs + ":" + cntr, s);
IF s = cntr THEN Dialog.MapString("#Dev:" + t, s) END
END
END GetTypeName;
PROCEDURE PollProp (v: Views.View);
VAR msg: Properties.PollMsg; q: Properties.Property; p: Controls.Prop;
BEGIN
inspect.control := ""; inspect.link := ""; inspect.label := '';
inspect.guard := ""; inspect.notifier := ""; inspect.level := 0;
inspect.opt0 := FALSE; inspect.opt1 := FALSE;
inspect.opt2 := FALSE; inspect.opt3 := FALSE; inspect.opt4 := FALSE;
inspect.known := {}; inspect.valid := {};
IF multiView OR (v # NIL) THEN
GetTypeName(v, inspect.type, inspect.control);
IF multiView THEN
Properties.CollectProp(q)
ELSE
msg.prop := NIL; Views.HandlePropMsg(v, msg); q := msg.prop
END;
WHILE (q # NIL) & ~(q IS Controls.Prop) DO q := q.next END;
IF q # NIL THEN
p := q(Controls.Prop);
inspect.known := p.known; inspect.valid := p.valid;
IF Controls.link IN p.valid THEN inspect.link := p.link$ END;
IF Controls.label IN p.valid THEN inspect.label := p.label$ END;
IF Controls.guard IN p.valid THEN inspect.guard := p.guard$ END;
IF Controls.notifier IN p.valid THEN inspect.notifier := p.notifier$ END;
IF Controls.level IN p.valid THEN inspect.level := p.level END;
IF Controls.opt0 IN p.valid THEN inspect.opt0 := p.opt[0] END;
IF Controls.opt1 IN p.valid THEN inspect.opt1 := p.opt[1] END;
IF Controls.opt2 IN p.valid THEN inspect.opt2 := p.opt[2] END;
IF Controls.opt3 IN p.valid THEN inspect.opt3 := p.opt[3] END;
IF Controls.opt4 IN p.valid THEN inspect.opt4 := p.opt[4] END
END
END;
Dialog.Update(inspect)
END PollProp;
PROCEDURE SetProp (v: Views.View);
VAR p: Controls.Prop; msg: Properties.SetMsg;
BEGIN
IF multiView OR (v # NIL) THEN
NEW(p);
p.valid := inspect.valid;
p.link := inspect.link$; p.label := inspect.label$;
p.guard := inspect.guard$; p.notifier := inspect.notifier$;
p.level := inspect.level;
p.opt[0] := inspect.opt0;
p.opt[1] := inspect.opt1;
p.opt[2] := inspect.opt2;
p.opt[3] := inspect.opt3;
p.opt[4] := inspect.opt4;
IF multiView THEN Properties.EmitProp(NIL, p)
ELSE msg.old := NIL; msg.prop := p; Views.HandlePropMsg(v, msg)
END
END
END SetProp;
PROCEDURE Singleton (): Views.View;
VAR v: Views.View;
BEGIN
v := Containers.FocusSingleton();
RETURN v
END Singleton;
PROCEDURE (a: Action) Do;
VAR c: Containers.Controller; v: Views.View; fp: INTEGER;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
IF multiView THEN
c := Containers.Focus(); fp := 0;
IF c # NIL THEN
c.GetFirstView(TRUE, v);
WHILE v # NIL DO fp := fp + Services.AdrOf(v); c.GetNextView(TRUE, v) END
END
ELSE
v := Singleton();
IF v = NIL THEN fp := 0 ELSE fp := Services.AdrOf(v) END
END;
IF fp # fingerprint THEN PollProp(v); fingerprint := fp END;
Controllers.ResetCurrentPath();
Services.DoLater(action, Services.Ticks() + Services.resolution DIV 2)
END Do;
PROCEDURE InitDialog*;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
PollProp(Singleton());
Controllers.ResetCurrentPath()
END InitDialog;
PROCEDURE GetNext*;
VAR c: Containers.Controller; v: Views.View;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
c := Containers.Focus();
IF c # NIL THEN
IF c.HasSelection() THEN v := c.Singleton() ELSE v := NIL END;
IF v = NIL THEN
c.GetFirstView(Containers.any, v)
ELSE
c.GetNextView(Containers.any, v);
IF v = NIL THEN c.GetFirstView(Containers.any, v) END
END;
c.SelectAll(FALSE);
IF v # NIL THEN c.SetSingleton(v); c.MakeViewVisible(v) END;
PollProp(v)
ELSE Dialog.ShowMsg("#Dev:NoTargetFocusFound")
END;
Controllers.ResetCurrentPath()
END GetNext;
PROCEDURE Set*;
VAR v: Views.View;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
v := Singleton();
IF multiView OR (v # NIL) THEN SetProp(v); PollProp(v) END;
Controllers.ResetCurrentPath()
END Set;
PROCEDURE MapLabel (
IN control: Stores.TypeName; IN type: Dialog.String; i: INTEGER; VAR label: Dialog.String
);
VAR l, k, subs, cntr: Dialog.String; si: ARRAY 2 OF CHAR;
BEGIN
Kernel.SplitName(control, subs, cntr);
si[0] := CHR(i + ORD("0")); si[1] := 0X;
k := cntr + "." + type + si;
Dialog.MapString("#" + subs + ":" + k, l);
IF l$ # k$ THEN label := l$ END
END MapLabel;
PROCEDURE OptGuard* (opt: INTEGER; VAR par: Dialog.Par);
VAR name: ARRAY 64 OF CHAR; num: ARRAY 2 OF CHAR;
BEGIN
ASSERT((opt >= 0) & (opt <= 9), 20);
IF ~(opt IN inspect.known) OR (inspect.type = "") THEN
par.disabled := TRUE
ELSE
num[0] := CHR(opt + ORD("0")); num[1] := 0X;
name := inspect.type + ".Opt" + num;
par.label := "#Dev:" + name;
Dialog.MapString(par.label, par.label);
IF par.label = name THEN par.label := "" END;
IF ~(opt IN inspect.valid) THEN par.undef := TRUE END;
MapLabel(inspect.type, "Opt", opt, par.label)
END
END OptGuard;
PROCEDURE LevelGuard* (VAR par: Dialog.Par);
BEGIN
IF ~(Controls.level IN inspect.known) THEN par.disabled := TRUE
ELSIF ~(Controls.level IN inspect.valid) THEN par.undef := TRUE
END;
IF inspect.type # "" THEN MapLabel(inspect.type, "Field", 5, par.label) END
END LevelGuard;
PROCEDURE NotifierGuard* (VAR par: Dialog.Par);
BEGIN
IF ~(Controls.notifier IN inspect.known) THEN par.disabled := TRUE
ELSIF ~(Controls.notifier IN inspect.valid) THEN par.undef := TRUE
END;
IF inspect.type # "" THEN MapLabel(inspect.type, "Field", 4, par.label) END
END NotifierGuard;
PROCEDURE GuardGuard* (VAR par: Dialog.Par);
BEGIN
IF ~(Controls.guard IN inspect.known) THEN par.disabled := TRUE
ELSIF ~(Controls.guard IN inspect.valid) THEN par.undef := TRUE
END;
IF inspect.type # "" THEN MapLabel(inspect.type, "Field", 3, par.label) END
END GuardGuard;
PROCEDURE LabelGuard* (VAR par: Dialog.Par);
BEGIN
IF ~(Controls.label IN inspect.known) THEN par.disabled := TRUE
ELSIF ~(Controls.label IN inspect.valid) THEN par.undef := TRUE
END;
IF inspect.type # "" THEN MapLabel(inspect.type, "Field", 2, par.label) END
END LabelGuard;
PROCEDURE LinkGuard* (VAR par: Dialog.Par);
BEGIN
IF ~(Controls.link IN inspect.known) THEN par.disabled := TRUE
ELSIF ~(Controls.link IN inspect.valid) THEN par.undef := TRUE
END;
IF inspect.type # "" THEN MapLabel(inspect.type, "Field", 1, par.label) END
END LinkGuard;
PROCEDURE ControlGuard* (VAR par: Dialog.Par);
BEGIN
IF inspect.known = {} THEN par.disabled := TRUE END
END ControlGuard;
PROCEDURE Notifier* (idx, op, from, to: INTEGER);
BEGIN
IF op = Dialog.changed THEN INCL(inspect.valid, idx) END
END Notifier;
BEGIN
NEW(action); Services.DoLater(action, Services.now)
END DevInspector.
DevCompiler.Compile
" DevInspector.InitDialog; OpenAuxDialog('#Dev:inspect', 'Inspect') "
" Unload('DevInspector'); DevInspector.InitDialog; OpenAuxDialog('DevInspector.inspect', 'Inspect') "
| Dev/Mod/Inspector.odc |
MODULE DevLinkChk;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Kernel, Strings, Dialog, Files, Fonts, Ports, Converters, Views, Containers,
TextModels, TextMappers, TextViews, TextControllers, StdLinks, StdCmds;
CONST
oneSubsystem* = 0; globalSubsystem* = 1; allSubsystems* = 2;
linkCommand = "DevLinkChk.Open('";
VAR
par*: RECORD
scope*: INTEGER; (* IN {oneSubsystem, globalSubsystem, allSubsystems} *)
subsystem*: ARRAY 9 OF CHAR;
legal: BOOLEAN (* legal => correct syntax for a subsystem name # "" *)
END;
TYPE
Iterator = POINTER TO IteratorDesc;
IteratorDesc = RECORD
root: Files.Locator;
locs: Files.LocInfo;
files: Files.FileInfo
END;
VAR default, link: TextModels.Attributes;
PROCEDURE MakeDocName (VAR name: Files.Name);
BEGIN
Kernel.MakeFileName(name, "")
END MakeDocName;
PROCEDURE New (root: Files.Locator): Iterator;
VAR i: Iterator;
BEGIN
NEW(i); i.root := root; i.locs := Files.dir.LocList(root); i.files := Files.dir.FileList(root);
(* could sort by name *)
RETURN i
END New;
PROCEDURE ReadLoc (i: Iterator; VAR loc: Files.Locator; VAR name: Files.Name);
BEGIN
IF i.locs # NIL THEN
loc := i.root.This(i.locs.name); ASSERT(loc # NIL, 60);
name := i.locs.name$;
i.locs := i.locs.next
ELSE
loc := NIL; name := ""
END
END ReadLoc;
PROCEDURE ReadFile (i: Iterator; OUT name: Files.Name);
BEGIN
IF i.files # NIL THEN
name := i.files.name$;
i.files := i.files.next
ELSE
name := ""
END
END ReadFile;
PROCEDURE Delimiter (ch: CHAR): BOOLEAN;
BEGIN
RETURN (ch = "'") OR (ch = '"') OR (ch = "/")
END Delimiter;
PROCEDURE Stale (IN s: ARRAY OF CHAR): BOOLEAN;
VAR i, j: INTEGER; ch: CHAR; loc: Files.Locator; name: Files.Name; t: ARRAY 1024 OF CHAR;
BEGIN
i := 0; ch := s[0]; WHILE (ch # 0X) & (ch # "(") DO INC(i); ch := s[i] END;
IF ch = "(" THEN
t := s$; t[i] := 0X;
(* StdCmds.OpenMask doesn't exist anymore *)
IF (t = "StdCmds.OpenMask") OR (t = "StdCmds.OpenBrowser") OR (t = "StdCmds.OpenDoc") OR
(t = "StdCmds.OpenAuxDialog") THEN
INC(i); ch := s[i]; WHILE (ch # 0X) & (ch # "'") & (ch # '"') DO INC(i); ch := s[i] END;
IF ch # 0X THEN
loc := Files.dir.This("");
REPEAT
j := 0;
INC(i); ch := s[i]; WHILE ~Delimiter(ch) DO t[j] := ch; INC(j); INC(i); ch := s[i] END;
t[j] := 0X;
IF ch = "/" THEN loc := loc.This(t) END
UNTIL ch # "/";
name := t$; MakeDocName(name);
RETURN Files.dir.Old(loc, name, Files.shared) = NIL (* file not found *)
ELSE RETURN TRUE (* wrong syntax *)
END
ELSE RETURN FALSE (* unknown kind of command *)
END
ELSE RETURN FALSE (* unknown kind of command *)
END
END Stale;
PROCEDURE GetCmd (IN path, file: Files.Name; pos: INTEGER; OUT cmd: ARRAY OF CHAR);
VAR p, bug0, bug1, bug2: ARRAY 128 OF CHAR;
BEGIN
Strings.IntToString(pos, p);
bug0 := linkCommand + path + "', '";
bug1 := bug0 + file + "', ";
bug2 := bug1 + p + ")";
cmd := bug2$
END GetCmd;
PROCEDURE CheckDoc (IN path, file: Files.Name; t: TextModels.Model; VAR f: TextMappers.Formatter;
tabs: INTEGER; check: BOOLEAN; VAR hit: BOOLEAN);
VAR r: TextModels.Reader; v: Views.View; leftSide, done: BOOLEAN; cmd, cmd0: ARRAY 1024 OF CHAR;
i: INTEGER;
BEGIN
r := t.NewReader(NIL);
r.ReadView(v);
WHILE v # NIL DO
WITH v: StdLinks.Link DO
IF v.leftSide THEN
v.GetCmd(cmd);
IF (cmd # "") & (~check OR Stale(cmd)) THEN
hit := TRUE;
i := 0; WHILE i # tabs DO f.WriteTab; INC(i) END;
GetCmd(path, file, r.Pos() - 1, cmd0);
f.WriteView(StdLinks.dir.NewLink(cmd0));
f.rider.SetAttr(link);
f.WriteString(cmd);
f.rider.SetAttr(default);
f.WriteView(StdLinks.dir.NewLink(""));
f.WriteLn
END
END
ELSE
END;
r.ReadView(v)
END
END CheckDoc;
PROCEDURE CheckLoc (
IN path: Files.Name; loc: Files.Locator; name: Files.Name; VAR f: TextMappers.Formatter;
check: BOOLEAN; OUT hit: BOOLEAN
);
VAR i: Iterator; fname: Files.Name; v: Views.View; conv: Converters.Converter;
label, label0: INTEGER; hit0: BOOLEAN;
BEGIN
label := f.Pos(); hit := FALSE;
loc := loc.This(name);
i := New(loc);
ReadFile(i, fname);
IF fname # "" THEN f.WriteTab; f.WriteString(name); f.WriteLn END;
hit := FALSE;
WHILE fname # "" DO
label0 := f.Pos(); hit0 := FALSE;
MakeDocName(fname);
v := Views.Old(Views.dontAsk, loc, fname, conv);
IF (v # NIL) & (v IS TextViews.View) THEN
f.WriteTab; f.WriteTab; f.WriteString(fname); f.WriteLn;
CheckDoc(path, fname, v(TextViews.View).ThisModel(), f, 3, check, hit0);
IF ~hit0 THEN f.SetPos(label0) END;
hit := hit OR hit0
END;
ReadFile(i, fname)
END;
IF ~hit THEN f.SetPos(label) END
END CheckLoc;
PROCEDURE Equal (IN a, b: ARRAY OF CHAR): BOOLEAN;
VAR i: INTEGER; ai, bi: CHAR;
PROCEDURE Eq (a, b: CHAR): BOOLEAN;
BEGIN
RETURN (a = b) OR (a >= "A") & (a <= "Z") & (a = CAP(b)) OR (b >= "A") & (b <= "Z") & (b = CAP(a))
END Eq;
BEGIN
i := 0; ai := a[0]; bi := b[0];
WHILE Eq(ai, bi) & (ai # 0X) DO INC(i); ai := a[i]; bi := b[i] END;
RETURN ai = bi
END Equal;
PROCEDURE Check* (subsystem: ARRAY OF CHAR; scope: INTEGER; check: BOOLEAN);
VAR i: Iterator; root, loc: Files.Locator; name: Files.Name; hit0, hit1: BOOLEAN;
out: TextModels.Model; f: TextMappers.Formatter; label: INTEGER; title: Views.Title;
v: TextViews.View; c: Containers.Controller; path: Files.Name;
BEGIN
out := TextModels.dir.New(); f.ConnectTo(out);
IF check THEN
Dialog.MapString("#Dev:InconsistentLinks", title)
ELSE
Dialog.MapString("#Dev:Links", title)
END;
v := TextViews.dir.New(out);
(* set Browser mode: *)
c := v.ThisController();
c.SetOpts(c.opts + {Containers.noCaret} - {Containers.noSelection, Containers.noFocus});
Views.OpenAux(v, title);
default := TextModels.dir.attr;
link := TextModels.NewColor(default, Ports.blue); link := TextModels.NewStyle(link, {Fonts.underline});
root := Files.dir.This("");
IF scope IN {globalSubsystem, allSubsystems} THEN
label := f.Pos();
Dialog.ShowStatus(".");
f.WriteString("."); f.WriteLn;
path := "Docu";
CheckLoc(path, root, "Docu", f, check, hit0);
path := "Mod";
CheckLoc(path, root, "Mod", f, check, hit1);
IF ~hit0 & ~hit1 THEN f.SetPos(label) END
END;
i := New(root);
ReadLoc(i, loc, name);
WHILE loc # NIL DO
IF (scope = allSubsystems) OR (scope = oneSubsystem) & Equal(name, subsystem) THEN
label := f.Pos();
Dialog.ShowStatus(name);
f.WriteString(name); f.WriteLn;
path := name + "/" + "Docu";
CheckLoc(path, loc, "Docu", f, check, hit0);
path := name + "/" + "Mod";
CheckLoc(path, loc, "Mod", f, check, hit1);
IF ~hit0 & ~hit1 THEN f.SetPos(label) END
END;
ReadLoc(i, loc, name)
END;
out.Delete(f.Pos(), out.Length());
Dialog.ShowStatus(""); default := NIL; link := NIL
END Check;
PROCEDURE PathToLoc (IN path: ARRAY OF CHAR; OUT loc: Files.Locator);
VAR i, j: INTEGER; ch: CHAR; name: ARRAY 256 OF CHAR;
BEGIN
loc := Files.dir.This("");
IF path # "" THEN
i := 0; j := 0;
REPEAT
ch := path[i]; INC(i);
IF (ch = "/") OR (ch = 0X) THEN name[j] := 0X; j := 0; loc := loc.This(name)
ELSE name[j] := ch; INC(j)
END
UNTIL (ch = 0X) OR (loc.res # 0)
END
END PathToLoc;
PROCEDURE Open* (path, file: ARRAY OF CHAR; pos: INTEGER);
VAR loc: Files.Locator; v: Views.View; bug: Files.Name; c: TextControllers.Controller;
BEGIN
ASSERT(file # "", 20); ASSERT(pos >= 0, 21);
PathToLoc(path, loc); ASSERT(loc # NIL, 22);
bug := file$;
v := Views.OldView(loc, bug);
IF v # NIL THEN
WITH v: TextViews.View DO
(*
v.DisplayMarks(TextViews.show);
*)
Views.Open(v, loc, bug, NIL);
c := v.ThisController()(TextControllers.Controller);
c.SetCaret(pos);
v.ShowRange(pos, pos + 1, TextViews.focusOnly)
ELSE
HALT(23)
END
END
END Open;
PROCEDURE ListLinks*;
(** Guard: CommandGuard **)
BEGIN
StdCmds.CloseDialog; Check(par.subsystem, par.scope, FALSE)
END ListLinks;
PROCEDURE CheckLinks*;
(** Guard: CommandGuard **)
BEGIN
StdCmds.CloseDialog; Check(par.subsystem, par.scope, TRUE)
END CheckLinks;
PROCEDURE SubsystemGuard* (VAR p: Dialog.Par);
BEGIN
p.readOnly := par.scope # oneSubsystem
END SubsystemGuard;
PROCEDURE CommandGuard* (VAR p: Dialog.Par);
BEGIN
p.disabled := (par.scope = oneSubsystem) & ~par.legal
END CommandGuard;
PROCEDURE SyntaxOK (VAR s: ARRAY OF CHAR): BOOLEAN;
VAR i: INTEGER; ch: CHAR;
BEGIN
i := 0; ch := s[0];
WHILE (ch >= "A") & (ch <= "Z") DO INC(i); ch := s[i] END;
WHILE (i # 0) & (ch >= "a") & (ch <= "z") OR (ch >= "0") & (ch <= "9") DO INC(i); ch := s[i] END;
RETURN (i >= 3) & (i <= 8) & (ch = 0X)
END SyntaxOK;
PROCEDURE SubsystemNotifier* (op, from, to: INTEGER);
BEGIN
IF par.scope = oneSubsystem THEN
par.legal := SyntaxOK(par.subsystem)
ELSE
par.subsystem := ""; par.legal := FALSE
END
END SubsystemNotifier;
END DevLinkChk.
| Dev/Mod/LinkChk.odc |
MODULE DevLinker;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Kernel, Files, Dates, Dialog, Strings,
TextModels, TextViews, TextMappers,
Log := StdLog, DevCommanders;
CONST
NewRecFP = 00000048H;
NewArrFP = 000004A8H;
ImageBase = 00400000H;
ObjAlign = 1000H;
FileAlign = 200H;
HeaderSize = 400H;
FixLen = 30000;
OFdir = "Code";
SYSdir = "System";
RsrcDir = "Rsrc";
WinDir = "Win";
(* meta interface consts *)
mConst = 1; mTyp = 2; mVar = 3; mProc = 4; mField = 5;
mInternal = 1; mReadonly = 2; mExported = 4;
(* fixup types *)
absolute = 100; relative = 101; copy = 102; table = 103; tableend = 104;
(* mod desc fields *)
modOpts = 4; modRefcnt = 8; modTerm = 40; modNames = 84; modImports = 92; modExports = 96;
TYPE
Name = ARRAY 40 OF SHORTCHAR;
Export = POINTER TO RECORD
next: Export;
name: Name;
adr: INTEGER
END;
Resource = POINTER TO RECORD
next, local: Resource;
typ, id, lid, size, pos, x, y: INTEGER;
opts: SET;
file: Files.File;
name: Files.Name
END;
Module = POINTER TO RECORD
next: Module;
name: Files.Name;
file: Files.File;
hs, ms, ds, cs, vs, ni, ma, ca, va: INTEGER;
dll, intf: BOOLEAN;
exp: Export;
imp: POINTER TO ARRAY OF Module;
data: POINTER TO ARRAY OF BYTE;
END;
VAR
W: TextMappers.Formatter;
Out: Files.File;
R: Files.Reader;
Ro: Files.Writer;
error, isDll, isStatic, comLine: BOOLEAN;
modList, kernel, main, last, impg, impd: Module;
numMod, lastTerm: INTEGER;
resList: Resource;
numType, resHSize: INTEGER;
numId: ARRAY 32 OF INTEGER;
firstExp, lastExp: Export;
entryPos, isPos, fixPos, himpPos, hexpPos, hrsrcPos, termPos: INTEGER;
codePos, dataPos, conPos, rsrcPos, impPos, expPos, relPos: INTEGER;
CodeSize, DataSize, ConSize, RsrcSize, ImpSize, ImpHSize, ExpSize, RelocSize, DllSize: INTEGER;
CodeRva, DataRva, ConRva, RsrcRva, ImpRva, ExpRva, RelocRva, ImagesSize: INTEGER;
CodeBase, DataBase, ConBase, maxCode, numImp, numExp, noffixup, timeStamp: INTEGER;
newRec, newArr: Name;
fixups: POINTER TO ARRAY OF INTEGER;
code: POINTER TO ARRAY OF BYTE;
atab: POINTER TO ARRAY OF INTEGER;
ntab: POINTER TO ARRAY OF SHORTCHAR;
PROCEDURE TimeStamp (): INTEGER; (* seconds since 1.1.1970 00:00:00 *)
VAR a: INTEGER; t: Dates.Time; d: Dates.Date;
BEGIN
Dates.GetTime(t); Dates.GetDate(d);
a := 12 * (d.year - 70) + d.month - 3;
a := a DIV 12 * 1461 DIV 4 + (a MOD 12 * 153 + 2) DIV 5 + d.day + 59;
RETURN ((a * 24 + t.hour) * 60 + t.minute) * 60 + t.second;
END TimeStamp;
PROCEDURE ThisFile (modname: ARRAY OF CHAR): Files.File;
VAR dir, name: Files.Name; loc: Files.Locator; f: Files.File;
BEGIN
Kernel.SplitName(modname, dir, name);
Kernel.MakeFileName(name, Kernel.objType);
loc := Files.dir.This(dir); loc := loc.This(OFdir);
f := Files.dir.Old(loc, name, TRUE);
IF (f = NIL) & (dir = "") THEN
loc := Files.dir.This(SYSdir); loc := loc.This(OFdir);
f := Files.dir.Old(loc, name, TRUE)
END;
RETURN f
END ThisFile;
PROCEDURE ThisResFile (VAR name: Files.Name): Files.File;
VAR loc: Files.Locator; f: Files.File;
BEGIN
f := Files.dir.Old(Files.dir.This(RsrcDir), name, TRUE);
IF f = NIL THEN
loc := Files.dir.This(WinDir); loc := loc.This(RsrcDir);
f := Files.dir.Old(loc, name, TRUE);
IF f = NIL THEN
f := Files.dir.Old(Files.dir.This(""), name, TRUE)
END
END;
RETURN f
END ThisResFile;
PROCEDURE Read2 (VAR x: INTEGER);
VAR b: BYTE;
BEGIN
R.ReadByte(b); x := b MOD 256;
R.ReadByte(b); x := x + 100H * (b MOD 256)
END Read2;
PROCEDURE Read4 (VAR x: INTEGER);
VAR b: BYTE;
BEGIN
R.ReadByte(b); x := b MOD 256;
R.ReadByte(b); x := x + 100H * (b MOD 256);
R.ReadByte(b); x := x + 10000H * (b MOD 256);
R.ReadByte(b); x := x + 1000000H * b
END Read4;
PROCEDURE ReadName (VAR name: ARRAY OF SHORTCHAR);
VAR i: INTEGER; b: BYTE;
BEGIN i := 0;
REPEAT
R.ReadByte(b); name[i] := SHORT(CHR(b)); INC(i)
UNTIL b = 0
END ReadName;
PROCEDURE RNum (VAR i: INTEGER);
VAR b: BYTE; s, y: INTEGER;
BEGIN
s := 0; y := 0; R.ReadByte(b);
WHILE b < 0 DO INC(y, ASH(b + 128, s)); INC(s, 7); R.ReadByte(b) END;
i := ASH((b + 64) MOD 128 - 64, s) + y
END RNum;
PROCEDURE WriteCh (ch: SHORTCHAR);
BEGIN
Ro.WriteByte(SHORT(ORD(ch)))
END WriteCh;
PROCEDURE Write2 (x: INTEGER);
BEGIN
Ro.WriteByte(SHORT(SHORT(x MOD 256))); x := x DIV 256;
Ro.WriteByte(SHORT(SHORT(x MOD 256)))
END Write2;
PROCEDURE Write4 (x: INTEGER);
BEGIN
Ro.WriteByte(SHORT(SHORT(x MOD 256))); x := x DIV 256;
Ro.WriteByte(SHORT(SHORT(x MOD 256))); x := x DIV 256;
Ro.WriteByte(SHORT(SHORT(x MOD 256))); x := x DIV 256;
Ro.WriteByte(SHORT(SHORT(x MOD 256)))
END Write4;
PROCEDURE WriteName (s: ARRAY OF SHORTCHAR; len: SHORTINT);
VAR i: SHORTINT;
BEGIN i := 0;
WHILE s[i] # 0X DO Ro.WriteByte(SHORT(ORD(s[i]))); INC(i) END;
WHILE i < len DO Ro.WriteByte(0); INC(i) END
END WriteName;
PROCEDURE Reloc (a: INTEGER);
VAR p: POINTER TO ARRAY OF INTEGER; i: INTEGER;
BEGIN
IF noffixup >= LEN(fixups) THEN
NEW(p, 2 * LEN(fixups));
i := 0; WHILE i < LEN(fixups) DO p[i] := fixups[i]; INC(i) END;
fixups := p
END;
fixups[noffixup] := a; INC(noffixup)
(*
ELSE
IF ~error THEN W.WriteSString(" too many fixups") END;
error := TRUE
END
*)
END Reloc;
PROCEDURE Put (mod: Module; a, x: INTEGER);
BEGIN
mod.data[a] := SHORT(SHORT(x)); INC(a); x := x DIV 256;
mod.data[a] := SHORT(SHORT(x)); INC(a); x := x DIV 256;
mod.data[a] := SHORT(SHORT(x)); INC(a); x := x DIV 256;
mod.data[a] := SHORT(SHORT(x))
END Put;
PROCEDURE Get (mod: Module; a: INTEGER; VAR x: INTEGER);
BEGIN
x := ((mod.data[a + 3] * 256 +
(mod.data[a + 2] MOD 256)) * 256 +
(mod.data[a + 1] MOD 256)) * 256 +
(mod.data[a] MOD 256)
END Get;
PROCEDURE GenName (VAR from, to: ARRAY OF SHORTCHAR; ext: ARRAY OF SHORTCHAR);
VAR i, j: INTEGER;
BEGIN
i := 0;
WHILE from[i] # 0X DO to[i] := from[i]; INC(i) END;
IF ext # "" THEN
to[i] := "."; INC(i); j := 0;
WHILE ext[j] # 0X DO to[i] := ext[j]; INC(i); INC(j) END
END;
to[i] := 0X
END GenName;
PROCEDURE Fixup0 (link, adr: INTEGER);
VAR offset, linkadr, t, n, x: INTEGER;
BEGIN
WHILE link # 0 DO
RNum(offset);
WHILE link # 0 DO
IF link > 0 THEN
n := (code[link] MOD 256) + (code[link+1] MOD 256) * 256 + code[link+2] * 65536;
t := code[link+3]; linkadr := CodeBase + impg.ca + link
ELSE
n := (impg.data[-link] MOD 256) + (impg.data[-link+1] MOD 256) * 256 + impg.data[-link+2] * 65536;
t := impg.data[-link+3]; linkadr := ConBase + impg.ma - link
END;
IF t = absolute THEN x := adr + offset
ELSIF t = relative THEN x := adr + offset - linkadr - 4
ELSIF t = copy THEN Get(impd, adr + offset - ConBase - impd.ma, x)
ELSIF t = table THEN x := adr + n; n := link + 4
ELSIF t = tableend THEN x := adr + n; n := 0
ELSE HALT(99)
END;
IF link > 0 THEN
code[link] := SHORT(SHORT(x));
code[link+1] := SHORT(SHORT(x DIV 100H));
code[link+2] := SHORT(SHORT(x DIV 10000H));
code[link+3] := SHORT(SHORT(x DIV 1000000H))
ELSE
link := -link;
impg.data[link] := SHORT(SHORT(x));
impg.data[link+1] := SHORT(SHORT(x DIV 100H));
impg.data[link+2] := SHORT(SHORT(x DIV 10000H));
impg.data[link+3] := SHORT(SHORT(x DIV 1000000H))
END;
IF (t # relative) & ((t # copy) OR (x DIV 65536 # 0)) THEN Reloc(linkadr) END;
link := n
END;
RNum(link)
END
END Fixup0;
PROCEDURE Fixup (adr: INTEGER);
VAR link: INTEGER;
BEGIN
RNum(link); Fixup0(link, adr)
END Fixup;
PROCEDURE CheckDllImports (mod: Module);
VAR i, x, y: INTEGER; name: Name; imp: Module; exp: Export;
PROCEDURE SkipLink;
VAR a: INTEGER;
BEGIN
RNum(a);
WHILE a # 0 DO RNum(a); RNum(a) END
END SkipLink;
BEGIN
R := mod.file.NewReader(R);
R.SetPos(mod.hs + mod.ms + mod.ds + mod.cs);
SkipLink; SkipLink; SkipLink; SkipLink; SkipLink; SkipLink; i := 0;
WHILE i < mod.ni DO
imp := mod.imp[i];
IF imp # NIL THEN
RNum(x);
WHILE x # 0 DO
ReadName(name); RNum(y);
IF x = mVar THEN SkipLink;
IF imp.dll THEN
W.WriteString("variable (");
W.WriteString(imp.name); W.WriteChar(".");
W.WriteSString(name);
W.WriteString(") imported from DLL in ");
W.WriteString(mod.name);
W.WriteLn; Log.text.Append(Log.buf); error := TRUE;
RETURN
END
ELSIF x = mTyp THEN RNum(y);
IF imp.dll THEN
RNum(y);
IF y # 0 THEN
W.WriteString("type descriptor (");
W.WriteString(imp.name); W.WriteChar(".");
W.WriteSString(name);
W.WriteString(") imported from DLL in ");
W.WriteString(mod.name);
W.WriteLn; Log.text.Append(Log.buf); error := TRUE;
RETURN
END
ELSE SkipLink
END
ELSIF x = mProc THEN
IF imp.dll THEN
SkipLink; exp := imp.exp;
WHILE (exp # NIL) & (exp.name # name) DO exp := exp.next END;
IF exp = NIL THEN
NEW(exp); exp.name := name$;
exp.next := imp.exp; imp.exp := exp; INC(DllSize, 6)
END
END
END;
RNum(x)
END
END;
INC(i)
END
END CheckDllImports;
PROCEDURE ReadHeaders;
VAR mod, im, t: Module; x, i: INTEGER; impdll: BOOLEAN; exp: Export; name: Name;
BEGIN
mod := modList; modList := NIL; numMod := 0;
WHILE mod # NIL DO (* reverse mod list & count modules *)
IF ~mod.dll THEN INC(numMod) END;
t := mod; mod := t.next; t.next := modList; modList := t
END;
IF isStatic THEN
IF isDll THEN
(* push ebx; cmp [12, esp], 1; jne L1; mov ebx, modlist; { call body; } jp L2 *)
(* L1: cmp [12, esp], 0; jne L2; { call term; } *)
(* L2: pop ebx; mov aex,1; ret 12 *)
CodeSize := 42 + 10 * numMod
ELSE
(* push ebx; push ebx; push ebx; mov ebx, modlist; { call body; } { call term; } *)
(* pop ebx; pop ebx; pop ebx; ret *)
CodeSize := 12 + 10 * numMod
END
ELSE
IF isDll THEN
(* push ebx; cmp [12, esp], 1; jne L1; mov ebx, modlist; call main; jp L2 *)
(* L1: cmp [12, esp], 0; jne L2; call mainTerm; *)
(* L2: pop ebx; mov aex,1; ret 12 *)
CodeSize := 41
ELSE
(* mov ebx, modlist; jmp main *)
CodeSize := 10
END
END;
(*
IF isDll THEN
CodeSize := 24 (* push ebx, esi, edi; mov bx, modlist; call main; pop edi, esi, ebx; mov aex,1; ret 12 *)
ELSE
CodeSize := 10 (* mov bx, modlist; jmp main *)
END
*)
DataSize := 0; ConSize := 0;
ImpSize := 0; ImpHSize := 0; ExpSize := 0;
RelocSize := 0; DllSize := 0; noffixup := 0; maxCode := 0; numImp := 0; numExp := 0;
mod := modList;
WHILE mod # NIL DO
IF ~mod.dll THEN
mod.file := ThisFile(mod.name);
IF mod.file # NIL THEN
R := mod.file.NewReader(R); R.SetPos(0); Read4(x);
IF x = 6F4F4346H THEN
Read4(x);
Read4(mod.hs); Read4(mod.ms); Read4(mod.ds); Read4(mod.cs);
Read4(mod.vs); RNum(mod.ni); ReadName(name); impdll := FALSE;
IF mod.ni > 0 THEN
NEW(mod.imp, mod.ni); x := 0;
WHILE x < mod.ni DO
ReadName(name);
IF name = "$$" THEN
IF (mod # kernel) & (kernel # NIL) THEN
mod.imp[x] := kernel
ELSE
W.WriteSString("no kernel"); W.WriteLn;
Log.text.Append(Log.buf); error := TRUE
END
ELSIF name[0] = "$" THEN
i := 1;
WHILE name[i] # 0X DO name[i-1] := name[i]; INC(i) END;
name[i-1] := 0X; impdll := TRUE; im := modList;
WHILE (im # mod) & (im.name # name) DO im := im.next END;
IF (im = NIL) OR ~im.dll THEN
NEW(im); im.next := modList; modList := im;
im.name := name$;
im.dll := TRUE
END;
mod.imp[x] := im;
ELSE
im := modList;
WHILE (im # mod) & (im.name # name) DO im := im.next END;
IF im # mod THEN
mod.imp[x] := im;
ELSE
W.WriteSString(name);
W.WriteString(" not present (imported in ");
W.WriteString(mod.name); W.WriteChar(")");
W.WriteLn; Log.text.Append(Log.buf); error := TRUE
END
END;
INC(x)
END
END;
IF impdll & ~error THEN CheckDllImports(mod) END;
mod.ma := ConSize; INC(ConSize, mod.ms + mod.ds);
mod.va := DataSize; INC(DataSize, mod.vs);
mod.ca := CodeSize; INC(CodeSize, mod.cs);
IF mod.cs > maxCode THEN maxCode := mod.cs END
ELSE
W.WriteString(mod.name); W.WriteString(": wrong file type");
W.WriteLn; Log.text.Append(Log.buf); error := TRUE
END;
mod.file.Close; mod.file := NIL
ELSE
W.WriteString(mod.name); W.WriteString(" not found");
W.WriteLn; Log.text.Append(Log.buf); error := TRUE
END;
last := mod
END;
mod := mod.next
END;
IF ~isStatic & (main = NIL) THEN
W.WriteSString("no main module specified"); W.WriteLn;
Log.text.Append(Log.buf); error := TRUE
END;
(* calculate rva's *)
IF DataSize = 0 THEN DataSize := 1 END;
CodeRva := ObjAlign;
DataRva := CodeRva + (CodeSize + DllSize + (ObjAlign - 1)) DIV ObjAlign * ObjAlign;
ConRva := DataRva + (DataSize + (ObjAlign - 1)) DIV ObjAlign * ObjAlign;
RsrcRva := ConRva + (ConSize + (ObjAlign - 1)) DIV ObjAlign * ObjAlign;
CodeBase := ImageBase + CodeRva;
DataBase := ImageBase + DataRva;
ConBase := ImageBase + ConRva;
(* write dll export adresses *)
mod := modList; x := 0;
WHILE mod # NIL DO
IF mod.dll THEN
exp := mod.exp; INC(ImpSize, 20);
WHILE exp # NIL DO exp.adr := x; INC(x, 6); exp := exp.next END
END;
mod := mod.next
END;
ASSERT(x = DllSize); INC(ImpSize, 20); (* sentinel *)
END ReadHeaders;
PROCEDURE MenuSize (r: Resource): INTEGER;
VAR s, i: INTEGER;
BEGIN
s := 0;
WHILE r # NIL DO
INC(s, 2);
IF r.local = NIL THEN INC(s, 2) END;
i := 0; WHILE r.name[i] # 0X DO INC(s, 2); INC(i) END;
INC(s, 2);
s := s + MenuSize(r.local);
r := r.next
END;
RETURN s
END MenuSize;
PROCEDURE PrepResources;
VAR res, r, s: Resource; n, i, j, t, x: INTEGER;
BEGIN
r := resList;
WHILE r # NIL DO
IF r.lid = 0 THEN r.lid := 1033 END;
IF r.name = "MENU" THEN
r.typ := 4; r.size := 4 + MenuSize(r.local);
ELSIF r.name = "ACCELERATOR" THEN
r.typ := 9; r.size := 0; s := r.local;
WHILE s # NIL DO INC(r.size, 8); s := s.next END;
ELSE
r.file := ThisResFile(r.name);
IF r.file # NIL THEN
IF r.typ = -1 THEN (* typelib *)
r.typ := 0; r.size := r.file.Length(); r.pos := 0
ELSE
R := r.file.NewReader(R); R.SetPos(0); Read2(n);
IF n = 4D42H THEN (* bitmap *)
Read4(n); r.typ := 2; r.size := n - 14; r.pos := 14;
ELSE
Read2(x);
IF x = 1 THEN (* icon *)
Read2(n); r.typ := 14; r.size := 6 + 14 * n; r.pos := 0; i := 0;
WHILE i < n DO
NEW(s); s.typ := 3; s.id := 10 * r.id + i; s.lid := r.lid; s.name := r.name$;
Read4(x); Read4(x); Read4(s.size); Read2(s.pos); Read2(x);
s.next := resList; resList := s;
INC(i)
END
ELSIF x = 2 THEN (* cursor *)
Read2(n); r.typ := 12; r.size := 6 + 14 * n; r.pos := 0; i := 0;
WHILE i < n DO
NEW(s); s.typ := 1; s.id := 10 * r.id + i; s.lid := r.lid; s.name := r.name$;
Read4(x); Read2(s.x); Read2(s.y); Read4(s.size); INC(s.size, 4); Read2(s.pos); Read2(x);
s.next := resList; resList := s;
INC(i)
END
ELSE
Read4(n);
IF (x = 0) & (n = 20H) THEN (* resource file *)
Read4(n); Read4(n); Read4(n); Read4(n); Read4(n); Read4(n); (* 32 bit marker *)
Read4(r.size); Read4(n); Read2(i); Read2(j);
IF (i = 0FFFFH) & (j >= 4) & ((j <= 11) OR (j = 16)) THEN
r.typ := j; r.pos := n + 32;
ELSE
W.WriteString(r.name); W.WriteString(": invalid type"); W.WriteLn;
Log.text.Append(Log.buf); error := TRUE
END
ELSE
W.WriteString(r.name); W.WriteString(": unknown type"); W.WriteLn;
Log.text.Append(Log.buf); error := TRUE
END
END
END
END;
r.file.Close; r.file := NIL
ELSE
W.WriteString(r.name); W.WriteString(" not found"); W.WriteLn;
Log.text.Append(Log.buf); error := TRUE
END
END;
r := r.next
END;
res := resList; resList := NIL; (* sort resources *)
WHILE res # NIL DO
r := res; res := res.next;
IF (resList = NIL) OR (r.typ < resList.typ) OR (r.typ = resList.typ) & ((r.id < resList.id) OR (r.id = resList.id) & (r.lid < resList.lid))
THEN
r.next := resList; resList := r
ELSE
s := resList;
WHILE (s.next # NIL) & (r.typ >= s.next.typ)
& ((r.typ # s.next.typ) OR (r.id >= s.next.id) & ((r.id # s.next.id) OR (r.lid >= s.next.lid))) DO s := s.next END;
r.next := s.next; s.next := r
END
END;
r := resList; numType := 0; resHSize := 16; t := 0; n := 0; (* get resource size *)
WHILE t < LEN(numId) DO numId[t] := 0; INC(t) END;
WHILE r # NIL DO
INC(numType); INC(resHSize, 24); t := r.typ;
WHILE (r # NIL) & (r.typ = t) DO
INC(numId[t]); INC(resHSize, 24); i := r.id;
WHILE (r # NIL) & (r.typ = t) & (r.id = i) DO
INC(resHSize, 24); INC(n, (r.size + 3) DIV 4 * 4); r := r.next
END
END
END;
IF numId[0] > 0 THEN INC(n, 16) END;
RsrcSize := resHSize + n;
ImpRva := RsrcRva + (RsrcSize + (ObjAlign - 1)) DIV ObjAlign * ObjAlign
END PrepResources;
PROCEDURE WriteHeader(VAR name: Files.Name);
BEGIN
Out := Files.dir.New(Files.dir.This(""), Files.ask); Ro := Out.NewWriter(Ro); Ro.SetPos(0);
(* DOS header *)
Write4(905A4DH); Write4(3); Write4(4); Write4(0FFFFH);
Write4(0B8H); Write4(0); Write4(40H); Write4(0);
Write4(0); Write4(0); Write4(0); Write4(0);
Write4(0); Write4(0); Write4(0); Write4(80H);
Write4(0EBA1F0EH); Write4(0CD09B400H); Write4(4C01B821H); Write2(21CDH);
WriteName("This program cannot be run in DOS mode.", 39);
WriteCh(0DX); WriteCh(0DX); WriteCh(0AX);
Write4(24H); Write4(0);
(* Win32 header *)
WriteName("PE", 4); (* signature bytes *)
Write2(014CH); (* cpu type (386) *)
IF isDll THEN
Write2(7); (* 7 objects *)
ELSE
Write2(6); (* 6 objects *)
END;
Write4(timeStamp); (* time/date *)
Write4(0); Write4(0);
Write2(0E0H); (* NT header size *)
IF isDll THEN
Write2(0A38EH); (* library image flags *)
ELSE
Write2(838EH); (* program image flags *)
END;
Write2(10BH); (* magic (normal ececutable file) *)
Write2(0301H); (* linker version !!! *)
Write4(CodeSize); (* code size *)
Write4(ConSize); (* initialized data size *)
Write4(DataSize); (* uninitialized data size *)
entryPos := Ro.Pos();
Write4(0); (* entry point *) (* !!! *)
Write4(CodeRva); (* base of code *)
Write4(ConRva); (* base of data *)
Write4(400000H); (* image base *)
Write4(ObjAlign); (* object align *)
Write4(FileAlign); (* file align *)
Write4(3); (* OS version *)
Write4(4); (* user version *)
Write4(4); (* subsys version *) (* mf 14.3.04: value changed from 0A0003H to 4. Corrects menubar pixel bug on Windows XP *)
Write4(0);
isPos := Ro.Pos();
Write4(0); (* image size *) (* !!! *)
Write4(HeaderSize); (* header size !!! *)
Write4(0); (* checksum *)
IF comLine THEN
Write2(3) (* dos subsystem *)
ELSE
Write2(2) (* gui subsystem *)
END;
Write2(0); (* dll flags *)
Write4(200000H); (* stack reserve size *)
Write4(10000H); (* stack commit size *)
IF isDll THEN
Write4(00100000H); (* heap reserve size *)
ELSE
Write4(00400000H); (* heap reserve size *)
END;
Write4(10000H); (* heap commit size *)
Write4(0);
Write4(16); (* num of rva/sizes *)
hexpPos := Ro.Pos();
Write4(0); Write4(0); (* export table *)
himpPos := Ro.Pos();
Write4(0); Write4(0); (* import table *) (* !!! *)
hrsrcPos := Ro.Pos();
Write4(0); Write4(0); (* resource table *) (* !!! *)
Write4(0); Write4(0); (* exception table *)
Write4(0); Write4(0); (* security table *)
fixPos := Ro.Pos();
Write4(0); Write4(0); (* fixup table *) (* !!! *)
Write4(0); Write4(0); (* debug table *)
Write4(0); Write4(0); (* image description *)
Write4(0); Write4(0); (* machine specific *)
Write4(0); Write4(0); (* thread local storage *)
Write4(0); Write4(0); (* ??? *)
Write4(0); Write4(0); (* ??? *)
Write4(0); Write4(0); (* ??? *)
Write4(0); Write4(0); (* ??? *)
Write4(0); Write4(0); (* ??? *)
Write4(0); Write4(0); (* ??? *)
(* object directory *)
WriteName(".text", 8); (* code object *)
Write4(0); (* object size (always 0) *)
codePos := Ro.Pos();
Write4(0); (* object rva *)
Write4(0); (* physical size *)
Write4(0); (* physical offset *)
Write4(0); Write4(0); Write4(0);
Write4(60000020H); (* flags: code, exec, read *)
WriteName(".var", 8); (* variable object *)
Write4(0); (* object size (always 0) *)
dataPos := Ro.Pos();
Write4(0); (* object rva *)
Write4(0); (* physical size *)
Write4(0); (* physical offset *) (* zero! (noinit) *)
Write4(0); Write4(0); Write4(0);
Write4(0C0000080H); (* flags: noinit, read, write *)
WriteName(".data", 8); (* constant object *)
Write4(0); (* object size (always 0) *)
conPos := Ro.Pos();
Write4(0); (* object rva *)
Write4(0); (* physical size *)
Write4(0); (* physical offset *)
Write4(0); Write4(0); Write4(0);
Write4(0C0000040H); (* flags: data, read, write *)
WriteName(".rsrc", 8); (* resource object *)
Write4(0); (* object size (always 0) *)
rsrcPos := Ro.Pos();
Write4(0); (* object rva *)
Write4(0); (* physical size *)
Write4(0); (* physical offset *)
Write4(0); Write4(0); Write4(0);
Write4(0C0000040H); (* flags: data, read, write *)
WriteName(".idata", 8); (* import object *)
Write4(0); (* object size (always 0) *)
impPos := Ro.Pos();
Write4(0); (* object rva *)
Write4(0); (* physical size *)
Write4(0); (* physical offset *)
Write4(0); Write4(0); Write4(0);
Write4(0C0000040H); (* flags: data, read, write *)
IF isDll THEN
WriteName(".edata", 8); (* export object *)
Write4(0); (* object size (always 0) *)
expPos := Ro.Pos();
Write4(0); (* object rva *)
Write4(0); (* physical size *)
Write4(0); (* physical offset *)
Write4(0); Write4(0); Write4(0);
Write4(0C0000040H); (* flags: data, read, write *)
END;
WriteName(".reloc", 8); (* relocation object *)
Write4(0); (* object size (always 0) *)
relPos := Ro.Pos();
Write4(0); (* object rva *)
Write4(0); (* physical size *)
Write4(0); (* physical offset *)
Write4(0); Write4(0); Write4(0);
Write4(42000040H); (* flags: data, read, ? *)
END WriteHeader;
PROCEDURE SearchObj (mod: Module; VAR name: ARRAY OF SHORTCHAR; m, fp, opt: INTEGER; VAR adr: INTEGER);
VAR dir, len, ntab, f, id, l, r, p, n, i, j: INTEGER; nch, och: SHORTCHAR;
BEGIN
Get(mod, mod.ms + modExports, dir); DEC(dir, ConBase + mod.ma); Get(mod, dir, len); INC(dir, 4);
Get(mod, mod.ms + modNames, ntab); DEC(ntab, ConBase + mod.ma);
IF name # "" THEN
l := 0; r := len;
WHILE l < r DO (* binary search *)
n := (l + r) DIV 2; p := dir + n * 16;
Get(mod, p + 8, id);
i := 0; j := ntab + id DIV 256; nch := name[0]; och := SHORT(CHR(mod.data[j]));
WHILE (nch = och) & (nch # 0X) DO INC(i); INC(j); nch := name[i]; och := SHORT(CHR(mod.data[j])) END;
IF och = nch THEN
IF id MOD 16 = m THEN Get(mod, p, f);
IF m = mTyp THEN
IF ODD(opt) THEN Get(mod, p + 4, f) END;
IF (opt > 1) & (id DIV 16 MOD 16 # mExported) THEN
W.WriteString(mod.name); W.WriteChar("."); W.WriteSString(name);
W.WriteString(" imported from "); W.WriteString(impg.name);
W.WriteString(" has wrong visibility"); W.WriteLn; error := TRUE
END;
Get(mod, p + 12, adr)
ELSIF m = mVar THEN
Get(mod, p + 4, adr); INC(adr, DataBase + mod.va)
ELSIF m = mProc THEN
Get(mod, p + 4, adr); INC(adr, CodeBase + mod.ca)
END;
IF f # fp THEN
IF opt = -1 THEN adr := -1
ELSE
W.WriteString(mod.name); W.WriteChar("."); W.WriteSString(name);
W.WriteString(" imported from "); W.WriteString(impg.name);
W.WriteString(" has wrong fprint"); W.WriteLn; error := TRUE
END
END
ELSE
IF opt = -1 THEN adr := -1
ELSE
W.WriteString(mod.name); W.WriteChar("."); W.WriteSString(name);
W.WriteString(" imported from "); W.WriteString(impg.name);
W.WriteString(" has wrong class"); W.WriteLn; error := TRUE
END
END;
RETURN
END;
IF och < nch THEN l := n + 1 ELSE r := n END
END;
IF opt = -1 THEN adr := -1
ELSE
W.WriteString(mod.name); W.WriteChar("."); W.WriteSString(name);
W.WriteString(" not found (imported from "); W.WriteString(impg.name);
W.WriteChar(")"); W.WriteLn; error := TRUE
END
ELSE (* anonymous type *)
WHILE len > 0 DO
Get(mod, dir + 4, f); Get(mod, dir + 8, id);
IF (f = fp) & (id MOD 16 = mTyp) & (id DIV 256 = 0) THEN
Get(mod, dir + 12, adr); RETURN
END;
DEC(len); INC(dir, 16)
END;
W.WriteString("anonymous type in "); W.WriteString(mod.name);
W.WriteString(" not found"); W.WriteLn; error := TRUE
END
END SearchObj;
PROCEDURE CollectExports (mod: Module);
VAR dir, len, ntab, id, i, j, n: INTEGER; e, exp: Export;
BEGIN
Get(mod, mod.ms + modExports, dir); DEC(dir, ConBase + mod.ma); Get(mod, dir, len); INC(dir, 4);
Get(mod, mod.ms + modNames, ntab); DEC(ntab, ConBase + mod.ma); n := 0;
WHILE n < len DO
Get(mod, dir + 8, id);
IF (id DIV 16 MOD 16 # mInternal) & ((id MOD 16 = mProc) OR (id MOD 16 = mVar))THEN (* exported procedure & var *)
NEW(exp);
i := 0; j := ntab + id DIV 256;
WHILE mod.data[j] # 0 DO exp.name[i] := SHORT(CHR(mod.data[j])); INC(i); INC(j) END;
exp.name[i] := 0X;
Get(mod, dir + 4, exp.adr);
IF id MOD 16 = mProc THEN INC(exp.adr, CodeRva + mod.ca)
ELSE ASSERT(id MOD 16 = mVar); INC(exp.adr, DataRva + mod.va)
END;
IF (firstExp = NIL) OR (exp.name < firstExp.name) THEN
exp.next := firstExp; firstExp := exp;
IF lastExp = NIL THEN lastExp := exp END
ELSE
e := firstExp;
WHILE (e.next # NIL) & (exp.name > e.next.name) DO e := e.next END;
exp.next := e.next; e.next := exp;
IF lastExp = e THEN lastExp := exp END
END;
INC(numExp);
END;
INC(n); INC(dir, 16)
END
END CollectExports;
(*
PROCEDURE WriteTermCode (m: Module; i: INTEGER);
VAR x: INTEGER;
BEGIN
IF m # NIL THEN
IF m.dll THEN WriteTermCode(m.next, i)
ELSE
IF isStatic THEN WriteTermCode(m.next, i + 1) END;
SearchObj(m, terminator, mProc, terminatorFP, -1, x);
IF x = -1 THEN
WriteCh(005X); Write4(0) (* add EAX, 0 (nop) *)
ELSE
WriteCh(0E8X); Write4(x - lastTerm + 5 * i - CodeBase) (* call term *)
END
END
END
END WriteTermCode;
*)
PROCEDURE WriteTermCode (m: Module; i: INTEGER);
VAR x: INTEGER;
BEGIN
IF m # NIL THEN
IF m.dll THEN WriteTermCode(m.next, i)
ELSE
IF isStatic THEN WriteTermCode(m.next, i + 1) END;
Get(m, m.ms + modTerm, x); (* terminator address in mod desc*)
IF x = 0 THEN
WriteCh(005X); Write4(0) (* add EAX, 0 (nop) *)
ELSE
WriteCh(0E8X); Write4(x - lastTerm + 5 * i - CodeBase) (* call term *)
END
END
END
END WriteTermCode;
PROCEDURE WriteCode;
VAR mod, m: Module; i, x, a, fp, opt: INTEGER; exp: Export; name: Name;
BEGIN
IF isStatic THEN
WriteCh(053X); (* push ebx *)
a := 1;
IF isDll THEN
WriteCh(083X); WriteCh(07CX); WriteCh(024X); WriteCh(00CX); WriteCh(001X); (* cmp [12, esp], 1 *)
WriteCh(00FX); WriteCh(085X); Write4(10 + 5 * numMod); (* jne L1 *)
INC(a, 11)
ELSE
WriteCh(053X); WriteCh(053X); (* push ebx; push ebx *)
INC(a, 2)
END;
WriteCh(0BBX); Write4(ConBase + last.ma + last.ms); Reloc(CodeBase + a + 1); (* mov bx, modlist *)
INC(a, 5); m := modList;
WHILE m # NIL DO
IF ~m.dll THEN
WriteCh(0E8X); INC(a, 5); Write4(m.ca - a) (* call body *)
END;
m := m.next
END;
IF isDll THEN
WriteCh(0E9X); Write4(11 + 5 * numMod); (* jp L2 *)
WriteCh(083X); WriteCh(07CX); WriteCh(024X); WriteCh(00CX); WriteCh(000X); (* L1: cmp [12, esp], 0 *)
WriteCh(00FX); WriteCh(085X); Write4(5 * numMod); (* jne L2 *)
INC(a, 16)
END;
termPos := Ro.Pos(); i := 0;
WHILE i < numMod DO (* nop for call terminator *)
WriteCh(02DX); Write4(0); (* sub EAX, 0 *)
INC(i); INC(a, 5)
END;
lastTerm := a;
WriteCh(05BX); (* L2: pop ebx *)
IF isDll THEN
WriteCh(0B8X); Write4(1); (* mov eax,1 *)
WriteCh(0C2X); Write2(12) (* ret 12 *)
ELSE
WriteCh(05BX); WriteCh(05BX); (* pop ebx; pop ebx *)
WriteCh(0C3X) (* ret *)
END
ELSIF isDll THEN
WriteCh(053X); (* push ebx *)
WriteCh(083X); WriteCh(07CX); WriteCh(024X); WriteCh(00CX); WriteCh(001X); (* cmp [12, esp], 1 *)
WriteCh(075X); WriteCh(SHORT(CHR(12))); (* jne L1 *)
WriteCh(0BBX); Write4(ConBase + last.ma + last.ms); Reloc(CodeBase + 9); (* mov bx, modlist *)
WriteCh(0E8X); Write4(main.ca - 18); (* call main *)
WriteCh(0EBX); WriteCh(SHORT(CHR(12))); (* jp L2 *)
WriteCh(083X); WriteCh(07CX); WriteCh(024X); WriteCh(00CX); WriteCh(000X); (* L1: cmp [12, esp], 0 *)
WriteCh(075X); WriteCh(SHORT(CHR(5))); (* jne L2 *)
termPos := Ro.Pos();
WriteCh(02DX); Write4(0); (* sub EAX, 0 *) (* nop for call terminator *)
lastTerm := 32;
WriteCh(05BX); (* L2: pop ebx *)
WriteCh(0B8X); Write4(1); (* mov eax,1 *)
WriteCh(0C2X); Write2(12) (* ret 12 *)
ELSE
WriteCh(0BBX); Write4(ConBase + last.ma + last.ms); Reloc(CodeBase + 1); (* mov bx, modlist *)
WriteCh(0E9X); Write4(main.ca - 10); (* jmp main *)
END;
NEW(code, maxCode);
mod := modList;
WHILE mod # NIL DO impg := mod; impd := mod;
IF ~mod.dll THEN
mod.file := ThisFile(mod.name);
R := mod.file.NewReader(R); R.SetPos(mod.hs);
NEW(mod.data, mod.ms + mod.ds);
R.ReadBytes(mod.data^, 0, mod.ms + mod.ds);
R.ReadBytes(code^, 0, mod.cs);
RNum(x);
IF x # 0 THEN
IF (mod # kernel) & (kernel # NIL) THEN
SearchObj(kernel, newRec, mProc, NewRecFP, 0, a); Fixup0(x, a)
ELSE
W.WriteSString("no kernel"); W.WriteLn;
Log.text.Append(Log.buf); error := TRUE; RETURN
END
END;
RNum(x);
IF x # 0 THEN
IF (mod # kernel) & (kernel # NIL) THEN
SearchObj(kernel, newArr, mProc, NewArrFP, 0, a); Fixup0(x, a)
ELSE
W.WriteSString("no kernel"); W.WriteLn;
Log.text.Append(Log.buf); error := TRUE; RETURN
END
END;
Fixup(ConBase + mod.ma);
Fixup(ConBase + mod.ma + mod.ms);
Fixup(CodeBase + mod.ca);
Fixup(DataBase + mod.va); i := 0;
WHILE i < mod.ni DO
m := mod.imp[i]; impd := m; RNum(x);
WHILE x # 0 DO
ReadName(name); RNum(fp); opt := 0;
IF x = mTyp THEN RNum(opt) END;
IF m.dll THEN
IF x = mProc THEN exp := m.exp;
WHILE exp.name # name DO exp := exp.next END;
a := exp.adr + CodeBase + CodeSize
END
ELSE
SearchObj(m, name, x, fp, opt, a)
END;
IF x # mConst THEN Fixup(a) END;
RNum(x)
END;
IF ~m.dll THEN
Get(mod, mod.ms + modImports, x); DEC(x, ConBase + mod.ma); INC(x, 4 * i);
Put(mod, x, ConBase + m.ma + m.ms); (* imp ref *)
Reloc(ConBase + mod.ma + x);
Get(m, m.ms + modRefcnt, x); Put(m, m.ms + modRefcnt, x + 1) (* inc ref count *)
END;
INC(i)
END;
Ro.WriteBytes(code^, 0, mod.cs);
IF mod.intf THEN CollectExports(mod) END;
mod.file.Close; mod.file := NIL
END;
mod := mod.next
END;
(* dll links *)
mod := modList; ImpHSize := ImpSize;
WHILE mod # NIL DO
IF mod.dll THEN
exp := mod.exp;
WHILE exp # NIL DO
WriteCh(0FFX); WriteCh(25X); Write4(ImageBase + ImpRva + ImpSize); (* JMP indirect *)
Reloc(CodeBase + CodeSize + exp.adr + 2);
INC(ImpSize, 4); INC(numImp); exp := exp.next
END;
INC(ImpSize, 4); INC(numImp) (* sentinel *)
END;
mod := mod.next
END
END WriteCode;
PROCEDURE WriteConst;
VAR mod, last: Module; x: INTEGER;
BEGIN
mod := modList; last := NIL;
WHILE mod # NIL DO
IF ~mod.dll THEN
IF last # NIL THEN
Put(mod, mod.ms, ConBase + last.ma + last.ms); (* mod list *)
Reloc(ConBase + mod.ma + mod.ms);
END;
Get(mod, mod.ms + modOpts, x);
IF isStatic THEN INC(x, 10000H) END; (* set init bit (16) *)
IF isDll THEN INC(x, 1000000H) END; (* set dll bit (24) *)
Put(mod, mod.ms + modOpts, x);
Ro.WriteBytes(mod.data^, 0, mod.ms + mod.ds);
last := mod
END;
mod := mod.next
END
END WriteConst;
PROCEDURE WriteResDir (n, i: INTEGER);
BEGIN
Write4(0); (* flags *)
Write4(timeStamp);
Write4(0); (* version *)
Write2(n); (* name entries *)
Write2(i); (* id entries *)
END WriteResDir;
PROCEDURE WriteResDirEntry (id, adr: INTEGER; dir: BOOLEAN);
BEGIN
IF id = 0 THEN id := resHSize + 80000000H END; (* name Rva *)
Write4(id);
IF dir THEN Write4(adr + 80000000H) ELSE Write4(adr) END
END WriteResDirEntry;
PROCEDURE WriteMenu (res: Resource);
VAR f, i: INTEGER;
BEGIN
WHILE res # NIL DO
IF res.next = NIL THEN f := 80H ELSE f := 0 END;
IF 29 IN res.opts THEN INC(f, 1) END; (* = grayed *)
IF 13 IN res.opts THEN INC(f, 2) END; (* - inctive *)
IF 3 IN res.opts THEN INC(f, 4) END; (* # bitmap *)
IF 10 IN res.opts THEN INC(f, 8) END; (* * checked *)
IF 1 IN res.opts THEN INC(f, 20H) END; (* ! menubarbreak *)
IF 15 IN res.opts THEN INC(f, 40H) END; (* / menubreak *)
IF 31 IN res.opts THEN INC(f, 100H) END; (* ? ownerdraw *)
IF res.local # NIL THEN Write2(f + 10H) ELSE Write2(f); Write2(res.id) END;
i := 0; WHILE res.name[i] # 0X DO Write2(ORD(res.name[i])); INC(i) END;
Write2(0);
WriteMenu(res.local);
res := res.next
END
END WriteMenu;
PROCEDURE WriteResource;
VAR r, s: Resource; i, t, a, x, n: INTEGER;
BEGIN
IF numId[0] > 0 THEN WriteResDir(1, numType - 1)
ELSE WriteResDir(0, numType)
END;
a := 16 + 8 * numType; t := 0;
WHILE t < LEN(numId) DO
IF numId[t] > 0 THEN WriteResDirEntry(t, a, TRUE); INC(a, 16 + 8 * numId[t]) END;
INC(t)
END;
r := resList; t := -1;
WHILE r # NIL DO
IF t # r.typ THEN t := r.typ; WriteResDir(0, numId[t]) END;
WriteResDirEntry(r.id, a, TRUE); INC(a, 16); i := r.id;
WHILE (r # NIL) & (r.typ = t) & (r.id = i) DO INC(a, 8); r := r.next END
END;
r := resList;
WHILE r # NIL DO
n := 0; s := r;
WHILE (s # NIL) & (s.typ = r.typ) & (s.id = r.id) DO INC(n); s := s.next END;
WriteResDir(0, n);
WHILE r # s DO WriteResDirEntry(r.lid, a, FALSE); INC(a, 16); r := r.next END
END;
ASSERT(a = resHSize);
IF numId[0] > 0 THEN INC(a, 16) END; (* TYPELIB string *)
r := resList;
WHILE r # NIL DO
Write4(a + RsrcRva); INC(a, (r.size + 3) DIV 4 * 4);
Write4(r.size);
Write4(0); Write4(0);
r := r.next
END;
ASSERT(a = RsrcSize);
IF numId[0] > 0 THEN
Write2(7); Write2(ORD("T")); Write2(ORD("Y")); Write2(ORD("P"));
Write2(ORD("E")); Write2(ORD("L")); Write2(ORD("I")); Write2(ORD("B"))
END;
r := resList;
WHILE r # NIL DO
IF r.typ = 4 THEN (* menu *)
Write2(0); Write2(0);
WriteMenu(r.local);
WHILE Ro.Pos() MOD 4 # 0 DO WriteCh(0X) END
ELSIF r.typ = 9 THEN (* accelerator *)
s := r.local;
WHILE s # NIL DO
i := 0; a := 0;
IF 10 IN s.opts THEN INC(a, 4) END; (* * shift *)
IF 16 IN s.opts THEN INC(a, 8) END; (* ^ ctrl *)
IF 0 IN s.opts THEN INC(a, 16) END; (* @ alt *)
IF 13 IN s.opts THEN INC(a, 2) END; (* - noinv *)
IF s.next = NIL THEN INC(a, 80H) END;
IF (s.name[0] = "v") & (s.name[1] # 0X) THEN
s.name[0] := " "; Strings.StringToInt(s.name, x, n); INC(a, 1)
ELSE x := ORD(s.name[0])
END;
Write2(a); Write2(x); Write2(s.id); Write2(0); s := s.next
END
ELSE
r.file := ThisResFile(r.name);
IF r.file # NIL THEN
R := r.file.NewReader(R); R.SetPos(r.pos); i := 0;
IF r.typ = 12 THEN (* cursor group *)
Read4(x); Write4(x); Read2(n); Write2(n);
WHILE i < n DO
Read4(x); Write2(x MOD 256); Write2(x DIV 256 MOD 256 * 2);
Write2(1); Write2(1); Read4(x); (* ??? *)
Read4(x); Write4(x + 4); Read4(x); Write2(r.id * 10 + i); INC(i)
END;
IF ~ODD(n) THEN Write2(0) END
ELSIF r.typ = 14 THEN (* icon group *)
Read4(x); Write4(x); Read2(n); Write2(n);
WHILE i < n DO
Read2(x); Write2(x); Read2(x);
IF (13 IN r.opts) & (x = 16) THEN x := 4 END;
Write2(x);
a := x MOD 256; Read4(x); Write2(1);
IF a <= 2 THEN Write2(1)
ELSIF a <= 4 THEN Write2(2)
ELSIF a <= 16 THEN Write2(4)
ELSE Write2(8)
END;
Read4(x);
IF (13 IN r.opts) & (x = 744) THEN x := 440 END;
IF (13 IN r.opts) & (x = 296) THEN x := 184 END;
Write4(x); Read4(x); Write2(r.id * 10 + i); INC(i)
END;
IF ~ODD(n) THEN Write2(0) END
ELSE
IF r.typ = 1 THEN Write2(r.x); Write2(r.y); i := 4 END; (* cursor hot spot *)
WHILE i < r.size DO Read4(x); Write4(x); INC(i, 4) END
END;
r.file.Close; r.file := NIL
END
END;
r := r.next
END
END WriteResource;
PROCEDURE Insert(VAR name: ARRAY OF SHORTCHAR; VAR idx: INTEGER; hint: INTEGER);
VAR i: INTEGER;
BEGIN
IF hint >= 0 THEN
ntab[idx] := SHORT(CHR(hint)); INC(idx);
ntab[idx] := SHORT(CHR(hint DIV 256)); INC(idx);
END;
i := 0;
WHILE name[i] # 0X DO ntab[idx] := name[i]; INC(idx); INC(i) END;
IF (hint = -1) & ((ntab[idx-4] # ".") OR (CAP(ntab[idx-3]) # "D") OR (CAP(ntab[idx-2]) # "L") OR (CAP(ntab[idx-1]) # "L")) THEN
ntab[idx] := "."; INC(idx);
ntab[idx] := "d"; INC(idx);
ntab[idx] := "l"; INC(idx);
ntab[idx] := "l"; INC(idx);
END;
ntab[idx] := 0X; INC(idx);
IF ODD(idx) THEN ntab[idx] := 0X; INC(idx) END
END Insert;
PROCEDURE WriteImport;
VAR i, lt, at, nt, ai, ni: INTEGER; mod: Module; exp: Export; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
IF numImp > 0 THEN NEW(atab, numImp) END;
IF numExp > numImp THEN i := numExp ELSE i := numImp END;
IF i > 0 THEN NEW(ntab, 40 * i) END;
at := ImpRva + ImpHSize; ai := 0; ni := 0;
lt := ImpRva + ImpSize; nt := lt + ImpSize - ImpHSize;
mod := modList;
WHILE mod # NIL DO
IF mod.dll THEN
Write4(lt); (* lookup table rva *)
Write4(0); (* time/data (always 0) *)
Write4(0); (* version (always 0) *)
Write4(nt + ni); (* name rva *)
ss := SHORT(mod.name$); Insert(ss, ni, -1);
Write4(at); (* addr table rva *)
exp := mod.exp;
WHILE exp # NIL DO
atab[ai] := nt + ni; (* hint/name rva *)
Insert(exp.name, ni, 0);
INC(lt, 4); INC(at, 4); INC(ai); exp := exp.next
END;
atab[ai] := 0; INC(lt, 4); INC(at, 4); INC(ai)
END;
mod := mod.next
END;
Write4(0); Write4(0); Write4(0); Write4(0); Write4(0);
i := 0;
WHILE i < ai DO Write4(atab[i]); INC(i) END; (* address table *)
i := 0;
WHILE i < ai DO Write4(atab[i]); INC(i) END; (* lookup table *)
i := 0;
WHILE i < ni DO WriteCh(ntab[i]); INC(i) END;
ASSERT(ai * 4 = ImpSize - ImpHSize);
INC(ImpSize, ai * 4 + ni);
ExpRva := ImpRva + (ImpSize + (ObjAlign - 1)) DIV ObjAlign * ObjAlign;
RelocRva := ExpRva;
END WriteImport;
PROCEDURE WriteExport (VAR name: ARRAY OF CHAR);
VAR i, ni: INTEGER; e: Export; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
Write4(0); (* flags *)
Write4(timeStamp); (* time stamp *)
Write4(0); (* version *)
Write4(ExpRva + 40 + 10 * numExp); (* name rva *)
Write4(1); (* ordinal base *)
Write4(numExp); (* # entries *)
Write4(numExp); (* # name ptrs *)
Write4(ExpRva + 40); (* address table rva *)
Write4(ExpRva + 40 + 4 * numExp); (* name ptr table rva *)
Write4(ExpRva + 40 + 8 * numExp); (* ordinal table rva *)
ExpSize := 40 + 10 * numExp;
(* adress table *)
e := firstExp;
WHILE e # NIL DO Write4(e.adr); e := e.next END;
(* name ptr table *)
ni := 0; e := firstExp;
ss := SHORT(name$); Insert(ss, ni, -2);
WHILE e # NIL DO
Write4(ExpRva + ExpSize + ni); Insert(e.name, ni, -2); e := e.next
END;
(* ordinal table *)
i := 0;
WHILE i < numExp DO Write2(i); INC(i) END;
(* name table *)
i := 0;
WHILE i < ni DO WriteCh(ntab[i]); INC(i) END;
ExpSize := (ExpSize + ni + 15) DIV 16 * 16;
RelocRva := ExpRva + (ExpSize + (ObjAlign - 1)) DIV ObjAlign * ObjAlign;
END WriteExport;
PROCEDURE Sort (l, r: INTEGER);
VAR i, j, x, t: INTEGER;
BEGIN
i := l; j := r; x := fixups[(l + r) DIV 2];
REPEAT
WHILE fixups[i] < x DO INC(i) END;
WHILE fixups[j] > x DO DEC(j) END;
IF i <= j THEN t := fixups[i]; fixups[i] := fixups[j]; fixups[j] := t; INC(i); DEC(j) END
UNTIL i > j;
IF l < j THEN Sort(l, j) END;
IF i < r THEN Sort(i, r) END
END Sort;
PROCEDURE WriteReloc;
VAR i, j, h, a, p: INTEGER;
BEGIN
Sort(0, noffixup - 1); i := 0;
WHILE i < noffixup DO
p := fixups[i] DIV 4096 * 4096; j := i; a := p + 4096;
WHILE (j < noffixup) & (fixups[j] < a) DO INC(j) END;
Write4(p - ImageBase); (* page rva *)
h := 8 + 2 * (j - i);
Write4(h + h MOD 4); (* block size *)
INC(RelocSize, h);
WHILE i < j DO Write2(fixups[i] - p + 3 * 4096); INC(i) END; (* long fix *)
IF h MOD 4 # 0 THEN Write2(0); INC(RelocSize, 2) END
END;
Write4(0); Write4(0); INC(RelocSize, 8);
ImagesSize := RelocRva + (RelocSize + (ObjAlign - 1)) DIV ObjAlign * ObjAlign;
END WriteReloc;
PROCEDURE Align(VAR pos: INTEGER);
BEGIN
WHILE Ro.Pos() MOD FileAlign # 0 DO WriteCh(0X) END;
pos := Ro.Pos()
END Align;
PROCEDURE WriteOut (VAR name: Files.Name);
VAR res, codepos, conpos, rsrcpos, imppos, exppos, relpos, relend, end: INTEGER;
BEGIN
IF ~error THEN Align(codepos); WriteCode END;
IF ~error THEN Align(conpos); WriteConst END;
IF ~error THEN Align(rsrcpos); WriteResource END;
IF ~error THEN Align(imppos); WriteImport END;
IF ~error & isDll THEN Align(exppos); WriteExport(name) END;
IF ~error THEN Align(relpos); WriteReloc END;
relend := Ro.Pos() - 8; Align(end);
IF ~error THEN
Ro.SetPos(entryPos); Write4(CodeRva);
Ro.SetPos(isPos); Write4(ImagesSize);
IF isDll THEN
Ro.SetPos(hexpPos); Write4(ExpRva); Write4(ExpSize);
END;
Ro.SetPos(himpPos); Write4(ImpRva); Write4(ImpHSize);
Ro.SetPos(hrsrcPos); Write4(RsrcRva); Write4(RsrcSize);
Ro.SetPos(fixPos); Write4(RelocRva); Write4(relend - relpos);
Ro.SetPos(codePos); Write4(CodeRva); Write4(conpos - HeaderSize); Write4(HeaderSize);
Ro.SetPos(dataPos); Write4(DataRva); Write4((DataSize + (FileAlign-1)) DIV FileAlign * FileAlign);
Ro.SetPos(conPos); Write4(ConRva); Write4(rsrcpos - conpos); Write4(conpos);
Ro.SetPos(rsrcPos); Write4(RsrcRva); Write4(imppos - rsrcpos); Write4(rsrcpos);
IF isDll THEN
Ro.SetPos(impPos); Write4(ImpRva); Write4(exppos - imppos); Write4(imppos);
Ro.SetPos(expPos); Write4(ExpRva); Write4(relpos - exppos); Write4(exppos)
ELSE
Ro.SetPos(impPos); Write4(ImpRva); Write4(relpos - imppos); Write4(imppos);
END;
Ro.SetPos(relPos); Write4(RelocRva); Write4(end - relpos); Write4(relpos);
IF isStatic THEN
Ro.SetPos(termPos); WriteTermCode(modList, 0)
ELSIF isDll THEN
Ro.SetPos(termPos); WriteTermCode(main, 0)
END
END;
IF ~error THEN
Out.Register(name, "exe", Files.ask, res);
IF res # 0 THEN error := TRUE END
END
END WriteOut;
PROCEDURE ScanRes (VAR S: TextMappers.Scanner; end: INTEGER; VAR list: Resource);
VAR res, tail: Resource; n: INTEGER;
BEGIN
tail := NIL;
WHILE (S.start < end) & (S.type = TextMappers.int) DO
NEW(res); res.id := S.int; S.Scan;
IF (S.type = TextMappers.char) & (S.char = "[") THEN
S.Scan;
IF S.type = TextMappers.int THEN res.lid := S.int; S.Scan END;
IF (S.type = TextMappers.char) & (S.char = "]") THEN S.Scan
ELSE W.WriteSString("missing ']'"); error := TRUE
END
END;
WHILE S.type = TextMappers.char DO
IF S.char = "@" THEN n := 0
ELSIF S.char = "^" THEN n := 16
ELSIF S.char = "~" THEN n := 17
ELSIF S.char <= "?" THEN n := ORD(S.char) - ORD(" ")
END;
INCL(res.opts, n); S.Scan
END;
IF S.type = TextMappers.string THEN
res.name := S.string$; S.Scan;
IF (S.type = TextMappers.char) & (S.char = ".") THEN S.Scan;
IF S.type = TextMappers.string THEN
IF (S.string = "tlb") OR (S.string = "TLB") THEN res.typ := -1 END;
Kernel.MakeFileName(res.name, S.string); S.Scan
END
END;
IF (S.type = TextMappers.char) & (S.char = "(") THEN S.Scan;
ScanRes(S, end, res.local);
IF (S.type = TextMappers.char) & (S.char = ")") THEN S.Scan
ELSE W.WriteSString("missing ')'"); error := TRUE
END
END;
IF tail = NIL THEN list := res ELSE tail.next := res END;
tail := res
ELSE
W.WriteSString("wrong resource name"); error := TRUE
END
END;
END ScanRes;
PROCEDURE LinkIt;
VAR S: TextMappers.Scanner; name: Files.Name; mod: Module; end: INTEGER;
BEGIN
comLine := FALSE;
modList := NIL; kernel := NIL; main := NIL;
last := NIL; impg := NIL; impd := NIL; resList := NIL;
firstExp := NIL; lastExp := NIL;
NEW(fixups, FixLen);
Dialog.ShowStatus("linking");
timeStamp := TimeStamp();
error := FALSE; modList := NIL; resList := NIL;
IF DevCommanders.par = NIL THEN RETURN END;
S.ConnectTo(DevCommanders.par.text);
S.SetPos(DevCommanders.par.beg);
end := DevCommanders.par.end;
DevCommanders.par := NIL;
W.ConnectTo(Log.buf); S.Scan;
IF S.type = TextMappers.string THEN
IF S.string = "dos" THEN comLine := TRUE; S.Scan END;
name := S.string$; S.Scan;
IF (S.type = TextMappers.char) & (S.char = ".") THEN S.Scan;
IF S.type = TextMappers.string THEN
Kernel.MakeFileName(name, S.string); S.Scan
END
ELSE Kernel.MakeFileName(name, "EXE");
END;
IF (S.type = TextMappers.char) & (S.char = ":") THEN S.Scan;
IF (S.type = TextMappers.char) & (S.char = "=") THEN S.Scan;
WHILE (S.start < end) & (S.type = TextMappers.string) DO
NEW(mod); mod.name := S.string$;
mod.next := modList; modList := mod;
S.Scan;
WHILE (S.start < end) & (S.type = TextMappers.char) &
((S.char = "*") OR (S.char = "+") OR (S.char = "$") OR (S.char = "#")) DO
IF S.char = "*" THEN mod.dll := TRUE
ELSIF S.char = "+" THEN kernel := mod
ELSIF S.char = "$" THEN main := mod
ELSE mod.intf := TRUE;
IF ~isDll THEN
W.WriteSString("Exports from Exe not possible. Use LinkDll or LinkDynDll.");
W.WriteLn; Log.text.Append(Log.buf); error := TRUE
END
END;
S.Scan
END
END;
ScanRes(S, end, resList);
ReadHeaders;
PrepResources;
IF ~error THEN WriteHeader(name) END;
IF ~error THEN WriteOut(name) END;
IF ~error THEN
W.WriteString(name); W.WriteString(" written ");
W.WriteInt(Out.Length()); W.WriteString(" "); W.WriteInt(CodeSize)
END
ELSE W.WriteString(" := missing")
END
ELSE W.WriteString(" := missing")
END;
W.WriteLn; Log.text.Append(Log.buf)
END;
IF error THEN Dialog.ShowStatus("failed") ELSE Dialog.ShowStatus("ok") END;
W.ConnectTo(NIL); S.ConnectTo(NIL);
modList := NIL; kernel := NIL; main := NIL; firstExp := NIL; lastExp := NIL;
last := NIL; impg := NIL; impd := NIL; resList := NIL; code := NIL; atab := NIL; ntab := NIL;
fixups := NIL
END LinkIt;
PROCEDURE Link*;
BEGIN
isDll := FALSE; isStatic := FALSE;
LinkIt
END Link;
PROCEDURE LinkExe*;
BEGIN
isDll := FALSE; isStatic := TRUE;
LinkIt
END LinkExe;
PROCEDURE LinkDll*;
BEGIN
isDll := TRUE; isStatic := TRUE;
LinkIt
END LinkDll;
PROCEDURE LinkDynDll*;
BEGIN
isDll := TRUE; isStatic := FALSE;
LinkIt
END LinkDynDll;
(*
PROCEDURE Show*;
VAR S: TextMappers.Scanner; name: Name; mod: Module; t: TextModels.Model;
BEGIN
t := TextViews.FocusText(); IF t = NIL THEN RETURN END;
W.ConnectTo(Log.buf); S.ConnectTo(t); S.Scan;
IF S.type = TextMappers.string THEN
mod := modList;
WHILE (mod # NIL) & (mod.name # S.string) DO mod := mod.next END;
IF mod # NIL THEN
W.WriteString(S.string);
W.WriteString(" ca = ");
W.WriteIntForm(CodeBase + mod.ca, TextMappers.hexadecimal, 8, "0", TRUE);
W.WriteLn; Log.text.Append(Log.buf)
END
END;
W.ConnectTo(NIL); S.ConnectTo(NIL)
END Show;
*)
BEGIN
newRec := "NewRec"; newArr := "NewArr"
END DevLinker.
DevLinker.Link Usekrnl.exe := TestKernel$+ Usekrnl ~ "DevDecExe.Decode('', 'Usekrnl.exe')"
DevLinker.LinkDynDll MYDLL.dll := TestKernel+ MYDLL$# ~ "DevDecExe.Decode('', 'MYDLL.dll')"
DevLinker.LinkExe Usekrnl.exe := TestKernel+ Usekrnl ~ "DevDecExe.Decode('', 'Usekrnl.exe')"
DevLinker.LinkDll MYDLL.dll := TestKernel+ MYDLL# ~ "DevDecExe.Decode('', 'MYDLL.dll')"
MODULE TestKernel;
IMPORT KERNEL32;
PROCEDURE Beep*;
BEGIN
KERNEL32.Beep(500, 200)
END Beep;
BEGIN
CLOSE
KERNEL32.ExitProcess(0)
END TestKernel.
MODULE Usekrnl;
(* empty windows application using BlackBox Kernel *)
(* Ominc *)
IMPORT KERNEL32, USER32, GDI32, S := SYSTEM, Kernel := TestKernel;
VAR Instance, MainWnd: USER32.Handle;
PROCEDURE WndHandler (wnd, message, wParam, lParam: INTEGER): INTEGER;
VAR res: INTEGER; ps: USER32.PaintStruct; dc: GDI32.Handle;
BEGIN
IF message = USER32.WMDestroy THEN
USER32.PostQuitMessage(0)
ELSIF message = USER32.WMPaint THEN
dc := USER32.BeginPaint(wnd, ps);
res := GDI32.TextOutA(dc, 50, 50, "Hello World", 11);
res := USER32.EndPaint(wnd, ps)
ELSIF message = USER32.WMChar THEN
Kernel.Beep
ELSE
RETURN USER32.DefWindowProcA(wnd, message, wParam, lParam)
END;
RETURN 0
END WndHandler;
PROCEDURE OpenWindow;
VAR class: USER32.WndClass; res: INTEGER;
BEGIN
class.cursor := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCArrow));
class.icon := USER32.LoadIconA(Instance, USER32.MakeIntRsrc(1));
class.menuName := NIL;
class.className := "Simple";
class.backgnd := GDI32.GetStockObject(GDI32.WhiteBrush);
class.style := {0, 1, 5, 7};
class.instance := Instance;
class.wndProc := WndHandler;
class.clsExtra := 0;
class.wndExtra := 0;
USER32.RegisterClassA(class);
MainWnd := USER32.CreateWindowExA({}, "Simple", "Empty Windows Application",
{16..19, 22, 23, 25},
USER32.CWUseDefault, USER32.CWUseDefault,
USER32.CWUseDefault, USER32.CWUseDefault,
0, 0, Instance, 0);
res := USER32.ShowWindow(MainWnd, 10);
res := USER32.UpdateWindow(MainWnd);
END OpenWindow;
PROCEDURE MainLoop;
VAR msg: USER32.Message; res: INTEGER;
BEGIN
WHILE USER32.GetMessageA(msg, 0, 0, 0) # 0 DO
res := USER32.TranslateMessage(msg);
res := USER32.DispatchMessageA(msg);
END;
(*
KERNEL32.ExitProcess(msg.wParam)
*)
END MainLoop;
BEGIN
Instance := KERNEL32.GetModuleHandleA(NIL);
OpenWindow;
MainLoop
CLOSE
Kernel.Beep
END Usekrnl.
MODULE MYDLL;
(* sample module to be linked into a dll *)
(* Ominc *)
IMPORT SYSTEM, KERNEL32;
VAR expVar*: INTEGER;
PROCEDURE GCD* (a, b: INTEGER): INTEGER;
BEGIN
WHILE a # b DO
IF a < b THEN b := b - a ELSE a := a - b END
END;
expVar := a;
RETURN a
END GCD;
PROCEDURE Beep*;
BEGIN
KERNEL32.Beep(500, 200)
END Beep;
CLOSE
Beep
END MYDLL.
Resource = Id [ "[" Language "]" ] Options name [ "." ext ] [ "(" { Resource } ")" ]
Id = number
Language = number
Options = { "@" | "!" .. "?" | "^" | "~" }
names
MENU
1 MENU (0 File (11 New 12 Open 13 Save 0 "" 14 Exit) 0 Edit (21 Cut 22 Copy 23 Paste))
= grayed
- inctive
# bitmap
* checked
! menuBarBreak
/ menuBreak
? ownerDraw
ACCELERATOR
1 ACCELERATOR (11 ^N 12 ^O 13 ^S 21 ^X 22 ^C 23 ^V)
* shift
^ ctrl
@ alt
- noInvert
filename.ico
filename.cur
filname.bmp
filename.res
filename.tlb
| Dev/Mod/Linker.odc |
MODULE DevMarkers; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20050626, Fyodor Tkachov, russification edited
- 20050519, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Kernel, Files, Stores, Fonts, Ports, Models, Views, Controllers, Properties, Dialog,
TextModels, TextSetters, TextViews, TextControllers, TextMappers,
i21sysCharacters;
CONST
(** View.mode **)
undefined* = 0; mark* = 1; message* = 2;
firstMode = 1; lastMode = 2;
(** View.err **)
noCode* = 9999;
errFile = "Errors"; point = Ports.point;
TYPE
View* = POINTER TO ABSTRACT RECORD (Views.View)
mode-: INTEGER;
err-: INTEGER;
msg-: POINTER TO ARRAY OF CHAR;
era: INTEGER
END;
Directory* = POINTER TO ABSTRACT RECORD END;
StdView = POINTER TO RECORD (View) END;
StdDirectory = POINTER TO RECORD (Directory) END;
SetModeOp = POINTER TO RECORD (Stores.Operation)
view: View;
mode: INTEGER
END;
VAR
dir-, stdDir-: Directory;
globR: TextModels.Reader; globW: TextModels.Writer; (* recycling done in Load, Insert *)
thisEra: INTEGER;
(** View **)
PROCEDURE (v: View) CopyFromSimpleView- (source: Views.View), EXTENSIBLE;
BEGIN
(* v.CopyFrom^(source); *)
WITH source: View DO
v.err := source.err; v.mode := source.mode;
IF source.msg # NIL THEN
NEW(v.msg, LEN(source.msg^)); v.msg^ := source.msg^$
END
END
END CopyFromSimpleView;
(*
PROCEDURE (v: View) InitContext* (context: Models.Context), EXTENSIBLE;
BEGIN
ASSERT(v.mode # undefined, 20);
v.InitContext^(context)
END InitContext;
*)
PROCEDURE (v: View) InitErr* (err: INTEGER), NEW, EXTENSIBLE;
BEGIN
ASSERT(v.msg = NIL, 20);
IF v.err # err THEN v.err := err; v.mode := mark END;
IF v.mode = undefined THEN v.mode := mark END
END InitErr;
PROCEDURE (v: View) InitMsg* (msg: ARRAY OF CHAR), NEW, EXTENSIBLE;
VAR i: INTEGER; str: ARRAY 256 OF CHAR;
BEGIN
ASSERT(v.msg = NIL, 20);
Dialog.MapString(msg, str);
i := 0; WHILE str[i] # 0X DO INC(i) END;
NEW(v.msg, i + 1); v.msg^ := str$;
v.mode := mark
END InitMsg;
PROCEDURE (v: View) SetMode* (mode: INTEGER), NEW, EXTENSIBLE;
VAR op: SetModeOp;
BEGIN
ASSERT((firstMode <= mode) & (mode <= lastMode), 20);
IF v.mode # mode THEN
NEW(op); op.view := v; op.mode := mode;
Views.Do(v, "#System:ViewSetting", op)
END
END SetMode;
(** Directory **)
PROCEDURE (d: Directory) New* (type: INTEGER): View, NEW, ABSTRACT;
PROCEDURE (d: Directory) NewMsg* (msg: ARRAY OF CHAR): View, NEW, ABSTRACT;
(* SetModeOp *)
PROCEDURE (op: SetModeOp) Do;
VAR v: View; mode: INTEGER;
BEGIN
v := op.view;
mode := v.mode; v.mode := op.mode; op.mode := mode;
Views.Update(v, Views.keepFrames);
IF v.context # NIL THEN v.context.SetSize(Views.undefined, Views.undefined) END
END Do;
PROCEDURE ToggleMode (v: View);
VAR mode: INTEGER;
BEGIN
IF ABS(v.err) # noCode THEN
IF v.mode < lastMode THEN mode := v.mode + 1 ELSE mode := firstMode END
ELSE
IF v.mode < message THEN mode := v.mode + 1 ELSE mode := firstMode END
END;
v.SetMode(mode)
END ToggleMode;
(* primitives for StdView *)
PROCEDURE NumToStr (x: INTEGER; VAR s: ARRAY OF CHAR; VAR i: INTEGER);
VAR j: INTEGER; m: ARRAY 32 OF CHAR;
BEGIN
ASSERT(x >= 0, 20);
j := 0; REPEAT m[j] := CHR(x MOD 10 + ORD("0")); x := x DIV 10; INC(j) UNTIL x = 0;
i := 0; REPEAT DEC(j); s[i] := m[j]; INC(i) UNTIL j = 0;
s[i] := 0X
END NumToStr;
PROCEDURE Load (v: StdView);
VAR view: Views.View; t: TextModels.Model; s: TextMappers.Scanner;
err: INTEGER; i: INTEGER; ch: CHAR; loc: Files.Locator;
msg: ARRAY 256 OF CHAR;
BEGIN
err := ABS(v.err); NumToStr(err, msg, i);
loc := Files.dir.This("Dev"); IF loc = NIL THEN RETURN END;
loc := loc.This("Rsrc"); IF loc = NIL THEN RETURN END;
view := Views.OldView(loc, errFile);
IF (view # NIL) & (view IS TextViews.View) THEN
t := view(TextViews.View).ThisModel();
IF t # NIL THEN
s.ConnectTo(t);
REPEAT
s.Scan
UNTIL ((s.type = TextMappers.int) & (s.int = err)) OR (s.type = TextMappers.eot);
IF s.type = TextMappers.int THEN
s.Skip(ch); i := 0;
WHILE (ch >= " ") & (i < LEN(msg) - 1) DO
msg[i] := (*ch*) i21sysCharacters.UnicodeOf(ch);
INC(i); s.rider.ReadChar(ch)
END;
msg[i] := 0X
END
END
END;
NEW(v.msg, i + 1); v.msg^ := msg$
END Load;
PROCEDURE DrawMsg (v: StdView; f: Views.Frame; font: Fonts.Font; color: Ports.Color);
VAR w, h, asc, dsc: INTEGER;
BEGIN
CASE v.mode OF
mark:
v.context.GetSize(w, h);
f.DrawLine(point, 0, w - 2 * point, h, 0, color);
f.DrawLine(w - 2 * point, 0, point, h, 0, color)
| message:
font.GetBounds(asc, dsc, w);
f.DrawString(2 * point, asc, color, v.msg^, font)
END
END DrawMsg;
PROCEDURE ShowMsg (v: StdView);
BEGIN
IF v.msg = NIL THEN Load(v) END;
Dialog.ShowStatus(v.msg^)
END ShowMsg;
PROCEDURE Track (v: StdView; f: Views.Frame; x, y: INTEGER; buttons: SET);
VAR c: Models.Context; t: TextModels.Model; u, w, h: INTEGER; isDown, in, in0: BOOLEAN; m: SET;
BEGIN
v.context.GetSize(w, h); u := f.dot; in0 := FALSE;
in := (0 <= x) & (x < w) & (0 <= y) & (y < h);
REPEAT
IF in # in0 THEN
f.MarkRect(u, 0, w - u, h, Ports.fill, Ports.invert, Ports.show); in0 := in
END;
f.Input(x, y, m, isDown);
in := (0 <= x) & (x < w) & (0 <= y) & (y < h)
UNTIL ~isDown;
IF in0 THEN
f.MarkRect(u, 0, w - u, h, Ports.fill, Ports.invert, Ports.hide);
IF Dialog.showsStatus & ~(Controllers.modify IN buttons) & ~(Controllers.doubleClick IN buttons) THEN
ShowMsg(v)
ELSE
ToggleMode(v)
END;
c := v.context;
WITH c: TextModels.Context DO
t := c.ThisModel();
TextControllers.SetCaret(t, c.Pos() + 1)
ELSE
END
END
END Track;
PROCEDURE SizePref (v: StdView; VAR p: Properties.SizePref);
VAR c: Models.Context; a: TextModels.Attributes; font: Fonts.Font; asc, dsc, w: INTEGER;
BEGIN
c := v.context;
IF (c # NIL) & (c IS TextModels.Context) THEN a := c(TextModels.Context).Attr(); font := a.font
ELSE font := Fonts.dir.Default()
END;
font.GetBounds(asc, dsc, w);
p.h := asc + dsc;
CASE v.mode OF
mark:
p.w := p.h + 2 * point
| message:
IF v.msg = NIL THEN Load(v) END;
p.w := font.StringWidth(v.msg^) + 4 * point
END
END SizePref;
(* StdView *)
PROCEDURE (v: StdView) ExternalizeAs (VAR s1: Stores.Store);
BEGIN
s1 := NIL
END ExternalizeAs;
PROCEDURE (v: StdView) SetMode(mode: INTEGER);
BEGIN v.SetMode^(mode); ShowMsg(v)
END SetMode;
PROCEDURE (v: StdView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
VAR c: Models.Context; a: TextModels.Attributes; font: Fonts.Font; color: Ports.Color;
w, h: INTEGER;
BEGIN
c := v.context; c.GetSize(w, h);
WITH c: TextModels.Context DO a := c.Attr(); font := a.font ELSE font := Fonts.dir.Default() END;
IF TRUE (*f.colors >= 4*) THEN color := Ports.grey50 ELSE color := Ports.defaultColor END;
IF v.err >= 0 THEN
f.DrawRect(point, 0, w - point, h, Ports.fill, color);
DrawMsg(v, f, font, Ports.background)
ELSE
f.DrawRect(point, 0, w - point, h, 0, color);
DrawMsg(v, f, font, Ports.defaultColor)
END
END Restore;
PROCEDURE (v: StdView) GetBackground (VAR color: Ports.Color);
BEGIN
color := Ports.background
END GetBackground;
PROCEDURE (v: StdView) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.TrackMsg DO
Track(v, f, msg.x, msg.y, msg.modifiers)
ELSE
END
END HandleCtrlMsg;
PROCEDURE (v: StdView) HandlePropMsg (VAR msg: Properties.Message);
VAR c: Models.Context; a: TextModels.Attributes; font: Fonts.Font; asc, w: INTEGER;
BEGIN
WITH msg: Properties.Preference DO
WITH msg: Properties.SizePref DO
SizePref(v, msg)
| msg: Properties.ResizePref DO
msg.fixed := TRUE
| msg: Properties.FocusPref DO
msg.hotFocus := TRUE
(*
| msg: Properties.StorePref DO
msg.view := NIL
*)
| msg: TextSetters.Pref DO
c := v.context;
IF (c # NIL) & (c IS TextModels.Context) THEN
a := c(TextModels.Context).Attr(); font := a.font
ELSE
font := Fonts.dir.Default()
END;
font.GetBounds(asc, msg.dsc, w)
ELSE
END
ELSE
END
END HandlePropMsg;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) New (err: INTEGER): View;
VAR v: StdView;
BEGIN
NEW(v); v.InitErr(err); RETURN v
END New;
PROCEDURE (d: StdDirectory) NewMsg (msg: ARRAY OF CHAR): View;
VAR v: StdView;
BEGIN
NEW(v); v.InitErr(noCode); v.InitMsg(msg); RETURN v
END NewMsg;
(** Cleaner **)
PROCEDURE Cleanup;
BEGIN
globR := NIL; globW := NIL
END Cleanup;
(** miscellaneous **)
PROCEDURE Insert* (text: TextModels.Model; pos: INTEGER; v: View);
VAR w: TextModels.Writer; r: TextModels.Reader;
BEGIN
ASSERT(v.era = 0, 20);
Models.BeginModification(Models.clean, text);
v.era := thisEra;
IF pos > text.Length() THEN pos := text.Length() END;
globW := text.NewWriter(globW); w := globW; w.SetPos(pos);
IF pos > 0 THEN DEC(pos) END;
globR := text.NewReader(globR); r := globR; r.SetPos(pos); r.Read;
IF r.attr # NIL THEN w.SetAttr(r.attr) END;
w.WriteView(v, Views.undefined, Views.undefined);
Models.EndModification(Models.clean, text);
END Insert;
PROCEDURE Unmark* (text: TextModels.Model);
VAR r: TextModels.Reader; v: Views.View; pos: INTEGER;
script: Stores.Operation;
BEGIN
Models.BeginModification(Models.clean, text);
Models.BeginScript(text, "#Dev:DeleteMarkers", script);
r := text.NewReader(NIL); r.ReadView(v);
WHILE ~r.eot DO
IF r.view IS View THEN
pos := r.Pos() - 1; text.Delete(pos, pos + 1); r.SetPos(pos)
END;
r.ReadView(v)
END;
INC(thisEra);
Models.EndScript(text, script);
Models.EndModification(Models.clean, text);
END Unmark;
PROCEDURE ShowFirstError* (text: TextModels.Model; focusOnly: BOOLEAN);
VAR v1: Views.View; pos: INTEGER;
BEGIN
globR := text.NewReader(globR); globR.SetPos(0);
REPEAT globR.ReadView(v1) UNTIL globR.eot OR (v1 IS View);
IF ~globR.eot THEN
pos := globR.Pos();
TextViews.ShowRange(text, pos, pos, focusOnly);
TextControllers.SetCaret(text, pos);
v1(View).SetMode(v1(View).mode)
END
END ShowFirstError;
(** commands **)
PROCEDURE UnmarkErrors*;
VAR t: TextModels.Model;
BEGIN
t := TextViews.FocusText();
IF t # NIL THEN Unmark(t) END
END UnmarkErrors;
PROCEDURE NextError*;
VAR c: TextControllers.Controller; t: TextModels.Model; v1: Views.View;
beg, pos: INTEGER;
BEGIN
c := TextControllers.Focus();
IF c # NIL THEN
t := c.text;
IF c.HasCaret() THEN pos := c.CaretPos()
ELSIF c.HasSelection() THEN c.GetSelection(beg, pos)
ELSE pos := 0
END;
TextControllers.SetSelection(t, TextControllers.none, TextControllers.none);
globR := t.NewReader(globR); globR.SetPos(pos);
REPEAT globR.ReadView(v1) UNTIL globR.eot OR (v1 IS View);
IF ~globR.eot THEN
pos := globR.Pos(); v1(View).SetMode(v1(View).mode);
TextViews.ShowRange(t, pos, pos, TextViews.focusOnly)
ELSE
pos := 0; Dialog.Beep
END;
TextControllers.SetCaret(t, pos);
globR := NIL
END
END NextError;
PROCEDURE ToggleCurrent*;
VAR c: TextControllers.Controller; t: TextModels.Model; v: Views.View; pos: INTEGER;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasCaret() THEN
t := c.text; pos := c.CaretPos();
globR := t.NewReader(globR); globR.SetPos(pos); globR.ReadPrev;
v := globR.view;
IF (v # NIL) & (v IS View) THEN ToggleMode(v(View)) END;
TextViews.ShowRange(t, pos, pos, TextViews.focusOnly);
TextControllers.SetCaret(t, pos);
globR := NIL
END
END ToggleCurrent;
PROCEDURE SetDir* (d: Directory);
BEGIN
dir := d
END SetDir;
PROCEDURE Init;
VAR d: StdDirectory;
BEGIN
thisEra := 1;
NEW(d); dir := d; stdDir := d
END Init;
BEGIN
Init; Kernel.InstallCleaner(Cleanup)
CLOSE
Kernel.RemoveCleaner(Cleanup)
END DevMarkers.
| Dev/Mod/Markers.odc |
MODULE DevMsgSpy;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT SYSTEM,
DevDebug, Dialog, Stores, Models, Views, Controllers, Properties, Kernel,
Ports, TextModels, TextViews, TextMappers, StdDialog,
Files, Converters, FormViews, FormModels, Windows, Containers, Services;
CONST
refViewSize = 9 * Ports.point;
TYPE
View = POINTER TO RECORD (Views.View)
inner: Views.View
END;
RefView = POINTER TO RECORD (Views.View)
msg: ANYPTR
END;
Msgs = POINTER TO RECORD
left, right: Msgs;
mod, ident: Kernel.Name;
index: INTEGER;
END;
VAR
para* : RECORD
sel*: Dialog.Selection;
selectNewMessages*: BOOLEAN;
showMessages*: BOOLEAN
END;
text*: TextModels.Model;
msgs: Msgs;
size: INTEGER;
path: ARRAY 4 OF Ports.Point;
(* ------------------- Selection ------------------- *)
PROCEDURE Find(mod, ident: Kernel.Name): Msgs;
VAR m: Msgs;
BEGIN m := msgs;
WHILE m # NIL DO
IF mod < m.mod THEN m := m.left
ELSIF mod > m.mod THEN m := m.right
ELSIF ident < m.ident THEN m := m.left
ELSIF ident > m.ident THEN m := m.right
ELSE RETURN m
END
END;
RETURN NIL
END Find;
PROCEDURE Insert(mod, ident: Kernel.Name);
PROCEDURE InsertTree(VAR m: Msgs);
VAR name: ARRAY 64 OF CHAR;
BEGIN
IF m = NIL THEN
NEW(m); m.mod := mod; m.ident := ident; m.index := size-1;
name := m.mod + "." + m.ident;
para.sel.SetItem(m.index, name);
IF para.selectNewMessages THEN para.sel.Incl(m.index, m.index) END
ELSE
IF mod < m.mod THEN InsertTree(m.left)
ELSIF mod > m.mod THEN InsertTree(m.right)
ELSIF ident < m.ident THEN InsertTree(m.left)
ELSIF ident > m.ident THEN InsertTree(m.right)
END
END
END InsertTree;
BEGIN
INC(size); para.sel.SetLen(size); (* increase size and reset all items *)
InsertTree(msgs); (* insert the new item *)
Dialog.UpdateList(para.sel)
END Insert;
(* ------------------- RefView ------------------- *)
PROCEDURE (v: RefView) Internalize (VAR rd: Stores.Reader);
VAR thisVersion: INTEGER;
BEGIN
v.Internalize^(rd); IF rd.cancelled THEN RETURN END;
rd.ReadVersion(0, 0, thisVersion); IF rd.cancelled THEN RETURN END;
END Internalize;
PROCEDURE (v: RefView) Externalize (VAR wr: Stores.Writer);
BEGIN
v.Externalize^(wr);
wr.WriteVersion(0);
END Externalize;
PROCEDURE (v: RefView) CopyFromSimpleView (source: Views.View);
BEGIN
(* v.CopyFrom^(source); *)
v.msg := source(RefView).msg
END CopyFromSimpleView;
PROCEDURE (v: RefView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawPath(path, 4, Ports.fill, Ports.blue, Ports.closedPoly)
END Restore;
PROCEDURE (v: RefView) HandleCtrlMsg (
f: Views.Frame; VAR msg: Controllers.Message; VAR focus: Views.View
);
TYPE ControllersMessage = POINTER TO Controllers.Message;
ViewsMessage = POINTER TO Views.Message;
ModelsMessage = POINTER TO Models.Message;
PropMessage = POINTER TO Properties.Message;
VAR x, y: INTEGER; isDown: BOOLEAN; mo: SET;name: ARRAY 32 OF CHAR;
BEGIN
WITH msg: Controllers.TrackMsg DO
IF v.msg # NIL THEN
REPEAT
f.MarkRect(0, 0, refViewSize, refViewSize, Ports.fill, Ports.hilite, Ports.show);
REPEAT
f.Input(x, y, mo, isDown)
UNTIL (x < 0) OR (x > refViewSize) OR (y < 0) OR (y > refViewSize) OR ~isDown;
f.MarkRect(0, 0, refViewSize, refViewSize, Ports.fill, Ports.hilite, Ports.hide);
WHILE isDown & ((x < 0) OR (x > refViewSize) OR (y < 0) OR (y > refViewSize)) DO
f.Input(x, y, mo, isDown)
END
UNTIL ~isDown;
IF (x >= 0) & (x <= refViewSize) & (y >= 0) & (y <= refViewSize) THEN
IF v.msg IS ControllersMessage THEN name := "Controllers.Message"
ELSIF v.msg IS PropMessage THEN name := "Properties.Message"
ELSIF v.msg IS ViewsMessage THEN name := "Views.Message"
ELSIF v.msg IS ModelsMessage THEN name := "Models.Message"
ELSE name := "Message Record"
END;
DevDebug.ShowHeapObject(SYSTEM.ADR(v.msg^), name)
END
END
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.refCursor
ELSE
END
END HandleCtrlMsg;
PROCEDURE (v: RefView) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.Preference DO
WITH msg: Properties.ResizePref DO msg.fixed := TRUE
| msg: Properties.SizePref DO msg.w := refViewSize; msg.h := refViewSize
| msg: Properties.FocusPref DO msg.hotFocus := TRUE
ELSE
END
ELSE
END
END HandlePropMsg;
(* ------------------- Wrapper ------------------- *)
PROCEDURE (v: View) CopyFromModelView (source: Views.View; model: Models.Model);
BEGIN
WITH source: View DO
IF model = NIL THEN v.inner := Views.CopyOf(source.inner, Views.shallow)
ELSE v.inner := Views.CopyWithNewModel(source.inner, model)
END;
Stores.Join(v, v.inner)
END
END CopyFromModelView;
PROCEDURE (v: View) ThisModel (): Models.Model;
BEGIN
RETURN v.inner.ThisModel()
END ThisModel;
PROCEDURE (v: View) InitContext (context: Models.Context);
BEGIN
v.InitContext^(context);
v.inner.InitContext(context) (* wrapper and wrapped view share the same context *)
END InitContext;
(*
PROCEDURE (v: View) PropagateDomain;
BEGIN
Stores.InitDomain(v.inner, v.domain)
END PropagateDomain;
*)
PROCEDURE (v: View) Neutralize;
BEGIN
v.inner.Neutralize
END Neutralize;
(* NewFrame: wrapper uses standard frame *)
(* Background: wrapper has no intrinsic background color *)
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
Views.InstallFrame(f, v.inner, 0, 0, 0, TRUE)
END Restore;
(* RestoreMarks: wrapper has no intrinsic marks, wrapped view's RestoreMarks is called by framework *)
PROCEDURE DescOfMsg (VAR x: ANYREC): Kernel.Type;
VAR desc: Kernel.Type;
BEGIN
desc := SYSTEM.VAL(Kernel.Type, SYSTEM.TYP(x)); (* tdesc of x *)
RETURN desc
END DescOfMsg;
PROCEDURE WriteLog(t: Kernel.Type; VAR msg: ANYREC; name: ARRAY OF SHORTCHAR);
VAR link: RefView; p: ANYPTR; name2 : ARRAY 256 OF CHAR; f: TextMappers.Formatter;
BEGIN
Kernel.NewObj(p, t);
SYSTEM.MOVE(SYSTEM.ADR(msg), p, t.size);
NEW(link); link.msg := p;
name2 := t.mod.name$ + "." + name$;
f.ConnectTo(text);
f.WriteString(name2 + " ");
f.WriteView(link);
f.WriteLn;
TextViews.ShowRange(text, text.Length(), text.Length(), ~TextViews.focusOnly)
END WriteLog;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message; VAR focus: Views.View);
VAR name: Kernel.Name; t: Kernel.Type; m: Msgs;
BEGIN
t := DescOfMsg(msg);
Kernel.GetTypeName (t, name);
m := Find(t.mod.name, name);
IF m = NIL THEN Insert(t.mod.name, name)
ELSIF para.sel.In(m.index) & para.showMessages THEN WriteLog(t, msg, name);
END;
focus := v.inner (* forward all controller messages to wrapped view *)
END HandleCtrlMsg;
PROCEDURE (v: View) ExternalizeAs (VAR s: Stores.Store);
BEGIN
s := v.inner
END ExternalizeAs;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
VAR name: Kernel.Name; t: Kernel.Type; m: Msgs;
BEGIN
t := DescOfMsg(msg);
Kernel.GetTypeName (t, name);
m := Find(t.mod.name, name);
IF m = NIL THEN Insert(t.mod.name, name)
ELSIF para.sel.In(m.index) & para.showMessages THEN WriteLog(t, msg, name);
END;
Views.HandlePropMsg(v.inner, msg)
END HandlePropMsg;
PROCEDURE (v: View) HandleViewMsg (f: Views.Frame; VAR msg: Views.Message);
VAR name: Kernel.Name; t: Kernel.Type; m: Msgs;
BEGIN
t := DescOfMsg(msg);
Kernel.GetTypeName (t, name);
m := Find(t.mod.name, name);
IF m = NIL THEN Insert(t.mod.name, name)
ELSIF para.sel.In(m.index) & para.showMessages THEN WriteLog(t, msg, name);
END;
WITH msg: Views.ScrollClassMsg DO
msg.allowBitmapScrolling := TRUE
ELSE
END
(* framework performs message propagation *)
END HandleViewMsg;
PROCEDURE (v: View) HandleModelMsg (VAR msg: Models.Message);
VAR name: Kernel.Name; t: Kernel.Type; m: Msgs;
BEGIN
t := DescOfMsg(msg);
Kernel.GetTypeName (t, name);
m := Find(t.mod.name, name);
IF m = NIL THEN Insert(t.mod.name, name)
ELSIF para.sel.In(m.index) & para.showMessages THEN WriteLog(t, msg, name);
END;
(* framework performs message propagation *)
END HandleModelMsg;
PROCEDURE Toggle*;
VAR v: Views.View; w: View; replace: Controllers.ReplaceViewMsg;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
v := Containers.FocusSingleton();
Controllers.ResetCurrentPath();
IF v # NIL THEN
WITH v: View DO
replace.old := v; replace.new := v.inner;
ELSE
NEW(w); w.inner := v;
replace.old := v; replace.new := w;
END;
Controllers.Forward(replace)
ELSE Dialog.Beep
END
END Toggle;
PROCEDURE ToggleGuard* (VAR par: Dialog.Par);
VAR v : Views.View;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
v := Containers.FocusSingleton();
Controllers.ResetCurrentPath();
IF (v = NIL) OR ~(v IS View) THEN
par.label := "#Dev:AddView";
par.disabled := v = NIL
ELSE
par.label := "#Dev:RemoveView"
END
END ToggleGuard;
PROCEDURE Reset*;
BEGIN
msgs := NIL; size := 0; para.sel.SetLen(size);
Dialog.UpdateList(para.sel)
END Reset;
PROCEDURE Clear*;
BEGIN
text.Delete(0, text.Length())
END Clear;
PROCEDURE PathToSpec (VAR path: ARRAY OF CHAR; VAR loc: Files.Locator; VAR name: Files.Name);
VAR i, j: INTEGER; ch: CHAR;
BEGIN
i := 0; j := 0; loc := Files.dir.This("");
WHILE (loc.res = 0) & (i < LEN(path) - 1) & (j < LEN(name) - 1) & (path[i] # 0X) DO
ch := path[i]; INC(i);
IF (j > 0) & ((ch = "/") OR (ch = "\")) THEN
name[j] := 0X; j := 0; loc := loc.This(name)
ELSE
name[j] := ch; INC(j)
END
END;
IF path[i] = 0X THEN name[j] := 0X
ELSE loc.res := 1; name := ""
END
END PathToSpec;
PROCEDURE OpenDialog*(file, title: ARRAY OF CHAR);
VAR loc: Files.Locator; fname: Files.Name; conv: Converters.Converter; view, v, t: Views.View;
r: FormModels.Reader; t0: Views.Title; done: BOOLEAN; c: Containers.Controller;
BEGIN
Dialog.MapString(title, t0);
Windows.SelectByTitle(NIL, {Windows.isTool}, t0, done);
IF ~ done THEN
PathToSpec(file, loc, fname);
IF loc.res = 0 THEN
conv := NIL;
view := Views.Old(Views.dontAsk, loc, fname, conv);
IF view IS FormViews.View THEN t := NIL;
r := view(FormViews.View).ThisModel().NewReader(NIL);
r.ReadView(v);
WHILE (v # NIL) & (t = NIL) DO
t := Properties.ThisType(v, "TextViews.View");
r.ReadView(v)
END;
IF t # NIL THEN
text := t(TextViews.View).ThisModel();
text.Delete(0, text.Length())
END;
END;
IF view # NIL THEN
WITH view: Containers.View DO
c := view.ThisController();
IF c # NIL THEN
c.SetOpts(c.opts - {Containers.noFocus} + {Containers.noCaret, Containers.noSelection})
ELSE Dialog.ShowMsg("#System:NotEditable")
END
ELSE Dialog.ShowMsg("#System:ContainerExpected")
END;
IF text # NIL THEN
StdDialog.Open(view, title, NIL, "", NIL, TRUE, FALSE, TRUE, FALSE, TRUE)
ELSE
Dialog.ShowMsg("#Dev:TextInDialogExpected")
END
END
ELSE Dialog.ShowParamMsg("#System:FileNotFound", file, "", "")
END;
END
END OpenDialog;
BEGIN
(* NEW(action); action.Do; *)
para.showMessages := TRUE;
size := 0;
path[0].x := refViewSize DIV 2; path[0].y := 0;
path[1].x := refViewSize; path[1].y := refViewSize DIV 2;
path[2].x := refViewSize DIV 2; path[2].y := refViewSize;
path[3].x := 0; path[3].y := refViewSize DIV 2;
END DevMsgSpy.
"DevMsgSpy.OpenDialog('Dev/Rsrc/MsgSpy', 'Message Spy')"
Menu:
"Message Spy..." "" "DevMsgSpy.OpenDialog('Dev/Rsrc/MsgSpy', 'Message Spy')" ""
Strings: (Dev)
AddView Add View
RemoveView Remove View
TextInDialogExpected Text in Dialog expected
Dialog:
StdCoder.Decode ..,, ..qX....3Qw7uP5PRPPNR9Rbf9b8R79FTvMf1uZlbcjRAktYcjRgp,
xW1xhiZiVBhihgmRiioedhgrp9XjJHPNjvQRdJHXS7wb8RTfQ9vQRtIdvPZHjU..D.JA06.Css
HorC4sQqorGqmmKjAST1.PuP.PuP7PNCLLq2o9ZD,6.ciDU7Umy.0E.0.3IXyKtqKfaqmQCb8R
7fJHPNjfL4TXyKt.bHfEjIy0.,.s,cMD.,6.5IXyKtgdjZACbHlayKmKaSNwB0UnNHEjIy4.,U
uq.e.8P16.,6.cUCoruamxhgRiiQeZZhZRgoBhjph0xhsp9XzE.QcjphoVSdw5.0.Z00.p,0E0
GYZdRqYntNCZkNSuWkNM8bVd9CbZ7P6..k.E.0ke59,BXgevQ4,TCbE,5zV.C5FPN5vO3uPlfL
8z4U.EEF.E2F.Y....05.C5MNCaodHKarNHKantQ4abNNCb.MH4amtO0WC,0WBNNsQ.66aai76
mYdtQGb.6...YiVA.1hBFlSzs9gh6Z33gwRE.6.YF0E.Eu0.,E0Uq,S4.05MMsQWajtRq2sQ.6
.CZc,0WB,C5.0WddPUjtN0E.0E...2cNA.fCKNl2Ts9Aoe343Qw.6IfvQFfEf9RdvPRfL8z4U.
EjU.EXU.Y..sNC3U17PKaVV.2U17P.00U.E...AYJ51f9APldCmGghh443gwT.0.,X.2.272.7
.O5UH,cIKanNNG5C2MM.aan7R6...A2guy23bu69lajvJIkmz,6.o96.o66.7sIGbYtEqaYtQu
W1VjtQKa2NO4agtPSa.sEm4C50.,.U,E.Yyvp2188PFHeQNAbZ443Qwb8R7vI5fQT9PNPNZvQR
dJ.5.,6.Yo0k1E49.,E.8cIhgsZiKBhZtQC3h0xmsHpmW5sQO3uZmL.0U..w.oa0.,sUGpmWbB
xhYltQeoNHEjAyI,ktg7cL8T1U.kk2.T.n0,6.Eb2.86.QC18RdfQHfMf9R9vQxGtH.0..c4E.
k.UesFnQ.E.0t.U,UzjV0CyIhACoruKuEqUHZC58RZ9Pxms,.U1xB.uZlT6AA.cQ...b1.o9ZD
,6.636.M00U.2..AU0CyIVGhighgmRCbWGhigFjAyI,ktIepVSdw5.,6.IIw.IH2U.sU.ktQ8C
JuaLqKKjAyI,.AjgVmz.2U..2,w86.IE.U,ZC..2..EGE.4E.E.EECOhU.wcNC.zwPA.A.2U.E
,9z8U...p.0.4.I3E.6.VQ.E..2eHJ.6...Z1Jsp0E9mr72YKQ4hO8BF,9z5U.E41.,.d1,E0G
2O5sNC3a5GZjtNSagNN0U,7NGaUMHC5C36.GYZdR..u0Ub7PsFKbVdQG40..EulEPHIoY8L4nw
gLF.3U..8ssP2Coru4UntIGqVyKr.o9XjF..Cb1,USdwl.,..A,,E.0U06.,6.,c.16QBaywPW
.0.161lbA2TmNeHXGBnmcUXDF.sET1.4zVkk.Um,..QC.Ej2yHZCQCwBu32..W.0..0F6Cb.yy
W8Utj00My7Yb6OQzL0yl1...
--- end of encoding --- | Dev/Mod/MsgSpy.odc |
MODULE DevPacker; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20050626, Fyodor Tkachov, russification edited
- 20050430, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
(* !!! HostPackedFiles depends on the way files are packed into the exe file by DevPacker. !!!! *)
IMPORT
Kernel, Services, Strings, Files, Dialog, Stores, Views, HostFiles, HostPackedFiles,
TextModels, TextViews, TextMappers, StdLog, DevCommanders, i21sysCharacters;
CONST
chunksize = 65536;
version = 1; (* same as in HostPackedFiles *)
TYPE
FileList = POINTER TO RECORD
path, name: Files.Name;
aliasPath, aliasName: Files.Name;
adr, len: INTEGER;
year, month, day, hour, minute, second: INTEGER;
next: FileList
END;
PROCEDURE Diff (VAR a, b: ARRAY OF CHAR; caseSens: BOOLEAN): INTEGER;
VAR i: INTEGER; cha, chb: CHAR;
BEGIN
i := 0;
REPEAT
cha := a[i]; chb := b[i]; INC(i);
IF cha # chb THEN
IF ~caseSens THEN
cha := i21sysCharacters.Cap(cha);
chb := i21sysCharacters.Cap(chb);
END;
IF cha = "\" THEN cha := "/" END;
IF chb = "\" THEN chb := "/" END;
IF cha # chb THEN RETURN ORD(cha) - ORD(chb) END
END
UNTIL cha = 0X;
RETURN 0
END Diff;
PROCEDURE SplitName (IN name: Files.Name; OUT path, fname: Files.Name);
VAR i, l, sp: INTEGER;
BEGIN
path := ""; fname := "";
l := LEN(name$);
i := 0; sp := -1;
WHILE i < l DO
path[i] := name[i];
IF (name[i] = "\") OR (name[i] = "/") THEN sp := i END;
INC(i)
END;
IF sp < 0 THEN
fname := name; path := ""
ELSE
path[sp] := 0X;
i := 0; INC(sp);
WHILE name[sp] # 0X DO fname[i] := name[sp]; INC(sp); INC(i) END
END
END SplitName;
PROCEDURE PackExe(files: FileList; exe: Files.File);
VAR tableadr, tot, err, ok, i, dl: INTEGER; l: FileList;
wr: Files.Writer; sw: Stores.Writer;
bytes: ARRAY chunksize OF BYTE;
loc: Files.Locator; f: Files.File; r: Files.Reader; shared: BOOLEAN;
num: ARRAY 7 OF CHAR;
BEGIN
tot := 0; err := 0; ok := 0;
l := files; wr := exe.NewWriter(NIL);
Dialog.ShowStatus('Packing...');
WHILE l # NIL DO
StdLog.String("Packing file: " + l.path + '/' + l.name); StdLog.Ln;
INC(tot);
loc := Files.dir.This(l.path); shared := FALSE;
f := Files.dir.Old(loc, l.name, shared);
IF f = NIL THEN shared := TRUE; f := Files.dir.Old(loc, l.name, shared) END;
IF f # NIL THEN
l.len := f.Length();
l.adr := exe.Length();
IF Services.Is(f, "HostFiles.File") THEN
(* If HostFiles.File is exported this can be replaced by an explicit type guard*)
HostFiles.GetModDate(f, l.year, l.month, l.day, l.hour, l.minute, l.second)
ELSIF Services.Is(f, "HostPackedFiles.File") THEN
(* could also be replaced by an explicit type guard*)
HostPackedFiles.GetModDate(f, l.year, l.month, l.day, l.hour, l.minute, l.second)
ELSE
l.year := 0; l.month := 0; l.day := 0; l.hour := 0; l.minute := 0; l.second := 0
END;
r := f.NewReader(NIL); r.SetPos(0);
wr.SetPos(l.adr);
i := 0; dl := MIN(chunksize, l.len);
WHILE dl > 0 DO
r.ReadBytes(bytes, 0, dl);
wr.WriteBytes(bytes, 0, dl); exe.Flush;
INC(i); dl := MIN(chunksize, l.len - i * chunksize)
END;
IF ~shared THEN f.Close END;
INC(ok);
Kernel.Collect
ELSE
StdLog.String("Could not read file: " + l.path + '/' + l.name); StdLog.Ln; INC(err)
END;
l := l.next
END;
l := files; tableadr := exe.Length();
sw.ConnectTo(exe); sw.SetPos(tableadr);
sw.WriteInt(tot);
WHILE l # NIL DO
sw.WriteString(l.aliasPath); sw.WriteString(l.aliasName);
sw.WriteInt(l.adr); sw.WriteInt(l.len);
sw.WriteInt(l.year); sw.WriteInt(l.month); sw.WriteInt(l.day);
sw.WriteInt(l.hour); sw.WriteInt(l.minute); sw.WriteInt(l.second);
l := l.next
END;
sw.WriteInt(HostPackedFiles.packTag);
sw.WriteInt(version);
sw.WriteInt(tableadr);
IF err > 0 THEN
Strings.IntToString(err, num);
Dialog.ShowMsg("Pack failed for: " + num + " files.");
Dialog.ShowStatus("failed")
ELSE
StdLog.String("Packed files: "); StdLog.Int(ok); StdLog.Ln;
Dialog.ShowStatus("ok")
END
END PackExe;
PROCEDURE RecAdd(path: Files.Name; VAR files: FileList; VAR tot: INTEGER);
VAR loc: Files.Locator; fi: Files.FileInfo; li: Files.LocInfo; l: FileList;
BEGIN
loc := Files.dir.This(path); fi := Files.dir.FileList(loc);
WHILE fi # NIL DO
NEW(l); l.path := path$; l.name := fi.name;
l.next := files; files := l; INC(tot);
fi := fi.next
END;
li := Files.dir.LocList(loc);
WHILE li # NIL DO
IF path = "" THEN RecAdd(li.name, files, tot) ELSE RecAdd(path + '/' + li.name, files, tot) END;
li := li.next
END
END RecAdd;
PROCEDURE ListFromSub* (sdir: ARRAY OF CHAR);
CONST colPerRow = 3;
VAR tot, col: INTEGER; files: FileList; t: TextModels.Model; f: TextMappers.Formatter; tv: TextViews.View;
name: Files.Name;
BEGIN
StdLog.String("Examining subdirectory: " + sdir); StdLog.Ln;
files := NIL; tot := 0;
RecAdd(sdir$, files, tot);
IF files # NIL THEN
t := TextModels.dir.New(); f.ConnectTo(t); f.SetPos(0);
f.WriteView(DevCommanders.dir.New()); f.WriteString(' DevPacker.PackThis exefilename.exe :='); f.WriteLn;
col := 0;
WHILE files # NIL DO
IF files.path # "" THEN name := '"' + files.path + '/' ELSE name := '"' END;
name := name + files.name + '"';
IF files.next # NIL THEN name := name + ' ' END;
f.WriteString(name);
INC(col); IF col >= colPerRow THEN f.WriteLn; col := 0 END; (* To avoid long lines *)
files := files.next
END;
f.WriteView(DevCommanders.dir.NewEnd()); f.WriteLn;
tv := TextViews.dir.New(t);
Views.OpenView(tv)
END;
StdLog.String("Found "); StdLog.Int(tot); StdLog.String(" files."); StdLog.Ln
END ListFromSub;
PROCEDURE ListLoadedModules*;
VAR
t: TextModels.Model; f: TextMappers.Formatter; tv: TextViews.View;
path, name: Files.Name; m: Kernel.Module;
BEGIN
t := TextModels.dir.New(); f.ConnectTo(t); f.SetPos(0);
f.WriteView(DevCommanders.dir.New()); f.WriteString(' DevPacker.PackThis exefilename.exe :='); f.WriteLn;
m := Kernel.modList;
WHILE m # NIL DO
Kernel.SplitName(m.name$, path, name);
IF path = "" THEN path := 'System' END;
path := path + '/Code/';
f.WriteString(path + name + '.ocf ');
m := m.next
END;
f.WriteView(DevCommanders.dir.NewEnd()); f.WriteLn;
tv := TextViews.dir.New(t);
Views.OpenView(tv)
END ListLoadedModules;
PROCEDURE FilesOk(files: FileList; exeloc: Files.Locator; IN exefile: Files.Name): BOOLEAN;
VAR l: FileList; loc: Files.Locator; fi: Files.FileInfo; ret: BOOLEAN;
err, tot: INTEGER;
BEGIN
StdLog.String("Validating files..."); StdLog.Ln;
IF files = NIL THEN StdLog.String("No files to pack."); StdLog.Ln; RETURN FALSE END;
l := files; ret := TRUE; err := 0; tot := 0;
WHILE l # NIL DO
loc := Files.dir.This(l.path);
IF loc # NIL THEN
fi := Files.dir.FileList(loc);
WHILE (fi # NIL) & (Diff(l.name, fi.name, FALSE) # 0) DO fi := fi.next END
END;
IF (loc = NIL) OR (fi = NIL) THEN
IF l.path # "" THEN StdLog.String(l.path + "/") END;
StdLog.String(l.name);
StdLog.String(" ...not found"); ret := FALSE; INC(err);
StdLog.Ln
ELSIF Files.dir.SameFile(exeloc, exefile, loc, fi.name) THEN
StdLog.String(
'Cannot pack a file into itself. (' + l.name + ' cannot be both the target exe and included in the list)');
StdLog.Ln; ret := FALSE; INC(err)
END;
INC(tot); l := l.next
END;
IF err > 0 THEN
StdLog.Int(err); StdLog.String(" files of"); StdLog.Int(tot); StdLog.String(" not correct.");
Dialog.ShowStatus("failed")
ELSE
StdLog.String("All"); StdLog.Int(tot); StdLog.String(" files found.")
END;
StdLog.Ln;
RETURN ret
END FilesOk;
(* Parse the file list *)
PROCEDURE GetCh (rd: TextModels.Reader);
BEGIN
REPEAT rd.Read UNTIL rd.char # TextModels.viewcode
END GetCh;
PROCEDURE RemoveWhiteSpaces (rd: TextModels.Reader; end: INTEGER);
BEGIN
WHILE (rd.Pos() <= end) & (rd.char <= 20X) DO GetCh(rd) END
END RemoveWhiteSpaces;
PROCEDURE FileName (rd: TextModels.Reader; end: INTEGER;
OUT name: ARRAY OF CHAR; OUT ok: BOOLEAN
);
VAR i: INTEGER; dquote, squote: BOOLEAN;
PROCEDURE ValidChar(ch: CHAR): BOOLEAN;
BEGIN
IF dquote THEN RETURN ch # '"'
ELSIF squote THEN RETURN ch # "'"
ELSE RETURN ch > 20X
END
END ValidChar;
BEGIN
ok := TRUE;
RemoveWhiteSpaces(rd, end);
i := 0; dquote := FALSE; squote := FALSE;
IF rd.char = '"' THEN dquote := TRUE
ELSIF rd.char = "'" THEN squote := TRUE
END;
IF dquote OR squote THEN GetCh(rd) END;
WHILE (rd.Pos() <= end) & ValidChar(rd.char) DO
name[i] := rd.char;
INC(i);
GetCh(rd)
END;
name[i] := 0X;
IF dquote THEN ok := rd.char = '"'; rd.Read END;
IF squote THEN ok := rd.char = "'"; rd.Read END
END FileName;
PROCEDURE GetNextFileName (rd: TextModels.Reader; end: INTEGER; VAR file: FileList; OUT ok: BOOLEAN);
VAR name: Files.Name;
BEGIN
FileName(rd, end, name, ok);
SplitName(name, file.path, file.name);
RemoveWhiteSpaces(rd, end);
IF ok & (rd.char = "=") THEN
GetCh(rd);
IF rd.char = ">" THEN
GetCh(rd);
FileName(rd, end, name, ok);
IF name # "" THEN
SplitName(name, file.aliasPath, file.aliasName)
ELSE
ok := FALSE
END
ELSE
ok := FALSE
END
ELSE
file.aliasPath := file.path; file.aliasName := file.name
END
END GetNextFileName;
PROCEDURE ParseExe (rd: TextModels.Reader; end: INTEGER;
OUT exepath, exefile: Files.Name; OUT ok: BOOLEAN
);
VAR name: Files.Name;
BEGIN
ok := FALSE;
GetCh(rd);
FileName(rd, end, name, ok);
IF ok THEN
SplitName(name, exepath, exefile);
RemoveWhiteSpaces(rd, end);
IF ok & (rd.char = ":") THEN
GetCh(rd);
IF rd.char = "=" THEN
GetCh(rd);
ok := TRUE
END
END
END
END ParseExe;
PROCEDURE AlreadyPacked (f: Files.File): BOOLEAN;
VAR rd: Stores.Reader; int: INTEGER;
BEGIN
rd.ConnectTo(f);
rd.SetPos(f.Length() - 12);
rd.ReadInt(int);
rd.ConnectTo(NIL);
RETURN int = HostPackedFiles.packTag
END AlreadyPacked;
PROCEDURE PackThis*;
VAR rd: TextModels.Reader; end, diff: INTEGER; exepath, exefile: Files.Name; ok: BOOLEAN;
files, l, tf, last: FileList; f: Files.File; loc: Files.Locator;
BEGIN
StdLog.String("Sorting file list..."); StdLog.Ln;
rd := DevCommanders.par.text.NewReader(NIL);
rd.SetPos(DevCommanders.par.beg);
end := DevCommanders.par.end;
ParseExe(rd, end, exepath, exefile, ok);
IF ~ok THEN
StdLog.String("exe file not correctly specified"); StdLog.Ln
ELSE
files := NIL; NEW(l);
GetNextFileName(rd, end, l, ok);
WHILE ok & (l.name # "") DO
IF files = NIL THEN
files := l
ELSE
tf := files; last := NIL;
diff := Diff(l.aliasPath, tf.aliasPath, FALSE);
WHILE (tf # NIL) & (diff < 0) DO
last := tf; tf := tf.next;
IF tf # NIL THEN diff := Diff(l.aliasPath, tf.aliasPath, FALSE) END
END;
IF (tf = NIL) OR (diff > 0) THEN
IF last = NIL THEN
l.next := files; files := l
ELSE
l.next := last.next; last.next := l
END
ELSE
diff := Diff(l.aliasName, tf.aliasName, FALSE);
WHILE (tf # NIL) & (diff < 0) & (Diff(l.aliasPath, tf.aliasPath, FALSE) = 0) DO
last := tf; tf := tf.next;
IF tf # NIL THEN diff := Diff(l.aliasName, tf.aliasName, FALSE) END
END;
IF (diff = 0) & (Diff(l.aliasPath, tf.aliasPath, FALSE) = 0) THEN
StdLog.String("File " + l.path + "/" + l.name + " appears more than once in the list."); StdLog.Ln
ELSE
IF last = NIL THEN
l.next := files; files := l
ELSE
l.next := last.next; last.next := l
END
END
END
END;
NEW(l);
GetNextFileName(rd, end, l, ok)
END;
loc := Files.dir.This(exepath$)
END;
IF ok & FilesOk(files, loc, exefile) THEN
f := Files.dir.Old(loc, exefile$, Files.exclusive);
IF f # NIL THEN
IF ~AlreadyPacked(f) THEN
StdLog.String("Packing files to exe..."); StdLog.Ln;
PackExe(files, f);
f.Flush; f.Close;
StdLog.String("Done."); StdLog.Ln
ELSE
f.Flush; f.Close;
IF exepath # "" THEN exepath := exepath + "/" END;
StdLog.String(
"Executable (" + exepath + exefile + ") already contains packed files. Link a new executable.");
StdLog.Ln;
Dialog.ShowMsg("failed")
END
ELSE
IF exepath # "" THEN exepath := exepath + "/" END;
StdLog.String("Could not open exe file: " + exepath + exefile); StdLog.Ln;
Dialog.ShowStatus("failed")
END
ELSE
StdLog.String("Packing canceled."); StdLog.Ln;
Dialog.ShowStatus("failed")
END
END PackThis;
END DevPacker.
"DevPacker.ListFromSub('')"
"DevPacker.ListLoadedModules"
DevPacker.PackThis BlackBoxP.exe := Host/Mod/files.odc
Host/Mod/cmds.odc Std\mod\log.odc Host/Sym\CFrames.osf host\Mod\CFrames.odc
DevPacker.PackThis exefile.exe := Host/Mod/files.odc => Host/Mod/Hoi.odc "host\Mod\CFrames.odc" Std/Mod/Log.odc => 'Std/Mod/Logg.odc'
DevLinker.Link BlackBoxP.exe := Kernel$+ Files HostFiles HostPackedFiles StdLoader
1 Applogo.ico 2 Doclogo.ico 3 SFLogo.ico 4 CFLogo.ico 5 DtyLogo.ico 6 folderimg.ico 7 openimg.ico
8 leafimg.ico
1 Move.cur 2 Copy.cur 3 Link.cur 4 Pick.cur 5 Stop.cur 6 Hand.cur 7 Table.cur | Dev/Mod/Packer.odc |
MODULE DevProfiler;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
WinApi, WinMM,
Kernel, Dialog, Fonts, Ports, Views,
TextModels, TextRulers, TextViews, TextControllers, TextMappers, StdLog;
CONST
maxMod = 256;
TYPE
Module = RECORD
start, end: INTEGER; (* address range *)
first, last: INTEGER; (* procedures *)
mod: Kernel.Module;
count: INTEGER;
END;
Proc = POINTER TO RECORD
name: Kernel.Name;
p: INTEGER;
next: Proc
END;
VAR
mod: ARRAY maxMod OF Module;
pEnd, pCount: POINTER TO ARRAY OF INTEGER;
numMod, numProc, listLen: INTEGER;
otherCount, totalCount: INTEGER;
out: TextMappers.Formatter;
started: BOOLEAN;
(* ------------- non-portable part ------------ *)
VAR id, periode: INTEGER;
PROCEDURE^ Count (pc: INTEGER);
PROCEDURE Recorder (id, msg, user, dw1, dw2: INTEGER);
VAR res: INTEGER; context: WinApi.CONTEXT;
BEGIN
context.ContextFlags := WinApi.CONTEXT_CONTROL;
res := WinApi.GetThreadContext(user, context);
Count(context.Eip) (* current pc of main thread *)
END Recorder;
PROCEDURE StartRecording;
(* Start calling Count periodically by an interrupt handler *)
VAR res: INTEGER; main: WinApi.HANDLE; tc: WinMM.TIMECAPS;
BEGIN
res := WinApi.DuplicateHandle(WinApi.GetCurrentProcess(), WinApi.GetCurrentThread(),
WinApi.GetCurrentProcess(), main, {1, 3, 4, 16..19}, 0, {});
res := WinMM.timeGetDevCaps(tc, SIZE(WinMM.TIMECAPS));
periode := tc.wPeriodMin * 3;
res := WinMM.timeBeginPeriod(periode);
id := WinMM.timeSetEvent(periode, 0, Recorder, main, WinMM.TIME_PERIODIC);
ASSERT(id # 0, 100)
END StartRecording;
PROCEDURE StopRecording;
(* stop calling Count *)
VAR res: INTEGER;
BEGIN
res := WinMM.timeKillEvent(id);
res := WinMM.timeEndPeriod(periode)
END StopRecording;
PROCEDURE Init;
BEGIN
END Init;
(* ------------- portable part ------------- *)
PROCEDURE Count (pc: INTEGER);
VAR l, r, m: INTEGER;
BEGIN
l := 0; r := numMod;
WHILE l < r DO (* binary search on modules *)
m := (l + r) DIV 2;
IF pc >= mod[m].end THEN l := m + 1 ELSE r := m END
END;
IF (r < numMod) & (pc >= mod[r].start) & (pc < mod[r].end) THEN
INC(mod[r].count); INC(totalCount);
l := mod[r].first; r := mod[r].last + 1;
WHILE l < r DO (* binary search on procedures *)
m := (l + r) DIV 2;
IF pc >= pEnd[m] THEN l := m + 1 ELSE r := m END
END;
INC(pCount[r])
ELSE INC(otherCount)
END
END Count;
(* ---------- programming interface ---------- *)
PROCEDURE InsertModule (m: Kernel.Module; VAR done: BOOLEAN);
VAR i: INTEGER;
BEGIN
IF (m # NIL) & (numMod < maxMod) THEN
i := numMod; INC(numMod);
WHILE (i > 0) & (m.code < mod[i-1].mod.code) DO mod[i] := mod[i-1]; DEC(i) END;
mod[i].mod := m;
done := TRUE
ELSE
done := FALSE
END
END InsertModule;
PROCEDURE Start*;
VAR ref, end, i, j: INTEGER; n: Kernel.Name; m: Kernel.Module; ok: BOOLEAN;
BEGIN
IF ~started THEN
IF listLen = 0 THEN (* all modules *)
m := Kernel.modList;
WHILE m # NIL DO
IF m.refcnt >= 0 THEN InsertModule(m, ok) END;
m := m.next
END
END;
otherCount := 0; totalCount := 0; numProc := 0; i := 0;
WHILE i < numMod DO
m := mod[i].mod;
mod[i].start := m.code;
mod[i].first := numProc;
ref := m.refs;
Kernel.GetRefProc(ref, end, n);
WHILE end # 0 DO INC(numProc); Kernel.GetRefProc(ref, end, n) END;
mod[i].last := numProc - 1;
INC(i)
END;
NEW(pEnd, numProc);
NEW(pCount, numProc);
i := 0; j := 0;
WHILE i < numMod DO
m := mod[i].mod; ref := m.refs;
Kernel.GetRefProc(ref, end, n);
WHILE end # 0 DO
pEnd[j] := m.code + end; pCount[j] := 0; INC(j);
Kernel.GetRefProc(ref, end, n)
END;
mod[i].end := pEnd[mod[i].last];
mod[i].count := 0;
INC(i)
END;
IF numMod > 0 THEN StartRecording END;
started := TRUE
END
END Start;
PROCEDURE Stop*;
BEGIN
IF started THEN
StopRecording;
started := FALSE
END
END Stop;
PROCEDURE Reset*;
BEGIN
Stop;
numMod := 0; numProc := 0; listLen := 0;
pEnd := NIL; pCount := NIL
END Reset;
PROCEDURE SetModuleList* (list: ARRAY OF CHAR);
VAR i, j: INTEGER; name: ARRAY 256 OF CHAR; ch: CHAR; done: BOOLEAN;
BEGIN
Stop;
Reset;
i := 0;
ch := list[i];
WHILE (i < LEN(list)) & (ch # 0X) DO
WHILE (ch # 0X) & (ch < "0") OR (ch > "9") & (CAP(ch) < "A") OR (CAP(ch) > "Z") DO INC(i); ch := list[i] END;
IF ch # 0X THEN
j := 0;
WHILE (ch >= "0") & (ch <= "9") OR (CAP(ch) >= "A") & (CAP(ch) <= "Z") DO
name[j] := ch; INC(j); INC(i); ch := list[i]
END;
name[j] := 0X;
InsertModule(Kernel.ThisMod(name), done);
IF done THEN INC(listLen) END
END
END
END SetModuleList;
(*
PROCEDURE GetModuleCount* (name: ARRAY OF CHAR; VAR count: LONGINT);
VAR i: LONGINT;
BEGIN
i := 0;
WHILE (i < numMod) & (mod[i].mod.name # name) DO INC(i) END;
IF i < numMod THEN count := mod[i].count
ELSE count := -1
END
END GetModuleCount;
PROCEDURE GetProcedureCount* (modName, procName: ARRAY OF CHAR; VAR count: LONGINT);
VAR i, j, last, ref, end: LONGINT; name: Kernel.Name;
BEGIN
i := 0;
WHILE (i < numMod) & (mod[i].mod.name # modName) DO INC(i) END;
IF i < numMod THEN
ref := mod[i].mod.refs; j := mod[i].first - 1; last := mod[i].last;
REPEAT INC(j); Kernel.GetRefProc(ref, end, name); UNTIL (j > last) OR (name = procName);
IF j <= last THEN count := pCount[j]
ELSE count := -1
END
ELSE count := -1
END
END GetProcedureCount;
PROCEDURE GetTotalCount* (VAR inModules, outside: LONGINT);
BEGIN
inModules := totalCount;
outside := otherCount
END GetTotalCount;
*)
(* ---------- menu commands ---------- *)
PROCEDURE Execute*;
VAR t0: LONGINT; res: INTEGER; str: Dialog.String;
BEGIN
t0 := Kernel.Time();
Dialog.Call("DevDebug.Execute", "", res);
StdLog.Int(SHORT((Kernel.Time() - t0) * 1000 DIV Kernel.timeResolution));
Dialog.MapString("#Dev:msec", str);
StdLog.Char(" "); StdLog.String(str);
StdLog.Ln
END Execute;
PROCEDURE NewRuler (): TextRulers.Ruler;
CONST mm = Ports.mm; pt = Ports.point;
VAR p: TextRulers.Prop;
BEGIN
NEW(p);
p.valid := {TextRulers.right, TextRulers.tabs, TextRulers.opts};
p.opts.val := {TextRulers.rightFixed}; p.opts.mask := p.opts.val;
p.right := 130 * mm;
p.tabs.len := 5;
p.tabs.tab[0].stop := 4 * mm; p.tabs.tab[1].stop := 50 * mm;
p.tabs.tab[2].stop := 54 * mm; p.tabs.tab[3].stop := 70 * mm;
p.tabs.tab[4].stop := 74 * mm;
RETURN TextRulers.dir.NewFromProp(p)
END NewRuler;
PROCEDURE ShowModule (VAR m: Module);
VAR i, p, ref, end: INTEGER; proc, list, a, b: Proc;
BEGIN
p := m.count * 100 DIV totalCount;
IF p > 0 THEN
out.WriteSString(m.mod.name); out.WriteTab; out.WriteTab;
out.WriteIntForm(p, 10, 2, "Џ", FALSE); out.WriteLn;
NEW(proc); list := NIL;
ref := m.mod.refs; i := m.first;
WHILE i <= m.last DO
Kernel.GetRefProc(ref, end, proc.name);
proc.p := pCount[i] * 100 DIV totalCount;
IF proc.p > 0 THEN proc.next := list; list := proc; NEW(proc) END;
INC(i)
END;
(* sort list *)
WHILE list # NIL DO
a := proc; b := proc.next;
WHILE (b # NIL) & (list.p < b.p) DO a := b; b := b.next END;
a.next := list; a := list.next; list.next := b; list := a
END;
list := proc.next;
WHILE list # NIL DO
out.WriteTab; out.WriteSString(list.name); out.WriteTab; out.WriteTab;
out.WriteIntForm(list.p, 10, 2, "Џ", FALSE); out.WriteLn;
list := list.next
END;
out.WriteLn;
END
END ShowModule;
PROCEDURE ShowProfile*;
VAR max, limit, maxi, pos, c, n, i: INTEGER; v: TextViews.View; a0: TextModels.Attributes; str: Views.Title;
BEGIN
Stop;
out.ConnectTo(TextModels.dir.New());
a0 := out.rider.attr;
out.rider.SetAttr(TextModels.NewStyle(a0, {Fonts.italic}));
Dialog.MapString("#Dev:Module", str); out.WriteString(str);
out.WriteTab; out.WriteTab;
Dialog.MapString("#Dev:PercentPerModule", str); out.WriteString(str);
out.WriteLn; out.WriteTab;
Dialog.MapString("#Dev:Procedure", str); out.WriteString(str);
out.WriteTab; out.WriteTab;
Dialog.MapString("#Dev:PercentPerProc", str); out.WriteString(str);
out.WriteLn; out.WriteLn;
out.rider.SetAttr(a0);
IF totalCount > 0 THEN
n := numMod; limit := MAX(INTEGER);
WHILE n > 0 DO
i := 0; max := -1;
WHILE i < numMod DO
c := mod[i].count;
IF (c > max) & ((c < limit) OR (c = limit) & (i > pos)) THEN max := c; maxi := i END;
INC(i)
END;
ShowModule(mod[maxi]);
pos := maxi; limit := max;
DEC(n)
END
END;
Dialog.MapString("#Dev:Samples", str); out.WriteString(str);
out.WriteTab; out.WriteTab; out.WriteInt(totalCount + otherCount);
out.WriteTab; out.WriteTab; out.WriteString("100%"); out.WriteLn;
out.WriteTab;
Dialog.MapString("#Dev:InProfiledModules", str); out.WriteString(str);
out.WriteTab; out.WriteTab;
out.WriteInt(totalCount); out.WriteTab; out.WriteTab;
n := totalCount * 100 DIV (totalCount + otherCount);
out.WriteInt(n); out.WriteChar("%"); out.WriteLn;
out.WriteTab;
Dialog.MapString("#Dev:Other", str); out.WriteString(str);
out.WriteTab; out.WriteTab;
out.WriteInt(otherCount); out.WriteTab; out.WriteTab;
out.WriteInt(100 - n); out.WriteChar("%"); out.WriteLn;
v := TextViews.dir.New(out.rider.Base());
v.SetDefaults(NewRuler(), TextViews.dir.defAttr);
Dialog.MapString("#Dev:Profile", str);
Views.OpenAux(v, str);
out.ConnectTo(NIL)
END ShowProfile;
PROCEDURE SetProfileList*;
VAR beg, end: INTEGER; s: TextMappers.Scanner;
c: TextControllers.Controller; done: BOOLEAN;
BEGIN
IF ~started THEN
Reset;
c := TextControllers.Focus();
IF c # NIL THEN
s.ConnectTo(c.text);
IF c.HasSelection() THEN c.GetSelection(beg, end)
ELSE beg := 0; end := c.text.Length()
END;
Reset;
s.SetPos(beg); s.Scan;
WHILE (s.start < end) & (s.type # TextMappers.eot) DO
IF s.type = TextMappers.string THEN
IF numMod < maxMod THEN
InsertModule(Kernel.ThisMod(s.string), done);
IF done THEN INC(listLen)
ELSE Dialog.ShowParamMsg("module ^0 not found", s.string, "", "")
END
ELSE
Dialog.ShowMsg("too many modules");
RETURN
END
END;
s.Scan
END
END
END
END SetProfileList;
PROCEDURE StartGuard* (VAR par: Dialog.Par);
BEGIN
IF started THEN par.disabled := TRUE END
END StartGuard;
PROCEDURE StopGuard* (VAR par: Dialog.Par);
BEGIN
IF ~started THEN par.disabled := TRUE END
END StopGuard;
BEGIN
Init
END DevProfiler.
STRINGS
msec msec
Module Module
PercentPerModule % per module
Procedure Procedure
PercentPerProc % per procedure
Samples samples:
InProfiledModules in profiled modules
Other other
Profile Profile
Menus
"Set Profile List" "" "DevProfiler.SetProfileList" "DevProfiler.StartGuard"
"Start Profiler" "" "DevProfiler.Start" "DevProfiler.StartGuard"
"Stop Profiler" "" "DevProfiler.Stop; DevProfiler.ShowProfile" "DevProfiler.StopGuard"
"Execute" "" "DevProfiler.Execute" "TextCmds.SelectionGuard"
| Dev/Mod/Profiler.odc |
MODULE DevRBrowser; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20050626, Fyodor Tkachov, russification edited
- 20050430, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Strings, Dialog, Files, Stores, Converters, Fonts, Ports, Views, Containers,
TextModels, TextMappers, TextRulers, TextViews, StdLinks, StdFolds, TextControllers, Models,
i21sysCharacters;
TYPE
SubDesc = RECORD (* description of subsystem contents *)
rsrc: BOOLEAN; (* does subsystem directory have a Rsrc subdirectory? *)
sym, code, mod, docu: Files.FileInfo (* file lists of Sym/Code/Mod/Docu subdirectories *)
END;
PROCEDURE Eq (a, b: CHAR): BOOLEAN;
BEGIN
a := i21sysCharacters.Cap(a);
b := i21sysCharacters.Cap(b);
RETURN a = b
END Eq;
PROCEDURE Gt (a, b: CHAR): BOOLEAN;
BEGIN
a := i21sysCharacters.Cap(a);
b := i21sysCharacters.Cap(b);
RETURN a > b
END Gt;
PROCEDURE ClipName (VAR s: ARRAY OF CHAR);
VAR h, k: INTEGER; ch: CHAR;
BEGIN (* strip file name suffix *)
IF (Dialog.platform DIV 10 = 1) OR (Dialog.platform = Dialog.linux) THEN (* some Windows variant or Linux *)
k := - 1; h := 0; ch := s[0];
WHILE ch # 0X DO
IF ch = "." THEN k := h END;
INC(h); ch := s[h]
END;
IF k # - 1 THEN s[k] := 0X END
END
END ClipName;
PROCEDURE Equal (IN a: ARRAY OF CHAR; b: ARRAY OF CHAR): BOOLEAN;
VAR i: INTEGER; cha, chb: CHAR;
BEGIN (* string comparison, not case sensitive *)
i := 0; cha := a[0]; chb := b[0];
WHILE (cha # 0X) & (chb # 0X) & Eq(cha, chb) DO INC(i); cha := a[i]; chb := b[i] END;
RETURN Eq(cha, chb)
END Equal;
PROCEDURE ClippedEqual (a: ARRAY OF CHAR; b: ARRAY OF CHAR): BOOLEAN;
VAR i: INTEGER; cha, chb: CHAR;
BEGIN (* string comparison, not case sensitive *)
ClipName(a); ClipName(b);
i := 0; cha := a[0]; chb := b[0];
WHILE (cha # 0X) & (chb # 0X) & Eq(cha, chb) DO INC(i); cha := a[i]; chb := b[i] END;
RETURN Eq(cha, chb)
END ClippedEqual;
PROCEDURE ClippedGreater (a: ARRAY OF CHAR; b: ARRAY OF CHAR): BOOLEAN;
VAR i: INTEGER; cha, chb: CHAR;
BEGIN (* string comparison, not case sensitive *)
ClipName(a); ClipName(b);
i := 0; cha := a[0]; chb := b[0];
WHILE (cha # 0X) & (chb # 0X) & Eq(cha, chb) DO INC(i); cha := a[i]; chb := b[i] END;
RETURN Gt(cha, chb)
END ClippedGreater;
PROCEDURE Ident (s: ARRAY OF CHAR): BOOLEAN;
CONST MaxIdLen = 256;
VAR i: INTEGER; ch: CHAR;
BEGIN
ClipName(s); i := 0;
REPEAT
ch := s[i]; INC(i)
UNTIL ~i21sysCharacters.IsIdentChar(ch) OR (i = MaxIdLen);
RETURN ch = 0X
END Ident;
PROCEDURE WriteOpenFold (VAR f: TextMappers.Formatter; hidden: ARRAY OF CHAR);
VAR fold: StdFolds.Fold; t: TextModels.Model; w: TextMappers.Formatter;
BEGIN
t := TextModels.CloneOf(f.rider.Base());
w.ConnectTo(t); w.WriteString(hidden);
fold := StdFolds.dir.New(StdFolds.expanded, "", t);
f.WriteView(fold)
END WriteOpenFold;
PROCEDURE WriteCloseFold (VAR f: TextMappers.Formatter; collaps: BOOLEAN);
VAR fold: StdFolds.Fold; m: TextModels.Model;
BEGIN
fold := StdFolds.dir.New(StdFolds.expanded, "", NIL);
f.WriteView(fold);
IF collaps THEN fold.Flip; m := f.rider.Base(); f.SetPos(m.Length()) END
END WriteCloseFold;
PROCEDURE WriteLink (VAR f: TextMappers.Formatter; subsystem, directory, file: ARRAY OF CHAR);
VAR v: Views.View; s: Files.Name;
BEGIN
IF directory = "" THEN
s := "StdCmds.OpenBrowser('";
s := s + subsystem + "/Docu/";
s := s + file + "', '";
s := s + subsystem + "/Docu/";
s := s + file + "')"
ELSIF Equal(directory , "Rsrc") THEN
s := "DevRBrowser.ShowFiles('";
s := s + subsystem + "/Rsrc')"
ELSE
s := "StdCmds.OpenBrowser('";
s := s + subsystem + "/" + directory;
s := s + "/" + file + "', '";
IF subsystem # "System" THEN s := s + subsystem END;
s := s + file + "')"
END;
v := StdLinks.dir.NewLink(s);
f.WriteView(v); (* insert left link view in text *)
IF directory # "" THEN s := directory$ ELSE s := file$; ClipName(s) END;
f.WriteString(s);
v := StdLinks.dir.NewLink("");
f.WriteView(v) (* insert right link view in text *)
END WriteLink;
PROCEDURE NewRuler (): TextRulers.Ruler;
VAR p: TextRulers.Prop;
BEGIN
NEW(p);
p.tabs.len := 5;
p.tabs.tab[0].stop := 4 * Ports.mm;
p.tabs.tab[1].stop := 50 * Ports.mm;
p.tabs.tab[2].stop := 70 * Ports.mm;
p.tabs.tab[3].stop := 90 * Ports.mm;
p.tabs.tab[4].stop := 110 * Ports.mm;
p.valid := {TextRulers.tabs};
RETURN TextRulers.dir.NewFromProp(p)
END NewRuler;
PROCEDURE MSort (l: Files.FileInfo; n: INTEGER): Files.FileInfo;
VAR h, h0, r: Files.FileInfo; n2, i: INTEGER;
BEGIN
IF n > 2 THEN
n2 := n DIV 2; h := l; i := n2; WHILE i # 1 DO DEC(i); h := h.next END;
r := h.next; h.next := NIL; (* split list into two half-length lists*)
l := MSort(l, n2); r := MSort(r, n - n2); (* sort both lists separately *)
IF ClippedGreater(r.name, l.name) THEN h := l; l := l.next ELSE h := r; r := r.next END;
h0 := h; (* h0 is back pointer of newly constructed list h *)
WHILE (l # NIL) & (r # NIL) DO
IF ClippedGreater(r.name, l.name) THEN h0.next := l; l := l.next ELSE h0.next := r; r := r.next END;
h0 := h0.next
END;
IF l # NIL THEN h0.next := l ELSIF r # NIL THEN h0.next := r END;
l := h
ELSIF n = 2 THEN
IF ClippedGreater(l.name, l.next.name) THEN l.next.next := l; l := l.next; l.next.next := NIL END
END;
RETURN l
END MSort;
PROCEDURE Sort (i: Files.FileInfo): Files.FileInfo;
VAR n: INTEGER; h: Files.FileInfo;
BEGIN (* merge sort *)
n := 0; h := i; WHILE h # NIL DO INC(n); h := h.next END; (* count number of list elements *)
RETURN MSort(i, n)
END Sort;
PROCEDURE GetThisSubsystem (loc: Files.Locator; VAR sub: SubDesc; VAR isSubsystem: BOOLEAN);
VAR i: Files.LocInfo; l: Files.Locator;
BEGIN
isSubsystem := FALSE; sub.rsrc := FALSE;
i := Files.dir.LocList(loc);
WHILE i # NIL DO
IF Equal(i.name, "Rsrc") THEN
isSubsystem := TRUE; sub.rsrc := TRUE
ELSIF Equal(i.name, "Sym") OR Equal(i.name, "Code") OR
Equal(i.name, "Mod") OR Equal(i.name, "Docu") THEN
isSubsystem := TRUE
END;
i := i.next
END;
sub.sym := Files.dir.FileList(loc.This("Sym"));
sub.code := Files.dir.FileList(loc.This("Code"));
sub.mod := Files.dir.FileList(loc.This("Mod"));
sub.docu := Files.dir.FileList(loc.This("Docu"));
sub.sym := Sort(sub.sym);
sub.code := Sort(sub.code);
sub.mod := Sort(sub.mod);
sub.docu := Sort(sub.docu)
END GetThisSubsystem;
PROCEDURE Convertible (l: Files.FileInfo): BOOLEAN;
VAR c: Converters.Converter;
BEGIN
c := Converters.list; WHILE (c # NIL) & (c.fileType # l.type) DO c := c.next END;
RETURN c # NIL
END Convertible;
PROCEDURE GetModule (VAR sub: SubDesc; OUT i: Files.FileInfo);
BEGIN
i := sub.sym;
IF (sub.code # NIL) & ((i = NIL) OR ClippedGreater(i.name, sub.code.name)) THEN i := sub.code END;
IF (sub.mod # NIL) & ((i = NIL) OR ClippedGreater(i.name, sub.mod.name)) THEN i := sub.mod END;
IF (sub.docu # NIL) & ((i = NIL) OR ClippedGreater(i.name, sub.docu.name)) THEN i := sub.docu END
END GetModule;
PROCEDURE GetNonmodule (VAR l: Files.FileInfo; OUT i: Files.FileInfo);
VAR h: Files.FileInfo;
BEGIN
h := l;
IF (h # NIL) & ~Ident(h.name) THEN
i := l; l := l.next
ELSIF h # NIL THEN
WHILE (h.next # NIL) & Ident(h.next.name) DO h := h.next END;
IF h.next # NIL THEN i := h.next; h.next := i.next ELSE i := NIL END
ELSE
i := NIL
END
END GetNonmodule;
PROCEDURE WriteSubsystem (VAR f: TextMappers.Formatter; old, new, bold: TextModels.Attributes;
VAR sub: SubDesc; name: Files.Name);
VAR i: Files.FileInfo; modname: Files.Name;
BEGIN
f.rider.SetAttr(bold); f.WriteString(name); f.rider.SetAttr(old);
f.WriteString(" ");
WriteOpenFold(f, ""); f.WriteLn;
f.rider.SetAttr(new);
IF sub.rsrc THEN f.WriteTab; WriteLink(f, name, "Rsrc", ""); f.WriteLn END;
GetNonmodule(sub.docu, i);
IF i # NIL THEN
f.WriteTab;
REPEAT
WriteLink(f, name, "", i.name); f.WriteString(" ");
GetNonmodule(sub.docu, i)
UNTIL i = NIL;
f.WriteLn
END;
f.rider.SetAttr(old);
GetModule(sub, i);
WHILE i # NIL DO (* iterate over all modules for which there is a symbol file *)
f.WriteTab;
IF ~Equal(name, "System") THEN f.WriteString(name) END; (* subsystem name *)
modname := i.name;
ClipName(modname); (* file name => module name *)
f.WriteString(modname);
f.rider.SetAttr(new);
f.WriteTab;
IF (sub.sym # NIL) & ClippedEqual(sub.sym.name, i.name) THEN
IF Convertible(sub.sym) THEN WriteLink(f, name, "Sym", sub.sym.name) END;
sub.sym := sub.sym.next
END;
f.WriteTab;
IF (sub.code # NIL) & ClippedEqual(sub.code.name, i.name) THEN
IF Convertible(sub.code) THEN WriteLink(f, name, "Code", sub.code.name) END;
sub.code := sub.code.next
END;
f.WriteTab;
IF (sub.mod # NIL) & ClippedEqual(sub.mod.name, i.name) THEN
IF Convertible(sub.mod) THEN WriteLink(f, name, "Mod", sub.mod.name) END;
sub.mod := sub.mod.next
END;
f.WriteTab;
IF (sub.docu # NIL) & ClippedEqual(sub.docu.name, i.name) THEN
IF Convertible(sub.docu) THEN WriteLink(f, name, "Docu", sub.docu.name) END;
sub.docu := sub.docu.next
END;
f.rider.SetAttr(old);
f.WriteLn;
GetModule(sub, i)
END;
WriteCloseFold(f, TRUE);
f.WriteLn
END WriteSubsystem;
PROCEDURE AddFiles(VAR t: TextModels.Model);
VAR f: TextMappers.Formatter; tv: TextViews.View;
c: Containers.Controller; old, new, bold: TextModels.Attributes; title: Views.Title;
subinfo: Files.LocInfo; root, subloc: Files.Locator; subdesc: SubDesc; isSubsystem: BOOLEAN;
v: Views.View;
BEGIN
f.ConnectTo(t);
old := f.rider.attr;
new := TextModels.NewStyle(old, old.font.style + {Fonts.underline}); (* use underline style *)
new := TextModels.NewColor(new, Ports.blue); (* use blue color *)
bold := TextModels.NewWeight(old, Fonts.bold); (* use bold outline *)
f.WriteView(NewRuler());
v := StdLinks.dir.NewLink("DevRBrowser.Update");
f.rider.SetAttr(new);
f.WriteView(v); (* insert left link view in text *)
f.WriteString("Update"); f.WriteLn;
v := StdLinks.dir.NewLink("");
f.WriteView(v); (* insert right link view in text *)
root := Files.dir.This("");
subinfo := Files.dir.LocList(root);
WHILE subinfo # NIL DO (* iterate over all locations; no particular sorting order is guaranteed *)
subloc := root.This(subinfo.name);
IF subloc # NIL THEN
GetThisSubsystem(subloc, subdesc, isSubsystem);
IF isSubsystem THEN WriteSubsystem(f, old, new, bold, subdesc, subinfo.name) END
END;
subinfo := subinfo.next
END
END AddFiles;
PROCEDURE ShowRepository*;
VAR t: TextModels.Model; tv: TextViews.View;
c: Containers.Controller; v: Views.View;
BEGIN
IF Dialog.platform = 11 THEN
(* this feature is not available under Windows 3.11, because it doesn't distinguish small/capital
letters, as is necessary for correct spelling of subsystem and module names *)
Dialog.ShowMsg("#Host:NotUnderWindows3")
ELSE
t := TextModels.dir.New();
AddFiles(t);
tv := TextViews.dir.New(t);
c := tv.ThisController();
(* set Browser mode: *)
c.SetOpts(c.opts + {Containers.noCaret} - {Containers.noSelection, Containers.noFocus});
Views.OpenAux(tv, "Repository")
END
END ShowRepository;
PROCEDURE Update*;
VAR t, t0: TextModels.Model; v: Views.View; script: Stores.Operation;
BEGIN
IF Dialog.platform = 11 THEN
(* this feature is not available under Windows 3.11, because it doesn't distinguish small/capital
letters, as is necessary for correct spelling of subsystem and module names *)
Dialog.ShowMsg("#Host:NotUnderWindows3")
ELSE
t0 := TextViews.FocusText();
Models.BeginScript(t0, "Update repository", script);
t := TextModels.CloneOf(t0);
AddFiles(t);
t0.Delete(0, t0.Length()); t0.Insert(0, t, 0, t.Length());
Models.EndScript(t0, script)
END
END Update;
PROCEDURE PathToLoc (path: ARRAY OF CHAR; VAR loc: Files.Locator);
VAR i, j: INTEGER; ch: CHAR; name: Files.Name;
BEGIN
loc := Files.dir.This("");
IF path # "" THEN
i := 0; j := 0;
REPEAT
ch := path[i]; INC(i);
IF (ch = "/") OR (ch = 0X) THEN name[j] := 0X; j := 0; loc := loc.This(name)
ELSE name[j] := ch; INC(j)
END
UNTIL (ch = 0X) OR (loc.res # 0)
END
END PathToLoc;
PROCEDURE ShowFiles* (path: ARRAY OF CHAR);
VAR t: TextModels.Model; f: TextMappers.Formatter; v: Views.View; tv: TextViews.View;
c: Containers.Controller; old, new: TextModels.Attributes; conv: Converters.Converter;
loc: Files.Locator; fi: Files.FileInfo; s: Files.Name;
BEGIN
t := TextModels.dir.New();
f.ConnectTo(t);
old := f.rider.attr; (* save old text attributes for later use *)
new := TextModels.NewStyle(old, old.font.style + {Fonts.underline}); (* use underline style *)
new := TextModels.NewColor(new, Ports.blue); (* use blue color *)
f.rider.SetAttr(new); (* change current attributes of formatter *)
(* generate list of all locations *)
PathToLoc(path, loc);
fi := Files.dir.FileList(loc);
fi := Sort(fi);
WHILE fi # NIL DO (* no particular sorting order is guaranteed *)
conv := Converters.list; WHILE (conv # NIL) & (conv.fileType # fi.type) DO conv := conv.next END;
IF conv # NIL THEN (* there is a converter for this file type *)
s := "DevRBrowser.OpenFile('";
s := s + path + "', '" + fi.name + "')";
v := StdLinks.dir.NewLink(s);
f.WriteView(v); (* insert left link view in text *)
s := fi.name$; ClipName(s); f.WriteString(fi.name);
v := StdLinks.dir.NewLink("");
f.WriteView(v); (* insert right link view in text *)
f.WriteLn
END;
fi := fi.next
END;
tv := TextViews.dir.New(t);
c := tv.ThisController();
(* set Browser mode: *)
c.SetOpts(c.opts + {Containers.noCaret} - {Containers.noSelection, Containers.noFocus});
Views.OpenAux(tv, path$)
END ShowFiles;
PROCEDURE OpenFile* (path, name: ARRAY OF CHAR);
VAR loc: Files.Locator; f: Files.File; c: Converters.Converter; n: Files.Name; s: Stores.Store;
BEGIN
PathToLoc(path, loc); n := name$;
IF loc # NIL THEN
f := Files.dir.Old(loc, n, Files.shared);
IF f # NIL THEN
c := Converters.list; WHILE (c # NIL) & (c.fileType # f.type) DO c := c.next END;
IF c # NIL THEN
Converters.Import(loc, n, c, s);
WITH s: Views.View DO
Views.Open(s, loc, n, c)
ELSE
END
END
END
END
END OpenFile;
END DevRBrowser.
| Dev/Mod/RBrowser.odc |
MODULE DevReferences;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20121106, Fyodor Tkachov, Scan uses V.IsModule, V.IsImport to correctly open documentation by module alias
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20091016, для поддержки русификации:
предложения Е.Э.Темиргалеева, вставка рукой Ткачева Ф.В.
ShowDocuLang добавлена Ф.В.Ткачевым.
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Kernel, Files, Fonts, Models, Views, Dialog, Containers,
StdDialog,
TextModels, TextMappers, TextViews, TextControllers,
Ch := i21sysCharacters, V := i21sysVocabulary;
CONST
(* additional scanner types *)
import = 100; module = 101; semicolon = 102; becomes = 103; comEnd = 104;
PROCEDURE SpecialFont (r: TextModels.Reader): BOOLEAN;
CONST max = 14 * Fonts.point;
BEGIN
RETURN (r.attr.font.weight > Fonts.normal) & (r.attr.font.size <= max)
END SpecialFont;
PROCEDURE SearchIdent (
t: TextModels.Model; ident: TextMappers.String; VAR beg, end: INTEGER; bold: BOOLEAN
);
VAR r: TextModels.Reader; found: BOOLEAN; ch: CHAR; len, i: INTEGER;
BEGIN
end := 0;
IF ident # "" THEN
len := 0; WHILE ident[len] # 0X DO INC(len) END;
r := t.NewReader(NIL); found := FALSE;
beg := 0; r.SetPos(0); r.ReadChar(ch);
WHILE ~r.eot & ~found DO
(* search legal start symbol *)
WHILE ~r.eot & ~Ch.IsFirstIdentChar(ch) DO
(* WHILE ~r.eot & ((ch < "A") OR (ch > "Z") & (ch # "_") & (ch < "a") OR (ch > "z")) DO *)
INC(beg); r.ReadChar(ch)
END;
i := 0;
WHILE ~r.eot & (~bold OR SpecialFont(r)) & (i # len) & (ch = ident[i]) DO
r.ReadChar(ch); INC(i)
END;
found := (i = len) & ~Ch.IsIdentChar(ch);
(* found := (i = len) &
((ch < "0") OR (ch > "9") & (ch < "A") OR (ch > "Z") & (ch # "_") & (ch < "a") OR (ch > "z")); *)
IF ~r.eot & ~found THEN (* skip rest of identifier *)
beg := r.Pos() - 1;
WHILE ~r.eot & Ch.IsIdentChar(ch) DO
(* WHILE ~r.eot &
~((ch < "0") OR (ch > "9") & (ch < "A") OR (ch > "Z") & (ch # "_") & (ch < "a") OR (ch > "z")) DO *)
INC(beg); r.ReadChar(ch)
END
END
END;
IF found THEN end := r.Pos() - 1 END
END
END SearchIdent;
PROCEDURE ShowText* (module, ident: TextMappers.String; category: Files.Name);
VAR title: Views.Title; loc: Files.Locator; name: Files.Name;
v: Views.View; m: Models.Model; t: TextModels.Model; beg, end: INTEGER; c: Containers.Controller;
PROCEDURE IsDocu ( category: Files.Name ): BOOLEAN;
BEGIN
category[4] := 0X;
RETURN category = "Docu"
END IsDocu;
BEGIN
StdDialog.GetSubLoc(module, category, loc, name); title := name$;
Kernel.MakeFileName(name, "");
IF IsDocu( category ) THEN
loc.res := 77; v := Views.OldView(loc, name); loc.res := 0;
IF v # NIL THEN
WITH v: Containers.View DO
c := v.ThisController();
IF c # NIL THEN
c.SetOpts(c.opts - {Containers.noFocus, Containers.noSelection} + {Containers.noCaret})
END
ELSE
END;
Views.OpenAux(v, title)
END
ELSE
v := Views.OldView(loc, name);
IF v # NIL THEN Views.Open(v, loc, name, NIL) END
END;
IF v # NIL THEN
m := v.ThisModel();
IF (m # NIL) & (m IS TextModels.Model) THEN
t := m(TextModels.Model);
SearchIdent(t, ident, beg, end, TRUE);
IF end <= 0 THEN SearchIdent(t, ident, beg, end, FALSE) END;
IF end > 0 THEN
TextViews.ShowRange(t, beg, end, TextViews.any);
TextControllers.SetSelection(t, beg, end)
ELSIF ident # "" THEN Dialog.Beep
END
ELSE Dialog.ShowMsg("#System:WrongSelection")
END
ELSE Dialog.ShowParamMsg("#System:FileNotFound", name, "", "")
END
END ShowText;
PROCEDURE Scan (VAR s: TextMappers.Scanner);
BEGIN
s.Scan;
IF s.type = TextMappers.string THEN
IF V.IsImport( s.string ) THEN s.type := import
ELSIF V.IsModule( s.string ) THEN s.type := module
END
ELSIF s.type = TextMappers.char THEN
IF s.char = ";" THEN s.type := semicolon
ELSIF s.char = ":" THEN
IF s.rider.char = "=" THEN s.rider.Read; s.type := becomes END
ELSIF s.char = "(" THEN
IF s.rider.char = "*" THEN
s.rider.Read;
REPEAT Scan(s) UNTIL (s.type = TextMappers.eot) OR (s.type = comEnd);
Scan(s)
END
ELSIF s.char = "*" THEN
IF s.rider.char = ")" THEN s.rider.Read; s.type := comEnd END
END
END
END Scan;
PROCEDURE CheckModName (VAR mod: TextMappers.String; t: TextModels.Model);
VAR s: TextMappers.Scanner;
BEGIN
s.ConnectTo(t); s.SetPos(0); Scan(s);
IF s.type = module THEN
Scan(s);
WHILE (s.type # TextMappers.eot) & (s.type # import) DO Scan(s) END;
WHILE (s.type # TextMappers.eot) & (s.type # semicolon)
& ((s.type # TextMappers.string) OR (s.string # mod)) DO Scan(s) END;
IF s.type = TextMappers.string THEN
Scan(s);
IF s.type = becomes THEN
Scan(s);
IF s.type = TextMappers.string THEN
mod := SHORT(s.string$)
END
END
END
END
END CheckModName;
PROCEDURE Show (category: Files.Name);
VAR c: TextControllers.Controller; s: TextMappers.Scanner; beg, end: INTEGER;
module, ident: TextMappers.String;
BEGIN
c := TextControllers.Focus();
IF c # NIL THEN
IF c.HasSelection() THEN
c.GetSelection(beg, end);
s.ConnectTo(c.text); s.SetOpts({7}); (* acceptUnderscores *)
s.SetPos(beg); s.Scan;
IF s.type = TextMappers.string THEN
module := s.string; ident := "";
CheckModName(module, c.text);
s.Scan;
IF (s.type = TextMappers.char) & (s.char = ".") THEN
s.Scan;
IF s.type = TextMappers.string THEN ident := s.string END
END;
ShowText(module, ident, category)
ELSE Dialog.ShowMsg("#System:WrongSelection")
END
ELSE Dialog.ShowMsg("#System:NoSelection")
END
ELSE Dialog.ShowMsg("#System:NoFocus")
END
END Show;
PROCEDURE ShowSource*;
BEGIN
Show("Mod")
END ShowSource;
PROCEDURE ShowDocu*;
BEGIN
Show("Docu")
END ShowDocu;
PROCEDURE ShowDocuLang* (lang: ARRAY OF CHAR);
(*cf. DevSearch.SearchInDocuLang*)
BEGIN
IF lang = '' THEN
Show( "Docu" )
ELSE
Show( "Docu/" + lang )
END;
END ShowDocuLang;
END DevReferences.
DevReferences.Show
Files.Directory
"DevReferences.ShowDocuLang('ru')"
DevReferences.ShowSource
i21sysInПримеры
| Dev/Mod/References.odc |
MODULE DevSearch;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20091016, FVT for multilanguage support modified: Search, added: SearchInDocuLang
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Kernel, Files, Fonts, Ports, Models, Views, Containers, Dialog, Windows,
TextModels, TextRulers, TextViews, TextControllers, TextMappers, TextCmds, StdLinks;
CONST
N = 32; T = 10;
maxPat = 64;
noMatchFoundKey = "#Std:NoMatchFound";
locationKey = "#Std:Location";
countKey = "#Std:Count";
searchingKey = "#Std:Searching";
openFindCmdKey = "#Dev:OpenFindCmd";
openFindCmdNotFoundKey = "#Dev:OpenFindCmdNotFound";
TYPE
Pattern = ARRAY maxPat OF CHAR;
Text = POINTER TO RECORD
next: Text;
num: INTEGER;
title: Files.Name
END;
VAR
w: TextMappers.Formatter;
key: ARRAY 256 OF INTEGER;
PROCEDURE Find (t: TextModels.Model; pat: Pattern; title: Files.Name; VAR list: Text; caseSens: BOOLEAN);
VAR r: TextModels.Reader; num: INTEGER; i, j, b, e, n: INTEGER; ch: CHAR; ref: Pattern; l: Text;
BEGIN
n := 0; num := 0;
WHILE pat[n] # 0X DO INC(n) END;
r := t.NewReader(NIL);
r.SetPos(0); r.ReadChar(ch);
WHILE ~r.eot DO
ref[0] := ch; i := 0; j := 0; b := 0; e := 1;
WHILE ~r.eot & (i < n) DO
(*
IF key[ORD(pat[i])] = key[ORD(ch)] THEN INC(i); j := (j + 1) MOD maxPat
*)
IF caseSens & (pat[i]=ch) OR ~caseSens & (CAP(pat[i]) = CAP(ch)) THEN INC(i); j := (j + 1) MOD maxPat
ELSE i := 0; b := (b + 1) MOD maxPat; j := b
END;
IF j # e THEN ch := ref[j]
ELSE r.ReadChar(ch); ref[j] := ch; e := (e + 1) MOD maxPat
END
END;
IF i = n THEN INC(num) END
END;
IF num > 0 THEN
NEW(l); l.num := num; l.title := title; l.next := list; list := l
END
END Find;
PROCEDURE List (list: Text; pat: Pattern; source, caseSens: BOOLEAN);
VAR a0: TextModels.Attributes; cmd: ARRAY 256 OF CHAR; this, t: Text; max: INTEGER;
BEGIN
IF list = NIL THEN
Dialog.MapString(noMatchFoundKey, cmd);
w.WriteString(cmd)
ELSE
a0 := w.rider.attr;
w.rider.SetAttr(TextModels.NewStyle(w.rider.attr, {Fonts.italic}));
Dialog.MapString(locationKey, cmd);
w.WriteString(cmd); w.WriteTab;
Dialog.MapString(countKey, cmd);
w.WriteString(cmd); w.WriteLn;
w.rider.SetAttr(a0);
REPEAT
t := list; max := 1; this := NIL;
WHILE t # NIL DO
IF t.num >= max THEN max := t.num; this := t END;
t := t.next
END;
IF this # NIL THEN
w.rider.SetAttr(TextModels.NewStyle(w.rider.attr, {Fonts.underline}));
w.rider.SetAttr(TextModels.NewColor(w.rider.attr, Ports.blue));
IF source THEN
cmd := "StdCmds.OpenDoc('" + this.title + "'); DevSearch.SelectCaseSens('" + pat + "')"
ELSE
IF caseSens THEN
cmd := "StdCmds.OpenBrowser('" + this.title + "', '" + this.title + "'); " +
"DevSearch.SelectCaseSens('" + pat + "')"
ELSE
cmd := "StdCmds.OpenBrowser('" + this.title + "', '" + this.title + "'); " +
"DevSearch.SelectCaseInSens('" + pat + "')"
END
END;
w.WriteView(StdLinks.dir.NewLink(cmd));
w.WriteString(this.title);
w.WriteView(StdLinks.dir.NewLink(""));
w.rider.SetAttr(a0);
w.WriteTab; w.WriteInt(this.num); w.WriteLn;
this.num := 0
END
UNTIL this = NIL
END
END List;
PROCEDURE NewRuler (): TextRulers.Ruler;
CONST mm = Ports.mm;
VAR p: TextRulers.Prop;
BEGIN
NEW(p);
p.valid := {TextRulers.right, TextRulers.tabs, TextRulers.opts};
p.opts.val := {TextRulers.rightFixed}; p.opts.mask := p.opts.val;
p.right := 100 * mm;
p.tabs.len := 1;
p.tabs.tab[0].stop := 70 * mm;
RETURN TextRulers.dir.NewFromProp(p)
END NewRuler;
PROCEDURE ThisText (loc: Files.Locator; VAR name: Files.Name): TextModels.Model;
VAR v: Views.View; m: Models.Model;
BEGIN
v := Views.OldView(loc, name);
IF v # NIL THEN
m := v.ThisModel();
IF m # NIL THEN
WITH m: TextModels.Model DO RETURN m ELSE END
END
END;
RETURN NIL
END ThisText;
PROCEDURE Search (source, caseSens: BOOLEAN; lang: ARRAY OF CHAR);
VAR pat: Pattern; t, log: TextModels.Model; v: Views.View; title: Views.Title; c: Containers.Controller;
files: Files.FileInfo; dirs: Files.LocInfo;
loc: Files.Locator; path, p: Files.Name; list: Text;
BEGIN
(*TextCmds.InitFindDialog; *)
pat := TextCmds.find.find$;
IF pat # "" THEN
Dialog.ShowStatus(searchingKey);
TextCmds.find.find := pat$;
log := TextModels.dir.New();
w.ConnectTo(log); w.SetPos(0);
IF source THEN loc := Files.dir.This("Mod"); path := "Mod"
ELSE loc := Files.dir.This("Docu"); path := "Docu";
IF lang # '' THEN
loc := loc.This( lang ); ASSERT( loc.res = 0 );
path := path + '/' + lang;
END;
END;
files := Files.dir.FileList(loc); list := NIL;
WHILE files # NIL DO
IF files.type = Kernel.docType THEN
p := path + "/" + files.name;
Find(ThisText(loc, files.name), pat, p, list, caseSens)
END;
files := files.next
END;
loc := Files.dir.This("");
dirs := Files.dir.LocList(loc);
WHILE dirs # NIL DO
loc := Files.dir.This(dirs.name); path := dirs.name + "/";
IF source THEN loc := loc.This("Mod"); path := path + "Mod"
ELSE loc := loc.This("Docu"); path := path +"Docu";
IF lang # '' THEN
loc := loc.This( lang ); ASSERT( loc.res = 0 );
path := path + '/' + lang;
END;
END;
files := Files.dir.FileList(loc);
WHILE files # NIL DO
IF files.type = Kernel.docType THEN
p := path + "/" + files.name;
t := ThisText(loc, files.name);
IF t # NIL THEN
Find(t, pat, p, list, caseSens)
END
END;
files := files.next
END;
dirs := dirs.next
END;
List(list, pat, source, caseSens);
v := TextViews.dir.New(log);
title := 'Search for "' + pat + '"';
v(TextViews.View).SetDefaults(NewRuler(), TextViews.dir.defAttr);
Views.OpenAux(v, title);
c := v(Containers.View).ThisController();
c.SetOpts(c.opts + {Containers.noCaret});
w.ConnectTo(NIL);
Dialog.ShowStatus("")
END
END Search;
PROCEDURE SearchInSources*;
BEGIN
Search(TRUE, TRUE, '')
END SearchInSources;
PROCEDURE SearchInDocu* (opts: ARRAY OF CHAR);
VAR caseSens: BOOLEAN;
BEGIN
caseSens := ~TextCmds.find.ignoreCase;
IF LEN(opts$) > 0 THEN
IF CAP(opts[0]) = 'S' THEN
caseSens := TRUE
ELSIF CAP(opts[0]) = 'I' THEN
caseSens := FALSE
END
END;
Search(FALSE, caseSens, '')
END SearchInDocu;
PROCEDURE SearchInDocuLang* (opts, lang: ARRAY OF CHAR);
(*cf. DevReferences.ShowDocuLang*)
VAR caseSens: BOOLEAN;
BEGIN
caseSens := ~TextCmds.find.ignoreCase;
IF LEN(opts$) > 0 THEN
IF CAP(opts[0]) = 'S' THEN
caseSens := TRUE
ELSIF CAP(opts[0]) = 'I' THEN
caseSens := FALSE
END
END;
Search(FALSE, caseSens, lang)
END SearchInDocuLang;
PROCEDURE SelectCaseSens* (pat: ARRAY OF CHAR);
BEGIN
TextCmds.find.find := pat$;
TextCmds.find.ignoreCase := FALSE;
Dialog.Update(TextCmds.find);
TextCmds.FindFirst("")
END SelectCaseSens;
PROCEDURE SelectCaseInSens* (pat: ARRAY OF CHAR);
VAR res: INTEGER; cmd: Dialog.String;
BEGIN
TextCmds.find.find := pat$;
TextCmds.find.ignoreCase := TRUE;
Dialog.Update(TextCmds.find);
Dialog.MapString(openFindCmdKey, cmd);
Dialog.Call(cmd, openFindCmdNotFoundKey, res);
TextCmds.FindFirst("")
END SelectCaseInSens;
PROCEDURE InitKey;
VAR i: INTEGER;
BEGIN
i := 0; WHILE i < 256 DO key[i] := SHORT(i); INC(i) END;
i := ORD("a"); WHILE i <= ORD("z") DO key[i] := ORD(CAP(CHR(i))); INC(i) END;
i := 192; WHILE i <= 255 DO key[i] := ORD(CAP(CHR(i))); INC(i) END
END InitKey;
PROCEDURE NextChar (r: TextModels.Reader): CHAR;
VAR ch: CHAR;
BEGIN
REPEAT r.ReadChar(ch) UNTIL (ch > " ") OR r.eot;
RETURN ch
END NextChar;
PROCEDURE CompTexts (ta, tb: TextModels.Model; VAR sa, sb, ea, eb: INTEGER);
VAR da, db, d, i, j, p: INTEGER; t: LONGINT; ra, rb: TextModels.Reader;
cha, chb: CHAR; s: ARRAY N OF CHAR;
BEGIN
ra := ta.NewReader(NIL); ra.SetPos(ea);
rb := tb.NewReader(NIL); rb.SetPos(eb);
REPEAT
cha := NextChar(ra); chb := NextChar(rb)
UNTIL (cha # chb) OR ra.eot OR rb.eot;
IF ra.eot THEN sa := ra.Pos() ELSE sa := ra.Pos() - 1 END;
IF rb.eot THEN sb := rb.Pos() ELSE sb := rb.Pos() - 1 END;
t := Kernel.Time() + T * Kernel.timeResolution;
da := sa + 1; db := sb + 1; d := 1; j := 0;
REPEAT
ea := da;
IF ea < ta.Length() THEN
ra.SetPos(ea); s[0] := NextChar(ra);
da := ra.Pos(); i := 1;
WHILE i < N DO s[i] := NextChar(ra); INC(i) END;
i := 0; rb.SetPos(sb);
REPEAT
eb := rb.Pos(); chb := NextChar(rb);
IF chb = s[0] THEN
p := rb.Pos(); j := 0;
WHILE (j < N) & (chb = s[j]) DO chb := NextChar(rb); INC(j) END;
rb.SetPos(p)
END;
INC(i)
UNTIL (j = N) OR (i = d) OR rb.eot
END;
INC(d);
IF j < N THEN
eb := db;
IF eb < tb.Length() THEN
rb.SetPos(eb); s[0] := NextChar(rb);
db := rb.Pos(); i := 1;
WHILE i < N DO s[i] := NextChar(rb); INC(i) END;
i := 0; ra.SetPos(sa);
REPEAT
ea := ra.Pos(); cha := NextChar(ra);
IF cha = s[0] THEN
p := ra.Pos(); j := 0;
WHILE (j < N) & (cha = s[j]) DO cha := NextChar(ra); INC(j) END;
ra.SetPos(p)
END;
INC(i)
UNTIL (j = N) OR (i = d) OR ra.eot
END
END
UNTIL (j = N) OR (ea >= ta.Length()) & (eb >= tb.Length()) OR (Kernel.Time() > t);
IF j < N THEN ea := ta.Length(); eb := tb.Length() END
END CompTexts;
PROCEDURE Compare*;
VAR wa, wb: Windows.Window; va, vb: Views.View; ca, cb: Containers.Controller; sa, sb, ea, eb: INTEGER;
BEGIN
wa := Windows.dir.First();
IF wa # NIL THEN
wb := Windows.dir.Next(wa);
IF wb # NIL THEN
va := wa.doc.ThisView();
WITH va: TextViews.View DO
vb := wb.doc.ThisView();
WITH vb: TextViews.View DO
ca := va.ThisController();
WITH ca: TextControllers.Controller DO
cb := vb.ThisController();
WITH cb: TextControllers.Controller DO
ca.GetSelection(sa, ea);
IF (* ea = -1 *) sa = ea THEN ea := MAX(0, ca.CaretPos()) END;
cb.GetSelection(sb, eb);
IF (* eb = -1 *) sb = eb THEN eb := MAX(0, cb.CaretPos()) END;
CompTexts(va.ThisModel(), vb.ThisModel(), sa, sb, ea, eb);
IF ea > sa THEN ca.SetSelection(sa, ea) ELSE ca.SetCaret(sa) END;
IF eb > sb THEN cb.SetSelection(sb, eb) ELSE cb.SetCaret(sb) END;
va.ShowRangeIn(Views.ThisFrame(wa.frame, va), sa, ea);
vb.ShowRangeIn(Views.ThisFrame(wb.frame, vb), sb, eb)
END
END
ELSE
END
ELSE
END
END
END
END Compare;
BEGIN
InitKey
END DevSearch.
| Dev/Mod/Search.odc |
MODULE DevSelectors;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Ports, Stores, Models, Views, Controllers, Fonts, Properties, TextModels, TextViews, TextSetters;
CONST
left* = 1; middle* = 2; right* = 3;
minVersion = 0; currentVersion = 0;
changeSelectorsKey = "#Dev:Change Selectors";
TYPE
Selector* = POINTER TO RECORD (Views.View)
position-: INTEGER; (* left, middle, right *)
leftHidden: TextModels.Model; (* valid iff (position = left) *)
rightHidden: TextModels.Model (* valid iff (position = left) *)
END;
Directory* = POINTER TO ABSTRACT RECORD END;
StdDirectory = POINTER TO RECORD (Directory) END;
VAR
dir-, stdDir-: Directory;
PROCEDURE (d: Directory) New* (position: INTEGER): Selector, NEW, ABSTRACT;
PROCEDURE GetFirst (selector: Selector; OUT first: Selector; OUT pos: INTEGER);
VAR c: Models.Context; rd: TextModels.Reader; v: Views.View; nest: INTEGER;
BEGIN
c := selector.context; first := NIL; pos := 0;
WITH c: TextModels.Context DO
IF selector.position = left THEN
first := selector
ELSE
rd := c.ThisModel().NewReader(NIL); rd.SetPos(c.Pos());
nest := 1; pos := 1; rd.ReadPrevView(v);
WHILE (v # NIL) & (nest > 0) DO
WITH v: Selector DO
IF v.position = left THEN DEC(nest);
IF nest = 0 THEN first := v END
ELSIF v.position = right THEN INC(nest)
ELSIF nest = 1 THEN INC(pos)
END
ELSE
END;
rd.ReadPrevView(v)
END
END
ELSE (* selector not embedded in a text *)
END;
ASSERT((first = NIL) OR (first.position = left), 100)
END GetFirst;
PROCEDURE GetNext (rd: TextModels.Reader; OUT next: Selector);
VAR nest: INTEGER; v: Views.View;
BEGIN
nest := 1; next := NIL; rd.ReadView(v);
WHILE v # NIL DO
WITH v: Selector DO
IF v.position = left THEN INC(nest)
ELSIF nest = 1 THEN next := v; RETURN
ELSIF v.position = right THEN DEC(nest)
END
ELSE
END;
rd.ReadView(v)
END
END GetNext;
PROCEDURE CalcSize (f: Selector; OUT w, h: INTEGER);
VAR c: Models.Context; a: TextModels.Attributes; font: Fonts.Font; asc, dsc, fw: INTEGER;
BEGIN
c := f.context;
IF (c # NIL) & (c IS TextModels.Context) THEN
a := c(TextModels.Context).Attr();
font := a.font
ELSE font := Fonts.dir.Default();
END;
font.GetBounds(asc, dsc, fw);
h := asc + dsc; w := 3 * h DIV 4
END CalcSize;
PROCEDURE GetSection (first: Selector; rd: TextModels.Reader; n: INTEGER; OUT name: ARRAY OF CHAR);
VAR i, p0, p1: INTEGER; ch: CHAR; sel: Selector;
BEGIN
sel := first;
IF first.leftHidden.Length() > 0 THEN
rd := first.leftHidden.NewReader(rd); rd.SetPos(0);
REPEAT p0 := rd.Pos(); GetNext(rd, sel); DEC(n) UNTIL (n < 0) OR (sel = NIL);
IF sel = NIL THEN INC(n) END;
p1 := rd.Pos() - 1
END;
IF n >= 0 THEN
rd := first.context(TextModels.Context).ThisModel().NewReader(rd);
rd.SetPos(first.context(TextModels.Context).Pos() + 1);
REPEAT p0 := rd.Pos(); GetNext(rd, sel); DEC(n) UNTIL (n < 0) OR (sel = NIL) OR (sel.position = right);
p1 := rd.Pos() - 1
END;
IF (n >= 0) & (first.rightHidden.Length() > 0) THEN
rd := first.rightHidden.NewReader(rd); rd.SetPos(1);
REPEAT p0 := rd.Pos(); GetNext(rd, sel); DEC(n) UNTIL (n < 0) OR (sel = NIL);
p1 := rd.Pos() - 1;
IF sel = NIL THEN p1 := first.rightHidden.Length() END
END;
IF n < 0 THEN
rd.SetPos(p0); rd.ReadChar(ch); i := 0;
WHILE (ch <= " ") & (rd.Pos() <= p1) DO rd.ReadChar(ch) END;
WHILE (i < LEN(name) - 1) & (rd.Pos() <= p1) & (ch # 0X) DO
IF ch >= " " THEN name[i] := ch; INC(i) END;
rd.ReadChar(ch)
END;
WHILE (i > 0) & (name[i - 1] = " ") DO DEC(i) END;
name[i] := 0X
ELSE
name := 7FX + ""
END
END GetSection;
PROCEDURE ChangeSelector (first: Selector; rd: TextModels.Reader; selection: INTEGER);
VAR pos, p0, len, s: INTEGER; text: TextModels.Model; sel: Selector;
BEGIN
text := rd.Base();
pos := first.context(TextModels.Context).Pos() + 1;
(* expand *)
rd.SetPos(pos);
REPEAT GetNext(rd, sel) UNTIL (sel = NIL) OR (sel.position = right);
IF sel # NIL THEN
len := first.rightHidden.Length();
IF len > 0 THEN text.Insert(rd.Pos() - 1, first.rightHidden, 0, len) END;
len := first.leftHidden.Length();
IF len > 0 THEN text.Insert(pos, first.leftHidden, 0, len) END;
IF selection # 0 THEN (* collapse *)
rd.SetPos(pos); s := 0;
REPEAT GetNext(rd, sel); INC(s) UNTIL (s = selection) OR (sel = NIL) OR (sel.position = right);
IF (sel # NIL) & (sel.position = middle) THEN
first.leftHidden.Insert(0, text, pos, rd.Pos());
rd.SetPos(pos); GetNext(rd, sel);
p0 := rd.Pos() - 1;
WHILE (sel # NIL) & (sel.position # right) DO GetNext(rd, sel) END;
IF sel # NIL THEN
first.rightHidden.Insert(0, text, p0, rd.Pos() - 1)
END
END
END
END;
rd.SetPos(pos)
END ChangeSelector;
PROCEDURE ChangeThis (
text: TextModels.Model; rd, rd1: TextModels.Reader; title: ARRAY OF CHAR; selection: INTEGER
);
VAR v: Views.View; str: ARRAY 256 OF CHAR;
BEGIN
rd := text.NewReader(rd);
rd.SetPos(0); rd.ReadView(v);
WHILE v # NIL DO
WITH v: Selector DO
IF v.position = left THEN
GetSection(v, rd1, 0, str);
IF str = title THEN
ChangeSelector(v, rd, selection)
END;
IF v.leftHidden.Length() > 0 THEN ChangeThis(v.leftHidden, NIL, rd1, title, selection) END;
IF v.rightHidden.Length() > 0 THEN ChangeThis(v.rightHidden, NIL, rd1, title, selection) END
END
ELSE
END;
rd.ReadView(v)
END
END ChangeThis;
PROCEDURE Change* (text: TextModels.Model; title: ARRAY OF CHAR; selection: INTEGER);
VAR rd, rd1: TextModels.Reader; script: Stores.Operation;
BEGIN
rd := text.NewReader(NIL);
rd1 := text.NewReader(NIL);
Models.BeginModification(Models.clean, text);
Models.BeginScript(text, changeSelectorsKey, script);
ChangeThis(text, rd, rd1, title, selection);
Models.EndScript(text, script);
Models.EndModification(Models.clean, text);
END Change;
PROCEDURE ChangeTo* (text: TextModels.Model; title, entry: ARRAY OF CHAR);
VAR rd, rd1: TextModels.Reader; str: ARRAY 256 OF CHAR; v: Views.View; sel: INTEGER;
BEGIN
rd := text.NewReader(NIL);
rd1 := text.NewReader(NIL);
rd.SetPos(0); rd.ReadView(v);
WHILE v # NIL DO
WITH v: Selector DO
IF v.position = left THEN
GetSection(v, rd1, 0, str);
IF title = str THEN
sel := 0;
REPEAT
INC(sel); GetSection(v, rd1, sel, str)
UNTIL (str[0] = 7FX) OR (str = entry);
IF str[0] # 7FX THEN
Change(text, title, sel);
RETURN
END
END
END
ELSE
END;
rd.ReadView(v)
END
END ChangeTo;
PROCEDURE (selector: Selector) HandlePropMsg- (VAR msg: Properties.Message);
VAR c: Models.Context; a: TextModels.Attributes; asc, w: INTEGER;
BEGIN
WITH msg: Properties.SizePref DO CalcSize(selector, msg.w, msg.h)
| msg: Properties.ResizePref DO msg.fixed := TRUE;
| msg: Properties.FocusPref DO msg.hotFocus := TRUE;
| msg: TextSetters.Pref DO c := selector.context;
IF (c # NIL) & (c IS TextModels.Context) THEN
a := c(TextModels.Context).Attr();
a.font.GetBounds(asc, msg.dsc, w)
END
ELSE (*selector.HandlePropMsg^(msg);*)
END
END HandlePropMsg;
PROCEDURE Track (selector: Selector; f: Views.Frame; x, y: INTEGER; buttons: SET; VAR hit: BOOLEAN);
VAR a: TextModels.Attributes; font: Fonts.Font; c: Models.Context;
w, h, asc, dsc, fw: INTEGER; isDown, in, in0: BOOLEAN; modifiers: SET;
BEGIN
c := selector.context; hit := FALSE;
WITH c: TextModels.Context DO
a := c.Attr(); font := a.font;
c.GetSize(w, h); in0 := FALSE;
in := (0 <= x) & (x < w) & (0 <= y) & (y < h);
REPEAT
IF in # in0 THEN
f.MarkRect(0, 0, w, h, Ports.fill, Ports.hilite, FALSE); in0 := in
END;
f.Input(x, y, modifiers, isDown);
in := (0 <= x) & (x < w) & (0 <= y) & (y < h)
UNTIL ~isDown;
IF in0 THEN hit := TRUE;
font.GetBounds(asc, dsc, fw);
f.MarkRect(0, 0, w, asc + dsc, Ports.fill, Ports.hilite, FALSE);
END
ELSE
END
END Track;
PROCEDURE (selector: Selector) HandleCtrlMsg* (
f: Views.Frame; VAR msg: Views.CtrlMessage; VAR focus: Views.View
);
VAR hit: BOOLEAN; sel, pos: INTEGER; text: TextModels.Model; title: ARRAY 256 OF CHAR; first: Selector;
BEGIN
WITH msg: Controllers.TrackMsg DO
IF selector.context IS TextModels.Context THEN
Track(selector, f, msg.x, msg.y, msg.modifiers, hit);
IF hit THEN
text := selector.context(TextModels.Context).ThisModel();
GetFirst(selector, first, pos);
IF first # NIL THEN
GetSection(first, NIL, 0, title);
IF selector.position = middle THEN sel := pos ELSE sel := 0 END;
Change(text, title, sel);
text := selector.context(TextModels.Context).ThisModel();
IF TextViews.FocusText() = text THEN
pos := selector.context(TextModels.Context).Pos();
TextViews.ShowRange(text, pos, pos+1, TRUE)
END
END
END
END
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.refCursor;
ELSE
END
END HandleCtrlMsg;
PROCEDURE (selector: Selector) Restore* (f: Views.Frame; l, t, r, b: INTEGER);
VAR w, h, d: INTEGER;
BEGIN
selector.context.GetSize(w, h);
(*
GetFirst(selector, first, pos);
*)
w := w - w MOD f.unit; d := 2 * f.dot;
f.DrawLine(d, d, w - d, d, d, Ports.grey25);
f.DrawLine(d, h - d, w - d, h - d, d, Ports.grey25);
IF selector.position # right THEN f.DrawLine(d, d, d, h - d, d, Ports.grey25) END;
IF selector.position # left THEN f.DrawLine(w - d, d, w - d, h - d, d, Ports.grey25) END
END Restore;
PROCEDURE (selector: Selector) CopyFromSimpleView- (source: Views.View);
BEGIN
(* selector.CopyFrom^(source); *)
WITH source: Selector DO
selector.position := source.position;
IF source.leftHidden # NIL THEN
selector.leftHidden := TextModels.CloneOf(source.leftHidden);
selector.leftHidden.InsertCopy(0, source.leftHidden, 0, source.leftHidden.Length())
END;
IF source.rightHidden # NIL THEN
selector.rightHidden := TextModels.CloneOf(source.rightHidden);
selector.rightHidden.InsertCopy(0, source.rightHidden, 0, source.rightHidden.Length())
END
END
END CopyFromSimpleView;
PROCEDURE (selector: Selector) InitContext* (context: Models.Context);
BEGIN
selector.InitContext^(context);
IF selector.position = left THEN
WITH context: TextModels.Context DO
IF selector.leftHidden = NIL THEN
selector.leftHidden := TextModels.CloneOf(context.ThisModel());
Stores.Join(selector, selector.leftHidden);
END;
IF selector.rightHidden = NIL THEN
selector.rightHidden := TextModels.CloneOf(context.ThisModel());
Stores.Join(selector, selector.rightHidden)
END
ELSE
END
END
END InitContext;
PROCEDURE (selector: Selector) Internalize- (VAR rd: Stores.Reader);
VAR version: INTEGER; store: Stores.Store;
BEGIN
selector.Internalize^(rd);
IF rd.cancelled THEN RETURN END;
rd.ReadVersion(minVersion, currentVersion, version);
IF rd.cancelled THEN RETURN END;
rd.ReadInt(selector.position);
rd.ReadStore(store);
IF store # NIL THEN selector.leftHidden := store(TextModels.Model)
ELSE selector.leftHidden := NIL
END;
rd.ReadStore(store);
IF store # NIL THEN selector.rightHidden := store(TextModels.Model)
ELSE selector.rightHidden := NIL
END
END Internalize;
PROCEDURE (selector: Selector) Externalize- (VAR wr: Stores.Writer);
BEGIN
selector.Externalize^(wr);
wr.WriteVersion(currentVersion);
wr.WriteInt(selector.position);
wr.WriteStore(selector.leftHidden);
wr.WriteStore(selector.rightHidden)
END Externalize;
PROCEDURE (d: StdDirectory) New (position: INTEGER): Selector;
VAR selector: Selector;
BEGIN
NEW(selector);
selector.position := position;
RETURN selector
END New;
PROCEDURE SetDir* (d: Directory);
BEGIN
ASSERT(d # NIL, 20);
dir := d
END SetDir;
PROCEDURE DepositLeft*;
BEGIN
Views.Deposit(dir.New(left))
END DepositLeft;
PROCEDURE DepositMiddle*;
BEGIN
Views.Deposit(dir.New(middle))
END DepositMiddle;
PROCEDURE DepositRight*;
BEGIN
Views.Deposit(dir.New(right))
END DepositRight;
PROCEDURE InitMod;
VAR d: StdDirectory;
BEGIN
NEW(d); dir := d; stdDir := d;
END InitMod;
BEGIN
InitMod
END DevSelectors.
"Insert Left" "*F5" "DevSelectors.DepositLeft; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Insert Middle" "*F6" "DevSelectors.DepositMiddle; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Insert Right" "*F7" "DevSelectors.DepositRight; StdCmds.PasteView" "StdCmds.PasteViewGuard"
| Dev/Mod/Selectors.odc |
MODULE DevSubTool; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20050626, Fyodor Tkachov, russification edited
- 20050519, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Files, Fonts, Views, TextModels, TextMappers, TextViews, StdCmds, StdLog, DevCommanders,
i21sysCharacters;
CONST
textCmds* = 0; formCmds* = 1; otherCmds = 2;
noModelView* = 3; modelView* = 4; complexView* = 5;
wrapper = 6; specialContainer = 7; generalContainer = 8;
VAR
create*: RECORD
subsystem*: ARRAY 16 OF CHAR;
kind*: INTEGER;
Create*: PROCEDURE
END;
PROCEDURE TranslateText (t: TextModels.Model; s: ARRAY OF CHAR);
VAR r: TextModels.Reader; w: TextModels.Writer; from, to: INTEGER; i: INTEGER; ch: CHAR;
BEGIN
r := t.NewReader(NIL); w := t.NewWriter(NIL);
r.ReadChar(ch);
WHILE ~r.eot DO
WHILE ~r.eot & ~(Fonts.strikeout IN r.attr.font.style) DO
r.ReadChar(ch);
END;
IF ~r.eot THEN
from := r.Pos() - 1;
WHILE ~r.eot & (Fonts.strikeout IN r.attr.font.style) DO
r.ReadChar(ch);
END;
IF ~r.eot THEN
to := r.Pos() - 1;
t.Delete(from, to);
w.SetPos(from);
w.SetAttr(TextModels.NewStyle(r.attr, r.attr.font.style - {Fonts.strikeout}));
i := 0; ch := s[0]; WHILE ch # 0X DO w.WriteChar(ch); INC(i); INC(from); ch := s[i] END;
r.SetPos(from); r.ReadChar(ch);
END
END
END
END TranslateText;
PROCEDURE TranslateFile (floc: Files.Locator; fname: Files.Name; tloc: Files.Locator; tname: Files.Name;
string: ARRAY OF CHAR; VAR res: INTEGER);
VAR v: Views.View;
BEGIN
v := Views.OldView(floc, fname);
IF v # NIL THEN
IF v IS TextViews.View THEN
TranslateText(v(TextViews.View).ThisModel(), string);
tloc.res := 76; (* don't ask whether directory should be created *)
Views.RegisterView(v, tloc, tname);
res := tloc.res
ELSE res := 101
END
ELSE res := 100
END
END TranslateFile;
PROCEDURE TranslateSubsystem (kind: INTEGER; string: ARRAY OF CHAR);
VAR loc, new: Files.Locator; t: TextModels.Model; res: INTEGER; f: TextMappers.Formatter;
v: Views.View;
PROCEDURE Message (sub, dir, old: ARRAY OF CHAR);
BEGIN
IF res = 0 THEN
f.WriteString(sub); f.WriteString(dir); f.WriteLn
ELSE
StdLog.String(old); StdLog.Msg("#Dev:CannotTranslate"); StdLog.Ln
END
END Message;
BEGIN
t := TextModels.dir.New(); f.ConnectTo(t);
loc := Files.dir.This("Dev"); loc := loc.This("Rsrc"); loc := loc.This("New");
new := Files.dir.This(string); new := new.This("Mod");
IF kind = textCmds THEN
TranslateFile(loc, "Cmds0", new, "Cmds", string, res);
Message(string, "Cmds", "Cmds0")
ELSIF kind = formCmds THEN
TranslateFile(loc, "Cmds1", new, "Cmds", string, res);
Message(string, "Cmds", "Cmds1")
ELSIF kind = otherCmds THEN
TranslateFile(loc, "Cmds2", new, "Cmds", string, res);
Message(string, "Cmds", "Cmds2")
ELSIF kind = noModelView THEN
TranslateFile(loc, "Views3", new, "Views", string, res);
Message(string, "Views", "Views3");
f.WriteLn;
f.WriteView(DevCommanders.dir.New());
f.WriteString(' "'); f.WriteString(string); f.WriteString('Views.Deposit; StdCmds.Open"'); f.WriteLn
ELSIF kind = modelView THEN
TranslateFile(loc, "Views4", new, "Views", string, res);
Message(string, "Views", "Views4");
f.WriteLn;
f.WriteView(DevCommanders.dir.New());
f.WriteString(' "'); f.WriteString(string); f.WriteString('Views.Deposit; StdCmds.Open"'); f.WriteLn
ELSIF kind = complexView THEN
TranslateFile(loc, "Models5", new, "Models", string, res);
Message(string, "Models", "Models5");
TranslateFile(loc, "Views5", new, "Views", string, res);
Message(string, "Views", "Views5");
TranslateFile(loc, "Cmds5", new, "Cmds", string, res);
Message(string, "Cmds", "Cmds5");
f.WriteLn;
f.WriteView(DevCommanders.dir.New());
f.WriteString(' "'); f.WriteString(string); f.WriteString('Views.Deposit; StdCmds.Open"'); f.WriteLn
ELSIF kind = wrapper THEN
TranslateFile(loc, "Views6", new, "Views", string, res);
Message(string, "Views", "Views6");
f.WriteLn;
f.WriteView(DevCommanders.dir.New());
f.WriteString(' "'); f.WriteString(string); f.WriteString('Views.Deposit; StdCmds.Open"'); f.WriteLn
ELSIF kind = specialContainer THEN
TranslateFile(loc, "Views7", new, "Views", string, res);
Message(string, "Views", "Views7");
f.WriteLn;
f.WriteView(DevCommanders.dir.New());
f.WriteString(' "'); f.WriteString(string); f.WriteString('Views.Deposit; StdCmds.Open"'); f.WriteLn
ELSIF kind = generalContainer THEN
TranslateFile(loc, "Models8", new, "Models", string, res);
Message(string, "Models", "Models8");
TranslateFile(loc, "Views8", new, "Views", string, res);
Message(string, "Views", "Views8");
TranslateFile(loc, "Controllers8", new, "Controllers", string, res);
Message(string, "Controllers", "Controllers8");
TranslateFile(loc, "Cmds8", new, "Cmds", string, res);
Message(string, "Cmds", "Cmds8");
f.WriteLn;
f.WriteView(DevCommanders.dir.New());
f.WriteString(' "'); f.WriteString(string); f.WriteString('Views.Deposit; StdCmds.Open"'); f.WriteLn
ELSE HALT(20)
END;
v := TextViews.dir.New(t);
Views.Open(v, new, "List", NIL);
IF t.Length() > 0 THEN Views.RegisterView(v, new, "List") END
END TranslateSubsystem;
PROCEDURE Len (s: ARRAY OF CHAR): INTEGER;
VAR n: INTEGER;
BEGIN
n := 0; WHILE s[n] # 0X DO INC(n) END;
RETURN n
END Len;
PROCEDURE SyntaxOK (s: ARRAY OF CHAR): BOOLEAN;
VAR i: INTEGER; ch: CHAR;
BEGIN
i := 0; ch := s[0];
(* WHILE (ch >= "A") & (ch <= "Z") DO INC(i); ch := s[i] END;
WHILE (i # 0) & (ch >= "a") & (ch <= "z") OR (ch >= "0") & (ch <= "9") DO INC(i); ch := s[i] END;*)
WHILE i21sysCharacters.IsCap( ch ) DO INC(i); ch := s[i] END;
WHILE (i # 0) & i21sysCharacters.IsIdentChar( ch ) DO INC(i); ch := s[i] END;
RETURN (i # 0) & (ch = 0X)
END SyntaxOK;
PROCEDURE Create;
BEGIN
IF Len(create.subsystem) >= 3 THEN
IF (create.kind >= textCmds) & (create.kind <= generalContainer) THEN
IF SyntaxOK(create.subsystem) THEN
StdCmds.CloseDialog;
TranslateSubsystem(create.kind, create.subsystem);
create.subsystem := ""
ELSE StdLog.Msg("#Dev:IllegalSyntax")
END
ELSE StdLog.Msg("#Dev:IllegalKind")
END
ELSE StdLog.Msg("#Dev:PrefixTooShort")
END
END Create;
BEGIN
create.Create := Create; create.kind := textCmds
END DevSubTool. | Dev/Mod/SubTool.odc |
MODULE DevTypeLibs;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
(* Code that is only reached with wrapper in options. Code that is not reached with wrapper in options. *)
IMPORT COM, WinOle, WinOleAut, TextModels, TextMappers;
CONST
(* options *)
browse = 1; interface = 2; wrapper = 3;
inAuto = 12; inAll = 13;
outAuto = 14; outAll = 15;
source = 31;
(* kind *)
value = 1; var = 2; varin = 3; varout = 4;
(* conv type *)
ret = 1; get = 2; par = 3; refpar = 4;
(* pseudo types *)
enumerator = -1; record = -2; union = -3; module = -4; class = -5; ptrVoid = -6;
VAR
modules: ARRAY 16, 64 OF CHAR;
noMod: INTEGER;
retName: ARRAY 156 OF CHAR;
PROCEDURE WriteBSTR (s: WinOle.BSTR; VAR out: TextMappers.Formatter);
BEGIN
IF s # NIL THEN out.WriteString(s$) END
END WriteBSTR;
PROCEDURE WriteGuid (VAR guid: COM.GUID; VAR out: TextMappers.Formatter);
BEGIN
out.WriteChar("{");
out.WriteIntForm((guid[2] MOD 256 + 256 * guid[3]) MOD 65536, TextMappers.hexadecimal, 4, "0", FALSE);
out.WriteIntForm((guid[0] MOD 256 + 256 * guid[1]) MOD 65536, TextMappers.hexadecimal, 4, "0", FALSE);
out.WriteChar("-");
out.WriteIntForm((guid[4] MOD 256 + 256 * guid[5]) MOD 65536, TextMappers.hexadecimal, 4, "0", FALSE);
out.WriteChar("-");
out.WriteIntForm((guid[6] MOD 256 + 256 * guid[7]) MOD 65536, TextMappers.hexadecimal, 4, "0", FALSE);
out.WriteChar("-");
out.WriteIntForm((guid[8]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE);
out.WriteIntForm((guid[9]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE);
out.WriteChar("-");
out.WriteIntForm((guid[10]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE);
out.WriteIntForm((guid[11]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE);
out.WriteIntForm((guid[12]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE);
out.WriteIntForm((guid[13]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE);
out.WriteIntForm((guid[14]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE);
out.WriteIntForm((guid[15]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE);
out.WriteChar("}")
END WriteGuid;
PROCEDURE^ GetInfoType (tinfo: WinOleAut.ITypeInfo; OUT type: INTEGER; OUT info: WinOleAut.ITypeInfo);
PROCEDURE GetDescType (IN desc: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo;
OUT type: INTEGER; OUT info: WinOleAut.ITypeInfo);
VAR res: COM.RESULT; t: INTEGER; i: WinOleAut.ITypeInfo;
BEGIN
type := desc.vt;
IF type = WinOle.VT_USERDEFINED THEN
res := tinfo.GetRefTypeInfo(desc.u.hreftype, i);
GetInfoType(i, type, info)
ELSIF type = WinOle.VT_PTR THEN
GetDescType(desc.u.lptdesc, tinfo, t, i);
IF (i # NIL) & ((t = WinOle.VT_DISPATCH) OR (t = WinOle.VT_UNKNOWN))
OR (t = WinOle.VT_VARIANT) OR (t = WinOle.VT_SAFEARRAY) THEN type := t; info := i
ELSIF t = WinOle.VT_VOID THEN type := ptrVoid
END
END
END GetDescType;
PROCEDURE GetInfoType (tinfo: WinOleAut.ITypeInfo; OUT type: INTEGER; OUT info: WinOleAut.ITypeInfo);
VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; i: INTEGER; flags: SET;
ti: WinOleAut.ITypeInfo; t: WinOleAut.HREFTYPE;
BEGIN
info := tinfo; res := tinfo.GetTypeAttr(attr);
CASE attr.typekind OF
| WinOleAut.TKIND_ENUM: type := WinOle.VT_I4
| WinOleAut.TKIND_RECORD: type := record
| WinOleAut.TKIND_UNION: type := union
| WinOleAut.TKIND_MODULE: type := module
| WinOleAut.TKIND_INTERFACE: type := WinOle.VT_UNKNOWN
| WinOleAut.TKIND_DISPATCH: type := WinOle.VT_DISPATCH
| WinOleAut.TKIND_ALIAS: GetDescType(attr.tdescAlias, tinfo, type, info)
| WinOleAut.TKIND_COCLASS:
type := class; i := 0;
WHILE (i < attr.cImplTypes) & (type = class) DO
res := tinfo.GetImplTypeFlags(i, flags);
IF (WinOleAut.IMPLTYPEFLAG_FDEFAULT * flags # {} )
& (WinOleAut.IMPLTYPEFLAG_FSOURCE * flags = {} ) THEN
res := tinfo.GetRefTypeOfImplType(i, t); ASSERT(res >= 0, 101);
res := tinfo.GetRefTypeInfo(t, ti); ASSERT(res >= 0, 102);
GetInfoType(ti, type, info)
END;
INC(i)
END
END;
tinfo.ReleaseTypeAttr(attr)
END GetInfoType;
PROCEDURE WriteVariant (VAR v: WinOleAut.VARIANT; VAR out: TextMappers.Formatter);
BEGIN
IF ODD(v.vt DIV WinOle.VT_ARRAY) THEN
out.WriteSString("array ");
(* to be completed *)
ELSIF ODD(v.vt DIV WinOle.VT_BYREF) THEN
out.WriteSString("ref ");
CASE v.vt MOD 4096 OF
| WinOle.VT_UI1: out.WriteInt(ORD(v.u.pbVal[0]))
| WinOle.VT_I2: out.WriteInt(v.u.piVal[0])
| WinOle.VT_I4:
IF v.u.plVal[0] = 80000000H THEN out.WriteString("80000000H")
ELSE out.WriteInt(v.u.plVal[0])
END
| WinOle.VT_R4: out.WriteReal(v.u.pfltVal[0])
| WinOle.VT_R8: out.WriteReal(v.u.pdblVal[0])
| WinOle.VT_BOOL:
IF v.u.pboolVal[0] = 0 THEN out.WriteSString("FALSE") ELSE out.WriteSString("TRUE") END
| WinOle.VT_CY: out.WriteReal(v.u.pcyVal[0] / 10000)
| WinOle.VT_DATE: out.WriteReal(v.u.pdate[0])
| WinOle.VT_BSTR: out.WriteChar('"'); WriteBSTR(v.u.pbstrVal[0], out); out.WriteChar('"')
| WinOle.VT_ERROR: out.WriteIntForm(v.u.pscode[0], TextMappers.hexadecimal, 9, "0", TRUE)
| WinOle.VT_DISPATCH: out.WriteSString("IDispatch")
| WinOle.VT_UNKNOWN: out.WriteSString("IUnknown")
ELSE out.WriteSString("undefined ("); out.WriteInt(v.vt MOD 4096); out.WriteChar(")")
END
ELSE
CASE v.vt MOD 4096 OF
| WinOle.VT_NULL: out.WriteSString("NIL")
| WinOle.VT_UI1: out.WriteInt(ORD(v.u.bVal))
| WinOle.VT_I2: out.WriteInt(v.u.iVal)
| WinOle.VT_I4:
IF v.u.lVal = 80000000H THEN out.WriteString("80000000H")
ELSE out.WriteInt(v.u.lVal)
END
| WinOle.VT_R4: out.WriteReal(v.u.fltVal)
| WinOle.VT_R8: out.WriteReal(v.u.dblVal)
| WinOle.VT_BOOL:
IF v.u.boolVal = 0 THEN out.WriteSString("FALSE") ELSE out.WriteSString("TRUE") END
| WinOle.VT_CY: out.WriteReal(v.u.cyVal / 10000)
| WinOle.VT_DATE: out.WriteReal(v.u.date)
| WinOle.VT_BSTR: out.WriteChar('"'); WriteBSTR(v.u.bstrVal, out); out.WriteChar('"')
| WinOle.VT_ERROR: out.WriteIntForm(v.u.scode, TextMappers.hexadecimal, 9, "0", TRUE)
| WinOle.VT_DISPATCH: out.WriteSString("IDispatch")
| WinOle.VT_UNKNOWN: out.WriteSString("IUnknown")
ELSE out.WriteSString("undefined ("); out.WriteInt(v.vt MOD 4096); out.WriteChar(")")
END
END
END WriteVariant;
PROCEDURE WriteTypeName (
tinfo: WinOleAut.ITypeInfo; convert, isThis: BOOLEAN; VAR out: TextMappers.Formatter
);
VAR ti: WinOleAut.ITypeInfo; lib: WinOleAut.ITypeLib; i, n, vt: INTEGER;
res: COM.RESULT; s: WinOle.BSTR; mod, name: ARRAY 64 OF CHAR; flags: SET;
BEGIN
res := tinfo.GetContainingTypeLib(lib, i); ASSERT(res >= 0, 102);
res := lib.GetDocumentation(-1, s, NIL, NIL, NIL); ASSERT(res >= 0, 105);
mod := s$; WinOleAut.SysFreeString(s);
res := tinfo.GetDocumentation(-1, s, NIL, NIL, NIL); ASSERT(res >= 0, 106);
(* !!! *)
name := s$; WinOleAut.SysFreeString(s);
IF convert THEN
IF mod = "stdole" THEN
IF name = "IDispatch" THEN mod := "CtlT"; name := "Object"
ELSE mod := "CtlStdType"
END
ELSE
GetInfoType(tinfo, vt, ti);
IF vt = WinOle.VT_UNKNOWN THEN mod := "CtlT"; name := "IUnknown"
ELSE mod := "Ctl" + mod
END
END;
END;
i := 0; WHILE (i < noMod) & (modules[i] # mod) DO INC(i) END;
IF i = noMod THEN modules[i] := mod$; INC(noMod) END;
IF i # 0 THEN out.WriteString(mod); out.WriteChar(".") END;
IF isThis THEN out.WriteString("This") END;
out.WriteString(name)
END WriteTypeName;
PROCEDURE WriteHandleName (
t: WinOleAut.HREFTYPE; tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter
);
VAR res: COM.RESULT; type: WinOleAut.ITypeInfo;
BEGIN
res := tinfo.GetRefTypeInfo(t, type); (* ASSERT(res >= 0, 100); *)
IF res >= 0 THEN
WriteTypeName(type, wrapper IN opts, FALSE, out)
ELSE
out.WriteSString("???("); out.WriteInt(res); out.WriteChar(")")
END
END WriteHandleName;
PROCEDURE WriteType (
VAR t: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter
);
VAR i, vt: INTEGER; ti: WinOleAut.ITypeInfo;
BEGIN
CASE t.vt OF
| WinOle.VT_I2: out.WriteSString("SHORTINT")
| WinOle.VT_I4: out.WriteSString("INTEGER")
| WinOle.VT_R4: out.WriteSString("SHORTREAL")
| WinOle.VT_R8: out.WriteSString("REAL")
| WinOle.VT_CY:
IF wrapper IN opts THEN out.WriteSString("CtlT.OleCy") ELSE out.WriteSString("CURRENCY") END
| WinOle.VT_DATE:
IF wrapper IN opts THEN out.WriteSString("CtlT.OleDate") ELSE out.WriteSString("DATE") END
| WinOle.VT_BSTR:
IF wrapper IN opts THEN out.WriteSString("CtlT.Strg") ELSE out.WriteSString("WinOle.BSTR") END
| WinOle.VT_DISPATCH:
IF wrapper IN opts THEN out.WriteSString("CtlT.Object")
ELSE out.WriteSString("WinOleAut.IDispatch")
END
| WinOle.VT_ERROR: out.WriteSString("CtlT.RESULT")
| WinOle.VT_BOOL:
IF wrapper IN opts THEN out.WriteSString("BOOLEAN")
ELSE out.WriteSString("WinOle.VARIANT_BOOL")
END
| WinOle.VT_VARIANT:
IF wrapper IN opts THEN out.WriteSString("CtlT.Any") ELSE out.WriteSString("WinOleAut.VARIANT") END
| WinOle.VT_UNKNOWN: out.WriteSString("CtlT.IUnknown")
| WinOle.VT_DECIMAL: out.WriteSString("DECIMAL")
| WinOle.VT_I1: out.WriteSString("BYTE")
| WinOle.VT_UI1: out.WriteSString("BYTE")
| WinOle.VT_UI2: out.WriteSString("SHORTINT")
| WinOle.VT_UI4: out.WriteSString("INTEGER")
| WinOle.VT_I8: out.WriteSString("LONGINT")
| WinOle.VT_UI8: out.WriteSString("LONGINT")
| WinOle.VT_INT: out.WriteSString("INTEGER")
| WinOle.VT_UINT: out.WriteSString("INTEGER")
| WinOle.VT_VOID:
IF browse IN opts THEN out.WriteSString("VOID") ELSE out.WriteSString("RECORD END") END
| WinOle.VT_HRESULT: out.WriteSString("CtlT.RESULT")
| WinOle.VT_PTR:
GetDescType(t, tinfo, vt, ti);
IF vt = ptrVoid THEN out.WriteSString("CtlT.PtrVoid")
ELSIF vt # WinOle.VT_PTR THEN WriteType(t.u.lptdesc, tinfo, opts, out)
ELSE out.WriteSString("POINTER TO "); WriteType(t.u.lptdesc^, tinfo, opts, out)
END
| WinOle.VT_SAFEARRAY:
IF wrapper IN opts THEN out.WriteSString("CtlT.Any")
ELSE out.WriteSString("ARRAY [safe] OF "); WriteType(t.u.lptdesc^, tinfo, opts, out)
END
| WinOle.VT_CARRAY: out.WriteSString("ARRAY ");
i := 0;
WHILE i < t.u.lpadesc.cDims DO
out.WriteInt(t.u.lpadesc.rgbounds[i].cElements); out.WriteChar(" "); INC(i)
END;
out.WriteSString("OF "); WriteType(t.u.lpadesc.tdescElem, tinfo, opts, out)
| WinOle.VT_USERDEFINED: WriteHandleName(t.u.hreftype, tinfo, opts, out)
| WinOle.VT_LPSTR:
IF wrapper IN opts THEN out.WriteSString("CtlT.Strg") ELSE out.WriteSString("PtrSTR") END
| WinOle.VT_LPWSTR:
IF wrapper IN opts THEN out.WriteSString("CtlT.Strg") ELSE out.WriteSString("PtrWSTR") END
| enumerator: out.WriteSString("CtlT.Enumerator")
END
END WriteType;
PROCEDURE WriteShortType (VAR t: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo; VAR out: TextMappers.Formatter);
VAR vt: INTEGER; ti: WinOleAut.ITypeInfo; res: COM.RESULT;
BEGIN
GetDescType(t, tinfo, vt, ti);
CASE vt OF
| WinOle.VT_I2: out.WriteSString("SInt")
| WinOle.VT_I4: out.WriteSString("Int")
| WinOle.VT_R4: out.WriteSString("SReal")
| WinOle.VT_R8: out.WriteSString("Real")
| WinOle.VT_CY: out.WriteSString("Cy")
| WinOle.VT_DATE: out.WriteSString("Date")
| WinOle.VT_BSTR: out.WriteSString("Str")
| WinOle.VT_DISPATCH: out.WriteSString("Obj")
| WinOle.VT_ERROR: out.WriteSString("Res")
| WinOle.VT_BOOL: out.WriteSString("Bool")
| WinOle.VT_VARIANT: out.WriteSString("Any")
| WinOle.VT_UNKNOWN: out.WriteSString("Intfce")
| WinOle.VT_DECIMAL: out.WriteSString("Decimal")
| WinOle.VT_I1: out.WriteSString("Byte")
| WinOle.VT_UI1: out.WriteSString("Byte")
| WinOle.VT_UI2: out.WriteSString("SInt")
| WinOle.VT_UI4: out.WriteSString("Int")
| WinOle.VT_I8: out.WriteSString("LInt")
| WinOle.VT_UI8: out.WriteSString("LInt")
| WinOle.VT_INT: out.WriteSString("Int")
| WinOle.VT_UINT: out.WriteSString("Int")
| WinOle.VT_VOID: out.WriteSString("Void")
| WinOle.VT_HRESULT: out.WriteSString("Res")
| WinOle.VT_PTR: out.WriteSString("Pointer")
| WinOle.VT_SAFEARRAY: out.WriteSString("Any"); (* t.u.lptdesc *)
| WinOle.VT_CARRAY: out.WriteSString("Array");
| WinOle.VT_USERDEFINED: HALT(100)
| WinOle.VT_LPSTR: out.WriteSString("Str")
| WinOle.VT_LPWSTR: out.WriteSString("Str")
| enumerator: out.WriteSString("Enum")
| ptrVoid: out.WriteSString("Int")
| record: out.WriteSString("Record")
| union: out.WriteSString("Union")
| module: out.WriteSString("Module")
| class: out.WriteSString("Class")
END
END WriteShortType;
PROCEDURE WriteTypeFlags (flags: SHORTINT; VAR out: TextMappers.Formatter);
BEGIN
IF ODD(flags DIV WinOleAut.TYPEFLAG_FAPPOBJECT) THEN out.WriteSString(", appObject") END;
IF ODD(flags DIV WinOleAut.TYPEFLAG_FCANCREATE) THEN out.WriteSString(", createable") END;
IF ODD(flags DIV WinOleAut.TYPEFLAG_FLICENSED) THEN out.WriteSString(", licensed") END;
IF ODD(flags DIV WinOleAut.TYPEFLAG_FPREDECLID) THEN out.WriteSString(", predeclared") END;
IF ODD(flags DIV WinOleAut.TYPEFLAG_FHIDDEN) THEN out.WriteSString(", hidden") END;
IF ODD(flags DIV WinOleAut.TYPEFLAG_FCONTROL) THEN out.WriteSString(", control") END;
IF ODD(flags DIV WinOleAut.TYPEFLAG_FDUAL) THEN out.WriteSString(", dual") END;
IF ODD(flags DIV WinOleAut.TYPEFLAG_FNONEXTENSIBLE) THEN out.WriteSString(", nonextensible") END;
IF ODD(flags DIV WinOleAut.TYPEFLAG_FOLEAUTOMATION) THEN out.WriteSString(", oleauto") END
END WriteTypeFlags;
PROCEDURE WriteTypeConv (t: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo;
type, n: INTEGER; VAR out: TextMappers.Formatter);
VAR ti: WinOleAut.ITypeInfo; vt: INTEGER;
BEGIN
GetDescType(t, tinfo, vt, ti);
IF (vt = WinOle.VT_DISPATCH) & (ti # NIL) THEN
WriteTypeName(ti, TRUE, TRUE, out);
IF type = ret THEN out.WriteSString("(CtlC.VarAny("); out.WriteString(retName); out.WriteString("))")
ELSIF type = get THEN out.WriteSString("(CtlC.GetAny(this, "); out.WriteInt(n); out.WriteSString("))")
ELSIF type = par THEN out.WriteSString("(CtlC.VarAny(par["); out.WriteInt(n); out.WriteSString("]))")
ELSE (* type = refpar *) out.WriteSString("(CtlC.VarRefAny(par["); out.WriteInt(n); out.WriteSString("])[0])")
END
ELSE
IF type = ret THEN
out.WriteSString("CtlC.Var"); WriteShortType(t, tinfo, out);
out.WriteChar("("); out.WriteString(retName); out.WriteChar(")")
ELSIF type = get THEN
out.WriteSString("CtlC.Get"); WriteShortType(t, tinfo, out);
out.WriteSString("(this, "); out.WriteInt(n); out.WriteChar(")")
ELSIF type = par THEN
out.WriteSString("CtlC.Var"); WriteShortType(t, tinfo, out);
out.WriteSString("(par["); out.WriteInt(n); out.WriteSString("])")
ELSE (* type = refpar *)
out.WriteSString("CtlC.VarRef"); WriteShortType(t, tinfo, out);
out.WriteSString("(par["); out.WriteInt(n); out.WriteSString("])[0]")
END
END
END WriteTypeConv;
PROCEDURE IsSpecial (IN type: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo): BOOLEAN;
(* special handling needed for bool, string, dispatch & variant passed by reference *)
VAR ti: WinOleAut.ITypeInfo; vt: INTEGER;
BEGIN
GetDescType(type, tinfo, vt, ti);
RETURN (vt = WinOle.VT_BOOL) OR (vt = WinOle.VT_BSTR)
OR (vt = WinOle.VT_DISPATCH) OR (vt = WinOle.VT_VARIANT)
END IsSpecial;
PROCEDURE GetParamType (IN param: WinOleAut.ELEMDESC; tinfo: WinOleAut.ITypeInfo; opts: SET;
OUT type: WinOleAut.TYPEDESC; OUT kind: SHORTINT);
VAR flags: SHORTINT; vt: INTEGER; ti: WinOleAut.ITypeInfo;
BEGIN
type := param.tdesc; kind := value;
GetDescType(param.tdesc, tinfo, vt, ti);
IF (type.vt = WinOle.VT_PTR) & (vt = WinOle.VT_PTR) THEN
flags := param.u.paramdesc.wParamFlags;
type := type.u.lptdesc^;
IF ODD(flags DIV WinOleAut.PARAMFLAG_FIN) THEN
IF ~ODD(flags DIV WinOleAut.PARAMFLAG_FOUT) THEN kind := varin;
(* correction for wrong IN attributes *)
GetDescType(type, tinfo, vt, ti);
IF (vt # record) & (vt # union) & (vt # WinOle.VT_CARRAY) THEN kind := var END
ELSE kind := var
END
ELSIF ODD(flags DIV WinOleAut.PARAMFLAG_FOUT) THEN kind := varout
ELSE kind := var
END
END
END GetParamType;
PROCEDURE ShowVar (VAR var: WinOleAut.PtrVARDESC; tinfo: WinOleAut.ITypeInfo;
opts: SET; VAR out: TextMappers.Formatter);
VAR n: INTEGER; name, s, t: WinOle.BSTR; res: COM.RESULT; e: SHORTINT;
BEGIN
res := tinfo.GetNames(var.memid, name, 1, n);
out.WriteTab; out.WriteTab; out.WriteTab; WriteBSTR(name, out);
WinOleAut.SysFreeString(name);
IF var.varkind = WinOleAut.VAR_CONST THEN
out.WriteSString("* = "); WriteVariant(var.u.lpvarValue^, out)
ELSE
IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN out.WriteChar("-")
ELSE out.WriteChar("*")
END;
IF var.varkind = WinOleAut.VAR_STATIC THEN
res := tinfo.GetDllEntry(var.memid, 0, s, t, e);
IF res >= 0 THEN
out.WriteSString(" [");
IF s # NIL THEN
out.WriteChar('"'); WriteBSTR(s, out); out.WriteSString('", '); WinOleAut.SysFreeString(s)
END;
IF t # NIL THEN out.WriteChar('"'); WriteBSTR(s, out); out.WriteChar('"'); WinOleAut.SysFreeString(t)
ELSE out.WriteChar('"'); out.WriteInt(e); out.WriteChar('"')
END;
out.WriteChar("]")
END
END;
out.WriteSString(": "); WriteType(var.elemdescVar.tdesc, tinfo, opts + {browse}, out)
END;
out.WriteChar(";");
res := tinfo.GetDocumentation(var.memid, NIL, s, NIL, NIL);
IF (s # NIL) OR (browse IN opts) THEN
out.WriteSString(" (* ");
IF s # NIL THEN
WriteBSTR(s, out);
IF browse IN opts THEN out.WriteSString(", ") END;
WinOleAut.SysFreeString(s)
END;
IF browse IN opts THEN
out.WriteSString("id: "); out.WriteIntForm(var.memid, TextMappers.hexadecimal, 8, "0", FALSE);
IF var.varkind = WinOleAut.VAR_DISPATCH THEN out.WriteSString(", property") END;
IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN out.WriteSString(", readonly")
END;
IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FSOURCE) THEN out.WriteSString(", source") END;
IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FBINDABLE) THEN out.WriteSString(", bindable")
END;
IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FDISPLAYBIND) THEN out.WriteSString(", display")
END;
IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FDEFAULTBIND) THEN out.WriteSString(", default")
END;
IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FHIDDEN) THEN out.WriteSString(", hidden") END;
IF var.varkind = WinOleAut.VAR_PERINSTANCE THEN
out.WriteSString(", offset: "); out.WriteInt(var.u.oInst)
END
END;
out.WriteSString(" *)")
END;
out.WriteLn
END ShowVar;
PROCEDURE ShowParam (VAR param: WinOleAut.ELEMDESC; name: WinOle.BSTR;
tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter);
VAR type: WinOleAut.TYPEDESC; flags, kind: SHORTINT; ti: WinOleAut.ITypeInfo; s: WinOle.BSTR; res: COM.RESULT;
BEGIN
GetParamType(param, tinfo, opts, type, kind);
IF kind = var THEN out.WriteSString("VAR ")
ELSIF kind = varin THEN out.WriteSString("IN ")
ELSIF kind = varout THEN out.WriteSString("OUT ")
END;
flags := param.u.paramdesc.wParamFlags;
IF ODD(flags DIV WinOleAut.PARAMFLAG_FLCID) THEN out.WriteSString("(* lcid *) ") END;
IF ODD(flags DIV WinOleAut.PARAMFLAG_FRETVAL) THEN out.WriteSString("(* retval *) ") END;
(*
(* correct parameter name *)
IF (type.vt = WinOle.VT_PTR) & (type.u.lptdesc.vt = WinOle.VT_USERDEFINED) THEN
res := tinfo.GetRefTypeInfo(type.u.lptdesc.u.hreftype, ti);
IF res >= 0 THEN
res := ti.GetDocumentation(-1, s, NIL, NIL, NIL);
IF s # NIL THEN
IF name^ = s^ THEN
IF name[0] < "a" THEN name[0] := CHR(ORD(name[0]) + 32)
ELSE name[0] := CHR(ORD(name[0]) - 32)
END
END;
WinOleAut.SysFreeString(s)
END
END
END;
*)
WriteBSTR(name, out); out.WriteSString(": ");
IF (wrapper IN opts) & (type.vt = WinOle.VT_BSTR) & (kind = value) THEN out.WriteSString("ARRAY OF CHAR")
ELSE WriteType(type, tinfo, opts, out)
END;
(*
IF ODD(param.u.paramdesc.wParamFlags DIV WinOleAut.PARAMFLAG_FHASDEFAULT) THEN
out.WriteSString(" (* := ");
WriteVariant(param.u.paramdesc.pparamdescex.varDefaultValue, out);
out.WriteSString(" *)")
END;
*)
END ShowParam;
PROCEDURE ShowWrapper (VAR [nil] param: ARRAY [untagged] OF WinOleAut.ELEMDESC;
VAR retTyp: WinOleAut.TYPEDESC;
VAR names: ARRAY OF WinOle.BSTR;
par, id, invoke: INTEGER; hasRet: BOOLEAN; opts: SET;
tinfo: WinOleAut.ITypeInfo; VAR out: TextMappers.Formatter);
VAR i: INTEGER; type: WinOleAut.TYPEDESC; kind: SHORTINT; hasVar: BOOLEAN;
BEGIN
IF (invoke = WinOleAut.INVOKE_PROPERTYPUT) & ~hasRet & (par = 1) THEN
out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteSString("CtlC.Put");
WriteShortType(param[0].tdesc, tinfo, out); out.WriteSString("(this, ");
out.WriteInt(id); out.WriteSString(", ");
WriteBSTR(names[1], out); out.WriteChar(")"); out.WriteLn
ELSIF (invoke = WinOleAut.INVOKE_PROPERTYGET) & hasRet & (par = 0) THEN
out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteSString("RETURN ");
WriteTypeConv(retTyp, tinfo, get, id, out); out.WriteLn
ELSE
hasVar := FALSE;
IF par > 0 THEN
IF ~hasVar THEN out.WriteTab; out.WriteTab; out.WriteSString("VAR"); hasVar := TRUE END;
out.WriteString(" arg: ARRAY "); out.WriteInt(par);
out.WriteString(" OF CtlT.Variant;")
END;
IF hasRet THEN
IF ~hasVar THEN out.WriteTab; out.WriteTab; out.WriteSString("VAR"); hasVar := TRUE END;
out.WriteString(" ret: CtlT.Variant;")
END;
i := 0;
WHILE i < par DO
GetParamType(param[i], tinfo, opts, type, kind);
IF (kind # value) & IsSpecial(type, tinfo) THEN
IF ~hasVar THEN out.WriteTab; out.WriteTab; out.WriteSString("VAR"); hasVar := TRUE END;
out.WriteChar(" "); WriteBSTR(names[i + 1], out); out.WriteString("_TEMP: CtlT.Variant;")
END;
INC(i)
END;
IF hasVar THEN out.WriteLn END;
out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn;
i := 0;
WHILE i < par DO
GetParamType(param[i], tinfo, opts, type, kind);
IF (kind IN {var, varin}) & IsSpecial(type, tinfo) THEN
out.WriteTab; out.WriteTab; out.WriteSString("CtlC.");
WriteShortType(type, tinfo, out);
out.WriteString("Var("); WriteBSTR(names[i + 1], out);
out.WriteString(", "); WriteBSTR(names[i + 1], out);
out.WriteString("_TEMP);"); out.WriteLn
END;
out.WriteTab; out.WriteTab; out.WriteSString("CtlC.");
IF kind # value THEN out.WriteSString("Ref") END;
WriteShortType(type, tinfo, out);
out.WriteSString("Var("); WriteBSTR(names[i + 1], out);
IF (kind # value) & IsSpecial(type, tinfo) THEN out.WriteString("_TEMP") END;
out.WriteSString(", arg["); out.WriteInt(par - i - 1);
out.WriteSString("]);"); out.WriteLn;
INC(i)
END;
out.WriteTab; out.WriteTab;
IF par = 0 THEN out.WriteSString("CtlC.CallMethod(this, ")
ELSIF ODD(invoke DIV WinOleAut.INVOKE_PROPERTYGET) THEN
out.WriteSString("CtlC.CallGetMethod(this, ")
ELSIF ODD(invoke DIV WinOleAut.INVOKE_PROPERTYPUT) THEN
out.WriteSString("CtlC.CallPutMethod(this, ")
ELSIF ODD(invoke DIV WinOleAut.INVOKE_PROPERTYPUTREF) THEN
out.WriteSString("CtlC.CallPutRefMethod(this, ")
ELSE out.WriteSString("CtlC.CallParMethod(this, ")
END;
out.WriteInt(id);
IF par > 0 THEN out.WriteSString(", arg") END;
IF hasRet THEN out.WriteSString(", ret") ELSE out.WriteSString(", NIL") END;
out.WriteSString(");"); out.WriteLn;
i := 0;
WHILE i < par DO
GetParamType(param[i], tinfo, opts, type, kind);
IF (kind IN {var, varout}) & IsSpecial(type, tinfo) THEN
out.WriteTab; out.WriteTab; WriteBSTR(names[i + 1], out);
out.WriteSString(" := "); retName := names[i + 1]$ + "_TEMP";
WriteTypeConv(type, tinfo, ret, 0, out);
out.WriteChar(";"); out.WriteLn
END;
INC(i)
END;
IF hasRet THEN
out.WriteTab; out.WriteTab; out.WriteSString("RETURN ");
retName := "ret";
WriteTypeConv(retTyp, tinfo, ret, 0, out); out.WriteLn
END
END
END ShowWrapper;
PROCEDURE ShowGenerator (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter);
VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; name: WinOle.BSTR;
BEGIN
res := tinfo.GetTypeAttr(attr);
res := tinfo.GetDocumentation(-1, name, NIL, NIL, NIL);
(* !!! *)
out.WriteTab; out.WriteSString("PROCEDURE This"); WriteBSTR(name, out);
out.WriteSString("* (v: CtlT.Any): "); WriteBSTR(name, out);
out.WriteChar(";"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteSString("VAR new: ");
WriteBSTR(name, out); out.WriteChar(";"); out.WriteLn;
out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteSString("IF v # NIL THEN"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteTab;
out.WriteSString('NEW(new); CtlC.InitObj(new, v, "');
WriteGuid(attr.guid, out);
out.WriteSString('"); RETURN new'); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteSString("ELSE RETURN NIL"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteSString("END"); out.WriteLn;
out.WriteTab; out.WriteSString("END This");
WriteBSTR(name, out); out.WriteChar(";"); out.WriteLn; out.WriteLn;
out.WriteTab; out.WriteSString("PROCEDURE Is"); WriteBSTR(name, out);
out.WriteSString("* (v: CtlT.Any): BOOLEAN;"); out.WriteLn;
out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn;
out.WriteTab; out.WriteTab;
out.WriteSString('RETURN CtlC.IsObj(v, "');
WriteGuid(attr.guid, out); out.WriteSString('")');
out.WriteLn; out.WriteTab; out.WriteSString("END Is");
WriteBSTR(name, out); out.WriteChar(";"); out.WriteLn; out.WriteLn;
WinOleAut.SysFreeString(name)
END ShowGenerator;
PROCEDURE ShowClassGenerator (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter);
VAR res: COM.RESULT; attr, iattr: WinOleAut.PtrTYPEATTR; sc, si: WinOle.BSTR; i: INTEGER;
t: WinOleAut.HREFTYPE; iinfo: WinOleAut.ITypeInfo; flags: SET;
BEGIN
IF (inAll IN opts) OR (inAuto IN opts) THEN
res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100); i := 0;
WHILE i < attr.cImplTypes DO
res := tinfo.GetImplTypeFlags(i, flags);
IF WinOleAut.IMPLTYPEFLAG_FSOURCE * flags = {} THEN
res := tinfo.GetRefTypeOfImplType(i, t); ASSERT(res >= 0, 101);
res := tinfo.GetRefTypeInfo(t, iinfo); ASSERT(res >= 0, 102);
res := iinfo.GetTypeAttr(iattr); ASSERT(res >= 0, 103);
IF iattr.typekind = WinOleAut.TKIND_DISPATCH THEN
res := tinfo.GetDocumentation(-1, sc, NIL, NIL, NIL); ASSERT(res >= 0, 104);
res := iinfo.GetDocumentation(-1, si, NIL, NIL, NIL); ASSERT(res >= 0, 105);
(* !!! *)
IF si # NIL THEN
out.WriteTab; out.WriteSString("PROCEDURE New"); WriteBSTR(sc, out);
IF WinOleAut.IMPLTYPEFLAG_FDEFAULT * flags = {} THEN
out.WriteChar("_"); WriteBSTR(si, out)
END;
out.WriteSString("* (): "); WriteBSTR(si, out); out.WriteChar(";"); out.WriteLn;
out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn;
out.WriteTab; out.WriteTab;
out.WriteSString("RETURN This"); WriteBSTR(si, out);
out.WriteSString('(CtlC.NewObj("'); WriteGuid(attr.guid, out);
out.WriteSString('"))'); out.WriteLn;
out.WriteTab; out.WriteSString("END New"); WriteBSTR(sc, out);
IF WinOleAut.IMPLTYPEFLAG_FDEFAULT * flags = {} THEN
out.WriteChar("_"); WriteBSTR(si, out)
END;
out.WriteChar(";"); out.WriteLn; out.WriteLn;
WinOleAut.SysFreeString(sc); WinOleAut.SysFreeString(si)
END
END;
iinfo.ReleaseTypeAttr(iattr)
END;
INC(i)
END;
tinfo.ReleaseTypeAttr(attr)
END
END ShowClassGenerator;
PROCEDURE ShowProperty (VAR var: WinOleAut.PtrVARDESC; tinfo: WinOleAut.ITypeInfo; opts: SET;
VAR attr: WinOleAut.PtrTYPEATTR; tn: WinOle.BSTR; VAR out: TextMappers.Formatter);
VAR n, i: INTEGER; s, t: WinOle.BSTR; res: COM.RESULT; e: SHORTINT;
names: ARRAY 2 OF WinOle.BSTR; elem: ARRAY 1 OF WinOleAut.ELEMDESC;
BEGIN
res := tinfo.GetNames(var.memid, names[0], 1, n);
out.WriteTab; out.WriteSString("PROCEDURE ");
out.WriteSString("(this: "); WriteBSTR(tn, out); out.WriteSString(") ");
WriteBSTR(names[0], out);
out.WriteSString("* (): "); WriteType(var.elemdescVar.tdesc, tinfo, opts, out);
out.WriteString(", NEW");
IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN
(* Something's wrong here, should choose ABSTRACT. *)
IF (outAll IN opts) OR (outAuto IN opts) & (source IN opts) THEN out.WriteString(", EXTENSIBLE") END;
out.WriteChar(";"); out.WriteLn;
ShowWrapper(elem, var.elemdescVar.tdesc, names, 0, var.memid,
WinOleAut.INVOKE_PROPERTYGET, TRUE, opts, tinfo, out);
out.WriteTab; out.WriteSString("END ");
WriteBSTR(names[0], out);
ELSE
out.WriteString(", ABSTRACT")
END;
out.WriteChar(";"); out.WriteLn; out.WriteLn;
IF ~ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN
out.WriteTab; out.WriteSString("PROCEDURE ");
out.WriteSString("(this: "); WriteBSTR(tn, out); out.WriteSString(") PUT");
WriteBSTR(names[0], out);
out.WriteSString("* (val: ");
IF var.elemdescVar.tdesc.vt = WinOle.VT_BSTR THEN out.WriteSString("ARRAY OF CHAR")
ELSE WriteType(var.elemdescVar.tdesc, tinfo, opts, out)
END;
out.WriteString("), NEW");
IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN
IF (outAll IN opts) OR (outAuto IN opts) & (source IN opts) THEN out.WriteString(", EXTENSIBLE") END;
out.WriteChar(";"); out.WriteLn;
elem[0] := var.elemdescVar;
names[1] := WinOleAut.SysAllocString("val");
ShowWrapper(elem, var.elemdescVar.tdesc, names, 1, var.memid,
WinOleAut.INVOKE_PROPERTYPUT, FALSE, opts, tinfo, out);
WinOleAut.SysFreeString(names[1]);
out.WriteTab; out.WriteSString("END PUT");
WriteBSTR(names[0], out);
ELSE
out.WriteString(", ABSTRACT")
END;
out.WriteChar(";"); out.WriteLn; out.WriteLn;
END;
WinOleAut.SysFreeString(names[0]);
END ShowProperty;
PROCEDURE ShowFunc (VAR func: WinOleAut.PtrFUNCDESC; tinfo: WinOleAut.ITypeInfo; VAR attr: WinOleAut.PtrTYPEATTR;
tn: WinOle.BSTR; opts: SET; VAR out: TextMappers.Formatter);
VAR n, i: INTEGER; names: ARRAY 64 OF WinOle.BSTR; s, t: WinOle.BSTR; res: COM.RESULT; e: SHORTINT;
retTyp: WinOleAut.TYPEDESC; ti: WinOleAut.ITypeInfo;
BEGIN
res := tinfo.GetNames(func.memid, names[0], LEN(names), n);
IF (wrapper IN opts) & ((func.memid = WinOleAut.DISPID_NEWENUM)
OR (names[0]^ = "_NewEnum") & (func.cParams = 0)
& ((func.elemdescFunc.tdesc.vt = WinOle.VT_UNKNOWN)
OR (func.elemdescFunc.tdesc.vt = WinOle.VT_VARIANT))) THEN
(*
IF names[0]^ = "_NewEnum" THEN names[0]^ := "NewEnum" END;
*)
retTyp.vt := enumerator
ELSE
retTyp := func.elemdescFunc.tdesc
END;
IF ~(wrapper IN opts) OR ~ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FRESTRICTED)
OR (retTyp.vt = enumerator) THEN
(*
IF ~(wrapper IN opts) OR (names[0]^ # "QueryInterface") & (names[0]^ # "AddRef") & (names[0]^ # "Release")
& (names[0]^ # "GetTypeInfoCount") & (names[0]^ # "GetTypeInfo")
& (names[0]^ # "GetIDsOfNames") & (names[0]^ # "Invoke") THEN
*)
out.WriteTab; out.WriteSString("PROCEDURE ");
IF ~(wrapper IN opts) & (func.callconv # WinOleAut.CC_STDCALL) THEN
out.WriteChar("[");
IF func.callconv = WinOleAut.CC_CDECL THEN out.WriteSString("ccall")
ELSIF func.callconv = WinOleAut.CC_PASCAL THEN out.WriteSString("pascal")
ELSIF func.callconv = WinOleAut.CC_MACPASCAL THEN out.WriteSString("macpascal")
ELSIF func.callconv = WinOleAut.CC_SYSCALL THEN out.WriteSString("syscall")
ELSIF func.callconv = WinOleAut.CC_MPWCDECL THEN out.WriteSString("mpwccall")
ELSIF func.callconv = WinOleAut.CC_MPWPASCAL THEN out.WriteSString("mpwpascal")
ELSE HALT(100)
END;
out.WriteSString("] ")
END;
IF (func.funckind = WinOleAut.FUNC_VIRTUAL)
OR (func.funckind = WinOleAut.FUNC_PUREVIRTUAL)
OR (func.funckind = WinOleAut.FUNC_DISPATCH) THEN
out.WriteSString("(this: ");
WriteBSTR(tn, out); out.WriteSString(") ")
END;
IF func.invkind = WinOleAut.INVOKE_PROPERTYPUT THEN out.WriteSString("PUT")
ELSIF func.invkind = WinOleAut.INVOKE_PROPERTYPUTREF THEN out.WriteSString("PUTREF")
END;
WriteBSTR(names[0], out); out.WriteChar("*");
IF func.funckind = WinOleAut.FUNC_STATIC THEN
res := tinfo.GetDllEntry(func.memid, func.invkind, s, t, e);
IF res >= 0 THEN
out.WriteSString(" [");
IF s # NIL THEN
out.WriteChar('"'); WriteBSTR(s, out); out.WriteSString('", '); WinOleAut.SysFreeString(s)
END;
IF t # NIL THEN out.WriteChar('"'); WriteBSTR(t, out); out.WriteChar('"'); WinOleAut.SysFreeString(t)
ELSE out.WriteChar('"'); out.WriteInt(e); out.WriteChar('"')
END;
out.WriteChar("]")
END
END;
out.WriteSString(" (");
WHILE n <= func.cParams DO
IF n <= 9 THEN
names[n] := WinOleAut.SysAllocString("p0");
names[n][1] := SHORT(CHR(n + ORD("0")))
ELSE
names[n] := WinOleAut.SysAllocString("p00");
names[n][1] := SHORT(CHR(n DIV 10 + ORD("0")));
names[n][2] := SHORT(CHR(n MOD 10 + ORD("0")))
END;
INC(n)
END;
(*
(* correct parameter name - return type conflict *)
IF (n > 1) & (retTyp.vt = WinOle.VT_PTR) & (retTyp.u.lptdesc.vt = WinOle.VT_USERDEFINED) THEN
res := tinfo.GetRefTypeInfo(retTyp.u.lptdesc.u.hreftype, ti);
IF res >= 0 THEN
res := ti.GetDocumentation(-1, s, NIL, NIL, NIL);
IF s # NIL THEN
IF names[1]^ = s^ THEN
IF names[1, 0] < "a" THEN names[1, 0] := CHR(ORD(names[1, 0]) + 32)
ELSE names[1, 0] := CHR(ORD(names[1, 0]) - 32)
END
END;
WinOleAut.SysFreeString(s)
END
END
END;
*)
i := 0;
WHILE i < func.cParams DO
IF i > 0 THEN out.WriteSString("; ") END;
IF i = func.cParams - ABS(func.cParamsOpt) THEN out.WriteSString("(* optional *) ") END;
ShowParam(func.lprgelemdescParam[i], names[i + 1], tinfo, opts, out);
INC(i)
END;
out.WriteChar(")");
IF retTyp.vt # WinOle.VT_VOID THEN
out.WriteSString(": "); WriteType(retTyp, tinfo, opts, out)
END;
IF (names[0]^ # "Date") & (names[0]^ # "Cy") & (names[0]^ # "Int") THEN
out.WriteString(", NEW")
END;
IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN
IF (outAll IN opts) OR (outAuto IN opts) & (source IN opts) THEN out.WriteString(", EXTENSIBLE") END
ELSE
out.WriteString(", ABSTRACT")
END;
out.WriteChar(";"); out.WriteLn;
res := tinfo.GetDocumentation(func.memid, NIL, s, NIL, NIL);
IF (s # NIL) OR (browse IN opts) THEN
out.WriteTab; out.WriteTab; out.WriteSString("(* ");
IF s # NIL THEN
WriteBSTR(s, out);
IF browse IN opts THEN out.WriteSString(", ") END;
WinOleAut.SysFreeString(s)
END;
IF browse IN opts THEN
out.WriteSString("id: "); out.WriteIntForm(func.memid, TextMappers.hexadecimal, 8, "0", FALSE);
IF func.memid = attr.memidConstructor THEN out.WriteSString(", contructor") END;
IF func.memid = attr.memidDestructor THEN out.WriteSString(", destructor") END;
IF func.funckind = WinOleAut.FUNC_DISPATCH THEN out.WriteSString(", dispatch") END;
IF func.invkind = WinOleAut.INVOKE_PROPERTYGET THEN out.WriteSString(", get")
ELSIF func.invkind = WinOleAut.INVOKE_PROPERTYPUT THEN out.WriteSString(", put")
ELSIF func.invkind = WinOleAut.INVOKE_PROPERTYPUTREF THEN out.WriteSString(", putref")
END;
IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FRESTRICTED) THEN
out.WriteSString(", restricted")
END;
IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FSOURCE) THEN
out.WriteSString(", source")
END;
IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FBINDABLE) THEN
out.WriteSString(", bindable")
END;
IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FREQUESTEDIT) THEN
out.WriteSString(", request")
END;
IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FDISPLAYBIND) THEN
out.WriteSString(", display")
END;
IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FDEFAULTBIND) THEN
out.WriteSString(", default")
END;
IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FHIDDEN) THEN
out.WriteSString(", hidden")
END;
IF (func.funckind = WinOleAut.FUNC_PUREVIRTUAL)
OR (func.funckind = WinOleAut.FUNC_VIRTUAL)
THEN
out.WriteSString(", offset: "); out.WriteInt(func.oVft)
END
END;
out.WriteSString(" *)"); out.WriteLn
END;
res := tinfo.GetMops(func.memid, s);
IF s # NIL THEN
out.WriteTab; out.WriteTab; out.WriteSString("(* mops: "); WriteBSTR(s, out);
out.WriteSString(" *)"); out.WriteLn; WinOleAut.SysFreeString(s)
END;
IF func.cScodes > 0 THEN
out.WriteTab; out.WriteTab; out.WriteSString("(* scodes:"); i := 0;
WHILE i < func.cScodes DO
out.WriteChar(" "); out.WriteIntForm(func.lprgscode[i], TextMappers.hexadecimal, 9, "0", TRUE); INC(i)
END;
out.WriteSString(" *)"); out.WriteLn
END;
IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN
IF wrapper IN opts THEN
ShowWrapper(func.lprgelemdescParam^, retTyp, names, func.cParams,
func.memid, func.invkind, retTyp.vt # WinOle.VT_VOID, opts, tinfo, out)
END;
out.WriteTab; out.WriteSString("END ");
IF func.invkind = WinOleAut.INVOKE_PROPERTYPUT THEN out.WriteSString("PUT")
ELSIF func.invkind = WinOleAut.INVOKE_PROPERTYPUTREF THEN out.WriteSString("PUTREF")
END;
WriteBSTR(names[0], out); out.WriteChar(";"); out.WriteLn
END;
out.WriteLn
END;
i := 0;
WHILE i < n DO WinOleAut.SysFreeString(names[i]); INC(i) END
END ShowFunc;
PROCEDURE ShowConst (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter);
VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; var: WinOleAut.PtrVARDESC;
i: INTEGER; s, t: WinOle.BSTR; used: BOOLEAN;
BEGIN
res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100);
i := 0; used := FALSE;
WHILE i < attr.cVars DO
res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 101);
IF var.varkind = WinOleAut.VAR_CONST THEN
IF ~used THEN
out.WriteTab; out.WriteTab; out.WriteSString("(* ");
res := tinfo.GetDocumentation(-1, s, t, NIL, NIL);
IF s # NIL THEN WriteBSTR(s, out); WinOleAut.SysFreeString(s) END;
IF t # NIL THEN out.WriteSString(": "); WriteBSTR(t, out); WinOleAut.SysFreeString(t) END;
WriteTypeFlags(attr.wTypeFlags, out);
out.WriteSString(" *)"); out.WriteLn; used := TRUE
END;
ShowVar(var, tinfo, opts, out)
END;
tinfo.ReleaseVarDesc(var);
INC(i)
END;
tinfo.ReleaseTypeAttr(attr)
END ShowConst;
PROCEDURE ShowStatic (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter);
VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; var: WinOleAut.PtrVARDESC;
i: INTEGER; s, t: WinOle.BSTR; used: BOOLEAN;
BEGIN
res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100);
i := 0; used := FALSE;
WHILE i < attr.cVars DO
res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 101);
IF var.varkind # WinOleAut.VAR_CONST THEN
IF ~used THEN
out.WriteTab; out.WriteTab; out.WriteSString("(* ");
res := tinfo.GetDocumentation(-1, s, t, NIL, NIL);
IF s # NIL THEN WriteBSTR(s, out); WinOleAut.SysFreeString(s) END;
IF t # NIL THEN out.WriteSString(": "); WriteBSTR(t, out); WinOleAut.SysFreeString(t) END;
WriteTypeFlags(attr.wTypeFlags, out);
out.WriteSString(" *)"); out.WriteLn; used := TRUE
END;
ShowVar(var, tinfo, opts, out)
END;
tinfo.ReleaseVarDesc(var);
INC(i)
END;
tinfo.ReleaseTypeAttr(attr)
END ShowStatic;
PROCEDURE ShowType (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter);
VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; var: WinOleAut.PtrVARDESC; flags: SET;
i, vt: INTEGER; func: WinOleAut.PtrFUNCDESC; s, s1: WinOle.BSTR; iinfo: WinOleAut.ITypeInfo;
t: WinOleAut.HREFTYPE;
BEGIN
res := tinfo.GetDocumentation(-1, s, s1, NIL, NIL);
(* !!! *)
IF s1 # NIL THEN
out.WriteTab; out.WriteTab; out.WriteSString("(* "); WriteBSTR(s1, out);
out.WriteSString(" *)"); out.WriteLn; WinOleAut.SysFreeString(s1)
END;
res := tinfo.GetMops(-1, s1);
IF s1 # NIL THEN
out.WriteTab; out.WriteTab; out.WriteSString("(* Mops: "); WriteBSTR(s1, out);
out.WriteSString(" *)"); out.WriteLn; WinOleAut.SysFreeString(s1)
END;
res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100);
IF attr.typekind = WinOleAut.TKIND_COCLASS THEN (* !!! *)
IF wrapper IN opts THEN
GetInfoType(tinfo, vt, iinfo);
IF vt = WinOle.VT_DISPATCH THEN
res := iinfo.GetDocumentation(-1, s1, NIL, NIL, NIL); ASSERT(res >= 0, 104);
IF s1 # NIL THEN
out.WriteTab; out.WriteTab;
WriteBSTR(s, out); out.WriteSString("* = "); WriteBSTR(s1, out);
out.WriteChar(";"); out.WriteLn;
WinOleAut.SysFreeString(s1)
END
END
END
ELSE
out.WriteTab; out.WriteTab;
WriteBSTR(s, out); out.WriteSString("* = ");
IF attr.typekind = WinOleAut.TKIND_ALIAS THEN
WriteType(attr.tdescAlias, tinfo, opts, out)
ELSIF attr.typekind = WinOleAut.TKIND_ENUM THEN
out.WriteString("INTEGER");
ELSE
out.WriteSString("POINTER TO ");
IF wrapper IN opts THEN
IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN
IF (outAll IN opts) OR (outAuto IN opts) & (source IN opts) THEN
out.WriteString("EXTENSIBLE ")
END
ELSE
out.WriteString("ABSTRACT ")
END;
out.WriteSString("RECORD ")
ELSE
out.WriteSString("RECORD ");
IF (attr.typekind = WinOleAut.TKIND_INTERFACE) OR (attr.typekind = WinOleAut.TKIND_DISPATCH)
THEN
out.WriteSString('["'); WriteGuid(attr.guid, out); out.WriteSString('"] ')
ELSIF attr.typekind = WinOleAut.TKIND_UNION THEN out.WriteSString("[union] ")
ELSIF attr.cbAlignment = 1 THEN out.WriteSString("[noalign] ")
ELSIF attr.cbAlignment = 2 THEN out.WriteSString("[align2] ")
ELSIF attr.cbAlignment = 8 THEN out.WriteSString("[align8] ")
ELSE out.WriteSString("[untagged] ")
END
END;
IF attr.cImplTypes > 0 THEN
ASSERT(attr.cImplTypes = 1, 101);
res := tinfo.GetRefTypeOfImplType(0, t); ASSERT(res >= 0, 102);
out.WriteChar("(");
IF (wrapper IN opts) & ((outAll IN opts) OR (outAuto IN opts) & (source IN opts)) THEN
out.WriteString("CtlT.OutObject")
ELSE
WriteHandleName(t, tinfo, opts, out)
END;
out.WriteSString(") ")
END;
IF ~(wrapper IN opts) THEN
IF attr.typekind = WinOleAut.TKIND_DISPATCH THEN
out.WriteSString("(* dispatch")
ELSE
out.WriteSString("(* size: "); out.WriteInt(attr.cbSizeInstance);
out.WriteSString(", vtbl size: "); out.WriteInt(attr.cbSizeVft)
END;
WriteTypeFlags(attr.wTypeFlags, out);
out.WriteSString(" *)"); out.WriteLn;
i := 0;
WHILE i < attr.cVars DO
res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 103);
IF var.varkind # WinOleAut.VAR_CONST THEN
ShowVar(var, tinfo, opts, out)
END;
tinfo.ReleaseVarDesc(var);
INC(i)
END;
out.WriteTab; out.WriteTab
END;
out.WriteSString("END")
END;
out.WriteChar(";"); out.WriteLn
END;
WinOleAut.SysFreeString(s);
tinfo.ReleaseTypeAttr(attr)
END ShowType;
PROCEDURE ShowInvokeCall (func: WinOleAut.PtrFUNCDESC; tinfo: WinOleAut.ITypeInfo;
opts: SET; VAR out: TextMappers.Formatter);
VAR p, n: INTEGER; res: COM.RESULT; name: WinOle.BSTR; type: WinOleAut.TYPEDESC; kind: SHORTINT;
BEGIN
res := tinfo.GetNames(func.memid, name, 1, n);
IF func.elemdescFunc.tdesc.vt # WinOle.VT_VOID THEN (* function *)
out.WriteSString("CtlC.");
IF (wrapper IN opts) & ((func.memid = WinOleAut.DISPID_NEWENUM)
OR (name^ = "_NewEnum") & (func.cParams = 0)
& ((func.elemdescFunc.tdesc.vt = WinOle.VT_UNKNOWN)
OR (func.elemdescFunc.tdesc.vt = WinOle.VT_VARIANT))) THEN out.WriteString("Enum")
ELSE WriteShortType(func.elemdescFunc.tdesc, tinfo, out)
END;
out.WriteSString("Var(")
END;
out.WriteSString("this.");
IF ODD(func.invkind DIV WinOleAut.INVOKE_PROPERTYPUT) THEN out.WriteSString("PUT")
ELSIF ODD(func.invkind DIV WinOleAut.INVOKE_PROPERTYPUTREF) THEN out.WriteSString("PUTREF")
END;
WriteBSTR(name, out); out.WriteChar("(");
WinOleAut.SysFreeString(name);
p := 0;
WHILE p < func.cParams DO
IF p > 0 THEN out.WriteSString(", ") END;
GetParamType(func.lprgelemdescParam[p], tinfo, opts, type, kind);
IF kind = value THEN WriteTypeConv(type, tinfo, par, func.cParams - 1 - p, out)
ELSE WriteTypeConv(type, tinfo, refpar, func.cParams - 1 - p, out)
END;
INC(p)
END;
out.WriteChar(")");
IF func.elemdescFunc.tdesc.vt # WinOle.VT_VOID THEN out.WriteSString(", ret)") END;
p := 0;
WHILE p < func.cParams DO
GetParamType(func.lprgelemdescParam[p], tinfo, opts, type, kind);
IF (kind # value) & IsSpecial(type, tinfo) THEN
out.WriteSString("; CtlC.Ret");
WriteShortType(type, tinfo, out);
out.WriteString("(par["); out.WriteInt(func.cParams - 1 - p); out.WriteString("])")
END;
INC(p)
END;
END ShowInvokeCall;
PROCEDURE ShowInvoke (tinfo: WinOleAut.ITypeInfo; attr: WinOleAut.PtrTYPEATTR;
tn: WinOle.BSTR; opts: SET; VAR out: TextMappers.Formatter);
VAR func, pfunc: WinOleAut.PtrFUNCDESC; res: COM.RESULT; i, j, n: INTEGER;
name: WinOle.BSTR; var: WinOleAut.PtrVARDESC; ifUsed: BOOLEAN;
BEGIN
out.WriteTab; out.WriteSString("PROCEDURE (this: "); WriteBSTR(tn, out);
out.WriteSString(") Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant);");
out.WriteLn; out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteSString("CASE id OF"); out.WriteLn;
i := 0;
WHILE i < attr.cVars DO (* property access *)
res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 101);
IF var.varkind # WinOleAut.VAR_CONST THEN
res := tinfo.GetNames(var.memid, name, 1, n);
out.WriteTab; out.WriteTab; out.WriteSString("| "); out.WriteInt(var.memid);
out.WriteSString(": ");
IF ~ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN
out.WriteSString("IF n = -1 THEN this.PUT");
WriteBSTR(name, out); out.WriteChar("(");
WriteTypeConv(var.elemdescVar.tdesc, tinfo, par, 0, out);
out.WriteChar(")"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("ELSE ")
END;
out.WriteSString("ASSERT(n = 0, 11); ");
out.WriteSString("CtlC."); WriteShortType(var.elemdescVar.tdesc, tinfo, out);
out.WriteSString("Var(this."); WriteBSTR(name, out);
out.WriteSString("(), ret)"); out.WriteLn;
IF ~ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN
out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("END"); out.WriteLn
END;
WinOleAut.SysFreeString(name)
END;
tinfo.ReleaseVarDesc(var);
INC(i)
END;
i := 0;
WHILE i < attr.cFuncs DO (* method access *)
res := tinfo.GetFuncDesc(i, func); ASSERT(res >= 0, 102);
IF ~ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FRESTRICTED)
& (func.invkind < WinOleAut.INVOKE_PROPERTYPUT) THEN
out.WriteTab; out.WriteTab; out.WriteSString("| "); out.WriteInt(func.memid);
out.WriteSString(": "); ifUsed := FALSE;
IF func.invkind = WinOleAut.INVOKE_PROPERTYGET THEN
j := 0;
WHILE j < attr.cFuncs DO
res := tinfo.GetFuncDesc(j, pfunc); ASSERT(res >= 0, 103);
IF (pfunc.memid = func.memid)
& ~ODD(pfunc.wFuncFlags DIV WinOleAut.FUNCFLAG_FRESTRICTED)
& (pfunc.invkind >= WinOleAut.INVOKE_PROPERTYPUT) THEN
IF ifUsed THEN out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("ELS") END;
out.WriteSString("IF n = -");
IF ODD(pfunc.invkind DIV WinOleAut.INVOKE_PROPERTYPUT) THEN
out.WriteInt(pfunc.cParams)
ELSE out.WriteInt(pfunc.cParams + 100)
END;
out.WriteSString(" THEN ");
ShowInvokeCall(pfunc, tinfo, opts, out); out.WriteLn;
ifUsed := TRUE
END;
tinfo.ReleaseFuncDesc(pfunc);
INC(j)
END
END;
IF ifUsed THEN out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("ELSE ") END;
out.WriteSString("ASSERT(n = "); out.WriteInt(func.cParams); out.WriteSString(", 11); ");
ShowInvokeCall(func, tinfo, opts, out); out.WriteLn;
IF ifUsed THEN out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("END"); out.WriteLn END
END;
tinfo.ReleaseFuncDesc(func);
INC(i)
END;
out.WriteTab; out.WriteTab; out.WriteSString("END"); out.WriteLn;
out.WriteTab; out.WriteSString("END Invoke;"); out.WriteLn; out.WriteLn;
(* GetIID *)
out.WriteTab; out.WriteSString("PROCEDURE (this: "); WriteBSTR(tn, out);
out.WriteSString(") GetIID* (OUT iid: CtlT.GUID);"); out.WriteLn;
out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn;
out.WriteTab; out.WriteTab; out.WriteSString('iid := "');
WriteGuid(attr.guid, out); out.WriteChar('"'); out.WriteLn;
out.WriteTab; out.WriteSString("END GetIID;"); out.WriteLn; out.WriteLn
END ShowInvoke;
PROCEDURE ShowProcs (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter);
VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; s, t: WinOle.BSTR;
i: INTEGER; func: WinOleAut.PtrFUNCDESC; var: WinOleAut.PtrVARDESC;
BEGIN
res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100);
IF (wrapper IN opts) OR (attr.cFuncs > 0) THEN
res := tinfo.GetDocumentation(-1, s, t, NIL, NIL);
(* !!! *)
out.WriteLn; out.WriteTab;
out.WriteSString("(* ---------- ");
IF s # NIL THEN WriteBSTR(s, out) END;
IF t # NIL THEN out.WriteSString(": "); WriteBSTR(t, out) END;
WriteTypeFlags(attr.wTypeFlags, out); out.WriteSString(" ---------- *)");
out.WriteLn; out.WriteLn;
IF wrapper IN opts THEN
i := 0;
WHILE i < attr.cVars DO
res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 101);
IF var.varkind # WinOleAut.VAR_CONST THEN
ShowProperty(var, tinfo, opts, attr, s, out)
END;
tinfo.ReleaseVarDesc(var);
INC(i)
END
END;
i := 0;
WHILE i < attr.cFuncs DO
res := tinfo.GetFuncDesc(i, func); ASSERT(res >= 0, 102);
ShowFunc(func, tinfo, attr, s, opts, out);
tinfo.ReleaseFuncDesc(func);
INC(i)
END;
IF (wrapper IN opts) & ((outAll IN opts) OR (outAuto IN opts) & (source IN opts)) THEN
ShowInvoke(tinfo, attr, s, opts, out)
END;
WinOleAut.SysFreeString(s);
WinOleAut.SysFreeString(t)
END;
tinfo.ReleaseTypeAttr(attr)
END ShowProcs;
PROCEDURE ShowClass (tinfo: WinOleAut.ITypeInfo; VAR out: TextMappers.Formatter);
VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; flags: SET;
i: INTEGER; s, s1: WinOle.BSTR; t: WinOleAut.HREFTYPE;
BEGIN
out.WriteTab; out.WriteSString("(* CLASS ");
res := tinfo.GetDocumentation(-1, s, s1, NIL, NIL);
IF s # NIL THEN WriteBSTR(s, out) END;
IF s1 # NIL THEN out.WriteSString(": "); WriteBSTR(s1, out); WinOleAut.SysFreeString(s1) END;
res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100);
out.WriteLn; out.WriteTab; out.WriteTab;
WriteGuid(attr.guid, out); WriteTypeFlags(attr.wTypeFlags, out);
out.WriteLn;
i := 0;
WHILE i < attr.cImplTypes DO
res := tinfo.GetImplTypeFlags(i, flags);
res := tinfo.GetRefTypeOfImplType(i, t); ASSERT(res >= 0, 103);
out.WriteTab; out.WriteTab; out.WriteSString("INTERFACE ");
WriteHandleName(t, tinfo, {}, out);
out.WriteTab; out.WriteSString("(* ");
IF WinOleAut.IMPLTYPEFLAG_FDEFAULT * flags # {} THEN out.WriteSString("default ") END;
IF WinOleAut.IMPLTYPEFLAG_FDEFAULTVTABLE * flags # {} THEN
out.WriteSString("defaultVtable ")
END;
IF WinOleAut.IMPLTYPEFLAG_FRESTRICTED * flags # {} THEN out.WriteSString("restricted ") END;
IF WinOleAut.IMPLTYPEFLAG_FSOURCE * flags # {} THEN out.WriteSString("source ") END;
out.WriteSString("*)"); out.WriteLn; INC(i)
END;
out.WriteTab; out.WriteSString("END *)"); out.WriteLn; out.WriteLn;
WinOleAut.SysFreeString(s);
tinfo.ReleaseTypeAttr(attr)
END ShowClass;
PROCEDURE IsSource (tlib: WinOleAut.ITypeLib; tinfo: WinOleAut.ITypeInfo): BOOLEAN;
VAR attr, ca, ta: WinOleAut.PtrTYPEATTR; ci, ti: WinOleAut.ITypeInfo; i, j, n: INTEGER;
res: COM.RESULT; kind: WinOleAut.TYPEKIND; t: WinOleAut.HREFTYPE; flags: SET;
BEGIN
res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100);
i := 0; n := tlib.GetTypeInfoCount();
WHILE i < n DO
res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 101);
IF kind = WinOleAut.TKIND_COCLASS THEN
res := tlib.GetTypeInfo(i, ci); ASSERT(res >= 0, 102);
res := ci.GetTypeAttr(ca); ASSERT(res >= 0, 103);
j := 0;
WHILE j < ca.cImplTypes DO
res := ci.GetImplTypeFlags(j, flags); ASSERT(res >= 0, 104);
IF WinOleAut.IMPLTYPEFLAG_FSOURCE * flags # {} THEN
res := ci.GetRefTypeOfImplType(j, t); ASSERT(res >= 0, 105);
res := ci.GetRefTypeInfo(t, ti); ASSERT(res >= 0, 106);
res := ti.GetTypeAttr(ta); ASSERT(res >= 0, 107);
IF ta.guid = attr.guid THEN i := n; j := ca.cImplTypes END;
ti.ReleaseTypeAttr(ta)
END;
INC(j)
END;
ci.ReleaseTypeAttr(ca)
END;
INC(i)
END;
tinfo.ReleaseTypeAttr(attr);
RETURN i > n
END IsSource;
PROCEDURE ShowLibrary (
tlib: WinOleAut.ITypeLib; name: ARRAY OF CHAR; opts: SET; VAR out: TextMappers.Formatter
);
VAR s1, s2, s3: WinOle.BSTR; str: ARRAY 256 OF SHORTCHAR; i, n, impPos: INTEGER; res: COM.RESULT;
attr: WinOleAut.PtrTLIBATTR; tinfo, ti: WinOleAut.ITypeInfo; kind: WinOleAut.TYPEKIND;
t: WinOleAut.HREFTYPE;
BEGIN
res := tlib.GetDocumentation(-1, s1, s2, n, s3); ASSERT(res >= 0, 100);
modules[0] := s1$; WinOleAut.SysFreeString(s1);
modules[1] := "CtlT"; modules[2] := "CtlC"; noMod := 3;
IF wrapper IN opts THEN modules[0] := "Ctl" + modules[0] END;
out.WriteSString("MODULE ");
out.WriteString(name);
IF interface IN opts THEN out.WriteSString(' [""]') END;
out.WriteChar(";"); out.WriteLn; out.WriteTab; out.WriteSString("(* ");
IF s2 # NIL THEN WriteBSTR(s2, out); WinOleAut.SysFreeString(s2) END;
out.WriteSString(", help: ");
IF s3 # NIL THEN WriteBSTR(s3, out); WinOleAut.SysFreeString(s3) END;
out.WriteSString(", id: "); out.WriteInt(n); out.WriteSString(" *)"); out.WriteLn;
res := tlib.GetLibAttr(attr); ASSERT(res >= 0, 102);
out.WriteTab; out.WriteSString("(* guid: "); WriteGuid(attr.guid, out);
out.WriteSString(", lcid: "); out.WriteInt(attr.lcid);
out.WriteSString(", syskind: ");
IF attr.syskind = WinOleAut.SYS_WIN16 THEN out.WriteSString("win16")
ELSIF attr.syskind = WinOleAut.SYS_WIN32 THEN out.WriteSString("win32")
ELSIF attr.syskind = WinOleAut.SYS_MAC THEN out.WriteSString("mac")
ELSE out.WriteInt(attr.syskind)
END;
out.WriteSString(", version: ");
out.WriteInt(attr.wMajorVerNum);
out.WriteChar(".");
out.WriteInt(attr.wMinorVerNum);
IF ODD(attr.wLibFlags DIV WinOleAut.LIBFLAG_FRESTRICTED) THEN out.WriteSString(", restricted") END;
IF ODD(attr.wLibFlags DIV WinOleAut.LIBFLAG_FCONTROL) THEN out.WriteSString(", control") END;
IF ODD(attr.wLibFlags DIV WinOleAut.LIBFLAG_FHIDDEN) THEN out.WriteSString(", hidden") END;
out.WriteSString(" *)"); out.WriteLn; out.WriteLn;
impPos := out.Pos();
tlib.ReleaseTLibAttr(attr);
n := tlib.GetTypeInfoCount();
out.WriteTab; out.WriteSString("CONST"); out.WriteLn; i := 0;
WHILE i < n DO
res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 103);
ShowConst(tinfo, opts, out);
INC(i)
END;
out.WriteLn; out.WriteLn;
out.WriteTab; out.WriteSString("TYPE"); out.WriteLn; i := 0;
WHILE i < n DO
res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 104);
IF (kind = WinOleAut.TKIND_ALIAS) OR (kind = WinOleAut.TKIND_ENUM)
OR ~(wrapper IN opts) & (kind IN {WinOleAut.TKIND_RECORD, WinOleAut.TKIND_INTERFACE,
WinOleAut.TKIND_ALIAS, WinOleAut.TKIND_UNION})
OR ~(interface IN opts) & (kind IN {WinOleAut.TKIND_DISPATCH, WinOleAut.TKIND_COCLASS})
THEN
res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 105);
IF (wrapper IN opts) & IsSource(tlib, tinfo) THEN
ShowType(tinfo, opts + {source}, out)
ELSE ShowType(tinfo, opts, out)
END
END;
IF (~(wrapper IN opts)) & (kind = WinOleAut.TKIND_DISPATCH) THEN
res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 105);
res := tinfo.GetRefTypeOfImplType(-1, t);
IF res >= 0 THEN (* dual interfaced *)
res := tinfo.GetRefTypeInfo(t, ti); ASSERT(res >= 0, 106);
ShowType(ti, opts, out)
END
END;
INC(i)
END;
out.WriteLn; out.WriteLn;
IF ~(wrapper IN opts) THEN
out.WriteTab; out.WriteSString("VAR"); out.WriteLn;
i := 0;
WHILE i < n DO
res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 107);
IF kind = WinOleAut.TKIND_MODULE THEN
res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 108);
ShowStatic(tinfo, opts, out)
END;
INC(i)
END;
out.WriteLn; out.WriteLn
ELSE
i := 0;
WHILE i < n DO
res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 109);
IF (wrapper IN opts) & (kind = WinOleAut.TKIND_DISPATCH) THEN
res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 110);
IF (inAll IN opts) OR (inAuto IN opts) & ~IsSource(tlib, tinfo) THEN
ShowGenerator(tinfo, opts, out)
END
END;
INC(i)
END;
out.WriteLn
END;
i := 0;
WHILE i < n DO
res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 109);
IF ~(wrapper IN opts) & (kind IN {WinOleAut.TKIND_MODULE, WinOleAut.TKIND_INTERFACE})
OR ~(interface IN opts) & (kind = WinOleAut.TKIND_DISPATCH) THEN
res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 110);
IF (wrapper IN opts) & IsSource(tlib, tinfo) THEN
ShowProcs(tinfo, opts + {source}, out)
ELSE ShowProcs(tinfo, opts, out)
END
END;
IF ~(wrapper IN opts) & (kind = WinOleAut.TKIND_DISPATCH) THEN
res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 110);
res := tinfo.GetRefTypeOfImplType(-1, t);
IF res >= 0 THEN (* dual interfaced *)
res := tinfo.GetRefTypeInfo(t, ti); ASSERT(res >= 0, 111);
ShowProcs(ti, opts, out)
END
END;
INC(i)
END;
out.WriteLn; i := 0;
WHILE i < n DO
res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 112);
IF kind = WinOleAut.TKIND_COCLASS THEN
res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 113);
IF wrapper IN opts THEN ShowClassGenerator(tinfo, opts, out)
ELSE ShowClass(tinfo, out)
END
END;
INC(i)
END;
out.WriteSString("END ");
out.WriteString(name); out.WriteChar("."); out.WriteLn;
IF (wrapper IN opts) & (noMod > 1) THEN
out.SetPos(impPos);
out.WriteTab; out.WriteSString("IMPORT "); i := 1;
WHILE i < noMod DO
IF i > 1 THEN out.WriteSString(", ") END;
out.WriteString(modules[i]); INC(i)
END;
out.WriteChar(";"); out.WriteLn; out.WriteLn
END;
END ShowLibrary;
PROCEDURE AutomationInterface* (
fileName: ARRAY 256 OF CHAR; modName: ARRAY 64 OF CHAR
): TextModels.Model;
VAR t: TextModels.Model; out: TextMappers.Formatter; res: COM.RESULT; tlib: WinOleAut.ITypeLib;
BEGIN
t := TextModels.dir.New();
out.ConnectTo(t);
res := WinOleAut.LoadTypeLib(fileName, tlib);
IF res >= 0 THEN
ShowLibrary(tlib, modName, {wrapper, inAuto, outAuto}, out)
END;
out.ConnectTo(NIL);
RETURN t
END AutomationInterface;
PROCEDURE CustomInterface* (
fileName: ARRAY 256 OF CHAR; modName: ARRAY 64 OF CHAR
): TextModels.Model;
(* not yet tested *)
VAR t: TextModels.Model; out: TextMappers.Formatter; res: COM.RESULT; tlib: WinOleAut.ITypeLib;
BEGIN
t := TextModels.dir.New();
out.ConnectTo(t);
res := WinOleAut.LoadTypeLib(fileName, tlib);
IF res >= 0 THEN
ShowLibrary(tlib, modName, {interface}, out)
END;
out.ConnectTo(NIL);
RETURN t
END CustomInterface;
PROCEDURE Browse* (fileName: ARRAY 256 OF CHAR; modName: ARRAY 64 OF CHAR): TextModels.Model;
(* not yet tested *)
VAR t: TextModels.Model; out: TextMappers.Formatter; res: COM.RESULT; tlib: WinOleAut.ITypeLib;
BEGIN
t := TextModels.dir.New();
out.ConnectTo(t);
res := WinOleAut.LoadTypeLib(fileName, tlib);
IF res >= 0 THEN
ShowLibrary(tlib, modName, {browse}, out)
END;
out.ConnectTo(NIL);
RETURN t
END Browse;
END DevTypeLibs.
DevComInterfaceGen
DevTypeLibs
| Dev/Mod/TypeLibs.odc |
Dev/Rsrc/Analyzer.odc |
|
Dev/Rsrc/Browser.odc |
|
Dev/Rsrc/ComInterfaceGen.odc |
|
Dev/Rsrc/Create.odc |
|
List of Oberon Error Numbers
Oberon microsystems 19. 7. 94
перевод: Информатика-21 2004-09-21
Sec.10: E.E.Temirgaleev, F.V.Tkachov 2010-04-10
1. Incorrect use of language Oberon
0 необъявленный идентификатор
1 повторно объявленный идентификатор
2 запрещенная литера в числе
3 запрещенная литера в литерной цепочке
4 идентификатор не совпадает с именем процедуры или модуля
5 комментарий не закрыт
6
7
8
9 ожидается "="
10
11
12 определение типа начинается с неправильной литеры
13 множитель начинается с неправильной литеры
14 оператор начинается с неправильной литеры
15 за объявлением следует неправильная литера
16 ожидается МОДУЛЬ (MODULE)
17
18
19 пропущена "."
20 пропущена ","
21 пропущено ":"
22
23 пропущена ")"
24 пропущена "]"
25 пропущена "}"
26 пропущено OF
27 пропущено ТОГДА (THEN)
28 пропущено ДЕЛАТЬ (DO)
29 пропущено ДО (TO)
30
31
32
33
34
35 ожидается "," или ИЗ (OF)
36 пропущено КОНСТАНТЫ, ТИП, ПЕР, ПРОЦЕДУРА, НАЧАЛО или КОНЕЦ (CONST, TYPE, VAR, PROCEDURE, BEGIN или END)
37 пропущено ПРОЦЕДУРА, НАЧАЛО или КОНЕЦ (PROCEDURE, BEGIN или END)
38 пропущено НАЧАЛО или КОНЕЦ (BEGIN или END)
39
40 пропущена литера "("
41 идентификатор помечен неправильно
42 константа не является целым числом
43 пропущено UNTIL
44 пропущено ":="
45
46 EXIT стоит вне предложения LOOP
47 ожидается литерная цепочка
48 ожидается идентификатор
49 пропущена ";"
50 выражение должно быть константным
51 пропущено КОНЕЦ (END)
52 идентификатор не обозначает тип
53 идентификатор не обозначает тип записей
54 тип результата процедуры не основной
55 процедурное обращение к функции
56 присваивание не переменной
57 указатель не связан с типом записей или типом массивов
58 рекурсивное определение типа
59 открытый массив не разрешен в качестве параметра
60 неправильный тип метки в предложении CASE
61 недопустимый тип метки в предложении CASE
62 метка в предложении CASE определена повторно
63 неправильное значение константы
64 фактических параметров больше, чем формальных
65 фактических параметров меньше, чем формальных
66 типы элементов фактического массива и формального открытого массива отличаются
67 фактический параметр, соответствующий открытому массиву, не является массивом
68 управляющая переменная должна быть целой
69 параметр должен быть целой константой
70 нужен указатель или VAR / IN - запись в качестве формального получателя
71 нужен указатель в качестве действительного получателя
72 процедура должна быть связана с записью, имеющей ту же область видимости
73 процедура должна быть на уровне 0
74 в типе-предке такой процедуры нет
75 неправильное обращение к базовой процедуре
76 эта переменная (поле) доступна только для чтения
77 объект не является записью
78 разыменованный объект не является переменной
79 индексированный объект не является переменной
80 индексное выражение не является целым
81 индекс выходит за рамки заданных границ
82 индексированная переменная не является массивом
83 неопределенное поле записи
84 разыменованная переменная не является указателем
85 охрана или проверяемый тип не переопределение типа переменной
86 охрана или проверяемый тип не указатель
87 охраняемая или проверяемая переменная не является ни указателем, ни VAR- или IN-параметром-записью
88 открытый массив не может быть переменной, полем записи или элементом массива
89 ANYREC не может быть размещена
90 разыменованная переменная не является литерным массивом
91
92 операнд операции IN не является целым или множеством
93 тип элемента множества не является целым
94 операнд операции & не имеет тип ЛОГИЧЕСКИЙ (BOOLEAN)
95 операнд операции ИЛИ (OR) не имеет тип ЛОГИЧЕСКИЙ (BOOLEAN)
96 операнд не разрешен с (унарным) +
97 операнд не разрешен с (унарным) -
98 операнд операции ~ не имеет тип ЛОГИЧЕСКИЙ (BOOLEAN)
99 ложное утверждение в УБЕДИТЬСЯ (ASSERT)
100 несовместимые операнды двуместной операции
101 тип операнда не разрешен с *
102 тип операнда не разрешен с /
103 тип операнда не разрешен с ДЕЛИТЬ (DIV)
104 тип операнда не разрешен с ОСТАТОК (MOD)
105 тип операнда не разрешен с +
106 тип операнда не разрешен с -
107 тип операнда не разрешен с = или #
108 тип операнда не разрешен с отношением порядка
109 переопределяющий метод должен быть экспортирован
110 операнд не является типом
111 операнд нельзя использовать с (этой) функцией
112 операнд не является переменной
113 несовместимое присваивание
114 цепочка литер слишком длинна для присваивания
115 параметр не соответствует
116 количество параметров не соответствует
117 тип результата не соответствует
118 метка экспорта не согласуется с упреждающим определением
119 переопределение текстуально предшествует процедуре, привязанной к типу-предку
120 тип выражения, следующего за ЕСЛИ, ПОКА, ДО или УБЕДИТЬСЯ (IF, WHILE, UNTIL или ASSERT), не является ЛОГИЧЕСКИМ (BOOLEAN)
121 вызываемый объект не является процедурой (или является процедурой прерывания)
122 фактический VAR-, IN- или OUT-параметр не является переменной
123 тип не совпадает с типом формального VAR-, IN- или OUT-параметра
124 тип результата выражения отличается от типа результата процедуры
125 тип управляющего выражения в предложении CASE не является ни INTEGER, ни CHAR
126 это выражение не может быть типом или процедурой
127 неправильное использование объекта
128 упреждающее объявление не удовлетворено
129 неудовлетворенное упреждающее определение процедуры
130 в операторе WITH не указана переменная
131 ДЛИНА (LEN) применена не к массиву
132 измерение в ДЛИНА (LEN) слишком велико или отрицательно
133 функция без ВЕРНУТЬ (RETURN)
135 модуль SYSTEM не импотирован
136 LEN applied to untagged array
137 длина массива неизвестна
138 NEW not allowed for untagged structures
139 Test applied to untagged record
140 untagged receiver
141 SYSTEM.NEW не реализована
142 tagged structures not allowed for NIL compatible var parameters
143 tagged pointer not allowed in untagged structure
144 no pointers allowed in BYTES argument
145 untagged open array not allowed as value parameter
150 key inconsistency of imported module
151 неправильный символьный файл
152 символьный файл импортируемого модуля не найден
153 объектный или символьный файл не открылся (диск полон?)
154 рекурсивный импорт запрещен
155 создание нового символьного файла запрещено
160 interfaces must be extensions of IUnknown
161 interfaces must not have fields
162 interface procedures must be abstract
163 interface records must be abstract
164 pointer must be extension of queried interface type
165 illegal guid constant
166 AddRef & Release may not be used
167 illegal assignment to [new] parameter
168 wrong [iid] - [new] pair
169 must be an interface pointer
177 IN разрешен только для записей и массивов
178 недопустимый атрибут
179 абстрактные методы экспортируемых записей должны экспортироваться
180 неправильный тип получателя
181 тип-предок не является переопределяемым
182 процедура-предок не является переопределяемой
183 несоответствующий экспорт
184 атрибут не соответствует упреждающему объявлению
185 пропущен атрибут NEW
186 неправильный атрибут NEW
187 новая пустая процедура в непереопределяемой записи
188 переопределяемая процедура в непереопределяемой записи
189 неправильное изменение атрибута
190 запись должна быть абстрактной
191 тип-предок должен быть абстрактным
192 нереализованные абстрактные процедуры в типах-предках
193 абстрактные или ограниченные записи не могут размещаться
194 не разрешены супер-вызовы абстрактных или пустых процедур
195 пустые процедуры не могут иметь OUT-параметров или возвращать значение
196 процедура экспортирована только для реализации
197 переопределение ограниченного типа должно быть ограничено
198 устаревший тип языка оберон
199 устаревшая функция языка оберон
2. Limitations of implementation
200 еще не реализовано
201 нижняя граница диапазона множества больше, чем верхняя граница
202 элемент множества больше, чем MAX(SET), или меньше, чем 0
203 число слишком велико
204 произведение слишком велико
205 деление на нуль
206 сумма слишком велика
207 разность слишком велика
208 переполнение в арифметическом сдвиге
209 диапазон в CASE слишком велик
210 исходный текст слишком велик
211 расстояние перехода слишком велико
212 недопустимая операция с вещественными числами
213 слишком много вариантов в CASE
214 структура слишком велика
215 недостаточно регистров: упростите выражение
216 недостаточно регистров с плавающей точкой: упростите выражение
217
218 неправильное значение параметра (0 <= p < 128)
219 неправильное значение параметра (0 <= p < 16)
220 неправильное значение параметра
221 слишком много указателей в записи
222 слишком много глобальных указателей
223 слишком много типов записей
224 слишком много указательных типов
225 illegal sys flag
226 слишком много экспортированных процедур
227 слишком много импортированных модулей
228 слишком много экспортированных структур
229 слишком много вложенных записей для импорта
230 слишком много констант (литерных цепочек) в модуле
231 too many link table entries (external procedures)
232 слишком много команд в модуле
233 иерархия переопределения записей слишком велика
235 слишком много модификаторов
240 слишком длинный идентификатор
241 слишком длинная литерная цепочка
242 слишком много мета-имен
243 слишком много импортированных переменных
249 несогласованный импорт
250 code-процедуры не должны экспортироваться
251 слишком много вложенных вызовов функций
254 debug position not found
255 debug position
260 операция запрещена для LONGINT
265 операция не поддерживается для цепочек литер
270 interface pointer reference counting restriction violated
3. Warnings
301 implicit type cast
302 guarded variable can be side-effected
303 open array (or pointer to array) containing pointers
3.5 Analyzer Warnings
900 не используется
901 не инициализируется
902 используется до инициализации
903 инициализируется, но не используется
904 используется как параметр-переменная, возможно не инициализирована
905 также определена в объемлющей области видимости
906 access/assignment to intermediate
907 переопределение
908 новое определение
909 предложение после RETURN/EXIT
910 присваивание упр. переменной цикла FOR
911 подразумевается охрана типа
912 избыточная охрана типа
913 вызов может зависеть от последовательности вычисления параметров
930 избыточная литера ";"
4.0 Bytecode Errors
401 bytecode restriction: no structured assignment
402 bytecode restriction: no procedure types
403 bytecode restriction: no nested procedures
404 bytecode restriction: illegal SYSTEM function
410 variable may not have been assigned
411 no proofable return
412 illegal constructor call
413 missing constructor call
10. Indentation errors
1000 отступы можно делать только клавишей Tab (Ctrl+H)
1001 нужно исправить отступ или начать с новой строки (Ctrl+H)
| Dev/Rsrc/Errors.odc |
List of Oberon Error Numbers
Oberon microsystems 28. 2. 2003
Sec.10: E.E.Temirgaleev, F.V.Tkachov 2010-04-10
1. Incorrect use of language Oberon
0 undeclared identifier
1 multiply defined identifier
2 illegal character in number
3 illegal character in string
4 identifier does not match procedure name
5 comment not closed
6
7
8
9 "=" expected
10
11
12 type definition starts with incorrect symbol
13 factor starts with incorrect symbol
14 statement starts with incorrect symbol
15 declaration followed by incorrect symbol
16 MODULE expected
17
18
19 "." missing
20 "," missing
21 ":" missing
22
23 ")" missing
24 "]" missing
25 "}" missing
26 OF missing
27 THEN missing
28 DO missing
29 TO missing
30
31
32
33
34
35 "," or OF expected
36 CONST, TYPE, VAR, PROCEDURE, BEGIN, or END missing
37 PROCEDURE, BEGIN, or END missing
38 BEGIN or END missing
39
40 "(" missing
41 illegally marked identifier
42 constant not an integer
43 UNTIL missing
44 ":=" missing
45
46 EXIT not within loop statement
47 string expected
48 identifier expected
49 ";" missing
50 expression should be constant
51 END missing
52 identifier does not denote a type
53 identifier does not denote a record type
54 result type of procedure is not a basic type
55 procedure call of a function
56 assignment to non-variable
57 pointer not bound to record or array type
58 recursive type definition
59 illegal open array parameter
60 wrong type of case label
61 inadmissible type of case label
62 case label defined more than once
63 illegal value of constant
64 more actual than formal parameters
65 fewer actual than formal parameters
66 element types of actual array and formal open array differ
67 actual parameter corresponding to open array is not an array
68 control variable must be integer
69 parameter must be an integer constant
70 pointer or VAR / IN record required as formal receiver
71 pointer expected as actual receiver
72 procedure must be bound to a record of the same scope
73 procedure must have level 0
74 procedure unknown in base type
75 invalid call of base procedure
76 this variable (field) is read only
77 object is not a record
78 dereferenced object is not a variable
79 indexed object is not a variable
80 index expression is not an integer
81 index out of specified bounds
82 indexed variable is not an array
83 undefined record field
84 dereferenced variable is not a pointer
85 guard or test type is not an extension of variable type
86 guard or testtype is not a pointer
87 guarded or tested variable is neither a pointer nor a VAR- or IN-parameter record
88 open array not allowed as variable, record field or array element
89 ANYRECORD may not be allocated
90 dereferenced variable is not a character array
91
92 operand of IN not an integer, or not a set
93 set element type is not an integer
94 operand of & is not of type BOOLEAN
95 operand of OR is not of type BOOLEAN
96 operand not applicable to (unary) +
97 operand not applicable to (unary) -
98 operand of ~ is not of type BOOLEAN
99 ASSERT fault
100 incompatible operands of dyadic operator
101 operand type inapplicable to *
102 operand type inapplicable to /
103 operand type inapplicable to DIV
104 operand type inapplicable to MOD
105 operand type inapplicable to +
106 operand type inapplicable to -
107 operand type inapplicable to = or #
108 operand type inapplicable to relation
109 overriding method must be exported
110 operand is not a type
111 operand inapplicable to (this) function
112 operand is not a variable
113 incompatible assignment
114 string too long to be assigned
115 parameter does not match
116 number of parameters does not match
117 result type does not match
118 export mark does not match with forward declaration
119 redefinition textually precedes procedure bound to base type
120 type of expression following IF, WHILE, UNTIL or ASSERT is not BOOLEAN
121 called object is not a procedure
122 actual VAR-, IN-, or OUT-parameter is not a variable
123 type is not identical with that of formal VAR-, IN-, or OUT-parameter
124 type of result expression differs from that of procedure
125 type of case expression is neither INTEGER nor CHAR
126 this expression cannot be a type or a procedure
127 illegal use of object
128 unsatisfied forward reference
129 unsatisfied forward procedure
130 WITH clause does not specify a variable
131 LEN not applied to array
132 dimension in LEN too large or negative
133 function without RETURN
135 SYSTEM not imported
136 LEN applied to untagged array
137 unknown array length
138 NEW not allowed for untagged structures
139 Test applied to untagged record
140 untagged receiver
141 SYSTEM.NEW not implemented
142 tagged structures not allowed for NIL compatible var parameters
143 tagged pointer not allowed in untagged structure
144 no pointers allowed in BYTES argument
145 untagged open array not allowed as value parameter
150 key inconsistency of imported module
151 incorrect symbol file
152 symbol file of imported module not found
153 object or symbol file not opened (disk full?)
154 recursive import not allowed
155 generation of new symbol file not allowed
160 interfaces must be extensions of IUnknown
161 interfaces must not have fields
162 interface procedures must be abstract
163 interface records must be abstract
164 pointer must be extension of queried interface type
165 illegal guid constant
166 AddRef & Release may not be used
167 illegal assignment to [new] parameter
168 wrong [iid] - [new] pair
169 must be an interface pointer
177 IN only allowed for records and arrays
178 illegal attribute
179 abstract methods of exported records must be exported
180 illegal receiver type
181 base type is not extensible
182 base procedure is not extensible
183 non-matching export
184 Attribute does not match with forward declaration
185 missing NEW attribute
186 illegal NEW attribute
187 new empty procedure in non extensible record
188 extensible procedure in non extensible record
189 illegal attribute change
190 record must be abstract
191 base type must be abstract
192 unimplemented abstract procedures in base types
193 abstract or limited records may not be allocated
194 no supercall allowed to abstract or empty procedures
195 empty procedures may not have out parameters or return a value
196 procedure is implement-only exported
197 extension of limited type must be limited
198 obsolete oberon type
199 obsolete oberon function
2. Limitations of implementation
200 not yet implemented
201 lower bound of set range greater than higher bound
202 set element greater than MAX(SET) or less than 0
203 number too large
204 product too large
205 division by zero
206 sum too large
207 difference too large
208 overflow in arithmetic shift
209 case range too large
210 code too long
211 jump distance too large
212 illegal real operation
213 too many cases in case statement
214 structure too large
215 not enough registers: simplify expression
216 not enough floating-point registers: simplify expression
217 unimplemented SYSTEM function
218 illegal value of parameter (0 <= p < 128)
219 illegal value of parameter (0 <= p < 16)
220 illegal value of parameter
221 too many pointers in a record
222 too many global pointers
223 too many record types
224 too many pointer types
225 illegal sys flag
226 too many exported procedures
227 too many imported modules
228 too many exported structures
229 too many nested records for import
230 too many constants (strings) in module
231 too many link table entries (external procedures)
232 too many commands in module
233 record extension hierarchy too high
235 too many modifiers
240 identifier too long
241 string too long
242 too many meta names
243 too many imported variables
249 inconsistent import
250 code proc must not be exported
251 too many nested function calls
254 debug position not found
255 debug position
260 illegal LONGINT operation
265 unsupported string operation
270 interface pointer reference counting restriction violated
3. Warnings
301 implicit type cast
302 guarded variable can be side-effected
303 open array (or pointer to array) containing pointers
3.5 Analyzer Warnings
900 never used
901 never set
902 used before set
903 set but never used
904 used as varpar, possibly not set
905 also declared in outer scope
906 access/assignment to intermediate
907 redefinition
908 new definition
909 statement after RETURN/EXIT
910 for loop variable set
911 implied type guard
912 superfluous type guard
913 call might depend on evaluation sequence of params.
930 superfluous semicolon
4.0 Bytecode Errors
401 bytecode restriction: no structured assignment
402 bytecode restriction: no procedure types
403 bytecode restriction: no nested procedures
404 bytecode restriction: illegal SYSTEM function
410 variable may not have been assigned
411 no proofable return
412 illegal constructor call
413 missing constructor call
10. Indentation errors
1000 illegal indent: spaces not allowed
1001 illegal indent: wrong number of tabs or no new line
| Dev/Rsrc/ErrorsEn.odc |
Dev/Rsrc/HeapSpy.odc |
|
Dev/Rsrc/Inspect.odc |
|
Dev/Rsrc/LinkChk original.odc |
|
Dev/Rsrc/LinkChk.odc |
|
MENU "Инфо"
"Открыть журнал" "" "StdLog.Open;i21sysWindows.AlignTopLeft" ""
"Очистить журнал" "" "StdLog.Clear" ""
SEPARATOR
"Загруженные модули" "" "DevDebug.ShowLoadedModules" ""
"Глобальные переменные" "" "DevDebug.ShowGlobalVariables" "TextCmds.SelectionGuard"
"&View State" "" "DevDebug.ShowViewState" "StdCmds.SingletonGuard"
"About &Alien" "" "DevAlienTool.Analyze" "StdCmds.SingletonGuard"
"&Heap Spy..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/HeapSpy', 'Heap Spy')" ""
"Message Spy..." "" "DevMsgSpy.OpenDialog('Dev/Rsrc/MsgSpy', 'Message Spy')" ""
"Control List" "" "DevCmds.ShowControlList" "StdCmds.ContainerGuard"
SEPARATOR
"Исходный текст" "" "DevReferences.ShowSource" "TextCmds.SelectionGuard"
"Интерфейс (клиентский)" "D" "DevBrowser.ShowInterface('@c')" "TextCmds.SelectionGuard"
"Интерфейс (полный)" "" "DevBrowser.ShowInterface('@')" "TextCmds.SelectionGuard"
"Интерфейс..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/Browser', 'Браузер')" ""
"Документация" "*D" "DevReferences.ShowDocuLang('ru')" "TextCmds.SelectionGuard"
"&Documentation" "" "DevReferences.ShowDocu" "TextCmds.SelectionGuard"
"Зависимости" "" "DevDependencies.Deposit;StdCmds.Open" "TextCmds.SelectionGuard"
"Create Tool" "" "DevDependencies.CreateTool" "TextCmds.SelectionGuard"
"Обзор подсистем" "" "DevRBrowser.ShowRepository" ""
SEPARATOR
"Искать в исходниках" "" "TextCmds.InitFindDialog; DevSearch.SearchInSources" "TextCmds.SelectionGuard"
"Search In Docu (Case Sensitive)" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocu('s')" "TextCmds.SelectionGuard"
"Искать в рус. документации" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocuLang('i','ru')" "TextCmds.SelectionGuard"
"Искать в англ. документации" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocu('i')" "TextCmds.SelectionGuard"
"Сравнить тексты" "F9" "DevSearch.Compare" "TextCmds.FocusGuard"
"Проверить ссылки..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/LinkChk', 'Проверить ссылки')" ""
"Check Links..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/LinkChk', 'Check Links')" ""
"Опции анализатора..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/Analyzer', 'Анализировать')" ""
"Анализировать модуль" "" "DevAnalyzer.Analyze" "TextCmds.FocusGuard"
SEPARATOR
"Меню" "" "StdMenuTool.ListAllMenus" ""
"Обновить меню" "" "StdMenuTool.UpdateAllMenus" ""
END
MENU "Программирование"
"Режим правки" "" "StdCmds.SetEditMode" "StdCmds.SetEditModeGuard"
"Режим проводника" "" "StdCmds.SetBrowserMode" "StdCmds.SetBrowserModeGuard"
"Режим разметки (диалога)" "" "StdCmds.SetLayoutMode" "StdCmds.SetLayoutModeGuard"
"Режим маски" "" "StdCmds.SetMaskMode" "StdCmds.SetMaskModeGuard"
SEPARATOR
"Открыть модули из списка" "0" "DevCmds.OpenModuleList" "TextCmds.SelectionGuard"
"Открыть файлы из списка" "" "DevCmds.OpenFileList" "TextCmds.SelectionGuard"
SEPARATOR
"Компилировать (ру+en)" "K" "i21sysCompiler.Compile" "TextCmds.FocusGuard"
"Компилировать (en)" "*K" "DevCompiler.Compile" "TextCmds.FocusGuard"
"Компилировать и выгрузить" "" "DevCompiler.CompileAndUnload" "TextCmds.FocusGuard"
"Компилировать и перегрузить" "^F9" "i21sysCompiler.CompileAndReload" "TextCmds.FocusGuard"
"Компилировать выделенное" "" "DevCompiler.CompileSelection" "TextCmds.SelectionGuard"
"Компилировать модули из списка" "" "DevCompiler.CompileModuleList" "TextCmds.SelectionGuard"
"Перевести в English" "" "i21sysLanguage.ConvertSource" "TextCmds.FocusGuard"
"Открыть список ключ. слов" "" "StdCmds.OpenDoc('i21sys/Rsrc/ru/vocab')" ""
"Обновить список ключ. слов" "" "i21sysCompiler.SetVocabulary('ru')" ""
SEPARATOR
"Переключить проверки отступов" "*I" "i21sysCompiler.ToggleIndentChecks" "i21sysCompiler.IndentGuard"
SEPARATOR
"Удалить маркеры ошибок" "" "DevMarkers.UnmarkErrors" "TextCmds.FocusGuard"
"Следующая ошибка" "E" "DevMarkers.NextError" "TextCmds.FocusGuard"
"Раскрыть/закрыть маркер ошибки" "T" "DevMarkers.ToggleCurrent" "TextCmds.FocusGuard"
SEPARATOR
"Выполнить (процедуру)" "" "DevDebug.Execute" "TextCmds.SelectionGuard"
"Выгрузить (модуль)" "" "DevDebug.Unload" "TextCmds.FocusGuard"
"Выгрузить модули из списка" "" "DevDebug.UnloadModuleList" "TextCmds.SelectionGuard"
"Обновить ресурсы" "" "DevCmds.FlushResources" ""
"Re&validate View" "" "DevCmds.RevalidateView" "DevCmds.RevalidateViewGuard"
SEPARATOR
"Определить список профилирования" "" "DevProfiler.SetProfileList" "DevProfiler.StartGuard"
"Начать профилирование" "" "DevProfiler.Start" "DevProfiler.StartGuard"
"Закончить профилирование" "" "DevProfiler.Stop; DevProfiler.ShowProfile" "DevProfiler.StopGuard"
"Выполнить с замером времени" "" "DevProfiler.Execute" "TextCmds.SelectionGuard"
SEPARATOR
"Новая задача" "" "Info21olimpExe.NewProblem" ""
"Создать олимпиадный ЕХЕ" "" "Info21olimpExe.Make " "TextCmds.FocusGuard"
"Справка по олимпиадным EXE" "" "StdCmds.OpenBrowser('Info21olimp/Docu/Введение.odc','Справка по олимпиадным EXE')" ""
END
MENU "Инструменты"
"Размеры документа..." "" "StdCmds.InitLayoutDialog; StdCmds.OpenToolDialog('Std/Rsrc/Cmds1', 'Размеры документа')"
"StdCmds.WindowGuard"
"Размер View..." "" "StdViewSizer.InitDialog;StdCmds.OpenToolDialog('Std/Rsrc/ViewSizer', 'Размеры вьюшки')"
"StdCmds.SingletonGuard"
SEPARATOR
"Вставить коммандер" "Q" "DevCommanders.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить закрывающий коммандер" "*Q" "DevCommanders.DepositEnd; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить штамп (дата, время, версия)" "" "StdStamps.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить часы" "" "StdClocks.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить колонтитул" "" "StdHeaders.Deposit; StdCmds.PasteView; TextCmds.ShowMarks" "StdCmds.PasteViewGuard"
"Вставить OLE-объект..." "" "OleClient.InsertObject" "StdCmds.PasteViewGuard"
SEPARATOR
"&Add Scroller" "" "StdScrollers.AddScroller" "StdCmds.SingletonGuard"
"&Remove Scroller" "" "StdScrollers.RemoveScroller" "StdCmds.SingletonGuard"
SEPARATOR
"Создать ссылку" "L" "StdLinks.CreateLink" "StdLinks.CreateGuard"
"Создать мишень" "*L" "StdLinks.CreateTarget" "StdLinks.CreateGuard"
SEPARATOR
"Поместить выделенное в складку" "" "StdFolds.Create(1)" "StdFolds.CreateGuard"
"Развернуть все" "" "StdFolds.Expand" "TextCmds.FocusGuard"
"Свернуть все" "" "StdFolds.Collapse" "TextCmds.FocusGuard"
"Складка..." "" "StdCmds.OpenToolDialog('Std/Rsrc/Folds', 'Складки')" ""
SEPARATOR
"Кодировать документ" "" "StdCoder.EncodeDocument" "StdCmds.WindowGuard"
"Кодировать выделенное" "" "StdCoder.EncodeSelection" "TextCmds.SelectionGuard"
"Кодировать файл..." "" "StdCoder.EncodeFile" ""
"Кодировать список файлов" "" "StdCoder.EncodeFileList" "TextCmds.SelectionGuard"
"Раскодировать" "" "StdCoder.Decode" "TextCmds.FocusGuard"
"О закодированном материале" "" "StdCoder.ListEncodedMaterial" "TextCmds.FocusGuard"
END
MENU "Диалоги"
"Новая форма..." "" "StdCmds.OpenToolDialog('Form/Rsrc/Gen', 'Новая форма для диалога')" ""
"Открыть как простой диалог" "" "StdCmds.OpenAsAuxDialog" "StdCmds.ContainerGuard"
"Открыть как инструментальный диалог" "" "StdCmds.OpenAsToolDialog" "StdCmds.ContainerGuard"
SEPARATOR
"Вставить Tab &View" "" "StdTabViews.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
SEPARATOR
"Вставить командную кнопку" "" "Controls.DepositPushButton; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить поле ввода" "" "Controls.DepositField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить флажок" "" "Controls.DepositCheckBox; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить переключатель" "" "Controls.DepositRadioButton; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить список" "" "Controls.DepositListBox; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить список с выбором" "" "Controls.DepositSelectionBox; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить комбинированный список" "" "Controls.DepositComboBox; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить поле с прокруткой" "" "Controls.DepositUpDownField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить поле выбора цвета" "" "Controls.DepositColorField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить &Time Field" "" "Controls.DepositTimeField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить &Date Field" "" "Controls.DepositDateField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить Tree Control" "" "Controls.DepositTreeControl; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить Table Control" "" "StdTables.DepositControl; StdCmds.PasteView" "StdCmds.PasteViewGuard"
SEPARATOR
"Вставить кнопку отмены" "" "Controls.DepositCancelButton; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить надпись" "" "Controls.DepositCaption; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить рамку" "" "Controls.DepositGroup; FormCmds.InsertAround; FormCmds.SetAsFirst" "StdCmds.PasteViewGuard"
SEPARATOR
"Примеры создания простых диалогов" "" "StdCmds.OpenBrowser('i21диал/Создание простых диалогов.odc', 'Создание простых диалогов')" ""
END
MENU "*" ("DevDependencies.View")
"Expand" "" "DevDependencies.ExpandClick" "DevDependencies.SubsGuard"
"Collapse" "" "DevDependencies.CollapseClick" "DevDependencies.ModsGuard"
"New Analysis" "" "DevDependencies.NewAnalysisClick" "DevDependencies.ModsGuard"
"Hide" "" "DevDependencies.HideClick" "DevDependencies.SelGuard"
SEPARATOR
"Show All Items" "" "DevDependencies.ShowAllClick" ""
"Show Basic System" "" "DevDependencies.ToggleBasicSystemsClick" "DevDependencies.ShowBasicGuard"
"Expand All" "" "DevDependencies.ExpandAllClick" ""
"Collapse All" "" "DevDependencies.CollapseAllClick" ""
"Arrange Items" "" "DevDependencies.ArrangeClick" ""
SEPARATOR
"Create tool..." "" "DevDependencies.CreateToolClick" ""
SEPARATOR
"P&roperties..." "" "StdCmds.ShowProp" "StdCmds.ShowPropGuard"
END | Dev/Rsrc/Menus-.odc |
MENU "Инфо"
"Открыть журнал" "" "StdLog.Open;i21sysWindows.AlignTopLeft" ""
"Очистить журнал" "" "StdLog.Clear" ""
SEPARATOR
"Загруженные модули" "" "DevDebug.ShowLoadedModules" ""
"Глобальные переменные" "" "DevDebug.ShowGlobalVariables" "TextCmds.SelectionGuard"
"&View State" "" "DevDebug.ShowViewState" "StdCmds.SingletonGuard"
"About &Alien" "" "DevAlienTool.Analyze" "StdCmds.SingletonGuard"
"&Heap Spy..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/HeapSpy', 'Heap Spy')" ""
"Message Spy..." "" "DevMsgSpy.OpenDialog('Dev/Rsrc/MsgSpy', 'Message Spy')" ""
"Control List" "" "DevCmds.ShowControlList" "StdCmds.ContainerGuard"
SEPARATOR
"Исходный текст" "" "DevReferences.ShowSource" "TextCmds.SelectionGuard"
"Интерфейс (клиентский)" "D" "DevBrowser.ShowInterface('@c')" "TextCmds.SelectionGuard"
"Интерфейс (полный)" "" "DevBrowser.ShowInterface('@')" "TextCmds.SelectionGuard"
"Интерфейс..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/Browser', 'Браузер')" ""
"Документация" "*D" "DevReferences.ShowDocuLang('ru')" "TextCmds.SelectionGuard"
"&Documentation" "" "DevReferences.ShowDocu" "TextCmds.SelectionGuard"
"Зависимости" "" "DevDependencies.Deposit;StdCmds.Open" "TextCmds.SelectionGuard"
"Create Tool" "" "DevDependencies.CreateTool" "TextCmds.SelectionGuard"
"Обзор подсистем" "" "DevRBrowser.ShowRepository" ""
SEPARATOR
"Искать в исходниках" "" "TextCmds.InitFindDialog; DevSearch.SearchInSources" "TextCmds.SelectionGuard"
"Search In Docu (Case Sensitive)" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocu('s')" "TextCmds.SelectionGuard"
"Искать в рус. документации" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocuLang('i','ru')" "TextCmds.SelectionGuard"
"Искать в англ. документации" "" "TextCmds.InitFindDialog; DevSearch.SearchInDocu('i')" "TextCmds.SelectionGuard"
"Сравнить тексты" "F9" "DevSearch.Compare" "TextCmds.FocusGuard"
"Проверить ссылки..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/LinkChk', 'Проверить ссылки')" ""
"Check Links..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/LinkChk', 'Check Links')" ""
"Опции анализатора..." "" "StdCmds.OpenToolDialog('Dev/Rsrc/Analyzer', 'Анализировать')" ""
"Анализировать модуль" "" "DevAnalyzer.Analyze" "TextCmds.FocusGuard"
SEPARATOR
"Меню" "" "StdMenuTool.ListAllMenus" ""
"Обновить меню" "" "StdMenuTool.UpdateAllMenus" ""
END
MENU "Программирование"
"Режим правки" "" "StdCmds.SetEditMode" "StdCmds.SetEditModeGuard"
"Режим проводника" "" "StdCmds.SetBrowserMode" "StdCmds.SetBrowserModeGuard"
"Режим разметки (диалога)" "" "StdCmds.SetLayoutMode" "StdCmds.SetLayoutModeGuard"
"Режим маски" "" "StdCmds.SetMaskMode" "StdCmds.SetMaskModeGuard"
SEPARATOR
"Открыть модули из списка" "0" "DevCmds.OpenModuleList" "TextCmds.SelectionGuard"
"Открыть файлы из списка" "" "DevCmds.OpenFileList" "TextCmds.SelectionGuard"
SEPARATOR
"Компилировать (ру+en)" "K" "i21sysCompiler.Compile" "TextCmds.FocusGuard"
"Компилировать и перегрузить" "^F9" "i21sysCompiler.CompileAndReload" "TextCmds.FocusGuard"
"Компилировать (en)" "*K" "DevCompiler.Compile" "TextCmds.FocusGuard"
"Компилировать и выгрузить" "" "DevCompiler.CompileAndUnload" "TextCmds.FocusGuard"
"Компилировать выделенное" "" "DevCompiler.CompileSelection" "TextCmds.SelectionGuard"
"Компилировать модули из списка" "" "DevCompiler.CompileModuleList" "TextCmds.SelectionGuard"
"Перевести в English" "" "i21sysVocabulary.ConvertFocus" "TextCmds.FocusGuard"
"Открыть список ключ. слов" "" "StdCmds.OpenDoc('i21sys/Rsrc/ru/vocab')" ""
"Обновить список ключ. слов" "" "i21sysEdit.SetVocabulary('ru')" ""
SEPARATOR
"Переключить проверки отступов" "*I" "i21sysCompiler.ToggleIndentChecks" "i21sysCompiler.IndentGuard"
SEPARATOR
"Удалить маркеры ошибок" "" "DevMarkers.UnmarkErrors" "TextCmds.FocusGuard"
"Следующая ошибка" "E" "DevMarkers.NextError" "TextCmds.FocusGuard"
"Раскрыть/закрыть маркер ошибки" "T" "DevMarkers.ToggleCurrent" "TextCmds.FocusGuard"
SEPARATOR
"Выполнить (процедуру)" "" "DevDebug.Execute" "TextCmds.SelectionGuard"
"Выгрузить (модуль)" "" "DevDebug.Unload" "TextCmds.FocusGuard"
"Выгрузить модули из списка" "" "DevDebug.UnloadModuleList" "TextCmds.SelectionGuard"
"Обновить ресурсы" "" "DevCmds.FlushResources" ""
"Re&validate View" "" "DevCmds.RevalidateView" "DevCmds.RevalidateViewGuard"
SEPARATOR
"Определить список профилирования" "" "DevProfiler.SetProfileList" "DevProfiler.StartGuard"
"Начать профилирование" "" "DevProfiler.Start" "DevProfiler.StartGuard"
"Закончить профилирование" "" "DevProfiler.Stop; DevProfiler.ShowProfile" "DevProfiler.StopGuard"
"Выполнить с замером времени" "" "DevProfiler.Execute" "TextCmds.SelectionGuard"
SEPARATOR
"Новая задача" "" "Info21olimpExe.NewProblem" ""
"Создать олимпиадный ЕХЕ" "" "Info21olimpExe.Make " "TextCmds.FocusGuard"
"Справка по олимпиадным EXE" "" "StdCmds.OpenBrowser('Info21olimp/Docu/Введение.odc','Справка по олимпиадным EXE')" ""
END
MENU "Инструменты"
"Размеры документа..." "" "StdCmds.InitLayoutDialog; StdCmds.OpenToolDialog('Std/Rsrc/Cmds1', 'Размеры документа')"
"StdCmds.WindowGuard"
"Размер View..." "" "StdViewSizer.InitDialog;StdCmds.OpenToolDialog('Std/Rsrc/ViewSizer', 'Размеры вьюшки')"
"StdCmds.SingletonGuard"
SEPARATOR
"Вставить коммандер" "Q" "DevCommanders.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить закрывающий коммандер" "*Q" "DevCommanders.DepositEnd; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить штамп (дата, время, версия)" "" "StdStamps.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить часы" "" "StdClocks.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить колонтитул" "" "StdHeaders.Deposit; StdCmds.PasteView; TextCmds.ShowMarks" "StdCmds.PasteViewGuard"
"Вставить OLE-объект..." "" "OleClient.InsertObject" "StdCmds.PasteViewGuard"
SEPARATOR
"&Add Scroller" "" "StdScrollers.AddScroller" "StdCmds.SingletonGuard"
"&Remove Scroller" "" "StdScrollers.RemoveScroller" "StdCmds.SingletonGuard"
SEPARATOR
"Создать ссылку" "L" "StdLinks.CreateLink" "StdLinks.CreateGuard"
"Создать мишень" "*L" "StdLinks.CreateTarget" "StdLinks.CreateGuard"
SEPARATOR
"Поместить выделенное в складку" "" "StdFolds.Create(1)" "StdFolds.CreateGuard"
"Развернуть все" "" "StdFolds.Expand" "TextCmds.FocusGuard"
"Свернуть все" "" "StdFolds.Collapse" "TextCmds.FocusGuard"
"Складка..." "" "StdCmds.OpenToolDialog('Std/Rsrc/Folds', 'Складки')" ""
SEPARATOR
"Кодировать документ" "" "StdCoder.EncodeDocument" "StdCmds.WindowGuard"
"Кодировать выделенное" "" "StdCoder.EncodeSelection" "TextCmds.SelectionGuard"
"Кодировать файл..." "" "StdCoder.EncodeFile" ""
"Кодировать список файлов" "" "StdCoder.EncodeFileList" "TextCmds.SelectionGuard"
"Раскодировать" "" "StdCoder.Decode" "TextCmds.FocusGuard"
"О закодированном материале" "" "StdCoder.ListEncodedMaterial" "TextCmds.FocusGuard"
END
MENU "Диалоги"
"Новая форма..." "" "StdCmds.OpenToolDialog('Form/Rsrc/Gen', 'Новая форма для диалога')" ""
"Открыть как простой диалог" "" "StdCmds.OpenAsAuxDialog" "StdCmds.ContainerGuard"
"Открыть как инструментальный диалог" "" "StdCmds.OpenAsToolDialog" "StdCmds.ContainerGuard"
SEPARATOR
"Вставить Tab &View" "" "StdTabViews.Deposit; StdCmds.PasteView" "StdCmds.PasteViewGuard"
SEPARATOR
"Вставить командную кнопку" "" "Controls.DepositPushButton; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить поле ввода" "" "Controls.DepositField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить флажок" "" "Controls.DepositCheckBox; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить переключатель" "" "Controls.DepositRadioButton; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить список" "" "Controls.DepositListBox; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить список с выбором" "" "Controls.DepositSelectionBox; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить комбинированный список" "" "Controls.DepositComboBox; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить поле с прокруткой" "" "Controls.DepositUpDownField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить поле выбора цвета" "" "Controls.DepositColorField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить &Time Field" "" "Controls.DepositTimeField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить &Date Field" "" "Controls.DepositDateField; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить Tree Control" "" "Controls.DepositTreeControl; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить Table Control" "" "StdTables.DepositControl; StdCmds.PasteView" "StdCmds.PasteViewGuard"
SEPARATOR
"Вставить кнопку отмены" "" "Controls.DepositCancelButton; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить надпись" "" "Controls.DepositCaption; StdCmds.PasteView" "StdCmds.PasteViewGuard"
"Вставить рамку" "" "Controls.DepositGroup; FormCmds.InsertAround; FormCmds.SetAsFirst" "StdCmds.PasteViewGuard"
SEPARATOR
"Примеры создания простых диалогов" "" "StdCmds.OpenBrowser('i21диал/Создание простых диалогов.odc', 'Создание простых диалогов')" ""
END
MENU "*" ("DevDependencies.View")
"Expand" "" "DevDependencies.ExpandClick" "DevDependencies.SubsGuard"
"Collapse" "" "DevDependencies.CollapseClick" "DevDependencies.ModsGuard"
"New Analysis" "" "DevDependencies.NewAnalysisClick" "DevDependencies.ModsGuard"
"Hide" "" "DevDependencies.HideClick" "DevDependencies.SelGuard"
SEPARATOR
"Show All Items" "" "DevDependencies.ShowAllClick" ""
"Show Basic System" "" "DevDependencies.ToggleBasicSystemsClick" "DevDependencies.ShowBasicGuard"
"Expand All" "" "DevDependencies.ExpandAllClick" ""
"Collapse All" "" "DevDependencies.CollapseAllClick" ""
"Arrange Items" "" "DevDependencies.ArrangeClick" ""
SEPARATOR
"Create tool..." "" "DevDependencies.CreateToolClick" ""
SEPARATOR
"P&roperties..." "" "StdCmds.ShowProp" "StdCmds.ShowPropGuard"
END | Dev/Rsrc/Menus.odc |
Dev/Rsrc/MsgSpy.odc |
|
STRINGS
OK, Cancel, Close, Apply см. System
(Dev)Analyzer (Dev)Analyzer
VAR Parameter VAR параметры
Exported Items Экспортированные элементы
Levels Уровни
Intermediate Items Промежуточные элементы
Side Effects Побочные эффекты
Semicolons Точки с запятой
Statements in операторов в
Reset Options Восстановить опции
Save Options Сохранить опции
Load Options Загрузить опции
Analyze Анализировать
&Font... Шрифт...
(Dev)Inspect (Dev)Inspect
Control: Тип:
Lin&k: Связан с:
&Label: Ярлык:
&Guard: Охрана:
&Notifier: Уведомитель:
Option 0 Опция 0
Option 1 Опция 1
Option 2 Опция 2
Option 3 Опция 3
Option 4 Опция 4
Le&vel: Уровень:
Ne&xt Следующий
(Dev)LinkChk (Dev)LinkChk
&All subsystems Все подсистемы
&Global Docu and Mod directories Общая документация и папки Mod
&Subsystem: Подсистема:
Check Links Проверить ссылки
&List Links Список ссылок
Folder Папка:
(Dev)Browser (Dev)Browser
Flat Interface Плоский интерфейс
Interface Hints Подсказки
Formatted Форматированный
Show Client Interface Интерфейс для клиента
Show Extension Interface Интерфейс для расширений
Show Complete Interface Полный интерфейс
(Dev)HeapSpy (Dev)HeapSpy
Heap Information Информация о куче
Allocated: Размещено:
Heap size: Размер кучи:
Clusters: Кластеров:
Show Heap Показать кучу
(Dev)MsgSpy (Dev)MsgSpy
Clear List Очистить список
Clear Log Очистить журнал (Log)
Mark New Messages in List Отметить новые сообщения в списке
Show Messages in Log Показать сообщения в журнале (Log)
Add MsgSpy Добавить MsgSpy
в модуле MstSpy: ----
--AddView Добавить вьюшку
--RemoveView Убрать вьюшку
Browse... Browse...
Browser Browser
Command Package (Form) Command Package (Form)
Command Package (Text) Command Package (Text)
Control: Элемент:
Create Create
Create Subsystem Create Subsystem
Document Size Document Size
File Name: File Name:
Generate Generate
Global Docu and Mod directories &Global Docu and Mod directories
Guard: Охрана:
Heap Spy Heap Spy
Label: Ярлык:
Level: Уровень:
Message Spy Message Spy
Module Name: Module Name:
New Form New Form
Next Следующий элемент
Notifier: &Уведомитель:
Subsystem: Subsystem:
&Subsystem: &Subsystem:
Type Library: Type Library:
View + Model in one Module View + Model in one Module
View + Model in three Modules View + Model in three Modules
View without Model View without Model
View Size View Size
Zoom Zoom
CannotOpenFile не удалось открыть файл ^0
InsertMarkers Вставка маркеров ошибок
DeleteMarkers Удаление маркеров ошибок
Log Рабочий журнал
LogSettings Настройки рабочего журнала
ModuleNotFound модуль ^0 не найден
NoAlienView no alien view
NoItemNameSelected не выделено имя
NoModuleNameSelected не выделено имя модуля
NoTargetFocusFound no target focus found
NoTextFileFound не найден текстовый файл ^0
NoTextViewFound не найдена текстовая вьюшка
NotOnlyModNames должны быть выделены только имена модулей
NoSelectionFound ничего не выделено
NoSingletonFound объект-одиночка не найден
NoSuchItemExported ^1 не экспортируется из ^0
NoSuchExtItemExported ^1 не экспортируется из переопределения ^0
NotOnlyFileNames выделены должны быть только имена файлов
StringExpected ожидается литерная цепочка
IllegalKind неверное значение типа подсистемы
PrefixTooShort слишком короткий префикс подсистемы (должен быть от 3 до 8 литер)
CannotTranslate не удалось транслировать шаблоны исходного кода
IllegalSyntax неверный синтаксис префикса подсистемы (начать с заглавных, затем следуют маленькие буквы или цифры)
Change Обновление
Unloading выгружается ^0
Unknown неизвестно
Analyzing Анализирую
Ok ok
Failed неудача
OneErrorDetected найдена одна ошибка
ErrorsDetected ошибок найдено
Compiling компилируется
Converting converting
Conversion Conversion
ModuleName имя модуля
BytesUsed байт использовано
Clients клиенты
Compiled скомпилирован
Loaded загружен
Linked слинкован
FileAccessPathsInUse используется путей к файлам:
FontsInUse используется шрифтов:
HeapBytesAllocated выделено байт в куче:
SourcefileNotFound исходник модуля ^0 не найден
Unloaded старый модуль ^0 выгружен
UnloadingFailed не удалось выгрузить модуль ^0
NotFound старый модуль ^0 не найден
NoModNameFound не найдено имя модуля
ProcInUnloadedMod процедура в выгруженном модуле
IllegalAddress недопустимый адрес:
IllegalPointer недопустимый указатель !!!
Undefined неопределено:
UnknownFormat неизвестный формат:
HeapObject Heap Object
Variables Переменные
LoadedModules Загруженные модули
LoadedTopModules Загруженные модули верхнего уровня
Commands Команды
Resources Ресурсы
Trap Трап
Update Обновить
Fields поля
Elements элементы
RemoteState Remote State
RemoteVariables Remote Variables
RemoteModules Remote Modules
ShowPrecedingObject показать предыдущий объект
ShowGlobalVariables показать глобальные переменные
ShowSourcePosition показать место в исходном тексте
ShowReferencedObject показать объект по ссылке
UpdateWindow обновить содержимое окна
Option Опция
Controls.PushButton Командная кнопка
Controls.PushButton.Opt0 По умолчанию
Controls.PushButton.Opt1 Отмена
Controls.CheckBox Флажок
Controls.RadioButton Переключатель
Controls.Field Текстовое поле
Controls.Field.Opt0 Влево
Controls.Field.Opt1 Вправо
Controls.Field.Opt2 Несколько строк
Controls.Field.Opt3 Пароль
Controls.ListBox Список
Controls.ListBox.Opt0 Сортирован
Controls.SelectionBox Список с выбором
Controls.SelectionBox.Opt0 Сортирован
Controls.ComboBox Комбинир. список
Controls.ComboBox.Opt0 Сортирован
Controls.Caption Название
Controls.Caption.Opt0 Влево
Controls.Caption.Opt1 Вправо
Controls.Group Группа
Controls.TreeControl.Opt0 Сортировка
Controls.TreeControl.Opt1 Lines
Controls.TreeControl.Opt2 Кнопки
Controls.TreeControl.Opt3 Lines/Buttons at root
Controls.TreeControl.Opt4 Иконки каталогов
StdTables.Control StdTables.Table
OleClient.View OLE-объект
DevBrowser.ImportSymFile Символьный файл
DevBrowser.ImportCodeFile Кодовый файл
msec миллисек
Module Модуль
PercentPerModule % в модуле
Procedure Процедура
PercentPerProc % в процедуре
Samples кол-во проверок:
InProfiledModules в профилируемых модулях
Other прочие
Profile Профиль
NoBasicType тип переменной ^0 не основной
NoVariable ^0 не является переменной
NoVarName не выделено имени переменной
NoQualident не выделено уточненного имени
NoModule модуль ^0 не найден
NoModuleName не выделено имени модуля
NoSourcePosInfoIn no source position info in ^0
NoSelectionOrCaret no selection or caret
NoText нет текста
AlreadyExists Не могу создать подсистему, потому что каталог уже существует
InconsistentLinks Висячие ссылки
Links Список всех ссылок
AddView Добавить вьюшку
RemoveView Убрать вьюшку
BasicSystems System, Text, Std, Ole
Implicit.CommStreams CommTCP
Implicit.Config StdLog
Implicit.Containers StdCmds, HostMenus
Implicit.Dates HostDialog
Implicit.Dialog HostDialog, StdLog, StdInterpreter, Views
Implicit.Files HostFiles
Implicit.Fonts HostFonts
Implicit.Init StdMenuTool, Config
Implicit.Kernel StdLoader, Init, Config
Implicit.Log StdLog
Implicit.Mechanisms HostMechanisms
Implicit.Printers HostPrinters
Implicit.Printing Documents
Implicit.Sequencers Windows
Implicit.Views HostDialog, StdDialog, Windows
Implicit.Windows HostWindows
Implicit.DevProfiler DevDebug
Implicit.FormViews FormControllers
Implicit.HostDialog StdCmds, TextCmds
Implicit.HostMenus StdMenuTool
Implicit.HostPrinters StdCmds
Implicit.MailerCmds MailerFolds
Implicit.StdCFrames HostCFrames
Implicit.StdCmds TextViews
Implicit.StdMeters StdCmds
Implicit.StdTabViews HostTabFrames
Implicit.TextViews TextControllers
Location Location
Count Count
Searching Поиск
NoMatchFound соответствий не найдено.
OpenFindCmd StdCmds.OpenToolDialog('Text/Rsrc/Cmds', 'Найти / Заменить')
OpenFindCmdNotFound команда открытия диалога поиска не найдена
DevDebug.Trap **************
division by zero деление на нуль
integer overflow целочисленное переполнение
stack overflow переполнение стека
string too long слишком длинная цепочка литер
index out of range индекс вне диапазона
value out of range значение вне диапазона
function without RETURN функция без ВЕРНУТЬ/RETURN
type guard охрана типа
infinite real result вещественная бесконечность
real underflow потеря точности вещественного значения
real overflow вещественное переполнение
undefined real result ( неопределенный вещественный результат
not a number не число
keyboard interrupt прерывание с клавиатуры
NIL dereference разыменование NIL'а
(not yet implemented) (еще не реализовано)
TRAP ТРАП
(invariant violated) (нарушен инвариант)
(postcondition violated) (нарушено постусловие)
(precondition violated) (нарушено предусловие)
(call of obsolete procedure) (вызов устаревшей процедуры)
invalid CASE invalid CASE
invalid WITH invalid WITH
implied type guard implied type guard
| Dev/Rsrc/Strings.odc |
BlackBox Object File Format
bj 19.04.2001 updated file header with correct file tag and added processor field. Added semantic part of this docu.
bh 12.12.95
Syntax:
ObjFile = HeaderBlk MetaBlk DescBlk CodeBlk FixBlk UseBlk.
HeaderBlk = OFTag processor4 headsize4 metasize4 descsize4 codesize4 datasize4 nofimp modname {impname} Align.
OFTag = 6FX 4FX 43X 46X.
MetaBlk = RefBlk Align ExpBlk PtrBlk FldBlk ImpBlk Names Consts Align.
DescBlk = ModBlk Align TDescBlk.
ExpBlk = Directory.
Directory = numobj4 {Object}.
Object = fprint4 offs4 id4 Struct.
Struct = form4 | strRef4.
PtrBlk = {offset4}.
FldBlk = {Directory}.
ImpBlk = {0.4}.
Names = {char}.
Consts = {byte}.
Align = {0X}.
ModBlk = 0.4 opts4 0.4 0.4 term4 nofimp4 nofptr4 csize4 dsize4 rsize4
codeRef4 dataRef4 refsRef4 namesRef4 ptrsRef4 impRef4 expRef4 name.
TDescBlk = {RecDesc | ArrDesc | DArrDesc | PtrDesc | ProcDesc | FieldList}.
RecDesc = 0.4 {methRef4} size4 modRef4 id4 {btypRef4} flistRef4 {ptrOffs4} sent4.
ArrDesc = nofele4 modRef4 id4 btypRef4.
PtrDesc = 0.4 modRef4 id4 btypRef4.
ProcDesc = fprint4 modRef4 id4.
FieldList = Directory.
FixBlk = newreclink newarrlink metalink desclink codelink datalink.
link = {fixupadr offset} 0X.
UseBlk = {{UConst | UType | UVar | UProc} 0X}.
UConst = 1X name fprint.
UType = 2X name fprint opt link.
UVar = 3X name fprint link.
UProc = 4X name fprint link.
RefBlk = {0F8X procend name {Mode Form adr name}}.
Mode = Var | VarPar.
Var = 0FDX.
VarPar = 0FFX.
Form = Bool | Char | LChar | SInt | Int | LInt | Real | LReal | Set | LargeInt | AnyRec | AnyPtr | Pointer | Proc | String | Struct.
Bool = 1X.
Char = 2X.
LChar = 3X.
SInt = 4X.
Int = 5X.
LInt = 6X.
Real = 7X.
LReal = 8X.
Set = 9X.
LargeInt = 0AX.
AnyRec = 0BX.
AnyPtr = 0CX.
Pointer = 0DX.
Proc = 0EX.
String = 0FX.
Struct = 10X descRef4.
Semantics:
Header
Contains the sizes of the different blocks, the name of the module and a list of the names of the imported modules.
Meta
Meta information about the module. Only used by the modules Meta and DevDebug.
Desc
Meta information about the module which should stay in memory even when the module have been unloaded. Consists of two parts corresponding to the types Kernel.Module and Kernel.Type. The layout is made so the memory addresses can be directly mapped to variables of these types.
Code
Contains the code for the module. The address of the Code section is the entry point to the body of the module.
Data
Memory space for the variables. Variables are stored in reversed order, i.e. the last global variable starts at this address.
Fixup
The fixup bulk contains links into the different memory blocks where there is a need for updating the addresses. The following links exist:
newreclink link to the memory location where the procedure pointer for allocating new records is stored
newarrlink link to the memory location where the procedure pointer for allocating new arrays is stored
metalink link to the start of the fixup links in the meta bulk
desclink link to the start of the fixup links in the desc bulk
codelink link to the start of the fixup links in the code bulk
datalink link to the start of the fixup links in the data bulk
For each memory block there is a list of fixup links. A link consists of two parts:
fixupadr the start of the memory location in need of fixup
offset the offset within the memory location to the first address which needs a fixup
When fixupadr = 0X then the end of the list of fixups for the corresponding memory block has been reached.
At the position given by fixupadr + offset there are four bytes which should be overwritten with the new fixed value. But before writning to this address the four bytes should be read and interpreted as follows:
- The most significant byte indicates the type of fixup that should be done.
- The other three bytes, interpreted as an INTEGER, x.
The type and x are used as in the table.
Fixup Types (mem[adr] = id * 2^24 + x, mem[adr] := value)
id type value next adr
100 absolute objadr + offs x
101 relative objadr + offs - adr - 4 x
102 copy mem[objadr + offs] x
103 table objadr + x adr + 4
104 table end objadr + x -
x = 0 indicates end of fixup for this address.
Use
For each imported module this section contains a list of imported constants, types, variabled and procedures. With exception for constants they all need to be fixed in the same way as other links.
| Dev/Spec/ObjFile.odc |
HostPackedFiles
DEFINITION HostPackedFiles;
CONST magicnum = 4711;
PROCEDURE IsInstalled;
PROCEDURE RestoreFilesDir;
PROCEDURE SetFilesDir;
END HostPackedFiles.
Module HostPackedFiles is an implementation of Files.Directory. The implementation is basically a wrapper around the HostFiles implementation with one major differnce: when a file is not present in the file system HostPackedFiles searches the current executable for files packed in there by DevPacker.
Since HostPackedFiles wraps HostFiles it cannot work unless HostFiles is installed first. For HostPackedFiles to work properly it is also important that the exe-file has the right format. This format is explained below.
Whenever HostPackedFiles is loaded it trys to install itself as the Files.Directory. There are two preconditions for HostPackedFiles to be installed; first the current Files.Directory must be a HostFiles implementation and secondly there must be some files packed into the current directory.
CONST magicnum
Used as a magic number in the exe-file to mark the position of the address to the file table. This constant is only exported to make it possible for DevPacker to write the appropriate magic number into the exe-file.
PROCEDURE SetFilesDir
If no files are found in the current executable a call to this procedure does nothing. Otherwise it checks if HostFiles is the current directory of Files. In that case it holds a reference to this directory and calls Files.SetDir with the HostPackedFiles.Directory. This procedure is called the first time the module is loaded.
PROCEDURE RestoreFilesDir
Calls Files.SetDir with the original directory saved by SetFilesDir. Thus, uninstalling HostPackedFiles as the current Files directory.
PROCEDURE IsInstalled
Checks wether HostPackedFiles.Directory is the directory used by Files or not. This is not always a reliable test, since HostPackedFiles installs itself when it is loaded. A call to IsInstalled may cause HostPackedFiles to be installed. If, however, the result is that HostPackedFiles is not installed then this is a reliable result.
Executable File Format Required by HostPackedFiles
(* Should this really be here? *)
When DevPacker is used to pack files into an executable file it simply appends its information at the end of the file. This means that the first part of such an executable is exactly the same as a normal Windows executable. This text therefore only explains the appended information that DevPacker adds to the file.
The format of the exe-file can be separated into four parts:
1) A Windows executable part
2) Contents of files packed in by DevPacker
3) File table of the files packed in by DevPacker
4) Address of the file table
The four parts appear in this order in the executable, which makes the executable look like Figure 1.
Figure 1. Executable file structure.
The first part contains the executable generated by the linker command and all Windows resources, such as icons and cursors. Since DevPacker only appends information to the file, it is important that all resources are added before files are packed into the executable. Otherwise the information about how to find the files within the executable will be destroyed.
The second part is the content of all the files packed in by DevPacker. The contents are simply an array of bytes. To know where a file starts and how long it is the third part, the file table, is needed. The file table has the structure described in Figure 2.
Figure 2. File table structure.
To avoid sorting each time the HostPackedFiles is loaded, DevPacker does the sorting when files are packed. HostPackedFiles therefore assumes that the files are listed in reversed alphabetical order.
The last eight bytes of the executable are interpreted as two integers, having the meaning shown in Figure 3.
Figure 3. Address of the file table.
If the first integer does not equal HostPackedFiles.magicnum it is assumed that no files are packed into the executable. Otherwise the next integer is interpreted as the address of the file table within the executable.
| Dev/Spec/PackedFiles.odc |
Stores File Format
Stream = { Byte | Structure }.
Structure = Nil | Link | Object.
Nil = nil Comment Next.
Link = (link | newlink) ObjectId Comment Next.
(* newlink and link have same meaning in new format, but newlink causes assertion trap in old *)
(* if Next = 0 & Comment = 0 indecates end of link chain, whereas Next = 0 & Comment = 1 indicates
next store at Pos(Next) + 4 *)
Object = (elem | store) TypePath Comment Next Down Length Stream.
(* elem = Models.Model-derived type; for backward comp only *)
Comment = 00000000. (* extension hook *)
ObjectId = 32bits. (* index into object dictionary *)
Next = 32bits. (* offset to next object on same nesting level; 00000000 if none *)
Down = 32bits. (* offset to first object on next lower nesting level; 00000000 if none *)
Length = 32bits. (* length of this object (including all subobjects) *)
TypePath = OldType | NewType. (* sequence of type names from most precise to root base type *)
OldType = oldType TypeId.
NewType = { NewExtension } (NewBase | OldType).
NewExtension = newExt TypeName.
NewBase = newBase TypeName.
TypeName = String.
TypeId = 32bits. (* index into type dictionary *)
nil = 80. (* nil store *)
link = 81. (* link to another elem in same file *)
store = 82. (* general store *)
elem = 83. (* elem store *)
newlink = 84. (* link to another non-elem store in same file *)
| Dev/Spec/StoresFileFormat.odc |
Oberon/F Symbol File Format bh
SymFile = tag4 processor version Module { Object } .
Module = 0 | negmno | [ LIB name ] MNAME name .
Object = [ SYS value ] [ LIB name ] [ ENTRY name ]
( Constant name
| TYPE Struct
| ALIAS Struct name
| (RVAR | VAR) Struct name
| (XPRO | IPRO) Signature name
| CPRO Signature len { code1 } name
).
Constant = CHAR8 value1
| CHAR16 value2
| BOOL ( FALSE | TRUE )
| ( INT8 | INT16 | INT32 | INT64 | SET ) value
| REAL32 value4
| REAL64 value8
| STRING8 name
| STRING16 length utf8string
| NIL .
Struct = negref
| STRUCT Module name [ SYS value ] [ LIB name ] [ ENTRY name ] [ STRING name ]
( PTR Struct
| ARR Struct nofElem
| DARR Struct
| ( REC | ABSREC | EXTREC | FINREC ) Struct size align nofMeth { Field } { Method } END
| PRO Signature
| ALIAS Struct
) .
Field = ( FLD | RFLD ) Struct name offset | ( HDPTR | SYS value | HDPRO ) offset .
Method = [ IMPO ] [ ENTRY name ]
( TPRO | ABSPRO | EMPPRO | EXTPRO | FINPRO ) Signature name methno | HDTPRO methno .
Signature = Struct { [ SYS value ] ( VALPAR | VARPAR | INPAR | OUTPAR ) Struct offset name } END .
MNAME = 16 BYTE = 1 byte = 1
END = 18 BOOL = 2 boolean = 2
TYPE = 19 CHAR8 = 3 char8 = 3
ALIAS = 20 INT8 = 4 int8 = 4
VAR = 21 INT16 = 5 int16 = 5
RVAR = 22 INT32 = 6 int32 = 6
VALPAR = 23 REAL32 = 7 real32 = 7
VARPAR = 24 REAL64 = 8 real64 = 8
FLD = 25 SET = 9 set = 9
RFLD = 26 STRING8 = 10
HDPTR = 27 NIL = 11
HDPRO = 28 notyp = 12
TPRO = 29 sysptr = 13
HDTPRO = 30 anypointer = 14
XPRO = 31 anyrecord = 15
IPRO = 32 CHAR16 = 16 char16 = 16
CPRO = 33 STRING16 = 17
STRUCT = 34 INT64 = 18 int64 = 18
SYS = 35 result = 20
PTR = 36 iunknown = 21
ARR = 37 ptriunk = 22
DARR = 38 guid = 23
REC = 39 HDUTPTR = 41
PRO = 40 LIB = 42
INPAR = 25 ENTRY = 43 FALSE = 0
OUTPAR = 26 FINPRO = 31 TRUE = 1
FINREC = 25 ABSPRO = 32
ABSREC = 26 EMPPRO = 33
EXTREC = 27 EXTPRO = 34 IMPO = 22 | Dev/Spec/SymFile.odc |
Character Set
Contents
Charactersetlisting
ControlcodesusedinBlackBox
The character set for the Component Pascal SHORTCHAR data type is an 8-bit character set based on the ISO 8859-1 standard. It includes the ASCII (American Standard Code for Information Interchange) and the so-called Latin-1 extension to ASCII. Latin-1 includes most characters necessary for writing in languages which are based on Latin.
The character set for the Component Pascal CHAR data type is Unicode.
Both ASCII and Latin-1 contain slots for control characters, which are character codes used for various purposes, but which do not correspond to any glyph, i.e. visual representation of a character.
For BlackBox, several punctuation marks from the 16-bit Unicode standard have been mapped into the unused upper control code portion of Latin-1.
Character set listing
The following list gives the names of every non-control code in the character set. The same naming conventions are used as in the Unicode standard, of which the Component Pascal character set is a subset.
Hex Char Name Comment
20 SPACE
21 ! EXCLAMATION MARK
22 " QUOTATION MARK
23 # NUMBER SIGN
24 $ DOLLAR SIGN
25 % PERCENT SIGN
26 & AMPERSAND
27 ' APOSTROPHE-QUOTE
28 ( OPENING PARENTHESIS
29 ) CLOSING PARENTHESIS
2A * ASTERISK
2B + PLUS SIGN
2C , COMMA
2D - HYPHEN-MINUS use as minus only, for hyphens
see codes 90, 91 and AD
2E . PERIOD
2F / SLASH
30 0 DIGIT ZERO
31 1 DIGIT ONE
32 2 DIGIT TWO
33 3 DIGIT THREE
34 4 DIGIT FOUR
35 5 DIGIT FIVE
36 6 DIGIT SIX
37 7 DIGIT SEVEN
38 8 DIGIT EIGHT
39 9 DIGIT NINE
3A : COLON
3B ; SEMICOLON
3C < LESS-THAN SIGN
3D = EQUAL SIGN
3E > GREATER-THAN SIGN
3F ? QUESTION MARK
40 @ COMMERCIAL AT
41 A LATIN CAPITAL LETTER A
42 B LATIN CAPITAL LETTER B
43 C LATIN CAPITAL LETTER C
44 D LATIN CAPITAL LETTER D
45 E LATIN CAPITAL LETTER E
46 F LATIN CAPITAL LETTER F
47 G LATIN CAPITAL LETTER G
48 H LATIN CAPITAL LETTER H
49 I LATIN CAPITAL LETTER I
4A J LATIN CAPITAL LETTER J
4B K LATIN CAPITAL LETTER K
4C L LATIN CAPITAL LETTER L
4D M LATIN CAPITAL LETTER M
4E N LATIN CAPITAL LETTER N
4F O LATIN CAPITAL LETTER O
50 P LATIN CAPITAL LETTER P
51 Q LATIN CAPITAL LETTER Q
52 R LATIN CAPITAL LETTER R
53 S LATIN CAPITAL LETTER S
54 T LATIN CAPITAL LETTER T
55 U LATIN CAPITAL LETTER U
56 V LATIN CAPITAL LETTER V
57 W LATIN CAPITAL LETTER W
58 X LATIN CAPITAL LETTER X
59 Y LATIN CAPITAL LETTER Y
5A Z LATIN CAPITAL LETTER Z
5B [ OPENING-SQUARE BRACKET
5C \ BACKSLASH
5D ] CLOSING SQUARE BRACKET
5E ^ SPACING CIRCUMFLEX
5F _ SPACING UNDERSCORE
60 ` SPACING GRAVE
61 a LATIN SMALL LETTER A
62 b LATIN SMALL LETTER B
63 c LATIN SMALL LETTER C
64 d LATIN SMALL LETTER D
65 e LATIN SMALL LETTER E
66 f LATIN SMALL LETTER F
67 g LATIN SMALL LETTER G
68 h LATIN SMALL LETTER H
69 i LATIN SMALL LETTER I
6A j LATIN SMALL LETTER J
6B k LATIN SMALL LETTER K
6C l LATIN SMALL LETTER L
6D m LATIN SMALL LETTER M
6E n LATIN SMALL LETTER N
6F o LATIN SMALL LETTER O
70 p LATIN SMALL LETTER P
71 q LATIN SMALL LETTER Q
72 r LATIN SMALL LETTER R
73 s LATIN SMALL LETTER S
74 t LATIN SMALL LETTER T
75 u LATIN SMALL LETTER U
76 v LATIN SMALL LETTER V
77 w LATIN SMALL LETTER W
78 x LATIN SMALL LETTER X
79 y LATIN SMALL LETTER Y
7A z LATIN SMALL LETTER Z
7B { OPENING CURLY BRACKET
7C | VERTICAL BAR
7D } CLOSING CURLY BRACKET
7E ~ TILDE
7F reserved
80 .. 8A reserved
8B ‹ ZERO WIDTH SPACE (Unicode 200B)
8C .. 8E reserved
8F Џ DIGIT SPACE (not in Unicode)
90 ђ HYPHEN (Unicode 2010)
91 NON-BREAKING HYPHEN (Unicode 2011)
92 .. 9F reserved
A0 NON-BREAKING SPACE
A1 Ў INVERTED EXCLAMATION MARK
A2 ў CENT SIGN
A3 Ј POUND SIGN
A4 CURRENCY SIGN
A5 Ґ YEN SIGN
A6 BROKEN VERTICAL BAR
A7 SECTION SIGN
A8 Ё SPACING DIAERESIS
A9 COPYRIGHT SIGN
AA Є FEMININE ORDINAL INDICATOR
AB LEFT POINTING GUILLEMET
AC NOT SIGN
AD SOFT HYPHEN
AE REGISTERED TRADE MARK SIGN
AF Ї SPACING MACRON
B0 DEGREE SIGN
B1 PLUS-OR-MINUS SIGN
B2 І SUPERSCRIPT DIGIT TWO
B3 і SUPERSCRIPT DIGIT THREE
B4 ґ SPACING ACUTE
B5 MICRO SIGN
B6 PARAGRAPH SIGN
B7 MIDDLE DOT
B8 ё SPACING CEDILLA
B9 № SUPERSCRIPT DIGIT ONE
BA є MASCULINE ORDINAL INDICATOR
BB RIGHT POINTING GUILLEMET
BC ј FRACTION ONE QUARTER
BD Ѕ FRACTION ONE HALF
BE ѕ FRACTION THREE QUARTERS
BF ї INVERTED QUESTION MARK
C0 А LATIN CAPITAL LETTER A GRAVE
C1 Б LATIN CAPITAL LETTER A ACUTE
C2 В LATIN CAPITAL LETTER A CIRCUMFLEX
C3 Г LATIN CAPITAL LETTER A TILDE
C4 Д LATIN CAPITAL LETTER A DIAERESIS
C5 Е LATIN CAPITAL LETTER A RING
C6 Ж LATIN CAPITAL LETTER A E
C7 З LATIN CAPITAL LETTER C CEDILLA
C8 И LATIN CAPITAL LETTER E GRAVE
C9 Й LATIN CAPITAL LETTER E ACUTE
CA К LATIN CAPITAL LETTER E CIRCUMFLEX
CB Л LATIN CAPITAL LETTER E DIAERESIS
CC М LATIN CAPITAL LETTER I GRAVE
CD Н LATIN CAPITAL LETTER I ACUTE
CE О LATIN CAPITAL LETTER I CIRCUMFLEX
CF П LATIN CAPITAL LETTER I DIAERESIS
D0 Р LATIN CAPITAL LETTER ETH
D1 С LATIN CAPITAL LETTER N TILDE
D2 Т LATIN CAPITAL LETTER O GRAVE
D3 У LATIN CAPITAL LETTER O ACUTE
D4 Ф LATIN CAPITAL LETTER O CIRCUMFLEX
D5 Х LATIN CAPITAL LETTER O TILDE
D6 Ц LATIN CAPITAL LETTER O DIAERESIS
D7 Ч MULTIPLICATION SIGN
D8 Ш LATIN CAPITAL LETTER 0 SLASH
D9 Щ LATIN CAPITAL LETTER U GRAVE
DA Ъ LATIN CAPITAL LETTER U ACUTE
DB Ы LATIN CAPITAL LETTER U CIRCUMFLEX
DC Ь LATIN CAPITAL LETTER U DIAERESIS
DD Э LATIN CAPITAL LETTER Y ACUTE
DE Ю LATIN CAPITAL LETTER THORN
DF Я LATIN SMALL LETTER SHARP S
E0 а LATIN SMALL LETTER A GRAVE
E1 б LATIN SMALL LETTER A ACUTE
E2 в LATIN SMALL LETTER A CIRCUMFLEX
E3 г LATIN SMALL LETTER A TILDE
E4 д LATIN SMALL LETTER A DIAERESIS
E5 е LATIN SMALL LETTER A RING
E6 ж LATIN SMALL LETTER A E
E7 з LATIN SMALL LETTER C CEDILLA
E8 и LATIN SMALL LETTER E GRAVE
E9 й LATIN SMALL LETTER E ACUTE
EA к LATIN SMALL LETTER E CIRCUMFLEX
EB л LATIN SMALL LETTER E DIAERESIS
EC м LATIN SMALL LETTER I GRAVE
ED н LATIN SMALL LETTER I ACUTE
EE о LATIN SMALL LETTER I CIRCUMFLEX
EF п LATIN SMALL LETTER I DIAERESIS
F0 р LATIN SMALL LETTER ETH
F1 с LATIN SMALL LETTER N TILDE
F2 т LATIN SMALL LETTER O GRAVE
F3 у LATIN SMALL LETTER O ACUTE
F4 ф LATIN SMALL LETTER O CIRCUMFLEX
F5 х LATIN SMALL LETTER O TILDE
F6 ц LATIN SMALL LETTER O DIAERESIS
F7 ч DIVISION SIGN
F8 ш LATIN SMALL LETTER O SLASH
F9 щ LATIN SMALL LETTER U GRAVE
FA ъ LATIN SMALL LETTER U ACUTE
FB ы LATIN SMALL LETTER U CIRCUMFLEX
FC ь LATIN SMALL LETTER U DIAERESIS
FD э LATIN SMALL LETTER Y ACUTE
FE ю LATIN SMALL LETTER THORN
FF я LATIN SMALL LETTER Y DIAERESIS
Control codes used in BlackBox
The following control codes are used in the BlackBox Component Framework:
00X nul string terminator
01X unicode unicode mask character
02X viewcode view mask character
07X rdel right delete key
08X del left delete key
09X tab tabulator key
0AX ltab reverse tabulator key
0DX line return key (Unicode 2028, LINE SEPARATOR)
0EX para paragraph separator (Unicode 2029, PARAGRAPH SEPARATOR)
10X pL page left
11X pR page right
12X pU page up
13X pD page down
14X dL document left
15X dR document right
16X dU document up
17X dD document down
1BX esc escape key
1CX aL arrow left key
1DX aR arrow right key
1EX aU arrow up key
1FX aD arrow down key
Of these codes, only tab, line, and para should ever be stored in a text, i.e., are not considered to be control codes in BlackBox. The ASCII DEL code (07FX) is not used in BlackBox and remains reserved.
| Docu/BB-Chars.odc |
Documentation Conventions
Documentation has two major purposes: to communicate how a program's service can be used interactively (user manual) and how the program's service can be used programmatically (developer manual). In BlackBox, services are arranged in subsystems. A subsystem typically consists of several possibly cooperating modules. In the general case, we need three kinds of documentation texts: a user manual, one module interface description per module, and an overview over how the modules may interact with each other, i.e., an introduction to the overall architecture of the subsystem (developer manual).
A subsystem is represented on the disk as a directory, e.g., directory Text. In this directory, there is a nested directory called Docu, e.g. Text/Docu. This documentation directory may contain the following text documents:
a user manual called User-Man
a hypertext map to the documentation, called Sys-Map
a programmer's introduction called Dev-Man
and one module interface description per module, having the module name without its subsystem prefix, e.g. Views for module TextViews.
Note that all documentation texts which do not directly denote the programmer's reference for a particular module must have a dash ("-") in their names, so that the repository browser can distinguish between module documentations and other documentation files.
The remainder of this text describes the format of a module interface description.
Each module description begins with a module definition. The Component Pascal notation for module definitions is used, which lists all exported items of a module, and only those. A module begins with the keyword DEFINITION instead of MODULE, export marks are omitted (except read-only marks), and procedure bodies and the module body are left out as well. A method appears in the corresponding record declaration itself, without the PROCEDURE keyword.
The hypothetical module "Dictionaries" serves as an example:
DEFINITION Dictionaries;
CONST maxElems = 32;
TYPE
Dictionary = POINTER TO LIMITED RECORD
elems-: INTEGER;
(d: Dictionary) Put (string: ARRAY OF CHAR; OUT key: INTEGER), NEW;
(d: Dictionary) Get (key: INTEGER; OUT string: ARRAY OF CHAR), NEW
END;
VAR someDict: Dictionary;
PROCEDURE Init;
END Dictionaries.
In an extended record, the inherited procedures are not listed, only the new procedures, or the procedures which have changed signatures or where the semantics are specialized so that they need to be clarified.
A changed signature may be caused by a covariant function result, i.e., the procedure returns a pointer that is an extension of the one returned by the base procedure. Or it may be caused by changed method attributes (final, ABSTRACT, EMPTY, EXTENSIBLE), e.g., an abstract method may have been implemented and made final.
A module definition is followed by a brief description of the abstraction(s) provided by the module.
This module provides a concrete type Dictionary for the manipulation of string dictionaries.
Then the constants of the module are listed, without their values:
CONST maxElems
Maximum number of elements in a dictionary.
This is followed by the module's types:
TYPE Dictionary
LIMITED
Manages a dictionary of strings, with an integer number as key.
Record attributes are given in the second line, as above. Record attributes are either none (final by default), EXTENSIBLE, ABSTRACT, or LIMITED.
If the type is an extension of another type, this is marked, e.g., as
Dictionary (OtherModule.Dictionary)
Then the record fields are listed:
elems-: INTEGER 0 <= elems <= maxElems
The number of elements currently in the dictionary.
As in the above example, an invariant over the record field's value may optionally be given.
Then the procedures bound to this type are given:
PROCEDURE (d: Dictionary) Put (string: ARRAY OF CHAR; OUT key: INTEGER)
NEW
For each method, it is specified whether this procedure is final (default), extensible, abstract, or empty.
An abstract procedure must not be called.
An empty procedure must not be called by an extending procedure (i.e., through a super-call of an implementing procedure).
In the second line, the method attributes are given, which are either none (final by default), EXTENSIBLE, ABSTRACT, or EMPTY. Before this attribute, NEW is written for newly introduced methods.
An implement-only method can only be called in its defining module. This module can thus establish the method's preconditions before every call to it that occurs in the module implementation. If the implementation is correct, these preconditions can never be violated, since no other module may perform a call. Thus an implementor can assume that the preconditions hold, and need not test them. Preconditions of implement-only methods are thus not attributed with a trap number; instead, they are marked as "guaranteed", meaning that the defining module guarantees them.
An explanation of the procedure's behavior follows:
Put a string into dictionary d, and receive key in return. If the string is already in the dictionary, the same key is returned as when it was inserted first. If the string is not in the dictionary, it is inserted and a value which has not been used before is returned.
After an explanation in plain English, some preconditions for this procedure may be specified. These preconditions are given in a semi-formal notation:
Pre
20 string # ""
This means that if the precondition is violated (i.e. if string = ""), the currently executing command is aborted with exception number 20. Instead of a number, the following exceptions may be specified as well:
invalid index
type guard check
A second precondition may thus be the following:
invalid index string in d OR d.elems < maxElems
In older parts of the documentation, the precondition numbers may also be given after the expression, instead of in front of it. Over time, all documentation should be adapted to the new and better readable style.
After the preconditions, some postconditions may be specified:
Post
string in d'
old key returned
~(string in d')
string in d
d.elems = d.elems' + 1
new key returned
This postcondition contains two cases, namely what happens if the string is already contained in d, and what happens if the string is not yet contained in d. The conditions are textually aligned to the left, while the respective conclusions are indented. Occasionally, conditions are nested by further indentations.
To refer to values before the operation, an expression is followed by an apostrophe if this is necessary for clarity (i.e. if the value may be changed at all). Thus the expression
d.elems = d.elems' + 1
means that the value of d.elems has been incremented by one.
Component Pascal is generally used as syntax for such expressions, although some liberties are taken, e.g., simple auxiliary procedures that are not described further may be used.
Function results are generically called "result".
The amount of formalism is kept small. It is attempted to limit formal specifications to few and simple conditions, or to the explanation of particularly subtle situations. It is not intended to specify complete formal semantics of the library, thus the formalism does not replace plain text explanations, examples, or graphical illustrations completely.
However, it is felt that checked preconditions in particular are often helpful even in this incomplete and semi-formal way, both for documentation and for debugging purposes.
PROCEDURE (d: Dictionary) Get (key: INTEGER; OUT string: ARRAY OF CHAR)
NEW
Retrieve a string from the dictionary, by using key. If the value is not found, string is set to the empty string.
Post
key in d
return corresponding string
~(key in d)
return ""
Procedures which are inherited through type extension are usually not listed here. Exceptions are procedures which have extended their semantics. Semantic extensions are restricted to having weaker preconditions or stronger postconditions.
After all types, the global variables are listed:
VAR someDict: Dictionary someDict # NIL
This variable contains a dictionary.
The optional invariant is established by the module body.
Finally, the procedures exported by the module are listed:
PROCEDURE Init (d: Dictionary)
Initializes a dictionary. Any dictionary may be allocated once only.
Pre
20 d not yet initialized
In BlackBox, all procedures whose names start with "Init" may be called only once per object, i.e., they are "snappy".
| Docu/BB-Docu.odc |
The BlackBox Component Builder Open Source License
The following is the license that applies to this copy of the BlackBox Component Builder software components and the accompanying documentation (collectively, the "Software"). For a license to use the Software under conditions other than those described here, or to purchase support for this Software, please contact Oberon microsystems, Inc. at the following address:
Oberon microsystems, Inc.
Technoparkstrasse 1
CH-8005 Zьrich
Switzerland
Net: [email protected]
Tel: +41 (0) 44 445 17 51
Fax: +41 (0) 44 445 17 52
Copyright (c) 1994 - 2005 Oberon microsystems, Inc., Switzerland. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Redistributions in any form must be accompanied by information on how to obtain complete source code for the Software and any accompanying software that uses the Software. The source code must either be included in the distribution or be available for no more than the cost of distribution plus a nominal fee, and must be freely redistributable under reasonable conditions. For an executable file, complete source code means the source code for all modules it contains. It does not include source code for modules or files that typically accompany the major components of the operating system on which the executable file runs.
4. Neither the name of Oberon microsystems, Inc. nor the names of the contributors to the Software may be used to endorse or promote products derived from the Software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY OBERON MICROSYSTEMS, INC. "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL OBERON MICROSYSTEMS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
| Docu/BB-License.odc |
The BlackBox Component Builder Licensing Policy
Beginning with release 1.5, the BlackBox Component Builder ("BlackBox") is an open source product. The complete source code, documentation, and files required to build the product are available for download from our web site at www.oberon.ch.
Our open source license is closely based on Sleepycat Software's Berkeley DB Open Source License (a.k.a. "The Sleepycat License", www.sleepycat.com).
The open source license permits you to use BlackBox at no charge under the condition that if you use the software in an application you redistribute, the complete source code for your application must be made available and freely redistributable under reasonable conditions. If you do not want to release the source code for your application, you may purchase a special license from Oberon microsystems, Inc. For pricing information, or if you have further questions and comments on licensing, please contact us at the following address:
Oberon microsystems, Inc.
Technoparkstrasse 1
CH-8005 Zьrich
Switzerland
Net: [email protected]
Tel: +41 (0) 44 445 17 51
Fax: +41 (0) 44 445 17 52
TheBlackBoxComponentBuilderOpenSourceLicense
What does "redistribute" mean?
The term "redistribution" in the BlackBox Open Source License means your application is distributed to one or more third parties. Giving an application to customers, even in alpha or beta releases, is redistribution. Giving contractors, affiliates, parent organizations or subsidiaries, business partners or support vendors a copy of the application is generally redistribution.
The following are not redistribution:
Building an application for use internal or external to your organization, deployed and managed on your organization's clients or servers.
Building a web service on top of BlackBox and making it available.
Off-site backups or other software archival procedures.
Whether or not you charge money for your application does not matter. The only test is if you redistribute it.
What does "using the Software" mean?
We say that a program A uses program B if B must be present and satisfy its specification for A to satisfy its specification. In other words, B must be present and operate correctly for A to operate correctly. This definition goes back to David Lorge Parnas.
What must I release as open source?
Under the BlackBox Open Source License, you must release the complete source code for the application that uses BlackBox. You do not need to release the source code for components that are generally installed on the operating system on which your application runs, such as system header files or libraries.
What open source license should I use?
Licenses recognized by opensource.org meet the Oberon microsystems, Inc. requirements of "freely redistributable under reasonable conditions."
Of course, releasing an application which uses BlackBox under an open source license does not change the requirements of the BlackBox Open Source License, and the BlackBox source code remains subject to the terms of the BlackBox Open Source License governing its use and redistribution. Sleepycat's open source license, on which BlackBox's open source license is based, is compatible with the GPL, so GPL'ed software can use BlackBox without violating the terms of either license.
Who owns the BlackBox Component Builder?
All source code (current and future) that is included in the BlackBox is the intellectual property of Oberon microsystems, Inc. Contributions to the source base (including error corrections) will only be accepted if their ownership is granted to Oberon microsystems, Inc. Third party contributions will be acknowledged with comments in the source code. If we allowed contributions that we did not own, we would not have the right to offer special licenses for our paying customers.
What if some contributors want to help but do not want to grant source code ownership to Oberon microsystems, Inc.?
They can develop such code, and redistribute their own version of BlackBox as long as they stick to the BlackBox Open Source License. Oberon microsystems, Inc. is unable to integrate those changes into its BlackBox distribution though. If you want your code contributions to be part of the distribution provided by Oberon microsystems, Inc., you need to transfer ownership of the source code to Oberon microsystems, Inc. There is no guarantee that Oberon microsystems, Inc. will include unsolicited contributions in its distribution of the software.
| Docu/BB-Licensing-Policy.odc |
The BlackBox Component Builder Open Source License
The following is the license that applies to this copy of the BlackBox Component Builder software components and the accompanying documentation (collectively, the "Software"). For a license to use the Software under conditions other than those described here, or to purchase support for this Software, please contact Oberon microsystems, Inc. at the following address:
Oberon microsystems, Inc.
Technoparkstrasse 1
CH-8005 Zьrich
Switzerland
Net: [email protected]
Tel: +41 (0) 44 445 17 51
Fax: +41 (0) 44 445 17 52
Copyright (c) 1994 - 2005 Oberon microsystems, Inc., Switzerland. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Redistributions in any form must be accompanied by information on how to obtain complete source code for the Software and any accompanying software that uses the Software. The source code must either be included in the distribution or be available for no more than the cost of distribution plus a nominal fee, and must be freely redistributable under reasonable conditions. For an executable file, complete source code means the source code for all modules it contains. It does not include source code for modules or files that typically accompany the major components of the operating system on which the executable file runs.
4. Neither the name of Oberon microsystems, Inc. nor the names of the contributors to the Software may be used to endorse or promote products derived from the Software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY OBERON MICROSYSTEMS, INC. "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL OBERON MICROSYSTEMS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
| Docu/BB-Open-Source-License.odc |
Roadmap
Contents
1Twokindsofcomponents
2Commands
3Views
4Overview
5Tableofcontents
1 Two kinds of components
BlackBox contains a component framework, which is a new concept for most programmers. This document gives a quick overview over which kinds of BlackBox components there are, when you need which, and where the documentation is.
Generally, BlackBox distinguishes two major categories of components: commands and views. Commands are comparable to traditional scripts or macros, except that they are implemented in a "real" programming language, rather than in a limited or inefficient special purpose scripting language. This means that if a problem grows, its programmatic solution can grow along; you'll not suddenly need to switch to another language. Thus commands range from simple automation tasks to complex programs such as compilers. The main purpose of commands is to assemble visual objects, i.e., to make them work together. Views are the visual objects of the BlackBox Component Framework.
2 Commands
Often, programs are built around data entry masks; these are forms in BlackBox. Module Controls and the form subsystem provide the necessary support to build form-based user interfaces.
Often, you'll also want to generate texts, e.g., for reporting purposes. You can use all capabilities of the BlackBox text subsystem, including fonts, type sizes, color, embedded components such as stamp views or link views, and so on. An example command which uses both the form and text subsystems is ObxOrders.
Before looking at this advanced example, you may want to have a look at simpler text and form sample programs. The Obx subsystem ("Overview by Example") provides a variety of such examples.
BlackBox programs are document-centric. This means that you typically work with documents and document parts; and not directly with files or windows. Files are used only for simple databases or for manipulating legacy data. Sometimes it's possible to convert legacy data to a BlackBox data type by writing a new converter. Obx also contains an example of such a converter.
3 Views
If the built-in subsystems are not sufficient for your purposes, you need to develop a new BlackBox component. Usually this is a document component, a so-called view implementation. In contrast to old-style programs, a view only owns a part of a document, and not the whole screen or even a whole window. If the view is the outermost view (root view), the result cannot be distinguished from a traditional application. However, a view is always able to be embedded in texts, forms, and so on.
Examples of views are text views; form views; link views (hypertext); stamp views (time stamps); clock views; Oberon microsystems logo views; bitmap (picture) views; commander views (buttons which execute a command); fold views; error views generated by the compiler; various controls (command buttons, check boxes, edit fields, ...) and so on. Before implementing your own view type, take a look at these views to get an idea of the variety of ways in which views can be used. Sometimes it's not necessary to implement a whole new complex subsystem in order to solve a problem, but rather some additional view which extends the functionality of the existing text subsystem, for example.
Views may or may not have a model. A model is the datastructure which is visually represented by the view. In simple cases where the view needs no editable persistent state, no model is needed. Examples are logo views, controls, etc. Full-fledged editors on the other hand should contain a separate model. Such more complex views are typically implemented in several modules, while simple views without separate modules are usually implemented in a single module.
Advanced views may contain other views. Such advanced views are called containers. There are three useful categories of containers:
A Wrapper contains another view and modifies or extends its behavior. Typically, a wrapper has the same size as the wrapped view. For example, a terminal view may wrap a standard text view; it adds the communication facilities, while the text view provides the echoing of communicated text.
A Special Container contains one or several embedded views. The container knows about the types of the embedded views and their layout. Views cannot be inserted or deleted. For example, such a special container could have a query view at the top where database queries can be typed in, and a larger text view at the bottom where the results of the query appear. Another example is given in ObxTwins.
A General Container may contain an arbitrary number of embedded views, and they may change over time. This is the most general and most complex kind of view, e.g., the built-in text and form subsystems. The form subsystem is available in source form. Examples for the other kinds of view are available as Obx examples.
Views may have no programming interface, a simple procedural interface (typically based on properties, see Controls), or a full-fledged extensible interface. For the latter, it is recommended that the exported interface is separated from the hidden default implementation; in order to achieve maximum extensibility.
4 Overview
How should you start to get acquainted with BlackBox? We suggest that you start with the introduction texts ABriefHistoryofPascal and GuidedTour.
The rest of the documentation consists of four major parts:
A usermanual which describes the user interface and most important commands of the BlackBox Component Builder.
A tutorial which discusses general design patterns (chapters 1 to 3) in BlackBox. Then graphical user interfaces, forms, and controls are discussed in chapter4, the text subsystem is discussed in chapter5. The remaining chapter6 deals with view programming.
OverviewbyExample is a rich source of examples, ordered by category and difficulty.
The programmer's reference consists of one documentation file per module. Each subsystem has a Sys-Map text which contains links to the individual texts.
Apart from the Obx samples and the tutorial examples, another documentation for the most important kinds of BlackBox programs is available in Dev/Rsrc/New. These are template documents that you can use as basis for your own programs. The template documents' module names are renamed automatically by the Tools->CreateSubsystem... command. This command also creates a suitable new subsystem directory structure (see DevSubTool).
Programmers who need to interface with non-BlackBox software should consult the text Platform-SpecificIssues.
Note that you can reach the entire on-line documentation via the help menu, or from the table of contents below.
5 Table of contents
Quick Start
GuidedTour
OverviewbyExample
Tutorial For easier printing:
1UserInteraction the complete tutorial can be printed
2CompoundDocuments from this document, which contains
3DesignPractices all chapters.
4Forms
5Texts
6ViewConstruction
A:ABriefHistoryofPascal
B:FromPascaltoComponentPascal
User Manuals
Framework
TextSubsystem
FormSubsystem
DevSubsystem
CustomCommands
Developer Manuals
Framework
TextSubsystem
FormSubsystem
DevSubsystem
SqlSubsystem
Component Pascal
LanguageReport
What'sNew?
CharacterSet
DocumentationConventions
ProgrammingConventions
Miscellaneous
License
LicensingPolicy
Contributors
Platform-SpecificIssues
| Docu/BB-Road.odc |
Programming Conventions
Contents
1Essentials
2Oberon
3Basictypes
4Fontattributes
5Comments
6Semicolons
7Dereferencing
8Case
9Names
10Whitespace
11Example
12OpenSourceHeader
This text describes the programming guidelines and source code formatting conventions which have been used for the BlackBox Component Framework. For the documentation there exist similar conventions.
Some programming guidelines are more important than others. In the first section, the more important ones are described. The remaining sections contain more cosmetic rules which describe the look-and-feel of programs published by Oberon microsystems. If you like them, feel free to use them for your programs as well. It may make your programs easier to understand for someone who is used to the design, documentation, and coding patterns of the BlackBox Component Framework.
1 Essentials
The most important programming conventions all center around the aspect of evolvability. It should be made as easy as possible to change existing programs in a reliable way, even if the program has been written a long time ago or by someone else. Evolvability can often be improved by increasing the locality of program pieces: if a piece of program may only have an effect on a clearly locatable stretch of program text, it is easier to know where a program modification may necessitate further changes. Basically, it's all a matter of keeping "ripple effects" under control.
Preconditions are one of the most useful tools to detect unaccounted ripple effects. Precondition checks allow to pinpoint semantic errors as early as possible, i.e. as closely to their true source as possible. After larger design changes, properly used assertions can help to dramatically reduce debugging time.
Whenever possible, use static means to express what you know about a program's design. In particular, use the type and module systems of Component Pascal for this purpose; so the compiler can help you to find inconsistencies, and thus can become an effective refactoring tool.
Precondition assertions should be used consequently. Don't allow client code to "enter" your module if it doesn't fulfill the preconditions of your module's entry points (procedures, methods). In this way, you avoid propagation of foreign errors into your own code.
Use the following numbers to be consistent with the rest of the BlackBox Component Builder:
Free ЏЏ0 .. Џ19 use for temporary breakpoints
Preconditions Џ20 .. Џ59 validate parameters at procedure entry
Postconditions Џ60 .. Џ99 validate results at procedure end
Invariants 100 .. 120 validate intermediate states
(detect local error)
Reserved 121 .. 125 reserved for future use
Not Yet Implemented 126 procedure is not yet implemented
Reserved 127 reserved for future use
There should be as few global variables as possible.
Global variables can be accessed from many places in a program, at different times. This makes it difficult to keep track of all possible interactions ("side effects") with such variables. This in turn increases the likelihood of introducing errors when changing the use of them.
Function procedures, i.e., procedures which return a result, should not modify global variables or VAR parameters as side effects. It is easier to deal with function procedures if they are true functions in the mathematical sense, i.e., if the don't have side effects. Returning function results and assigning OUT parameters is ok.
Only use ELSE in CASE or WITH if input data is extensible.
ELSE clauses in CASE x OF or WITH x DO statements should only be used if x is genuinely extensible. If x is not extensible, all cases that can occur should be statically known, and can be listed in the statement.
2 Oberon
For new software, don't use the special Oberon features that are not part of Component Pascal. In particular, this is the LONGREAL type and the COPY procedure. Try to avoid super calls (use composition instead of inheritance) and procedure types (use objects and methods instead).
3 Basictypes
Use the types INTEGER, REAL and CHAR as defaults. BYTE, SHORTINT, LONGINT, SHORTREAL and SHORTCHAR should only be used if there is a strong particular reason to justify this choice. The auxiliary types are there mainly for interfacing purposes, for packing of very large structures, or for computation of extremely large integers. This rule is more important for exported interfaces than for hidden implementations, of course.
4 Font attributes
Programs are written in plain text, in the default color, with the following exceptions:
Comments are written in italics, e.g. (* this is a comment *)
Exported items, except for record fields and method signatures in record declarations, are written in bold, e.g. PROCEDURE Do*;
Keywords which indicate non-local control flow are written in bold, i.e. RETURN, EXIT, and HALT
Text parts which are currently being changed and tested may temporarily be written in a different color
5 Comments
Comments which are part of an interface description (rather than a mere implementation description) have additional asterisks, a kind of "export mark" for comments, e.g. (** guard for xyz command **)
6 Semicolons
Semicolons are used to separate statements, not to terminate statements. This means that there should be no superfluous semicolons.
Good
IF done THEN
Print(result)
END
Bad
IF done THEN
Print(result);
END
7 Dereferencing
The dereferencing operator ^ should be left out wherever possible.
Good
h.next := p.prev.next
Bad
h^.next := p^.prev^.next
8 Case
In general, each identifier starts with a small letter, except
A module name always starts with a capital letter
A type name always starts with a capital letter
A procedure always starts with a capital letter, this is true for procedure constants, types, variables, parameters, and record fields.
Good
null = 0X;
DrawDot = PROCEDURE (x, y: INTEGER);
PROCEDURE Proc (i, j: INTEGER; Draw: DrawDot);
Bad
NULL = 0X;
PROCEDURE isEmpty (q: Queue): BOOLEAN;
R = RECORD
draw: DrawDot
END;
Don't use all-caps identifiers with more than one character. They should be reserved for the language.
9 Names
A proper procedure has a verb as name, e.g. DrawDot
A function procedure has a noun or a predicate as name, e.g. NewObject(), IsEmpty(q)
Only declare a record type if necessary (FooDesc for each Foo are normally not needed anymore)
Procedure names which start with the prefix Init are snappy, i.e., they have an effect only when called for the first time. If called a second time, a snappy procedure either does nothing, or it halts. In contrast, a procedure which sets some state and may be called several times starts with the prefix Set.
Examples
PROCEDURE InitDir (dir: Directory);
PROCEDURE (p: Port) Init (unit, colors: LONGINT);
Guard procedures have the same name as the guarded command, except that they have a Guard suffix appended.
Example
PROCEDURE PasteChar;
PROCEDURE PasteCharGuard (VAR par: Dialog.Par);
10 White space
A new indentation level is realized by adding one further tabulator character
Between lists of symbols, between actual parameters, and between operators a single space is inserted
Good
VAR a, b, c: INTEGER;
DrawRect(l, t, r, b);
a := i * 8 + j - m[i, j];
Bad
VAR a,b,c: INTEGER;
DrawRect(l,t,r,b);
a:=b;
a := i*8 + j - m[i,j];
There is a space between a procedure name (or its export mark) and the parameter list in a declaration, but not in a call
Good
PROCEDURE DrawDot* (x, y: INTEGER);
DrawDot(3, 5);
Bad
PROCEDURE DrawDot*(x, y: INTEGER);
DrawDot (3, 5);
Opening and closing keywords are either aligned or on the same line
IMPORT, CONST, TYPE, VAR, PROCEDURE sections are one level further indented than the outer level.
LOOP statements are never on one line
PROCEDURE X and END X are always aligned
If the whole construct does not fit on one line, there is never a statement or a type declaration after a keyword
The contents of IF, WHILE, REPEAT, LOOP, FOR, CASE constructs is one level further indented if it does not fit on one line.
Good
IF expr THEN S0 ELSE S1 END;
REPEAT S0 UNTIL expr;
WHILE expr DO S0 END;
IF expr THEN
S0
ELSE
S1
END;
REPEAT
S0
UNTIL expr;
LOOP
S0;
IF expr THEN EXIT END;
S1
END;
i := 0; WHILE i # 15 DO DrawDot(a, i); INC(i) END;
TYPE View = POINTER TO RECORD (Views.ViewDesc) END;
IMPORT Views, Containers,
TextModels, TextViews;
VAR a, b: INTEGER;
s: TextMappers.Scanner;
Bad
IF expr THEN S0
ELSE S1 END;
PROCEDURE P;
BEGIN ... END P;
BEGIN i := 0;
j := a + 2;
...
REPEAT i := 0;
j := a + 2;
...
11 Example
MODULE StdExample;
IMPORT Models, Views, Controllers;
CONST null = 0X;
TYPE
View* = POINTER TO RECORD (Views.View)
a*, b*: INTEGER
END;
VAR view-: View;
PROCEDURE Calculate* (x, y: INTEGER);
VAR area: LONGINT;
PROCEDURE IsOdd (x: INTEGER): BOOLEAN;
BEGIN
RETURN ODD(x)
END IsOdd;
BEGIN
area := x * y;
IF IsOdd(area) THEN area := 1000 END
END Calculate;
BEGIN
Calculate(7, 9)
END StdExample.
12 Open Source Header
Modules published under the BlackBoxComponentBuilderOpenSourceLicense include a header text along the lines of the following template.
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
purpose = ""
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
| Docu/BB-Rules.odc |
Component Pascal Language Report
Copyright 1994-2005 by Oberon microsystems, Inc., Switzerland.
All rights reserved. No part of this publication may be reproduced in any form or by any means, without prior written permission by Oberon microsystems except for the free electronic distribution of the unmodified document.
Oberon microsystems, Inc.
Technoparkstrasse 1
CH-8005 Zьrich
Switzerland
Oberon is a trademark of Prof. Niklaus Wirth.
Component Pascal is a trademark of Oberon microsystems, Inc.
All other trademarks and registered trademarks belong to their respective owners.
Authors
Oberon microsystems, Inc.
March 2001
Authors of Oberon-2 report
H. Mцssenbцck, N. Wirth
Institut fьr Computersysteme, ETH Zьrich
October 1993
Author of Oberon report
N. Wirth
Institut fьr Computersysteme, ETH Zьrich
1987
Contents
1.Introduction
2.Syntax
3.VocabularyandRepresentation
4.DeclarationsandScopeRules
5.ConstantDeclarations
6.TypeDeclarations
6.1BasicTypes
6.2ArrayTypes
6.3RecordTypes
6.4PointerTypes
6.5ProcedureTypes
6.6StringTypes
7.VariableDeclarations
8.Expressions
8.1Operands
8.2Operators
9.Statements
9.1Assignments
9.2ProcedureCalls
9.3StatementSequences
9.4IfStatements
9.5CaseStatements
9.6WhileStatements
9.7RepeatStatements
9.8ForStatements
9.9LoopStatements
9.10ReturnandExitStatements
9.11WithStatements
10.ProcedureDeclarations
10.1FormalParameters
10.2Methods
10.3PredeclaredProcedures
10.4Finalization
11.Modules
AppendixA:DefinitionofTerms
AppendixB:SyntaxofComponentPascal
AppendixC:DomainsofBasicTypes
AppendixD:MandatoryRequirementsforEnvironment
1. Introduction
Component Pascal is Oberon microsystems' refinement of the Oberon-2 language. Oberon microsystems thanks H. Mцssenbцck and N. Wirth for the friendly permission to use their Oberon2 report as basis for this document.
Component Pascal is a general-purpose language in the tradition of Pascal, Modula-2, and Oberon. Its most important features are block structure, modularity, separate compilation, static typing with strong type checking (also across module boundaries), type extension with methods, dynamic loading of modules, and garbage collection.
Type extension makes Component Pascal an object-oriented language. An object is a variable of an abstract data type consisting of private data (its state) and procedures that operate on this data. Abstract data types are declared as extensible records. Component Pascal covers most terms of object-oriented languages by the established vocabulary of imperative languages in order to minimize the number of notions for similar concepts.
Complete type safety and the requirement of a dynamic object model make Component Pascal a component-oriented language.
This report is not intended as a programmer's tutorial. It is intentionally kept concise. Its function is to serve as a reference for programmers. What remains unsaid is mostly left so intentionally, either because it can be derived from stated rules of the language, or because it would require to commit the definition when a general commitment appears as unwise.
Appendix A defines some terms that are used to express the type checking rules of Component Pascal. Where they appear in the text, they are written in italics to indicate their special meaning (e.g. the same type).
It is recommended to minimize the use of procedure types and super calls, since they are considered obsolete. They are retained for the time being, in order to simplify the use of existing Oberon-2 code. Support for these features may be reduced in later product releases.
2. Syntax
An extended Backus-Naur formalism (EBNF) is used to describe the syntax of Component Pascal: Alternatives are separated by |. Brackets [ and ] denote optionality of the enclosed expression, and braces { and } denote its repetition (possibly 0 times). Ordinary parentheses ( and ) are used to group symbols if necessary. Non-terminal symbols start with an upper-case letter (e.g., Statement). Terminal symbols either start with a lower-case letter (e.g., ident), or are written all in upper-case letters (e.g., BEGIN), or are denoted by strings (e.g., ":=").
3. Vocabulary and Representation
The representation of (terminal) symbols in terms of characters is defined using ISO8859-1, i.e.,the Latin1extensionoftheASCIIcharacterset. Symbols are identifiers, numbers, strings, operators, and delimiters. The following lexical rules must be observed: Blanks and line breaks must not occur within symbols (except in comments, and blanks in strings). They are ignored unless they are essential to separate two consecutive symbols. Capital and lower-case letters are considered as distinct.
1. Identifiers are sequences of letters, digits, and underscores. The first character must not be a digit.
ident = (letter | "_") {letter | "_" | digit}.
letter = "A" .. "Z" | "a" .. "z" | "А".."Ц" | "Ш".."ц" | "ш".."я".
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9".
Examples: x Scan Oberon2 GetSymbol firstLetter
2. Numbers are (unsigned) integer or real constants. The type of an integer constant is INTEGER if the constant value belongs to INTEGER, or LONGINT otherwise (see 6.1). If the constant is specified with the suffix 'H' or 'L', the representation is hexadecimal, otherwise the representation is decimal. The suffix 'H' is used to specify 32-bit constants in the range -2147483648 .. 2147483647. At most 8 significant hex digits are allowed. The suffix 'L' is used to specify 64-bit constants.
A real number always contains a decimal point. Optionally it may also contain a decimal scale factor. The letter E means "times ten to the power of". A real number is always of type REAL.
number = integer | real.
integer = digit {digit} | digit {hexDigit} ( "H" | "L" ).
real = digit {digit} "." {digit} [ScaleFactor].
ScaleFactor = "E" ["+" | "-"] digit {digit}.
hexDigit = digit | "A" | "B" | "C" | "D" | "E" | "F".
Examples:
1234567 INTEGER 1234567
0DH INTEGER 13
12.3 REAL 12.3
4.567E8 REAL 456700000
0FFFF0000H INTEGER -65536
0FFFF0000L LONGINT 4294901760
3. Character constants are denoted by the ordinal number of the character in hexadecimal notation followed by the letter X.
character = digit {hexDigit} "X".
4. Strings are sequences of characters enclosed in single (') or double (") quote marks. The opening quote must be the same as the closing quote and must not occur within the string. The number of characters in a string is called its length. A string of length 1 can be used wherever a character constant is allowed and vice versa.
string = ' " ' {char} ' " ' | " ' " {char} " ' ".
Examples: "Component Pascal" "Don't worry!" "x"
5. Operators and delimiters are the special characters, character pairs, or reserved words listed below. The reserved words consist exclusively of capital letters and cannot be used as identifiers.
+ := ABSTRACT EXTENSIBLE POINTER
- ^ ARRAY FOR PROCEDURE
* = BEGIN IF RECORD
/ # BY IMPORT REPEAT
~ < CASE IN RETURN
& > CLOSE IS THEN
. <= CONST LIMITED TO
, >= DIV LOOP TYPE
; .. DO MOD UNTIL
| : ELSE MODULE VAR
$ ELSIF NIL WHILE
( ) EMPTY OF WITH
[ ] END OR
{ } EXIT OUT
6. Comments may be inserted between any two symbols in a program. They are arbitrary character sequences opened by the bracket (* and closed by *). Comments may be nested. They do not affect the meaning of a program.
4. Declarations and Scope Rules
Every identifier occurring in a program must be introduced by a declaration, unless it is a predeclared identifier. Declarations also specify certain permanent properties of an object, such as whether it is a constant, a type, a variable, or a procedure. The identifier is then used to refer to the associated object.
The scope of an object x extends textually from the point of its declaration to the end of the block (module, procedure, or record) to which the declaration belongs and hence to which the object is local. It excludes the scopes of equally named objects which are declared in nested blocks. The scope rules are:
1. No identifier may denote more than one object within a given scope (i.e., no identifier may be declared twice in a block);
2. An object may only be referenced within its scope;
3. A declaration of a type T containing references to another type T1 may occur at a point where T1 is still unknown. The declaration of T1 must follow in the same block to which T is local;
4. Identifiers denoting record fields (see 6.3) or methods (see 10.2) are valid in record designators only.
An identifier declared in a module block may be followed by an export mark (" * " or " - ") in its declaration to indicate that it is exported. An identifier x exported by a module M may be used in other modules, if they import M (see Ch.11). The identifier is then denoted as M.x in these modules and is called a qualified identifier. Variables and record fields marked with " - " in their declaration are read-only (variables and fields) or implement-only (methods) in importing modules.
Qualident = [ident "."] ident.
IdentDef = ident [" * " | " - "].
The following identifiers are predeclared; their meaning is defined in the indicated sections:
ABS (10.3) INTEGER (6.1)
ANYPTR (6.1) FALSE (6.1)
ANYREC (6.1) LEN (10.3)
ASH (10.3) LONG (10.3)
ASSERT (10.3) LONGINT (6.1)
BITS (10.3) MAX (10.3)
BOOLEAN (6.1) MIN (10.3)
BYTE (6.1) NEW (10.3)
CAP (10.3) ODD (10.3)
CHAR (6.1) ORD (10.3)
CHR (10.3) REAL (6.1)
DEC (10.3) SET (6.1)
ENTIER (10.3) SHORT (10.3)
EXCL (10.3) SHORTCHAR (6.1)
HALT (10.3) SHORTINT (6.1)
INC (10.3) SHORTREAL (6.1)
INCL (10.3) SIZE (10.3)
INF (6.1) TRUE (6.1)
5. Constant Declarations
A constant declaration associates an identifier with a constant value.
ConstantDeclaration = IdentDef "=" ConstExpression.
ConstExpression = Expression.
A constant expression is an expression that can be evaluated by a mere textual scan without actually executing the program. Its operands are constants (Ch.8) or predeclared functions (Ch.10.3) that can be evaluated at compile time. Examples of constant declarations are:
N = 100
limit = 2*N - 1
fullSet = {MIN(SET) .. MAX(SET)}
6. Type Declarations
A data type determines the set of values which variables of that type may assume, and the operators that are applicable. A type declaration associates an identifier with a type. In the case of structured types (arrays and records) it also defines the structure of variables of this type. A structured type cannot contain itself.
TypeDeclaration = IdentDef "=" Type.
Type = Qualident | ArrayType | RecordType | PointerType | ProcedureType.
Examples:
Table = ARRAY N OF REAL
Tree = POINTER TO Node
Node = EXTENSIBLE RECORD
key : INTEGER;
left, right: Tree
END
CenterTree = POINTER TO CenterNode
CenterNode = RECORD (Node)
width: INTEGER;
subnode: Tree
END
Object = POINTER TO ABSTRACT RECORD END;
Function = PROCEDURE (x: INTEGER): INTEGER
6.1 Basic Types
The basic types are denoted by predeclared identifiers. The associated operators are defined in 8.2 and the predeclared function procedures in 10.3. The values of the given basic types are the following:
1. BOOLEAN the truth values TRUE and FALSE
2. SHORTCHAR the characters of the Latin1character set (0X .. 0FFX)
3. CHAR the characters of the Unicode character set (0X .. 0FFFFX)
4. BYTE the integers between MIN(BYTE) and MAX(BYTE)
5. SHORTINT the integers between MIN(SHORTINT) and MAX(SHORTINT)
6. INTEGER the integers between MIN(INTEGER) and MAX(INTEGER)
7. LONGINT the integers between MIN(LONGINT) and MAX(LONGINT)
8. SHORTREAL the real numbers between MIN(SHORTREAL) and MAX(SHORTREAL), the value INF
9. REAL the real numbers between MIN(REAL) and MAX(REAL), the value INF
10. SET the sets of integers between 0 and MAX(SET)
Types 4 to 7 are integer types, types 8 and 9 are real types, and together they are called numeric types. They form a hierarchy; the larger type includes (the values of) the smaller type:
REAL >= SHORTREAL >= LONGINT >= INTEGER
>= SHORTINT >= BYTE
Types 2 and 3 are character types with the type hierarchy:
CHAR >= SHORTCHAR
6.2 Array Types
An array is a structure consisting of a number of elements which are all of the same type, called the element type. The number of elements of an array is called its length. The elements of the array are designated by indices, which are integers between 0 and the length minus 1.
ArrayType = ARRAY [Length {"," Length}] OF Type.
Length = ConstExpression.
A type of the form
ARRAY L0, L1, ..., Ln OF T
is understood as an abbreviation of
ARRAY L0 OF
ARRAY L1 OF
...
ARRAY Ln OF T
Arrays declared without length are called open arrays. They are restricted to pointer base types (see 6.4), element types of open array types, and formal parameter types (see 10.1). Examples:
ARRAY 10, N OF INTEGER
ARRAY OF CHAR
6.3 Record Types
A record type is a structure consisting of a fixed number of elements, called fields, with possibly different types. The record type declaration specifies the name and type of each field. The scope of the field identifiers extends from the point of their declaration to the end of the record type, but they are also visible within designators referring to elements of record variables (see 8.1). If a record type is exported, field identifiers that are to be visible outside the declaring module must be marked. They are called public fields; unmarked elements are called private fields.
RecordType = RecAttributes RECORD ["("BaseType")"]
FieldList {";" FieldList} END.
RecAttributes = [ABSTRACT | EXTENSIBLE | LIMITED].
BaseType = Qualident.
FieldList = [IdentList ":" Type].
IdentList = IdentDef {"," IdentDef}.
The usage of a record type is restricted by the presence or absence of one of the following attributes:
ABSTRACT, EXTENSIBLE, and LIMITED.
A record type marked as ABSTRACT cannot be instantiated. No variables or fields of such a type can ever exist. Abstract types are only used as base types for other record types (see below).
Variables of a LIMITED record type can only be allocated inside the module where the record type is defined. The restriction applies to static allocation by a variable declaration (Ch. 7) as well as to dynamic allocation by the standard procedure NEW (Ch. 10.3).
Record types marked as ABSTRACT or EXTENSIBLE are extensible, i.e., a record type can be declared as an extension of such a record type. In the example
T0 = EXTENSIBLE RECORD x: INTEGER END
T1 = RECORD (T0) y: REAL END
T1 is a (direct) extension of T0 and T0 is the (direct) base type of T1 (see App. A). An extended type T1 consists of the fields of its base type and of the fields which are declared in T1. All identifiers declared in the extended record must be different from the identifiers declared in its base type record(s). The base type of an abstract record must be abstract.
Alternatively, a pointer type can be specified as the base type. The record base type of the pointer is used as the base type of the declared record in this case.
A record which is an extension of a hidden (i.e., non-exported) record type may not be exported.
Each record is implicitly an extension of the predeclared type ANYREC. ANYREC does not contain any fields and can only be used in pointer and variable parameter declarations.
Summary of attributes:
attribute extension allocate
none no yes
EXTENSIBLE yes yes
ABSTRACT yes no
LIMITED in defining module only
Examples of record type declarations:
RECORD
day, month, year: INTEGER
END
LIMITED RECORD
name, firstname: ARRAY 32 OF CHAR;
age: INTEGER;
salary: REAL
END
6.4 Pointer Types
Variables of a pointer type P assume as values pointers to variables of some type T. T is called the pointer base type of P and must be a record or array type. Pointer types adopt the extension relation of their pointer base types: if a type T1 is an extension of T, and P1 is of type POINTER TO T1, then P1 is also an extension of P.
PointerType = POINTER TO Type.
If p is a variable of type P = POINTER TO T, a call of the predeclared procedure NEW(p) (see 10.3) allocates a variable of type T in free storage. If T is a record type or an array type with fixed length, the allocation has to be done with NEW(p); if T is an n-dimensional open array type the allocation has to be done with NEW(p, e0, ..., en-1) where T is allocated with lengths given by the expressions e0, ..., en-1. In either case a pointer to the allocated variable is assigned to p. p is of type P. The referenced variable p^ (pronounced as p-referenced) is of type T. Any pointer variable may assume the value NIL, which points to no variable at all.
All fields or elements of a newly allocated record or array are cleared, which implies that all embedded pointers and procedure variables are initialized to NIL.
The predeclared type ANYPTR is defined as POINTER TO ANYREC. Any pointer to a record type is therefore an extension of ANYPTR. The procedure NEW cannot be used for variables of type ANYPTR.
6.5 Procedure Types
Variables of a procedure type T have a procedure (or NIL) as value. If a procedure P is assigned to a variable of type T, the formal parameter lists (see Ch. 10.1) of P and T must match (see App. A). P must not be a predeclared procedure or a method nor may it be local to another procedure.
ProcedureType = PROCEDURE [FormalParameters].
6.6 String Types
Values of a string type are sequences of characters terminated by a null character (0X). The length of a string is the number of characters it contains excluding the null character.
Strings are either constants or stored in an array of character type. There are no predeclared identifiers for string types because there is no need to use them in a declaration.
Constant strings which consist solely of characters in the range 0X..0FFX and strings stored in an array of SHORTCHAR are of type Shortstring, all others are of type String.
7. Variable Declarations
Variable declarations introduce variables by defining an identifier and a data type for them.
VariableDeclaration = IdentList ":" Type.
Record and pointer variables have both a static type (the type with which they are declared - simply called their type) and a dynamic type (the type of their value at run-time). For pointers and variable parameters of record type the dynamic type may be an extension of their static type. The static type determines which fields of a record are accessible. The dynamic type is used to call methods (see 10.2).
Examples of variable declarations (refer to examples in Ch. 6):
i, j, k: INTEGER
x, y: REAL
p, q: BOOLEAN
s: SET
F: Function
a: ARRAY 100 OF REAL
w: ARRAY 16 OF
RECORD
name: ARRAY 32 OF CHAR;
count: INTEGER
END
t, c: Tree
8. Expressions
Expressions are constructs denoting rules of computation whereby constants and current values of variables are combined to compute other values by the application of operators and function procedures. Expressions consist of operands and operators. Parentheses may be used to express specific associations of operators and operands.
8.1 Operands
With the exception of set constructors and literal constants (numbers, character constants, or strings), operands are denoted by designators. A designator consists of an identifier referring to a constant, variable, or procedure. This identifier may possibly be qualified by a module identifier (see Ch. 4 and 11) and may be followed by selectors if the designated object is an element of a structure.
Designator = Qualident {"." ident | "[" ExpressionList "]" | "^" |
"(" Qualident ")" | ActualParameters} [ "$" ].
ExpressionList = Expression {"," Expression}.
ActualParameters = "(" [ExpressionList] ")".
If a designates an array, then a[e] denotes that element of a whose index is the current value of the expression e. The type of e must be an integer type. A designator of the form a[e0, e1, ..., en] stands for a[e0][e1]...[en]. If r designates a record, then r.f denotes the field f of r or the method f of the dynamic type of r (Ch. 10.2). If a or r are read-only, then also a[e] and r.f are read-only.
If p designates a pointer, p^ denotes the variable which is referenced by p. The designators p^.f, p^[e], and p^$ may be abbreviated as p.f, p[e], and p$, i.e., record, array, and string selectors imply dereferencing. Dereferencing is also implied if a pointer is assigned to a variable of a record or array type (Ch. 9.1), if a pointer is used as actual parameter for a formal parameter of a record or array type (Ch. 10.1), or if a pointer is used as argument of the standard procedure LEN (Ch. 10.3).
A type guard v(T) asserts that the dynamic type of v is T (or an extension of T), i.e., program execution is aborted, if the dynamic type of v is not T (or an extension of T). Within the designator, v is then regarded as having the static type T. The guard is applicable, if
1. v is an IN or VAR parameter of record type or v is a pointer to a record type, and if
2. T is an extension of the static type of v
If the designated object is a constant or a variable, then the designator refers to its current value. If it is a procedure, the designator refers to that procedure unless it is followed by a (possibly empty) parameter list in which case it implies an activation of that procedure and stands for the value resulting from its execution. The actual parameters must correspond to the formal parameters as in proper procedure calls (see 10.1).
If a designates an array of character type, then a$ denotes the null terminated string contained in a. It leads to a run-time error if a does not contain a 0X character. The $ selector is applied implicitly if a is used as an operand of the concatenation operator (Ch. 8.2.4), a relational operator (Ch. 8.2.5), or one of the predeclared procedures LONG and SHORT (Ch. 10.3).
Examples of designators (refer to examples in Ch.7):
i (INTEGER)
a[i] (REAL)
w[3].name[i] (CHAR)
t.left.right (Tree)
t(CenterTree).subnode (Tree)
w[i].name$ (String)
8.2 Operators
Four classes of operators with different precedences (binding strengths) are syntactically distinguished in expressions. The operator ~ has the highest precedence, followed by multiplication operators, addition operators, and relations. Operators of the same precedence associate from left to right. For example, x-y-z stands for (x-y)-z.
Expression = SimpleExpression [Relation SimpleExpression].
SimpleExpression = ["+" | "-"] Term {AddOperator Term}.
Term = Factor {MulOperator Factor}.
Factor = Designator | number | character | string | NIL | Set |
"(" Expression ")" | "~" Factor.
Set = "{" [Element {"," Element}] "}".
Element = Expression [".." Expression].
Relation = "=" | "#" | "<" | "<=" | ">" | ">=" | IN | IS.
AddOperator = "+" | "-" | OR.
MulOperator = "*" | "/" | DIV | MOD | "&".
The available operators are listed in the following tables. Some operators are applicable to operands of various types, denoting different operations. In these cases, the actual operation is identified by the type of the operands. The operands must be expression compatible with respect to the operator (see App. A).
8.2.1 Logical operators
OR logical disjunction p OR q "if p then TRUE, else q"
& logical conjunction p & q "if p then q, else FALSE"
~ negation ~ p "not p"
These operators apply to BOOLEAN operands and yield a BOOLEAN result. The second operand of a disjunction is only evaluated if the result of the first is FALSE. The second oprand of a conjunction is only evaluated if the result of the first is TRUE.
8.2.2 Arithmetic operators
+ sum
- difference
* product
/ real quotient
DIV integer quotient
MOD modulus
The operators +, -, *, and / apply to operands of numeric types. The type of the result is REAL if the operation is a division (/) or one of the operand types is a REAL. Otherwise the result type is SHORTREAL if one of the operand types is SHORTREAL, LONGINT if one of the operand types is LONGINT, or INTEGER in any other case. If the result of a real operation is too large to be represented as a real number, it is changed to the predeclared value INF with the same sign as the original result. Note that this also applies to 1.0/0.0, but not to 0.0/0.0 which has no defined result at all and leads to a run-time error. When used as monadic operators, - denotes sign inversion and + denotes the identity operation. The operators DIV and MOD apply to integer operands only. They are related by the following formulas:
x = (x DIV y) * y + (x MOD y)
0 <= (x MOD y) < y or0>=(xMODy)>y
Note:xDIVy=ENTIER(x/y)
Examples:
x y x DIV y x MOD y
5 3 1 2
-5 3 -2 1
5 -3 -2 -1
-5 -3 1 -2
Note:
(-5) DIV 3 = -2
but
-5 DIV 3 = -(5 DIV 3) = -1
8.2.3 Set operators
+ union
- difference (x - y = x * (-y))
* intersection
/ symmetric set difference (x / y = (x-y) + (y-x))
Set operators apply to operands of type SET and yield a result of type SET. The monadic minus sign denotes the complement of x, i.e., -x denotes the set of integers between 0 and MAX(SET) which are not elements of x. Set operators are not associative ((a+b)-c # a+(b-c)).
A set constructor defines the value of a set by listing its elements between curly brackets. The elements must be integers in the range 0..MAX(SET). A range a..b denotes all integers iwith i>=aandi<=b.
8.2.4 String operators
+ string concatenation
The concatenation operator applies to operands of string types. The resulting string consists of the characters of the first operand followed by the characters of the second operand. If both operands are of type Shortstring the result is of type Shortstring, otherwise the result is of type String.
8.2.5 Relations
= equal
# unequal
< less
<= less or equal
> greater
>= greater or equal
IN set membership
IS type test
Relations yield a BOOLEAN result. The relations =, #, <, <=, >, and >= apply to the numeric types, character types, and string types. The relations = and # also apply to BOOLEAN and SET, as well as to pointer and procedure types (including the value NIL). x IN s stands for "x is an element of s". x must be an integer in the range 0..MAX(SET), and s of type SET. v IS T stands for "the dynamic type of v is T (or an extension of T)" and is called a type test. It is applicable if
1. v is an IN or VAR parameter of record type or v is a pointer to a record type, and if
2. T is an extension of the static type of v
Examples of expressions (refer to examples in Ch.7):
1991 INTEGER
i DIV 3 INTEGER
~p OR q BOOLEAN
(i+j) * (i-j) INTEGER
s - {8, 9, 13} SET
i + x REAL
a[i+j] * a[i-j] REAL
(0<=i) & (i<100) BOOLEAN
t.key = 0 BOOLEAN
k IN {i..j-1} BOOLEAN
w[i].name$ <= "John" BOOLEAN
t IS CenterTree BOOLEAN
9. Statements
Statements denote actions. There are elementary and structured statements. Elementary statements are not composed of any parts that are themselves statements. They are the assignment, the procedure call, the return, and the exit statement. Structured statements are composed of parts that are themselves statements. They are used to express sequencing and conditional, selective, and repetitive execution. A statement may also be empty, in which case it denotes no action. The empty statement is included in order to relax punctuation rules in statement sequences.
Statement = [ Assignment | ProcedureCall | IfStatement | CaseStatement |
WhileStatement | RepeatStatement |
ForStatement | LoopStatement | WithStatement |
EXIT | RETURN [Expression] ].
9.1 Assignments
Assignments replace the current value of a variable by a new value specified by an expression. The expression must be assignment compatible with the variable (see App. A). The assignment operator is written as ":=" and pronounced as becomes.
Assignment = Designator ":=" Expression.
If an expression e of type Te is assigned to a variable v of type Tv, the following happens:
1. if Tv and Te are record types, all fields of that type are assigned.
2. if Tv and Te are pointer types, the dynamic type of v becomes the dynamic type of e;
3. if Tv is an array of character type and e is a string of length m < LEN(v), v[i] becomes ei for i = 0..m-1 and v[m] becomes 0X. It leads to a run-time error if m >= LEN(v).
Examples of assignments (refer to examples in Ch.7):
i := 0
p := i = j
x := i + 1
k := Log2(i+j)
F := Log2 (* see 10.1 *)
s := {2, 3, 5, 7, 11, 13}
a[i] := (x+y) * (x-y)
t.key := i
w[i+1].name := "John"
t := c
9.2 Procedure Calls
A procedure call activates a procedure. It may contain a list of actual parameters which replace the corresponding formal parameters defined in the procedure declaration (see Ch. 10). The correspondence is established by the positions of the parameters in the actual and formal parameter lists. There are two kinds of parameters: variable and value parameters.
If a formal parameter is a variable parameter, the corresponding actual parameter must be a designator denoting a variable. If it denotes an element of a structured variable, the component selectors are evaluated when the formal/actual parameter substitution takes place, i.e., before the execution of the procedure. If a formal parameter is a value parameter, the corresponding actual parameter must be an expression. This expression is evaluated before the procedure activation, and the resulting value is assigned to the formal parameter (see also 10.1).
ProcedureCall = Designator [ActualParameters].
Examples:
WriteInt(i*2+1) (* see 10.1 *)
INC(w[k].count)
t.Insert("John") (* see 11 *)
9.3 Statement Sequences
Statement sequences denote the sequence of actions specified by the component statements which are separated by semicolons.
StatementSequence = Statement {";" Statement}.
9.4 If Statements
IfStatement =
IF Expression THEN StatementSequence
{ELSIF Expression THEN StatementSequence}
[ELSE StatementSequence]
END.
If statements specify the conditional execution of guarded statement sequences. The Boolean expression preceding a statement sequence is called its guard. The guards are evaluated in sequence of occurrence, until one evaluates to TRUE, whereafter its associated statement sequence is executed. If no guard is satisfied, the statement sequence following the symbol ELSE is executed, if there is one.
Example:
IF (ch >= "A") & (ch <= "Z") THEN ReadIdentifier
ELSIF (ch >= "0") & (ch <= "9") THEN ReadNumber
ELSIF (ch = "'") OR (ch = '"') THEN ReadString
ELSE SpecialCharacter
END
9.5 Case Statements
Case statements specify the selection and execution of a statement sequence according to the value of an expression. First the case expression is evaluated, then that statement sequence is executed whose case label list contains the obtained value. The case expression must be of an integer or character type that includes the values of all case labels. Case labels are constants, and no value must occur more than once. If the value of the expression does not occur as a label of any case, the statement sequence following the symbol ELSE is selected, if there is one, otherwise the program is aborted.
CaseStatement = CASE Expression OF Case {"|" Case}
[ELSE StatementSequence] END.
Case = [CaseLabelList ":" StatementSequence].
CaseLabelList = CaseLabels {"," CaseLabels}.
CaseLabels = ConstExpression [".." ConstExpression].
Example:
CASE ch OF
"A" .. "Z": ReadIdentifier
| "0" .. "9": ReadNumber
| "'", '"': ReadString
ELSE SpecialCharacter
END
9.6 While Statements
While statements specify the repeated execution of a statement sequence while the Boolean expression (its guard) yields TRUE. The guard is checked before every execution of the statement sequence.
WhileStatement = WHILE Expression DO StatementSequence END.
Examples:
WHILE i > 0 DO i := i DIV 2; k := k + 1 END
WHILE (t # NIL) & (t.key # i) DO t := t.left END
9.7 Repeat Statements
A repeat statement specifies the repeated execution of a statement sequence until a condition specified by a Boolean expression is satisfied. The statement sequence is executed at least once.
RepeatStatement = REPEAT StatementSequence UNTIL Expression.
9.8 For Statements
A for statement specifies the repeated execution of a statement sequence while a progression of values is assigned to an integer variable called the control variable of the for statement.
ForStatement =
FOR ident ":=" Expression TO Expression [BY ConstExpression]
DO StatementSequence END.
The statement
FOR v := beg TO end BY step DO statements END
is equivalent to
temp := end; v := beg;
IF step > 0 THEN
WHILE v <= temp DO statements; INC(v, step) END
ELSE
WHILE v >= temp DO statements; INC(v, step) END
END
temp has the same type as v. step must be a nonzero constant expression. If step is not specified, it is assumed to be 1.
Examples:
FOR i := 0 TO 79 DO k := k + a[i] END
FOR i := 79 TO 1 BY -1 DO a[i] := a[i-1] END
9.9 Loop Statements
A loop statement specifies the repeated execution of a statement sequence. It is terminated upon execution of an exit statement within that sequence (see 9.10).
LoopStatement = LOOP StatementSequence END.
Example:
LOOP
ReadInt(i);
IF i < 0 THEN EXIT END;
WriteInt(i)
END
Loop statements are useful to express repetitions with several exit points or cases where the exit condition is in the middle of the repeated statement sequence.
9.10 Return and Exit Statements
A return statement indicates the termination of a procedure. It is denoted by the symbol RETURN, followed by an expression if the procedure is a function procedure. The type of the expression must be assignment compatible (see App. A) with the result type specified in the procedure heading (see Ch.10).
Function procedures require the presence of a return statement indicating the result value. In proper procedures, a return statement is implied by the end of the procedure body. Any explicit return statement therefore appears as an additional (probably exceptional) termination point.
An exit statement is denoted by the symbol EXIT. It specifies termination of the enclosing loop statement and continuation with the statement following that loop statement. Exit statements are contextually, although not syntactically associated with the loop statement which contains them.
9.11 With Statements
With statements execute a statement sequence depending on the result of a type test and apply a type guard to every occurrence of the tested variable within this statement sequence.
WithStatement = WITH [ Guard DO StatementSequence ]
{"|" [ Guard DO StatementSequence ] }
[ELSE StatementSequence] END.
Guard = Qualident ":" Qualident.
If v is a variable parameter of record type or a pointer variable, and if it is of a static type T0, the statement
WITH v: T1 DO S1 | v: T2 DO S2 ELSE S3 END
has the following meaning: if the dynamic type of v is T1, then the statement sequence S1 is executed where v is regarded as if it had the static type T1; else if the dynamic type of v is T2, then S2 is executed where v is regarded as if it had the static type T2; else S3 is executed. T1 and T2 must be extensions of T0. If no type test is satisfied and if an else clause is missing the program is aborted.
Example:
WITH t: CenterTree DO i := t.width; c := t.subnode END
10. Procedure Declarations
A procedure declaration consists of a procedure heading and a procedure body. The heading specifies the procedure identifier and the formal parameters. For methods it also specifies the receiver parameter and the attributes (see 10.2). The body contains declarations and statements. The procedure identifier is repeated at the end of the procedure declaration.
There are two kinds of procedures: proper procedures and function procedures. The latter are activated by a function designator as a constituent of an expression and yield a result that is an operand of the expression. Proper procedures are activated by a procedure call. A procedure is a function procedure if its formal parameters specify a result type. The body of a function procedure must contain a return statement which defines its result.
All constants, variables, types, and procedures declared within a procedure body are local to the procedure. Since procedures may be declared as local objects too, procedure declarations may be nested. The call of a procedure within its declaration implies recursive activation.
Local variables whose types are pointer types or procedure types are initialized to NIL before the body of the procedure is executed.
Objects declared in the environment of the procedure are also visible in those parts of the procedure in which they are not concealed by a locally declared object with the same name.
ProcedureDeclaration = ProcedureHeading [";" ProcedureBody ident ].
ProcedureHeading = PROCEDURE [Receiver] IdentDef
[FormalParameters] MethAttributes.
ProcedureBody = DeclarationSequence
[BEGIN StatementSequence] END.
DeclarationSequence = {CONST {ConstantDeclaration ";"} |
TYPE {TypeDeclaration ";"} |
VAR {VariableDeclaration ";"} }
{ProcedureDeclaration ";" | ForwardDeclaration ";"}.
ForwardDeclaration = PROCEDURE " ^ " [Receiver] IdentDef
[FormalParameters] MethAttributes.
If a procedure declaration specifies a receiver parameter, the procedure is considered to be a method of the type of the receiver (see 10.2). A forward declaration serves to allow forward references to a procedure whose actual declaration appears later in the text. The formal parameter lists of the forward declaration and the actual declaration must match (see App. A) and the names of corresponding parameters must be equal.
10.1 Formal Parameters
Formal parameters are identifiers declared in the formal parameter list of a procedure. They correspond to actual parameters specified in the procedure call. The correspondence between formal and actual parameters is established when the procedure is called. There are two kinds of parameters, value and variable parameters, the latter indicated in the formal parameter list by the presence of one of the keywords VAR, IN, or OUT. Value parameters are local variables to which the value of the corresponding actual parameter is assigned as an initial value. Variable parameters correspond to actual parameters that are variables, and they stand for these variables. Variable parameters can be used for input only (keyword IN), output only (keyword OUT), or input and output (keyword VAR). IN can only be used for array and record parameters. Inside the procedure, input parameters are read-only. Like local variables, output parameters of pointer types and procedure types are initialized to NIL. Other output parameters must be considered as undefined prior to the first assignment in the procedure. The scope of a formal parameter extends from its declaration to the end of the procedure block in which it is declared. A function procedure without parameters must have an empty parameter list. It must be called by a function designator whose actual parameter list is empty too. The result type of a procedure can be neither a record nor an array.
FormalParameters = "(" [FPSection {";" FPSection}] ")" [":" Type].
FPSection = [VAR | IN | OUT] ident {"," ident} ":" Type.
Let f be the formal parameter and a the corresponding actual parameter. If f is an open array, then a must be array compatible to f and the lengths of f are taken from a. Otherwise a must be parameter compatible to f (see App. A)
Examples of procedure declarations:
PROCEDURE ReadInt (OUT x: INTEGER);
VAR i: INTEGER; ch: CHAR;
BEGIN
i := 0; Read(ch);
WHILE ("0" <= ch) & (ch <= "9") DO
i := 10 * i + (ORD(ch) - ORD("0")); Read(ch)
END;
x := i
END ReadInt
PROCEDURE WriteInt (x: INTEGER); (* 0 <= x < 100000 *)
VAR i: INTEGER; buf: ARRAY 5 OF INTEGER;
BEGIN
i := 0;
REPEAT buf[i] := x MOD 10; x := x DIV 10; INC(i) UNTIL x = 0;
REPEAT DEC(i); Write(CHR(buf[i] + ORD("0"))) UNTIL i = 0
END WriteInt
PROCEDURE WriteString (IN s: ARRAY OF CHAR);
VAR i: INTEGER;
BEGIN
i := 0; WHILE (i < LEN(s)) & (s[i] # 0X) DO Write(s[i]); INC(i) END
END WriteString
PROCEDURE Log2 (x: INTEGER): INTEGER;
VAR y: INTEGER; (* assume x > 0 *)
BEGIN
y := 0; WHILE x > 1 DO x := x DIV 2; INC(y) END;
RETURN y
END Log2
PROCEDURE Modify (VAR n: Node);
BEGIN
INC(n.key)
END Modify
10.2 Methods
Globally declared procedures may be associated with a record type declared in the same module. The procedures are said to be methods bound to the record type. The binding is expressed by the type of the receiver in the heading of a procedure declaration. The receiver may be either a VAR or IN parameter of record type T or a value parameter of type POINTER TO T (where T is a record type). The method is bound to the type T and is considered local to it.
ProcedureHeading = PROCEDURE [Receiver] IdentDef
[FormalParameters] MethAttributes.
Receiver = "(" [VAR | IN] ident ":" ident ")".
MethAttributes = ["," NEW] ["," (ABSTRACT | EMPTY | EXTENSIBLE)].
If a method M is bound to a type T0, it is implicitly also bound to any type T1 which is an extension of T0. However, if a method M' (with the same name as M) is declared to be bound to T1, this overrides the binding of M to T1. M' is considered a redefinition of M for T1. The formal parameters of M and M' must match,except if M is a function returning a pointer type. In the latter case, the function result type of M' must be an extension ofthefunctionresulttypeofM(covariance) (see App. A). If M and T1 are exported (see Chapter 4) M' must be exported too.
If M is not exported, M' must not be exported either. If M and M' are exported, they must use the same export marks.
The following attributes are used to restrict and document the desired usage of a method:
NEW, ABSTRACT, EMPTY, and EXTENSIBLE.
NEW must be used on all newly introduced methods and must not be used on redefining methods. The attribute helps to detect inconsistencies between a record and its extension when one of the two is changed without updating the other.
Abstract and empty method declarations consist of a procedure header only. Abstract methods are never called. A record containing abstract methods must be abstract. A method redefined by an abstract method must be abstract. An abstract method of an exported record must be exported. Calling an empty method has no effect. Empty methods may not return function results and may not have OUT parameters. A record containing new empty methods must be extensible or abstract. A method redefined by an empty method must be empty or abstract. Abstract or empty methods are usually redefined (implemented) in a record extension. They may not be called via super calls. A concrete (nonabstract) record extending an abstract record must implement all abstract methods bound to the base record.
Concrete methods (which contain a procedure body) are either extensible or final (no attribute). A final method cannot be redefined in a record extension. A record containing extensible methods must be extensible or abstract.
If v is a designator and M is a method, then v.M denotes that method M which is bound to the dynamic type of v. Note, that this may be a different method than the one bound to the static type of v. v is passed to M's receiver according to the parameter passing rules specified in Chapter 10.1.
If r is a receiver parameter declared with type T, r.M^ denotes the method M bound to the base type of T (super call). In a forward declaration of a method the receiver parameter must be of the same type as in the actual method declaration. The formal parameter lists of both declarations must match (App. A) and the names of corresponding parameters must be equal.
Methods marked with " - " are "implement-only" exported. Such a method can be redefined in any importing module but can only be called within the module containing the method declaration. (Currently, the compiler also allows super calls to implement-only methods outside of their defining module. This is a temporary feature to make migration easier.)
Examples:
PROCEDURE (t: Tree) Insert (node: Tree), NEW, EXTENSIBLE;
VAR p, father: Tree;
BEGIN p := t;
REPEAT father := p;
IF node.key = p.key THEN RETURN END;
IF node.key < p.key THEN p := p.left ELSE p := p.right END
UNTIL p = NIL;
IF node.key < father.key THEN
father.left := node
ELSE
father.right := node
END;
node.left := NIL; node.right := NIL
END Insert
PROCEDURE (t: CenterTree) Insert (node: Tree); (* redefinition *)
BEGIN
WriteInt(node(CenterTree).width);
t.Insert^ (node) (* calls the Insert method of Tree *)
END Insert
PROCEDURE (obj: Object) Draw (w: Window), NEW, ABSTRACT
PROCEDURE (obj: Object) Notify (e: Event), NEW, EMPTY
10.3 Predeclared Procedures
The following table lists the predeclared procedures. Some are generic procedures, i.e., they apply to several types of operands. v stands for a variable, x and y for expressions, and T for a type. The first matching line gives the correct result type.
Function procedures
Name Argument type Result type Function
ABS(x) <= INTEGER INTEGER absolute value
real type, LONGINT type of x
ASH(x, y) x: <= INTEGER INTEGER arithmetic shift (x * 2^y)
x: LONGINT LONGINT
y: integer type
BITS(x) INTEGER SET {i | ODD(x DIV 2^i)}
CAP(x) character type type of x x is a Latin-1 letter:
corresponding capital letter
CHR(x) integer type CHAR character with ordinal number
x
ENTIER(x) real type LONGINT largest integer not greater
than x
LEN(v, x) v: array; x: integer INTEGER length of v in dimension x
constant (first dimension = 0)
LEN(v) array type INTEGER equivalent to LEN(v, 0)
String INTEGER length of string
(not counting 0X)
LONG(x) BYTE SHORTINT identity
SHORTINT INTEGER
INTEGER LONGINT
SHORTREAL REAL
SHORTCHAR CHAR
Shortstring String
MAX(T) T = basic type T maximum value of type T
T = SET INTEGER maximum element of a set
MAX(x, y) <= INTEGER INTEGER the larger value of x and y
integer type LONGINT
<= SHORTREAL SHORTREAL
numeric type REAL
SHORTCHAR SHORTCHAR
character type CHAR
MIN(T) T = basic type T minimum value of type T
T = SET INTEGER 0
MIN(x, y) <= INTEGER INTEGER the smaller of x and y
integer type LONGINT
<= SHORTREAL SHORTREAL
numeric type REAL
SHORTCHAR SHORTCHAR
character type CHAR
ODD(x) integer type BOOLEAN x MOD 2 = 1
ORD(x) CHAR INTEGER ordinal number of x
SHORTCHAR SHORTINT ordinal number of x
SET INTEGER (SUM i: i IN x: 2^i)
SHORT(x) LONGINT INTEGER identity
INTEGER SHORTINT identity
SHORTINT BYTE identity
REAL SHORTREAL identity (truncation possible)
CHAR SHORTCHAR projection
String Shortstring projection
SIZE(T) any type INTEGER number of bytes required by T
SIZE cannot be used in constant expressions because its value depends on the actual compiler implementation.
Proper procedures
Name Argument types Function
ASSERT(x) x: Boolean expression terminate program execution if not x
ASSERT(x, n) x: Boolean expression; terminate program execution
n: integer constant if not x
DEC(v) integer type v := v - 1
DEC(v, n) v, n: integer type v := v - n
EXCL(v, x) v: SET; x: integer type, v := v - {x}
0 <= x <= MAX(SET)
HALT(n) integer constant terminate program execution
INC(v) integer type v := v + 1
INC(v, n) v, n: integer type v := v + n
INCL(v, x) v: SET; x: integer type, v := v + {x}
0 <= x <= MAX(SET)
NEW(v) pointer to record or allocate v ^
fixed array
NEW(v, x0, ..., xn) v: pointer to open array; allocate v ^ with
xi: integer type lengths x0.. xn
In ASSERT(x, n) and HALT(n), the interpretation of n is left to the underlying system implementation.
10.4 Finalization
A predeclared method named FINALIZE is associated with each record type as if it were declared to be bound to the type ANYREC:
PROCEDURE (a: ANYPTR) FINALIZE-, NEW, EMPTY;
The FINALIZE procedure can be implemented for any pointer type. The method is called at some unspecified time after an object of that type (or a base type of it) has become unreachable via other pointers (not globally anchored anymore) and before the object is deallocated.
It is not recommended to re-anchor an object in its finalizer and the finalizer is not called again when the object repeatedly becomes unreachable. Multiple unreachable objects are finalized in an unspecified order.
11. Modules
A module is a collection of declarations of constants, types, variables, and procedures, together with a sequence of statements for the purpose of assigning initial values to the variables. A module constitutes a text that is compilable as a unit.
Module = MODULE ident ";" [ImportList] DeclarationSequence
[BEGIN StatementSequence]
[CLOSE StatementSequence] END ident ".".
ImportList = IMPORT Import {"," Import} ";".
Import = [ident ":="] ident.
The import list specifies the names of the imported modules. If a module A is imported by a module M and A exports an identifier x, then x is referred to as A.x within M. If A is imported as B := A, the object x must be referenced as B.x. This allows short alias names in qualified identifiers. A module must not import itself. Identifiers that are to be exported (i.e., that are to be visible in client modules) must be marked by an export mark in their declaration (see Chapter 4).
The statement sequence following the symbol BEGIN is executed when the module is added to a system (loaded), which is done after the imported modules have been loaded. It follows that cyclic import of modules is illegal. Individual exported procedures can be activated from the system, and these procedures serve as commands .
Variables declared in a module are cleared prior to the execution of the module body. This implies that all pointer or procedure typed variables are initialized to NIL.
The statement sequence following the symbol CLOSE is executed when the module is removed from the system.
Example:
MODULE Trees; (* exports: Tree, Node, Insert, Search, Write, Init *)
IMPORT StdLog;
TYPE
Tree* = POINTER TO Node;
Node* = RECORD (* exports read-only: Node.name *)
name-: POINTER TO ARRAY OF CHAR;
left, right: Tree
END;
PROCEDURE (t: Tree) Insert* (name: ARRAY OF CHAR), NEW;
VAR p, father: Tree;
BEGIN
p := t;
REPEAT father := p;
IF name = p.name^ THEN RETURN END;
IF name < p.name^ THEN p := p.left ELSE p := p.right END
UNTIL p = NIL;
NEW(p); p.left := NIL; p.right := NIL;
NEW(p.name, LEN(name$) + 1); p.name^ := name$;
IF name < father.name^ THEN father.left := p ELSE father.right := p END
END Insert;
PROCEDURE (t: Tree) Search* (name: ARRAY OF CHAR): Tree, NEW;
VAR p: Tree;
BEGIN
p := t;
WHILE (p # NIL) & (name # p.name^) DO
IF name < p.name^ THEN p := p.left ELSE p := p.right END
END;
RETURN p
END Search;
PROCEDURE (t: Tree) Write*, NEW;
BEGIN
IF t.left # NIL THEN t.left.Write END;
StdLog.String(t.name); StdLog.Ln;
IF t.right # NIL THEN t.right.Write END
END Write;
PROCEDURE Init* (t: Tree);
BEGIN
NEW(t.name, 1); t.name[0] := 0X; t.left := NIL; t.right := NIL
END Init;
BEGIN
StdLog.String("Trees loaded"); StdLog.Ln
CLOSE
StdLog.String("Trees removed"); StdLog.Ln
END Trees.
Appendix A: Definition of Terms
Character types SHORTCHAR, CHAR
Integer types BYTE, SHORTINT, INTEGER, LONGINT
Real types SHORTREAL, REAL
Numeric types integer types, real types
String types Shortstring, String
Basic types BOOLEAN, SET, character types, numeric types
Same types
Two variables a and b with types Ta and Tb are of the same type if
1. Ta and Tb are both denoted by the same type identifier, or
2. Ta is declared in a type declaration of the form Ta = Tb, or
3. a and b appear in the same identifier list in a variable, record field,
or formal parameter declaration.
Equal types
Two types Ta and Tb are equal if
1. Ta and Tb are the same type, or
2. Ta and Tb are open array types with equal element types, or
3. Ta and Tb are procedure types whose formal parameter lists match, or
4. Ta and Tb are pointer types with equal base types.
Matching formal parameter lists
Two formal parameter lists match if
1. they have the same number of parameters, and
2. they have either equal function result types or none, and
3. parameters at corresponding positions have equal types, and
4. parameters at corresponding positions are both either value, IN, OUT, or VAR parameters.
Type inclusion
Numeric and character types include (the values of) smaller types of the same class according to the following hierarchies:
REAL >= SHORTREAL >= LONGINT >= INTEGER >= SHORTINT >= BYTE
CHAR >= SHORTCHAR
Type extension (base type)
Given a type declaration Tb = RECORD (Ta) ... END, Tb is a direct extension of Ta, and Ta is a direct base type of Tb. A type Tb is an extension of a type Ta (Ta is a base type of Tb) if
1. Ta and Tb are the same types, or
2. Tb is a direct extension of an extension of Ta, or
3. Ta is of type ANYREC.
If Pa = POINTER TO Ta and Pb = POINTER TO Tb, Pb is an extension of Pa (Pa is a base type of Pb) if Tb is an extension of Ta.
Assignment compatible
An expression e of type Te is assignment compatible with a variable v of type Tv if one of the following conditions hold:
1. Te and Tv are equal and neither abstract, extensible, or limited record nor open array types;
2. Te and Tv are numeric or character types and Tv includes Te;
3. Te and Tv are pointer types and Te is an extension of Tv;
4. Tv is a pointer or a procedure type and e is NIL;
5. Tv is a numeric type and e is a constant expression whose value is contained in Tv;
6. Tv is an array of CHAR, Te is String or Shortstring, and LEN(e) < LEN(v);
7. Tv is an array of SHORTCHAR, Te is Shortstring, and LEN(e) < LEN(v);
8. Tv is a procedure type and e is the name of a procedure whose formal parameters match those of Tv.
Array compatible
An actual parameter a of type Ta is array compatible with a formal parameter f of type Tf if
1. Tf and Ta are equal types, or
2. Tf is an open array, Ta is any array, and their element types are array compatible, or
3. Tf is an open array of CHAR and Ta is String, or
4. Tf is an open array of SHORTCHAR and Ta is Shortstring.
Parameter compatible
An actual parameter a of type Ta is parameter compatible with a formal parameter f of type Tf if
1. Tf and Ta are equal types, or
2. f is a value parameter and Ta is assignment compatible with Tf, or
3. f is an IN or VAR parameter and Tf and Ta are record types and Ta is an extension of Tf.
Expression compatible
For a given operator, the types of its operands are expression compatible if they conform to the following table. The first matching line gives the correct result type. Type T1 must be an extension of type T0:
operator first operand second operand result type
+ - * DIV MOD <= INTEGER <= INTEGER INTEGER
integer type integer type LONGINT
/ integer type integer type REAL
+ - * / <= SHORTREAL <= SHORTREAL SHORTREAL
numeric type numeric type REAL
SET SET SET
+ Shortstring Shortstring Shortstring
string type string type String
OR & ~ BOOLEAN BOOLEAN BOOLEAN
= # < <= > >= numeric type numeric type BOOLEAN
character type character type BOOLEAN
string type string type BOOLEAN
= # BOOLEAN BOOLEAN BOOLEAN
SET SET BOOLEAN
NIL, pointer type T0 or T1 NIL, pointer type T0 or T1 BOOLEAN
procedure type T, NIL procedure type T, NIL BOOLEAN
IN integer type, 0..MAX(SET) SET BOOLEAN
IS T0 type T1 BOOLEAN
Constant expressions are calculated at compile time with maximum precision (LONGINT for integer types, REAL for real types) and the result is handled like a numeric literal of the same value.
If a real constant x with |x| <= MAX(SHORTREAL) or x = INF is combined with a nonconstant operand of type SHORTREAL, the constant is considered a SHORTREAL and the result type is SHORTREAL.
Appendix B: Syntax of Component Pascal
Module = MODULE ident ";" [ImportList] DeclSeq
[BEGIN StatementSeq]
[CLOSE StatementSeq] END ident ".".
ImportList = IMPORT [ident ":="] ident {"," [ident ":="] ident} ";".
DeclSeq = { CONST {ConstDecl ";" } | TYPE {TypeDecl ";"} |
VAR {VarDecl ";"}} {ProcDecl ";" | ForwardDecl ";"}.
ConstDecl = IdentDef "=" ConstExpr.
TypeDecl = IdentDef "=" Type.
VarDecl = IdentList ":" Type.
ProcDecl = PROCEDURE [Receiver] IdentDef [FormalPars] MethAttributes
[";" DeclSeq [BEGIN StatementSeq] END ident].
MethAttributes = ["," NEW] ["," (ABSTRACT | EMPTY | EXTENSIBLE)].
ForwardDecl = PROCEDURE " ^ " [Receiver] IdentDef [FormalPars] MethAttributes.
FormalPars = "(" [FPSection {";" FPSection}] ")" [":" Type].
FPSection = [VAR | IN | OUT] ident {"," ident} ":" Type.
Receiver = "(" [VAR | IN] ident ":" ident ")".
Type = Qualident
| ARRAY [ConstExpr {"," ConstExpr}] OF Type
| [ABSTRACT | EXTENSIBLE | LIMITED]
RECORD ["("Qualident")"] FieldList {";" FieldList} END
| POINTER TO Type
| PROCEDURE [FormalPars].
FieldList = [IdentList ":" Type].
StatementSeq = Statement {";" Statement}.
Statement = [ Designator ":=" Expr
| Designator ["(" [ExprList] ")"]
| IF Expr THEN StatementSeq
{ELSIF Expr THEN StatementSeq}
[ELSE StatementSeq] END
| CASE Expr OF Case {"|" Case}
[ELSE StatementSeq] END
| WHILE Expr DO StatementSeq END
| REPEAT StatementSeq UNTIL Expr
| FOR ident ":=" Expr TO Expr [BY ConstExpr]
DO StatementSeq END
| LOOP StatementSeq END
| WITH [ Guard DO StatementSeq ]
{"|" [ Guard DO StatementSeq ] }
[ELSE StatementSeq] END
| EXIT
| RETURN [Expr]
].
Case = [CaseLabels {"," CaseLabels} ":" StatementSeq].
CaseLabels = ConstExpr [".." ConstExpr].
Guard = Qualident ":" Qualident.
ConstExpr = Expr.
Expr = SimpleExpr [Relation SimpleExpr].
SimpleExpr = ["+" | "-"] Term {AddOp Term}.
Term = Factor {MulOp Factor}.
Factor = Designator | number | character | string | NIL | Set |
"(" Expr ")" | " ~ " Factor.
Set = "{" [Element {"," Element}] "}".
Element = Expr [".." Expr].
Relation = "=" | "#" | "<" | "<=" | ">" | ">=" | IN | IS.
AddOp = "+" | "-" | OR.
MulOp = " * " | "/" | DIV | MOD | "&".
Designator = Qualident {"." ident | "[" ExprList "]" | " ^ " | "(" Qualident ")"
| "(" [ExprList] ")"} [ "$" ].
ExprList = Expr {"," Expr}.
IdentList = IdentDef {"," IdentDef}.
Qualident = [ident "."] ident.
IdentDef = ident [" * " | "-"].
AppendixC:DomainsofBasicTypes
Type Domain
BOOLEAN FALSE, TRUE
SHORTCHAR 0X .. 0FFX
CHAR 0X .. 0FFFFX
BYTE -128 .. 127
SHORTINT -32768 .. 32767
INTEGER -2147483648 .. 2147483647
LONGINT -9223372036854775808 .. 9223372036854775807
SHORTREAL -3.4E38 .. 3.4E38, INF (32-bit IEEE format)
REAL -1.8E308 .. 1.8E308, INF (64-bit IEEE format)
SET set of 0 .. 31
AppendixD: Mandatory Requirements for Environment
The Component Pascal definition implicitly relies on three fundamental assumptions.
1) There exists some run-time type information that allows to check the dynamic type of an object. This is necessary to implement type tests and type guards.
2) There is no DISPOSE procedure. Memory cannot be deallocated manually, since this would introduce the safety problem of memory leaks and of dangling pointers, i.e., premature deallocation. Except for those embedded systems where no dynamic memory is used, or where it can be allocated once and never needs to be released, an automatic garbage collector is required.
3) Modules and at least their exported procedures (commands) and exported types must be retrievable dynamically. If necessary, this may cause modules to be loaded. The programming interface used to load modules or to access the mentioned meta information is not defined by the language, but the language compiler needs to preserve this information when generating code.
Except for fully linked applications where no modules will ever be added at run-time, a linking loader for modules is required. Embedded systems are important examples of applications that can be fully linked.
An implementation that doesn't fulfill these compiler and environment requirements is not compliant with Component Pascal.
| Docu/CP-Lang.odc |
What's New in Component Pascal?
Except for some minor points, Component Pascal is a superset of Oberon-2. Compared to Oberon-2, it provides several clarifications and improvements. This text summarizes the differences. Some of the changes had already been realized in earlier releases of the BlackBox Component Builder, all of them are implemented for Release 1.3 and higher.
The language revision was driven by the experience with the BlackBox Component Framework, and the desire to further improve support for the specification, documentation, development, maintenance, and refactoring of component frameworks. The goal was to give a framework architect the means to better control the overall integrity of large component-based software systems. Control over a system's integrity is key to increased reliability, reduced maintenance costs, and to higher confidence in the system's correctness when it evolves over time.
Care was taken that the language remains small, easy to use, and easy to learn. The new features are most visible to framework designers, less visible to framework extenders, and least visible to mere framework clients. This ensures that these different categories of developers are burdened with the minimal amounts of complexity that their respective tasks require.
More expressive type system
Covariant pointer function results
A type-bound function which returns a pointer may be redefined, such that it returns an extended type. For example, the function
PROCEDURE (v: View) ThisModel (): Model
could be extended in a subtype MyView, which is assumed to be a subtype of View, to the following function signature
PROCEDURE (v: MyView) ThisModel (): MyModel
where MyModel is assumed to be a subtype of Model. Note that covariant function results are type safe; they simply strengthen the postcondition of a function, which is always legal. They allow to make interface declarations more precise.
Pointer compatibility
The compatibility rules for pointers have been relaxed and simplified. Pointers are now compatible by structure; i.e., two pointer types that have the same base type are compatible. This can be useful mostly in procedure signatures, where it previously wasn't possible to use a function like the following:
PROCEDURE P (p: POINTER TO ARRAY OF INTEGER)
Pointer function results
A function's return type is now Type not Ident; e.g.,
PROCEDURE Bla (): POINTER TO Rec
is now legal, and due to simplified compatibility rules (see previous point) their use can actually make sense.
IN and OUT
These parameter modes are like the VAR mode, except that some restrictions apply. IN parameters cannot directly be modified inside a procedure, OUT parameters are considered undefined upon procedure entry (except for pointers and procedure variables, which are set to NIL upon procedure entry). OUT record parameters must have identical actual and formal parameter types.
These parameter modes are important for procedure signatures of distributed objects, and they can increase convenience and efficiency. Most importantly, they allow to make interface declarations more precise and more self-documenting. In particular, where formerly VAR parameters have been used for efficiency reasons only, it is now possible to use IN parameters. IN parameters are only allowed for record and array types.
Example:
PROCEDURE ShowModes (value: INTEGER; VAR inout: INTEGER;
(* value and VAR parameters *)
IN in: ARRAY OF SET;
(* IN for efficiency *)
OUT res: INTEGER): INTEGER;
(* OUT parameter and function result *)
Since IN and OUT are specializations of VAR, it is not possible to pass constants to IN parameters. There is one convenient exception: string constants may be passed to open-array IN parameters, since they are implemented by the compiler as a kind of "read-only variable" anyway.
NEW methods
Component Pascal requires that the introduction of a new method is indicated explicitly. This is done by appending the identifier NEW to the method's signature. NEW may not be used for extending methods.
In the following example, method SomeMethod is newly introduced in T and inherited in T1, which is assumed to be an extension of T:
PROCEDURE (t: T) SomeMethod (x, y: INTEGER), NEW;
BEGIN
...
END SomeMethod;
PROCEDURE (t: T1) SomeMethod (x, y: INTEGER);
BEGIN
...
END SomeMethod;
NEW indicates that a method is new, not extending. The need to declare this fact explicitly is useful whenever changes to a framework are made, which often happens during the initial design iterations, and later when the software architecture undergoes refactoring. NEW makes it possible for the compiler to detect for example if a base method's name has been changed, but extending methods have not been renamed accordingly. Also, the compiler detects if a method is newly introduced, although it already exists in a base type or in a subtype. These checks make it easier to achieve consistency again after a change to a framework's interfaces.
Default, EXTENSIBLE, ABSTRACT, and LIMITED record types
Component Pascal uses a single construct to denote both interfaces of objects and their implementations: record types. This unification allows to freeze some implementation aspects of an interface while leaving others open. This flexibility is often desirable in complex frameworks. But it is important to communicate such architectural decisions as precisely as possible, since they may affect a large number of clients.
For this reason, a Component Pascal record type can be attributed to allow an interface designer to formulate several fundamental architectural decisions explicitly. This has the advantage that the compiler can help to verify compliance with these decisions. The carefully chosen attributes are EXTENSIBLE, ABSTRACT, and LIMITED. They allow to distinguish four different combinations of extension and allocation possibilities:
modifier extension allocation record assignment
none ("final") no yes yes
EXTENSIBLE yes yes no
ABSTRACT yes no no
LIMITED no* no* no
*except in the defining module
Record types may either be extensible or non-extensible ("final"). By default, a record type is final. Final types allow to "close" a type, such that an implementor can perform a complete analysis of the type's implementation, e.g., to find out how it could be improved without breaking clients.
Record types may either be allocatable (as static or dynamic variables), or allocation may be prevented (ABSTRACT) or limited to the defining module (LIMITED). With limited types, allocation and extension is possible in the defining module only, never by an importing module.
Final types typically are simple auxiliary data types, e.g.:
Point = RECORD
x, y: INTEGER
END
Variables of such types can be copied using the assignment operator, e.g. pt := pt2. The compiler never needs to generate the hidden type guard that is sometimes necessary for such an assignment in Oberon.
On the other hand, extensible records can neither be copied, nor passed as value parameters (since value parameters imply a record assignment).
Final types, like extensible types, may be extensions of other record types and they may have methods.
Extensible types are declared in the following way:
Frame = EXTENSIBLE RECORD
l-, t-, r-, b-: INTEGER
END
Plain EXTENSIBLE types are rare, it is more typical to use ABSTRACT types instead, which are a special case of extensible types that cannot be instantiated. The following paragraph gives a more precise description of what this restriction means:
Types of values can never be abstract, but types of variables may be abstract. The type of a value can be different from the type of its holding variable only if the variable is referential; i.e., a pointer; or a VAR, IN, or OUT parameter. Thus, only those variables may be declared to be of an abstract type. In all other cases; i.e., static variables, record fields, array base types, and value parameters, non-abstract types or pointers (possibly to abstract types) must be used. Since the allocation operation NEW produces a value of the argument's type, NEW can only be used with variables of non-abstract type.
Example of an abstract type:
TextView = POINTER TO ABSTRACT RECORD (Views.View) END
Abstract types are design tools, they denote interfaces of objects. They are the primary means of Component Pascal to model component interfaces. Denoting records as abstract allows to indicate more precisely the use of a record: as an interfacing construct rather than an implementation construct.
Nevertheless, an abstract type may have all types of methods (see below), i.e., it is not forced to be fully abstract.
LIMITED types are a special case of final types. They are special in that they can be instantiated only within the defining module, and they cannot be copied. For example, a client may not perform a NEW on variables of limited types. Since allocation is under complete control of the defining module, the programmer of this module can guarantee that all newly allocated variables are correctly initialized before they are made accessible to client modules. This means that clients can only see variables that respect the type's invariants (which are established during initialization). An implementor is free to change the type's internal representation with less risk of breaking client code; there is no need for lazy initialization schemes; there cannot be delayed run-time errors due to missing initializations; and invariants (e.g., invariants over hidden record fields) cannot be violated through copying.
Typically, factory functions or factory objects are provided to create new instances of dynamic LIMITED types.
Example:
Semaphore = POINTER TO LIMITED RECORD END;
PROCEDURE New (level: INTEGER): Semaphore;
In the BlackBox Component Framework, most abstractions are represented as abstract types, which are implemented by (non-exported) final types. This is another approach that allows to guarantee correct initialization, but it is too inconvenient for simple non-extensible abstractions. Moreover, LIMITED types cannot be substituted by client-side extensions. This is important, because it allows to protect non-extensible services, such as a real-time kernel, from being used with illegal types.
Record syntax
The record syntax looks as follows:
RecordType = [EXTENSIBLE | ABSTRACT | LIMITED] RECORD ["(" QualIdent ")"] FieldList {";" FieldList} END.
Note that a pure client programmer never needs to write any of the above attributes. The same is true for an implementor of a framework extension. Even the framework designer may save some time using these attributes, because they are an important part of the documentation that can be extracted automatically from the source code.
The goal for the introduction of these attributes was to increase the static expressiveness of interfaces, such that important architectural decisions can be written down explicitly, in a way that a compiler can check conformance of an implementation or a client with the interface contract. A pure implementation language wouldn't need the new attributes, only a component-oriented implementation and design language needs to be able to express such design constraints. Control over such constraints enables a framework designer to establish important invariants over a whole software system (= system architecture), thus improving safety, maintainability, and evolvability.
Some of the new attributes also add convenience; e.g., abstract methods need no procedure body anymore. Such additional convenience is a welcome benefit, but it was by no means the reason for the introduction of the attributes.
Default and EXTENSIBLE methods
Like record types, methods of a record type can also be attributed. The attributes available are the default (no attribute), EXTENSIBLE, ABSTRACT and EMPTY.
Like record types, methods are final by default:
PROCEDURE (t: T) StaticProcedure (x, y: INTEGER), NEW;
BEGIN
...
END StaticProcedure;
Methods that are both new and final can be treated by a compiler like normal procedures, since they don't require late binding. Nevertheless, their use can be appropriate if they clearly belong to a particular type.
Extensible methods on the other hand are marked as such, e.g.:
PROCEDURE (t: T) Method (x, y: INTEGER), NEW, EXTENSIBLE;
BEGIN
...
END Method;
It is much more common to use abstract or empty methods, which are special cases of extensible methods (see below).
Declaring a method as final is achieved by simply leaving away the EXTENSIBLE attribute:
PROCEDURE (t: T) FinalInheritedMethod (x, y: INTEGER);
BEGIN
...
END FinalInheritedMethod;
If a black-box design style is used, most methods that need to be implemented for a framework extension are of the above kind, which requires no special attributes in the method signature. This is reasonable, because there are more framework extension programmers than there are framework designers, thus extensions should be as convenient as possible to write down.
Final methods may be bound to any record types. Extensible methods may only be bound to extensible types (i.e., EXTENSIBLE or ABSTRACT).
Since final methods cannot be "overridden", the invariants that they guarantee and the postconditions that they establish cannot be violated. Note that correct "extension" of a method means that the extending method implements a refinement of the extended method. Semantically, this means that the extending method accepts a weaker precondition or establishes a stronger postcondition compared to the extended method.
ABSTRACT methods
An abstract method is declared in the following way:
PROCEDURE (t: T) SomeMethod (s: SET), NEW, ABSTRACT;
PROCEDURE (t: T) CovariantMethod2 (): NarrowedType, ABSTRACT;
Abstract methods are extensible. The compiler checks that a concrete type implements all abstract methods that it inherits. A concrete extension of an abstract method (or type) can be regarded as its implementation. Abstract methods may only be bound to abstract types, and they may not be called via super calls.
An abstract method has no corresponding procedure body, it only exists as a signature. There is no need anymore to write a procedure body with a HALT statement.
EMPTY methods
A method can be declared as empty. Empty methods are extensible. An empty method is very similar to an abstract method, in that it is a hook for functionality that can be provided in later extensions. However, empty methods are concrete and can be called. If they have not been extended (i.e., implemented), calling them has no effect.
Empty methods represent optional interfaces. For example, a BlackBox Component Framework View provides an empty method for handling user events (HandleCtrlMsg). This method is implemented in interactive views, passive views ignore it.
It is not possible to introduce code in an empty procedure. For this reason, an empty method has no corresponding procedure body, and may not be called via super calls.
Empty procedures may not return function results and may not have OUT parameters.
Example:
PROCEDURE (t: T) Broadcast (msg: Message), NEW, EMPTY;
Method syntax
The method syntax looks as follows:
TBProc = PROCEDURE Receiver IdentDef [FormalPars] [Attribution].
Attribution = ["," NEW] ["," (EXTENSIBLE | ABSTRACT | EMPTY)].
Note that a pure client programmer never needs to write any of these attributes. The same is true for an implementor of a framework extension. Even the framework designer may save some time using these attributes, because they are an important part of the documentation that can be extracted automatically from the source code.
Implement-only export of methods
A method may now also be exported as implement-only, using the "-" export mark instead of the "*". Implement-only export means that the method may be implemented outside the defining module, but may not be called from there.
Whether a method is exported normally or implement-only is decided when the method is first introduced (NEW method). Later extensions must use the same export mode if exported.
Implement-only exported methods are called from within the module where a method is newly introduced; they go "upwards" in the module hierarchy (upcalls). For frameworks, the existence of such upcalls is typical. Implement-only export allows to prevent framework clients from violating the framework's invariants, while still making it possible to provide new implementations of the framework's types.
Every framework has two "faces": an interface for clients, and an interface for implementors, the so-called specialization interface. These two interfaces may overlap. Implement-only export allows to clearly label those parts of an interface that belong to the specialization interface only.
Super calls
Because of the so-called semantic fragile base class problem, it is recommended to avoid super calls whenever possible. It is possible to design new software such that they are not needed, by relying on composition rather than on implementation inheritance. Super calls are considered to be an obsolete feature. For the time being, they are retained for backward compatibility. In the long run, support for super calls may be reduced.
Procedure types
Procedure types are less flexible than objects with methods. Even standard examples for procedure types in numerical software can benefit from modeling them as objects. Objects are extensible, procedure types are not. Procedure types can pose considerable implementation difficulties concerning the safe unloading of code. For these reasons, procedure types are considered as obsolete. For the time being, they are retained for backward compatibility and for implementation low-level interfacing code (callbacks). In the long run, support for super calls may be reduced.
ANYREC and ANYPTR
Each base record is implicitly regarded as an extension of the new abstract standard type ANYREC, even if it is declared without explicit base type. ANYREC is an empty record that forms the root of all record type hierarchies. ANYPTR is a new standard type that corresponds to a POINTER TO ANYREC.
These new types make it easier to achieve interoperability between independently developed frameworks, by allowing completely generic parameters.
The following pseudo definitions can be assumed:
ANYREC = ABSTRACT RECORD END;
ANYPTR = POINTER TO ANYREC;
PROCEDURE (a: ANYPTR) FINALIZE-, NEW, EMPTY;
The FINALIZE procedure is empty. It can be implemented for a pointer type extension. The procedure is called at some unspecified time after the object has become unreachable via other pointers (not globally anchored anymore) and before the object is deallocated. Finalizers are needed to release resources that are not directly Component Pascal objects; e.g., file sectors, font handles, window pointers of the operating system, and so on.
The finalization order is not defined. An object is only finalized once.
String support
Explicit string types
We can distinguish a string value (the actual character values) from the variable in which it is contained (an array of character). Some operations in Component Pascal operate on the string value (e.g., comparison for equality), others operate on the container variable (e.g., assignment). A compiler can automatically derive which interpretation is needed in a given situation. Unfortunately, there are situations where both interpretations make sense. For example, passing an array of character to a value parameter (which is also an array of character) should be interpreted as an assignment. But often it is more efficient only to copy the string value in the actual parameter, rather than the whole array. Consider passing a Unix path name, declared as an array of character with 2048 elements, when it usually contains only a few dozen characters.
In Component Pascal, it can be made explicit that the programmer wants to work with the string value, rather than the character array variable. Selecting the string value in a variable is denoted with the $ operator; for example
OpenFile(pathname$)
where OpenFile is declared as
PROCEDURE OpenFile (name: ARRAY 2048 CHAR)
Note an additional benefit: it is now more attractive to declare character array parameters with a fixed number of elements, like in the above example. In Oberon, this is inconvenient since often the type of the actual parameter is not compatible with the formal parameter. Since string values are always compatible with character arrays, this problem vanishes in Component Pascal. This is important because it is more precise to specify a fixed size array when the array is known to be limited. Note that declaring an open array would be a contract to accept arrays of any length whatsoever (without ever leading to an out-of-range error at run-time!).
String concatenation
The + operator now allows to concatenate strings. The target variable must be of sufficient length to hold the resulting string.
Elimination of COPY
The auxiliary procedure COPY is not necessary anymore, since the $ operator makes it superfluous. For example,
COPY(a, varpar) is replaced by varpar := a$
Specified domains of types
To achieve fully portable code, it is necessary to fully specify the domains of all base types. The Component Pascal base types are a superset of the Java base types.
Type Size Domain
SHORTCHAR 1 byte Latin-1 character set
(first Unicode page and a superset of ASCII)
CHAR 2 byte Unicode character set
BYTE 1 byte signed integer
SHORTINT 2 byte signed integer
INTEGER 4 byte signed integer
LONGINT 8 byte signed integer
SHORTREAL 32 bit IEEE
REAL 64 bit IEEE
SET 4 byte bitset
BOOLEAN 1 byte FALSE or TRUE
Type LONGREAL has been eliminated. Longreal literals have been eliminated; i.e., use 1.0E2 instead of 1.0D2. The identifier LONGREAL is reserved for possible future use. Real constants are always REAL (64 bit) values.
Hexadecimal integer constants now can be specified either as 4 byte (e.g., 0FFFFFFFFH) or 8 byte constants (e.g., 0FFFFFFFFFFFFFFFFL). This allows to distinguish negative INTEGER hex constants from positive LONGINT hex constants. For example, 0FFFFFFFF denotes -1 when interpreted as INTEGER, but 4294967295 when interpreted as a LONGINT.
Integer constants are always INTEGER (4 byte) values. Assignment of an integer constant to a smaller type (e.g., BYTE) is legal if the constant lies within the range of the target type. Integer constants of other types can only be constructed using SHORT or LONG, except that sufficiently large constants automatically have type LONGINT.
Integer arithmetic is now always performed with 32-bit precision, except for expressions that contain LONGINT values. In the latter case, 64-bit precision is used. This rule makes it less likely to produce hard-to-find overflows of intermediate results that are calculated at insufficient precision.
Floating-point arithmetic is always perfomed at 64-bit precision.
Miscellaneous
The semantics of DIV is strengthened, by specifying the result of divisions by negative numbers.
The new real value INF for infinity has been introduced. This value may be generated e.g. through floating-point division by zero. The meaning of infinity for floating-point numbers is defined by the IEEE standard for floating-point numbers.
It has been specified more comprehensively where pointer dereferencing is implicit. For example, it is now also available when passing a pointer variable to a record type formal parameter.
Record types can be declared as extensions of other record types by mentioning a pointer type as base type (instead of a record type). This makes the explicit naming of a record type superfluous, if the record variables are used via pointers only.
Within a scope, type names can be considered as forward-declared. This means that any type name can be used before it is declared. Old-style pointer forward declarations like T = POINTER TO TDesc are still allowed, since they are simply a special case of the new rule, but they are not necessary anymore.
BITS is a new standard function that converts an INTEGER value to a SET value, such that BITS(1) yields {0}. For example, this allows to write more portable device drivers, since it doesn't depend on the processor's bit ordering (which differs for 68k and PowerPC, for example).
ORD can now also be applied to SET values (inverse operation of BITS).
MIN and MAX now also accept two parameters; e.g. real0 := MAX(someInt, real1). They select the minimal/maximal values of the two inputs, which must be number types.
LEN can also be used on string values. LEN(chararray) returns the length of the chararray variable, while LEN(chararray$) returns the length of the string value. Note that a character array must have at least one more element than the string value contains characters, to hold the terminating 0X character.
Designators are generalized to allow dereferencing etc. on a function result. For example, the following is now legal:
length := view.ThisModel()(TextModels.Model).Length() or
view.Context().GetSize(w, h)
The relaxation of the designator syntax makes it easier to use methods instead of record fields. Methods are more flexible and make it simpler to implement wrappers (forwarding of method calls) than record fields do.
Global variables, including heap variables allocated with NEW, now have a defined initial value (FALSE, 0X, 0, 0.0, {}, NIL, ""). Local (i.e., stack) variables are not initialized, except for pointers and procedure variables which are set to NIL for safety reasons.
An appendix of the language report specifies the minimal environment requirements that any Component Pascal implementation must fulfill. In particular, commands, dynamic loading, and garbage collection are fundamental requirements for component-oriented systems. Like for all dynamic languages, this appendix acknowledges that the language cannot be regarded completely independently from its environment. The object model, whether assumed in the language definition or accessed as an external service, is always part of the environment.
To simplify interfacing of existing C libraries, underscores in identifiers are allowed.
The rules for export marks have been simplified compared to Oberon: An extending method must have exactly the same export mark as the method that it extends. The only exception occurs if the method is part of a non-exported record; in this case it may not be exported.
A module now has an optional CLOSE section, after the BEGIN section. The close section is called before a module is unloaded. A module's BEGIN section is called after all the imported modules' BEGIN sections have been called. A module's CLOSE section may only be called after all the importing modules' CLOSE sections have been called.
In summary, you'll note that this revised language definition contains one major extension: a more expressive interface definition language (IDL) subset (NEW; EXTENSIBLE; ABSTRACT; LIMITED; EMPTY; implement-only export of methods) that makes it easier to specify architectural properties of a component framework.
The other points are mostly detail improvements based on a decade of experience in using the language. Particularly noteworthy are the more general and systematic treatment of strings and the new specification of the base type sizes.
Acknowledgements
I would like to thank Beat Heeb, Dominik Gruntz, Matthias Hausner, and Daniel Diez of Oberon microsystems for their valuable input. In particular, without Beat's work this endeavour would have been impossible. The most important external contributions came from Clemens Szyperski (Queensland University of Technology, Australia) and Wolfgang Weck (Еbo Akademi, Finland). Last but not least, I would like to thank Prof. Niklaus Wirth for commenting an early revision of the Component Pascal language report, and for having created such a great foundation.
| Docu/CP-New.odc |
Direct-To-COM Compiler
The Component Object Model
The Component Object Model (COM) is an object model which allows independently developed binary software components to connect to and communicate with each other in a well-defined manner. COM defines a binary standard for object interoperability which is programming-language and compiler independent.
The primary architectural feature of COM is that an object exposes a set of interfaces to a client. An interface is a set of semantically related functions. Every object can provide multiple interfaces. COM objects can only be accessed through pointers to interfaces (interface pointers). Direct access to an object's internal variables is not possible. This allows for encapsulation of data and processing, a fundamental requirement of a true component software standard.
Another fundamental concept of the COM model is reference counting. Reference counting allows objects to track their own lifetime and delete themselves when appropriate.
The following figure visualizes a COM object as large black box, which is accessible from the outside only via pointers to its exported interfaces. Internally, a COM object typically contains a large number of simpler objects, which constitute its hidden implementation. Note that there are pointers from each interface record of the COM object to each other interface record, directly or indirectly. Also, every implementation object is connected to the interfaces through one or several pointer chains. Pointer chains may contain cycles.
Binary Standard
COM defines a standardized way to layout the concrete implementation of interfaces. Every COM object provides the implementation of each method specified in the interface. The pointers to the method implementations are stored in an array, a so called virtual function table (vtable). The interface record is a structure whose first entry is a pointer to a vtable; it may contain additional private object data. COM clients only interact with a COM object through pointers to interfaces, i.e. with pointers to pointers to vtables. It is through such a pointer that the client accesses the object's implementation of the interface. Therefore, any language that can call functions via pointers (using the StdCall calling conventions) can be used to write and use COM components.
interface pointer interface vtable
Reference Counting in COM
COM uses reference counting as a simple form of (manual) garbage collection. Reference counting is performed through two standard methods called AddRef and Release. Whenever a new reference to an interface is established, AddRef must be called. When the interface is no longer needed, Release must be called. Reference counting is done at the interface level, i.e., every interface must support the two methods AddRef and Release. They are defined in the interface IUnknown which is the base interface of every COM interface. Internally, the interface implementation counts the number of AddRef and Release calls, and thereby knows when it is safe to free the memory that it occupies.
Conceptually, reference counting is performed at the interface level. However, as a COM object can support several interfaces, it is free to implement one central reference count per object, instead of one reference count per interface. However, a client should never assume that an object uses the same counter for several interfaces; i.e., it should increment the reference count always through the interface which is about to be used.
The following two simple rules define how reference counts have to be managed. Interface pointer variables are variables which hold interface pointers. Such variables may be located in memory or in processor registers.
1) Whenever an interface pointer is stored in an interface pointer variable, AddRef must be called through this interface pointer.
2) Immediately before an interface pointer variable is cleared, overwritten, or destroyed, Release must be called on the interface pointer presently in the variable.
Rule 1 implies that a function that returns an interface pointer must call AddRef on this interface, as it stores a new interface pointer in a register or in memory (i.e., at a place where access is still possible). Examples of such functions are IUnknown.QueryInterface and IFactory.CreateInstance.
Rule 2 implies that Release must be called on old values of an interface pointer variable before assigning a new value, and on local interface pointers before leaving the scope.
The example below demonstrates the use of these two rules:
IFactory* pFactory;
HRESULT hr = GetFactory(IID_IFactory, (void**)&pFactory);
if (SUCCEEDED(hr)) // Reference count of factory has been incremented by GetFactory
{
IAnimal* pAnimal1;
hr = pFactory->CreateInstance(0, IID_IAnimal, (void**)&pAnimal1); // (2)
if (SUCCEEDED(hr)) // Reference count of pAnimal1 incremented by CreateInstance
{
IAnimal* pAnimal2 = pAnimal1;
pAnimal2->AddRef(); // Increment Reference Count (1)
pAnimal2->Sleep(); // Do something through pAnimal2
pAnimal1->Release(); // Release Interface before assigning a new animal (1) (3)
hr = factory->CreateInstance(0, IID_IAnimal, (void**)&pAnimal1);
if (SUCCEEDED(hr)) // Reference count of pAnimal1 incremented by CreateInstance
{
pAnimal1->Eat(); // Do something with second animal
pAnimal1->Release(); // scope in which pAnimal1 is declared will be closed soon
}
pAnimal2->Release(); // scope in which pAnimal2 is declared will be closed
}
pFactory->Release(); // scope in which pFactory is declared wil be closed soon
}
In principle, every assignment to an interface pointer must be accompanied by a Release call (except for NULL or uninitialized interface pointers) and an AddRef call. However, in some special situations, AddRef and Release pairs can be omitted safely.
Unfortunately, the COM specification defines some special rules for interface parameters of methods. An interface may specify that some arguments of its methods are passed only in one direction; i.e., only from the client to the server or vice versa. This minimizes communication overhead for calls across process or machine boundaries (remote procedure calls), but it complicates the rules for the COM programmer.
| Docu/DTC-COM.odc |
Direct-To-COM Compiler
The Direct-To-COM Compiler
Contents
COMCompilerExtensions
COMSysflagsforInterfaceStructures
COMsysflagsforVARparameters
TheModuleCOM
NewPredefinedProcedures
Unions
COMProgrammingHints
CompilerImplementationRestrictions
The Direct-To-COM (DTC) compiler is a Component Pascal compiler that supports Microsoft's Component Object Model (COM) binary interface standard. In DTC Component Pascal, COM objects are declared and implemented in a superset of the Component Pascal language. They can be used from any other language, and COM objects implemented in any language can be used from Component Pascal.
In Component Pascal, COM interfaces are mapped to special Component Pascal records. Interface pointers are pointers to such records. The virtual function table is the method table of the Component Pascal type descriptor. It is hidden from the programmer. A COM interface can be defined in the following way:
ILookup* = POINTER TO ABSTRACT RECORD
["{C4910D71-BA7D-11CD-94E8-08001701A8A3}"] (COM.IUnknown) END;
PROCEDURE (this: ILookup) LookupByName*(
name: WinApi.PtrWSTR; OUT number: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT;
PROCEDURE (this: ILookup) LookupByNumber*(
number: WinApi.PtrWSTR; OUT name: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT;
Interface definitions can be derived from one another using Component Pascal subtyping. The above interface is a subtype of the interface COM.IUnknown. The interface identifier (IID) is specified in the declaration of the interface. The interface is declared to be abstract and cannot be instantiated. Concrete implementations of interface objects are extensions of interface records. In contrast to the interface records which are referenced through (reference-counted) interface pointers, the implementation records are referenced through regular Component Pascal pointers.
The COM standard uses reference counting as its memory management strategy. Reference counting errors, however, are the most difficult and dangerous errors when programming to the OLE interfaces. The "Safer OLE" technology of the DTC compiler adds automatic memory management to COM objects. In contrast to C and C++, programmers using the DTC Component Pascal compiler do not need to worry about reference counting. The compiler automatically generates calls of an object's AddRef and Release methods where necessary, and the compiler also automatically implements the AddRef and Release methods for interfaces implemented in Component Pascal. When a COM object is no longer used, it is automatically removed from memory. Components written in DTC Component Pascal become more reliable and maintainable.
In Component Pascal, the above example looks as follows:
VAR
factory: IFactory;
animal1, animal2: IAnimal;
hr: COM.RESULT;
BEGIN
hr := GetFactory(COM.ID(IFactory), factory);
IF hr >= 0 THEN
hr := factory.CreateInstance(NIL, COM.ID(animal1), animal1);
IF hr >= 0 THEN
animal2 := animal1;
animal2.Sleep();
hr := factory.CreateInstance(NIL, COM.ID(animal1), animal1);
IF hr >= 0 THEN
animal1.Eat()
END
END
END
END
Calls to the reference counting methods are generated for assignments to interface pointer variables. The garbage collector recognizes COM interface implementations and does not remove such objects with a reference count greater than zero. If the garbage collector finds a COM interface object with reference count zero, then all interface pointers stored in this object are released before the object is collected. The same holds for local variables if the scope is left and for global variables that are stored in a component to be unloaded. This automatic garbage collection mechanism just generates code that would have to be written manually in any case. Thus it does not require any extra run time and is fully compatible with other components, created with other tools.
The DTC compiler is integrated in the development environment BlackBox. The debugger allows to inspect components and objects on a symbolic level. In order to browse through dynamic memory, you use hypertext links to follow pointers.
Effective support for COM in Component Pascal requires special language constructs, e.g. to specify the unique id of a COM interface. We clearly separate these language extensions from the core language. The reason is that such interfacing features should and need not be used in normal Component Pascal modules, and moreover, COM is only one of an increasing number of object models which could be supported. Modules using the special language constructs must flag this fact in the module header. If you look at the beginning of a module source, it should immediately be clear whether this is an (unportable) module and whether it is unsafe or not. We already have followed this principle in earlier products: system flags and other similar features are only allowed in modules which import the pseudo-module SYSTEM. This module and the necessary compiler extensions are not considered part of the language definition proper. In a similar vein, a pseudo-module COM needs to be imported in order to make the special COM features available in a module. This module is not considered a part of Component Pascal itself.
To quote Prof. N. Wirth from the ETH technical report #82 (From Modula to Oberon):
"It appears preferrable to drop the pretense of portability of programs that import a "standard", yet system-specific module. Both, the module SYSTEM and the type transfer functions are therefore eliminated, and with them also the types ADDRESS and WORD. Individual implementations are free to provide system-dependent modules, but they do not belong to the general language definition. Their use then declares a program to be patently implementation-specific, and thereby non-portable."
In this spirit, procedural DLLs and COM DLLs are system-specific. A software system should minimize the number and size of modules directly using them, and encapsulate the latter such that their module interfaces only use the core Component Pascal features wherever possible (abstraction!).
For this reason it is considered good software engineering practice to structure the implementation of a complex COM object such that the number of objects (and their modules) that contain references to interfaces are minimized and they are concentrated at the "top" and "bottom" of the module hierarchy, so that the intermediate layer consists of pure Component Pascal modules which don't use any special COM features:
This leads to a module structure such as the following, where the top-level module implements the COM interfaces (export), the bottom-level modules implement access to existing COM interfaces (import), while the intermediate modules are implemented in portable, safe, and non-COM-specific modules:
COM Compiler Extensions
The compiler features added in order to support COM are modest. In particular, new sysflags for interface records and VAR parameters have been defined and union records are provided. Some additional types and functions are defined in the pseudo module COM.
In order to access these extended facilities, the pseudo module COM must be imported. In the following, the special COM extensions are explained.
COM Sysflags for Interface Structures
Interface records are marked by the interface sysflag or by a GUID (globally unique identifier) flag. The GUID string must be a valid GUID constant spelled out in hex and wrapped in braces.
TYPE
IExample = POINTER TO ABSTRACT RECORD
["{91C074A1-C2D7-11CF-A4A1-444553540000}"] (COM.IUnknown) END;
PROCEDURE (e: IExample) MethodA(): COM.RESULT, NEW, ABSTRACT;
Instead of an explicit GUID, an interface record can also be marked with the interface sysflag. Such interfaces however cannot be requested through a QueryInterfaceЏcall as they have no identifier. They can be used to implement outgoing interfaces which are not explicitely requested.
TYPE
IExample = POINTER TO ABSTRACT RECORD [interface] (COM.IUnknown) END;
PROCEDURE (e: IExample) MethodA(): COM.RESULT, NEW, ABSTRACT
Interface records and interface pointers must be (direct or indirect) extensions of COM.IUnknown. Interface records must be abstract and therefore must not contain any fields. Procedures bound to interface records must also be abstract. Abstract records cannot be allocated. The only legal usage of an interface record is as a record or pointer base type or as type of an interface pointer variable.
An implementation extension of an interface must overwrite all abstract procedures bound to the interface record. Exceptions are the procedures defined by COM.IUnknown:
The following example defines an implementation of the IExample interface. By convention, type names of interface pointers start with an I, and type names of (implementing) classes with a C.
TYPE
CExample = POINTER TO RECORD (IExample) END;
PROCEDURE (e: CExample) MethodA(): COM.RESULT;
BEGIN RETURN WinApi.E_NOTIMPL
END MethodA;
COM Sysflags for VAR Parameters
[nil] The nil flag for VAR parameters indicates that NIL may also be used as an actual parameter.
With the function VALID (see below) it can be tested whether an actual VAR parameter is valid, i.e. is not NIL. If the actual parameter is not valid (i.e. is NIL), then it must neither be read nor written. It may only be passed as actual parameter for another nil-parameter. Attempts to read or write an invalid nil parameter leads to a NIL dereference trap.
[new] [iid] The iid and new VAR parameter flags allow to specify polymorphic out parameters. They allow to implement QueryInterface-like operations.
The new and iid parameters must always be paired in a parameter list. A new parameter must be followed by a corresponding iid parameter or vice versa. A parameter list may contain only one new-iid pair.
The iid parameter must be an IN parameter of type GUID, and the new parameter must be an OUT parameter of an interface type.
The type passed as iid parameter defines the static type of the polymorphic out parameter. The dynamic type of the out parameter can be a subtype of the asserted static type. The actual parameter passed for the interface parameter may be a base type of the asserted static type and may be an extension of the formal parameter. In other words, the following relation must be satisfied for the actual parameters of a polymorphic out parameter (<= refers to the subtype relation)
type of formal new parameter
<= static type of actual new parameter
<= type specified through iid parameter
<= dynamic type of actual new parameter (on return)
The following program fragment shows some examples of the use of polymorphic out parameters.
TYPE
IExample = POINTER TO ABSTRACT RECORD
["{91C074A1-C2D7-11CF-A4A1-444553540000}"] (COM.IUnknown) END;
IExample2 = POINTER TO ABSTRACT RECORD
["{91C074A2-C2D7-11CF-A4A1-444553540000}"] (IExample) END;
PROCEDURE GetInterface(IN [iid] id: COM.GUID; OUT [new] int: COM.IUnknown);
END GetInterface;
PROCEDURE Test;
VAR i0: COM.IUnknown; i1: IExample; i2: IExample2;
BEGIN
GetInterface(COM.ID(i1), i0); (* valid *)
GetInterface(COM.ID(i1), i1); (* valid *)
GetInterface(COM.ID(i1), i2); (* compiler error: wrong [iid] - [new] pair *)
END Test;
A procedure like
PROCEDURE QueryInterface (IN [iid] id: COM.GUID; OUT [new] int: COM.IUnknown);
can be called in four different ways:
- QueryInterface(COM.ID(p1), p0) where p0 is an extension of COM.IUnknown and p1 is an extension of p0.
VAR i1: IExample; i2: IExample2;
QueryInterface(COM.ID(i2), i1);
- QueryInterface(COM.ID(T), p) where p is an extension of COM.IUnknown and T is a subtype of the type of p.
VAR i1: IExample;
QueryInterface(COM.ID(IExample2), i1);
- QueryInterface(id, p) where id is an arbitrary GUID and p is of type COM.IUnknown.
VAR p: COM.IUnknown;
QueryInterface("{91C074A1-C2D7-11CF-A4A1-444553540000}", p);
- QueryInterface(id, int) where id and int are another [iid], [new] pair.
PROCEDURE P (IN [iid] id: COM.GUID; OUT [new] int: COM.IUnknown);
BEGIN QueryInterface(id, int)
END P;
In a procedure with an iid-new parameter pair, the interface parameter cannot be assigned directly, but id and int can be used as formal parameters to another [new], [iid] pair or to COM.QUERY (see below).
The Module COM
The module COM contains certain types and procedures that are necessary to implement COM components. As module SYSTEM, module COM is a pseudo module, i.e., no symbol file exists for module COM. If module COM is imported, this is only a declaration for the compiler. A pseudo description of the interface is shown below:
DEFINITION COM;
TYPE
RESULT = INTEGER;
GUID = ARRAY 16 OF BYTE; (* modified compare semantics *)
IUnknown = POINTER TO ABSTRACT RECORD ["{00000000-0000-0000-C000-000000000046}"]
(this: IUnknown) QueryInterface (IN [iid] iid: GUID; OUT [new] int: IUnknown): RESULT,
NEW, ABSTRACT;
(this: IUnknown) AddRef, NEW, ABSTRACT; (* hidden, can neither be called nor overwritten *)
(this: IUnknown) Release, NEW, ABSTRACT; (* hidden, can neither be caled nor overwritten *)
(this: IUnknown) RELEASE-, NEW, EXTENSIBLE;
END;
PROCEDURE QUERY (p: IUnknown; IN [iid] id: GUID; OUT [new] ip: IUnknown): BOOLEAN;
PROCEDURE ID (t: INTERFACETYPE): GUID;
PROCEDURE ID (p: IUnknown): GUID;
PROCEDURE ID (s: ARRAY OF CHAR): GUID;
END COM.
TYPE RESULT
Result type of most COM operations (alias of INTEGER). The error translator of the Direct-To-COM development environment can be used to obtain a meaningful description from such a result.
TYPE GUID
Type for globally unique identifiers (GUIDs). A GUID is a 128 bit identifier. String constant expressions representing a valid GUID can be assigned to a GUID variable.
VAR id: COM.GUID;
id := "{12345678-1000-11cf-adf0-444553540000}";
TYPE IUnknown
COM Interface, ABSTRACT
The type IUnknown is the base type of all COM interfaces. IUnknown is a pointer to an abstract record.
PROCEDURE (this: IUnknown) AddRef;
NEW, HIDDEN
PROCEDURE (this: IUnknown) Release;
NEW, HIDDEN
The AddRef and Release methods are necessary to control the reference count of a COM object. AddRef and Release are always handled implicitly, they can neither be overwritten nor called.
PROCEDURE (this: IUnknown) QueryInterface (IN [iid] iid: GUID; OUT [new] int: IUnknown): RESULT;
NEW, DEFAULT
QueryInterface is used to ask for interfaces a COM object supports. It is implemented by default but may be overwritten if special behaviour is needed (e.g. for objects which support several interfaces). For an example see module ComObject.
The default implementation of QueryInterface has the following form. The pointer this.outer is a hidden reference to another COM object which can be specified with the two-argument NEW procedure (see below).
PROCEDURE (this: IUnknown) QueryInterface (
IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT;
BEGIN
IF this.outer # NIL THEN
RETURN this.outer.QueryInterface(iid, int)
ELSE
IF COM.QUERY(this, iid, int) THEN RETURN WinApi.S_OK
ELSE RETURN WinApi.E_NOINTERFACE
END
END
END QueryInterface;
PROCEDURE (this: IUnknown) RELEASE-;
NEW, EMPTY
The RELEASE method is called whenever the reference cout drops from one to zero. Note that if the system calls the RELEASE method, the interface is not necessarily removed by the garbage collector as Component Pascal pointer references to the object may still exist.
RELEASE gives additional control over COM objects besides the FINALIZE method which is provided for all (tagged) Component Pascal records. In contrast to the FINALIZE method, the RELEASE method may be called several times.
PROCEDURE ID (t: INTERFACETYPE): GUID
The actual parameter must be the name of a type.
Returns the GUID associated with interface type t (pointer or record).
PROCEDURE ID (p: IUnknown): GUID
Returns the GUID associated with the static type of the actual parameter passed for p.
PROCEDURE ID (s: ARRAY OF CHAR): GUID
Returns the GUID from a textual representation (string constant).
PROCEDURE QUERY (p: COM.IUnknown;
IN [iid] id: COM.GUID, OUT [new] ip: COM.IUnknown): BOOLEAN;
QUERY allows safe assignments to polymorphic out parameters.
If there exists a type t with the following properties:
- t is an interface type
- p points to an extension of t
- ID(t) = id
then p is assigned to ip and the function returns TRUE. Otherwise ip remains unchanged and the function returns FALSE. COM.QUERY allows safe and simple implementations of QueryInterface without any restrictions.
New Predefined Procedures
In the Direct-To-COM compiler the following additional predefined procedures are available.
Function procedures
VALID (v: VARPAR): BOOLEAN; v (a VAR [nil] parameter) is not nil
Proper procedures
NEW(VAR p: COM.IUnknown); allocates p^
NEW(VAR p: COM.IUnknown; outer: COM.IUnknown); allocates p^ as subobject of outer
The two-argument version of NEW is used when implementing aggregation (see example ComAggregate) or to implement COM objects supporting several interfaces (see example ComObject). AddRef, Release, and QueryInterface calls are forwarded to the outer object. If AddRef or Release of p is called, then both the reference count of p and of the outer interface are incremented or decremented respectively.
Unions
In order to simplify the mapping of C data structures, the Direct-To-COM compiler supports union records. In a union record all fields are aligned at offset 0. The size of a union record is the maximal size of its fields. The semantics of union records are the one of C union structures and not the one of Pascal-like variant records. With nested records and union records, Pascal-like variant records can be simulated also. A union record is marked with the union sysflag.
Example:
TYPE
Complex = RECORD
type: SHORTINT;
u: RECORD [union]
cart: RECORD x, y: LONGREAL END;
polar: RECORD phi, rho: LONGREAL END
END
END
Warning: pointers in union records are unsafe and are ignored by the garbage collector!
COM Programming Hints
If you want to free an interface explicitly for some reason, just assign NIL to the interface pointer. This will call Release() on the pointer and additionally prevents you from using the (no longer valid) pointer accidentally.
The golden rule of COM programming in Component Pascal:
Never use an interface pointer if you can use a Component Pascal pointer instead.
Although interface pointers are safely handled by the compiler, there are still unsafe constructs which must be handled carefully. This specifically applies to C pointers which are not interface pointers, like pointers to strings. The lifecycle of such pointers must be controlled by explicit Allocate and Deallocate calls. It also applies to structures containing C-style unions. Pointers in such structures (including interface pointers) must be handled manually. See the ComTools documentation for an example of how such a structure can be used safely.
Compiler Implementation Restrictions
- Untagged open arrays (arrays with unspecified length) containing interface pointers may not be assigned as a whole.
Workaround: Assign the individual elements.
- The array supplied for an out parameter of type "untagged array of interface pointer" may not be open.
Workaround: Use an array with defined length.
- Out parameters of type "untagged open array of pointer" are not initialized to NIL.
Workaround: Initialize them manually.
| Docu/DTC-Comp.odc |
Direct-To-COM Compiler
The Integrated Development Environment
Contents
Linker
InterfaceЏBrowser
COMЏInterfaceЏInspector
OtherЏCOMЏCommands
Besides the compiler (which is described in COM Compiler Extension documentation), the DTC development environment offers some special facilities. Most of them are accessible through the COM menu.
Linker
With the linker Component Pascal modules can be linked to DLL (in process servers) or to EXE (out of process servers) files. Furthermore it can be decided whether a dynamic module loader should be added or not. This leads to the following four link commands:
EXE DLL
unextensible DevLinker.LinkExe DevLinker.LinkDll
extensible DevLinker.Link DevLinker.LinkDynDll
For further information about the linker we also refer to the DevLinker Documentation.
DevLinker.Link
This command links a module set containing a dynamic module loader to an EXE file.
At startup the body of the main module is called.
Initialization and termination of the dynamically loaded modules must be done by the runtime system.
DevLinker.LinkExe
This command links an nonextensible module set to an EXE file.
At startup the bodies of all modules are called in the correct order.
If the last body terminates, the terminators of all modules are called in reverse order.
No runtime system is needed for initialization and termination.
For an example see ComKoalaExe.
DevLinker.LinkDll
This command links a non-extensible module set to a DLL file.
When the DLL is attached to a process, the bodies of all modules are called in the correct order.
When the DLL is released from the process, the terminators of all modules are called in reverse order.
No runtime system is needed for initialization and termination.
For an example see ComKoalaDll.
DevLinker.LinkDynDll
(rarely used, present for completeness)
Links a module set containing a dynamic module loader to a DLL file.
When the DLL is attached to a process, the body of the main module is called.
When the DLL is released from the process, the terminator of the main module is called.
Initialization and termination of the dynamically loaded modules must be done by the runtime system.
Interface Browser
To quickly retrieve the actual definition of an interface, a special interface browser is available under the menu command COM->Interface Info. In contrast to the BlackBox browser, the COM interface browser displays additional information such as the number of the functions in the interface. Note that the first three entries of every interface are used by the functions of the IUnknown interface.
If you select WinOle.IEnumUnknown and execute COM->Interface Info the following window is opened:
COM Interface Inspector
The COM interface inspector is the most important tool for the development of COM objects. It allows to inspect all currently allocated interface records. The browser is opened with the command COM->Show Interfaces.
For every interface the actual value of its reference count is displayed. After the name and the address of an interface, a diamond mark allows to follow the pointer to the record to which it points (by clicking on the diamond mark). If the interface is anchored globally through a Component Pascal reference, the global anchor is also shown.
With the Update link the interface inspector can be updated, and the All link allows to toggle between the display of all interfaces and of only the non-BlackBox-internal ones.
Interfaces with reference count zero are no longer referenced through an interface pointer, however they might still be referenced by a Component Pascal pointer. Interfaces which are neither referenced through an interface pointer nor through a Component Pascal pointer are garbage collected upon the next run of the garbage collector. The run of the garbage collector can be enforced through the menu command COM->Collect. The collected interfaces disappear when the interface inspector is updated.
Note: If you look at the ComObject example, you will see that every ComObject.Object interface contains Component Pascal pointers to the three interfaces ComObject.IOleObject, ComObject.IDataObject and ComObject.IPersistStorage, i.e. they are not removed by the garbage collector as long as interface pointers refer to a ComObject.Object.
Other COM Commands
Show Error
Almost all COM and OLE API functions and nearly every interface method returns a value of type COM.RESULT. COM.RESULT is an alias type to INTEGER. A result code consists of a severity bit (success or error), a facility code and an error code. If result >= 0, then it is a success code, otherwise it is an error code.
The menu command COM->Show Error can be used to obtain a full text description of the selected result. As input a selected integer is taken. The integer may be given in decimal or hexadecimal notation. E.g. if you select 1236 and execute COM->Show Error, the following window is opened:
For the use in programs the most common error codes are defined in module WinApi.
New GUID
The command COM->New GUID generates a text which contains 10 interface GUIDs. It calls the OLE procedure CoCreateGuid.
Collect
The command COM->Collect explicitly calls the garbage collector.
| Docu/DTC-Env.odc |
Map to the Direct-To-COM Compiler Documentation
Introduction
Direct-To-COM Compiler Tutorials
TheComponentObjectModel HowtoDevelopnewCOMObjects
TheDirect-To-COMCompiler Direct-To-COMExamples
TheDevelopmentEnvironment
Related Documentation
ComponentPascelLanguageReport Platform-SpecificIssues
BlackBoxDocumentation WindowsProgrammingInterfaces
| Docu/DTC-Help.odc |
Direct-To-COM Compiler
How to Develop new COM Objects
This text gives an overview of the typical way in which new OLE objects are developed. It summarizes the most important aspects of what is detailed in the BlackBox user's guide. BlackBox is the integrated development environment (IDE) for the Direct-To-COM Component Pascal compiler with Safer OLE technology.
In a first step, a subsystem name for the project is chosen, and a suitable directory created (with its Code, Mod, and Sym directories). This directory must be in the BlackBox directory itself, i.e. at the same location where the System, Host, etc. directories are. Note that there are no environment variables or path name lists in BlackBox. File lookup is static and determined by module names, not by configurable search paths or similar constructs. It can be convenient to provide a subsystem for private software, like test modules or personal tool commands, e.g. a subsystem Priv.
It is helpful to set up a text document which contains the names of all the subsystem's modules, starting with the one lowest in the module hierarchy. Such a tool text can be used as input to the Dev->OpenModuleList command. This command opens the source file of the module whose name is selected. This is convenient since it can almost eliminate the need to navigate through the directory hierarchy. As a mnemonic aid, the keyboard equivalent for Dev->OpenModuleList is the digit "0", while the keyboard equivalent of the File->Open... command is the letter "O". Dev->OpenModuleList even allows to open several files at the same time, if the selection includes several module names.
Now you are ready to create the module sources, which should be placed in your subsystem's Mod directory. In order to take advantage of autoindentation, you should use tab characters for indentation. You can directly compile the module on which you are working with the Dev->Compile command. This command compiles, but does not yet load, the module. The command Dev->CompileModuleList takes a list of module names and compiles them all.
In order to load the module, you can execute one of its exported parameterless procedures, either by executing the Dev->Execute menu command on the command's name (e.g. on Dialog.Beep), or you can augment your tool text with commanders, e.g. Dialog.Beep (execute Tools->InsertCommander). Once loaded, a module remains loaded, unless you explicitly unload it. Unloading can be done by executing Unload when the source code is focused, or by selecting a module name and calling Dev->UnloadModuleList. This command also works on a sequence of module names, similar to Dev->CompileModuleList. Note that modules must be unloaded from top to bottom, since only modules which are not imported anymore may be unloaded. The loaded modules are displayed in the correct order by the command Info->Loaded Moules. This command opens a text which lists all loaded modules. The command Dev->Unload Module List may directly be called on a selection in this text. In this text, top-level modules, i.e. modules which are not imported by other modules, have a clients count of 0. For the unloading of top-level modules, there is a shortcut if you use a commander: modifier-click on the commander first unloads the old version of the module, then loads the new version, and then calls the procedure.
In order to get quick access to a module's definition or documentation, you can use the commands Info->Interface, or Info->Documentation, respectively. Info->Interface calls the browser to construct a definition text out of a module's symbol file. Note that in this text you can select further module names (or names of imported constants, variables, types, or procedures) and get the interface of those by calling the same command again. If there is a documentation file available for a module, you can execute Info->Documentation after selecting the module's name. This command opens the documentation text. If you have selected not only the module name (e.g. Math) but an object of this module (e.g. Math.Sin), the command tries to find the first occurence of the object's name which is written in boldface. The name is selected, and the window scrolls to the selection's position. In the rare cases where this first occurence is not the one you need, you may call Text->FindAgain to search for the next occurence.
In order to test a module, you can use module Out to write debugging output into the Log window. In order to set breakpoints, you can introduce HALT statements and recompile the module. The trap text which is opened when the HALT is reached gives you information about the call chain (stack) as it has been at the moment the command was interrupted. Note that at no point in time the normal BlackBox environment is left; debugging takes place completely inside BlackBox.
It is recommended to check preconditions and important invariants systematically in all programs, using the ASSERT statement. This debugging strategy is called static debugging, since error conditions are specified statically (even though they can be checked only at run-time). In an object-oriented environment, where the control flow tends to become too convoluted to follow step-by-step, the systematic application of assertions proves to keep debugging times shorter than any interactive debugging ever could.
There is a global menu configuration text. It can be opened with command Info->Menus, edited, and then made the current configuration by calling Info->UpdateMenus.
A menu item may not only have an action command, but also a guard command. Guards mainly determine whether a menu item is currently enabled or disabled.
Distribution of a COM object basically consists of distributing a linked EXE file (application) or a linked DLL (e.g. a control).
How does the dynamic loading facility of BlackBox, as described above, relate to COM binaries? Basically, dynamic loading of individual modules is convenient during development, so you don't need a separate linking step every time before trying out a new version of your code. Only before distributing the code you need to link it into an EXE or DLL.
For example, if you develop an OLE object as one Component Pascal module, you typically load the module by executing its command that registers the object with OLE. Then you switch to some other application which is an OLE client (i.e. a container), such as MS Word. There you can insert the new object and try it out. If you detect some erroneous behavior, close the document and return to BlackBox, i.e. to the OLE server. Unload the module, correct the error in the Component Pascal module(s), recompile, and then continue again with loading the new version of the module.
When working in this way, in principle you can use all BlackBox features for debugging, e.g. the Out module which writes into the Log text, or the symbolic debugger of BlackBox. Only when you're completely satisfied with the object's behavior, you link it together into a DLL.
Unfortunately, for historical reasons ActiveX controls are treated somewhat differently than ordinary OLE objects. For example, controls require the existence of a DLL. For you, this means that you need to link the program into a DLL after each modification and compilation of the sources. Furthermore, for testing you need a program which is a control container; normal OLE containers are not sufficient.
| Docu/DTC-HowTo.odc |
Direct-To-COM Compiler
Introduction
COM
Microsoft's Component Object Model (COM) is a language and compiler independent interface standard for object interoperability on the binary level. COM specifies how objects implemented in one component can access services provided by objects implemented in another component. The services provided by objects are grouped in interfaces, which are sets of semantically related functions. For example, an ActiveX control is a COM object that extends OLE, by implementing concrete implementations of the necessary OLE interfaces. COM makes it possible that an extended software component can be updated without invalidating extending components, e.g., a new release of OLE can be introduced without breaking existing ActiveX controls.
In such an evolving, decentrally constructed system it is difficult to decide whether an object is still used or whether it can be removed from the system. The client of an object does not know whether other clients still have access to the same object, and a server does not know whether a client passed its reference to other clients. This lack of global knowledge can make it hard to determine whether an object is no longer referenced, and thus could be released. If an object is released prematurely, then unpredictable errors will occur. The problem is critical in component software environments, because an erroneous component of one vendor may destroy objects implemented by other vendors' components. It may even take some time until the destroyed objects begin to visibly malfunction. For the end user, it is next to impossible to determine which vendor is to blame.
As a consequence, some form of automatic garbage collection mechanism must be provided. In contrast to closed systems, this is a necessity with component software, and not merely an option or a convenience feature. COM uses reference counting as a rather simple form of garbage collection. Whenever a client gets access to a COM object, it must inform the object that a new reference exists. As soon as the client releases the COM object, it must inform the object that a reference will disappear. A COM object counts its references and thus can control its own lifetime.
Direct-To-COM Compiler
The problem with reference counting is that it depends on the discipline of the programmer. The situation is aggravated by additional subtle rules about who is responsible for the management of the reference counts if COM objects are passed as function arguments. Reliable software construction requires the management of reference counts to be automated.
The Direct-To-COM compiler for Component Pascal completely automates memory management. The compiler and its small run-time system (module Kernel) hides the reference counting mechanism, i.e., a program need not call nor implement the AddRef and Release methods.
For programmers, the integration of COM into a strongly typed, garbage-collected language has two major advantages. Firstly, it brings all the amenities of automatic garbage collection to COM. Secondly, it makes the handling of COM interfaces typesafe.
BlackBox Component Builder
BlackBox Component Builder is the name of the integrated development environment (IDE) of the Direct-To-COM compiler. It provides a program editor, the compiler, and a symbolic debugger. It also contains a multiplatform component framework, which simplifies the implementation of platform-independent software components. However, it is assumed that you won't need access to the BlackBox APIs, since they isolate software from non-portable COM interfaces, while you want to do COM programming.
Note
It is possible to do COM programming while also using the component framework, e.g. to access some functionality for which there is no framework counterpart. In such a case, you can always access the full framework documentation via the help screen.
Getting Started
How should you start to get acquainted with this product? Note that all documentation is available on-line, and can be reached from the help screen. After the Installation of the BlackBox Component Builder, we suggest that you start with the introduction text ABriefHistoryofPascal.
Then move on to the chapters of the user guide which deal with text editing and with the development tools (TextSubsystem and DevSubsystem). After you thus have gained a working knowledge of BlackBox, it is time to delve into the COM-specific parts of the IDE and the Component Pascal compiler extensions for COM.
The section HowtoDevelopnewCOMobjects (p. 20) summarizes the main points of the user guide as far as it pertains to COM development. Then proceed with the various example implementations of COM objects, which demonstrate all basic aspects of COM programming. Knowledge of the Windows APIs (e.g. OLE) is assumed.
Further Reading
We recommend the following books on COM, OLE and ActiveX:
Kraig Brockschmidt,
Inside OLE,
2nd Edition, Microsoft Press, 1995.
David Chappell,
Understanding ActiveX and OLE,
Microsoft Press, 1996, ISBN 1-57231-216-5.
Adam Denning,
OLE Controls Inside Out,
Microsoft Press, 1995.
Dale Rogerson,
Inside COM,
Microsoft Press, 1997, ISBN 1-57231-349-8,
Don Box,
Creating Components with DCOM and C++,
Addison Wesley, 1997.
Microsoft
COM Home Page,
http://www.microsoft.com/com
Changes since Release 1.2
The upgrade of BlackBox 1.2 to BlackBox 1.3 also made the upgrade of the Direct-To-COM compiler necessary. However, the new language Component Pascal now supports many extensions which have been introduced in the language DTC Oberon which was used with DTC Release 1.2. In particular, the following features now belong to Component Pascal and are no longer special to DTC:
[in] sysflag for VAR parameters
instead of the [in] sysflag, which specified read-only VAR parameters, the IN parameter mode can now be used. IN parameters can neither be written nor passed as actual parameter to a formal VAR parameter. An IN parameter can only be read, or passed as actual parameter to another IN parameter. As with the [in] parameters in DTC Release 1.2, constants strings can be passed as actual parameters of a Component Pascal IN parameters.
[out] sysflag for VAR parameters
instead of the [out] sysflag, the Component Pascal OUT parameter mode can be used to mark out parameters. Actual pointer parameters to formal OUT parameters are initialized to NIL upon function call. If a COM interface method is called remotely, the actual parameters of OUT parameters are not passed upon procedure entry and their values on the server side are not defined.
LONGCHAR
Component Pascal now supports 16 bit characters (CHAR), which replaces type LONGCHAR of DTC Release 1.2. The predefined procedure LCHR is now called CHR.
LARGEINT
Component Pascal now supports 64 bit integers (LONGINT) which is equivalent to the type LARGEINT of DTC Release 1.2. The predefined procedure LENTIER is now called ENTIER.
FINALIZE Method
The FINALIZE method for (tagged) records is now part of Component Pascal. This method is called before the object is collected by the garbage collector. The RELEASE method is still unique to COM objects.
TERMINATE
Support for module finalization is now provided by Component Pascal. Whenever a module is unloaded, the CLOSE section of the module body is executed.
Compiler Implementation Restrictions
some of the compiler restrictions have been removed in the new release. In particular, it is now possible to specify a function call as actual value for a formal parameter of type "pointer to interface", and function calls with interface pointer results may now be used as arguments for pointer comparison operations.
| Docu/DTC-Intro.odc |
Map to the BlackBox Component Builder Documentation
Quick Start GuidedTour Roadmap OverviewbyExample
Component Software: A Case Study Using BlackBox Components Introduction
Part I 1UserInteraction 2CompoundDocuments 3DesignPractices
Part II 4Forms 5Texts
Part III 6ViewConstruction
Appendices A:BriefHistoryofPascal B:PascaltoComp.Pascal
User Manuals Developer Manuals Component Pascal Miscellaneous
Framework Framework LanguageReport License
TextSubsystem TextSubsystem What'sNew? LicensingPolicy
FormSubsystem FormSubsystem CharacterSet Contributors
DevSubsystem DevSubsystem DocumentationConventions Platform-SpecificIssues
CustomCommands SqlSubsystem ProgrammingConventions
| Docu/Help.odc |
BlackBox Contributors of Oberon microsystems, Inc.
BlackBox is based on the foundation laid at ETH Zьrich by the professors Niklaus Wirth and Jьrg Gutknecht (Oberon language and system), Hanspeter Mцssenbцck (Oberon-2 extensions) and several former research assistants, e.g., Rйgis Crelier, Josef Templ and Stefan Ludwig. At Oberon microsystems, the following (current or former) employees have contributed to BlackBox:
- Beat Heeb
- Cuno Pfister
- Clemens Szyperski
- Thomas Amberg
- Daniel Diez
- Christian Di Giorgio
- Marc Frei
- Dominik Gruntz
- Matthias Hausner
- Stephan Koch
- Ivan Posva
- Bengt Rutisson
- Wolfgang Weck
- Jьrg Wullschleger
| Docu/Ominc-Contributors.odc |
Part I: Design Patterns
Part I of the BlackBox tutorial gives an introduction to the design patterns that are used throughout BlackBox. To know these patterns makes it easier to understand and remember the more detailed design decisions in the various BlackBox modules.
Part II of the BlackBox tutorial demonstrates how the most important library components can be used: control, form, and text components.
Part III of the BlackBox tutorial demonstrates how new views can be developed, by giving a series of examples that gradually become more sophisticated.
1 User Interaction
In this section, we will discuss how a user interface can be made user-friendly. Graphical user interfaces are part of the answer. Unfortunately, this answer leads to another problem: how can such a user interface be implemented at reasonable cost? The design approach which solves this problem is surprisingly fundamental, and has deep consequences on the way we construct modern software. It is called object-oriented programming.
1.1 User-friendliness
There are at least 100 million personal computers in use today. With so many users who are not computer specialists, it is important that computers be easy to use. This implies that operating systems and applications must be user-friendly. What does this mean? There are several aspects.
First, the various applications should be consistent with one another: a function that is available in several programs should have the same user interface in all of them, so that the user does not have to learn different ways to do one and the same thing. One way to achieve this is to publish user interface guidelines that all software developers should adhere to. This approach was championed by Apple when they introduced the Macintosh. A second approach is to implement a function only once, so that it can be reused across different applications. This is the idea of component software. Apple didn't go that far, but they at least provided a number of so-called "toolbox" routines. The toolbox is a comprehensive library built into the Mac OS.
Second, the idea of the desktop metaphor, where icons graphically represent files, directories, programs, and other items, made it possible to replace arcane commands that have to be remembered and typed in by more intuitive direct manipulation: for example, an icon can be dragged with the mouse and dropped into a waste basket, instead of typing in "erase myfile" or something similar. Such a rich user interface requires a vast set of services. Not surprisingly, the Mac OS toolbox included services for windows, menus, mouse, dialog boxes, graphics, and so on. The toolbox made it possible to build applications that really adhered to the user interface guidelines. Unfortunately, programming for such an environment implied a tremendous leap in complexity. As a result, the Macintosh was much easier to use than earlier computers, but it was also much more difficult to program.
Today, the browser metaphor is an increasingly popular addition to traditional graphical user interfaces. Combined with Internet access, it opens a huge universe of documents to a computer user ђ and makes the job of a developer even more complicated.
Finally, one of the most general and most important aspects of user-friendliness is the avoidance of modes. A modal user interface separates user interactions into different classes, and gives a separate environment to each class. Switching between environments is cumbersome. For example, in a database application, a user may open a window (or "screen", "mask") for data entry. In this window, no records may be deleted, no records may be searched, no notes taken, no email read, etc. For each of these other tasks, the data entry environment would have to be left first. This is cumbersome, and reminds us of the application- rather than the document-centric way of computing discussed in the first part of this book. In complex applications, it is often difficult to remember where you currently are, what commands are available, and where you may go next. Figure 1-1 shows an example of the states and possible state transitions of a hypothetical modal application.
Figure 1-1. Navigation possibilities in a modal user interface
Non-modal user interfaces have no separate working environments, or at least let you switch between environments without losing the state of others. For example, if during data entry you want to look up something with a library browser or text searching tool, you don't lose the partial data that you have already entered. If there are separate working environments, navigation is made simple and obvious by giving explicit feedback about the environment and its capabilities.
A modern graphical user interface is a prime example of a mostly non-modal user interface. There may be several windows (environments) open at the same time, but it is clearly visible with which window you are currently interacting (usually the "top" window). You can work in one window, temporarily work in another one (thereby bringing it to the top), and later switch back to resume your work in the first window.
These user interfaces are a huge improvement over old-style modal interfaces. Users feel more comfortable because they have a better idea of where they are and what they can do. However, even modern GUIs are far from perfect. Most of them still use modal dialog boxes, i.e., windows that you can't put aside to work with another one for a while. For example, a typical modal file dialog box lets you open a file, but doesn't allow you to quickly switch to a file searching tool and back again. The dialog box "modes you in". Even the fact that you have to bring a window to the top before manipulating it constitutes an inconvenient and unnecessary mode, at least if you have a screen large enough that you can lay out all needed windows in a non-overlapping fashion. And many database products don't allow you to have several data entry or data manipulation forms open at the same time. A Web browser is the closest thing to a truly non-modal user interface today: if you have entered some incomplete data into an HTML form, and then switch to another Web page, the browser won't prevent you from doing it.
The BlackBox Component Builder is more radical than other tools in that it simply doesn't support modal dialog boxes. Every dialog box is non-modal, except for a very few built-in operating system dialog boxes such as the standard file dialog boxes. In general, you can always put dialog boxes aside and get back to them later.
1.2 Event loops
Implementing a non-modal application looks deceptively simple: the program waits for a user event, such as a mouse click or a key press; reacts in an appropriate way; waits for the next event; and so on. This programming style, with a central loop that polls the operating system for events and then calls the appropriate handlers for them, is called event-driven programming.
Figure 1-2. Event loop of a non-modal program
The event-polling loop of a typical event-driven program looks similar to the following program fragment:
PROCEDURE Main;
VAR event: OS.Event;
BEGIN
LOOP
event := OS.NextEvent(); (* poll the operating system for the next event *)
IF event IS KeyDownEvent THEN
HandleKeyDown(event)
ELSIF event IS MouseDownEvent THEN
IF MouseInMenu(event) THEN
HandleMenuEvent(event)
ELSIF MouseInWindowTitle(event) THEN
HandleTitleEvent(event)
ELSIF MouseInWindowBorder(event) THEN
HandleBorderEvent(event)
ELSIF MouseInWindowContents(event) THEN
HandleContentsEvent(event)
ELSIF...
...
END
ELSIF ...
...
END
END Main;
Listing 1-3. Event loop with cascaded selection of event handlers
In realistic programs, these cascaded IF-statements can easily span several pages of code, and are always similar. Thus it suggests itself to put this code into a library (or even better, into the operating system).
Such a library would implement the standard user interface guidelines. For example, the HandleTitleEvent would further distinguish where in the window's title bar the mouse has been clicked. Depending on the exact location, the window will be dragged to another place, zoomed, closed, etc. This is a generic behavior that can, and for consistency reasons should, only be implemented once. A procedure like HandleContentsEvent is different, though. A standard library cannot know what should happen when the user has clicked into the interior (contents) area of a window.
If we require that the library itself must never need adaptation to a particular application, then there results a peculiar kind of system structure, where a library sometimes calls the application. Such a call is called a "call-back". When we visualize an application as sitting on top of the library, it becomes obvious why such calls are also called "up-calls" and the resulting programming style as "inverted programming":
Figure 1-4. Inverted programming design pattern
A library which strongly relies on inverted programming is called a framework. It is a semi-finished product that must be customized by plugging in procedures at run-time. For some of the procedures, this can be optional: for procedure HandleTitleEvent there can be a default implementation that implements the standard user interface guidlines. Such procedures will only be replaced if unconventional behavior is desired.
Experience shows that a procedure plugged into a framework frequently refers to the same data. For example, the procedure HandleTitleEvent will often access the window in which the user has clicked. This makes it convenient to bundle the procedure and its state into a capsule. Such a capsule is called an object, and it lifts inverted programming to object-oriented programming.
Thinking about user-friendly software led us to the problem of how to reduce the amount of repetitive and complex coding of event loops, which led us straight to the inverted programming design style; to frameworks as a way of casting such a design style into code; and to object-oriented programming as a means to implement frameworks in a convenient way.
The BlackBox Component Framework hides the event loop from application programmers. It goes even further than older frameworks in that it also hides platform-specific user-interface features such as windows and menus. This was achieved by focusing on the abstraction that represents the contents of a window: the so-called View type. We will come back to this topic in Chapter 2 in more detail.
1.3 Access by multiple users
Personal computers have made computer users independent from central IT (information technology) departments, their bureaucracies, and their overloaded time-sharing servers. This independence is a good thing, if it can be combined with integration where this is useful and cost-effective. Local area networks, wide area networks, and then the Internet have made integration possible. When two computers cooperate over a network, one of them asks the other to provide a service, for example to deliver a file over the network. The computer which issues the request is called the client, the other one is called the server. The same machine may act both as a client and as a server, but often these roles are assigned in a fixed manner: the clerk at the counter of a bank's branch office always uses a client machine, and the large box in the air-conditioned vault of the bank's headquarters is always used as a server. A bank's internal network may connect thousands of clients to dozens of servers. But even the smallest network obviously requires that applications are split into two parts: a client and a server part. Consequently, this kind of architecture is called client/server computing. It allows to assign processing tasks to the machines which are most suitable. In enterprise environments, the most popular assignment is to put a centralized database on a database server, and the remaining functionality on the client machines. This is called a 2-tier architecture. It requires fat clients, i.e., client machines have to perform everything but the actual database accesses. To reduce this burden, high-end database management systems allow to execute some code on the server itself, as an interpreted stored procedure. This can greatly increase performance, because it can prevent large amounts of data being shuffled back and forth over the network.
If large numbers of clients are involved, it can become hard to keep all client installations up-to-date and consistent. This problem can be reduced using a 3-tier architecture, where special application servers are interposed between clients and servers. The "thin" clients are reduced to implementing user interfaces, the database servers handle the databases, while the application servers contain all application-specific knowledge ("business logic").
Figure 1-5. 3-tier client/server architecture pattern
A 3-tier architecture is reasonably manageable and scalable in terms of size. Note that a software system separated in this way can be scaled down, in the extreme case by putting the client, application server, and database server on a single machine. The other way around does not work: a monolithic application cannot be easily partitioned to fit a client/server architecture.
Clients and servers are coupled over a network. Communication either operates at the low abstraction level of untyped byte streams (e.g., using a sockets interface for TCP/IP communication) or at the high abstraction level of typed data. In the latter case, either distributed objects (for immediate point-to-point communication) or message objects (for multicast or delayed communication) are used.
The Comm subsystem of the BlackBox Component Framework provides a simple byte stream communication abstraction, on top of which messaging services can be built. Among other things, this has been used to implement remote controls, i.e., controls which visualize and manipulate data on a remote machine. For example, the internal state of an embedded system can be monitored in this way.
The Sql subsystem of the BlackBox Component Framework provides a simple distributed object interface specialized for accessing SQL databases. More general DCOM-based [COM] distributed objects can be accessed and implemented with the optional Direct-To-COM Component Pascal compiler.
1.4 Language-specific parameters
The global nature of today's software business often makes it necessary to produce "localized" versions of a software package. At the least, this requires translation of all string constants in the program that the user may see. For example, in a country like Switzerland, where four official languages are spoken, it is often required that the same application is available in German, French, and Italian language versions. This can even mean that the layouts of dialog boxes need to be adapted to the different languages, since the captions and control labels have different lengths in different languages.
If such language-specific aspects are hard-coded into the program sources, language-specific versions require editing and compiling the source code. This is always a sensitive point, since errors and inconsistencies can easily be introduced. It is also very inconvenient: hard-coded layouts of dialog boxes are very unintuitive to modify, and the edit-compile-run cycle is cumbersome if you only want to move or resize a control.
Many tools have been developed which provide more convenient special-purpose editors, in particular layout editors for dialog boxes. One type of tool produces source code out of the interactively produced layout, which then has to be compiled. Since a programmer have to edit the generated source code, it is easy to introduce inconsistencies between the layout and the source code.
Fortunately, there is a much better way to solve this problem, by avoiding the intermediate source-code generator and directly use the editor's output in the program. The editor saves the dialog box layout in a file, a so-called resource file. The program then reads these resources when it needs them, e.g., when it opens a dialog box. Resources can be regarded as persistent objects which are only modified if the configuration is changed.
We have seen that the problem of convenient adaptation of a program to different languages can be solved by separating language- or location-specific parameters from the source code. They are put into resource files, which can be modified by convenient special-purpose editors.
Moving user-interface aspects away from the proper application logic is a way to make client software more modular and better adaptable. If taken to the extreme, resources almost become the client software: a Web browser on a client is all that is needed to present a user interface; the resources (HTML texts) are downloaded from a server whenever needed. (However, this approach with "ultra-thin" clients becomes less credible the fatter the Web browsers themselves become.)
The BlackBox Component Framework uses its standard document format to store resources. For example, a dialog box and its controls are simply parts of a compound document stored in a file. The same view is used for layouting and for actually using a dialog box ђ no separate layout editor progam is needed. Resources can be available in several language versions simultaneously, and languages can even be switched at run-time. This is useful for customs applications or other programs used in regions where several languages are spoken.
| Docu/Tut-1.odc |
2 Compound Documents
In the previous sections, we have discussed a variety of problems that occur with interactive systems, and we have seen various architecture and design approaches that help to solve them.
In the following sections we focus specifically on the programming problems posed by compound documents, and the design patterns that help to solve them.
2.1 Persistence
We call the object that is contained in a window a view. A view displays itself in the window, and it may interpret user input in this area, such as mouse clicks. In the most general case, a view can be opened and saved as a document. Other views may be created at run-time or are loaded from resource files. The contents of a "Find & Replace" dialog box is an example of the latter case.
In general, a view is a persistent object. This presumes a mechanism for the externalization (saving) and the internalization (opening) of a view. Using object-oriented programming, we can model a view as a specialization of a generic persistent object, which we call a store. A store can externalize and internalize its persistent state. A view is a specialized store, i.e., a subtype. In addition to externalizing and internalizing themselves, views can display themselves and can handle user input. These generic views can be further specialized, for example to text views, picture views, and so on (see Figure 2-1).
Figure 2-1. Subtype relations between views and stores
In the BlackBox Component Framework, stores are represented as type Store in module Stores; views are represented as type View in module Views; and there are various specific views such as type View in module TextViews or type View in module FormViews or type Control in module Controls (see Figure 2-2). This is only a small selection, actually there are many more view types. The store mechanism's file format is platform-independent, i.e., differences in byte ordering are compensated for.
Figure 2-2. Subtype relations between views and stores in BlackBox
Often, copying of a store is equivalent to writing it to a temporary file, and then reading it in again (externalize old object to file, then allocate and internalize new object from file). This makes it convenient to combine persistence and copying support in the same store abstraction. However, BlackBox stores are able to change their identities or to "dissolve" upon externalization to a file, in which case copying is not equivalent to externalize/internalize anymore. For example, error marker views which indicate syntax errors remove themselves upon externalization ђ yet a visible error marker can be copied with drag & drop like any other view. To allow for such flexibility, BlackBox doesn't automatically treat copying as an externalize/internalize pair. Stores have explicit Externalize, Internalize and CopyFrom methods. Upon externalization, a store gets the opportunity to substitute another store for itself, possibly NIL. This is the mechanism which allows to change its identity to another one, a so-called proxy.
2.2 Display independence
The computing world is heterogeneous, with different hardware and operating system platforms on the market. The Internet, with its millions of platforms of all flavors, has finally made it clear how important platform-independence of code and data is. This is not easy to achieve, because software and hardware can vary widely between platforms. Display devices, such as monitors and printers, are a good example. Their spatial and color resolutions can differ enormously.
To achieve platform-independent code, views and their persistent state must not refer to specific devices. Instead, the document space and the display space must be clearly separated and a suitable mapping between the two must be provided by a framework. For example, in the document space, distances are measured in well-defined units such as inches or millimeters, while in the display space, distances are measured in pixels, whatever their actual sizes may be.
To model the separation between display and document space, where the document space is populated by persistent views, we need an abstraction of a display device. We call such an object a frame. A frame is a rectangular drawing surface which provides a set of drawing operations. When it is made visible, a view obtains a frame, and via this frame it can draw on the screen (or printer). The frame performs the mapping between the document space units and the pixels of the display device, so that views never need to deal with pixel sizes directly.
Figure 2-3. Separation of display and document space
In the BlackBox Component Framework, document space units are measured in 1/36000 millimeters. This value is chosen such that it minimizes rounding errors for typical display resolutions. A BlackBox frame provides a local coordinate system for its view. For the time being, you can regard a frame as a window and a view as a document. A view which isn't displayed has no frame. Frames are light-weight objects that come and go as needed. They are created and destroyed by the framework, and need not be implemented or extended by the view programmer.
The only case where it is necessary to extend frames is when platform-specific controls or OLE objects need to be wrapped as BlackBox views. Since writing such wrappers is a messy business, the framework provides standard OLE wrappers (Windows version) and wrappers for the important (pre-OLE) standard controls.
2.3 Multi-view editing
Simple views work fine if they are small enough to fit on a screen. However, texts, tables, or graphics can easily become larger than a screen or printed page. In this case, a frame (which lies strictly within the boundaries of its display device) can only display part of the view. To see the other parts, the user must scroll the view, i.e., change the way in which it translates its data to its local coordinate system. For example, a text view's first line (its origin) may be changed from the topmost line to another one further below, thus displaying a text part further below (see Figure 2-4).
Figure 2-4. Scrolling a text view
The need for scrolling can become very inconvenient when working with two parts of a view that are far apart, because it means that the user often must scroll back and forth. This problem can be solved by multi-view editing: the same data is presented in more than one view. The views may differ in their origins only, or they may differ more thoroughly. For example, one view may present a list of number values as a table of numbers, while another view may present the same data as a pie chart (see Figure 2-5).
Figure 2-5. Different kinds of views presenting the same data
An object which represents data that may be presented by several views is called a model. The separation into view and model go back to the Smalltalk project at Xerox PARC. In the patterns terminology, the view is an observer of the model.
In the BlackBox Component Framework, the model/view separation is optional. Small fixed-size views that easily fit in a window usually don't need separate models, while larger or more refined views do. This can result in a situation like the following one, where a view has a separate model, and both together form the document which is displayed in a window:
Figure 2-6. Separation of models and views in BlackBox
The user can open a second window, which displays its own view, but for the same model. This results in the following situation:
Figure 2-7: Multiple views for the same model
Only one of the two views is externalized when the document is saved in a file. To avoid schizophreny, one window is clearly distinguished as the main window, while all others are so-called subwindows. If you close a subwindow, only this window is closed. But if you close the main window, it and all its subwindows are closed simultaneously.
2.4 Change propagation
Multi-view editing creates a consistency problem. Editing a view means that the view causes its model to change. As a result, all views presenting this model must be updated if necessary, not only the view in which the user currently works. For example, if the user changes a value in the table view of Figure 2-5, then the pie chart in the other view must be updated accordingly, because their common model has changed.
Such a change propagation is easy to implement. After the model has performed an operation on the data that it represents, it notifies all views which present it, by sending them an update message describing the operation that has been performed.
Notification could be easily done by iterating over a linear list of views anchored in the model. Such a functionality can be provided once and for all, by properly encapsulating it in a class. This change propagation class provides an interface consisting of two parts. The first part allows to register new views that want to listen to update messages ("subscribe"). The second part allows to send update messages ("publish"):
Figure 2-8. Change propagation mechanism
This mechanism has an important advantage: it decouples model and views such that the model itself need not be aware of its views, and the list of views can be encapsulated in the change propagation mechanism. Such a reduced coupling between model and views is desirable because it reduces complexity. It makes the model unaware, and thus independent, of its views. This is important in an extensible system, because it allows to add new view types without modifying the model. This would not be possible if the model had to know too much about its views.
Sometimes the mechanism described above does too much. It sends update messages to all views, independent of whether they need updating or not. For example, when a word was deleted in a text model, then some text view may display a part of the text which is not affected by the deletion at all. This view need not do anything. Of course, all the views that do display the affected text stretch must be updated accordingly.
For this reason, the BlackBox Component Framework sends update messages only to those views which have frames. Since every frame knows its view, the change propagation mechanism actually registers the frames, not the views. Even better, the framework already has a list of frames for window management, so it can reuse this list. Thus, instead of having one change propagation object per model, BlackBox uses one global change propagation service integrated into the window manager. Messages are represented as static message records. This is an unconventional but robust, efficient, and light-weight implementation of the observer pattern.
2.5 Nested views
So far, we have assumed that a view (possibly with a model) is a document, and a frame is a window. Actually, things are a bit more difficult. The reason is that views may be nested. Some views are able to contain ("embed") other views; for this reason they are called container views. Some containers are very general, and allow to embed arbitrary numbers and types of other views. For example, a text view may embed table views, bitmap views, and so on. It may even embed another text view, meaning that arbitrarily deep nesting hierarchies can be created.
How does this affect what we have said so far? Obviously, we need to generalize our notion of views and frames. A view can contain other views, which can contain still other views, etc.; i.e., views become hierarchical. In principle, those hierarchies need not even be trees, they can be arbitrary directed acyclic graphs (DAGs). This means that several views in a document may refer to the same model, but no references may go "upwards" in the document hierarchy, because this would lead to an endless recursion when drawing the document, like a TV which displays itself.
The frames represent a subset of the view hierarchy. Since a frame is always completely contained within its parent frame, the frame hierarchy is strictly a tree.
A document can now be regarded as the root of a view DAG, and a window can be regarded as the root of a frame tree.
Figure 2-9. Nested views and frames
This is a straight-forward generalization which doesn't add unexpected complexity. It is a simplified implementation of the composite design pattern. It was simplified because the type safety of Component Pascal makes it unnecessary to burden the abstract view type with container-specific operations that are meaningless for non-containers.
Unfortunately, more complexity comes in when we consider the combination of nested views and multi-view editing. First of all, multi-view editing means the separation of views and models. An embedded view belongs to the model, since it is part of the data that the container view presents. For example, a user who edits a text view may delete embedded views just like she may delete embedded characters. Figure 2-10 illustrates the situation of two container views with a container model in which some other view is embedded:
Figure 2-10. Container views with model, context, and embedded view
Note the interesting link between a model and an embedded view: the context object. It describes the location and possibly other attributes of one embedded view. The context's type is defined by the container. A context is created by the container when the view is being embedded. The embedded view can ask its context about its own location in the container, and may even obtain further information. For example, text container contexts may provide information about the embedded view's position in the text (character index), about its current font and color, and so on.
An embedded view may use its context object not only for getting information about its container, it may also cause the container to perform some action. For example, the embedded view may ask the container, via the context object, to make it smaller or larger. Containers are free to fulfill such requests, or to ignore them. In negotiations between a container and one of its embedded views, the container always wins. For example, a container doesn't allow an embedded view to become wider than the container itself.
A context object can be regarded as a call-back interface which the container installs in the embedded view as a plug-in, so the view can call back the container and obtain services from it. A context is part of a notification mechanism that allows the container to observe messages from the contained views.
In subsequent figures, context objects are not drawn expliclity in order to make the figures easier to understand. Just remember that every view carries a context that it can use when necessary.
Now that nested views and the separation of model and view are supported, it becomes possible to allow subwindows on embedded views, not only on root views. This can be quite helpful, if a small view must be edited. Just open a subwindow for it, enlarge the window, and editing becomes much easier.
Figure 2-11. Subwindow on embedded view
Compound documents introduce a further complication. For root views, scrolling state is not retained when the document is saved to disk. At least most users seem to prefer that the scrolling state of a view not be persistent. This is different for embedded views, though. Setting the origin of an embedded view is not so much for convenience (subwindows are better for that) as for publishing: the user chooses which part of the view should be visible in the container.
The same holds for an undo/redo mechanism: scrolling in a root view is not a true document editing manipulation, and thus undo/redo would add inconvenience rather than usefulness. However, the scrolling of an embedded view must be treated as a genuine editing operation, and thus should be undoable/redoable.
In summary, this means that the implementor of a view must treat non-persistent view state differently, depending whether the view is a root view or an embedded view.
Combining nested views with multi-view editing also destroys the one-to-one relationship between frames and views. As we will see shortly, this is the most far-reaching additional burden that a view implementor must handle.
To see why a view may be displayed in several frames, consider the situation in Figure 2-12:
Figure 2-12. Several frames displaying the same view
Such a situation cannot occur without nested views, because the outermost view is always copied (to allow independent scrolling, or other view-specific operations). But whenever a view is embedded in a container displayed in two different windows, then this view is displayed in two different frames. This makes the management of links between frames and views more complicated; but more importantly, it makes change propagation and screen updates more complicated.
Why? Let us assume that there are n frames which display the same view. Now the view's model is changed, and this change is propagated to all views which display the model. Since there is only one view for the model, the change propagation mechanism as we have discussed earlier will send the view an update message exactly once. However, there are n places on the screen which need updating. As a result, the view must perform n updates, by iterating over all frames that display it.
For a view, correctly maintaining the list of frames in which it is displayed is a complicated endeavour. Therefore, the BlackBox Component Framework relieves the view implementor of this error-prone task. A BlackBox view doesn't contain a frame list. Instead, the framework maintains the frame trees automatically. This was the reason that in the above figures, the arrows from frames to views only pointed in one direction, because in BlackBox the view doesn't know its frame(s). The correct frames are passed to a view whenever the framework asks the view to do something that may involve drawing. (This approach is related to the flyweight pattern.)
When the view receives an update message and decides that it needs to update its frame(s), it simply asks the framework to send another update message to all its frames. Each of these frames will then ask the view to update the frame where this is necessary. This mechanism will be discussed in more detail in the chapters on view construction.
Since there is no more one-to-one relationship between views and frames anymore, it is helpful to summarize the differences between frames and view:
aspect frame view
lives in display space document space
persistent no yes
extended by view implementor usually not yes
may contain device-specific data yes no
hierarchy tree DAG
associated with one view 0..n frames
update caused by its view its model (if any)
completely enclosed by container yes not necessarily
Table 2-13. Differences between frames and views
2.6 Delayed updates
In the previous section we have seen how updates are performed in two steps: a model notifies its views of a change, and the views notify their frames of the region which needs updating.
Now consider a complex model change. For example, a selection of graphical objects, which are part of a graphics model, are moved by some distance. It would be possible to perform an update in three phases: in the first phase, the selected objects would be removed (requiring an update); then the selected objects would be moved; and finally, the selected objects would be inserted again at their destination (requiring another update).
This approach is not very efficient, since it requires two notifications and partial updates. Furthermore, it needs careful sequencing of the actions, since some of them need the model's state prior to movement, and others need the model's state after movement.
There is a much simpler and more efficient approach. The idea is to delay the second phase of the updates, i.e., the phase where the frames for a view are redrawn. Instead of updating the frames immediately, the view only remembers the geometrical region which needs updating. In the above example, it could add the areas of the graphical objects prior to movement and their areas after movement (see Figure 2-14).
Figure 2-14. Update region of a selection which was moved
The accumulated update region is then updated in one single step after the translation of the graphical objects has been performed. In the figure above, the update region is the total hatched area, consisting of the area occupied by the selection before the movement and the area occupied by it after the movement.
The framework must support this approach by providing some mechanism to add up geometrical regions, and to redraw a frame in exactly this region ("clipping" away all unnecessary drawing, to increase performance and to minimize flicker).
This delayed or lazy updating approach is used by the BlackBox Component Framework and all major windowing systems that exist today. Its only drawback is that for long-running commands, it may be necessary to force intermediate updates in order to inform the user of the command's progress. For this reason, forced updates are also supported by the BlackBox framework.
2.7 Container modes
To create graphical user interfaces, it is convenient to create form layouts interactively, rather than burning in the coordinates of controls in the source code of a program. A visual designer, i.e., a special-purpose graphics editor can be used for interactive manipulation of form layouts. This suggests two different modes in which a form, and its controls, can be used: design-time and run-time. When a form layout is edited in a visual designer, it is design-time: the form is designed, but not yet used. The completed form can be saved and later opened for use by the end user. This is called run-time.
There are two different approaches to handling layouts at run-time: either the framework allows to open the data that has been saved by the visual designer, or it runs code that has been generated out of this saved data. The first approach requires an interpreter for the visual designer's data, the second approach requires a generator between the visual designer and actual use of a form. Typically, the generator generates source code, which is possibly completed by the programmer, and then compiled into machine code using a standard programming language compiler.
Today, the latter approach should be considered obsolete, although it is still used by many tools: it is merely an inconvenient detour. Moreover, when it forces programmers to edit the generated source code, it makes iterative changes to a layout problematic: the source code has to be regenerated without losing the changes that have been made by the programmer. This is a needless source of inconsistencies, complexity, and it slows down development.
The former approach is much simpler. The visual designer's output data is treated as a resource that can be utilized as is at run-time. This requires an interpreter for the visual designer's file format.
The most elegant approach is to use the same editor (i.e., view implementation) and thus the same file format both for design-time and run-time. As file format, the standard format of a compound document can be reused. This means that a form layout at design-time is a completely ordinary compound document. At run-time, it is still the same document, albeit its interaction with the user is different.
At design-time, a control is a passive box which can be moved around, copied or deleted, but which has no interactive behavior of its own. At run-time, a control may be focused and the control's contents may be edited. For example, the string contained in a text field control may be edited, or a button may be pressed and released again.
The direct use of compound documents as user interfaces is called compound user interfaces. Note that this generalization of compound documents renders the term "document" rather misleading, because an application may contain many forms (and thus compound user interface documents) even if it does not manipulate any documents in the traditional sense (i.e., as seen by an end-user).
The BlackBox Component Framework utilizes its support for multi-view editing to go one step further. Since a document can be opened in several views simultaneosly, it is possible to open a form layout in two windows. BlackBox allows to use form views in different modes: layout and mask mode. These modes correspond to design-time and run-time, with one major improvement: they can be used simultaneously. For example, one window may display a form in layout mode, and another window may display it in mask mode (see Figure 2-15). When the developer edits the layout in the layout mode window, any layout change is immediately reflected in the mask mode window. Vice versa, user input in the mask mode window immediately becomes visible in the layout window. This is a result of the standard change propagation mechanism of BlackBox.
Figure 2-15. Data entry form in a layout-mode view (behind) and in a mask-mode view (front)
In fact, BlackBox is even more general. In addition to layout and mask mode, it supports a few further modes. The edit mode allows to modify the layout and the contents of controls simultaneously, and a browser mode makes the form read-only except for allowing to select and copy out parts of the document.
These general modes are not only available for graphical forms. They are a capability shared by all general container views, including text views. This means that it is possible (and sometimes more convenient for the developer) to use a text view instead of a form view when assembling a dialog box. The user won't notice the difference. To simplify the construction of such powerful containers, the framework provides a comprehensive container abstraction, with an abstract container model class, an abstract container view class, and an abstract container controller class. A controller can be regarded as a split-off part of a view. It performs all user interaction, including handling of keyboard input and mouse manipulations, and it also manages selections. There is a 1:1 relation between view and controller at run-time. Separating part of a view into a controller object improves extensibility (different controllers could be implemented for the same view, and the same controller works with all concrete view implementations) and it also allows to reduce complexity: the controller of a complex view, such as a container view, can become large, which makes the separation of concerns into different types (and typically into different modules) a good idea. In terms of design patterns, a controller is a strategy object.
The container abstractions of BlackBox have been designed to abstract from specific container user interfaces. This means that details of the container look-and-feel (such as the hatched focus marks of an OLE object) are hidden from the developer. In turn, this makes it possible to implement containers in different ways for different platforms, without affecting the developer of containers. In particular, the OLE and Apple OpenDoc container look-and-feel have been implemented. While OpenDoc isn't relevant anymore, some of the human interface guidelines developed for it are still useful today.
2.8 Event handling
When a user interacts with a compound document, this interaction always occurs in one view at a time. This view is called the current focus. By clicking around, the user can change the current focus. Among other events, the focus handles keyboard events, i.e., a keypress is interpreted by the focused view. The focus view and its containing views are called the focus path, with the innermost view being the focus.
It is possible to let a user interface framework manage the current focus. This requires a central manager for the focus. A more light-weight approach is to make focus management a decentral activity: leave focus management to the individual container views, which have to deal with focus changes and focus rendering anyway. Every container simply remembers which of its embedded views is the current focus, if any. The container is oblivious whether this view is on the current focus path or not.
In BlackBox, user events are sent along the focus path as message records, starting at the outermost view. Messages records are static (stack-allocated) variables of some subtype of Controllers.Message. There are controller messages for keyboard input, mouse tracking, drag & drop, and so on. A controller message is forwarded along the focus path until one of the views either interprets it or discards it. This view by definition is the focus.
In terms of design patterns, the focus path is a chain of responsibility.
What happens when the focus view receives and interprets a controller message? The view (or its model, if it has one) performs some operation on its own state. If this operation affects persistent state of the view or model, it should be reversible ("undoable"). How is an undo/redo mechanism implemented?
The main idea is that upon receipt of a controller message, the view / model doesn't perform a state modification directly. Instead, it creates a special operation object and registers it in the framework. The framework then can call the operation's appropriate procedure for performing the actual do/undo/redo functionality.
Operations are managed per document. Every document contains two operation stacks; one is the undo stack, the other is the redo stack. Executing an operation for the first time pushes the object on the undo stack and clears the redo stack. When the user performs an undo, the operation on top of the undo stack is undone, removed from the undo stack, and pushed onto the redo stack. When the user performs a redo, the operation on top of the redo stack is redone, removed from the redo stack, and pushed onto the undo stack.
A document's undo and redo stacks are cleared when the document is saved (check point). Furthermore, they may be cleared or made shallower when the framework runs out of memory. For this purpose, the garbage collector informs the framework about low-memory conditions, so old operation objects can be thrown away.
Some operations, such as a moving drag & drop (in contrast to the normal copying drag & drop), modify two documents simultaneously. In these rare cases, two operations are created: one for the source document (e.g., a delete operation) and one for the destination document (e.g., an insert operation).
Figure 2-16. Sequence of operations and resulting modifications of undo and redo stacks.
In Figure 2-16, a sequence of operations is shown, from 1) to 8). For the last five situations, the resulting undo and redo stacks are shown. For example, after operation 5), the undo stack contains the operations Inserting, Set Properties, and Inserting (from top to bottom of stack), while the redo stack contains Deleting.
The undo/redo mechanism is only concerned with the persistent state of a document. This is the state which can be saved in a file. Modifications of temporary state, such as a view's scroll position, are not recorded as operations, and thus cannot be undone (at least for root views).
Undoable operations either modify the persistent state of a view, or of its model (controller state is mostly temporary). The framework knows to which document a persistent object belongs, because all persistent objects of a document share the same domain. Domains will be discussed in Part III where the store mechanism is discussed in more detail.
The BlackBox Component Framework is unique in that its undo/redo mechanism is component-oriented: it allows to compose undoable operations into compound operations, which are undoable as a whole. Without this capability, nested operations would be recorded as a flat sequence of atomic operations.
Consider what this would mean for the end user. It would mean that the user could execute a menu command, which causes the execution of a hierarchy of operations. So far so good. But when the user wanted to undo this command, he or she would have to execute Edit->Undo individually for every single operation of the command, instead of only once.
For this reason, BlackBox provides support for arbitrarily nested operations: modules Models and Views both export a pair of BeginScript / EndScript procedures. In this context, "script" means a sequence or hierarchy of atomic operations which is undoable as a whole. Model and view operations can be freely mixed in a script.
Abstract operations are very light-weight. They only provide one single parameterless procedure, called Do. This procedure must be implemented in a reversible way, so that if it is executed an even number of times, it has no effect. If it is executed an odd number of times, it has the same effect as when it is executed once.
In the design patterns terminology, an operation is called a command.
2.9 Controls
Controls are light-weight views that only provide very specific functionality, which only makes sense in concert with other controls and a container. Typical controls are command buttons and text entry fields. They are used in dialog boxes or date entry forms. The parameters or other data being represented by a control must somehow be manipulated by a corresponding program. For example, a Find command takes a search string as input, or the data entered into a form must be sent to an SQL database. There may even be complicated interactions between the controls of a form. For example, when a search string is empty, the Find button may be disabled. If something is typed in, the button is enabled. Such interactions can become very involved.
In principle, a control is simply an observer view on its data. This means that it would be most straight-forward to implement the data (e.g., the search string) as a model.
For BlackBox, it was felt that this approach is too heavy-weight and unconvenient. Instead, a special implementation of the observer pattern was realized, where typical applications never need to access control objects directly. They are completely "abstracted away". The programmer only deals with the observed data. In order to make the definition and manipulation of this data as convenient as possible, it is simply a global Component Pascal variable, called an interactor. A control has a symbolic name (e.g. "TextCmds.find.ignoreCase") which enables it to find its variable, using built-in metaprogramming facilities of BlackBox. In the interactor's module itself, there is no object reference to a control.
When a control is being edited, it transparently uses the standard change propagation mechanism of BlackBox, i.e., it broadcasts view messages that notify other controls which may display the same variable.
Although the interactor's module doesn't have access to its controls, it can still influence the way controls are displayed (e.g., enabled or disabled) and the way they interact with each other. This is done by exporting suitable guard and notifier procedures. They are attached to a control in the same way as its interactor link, using a suitable control property editor. The important thing is that the program need not access the controls directly, and no direct control-to-control interactions need to be programmed. This greatly simplifies the implementation and maintenance of complex user interface behaviors. The mechanism is described in more detail in Chapter 4.
In principle, the framework accesses the interactor's module (via metaprogramming) as a singleton mediator.
| Docu/Tut-2.odc |
3 BlackBox Design Practices
In the previous chapters, various patterns and design approaches have been described. They help to solve problems that occur in interactive compound document applications. In this chapter, more general aspects are discussed which help to make a framework component-oriented, i.e., extensible through dynamically loaded black-box components.
We don't attempt to create a full design method that gives step-by-step recipes for how to design a new framework. This would not be realistic. But we want to demonstrate and motivate the practices, approaches, and patterns that have been followed in the design of the BlackBox Component Framework. Some of the design practices have even led to the incorporation of specific framework-related features into the language Component Pascal. Language support for framework design is discussed first, followed by the way Component Pascal components are managed, and the rules which govern many component collaborations in BlackBox.
3.1 Language support
A framework embodies a collection of design patterns, cast into the notation of a particular programming language. Thus the expressiveness of the language, in particular of its interface definition subset, has a major impact on how much of the framework's design can be captured directly in code. Capturing architectural decisions and design patterns explicitly in the language is important for making refactoring of a framework less risky. Refactoring of a framework and its extension components allows to prevent that old architectures grow into brittle structures that threaten to collapse under their own weight. Preventing architecture degradation is the key to keeping software systems productive over a longer period of time, especially if the software consists of components that are replaced, added, or removed incrementally over time.
A framework represents an architecture for solving a certain class of problems. A good architecture uses a minimal number of design patterns wherever they are applicable. Consistent use of design patterns make the framework easier to document and easier to comprehend.
Design patterns are abstract solutions to a problem. For a framework, they need to be formulated in terms of a concrete programming language. The programming language has a large influence on how well the design pattern can be represented and how well consistency with the pattern can be maintained.
There are two major "philosophies" of programming language design. One of them is exemplified by the language C. C is a terse systems programming language which allows to easily and efficiently manipulate memory data structures. The other approach is exemplified by Pascal. Pascal is a readable application programming language which provides a high degree of safety.
The C approach is particularly adequate for writing low-level code such as device drivers. When C was increasingly being used for applications as well, a zero errors ideology formed, which says that because programming errors must not occur, they will not occur. A "real programmer" doesn't make mistakes, and therefore doesn't need any kind of protection facilities forced upon him by the language. Safety features such as index overflow checks are for beginners only; for professionals they are merely a handicap.
However, modern psychological research has clearly shown that humans make mistakes all the time, whether they write programs, develop mathematical proofs, fly airplanes, or perform operations on a patient. Mistakes are made whether or not they are admitted. The important insight is that most mistakes can be corrected easily if they are detected early on. Detection works best in an openly communicating team, where a team member is not afraid of others double-checking his or her work (and thereby exposing the mistakes). Good airlines let their pilots train such cooperative behavior under stress. Some very forward-thinking clinics use a similar training for surgeons and their aides. They have overcome the zero errors ideology in their fields.
In the world of programming, a reverse trend has shaped the industry in the last ten years, by making C the language of choice for all kinds of programs. In terms of software engineering and safety consciousness, this was a huge step backwards behind the state-of-the-art. Large companies tried to limit the damage by imposing the use of tools that reintroduce at least a modest level of safety ђ instead of solving the problems where it costs least, namely at the language level.
But while it is difficult for a programmer to admit that he makes mistakes, it is much easier for him to acknowledge that other programmers make mistakes. This became relevant with the Internet. The Internet makes it easy and sometimes even automatic to download and execute small programs ("applets") from unknown sites. This code clearly cannot be trusted in general. Foor good reason, this has scared large corporations enough to look at safer languages again. In fact, safety concerns were the reason why the language Java was created in the first place. Superficially, Java looks similar to C++; but unlike C and C++, it is completely typesafe, like Component Pascal.
In Component Pascal, objects and their classes (record types) may be hidden completely in a module, or they may be wholly exported, i.e., they and their parts (record fields / instance variables) may be made completely visible outside of the defining module. In practice, it is useful to have even more control. For this reason, Component Pascal allows to determine for each record field whether it is fully exported, read-only exported, or hidden. The following example (Figure 3-1) shows how the asterisk ("*") is used for export, and the dash ("-") is used for the more restricted read-only export:
MODULE ObxSample;
TYPE
File* = POINTER TO RECORD
len: INTEGER (* hidden instance variable *)
END;
Rider* = POINTER TO RECORD
(* there may be several riders on one file *)
file-: File; (* read-only instance variable *)
eof*: BOOLEAN; (* fully exported instance variable *)
pos: INTEGER (* hidden instance variable *)
(* Invariant: (pos >= 0) & (pos < file.len) *)
END;
PROCEDURE (f: File) GetLength* (OUT length: INTEGER), NEW;
BEGIN
length := f.len
END GetLength;
PROCEDURE (rd: Rider) SetPos* (pos: INTEGER), NEW;
BEGIN
(* assert invariants, so that errors may not be propagated across components *)
ASSERT(pos >= 0); ASSERT(pos < rd.file.len);
rd.pos := pos
END SetPos;
...
END ObxSample.
Listing 3-1. Sample module in Component Pascal
Java does not support read-only export, but it does support protected fields, which are fields that are only visible to extensions of a class, but not to normal clients. This feature is only relevant if implementation inheritance is used across module boundaries. For reasons that go beyond the scope of this text, implementation inheritance is not a good idea across black-box abstractions, such as components, and thus should not normally be used across component boundaries or in component framework interfaces. Protected export is thus not supported by Component Pascal.
Safety means different things to different people. On the one hand, C++ can be considered safer than plain C. On the other hand, the Internet also raises concerns that go beyond mere safety; security has to be considered as well (i.e., unauthorized access, criminal attacks, and so on). Security issues are a matter of authorization and authorization checking and are generally dealt with at the operating system or hardware level. Higher-level security features are a matter of library definition and implementation. However, overheads incurred by the excessive crossing of hardware protection boundaries can be avoided if it is possible to build on strong safety properties of the used language(s), which leads us back to the question of safety. But what exactly is "safety"?
In short, "safety" of a programming language means that its definition allows to specify invariants, and that its implementation guarantees that these invariants are kept. (The availability of a trusted implementation must be assumed; this trust is usually earned by successfully surviving attacks.) In short: safety is "invariants taken seriously".
What kinds of invariants are we talking about? The most fundamental invariants are the memory invariants: memory occupied by a variable is only used in the way that the language (e.g., a type declaration) allows. In practice, this means that arbitrary type casting must be ruled out and that manual deallocation of dynamic data structures is not permitted anymore, because deallocation could happen too early, and some still used memory could be reallocated and thus being used simultaneously by two unrelated variables. These dangling pointers are usually desastrous, but can be avoided completely if garbage collection is used instead of manual deallocation. Consequently, Java and Component Pascal are garbage-collected.
Memory invariants are fundamental. More application-specific invariants are typically established over several cooperating objects. For example, an object which represents a file access path must always have a current position which lies within the length of the file, where the file is represented by a second object. This invariant spans two objects (and thus classes). It can only be guaranteed if the programming language allows to define interactions between the two objects that are private to them, so that no outside code may interfere.
Note that this is different from the "protected" relation discussed above. Rather than covering the relation between a base class and its yet unknown subclasses, the issue here is classes that have been co-designed and will always be used in conjunction. A module or package construct is a suitable structured means to allow the definition of such higher-order safety properties. Java packages are not ideal in this respect. Since Java packages are open modules, new classes can be added to a package at run-time, and may well violate the invariants that have been established earlier. Such addition of "foreign" classes to a package thus needs to be prevented by run-time management facilities that are beyond the control of the language definition. In Java, this is related to the concept of unique ownership: every package is conceptually owned by its source and only that single source should have authority to add new classes to a package. In any case, the Java package construct is an improvement over most other object-oriented languages, for example the entirely unstructured approach of C++'s friend classes, or the complete absence of a suitable construct in standard Smalltalk.
In contrast to Java packages, Component Pascal supports closed modules, or modules for short. In Component Pascal, a module is the appropriate unit of compilation, loading, and information hiding.
Applying strong typing and information hiding makes it easier to catch mistakes as early as possible, when they are still easy and inexpensive to correct. This is valuable because it helps increase the program's robustness.
But the benefits of type and module safety go even further. They also provide more flexibility. This is surprising at first sight. Why should restrictions such as types (which restrict the operations on variables) and modules (which restrict visibility) create anything else than reduced flexibility? The reason for this so-called refactoring paradoxon is two-fold. On the one hand, everything that is completely hidden in a module may be changed only by considering this one module. Local changes in the hidden part of the module don't reverberate beyond the module itself. Not even recompilation of other client modules is necessary. On the other hand, when a well-typed interface for some reason is changed, then mere recompilation of the clients will detect the interface usages that have become inconsistent, e.g., after a parameter's type or a method name was changed. A compiler thus can actually increase the confidence in a software system which has been "refactored" due to some interface changes.
By checking typed interfaces at a carefully chosen level of granularity, a balance can be struck between release-to-release binary compatibility and detection of definite inconsistencies. Component Pascal supports an expressive type system to allow the detection of such inconsistencies. For example, newly introduced methods must be marked as NEW, and VAR parameters can be specialized to IN or OUT parameters. In Java, for example, it is not possible to distinguish between a new method, an overloading attempt, and an overriding attempt. By misspelling a method name, by changing a base or a subclass, or by combining incompatible versions, this ambiguity can lead to errors that are hard to track.
A framework typically predefines interfaces for extensions of the framework. The framework may even contain code that uses these interfaces, although no implementation exists yet. The calling of code that resides "higher up" in the module hierarchy is typical for object-oriented frameworks. A language can support this typical framework control flow pattern by providing some form of interfaces, which are abstract classes to be implemented elsewhere. Component Pascal supports abstract record types with single inheritance, in a way that a complete spectrum between fully abstract and fully concrete types are possible. Java is similar to Component Pascal in this respect, except that it additionally supports a separate interface construct. A Java interface is the same thing as a fully abstract class, except that it allows multiple (interface) inheritance.
MODULE TestViews;
TYPE
View* = POINTER TO ABSTRACT RECORD
(* partially abstract type *)
context-: Context;
... some hidden fields ...
END;
Context* = POINTER TO ABSTRACT RECORD END;
(* fully abstract type *)
PROCEDURE (v: View) Restore* (l, t, r, b: INTEGER), NEW, ABSTRACT;
...
END TestViews.
Listing 3-2. Semi-abstract and abstract record types in Component Pascal
Invariants are properties that supposedly stay invariant. Thus it is questionable whether even a subtype (subclass / extended type) should be allowed to arbitrarily modify the behavior of its basetype. In object-oriented languages, such modifications can be achieved by overriding inherited methods. Java allows to make classes or methods final, to give the framework designer the possibility to prevent any kind of invariant violation through the back door of overriding. Component Pascal record types and methods are final by default, they can be marked as extensible explicitly.
Component Pascal goes beyond Java with several other language constructs. One are limited records. Those are records that may be extended and allocated only within their defining module. From the perspective of importing modules, limited types are final and not even allocatable. This makes it possible to guarantee that all allocation occurs centrally in the defining (framework) module, which gives this module full control over initialization. For example, it may provide factory functions that allocate an object and initialize it in different ways, establishing invariants before the objects are passed to client modules. This is more flexible and simpler than constructors as used in Java.
Implement-only export is a prime example of a feature motivated by typical framework design patterns. A record type's methods may be exported as implement-only, by using a dash instead of an asterisk. An implement-only method can only be called inside the defining module. But it can be implemented outside the defining module, in an implementation component of the framework. For example, the BlackBox Component Framework's store mechanism uses this feature to protect a store's Internalize and Externalize methods from being called out of their correct context. Basically, the framework (in this case the Stores module) uses the implement-only methods in all possible legal ways (i.e., implements all legal kinds of use-cases), and only exports them for implementation purposes.
For methods that represent optional interfaces, the method attribute EMPTY is supported. An empty method is a fully abstract hook that can be implemented in an extension, but unlike abstract methods it need not be implemented. For example, a view has an empty HandleCtrlMsg method which need only be implemented by views that react on user input, e.g., via mouse or keyboard.
In the Design Patterns book of Gamma et. al. ["Design Patterns, Elements of Reusable Object-Oriented Software"; Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides; Addison-Wesley, 1994; ISBN 0-201-63361-2], a list of common design problems is identified. These problems often lead to unnecessary redesigns, because the software doesn't allow for a sufficient degree of change. Several of these problems are addressed by Component Pascal:
Creating an object by specifying a class explicity
Modules allow to hide classes. A hidden class cannot be instantiated directly by a client module, since it is not visible there. This makes it possible to enfore a variety of indirect allocation mechanisms.
Abstract record types allow to separate interfaces from implementations, so that abstract record types can be exported, without risking direct allocation by clients.
Like abstract types, limited record types cannot be directly allocated by clients.
Implement-only export allows to restrict the execution of allocation and initialization sequences to the defining module, which also prevents clients from binding themselves to concrete classes by instantiating them directly.
These features can be combined to develop safe implementations of all creational patterns described in Design Patterns: abstract factories, builders, factory methods, prototypes, and singletons.
Dependence on specific operations
Static record variables can be used as light-weight (stack-allocated) message objects, instead of using hard-coded method signatures or heavy-weight (heap-allocated) message objects. Message records can be forwarded, filtered, broadcast, and so on. Yet they don't violate type safety, since addresses of static records cannot be manipulated in unsafe ways.
Message records can be used to implement the chain of responsibility and observer patterns, which decouple a message sender and its receiver(s).
Dependence on hardware and software platforms
Dependence on object representations or implementations
Portability is one of the main advantages of using a true high-level language. Component Pascal abstracts from the underlying hardware, yet its semantic gap is small enough that very efficient machine code can be generated. As in Java, type sizes are defined so that data transfer between machines doesn't create problems.
Algorithmic dependencies
Parts of an algorithm can be made replaceable by using abstract methods, empty (hook) methods, or auxiliary objects. Implement-only export makes it possible to safely assign responsibilities: correct method calling sequences must be implemented by the defining module, implementing the methods must be done by the extension programmer. This feature allows to develop safe implementations of all behavioral patterns (builder, internal iterator, strategy, template method, and so on).
Tight coupling
Modules act as visibility boundaries. Thus tight coupling is possible where it is necessary (within a module's implementation), while loose coupling is possible across module boundaries. This simplifies safe implementation of virtually all design patterns.
Extending functionality by subclassing
Classes can be hidden in modules. Final or limited classes, and final methods can be exported without risk that they may be subclassed or overridden.
Inability to alter classes conveniently
Strong typing, record and method attributes such as NEW, and run-time assertions increase the confidence that an interface can be changed in a way that all clients can be made consistent again easily and reliably. This is basic software engineering, and thus important for all kinds of designs.
All these problems have one common theme: a local change may cause ripple effects that affect the entire software system. Good languages and design practices help to design for change:
Ensure that possible design changes have local effects only.
Where this is not possible, ensure that the effects are detected by the compiler.
Where this is not possible, ensure that the effects are detected at run-time as early as possible.
It is clear that there still remains a considerable gap between current state-or-the-art languages like Component Pascal, and complete specification languages that also allow to specify the semantics of a program. In the future, it will be the challenge to close those parts of the gap which have a good enough cost/benefit ratio, i.e., which help to change a component's behavior in a controlled manner, without making programs unreadable and unwriteable for average programmers.
3.2 Modules and subsystems
In this section, we give a more concrete idea of how Component Pascal code looks like and how it is managed by the BlackBox Component Builder environment. For this purpose, we have to go into more BlackBox-specific details than in the other sections of this part of the book.
All Component Pascal code lives in modules. A module is the compilation unit of Component Pascal. A module has an interface and a hidden implementation. Syntactically this is achieved by marking some items in a module, e.g., some types and procedures, as exported. Everything not exported is invisible and thus not directly accessible from outside of the module. If a module needs services of one or several other modules, it imports them. Thereby the module declares that it requires descriptions of the interfaces of the imported modules at compile-time, and suitable implementations of these modules at run-time. Listing 3-3 shows a possible implementation of a module called ObxPhoneDB. It exports three procedures for looking up phone book entries: by index, by name, and by number. Please note the asterisks which denote items as exported, in this case the type String and the three lookup procedures:
MODULE ObxPhoneDB;
CONST
maxLen = 32; (* maximum length of name/number strings *)
maxEntries = 5; (* maximum number of entries in the database *)
TYPE
String* = ARRAY maxLen OF CHAR;
Entry = RECORD
name, number: String
END;
VAR db: ARRAY maxEntries OF Entry;
PROCEDURE LookupByIndex* (index: INTEGER; OUT name, number: String);
BEGIN (* given an index, return the corresponding <name, number> pair *)
ASSERT(index >= 0);
IF index < maxEntries THEN
name := db[index].name; number := db[index].number
ELSE
name := ""; number := ""
END
END LookupByIndex;
PROCEDURE LookupByName* (name: String; OUT number: String);
VAR i: INTEGER;
BEGIN (* given a name, find the corresponding phone number *)
i := 0; WHILE (i # maxEntries) & (db[i].name # name) DO INC(i) END;
IF i # maxEntries THEN (* name found in db[i] *)
number := db[i].number
ELSE (* name not found in db[0..maxEntries-1] *)
number := ""
END
END LookupByName;
PROCEDURE LookupByNumber* (number: String; OUT name: String);
VAR i: INTEGER;
BEGIN (* given a phone number, find the corresponding name *)
i := 0; WHILE (i # maxEntries) & (db[i].number # number) DO INC(i) END;
IF i # maxEntries THEN (* number found in db[i] *)
name := db[i].name
ELSE (* number not found in db[0..maxEntries-1] *)
name := ""
END
END LookupByNumber;
BEGIN (* initialization of database contents *)
db[0].name := "Daffy Duck"; db[0].number := "310-555-1212";
db[1].name := "Wile E. Coyote"; db[1].number := "408-555-1212";
db[2].name := "Scrooge McDuck"; db[2].number := "206-555-1212";
db[3].name := "Huey Lewis"; db[3].number := "415-555-1212";
db[4].name := "Thomas Dewey"; db[4].number := "617-555-1212"
END ObxPhoneDB.
Listing 3-3. Implementation of ObxPhoneDB
Before a module can be used, it must be loaded from disk into memory. But before it can be loaded, it must be compiled (command Dev->Compile). When compiling a module, the compiler produces a code file and a symbol file. The code file contains the executable code, which can be loaded into memory. The code file is a kind of super-lightweight DLL. The compiler also produces a symbol file, which contains a binary representation of the module's interface. If a module imports other modules, the compiler reads the symbol files of all these modules, in order to check that their interfaces are used correctly. The compilation process can be visualized in the following way:
Figure 3-4. Compilation process
When you compile a module for the first time, a new symbol file is generated. In the log window, the compiler writes a message similar to the following one:
compiling "ObxPhoneDB"
new symbol file 964 640
The first of the two numbers indicates that the machine code in the new code file is 964 bytes long. The second number indicates that the module contains 320 bytes global variables (five entries in the db variable; each entry consisting of two strings with 32 elements each; each element is a 2-byte Unicode character). If a symbol file for exactly the same interface already exists, the compiler writes a shorter message:
compiling "ObxPhoneDB" 964 640
If the interface has changed, the compiler writes a new symbol file and indicates the changes compared to the old version in the log. For example, if you just have introduced procedure LookupByNumber in the most recent version, the compiler writes:
compiling "ObxPhoneDB"
LookupByNumber is new in symbol file 964 640
Symbol files are only used at compile-time, they have no meaning at run-time. In order to load a module, only its code file is needed. Modules are loaded dynamically, i.e., there is no separate linking step as required by more static languages. To see a list of currently loaded modules, call command Info->Loaded Modules. As result, a window will be opened with a contents similar to the following one:
module name bytes used clients compiled loaded Update
StdLinks Џ20639 ЏЏ1 2.7.1996 18:42:15 29.8.1996 14:31:14
StdFolds Џ20425 ЏЏ1 2.7.1996 18:41:33 29.8.1996 14:31:12
StdCmds Џ25066 ЏЏ7 2.7.1996 18:39:12 29.8.1996 14:31:00
Config ЏЏЏ125 ЏЏ0 2.7.1996 18:38:21 29.8.1996 14:31:20
Init ЏЏЏ682 ЏЏ0 2.7.1996 18:40:21 29.8.1996 14:31:05
Controls Џ78876 ЏЏ5 7.7.1996 14:14:58 29.8.1996 14:31:00
Services ЏЏ1472 ЏЏ5 2.7.1996 18:37:14 29.8.1996 14:30:54
Containers Џ37348 Џ40 2.7.1996 18:37:51 29.8.1996 14:30:52
Properties ЏЏ8337 Џ42 2.7.1996 18:37:40 29.8.1996 14:30:49
Controllers ЏЏ6037 Џ42 2.7.1996 18:37:36 29.8.1996 14:30:49
Views Џ31589 Џ49 2.7.1996 18:37:33 29.8.1996 14:30:49
Models ЏЏ4267 Џ50 2.7.1996 18:37:27 29.8.1996 14:30:48
Converters ЏЏ2189 Џ51 14.7.1996 22:45:12 29.8.1996 14:30:48
Dialog ЏЏ8979 Џ54 2.7.1996 18:37:13 29.8.1996 14:30:48
Dates ЏЏ3848 Џ45 2.7.1996 18:37:07 29.8.1996 14:30:48
Meta Џ19275 Џ11 2.7.1996 18:37:10 29.8.1996 14:30:48
Stores Џ22302 Џ53 2.7.1996 18:37:22 29.8.1996 14:30:47
Strings Џ17547 Џ15 2.7.1996 18:37:05 29.8.1996 14:30:47
Math Џ15408 ЏЏ2 3.7.1996 1:45:05 29.8.1996 14:30:47
Ports Џ10631 Џ56 2.7.1996 18:37:17 29.8.1996 14:30:46
Fonts ЏЏ1589 Џ58 2.7.1996 18:37:15 29.8.1996 14:30:46
Files ЏЏ3814 Џ62 2.7.1996 18:36:28 linked
...
Table 3-5. List of loaded modules
The list shows all loaded modules. For each module, it shows its code size in bytes, how many other modules import it, when it has been compiled, and when it has been loaded.
It is easy to get an overview over the already loaded modules, but what about modules not yet loaded? The idea of having access to a wealth of prebuilt components raises some organizational issues. How do you find out exactly which components are available? How do you find out which of the available components provide the services that you need?
This is a matter of conventions, documentation, and supporting tools. For the BlackBox Component Builder, it is a convention that collections of related components, called subsystems, are placed into separate directories; all of which are located directly in the BlackBox directory. There are subsystems like System, Std, Host, Mac, Win, Text, Form, Dev, or Obx. The whole collection of subsystems is called the BlackBox repository. The basic idea behind the repository's structure is that everything that belongs to a component (code files, symbol files, documentation, resources) are stored together in a systematic and simple directory structure, according to the rule
Keep all constituents of a component in one place.
It is only appropriate for component-oriented software that addition and removal of a component can be performed incrementally, by adding or removing a directory. All kinds of central installation or registration mechanisms which distribute the constituents of a component should be avoided, since they inevitably lead to (unnecessary) management problems.
Figure 3-6. Standard subsystems of the BlackBox Component Builder
Each subsystem directory, e.g. Obx, may contain the following subdirectories:
Figure 3-7. Structure of a typical subsystem directory
The module source is saved in a subsystem's Mod directory. The file name corresponds to the module name without its subsystem prefix; e.g., the modules ObxPhoneDB and ObxPhoneUI are stored as Obx/Mod/PhoneDB and Obx/Mod/PhoneUI, respectively. For each source file, there may be a corresponding symbol file, e.g., Obx/Sym/PhoneDB; a corresponding code file, e.g., Obx/Code/PhoneDB; and a corresponding documentation file, e.g., Obx/Docu/PhoneDB. There may be zero or more resource documents in a subsystem, e.g., Obx/Rsrc/PhoneUI. There is not necessarily a 1:1 relationship between modules and resources, although it is generally recommended to use a module name as part of a resource name, in order to simplify maintenance.
Modules whose names have the form SubMod, e.g., TextModels, FormViews, or StdCmds, are stored in their respective subsystems given by their name prefixes, e.g., Text, Form, or Std. The subsystem prefix starts with an uppercase letter and may be followed by several other uppercase letters and then by several lowercase letters or digits. The first uppercase letter afterwards denotes the particular module in the subsystem.
Modules which belong to no subsystem, i.e., modules whose names are not in the form of SubMod, are stored in a special subsystem called System. The whole BlackBox library and framework core belongs to this category, e.g., the modules Math, Files, Stores, Models, etc.
Each subsystem directory may contain the following subdirectories:
Code Directory with the executable code files, i.e., lightweight DLLs.
For example, for module "FormCmds" there is file "Form/Code/Cmds".
A module for interfacing native DLLs (Windows DLLs or Mac OS code fragments) has no code file. Docu Directory with the fully documented interfaces and other docu.
For example, for module "FormCmds" there is file "Form/Docu/Cmds".
For a module that is only used internally, its docu file is not distributed to the customer.
Often, there are further documentation files which are not specific to a particular module of the subsystem. Such files contain one or more dashes as parts of their names, e.g., "Dev/Docu/P-S-I".
Typical files are
"Sys-Map" (overview with hyperlinks to other documents of this subsystem)
"User-Man" (user manual)
"Dev-Man" (developer manual)
Mod Directory with module sources.
For example, for module "FormCmds" there is file "Form/Mod/Cmds".
For a module that is not published in source code ("white box"), its source file is not distributed to the customer.
Rsrc Directory with the subsystem's resource documents.
For example, for module "FormCmds" there is file "Form/Rsrc/Cmds".
There may be zero, one, or more resource files for one module. If there are several files, the second gets a suffix "1", the third a suffix "2", and so on. For example, "Form/Rsrc/Cmds", "Form/Rsrc/Cmds1", "Form/Rsrc/Cmds2", etc.
Often, there are further resource files which are not specific to a particular module of the subsystem.
Typical files are
"Strings" (string resources of this subsystem)
"Menus" (menus of this subsystem)
Sym Directory with the symbol files.
For example, for module "FormCmds" there is file "Form/Sym/Cmds".
For a module that is only used internally, its symbol file is not distributed to the customer.
Table 3-8. Contents of the standard subsystem subdirectories
If you want to find out about the repository, its subsystems and their subdirectories, you can invoke the command Info->Repository. If you want to find out more about a module, you can select the module name in a text and then execute Info->Source, Info->Interface or Info->Documentation. These commands open the module's Mod, Sym or Docu files. For this purpose, Info->Interface converts the binary representation of the symbol file into a readable textual description. For example, type the string "ObxPhoneDB" into the log window, select the string, and then execute the Info->Interface browser command. As a result, the following text will be opened in a new window:
DEFINITION ObxPhoneDB;
TYPE
String = ARRAY 32 OF CHAR;
PROCEDURE LookupByIndex (index: INTEGER; OUT name, number: String);
PROCEDURE LookupByName (name: String; OUT number: String);
PROCEDURE LookupByNumber (number: String; OUT name: String);
END ObxPhoneDB.
Listing 3-9. Definition of ObxPhoneDB
A module definition as generated by the browser syntactically is a subset of the module implementation, except for the keyword MODULE which is replaced by DEFINITION. This syntax can be regarded as the interface description language (IDL) of Component Pascal. Texts in this language are usually created out of complete module sources by the browser or similar tools, and thus need not be written manually and cannot be compiled.
Since the browser command operates on the symbol file of a module, it can be used even if there is neither a true documentation nor a code file available. During prototyping, where documentation is rarely available, the symbol file browser is very convenient for quickly looking up details like the signature of a procedure, or to get an overview over the interface of an entire module. When a full documentation is available, the command Info->Documentation can be used. It opens the module's documentation file, which starts with the definition of the module's interface just like above, but then continues with an explanation of the module's purpose and a detailed description of the various items exported by the module, for example:
Module ObxPhoneDB provides access to a phone database. Access may happen by index, by name, or by number. An entry consists of a name and a phone number string. Neither may be empty. The smallest index is 0, and all entries are contiguous.
PROCEDURE LookupByIndex (index: INTEGER; OUT name, number: ARRAY OF CHAR)
Return the <name, number> pair of entry index. If the index is too large, <"", ""> is returned.
The procedure operates in constant time.
Pre
index >= 0 20
Post
index is legal
name # "" & number # ""
index is not legal
name = "" & number = ""
PROCEDURE LookupByName (name: ARRAY OF CHAR; OUT number: ARRAY OF CHAR)
Returns a phone number associated with name, or "" if no entry for name is found.
The procedure operates in linear time, depending on the size of the database.
Post
name found
number # ""
name not found
number = ""
PROCEDURE LookupByNumber (number: ARRAY OF CHAR; OUT name: ARRAY OF CHAR)
Returns the name associated with number, or "" if no entry for number is found.
The procedure operates in linear time, depending on the size of the database.
Post
number found
name # ""
number not found
name = ""
Listing 3-10. Documentation of ObxPhoneDB
Note that preconditions and postconditions are documented in a semi-formal notation. Their goal is not to give a complete formal specification, but rather to help making the plain text description less ambiguous, where this is possible without using overly complex (and thus unreadable) formal conditions. The following assertion numbers are used for run-time checking in BlackBox:
Free 0 .. 19
Preconditions 20 .. 59
Postconditions 60 .. 99
Invariants 100 .. 120
Reserved 121 .. 125
Not Yet Implemented 126
Reserved 127
Listing 3-11. Assertion numbers in BlackBox
It is well known that the detection of an error is more difficult and more expensive the later it occurs, i.e., the farther apart the cause and its effects are. This motivates the following design rule:
Let errors become manifest as early as possible.
In a component-oriented system, defects should always be contained within their components, and not be allowed to propagate into other components. The other components may even be black-boxes for which no source code is available, which makes source-level debugging impossible. Furthermore, the control flow of a large object-oriented software system is so convoluted that it is unrealistic, and thus a waste of time, to trace it beyond component boundaries for debugging purposes.
The only viable debugging approach is to design everything, from programming language to libraries to components and applications using a defensive programming style. In particular, entry points into components (procedure/method calls) should refuse to execute if their preconditions are not met:
Never let errors propagate beyond component boundaries.
Fortunately, most precondition checks are inexpensive and thus their run-time overhead is negligible. This is important because in a component-oriented system, run-time checks cannot be switched off in a production system, because there are no separate development and production systems. In practice, most components during development are already debugged ("production") black-boxes, and the others are currently being debugged white-boxes. The production components must cooperate in order to make adherence to the above rule possible, which means never switching off run-time checks.
3.3 Bottleneck interfaces
One particular pattern that we would like to discuss here is the Carrier-Rider-Mapper pattern. This pattern is used in several ways in the BlackBox Component Framework: in the text subsystem, in the file abstraction, in the frame abstraction, in the container/context abstraction, and others. Let us consider texts as an example.
We regard a text as a so-called carrier. A carrier is an object that carries (contains) data, in this case textual data. Basically, a text can be regarded as a linear stream of elements, where elements have attributes such as font, color, style and vertical offset (for subscript and superscript characters). Elements are characters or views. For all practical purposes, a view in a text can simply be regarded as a special character.
When reading a text, it is convenient not to require the specification of a text position for each and every character read. This convenience can be achieved by supporting a current position, i.e., the text itself knows where to read the next character. Each read operation automatically increments the current position.
Several client objects may use a text carrier independently. For example, a text view needs to read its text when it redraws the text on screen, and a menu command may need to read the same text as its input. These clients are independent of each other; they don't need to know about each other. For this reason, the current read position cannot be stored in the text carrier itself, since this would mean that clients could interfere with each other and lose their independence.
To avoid such interference, a carrier provides allocation functions that return so-called rider objects. A rider is an independent access path to a carrier's data. Every text rider has its own current position, and possibly further state such as the current attributes.
Figure 3-12. Carrier-Rider separation
The reason why carrier and rider are separated into different data types is the one-to-many relationship between the two: for one carrier there may be an arbitrary number (including zero) riders.
Typically, carrier and rider need to be implemented by the same component, since a rider must have intimate knowledge about the internals of its carrier. For example, text riders and text carriers are both implemented in module TextModels. A text rider contains hidden pointers to the internal data structure of a text carrier. Since this information is completely hidden by the module boundary of TextModels, no outside client can make a rider inconsistent with its carrier. This kind of invariant, guaranteed by Component Pascal's module system, is an example why information hiding beyond single classes is important for safety reasons.
In the design patterns terminology, a text rider is an external iterator. However, not all riders are necessarily iterators. For example, a context object managed by a container is not an iterator.
Text riders come in two flavors: readers and writers. Readers support the reading of characters and views, while writers support the writing of characters and views. For example, the following calls may be made:
reader.ReadView(view)
or
writer.WriteChar("X")
Often, a programmer needs to read or write complex character sequences, so that working at the level of individual characters is too cumbersome. A higher-level abstraction for reading and writing is clearly desirable. This is the purpose of the mappers. A mapper contains a rider that it uses to provide more problem-oriented operations for reading or for writing. Since there exist very different programming problems, different applications may use different mappers, possibly even while working with the same carrier.
For text manipulation, BlackBox provides module TextMappers, which defines and implements two text mappers: formatters for writing, and scanners for reading.
Figure 3-13. Carrier-Rider-Mapper separation
Both scanner and formatter work on the level of Component Pascal symbols: with integer numbers, real numbers, strings, and so on. For example, the following calls may be made:
scanner.ReadInt(int)
or
formatter.WriteReal(3.14)
If there are different mappers for the same kind of carrier, they all have to be implemented in terms of the rider interface. For this reason, the rider/carrier interface is sometimes called a bottleneck interface. The reason why riders and mappers are separated is not a one-to-many relation as with carrier and rider ђ there is a one-to-one relation between mapper and rider ђ but independent extensibility: special circumstances may require special mappers. If carriers and mappers adhere to a well-defined rider (bottleneck) interface, it is possible to add new mappers anytime, and to use them with the same carrier.
Even better: the carrier/rider interface can be an abstract interface, such that different implementations of it may exist. For example, a file carrier may be implemented differently for floppy disk files, hard disk files, CD-ROM files, and network files. But if they all implement the same bottleneck interface, then all file mappers can operate on all file implementations! Compare this with a situation where you would have to re-implement all mappers for all carriers: instead of implementing n carriers plus m mappers, you would have to implement n carriers plus n * m mappers! Wherever such an extensibility in two dimensions occurs (carrier/rider and mapper), a bottleneck interface is needed to avoid the so-called cartesian product problem, i.e., an explosion of implementations.
Note that a bottleneck interface is not extensible itself, because every extension that cannot be implemented in terms of the bottleneck interface invalidates all its existing implementations. For example, if you extend the interface of a device driver for black-and-white bitmap displays by a color extension, then all existing device driver implementations will have to be updated. Since they probably have been implemented by different companies, this can become a major problem.
The problem can be defused if the new interface extension is specified as optional: then clients must test whether the option is supported. If not, a client either has to signal that it cannot operate in this environment, or it must gracefully degrade by providing a more limited functionality. If the optional interface is supported and used, it acts as a kind of "conspiracy" between the interface implementation and its client. This is admissible, but it clearly reduces the combinations of clients and implementations that are fully functional. This underlines how crucial good bottleneck designs are, in order to avoid the need for later extensions.
Figure 3-14. Extensibility in two dimensions
In terms of design patterns, the Carrier-Rider-Mapper pattern solves the problem of flexible and convenient access to a data carrier, however it is implemented. It can be regarded to consist of two simpler and very basic design patterns: the separation of one object into several objects to allow many-to-one relations; and the separation of one object into two objects to allow for independent extensibility:
Split an abstraction into two interfaces if several clients may access an instance simultaneously, and if independent state may have to be managed for every client.
Split an abstraction into two interfaces, if it needs to be extended independently in two different dimensions.
The Carrier-Rider-Mapper separation goes back to a research project ["Insight ETHOS: On Object-Orientation in Operating Systems"; Clemens Szyperski; vdf, Zьrich, 1992, ISBN 3 7281 1948 2] predating BlackBox. This project used several design patterns and design rules (e.g., avoidance of implementation inheritance) that are also described in Design Patterns. In the Design Patterns terminology, a Rider-Mapper combination (or Carrier-Mapper combination if there is no rider) forms a bridge pattern.
In BlackBox, riders are often created and managed in a particular way. A rider is typically under exclusive control of one client object, because after all, the reason why there can be multiple riders on one carrier (and thus why the two are distinguished) is precisely to allow several clients access to the carrier's data via their private access paths. Since riders are used in such controlled environments, BlackBox usually creates riders in the following way:
rider := carrier.NewRider(rider);
The idea is that if there already exists an old rider that isn't used anymore, it can be recycled. Recycling is done by the NewRider factory method (see next section) if possible. Of course, recycling is only legal if the old rider isn't used anymore for something else (possibly by someone else); that's why it is important that the rider is maintained in a controlled environment.
Typically, a NewRider procedure is implemented in the following way:
PROCEDURE (o: Obj) NewRider (old: Rider): Rider;
VAR r: RiderImplementation;
BEGIN
IF (old # NIL) & (old IS RiderImplementation) THEN (* recycle old rider *)
r := old(RiderImplementation)
ELSE (* allocate new rider *)
NEW(r)
END;
... initialize r ...
RETURN r
END NewRider;
Listing 3-15. Rider recycling
This approach is used in BlackBox for files, texts, and forms. It can make a considerable difference in efficiency, depending on the kind of application. However, where efficiency is not a concern, it is probably a good idea to omit this mechanism, thereby avoiding any possibility for inadvertant reuse of riders in different contexts simultaneously.
3.4 Object creation
The BlackBox Component Framework is mostly a black-box design. It strictly separates interface from implementation. A client can only import, and thus directly use or manipulate, interfaces of objects. The implementations are hidden within the modules. This enforces that module clients adhere to the following design rule (Gamma et.al.):
Program to an interface, not to an implementation.
In Component Pascal, object interfaces are represented as abstract record types. An implementation of an abstract record type is a concrete extension of it. Typically, implementations are not exported and thus cannot be extended ("subclassed") in other modules, meaning that implementation inheritance cannot be used. Thus it is also enforced that extension programmers adhere to the following design rule (Gamma et.al.):
Favor object composition over class inheritance.
Concrete record types cannot even be instantianted directly: because a client cannot import an object implementation whose type is not exported, it cannot allocate an instance by calling NEW. This is desirable, because NEW would couple the client code forever to one particular object implementation; reuse of the code for other implementations wouldn't be possible anymore. But how can client code solve the black-box allocation problem; i.e., obtain an object implementation without specific knowledge of it?
Figure 3-16. Exported interface records and hidden implementation records
Instead of calling NEW it might be possible to call an allocation function instead, a so-called factory function. For example, module TextModels might export a function New that allocates and returns a text model. Internally, it would execute a NEW on the non-exported implementation type and possibly perform some initialization. This would be better than clients directly calling NEW, because the allocating module can guarantee correct initialization, and a new release of the module could perform allocation or initialization in some different way without affecting clients. However, static factory functions are still too inflexible. A proper solution of the black-box allocation problem requires a level of indirection. There are several approaches to achieve this. They are called creational patterns. BlackBox uses four major creational patterns: prototypes, factory methods, directory objects, and factory managers. They are discussed one by one.
Sometimes it is necessary to create an object of the same type as some other already existing object. In this case, the existing object is called a prototype, which provides a factory function or initialization method. BlackBox models can act as prototypes. For example, it is possible to clone a prototype and to let the prototype initialize its clone. This makes sure that the newly created object has exactly the same concrete type as the prototype, and it allows the prototype and its clone(s) to share caches for performance reasons. For example, a BlackBox text model and its clones share the same spill file that they use for buffering temporary data. Sharing avoids the proliferation of open files.
Sometimes there exists an object that can be used to create an object of another type. For this purpose, the existing object provides a factory function, a factory method. Possibly, the object may provide different factory methods which support different initialization strategies or which create different types of concrete objects.
In BlackBox, a text model provides the procedures NewReader and NewWriter, which generate new readers and writers. They are rider objects that represent access paths to a text.
Factory methods are appropriate for objects that are implemented simultaneously ("implementation covariance"). This is always the case for riders and their carriers.
But this approach is not sufficient for allocating the text models themselves. Where does the first text model come from? BlackBox uses special objects with factory methods, so-called factory objects. In BlackBox, factory objects are used in a particular way: they are installed in global variables and may be replaced at run-time, without affecting client code. For historical reasons, we call factory objects which are used for configuration purposes directory objects.
For example, module TextModels exports the type Directory which contains a New function, furthermore it exports the two variables dir and stdDir and the procedure SetDir. By default, TextModels.dir is used by client code to allocate new empty text models. TextModels.stdDir contains the default implementation of a text model, which is mostly useful during the debugging of a new text model implementation. For example, you could use the old directory while developing a new text model implementation. When the new one is ready you install its directory object by calling SetDir, thereby upgrading the text subsystem to the new implementation on the fly. From this time, newly created texts will have the new implementation. Texts with the old implementation won't be affected. If the new implementation has errors, the default implementation can be reinstalled by calling TextModels.SetDir(TextModels.stdDir). The text subsystem uses directory objects in this typical way; the same design pattern can be found in other container model abstractions; e.g., for forms models. In BlackBox, it is even used for much simpler models and views; e.g., for DevMarkers.
Note that objects allocated via directories are often persistent and their implementation thus long-lived. For this reason, several different implementations appear over time which have to be used simultaneously.
Typically, the normal default directory objects of a subsystem are installed automatically when the subsystem is loaded. If other directory objects should be installed, a Config module is used to set up the desired directory object configuration upon startup.
The name "directory object" comes from another use of the directory design pattern: in module Files, a file can be created by using the directory object Files.dir. But a Files.Directory also provides means to find out more about the current configuration of the file system (e.g., procedure Files.Directory.FileList).
File directories are interesting also because they show that a replacement directory may sometimes need to forward to the replaced directory object. For example, if the new directory implements special memory files, which are distinguished by names that begin with "M:\", then the new directory must check at each file lookup whether the name begins with the above pattern. If so, it is a memory file. If not, it is a normal file and must be handled by the old directory object.
There may exist several directory objects simultaneously. For example, if a service uses files in a particular way, it may provide its own file directory object which by default forwards to the file system's standard directory object.
Multiple directory objects and chaining of directory objects are part of the directory design pattern. This chaining part of the pattern is cascadable, if a new directory object accesses the most recent old one, instead of stdDir.
Note that unlike typical factory classes, directories are rarely extended.
Figure 3-17. Forwarding between two directory objects
Directory objects are a particularly appropriate solution when the existence of one dominating implementation of an extensible black-box type can be expected, without excluding the existence of other implementations.
On the other hand, there could also be several special directory objects for the same implementation but for different purposes. For example, there may be a special text directory object for texts that have a special default ruler useful for program texts. A program editor would then create new program text via this directory object rather than via the standard directory of the text subsystem.
A registry would be a valuable addition to directory objects. A registry is a persistent central database which stores configuration information, such as the particular directory objects to install upon startup. The problem with registries is that they contradict the decentral nature of software components, which leads to management problems such as finding registry entries that are no longer valid.
We have seen that allocation via one level of indirection is key to solving the black-box allocation problem. Directory objects are a solution involving global state. This is only desirable if this state changes rarely, and if no parallel activities occur (threads). For example, in server environments a state-free solution is often preferable. This can be achieved by parameterizing the client: the client must be passed a factory object as parameter. This makes it possible to determine the exact nature of an implementation at the "top" of a hierarchy of procedure calls, always passing the factory object "downward". This is useful since the top-level is typically much less reusable than lower-level code.
As an example, a file transfer dialog box may allow to specify the file transfer protocol along with information such as remote address, communication speed, and so on. The file transfer protocol, which indicates the implementation of a communication object, can be passed from the dialog box down to the communication software, where it is used to allocate a suitable communication object (e.g., a TCP stream object).
Instead of passing a factory object, its symbolic name may be passed. At the "bottom", a service interprets this name; if necessary loads the module which implements the corresponding factory function; and then creates an object using the factory function. In this way, the service acts as a factory manager.
This approach is used for some BlackBox services, in particular for the Sql and Comm subsystems. In both cases, the name of a module can be passed when allocating a new object. This module is expected to provide suitable factory functions. For Sql, the modules SqlOdbc and DtfDriver provide appropriate object implementations and factory functions. For Comm, the module CommTCP provides a suitable object implementation.
Factory managers are often more suitable for creating non-persistent objects, while directory objects are often more suitable for creating persistent objects.
| Docu/Tut-3.odc |
Part II: Library
Part I of the BlackBox tutorial gives an introduction to the design patterns that are used throughout BlackBox. To know these patterns makes it easier to understand and remember the more detailed design decisions in the various BlackBox modules.
Part II of the BlackBox tutorial demonstrates how the most important library components can be used: control, form, and text components.
Part III of the BlackBox tutorial demonstrates how new views can be developed, by giving a series of examples that gradually become more sophisticated.
4 Forms
In the first chapter of this part, we concentrate on the forms-based composition of controls. "Forms-based" means that there exists a graphical layout editor, sometimes called a visual designer or screen painter, that allows to insert, move, resize, and delete controls. Controls can be made active by linking them to code pieces. For example, it can be defined what action should happen when a command button is clicked.
Controls can have different visible states, e.g., they can be enabled or disabled. This is a way to inform a user about which actions currently make sense. Setting up control states in a sensible way can make a large difference in the user-friendliness of an application. Unfortunately, these user interface features often require more programming effort than the actual application logic itself does. However, there are only a few concepts necessary to understand in order to build such user interfaces. These concepts will be explained by means of simple examples.
4.1 Preliminaries
We want to start as quickly as possible with a concrete example, but a few preliminary remarks are still in order. The reader is expected to have some basic knowledge of programming, preferably in some dialect of Pascal. Furthermore, he of she is expected to know how to use the platform (Windows or Macintosh), and the general user interface guidelines for the platform.
The BlackBox Component Builder is used as the tool to expose the various characteristics of component software in an exemplary way. The contents of the book applies both to the Windows and the Macintosh version of the BlackBox Component Builder; except for screendumps, which mostly use Windows 95. In order to minimize platform-specific remarks in the text, a few notational conventions are followed:
Mac OS folders are called directories
Path names contain "/" as directory separators, as in Unix and the World-Wide Web
File and directory names may contain both capital and small letters
Document file names are given without the ".odc" suffix used in Windows. Thus the file name Text/Rsrc/Find under Windows corresponds to Text\Rsrc\Find.odc on Windows 95, and to Text:Rsrc:Find under Mac OS.
Modifier key: on Windows this is the Ctrl key, on Mac OS it is the Option key
Menu commands: M->I is a shorthand notation for menu item I in menu M, e.g., File->New
When working in the BlackBox environment for the first time, the following may be helpful to remember: almost all modifications to BlackBox documents are undoable, making it quite safe to try out a feature. In general, multi-level undo is available; i.e., not only one, but several commands can be undone; as many as memory permits.
This book is not a replacement for the BlackBox user manual. It minimizes the use of specific BlackBox Component Builder tool features, and therefore the need for tool-specific descriptions. The text is intended to concentrate on programming, rather than on the tool. Where unavoidable, tool-specific explanations are given where they are first needed.
Most examples are also available on-line in the Obx/Mod directory of BlackBox. They can be opened and compiled immediately. At the end of every section, references to further Obx on-line examples for the same topic are given.
For readers who are not yet fluent in Component Pascal, Appendix B describes the differences beween Pascal and Component Pascal.
The Help screen of the BlackBox Component Builder gives direct or indirect access to the complete and extensive on-line documentation, e.g., to the user manual, to all the Obx ("Overview by example") examples, and so on. On the Web, additional resources may be found at http://www.oberon.ch.
4.2 Phone book example
Throughout this part of the book, we will meet variations of and additions to a specific example. The example is an exceedingly simple address database. The idea is not to present a full-fledged application with all possible bells and whistles, but rather a minimal example which doesn't hide the concepts to be explained behind large amounts of code. Nevertheless, the idea of how bells and whistles can be added, component by component, should become obvious over time.
Our phone book database contains the following fixed entries:
Daffy Duck 310-555-1212
Wile E. Coyote 408-555-1212
Scrooge McDuck 206-555-1212
Huey Lewis 415-555-1212
Thomas Dewey 617-555-1212
Table 4-1. Entries in phone book database
The database can be searched for a phone number, given a name. Alternatively, the database can be searched for a name, given a phone number; or its contents can be accessed by index. We have met a possible implementation of this database in section 3.2.
Our goal is to create a user interface for the database. The user interface is a dialog box that contains two edit fields; one for the name, and the other for the phone number. For each text field, there is a caption that indicates its purpose. Furthermore, the dialog box contains a check box which allows to specify whether the name or the phone number should be looked up, and finally there is a command button which invokes the lookup command. The following screendump shows how the dialog box will look like eventually:
Figure 4-2. Phone book database mask
To construct this mask, we start by creating a new empty form for the dialog box, using command Controls->New Form. This results in the following dialog box:
Figure 4-3. New Form dialog box
Clicking on the Empty command button opens an empty form:
Figure 4-4. Empty form
Using the commands of menu Controls , we insert the various controls we need, i.e., two captions, two edit fields, a check box, and a command button. The controls we've inserted still have generic labels such as "untitled" or "Caption". To change these visual properties, a control property inspector is used. It is opened by selecting a control and then issuing Edit->Object Properties... (Windows) or Edit->Part Info (Mac OS), respectively. Edit the "label" field in order to change the selected control's label, and click on the default button to make the change permanent.
Figure 4-5. Control property editor
Change the "label" field of each control so that you end up with a layout similar to the one of Figure 4-2. Listed in a tabular way, the labels are the following ones (from left to right, top to bottom):
Control type Label
Caption Name
Text Field
Caption Number
Text Field
Check Box Lookup by Name
Command Button Lookup
Table 4-6. List of controls in phone book dialog box
The controls can be rearranged by using the mouse or by using the layout commands in menu Layout. After having edited the layout, make sure to call Layout->Sort Views; this command sorts the controls in such a way that when being pressed, the tabulator key moves the cursor between them in the order you would expect, i.e., from left to right and from top to bottom.
Figure 4-7. Completed layout of phone book dialog box
When you are happy with the layout, you can save the dialog box just like any other document, by using File->Save. As a convention, the dialog box layouts of all examples are saved in directory Obx/Rsrc. In this case, we save the new dialog box as Obx/Rsrc/PhoneUI.
The directory name Rsrc stands for "Resources". Resources are documents that are necessary for a program to work. In particular, they are dialog box layouts and string resources. String resources allow to move strings out of a program's source code into a separately editable document.
Resources can be edited without recompiling anything. For example, you could change all labels in the above dialog box from English to German, without having access to any source code or development tool.
4.3 Interactors
Creating a dialog box layout is fine, but there also must be a way to add behavior to the dialog box. In our example, user interactions with the dialog box should lead to lookup operations in the phone book database. To achieve this, we need an actual implementation of the database. We mentioned earlier that a suitable implementation already exists. This is not surprising, since in this part of the book we talk about component object assembly, which means taking existing components and suitably integrating persistent objects that they implement.
In our example, the phone book database is a Component Pascal module called ObxPhoneDB. We have already met this module in Chapter 3. Now we want to write our first new module, whose purpose is to build a bridge between the database module ObxPhoneDB and the dialog box we've built earlier. The new module is called ObxPhoneUI, where "UI" stands for "user interface". It is a typical script module whose only purpose is to add behavior to a compound document, such that it can be used as a front-end for the application logic, which in our case is simply the phone book database.
The new module uses, i.e., imports, two existing modules. On the one hand, it is the ObxPhoneDB module. On the other hand, module Dialog:
Figure 4-8. Import relation between ObxPhoneUI and ObxPhoneDB
Dialog is part of a fundamental framework coming with the BlackBox Component Builder. The module provides various services that support user interaction. We'll meet the most important ones in this chapter.
MODULE ObxPhoneUI;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String;
lookupByName*: BOOLEAN
END;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
END;
Dialog.Update(phone)
END Lookup;
END ObxPhoneUI.
Listing 4-9. First version of ObxPhoneUI
ObxPhoneUI exports a global record variable phone, which contains two string fields and a Boolean field. Depending on the current value of the Boolean field, the Lookup procedure either takes phone.name to look up the corresponding number, or phone.number to look up the corresponding name. If the lookup fails, i.e., returns the empty string, the result is turned into "not found". Either result is put into phone, i.e., phone carries both input and output parameters for the database lookup.
Since the user could change the contents of phone by interactively manipulating a control, e.g., by typing into a text entry field, a global variable like phone is called an interactor. Controls display the contents of their interactor fields and possibly let them be modified interactively. To do this, every control must first be linked to its corresponding interactor field. This is done with the control property editor that we have seen earlier. Its "Link" field should contain the field name, e.g., ObxPhoneDB.phone.name or a procedure name such as ObxPhoneDB.Lookup. Use the control property inspector to set up the link fields according to Table 4-10:
Control type Label Link
Caption Name
Text Field ObxPhoneUI.phone.name
Caption Number
Text Field ObxPhoneUI.phone.number
Check Box Lookup by Name ObxPhoneUI.phone.lookupByName
Command Button Lookup ObxPhoneUI.Lookup
Table 4-10. Links of phone book dialog box
Note that the previously disabled controls now have become enabled. What does this mean? When a control is linked, which normally happens when it is being read from a file, or in our case when the link is changed by the inspector, then the module to which the control should be linked must be loaded. If it is already loaded, nothing needs to be done. If it isn't loaded yet (remember that you can check with Info->Loaded Modules), loading is done now. If loading fails, e.g., because the module's code file doesn't yet exist, then control linking fails and the control remains disabled. Linking also fails if the control and field types don't match, e.g., if a check box is linked to a string field.
To achieve this level of functionality (and safety against incorrect use), BlackBox provides several advanced "metaprogramming" services, in particular dynamic module loading on demand and typesafe lookup of variables. The latter requires extensive run-time type information (RTTI) that is relatively uncommon in fully compiled languages.
The links of all controls are reevaluated whenever a module has been unloaded. This ensures that controls are never linked to unloaded modules.
It was one of the design goals for BlackBox to separate user interface details from program logic. For this reason, module ObxPhoneUI doesn't know about controls and forms and the like. Instead, the controls of our form have links, which tell them the interactor fields with which they should interact. For example, the command button's "ObxPhoneUI.Lookup" link tells it to activate the ObxPhoneUI.Lookup procedure when the button is pressed. This procedure in turn doesn't know about the command button (there even may be several of them), the only thing it does to acknowledge the possible existence of controls is to call
Dialog.Update(phone)
at the end of the command procedure. Dialog.Update causes an update of all controls that need updating. For example, if Lookup has assigned "not found" to phone.number, the corresponding text field(s) or similar controls need to be redrawn accordingly.
As parameter of Dialog.Update, an interactor must be passed. Calling Dialog.Update is necessary after one or several fields of this interactor have been modified by a program. If several fields have been modified, Dialog.Update should only be called once, for efficiency reasons. Note that a control calls Dialog.Update itself when the user has modified an interactor field; you only need to call it after your own code has modified the interactor.
This strong separation of user interface from program logic is uncommon. Its advantage is simplicity: as soon as you know how to define procedures and how to declare record types and global variables, you can already construct graphical user interfaces for modules. This is possible even for someone who is just beginning to learn programming. Another advantage is that you have to write no code for simple user interfaces. User interface construction happens in the forms editor (e.g., setting the position and size of a control) and with the inspector (e.g., setting the alignment of text in a text field). This makes it easier to adapt an application to different user interface requirements, without touching the application logic itself. Only if you want to exercise more control over the user interface, e.g., disabling controls or reacting on special events such as the user's typing, then you need to write small amounts of code, which can be very cleanly separated from the application logic itself. The necessary concepts, so-called guards and notifiers, will be discussed in the next two sections. If you need still more control, then you can access controls individually, as described in section 4.9.
Currently, a disavantage of the BlackBox Component Builder's approach is that all controls have to be linked to global interactor variables. If there are several controls for the same interactor field, all of them display the same value. The controls cannot have independent state of their own.
Note an interesting feature of BlackBox: if you have written a module like ObxPhoneUI in Listing 4-9, you can automatically generate a form with suitable controls in a default layout. This is done by clicking "Create" in the "New Form" dialog box instead of "Empty". This feature is useful to create temporary testing and debugging user interfaces during development, where it isn't useful to spend time with manual form construction.
We now have a dialog box layout with controls linked to module ObxPhoneUI, and this module imports the database engine ObxPhoneDB. What is still missing is a way to use the dialog box, rather than to merely edit its layout. During editing, it can be useful to immediately try out the dialog box, even before its layout is perfect. To try this out, make sure that the layout window is on top and then execute Controls->Open As Aux Dialog. A new window is opened which contains the same dialog box, but in a way that its controls can be edited, rather than its layout. The window acts as a data entry mask. Now you can type, for example, "Huey Lewis" into the name string, click on the "Lookup by Name" check box, and then click on the "Lookup" button. You'll see that the appropriate phone number appears in the "Number" field.
Figure 4-11. Layout view (left) and mask view (right) displaying the same form model
Note that the same name and number also appeared in the layout window. Even better, if you change the layout in the layout window, e.g., by moving the check box somewhat, you'll note that the layout change is immediately reflected in the other window. This is a result of the so-called Model-View-Controller implementation of BlackBox. In Part II of the book, we have discussed this design pattern in more detail. Here it is sufficient to note that several views can share the same data, e.g., a layout view and a mask view can display the same form; and that both layout and mask views are basically the same kind of view albeit in different modes. You can switch between these modes by applying the Dev->Layout Mode or Dev->Mask Mode commands.
The two modes differ in the ways they treat selection and focus. In layout mode, you can select the embedded views and edit the selection, but you cannot focus the embedded views. In mask mode, you can focus the embedded views, but you cannot select them (only their contents) and thus cannot edit their layout, i.e., their sizes, positions, etc. In other words: layout mode prevents focusing, while mask mode prevents selection.
Opening a second view in mask mode for our form layout is convenient during layout editing, but you wouldn't want any layout view open when your program should actually be used. In this case, you want to open the dialog box in mask mode by invoking a suitable menu command.
A new menu command can be introduced by editing a menu configuration text. You can open this text (which resides in System/Rsrc/Menus) by calling Info->Menus. Append the following text to its end:
MENU "Priv"
"Open..." "" "StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phonebook')" ""
END
Having done this, execute Info->Update Menus. You'll notice that the new menu "Priv" has appeared. Execute its menu item "Open...". As a result, the command
StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phonebook')
will be executed. It opens the Obx/Rsrc/PhoneUI layout document, turns it into mask mode, and opens it in a window with title "Phonebook". If you want the modification of your menu text to become permanent, save the "Menus" text before closing it.
Note that the form has not been saved in mask mode (this would be inconvenient for later editing), it is only temporarily turned into mask mode by the StdCmds.OpenAuxDialog command.
4.4 Guards
In terms of genuine functionality, we have seen everything that is important about the standard set of controls. We will look at the palette of standard controls in more detail later. However, we first need to discuss important aspects of standard controls which, strictly speaking, do not increase the functionality of an application, but rather its useability, i.e., its user-friendliness.
In section 1.2 we have already discussed what user-friendliness means. For example, it means avoiding modes wherever possible. For this reason, BlackBox doesn't support modal dialog boxes.
Modes are unavoidable if a user action sometimes makes sense, and sometimes doesn't. For example, if the clipboard is empty, its contents cannot be pasted into a text. If it is not empty and contains text, pasting is possible. This cannot be helped, and is harmless if the current state is clearly visible or can easily be inquired by the user. For example, if the clipboard is empty, the Paste menu command can be visibly marked as disabled. The visual distinction gives the user early feedback that this command is currently not meaningful. This is usually much better than to let the user try out a command and then give an error message afterwards.
The following example shows a dialog box with two buttons. The Empty button is enabled, while the Create button is disabled. The Create button only becomes enabled if something has been typed into the dialog box's text field:
Figure 4-12. Enabled and disabled buttons
In summary, a good user interface always lets the user perform every meaningful action, and gives visual cues about actions that are not meaningful.
For the BlackBox, we thus need a way to provide feedback about the current state of the system, especially about which commands are currently possible and which aren't.
For this purpose, it must be possible to enable and disable controls and menu items. For example, looking up a phone number is only possible if some name has been entered, i.e., if the name field is not empty. To determine whether a command procedure, in our case the Lookup procedure, may be called, i.e., whether a corresponding control or menu item may be enabled, a suitable guard must be provided. A guard is a procedure called by the framework, whenever it might be necessary to change the state of a control or menu item. The guard inspects some global state of the system, uses this state to determine whether the guarded command currently makes sense, and then sets up an output parameter accordingly. A guard has the following form:
PROCEDURE XyzGuard* (VAR par: Dialog.Par);
BEGIN
par.disabled := ...some Boolean expression...
END XyzGuard;
A guard has the following type:
GuardProc = PROCEDURE (VAR par: Dialog.Par);
To guard procedure Lookup in our example, we extend module ObxPhoneUI in the following way:
MODULE ObxPhoneUI;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String;
lookupByName*: BOOLEAN
END;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
END;
Dialog.Update(phone)
END Lookup;
PROCEDURE LookupGuard* (VAR par: Dialog.Par);
BEGIN (* disable if input string is empty *)
par.disabled := phone.lookupByName & (phone.name = "") OR
~phone.lookupByName & (phone.number = "")
END LookupGuard;
END ObxPhoneUI.
Listing 4-13. ObxPhoneUI with LookupGuard
What happens if we compile the above module? Its symbol file on disk is replaced by a new version, because the module interface has been changed from the previous version. Because the change is merely an addition of a global procedure (i.e., the new version is compatible with the old version) possible client modules importing ObxPhoneUI are not invalidated and need not be recompiled.
Compilation also produced a new code file on disk. However, the old version of ObxPhoneUI is still loaded in memory! In other words: once loaded, a module remains loaded ("terminate-and-stay-resident"). This is not a problem, since modules are extremely light-weight and consume little memory. However, a programmer of course must be able to unload modules without leaving the BlackBox Component Builder entirely, in order to try out a new version of a module. For this purpose, the command Dev->Unload is provided which unloads the module whose source code is currently focused.
Note that compilation does not automatically unload a module, since this is often undesirable. In particular, as soon as you work on several related modules concurrently, unloading one of them before the others are correctly updated would render this whole set of modules inconsistent.
For those cases where immediate unloading after compilation does make sense, like in the simple examples that we are currently discussing, the command Dev->Compile And Unload is provided.
You may use this command to try out our new version of ObxPhoneUI. Notice how the Lookup button is disabled when the Name field is empty (if Lookup by Name is chosen) or when the Number field is empty (if Lookup by Number is chosen). Typing something into the field makes Lookup enabled again; deleting all characters in the field disables it again. At the end of this section we will explain more precisely when guards are evaluated; for now it is sufficient to know that they are evaluated after every character typed into a text field control.
Guards are mostly used to enable and disable user interface elements such as controls or menu items. However, they sometimes play a more general role as well. For example, controls may not only be disabled, but they also may be made read-only or undefined.
Read-only means that a control currently cannot be modified interactively. For example, the following guards set up the output parameter's readOnly field. The first guard sets read-only if lookup is not by name, i.e., by number. Obviously, in this case a number is input and a name is output. Pure outputs should be read-only. Thus the first guard can be used as guard for the Name field. The second guard can be used for the Number field, since it sets read-only if lookup returns a number.
PROCEDURE NameGuard* (VAR par: Dialog.Par);
BEGIN (* make read-only if lookup is by number *)
par.readOnly := ~phone.lookupByName
END NameGuard;
PROCEDURE NumberGuard* (VAR par: Dialog.Par);
BEGIN (* make read-only if lookup is by name *)
par.readOnly := phone.lookupByName
END NumberGuard;
Listing 4-14. Read-only guards for ObxPhoneUI
Interactor fields which are exported read-only, i.e., with the "-" export mark instead of the "*" export mark, are always in read-only state regardless of what a guard specifies (otherwise this would violate module safety, i.e., the invariant that a read-only exported item can only be modified within its defining module).
The undefined state of a control means that the control currently has no meaning at all. This happens if a control displays the state of a heterogeneous selection. For example, a check box may indicate whether the text selection is all caps or all small letters. If part of the selection is capital letters and the rest small letters, then the control has no defined value. However, by clicking on the check box, the selection is made all caps and then has a defined state again. The undefined state can be set by a guard with the statement
par.undef := TRUE
The undefined state can be regarded as "write-only", i.e., the control's state cannot be read by the user because it currently has no defined value, but it can be modified and thus set to a defined value.
Of the fields disabled, readOnly and undef, at most one may be set to TRUE by a guard. This leads to four possible temporary states of the control: it is in none or in exactly one of the three special states. When a guard is called by the framework, all three Boolean fields are preset to FALSE. This is a general rule in BlackBox: Boolean values default to FALSE.
In Table 4-15, suitable guards for the layout of Figure 4-2 are listed:
Control type Link Guard
Caption
Text Field ObxPhoneUI.phone.name ObxPhoneUI.NameGuard
Caption
Text Field ObxPhoneUI.phone.number ObxPhoneUI.NumberGuard
Check Box ObxPhoneUI.phone.lookupByName
Command Button ObxPhoneUI.Lookup ObxPhoneUI.LookupGuard
Table 4-15. Guards in phone book dialog box
A guard applies to a procedure, to an interactor field, or to several procedures or interactor fields. If it applies to mainly one procedure or field, the guard's name is constructed by appending "Guard" to the (capitalized) name of the procedure/field. For example, the guard for procedure Lookup is called LookupGuard, the guard for field phone.name is called NameGuard, etc. This is a simple naming convention which makes it easier to recognize the relation between guard and guarded item. The naming convention is "soft", i.e., it is not enforced by the framework; in fact the framework doesn't know about it at all.
It is not a convention, but a necessity, to export guards. Guards are accessed by the so-called metaprogramming mechanism of BlackBox which, for safety reasons, only operates on exported items. This is consistent with the treatment of a module as a black-box, of which only the set of exported items, i.e., its interface, is accessible from the outside. If a guard isn't exported, a control cannot call it. This is similar to the fields of an interactor, which also must be exported if an interactor should be able to link to it.
If we look at the declaration of type Dialog.Par (use Info->Interface!), we see that two fields have not yet been discussed: label and checked:
Par = RECORD
disabled, checked, undef, readOnly: BOOLEAN;
label: Dialog.String
END
Field label allows to change the label of a control. For example, instead of using the label "Toggle" for a button it may be more telling to use the labels "Switch On" and "Switch Off" depending on the current state of the system. This can be done by a procedure like this:
PROCEDURE ToggleGuard* (VAR par: Dialog.Par);
BEGIN
IF someInteractor.isOn THEN
par.label := "Switch Off"
ELSE
par.label := "Switch On"
END
END ToggleGuard;
Listing 4-16. Label guard example
Note that the guard overrides whatever label was set up in the control property inspector. This is true for all controls (and for menu items as well, see below).
It is strongly recommended not to place string literals in the source code like in the above example, because this would force a recompilation of the code if the language were changed, e.g., from English to German (see also section 1.4). In BlackBox, user interface strings such as labels or messages are generally packed into separate parameter files, so-called string resources. For each subsystem there can be one string resource file, e.g., Text/Rsrc/Strings or Form/Rsrc/Strings. A string resource file is a BlackBox text document starting with the keyword STRINGS and followed by an arbitrary number of <key, string> pairs. The key is a string, separated by a tab character from the actual string into which it will be mapped. Every <key, string> pair must be terminated by a carriage return. The pairs need not be arranged in any particular order, although it is helpful to sort them alphabetically by key, because this makes it easier to find a particular key when editing the string resources.
For example, System/Rsrc/Strings starts the following way:
STRINGS
About About BlackBox
AlienAttributes alien attributes
AlienCause alien cause
AlienComponent alien component
AlienControllerWarning alien controller (warning)
...
Table 4-17. String resources of System/Rsrc/Strings
To use string resources in our guard example, a special syntax must be used to indicate that the string is actually a key that first must be mapped using the appropriate subsystem's string resources. Assuming that in the Obx subsystem's string resources there exist "On" and "Off" keys, the following code emerges:
PROCEDURE ToggleGuard* (VAR par: Dialog.Par);
BEGIN
IF someInteractor.isOn THEN
par.label := "#Obx:Off"
ELSE
par.label := "#Obx:On"
END
END ToggleGuard;
Listing 4-18. Label guard example with string mapping
The leading "#" indicates that a string mapping is desired. It is followed by the subsystem name, in this case "Obx". Then comes a colon, followed by the key to be mapped. A command button with this guard would either display the label "Switch Off" or "Switch On" in an English version of BlackBox, "Ausschalten" or "Einschalten" in a German version, and so on.
If there is no suitable string resource, the key is mapped to itself. For example, if there is no "Off" key in Obx/Rsrc/Strings, then "#Obx:Off" will be mapped to "Off".
The remaining field of Dialog.Par that we have not yet discussed is called checked. Actually, so far it has never been used for controls in BlackBox. It is used for menu items. Menu items are similar to controls: they can invoke actions, they may be enabled or disabled, and they have labels. For this reason it makes sense to use the same guard mechanism for them also. A menu guard is specified in the Menus text as a string after the menu label and the keyboard equivalent of the menu item. For example, the following entry for the Dev menu specifies the guard StdCmds.SetEditModeGuard:
"Edit Mode" "" "StdCmds.SetEditMode" "StdCmds.SetEditModeGuard"
A unique feature of menu items is that they may be checked. For example, in the following menu, menu item Edit Mode is checked:
Figure 4-19. Menu item with check mark
The check mark indicates which of the items has been selected most recently, and the state that has been established by the selection. The state can be changed by invoking one of the other menu items, e.g., Mask Mode as in the figure above. Basically, the four menu items form a group of possibilities from which one can be selected.
Guard procedures for menu items may set up the disabled, checked and label fields of Dialog.Par. The other fields are ignored for menus.
A guard procedure may set up several fields of its par output parameter simultaneously, e.g., it may assign the disabled and label fields for a command button. However, a guard may set at most one of the Boolean fields of par and must never modify any state outside of par, e.g., a field of an interactor or something else; i.e., it must have no side effects. It may not call any procedures which may have side effects either. The reason is that a program cannot assume much about when (and especially when not) a guard is being called by the framework.
A guard may use any interactor or set of interactors as its input, or the state of the current focus or selection. The latter is often used for menu guards. The current focus or selection is only used in control guards if the controls are in so-called tool dialog boxes, i.e., dialog boxes that operate on some document underneath. A Find & Replace dialog box operating on a focused text is a typical example of a tool dialog box. The other dialog boxes are self-contained and called auxiliary dialog boxes. Data entry masks are typical examples of auxiliary dialog boxes.
When is a guard evaluated? There are four reasons why a guard may be called: when the control's link is established, when the contents of an interactor is being edited, when the window hierarchy has changed, or when the user has clicked into the menu bar.
A control's link is established after it is newly inserted into a container, after it has been loaded from a file, after a module was unloaded, or after its link has been modified through the control property inspector or other tool.
When some piece of code modifies the contents of an interactor, it is required to call Dialog.Update for this interactor. As a result, every currently visible control is notified (see section 2.9). In turn, the control compares its actual state with the interactor field to which it is linked. If the interactor field has changed, the control redraws itself accordingly. After all controls have updated themselves, the guards of all visible controls are evaluated. For this reason, guards should be efficient and not perform too much processing.
Guards are also evaluated when the window hierarchy is changed, e.g., when a bottom window is brought to the top. This is necessary because many commands depend on the current focus or selection, which vanishes if another window comes to the top.
Menus are another reason why a guard may be called. When the user clicks in a menu bar, all guards of this menu, or even the guards of the whole menu bar, are evaluated.
Usually, a guard has the form
PROCEDURE SomeGuard* (VAR par: Dialog.Par)
Alternatively, the form
PROCEDURE SomeGuard* (n: INTEGER; VAR par: Dialog.Par)
may be used, which allows to parameterize a single guard procedure for several related commands. For example, the commands to set a selection to the colors red, green or blue are the following:
StdCmds.Color(00000FFH)
StdCmds.Color(000FF00H)
StdCmds.Color(0FF0000H)
For these commands, the following guards can be used:
StdCmds.ColorGuard(00000FFH)
StdCmds.ColorGuard(000FF00H)
StdCmds.ColorGuard(0FF0000H)
The actual signature of StdCmds.ColorGuard is
PROCEDURE ColorGuard (color: INTEGER; VAR par: Dialog.Par)
4.5 Notifiers
A control guard sets up the temporary state of a control, such as whether it is disabled or not. It has no other effect. It doesn't modify any interactor state. It doesn't add any functionality. It only lets the control give feedback about the currently available functionality, or its lack thereof. A guard is evaluated ,e.g., when the user changes the state of a control interactively. It can be regarded as a merely "cosmetic" feature whose sole purpose is to increase user-friendliness.
However, sometimes a user interaction should trigger more than the evaluation of guards only. In particular, it may sometimes be necessary to change some interactor state as a response to user interaction. For example, changing the selection in a selection box may cause the update of a corresponding counter, which counts the number of currently selected items in the selection box. Or some postprocessing of user input may be implemented, as we will see in the following example. It is an alternate implementation of our ObxPhoneUI example. Instead of having a Lookup button, this version just has two edit fields. After any character typed in, a database lookup is executed to test whether now a correct key is entered. Note that unsuccessful lookup in ObxPhoneDB results in returning an empty string.
MODULE ObxPhoneUI1;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String
END;
PROCEDURE NameNotifier* (op, from, to: INTEGER);
BEGIN
ObxPhoneDB.LookupByName(phone.name, phone.number);
Dialog.Update(phone)
END NameNotifier;
PROCEDURE NumberNotifier* (op, from, to: INTEGER);
BEGIN
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
Dialog.Update(phone)
END NumberNotifier;
END ObxPhoneUI1.
Listing 4-20. ObxPhoneUI1 with notifiers
These notifiers create dependencies between two fields of an interactor: a modification of one text field may lead to a modification of the other text field, i.e., a dependency between interactor fields is defined.
Notifiers are called right after an interaction happens, but before the guards are evaluated. A notifier has the following form:
PROCEDURE XyzNotifier* (op, from, to: INTEGER);
BEGIN
...
END XyzNotifier;
A notifier's type is
NotifierProc = PROCEDURE (op, from, to: INTEGER);
For simple notifiers, the parameters can be ignored. They give a more precise indication of what kind of modification actually took place. Which of the parameters are valid and what their meaning exactly is is defined separately for every kind of control. See the next section for details.
4.6 Standard controls
In this section, the various controls that come standard with the BlackBox Component Builder are presented. For each control, a list of data types to which it may be linked is given, and the meaning of the notifier parameters is indicated.
A control may have various properties, e.g., its label, or whether the label should be displayed in the normal system font or in a lighter, less flashy font. However, such cosmetic properties may not be implemented the same way on every platform, sometimes they may even be ignored.
A label may specify a keyboard shortcut, which on some platforms is used to navigate between controls without using the mouse. The shortcut character is indicated by preceding it with a "&" sign. Two successive "&" signs indicate a normal "&", without interpreting the following character as shortcut. Only one shortcut per label is allowed. For example, "Clear Text &Field" defines "F" as a keyboard shortcut, while "Find && &Replace" defines "R" as keyboard shortcut. The same syntax for keyboard shortcuts is used in menu commands.
The label property of every control can be modified at run-time, by using a guard procedure as demonstrated in Listing 4-16. For controls without visible label, this has no visible effect.
Two of the most important control properties, the guard and notifier names, are optional. If there is no guard for the control, it will use its default states (enabled, read-write, defined). If there is no notifier for the control, none will be called.
BlackBox attempts to minimize the number of different properties, in order to make it easier to use. This is consistent with the general trend, both under Windows and the Mac OS, towards globally controlled appearances. This means that a control should not define its colors, font, and so on individually. Instead, the user should be able to define a system-wide and consistent configuration of these properties.
However, if for some special reason this is still deemed important, specific fonts can be assigned to controls, simply by selecting the control(s) and applying the commands of the Font, Attributes or Characters menus. If the default font is set, then the system preferences will be used. This is the normal case. Note that other font attributes, such as styles, weight, or size, may be restricted on certain platforms. For example, on Mac OS the font size is always 12 points.
In the following text, all standard controls of BlackBox are described in turn: command buttons, edit fields, check boxes, radio buttons, date fields, time fields, color fields, captions, groups, list boxes, selection boxes and combo boxes. For each control, its valid properties are given, the variable types to which it may be linked, and the meaning of the op, from and to parameters of the notifier.
Note that there is no special control for currency values, you can use edit fields bound to variables of type Dialog.Currency instead.
In the following descriptions, some abbreviations are used:
pressed stands for Dialog.pressed
released stands for Dialog.released
changed stands for Dialog.changed
included stands for Dialog.included
excluded stands for Dialog.excluded
undefined means that the from or to parameter of a notifier has no defined value that can be relied upon
modifier means a 0 for single-clicks and a 1 for double-clicks
link, label, guard, notifier, and level stand for their respective control properties as defined in module Controls. There are up to five optional Boolean properties. Depending on the control, they are called differently, e.g. default font, default, cancel, sorted, left, right, multiLine, password.
Command Button
Figure 4-21. Command button
A command button is used to execute a parameterless Component Pascal command, or a whole command sequence. A button with the default property looks different than normal buttons; input of a carriage return corresponds to a mouse click in the default button. For a button with the cancel property, input of an escape character corresponds to a mouse click in it. A button should not be default and cancel button simultaneously. Note that the default and cancel properties are set and cleared individually per control, i.e., making one button a default button doesn't automatically make an existing default button a normal button again. There should be at most one default and at most one cancel button per dialog box.
A cancel button or another button that should close the dialog box in which it is contained can use the command StdCmds.CloseDialog.
properties: link, label, guard, notifier, font, default, cancel
linkable to: parameterless procedure, command sequence
op: pressed, released
from: undefined, modifier
to: undefined
Text Field
Figure 4-22. Text field
A text field displays the value of a global variable which may be a string, an integer, a floating-point number, or a variable of type Dialog.Currency or Dialog.Combo. The value of the variable can be changed by editing the field.
Whenever the contents of the linked interactor field is changed, the notifier is called. Key presses that do not change the interactor state, such as pressing arrow keys or entering leading zeroes in number fields, cause no notifier call. Changing the selection contained in the field causes no notification either.
If a modification occurs in a field that is linked to a string, real, currency, or combo variable, the notifier with (change, undefined, undefined) is called. If the field is linked to an integer value, the notifier with (change, oldvalue, newvalue) is called.
Illegal characters, e.g., characters in a field linked to an integer, are not accepted.
A text field may have a label, even though it doesn't display it. The reason for this is that keyboard shortcuts may be defined in labels, which is useful even for edit fields.
If the level property is 0 (the default), or the control is not linked to a number type, or it is linked to Dialog.Currency, then level has no effect. When linked to an integer variable the level defines the scale factor used for displaying the number, i.e., the displayed number is the linked value divided by 10level. For example, if the current value is 42 and level is 2, then 0.42 is displayed. For variable of real type, level indicates the format in the following way:
level > 0: exponential format (scientific) with at least level digits in the exponent.
level = 0: fixpoint or floatingpoint format, depending on x.
level < 0: fixpoint format with -level digits after the decimal point.
The left and right properties define the adjustment mode of the field. The following combinations are possible:
left & ~right left adjust
left & right fully adjusted (may have no effect on some platforms)
~left & ~right centered
~left & right right adjust
The default is left & ~right (left adjust).
Property multiLine defines whether a carriage return, with its resulting line break, may be accepted by the field, which then must be linked to a string variable.
Property password causes the text field to display only asterisks instead of the characters typed in. This makes it possible to use such a field for password entry.
properties: link, label, guard, notifier, level, font, left, right, multiLine,
password
linkable to: ARRAY const OF CHAR,
BYTE, SHORTINT, INTEGER, LONGINT, SHORTREAL, REAL,
Dialog.Currency, Dialog.Combo
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Check Box
Figure 4-23. Check box
A check box displays the value of a global variable which may be a Boolean or an element of a set. Clicking on the control toggles its state.
When the control's state is changed, the notifier with (changed, undefined, undefined) is called if the control is linked to a Boolean variable. If it is linked to an element of a set variable, (included, level, undefined) or (excluded, level, undefined) is called, depending on whether the bit is set or cleared. The value level corresponds to the element of the set to which the control is linked. It can be defined using the control property inspector. It may lie in the range 0..31.
Only the last and final state change of the control leads to a notifier call, possible intermediate state changes (by dragging the mouse outside of the control's bounding box or back inside) have no effect.
properties: link, label, guard, notifier, font, level
linkable to: BOOLEAN, SET
op: pressed, released, changed, included, excluded
from: undefined, level value, modifier
to: undefined
Radio Button
Figure 4-24. Radio button
A radio button is active at a particular value of a global integer or Boolean variable. Typically, several radio buttons are linked to the same variable. Each radio button is "on" at another value, which is defined by the level property; i.e., the button is "on" if its level value is equal to the value of the variable it is linked to. For Boolean types, "on" corresponds to TRUE and "off" corresponds to FALSE.
Only the last and final state change of the control leads to a notifier call, possible intermediate state changes (by dragging the mouse outside of the control's bounding box or back inside) have no effect.
properties: link, label, guard, notifier, font, level
linkable to: BYTE, SHORTINT, INTEGER, LONGINT, BOOLEAN
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value = level value
Date Field
Figure 4-25. Date field
A date field displays the date specified in a global variable of type Dates.Date.
Whenever the contents of the linked interactor field is changed, the notifier is called with (change, undefined, undefined). Key presses that do not change the interactor state, such as pressing left/right arrow keys, cause no notifier call. The up/down arrow keys change the date. Changing the selection in the field has no effect.
Illegal date values cannot be entered.
properties: link, label, guard, notifier, font
linkable to: Dates.Date
op: pressed, released, changed
from: undefined, modifier
to: undefined
Time Field
Figure 4-26. Time field
A time field displays the time specified in a global variable of type Dates.Time.
Whenever the contents of the linked interactor field is changed, the notifier is called with (change, undefined, undefined). Key presses that do not change the interactor state, such as pressing left/right arrow keys, cause no notifier call. The up/down arrow keys change the time. Changing the selection in the field has no effect.
Illegal time values cannot be entered.
properties: link, label, guard, notifier, font
linkable to: Dates.Time
op: pressed, released, changed
from: undefined, modifier
to: undefined
Color Field
Figure 4-27. Color field
A color field displays a color. It can be linked to variables of type INTEGER or Dialog.Color. Ports.Color is an alias of INTEGER and thus can be used also.
Whenever another color is selected, the notifier is called with (change, oldval, newval). The old and new values are integer values; for Dialog.Color type variables the val field's value is taken.
properties: link, label, guard, notifier, font
linkable to: Dialog.Color, Ports.Color = INTEGER
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Up/Down Field
Figure 4-28. Up/down field
This is a field linked to an integer variable. The value can also be changed through arrow keys.
Whenever the contents of the linked interactor field is changed, the notifier is called with (change, oldvalue, newvalue).
properties: link, label, guard, notifier, font
linkable to: BYTE, SHORTINT, INTEGER, LONGINT
op: pressed, released
from: undefined, old value, modifier
to: undefined, new value
Caption
Figure 4-29. Caption
A caption is typically used in conjunction with a text field, to indicate the nature of its contents. A caption is passive, i.e., it cannot be edited and thus cannot have a notifier.
A caption is linkable to the same types as a text field is, and it may have a guard. This is useful since ђ depending on the platform ђ a caption may have a distinct visual appearance if it (or rather its corresponding text field) is disabled, read-only, etc. This means that a caption may be disabled along with its corresponding text field, by linking both to the same interactor field. A caption's guard may modify the control's label, as is true for all controls with a visible label.
properties: link, label, guard, font, right, left
linkable to: ARRAY const OF CHAR,
BYTE, SHORTINT, INTEGER, LONGINT, SHORTREAL, REAL,
Dialog.Currency, Dialog.Combo
The left and right properties define the adjustment mode of the caption. The following combinations are possible:
left & ~right left adjust
left & right fully adjusted (may have no effect on some platforms)
~left & ~right centered
~left & right right adjust
The default is left & ~right (left adjust).
Group
Figure 4-30. Group
A group is used to visually group related controls, e.g., radio buttons that belong together. A group is passive, i.e., it cannot be edited and thus cannot have a notifier.
A group may not be linked, but it may have a guard which allows to disable or enable it. A group's guard may modify the control's label, as is true for all controls with a visible label.
properties: label, guard, font
List Box
Figure 4-31. List box (expanded and collapsed shapes)
A list box allows to select one value out of a list of choices. It is linked to a variable of type Dialog.List (see next section). If the height of the list box is large enough, a scrollable list is displayed. If it is not large enough, the box collapses into a pop-up menu.
Interactively, the selection can be changed. It is either empty or it consists of one selected item. When the user modifies the selection, the notifier is called with (changed, oldvalue, newvalue). The old/new value corresponds to the selected item's index. The top-most item corresponds to value 0, the next one below to value 1, etc. The empty selection corresponds to value -1.
The sorted property determines whether the string items will be sorted lexically (no effect on Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.List
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Selection Box
Figure 4-32. Selection box
A selection box allows to select a subset out of a set of choices. It is linked to a variable of type Dialog.Selection (see next section).
Interactively, the selection can be changed. Each item may be selected individually. When the user modifies the selection, the notifier is called in one of three ways:
(included, from, to): range from..to is now selected; it wasn't selected before
(excluded, from, to): range from..to is not selected now; it was selected before
(set, from, to): range from..to is now selected; any previous selection was cleared before
The three codes included and excluded and set take the place of changed used for most other controls. The notifier is called as often as necessary to include and/or exclude all necessary ranges of items.
The from/to value corresponds to the selected item's index. The topmost item corresponds to value 0, the next one below to value 1, and so on.
The sorted property determines whether the string items will be sorted lexically (no effect on Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.Selection
op: pressed, released, included, excluded, set
from: undefined, lowest element of range, modifier
to: undefined, highest element of range
Combo Box
Figure 4-33. Combo box
A combo box is a text field whose contents can also be set via a pop-up menu. Unlike pure pop-up menus/selection boxes, a value may be entered which does not occur in the pop-up menu. The control is linked to a variable of type Dialog.Combo (see next section).
When the contents of the combo is changed, the notifier is called with (changed, undefined, undefined).
The sorted property determines whether the string items will be sorted lexically (no effect on Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.Combo
op: pressed, released, changed
from: undefined, modifier
to: undefined
Each interactive control (i.e., not a caption or a group) calls its notifier ђ if there is one ђ when the user first clicks in the control with parameter op = Dialog.pressed, and later with op = Dialog.released when the mouse button is released again. This feature is used mostly to display some string in the dialog box window's status area. This is done with the calls Dialog.ShowStatus or Dialog.ShowParamStatus. For example, the following notifier indicates a command button's function to the user:
PROCEDURE ButtonNotifier* (op, from, to: LONGINT);
BEGIN
IF op = Dialog.pressed THEN
Dialog.ShowStatus("This button causes the disk to spin down")
ELSIF op = Dialog.released THEN
Dialog.ShowStatus("") (* clear the status message again *)
END
END ButtonNotifier;
Listing 4-34. Notifier displaying status messages
On some platforms, e.g., on Mac OS, there is no status area and the above code has no effect.
Sometimes it is useful to detect double-clicks, e.g., a double-click in a list box may select the item and invoke the default button. A double-click can be detected in a notifier with the test
IF (op = Dialog.pressed) & (from = 1) THEN ... (* double-click *)
For the above-mentioned case, where the reaction on a double-click should merely be the invocation of the default button, a suitable standard notifier is available:
StdCmds.DefaultOnDoubleClick
We have seen earlier that the BlackBox Component Builder provides a string mapping facility which maps keys to actual strings, by using resource files. This feature is also supported by Dialog.ShowStatus. In fact, string mapping even allows to use place holders. For example, calling
Dialog.ShowParamStatus("This ^0 causes the ^1 to ^2", control, object, verb)
allows to supply different strings for the place holders ^0, ^1 and ^2. The strings actually used are the three additional parameters control, object and verb. Note that these strings are mapped themselves before being spliced into the first string. String mapping is a feature that you can use explicitly by calling the procedure Dialog.MapParamString.
4.7 Complex controls and interactors
A list box has two kinds of contents: the string items which make up the list, and the current selection. Typically, the item list is more persistent than the selection, but it too may be changed while the control is being used. For list and selection boxes, the application is not so much interested in the item list, since this list is only a hint for the user. The application is interested in the selection that the user creates. For a list box, the selection is defined by the index of the selected item. For a selection box, the selection is defined by the set of indices of selected items. For combo boxes, the relevant state is not a selection, but the string that was entered.
For all three box controls, the item list must be built up somehow. For this purpose, module Dialog defines suitable interactor types: Dialog.List for list boxes, Dialog.Selection for selection boxes, and Dialog.Combo for combo boxes. These types are defined the following way:
List = RECORD
index: INTEGER; (* index of currently selected item *)
len-: INTEGER; (* number of list elements *)
PROCEDURE (VAR l: List) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR l: List) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR l: List) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR l: List) SetResources (IN key: ARRAY OF CHAR), NEW
END;
Selection = RECORD
len-: INTEGER; (* number of selection elements *)
PROCEDURE (VAR s: Selection) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR s: Selection) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR s: Selection) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR s: Selection) SetResources (IN key: ARRAY OF CHAR), NEW;
PROCEDURE (VAR s: Selection) Incl (from, to: INTEGER), NEW;
(* select range [from..to] *)
PROCEDURE (VAR s: Selection) Excl (from, to: INTEGER), NEW;
(* deselect range [from..to] *)
PROCEDURE (VAR s: Selection) In (index: INTEGER): BOOLEAN, NEW
(* test whether index-th item is selected *)
END;
Combo = RECORD
item: String; (* currently entered or selected string *)
len-: INTEGER; (* number of combo elements *)
PROCEDURE (VAR c: Combo) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR c: Combo) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR c: Combo) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR c: Combo) SetResources (IN key: ARRAY OF CHAR), NEW
END;
Listing 4-35. Definitions of List, Selection and Combo
Before a variable of one of these types can be used, it must be initialized by first defining the individual items. During use, items can be changed. For example, the following code fragment builds up a list:
list.SetLen(5); (* define length of list *)
list.SetItem(0, "Daffy Duck");
list.SetItem(1, "Wile E. Coyote");
list.SetItem(2, "Scrooge Mc Duck");
list.SetItem(3, "Huey Lewis");
list.SetItem(4, "Thomas Dewey");
Dialog.UpdateList(list); (* must be called after any change(s) to the item list *)
Listing 4-36. Setting up a list explicitly
When used with list-structured controls (list, selection, or combo boxes), Dialog.Update only updates the selection or text entry state of these controls, but not the list structure. If the list structure, i.e., the elements of the control's list, is changed, then the procedure Dialog.UpdateList must be called instead of Dialog.Update.
For fixed item lists, the individual strings should be stored in resources. This is simplified by the SetResources procedures. They look up the strings in a resource file. For example, the above statements can be replaced completely by the statement
list.SetResources("#Obx:list")
which will read the Obx/Rsrc/Strings file and look for strings with keys of the kind "list[index]", e.g., for
list[0] Daffy Duck
list[1] Wile E. Coyote
list[2] Scrooge Mc Duck
list[3] Huey Lewis
list[4] Thomas Dewey
Table 4-37. Resources for a list
The indices must start from 0 and be consecutive (no holes allowed).
Procedure SetLen is optional. Its use is recommended wherever the number of list items is known in advance. If this is not the case, it may be omitted. The list will become as large as the largest index requires.
SetLen is necessary if an existing item list should be shortened, or if it should be cleared completely.
4.8 Input validation
Validity checks are an important, and for the uninitiated sometimes a surprising, aspect of non-modal user interfaces. Among other things, non-modality also means that the user must not be forced into a mode depending on where the caret currently is and whether or not the entered data is currently valid. In particular, a user must not be forced to correctly enter some data into a field before permitting him or her to do something else.
This basically leaves two strategies for checking the validity of entered data: early or late. Early checks are performed whenever the user has manipulated a control. Late checks are performed when the user has completed input and wants to perform some action, e.g., entering the new data into a database.
Late checks are most suitable for checking global invariants, e.g., whether all necessary fields in the input mask contain some input. Early checks are most suitable for local, control-specific invariants, e.g., the correct syntax of an entered string.
We give examples of both early and late checks for our module ObxPhoneUI. Let us assume that a phone number always has the following form: 310-555-1212. For a late check, we extend the Lookup procedure (boldface text) and add a few auxiliary procedures. Note the use of the "$" operator, which makes sure the LEN function returns the length of the string, not of the array containing the string.
PROCEDURE Valid (IN s: ARRAY OF CHAR): BOOLEAN;
PROCEDURE Digits (IN s: ARRAY OF CHAR; from, to: INTEGER): BOOLEAN;
BEGIN (* check whether range [from..to] in s consists of digits only *)
WHILE (from <= to) & (s[from] >= "0") & (s[from] <= "9") DO INC(from) END;
RETURN from > to (* no non-digit found in checked range *)
END Digits;
BEGIN (* check syntax of phone number *)
RETURN (LEN(s$) = 12) & Digits(s, 0, 2) & (s[3] = "-") & Digits(s, 4, 6) &
(s[7] = "-") & Digits(s, 8, 11)
END Valid;
PROCEDURE ShowErrorMessage;
BEGIN
phone.name := "illegal syntax of number"
END ShowErrorMessage;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
IF Valid(phone.number) THEN
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
ELSE
ShowErrorMessage
END
END;
Dialog.Update(phone)
END Lookup;
Listing 4-38. Late check for input validation
A more rude reminder would be to display an error message. If the BlackBox Component Builder's log window is open, the message is written to the log and the window is brought to the top if necessary. If no log is used, a dialog box is displayed. This behavior can be achieved by replacing the statement in procedure ShowErrorMessage by the following statement:
Dialog.ShowMsg("Please correct the phone number")
Now we look at an early checked alternative to the above solution to input checking. It uses a notifier to check after each character typed into the phone number field whether the number is legal so far. In contrast to the late check, it must be able to deal with partially entered phone numbers. Whenever an illegal suffix is detected, the string is simply clipped to the legal prefix.
PROCEDURE Correct (VAR s: ObxPhoneDB.String);
PROCEDURE CheckMinus (VAR s: ObxPhoneDB.String; at: INTEGER);
BEGIN
IF s[at] # "-" THEN s[at] := 0X END (* clip string *)
END CheckMinus;
PROCEDURE CheckDigits (VAR s: ARRAY OF CHAR; from, to: INTEGER);
BEGIN
WHILE from <= to DO
IF (s[from] < "0") OR (s[from] > "9") THEN
s[from] := 0X; from := to (* clip string and terminate loop *)
END;
INC(from)
END
END CheckDigits;
BEGIN (* clip string to a legal prefix if necessary *)
CheckDigits(s, 0, 2);
CheckMinus(s, 3);
CheckDigits(s, 4, 6);
CheckMinus(s, 7);
CheckDigits(s, 8, 11)
END Correct;
PROCEDURE NumberNotifier (op, from, to: INTEGER);
BEGIN
Correct(phone.number)
(* Dialog.Update is not called, because it will be called afterwards by the notifying control *)
END NumberNotifier;
Listing 4-39. Early check for input validation
Note that a focused view, e.g. a control, has no means to prevent the user from focusing another view. A view may merely change the way that it displays itself, its contents, or its marks (selection, caret). For this purpose, a view receives a Controllers.MarkMsg when the focus changes.
4.9 Accessing controls explicitly
In most circumstances, guards and notifiers allow sufficient control over a control's specific look & feel. However, sometimes you may want to exercise direct control over a control in a form. How to do this is described in this section. For example, assume that you want to write your own special alignment command, and add it to the commands of the Layout menu. To do this, you need to get access to the form view in the window that is currently being edited. The form view is a container that contains the controls that you want to manipulate. The function FormControllers.Focus delivers a handle on the currently focused form editor. This leads to the typical code pattern for accessing a form (Listing 4-40):
VAR c: FormControllers.Controller;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
...
Listing 4-40. Accessing a form's controller
A form contains controls and possibly some other types of views. The views can be edited if the enclosing form view is in layout mode. Typically, some views are selected first, and then a command is executed that operates on the selected views. The following example shifts every selected view to the right by one centimeter (Listing 4-41):
MODULE ObxControlShifter;
IMPORT Ports, Views, FormModels, FormControllers;
PROCEDURE Shift*;
VAR c: FormControllers.Controller; sel: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
sel := c.GetSelection(); (* generates a list with references to the selected views *)
WHILE sel # NIL DO
c.form.Move(sel.view, 10 * Ports.mm, 0); (* move to the right *)
sel := sel.next
END
END
END Shift;
END ObxControlShifter.
Listing 4-41. Shift all selected views to the right
This code works on selected views (whether they are controls or not). Sometimes you may want to manipulate views that are not selected. In this case, you need a form reader (FormModels.Reader) to iterate over the views in the currently focused form. The following code pattern shows how a command can iterate over the views of a form (Listing 4-42):
VAR c: FormControllers.Controller; rd: FormModels.Reader;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* read first view *)
WHILE v # NIL DO
...
rd.ReadView(v) (* read next view *)
END;
...
Listing 4-42. Iterating over the selected views in a form
Controls are special views (of type Controls.Control). Controls can be linked to global variables. The following example shows how the labels of all controls in a form can be listed (Listing 4-43):
MODULE ObxLabelLister;
IMPORT Views, Controls, FormModels, FormControllers, StdLog;
PROCEDURE List*;
VAR c: FormControllers.Controller; rd: FormModels.Reader; v: Views.View;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* read first view *)
WHILE v # NIL DO
IF v IS Controls.Control THEN
StdLog.String(v(Controls.Control).label); StdLog.Ln
END;
rd.ReadView(v) (* read next view *)
END
END
END List;
END ObxLabelLister.
Listing 4-43. Listing the labels of all controls in a form
With the same kind of iteration, any other type of view could be found in forms as well, not only controls. For example, consider that you have a form with a "Clear" command button that causes a plotter view in the same form to be cleared. The command button is a standard control, the plotter view is your special view type. The command associated with the command button first needs to search for its plotter view, in the same form where the button is placed. The code pattern shown below demonstrates how such a command can be implemented (Listing 4-44):
VAR c: FormControllers.Controller; rd: FormModels.Reader; v: Views.View;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* read first view *)
WHILE v # NIL DO
IF v IS MyPlotterView THEN
(* clear v(MyPlotterView) *)
END;
rd.ReadView(v) (* read next view *)
END
END
Listing 4-44. Finding a particular view in a form
There is one potential problem with the above code pattern. Let us assume that we have a dialog box containing a command button with ObxLabelLister.List as associated command. Beneath the dialog box, we have a window with a focused form layout. Now, if you click on the dialog box' command button, which labels are listed? The ones in the form of the dialog box itself, or the ones in the focused form layout underneath? In other words: does FormControllers.Focus yield the form that contains the button you clicked on, or the form focused for editing? Depending on what the button's command does, both versions could make sense. For a form editing command like ObxControlShifter.Shift, the focused layout editor should be returned. This is the top-most document window, but it is overlaid by the dialog box window. In contrast, if you want to find your plotter view, the form of the dialog box should be returned instead. In this case, you want to search the direct "neighborhood" of the button.
One solution for the plotter view search would be to start searching in the context of the button that is currently being pressed. This can be done using the following code pattern (Listing 4-45):
VAR button: Controls.Control; m: Models.Model; rd: FormModels.Reader; v: Views.View;
BEGIN
button := Controls.par; (* during the button click, this variable contains a reference to the button *)
m := button.context.ThisModel(); (* get the model of the container view that contains the button *)
IF m IS FormModels.Model THEN (* the container is a form *)
rd := m(FormModels.Model).NewReader(NIL);
rd.ReadView(v); (* read first view *)
WHILE v # NIL DO
IF v IS MyPlotterView THEN
(* clear v(MyPlotterView) *)
END;
rd.ReadView(v) (* read next view *)
END
END
Listing 4-45. Finding a particular view in the same form as a button
This code assumes that the command is executed from a command button. It doesn't work if placed in a menu. In order to better decouple the user interface and the application logic, this assumption should be eliminated. BlackBox solves the problem by giving the programmer explicit control over the behavior of FormControllers.Focus. The trick is that BlackBox supports two kind of windows for dialog boxes: tool windows and auxiliary windows, in addition to the normal document windows. If the command button is in a tool window dialog box, then FormControllers.Focus yields the form in the top-most document window, or NIL if there is no such document window or if the focus of the top-most document window is not a form view. If the command button is in an auxiliary window, then FormControllers.Focus yields the dialog box' form whose command button you have clicked. The following paragraphs further explain the differences between these two kinds of windows.
Dialog boxes in tool windows are not self-contained, they provide the parameters and the control panel for an operation on a document underneath. A typical example is the "Find / Replace" dialog box that operates on a text document underneath. The command buttons in a tool dialog box invoke a command, and this command fetches the view on which it operates. In the "Find / Replace" example, this is the focused text view. Under Windows, tool windows always lie above the topmost document window; i.e., they can never be overlapped by document windows or auxiliary windows, only by other tool windows. Unlike other windows, tool windows cannot be resized or iconized, but can me moved outside of the application window. On Mac OS, tool windows look and behave like document windows, except that they have no scroll bars and cannot be resized or zoomed.
An auxiliary window on the other hand is self-contained. It contains, and operates on, its own data. At least, it knows where to find the data on which to operate (e.g., in a database). The "Phone Database" dialog box is a typical auxiliary window, like most data-entry forms. Auxiliary windows can be manipulated like normal document windows; in particular, the may be overlapped by other document or auxiliary windows.
Both kinds of dialog boxes are stored as documents in their appropriate RSRC directories. But to open them, module StdCmds provides two separate commands: OpenToolDialog and OpenAuxDialog. Both of them take a portable path name of the resource document as first parameter, and the title of the dialog box window as a second parameter. For example, the following menu commands may be used:
"Find / Replace..." "" "StdCmds.OpenToolDialog('Text/Rsrc/Cmds', 'Find / Replace')" ""
"Phone Database..." "" "StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phone Database')" ""
The function FormControllers.Focus returns different results, depending on whether the form is in a tool or in an auxiliary window.
For more examples on how forms can be manipulated, see also module FormCmds. It is available in source form, like the rest of the Form subsystem.
4.10 Summary
In this chapter, we have discussed the important aspects of how a graphical user interface and its supporting code is implemented in the BlackBox Component Builder. There are three parts of an application: application logic, user interface logic, and user interface resources, i.e., documents. A clean separation of these parts makes a program easier to understand, maintain, and extend.
For more examples of how the form system and controls can be used, see the on-line examples ObxAddress0, ObxAddress1, ObxAddress2, ObxOrders, ObxControls, ObxDialog, and ObxUnitConv. For advanced programmers, the sources of the complete Form subsystem may be interesting.
For more information on how to use the BlackBox development environment, consult the documentation of the following modules:
DevCompiler, DevDebug, DevBrowser, DevInspector, DevReferences,
DevMarkers, DevCmds, StdCmds, StdMenuTool, StdLog, FormCmds, TextCmds
To obtain more information on a module, select a module name and then invoke Info->Documentation.
In order to provide a straight-forward description, we only used the most important commands in this book. However, there are other useful commands in the menus Info, Dev, Controls, Tools, and Layout. For example, there are several "wizards" for the creation of new source code skeletons. Consult the files System/Docu/User-Man, Text/Docu/User-Man, Form/Docu/User-Man, and Dev/Docu/User-Man for a comprehensive user manual on how to use the framework, the editor (Text subsystem), the visual designer (Form subsystem), and the development tools (Dev subsystem).
| Docu/Tut-4.odc |