WO2001095108A1

WO2001095108A1 - System for program source code conversion

Info

Publication number: WO2001095108A1
Application number: PCT/AU2001/000685
Authority: WO
Inventors: Benedict Bede Mcnamara
Original assignee: Educational And Computing Software Pty Ltd
Priority date: 2000-06-09
Filing date: 2001-06-08
Publication date: 2001-12-13
Also published as: AUPQ811500A0

Abstract

A computer system/program (10) for converting at least keywords in a program source code. The system/program (10) has a program source code conversion means (12) for converting C/C++ source codes including C/C++ keywords written in a non-English language such as French or Spanish into a form that can be compiled by a standard compiler, storage means (20) storing English keywords of C/C++ and words in at least one other natural language corresponding to said keywords, and program code conversion for converting keywords and other words written in one natural language into a target code in another natural language. The system/program (10) can be in the form of a compiler or incorporated into a computer operating system so that the natural language for the system interface can be selected.

Description

SYSTEM FOR PROGRAM SOURCE CODE CONVERSION

TECHNICAL FIELD OF THE INVENTION THIS invention relates to a computer system/program for converting a program source code written in one natural language to a target code in another natural language.

This invention also relates to a compiler program adapted for compiling source codes written in a non-English language.

This invention further relates to a computer operating system software having conversion means for converting a natural language for operating system interface whereby the natural language for the operating system interface can be selected from any of a plurality of natural languages.

BACKGROUND OF THE INVENTION Computer program developments generally involve writing a source code in a high level programming language and translating the source code into a machine code that can be run in a computer system.

Programmers prefer to write program source codes in a high level computer language as they can write the code statements and instructions in a natural language-like structure which allow them to easily write and if required debug the codes. "C", "C+ + ", Pascal, Basic, COBOL and Fortran are examples of the high level languages.

Compilers are computer programs which translate program source codes into machine instructions, generally called machine code, which the computer system can understand and execute.

High level programming languages have a set of keywords which cannot be redefined in source codes. This is so that the compilers can translate them into appropriate machine instructions. As the compilers are developed in English speaking countries all the keywords are English based. Accordingly programmers must use the English based keywords irrespective of the natural languages in which the source codes are written. Efficiency in developing program codes by non English speaking programmers is therefore hindered by the burden of having to use English based words which they are not familiar with. Many of these programmers also have to learn English so that they can understand the functions and purposes of the keywords.

The need to use the English based keywords also prevent automatic translation of source codes from one natural language to another natural language. Compilers are difficult to write. It is therefore not practical to provide them for every natural language.

While conversion of source codes can be done manually, it is time consuming and therefore costly. It is also prone to error. Computer operating systems such as Windows^® are generally written in C or

C+ + programming language and they have hundreds of thousands and even millions of lines of source codes written in English. Translation of the source codes for the operating systems to present non-English interface is a very complex and difficult task. Accordingly, non-English operating systems are produced a long time after their corresponding English operating systems are marketed.

OBIECT OF THE INVENTION It is an object of the present invention to alleviate or to reduce to a certain level one or more of the prior art disadvantages.

SUMMARY OF THE INVENTION In one aspect therefor the present invention resides in a computer system for converting at least keywords in a program source code. The system/program comprises storage means adapted to store keywords of at least one programming language, the keywords being nominally used for programming source codes written in one natural language, and words in at least one other natural language corresponding to said keywords, and program code conversion means adapter to access said storage means for converting keywords or corresponding words in a program source code written in said one natural language or one of said at least one other language to corresponding words or keywords as stored in the storage means into a target code in another natural language. In another aspect therefor the present invention resides in a computer program for converting at least keywords in a program source code. The software comprises storing means adapted to store in a storage means keywords of at least one programming language nominally used for programming source codes in one natural language and words in at least one other natural language corresponding to said keywords, and program code conversion means adapter to access said storage means for converting keywords or corresponding words in a program source code written in said one natural language or one of said at least one other natural language to corresponding words or keywords as stored in the storage means into a target code in another natural language.

In a further aspect therefor the present invention resides in a computer operating system comprising interface language selection means adapted for selecting one from a plurality of natural languages for presenting system interface, storing means adapted to store keywords of the programming language used for programming the operating system source codes in one natural language and words in at least one other natural language corresponding to said keywords, and program code conversion means adapter to access said storage means for converting keywords or corresponding words in a program source code written in said one natural language or one of said at least one other natural language to corresponding words or keywords as stored in the storage means into a target code in another natural language selected for the interface. In preference said storage means includes corresponding words in a plurality of other natural languages and the system further comprises a language selection means for selectively choosing the natural language of the target code. The language selection means may be arranged to automatically detect the natural language in which the source code is written, or provided with a source code language selection arrangement for choosing the natural language of the source code.

Advantageously the storage means includes a primary database containing the keywords and the corresponding words in said plurality of other natural languages, and a secondary database containing the keywords and the corresponding words in the chosen one said other natural languages. The code conversion means is adapted to access the secondary database for conversion of the keywords to corresponding words in the chosen natural language.

The storage means can also include a user defined database containing user provided words in one natural language and corresponding words in one or more other natural languages.

The program code conversion means may include a character replacement arrangement for replacing characters and/or signs in the target code which are unrecognisable by the programming language to ones which are recognised. Said unrecognisable characters and/or signs may accented letters and/or specific signs in a natural language. For example, in French the letters "e", "e", and "e" may be replaced by "e".

Preferably the conversion means further includes a translator for translating words and/or signs other than the keywords and/or user defined words in the source code into one of said other natural languages. The invention can thus be used not only to convert the keywords but also to translate all other words and/or signs in a program code to another natural language.

The invention of the present invention allows program source codes including keywords of a programming language written in any natural language to be converted into a target code in another natural language in a manner that the target code a compilable by a compiler program into a machine code.

In a further aspect therefor the present invention resides in a compiler for program codes. The compiler comprises the system/software as hereinbefore described.

In a preferred form, the invention defines a set of interfaces for conversion and compilation of a program written in a programming language such as C+ + or Windows'⁹ into various natural (spoken) languages. Hereafter, the suite of C+ + language compilers that are defined by the invention, will be referred to as the language D. Additionally, D extends the Windows operating system into any of the target spoken languages. The keywords of the C+ + language are defined in English. The language

D retains the English keywords when programming in English, but provides the keywords for expressing the same in any of a set of different spoken languages (see Appendix A). The D is executable and automatically converts the keywords of any given D program between spoken languages, and provides a facility for extending the conversion to cover any program variables within the source. D may be used to define native compilers for languages other than English, using the source code of an existing English C+ + compiler. Furthermore, D is symmetric in the sense that a native D Language compiler is capable of processing code from certain other language components (when only the keywords have been transformed). This can be done without actually translating the entire program. Apart from altering the language keywords, the extension of C+ + to D requires that the definition program identifiers be altered for each language component. In the case of some European languages, this modification includes accented characters from the standard ANSI code page (the same code page algorithm works for Spanish, Italian, French and German). In C+ + , an identifier is an arbitrarily long sequence of letters, digits and the character '_'. The first character of an identifier must begin with a letter or '_'. In C+ +, a letter is defined to be an element of the set {a,b,c...,z,A,B,C,...,Z}. Identifiers in the previously mentioned, European D language components include accented characters such as: a, e and ζ. The Vietnamese character set has a great variety of accents and requires a completely different algorithm for determining whether a character is an accented alphabetic character.

As well as the single byte D language components that have been already substantially developed, 3000 translations in Chinese (double byte) have been performed. The D language converter can also define the standard for programming C+ + and Windows in Chinese. Accordingly, the invention can extend to native double-byte Chinese D compilers, and to native Arabic D compilers.

The programming interface for the Windows Operating Systems is in C and is referred to as Win32. The D converter provides transformations that define an operating system programming interface in languages other than English (for example, Spanish and Italian). By virtue of the fact t at C is a subset of C+ +, any non-English D language component has an equivalent C subset embedded within. This implies that the Engl ish Win32 interface maps to an equivalent C operating system interface in the target language component (for example, Spanish, in which case the transformed Win32 C interface is called Ven32). The same transformations that map the operating system interface also map application code written to that operating system standard. Additionally, the D converter may be applied to the source code of the operating system itself to produce the source code of an equivalent operating system in a target language. When multiple operating systems result, the converter may later be modified so that it can be applied to executable code (rather than source code - although, that process is presently compiler dependent). This implies that D may be used to generate a suite of Windows Operating Systems that are convertible both at the source code level and at the executable level (.exe & .dll).

BRIEF DESCRIPTION OR THE DRAWINGS In order that the present invention can be more readily understood and be put into practical effect reference will now be made to the accompanying drawings which illustrate embodiments of the present invention and wherein:-

Figure 1 is a flow diagram showing certain elements in a C/C+ + source code conversion system according to the present invention; and

Figures 2 is a drawing showing a window interface on a computer system and the window is created according to a computer program the source code of which is attached as Annex 2.

Figure 3 is a French version of the window interface shown in Figure 2; and Figure 4 is a Spanish version of the window interface shown in Figure 2. DETAILED DESCRIPTION OF THE INVENTION Referring to Figure 1 there is shown a C/C+ + program source code conversion system 10 according to the present invention. The system 10 has a program source code conversion means 12 which in this case is adapted for converting C/C+ + source codes including C/C+ + keywords written in French or Spanish into a form that can be compiled by a standard compiler for a computer system running under DOS or Windows operating system. The system 10 also has a target language selector 14 which is arranged to allow selection of converting a program source code 16 written in one of English, French and Spanish into another one of English, French and Spanish for a target source code 18. Once the natural language of the desired target code is selected the system

10 interrogates a primary conversion table 20 stored in a storage means (hard disk). The table 20 has corresponding keywords in English, French and Spanish. The keywords include interfaces of the operating system, C/C+ + keywords (including preprocessor keywords), C/C+ + application programming interfaces (C/C+ + APIs), Windows APIs, C/C+ + constants, operating system constants, and the like.

The system 10 extracts the corresponding keywords for the source and target natural languages from the primary table into a smaller working database 22. The working database 22 allows a relatively faster access speed for the conversion means 12. The conversion means 12 also interrogates a user defined database 24 in which a user can set up specific corresponding words in different natural languages.

The database 24 thus allow the user to have a high degree of flexibility in determining how non keywords are to be translated between different languages.

The system 10 then creates a target code for the source code, with all words and/or signs in the source code that appear in the database 22 and the database 24 converted to the corresponding words and/or signs in the target natural language. All other words in the source code can be left unchanged when creating the target code, or be automatically translated by a language translator.

The target code is compilable by a compiler unless it has accented letters. Where the target code is in a language that has accented letters the system

10 has a further conversion process which flatten the target code by replacing the accented letters with corresponding letters in the standard ASCII character set.

For non English target codes the system 10 converts the keywords therein to English form so that the codes are compilable. Annexl shows a listing of the core C+ + keywords in the first column and the corresponding words in French, Spanish, and German in columns two, three and four respectively. C+ + programmers can write program codes using corresponding keywords in French, Spanish or German as shown in the listing. For compiling the system 10 of the present invention is used to convert the corresponding keywords into English while keeping other words unchanged. Accordingly non English programmers need not have to learn English in order to code programs or use the unfamiliar English keywords in their program codes.

It should be noted the four natural languages shown are examples only. The system of the present invention can have considerably more languages including those that use double byte character sets in their writings. Chinese and Japanese are examples of the languages that use double byte character sets.

D defines a 2 dimensional matrix that encapsulates both the C+ + language and Windows. The matrix at the heart of D is transformations for the definition of non-English Systems. Appendix B lists some examples of the transformations which illustrate certain transformations forthe definition ofthe Spanish and Italian Systems (which in turn contain Ven32 and Fin32- the C Operating System Interface of D). The C+ + and D keywords are embedded within the transformation definitions (see Appendix B for some examples) as well being separately listed in Appendix A. Thus, a column within the Matrix simultaneously defines the D language interface and the Operating System Interface. When the substitutions within a column are assembled to form the Interface, the resultant operating system definition appears in the D Language. Appendix C contains a portion of Ven32 in Spanish. A sample D, C application in Spanish is shown in Appendix D. The code found in appendixDI and appendixD2 was generated by the D translator from the code in appendixD3 (which conforms to the Win32 standard). The application code samples have a direct 1-1 correspondence.

This is true for translated code that originally conformed to the Win32 interface.

For a particular target language, D presents a primary operating system interface (which is the non-English equivalent of C+ +), as well as a secondary C- equivalent interface (Appendix C). Appendix C contains only function declarations - not the data types. The operating system data types are defined predominantly in D. The header files defining these data types are presented in the Spanish language.

Programs may be written to the C standard or to the newer standard that D contains. As previously mentioned, the production of native D compilers is possible in languages other than English. Presently only English C+ + compilers are available; however, the techniques of compilation of non-English code with an

English C+ + compiler apply symmetrical ly to other languages that share the ANSI character set (e.g. an Italian D compiler can be used to compile Spanish code, after keyword replacement has been performed).

The technique for compiling Spanish D code with an English C+ + compiler is illustrated via a program that draws an arc in a window. The D source for the program is contained in the files arco.hpt and arco.cpt. These files are unable to be compiled with an English C+ + compiler; although, they would be directly compilable using a native Spanish D compiler. To compile the application using

English C+ +, the program must be modified in two ways: 1 ) keywords are replaced (see Appendix A) and

2) accents are removed. The second of these operations is avoidable by incorporating accents into the English definition of C+ +. The resultant code is contained in the files arco.hpp and arco.cpp, and it is capable of being compiled with an English C+ + compiler. The D code contained in arco.hpt and arco.cpt is transformable, whereas the modified code is not (transformations are defined with accents included). The corresponding, transformed, Italian D code has also been included, and like the

Spanish, it may be processed for compilation with an English C+ + compiler.

Sample - Italian File arco.cpp

// Copyright (c) Educational & Computing Software Pty Ltd 1989-2001

// Archivio: arco.cpp

#define includereFin32

#include < Finestre.hpp > #include "arco.hpp" #include "arco.h"

#define stringaDinamicaMassimo 80

extern "C" int standardChiamare WinMain(manico manicoCaso, manico manicoPrecedente, char* pcharacterCommandLine, int numeroMostrareComando) { int interoRisultato = 0; try

{

RegistrareClasse(informazioneDiClasse(interoARisorsa(identitaDiMenu), (manico)icona(iconaApplicazione),

(manico)cursore(cursoreFreccia), pennello(stileDiPennelloSolido,pennelIoBianco)));

c I i e n t e finestraPrincipale(stringaDinamica(stringaDinamicaMassimo,stringaDinamicaTito lo));

finestraPrincipale < < mostrare(numeroMostrareComando); finestraPrincipale < < aggiornare;

acceleratore acceleratorePrincipale(interoARisorsa(identitaDiMenu));

fila filaPrincipale; interoRisultato = filaPrincipale.Cappio(acceleratorePrincipale, finestraPrincipale);

} catch (eccezioneFinestre& eccezionePrenduto)

{eccezionePrenduto.Mostrare(stringaDinamica(stringaDinamicaMassimo,stringa DinamicaErrore));}

return interoRisultato; }

Irisultato cliente::msgComando(parola parolaldentita, parola parolaNotificare, manico manicoControllo)

{ switch(parolaldentita)

{ case articoloDiMenuSmettere: if (EsporreScatolaDiMessagio(manicoFinestra, stringaDinamica(stringaDinamicaMassimo,stringaDinamicaSmettere), stringaDinamica(stringaDinamicaMassimo,stringaDinamicaFinestre), stilelconaDomanda | stileSiNon) = = articoloSi)

ImpostareMessagioSmettereO; break;

} return 0; }

Irisultato cliente::msgDistruggere() {ImpostareMessagioSmettereO; return 0;}

Irisultato cliente::msgDipingere() { dispositivo dispositivoDisegnare(*this,(pittura*)0);

arco arcoADisegnare( rettangolo(punto(100,100), punto(300,300)), punto(200,300), punto(300,200) );

dispositivoDisegnare < < punto(200,200)

< < arcoADisegnare < < punto(50,50)

< < matrice(.25,0,0,.25) * arcoADisegnare;

return 0;

} ^' File arco.cpt

#definire includereFin32 #includere <Finestre.hpp>

#includere "arco.hpp" #includere "arco.h"

#definire stringaDinamicaMassimo 80

esterno "C" intero standardChiamare FinestraPrincipale(manico manicoCaso, manico manicoPrecedente, carattere* pcharacterCommandLine, intero numeroMostrareCo ando) { intero interoRisultato=0; provare

{ RegistrareClasse(informazioneDiClasse(interoARisorsa(identitαDiMenu),

(manico)icona(iconaApplicazione),

(manico)cursore(cursoreFreccia), pennello(stileDiPennelloSolido,pennelloBianco)));

c 1 i e n t e finestraPrincipale(stringaDinamica(stringaDinamicaMassimo,stringaDinamicaTitolo));

finestraPrincipale « mostrare(numeroMostrareComando); finestraPrincipale « aggiornare;

acceleratore acceleratorePrincipale(interoARisorsa(identitαDiMenu));

fila filaPrincipale; interoRisultato = filaPrincipale. Cappio(acceleratorePrincipale, finestraPrincipale);

} prendere (eccezioneFinestre& eccezionePrenduto)

{eccezionePrenduto.Mostrare(stringaDinamica(stringaDinamicaMassimo,stringaDina micaErrore));}

ritornare interoRisultato; }

Irisultato cliente: :msgComando(parola parolaldentitα, parola parolaNotificare, manico manicoControllo)

{ selezionare(parolaIdentitα)

{ caso articoloDiMenuSmettere: se (EsporreScatolaDiMessagio(manicoFinestra, stringaDinamica(stringaDinamicaMassimo,stringaDinamicaSmettere), stringaDinamica(stringaDinamicaMassimo,stringaDinamicaFinestre), stilelconaDomanda | stileSiNon) == articoloSi)

ImpostareMessagioSmettereO; rompere;

} ritornare 0; }

Irisultato cliente: :msgDistruggere() {ImpostareMessagioSmettereO; ritornare 0;}

Irisultato cliente: :msgDipingereO

{ dispositivo dispositivoDisegnare(*questo,(pittura*)0);

dispositivoDisegnare « punto(200,200) « arcoADisegnare

« punto(50,50) « matrice(.25,0,0,.25) * arcoADisegnare;

ritornare 0; }

File arco.h

// Copyright (c) Educational & Computing Software Pty Ltd 1989-2000

// Archivio: arco.h (Resource Identities)

#define identitaDiMenu 100

#define articoloDiMenuSmettere 101 #define articoloDiMenuRicominciare 102

#define stringaDinamicaTitolo 1 #define stringaDinamicaSmettere 2 #define stringaDinamicaFinestre 3 #define stringaDinamicaErrore 4

#define controlOk 1

File arco.hpp

class cliente : public finestra

{ public:

cliente(const char* pcharacterTitle) : finestra(cppClasseDefault,pcharacterTitle,stileStandard) {}

Irisultato msgComando(parola parolaldentita, parola parolaNotificare, manico manicoControllo);

Irisultato msgDistruggereO;

Irisultato msgDipingereO; };

File arco.hpt

classe cliente : pubblico finestra

{ pubblico:

cliente(const carattere* pcharacterTitle)

: finestra(cppClasseDefault,pcharacterTitle,stileStandard) {}

Irisultato msgDistruggereO;

Irisultato msgDipingereO; File arco.rc

// Archivo: arco.rc (Application Resource Archivo)

#include "arco.h" #include "windows.h"

identitaDiMenu MENU {

POPUP "&Archivo"

{

MENUITEM "&Smettere",articoloDiMenuSmettere

MENUITEM SEPARATOR MENUITEM "&Ricominciare",articoloDiMenuRicominciare

} }

identitaDiMenu ACCELERATORS {

VK F3, articoloDiMenuSmettere, VIRTKEY "s", articoloDiMenuSmettere, ALT "S", articoloDiMenuSmettere, ALT

}

STRINGTABLE PRELOAD

{ stringaDinamicaFinestre "Finestre++" stringaDinamicaTitolo "clase arco" stringaDinamicaSmettere "Smettere ?" stringaDinamicaErrore "Smettere fil!" }

File make.bcc

WinStart = \Borland\Lib\c0w32.obj

Bcclmplib = \Borland\bin\implib LibSearch = \ipp\lib;\Borland\lib

I n c = \Borland\include;\ipp\inc\ita;\ipp\exc\ita;\ipp\utl\ita;\ipp\bse\ita;\ipp\win\ita;\ipp\gdi\ita;

CFlags = -D_RTLDLL -b -w-par -v- -WM -c -I$(Inc) LFlags = /Gn /m /x /c /L$(LibSearch) /s /Oc /Tpe

Libs = cw32mti import32 BExcI BBsel BGdil BFinl

.rc.res: brcc32 -v -w32 -i$(Inc) $*.rc

.cpp.obj: bcc32 $(CFlags) $*.cpp

def = WinExe.def

arco.exe: $*.obj $*.res $(def) ilink32 $(LFlags) $(WinStart) $*.obj, $*.exe, $*.unite, $(Libs), $(def), $*.res

arco.obj: $*.cpp $*.hpp

arco.cpp: $*.cpt copy $*.cpt $*.cpp flatten 3 $*.cpp

arco.hpp: $*.hpt copy $*.hρt $*.hpp flatten 3 $*.hpp

arco.res: $*.rc $*.h

Sample - Spanish File arco.cpp

#define incluirNen32

#include <Nentanas.hpp>

#include "arco.hpp" #include "arco.h"

#define secuenciaDinamicaMaximo 80

extern "C" int estandarLlamar WinMain(asidero asiderolnstancia, asidero asideroAnterior, char* pcharacterCommandLine, int numeroMostrarComando)

{ int enteroResultado=0; try {

RegistrarClase(informacionDeClase(enteroARecurso(identidadDeMenu), (asidero)icono(iconoAplicacion),

(asidero)cursor(cursorFlecha), pincel(estiloDePincelContinuo,pincelBlanco)));

c l i e n t e ventanaPrincipal(secuenciaDinamica(secuenciaDinamicaMaximo,secuenciaDinamica Titulo));

ventanaPrincipal « mostrar(numeroMostrarComando); ventanaPrincipal « actualizar;

acelerador aceleradorPrincipal(enteroARecurso(identidadDeMenu));

fila filaPrincipal; enteroResultado = filaPrincipal.Bucle(aceleradorPrincipal, ventanaPrincipal);

} catch (excepcionDeNentanas& excepcionAtrapado)

{excepcionAtrapado.Mostrar(secuenciaDinamica(secuenciaDinamicaMaximo,secuenc iaDinamicaError)); }

return enteroResultado;

}

lresultado cliente::msjComando(palabra palabraldentidad, palabra palabraNotificar, asidero asidero Control)

{ switch(palabraldentidad)

{ case elementoDeMenuSalir: if (VisualizarCuadroDeMensaj e(asideroNentana, secuenciaDinamica(secuenciaDinamicaMaximo,secuenciaDinamicaSalir), secuenciaDinamica(secuenciaDinamicaMaximo,secuenciaDinamicaVentanas), estiloIconoPregunta | estiloSiΝo) == elementoSi)

EnviarMensajeDejarO; break;

} return 0;

}

lresultado cliente: :msjDestruirO {EnviarMensajeDejarO; return 0;}

lresultado cliente: :msjPintarO

{ dispositivo dispositivoADibujar(*this,(pintura*)0);

arco arcoADibujar( rectangulo(punto(100,100), punto(300,300)), punto(200,300), punto(300,200) );

dispositivoADibujar « punto(200,200) « arcoADibujar « punto(50,50) « matriz(.25,0,0,.25) * arcoADibujar;

return 0; } File arco.cpt

#definir incluirNen32 #incluir <Nentanas.hpp>

#incluir "arco.hpp" #incluir "arco.h"

#definir secuenciaDinβmicaMBximo 80

externo "C" entero estandarLlamar NentanaPrincipal(asidero asiderolnstancia, asidero asideroAnterior, carBcter* pcharacterCommandLine, entero n-meroMostrarComando)

{ entero enteroResultado=0; intentar

{ RegistrarClase(informaci≤nDeClase(enteroARecurso(φdentidadDeMen-),

(asidero)icono(iconoAplicaci<n),

(asidero)cursor(cursorFlecha), pincel(estiloDePincelContinuo,pincelBlanco)));

c l i e n t e ventanaPrincipal(secuenciaDinBmica(secuenciaDinJ3micaMBximo,secuenciaDinBmica Tφtulo));

ventanaPrincipal « mostrar(n-meroMostrarComando); ventanaPrincipal « actualizar;

acelerador aceleradorPrincipal(enteroARecurso(φdentidadDeMen-));

} atrapar (excepci≤nDeNentanas& excepci≤nAtrapado)

{excepci≤nAtrapado. Mostrar(secuenciaDinβmica(secuenciaDinβmicaMβχimo,secuen ciaDinβmicaError)); }

retornar enteroResultado; }

lresultado cliente ::msjComando(palabra palabraldentidad, palabra palabraNotificar, asidero asideroControl) { seleccionar alabraldentidad)

{ caso elementoDeMen-Salir: si (VisualizarCuadroDeMensaje(asideroVentana, secuenciaDin^βmica(secuenciaDinβmicaMβχimo,secuenciaDinβmicaSalir), secuenciaDin^βmica(secuenciaDinβmicaMβχimo,secuenciaDinβmicaVentanas), estiloIconoPregunta | estiloSiNo) == elementoSi)

EnviarMensajeDejarO; quebrar;

} retornar 0; }

lresultado cliente: :msjDestruir {EnviarMensajeDejarO; retornar 0;}

lresultado cliente: :msjPintarO

{ dispositivo dispositivoADibujar(*Θste,(pintura*)0);

arco arcoADibujar( rectβngulo(punto(100,100), punto(300,300)), punto(200,300), punto(300,200) );

dispositivo ADibujar « punto(200,200) « arcoADibujar « punto(50,50) « matriz(.25,0,0,.25) * arcoADibujar;

retornar 0; }

#define identidadDeMenu 100 #define elementoDeMenuSalir 101

#define elementoDeMenuReanundar 102 #define secuenciaDinamicaTitulo 1 #define secuenciaDinamicaSalir 2 #define secuenciaDinamicaVentanas 3 #define secuenciaDinamicaError 4

#define controlOk 1

// Copyright (c) Educational & Computing Software Pty Ltd 1989-2000

// Archivo: arco.h (Resource Identities)

#define identidadDeMenu 100 #define elementoDeMenuSalir 101 #define elementoDeMenuReanundar 102

#define secuenciaDinamicaTitulo 1 #define secuenciaDinamicaSalir 2 #define secuenciaDinamicaNentanas 3 #define secuenciaDinamicaError 4

#define controlOk 1

File arco.hpp

class cliente : public ventana

{ public:

cliente(const char* pcharacterTitle) : ventana(cppClasePredeterminada,pcharacterTitle,estiloEstandar) { }

lresultado msjComando(palabra palabraldentidad, palabra palabraNotificar, asidero asideroControl);

lresultado msjDestruirO;

lresultado msjPintarO; };

File arco.hpp

clase cliente : p-blico ventana

{ p-blico:

cliente(const carβcter* pcharacterTitle)

: ventana(cppClasePredeterminada,pcharacterTitle,estiloEstβndar) { }

lresultado msjDestruirO;

lresultado msjPintarO;

}; File arco.rc

// Archivo: arco.rc (Application Resource Archivo)

#include "arco.h" #include "windows.h"

identidadDeMenu MENU {

POPUP "&Archivo"

{

MENUITEM "&Salir",elementoDeMenuSalir

MENUITEM SEPARATOR MENUITEM "&Reanundar",elementoDeMenuReammdar

} }

identidadDeMenu ACCELERATORS {

VKJF3, elementoDeMenuSalir, VIRTKEY "s", elementoDeMenuSalir, ALT "S", elementoDeMenuSalir, ALT

}

STRINGTABLE PRELOAD

{ secuenciaDinamicaVentanas "Ventanas++" secuenciaDinamicaTitulo "clase arco" secuenciaDinamicaSalir "Salir ?" secuenciaDinamicaError "Salir subprocesso!" }

File make.bcc

WinStart = \Borland\Lib\c0w32.obj

Bcclmplib = \Borland\bin\implib LibSearch = \ipp\lib;\Borland\lib

I n c = \Borland\include;\ipp\inc\spn;\ipp\exc\spn;\ipp\utl\spn;\ipp\bse\spn;\ipp\win\spn;\ipp\ gdi\spn;

Libs = cw32mti import32 BExcS BBseS BGdiS BNenS

.rc.res: brcc32 -v -w32 -i$(Inc) $*.rc

.cpp.obj: bcc32 $(CFlags) $*.cpp

arco.exe: $*.obj $*.res $(def) ilink32 $(LFlags) $(WinStart) $*.obj, $*.exe, $*.unite, $(Libs)„ $*.res

arco.obj: $*.cpp $*.hpp

arco.cpp: $*.cpt copy $*.cpt $*.cpρ flatten 1 $*.cpp arco.hpp: $*.hpt copy $*.hρt $*.hρρ flatten 1 $*.hpp

arco. res: $*.rc $*.h

File WinExe

NAME WinExe

DESCRIPΗON Windows Executable' EXETYPE WINDOWS

CODE PRELOAD MONEABLE DISCARDABLE

DATA PRELOAD MONEABLE MULTIPLE

STACKSIZE 65536

Another sample - Italian File arco.cpp

// Copyright (c) Educational & Computing Software Pty Ltd 1989-2001

// Archivio: arco.cpp

#define includereFin32 #include <Finestre.hpp>

#include "arco.hpp" #include "arco.h"

#define stringaDinamicaMassimo 80

extern "C" int standardChiamare WinMain(manico manicoCaso, manico manicoPrecedente, char* pcharacterCommandLine, int numeroMostrareComando) { int interoRisultato=0; try

{ RegistrareClasse(informazioneDiClasse(interoARisorsa(identitaDiMenu),

(manico)icona(iconaApplicazione),

c l i e n t e finestraPrincipale(stringaDinamica(stringaDinamicaMassimo,stringaDinamicaTitolo));

acceleratore acceleratorePrincipale(interoARisorsa(identitaDiMenu));

} catch (eccezioneFinestre& eccezionePrenduto)

return interoRisultato; }

Irisultato cliente: :msgComando(parola parolaldentita, parola parolaNotificare, manico manicoControllo)

{ switch(parolaIdentita)

{ case articoloDiMenuSmettere: if (EsporreScatolaDiMessagio(manicoFinestra, stringaDinamica(stringaDinamicaMassimo,stringaDinamicaSmettere), stringaDinamica(stringaDinamicaMassimo₃stringaDinamicaFinestre), stilelconaDomanda | stileSiNon) == articoloSi)

ImpostareMessagioSmettereO; break;

} return 0; }

Irisultato cliente: :msgDistruggereO {ImpostareMessagioSmettereO; return 0;}

Irisultato cliente: :msgDipingere

{ dispositivo dispositivoDisegnare(*this,(pittura*)0);

dispositivoDisegnare « punto(200,200) « arcoADisegnare

« punto(50,50) « matrice(.25,0,0,.25) * arcoADisegnare;

return 0; }

File arco.cpt

// Copyright (c) Educational & Computing Software Pty Ltd 1989-2001

// Archivio: arco.cpp

#definire includereFin32 #includere <Finestre.hpp>

#includere "arco.hpp" #includere "arco.h"

#definire stringaDinamicaMassimo 80

esterno "C" intero standardChiamare FinestraPrincipale(manico manicoCaso, manico manicoPrecedente, carattere* pcharacterCommandLine, intero numeroMostrareComando)

{ intero interoRisultato=0; provare

{ RegistrareClasse(informazioneDiClasse(interoARisorsa(identitαDiMenu),

(manico)icona(iconaApplicazione),

(manico)cursore(cursoreFreccia), pennello(stileDiPennelloSolido,pennelloBianco))); c l i e n t e finestraPrincipale(stringaDinamica(stringaDinamicaMassimo,stringaDinamicaTitolo));

acceleratore acceleratorePrincipale(interoARisorsa(identitαDiMenu));

} prendere (eccezioneFinestre& eccezionePrenduto)

ritornare interoRisultato;

}

{ selezionare arolaldentitα)

{ caso articoloDiMenuSmettere: se (EsporreScatolaDiMessagio(manicoFinestra, stringaDinamica(stringaDinamicaMassimo,stringaDinamicaSmettere), stringaDinamica(stringaDinamicaMassimo,stringaDinamicaFinestre), stilelconaDomanda | stileSiNon) == articoloSi) ImpostareMessagioSmettereO; rompere;

} ritornare 0; }

Irisultato cliente: :msgDistruggereO {ImpostareMessagioSmettereO; ritornare 0;}

Irisultato cliente: :msgDipingereO

{ dispositivo dispositivoDisegnare(*questo,(pittura*)0);

dispositivoDisegnare « punto(200,200) « arcoADisegnare

« punto(50,50) « matrice(.25,0,0,.25) * arcoADisegnare;

ritornare 0; }

File arco.h

#define articoloDiMenuSmettere 101 #define articoloDiMenuRicominciare 102

#define controlOk 1

File arco.hpp

class cliente : public finestra

{ public:

cliente(const char* pcharacterTitle)

: finestra(cppClasseDefault,pcharacterTitle,stileStandard) {}

Irisultato msgDistruggereO;

Irisultato msgDipingereO; File arco.hpt

classe cliente : pubblico finestra

{ pubblico:

cliente(const carattere* pcharacterTitle)

: finestra(cppClasseDefault,pcharacterTitle,stileStandard) {}

Irisultato msgComando arola parolaldentita, parola parolaNotificare, manico manicoControllo);

Irisultato msgDistruggereO;

Irisultato msgDipingereO; };

File arco.rc

#include "arco.h" #include "windows.h"

identitaDiMenu MENU { POPUP "&Archivo"

{

MENUITEM "&Smettere",articoloDiMenuSmettere

MENUITEM SEPARATOR MENUITEM "&Ricominciare",articoloDiMenuRicominciare

} }

identitaDiMenu ACCELERATORS {

VK_F3, articoloDiMenuSmettere, VIRTKEY V, articoloDiMenuSmettere, ALT "S", articoloDiMenuSmettere, ALT

}

STRINGTABLE PRELOAD

{ stringaDinamicaFinestre "Finestre++ " stringaDinamicaTitolo "clase arco" stringaDinamicaSmettere "Smettere ?" stringaDinamicaErrore "Smettere fill"

}

File make.bcc WinStart = \Borland\Lib\c0w32.obj

Bcclmplib = \Borland\bin\implib LibSearch = \ipp\lib;\Borland\lib

I n c

\Borland\include;\ipp\inc\ita;\ipp\exc\ita;\ipp\utl\ita;\ipp\bse\ita;\iρρ\win\ita;\ipp\gdi\ita; CFlags = -D_RTLDLL -b -w-par -v- -WM -c -I$(Inc) LFlags = /Gn /m /x /c /L$(LibSearch) /s /Oc /Tpe

Libs = cw32mti import32 BExcI BBsel BGdil BFinl

.rc.res: brcc32 -v -w32 -i$(Inc) $*.rc

.cpp.obj: bcc32 $(CFlags) $ * .cpp

def = WinExe.def

arco.exe: $*.obj $*.res $(def) ilink32 $(LFlags) $(WinStart) $* .obj, $* .exe, $* .unite, $(Libs), $(def), $* .res

arco.obj: $*.cpp $*.hpp

arco.cpp: $*.cpt copy $*.cpt $*. cpp flatten 3 $*. cpp

arco.hpp: $*.hpt coρy $*.hρt $*.hρp flatten 3 $*.hρp

arco.res: $*.rc $*.h

Another sample - Spanish File arco.cpp

#define incluirNen32 #include <Nentanas.hpp>

#include "arco.hpp" #include "arco.h"

#define secuenciaDinamicaMaximo 80

{ int enteroResultado=0; try

{ RegistrarClase(informacionDeClase(enteroARecurso(identidadDeMenu),

(asidero)icono(iconoAplicacion),

(asidero)cursor(cursorFlecha), pincel(estiloDePincelContinuo,pincelBlanco)));

ventanaPrincipal « mostrar(numeroMostrarComando); ventanaPrincipal « actualizar; acelerador aceleradorPrincipal(enteroARecurso(identidadDeMenu));

} catch (excepcionDeNentanas& excepcionAtrapado)

{excepcionAtrapado.Mostrar(secuenciaDinamica(secuenciaDinamicaMaximo,secuenc iaDinamicaError)) ; }

return enteroResultado; }

lresultado cliente: :msjComando(palabra palabraldentidad, palabra palabraNotificar, asidero asideroControl)

{ switch(palabraldentidad) { case elementoDeMenuSalir: if (VisualizarCuadroDeMensaje(asideroNentana, secuenciaDinamica(secuenciaDinamicaMaximo,secuenciaDinamicaSalir), secuenciaDinamica(secuenciaDinamicaMaximo,secuenciaDinamicaNentanas), estiloIconoPregunta | estiloSiΝo) == elementoSi)

EnviarMensajeDejarO; break;

} return 0;

} lresultado cliente: :msjDestruirO {EnviarMensajeDejarO; return 0;}

lresultado cliente: :msjPintarO { dispositivo dispositivoADibujar(*this,(pintura*)0);

dispositivo ADibujar « punto(200,200) « arcoADibujar « punto(50,50)

« matriz(.25,0,0,.25) * arcoADibujar;

return 0; }

File arco.cpt

// Copyright (c) Educational & Computing Software Pty Ltd 1989-2001

// Archivo: arco.cpp

#definir incluirNen32 #incluir <Nentanas.hpp>

#incluir "arco.hpp" #incluir "arco.h" #definir secuenciaDinβmicaMβximo 80

externo "C" entero estandarLlamar NentanaPrincipal(asidero asiderolnstancia, asidero asideroAnterior, carβcter* pcharacterCommandLine, entero n-meroMostrarComando)

{ entero enteroResultado=0; intentar {

RegistrarClase(informaci≤nDeClase(enteroARecurso(φdentidadDeMen-),

(asidero)icono(iconoAplicaci≤n),

(asidero)cursor(cursorFlecha), pincel(estiloDePincelContinuo,pincelBlanco)));

c l i e n t e ventanaPrincipal(secuenciaDinβmica(secuenciaDinβmicaMβχimo,secuenciaDinβmica

Tφtulo));

acelerador aceleradorPrincipal(enteroARecurso(φdentidadDeMen-));

} atrapar (excepci≤nDeNentanas& excepci≤nAtrapado) {excepc nAtrapadoMostrar(secuenda^

retornar enteroResultado;

}

{ seleccionar(palabraIdentidad)

{ caso elementoDeMen-Salir: si (VisualizarCuadroDeMensaje(asideroVentana, secuenciaDinβmica(secuenciaDinβmicaMβχimo,secuenciaDinβmicaSalir), secuenciaDinβmica(secuenciaDinβmicaMβχimo,secuenciaDinβmicaNentanas), estiloIconoPregunta | estiloSiNo) == elementoSi)

EnviarMensajeDejarO; quebrar; } retornar 0;

}

lresultado cliente: :msjDestruirO {EnviarMensajeDejarO; retornar 0;}

lresultado cliente: :msjPintar0

{ dispositivo dispositivoADibujar(*Θste,(pintura*)0);

retornar 0; }

File arco.h

//Archivo: arco.h (Resource Identities)

#define identidadDeMenu 100

#define elementoDeMenuSalir 101 #define elementoDeMenuReanundar 102

#define controlOk 1

class cliente : public ventana

{ public:

cliente(const char* punteroCarβcterTitulo) : ventana(cppClasePredeterminada,punteroCarβcterTitulo,estiloEstandar) { }

lresultado msjDestruirO;

lresultado msjPintarO;

};

clase cliente : p-blico ventana { p-blico:

cliente(const carβcter* punteroCarβcterTφtulo) : ventana(cppClasePredeterminada,punteroCarβcterTφtulo,estiloEstβndar) { }

lresultado msjDestruirO;

lresultado msjPintarO;

};

#include "arco.h" #include " windows. h"

identidadDeMenu MENU

{

POPUP "&Aιchivo" {

MENUITEM "&Salir",elementoDeMenuSalir

MENUITEM SEPARATOR

MENUITEM " &Reanundar " elementoDeMenuReanundar

} }

identidadDeMenu ACCELERATORS

{

VK F3, elementoDeMenuSalir, VIRTKEY "s", elementoDeMenuSalir, ALT

"S", elementoDeMenuSalir, ALT }

STRINGTABLE PRELOAD

{ secuenciaDinamicaVentanas "Nentanas++" secuenciaDinamicaTitulo "clase arco" secuenciaDinamicaSalir "Salir ?" secuenciaDinamicaError "Salir subprocesso!"

}

File make.bcc

// Copyright (c) Educational & Computing Software Pty Ltd 1989-2000

// Archivo: arco.rc (Application Resource Archivo)

#include "arco.h" #include "windows.h"

identidadDeMenu MENU {

POPUP "&Archivo"

{

MENUITEM "&Salir",elementoDeMenuSalir

MENUITEM SEPARATOR MENUITEM "&Reanundar",elementoDeMenuReanundar

} }

identidadDeMenu ACCELERATORS {

VK_F3, elementoDeMenuSalir, VIRTKEY "s", elementoDeMenuSalir, ALT "S", elementoDeMenuSalir, ALT

}

STRINGTABLE PRELOAD

{ secuenciaDinamicaVentanas "Ventanas++ " secuenciaDinamicaTitulo "clase arco" secuenciaDinamicaSalir "Salir ?" secuenciaDinamicaError "Salir subprocesso!"

}

Although D automatically converts the language keywords and all identifiers for the operating system, identifiers specific to a program also require translation.

D provides a mechanism for supplying additional translations when processing code so that the result is entirely in the target language.

D provides support to all natural languages including single byte languages such as English, Spanish, French, Italian, German and Vietnamese; and double byte languages such as Chinese and Japanese.

Annex 2 are a set of C+ + program codes for an application to create the window shown in Figure 2. These program codes are written in English and they include the following file components:

1 . .cpp file containing the main source code for the application;

2. .hpp file containing the class definitions for the application;

3. .h file containing the constant definitions shared by the resource compiler (C/C+ +) and the application;

4. .re file containing the menu definitions, string definitions; and

5. A module definition file determining the linking properties. Annexes 3 and 4 are respective French and Spanish program codes of the

Annex 1 application. As French and Spanish have accented characters in their writings and the accented characters must be replaced in order for the codes to be compilable by the C/C+ + compiler. The source codes for theses languages are saved in files named with .cpt, .hpt, .ht and .ret extensions.

The system 10 of the present invention maps programs and resources from one accented form to another. The flattening conversion stage of the system 10 maps from the accented form to the non-accented form ( i.e. .cpt to .cpp, .hpt to .hpp, ,ht to .h and .ret to .re) and replaces the non-English C/C+ + keywords with the corresponding English keywords. The converted files are compilable by the C/C+ + compiler.

The flattening conversion stage can be performed automatically as the system 10 has been informed of the natural languages of the source and target codes.

The conversion and flattening stages of the present invention can be incorporated into any compiler program. This will allow compilers to be capable of compiling program codes including keywords written in any language. Whilst the above has been given by way of illustrative example of the present invention many variations and modifications thereto will be apparent to those skilled in the art without departing from the broad ambit and scope of the invention as herein set forth.

Appendix A

"WinMain", "VentanaPrincipal", "FinestraPrincipale",

"ifdef", "sidef", "sedef",

"ifndef", "sindef", "sendef",

"endif", "fin_si", "se_fine",

"define", "definir", "definire",

"defined", "definida", "definito",

"include", "incluir", "includere",

"asm", "ensamblar", "asm",

"auto", "auto", "auto",

"break", "quebrar", "rompere",

"case", "caso", "caso",

"catch", "atrapar", "prendere",

"char", "carβcter", "carattere",

"class", "clase", "classe",

"const", "const", "const",

"continue", "continuar", "continuare",

"default", "predeterminado", "default",

"delete", "eliminar", "cancellare",

"do", "hacer", "fare",

"double", "doble", "doppio",

"else", "otro", "altro",

"enum", "enum", "enum",

"extern", "externo", "esterno",

"float", "decimal", "decimale",

"for", "para", "per",

"friend", "amigo", "amico",

"goto", "ir_a", "andare_a",

"if", "si", "se",

"inline", "enlφnea", "inlinea",

"int", "entero", "intero", "lungo",

"nuovo",

"operatore",

"privato",

"protetto",

"pubblico",

"rapido",

"ritornare",

"corto",

"segno",

"grandezza_di",

"statico",

"strutt",

"selezionare",

"templet",

"questo",

"lanciare",

"provare",

"tipodef",

"unione",

"senzasegno",

"virtuale",

"vuoto",

"volatile",

"mentre", APPENDIX B // Appendix B - Spanish and French D Transformations // Primary Translation Table Elements.

// The first column defines the Operating System and D Language in Spanish. // The second column defines the Operating System and D Language in Italian.

"abcDecimal", "abcDecimale",

"abcAnchos", "abcLarghezze",

"Absoluto", "Assoluto",

"acelerador", "acceleratore",

"aceleradorAlt", "acceleratoreAlt",

" aceleradorAAsignar " , " acceleratore AAssegnare " ,

" aceleradorControl" , " acceleratoreControllo" ,

" aceleradorACopiar " , " acceleratore ACopiare " ,

"entradasDeAcelerador", " acceler atoreEntr ate " ,

" entradaDeAcelerador " , " entrataDiAcceleratore " ,

"indicadoresDeAcelerador", " indicazioneDiAcceleratore " ,

"acelerador _rltimo " , " acceler atoreUltimo " ,

" aceleradorPrincipal" , " acceleratorePrincipale " ,

"formaci≤nDecimalAnchos", " arrayDecimaleLarghezze " ,

" f ormaci≤ nDoblePalabraCampos " , " arrayDoppioParolaBitCampi " , "formaci≤nDoblePalabraMβscaraDeBit", "arrayDoppioParolaBitMaschera", "f ormaci ≤ nDoblePalabraCuentas " , " arrayDoppioParolaConti " , "formaci≤nDoblePalabraEstilosPersonalizado", "arrayDoppioParolaStiliUsanza", "formaci≤nDoblePalabralnformaci≤n", " arrayDoppioParolaln ormazione" , "formaci≤nDoblePalabraM^βscara", "arrayDoppioParolaMaschera", "formaci≤nDoblePalabraParβmetros", " arrayDoppioParolaParametri " , "agosto", "augusto",

"autoridades", "autoritαSistema",

"autoridad", "autoritα",

"Autoridad", "Autoritα",

" autoridadAAsignar" , " autoritαAssegnare " ,

"autoridadConstantes " , "autoritαCostanti",

" autoridadACopiar " , "autoritαCopiare",

"autoridadCreador", " autoritαCreatore " ,

"AutoridadCreador", " AutoritαCreatore " ,

"baudio", "baud", "baudio_075", "baud_075", "baudio_110", "baud_110", "baudio_115200", "baud_115200", "baudio 1200", "baud_1200",

"baudio", "baud", "baudio_075", "baud_075", "baudio_110", "baud_110", "baudio_115200", "baud_115200", "baudio 1200", "baud 1200", "bitmapaACrear", "bitmappaCreare", "bitmapaDFlechaAbajo", "bitmappaDFrecciaGi-", "bitmapaDFlechalzquierda", "bitmappaDFrecciaSinistro", "bitmapaDFlechaDerecha" , "bitmappaDFrecciaDestro", "bitmapaDFlechaArriba", "bitmappaDFrecciaSu " ,

"punteroFunci≤nTrazarLφnea", "puntatoreFunzioneTracciareLmea", "punteroFunci≤nSalida", "puntatoreFunzioneOutput",

"punteroFunci≤nPosici≤n", "puntatoreFunzionePosizione " , "punteroFunci≤ nProgreso " , "puntatoreFunzioneProgresso " ,

"puntoDeActuaci≤n", "puntoZonacalda" , "puntoDentro", "puntolnterno", "puntoL≤gico", "puntoLogico", "puntoMβscara", "puntoMaschera", "puntoMβximo", "puntoMassimo", "puntoMφnimo", "puntoMinimo", "puntoM≤dulo", "puntoModulo",

APPENDIX Cl

#sindef base_functions_included

#definir base_functions_included

#incluir <unidefs.h>

#incluir <estructuras.hpp> #incluir <seguridad.hpp>

externo "C" {

#si def inida(incluir CuadroDeMensaj e)

entero estandarEntrar _CajaDeMensaje(asidero asidero Ventana, const tipoCarβcter* punteroCarβcterTexto, const tipoCarβcter* punteroCarβcterTφtulo, sinsigno sinsignoTipo);

entero estandarEntrar _CajaDeMensajeExtendido(asidero asidero Ventana, const tipoCarβcter* punteroCarβcterTexto, const tipoCarβcter* punteroCarβcterTφtulo, sinsigno sinsignoTipo, palabra palabraldentidadDeLenguaje);

entero e s tand arEntrar _Caj aD eMens aj eIndire cto (cons t parβmetrosDeCuadroDeMensaje*);

decisi≤n estandarEntrar MessageBeep(sinsigno sinsignoTipo);

#fin si #si definida(incluirError) sinsigno estandarEntrar PonerModoDeError(sinsigno sinsignoModo);

doblePalabra estandarEntrar ObtenerError_rltimo0;

vacφo estandarEntrar PonerError _rltimo(doblePalabra doblePalabraC≤digoDeError);

vacφo estandarEntrar PonerError _rltimoExtendido(doblePalabra doblePalabraC≤digoDeError, doblePalabra doblePalabraTipo);

#fin_si

#si definida(incluirSemβforo) ||\ definida(incluirArchivo) ||\ definida(incluirSubproceso)

decisi≤n estandarEntrar _CerrarAsidero(asidero asideroObjeto);

decisi≤n estandarEntrar _CancelarEntradaSalida(asidero asideroArchivo);

decisi≤n estandarEntrar _DuplicarAsidero(asidero asideroOrigen, asidero asideroDuplicar, asidero asideroObjetivo, asidero* punteroAsideroResultado, doblePalabra doblePalabraAcceso, decisi≤n decidirHeredar, doblePalabra doblePalabraOpciones); #fin si #si definida(incluirSecuencia)

entero estandarEntrar _CompararSecuencia(const tipoCarβcter* punteroCarβcterSecuencial, const tipoCarβcter* punteroCarβcterSecuencia2);

entero estandarEntrar _CompararSecuenciaIgnorar(const tipoCarβcter* punteroCarβcterSecuencial, const tipoCarβcter* punteroCarβcterSecuencia2);

tipoCarβcter* estandarEntrar _CopiarSecuencia(tipoCarβcter* punteroCarβcterSecuencial, const tipoCarβcter* punteroCarβcterSecuencia2);

tipoCarβcter* estandarEntrar _ConcatenarSecuencia(tipoCarβcter* punteroCarβcterSecuencial, const tipoCarβcter* punteroCarβcterSecuencia2);

entero estandarEntrar _LargoDeSecuencia(const tipoCarβcter* punteroCarβcterSecuencia);

decisi≤n estandarEntrar _CarBcterAOem(const tipoCarβcter* punteroCarβcterOrigen, carβcter* punteroCarβcterDestino);

decisi≤n estandarEntrar _OemACarβcter(const carβcter* punteroCarβcterOrigen, tipoCarβcter* punteroCarβcterDestino);

decisi≤n estandarEntrar _CarβcterAOemB-fer(const tipoCarβcter* punteroCarβcterOrigen, carβcter* punteroCarβcterDestino, doblePalabra doblePalabraLargoDeDestino); decisi≤n estandarEntrar _OemAB-ferDeCarBcter(const carβcter* punteroCarβcterOrigen, tipoCarβcter* punteroCarβcterDestino, doblePalabra doblePalabraLargoDeDestino);

tipoCarβcter* estandarEntrar_CarβcterMayscula(tipoCarβcter*punteroCarβcterB-fer);

doblePalabra estandarEntrar _CarβcterMaysculaB-fer(tipoCarβcter* punteroCarBcterB -f er, doblePalabra doblePalabraLargo);

tipoCarβcter* estandarEntrar _CarβcterMin-scula(tipoCarβcter* punteroCarβcter);

doblePalabra estandarEntrar _CarβcterMin-sculaB-fer(tipoCarβcter* punteroCarβcterB-fer, doblePalabra doblePalabraLargo);

tipoCarβcter* estandarEntrar _CarβcterPr≤ximo(const tipoCarβcter* punteroCarβcterActual);

tipoCarβcter* estandarEntrar _CarβcterAnterior(const tipoCarβcter* punteroCarβcterComienzo, const tipoCarβcter* punteroCarβcterActual);

carβcter* estandarEntrar _CarβcterPr<ximoExtendido(palabra wordCodePage, const carβcter* punteroCarβcterActual, doblePalabra doblePalabralndicadores);

carβcter* estandarEntrar _CarBcterAnteriorExtendido(palabra wordCodePage, const carβcter* punteroCarβcterComienzo, const carβcter* punteroCarβcterActual, doblePalabra doblePalabralndicadores); #fin_si

#si definida(incluirSemβforo)

asidero estandarEntrar _CrearExclusivo(atributosDeSeguridad* punteroAtributosDeSeguridad, decisi≤n decidirDue±o, const tipoCarβcter* punteroCarβcterNombre);

decisi≤n estandarEntrar _LiberarExclusivo (asidero asideroExclusivo);

asidero estandarEntrar _AbrirExclusivo(doblePalabra doblePalabraAcceso, decisi≤n decidirHeredar, const tipoCarβcter* punteroCarβcterNombre);

asidero estandarEntrar _CrearEvento(atributosDeSeguridad* punteroAtributosDeSeguridad, decisi≤n decidirReponerManual, decisi≤n decidirlnicialEstado, const tipoCarβcter* punteroCarβcterNombre);

asidero estandarEntrar _AbrirEvento(doblePalabra doblePalabraAcceso, decisi≤n decidirHeredar, const tipoCarβcter* punteroCarβcterNombre);

decisi≤n estandarEntrar _PonerEvento(asidero asideroEvento);

decisi≤n estandarEntrar _ReponerEvento(asidero asideroEvento);

decisi≤n estandarEntrar _PulsarEvento(asidero asideroEvento); asidero estandarEntrar _CrearSemβforo(atributosDeSeguridad* punteroAtributosDeSeguridad, largo largoCuentalnicial, largo largoCuentaMBxima, const tipoCarβcter* punteroCarβcterNombre);

asidero estandarEntrar _AbrirSemβforo(doblePalabra doblePalabraAcceso, decisi≤n decidirHeredar, const tipoCarβcter* punteroCarβcterNombre);

decisi≤n estandarEntrar _LiberarSemβforo(asidero asideroSemβforo, largo largoCuentaDeLiberac≤n, largo* punteroLargoCuentaAnterior);

doblePalabra estandarEntrar _EsperarObjetoSolo(asidero asideroObjeto, doblePalabra doblePalabraMilisegundos) ;

doblePalabra estandarEntrar _EsperarObjetoSoloExtendido(asidero asideroObjeto, doblePalabra doblePalabraMilisegundos, decisi≤n decidirAlertable);

doblePalabra estandarEntrar _EsperarObjetosMultiple(doblePalabra doblePalabraCuenta, const asidero* punteroAsideros, decisi≤n decidirEsperarTodo, doblePalabra doblePalabraMilisegundos);

doblePalabra estandarEntrar _EsperarObjetosMultipleExtendidos(doblePalabra doblePalabraCuenta, const asidero* punteroAsideros, decisi≤n decidirEsperarTodo, doblePalabra doblePalabraMilisegundos, decisi≤n decidirAlertable);

doblePalabra estandarEntrar MsgWaitForMultipleObjectsEx(doblePalabra doblePalabraCuenta, const asidero* punteroAsideros, doblePalabra doblePalabraMilisegundos, doblePalabra double WordWakeMask, doblePalabra doblePalabralndicadores);

vacφo estandarEntrar _Dormir(doblePalabra doblePalabraMilisegundos);

doblePalabra estandarEntrar _DormirExtendido(doblePalabra doblePalabraMilisegundos, decisi≤n decidirAlertable);

largo estandarEntrar _IncrementarEntrelazado(largo* punteroLargoSumar);

entero estandarEntrar _DecrementarEntrelazado(largo* punteroLargoSumar);

largo estandarEntrar _IntercambiarEntrelazado(largo* punteroLargoObjetivo, largo largo Valor);

largo estandarEntrar InterlockedExchangeAdd(largo* punteroLargoObjetivo, largo largo Valor);

#fin_si

#si definida(incluirMiscelβnea) vacφo estandarEntrar _InicializarSecci≤nCritica(secci≤nCritica* punteroSecci ≤ nCritica) ; vacφo estandarEntrar _EntrarSecci<nCritica(secci<nCritica* punteroSecci≤nCritica); vacφo estandarEntrar _SalirDeSecci≤nCrφtica(secci≤nCritica* punteroSecci≤nCritica); vacφo estandarEntrar _EliminarSecci≤nCritica(secci≤nCritica* punteroSecci≤nCritica); vacφo estandarEntrar_IntentarSecci≤nCritica(secci≤nCritica* punteroSecci≤nCritica);

doblePalabra estandarEntrar _ObtenerVersi≤n0;

decisi≤n estandarEntrar _ObtenerInformaci≤nDeVersion(informaci≤nDeVersi≤n* pversionlnformation);

doblePalabra estandarEntrar _FormatearMensage(doblePalabra doblePalabralndicadores, const vacφo* pSource, doblePalabra doblePalabraldentidadDeMensaje, doblePalabra doblePalabraldentidadDeLenguaje, tipoCarβcter* punteroCarβcterB-fer, doblePalabra doblePalabraTama±o, vacφo* punteroParBmetros); #fin_si

#si definida(incluirMemoria)

asidero estandarEntrar _AsignarMemoriaGlobal(sinsigno sinsignolndicadores, doblePalabra doblePalabraBytes);

asidero estandarEntrar _ReasignarMemoriaGlobal(asidero asideroMemoria, doblePalabra doblePalabraBytes, sinsigno sinsignolndicadores); doblePalabra estandarEntrar _Tama±oDeMemoriaGlobal(asidero asideroMemoria);

sinsigno estandarEntrar _IndicadoresDeMemoriaGlobal(asidero asideroMemoria);

vacφo* estandarEntrar _BloquearMemoriaGlobal(asidero asideroMemoria);

asidero estandarEntrar _AsideroDeMemoriaGlobal(const vacφo* punteroMemoria);

decisi≤n estandarEntrar _DesbloquearMemoriaGlobal(asidero asideroMemoria);

asidero estandarEntrar _LiberarMemoriaGlobal(asidero asideroMemoria);

vacφo estandarEntrar _EstadoDeMemoriaGlobal(memoriaEstado* punteroEstadoDeMemoria);

asidero estandarEntrar _CagarRecurso(asidero asideroM≤dulo, asidero asideroInformaci≤nDeRecurso);

decisi≤n estandarEntrar _LiberarRecurso(asidero asideroDataDeResurso);

vacφo* estandarEntrar _BloquearRecurso(asidero asideroDataDeResurso);

asidero estandarEntrar _AsignarMemoriaLocal(sinsigno sinsignolndicadores, sinsigno sinsignoBytes);

asidero estandarEntrar _ReasignarMemoriaLocal(asidero asideroMemoria, sinsigno sinsignoBytes, sinsigno sinsignolndicadores);

vacφo* estandarEntrar _BloquearMemoriaLocal(asidero asideroMemoria); asidero estandarEntrar _AsideroDeMemoriaLocal(const vacφo* punteroMemoria);

decisi≤n estandarEntrar _DesbloquearMemoriaLocal(asidero asideroMemoria);

sinsigno estandarEntrar _Tama±oDeMemoriaLocal(asidero asideroMemoria);

sinsigno estandarEntrar _IndicadoresDeMemoriaLocal(asidero asideroMemoria);

asidero estandarEntrar _LiberarMemoriaLocal(asidero asideroMemoria);

vacφo* estandarEntrar _AsignarMemoriaVirtual(vacφo* punteroDirecci≤n, doblePalabra doblePalabraTama±o, doblePalabra doblePalabraTipoDeAsignaci≤ n, doblePalabra doblePalabraProteger);

vacφo* estandarEntrar _AsignarVirtualExtendido(asidero asideroProceso, vacφo* punteroDirecci≤n, doblePalabra doblePalabraTama±o, doblePalabra doblePalabraTipoDeAsignaci≤n, doblePalabra doblePalabraProteger);

decisi≤n estandarEntrar _LiberarMemoriaVirtual(vacφo* punteroDirecci≤n, doblePalabra doblePalabraTama±o, doblePalabra doblePalabraTipoDeLibre);

decisi≤n estandarEntrar _LiberarVirtualExtendido(asidero asideroProceso, vacφo* punteroDirecci≤n, doblePalabra doblePalabraTama±o, doblePalabra doblePalabraTipoDeLibre);

decisi≤n estandarEntrar _BloquearMemoriaVirtual(vacφo* punteroDirecci≤n, doblePalabra doblePalabraTama±o);

decisi≤n estandarEntrar _DesbloquearMemoriaVirtual(vacφo* punteroDirecci≤n, doblePalabra doblePalabraTama±o);

decisi≤n estandarEntrar _ProtegerMemoriaVirtual(vacφo* punteroDirecci≤n, doblePalabra doblePalabraTama±o, doblePalabra doblePalabraProtegerNuevo, doblePalabra* pointerDoubleWordProtectOld);

decisi≤n estandarEntrar _ProtegerMemoriaVirtualExtendido(asidero asideroProceso, vacφo* punteroDirecci≤n, doblePalabra doblePalabraTama±o, doblePalabra doblePalabraProtegerNuevo, doblePalabra* pointerDoubleWordProtectOld);

doblePalabra estandarEntrar _PreguntarMemoriaVirtual(vacφo* punteroDirecci≤n, inf ormaci < nDeMemo ria * punter oB -fer, doblePalabra doblePalabraLargo);

doblePalabra estandarEntrar _PreguntarMemoriaVirtualExtendido(asidero asideroProceso, vacφo* punteroDirecci≤n, inf ormaci≤ nDeMemoria * punterolnf ormaci≤ nDeMemoria, doblePalabra doblePalabraLargo);

asidero estandarEntrar _CrearMont≤n(doblePalabra doblePalabraOpciones, doblePalabra doblePalabraTama±oInicial, doblePalabra doblePalabraTama±oMβximo); decisi≤n estandarEntrar _DestruirMont≤n(asidero asideroMont≤n);

vacφo* estandarEntrar _AsignarMont≤n(asidero asideroMont≤n, doblePalabra doblePalabralndicadores, doblePalabra doblePalabraBytes);

vacφo* estandarEntrar _ReasignarMont≤n(asidero asideroMont≤n, doblePalabra doblePalabralndicadores, vacφo* punteroMemoria, doblePalabra doblePalabraBytes);

decisi≤n estandarEntrar _LiberarMont≤n(asidero asideroMont≤n, doblePalabra doblePalabralndicadores, vacφo* punteroMemoria);

doblePalabra estandarEntrar _Tama±oDePila(asidero asideroMont≤n, doblePalabra doblePalabralndicadores, const vacφo* punteroMemoria);

decisi≤n estandarEntrar _ValidarMont≤n(asidero asideroMont≤n, doblePalabra doblePalabralndicadores, const vacφo* punteroMemoria);

sinsigno estandarEntrar _ComprimirMont≤n(asidero asideroMont≤n, doblePalabra doblePalabralndicadores);

decisi≤n estandarEntrar _BloquearMont≤n(asidero asideroMont≤n);

decisi≤n estandarEntrar _DesbloquearMont≤n(asidero asideroMont≤n);

decisi≤n estandarEntrar _CaminarMont≤n(asidero asideroMont≤n, entradaDeMont≤n* punteroEntradaDeMont≤n);

asidero estandarEntrar _ObtenerMont≤nDeProceso(vacφo);

doblePalabra _ObtenerMontonesDeProceso(doblePalabra dobleP alabr aMontones, asidero* formaci≤nAsideroMontones);

#fin si

#si definida(incluirArchivo)

decisi≤n estandarEntrar _PonerInformaci≤nDeAsidero(asidero asideroObjeto, doblePalabra doblePalabraMBscara, doblePalabra doblePalabralndicadores);

asidero estandarEntrar _ObtenerAsideroEstandar(doblePalabra doblePalabraAsideroDeDestino);

decisi ≤ n estandarEntrar _PonerAsideroEstandar(dobIePalabra doblePalabraAsideroDeDestino, asidero asideroEstβndar);

asidero estandarEntrar _CrearArchivo(const tipoCarβcter * punteroCarβcterNombreDeArchivo, doblePalabra doblePalabraAcceso, doblePalabra doblePalabraModoDeCompartir, atributosDeSeguridad* punteroAtributosDeSeguridad, doblePalabra doblePalabraDisposici≤n, doblePalabra doblePalabralndicadoresYAtributos, asidero asideroArchivoDePlantilla); decisi≤n estandarEntrar _EscribirArchivo(asidero asideroArchivo, const vacφo* punteroB-fer, doblePalabra doblePalabraBytes, doblePalabra* punteroDoblePalabraEscrito, traslapado* punteroTraslapado);

decisi≤n estandarEntrar _EscribirArchivoExtendido(asidero asideroArchivo, const vacφo* punteroB-fer, doblePalabra doblePalabraEscribir, traslapado* punteroTraslapado, fun ≤ nFinalizaci ≤ nTraslapada funci ≤ nFinalizaci ≤ n);

decisi≤n estandarEntrar _LeerArchivo(asidero asideroArchivo, vacφo* punteroB-fer, doblePalabra doblePalabraLeer, doblePalabra* punteroDoblePalabraLeφdo, traslapado* punteroTraslapado);

decisi≤n estandarEntrar _LeerArchivoExtendido(asidero asideroArchivo, vacφo* punteroB-fer, doblePalabra doblePalabraLeer, traslapado* punteroTraslapado, funci ≤ nFinalizaci < nTraslapada funci ≤ nFinalizaci ≤ n);

doblePalabra estandarEntrar _PonerPunteroDeArchivo(asidero asideroArchivo, largo largoMoverAbajo, largo * punteroLargoMoverSuperior , doblePalabra doblePalabraMΘtodo);

decisi≤n estandarEntrar _ControlarEntradaSalidaDeDispositivo(asidero asideroDispositivo, doblePalabra doblePalabraC≤digo, vacφo* punteroB-ferEn, doblePalabra doblePalabraB -ferEn, vacφo* punter oB-ferAfuer a, doblePalabra doblePalabraB-ferAfuera, doblePalabra* punteroDoblePalabraRetornado, traslapado* punteroTraslapado);

decisi≤n estandarEntrar _BloquearArchivo(asidero asideroArchivo, doblePalabra doblePalabraDesplazamientoInferior, doblePalabra doblePalabraDesplazamientoSuperior, doblePalabra doblePalabraBytesInferior, doblePalabra doblePalabraBytesSuperior);

decisi≤n estandarEntrar _BloquearArchivoExtendido(asidero asideroArchivo, dobleP alabr a doblePalabralndicadores, doblePalabra doblePalabraReservada, doblePalabra doblePalabraBytesInferior, doblePalabra doblePalabraBytesSuperior, traslapado* punteroTraslapado);

decisi≤n estandarEntrar _DesbloquearArchivo(asidero asideroArchivo, doblePalabra doblePalabraDesplazamientoInferior, doblePalabra doblePalabraDesplazamientoSuperior, doblePalabra doblePalabraBytesInferior, doblePalabra doblePalabraBytesSuperior);

decisi≤n estandarEntrar _DesbloquearArchivoExtendido(asidero asideroArchivo, doblePalabra doblePalabraReservada, doblePalabra doblePalabraBytesInferior, doblePalabra doblePalabraBytesSuperior, traslapado* punteroTraslapado);

decisi≤n estandarEntrar _ObtenerInformaci≤nDeArchivo(asidero asideroArchivo, inf ormaci ≤ nDe Archivo * punteroInformaci≤nDeArchivo);

doblePalabra estandarEntrar _ObtenerTipoDeArchivo(asidero asideroArchivo);

doblePalabra estandarEntrar _ObtenerTama±oDeArchivo(asidero asideroArchivo, doblePalabra* pointerDoubleWordFileSizeHigh);

decisi≤n estandarEntrar _PurgarB-feresDeArchivo(asidero asideroArchivo);

decisi≤n estandarEntrar _PonerFinDeArchivo(asidero asideroArchivo);

decisi≤n estandarEntrar _ObtenerTiempoDeArchivo(asidero asideroArchivo, tiempoDeArchivo* pfiletimeCreate, tiempoDe Archivo * pfiletimeLast Access, tiempoDeArchivo * pfiletimeLastWrite);

decisi≤n estandarEntrar _PonerTiempoDeArchivo(asidero asideroArchivo, const tiempoDeArchivo* pfiletimeCreate, const tiempoDeArchivo* pfiletimeLastAccess, const tiempoDeArchivo* pfiletimeLastWrite);

decisi≤n estandarEntrar _ObtenerResultadoTraslapado(asidero asideroArchivo, traslapado* punteroTraslapado, doblePalabra* punteroDoblePalabraTransferido, decisi≤n decidirEsperar);

decisi≤n estandarEntrar _LeerCopia(asidero asideroArchivo, byte* punteroByteB-fer, doblePalabra doblePalabraLeer, doblePalabra* punteroDoblePalabraLeφdo, decisi≤n decideAbort, decisi≤n decidirSeguridadDeProceso, vacφo** punteroPunteroContexto);

decisi≤n estandarEntrar _BuscarCopia(asidero asideroArchivo, doblePalabra doblePalabraBuscarlnferior, doblePalabra doblePalabraBuscarSuperior, doblePalabra* punteroDoblePalabraDesplazamientoInferior, doblePalabra* punteroDoblePalabraDesplazamientoSuperior, vacφo** punteroPunteroContexto);

decisi≤n estandarEntrar _EscribirCopia(asidero asideroArchivo, const byte* punteroByteB-fer, doblePalabra doblePalabraEscribir, doblePalabra* punteroDoblePalabraEscrito, decisi≤n decideAbort, decisi≤n decidirSeguridadDeProceso, vacφo** punteroPunteroContexto);

decisi≤n estandarEntrar _PonerAtributosDeArchivo(const tipoCarβcter* punteroCarβcterNombreDeArchivo, doblePalabra doblePalabraAtributosDeArchivo);

sinsigno estandarEntrar _ObtenerAtributosDeArchivo(const tipoCarβcter* punteroCarβcterNombreDeArchivo);

decisi≤n estandarEntrar _ObtenerAtributosDeArchivoExtendido(const tipoCarβcter* punteroCarβcterNombreDeArchivo, nivelDeAtributoDeArchivo informaci≤nDeAtributoDeArchivo, vacφo* pFilelnformation);

decisi≤n estandarEntrar _RemovarArchivo(const tipoCarβcter* punteroCarβcterNombreDeArchivo);

asidero estandarEntrar _EncontrarPrimerArchivo(const tipoCarβcter* punteroCarβcterNombreDeArchivo, dataDeEncuentro* punteroDataParaEncontrar);

enum fileFindLevel {fileFindStandard = 1};

asidero estandarEntrar _EncontrarPrimerArchivoExtendido(const tipoCarβcter* punteroCarβcterNombreDeArchivo, fileFindLevel fileFindLevellnformation, vacφo* pfileFindData, opcionesDeEncontrarArchivo fileFindSearch, vacφo* pSearchFilter, doblePalabra double WordAdditionalFlags);

decisi≤n estandarEntrar _EncontrarPr≤ximoArchivo(asidero handleFindFile, dataDeEncuentro* punteroDataParaEncontrar);

decisi≤n estandarEntrar _CerrarEncuentro(asidero handleFindFile);

doblePalabra estandarEntrar _EncontrarCamino(const tipoCarβcter* punteroCarβcterCamino, const tipoCarβcter* punteroCarβcterNombreDeArchivo, const tipoCarβcter* pointerCharacterExtension, doblePalabra doblePalabraTama±oDeB -f er, tipoCarβcter* punteroCarβcterB-fer, tipoCarβcter* * punteroPunteroCarβcterArchivoParte);

decisi≤n estandarEntrar _CopiarArchivo(const tipoCarβcter* punteroCarβcterOrigen, const tipoCarβcter* punteroCarβcterObjetivo, decisi≤n decidirFracazarSiExiste);

decisi≤n estandarEntrar _MoverArchivo(const tipoCarβcter* punteroCarβcterOrigen, const tipoCarβcter* punteroCarβcterObjetivo);

decisi≤n estandarEntrar _MoverArchivoExtendido(const tipoCarβcter* punteroCarβcterOrigen, const tipoCarβcter* punteroCarβcterObjetivo, doblePalabra doblePalabralndicadores);

doblePalabra estandarEntrar _ObtenerDirectorioDeSistema(tipoCarβcter* punteroCarβcterB -f er, doblePalabra doblePalabraTama±oDeB-fer);

doblePalabra estandarEntrar _ObtenerDirectorioDeVentanas(tipoCarBcter* punteroCarβcterB-fer, doblePalabra doblePalabraTama±oDeB -fer);

decisi≤n estandarEntrar _PonerDirectorioActual(const tipoCarβcter* punteroCarβcterNombreDeCamino);

doblePalabra estandarEntrar _ObtenerDirectorioActual(doblePalabra doblePalabraLargoDeB -fer, tipoCarβcter* punteroCarβcterB-fer); decisi≤n estandarEntrar _CrearDirectorio(const tipoCarβcter* punteroCarβcterNombreDeCamino, atributosDeSeguridad* punteroAtributosDeSeguridad);

decisi≤n estandarEntrar _CrearDirectorioExtendido(const tipoCarβcter* punteroCarβcterDirectorioDePlantilla, const tipoCarβcter* punteroCarβcterDirectorioNuevo, atributosDeSeguridad* punteroAtributosDeSeguridad);

decisi≤n estandarEntrar _RemovarDirectorio(const tipoCarβcter* punteroCarβcterNombreDeCamino);

asidero estandarEntrar _EncontrarPrimerNotificaci≤nDeCambio(const tipoCarβcter* punteroCarβcterNombreDeCamino, decisi≤n decidirMirarSubβrbol, doblePalabra doblePalabraFiltroDeNotif icaci ≤ n) ;

decisi≤n estandarEntrar _EncontrarPr≤ximaNotificaci≤nDeCambio(asidero asideroCambio);

decisi≤n estandarEntrar _CerrarEncuentroDeNotificaci≤nDeCambio(asidero asideroCambio);

#fin si

#si definida(incluirCanal)

asidero estandarEntrar _CrearCanal(const tipoCarβcter* punteroCarβcterNombre, doblePalabra doblePalabraModoDeApertura, doblePalabra doblePalabraModoDeCanal, doblePalabra doblePalabraMβximasInstancias, doblePalabra doblePalabraTama±oDeB-ferAfuera, doblePalabra doblePalabraTama±oDeB -f erEn, doblePalabra doblePalabraTiempoDeEsperaPredeterminado, atributosDeSeguridad* punteroAtributosDeSeguridad);

decisi≤n estandarEntrar _ConectarCanal(asidero asideroCanal, traslapado* punteroTraslapado);

decisi≤n estandarEntrar _DesconectarCanal(asidero asideroCanal);

decisi≤n estandarEntrar _PonerEstadoDeCanal(asidero asideroCanal, doblePalabra* punteroDoblePalabraModo, doblePalabra* punteroDoblePalabraMβximoDeColecci≤ n, doblePalabra* punteroDoblePalabraTiempoDeEsperaDeColecci≤n);

decisi≤n estandarEntrar _ObtenerEstadoDeCanal(asidero asideroCanal, doblePalabra* pointerDoubleWordDestination, doblePalabra* punteroDoblePalabralnstancias, doblePalabra* punteroDoblePalabraMβximoDeColecci≤n, doblePalabra* punteroDoblePalabraTiempoDeEsperaDeColecci≤n, tipoCarβcter* punteroCarβcterNombreDeUsuario, doblePalabra doblePalabraTama±oDeNombreDeUsuario);

decisi≤n estandarEntrar _ObtenerInformaci≤nDeCanal(asidero asideroCanal, doblePalabra* punteroDoblePalabralndicadores, doblePalabra* punteroDoblePalabraTama±oDeB -ferAfuera, doblePalabra* punteroDoblePalabraTama±oDeB-ferEn, doblePalabra* punteroDoblePalabraMBximoInstancias); decisi≤n estandarEntrar _MirarCanal(asidero asideroCanal, vacφo* punteroB-fer, doblePalabra doblePalabraTama±oDeB-fer, doblePalabra* punteroDoblePalabraBytesLeφdo, doblePalabra* punteroDoblePalabraBytesDisponible, doblePalabra* punteroDoblePalabraBytesQuedan);

decisi≤n estandarEntrar _NegociarCanal(asidero asideroCanal, vacφo* punteroB-ferEn, doblePalabra doblePalabraTama±oDeB-fer, vacφo* punteroB-ferAfuera, doblePalabra doblePalabraTama±oDeB -f er Afuera, doblePalabra* punteroDoblePalabraBytesLeφdo, traslapado* punteroTraslapado);

decisi≤n estandarEntrar _ImitarClienteDeCanal(asidero asideroCanal);

decisi≤n estandarEntrar CallNamedPipe(const tipoCarβcter* punteroCarβcterNombre, vacφo* punteroB-ferEn, doblePalabra doblePalabraTama±oDeB -ferEn, vacφo* punteroB -fer Afuera, doblePalabra doblePalabraTama±oDeB-ferAfuera, doblePalabra* punteroDoblePalabraLeφdo, doblePalabra doblePalabraTiempoDeEspera); #fin_si

#si definida(incluirlnf ormaci≤ nDeSistema) vacφo estandarEntrar GetSystemInfo(informaci≤ nDeSistema * punteroInformaci≤nDeSistema); #fin si #si definida(incluirTiempo)

vacφo estandarEntrar _ObtenerTiempoDeSistema(tiempoDeSistema* punteroTiempoDeSistema);

decisi≤n estandarEntrar _AjustarTiempoDeSistema(const tiempoDeSistema* punteroTiempoDeSistema);

vacφo estandarEntrar _ObtenerTiempoLocal(tiempoDeSistema* punteroTiempoDeSistema);

decisi≤n estandarEntrar _AjustarTiempoLocal(const tiempoDeSistema* punteroTiempoDeSistema);

d o b l e P a l a b r a e s t a n d a r E n t r a r

_ObtenerInformaci≤nDeTiempoDeZona(informaci≤nDeZonaDeTiempo* punterolnf ormaci≤ nDeZonaDeTiempo);

decisi≤n estandarEntrar _PonerInformaci≤nDeTiempoDeZona(const informaci≤nDeZonaDeTiempo* punteroInformaci≤nDeZonaDeTiempo);

decisi≤n estandarEntrar _TiempoDeSistemaATiempoDeArchivo(const tiempoDeSistema* punteroTiempoDeSistema, tiempoDeArchivo * punteroTiempoDeArchivo);

decisi≤n estandarEntrar _TiempoDeArchivoALocalTiempoDeArchivo(const tiempoDeArchivo * punteroTiempoDeArchivo, tiempoDeArchivo * punteroTiempoDeArchivoLocal);

decisi≤n estandarEntrar _TiempoDeArchivoLocalATiempoDeArchivo(const tiempoDeArchivo *punteroTiempoDeArchivoLocal, tiempoDeArchivo* punteroTiempoDeArchivo);

decisi≤n estandarEntrar_TiempoDeArchivoASistemaTiempo(const tiempoDeArchivo *punteroTiempoDeArchivo, tiempoDeSistema* punteroTiempoDeSistema);

entero estandarEntrar _CompararTiempoDeArchivo(const tiempoDeArchivo* punteroTiempoDeArchivoA, const tiempoDeArchivo* punteroTiempoDeArchivoB);

decisi≤n estandarEntrar _TiempoDeArchivoAFechaTiempo(const tiempoDeArchivo* punteroTiempoDeArchivo, palabra* punteroPalabraArchivoAsignaci≤nTablaFecha, palabra* punteroPalabraArchivoAsignaci≤ nTablaTiempo);

decisi≤n estandarEntrar _FechaTiempoATiempoDeArchivo(palabra palabraFechaDeTablaDe Asignaci ≤ nDe Archivo, palabra palabraTiempoDeTablaDeAsignaci≤nDeArchivo, tiempoDeArchivo* punteroTiempoDeArchivo); #fin si

#si definida(incluirSubproceso)

asidero estandarEntrar _ObtenerSubprocesoActual0;

asidero estandarEntrar _CrearSubproceso(atributosDeSeguridad* punteroSeguridadParaSubproceso, doblePalabra doblePalabraTama±oDePila, funci ≤nSubproceso funci≤nDirecci≤n, vacφo* punteroParβmetro, doblePalabra doblePalabralndicadores, doblePalabra* punteroDoblePalabraldentitadDeSubproceso);

asidero estandarEntrar _CrearSubprocesoRemoto(asidero asideroProceso, atributosDeSeguridad* punteroSeguridadParaSubproceso, doblePalabra doblePalabraTama±oDePila, funci≤nSubproceso funci≤nDirecci≤n, vacφo* punteroParβmetro, doblePalabra doblePalabralndicadores, doblePalabra* punteroDoblePalabraldentitadDeSubproceso);

doblePalabra estandarEntrar _PonerIdentidadDeSubprocessoActualO;

decisi≤n estandarEntrar _PonerPrioridadDeSubproceso(asidero asideroSubproceso, entero enteroPrioridad);

entero estandarEntrar _ObtenerPrioridadDeSubproceso(asidero asideroSubproceso);

decisi≤n estandarEntrar _ObtenerTiemposDeSubproceso(asidero asideroSubproceso, tiempoDeArchivo* punteroTiempoDeArchivoCrear, tiempoDeArchivo* punteroTiempoDeArchivoSalir, tiempoDeArchivo * punteroTiempoDe ArchivoN- cleo, tiempoDeArchivo * punteroTiempoDeArchivoUsuario);

decisi≤n estandarEntrar _TerminarSubproceso(asidero asideroSubproceso, doblePalabra doblePalabraC≤ digoDeSalida);

decisi≤n estandarEntrar _ObtenerC≤digoDeSalidaDeSubproceso(asidero asideroSubproceso, doblePalabra* punteroDoblePalabraC≤digoDeSalida); decisi≤n estandarEntrar _ObtenerEntradaDeSelectorDeSubproceso(asidero asideroSubproceso, doblePalabra doblePalabraSelector, vacφo* punteroEntradaDeSelector);

decisi≤n estandarEntrar _ObtenerContextoDeSubproceso(asidero asideroSubproceso, contexto* punteroContextoDeSubproceso);

decisi≤n estandarEntrar _PonerContextoDeSubproceso(asidero asideroSubproceso, const contexto* punteroContextoDeSubproceso);

doblePalabra estandarEntrar _SuspenderSubproceso(asidero asideroSubproceso);

doblePalabra estandarEntrar _ReanudarSubproceso(asidero asideroSubproceso);

vacφo estandarEntrar _SalirSubprocesso(doblePalabra doblePalabraC≤digoDeSalida);

#fin si

#si definida(incluirProceso)

doblePalabra _ObtenerRecursoDeGrβficos(asidero asideroProceso, doblePalabra doblePalabralndicadores);

decisi≤n estandarEntrar _PonerClaseDePrioridad(asidero asideroProceso, doblePalabra doubleWordPriorityClass);

doblePalabra estandarEntrar _ObtenerClaseDePrioridad(asidero asideroProceso); vacφo estandarEntrar _ObtenerInformaci≤nDeComienzo(informaci≤nDeComienzo* punterolnf ormaci ≤ nDeComienzo);

asidero estandarEntrar _ObtenerProcesoActual0;

asidero estandarEntrar _AbrirProceso(doblePalabra doblePalabraAcceso, decisi≤n decidirHeredar, doblePalabra doblePalabraldentidadDeProceso);

decisi ≤ n estandarEntrar _CrearProceso(const tipoCarβ cter * punteroCarβcterNombreDe Aplicaci ≤ n, const tipoCarβcter* punteroCarβcterLφneaDeComando, atributosDeSeguridad* punteroSeguridadParaProceso, atributosDeSeguridad* punteroSeguridadParaSubproceso, decisi≤n decidirHeredarAsideros, doblePalabra doblePalabralndicadoresDeCreaci≤n, vacφo* punteroAmbiente, const tipoCarβcter* punteroCarβcterDirectorioActual, inf ormaci ≤ nDeComienzo * punterolnf ormaci≤ nDeComienzo, procesolnformaci≤n* punteroProcesoInformaci≤n);

decisi≤n estandarEntrar _CrearProcesoComoUsario(asidero asideroFicha, const tipoCarβcter* punteroCarβcterNombreDeAplicaci≤n, const tipoCarβcter* punteroCarβcterLφneaDeComando, atributosDeS eguridad * punteroS eguridadParaProceso, atributosDeSeguridad* punteroSeguridadParaSubproceso, decisi≤n decidirHeredarAsideros, doblePalabra doblePalabralndicadoresDeCreaci ≤ n, vacφo* punteroAmbiente, const tipoCarβcter* punteroCarβcterDirectorioActual, inf ormaci≤ nDeComienzo * punteroInformaci≤nDeComienzo, procesolnformaci≤n* punteroProcesoInformaci≤n);

decisi≤n estandarEntrar GetProcessWorkingSetSize(asidero asideroProceso, doblePalabra* pointerDoubleWordWorkingSetSizeMinimum, doblePalabra* pointerDoubleWordWorkingSetSizeMaximum);

decisi≤n estandarEntrar SetProcessWorkingSetSize(asidero asideroProceso, doblePalabra doubleWordMinimumWorkingSetSize, doblePalabra doubleWordMaximumWorkingSetSize);

doblePalabra estandarEntrar _CargarM ≤ dulo(const carβcter* punteroCarβcterNombreDeM≤ dulo, vacφo* punteroCargarParβmetros);

decisi≤n estandarEntrar _TerminarProceso(asidero asideroProceso, doblePalabra doblePalabraC≤digoDeSalida);

decisi≤n estandarEntrar __ObtenerC≤digoDeSalidaDeProceso(asidero asideroProceso, doblePalabra* punteroDoblePalabraC≤ digoDeSalida);

decisi≤n estandarEntrar _ObtenerTiemposDeProceso(asidero asideroProceso, tiempoDeArchivo* punteroTiempoDeArchivoCrear, tiempoDeArchivo* punteroTiempoDeArchivoSalir, tiempoDeArchivo * punteroTiempoDeArchivoN-cleo, tiempoDeArchivo * punteroTiempoDeArchivoUsuario);

decisi≤n estandarEntrar _LeerMemoriaDeProceso(asidero asideroProceso, const vacφo* punteroBaseDirecci≤n, vacφo* punteroB-fer, doblePalabra doblePalabraTama±o, doblePalabra* punteroDoblePalabraLeφdo);

decisi≤n estandarEntrar _EscribirMemoriaDeProceso(asidero asideroProceso, vacφo* punteroBaseDirecci≤n, vacφo* punteroB-fer, doblePalabra doblePalabraTama±o, doblePalabra* punteroDoblePalabraEscrito);

decisi≤n estandarEntrar _PurgarCacheDeInstrucci≤n(asidero asideroProceso, const vacφo* punteroBaseDirecci≤n, doblePalabra doblePalabraTama±o);

decisi≤n estandarEntrar SetProcessShutdownParameters(doblePalabra doblePalabraNivel, doblePalabra doblePalabralndicadores);

decisi≤n estandarEntrar GetProcessShutdownParameters(doblePalabra* punteroDoblePalabraNivel, doblePalabra* punteroDoblePalabralndicadores);

asidero estandarEntrar _ObtenerMont≤nDeProceso0;

doblePalabra estandarEntrar _ObtenerIdentidadDeProcesoActual0;

vacφo estandarEntrar _SalirProceso(doblePalabra doblePalabraC≤digoDeSalida);

#fin si #si definida(incluirM≤dulo)

asidero estandarEntrar _ObtenerAsideroDeM≤dulo(const tipoCarβcter* punteroCarβcterNombreDeM≤ dulo);

doblePalabra estandarEntrar _ObtenerNombreDeArchivoDeM≤ dulo(asidero asideroM≤dulo, tipoCarβcter* punteroCarβcterNombreDeArchivo, doblePalabra doblePalabraTama±o);

asidero estandarEntrar _CargarBiblioteca(const tipoCarβcter* punteroCarβcterNombreDeArchivo);

asidero estandarEntrar _CargarBibliotecaExtendido(const tipoCarβcter* punteroCarβcterNombreDeArchivo, asidero asideroArchivo, doblePalabra doblePalabralndicadores);

decisi≤n estandarEntrar _LiberarBiblioteca(asidero handleLibrary);

punteroFunci≤nestandarEntrar_ObtenerDirecci≤nDeFunci≤n(asidero asideroM≤dulo, const tipoCarβcter* pointerCharacterProcessName);

doblePalabra estandarEntrar _Tama±oDeRecurso(asidero asideroM≤dulo, asidero asiderolnf ormaci≤ nDeRecurso);

asidero estandarEntrar _EncontrarRecurso(asidero asideroM≤dulo, const tipoCarβcter* punteroCarβcterNombre, const tipoCarβcter* punteroCarβcterTipo);

asidero estandarEntrar _EncontrarRecursoExtendido(asidero asideroM≤dulo, const tipoCarβcter* punteroCarβcterTipo, const tipoCarβcter* punteroCarβcterNombre, palabra palabraLenguaje);

decisi≤n estandarEntrar _EnumerarTiposDeRecurso(asidero asideroM≤dulo, funci≤ nEnumerarTipoDeRecurso punteroFunci≤nEnumerar, largo largoParβmetro);

decisi≤n estandarEntrar _EnumerarNombresDeRecurso(asidero asideroM≤dulo, const tipoCarβcter* punteroCarβcterTipo, funci≤nEnumerarNombreDeRecurso punteroFunci≤nEnumerar, largo largoParβmetro);

decisi≤n estandarEntrar _EnumerarLengagesDeRecurso(asidero asideroM≤dulo, const tipoCarβcter* punteroCarβcterTipo, const tipoCarβcter* punteroCarβcterNombre, funci≤ nEnumerarLenguajeDeRecurso punteroFunci≤nEnumerar, largo largoParβmetro); #fin si

#si definida(incluirRecurso)

e n u m i n d i c a d o r e s D e R e c u r s o

{indicadorDeRecursoNinguno=0,indicadorDeRecursoDesechar=2};

asidero estandarEntrar _ComenzarActualizaci≤nDeRecurso(const tipoCarβcter* punteroCarβcterNombreDeArchivo, decisi≤n decidirEliminarExistente);

decisi≤n estandarEntrar _ActualizarRecurso(asidero asideroActualizar, const tipoCarβcter* punteroCarβcterTipo, const tipoCarβcter* punteroCarβcterNombre, palabra palabraLenguaje, vacφo* punteroData, doblePalabra doblePalabraData);

decisi≤n estandarEntrar _AcabarActualizaci≤nDeRecurso(asidero asideroActualizar, decisi≤n decidirDesechar); #fin_si

#si definida(incluirS eguridad)

decisi≤n estandarEntrar _AsignarIdentidad _rnica(-nica* pointerUnique);

decisi≤n estandarEntrar ImpersonateSelf iivelDeFicha nivelDeFichaMisma);

decisi≤n estandarEntrar RevertToSelfO;

decisi≤n estandarEntrar _ChequearAcceso(describidor* punteroDescribidor, asidero asideroCliente, doblePalabra doblePalabraAcceso, const genΘrico* punteroGenΘrica, privilegios* punteroPrivilegios, doblePalabra* punteroDoblePalabraLargoDePrivilegio, doblePalabra* punteroDoblePalabraAccesoPermitido, decisi≤ n* punteroDecidirEstatusDeAcceso);

decisi≤n estandarEntrar _AbriFichaDeProcesor(asidero asideroProceso, doblePalabra doblePalabraAcceso, asidero* puntero AsideroFicha);

decisi≤n estandarEntrar _AbrirFichaDeSubproceso(asidero asideroSubproceso, doblePalabra doblePalabraAcceso, decisi≤n decidirAbrirComoMismo, asidero* puntero AsideroFicha);

decisi≤ n estandarEntrar _PonerFichaDeSubproceso(asidero * punteroAsideroSubproceso, asidero asideroFicha);

decisi≤n estandarEntrar _DuplicarFicha(asidero asideroFicha, nivelDeFicha nivelDeFichaDuplicar, asidero* punteroAsideroDuplicar);

decisi≤n estandarEntrar _DuplicarFichaExtendido (asidero asideroExistente, doblePalabra doblePalabraAccesoRequerido, atributosDeS eguridad * pattributesToken, nivelDeFicha nivelDeFichaDuplicar, tipoDeFicha tipoDeFichalmitaci≤n, asidero * puntero AsideroFichaNeuva);

decisi≤n estandarEntrar _ObtenerInformaci≤nDeFicha(asidero asideroFicha, claseDeFicha informaci≤nDeClaseDeFicha, vacφo* punteroInformaci≤nDeFicha, doblePalabra doblePalabraLargoDelnformaci≤nDeFicha, doblePalabra* punteroDoblePalabraLargoRetornado);

decisi≤n estandarEntrar _PonerInformaci≤nDeFicha(asidero asideroFicha, claseDeFicha informaci≤nDeClaseDeFicha, vacφo * punterolnf ormaci ≤ nDeFicha, doblePalabra doblePalabraLargoDelnformaci≤nDeFicha);

decisi≤n estandarEntrar _AjustarPrivilegiosDeFicha(asidero asideroFicha, decisi≤n decidirlnhabilitarTodo, privilegiosDeFicha* punteroPrivilegiosDeFichaNuevo, doblePalabra doblePalabraLargoDeB-fer, privilegiosDeFicha* punteroPrivilegiosDeFichaAnterior, doblePalabra* pointerDoubleWordRetumLength);

decisi≤n estandarEntrar _AjustarGrouposDeFicha(asidero asideroFicha, decisi≤n decidirReponerAPredeterminado, gruposDeFicha* punteroGruposDeFichaNuevo, doblePalabra doblePalabraLargoDeB -fer, gruposDeFicha* punteroGruposDeFichaAnterior, doblePalabra* pointerDoubleWordRetumLength);

decisi≤n estandarEntrar _ChequearPrivilegio(asidero asideroFicha, privilegios * pprivilegesRequired, decisi≤n* punteroDecidirResultado);

decisi≤n estandarEntrar _EstβValidaIdentidad(identidad* punteroldentidad);

decisi≤n estandarEntrar _CompararIdentidad(identidad* punteroIdentidadA, identidad* punteroIdentidadB);

decisi≤n estandarEntrar _CompararIdentidadDePrefijo(identidad* punteroIdentidadA, identidad* punteroIdentidadB);

doblePalabra estandarEntrar _ObtenerLargoDeIdentidadRequerido(sinsignoCarβcter sinsignoCarβcterCuentaDeSubautoridad);

decisi≤n estandarEntrar _AsignarIdentidad(const autoridad* a, byte byteCuentaDeSubautoridad, doblePalabra doblePalabraSubautoridadO, doblePalabra doblePalabraSubautoridadl, doblePalabra doblePalabraSubautoridad2, doblePalabra doblePalabraSubautoridad3, doblePalabra doblePalabraSubautoridad4, doblePalabra doblePalabraSubautoridad5, doblePalabra doblePalabraSubautoridadO, doblePalabra doblePalabraSubautoridad7, identidad* * punteroPunteroIdentidad);

vacφo* estandarEntrar _LiberarIdentidad(identidad* punteroldentidad);

decisi≤n estandarEntrar _lnicializarldentidad(identidad* punteroldentidad, const autoridad* puntero Autoridad, byte byteCuentaDeSubautoridad);

autoridad* estandarEntrar _ObtenerAutoridadDeIdentidad(identidad* punteroldentidad) ;

doblePalabra* estandarEntrar _ObtenerSubautoridadDeIdentidad(identidad* punteroldentidad, doblePalabra doubleWordSubauthority); s i n s i g n o C a r β c t e r * e s t a n d a r E n t r a r _ObtenerCuentaDeSubautoridadesDeIdentidad(identidad* punteroldentidad);

sinsigno estandarEntrar_ObtenerLargoDeIdentidad(const identidad* punteroldentidad);

decisi≤n estandarEntrar _CopiarIdentidad(doblePalabra doblePalabraLargoDeDestino, identidad* punteroIdentidadDestino, identidad * punteroIdentidadOrigen);

decisi≤n estandarEntrar _EncontrarIdentidadDeCuenta(const tipoCarβcter* punteroCarβcterNombreDeSistema, identidad* punteroldentidad, tipoCarβcter* punteroCarβcterNombreDeCuenta, doblePalabra* punteroDoblePalabraNombreDeCuenta, tipoCarβcter* punteroCarβcterNombreDeDominioReferido, doblePalabra* punteroDoblePalabraNombreDeDominioRefiri≤, tipoDeCuenta* punteroCuentaUtilizaci≤n);

decisi≤n estandarEntrar _EncontrarNombreDeCuenta(const tipoCarβcter* punteroCarβcterNombreDeSistema, const tipoCarβcter* punteroCarβcterNombreDeCuenta, identidad* punteroldentidad, doblePalabra* punteroDoblePalabraldentidad, tipoCarβcter* punteroCarβcterNombreDeDominioReferido, doblePalabra* punteroDoblePalabraNombreDeDominioRefiri≤, tipoDeCuenta* punteroCuentaUtilizaci≤n); decisi≤n estandarEntrar _EstBValidaListaDeAcceso(listaDeAcceso* punteroListaDeAcceso);

decisi≤n estandarEntrar _InicializarListaDeAcceso(listaDeAcceso* punteroListaDeAcceso, doblePalabra doblePalabraLargo, doblePalabra doblePalabraRevisi≤n);

decisi≤n estandarEntrar _ObtenerInformaci≤nDeListaDeAcceso(listaDeAcceso* punteroListaDeAcceso, vacφo* punterolnformaci≤n, doblePalabra doblePalabraLargoDelnformaci≤n, doblePalabra doblePalabraClaseDelnf ormaci≤ n);

decisi≤n estandarEntrar _PonerInformaci≤nDeListaDeAcceso(listaDeAcceso* punteroListaDeAcceso, vacφo* punterolnformaci≤n, doblePalabra doblePalabraLargo, doblePalabra doblePalabraClaseDelnf ormaci ≤ n) ;

decisi≤n estandarEntrar _A±adirEntradaDeAcceso(listaDeAcceso * punteroListaDeAcceso, doblePalabra doblePalabraRevisi≤ n, doblePalabra doblePalabra=ndice, vacφo* punteroEntrada, doblePalabra doblePalabraLargo);

decisi≤n estandarEntrar _EliminarEntradaDeAcceso(listaDeAcceso* punteroListaDeAcceso, doblePalabra doblePalabra=ndice); decisi≤n estandarEntrar _ObtenerEntradaDeAcceso(listaDeAcceso* punteroListaDeAcceso, doblePalabra doblePalabra=ndice, entradaDeAcceso* * pointerPaccessEntry);

decisi≤n estandarEntrar _A±adirEntradaDeAccesoPermitido(listaDeAcceso* punteroListaDeAcceso, doblePalabra doblePalabraRevisi≤n, doblePalabra doblePalabraMβscaraDeAcceso, const identidad* punteroldentidad);

decisi≤n estandarEntrar _A±adirEntradaDeAccesoNegado(listaDeAcceso* punteroListaDeAcceso, doblePalabra doblePalabraRevisi≤n, doblePalabra doblePalabraMβscaraDeAcceso, const identidad* punteroldentidad);

decisi≤n estandarEntrar _A±adirEntradaDeAccesoDeAuditorφa(listaDeAcceso* punteroListaDeAcceso, doblePalabra doblePalabraRevisi≤n, doblePalabra doblePalabraMβscaraDeAcceso, const identidad* punteroldentidad, decisi≤n decidirAuditorφafxito, decisi≤n decidirAuditorφaFracaso);

decisi≤n estandarEntrar _EncontrarEntradaDeAccesoLibre(listaDeAcceso* punteroListaDeAcceso, entradaDeAcceso* * pointerPaccessEntry);

decisi≤n estandarEntrar _InicializarDescribidor(vacφo* punteroDescribidor, doblePalabra doblePalabraRevisi≤n); decisi≤n estandarEntrar _EstβValidaDescribidor(const describidor* punteroDescribidor);

doblePalabra estandarEntrar _ObtenerLargoDeDescribidor(const describidor* punteroDescribidor);

decisi≤n estandarEntrar _ObtenerControlDeDescribidor(const describidor* punteroDescribidor, palabra* punteroControlDeSeguridad, doblePalabra* punteroDoblePalabraRevisi≤n);

decisi≤n estandarEntrar _PonerListaDeAccesoDiscrecionalDeDescribidor(vacφo* punteroDescribidor, decisi ≤ n decidirDiscrecionalPresente, HstaDeAcceso* punteroListaDeAccesoDiscrecional, decisi≤n decidirDiscrecionalPredeterminado);

decisi≤n estandarEntrar _ObtenerListaDeAccesoDiscrecionalDeDescribidor(vacφo* punteroDescribidor, decisi≤n* pointerDecideDiscretionaryPresent,

HstaDeAcceso** punteroPunteroListaDeAccesoDiscrecional, decisi≤n* pointerDecideDiscretionaryDefaulted);

decisi≤n estandarEntrar _PonerListaDeAccesoSistemaDeDescribidor(vacφo* punteroDescribidor, decisi≤n decidirSistemaPresente, HstaDeAcceso * punteroListaDeAccesoSistema, decisi≤n decidirSistemaPredeterminado);

decisi≤n estandarEntrar _ObtenerListaDeAccesoSistemaDeDescribidor(vacφo* punteroDescribidor, decisi≤n* pointerDecideSystemPresent,

HstaDeAcceso** punteroPunteroListaDeAccesoSistema, decisi≤n* pointerDecideSystemDefaulted);

decisi≤n estandarEntrar _PonerDue±oDeDescribidor(vacφo* punteroDescribidor, identidad* punteroIdentidadDue±o, decisi≤n decideOwnerDefaulted);

decisi≤n estandarEntrar _ObtenerDue±oDeDescribidor(vacφo* punteroDescribidor, identidad* * punteroPunteroIdentidadDue±o, decisi≤n* punteroDecidirDue±oPredeterminado);

decisi≤n estandarEntrar _PonerGroupoDeDescribidor(vacφo* punteroDescribidor, . identidad* punteroIdentidadGrupo, decisi≤n decidirGrupoPredeterminado);

decisi≤n estandarEntrar _ObtenerGroupoDeDescribidor(vacφo* punteroDescribidor, identidad** ppidentityGroup, decisi≤n* punteroDecidirGrupoPredeterminado);

decisi≤n estandarEntrar _CrearDescribidorDeObjeto(describidor* punteroDescribidorMaestro, describidor* punteroDescribidorCreador, describidor** punteroPunteroDescribidorNuevo, decisi≤n decidirEstβDirectorio, asidero asideroFicha, const genΘrico* punteroGenΘrica);

decisi≤n estandarEntrar _PonerDescribidorDeObjeto(doblePalabra doblePalabralnformaci≤nDeSeguridad, describidor* punteroDescribidorModificar, describidor* * punteroPunteroDescribidorObjeto, const genΘrico* punteroGenΘrica, asidero asideroFicha);

decisi≤n estandarEntrar _ObtenerDescribidorDeObjeto(describidor* punteroDescribidorObj eto, doblePalabra doblePalabralnformaci≤nDeSeguridad, describidor* punteroDescribidorResultado, doblePalabra doblePalabraLargoDeDescribidor, doblePalabra* punteroDoblePalabraLargoRetornado);

decisi≤n estandarEntrar _DestruirDescribidorDeObjeto(vacφo * * punteroPunteroDescribidor Obj eto); _

decisi≤n estandarEntrar _HacerDescribidorRelativoASiMismo(const vacφo* punteroDescribidorAbsoluto, vacφo* punteroDescribidorRelativoASiMismo, doblePalabra* punteroDoblePalabraLargoDeB -fer);

decisi≤n estandarEntrar _HacerDescribidorAbsoluto(const describidor* punteroDescribidorRelativoASiMismo, describidor* punteroDescribidorAbsoluto, doblePalabra* punteroDoblePalabraTama±oAbsoluto, HstaDeAcceso* punteroListaDeAccesoDiscrecional, doblePalabra* punteroDoblePalabraTama±oDeDiscrecional,

HstaDeAcceso * punteroListaDe AccesoSistema, doblePalabra* punteroDoblePalabraTama±oDeSistema, identidad* punteroIdentidadDue±o, doblePalabra* punteroDoblePalabraTama±oDeDue±o, identidad* punteroIdentidadGrupoPrimario, doblePalabra* punteroDoblePalabraTama±oDeGrupoPrimario);

decisi≤n estandarEntrar _PonerDescribidorDeArchivo(const tipoCarβcter* punteroCarβcterNombreDeArchivo, doblePalabra doblePalabralnformaci≤n, const describidor* punteroDescribidorArchivo);

decisi≤n estandarEntrar _ObtenerDescribidorDeArchivo(const tipoCarβcter* punteroCarβcterNombreDeArchivo, doblePalabra doblePalabralnformaci≤ n, describidor* punteroDescribidorArchivo, doblePalabra doblePalabraLargo, doblePalabra* punteroDoblePalabraRequerido);

decisi≤n estandarEntrar _ObtenerDescribidorDeObjetoDeN-cleo(asidero asideroObjeto, doblePalabra doblePalabralnformaci≤ n, describidor* punteroDescribidor, doblePalabra doblePalabraLargo, doblePalabra* punteroDoblePalabraRequerido);

decisi≤n estandarEntrar _PonerDescribidorDeObjetoDeN-cleo(asidero asideroObjeto, doblePalabra doblePalabralnformaci≤n, describidor* punteroDescribidor); decisi ≤n estandarEntrar _AccesoPermitidoTodo(doblePalabra doblePalabraAccesoPermitido, doblePalabra doblePalabraAccesoNecesario);

decisi≤n estandarEntrar _AccesoPermitidoCualquiera(doblePalabra doblePalabraAccesoPermitido, doblePalabra doblePalabraAccesoNecesario);

decisi≤n estandarEntrar _ChequearAccesoYAlarmaDeAuditorφa(const tipoCarβcter* punteroCarβcterNombreDeSubsistema, vacφo* punteroAsidero, tipoCarβcter* punteroCarβcterNombreDeTipoDeObjeto, tipoCarβcter* punteroCarβcterNombreDeObj eto, vacφo* punteroDescribidorSeguridad, doblePalabra doblePalabraAcceso, const genΘrico* punteroGenΘrica, decisi≤n decidirCrearObjeto, doblePalabra* punteroDoblePalabraAccesoPermitido, decisi < n * punteroDecidirEstatusDe Acceso, decisi ≤ n* punteroDecidirGenerarAlCerrar) ;

vacφo estandarEntrar _MaρearMβscaraGenΘrica(doblePalabra* punteroDoblePalabraMβscaraDeAcceso, genΘrico* punteroGenΘrica);

decisi≤n estandarEntrar _EncontrarValorDePrivilegio(const tipoCarβcter* punteroCarβcterNombreDeSistema, const tipoCarβcter* punteroCarβcterNombre,

^•nica* -nicaEncontrar); decisi≤n estandarEntrar _EncontrarNombreDePrivilegio(const tipoCarβcter* punteroCarβcterNombreDeSistema,

•nica* -nicaNombre, tipoCarβcter* punteroCarβcterNombre, doblePalabra* punteroDoblePalabraNombre);

decisi≤n estandarEntrar _EncontrarNombreParaVisualizaci≤nDePrivilegio(const tipoCarβcter* punteroCarβcterNombreDeSistema, const tipoCarβcter* punteroCarβcterNombre, tipoCarβcter* punteroCarβcterNombreParaVisualizaci≤n, doblePalabra* punteroDoblePalabraNombreParaVisualizaci≤n, doblePalabra* punteroDoblePalabraldentidadDeLenguaje); #fin si

#si definida(incluirServicio)

decisi≤n estandarEntrar _CambiarServicioDeConfiguraci≤n(asidero asideroServicio, doblePalabra doblePalabraTipoDeServicio, doblePalabra doblePalabraTipoDeDestino, doblePalabra doblePalabraControlDeError, const tipoCarβcter* punteroCarβcterNornbreDeCaminoDeBinario, const tipoCarβcter* punteroCarβcterGrupoDeOrdenDeCarga, doblePalabra* punteroDoblePalabraldentidadDeEtiqueta, const tipoCarβcter* punteroCarβcterDependencias, const tipoCarβcter* punteroCarβcterNombreDeComienzoDeServicio, const tipoCarβcter* punteroCarβcterContrase±a, const tipoCarβcter* punteroCarβcterNombreParaVisualizaci≤n);

decisi≤n estandarEntrar _CerrarAsideroDeServicio(asidero asideroControlServicio);

asidero estandarEntrar _AbrirManagerDeServicio(const tipoCarβcter* punteroCarβcterNombreDeMβquina, const tipoCarβcter* punteroCarβcterNombreDeBaseDeData, doblePalabra doblePalabraAccesoNecesario);

decisi≤n estandarEntrar _EnumerarEstβtusDeServicios(asidero asideroManager, doblePalabra doblePalabraTipoDeServicio, doblePalabra doblePalabraEstadoDeServicio, enumerarEstatusDeServicio * punteroServicios, doblePalabra doblePalabraTama±oDeB-fer, doblePalabra* punteroDoblePalabraBytesRequerido, doblePalabra* punteroDoblePalabraServicios, doblePalabra* punteroDoblePalabraAsideroParaReanundar);

decisi≤n estandarEntrar _ObtenerNombreDeClaveDeServicio(asidero asideroManager, const tipoCarβcter* punteroCarβcterNombreParaVisualizaci≤n, tipoCarβcter* punteroCarβcterNombreDeServicio, doblePalabra* punteroDoblePalabraB-fer); decisi≤n estandarEntrar _ObtenerNombreParaVisualizaci≤nDeServicio(asidero asideroManager, const tipoCarβcter* punteroCarβcterNombreDeServicio, tipoCarβcter* punteroCarβcterNombreParaVisualizaci≤n, doblePalabra* punteroDoblePalabraB-fer);

asidero estandarEntrar _AbrirServicio(asidero asideroManager, const tipoCarβcter* punteroCarβcterNombreDeServicio, doblePalabra doblePalabraAccesoNecesario);

asidero estandarEntrar _CrearServicio(asidero asideroManager, const tipoCarβcter* punteroCarβcterNombreDeServicio, const tipoCarβcter* punteroCarβcterNombreParaVisualizaci≤n, doblePalabra doblePalabraAccesoNecesario, doblePalabra doblePalabraTipoDeServicio, doblePalabra doblePalabraTipoDeDestino, doblePalabra doblePalabraControlDeError, const tipoCarβcter* punteroCarβcterNombreDeCaminoDeBinario, const tipoCarβcter* punteroCarβcterGrupoDeOrdenDeCarga, doblePalabra* punteroDoblePalabraldentidadDeEtiqueta, const tipoCarβcter* punteroCarβcterDependencias, const tipoCarβcter* punteroCarβcterNombreDeComienzoDeServicio, const tipoCarβcter* punteroCarβcterContrase±a);

decisi≤n estandarEntrar _EHminarServicio(asidero asideroServicio);

decisi≤n estandarEntrar _ControlarServicio(asidero asideroServicio, doblePalabra doblePalabraControl, estatusDeServicio* punteroEstatusDeServicio);

decisi≤n estandarEntrar _PreguntarServicioDeConfiguraci≤n(asidero asideroServicio, configuraci≤nDeServicio* pserviceConfigation, doblePalabra doblePalabraTama±oDeB-fer, doblePalabra* punteroDoblePalabraBytesRequerido);

decisi≤n estandarEntrar _EnumerarServiciosDependientes(asidero asideroServicio, doblePalabra doblePalabraEstadoDeServicio, enumerarEstatusDeServicio* punteroServicios, doblePalabra doblePalabraTama±oDeB -fer, doblePalabra* punteroDoblePalabraBytesRequerido, doblePalabra* punteroDoblePalabraServicios);

decisi≤n estandarEntrar _PreguntarEstatusDeServicioDeBloqueo(asidero asideroManager, estatusDeBloqueoDeServicio * pointerServiceLockStatus, doblePalabra doblePalabraTama±oDeB-fer, doblePalabra* punteroDoblePalabraBytesRequerido);

decisi≤n estandarEntrar _PreguntarServicioDeDescribidorDeObjeto(asidero asideroServicio, doblePalabra doblePalabralnformaci≤nDeSeguridad, vacφo * punteroDescribidorSeguridad, doblePalabra doblePalabraTama±oDeB -fer, doblePalabra* punteroDoblePalabraBytesRequerido);

decisi≤nestandarEntrar_PonerDescribidorDeObjetoDeServicio(asidero asideroServicio, doblePalabra doblePalabralnformaci≤nDeSeguridad, vacφo* punteroDescribidorSeguridad);

decisi≤n estandarEntrar _PreguntarEstatusDeServicio(asidero asideroServicio, estatusDeServicio* punteroEstatusDeServicio);

decisi≤n estandarEntrar _ComenzarServicio(asidero asideroServicio, doblePalabra double WordNumberServiceParameters, const tipoCarβcter** punteroPunteroCarβcterServicioParβmetro);

doblePalabra estandarEntrar RegisterServiceCtrlHandler(const tipoCarβcter* punteroCarβcterNombreDeServicio, funci≤nManipulador punteroFunci≤nManipulador);

decisi≤n estandarEntrar SetServiceStatus(doblePalabra asideroEstatusDeServicio, estatusDeServicio* punteroEstatusDeServicio);

decisi≤n estandarEntrar Starts erviceCtrlDispatcher(entradaDeTablaDeServicio* punteroEntradaDeTablaDeServicio);

#fin_si }

#fin si APPENDIX C2 #sindef_graphics_functions_included #definir _graphics_functions_included

#incluir "g_unidefs.h"

externo "C"

{

#si definida(incluirDispositivo)

asidero estandarEntrar _CrearDispositivoCompatible(asidero asideroDispositivo);

asidero estandarEntrar _CrearDispositivo(const tipoCarβcter* punteroCarβcterControlador, const tipoCarβcter* punteroCarβcterDispositivo, const tipoCarβcter* punteroCarβcterSalida, const modoDeDispositivo* punteroModoDeDispositivoInicial);

asidero estandarEntrar _CrearDispositivoDeInformaci≤n(const tipoCarβcter* punteroCarβcterControlador, const tipoCarβcter* punteroCarβcterDispositivo, const tipoCarβcter* punteroCarβcterSalida, const modoDeDispositivo* punteroModoDeDispositivoInicial);

asidero estandarEntrar _CrearMetaArchivo(asidero asideroReferenciaDeDispositivo, const tipoCarβcter* punteroCarβcterNombreDeArchivo, const rectBngulo* punteroRectβnguloLφmite, const tipoCarβcter* punteroCarβcterDescripci≤n);

asidero estandarEntrar _CopiarMetaArchivo(asidero asideroDispositivo, const tipoCarβcter* punteroCarβcterNombreDeArchivo); asidero estandarEntrar _CargarMetaArchivo(const tipoCar^βcter* punteroCarβcterNombreDeArchivo);

asidero estandarEntrar _PonerBitsDeMetaArchivo(sinsigno sinsignoTama±oDeData, const byte* punteroByteData);

asidero estandarEntrar _PonerBitsDeMetaArchivoDeVentanas(sinsigno sinsignoTama±oDeB -fer, const byte* punteroByteB-fer, asidero asideroReferenciaDeDispositivo, const metaPintar* punteroMetaTama±oDeCuadro);

decisi≤n estandarEntrar _EliminarMetaArchivo(asidero);

asidero estandarEntrar _ObtenerDispositivo(asidero asidero Ventana);

asidero estandarEntrar _ObtenerDispositivoMejorado(asidero asidero Ventana, asidero asideroRecortarRegi≤n, sinsigno sinsignolndicadores);

asidero estandarEntrar _ObtenerContextoDeDispositivoDeVentana(asidero asideroVentana);

entero estandarEntrar _LiberarDispositivo(asidero asideroVentana, asidero asideroDispositivo);

asidero estandarEntrar _ComenzarPintar(asidero asideroVentana, pintura* punteroPintura);

decisi≤n estandarEntrar _AcabarPintar(asidero asideroVentana, const pintura* punteroPintura); asidero estandarEntrar _CerrarMetaArchivo(asidero asideroDispositivo);

decisi≤n estandarEntrar _EHminarDispositivo(asidero asideroDispositivo);

decisi≤n estandarEntrar _Dibujar Arco (asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior, entero enteroComienzoDeArcoX, entero enteroComienzoDeArcoY, entero enteroExtremoDeArcoX, entero enteroExtremoDeArcoY);

decisi≤n estandarEntrar _DibujarArcoA(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior, entero enteroRadiallX, entero enteroRadiallY, entero enteroRadial2X, entero enteroRadial2Y);

decisi≤n estandarEntrar _DibujarArco-Lngulo(asidero asideroDispositivo, entero enteroCentroX, entero enteroCentroY, doblePalabra doblePalabraRadio, decimal decimaP-nguloComenzar, decimal decima nguloSubtender); entero estandarEntrar _ObtenerDirecci≤nDeArco(asidero asideroDispositivo);

entero estandarEntrar _PonerDirecci≤nDeArco(asidero asideroDispositivo, entero enteroDirecci≤n);

decisi≤n estandarEntrar _ObtenerFiltroDeRatioDeAspecto(asidero asideroDispositivo, dimensiones* pointerDimensionsAspect);

decisi≤n estandarEntrar _TransferirBits(asidero asideroDispositivo, entero enteroDestinoX, entero enteroDestinoY, entero enteroAnchoDeDestino, entero enteroAlturaDeDestino, asidero asideroOrigenDeDispositivo, entero enteroOrigenlzquierda, entero enteroOrigenSuperior, doblePalabra doblePalabraOperaci≤nDeCuadrφculo);

decisi≤n estandarEntrar _TransferirBitsConMβscara(asidero asideroDispositivo, entero enteroDestinoIzquierda, entero enteroDestinoSuperior, entero enteroAncho, entero enteroAltura, asidero asideroOrigenDeDispositivo, entero enteroOrigenlzquierda, entero enteroOrigenSuperior, asidero asideroMBscaraDeBitmapa, entero enteroDesplazamientoDeMBscaraX, entero enteroDesplaza ientoDeMBscaraY, doblePalabra doblePalabraOperaci≤nDeCuadrφculo); decisi≤n estandarEntrar _TransferirBitsDeParalel≤gramo(asidero asideroDispositivo, const punto* formaci≤nPuntoVΘrtices, asidero asideroOrigenDeDispositivo, entero enteroOrigenlzquierda, entero enteroOrigenSuperior, entero enteroAncho, entero enteroAltura, asidero asideroMBscaraDeBitmapa, entero enteroDesplazamientoDeMBscaraX, entero enteroDesplazamientoDeMBscaraY);

decisi≤n estandarEntrar _TransferirBitsConDise±o(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroAncho, entero enteroAltura, doblePalabra doblePalabraOperaci≤nDeCuadrφculo);

decisi≤n estandarEntrar _EstirarBits(asidero asideroDispositivo, entero enteroDestinoIzquierda, entero enteroDestinoSuperior, entero enteroAnchoDeDestino, entero enteroAlturaDeDestino, asidero asideroOrigenDeDispositivo, entero enteroOrigenlzquierda, entero enteroOrigenSuperior, entero enteroAnchoDeOrigen, entero enteroAlturaDeOrigen, doblePalabra doblePalabraOperaci≤nDeCuadrφculo);

entero estandarEntrar _ObtenerModoParaEstirarBits(asidero asideroDispositivo); entero estandarEntrar _PonerModoParaEstirarBits(asidero asideroDispositivo, entero enteroModo);

sinsigno estandarEntrar _ObtenerRectBnguloDeLφmites(asidero asideroDispositivo, rectβngulo* punteroRectBnguloLφmites, sinsigno sinsignolndicadores);

sinsigno estandarEntrar _PonerRectβnguloDeLφmites(asidero asideroDispositivo, const rectβngulo* punteroRectβnguloLφmites, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _ObtenerOrigenDePincel(asidero asideroDispositivo, punto* punteroPuntoOrigen);

decisi≤n estandarEntrar _PonerOrigenDePincel(asidero asideroPincel, entero enteroX, entero entero Y, punto* punteroPuntoAnterior);

decisi≤n estandarEntrar _CancelarDispositivo(asidero asideroDispositivo);

entero estandarEntrar _ObtenerCapacidadesDeDispositivo(asidero asideroDispositivo, entero entero=ndice);

decisi≤n estandarEntrar _ObtenerAnchoDeCarβcter(asidero asideroDispositivo, sinsigno sinsignoCarBcterPrimero, sinsigno sinsignoCarBcter_rltimo, entero* formaci≤nEnteroAnchos);

decisi < n estandarEntrar _ObtenerDecimalAnchoDeCarBcter(asidero asideroDispositivo, sinsigno sinsignoCarBcterPrimero, sinsigno sinsignoCarBcter f-ltimo, decimal* formaci≤nDeci alAnchos);

decisi≤n estandarEntrar _ObtenerAbcAnchosDeCarBcter(asidero asideroDispositivo, sinsigno sinsignoCarBcterPrimero, sinsigno sinsignoCarBcter ltimo, abc* punteroAbcAnchos);

decisi≤n estandarEntrar _ObtenerAbcDecimalDeCarBcter(asidero asideroDispositivo, sinsigno sinsignoCarBcterPrimero, sinsigno sinsignoCarBcter _rltimo, abcDecimal* punteroAbcDecimalAnchos); o

decisi≤n estandarEntrar _DibujarCuerda(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior, entero enteroRadiallX, entero enteroRadiallY, entero enteroRadial2X, entero enteroRadial2Y);

entero estandarEntrar _ObtenerCuadroDeRecorte(asidero asideroDispositivo, rectβngulo* punteroRectβnguloRecortar);

decisi≤n estandarEntrar _SeleccionarCaminoDeRecorte(asidero asideroDispositivo, entero enteroModo);

entero estandarEntrar _ExcluirRectBnguloDeRecorte(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior);

entero estandarEntrar _IntersectarRectβnguloDeRecorte(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior);

entero estandarEntrar _DesplazarRegi≤nDeRecorte(asidero asideroDispositivo, entero enteroDesplazamientoX, entero enteroDesplazamientoY);

entero estandarEntrar _ObtenerRegi≤nDeRecorte(asidero asideroDispositivo, asidero asideroRegi≤n);

entero estandarEntrar _SeleccionarRegi≤nDeRecorte(asidero asideroDispositivo, asidero asideroRegi≤n);

entero estandarEntrar _SeleccionarRegi≤nDeRecorteExtendido(asidero asideroDispositivo, asidero asideroRegi≤n, entero enteroModo);

decisi≤n estandarEntrar _ObtenerAdjusteDeColor(asidero asideroDispositivo, adjusteDeColor* punteroAdjusteDeColor);

decisi≤n estandarEntrar _PonerAdjusteDeColor(asidero asideroDispositivo, const adjusteDeColor* punteroAdjusteDeColor); color estandarEntrar _ObtenerColorDeFondo(asidero asideroDispositivo);

color estandarEntrar _PonerColorDeFondo(asidero asideroDispositivo, color colorDeFondo);

decisi≤n estandarEntrar _ActualizarColores(asidero asideroDispositivo);

decisi≤n estandarEntrar _ComentarioGrβfico(asidero asideroDispositivo, sinsigno sinsignoLargo, const byte* pointerCharacterComment);

decisi≤n estandarEntrar _ObtenerOrigenDeDispositivo(asidero asideroDispositivo, punto* punteroPuntoOrigen);

entero estandarEntrar _EstirarBitsDeBitmapa(asidero asideroDispositivo, entero enteroDestinoIzquierda, entero enteroDestinoSuperior, entero enteroAnchoDeDestino, . entero enteroAlturaDeDestino, entero enteroOrigenlzquierda, entero enteroOrigenSuperior, entero enteroAnchoDeOrigen, entero enteroAlturaDeOrigen, const vacφo* pBitData, const informaci≤nDeBitmapa* punteroBitmapalnformaci≤n, sinsigno sinsignoUtilizaci≤ nDeColor, doblePalabra doblePalabraOperaci≤nDeCuadrφculo);

entero estandarEntrar _PonerBitsDeBitmapaADispositivo(asidero asideroDispositivo, entero enteroDestinoIzquierda, entero enteroDestinoSuperior, sinsignoLargo sinsignoLargoAncho, sinsignoLargo sinsignoLargoAltura, entero enteroOrigenFinallzquierdaX, entero enteroOrigenFinallzquierdaY, sinsigno sinsignoComienzoDeEscaneo, sinsigno sinsignoLφneasDeEscaneo, const vacφo* pBitData, const informaci≤nDeBitmapa* punteroBitmapalnformaci≤n, sinsigno sinsignoUtilizaci≤nDeColor);

sinsigno estandarEntrar _ObtenerColoresDeBitmapa(asidero asideroDispositivo, sinsigno sinsigno=ndiceDeComienzo, sinsigno sinsignoEntradas, rva* formaci≤nRVAColores);

sinsigno estandarEntrar _PonerColoresDeBitmapa(asidero asideroDispositivo, sinsigno sinsigno=ndiceDeComienzo, sinsigno sinsignoEntradas, const rva* formaci≤nRVAColores);

entero estandarEntrar _ComenzarDocumento(asidero asideroDispositivo, const informaci≤nDeDocumento* punteroInformaci≤nDeDocumento);

entero estandarEntrar _AcabarDocumento(asidero asideroDispositivo);

entero estandarEntrar _ComenzarPBgina(asidero asideroDispositivo);

entero estandarEntrar _AcabarPBgina(asidero asideroDispositivo);

entero estandarEntrar _CancelarDocumento(asidero asideroDispositivo); entero estandarEntrar _PonerFunci≤nDeCancelaci≤nDeDocumento(asidero asideroDispositivo, funci≤ nCancelarDocumento punteroFunci≤ nParaCancelar);

decisi≤n estandarEntrar _PuntoDeDispositivoAPuntoL≤gico(asidero asideroDispositivo, punto* formaci≤nPuntoConvertir, entero enteroPuntos);

decisi≤n estandarEntrar DrawEdge(asidero asideroDispositivo, const rectβngulo* prectangle, sinsigno sinsignoTipo, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar DrawFrameControl(asidero asideroDispositivo, const rectβngulo* prectangle, . sinsigno sinsignoTipo, sinsigno sinsignoEstado);

decisi≤n estandarEntrar _DibujarElipse(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior);

entero estandarEntrar _EjecutarEscapa(asidero asideroDispositivo, entero enteroEscape, entero enteroLargoDeB-ferEn, const carβcter* puntero CarBcterB -fer, vacφo* punteroB-ferAfuera); entero estandarEntrar _EjecutarEscapeExtendido(asidero asideroDispositivo, entero enteroEscape, entero enteroLargoDeB-ferEn, const carβcter* punteroCarβcterB-ferEn, entero enteroLargoDeB-ferAfuera, carβcter* punteroCarβcterB-ferAfuera);

entero estandarEntrar _DibujarEscape(asidero asideroDispositivo, entero enteroEscape, entero enteroLargoDeB-fer, const carβcter* punteroCarβcterB-fer);

decisi≤n estandarEntrar _CerrarFigura(asidero asideroDispositivo);

decisi≤n estandarEntrar _RellenarViejo(asidero asideroDispositivo, entero enteroComienzoX, entero enteroComienzoY, color colorParaLlenar);

decisi≤n estandarEntrar _Rellenar(asidero asideroDispositivo, entero enteroComienzoX, entero enteroComienzoY, color colorParaLlenar, sinsigno sinsignoTipoDeLleno);

sinsignoLargo estandarEntrar _ObtenerDataDeFuente(asidero asideroDispositivo, sinsignoLargo sinsignoLargoMΘtrica, sinsignoLargo unsignedLongOffset, vacφo* punteroB-fer, sinsignoLargo sinsignoLargoLargo); entero estandarEntrar _EnumerarFamiliasDeFuente(asidero asideroDispositivo, const tipoCarβcter* punteroCarβcterFamilia, funci ≤nEnumerarFuentes punteroFunci≤nEnumerar, lparBmetro lParβmetro);

entero estandarEntrar _EnumerarFamiliasDeFuenteExtendidas(asidero asideroDispositivo, const fuenteL≤gica* punteroFuenteL≤gica, funci≤nEnumerarFuentes punteroFunci≤nEnumerar, lparBmetro lParβmetro, doblePalabra doblePalabralndicadores);

entero estandarEntrar _EnumerarFuentes(asidero asideroDispositivo, const tipoCarβcter* punteroCarBcterNombreDeFace, funci≤nEnumerarFuentes punteroFunci≤nEnumerar, lparBmetro lParβmetro);

decisi≤n estandarEntrar _DibujarRect6nguloDeEnfoque(asidero asideroDispositivo, const rectβngulo* punteroRectBnguloDibujar);

sinsignoLargo estandarEntrar _ObtenerContornoDeGlφfico(asidero asideroDispositivo, sinsigno sinsignoCarβcterParaDφa, sinsigno sinsignoFormato, mΘtricosDeGlφfico * punteroMΘtricasDeGlφf ico, sinsignoLargo sinsignoLargoLargoDeB-fer, vacφo* punteroB-fer, const ematriz* punteroEMmatriz);

entero estandarEntrar _ObtenerModoDeGrβficos(asidero asideroDispositivo);

entero estandarEntrar _PonerModoDeGlφficos(asidero asideroDispositivo, entero enteroModo);

decisi≤n estandarEntrar _DibujarIcono(asidero asideroDispositivo, entero enteroX, entero entero Y, asidero asiderolcono);

decisi≤n estandarEntrar DrawIconEx(asidero asideroDispositivo, entero enteroX, entero entero Y, asidero asiderolcono, entero enteroAncho, entero enteroAltura, sinsigno sinsignoEtapa, asidero asideroPincelDeFondo, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _EstBElPuntoVisible(asidero asideroDispositivo, entero enteroPosici≤nX, entero enteroPosici≤nY);

decisi≤n estandarEntrar _EstβElRectβnguloVisible(asidero asideroDispositivo, const rectβngulo* punteroRectβnguloPrueba);

sinsignoLargo estandarEntrar _ObtenerParesCercanos(asidero asideroDispositivo, sinsignoLargo sinsignoLargoPares, parCercano * punteroParesCercanos);

decisi≤n estandarEntrar _LφneaA(asidero asideroDispositivo, entero enteroExtremoX, entero enter oExtremoY); decisi≤n estandarEntrar _LφneaDDA(entero enteroComienzoX, entero enteroComienzoY, entero enteroExtremoX, entero enteroExtremoY, funci≤nTrazarLφnea punteroFunci≤ nTrazarLφnea, lparBmetro lParβmetro);

decisi≤n estandarEntrar _DibujarLφneas(asidero asideroDispositivo, const punto* f ormaci≤ nPuntoVΘrtices, doblePalabra doblePalabra VΘrtices);

decisi≤n estandarEntrar _DibujarLφneasA(asidero asideroDispositivo, const punto* formaci≤nPunto VΘrtices, doblePalabra doblePalabra VΘrtices);

decisi≤n estandarEntrar _DibujarPoliPolilφneas(asidero asideroDispositivo, const punto* formaci≤ nPuntoVΘrtices, const sinsignoLargo* formaci≤nSinsignoCuentas, sinsignoLargo sinsignoLargoCuentas) ;

decisi≤n estandarEntrar _PuntoL≤gicoAPuntoDispositivo(asidero asideroDispositivo, punto* formaci≤nPuntoConvertir, entero enteroPuntos);

entero estandarEntrar _ObtenerModoDeUnidad(asidero asideroDispositivo);

entero estandarEntrar _PonerModoDeUnidad(asidero asideroDispositivo, entero enteroModo);

sinsignoLargo estandarEntrar _PonerIndicatoresDeMapeadorDeFuentes(asidero asideroDispositivo, sinsignoLargo sinsignolndicadores);

sinsigno estandarEntrar _ObtenerBitsDeMetaArchivo(asidero asideroMetaArchivo, sinsigno sinsignoTama±oDeB-fer, byte* punteroB-fer);

sinsigno estandarEntrar _ObtenerDescripci≤nDeMetaArchivo(asidero asideroMetaArchivo, sinsigno sinsignoTama±oDeB-fer, tipoCarβcter* punteroCarBcterB-fer);

decisi≤n estandarEntrar _EnumerarMetaArchivo(asidero asideroDispositivo, asidero asideroMetaArchivo, funci≤ nEnumerarMetaArchivo punteroFunci≤nEnumerar, vacφo* punteroDataDeEnumeraci≤n, const rectβngulo* punteroRectβnguloLφmite);

decisi≤n estandarEntrar _PonerMeta Archivo (asidero asideroDispositivo, asidero asideroMetaArchivo, const rectβngulo* punteroRectβnguloLφmite);

decisi≤n estandarEntrar _PonerRegistroDeMetaArchivo(asidero asideroDispositivo, asideroTabla* punteroAsideroObjetosDeTabla, const meta* punteroMetaPoner, sinsigno sinsignoAsideros);

sinsigno estandarEntrar _ObtenerDescripci≤nDeMetaArchivo(asidero asideroMetaArchivo , sinsigno sinsignoTama±oDeB-fer, tipoCarβcter* punteroCarBcterB-fer); sinsigno estandarEntrar _ObtenerCabeceraDeMetaArchivo(asidero asideroMetaArchivo, sinsigno sinsignoTama±oDeB-fer, metaCabecera* punteroPreguntarMetaCabecera);

sinsigno estandarEntrar _ObtenerEntradasDePaletaDeMetaArchivo(asidero asideroMetaArchivo, sinsigno sinsignoEntradas, entradaDePaleta* formaci≤nEntradasDePaleta);

sinsigno estandarEntrar _ObtenerBitsDeMetaArchivoDeVentanas(asidero asideroMetaArchivo, sinsigno sinsignoB-fer, byte* punteroByteB-fer, entero enteroModoDeUnidad, asidero asideroReferenciaDeDispositivo);

decisi≤n estandarEntrar _ObtenerMetaRegi≤n(asidero asideroDispositivo, asidero asideroRegi≤n);

entero estandarEntrar _PonerMetaRegi≤n(asidero asideroDispositivo);

decisi≤n estandarEntrar _ObtenerLφmiteDeMitra(asidero asideroDispositivo, decimal* punteroDΘcimaleLφmite);

decisi≤n estandarEntrar _PonerLφmiteDeMitra(asidero asideroDispositivo, decimal dΘcimaleLφmiteNuevo, decimal* punteroDΘcimaleLφmiteAnterior);

entero estandarEntrar _ObtenerMezclaDeFondo(asidero asideroDispositivo);

entero estandarEntrar _PonerMezclaDeFondo(asidero asideroDispositivo, entero enteroModo);

entero estandarEntrar _ObtenerMezclaDePrimerPlano(asidero asideroDispositivo);

entero estandarEntrar _PonerPrimerPlanoDeMezcla(asidero asideroDispositivo, entero enteroModoDeDibujar);

color estandarEntrar _ObtenerColorMasCercano(asidero asideroDispositivo, color colorMasCercano);

entero estandarEntrar _EnumerarObjetoGrBfico(asidero asideroDispositivo, entero enteroTipoDeObjeto, funci≤nEnumerarObjetoGrβfico punteroFunci≤nEnumerar, lparBmetro lParβmetro);

asidero estandarEntrar _SeleccionarObjeto(asidero asideroDispositivo, asidero asideroObjeto);

asidero estandarEntrar _ObtenerObjetoActual(asidero asideroDispositivo, sinsigno sinsignoTipoDeObjeto);

sinsigno estandarEntrar _ObtenerMΘtricosDeTextoDeContorno(asidero asideroDispositivo, sinsigno sinsignoTama±o, mΘtricosDeContornoDeTexto* punteroPreguntarMΘtricasDeContorno);

doblePalabra estandarEntrar GetCharacterPlacement(asidero asideroDispositivo, const tipoCarβcter* punteroCarBcterSecuencia, entero enteroLargoDeSecuencia, entero integerMaximumExtent, carβcterColocaci≤n* pointerCharacterPlacement, doblePalabra doblePalabralndicadores);

sinsigno estandarEntrar _RealizarPaleta(asidero asideroDispositivo);

asidero estandarEntrar _SeleccionarPaleta(asidero asideroDispositivo, asidero asideroPaleta, decisi≤n decidirObligarFondo);

decisi≤n estandarEntrar _CancelarCamino(asidero asideroDispositivo);

decisi≤n estandarEntrar _ComenzarCamino(asidero asideroDispositivo);

decisi≤n estandarEntrar _AcabarCamino(asidero asideroDispositivo);

decisi≤n estandarEntrar _LlenarCamino(asidero asideroDispositivo);

decisi≤n estandarEntrar _AplanarCamino(asidero asideroDispositivo);

entero estandarEntrar _ObtenerCamino(asidero asideroDispositivo, punto* formaci≤nPunto VΘrtices, byte* formaci≤nByteTipos, entero enteroContar);

decisi≤n estandarEntrar _TrazarCamino(asidero asideroDispositivo);

decisi≤n estandarEntrar _TrazarALlenarCamino(asidero asideroDispositivo);

decisi≤n estandarEntrar _EnsancharCamino(asidero asideroDispositivo);

decisi≤n estandarEntrar _DibujarSector(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior, entero enteroRadiallX, entero enteroRadiallY, entero enteroRadial2X, entero enteroRadial2Y);

entero estandarEntrar _ObtenerFormatoDePixel(asidero asideroDispositivo);

decisi≤n estandarEntrar _PonerFormatoDePixel(asidero asideroDispositivo, entero, const describidorDeFormatoDePixel*);

color estandarEntrar _ObtenerPixel(asidero asideroDispositivo, entero enteroPosici≤nX, entero enteroPosici≤nY);

color estandarEntrar _PonerPixel(asidero asideroDispositivo, entero enteroPosici≤nX, entero enteroPosici≤nY, color colorAPoner);

decisi≤n estandarEntrar _PonerPixelRβpido(asidero asideroDispositivo, entero enteroPosici≤nX, entero enteroPosici≤nY, color colorAPoner);

decisi≤n estandarEntrar _PoliDibujar (asidero asideroDispositivo, const punto* formaci≤nPuntos, const byte* formaci≤nByteTipos, entero enteroContar);

entero estandarEntrar _ObtenerModoDeRelleno(asidero asideroDispositivo);

entero estandarEntrar _PonerModoDeLlenar(asidero asideroDispositivo, entero enteroModoDeRelleno);

decisi≤n estandarEntrar _DibujarPolφgono(asidero asideroDispositivo, const punto* formaci≤nPunto VΘrtices, entero entero VΘrtices);

decisi≤n estandarEntrar _PoliPolφgono(asidero asideroDispositivo, const punto* formaci≤ nPuntoVΘrtices, const doblePalabra* formaci≤nEntero VΘrtices, doblePalabra doblePalabraPolφgonos);

decisi≤n estandarEntrar _ObtenerPosici≤nActual(asidero asideroDispositivo, punto* puntoPosici≤n);

decisi≤n estandarEntrar _MoverA(asidero asideroDispositivo, entero enteroPosici≤nNuevoX, entero enteroPosici≤nNuevoY, punto* punteroPuntoPosici≤nAnterior);

decisi≤n estandarEntrar _DibujarRectBngulo(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior); decisi≤n estandarEntrar _DibujarRectBnguloRedondeado(asidero asideroDispositivo, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior, entero enteroAncho, entero enteroAltura);

decisi≤n estandarEntrar __LlenarRectBngulo(asidero asideroDispositivo, const rectβngulo* punteroRectβnguloLlenar, asidero asideroPincel);

decisi≤n estandarEntrar _EnmarcarRectBngulo(asidero asideroDispositivo, const rectβngulo* punteroRectβnguloEnmarcar, asidero asideroPincel);

decisi≤n estandarEntrar _InvertirRectBngulo(asidero asideroDispositivo, const rectβngulo* punteroRectβnguloInvertir);

decisi≤n estandarEntrar _LlenarRegi≤n(asidero asideroDispositivo, asidero asideroRegi≤n, asidero asideroPincel);

decisi≤n estandarEntrar _EnmarcarRegi≤n(asidero asideroDispositivo, asidero asideroRegi≤n, asidero asideroPincel, entero enteroAncho, entero enteroAltura);

decisi≤n estandarEntrar _InvertirRegi≤n(asidero asideroDispositivo, asidero asideroRegi≤n);

decisi≤n estandarEntrar _PintarRegi≤n(asidero asideroDispositivo, asidero asideroRegi≤n);

entero estandarEntrar _DesplazarRegi≤n(asidero asideroDispositivo, entero enteroDesplazamientoX, entero enteroDesplazamientoY);

asidero estandarEntrar _ReponerDispositivo(asidero asideroDispositivo, const modoDeDispositivo* punteroModoDeDispositivoAReponer);

decisi≤n estandarEntrar _RestaurarDispositivo(asidero asideroDispositivo, entero enteroIdentidadDeGuarda);

entero estandarEntrar _GuardarDispositivo(asidero asideroDispositivo);

asidero estandarEntrar _VentanaDesdeDispositivo(asidero asideroDispositivo);

entero estandarEntrar _ExcluirRegi≤nDeActualizaci≤n(asidero asideroDispositivo, asidero asideroVentana);

decisi≤n estandarEntrar _DesplazarDispositivo(asidero asideroDispositivo, entero enteroX, entero entero Y, const rectβngulo* punteroRectβnguloDesplazar, const rectβngulo* punteroRectβnguloRecortar, asidero asideroReponerRegi≤n, rectβngulo * punteroRectβnguloActualizar);

decisi≤n estandarEntrar _DibujarC-bico(asidero asideroDispositivo, const punto* formaci≤nPuntos, sinsignoLargo sinsignoLargoPuntos);

decisi≤n estandarEntrar __DibujarC-bicoA(asidero asideroDispositivo, const punto* formaci≤nPuntos, sinsignoLargo sinsignoLargoPuntos);

sinsigno estandarEntrar _ObtenerEntadasDePaletaDeSistema(asidero asideroDispositivo, sinsigno sinsignoComienzo, sinsigno sinsignoEntradas, entradaDePaleta* formaci≤ nEntradasDePaleta);

sinsigno estandarEntrar _ObtenerUtilizaci< nDePaletaDeSistema(asidero asideroDispositivo);

sinsigno estandarEntrar _PonerUtilizaci≤nDePaletaDeSistema(asidero asideroDispositivo, sinsigno sinsignoUtilizaci≤n);

decisi≤n estandarEntrar _DibujarTexto(asidero asideroDispositivo, entero enteroPosici≤nX, entero enteroPosici≤nY, const tipoCarβcter* punteroCarβcterTexto, entero enteroLargo);

decisi≤n estandarEntrar _DibujarTextoVector(asidero asideroDispositivo, entero enteroPosici≤nX, entero enteroPosici≤nY, sinsigno sinsignoOpciones, const rectβngulo* punteroRect^βnguloRecortar, const tipoCarβcter* punteroCar^βcterTexto, sinsigno sinsignoLargo, const entero* f ormaci ≤nEntero Vector);

entero estandarEntrar _DibujarTextoFormateado(asidero asideroDispositivo, const tipoCarβcter* punteroCarβcterSecuencia, doblePalabra doblePalabraCuenta, rectβngulo* prectangle, sinsigno sinsignoFormato);

entero estandarEntrar JDibujarTextoFormateadoExtendido(asidero asideroDispositivo, const tipoCarβcter* punteroCarβcterSecuencia, doblePalabra doblePalabraCuenta, rectβngulo* prectangle, sinsigno sinsignoFormato, parBmetrosDeDibujoDeTexto* punteroListaDeBloqueosDeProcesoDeEntrada);

decisi≤n estandarEntrar _DibujarTextoGris(asidero asideroDispositivo, asidero asideroPincel, funci≤nTextoGris punteroFunci≤nSalida, lparBmetro lParβmetro, entero enteroContar, entero enteroX, entero entero Y, entero enteroAncho, entero enteroAltura);

decisi≤n estandarEntrar _DibujarEstado(asidero asideroDispositivo, asidero asideroPincel, funci≤nDibujarEstado unteroFunci≤nDibujo, lparBmetro lParβmetro, vparBmetro vParBmetro, entero enteroX, entero entero Y, entero enteroAncho, entero enteroAltura, sinsigno sinsignolndicadores);

largo estandarEntrar _DibujarTextoTabulado(asidero asideroDispositivo, entero enteroX, entero entero Y, const tipoCarβcter* punteroCarβcterSecuencia, entero enteroContar, entero enteroPosicionesDeTabulaci≤n, const entero* formaci≤nEnteroPosicionesDeTabulaci≤n, entero enteroOrigenDeTabulaci≤n);

sinsignoLargo estandarEntrar _ObtenerLφmiteDeTextoTabulado(asidero asideroDispositivo, const tipoCarβcter* punteroCarβcterSecuencia, entero enteroContar, entero enteroPosicionesDeTabulaci≤n, entero* formaci≤nEnteroPosicionesDeTabulaci≤n);

sinsigno estandarEntrar _ObtenerAlφneaci≤nDeTexto(asidero asideroDispositivo);

sinsigno estandarEntrar _PonerAlφneaci≤nDeTexto(asidero asideroDispositivo, sinsigno sinsignoModo);

entero estandarEntrar _ObtenerExtraDeCarBcterDeTexto(asidero asideroDispositivo); entero estandarEntrar _PonerExtraDeCarβcter(asidero asideroDispositivo, entero enteroExtraDeCarβcter);

color estandarEntrar _ObtenerColorDeTexto(asidero asideroDispositivo);

color estandarEntrar _PonerColorDeTexto(asidero asideroDispositivo, color colorAPoner);

decisi≤n estandarEntrar _ObtenerExtentoDeTexto(asidero asideroDispositivo, const tipoCarβcter* punteroCarβcterTexto, entero enteroLargoDeTexto, dimensiones * punteroDimensi≤ nesDeExtento);

decisi≤n estandarEntrar _ObtenerExtentoDeVectorDeTexto(asidero asideroDispositivo, const tipoCarβcter* punteroCarβcterTexto, entero enteroLargoDeTexto, entero enteroMBximoDeExtento, entero* formaci≤nEnteroPoner, entero* f ormaci≤ nEnteroDX, dimensiones* punteroDimensi≤nesDeExtento);

entero estandarEntrar _ObtenerFaseDeTexto(asidero asideroDispositivo, entero enteroTama±oDeB-fer, tipoCarβcter* punteroCarβcterB -fer);

decisi≤n estandarEntrar _PonerJustificaci≤nDeTexto(asidero asideroDispositivo, entero enteroExtraDeSeparaci≤n, entero enteroCuentaDeSeparaci≤n);

decisi≤n estandarEntrar _ObtenerMΘtricosDeTexto(asidero asideroDispositivo, mΘtricasDeTexto * punteroPreguntarMΘtricasDeTexto); decisi≤n estandarEntrar _DibujarPoliTexto(asidero asideroDispositivo, const informaci≤nDePoliTexto* textPolylnformationOut, entero enteroSecuencias);

decisi≤n estandarEntrar _ObtenerExtentoDePuertoDeVista(asidero asideroDispositivo, dimensiones* punteroDimensi≤nesDeExtento);

decisi≤n estandarEntrar _PonerExtentoDePuertoDeVista(asidero asideroDispositivo, entero enteroExtentoX, entero enteroExtentoY, dimensiones* punteroDimensi≤nesAnterior);

decisi≤ n estandarEntrar _EscalarExtentoDePuertoDeVista(asidero asideroDispositivo, entero enteroNumeradorX, entero enteroDenominadorX, entero enteroNumeradorY, entero enteroDenominadorY, dimensiones* punteroDimensi≤nesAnterior);

decisi≤ n estandarEntrar _Desplazar OrigenDePuertoDe Vista(asidero asideroDispositivo, entero enteroDesplazamientoX, entero enteroDesplazamientoY, punto* punteroPunto Anterior);

decisi≤ n estandarEntrar _ObtenerOrigenDePuertoDe Vista(asidero asideroDispositivo, punto* punteroPuntoOrigen);

decisi≤n estandarEntrar _PonerOrigenDePuertoDeVista(asidero asideroDispositivo, entero enteroOrigenX, entero enteroOrigenY, punto* punteroPunto Anterior); decisi≤n estandarEntrar _DesplazarOrigenDeVentana(asidero asideroDispositivo, entero enteroDesplazamientoX, entero enteroDesplazamientoY, punto* punteroPunto Anterior);

decisi≤n estandarEntrar _ObtenerOrigenDeVentana(asidero asideroDispositivo, punto* punteroPuntoOrigen);

decisi≤n estandarEntrar _PonerOrigenDeVentana(asidero asideroDispositivo, entero enteroOrigenX, entero enteroOrigenY, punto* punteroPunto Anterior);

decisi≤n estandarEntrar _EscalarExtentoDeVentana(asidero asideroDispositivo, entero enteroNumeradorX, entero enteroDenominadorX, entero enteroNumeradorY, entero enteroDenominadorY, dimensiones * punteroDimensi ≤ nes Anterior);

decisi≤n estandarEntrar __ObtenerExtentoDeVentana(asidero asideroDispositivo, dimensiones* punteroDimensi≤nesDeExtento);

decisi≤n estandarEntrar JPonerExtentoDeVentana(asidero asideroDispositivo, entero enteroExtentoX, entero enteroExtentoY, dimensiones* punteroDimensi ≤ne s Anterior) ;

decisi≤n estandarEntrar_ObtenerTransformaci≤nDeMundo(asidero asideroDispositivo, transf ormaci≤ n* punteroTransformaci≤nDeMundo); decisi≤n estandarEntrar _PonerTransformaci≤nDeMundo(asidero asideroDispositivo, const transformaci≤n* punteroTransformaci≤nDeMundo);

decisi≤n estandarEntrar _ModificarTransformaci≤nDeMundo(asidero asideroDispositivo, const transformaci≤n* punteroTransformaci≤nDeMundo, sinsignoLargo sinsignoLargoModo);

entero estandarEntrar _DescribirFormatoDePixel(asidero asideroDispositivo, entero, sinsigno, describidorDeFormatoDePixel*); #fin_si

#si definida(incluirBitmapa)

asidero estandarEntrar _CargarBitmapa(asidero asiderolnstancia, const tipoCarβcter* punteroCarBcterNombreDeBitmapa);

asidero estandarEntrar _CrearBitmapaCompatible(asidero asideroBitmapa, entero enteroX, entero entero Y);

asidero estandarEntrar _CrearBitmapaDesechable(asidero asideroBitmapa, entero enteroX, entero entero Y);

asidero estandarEntrar _CrearBitmapaIndependienteDeDispositivo(asidero asideroDispositivo, const informaci≤nDeBitmapa* punteroBitmapaCabecera, sinsignoLargo sinsignoLargoInicializar, const vacφo* punteroDatalnicial, const informaci≤nDeBitmapa* punteroBitmapalnformaci≤n, sinsigno sinsignoUtilizaci ≤ nDeColor) ;

asidero estandarEntrar _CrearSecci≤nDeBitmapa(asidero asideroDispositivo, const informaci≤nDeBitmapa* punteroBitmapalnformaci≤n, sinsigno sinsignoUtilizaci ≤n, vacφo** pointerPBits, asidero asideroMapa, sinsignoLargo sinsignoLargoDesplazamientoDeMapa);

asidero estandarEntrar _CrearBitmapa(entero enteroAncho, entero enteroAltura, sinsigno sinsignoPlanos, sinsigno sinsignoBitsPerPixel, const vacφo* punteroDataDeColor);

asidero estandarEntrar _CrearBitmapaIndirecto(const definici≤nDeBitmapa* pbitmapDefinition);

largo estandarEntrar _ObtenerBitsDeBitmapa(asidero asideroBitmapa, largo largoBits, vacφo* pBitData);

largo estandarEntrar _PonerBitsDeBitmapa(asidero asideroBitmapa, sinsignoLargo sinsignoLargoBits, const vacφo* pBitData);

entero estandarEntrar _ObtenerBitsDeBitmapaDispositivoIndependiente(asidero asideroDispositivo, asidero asideroBitmapa, sinsigno sinsignoComienzoDeEscaneo, sinsigno sinsignoLφneasDeEscaneo, vacφo* pBits, informaci≤nDeBitmapa* punteroBitmapalnformaci≤n, sinsigno sinsignoUtilizaci≤n);

entero estandarEntrar _PonerBitmapaDeBitsDispositivoIndependiente(asidero asideroDispositivo, asidero asideroBitmapa, sinsigno sinsignoComienzoDeEscaneo, sinsigno sinsignoLφneasDeEscaneo, const vacφo* pBitData, const informaci≤nDeBitmapa* punteroBitmapalnformaci≤n, sinsigno sinsignoUtilizaci≤nDeColor);

decisi≤n estandarEntrar _ObtenerDimensionesDeBitmapa(asidero asideroBitmapa, dimensiones* punteroDimensi≤nesDeBitmapa);

decisi≤n estandarEntrar _PonerDimensi≤nDeBitmapa(asidero asideroBitmapa, entero enteroAncho, entero enteroAltura, dimensiones* punteroDimensi≤nesAnterior);

decisi≤n estandarEntrar AlphaBlend(asidero handleDeviceDestination, entero enteroDestinoX, entero enteroDestinoY, entero enteroAnchoDeDestino, entero enteroAlturaDeDestino, asidero asideroOrigenDeDispositivo, entero integerSourceX, entero integerSourceY, entero enteroAnchoDeOrigen, entero enteroAlturaDeOrigen, funci≤nDeMezcla blendFunctionBitmap);

decisi≤n estandarEntrar AlphaDIBBlend(asidero handleDeviceDestination, entero enteroDestinoX, entero enteroDestinoY, entero enteroAnchoDeDestino, entero enteroAlturaDeDestino, const vacφo* punteroBits, const informaci≤nDeBitmapa* punteroBitmapalnformaci≤n, sinsigno sinsignolndicadores, entero integerSourceX, entero integerSourceY, entero enteroAnchoDeOrigen, entero enteroAlturaDeOrigen, funci≤nDeMezcla blendFunctionBitmap);

decisi≤n estandarEntrar TransparentBlt(asidero handleDeviceDestination, entero enteroDestinoX, entero enteroDestinoY, entero enteroAnchoDeDestino, entero enteroAlturaDeDestino, asidero asideroOrigenDeDispositivo, entero integerSourceX, entero integerSourceY, entero enteroAnchoDeOrigen, entero enteroAlturaDeOrigen, sinsigno unsignedTransparentRGB);

decisi≤n estandarEntrar TransparentDIBits(asidero handleDeviceDestination, entero enteroDestinoX, entero enteroDestinoY, entero enteroAnchoDeDestino, entero enteroAlturaDeDestino, const vacφo* punteroBits, const informaci≤nDeBitmapa* punteroBitmapalnformaci≤n, sinsigno sinsignolndicadores, entero integerSourceX, entero integerSourceY, entero enteroAnchoDeOrigen, entero enteroAlturaDeOrigen, sinsigno unsignedTransparentRGB); #fin_si

#si definida(incluirPincel)

asidero estandarEntrar _CrearPincelIndirecto(const pincelL≤gico* punteroCrearPincelL≤ gico);

asidero estandarEntrar _CrearPincelDise±oIndependienteDeDispositivo(asidero asideroMemoriaGlobal, sinsigno sinsignoEspecificaci≤nDeColor);

asidero estandarEntrar _CrearPincelDise±oIndependienteDeDispositivoPuntero(const informaci≤nDeBitmapa* bitmapInformationBrush, sinsigno sinsignoEspecificaci≤nDeColor);

asidero estandarEntrar _CrearPincelDise±o(asidero asideroBitmapa);

asidero estandarEntrar _CrearPincelSombreado(entero enteroEstilo, color colorDePincel); asidero estandarEntrar _CrearPincelContinuo(color colorSolido);

#fin si

#si definida(incluirFuente)

asidero estandarEntrar _CrearFuenteIndirecto(const fuenteL≤gica* punteroFuenteL≤ gica);

asidero estandarEntrar _CrearFuente(entero enteroAncho, entero enteroAltura, entero enteroEscape, entero enteroOrientaci≤n, entero enteroPeso, doblePalabra doblePalabraCursiva, doblePalabra doblePalabraSubrayar, doblePalabra doblePalabraTachar, doblePalabra doblePalabraConjuntoDeCarBcter, doblePalabra doblePalabraSalidaDePrecisi≤n, doblePalabra doblePalabraRecortarPrecisi≤n, doblePalabra doblePalabraCalidad, doblePalabra doblePalabraPendienteYFamilia, const tipoCarβcter* pointerCharacterFace);

asidero estandarEntrar CreateFontIndirectEx(const fuenteL≤gicaVectorDeDise±o*);

entero estandarEntrar AddFontResource(const tipoCarβcter* punteroCar^βcterNombreDeArchivo);

entero estandarEntrar AddFontResourceEx(const tipoCarβcter*, doblePalabra, vectorDeDise±o*);

decisi≤n estandarEntrar RemoveFontResourceEx(const tipoCarβcter*, doblePalabra, vectorDeDise±o*);

asidero estandarEntrar AddFontMemResourceEx(vacφo*, doblePalabra, vectorDeDise±o * , doblePalabra*);

decisi≤n estandarEntrar RemoveFontMemResourceEx(asidero handleFontResource);

decisi≤n estandarEntrar CreateScalableFontResource(sinsignoLargo sinsignoLargoEscondido, const tipoCarβcter* punteroCarBcterReservadaDeFuente, const tipoCarβcter* punteroCarβcterArchivoDeFuente, const tipoCarβcter* punteroCarBcterCamino);

decisi≤n estandarEntrar RemoveFontResource(const tipoCarβcter* punteroCarβcterNombreDeArchivo);

#fin si

#si definida(incMetafile) asidero estandarEntrar GetMetaFile (const tipo Carβcter * punteroCarβcterNombreDeMetaArchivo);

asidero estandarEntrar CloseMetaFile(asidero asideroMetaArchivo);

asidero estandarEntrar CopyMetaFile(asidero asideroMetaArchivo, const tipoCarβcter*);

sinsigno estandarEntrar GetMetaFileBitsEx(asidero asideroMetaArchivo, sinsigno sinsignoTama±oDeMetaArchivo, vacφo* punteroB-fer);

decisi≤n estandarEntrar DeleteMetaFile(asidero asideroMetaArchivo); #fin_si

#si definida(incluirObjeto)

decisi≤n estandarEntrar _EHminarObjeto(asidero asideroObjeto);

asidero estandarEntrar _ObtenerObjetoEstBndar(entero enteroObjeto);

sinsignoLargo estandarEntrar _ObtenerTipoDeObjeto(asidero asideroObjeto);

entero estandarEntrar _ObtenerObjeto(asidero asideroObjeto, entero enteroLargoDeB-fer, vacφo* punteroB-fer);

#fin_si

#si definida(incluirPaleta)

asidero estandarEntrar _CrearPaleta(const paletaL≤gica* punteroPaletaL≤gica);

asidero estandarEntrar _CrearPaletaMediotono(asidero asideroDispositivo);

decisi≤n estandarEntrar _AnimarPaleta(asidero asideroPaleta, sinsigno sinsigno=ndiceDeComienzo, sinsigno sinsignoEntradas, const entradaDePaleta* formaci≤nEntradasDePaleta);

sinsigno estandarEntrar _ObtenerEntradasDePaleta(asidero asideroPaleta, sinsigno sinsigno=ndiceDeComienzo, sinsigno sinsignoEntradas, entradaDePaleta* formaci≤nEntradasDePaleta);

sinsigno estandarEntrar _PonerEntradasDePaleta(asidero asideroPaleta, sinsigno sinsigno=ndiceDeComienzo, sinsigno sinsignoEntradas, const entradaDePaleta* formaci≤nEntradasDePaleta);

decisi≤n estandarEntrar _AjustarTama±oDePaleta(asidero asideroPaleta, sinsigno sinsignoTama±oNuevo);

sinsigno estandarEntrar _Obtener=ndiceDePaletaMasCercano(asidero asideroPaleta, color colorAPreguntar);

decisi≤n estandarEntrar _DesrealizarObjeto(asidero asideroObjeto); #fin_si

#si definida(incluirLBpiz)

asidero estandarEntrar _CrearLβpiz(entero enteroEstilo, entero enteroAncho, color colorDeLBpiz);

asidero estandarEntrar _CrearLβpizIndirecto(constlBpizL≤gico* punteroLβpizL≤gico);

asidero estandarEntrar _CrearLβpizExtendido(sinsignoLargo sinsignoLargoEstilo, sinsignoLargo sinsignoLargo Ancho, const pincelL≤ gico * punteroPincelL≤ gicoLBpiz, sinsignoLargo sinsignoLargoEstilosPersonalizado, const sinsignoLargo* punteroSinsignoLargoEstilosPersonalizados); #fin si

#si definida(incluirRegi≤n)

asidero estandarEntrar _CrearRegi≤n(const transformaci≤ n* punteroTransformaci≤nDeRegi≤n, sinsignoLargo sinsignoLargoCuenta, const dataDeRegi≤n* punteroDataDeRegi≤n);

asidero estandarEntrar _CrearRegi≤nElφptica(entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior);

asidero estandarEntrar _CrearRegi≤nElφpticaIndirecto(const rectβngulo* punteroRectβnguloRegi≤n);

asidero estandarEntrar _CrearRegi≤nRectβngularIndirecto(const rectBngulo* punteroRectβnguloRegi≤n);

asidero estandarEntrar _CrearRegi≤nRectBngular(entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior);

asidero estandarEntrar _CrearRegi≤nDeRectβnguloRedondeado(entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior, entero enteroAnchoDeEHpse, entero enteroAlturaDeEHpse);

asidero estandarEntrar _CrearRegi≤ nPolφgono(const punto * f ormaci ≤ nPuntoPolφgonos, entero enteroPuntos, entero enteroModoDeRelleno);

asidero estandarEntrar _CrearRegi≤nPoliPolφgono(const punto* formaci≤nPuntoPolφgonos, const entero* formaci≤nEnteroCuentas, entero enteroContar, entero enteroModoDeRelleno);

asidero estandarEntrar _CaminoARegi≤n(asidero asideroDispositivo);

decisi≤n estandarEntrar _EstBElRectβnguloDentroDeRegi≤n(asidero asideroRegi≤n, const rectBngulo* punteroRectβnguloPrueba);

decisi≤n estandarEntrar _PonerRectBnguloDeRegi≤n(asidero asideroRegi≤n, entero enterolzquierda, entero enteroSuperior, entero enteroDerecho, entero enterolnferior);

entero estandarEntrar CombineRgn(asidero asideroDestinoDeRegi≤n, asidero asideroRegi≤nOrigenl, asidero asideroRegi≤nOrigen2, entero enteroModo); decisi≤n estandarEntrar _CompararRegi≤n(asidero asideroRegi≤nA, asidero asideroRegi≤nB);

sinsignoLargo estandarEntrar _ObtenerDataDeRegi≤n(asidero asideroRegi≤n, sinsignoLargo sinsignoLargoCuenta, dataDeRegi≤n* punteroDataDeRegi≤n);

entero estandarEntrar _ObtenerRectβnguloDeRegi≤n(asidero asideroRegi≤n, rectBngulo * punteroRectβnguloPreguntar);

decisi≤n estandarEntrar _EstβElPuntoDentroDeRegi≤n(asidero asideroRegi≤n, entero enteroX, entero entero Y); #fin_si

#si definida(incluirGrBficoMiscelBnea)

entero estandarEntrar _CapacidadesDeDispositivo(const tipoCarβcter* punteroCarBcterDispositivo, const tipoCarβcter* punteroCarβcterPuerto, sinsignoCorto sinsignoCortoCapacidad, tipoCarβcter* punteroCarβcterSalida, const modoDeDispositivo* punteroModoDeDispositivo);

decisi≤n estandarEntrar _ObtenerCapacidadesDeCuadriculador(cuadrφculoEstatus*, sinsigno);

decisi≤n estandarEntrar GdiFlushO;

sinsignoLargo estandarEntrar _PonerLφmiteDeLote(sinsignoLargo sinsignoLargoLφmite); • sinsignoLargo estandarEntrar _ObtenerLφmiteDeLote0;

entero estandarEntrar ChoosePixelFormat(asidero, const describidorDeFormatoDePixel *);

decisi≤n estandarEntrar CombineTransform(transformaci≤n*, const transformaci≤n *, const transformaci≤n *); #fin si

#si definida(incTheRest) asidero estandarEntrar wglCreateContext(asidero); decisi≤n estandarEntrar wglDeleteContext(asidero); asidero estandarEntrar wglGetCurrentContext(vacφo); asidero estandarEntrar wglGetCurrentDC(vacφo); decisi≤n estandarEntrar wglMakeCurrent(asidero, asidero); decisi≤n estandarEntrar wglUseFontBitmapsA(asidero, sinsignoLargo, sinsignoLargo, sinsignoLargo); decisi≤n estandarEntrar wglUseFontBitmapsW(asidero, sinsignoLargo, sinsignoLargo, sinsignoLargo); #fin_si

} #fin si

APPENDIX C3

#sindef_windows_functions_included #definir _windows_functions_included

#incluir<v_unidefs.h>

externo "C"

#si definida(includeHelp)

decisi≤n estandarEntrar _AyudaParaVentanas(asidero handleMain, const tipoCarβcter* punteroCarβcterAyuda, sinsigno sinsignoComando, doblePalabra doblePalabraData);

#fin_si

#si definida(incluirRegistrar)

Btomo estandarEntrar __RegistrarClase(const informaci≤nDeClase* punteroInformaci≤nDeClase);

Btomo estandarEntrar _RegistrarClaseExtendido(const informaci≤nDeClaseNueva* punteroInformaci≤nDeClase);

decisi≤n estandarEntrar _DesregistrarClase(const tipoCarβcter* punteroCarβcterNombreDeClase, asidero asiderolnstancia);

decisi≤n estandarEntrar _ObtenerInformaci≤nDeClase(asidero asiderolnstancia, const tipoCarβcter* punteroCarβcterNombreDeClase, informaci≤nDeClase* punteroInformaci≤nDeClase);

decisi≤n estandarEntrar _ObtenerInformaci≤nDeClaseExtendido(asidero asiderolnstancia, const tipoCarβcter* punteroCarβcterNombreDeClase, inf ormaci ≤ nDeClaseNue va * punterolnf ormaci ≤ nDeClase);

#fin_si

#si definida(incluirFila)

decisi≤n estandarEntrar _ObtenerMensaje(fila* punteroMensajeDeFila, asidero asideroVentana, sinsigno sinsignoFiltroMφnimo, sinsigno sinsignoFiltroMBximo);

decisi≤n estandarEntrar _TraducirMensaje(const fila* punteroMensajeDeFila);

largo estandarEntrar _DespacharMensaje(const fila* const punteroMensajeDeFila);

decisi≤n estandarEntrar _MirarMensaje(fila* punteroMensajeDeFila, asidero asideroVentana, sinsigno sinsignoFiltroMφnimo, sinsigno sinsignoFiltroMBximo, sinsigno sinsignoRemoverMensage);

decisi≤n estandarEntrar _LlamarFiltroDeMensaje(fila* punteroMensajeDeFila, entero enteroC≤digo); vacφo estandarEntrar _EnviarMensajeADejar(entero enteroC≤digoDeSalφda);

#fin_si

#si definida(incluirVen)

asidero estandarEntrar _VentanaDesdePunto(punto punteroPuntoPosici≤n);

asidero estandarEntrar _CrearVentanaExtendido(doblePalabra doblePalabraEstiloExtendido, const tipoCarβcter* punteroCarβcterNombreDeClase, const tipoCarβcter* punteroCarβcterNombreDeVentana, doblePalabra doblePalabraEstilo, entero enteroX, entero entero Y, entero enteroAncho, entero enteroAltura, asidero asideroMaestro, asidero asideroMen-, asidero asiderolnstancia, vacφo* punteroParBm);

enlφnea asidero _CrearVentana(doblePalabra doblePalabraEstiloExtendido, const tipoCarβcter* punteroCarβcterNombreDeClase, const tipoCarβcter* punteroCarβcterNombreDeVentana, doblePalabra doblePalabraEstilo, entero enteroX, entero entero Y, entero enteroAncho, entero enteroAltura, asidero asideroMaestro, asidero asideroMen-, asidero asiderolnstancia, vacφo* punteroParBm) { retornar _CrearVentanaExtendido(0, punteroCarβcterNombreDeClase, punteroCarβcterNombreDeVentana, doblePalabraEstilo, enteroX, entero Y, enteroAncho, enteroAltura, asideroMaestro, asideroMen-, asiderolnstancia, punteroParBm);

};

asidero estandarEntrar _CrearVentanaDeMultidocumento(const tipoCarβcter* punteroCarβcterNombreDeClase, const tipoCarβcter* punteroCarβcterNombreDeVentana, doblePalabra doblePalabraEstilo, entero enteroX, entero entero Y, entero enteroAncho, entero enteroAltura, asidero asideroMaestro, asidero asiderolnstancia, lparBmetro lParβmetro); asidero estandarEntrar _ObtenerDescendienteDeVentana(asidero asideroVentana, entero enteroIdentidadDeDescendiente);

decisi≤n estandarEntrar _DestruirVentana(asidero asideroDestruir);

decisi≤n estandarEntrar _ObtenerColocaci≤nDeNentana(asidero asideroVentana, colocaci≤n* punteroObtenerColocaci≤n);

decisi≤n estandarEntrar _PonerColocaci≤nDeVentana(asidero asideroVentana, const colocaci≤n* punteroPonerColocaci≤n);

decisi≤n estandarEntrar _TraducirAcelerador(asidero asideroVentana, asidero asideroAcelerador, const fila* punteroMensajeDeFila);

decisi≤n estandarEntrar _CrearCaret(asidero asideroVentana, asidero asideroBitmapa, entero enteroAncho, entero enteroAltura);

decisi≤n estandarEntrar _EsconderCaret(asidero asideroVentana);

decisi≤n estandarEntrar _MostrarCaret(asidero asideroVentana);

asidero estandarEntrar _PonerCaptura(asidero asideroVentana);

asidero estandarEntrar _ObtenerCaptura0;

decisi≤n estandarEntrar JLiberarCapturaO;'

sinsigno estandarEntrar _ObtenerN-meroDeDescendiente(asidero asideroDiBlogo, entero enteroIdentidadDeDescendiente, decisi≤n *punteroDecidirTraducidoo, decisi≤n decidirSigno);

decisi≤n estandarEntrar _PonerN-meroDeDescendiente(asidero asideroDiBlogo, entero enteroIdentidadDeDescendiente, sinsigno sinsignoValor, decisi≤n decidirSigno);

sinsigno estandarEntrar _ObtenerTextoDeDescendiente(asidero asideroDiBlogo, entero enteroIdentidadDeDescendiente, tipoCarβcter* punteroCarβcterSecuencia, doblePalabra doblePalabraLargoDeSecuencia);

decisi≤n estandarEntrar _PonerTextoDeDescendiente(asidero asideroDiBlogo, entero enteroIdentidadDeDescendiente, const tipoCarβcter* punteroCarβcterSecuencia);

decisi≤n estandarEntrar _MarcarDescendiente(asidero asideroDiBlogo, entero enteroIdentidadDeDescendiente, sinsigno sinsignoMarcar);

decisi≤n estandarEntrar _MarcarBot<nDeRadio(asidero asideroDiβlogo, entero enteroBot≤nPimero, entero enteroBot≤n_rltimo, entero enteroBot≤nMarcar);

sinsigno estandarEntrar _EstβDescendienteMarcado(asidero asideroDiBlogo, entero enteroIdentidadDeDescendiente);

largo estandarEntrar _MandarMensajeADescendiente(asidero asideroDiBlogo, entero enteroIdentidadDeDescendiente, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro);

asidero estandarEntrar _DescendienteDesdePunto(asidero asideroMaestroDeVentana, punto puntoDescendiente);

asidero estandarEntrar ChildWindowFromPointEx(asidero asideroMaestroDeVentana, punto puntoDescendiente, sinsigno sinsignoIndicadoresDeSalto);

decisi≤n estandarEntrar _EnumerarDescendientes(asidero asideroMaestroDeVentana, funci≤nEnumerar Ventana pfunctionEnumate, lparBmetro IParBmetro);

asidero estandarEntrar _ObtenerVentanaSuperior(asidero asideroVentana);

entero estandarEntrar _ObtenerNombreDeClase(asidero asideroVentana, . _ tipoCarβcter* punteroCarβcterNombreDeClase, entero enteroLargoDeNombre);

sinsignoCorto estandarEntrar _ObtenerPalabraDeClase(asidero asideroVentana, entero entero=ndice);

sinsignoCorto estandarEntrar _PonerPalabraDeClase(asidero asideroVentana, entero entero=ndice, palabra palabraNueva);

sinsignoLargo estandarEntrar _ObtenerLargoDeClase(asidero asideroVentana, entero entero=ndice); sinsignoLargo estandarEntrar _PonerLargoDeClase(asidero asideroVentana, entero entero=ndice, largo largoNeuvo);

decisi≤n estandarEntrar _ObtenerRectBnguloDeCHente(asidero asideroVentana, rectBngulo * punteroRectβnguloCHente);

decisi≤n estandarEntrar _CerrarVentana(asidero asideroCerrar);

decisi≤n estandarEntrar _CHenteAPaπtalla(asidero asideroVentana, punto* punteroPuntoAConvertir);

decisi≤n estandarEntrar _ListarDirectorio(asidero asideroVentana, tipoCarβcter* punteroCarβcterCamino, entero enteroIdentidadDeCuadroDeLista, entero enteroIdentidadDe Vista, sinsigno sinsignoTipoDeArchivo);

decisi≤n estandarEntrar _SeleccionarDirectorio(asidero asideroVentana, tipoCarβcter* punteroCarβcterSecuencia, entero enteroContar, entero enteroIdentidadDeCuadroDeLista);

decisi≤n estandarEntrar _ListarDirectorioCajaCombinada(asidero asideroVentana, tipoCarβcter* punteroCarβcterCamino, entero enteroIdentidadDeCajaCombinada, entero enteroIdentidadDeVista, sinsigno unsignedFiletype);

decisi≤n estandarEntrar _SeleccionarDirectoriCajaCombinada(asidero asideroVentana, tipoCarβcter* punteroCarβcterSecuencia, entero enteroContar, entero enteroIdentidadDeCaj aCombinada);

decisi≤n estandarEntrar _HabilitarVentana(asidero asideroVentana, decisi≤n decidirHabilitar);

decisi≤n estandarEntrar _DestellarVentana(asidero asideroVentana, decisi≤n decidirlnvertir);

asidero estandarEntrar _PonerEnfoque(asidero asideroVentana);

asidero estandarEntrar _ObtenerElementoDeGroupo(asidero asideroDiBlogo, asidero asideroControl, decisi≤n decidirAnterior);

decisi≤n estandarEntrar _AyudaParaVentanas(asidero asideroVentana, const tipoCarβcter* punteroCarβcterAyuda, sinsigno sinsignoCo ando, doblePalabra doblePalabraData);

decisi≤n estandarEntrar _RegistrarTeclaRapida(asidero asideroVentana, entero enteroldentidad, sinsigno sinsignoModificantes, sinsigno sinsignoTeclaVirtual);

decisi≤n estandarEntrar _DesregistrarTeclaRapida(asidero asideroVentana, entero enteroldentidad);

entero estandarEntrar _ObtenerIdentidadDeDescendiente(asidero asideroVentana); decisi≤n estandarEntrar _EstBDescendiente(asidero asideroMaestro, asidero asideroDescendiente);

decisi≤n estandarEntrar _EstβVentanaMφnimo(asidero asideroVentana);

decisi≤n estandarEntrar _EstBMen- (asidero asideroMen-);

decisi≤n estandarEntrar _EstBVentanaHabilitada(asidero asideroVentana);

decisi≤n estandarEntrar _EstBVentanaUnic≤digo(asidero asideroVentana);

decisi≤n estandarEntrar _EstBVentana(asidero asideroVentana);

decisi≤n estandarEntrar _EstBVentanaVisible(asidero asideroVentana);

decisi≤n estandarEntrar _EstβMβχima(asidero asideroVentana);

decisi≤n estandarEntrar _EstβMensajeDeDiβlogo(asidero asideroDiBlogo, fila* punteroMensajeDeFila);

asidero estandarEntrar _Obtener _rltimoSaltadorActivo(asidero asideroVentana);

largo estandarEntrar _ObtenerLargoDeVentana(asidero asideroVentana, entero entero=ndice);

largo estandarEntrar _PonerLargoDeVentana(asidero asideroVentana, entero entero^ndice, largo longNew);

decisi≤n estandarEntrar _TraducirAceleradorDeSistemaDeMultidocumento(asidero asideroVentana, fila* punteroMensajeDeFila);

decisi≤n estandarEntrar _DibujarBarraDeMen-(asidero asideroVentana);

asidero estandarEntrar _Obtener Men- (asidero asideroVentana);

decisi≤n estandarEntrar _MarcarElementoDeMenu(asidero asideroVentana, asidero asideroMen-, sinsigno sinsignoldentidad, sinsigno sinsignoResaltar);

decisi≤n estandarEntrar _PonerMen -(asidero asideroVentana, asidero asideroMen-);

decisi≤n estandarEntrar _EnviarMensaje(asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro);

lresultado estandarEntrar _MandarMensaje(asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro);

decisi≤n estandarEntrar _MandarMensajeTiempoDeEspera(asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro, sinsigno decidirlndicadores, sinsigno sinsignoTiempoDeEspera, lresultado* plresult); decisi≤n estandarEntrar _MandarMensajeDeNotificaci≤n(asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro);

decisi≤n estandarEntrar _MandarMensajeLlamadaDeVuelta(asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro, funci ≤ nVentana punteroFunci ≤ nMandar, doblePalabra doblePalabraData);

decisi≤n estandarEntrar _MoverVentana(asidero asideroVentana, entero enteroX, entero entero Y, entero enteroAncho, entero enteroAltura, decisi≤n decidirRepintar);

decisi≤n estandarEntrar _MostrarSaltadoresPropios(asidero asideroVentana, decisi≤n decidirMostrar);

asidero estandarEntrar _ObtenerMaestro(asidero asideroVentana);

asidero estandarEntrar _PonerMaestro(asidero asideroDescendiente, asidero asideroMaestro);

entero estandarEntrar _EnumerarPropiedadesExtendido(asidero asideroVentana, funci≤nPropiedadEnumerarExtendido punteroFunci≤nEnumerar, lparBmetro IParBmetro); asidero estandarEntrar _ObtenerPropiedad(asidero asideroVentana, const carβcter* punteroCarβcterSecuencia);

asidero estandarEntrar _RemoverPropiedad(asidero asideroVentana, const tipoCarβcter* punteroCarβcterSecuencia);

decisi≤n estandarEntrar _PonerPropiedad(asidero asideroVentana, const tipoCarβcter* punteroCarβcterSecuencia, asidero asideroData);

entero estandarEntrar _EnumerarPropiedades(asidero asideroVentana, funci≤nEnumerarPropiedad punteroFunci≤nEnumerar);

decisi≤n estandarEntrar _InvalidarRectBngulo(asidero asideroVentana, const rectBngulo* punteroRectβnguloInvalidar, decisi≤n decidirBorrar);

decisi≤n estandarEntrar _ValidarRectBngulo(asidero asideroVentana, const rectβngulo* punteroRectBnguloValidar);

decisi≤n estandarEntrar _ObtenerRectBnguloDeVentana(asidero asideroVentana, rectBngulo * punteroRectBngulo Ventana);

decisi≤n estandarEntrar _RedibujarVentana(asidero asideroVentana, const rectBngulo* punteroRectβnguloActualizar, asidero asideroReponerRegi≤n, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _InvalidarRegi≤n(asidero asideroVentana, asidero asideroRegi≤n, decisi≤n decidirBorrar); decisi≤n estandarEntrar _ValidarRegi≤n(asidero asideroVentana, asidero asideroRegi≤n);

decisi≤n estandarEntrar _PantallaACHente(asidero asideroVentana, punto* punteroPuntoAConvertir);

decisi≤n estandarEntrar _DesplazarVentana(asidero asideroVentana, entero enteroX, entero entero Y, const rectBngulo* punteroRectBnguloDesplazar, const rectβngulo* punteroRectBnguloRecortar);

entero estandarEntrar _DesplazarVentanaExtendido(asidero asideroVentana, entero enteroX, entero entero Y, const rectβngulo* punteroRectBnguloDesplazar, const rectBngulo* punteroRectBnguloRecortar, asidero asideroReponerRegi≤n, rectBngulo* punteroRectβnguloActualizar, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _HabilitarBarraDeDesplazamiento(asidero asideroVentana, sinsigno sinsignolndicadores, sinsigno sinsignoFlechas);

decisi≤n estandarEntrar _MostrarBarraDeDesplazamiento(asidero asideroVentana, entero enteroBarra, decisi≤n decidirMostrar);

entero estandarEntrar _ObtenerPosici≤nDeDesplazamiento(asidero asideroVentana, entero enteroBarra); entero estandarEntrar _PonerPosici≤nDeDesplazamiento(asidero asideroVentana, entero enteroBarra, entero enteroPosici≤n, decisi≤n decidirRedibujar);

decisi≤n estandarEntrar _ObtenerGamaDeDesplazamiento(asidero asideroVentana, entero enteroBarra, entero * punteroEnteroPosici≤ nMφnima, entero* punteroEnteroPosici≤nMBxima);

decisi≤n estandarEntrar _PonerGamaDeDesplazamiento(asidero asideroVentana, entero enteroBarra, entero integerPositionMinimum, entero integerPositionMaximum, decisi≤n decidirRedibujar);

entero estandarEntrar _PonerInformaci≤nDeDesplazamiento(asidero asideroVentana, entero enteroBarra, informaci≤nDeBarraDeDesplazamiento* pscrollBarlnformation, decisi≤n decidirRedibujar);

decisi≤n estandarEntrar _ObtenerInformaci≤nDeDesplazamiento(asidero asideroVentana, entero enteroBarra, informaci≤nDeBarraDeDesplazamiento* pscrollBarlnformation);

decisi≤n estandarEntrar _MostrarVentana(asidero asideroVentana, entero enteroMostrarComando); entero estandarEntrar _ObtenerLargoDeTextoDeVentana(asidero asideroVentana);

entero estandarEntrar _ObtenerTextoDeVentana(asidero asideroVentana, tipoCarβcter* punteroCarβcterSecuencia, entero enteroLargoDeTexto);

decisi≤n estandarEntrar _PonerTextoDeVentana(asidero asideroVentana, const tipoCarβcter* punteroCarβcterSecuencia);

s i n s i g n o L a r g o e s t a n d a r E n t r a r

_ObtenerIdentidadesDeProcesoYSubprocesoDeVentana(asidero asideroVentana, doblePalabra* punteroDoblePalabraldentidadDeProceso);

sinsigno estandarEntrar _PonerCron≤metro(asidero asideroVentana, sinsigno sinsignoldentidad, sinsigno sinsignoTiempoDeEspera, funci≤nCron≤metropunteroFunci≤nCron≤metro);

decisi≤n estandarEntrar _CancelarCron≤metro(asidero asideroVentana, sinsigno sinsignoldentidad);

decisi≤n estandarEntrar _ActualizarVentana(asidero asideroVentana);

decisi ≤ n estandarEntrar _ObtenerRectBnguloDeActualizaci ≤ n(asidero asideroVentana, rectBngulo * punteroRectβnguloActualizar, decisi≤n decidirBorrar);

entero estandarEntrar _ObtenerRegi≤nDeActualizaci≤(asidero asideroVentana, asidero asideroRegi≤n, decisi≤n decidirBorrar); sinsignoCorto estandarEntrar _ObtenerPalabraDeVentana(asidero asideroVentana, entero entero=ndice);

sinsignoCorto estandarEntrar _PonerPalabraDeVentana(asidero asideroVentana, entero entero=ndice, palabra palabraNueva);

decisi≤n estandarEntrar _PonerPosici<nDeVentana(asidero asideroVentana, asidero asideroDespuΘs, entero enteroX, entero entero Y, entero enteroAncho, entero enteroAltura, sinsigno sinsignolndicadores);

asidero estandarEntrar _ObtenerVentana(asidero asideroVentana, sinsigno sinsignoComando);

lresultado estandarEntrar _LlamarFunci≤onDeVentana(funci≤nVentana funci≤ nAnterior, asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro);

asidero estandarEntrar _ComenzarColocaci≤nDeVentanaDiferida(entero entero Ventanas);

asidero estandarEntrar _DiferirColocaci≤ nDeVentana(asidero asideroInformaci≤nDePosici≤n, asidero asideroVentana, asidero asideroDespuΘs, entero enteroX, entero entero Y, entero enteroAncho, entero enteroAltura, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _AcabarColocaci≤nDeVentanaDiferida(asidero asideroInformaci≤nDePosici≤n);

lresultado estandarEntrar Funci≤nPredeterminadoDeVentana(asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro);

decisi≤n estandarEntrar _BloquearActualizaci≤nDeVentana(asidero asideroBloquearVentana);

#fin_si

#si definida(incluirCursor)

asidero estandarEntrar _CargarCursor(asidero asiderolnstancia, const tipoCarβcter* punteroCarBcterNombreDeCursor);

asidero estandarEntrar _CrearCursor(asidero asiderolnstancia, entero enteroXPuntoDeActuaci≤n, entero enteroYPuntoDeActuaci≤n, entero enteroAncho, entero enteroAltura, const vacφo *punteroYPlano, const vacφo *punteroExcluyenteOPlano);

decisi≤n estandarEntrar _DestruirCursor(asidero asideroCursor);

entero estandarEntrar _MostrarCursor(decisi≤n decidirMostrar);

decisi≤n estandarEntrar _PonerPosici≤nDeCursor(entero enteroX, entero entero Y);

asidero estandarEntrar _PonerCursor(asidero asideroCursor);

decisi≤n estandarEntrar _PonerPosici≤nDeCursor(punto* punteroPuntoPosici≤n);

decisi≤n estandarEntrar _CortarCursor(const rectβngulo* punteroRectBnguloRecortar);

decisi≤ n estandarEntrar _ObtenerCursorParaCortar(rectBngulo punteroRectBnguloRecortar);

asidero estandarEntrar _ObtenerCursor0; #fin_si

#si definida(incluirlcono)

asidero estandarEntrar _CargarIcono(asidero asiderolnstancia, const tipoCarβcter* punteroCarβcterNombreDelcono);

asidero estandarEntrar _CrearIcono(asidero asiderolnstancia, entero enteroAncho, entero enteroAltura, byte bytePlanos, byte byteBitsPixel, const byte* punteroByteYBits, const byte* punteroByteExcluyenteOBits);

asidero estandarEntrar _CrearIconoDesdeRecurso(byte* punteroByteBitsDeRecurso, doblePalabra doblePalabraTama±oDeRecurso, decisi≤n decidirlcono, doblePalabra doblePalabraVersi≤n);

asidero estandarEntrar _CrearIconoDesdeRecursoExtendido(byte* punteroByteBitsDeRecurso, doblePalabra doblePalabraTama±oDeRecurso, decisi≤n decidirlcono, doblePalabra doblePalabra Versi ≤ n, entero enteroAncho, entero enteroAltura, sinsigno sinsignolndicadores);

asidero estandarEntrar _CrearIconoIndirecto(informaci≤nDeIcono* punteroInformaci≤nDelcono);

decisi≤n estandarEntrar _DestruirIcono (asidero asiderolcono);

asidero estandarEntrar _CopiarIcono(asidero asiderolcono);

decisi≤n estandarEntrar _ObtenerInformaci≤nDeIcono(asidero asiderolcono, informaci≤ nDelcono * punterolnf ormaci≤ nDelcono); #fin si

#si definida(incluirTeclado) asidero estandarEntrar _CargarDise±oDeTeclado(const tipoCarβcter* punteroCarBcterNombreDeTeclado, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _ActivarDise±oDeTeclado(asidero asideroDise±oDeTeclado, sinsigno sinsignolndicadores);

decisi≤ n estandarEntrar _DescargarDise±oDeTeclado(asidero asideroDise±oDeTeclado);

decisi≤n estandarEntrar _ObtenerNombreDeDise±oDeTeclado(tipoCarBcter* punteroCarβcterNombreDeDise±oDeTeclado);

#fin si

#si definida(incluirDiBlogo)

asidero estandarEntrar _CrearDiBlogoParBmetro(asidero asiderolnstancia, const tipoCarβcter* punteroCarBcterNombreDePlantilla, asidero asideroMaestro , funci≤nVentana punteroFunci≤nDiBlogo, lparBmetro IParBmetro);

asidero estandarEntrar _CrearDiBlogoIndirectoParBmetro(asidero asiderolnstancia, plantillaDeDiBlogo* punteroPlantillaDeDiβlogo, asidero asideroMaestro, funci≤nVentana punteroFunci≤nDiBlogo, lparBmetro IParBmetro);

entero estandarEntrar _CajaDeDiBlogoParBmetro(asidero asiderolnstancia, const tipoCarβcter* punteroCarβcterNombreDePlantilla, asidero asideroMaestro, funci ≤ n Ventana punteroFunci ≤ nDiβlogo, lparBmetro IParBmetro);

entero estandarEntrar __CajaDeDiBlogoIndirectoParBmetro(asidero asiderolnstancia, plantillaDeDiBlogo * punteroPlantillaDeDiβlogo, asidero asideroMaestro, funci≤nVentana punteroFunci≤nDiβlogo, lparBmetro IParBmetro);

decisi≤n estandarEntrar _AcabarDiBlogo(asidero asideroDiBlogo, entero enteroResultado);

decisi≤n estandarEntrar _MapearRectanguloDeDialog(asidero asideroDiBlogo, rectBngulo* punteroRectBnguloMapear);

#fin si

#si definida(incluirCarBcter)

decisi≤n estandarEntrar _OemACarBcter(const carβcter* punteroCarβcterOrigen, tipoCarβcter* punteroCarβcterDestino);

decisi≤n estandarEntrar _CarBcterAOemB-fer(const tipoCarβcter* punteroCarβcterOrigen, carβcter* punteroCarβcterDestino, doblePalabra doblePalabraLargoDeDestino); decisi≤n estandarEntrar _OemAB-ferDeCarBcter(const carβcter* punteroCarβcterOrigen, tipoCarβcter* punteroCarβcterDestino, doblePalabra doblePalabraLargoDeDestino);

tipoCarβcter* estandarEntrar _CarBcterMayscula(tipoCarBcter* punteroCarBcterMayscula);

sinsignoLargo estandarEntrar _CarBcterMaysculaB-fer(tipoCarBcter* punteroCarBcterMay ^• scula, doblePalabra doblePalabraLargo);

tipoCarβcter* estandarEntrar _CarβcterMin-scula(tipoCarβcter* punteroCarBcterMin-scula);

sinsignoLargo estandarEntrar _CarBcterMin-sculaB-fer(tipoCarBcter* punteroCarBcterMin-scula, doblePalabra doblePalabraLargo);

tipoCarβcter* estandarEntrar _CarβcterPr≤ximo(const tipoCarβcter* punteroCarβcterPr≤ximo);

tipoCarβcter* estandarEntrar __CarBcterAnterior(const tipoCarβcter* punteroCarβcterComienzo, const tipoCarβcter* punteroCarβcterActual);

#fin si

#si definida(incluirMen-)

asidero estandarEntrar _CrearMen-0; asidero estandarEntrar _CrearMen-SaltadorO;

asidero estandarEntrar _CargarMen- (asidero asiderolnstancia, const tipoCarβcter* punteroCarBcterNombreDeMen-);

asidero estandarEntrar _CargarMen-Indirecto(const vacφo* punteroPlantillaDeMen-);

asidero estandarEntrar _ObtenerMen-DeSistema(asidero asideroVentana, decisi≤n decidirRevertir);

decisi≤n estandarEntrar _DestruirMen-(asidero asideroMen-);

decisi≤n estandarEntrar _AgregarMen-(asidero asideroMen-, sinsigno sinsignolndicadores, sinsigno sinsignoldentidad, const tipoCarβcter* punteroCarβcterElemento);

decisi≤n estandarEntrar _CambiarMen- (asidero asideroMen-, sinsigno sinsignoComando, const tipoCarβcter* punteroCarβcterElemento, sinsigno sinsignolnsertar, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _EliminarMen-(asidero asideroMen-, sinsigno sinsignoPosici < n, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _InsertarMen- (asidero asideroMen-, sinsigno sinsignoPosici ≤n, sinsigno sinsignolndicadores, sinsigno sinsignoldentidad, const tipoCarβcter* punteroCarβcterElemento);

decisi≤n estandarEntrar _InsertarElementoDeMenu(asidero asideroMen-, sinsigno sinsignoElemento, decisi≤n decidirPorPosici≤n, elementoDeMen-Informaci≤n* pmenultemlnformation);

decisi≤n estandarEntrar _ObtenerInformaci≤onDeElementoDeMenu(asidero asideroMen-, sinsigno sinsignoElemento, decisi≤n decidirPorPosici≤n, elementoDeMen-Informaci≤n* pmenultemlnformation);

decisi≤n estandarEntrar _PonerInformaci≤onDeElementoDeMenu(asidero asideroMen-, sinsigno sinsignoElemento, decisi≤n decidirPorPosici≤n, elementoDeMen-Inf ormaci ≤ n* pmenultemlnformation);

sinsigno estandarEntrar _ObtenerElementoPredeterminadoDeMenu(asidero asideroMen-, sinsigno unsignedByPosition, sinsigno sinsignolndicadores);

decisi≤n estandarEntrar _PonerElementoPredeterminadoDeMenu(asidero asideroMen-, sinsigno sinsignoElemento, decisi≤n decidirPorPosici≤n);

decisi≤n estandarEntrar _PonerBitmapasDeElementoDeMen-(asidero asideroMen-, sinsigno sinsignoPosici≤n, sinsigno sinsignolndicadores, asidero asideroNoEstBMarcado, asidero asideroMarcado);

sinsignoLargo estandarEntrar _MarcarElementoDeMen-(asidero asideroMen-, sinsigno sinsignoldentidad, sinsigno sinsignoMarcar);

entero estandarEntrar _ObtenerCuentaDeElementoDeMen-(asidero asideroMen-);

sinsigno estandarEntrar _HabilitarElementoDeMen-(asidero asideroMen-, sinsigno sinsignoldentidad, sinsigno sinsignoHabilitar);

sinsigno estandarEntrar _ObtenerIdentidadDeElementoDeMenu(asidero asideroMen-, entero enteroPosici≤n);

decisi≤n estandarEntrar _ModificarMen-(asidero asideroMen-, sinsigno sinsignoPosici≤n, sinsigno sinsignolndicadores, sinsigno sinsignoldentidad, const tipoCarβcter* punteroCarβcterElemento);

decisi≤n estandarEntrar _RastrearMen-DeSaltador(asidero asideroMen-, sinsigno sinsignolndicadores, entero enteroX, entero entero Y, entero enteroReservada, asidero asideroDue±o, const rectBngulo* punteroRect^βnguloRastrear);

decisi≤n estandarEntrar _RemoverMen-(asidero asideroMen-, sinsigno sinsignoPosici≤n, sinsigno sinsignolndicadores);

sinsigno estandarEntrar _ObtenerEstadoDeMen-(asidero asideroMen-, sinsigno sinsignoldentidad, sinsigno sinsignolndicadores);

entero estandarEntrar _ObtenerTextoDeMen-(asidero asideroMen-, sinsigno sinsignoldentidad, tipoCarβcter* punteroCarβcterSecuencia, entero enteroLargoDeSecuencia, sinsigno sinsignolndicador);

asidero estandarEntrar _ObtenerSubmen-(asidero asideroMen-, entero enteroPosici≤n);

#fin si

#si definida(incluirAcelerador)

asidero estandarEntrar _CargarTablaDeAcelerador(asidero asiderolnstancia, const tipoCarβcter* punteroCarBcterNombreDeTabla);

asidero estandarEntrar _CrearTablaDeAcelerador(entradaDeAcelerador*,entero);

decisi≤n estandarEntrar _DestruirTablaDeAcelerador(asidero asideroAcelerador);

entero estandarEntrar _CopiarTablaDeAcelerador(asidero asideroOrigen, entradaDeAcelerador* punteroEntradasDeAcelerador, entero enteroEntradas);

#fin si #si definida(incluirGancho)

decisi≤n estandarEntrar _DescargarGanchoDeVentanas(entero enteroC≤digo, funci≤ nGancho punteroFunci≤ nGancho);

asidero estandarEntrar _PonerGanchoDeVentanaje(entero enteroIdentidadDeGancho, funci≤nGancho punteroFunci≤nGancho, asidero asideroM≤dulo, doblePalabra doblePalabraldentidadDeSubproceso);

decisi≤n estandarEntrar _DescargarGanchoDeVentanasExtendido(asidero asideroGancho);

sinsigno estandarEntrar _LlamarGanchoPr≤ximo(asidero asideroGancho, entero enteroC≤digo, vparβmetro vParBmetro, lparBmetro IParBmetro); #fin_si

#si definida(incluirEscritorio)

asidero estandarEntrar _ObtenerEscritorioDeSubproceso(sinsigno sinsignoIdentitadDeSubproceso);

asidero estandarEntrar _CrearEscritorio(const tipoCarβcter* punteroCarBcterEscritorio, const tipoCarβcter* punteroCarβcterDispositivo, const vacφo* punteroModoDeDispositivo, doblePalabra doblePalabralndicadores, doblePalabra doblePalabraAcceso, const atributosDeSeguridad* punteroAtributosDeSeguridad); asidero estandarEntrar _AbrirEscritorio(const tipoCarβcter* punteroCarBcterEscritorio, doblePalabra doblePalabralndicadores, decisi≤n decidirHeredar, doblePalabra doblePalabraAcceso);

asidero estandarEntrar OpenInputDesktop(doblePalabra doblePalabralndicadores, decisi≤n decidirHeredar, doblePalabra doublePalabraAcesso);

decisi≤n estandarEntrar _EnumerarEscritorios(asidero asideroEstaci≤n, funci ≤ nEnumerarEscritorio punteroFunci ≤ nEnumerar, lparBmetro IParBmetro);

asidero estandarEntrar _CrearEstaci≤nDeVentana(const tipoCarβcter* punteroCarβcterEstaci≤n, doblePalabra doblePalabraReservada, doblePalabra doblePalabraAcceso, const atributosDeSeguridad* punteroAtributosDeSeguridad);

asidero estandarEntrar _AbrirEstaci≤nDeVentana(const tipoCarβcter* punteroCarBcterEstaci≤ n, decisi≤n decidirHeredar, doblePalabra doblePalabraAcceso);

#fin si

#si definida(incluirMiscelBnea)

sinsigno estandarEntrar _PreguntarArchivoDeArrastre(asidero asideroCaφda, sinsigno sinsigno=ndice, tipoCarβcter* punteroCarβcterArchivo, sinsigno sinsignoLargo);

decisi≤n estandarEntrar _PreguntarPuntoDeArrastre(asidero asideroCaφda, punto* punteroPuntoDeCaφda);

vacφo estandarEntrar _TerminarArrastre(asidero asideroCaφda);

asidero estandarEntrar _CargarImagen(asidero asiderolnstancia, const tipoCarβcter* punteroCarβcterNombre, sinsigno sinsignoTipo, entero enteroAncho, entero enteroAltura, sinsigno sinsignolndicadores);

asidero estandarEntrar _CopiarImagen(asidero asiderolmagen, sinsigno unsignedlmageType, entero enteroAncho, entero enteroAltura, sinsigno sinsignolndicadores);

entero estandarEntrar _AAscii(sinsigno sinsignoTeclaVirtual, sinsigno sinsignoC≤digoDeEscaneo, byte* punteroByteEstadoDeTecla, ' carβcterAncho* punteroCarβcter, sinsigno sinsignolndicadores);

entero estandarEntrar _AUnic≤digo(sinsigno sinsignoTeclaVirtual, sinsigno sinsignoC≤digoDeEscaneo, byte* punteroByteEstadoDeTecla, carβcterAncho* punteroCarBcterB-fer, entero enteroLargoDeB-fer, sinsigno sinsignolndicadores);

sinsignoLargo estandarEntrar _EscanearTeclaDeOem(sinsignoCorto sinsignoCortoCarBcterOem);

#fin si

}

#fin si

APPENDIXD1 // Copyright (c) Educational and Computing Software 1994 // Ejemplo de Ventanas++ (Ven32) C Programa

#define incluirVen32 #incluir <ventanas.hpp> #incluir <ventanas.h>

#incluir "EjemploC.h"

carβcter formaci≤nCarβcterNombreDeClase[] = "ejemploDeClaseDeNentana"; carβcter formaci≤nCarβcterTφtulo[] = "Ventanas C";

externo "C" lresultado estandarLlamar funci ≤nNentana(asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParBmetro, lparBmetro IParBmetro);

externo "C" entero estandarEntrar VentanaPrincipal(asidero asiderolnstancia, asidero asidero Anterior, carβcter* punteroCarβcterLφneaDeComando, entero enteroComandoDeMostra)

{ informaci≤nDeClase claseDe Ventana;

claseDeVentana.asideroInstancia = asiderolnstancia; claseDeVentana.punteroCarBcterNombreDeClase = formaci≤ nCarBcterNombreDeClase; claseDe Ventana.punteroFunci≤nDeVentana = funci ≤n Ventana; claseDe Ventana.sinsignoEstilo = 0; claseDeVentana.asideroIcono = _CargarIcono(nulo,iconoAplicaci≤n); claseDeVentana.asideroCursor = _CargarCursor(nulo,cursorFlecha); claseDe Ventana.punteroCarBcterNombreDeMen- =enteroARecurso(identidadDeMen-); claseDeVentana.enteroExtraDeClase = 0; claseDeVentana.enteroExtraDeVentana = 0; claseDeVentana.asideroPincelDeFondo = (asidero)_ObtenerObjetoEstBndar(pincelBlanco);

si (!_RegistrarClase(&claseDe Ventana)) retornar 0;

asidero asideroVentana = _CrearVentana(formaci≤nCarBcterNombreDeClase, formaci≤nCarBcterTφtulo, estiloEstBndar, usarPredeterminado, usarPredeterminado, usarPredeterminado, usarPredeterminado, nulo, nulo, asiderolnstancia, nulo);

_MostrarVentana(asideroVentana,enteroComandoDeMostra); _ActualizarVentana(asidero Ventana);

fila mensajeDeFila; mientras (_ObtenerMensaje(&mensajeDeFila,nulo,0,0))

{ _TraducirMensaje(&mensajeDeFila);

_DespacharMensaj e(&mensaj eDeFila); }

retornar mensajeDeFila.vParBmetro; }

externo "C" lresultado estandarLlamar funci ≤nVentana(asidero asideroVentana, sinsigno sinsignoMensaje, vparβmetro vParβmetro, lparBmetro lParβmetro)

{ seleccionar(sinsignoMensaj e)

{ caso mensajeDestruir:

_EnviarMensajeADejar(0); quebrar;

caso mensajeComando: { palabra palabraldentidadDeElementoDeMen- = bajoPalabra(vParβmetro); si (palabraldentidadDeElementoDeMen- == elementoDeMen-Salir) si (_CajaDeMensaje(asidero Ventana, "Salir ?","Ventanas++", estiloIconoPregunta | estiloSiNo) == φtemSi)

_EnviarMensaje(asideroVentana,mensajeDejar,0,0);

} quebrar;

caso mensajePintar :

{ pintura estracturaDePintura; rectBngulo rectβnguloPintar ;

asidero asideroDispositivo = _ComenzarPintar(asidero Ventana,

&estructuraDePintura) ; _ObtenerRectBnguloDeCHente(asidero Ventana, &rectβnguloPintar);

_LlenarRectBngulo(asideroDispositivo,&rectBnguloPintar,(asidero)colorDeSistemaFo ndo+1);

_DibujarTextoFormateado(asideroDispositivo, "Hola, Ventanas++ !ϋ",

-1, &rectβnguloPintar, dibujarTextoLφneaS≤la | dibujarTextoCentrar | dibuj arTextoCentrar Vertical);

_AcabarPintar(asidero Ventana, &estructuraDePintura) ; } quebrar;

predeterminado: r e t o r n a r Funci≤nPredeterminadoDeVentana(asideroVentana,sinsignoMensaje,vParBmetro,lPar βmetro);

} retornar 0;

} APPENDIXD2

// Copyright (c) Educational and Computing Software 1994 // Ejemplo de Finestre++ (Ven32) C Programa

#define includereFin32 #includere <finestre.hpp> #includere <finestre.h>

#includere "EjemploC.h"

carattere arrayCarattereNomeDiClasse[] = "ejemploDeClaseDe Ventana"; carattere arrayCarattereTitolo[] = "Finestre C";

esterno "C" Irisultato standardChiamare funzioneFinestra(manico manicoFinestra, senzasegno senzasegnoMessagio, fparametro fParametro, lparametro lParametro);

esterno "C" intero standardEntrata FinestraPrincipaleμnanico manicoCaso, manico manicoPrecedente, carattere* puntatoreCarattereLineaDiComando, intero interoComandoDiMostra)

{ informazioneDiClasse classeDiFinestra;

classeDiFinestra.manicoCaso = manicoCaso; classeDiFinestra.puntatoreCarattereNomeDiClasse = arrayCarattereNomeDiClasse; classeDiFinestra.puntatoreFunzioneFinestra = funzioneFinestra; classeDiFinestra.senzasegnoStile = 0; classeDiFinestra.manicoIcona = _CaricareIcono(nullo,iconaApplicazione); classeDiFinestra.manicoCursore = _CaricareCursore(nullo,cursoreFreccia); classeDiFinestra.puntatoreCarattereNomeDiMenu =interoARisorsa(identitαDiMenu); classeDiFinestra.interoExtraDiClasse = 0; classeDiFinestra.interoExtraDiFinestra = 0; classeDiFinestra .manicoFondoDiPennello = (manico)_OttenereOggettoStandard(pennelloBianco);

se (!_RegistrareClasse(&classeDiFinestra)) ritornare 0;

manico manicoFinestra = _CreareFinestra(arrayCarattereNomeDiClasse, arrayCarattereTitolo, stileStandard, usareDefault, usareDefault, usareDefault, usareDefault, nullo, nullo, manicoCaso, nullo);

_MostrareFinestra(manicoFinestra,interoComandoDiMostra); _AggiornareFinestra(manicoFinestra);

fila messagioDiFila; mentre (_OttenereMessagio(&messagioDiFila,nullo,0,0))

{ _TradurreMessagio(&messagioDiFila);

_SbrigareMessagio(&messagioDiFila); }

ritornare messagioDiFila.fParametr o ; }

esterno "C" Irisultato standardChiamare funzioneFinestra(manico manicoFinestra, senzasegno senzasegnoMessagio, fparametro fParametro, lparametro IParametro)

{ selezionare(senzasegnoMessagio)

{ caso messagioDistruggere:

_ImpostareMessagioASmettere(0); rompere;

caso messagioComando: { parola parolaldentitαDiArticoloDiMenu = bassoParola(fParametro); se (parolaldentitαDiArticoloDiMenu == articoloDiMenuUscire) se (_ScatolaDiMessagio(manicoFinestra, "Salir ?","Finestre++", stilelconaDomanda | stileSiNon) == φtemSi)

_ImpostareMessagio(manicoFinestra,messagioSmettere,0,0);

} rompere;

caso messagioDipingere :

{ pittura strutturaDiPittura; rettangolo rettangoloDipingere ;

manico manicoDispositivo = _IniziareDipingere(manicoFinestra, &strutturaDiPittura) _OttenereRettangoloDiCHent(manicoFinestra, &rettangoloDipingere);

_RiempireRettangolo(manicoDispositivo,&rettangoloDipingere,(manico)coloreDiSist emaFondo+1);

_DisegnareFormatoDiTesto(manicoDispositivo, "Hola, Finestre++ ! !!",

-1, &rettangoloDipingere, disegnareTestoLineaSingola | disegnareTestoCentrare | disegnareTestoVerticaleCentrare);

_FinireDipingere(manicoFinestra, &strutturaDiPittura) ; } rompere;

default: r i t o r n a r e FunzioneDefaultDiFinestra(manicoFinestra,senzasegnoMessagio,fParametro,lParamet ro);

} ritornare 0;

} APPENDIXD3 // Copyright (c) Virtual Software 1994 // An example of a Windows Nt (Win32) C Program

#define STRICT

#include <windows.h>

#include "CSamp.h"

char arrayCharacterClassName[] = "SkeletonClass"; char arrayCharacterTitlef] = "Windows NT Skeleton";

extern "C" LRESULT CALLBACK functionWindow(HWND handleWindow,

UINT unsignedMessage, WPARAM wParam,

LPARAM lParam);

extern "C" int WINAPI WinMain(HINSTANCE handlelnstance, HINSTANCE handlePrevious, LPSTR pointerCharacterCommandLine, int integerCommandShow)

{

WNDCLASS windowClass;

windowClass.hlnstance = handlelnstance; windowClass.lpszClassName = array Char acterClassName; windowClass.lpfnWndProc = function Window; windowClass.style = 0; windowClass. con = LoadIcon(NULL,IDI_APPLICATION); windowClass.hCursor = LoadCursor(NULL,IDC_ARROW); windowClass.lpszMenuName = MAKEINTRESOURCE(identityMenu); windowClass.cbClsExtra = 0; windowClass.cbWndExtra = 0; windowClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

if (!RegisterClass(&windowClass)) return 0;

HWND handleWindow = Create Window(arrayCharacterClassName, arrayCharacterTitle,

WS_OVERLAPPEDWINDOW, CW JSEDEFAULT,

CW_USEDEFAULT,

NULL, NULL, handlelnstance,

NULL);

ShowWindow(handleWindow,integerCommandShow); Update Window(handleWindow);

MSG queueMessage; while (GetMessage(&queueMessage,NULL,0,0))

{ TranslateMessage(&queueMessage);

DispatchMessage(&queueMessage); }

return queueMessage.wParam; } extern "C" LRESULT CALLBACK functionWindow(HWND handleWindow,

UINT unsignedMessage, WPARAM wParam, LPARAM lParam) { switch(unsignedMessage)

{ case WM_DESTROY:

PostQuitMessage(0); break;

case WM_COMMAND:

{

WORD wordMenuItemldentity = LOWORD(wParam); if (wordMenuItemldentity == menuItemExit) if (MessageBox(handleWindow,

"Want to quit now you dummy ?","i++",

MB CONQUESTION | MB_YESNO) == ID YES)

PostMessage(handleWindow,WM_QUIT,0,0); } break;

case WM_PAINT :

{ PAINTSTRUCT paintStructure;

RECT rectanglePaint ;

HDC handleDevice = BeginPaint(handle Window, &paintStructure) ;

GetCHentRect(handle Window, &rectanglePaint); FillRect(handleDevice,&rectanglePaint,(HBRUSH)COLOR_BACKGROUND+l);

DrawText(handleDevice, "Hello, Windows 95!", -1,

&rectanglePaint,

DT_SINGLELINE | DT_CENTER | DT_VCENTER) ;

EndPaint(handleWindow, &paintStructure) ; } break;

default: return DefWindowProc(handleWindow,unsignedMessage,wParam,lPar am); } return 0;

}

Claims

1. A computer system for converting at least keywords in a program source code, the computer system comprising storage means adapted to store keywords of at least one programming language, the keywords being nominally used for programming source codes written in one natural language, and words in at least one other natural language corresponding to said keywords; and program code conversion means adapter to access said storage means for converting keywords or corresponding words in a program source code written in said one natural language or one of said at least one other language, to corresponding words or keywords as stored in the storage means into a target code in another natural language.

2. A computer program for converting at least keywords in a program source code, the computer program comprising storing means adapted to store in a storage means keywords of at least one programming language nominally used for programming source codes in one natural language and words in at least one other natural language corresponding to said keywords, and program code conversion means adapter to access said storage means for converting keywords or corresponding words in a program source code written in said one natural language or one of said at least one other natural language to corresponding words or keywords as stored in the storage means into a target code in another natural language.

3. A computer ope rating system comprising interface language selection means adapted for selecting one from a plural ity of natural languages for presenting system interface, storing means adapted to store in storage means keywords of the programming language used for programming the operating system source codes in one natural language and words in at least one other natural language corresponding to said keywords, and program code conversion means adapter to access said storage means for converting keywords or corresponding words in a program source code written in said one natural language or one of said at least one other natural language to corresponding words or keywords as stored in the storage means into a target code in another natural language selected for the interface.

4. The invention according to any one of claims 1 to 3 further comprising language selection means for selectively choosing the natural language for the target code, wherein said storage means includes corresponding words in a plurality of other natural languages and the language selection means being arranged to automatically detect the natural language in which the source code is written, or provided with a source code language selection arrangement for choosing the natural language of the source code.

5. The invention according to claim 4 wherein the storage means includes a primary database containing the keywords and the corresponding words in said plurality of other natural languages, and a secondary database containing the keywords and the corresponding words in the chosen one said other natural languages; the code conversion means being adapted to access the secondary database for converting the keywords to corresponding words in the chosen natural language.

6. The invention according to claim 5 wherein the storage means further including a user defined database containing user provided words in one natural language and corresponding words in one or more other natural languages.

7. The invention according to any one of claims 1 to 6 wherein the program code conversion means including a character replacement arrangement for replacing characters and/or signs in the target code which are unrecognisable by the programming language to ones which are recognised.

8. The invention according to claim 7 wherein said unrecognisable characters and/or signs including accented letters and/or specific signs in a natural language.

9. The invention according to any one of claims 1 to 8 wherein the conversion means further including a translator for translating words and/or signs other than the keywords and/or user defined words in the source code or interface into one of said other natural languages.

10. The invention according to any one of claims 1 to 9 wherein the invention being arranged so that a program source code including keywords of a programming language written in any natural language for conversion into a target code in another natural language, are converted in a manner that the target code a compilable by a compiler program into a machine code.

11. A compiler for compiling program source codes into executable computer instructions comprising the system according to claim 1 or the program according to claim 2.

12. The invention according to any one of claims 1 to 11 wherein the invention defines a set of interfaces for conversion and compilation of a program written in a programming language into various natural (spoken) languages, said programming language including C+ +, Windows^® and the like.