ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fixed some LPPOINT/LPSIZE mismatches and some missing "const" in the 

headers prototypes.
This commit is contained in:
François Gouget 1998-10-28 10:47:09 +00:00 committed by Alexandre Julliard
parent 87f87bf61c
commit 241c730d54
24 changed files with 254 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
debugger/dbg.y
View File

@ -292,23 +292,23 @@ type_cast:
type_expr:
type_expr '*' { $$ = DEBUG_FindOrMakePointerType($1); }
| tINT { $$ = DEBUG_TypeCast(BASIC, "int"); }
| tCHAR { $$ = DEBUG_TypeCast(BASIC, "char"); }
| tLONG tINT { $$ = DEBUG_TypeCast(BASIC, "long int"); }
| tUNSIGNED tINT { $$ = DEBUG_TypeCast(BASIC, "unsigned int"); }
| tLONG tUNSIGNED tINT { $$ = DEBUG_TypeCast(BASIC, "long unsigned int"); }
| tLONG tLONG tINT { $$ = DEBUG_TypeCast(BASIC, "long long int"); }
| tLONG tLONG tUNSIGNED tINT { $$ = DEBUG_TypeCast(BASIC, "long long unsigned int"); }
| tSHORT tINT { $$ = DEBUG_TypeCast(BASIC, "short int"); }
| tSHORT tUNSIGNED tINT { $$ = DEBUG_TypeCast(BASIC, "short unsigned int"); }
| tSIGNED tCHAR { $$ = DEBUG_TypeCast(BASIC, "signed char"); }
| tUNSIGNED tCHAR { $$ = DEBUG_TypeCast(BASIC, "unsigned char"); }
| tFLOAT { $$ = DEBUG_TypeCast(BASIC, "float"); }
| tDOUBLE { $$ = DEBUG_TypeCast(BASIC, "double"); }
| tLONG tDOUBLE { $$ = DEBUG_TypeCast(BASIC, "long double"); }
| tSTRUCT tIDENTIFIER { $$ = DEBUG_TypeCast(STRUCT, $2); }
| tUNION tIDENTIFIER { $$ = DEBUG_TypeCast(STRUCT, $2); }
| tENUM tIDENTIFIER { $$ = DEBUG_TypeCast(ENUM, $2); }
| tINT { $$ = DEBUG_TypeCast(DT_BASIC, "int"); }
| tCHAR { $$ = DEBUG_TypeCast(DT_BASIC, "char"); }
| tLONG tINT { $$ = DEBUG_TypeCast(DT_BASIC, "long int"); }
| tUNSIGNED tINT { $$ = DEBUG_TypeCast(DT_BASIC, "unsigned int"); }
| tLONG tUNSIGNED tINT { $$ = DEBUG_TypeCast(DT_BASIC, "long unsigned int"); }
| tLONG tLONG tINT { $$ = DEBUG_TypeCast(DT_BASIC, "long long int"); }
| tLONG tLONG tUNSIGNED tINT { $$ = DEBUG_TypeCast(DT_BASIC, "long long unsigned int"); }
| tSHORT tINT { $$ = DEBUG_TypeCast(DT_BASIC, "short int"); }
| tSHORT tUNSIGNED tINT { $$ = DEBUG_TypeCast(DT_BASIC, "short unsigned int"); }
| tSIGNED tCHAR { $$ = DEBUG_TypeCast(DT_BASIC, "signed char"); }
| tUNSIGNED tCHAR { $$ = DEBUG_TypeCast(DT_BASIC, "unsigned char"); }
| tFLOAT { $$ = DEBUG_TypeCast(DT_BASIC, "float"); }
| tDOUBLE { $$ = DEBUG_TypeCast(DT_BASIC, "double"); }
| tLONG tDOUBLE { $$ = DEBUG_TypeCast(DT_BASIC, "long double"); }
| tSTRUCT tIDENTIFIER { $$ = DEBUG_TypeCast(DT_STRUCT, $2); }
| tUNION tIDENTIFIER { $$ = DEBUG_TypeCast(DT_STRUCT, $2); }
| tENUM tIDENTIFIER { $$ = DEBUG_TypeCast(DT_ENUM, $2); }
expr_addr:
expr { $$ = DEBUG_EvalExpr($1); }

58
debugger/msc.c
View File

@ -620,11 +620,11 @@ DEBUG_ParseTypeTable(char * table, int len)
{
memset(symname, 0, sizeof(symname));
memcpy(symname, type->array.name, type->array.namelen);
typeptr = DEBUG_NewDataType(ARRAY, symname);
typeptr = DEBUG_NewDataType(DT_ARRAY, symname);
}
else
{
typeptr = DEBUG_NewDataType(ARRAY, NULL);
typeptr = DEBUG_NewDataType(DT_ARRAY, NULL);
}
cv_defined_types[curr_type - 0x1000] = typeptr;
@ -653,13 +653,13 @@ DEBUG_ParseTypeTable(char * table, int len)
type2 = (union codeview_type *) ptr2.c;
if( type2->member.id == LF_MEMBER )
{
typeptr = DEBUG_NewDataType(STRUCT, NULL);
fieldtype = STRUCT;
typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
fieldtype = DT_STRUCT;
}
else if( type2->member.id == LF_ENUMERATE )
{
typeptr = DEBUG_NewDataType(ENUM, NULL);
fieldtype = ENUM;
typeptr = DEBUG_NewDataType(DT_ENUM, NULL);
fieldtype = DT_ENUM;
}
else
{
@ -670,7 +670,7 @@ DEBUG_ParseTypeTable(char * table, int len)
while( ptr2.c < (ptr.c + ((type->generic.len + 3) & ~3)) )
{
type2 = (union codeview_type *) ptr2.c;
if( type2->member.id == LF_MEMBER && fieldtype == STRUCT )
if( type2->member.id == LF_MEMBER && fieldtype == DT_STRUCT )
{
memset(symname, 0, sizeof(symname));
memcpy(symname, type2->member.name, type2->member.namelen);
@ -697,7 +697,7 @@ DEBUG_ParseTypeTable(char * table, int len)
elem_size << 3);
}
}
else if( type2->member.id == LF_ENUMERATE && fieldtype == ENUM )
else if( type2->member.id == LF_ENUMERATE && fieldtype == DT_ENUM )
{
memset(symname, 0, sizeof(symname));
memcpy(symname, type2->enumerate.name, type2->enumerate.namelen);
@ -746,11 +746,11 @@ DEBUG_ParseTypeTable(char * table, int len)
memcpy(symname, type->structure.name, type->structure.namelen);
if( strcmp(symname, "__unnamed") == 0 )
{
typeptr = DEBUG_NewDataType(STRUCT, NULL);
typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
}
else
{
typeptr = DEBUG_NewDataType(STRUCT, symname);
typeptr = DEBUG_NewDataType(DT_STRUCT, symname);
}
cv_defined_types[curr_type - 0x1000] = typeptr;
@ -780,11 +780,11 @@ DEBUG_ParseTypeTable(char * table, int len)
if( strcmp(symname, "__unnamed") == 0 )
{
typeptr = DEBUG_NewDataType(STRUCT, NULL);
typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
}
else
{
typeptr = DEBUG_NewDataType(STRUCT, symname);
typeptr = DEBUG_NewDataType(DT_STRUCT, symname);
}
cv_defined_types[curr_type - 0x1000] = typeptr;
@ -801,7 +801,7 @@ DEBUG_ParseTypeTable(char * table, int len)
}
break;
case LF_BITFIELD:
typeptr = DEBUG_NewDataType(BITFIELD, NULL);
typeptr = DEBUG_NewDataType(DT_BITFIELD, NULL);
cv_defined_types[curr_type - 0x1000] = typeptr;
DEBUG_SetBitfieldParams(typeptr, type->bitfield.bitoff,
type->bitfield.nbits,
@ -810,7 +810,7 @@ DEBUG_ParseTypeTable(char * table, int len)
case LF_ENUMERATION:
memset(symname, 0, sizeof(symname));
memcpy(symname, type->enumeration.name, type->enumeration.namelen);
typeptr = DEBUG_NewDataType(ENUM, symname);
typeptr = DEBUG_NewDataType(DT_ENUM, symname);
cv_defined_types[curr_type - 0x1000] = typeptr;
/*
@ -842,21 +842,21 @@ DEBUG_InitCVDataTypes()
*/
cv_basic_types[T_NOTYPE] = NULL;
cv_basic_types[T_ABS] = NULL;
cv_basic_types[T_VOID] = DEBUG_NewDataType(BASIC, "void");
cv_basic_types[T_CHAR] = DEBUG_NewDataType(BASIC, "char");
cv_basic_types[T_SHORT] = DEBUG_NewDataType(BASIC, "short int");
cv_basic_types[T_LONG] = DEBUG_NewDataType(BASIC, "long int");
cv_basic_types[T_QUAD] = DEBUG_NewDataType(BASIC, "long long int");
cv_basic_types[T_UCHAR] = DEBUG_NewDataType(BASIC, "unsigned char");
cv_basic_types[T_USHORT] = DEBUG_NewDataType(BASIC, "short unsigned int");
cv_basic_types[T_ULONG] = DEBUG_NewDataType(BASIC, "long unsigned int");
cv_basic_types[T_UQUAD] = DEBUG_NewDataType(BASIC, "long long unsigned int");
cv_basic_types[T_REAL32] = DEBUG_NewDataType(BASIC, "float");
cv_basic_types[T_REAL64] = DEBUG_NewDataType(BASIC, "double");
cv_basic_types[T_RCHAR] = DEBUG_NewDataType(BASIC, "char");
cv_basic_types[T_WCHAR] = DEBUG_NewDataType(BASIC, "short");
cv_basic_types[T_INT4] = DEBUG_NewDataType(BASIC, "int");
cv_basic_types[T_UINT4] = DEBUG_NewDataType(BASIC, "unsigned int");
cv_basic_types[T_VOID] = DEBUG_NewDataType(DT_BASIC, "void");
cv_basic_types[T_CHAR] = DEBUG_NewDataType(DT_BASIC, "char");
cv_basic_types[T_SHORT] = DEBUG_NewDataType(DT_BASIC, "short int");
cv_basic_types[T_LONG] = DEBUG_NewDataType(DT_BASIC, "long int");
cv_basic_types[T_QUAD] = DEBUG_NewDataType(DT_BASIC, "long long int");
cv_basic_types[T_UCHAR] = DEBUG_NewDataType(DT_BASIC, "unsigned char");
cv_basic_types[T_USHORT] = DEBUG_NewDataType(DT_BASIC, "short unsigned int");
cv_basic_types[T_ULONG] = DEBUG_NewDataType(DT_BASIC, "long unsigned int");
cv_basic_types[T_UQUAD] = DEBUG_NewDataType(DT_BASIC, "long long unsigned int");
cv_basic_types[T_REAL32] = DEBUG_NewDataType(DT_BASIC, "float");
cv_basic_types[T_REAL64] = DEBUG_NewDataType(DT_BASIC, "double");
cv_basic_types[T_RCHAR] = DEBUG_NewDataType(DT_BASIC, "char");
cv_basic_types[T_WCHAR] = DEBUG_NewDataType(DT_BASIC, "short");
cv_basic_types[T_INT4] = DEBUG_NewDataType(DT_BASIC, "int");
cv_basic_types[T_UINT4] = DEBUG_NewDataType(DT_BASIC, "unsigned int");
cv_basic_types[T_32PVOID] = DEBUG_FindOrMakePointerType(cv_basic_types[T_VOID]);
cv_basic_types[T_32PCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_CHAR]);

28
debugger/stabs.c
View File

@ -270,28 +270,28 @@ DEBUG_HandlePreviousTypedef(const char * name, const char * stab)
switch(ptr[1])
{
case '*':
expect = POINTER;
expect = DT_POINTER;
break;
case 's':
case 'u':
expect = STRUCT;
expect = DT_STRUCT;
break;
case 'a':
expect = ARRAY;
expect = DT_ARRAY;
break;
case '1':
case '(':
case 'r':
expect = BASIC;
expect = DT_BASIC;
break;
case 'x':
expect = STRUCT;
expect = DT_STRUCT;
break;
case 'e':
expect = ENUM;
expect = DT_ENUM;
break;
case 'f':
expect = FUNC;
expect = DT_FUNC;
break;
default:
fprintf(stderr, "Unknown type (%c).\n",ptr[1]);
@ -390,35 +390,35 @@ DEBUG_ParseTypedefStab(char * ptr, const char * typename)
switch(c[1])
{
case '*':
stab_types[typenum] = DEBUG_NewDataType(POINTER, NULL);
stab_types[typenum] = DEBUG_NewDataType(DT_POINTER, NULL);
curr_types[ntypes++] = stab_types[typenum];
break;
case 's':
case 'u':
stab_types[typenum] = DEBUG_NewDataType(STRUCT, typename);
stab_types[typenum] = DEBUG_NewDataType(DT_STRUCT, typename);
curr_types[ntypes++] = stab_types[typenum];
break;
case 'a':
stab_types[typenum] = DEBUG_NewDataType(ARRAY, NULL);
stab_types[typenum] = DEBUG_NewDataType(DT_ARRAY, NULL);
curr_types[ntypes++] = stab_types[typenum];
break;
case '(':
case '1':
case 'r':
stab_types[typenum] = DEBUG_NewDataType(BASIC, typename);
stab_types[typenum] = DEBUG_NewDataType(DT_BASIC, typename);
curr_types[ntypes++] = stab_types[typenum];
break;
case 'x':
stab_strcpy(element_name, c + 3);
stab_types[typenum] = DEBUG_NewDataType(STRUCT, element_name);
stab_types[typenum] = DEBUG_NewDataType(DT_STRUCT, element_name);
curr_types[ntypes++] = stab_types[typenum];
break;
case 'e':
stab_types[typenum] = DEBUG_NewDataType(ENUM, NULL);
stab_types[typenum] = DEBUG_NewDataType(DT_ENUM, NULL);
curr_types[ntypes++] = stab_types[typenum];
break;
case 'f':
stab_types[typenum] = DEBUG_NewDataType(FUNC, NULL);
stab_types[typenum] = DEBUG_NewDataType(DT_FUNC, NULL);
curr_types[ntypes++] = stab_types[typenum];
break;
default:

120
debugger/types.c
View File

@ -166,7 +166,7 @@ DEBUG_InitBasic(int type, char * name, int size, int b_signed,
hash = NR_TYPE_HASH;
}
dt->type = BASIC;
dt->type = DT_BASIC;
dt->name = name;
dt->next = type_hash_table[hash];
type_hash_table[hash] = dt;
@ -242,7 +242,7 @@ DEBUG_NewDataType(enum debug_type xtype, const char * typename)
{
dt->name = NULL;
}
if( xtype == POINTER )
if( xtype == DT_POINTER )
{
dt->next = pointer_types;
pointer_types = dt;
@ -267,7 +267,7 @@ DEBUG_FindOrMakePointerType(struct datatype * reftype)
{
for( dt = pointer_types; dt; dt = dt->next )
{
if( dt->type != POINTER )
if( dt->type != DT_POINTER )
{
continue;
}
@ -285,7 +285,7 @@ DEBUG_FindOrMakePointerType(struct datatype * reftype)
if( dt != NULL )
{
dt->type = POINTER;
dt->type = DT_POINTER;
dt->un.pointer.pointsto = reftype;
dt->next = pointer_types;
pointer_types = dt;
@ -336,7 +336,7 @@ DEBUG_InitTypes()
DEBUG_InitBasic(BASIC_CMPLX_LONG_DBL,"complex long double",24,0,NULL);
DEBUG_InitBasic(BASIC_VOID,"void",0,0,NULL);
DEBUG_TypeString = DEBUG_NewDataType(POINTER, NULL);
DEBUG_TypeString = DEBUG_NewDataType(DT_POINTER, NULL);
DEBUG_SetPointerType(DEBUG_TypeString, chartype);
/*
@ -361,7 +361,7 @@ DEBUG_GetExprValue(DBG_ADDR * addr, char ** format)
switch(addr->type->type)
{
case BASIC:
case DT_BASIC:
if (!DBG_CHECK_READ_PTR( &address, addr->type->un.basic.basic_size))
{
return 0;
@ -389,11 +389,11 @@ DEBUG_GetExprValue(DBG_ADDR * addr, char ** format)
def_format = "%d";
}
break;
case POINTER:
case DT_POINTER:
if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
rtn = (unsigned int) *((unsigned char **)addr->off);
type2 = addr->type->un.pointer.pointsto;
if( type2->type == BASIC && type2->un.basic.basic_size == 1 )
if( type2->type == DT_BASIC && type2->un.basic.basic_size == 1 )
{
def_format = "\"%s\"";
break;
@ -403,13 +403,13 @@ DEBUG_GetExprValue(DBG_ADDR * addr, char ** format)
def_format = "0x%8.8x";
}
break;
case ARRAY:
case STRUCT:
case DT_ARRAY:
case DT_STRUCT:
if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
rtn = (unsigned int) *((unsigned char **)addr->off);
def_format = "0x%8.8x";
break;
case ENUM:
case DT_ENUM:
if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
rtn = (unsigned int) *((unsigned char **)addr->off);
for(e = addr->type->un.enumeration.members; e; e = e->next )
@ -450,7 +450,7 @@ DEBUG_TypeDerefPointer(DBG_ADDR * addr, struct datatype ** newtype)
/*
* Make sure that this really makes sense.
*/
if( addr->type->type != POINTER )
if( addr->type->type != DT_POINTER )
{
*newtype = NULL;
return 0;
@ -470,7 +470,7 @@ DEBUG_FindStructElement(DBG_ADDR * addr, const char * ele_name, int * tmpbuf)
/*
* Make sure that this really makes sense.
*/
if( addr->type->type != STRUCT )
if( addr->type->type != DT_STRUCT )
{
addr->type = NULL;
return FALSE;
@ -497,7 +497,7 @@ DEBUG_FindStructElement(DBG_ADDR * addr, const char * ele_name, int * tmpbuf)
* Check to see whether the basic type is signed or not, and if so,
* we need to sign extend the number.
*/
if( m->type->type == BASIC && m->type->un.basic.b_signed != 0
if( m->type->type == DT_BASIC && m->type->un.basic.b_signed != 0
&& (*tmpbuf & (1 << (m->size - 1))) != 0 )
{
*tmpbuf |= mask;
@ -518,7 +518,7 @@ DEBUG_FindStructElement(DBG_ADDR * addr, const char * ele_name, int * tmpbuf)
int
DEBUG_SetStructSize(struct datatype * dt, int size)
{
assert(dt->type == STRUCT);
assert(dt->type == DT_STRUCT);
if( dt->un.structure.members != NULL )
{
@ -535,9 +535,9 @@ int
DEBUG_CopyFieldlist(struct datatype * dt, struct datatype * dt2)
{
assert( dt->type == dt2->type && ((dt->type == STRUCT) || (dt->type == ENUM)));
assert( dt->type == dt2->type && ((dt->type == DT_STRUCT) || (dt->type == DT_ENUM)));
if( dt->type == STRUCT )
if( dt->type == DT_STRUCT )
{
dt->un.structure.members = dt2->un.structure.members;
}
@ -557,7 +557,7 @@ DEBUG_AddStructElement(struct datatype * dt, char * name, struct datatype * type
struct member * last;
struct en_values * e;
if( dt->type == STRUCT )
if( dt->type == DT_STRUCT )
{
for(last = dt->un.structure.members; last; last = last->next)
{
@ -595,14 +595,14 @@ DEBUG_AddStructElement(struct datatype * dt, char * name, struct datatype * type
* If the base type is bitfield, then adjust the offsets here so that we
* are able to look things up without lots of falter-all.
*/
if( type->type == BITFIELD )
if( type->type == DT_BITFIELD )
{
m->offset += m->type->un.bitfield.bitoff;
m->size = m->type->un.bitfield.nbits;
m->type = m->type->un.bitfield.basetype;
}
}
else if( dt->type == ENUM )
else if( dt->type == DT_ENUM )
{
e = (struct en_values *) xmalloc(sizeof(struct en_values));
if( e == FALSE )
@ -625,7 +625,7 @@ DEBUG_AddStructElement(struct datatype * dt, char * name, struct datatype * type
struct datatype *
DEBUG_GetPointerType(struct datatype * dt)
{
if( dt->type == POINTER )
if( dt->type == DT_POINTER )
{
return dt->un.pointer.pointsto;
}
@ -638,10 +638,10 @@ DEBUG_SetPointerType(struct datatype * dt, struct datatype * dt2)
{
switch(dt->type)
{
case POINTER:
case DT_POINTER:
dt->un.pointer.pointsto = dt2;
break;
case FUNC:
case DT_FUNC:
dt->un.funct.rettype = dt2;
break;
default:
@ -654,7 +654,7 @@ DEBUG_SetPointerType(struct datatype * dt, struct datatype * dt2)
int
DEBUG_SetArrayParams(struct datatype * dt, int min, int max, struct datatype * dt2)
{
assert(dt->type == ARRAY);
assert(dt->type == DT_ARRAY);
dt->un.array.start = min;
dt->un.array.end = max;
dt->un.array.basictype = dt2;
@ -666,7 +666,7 @@ int
DEBUG_SetBitfieldParams(struct datatype * dt, int offset, int nbits,
struct datatype * dt2)
{
assert(dt->type == BITFIELD);
assert(dt->type == DT_BITFIELD);
dt->un.bitfield.bitoff = offset;
dt->un.bitfield.nbits = nbits;
dt->un.bitfield.basetype = dt2;
@ -683,26 +683,26 @@ int DEBUG_GetObjectSize(struct datatype * dt)
switch(dt->type)
{
case BASIC:
case DT_BASIC:
return dt->un.basic.basic_size;
case POINTER:
case DT_POINTER:
return sizeof(int *);
case STRUCT:
case DT_STRUCT:
return dt->un.structure.size;
case ENUM:
case DT_ENUM:
return sizeof(int);
case ARRAY:
case DT_ARRAY:
return (dt->un.array.end - dt->un.array.start)
* DEBUG_GetObjectSize(dt->un.array.basictype);
case BITFIELD:
case DT_BITFIELD:
/*
* Bitfields have to be handled seperately later on
* when we insert the element into the structure.
*/
return 0;
case TYPEDEF:
case FUNC:
case CONST:
case DT_TYPEDEF:
case DT_FUNC:
case DT_CONST:
assert(FALSE);
}
return 0;
@ -716,7 +716,7 @@ DEBUG_ArrayIndex(DBG_ADDR * addr, DBG_ADDR * result, int index)
/*
* Make sure that this really makes sense.
*/
if( addr->type->type == POINTER )
if( addr->type->type == DT_POINTER )
{
/*
* Get the base type, so we know how much to index by.
@ -725,7 +725,7 @@ DEBUG_ArrayIndex(DBG_ADDR * addr, DBG_ADDR * result, int index)
result->type = addr->type->un.pointer.pointsto;
result->off = (*(unsigned int*) (addr->off)) + size * index;
}
else if (addr->type->type == ARRAY)
else if (addr->type->type == DT_ARRAY)
{
size = DEBUG_GetObjectSize(addr->type->un.array.basictype);
result->type = addr->type->un.array.basictype;
@ -784,13 +784,13 @@ DEBUG_Print( const DBG_ADDR *addr, int count, char format, int level )
switch(addr->type->type)
{
case BASIC:
case ENUM:
case CONST:
case POINTER:
case DT_BASIC:
case DT_ENUM:
case DT_CONST:
case DT_POINTER:
DEBUG_PrintBasic(addr, 1, format);
break;
case STRUCT:
case DT_STRUCT:
DEBUG_nchar += fprintf(stderr, "{");
for(m = addr->type->un.structure.members; m; m = m->next)
{
@ -811,7 +811,7 @@ DEBUG_Print( const DBG_ADDR *addr, int count, char format, int level )
}
DEBUG_nchar += fprintf(stderr, "}");
break;
case ARRAY:
case DT_ARRAY:
/*
* Loop over all of the entries, printing stuff as we go.
*/
@ -893,15 +893,15 @@ DEBUG_DumpTypes()
}
switch(dt->type)
{
case BASIC:
case DT_BASIC:
fprintf(stderr, "0x%p - BASIC(%s)\n",
dt, name);
break;
case POINTER:
case DT_POINTER:
fprintf(stderr, "0x%p - POINTER(%s)(%p)\n",
dt, name, dt->un.pointer.pointsto);
break;
case STRUCT:
case DT_STRUCT:
member_name = "none";
nm = 0;
if( dt->un.structure.members != NULL
@ -916,23 +916,23 @@ DEBUG_DumpTypes()
fprintf(stderr, "0x%p - STRUCT(%s) %d %d %s\n", dt, name,
dt->un.structure.size, nm, member_name);
break;
case ARRAY:
case DT_ARRAY:
fprintf(stderr, "0x%p - ARRAY(%s)(%p)\n",
dt, name, dt->un.array.basictype);
break;
case ENUM:
case DT_ENUM:
fprintf(stderr, "0x%p - ENUM(%s)\n",
dt, name);
break;
case BITFIELD:
case DT_BITFIELD:
fprintf(stderr, "0x%p - BITFIELD(%s)\n", dt, name);
break;
case FUNC:
case DT_FUNC:
fprintf(stderr, "0x%p - FUNC(%s)(%p)\n",
dt, name, dt->un.funct.rettype);
break;
case CONST:
case TYPEDEF:
case DT_CONST:
case DT_TYPEDEF:
fprintf(stderr, "What???\n");
break;
}
@ -984,31 +984,31 @@ DEBUG_PrintTypeCast(struct datatype * dt)
switch(dt->type)
{
case BASIC:
case DT_BASIC:
fprintf(stderr, "%s", name);
break;
case POINTER:
case DT_POINTER:
DEBUG_PrintTypeCast(dt->un.pointer.pointsto);
fprintf(stderr, "*");
break;
case STRUCT:
case DT_STRUCT:
fprintf(stderr, "struct %s", name);
break;
case ARRAY:
case DT_ARRAY:
fprintf(stderr, "%s[]", name);
break;
case ENUM:
case DT_ENUM:
fprintf(stderr, "enum %s", name);
break;
case BITFIELD:
case DT_BITFIELD:
fprintf(stderr, "unsigned %s", name);
break;
case FUNC:
case DT_FUNC:
DEBUG_PrintTypeCast(dt->un.funct.rettype);
fprintf(stderr, "(*%s)()", name);
break;
case CONST:
case TYPEDEF:
case DT_CONST:
case DT_TYPEDEF:
fprintf(stderr, "What???\n");
break;
}

2
graphics/escape.c
View File

@ -22,7 +22,7 @@ INT16 WINAPI Escape16( HDC16 hdc, INT16 nEscape, INT16 cbInput,
}
INT32 WINAPI Escape32( HDC32 hdc, INT32 nEscape, INT32 cbInput,
LPVOID lpszInData, LPVOID lpvOutData )
LPCSTR lpszInData, LPVOID lpvOutData )
{
DC *dc = DC_GetDCPtr( hdc );
SEGPTR segin,segout;

8
graphics/metafiledrv/graphics.c
View File

@ -121,7 +121,7 @@ MFDRV_SetPixel( DC *dc, INT32 x, INT32 y, COLORREF color )
* MFDRV_Polyline
*/
BOOL32
MFDRV_Polyline( DC *dc, const LPPOINT32 pt, INT32 count )
MFDRV_Polyline( DC *dc, const POINT32* pt, INT32 count )
{
register int i;
LPPOINT16 pt16;
@ -140,7 +140,7 @@ MFDRV_Polyline( DC *dc, const LPPOINT32 pt, INT32 count )
* MFDRV_Polygon
*/
BOOL32
MFDRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count )
MFDRV_Polygon( DC *dc, const POINT32* pt, INT32 count )
{
register int i;
LPPOINT16 pt16;
@ -159,11 +159,11 @@ MFDRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count )
* PolyPolygon
*/
BOOL32
MFDRV_PolyPolygon( DC *dc, LPPOINT32 pt, LPINT32 counts, UINT32 polygons)
MFDRV_PolyPolygon( DC *dc, const POINT32* pt, const INT32* counts, UINT32 polygons)
{
int i,j;
LPPOINT16 pt16;
LPPOINT32 curpt=pt;
const POINT32* curpt=pt;
BOOL32 ret;
for (i=0;i<polygons;i++) {

32
graphics/painting.c
View File

@ -423,11 +423,9 @@ COLORREF WINAPI GetPixel32( HDC32 hdc, INT32 x, INT32 y )
* Success: Pixel format index closest to given format
* Failure: 0
*/
INT32 WINAPI ChoosePixelFormat( HDC32 hdc, PIXELFORMATDESCRIPTOR *ppfd )
INT32 WINAPI ChoosePixelFormat( HDC32 hdc, const PIXELFORMATDESCRIPTOR* ppfd )
{
FIXME(gdi, "(%d,%p): stub\n",hdc,ppfd);
ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
ppfd->nVersion = 1;
return 1;
}
@ -444,7 +442,7 @@ INT32 WINAPI ChoosePixelFormat( HDC32 hdc, PIXELFORMATDESCRIPTOR *ppfd )
* RETURNS STD
*/
BOOL32 WINAPI SetPixelFormat( HDC32 hdc, int iPixelFormat,
PIXELFORMATDESCRIPTOR * ppfd)
const PIXELFORMATDESCRIPTOR* ppfd)
{
FIXME(gdi, "(%d,%d,%p): stub\n",hdc,iPixelFormat,ppfd);
return TRUE;
@ -656,7 +654,7 @@ void WINAPI DrawFocusRect32( HDC32 hdc, const RECT32* rc )
/**********************************************************************
* Polyline16 (GDI.37)
*/
BOOL16 WINAPI Polyline16( HDC16 hdc, LPPOINT16 pt, INT16 count )
BOOL16 WINAPI Polyline16( HDC16 hdc, const POINT16* pt, INT16 count )
{
register int i;
BOOL16 ret;
@ -674,7 +672,7 @@ BOOL16 WINAPI Polyline16( HDC16 hdc, LPPOINT16 pt, INT16 count )
/**********************************************************************
* Polyline32 (GDI32.276)
*/
BOOL32 WINAPI Polyline32( HDC32 hdc, const LPPOINT32 pt, INT32 count )
BOOL32 WINAPI Polyline32( HDC32 hdc, const POINT32* pt, INT32 count )
{
DC * dc = DC_GetDCPtr( hdc );
@ -686,7 +684,7 @@ BOOL32 WINAPI Polyline32( HDC32 hdc, const LPPOINT32 pt, INT32 count )
/**********************************************************************
* Polygon16 (GDI.36)
*/
BOOL16 WINAPI Polygon16( HDC16 hdc, LPPOINT16 pt, INT16 count )
BOOL16 WINAPI Polygon16( HDC16 hdc, const POINT16* pt, INT16 count )
{
register int i;
BOOL32 ret;
@ -704,7 +702,7 @@ BOOL16 WINAPI Polygon16( HDC16 hdc, LPPOINT16 pt, INT16 count )
/**********************************************************************
* Polygon32 (GDI32.275)
*/
BOOL32 WINAPI Polygon32( HDC32 hdc, LPPOINT32 pt, INT32 count )
BOOL32 WINAPI Polygon32( HDC32 hdc, const POINT32* pt, INT32 count )
{
DC * dc = DC_GetDCPtr( hdc );
@ -716,7 +714,7 @@ BOOL32 WINAPI Polygon32( HDC32 hdc, LPPOINT32 pt, INT32 count )
/**********************************************************************
* PolyPolygon16 (GDI.450)
*/
BOOL16 WINAPI PolyPolygon16( HDC16 hdc, LPPOINT16 pt, LPINT16 counts,
BOOL16 WINAPI PolyPolygon16( HDC16 hdc, const POINT16* pt, const INT16* counts,
UINT16 polygons )
{
int i,nrpts;
@ -743,7 +741,7 @@ BOOL16 WINAPI PolyPolygon16( HDC16 hdc, LPPOINT16 pt, LPINT16 counts,
/**********************************************************************
* PolyPolygon32 (GDI.450)
*/
BOOL32 WINAPI PolyPolygon32( HDC32 hdc, LPPOINT32 pt, LPINT32 counts,
BOOL32 WINAPI PolyPolygon32( HDC32 hdc, const POINT32* pt, const INT32* counts,
UINT32 polygons )
{
DC * dc = DC_GetDCPtr( hdc );
@ -755,7 +753,7 @@ BOOL32 WINAPI PolyPolygon32( HDC32 hdc, LPPOINT32 pt, LPINT32 counts,
/**********************************************************************
* PolyPolyline32 (GDI32.272)
*/
BOOL32 WINAPI PolyPolyline32( HDC32 hdc, LPPOINT32 pt, LPDWORD counts,
BOOL32 WINAPI PolyPolyline32( HDC32 hdc, const POINT32* pt, const DWORD* counts,
DWORD polylines )
{
DC * dc = DC_GetDCPtr( hdc );
@ -809,8 +807,8 @@ BOOL32 WINAPI FloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
* DrawAnimatedRects32 (USER32.153)
*/
BOOL32 WINAPI DrawAnimatedRects32( HWND32 hwnd, int idAni,
const LPRECT32 lprcFrom,
const LPRECT32 lprcTo )
const RECT32* lprcFrom,
const RECT32* lprcTo )
{
FIXME(gdi,"(0x%x,%d,%p,%p): stub\n",hwnd,idAni,lprcFrom,lprcTo);
return TRUE;
@ -1057,7 +1055,7 @@ BOOL16 WINAPI DrawState16(HDC16 hdc, HBRUSH16 hbr,
/******************************************************************************
* PolyBezier16 [GDI.502]
*/
BOOL16 WINAPI PolyBezier16( HDC16 hDc, LPPOINT16 lppt, INT16 cPoints )
BOOL16 WINAPI PolyBezier16( HDC16 hDc, const POINT16* lppt, INT16 cPoints )
{
int i;
BOOL16 ret;
@ -1073,7 +1071,7 @@ BOOL16 WINAPI PolyBezier16( HDC16 hDc, LPPOINT16 lppt, INT16 cPoints )
/******************************************************************************
* PolyBezierTo16 [GDI.503]
*/
BOOL16 WINAPI PolyBezierTo16( HDC16 hDc, LPPOINT16 lppt, INT16 cPoints )
BOOL16 WINAPI PolyBezierTo16( HDC16 hDc, const POINT16* lppt, INT16 cPoints )
{
int i;
BOOL16 ret;
@ -1097,7 +1095,7 @@ BOOL16 WINAPI PolyBezierTo16( HDC16 hDc, LPPOINT16 lppt, INT16 cPoints )
*
* RETURNS STD
*/
BOOL32 WINAPI PolyBezier32( HDC32 hdc, LPPOINT32 lppt, DWORD cPoints )
BOOL32 WINAPI PolyBezier32( HDC32 hdc, const POINT32* lppt, DWORD cPoints )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
@ -1120,7 +1118,7 @@ BOOL32 WINAPI PolyBezier32( HDC32 hdc, LPPOINT32 lppt, DWORD cPoints )
*
* RETURNS STD
*/
BOOL32 WINAPI PolyBezierTo32( HDC32 hdc, LPPOINT32 lppt, DWORD cPoints )
BOOL32 WINAPI PolyBezierTo32( HDC32 hdc, const POINT32* lppt, DWORD cPoints )
{
DC * dc = DC_GetDCPtr( hdc );
POINT32 pt;

7
graphics/path.c
View File

@ -340,7 +340,8 @@ BOOL32 WINAPI FillPath32(HDC32 hdc)
{
GdiPath *pPath;
INT32 mapMode, graphicsMode;
POINT32 ptViewportExt, ptViewportOrg, ptWindowExt, ptWindowOrg;
SIZE32 ptViewportExt, ptWindowExt;
POINT32 ptViewportOrg, ptWindowOrg;
XFORM xform;
HRGN32 hrgn;
@ -392,9 +393,9 @@ BOOL32 WINAPI FillPath32(HDC32 hdc)
/* Restore the old mapping mode */
SetMapMode32(hdc, mapMode);
SetViewportExtEx32(hdc, ptViewportExt.x, ptViewportExt.y, NULL);
SetViewportExtEx32(hdc, ptViewportExt.cx, ptViewportExt.cy, NULL);
SetViewportOrgEx32(hdc, ptViewportOrg.x, ptViewportOrg.y, NULL);
SetWindowExtEx32(hdc, ptWindowExt.x, ptWindowExt.y, NULL);
SetWindowExtEx32(hdc, ptWindowExt.cx, ptWindowExt.cy, NULL);
SetWindowOrgEx32(hdc, ptWindowOrg.x, ptWindowOrg.y, NULL);
/* Go to GM_ADVANCED temporarily to restore the world transform */

13
graphics/psdrv/graphics.c
View File

@ -217,11 +217,11 @@ BOOL32 PSDRV_Ellipse( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom)
/***********************************************************************
* PSDRV_PolyPolyline
*/
BOOL32 PSDRV_PolyPolyline( DC *dc, LPPOINT32 pts, LPDWORD counts,
BOOL32 PSDRV_PolyPolyline( DC *dc, const POINT32* pts, const DWORD* counts,
DWORD polylines )
{
DWORD polyline, line;
LPPOINT32 pt;
const POINT32* pt;
TRACE(psdrv, "\n");
pt = pts;
@ -242,7 +242,7 @@ BOOL32 PSDRV_PolyPolyline( DC *dc, LPPOINT32 pts, LPDWORD counts,
/***********************************************************************
* PSDRV_Polyline
*/
BOOL32 PSDRV_Polyline( DC *dc, const LPPOINT32 pt, INT32 count )
BOOL32 PSDRV_Polyline( DC *dc, const POINT32* pt, INT32 count )
{
return PSDRV_PolyPolyline( dc, pt, (LPDWORD) &count, 1 );
}
@ -251,11 +251,11 @@ BOOL32 PSDRV_Polyline( DC *dc, const LPPOINT32 pt, INT32 count )
/***********************************************************************
* PSDRV_PolyPolygon
*/
BOOL32 PSDRV_PolyPolygon( DC *dc, LPPOINT32 pts, LPINT32 counts,
BOOL32 PSDRV_PolyPolygon( DC *dc, const POINT32* pts, const INT32* counts,
UINT32 polygons )
{
DWORD polygon, line;
LPPOINT32 pt;
const POINT32* pt;
TRACE(psdrv, "\n");
pt = pts;
@ -278,10 +278,11 @@ BOOL32 PSDRV_PolyPolygon( DC *dc, LPPOINT32 pts, LPINT32 counts,
return TRUE;
}
/***********************************************************************
* PSDRV_Polygon
*/
BOOL32 PSDRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count )
BOOL32 PSDRV_Polygon( DC *dc, const POINT32* pt, INT32 count )
{
return PSDRV_PolyPolygon( dc, pt, &count, 1 );
}

4
graphics/win16drv/graphics.c
View File

@ -84,7 +84,7 @@ WIN16DRV_Rectangle(DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom)
* WIN16DRV_Polygon
*/
BOOL32
WIN16DRV_Polygon(DC *dc, LPPOINT32 pt, INT32 count )
WIN16DRV_Polygon(DC *dc, const POINT32* pt, INT32 count )
{
WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev;
BOOL32 bRet = 0;
@ -117,7 +117,7 @@ WIN16DRV_Polygon(DC *dc, LPPOINT32 pt, INT32 count )
* WIN16DRV_Polyline
*/
BOOL32
WIN16DRV_Polyline(DC *dc, LPPOINT32 pt, INT32 count )
WIN16DRV_Polyline(DC *dc, const POINT32* pt, INT32 count )
{
WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev;
BOOL32 bRet = 0;

10
graphics/x11drv/graphics.c
View File

@ -652,7 +652,7 @@ X11DRV_PaintRgn( DC *dc, HRGN32 hrgn )
* X11DRV_Polyline
*/
BOOL32
X11DRV_Polyline( DC *dc, LPPOINT32 pt, INT32 count )
X11DRV_Polyline( DC *dc, const POINT32* pt, INT32 count )
{
INT32 oldwidth;
register int i;
@ -680,7 +680,7 @@ X11DRV_Polyline( DC *dc, LPPOINT32 pt, INT32 count )
* X11DRV_Polygon
*/
BOOL32
X11DRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count )
X11DRV_Polygon( DC *dc, const POINT32* pt, INT32 count )
{
register int i;
XPoint *points;
@ -710,7 +710,7 @@ X11DRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count )
* X11DRV_PolyPolygon
*/
BOOL32
X11DRV_PolyPolygon( DC *dc, LPPOINT32 pt, LPINT32 counts, UINT32 polygons)
X11DRV_PolyPolygon( DC *dc, const POINT32* pt, const INT32* counts, UINT32 polygons)
{
HRGN32 hrgn;
@ -754,7 +754,7 @@ X11DRV_PolyPolygon( DC *dc, LPPOINT32 pt, LPINT32 counts, UINT32 polygons)
* X11DRV_PolyPolyline
*/
BOOL32
X11DRV_PolyPolyline( DC *dc, LPPOINT32 pt, LPDWORD counts, DWORD polylines )
X11DRV_PolyPolyline( DC *dc, const POINT32* pt, const DWORD* counts, DWORD polylines )
{
if (DC_SetupGCForPen ( dc ))
{
@ -1086,7 +1086,7 @@ static void X11DRV_Bezier(int level, DC * dc, POINT32 *Points,
* multiple of 3.
*/
BOOL32
X11DRV_PolyBezier(DC *dc, POINT32 start, POINT32 *BezierPoints, DWORD count)
X11DRV_PolyBezier(DC *dc, POINT32 start, const POINT32* BezierPoints, DWORD count)
{
POINT32 Points[4];
int i;

2
include/debugger.h
View File

@ -23,7 +23,7 @@
#define SYM_TRAMPOLINE 0x10
#define SYM_STEP_THROUGH 0x20
enum debug_type {BASIC, CONST, POINTER, ARRAY, STRUCT, ENUM, TYPEDEF, FUNC, BITFIELD};
enum debug_type {DT_BASIC, DT_CONST, DT_POINTER, DT_ARRAY, DT_STRUCT, DT_ENUM, DT_TYPEDEF, DT_FUNC, DT_BITFIELD};
/*

10
include/gdi.h
View File

@ -200,11 +200,11 @@ typedef struct tagDC_FUNCS
BOOL32 (*pPaintRgn)(DC*,HRGN32);
BOOL32 (*pPatBlt)(DC*,INT32,INT32,INT32,INT32,DWORD);
BOOL32 (*pPie)(DC*,INT32,INT32,INT32,INT32,INT32,INT32,INT32,INT32);
BOOL32 (*pPolyPolygon)(DC*,LPPOINT32,LPINT32,UINT32);
BOOL32 (*pPolyPolyline)(DC*,LPPOINT32,LPDWORD,DWORD);
BOOL32 (*pPolygon)(DC*,LPPOINT32,INT32);
BOOL32 (*pPolyline)(DC*,LPPOINT32,INT32);
BOOL32 (*pPolyBezier)(DC*,POINT32, LPPOINT32,DWORD);
BOOL32 (*pPolyPolygon)(DC*,const POINT32*,const INT32*,UINT32);
BOOL32 (*pPolyPolyline)(DC*,const POINT32*,const DWORD*,DWORD);
BOOL32 (*pPolygon)(DC*,const POINT32*,INT32);
BOOL32 (*pPolyline)(DC*,const POINT32*,INT32);
BOOL32 (*pPolyBezier)(DC*,POINT32, const POINT32*,DWORD);
UINT32 (*pRealizePalette)(DC*);
BOOL32 (*pRectangle)(DC*,INT32,INT32,INT32,INT32);
BOOL32 (*pRestoreDC)(DC*,INT32);

6
include/metafiledrv.h
View File

@ -63,9 +63,9 @@ extern BOOL32 MFDRV_RoundRect( struct tagDC *dc, INT32 left, INT32 top,
INT32 right, INT32 bottom, INT32 ell_width,
INT32 ell_height );
extern COLORREF MFDRV_SetPixel( struct tagDC *dc, INT32 x, INT32 y, COLORREF color );
extern BOOL32 MFDRV_Polyline( struct tagDC *dc, const LPPOINT32 pt,INT32 count);
extern BOOL32 MFDRV_Polygon( struct tagDC *dc, LPPOINT32 pt, INT32 count );
extern BOOL32 MFDRV_PolyPolygon( struct tagDC *dc, LPPOINT32 pt, LPINT32 counts,
extern BOOL32 MFDRV_Polyline( struct tagDC *dc, const POINT32* pt,INT32 count);
extern BOOL32 MFDRV_Polygon( struct tagDC *dc, const POINT32* pt, INT32 count );
extern BOOL32 MFDRV_PolyPolygon( struct tagDC *dc, const POINT32* pt, const INT32* counts,
UINT32 polygons);
extern HGDIOBJ32 MFDRV_SelectObject( DC *dc, HGDIOBJ32 handle );
extern COLORREF MFDRV_SetBkColor( DC *dc, COLORREF color );

8
include/psdrv.h
View File

@ -310,11 +310,11 @@ extern BOOL32 PSDRV_MoveToEx( DC *dc, INT32 x, INT32 y, LPPOINT32 pt );
extern BOOL32 PSDRV_Pie( DC *dc, INT32 left, INT32 top, INT32 right,
INT32 bottom, INT32 xstart, INT32 ystart,
INT32 xend, INT32 yend );
extern BOOL32 PSDRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count );
extern BOOL32 PSDRV_Polyline( DC *dc, const LPPOINT32 pt, INT32 count );
extern BOOL32 PSDRV_PolyPolygon( DC *dc, LPPOINT32 pts, LPINT32 counts,
extern BOOL32 PSDRV_Polygon( DC *dc, const POINT32* pt, INT32 count );
extern BOOL32 PSDRV_Polyline( DC *dc, const POINT32* pt, INT32 count );
extern BOOL32 PSDRV_PolyPolygon( DC *dc, const POINT32* pts, const INT32* counts,
UINT32 polygons );
extern BOOL32 PSDRV_PolyPolyline( DC *dc, LPPOINT32 pts, LPDWORD counts,
extern BOOL32 PSDRV_PolyPolyline( DC *dc, const POINT32* pts, const DWORD* counts,
DWORD polylines );
extern BOOL32 PSDRV_Rectangle( DC *dc, INT32 left, INT32 top, INT32 right,
INT32 bottom );

4
include/win16drv.h
View File

@ -216,8 +216,8 @@ extern BOOL32 WIN16DRV_ExtTextOut( DC *dc, INT32 x, INT32 y, UINT32 flags,
const INT32 *lpDx );
extern BOOL32 WIN16DRV_LineTo( DC *dc, INT32 x, INT32 y );
extern BOOL32 WIN16DRV_MoveToEx(DC *dc,INT32 x,INT32 y,LPPOINT32 pt);
extern BOOL32 WIN16DRV_Polygon(DC *dc, LPPOINT32 pt, INT32 count );
extern BOOL32 WIN16DRV_Polyline(DC *dc, LPPOINT32 pt, INT32 count );
extern BOOL32 WIN16DRV_Polygon(DC *dc, const POINT32* pt, INT32 count );
extern BOOL32 WIN16DRV_Polyline(DC *dc, const POINT32* pt, INT32 count );
extern BOOL32 WIN16DRV_Rectangle(DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom);
extern HGDIOBJ32 WIN16DRV_SelectObject( DC *dc, HGDIOBJ32 handle );
extern BOOL32 WIN16DRV_PatBlt( struct tagDC *dc, INT32 left, INT32 top,

74
include/windows.h
View File

@ -5445,6 +5445,28 @@ typedef struct {
#define TIME_ZONE_ID_STANDARD 1
#define TIME_ZONE_ID_DAYLIGHT 2
/*
* Process Entry list as created by CreateToolHelp32Snapshot
*/
#ifndef MAX_PATH
#define MAX_PATH 260
#endif
typedef struct tagPROCESSENTRY32 {
DWORD dwSize;
DWORD cntUsage;
DWORD th32ProcessID;
DWORD th32DefaultHeapID;
DWORD th32ModuleID;
DWORD cntThreads;
DWORD th32ParentProcessID;
LONG pcPriClassBase;
DWORD dwFlags;
char szExeFile[MAX_PATH];
} PROCESSENTRY32;
typedef PROCESSENTRY32 * PPROCESSENTRY32;
typedef PROCESSENTRY32 * LPPROCESSENTRY32;
/* CreateProcess: dwCreationFlag values
*/
#define DEBUG_PROCESS 0x00000001
@ -6765,7 +6787,7 @@ INT32 WINAPI ExtSelectClipRgn(HDC32,HRGN32,INT32);
DWORD WINAPI ExpandEnvironmentStrings32A(LPCSTR,LPSTR,DWORD);
DWORD WINAPI ExpandEnvironmentStrings32W(LPCWSTR,LPWSTR,DWORD);
#define ExpandEnvironmentStrings WINELIB_NAME_AW(ExpandEnvironmentStrings)
HRGN32 WINAPI ExtCreateRegion(LPXFORM,DWORD,LPRGNDATA);
HRGN32 WINAPI ExtCreateRegion(const XFORM*,DWORD,const RGNDATA*);
INT32 WINAPI ExtEscape32(HDC32,INT32,INT32,LPCSTR,INT32,LPSTR);
BOOL32 WINAPI FileTimeToDosDateTime(const FILETIME*,LPWORD,LPWORD);
BOOL32 WINAPI FileTimeToLocalFileTime(const FILETIME*,LPFILETIME);
@ -6957,7 +6979,7 @@ HANDLE32 WINAPI OpenService32W(HANDLE32,LPCWSTR,DWORD);
BOOL32 WINAPI PaintDesktop(HDC32);
BOOL32 WINAPI PlayEnhMetaFile(HDC32,HENHMETAFILE32,const RECT32*);
BOOL32 WINAPI PlayEnhMetaFileRecord(HDC32,LPHANDLETABLE32,const ENHMETARECORD*,UINT32);
BOOL32 WINAPI PolyPolyline32(HDC32,LPPOINT32,LPDWORD,DWORD);
BOOL32 WINAPI PolyPolyline32(HDC32,const POINT32*,const DWORD*,DWORD);
BOOL32 WINAPI PulseEvent(HANDLE32);
DWORD WINAPI QueryDosDevice32A(LPCSTR,LPSTR,DWORD);
DWORD WINAPI QueryDosDevice32W(LPCWSTR,LPWSTR,DWORD);
@ -7174,8 +7196,8 @@ BOOL32 WINAPI AdjustWindowRect32(LPRECT32,DWORD,BOOL32);
BOOL16 WINAPI AdjustWindowRectEx16(LPRECT16,DWORD,BOOL16,DWORD);
BOOL32 WINAPI AdjustWindowRectEx32(LPRECT32,DWORD,BOOL32,DWORD);
#define AdjustWindowRectEx WINELIB_NAME(AdjustWindowRectEx)
void WINAPI AnimatePalette16(HPALETTE16,UINT16,UINT16,LPPALETTEENTRY);
BOOL32 WINAPI AnimatePalette32(HPALETTE32,UINT32,UINT32,LPPALETTEENTRY);
void WINAPI AnimatePalette16(HPALETTE16,UINT16,UINT16,const PALETTEENTRY*);
BOOL32 WINAPI AnimatePalette32(HPALETTE32,UINT32,UINT32,const PALETTEENTRY*);
#define AnimatePalette WINELIB_NAME(AnimatePalette)
SEGPTR WINAPI AnsiLower16(SEGPTR);
#define AnsiLower32A CharLower32A
@ -7310,7 +7332,7 @@ BOOL32 WINAPI CheckRadioButton32(HWND32,UINT32,UINT32,UINT32);
HWND16 WINAPI ChildWindowFromPoint16(HWND16,POINT16);
HWND32 WINAPI ChildWindowFromPoint32(HWND32,POINT32);
#define ChildWindowFromPoint WINELIB_NAME(ChildWindowFromPoint)
INT32 WINAPI ChoosePixelFormat(HDC32,PIXELFORMATDESCRIPTOR*);
INT32 WINAPI ChoosePixelFormat(HDC32,const PIXELFORMATDESCRIPTOR*);
BOOL16 WINAPI Chord16(HDC16,INT16,INT16,INT16,INT16,INT16,INT16,INT16,INT16);
BOOL32 WINAPI Chord32(HDC32,INT32,INT32,INT32,INT32,INT32,INT32,INT32,INT32);
#define Chord WINELIB_NAME(Chord)
@ -7644,6 +7666,8 @@ BOOL32 WINAPI DragDetect32(HWND32,POINT32);
DWORD WINAPI DragObject16(HWND16,HWND16,UINT16,HANDLE16,WORD,HCURSOR16);
DWORD WINAPI DragObject32(HWND32,HWND32,UINT32,DWORD,HCURSOR32);
#define DragObject WINELIB_NAME(DragObject)
BOOL32 WINAPI DrawAnimatedRects32(HWND32,int,const RECT32*,const RECT32*);
#define DrawAnimatedRects WINELIB_NAME(DrawAnimatedRects)
BOOL16 WINAPI DrawCaption16(HWND16,HDC16,const RECT16*,UINT16);
BOOL32 WINAPI DrawCaption32(HWND32,HDC32,const RECT32*,UINT32);
#define DrawCaption WINELIB_NAME(DrawCaption)
@ -7751,7 +7775,7 @@ BOOL16 WINAPI EqualRgn16(HRGN16,HRGN16);
BOOL32 WINAPI EqualRgn32(HRGN32,HRGN32);
#define EqualRgn WINELIB_NAME(EqualRgn)
INT16 WINAPI Escape16(HDC16,INT16,INT16,SEGPTR,SEGPTR);
INT32 WINAPI Escape32(HDC32,INT32,INT32,LPVOID,LPVOID);
INT32 WINAPI Escape32(HDC32,INT32,INT32,LPCSTR,LPVOID);
#define Escape WINELIB_NAME(Escape)
LONG WINAPI EscapeCommFunction16(UINT16,UINT16);
BOOL32 WINAPI EscapeCommFunction32(INT32,UINT32);
@ -8340,8 +8364,8 @@ INT32 WINAPI GetUpdateRgn32(HWND32,HRGN32,BOOL32);
LONG WINAPI GetVersion16(void);
LONG WINAPI GetVersion32(void);
#define GetVersion WINELIB_NAME(GetVersion)
BOOL16 WINAPI GetViewportExtEx16(HDC16,LPPOINT16);
BOOL32 WINAPI GetViewportExtEx32(HDC32,LPPOINT32);
BOOL16 WINAPI GetViewportExtEx16(HDC16,LPSIZE16);
BOOL32 WINAPI GetViewportExtEx32(HDC32,LPSIZE32);
#define GetViewportExtEx WINELIB_NAME(GetViewportExtEx)
BOOL16 WINAPI GetViewportOrgEx16(HDC16,LPPOINT16);
BOOL32 WINAPI GetViewportOrgEx32(HDC32,LPPOINT32);
@ -8355,8 +8379,8 @@ HWND32 WINAPI GetWindow32(HWND32,WORD);
HDC16 WINAPI GetWindowDC16(HWND16);
HDC32 WINAPI GetWindowDC32(HWND32);
#define GetWindowDC WINELIB_NAME(GetWindowDC)
BOOL16 WINAPI GetWindowExtEx16(HDC16,LPPOINT16);
BOOL32 WINAPI GetWindowExtEx32(HDC32,LPPOINT32);
BOOL16 WINAPI GetWindowExtEx16(HDC16,LPSIZE16);
BOOL32 WINAPI GetWindowExtEx32(HDC32,LPSIZE32);
#define GetWindowExtEx WINELIB_NAME(GetWindowExtEx)
LONG WINAPI GetWindowLong16(HWND16,INT16);
LONG WINAPI GetWindowLong32A(HWND32,INT32);
@ -8803,20 +8827,20 @@ BOOL32 WINAPI PlayMetaFile32(HDC32,HMETAFILE32);
VOID WINAPI PlayMetaFileRecord16(HDC16,LPHANDLETABLE16,LPMETARECORD,UINT16);
BOOL32 WINAPI PlayMetaFileRecord32(HDC32,LPHANDLETABLE32,LPMETARECORD,UINT32);
#define PlayMetaFileRecord WINELIB_NAME(PlayMetaFileRecord)
BOOL16 WINAPI PolyBezier16(HDC16,LPPOINT16,INT16);
BOOL32 WINAPI PolyBezier32(HDC32,LPPOINT32,DWORD);
BOOL16 WINAPI PolyBezier16(HDC16,const POINT16*,INT16);
BOOL32 WINAPI PolyBezier32(HDC32,const POINT32*,DWORD);
#define PolyBezier WINELIB_NAME(PolyBezier)
BOOL16 WINAPI PolyBezierTo16(HDC16,LPPOINT16,INT16);
BOOL32 WINAPI PolyBezierTo32(HDC32,LPPOINT32,DWORD);
BOOL16 WINAPI PolyBezierTo16(HDC16,const POINT16*,INT16);
BOOL32 WINAPI PolyBezierTo32(HDC32,const POINT32*,DWORD);
#define PolyBezierTo WINELIB_NAME(PolyBezierTo)
BOOL16 WINAPI PolyPolygon16(HDC16,LPPOINT16,LPINT16,UINT16);
BOOL32 WINAPI PolyPolygon32(HDC32,LPPOINT32,LPINT32,UINT32);
BOOL16 WINAPI PolyPolygon16(HDC16,const POINT16*,const INT16*,UINT16);
BOOL32 WINAPI PolyPolygon32(HDC32,const POINT32*,const INT32*,UINT32);
#define PolyPolygon WINELIB_NAME(PolyPolygon)
BOOL16 WINAPI Polygon16(HDC16,LPPOINT16,INT16);
BOOL32 WINAPI Polygon32(HDC32,LPPOINT32,INT32);
BOOL16 WINAPI Polygon16(HDC16,const POINT16*,INT16);
BOOL32 WINAPI Polygon32(HDC32,const POINT32*,INT32);
#define Polygon WINELIB_NAME(Polygon)
BOOL16 WINAPI Polyline16(HDC16,LPPOINT16,INT16);
BOOL32 WINAPI Polyline32(HDC32,LPPOINT32,INT32);
BOOL16 WINAPI Polyline16(HDC16,const POINT16*,INT16);
BOOL32 WINAPI Polyline32(HDC32,const POINT32*,INT32);
#define Polyline WINELIB_NAME(Polyline)
BOOL16 WINAPI PostAppMessage16(HTASK16,UINT16,WPARAM16,LPARAM);
#define PostAppMessage32A(thread,msg,wparam,lparam) \
@ -8849,8 +8873,8 @@ BOOL32 WINAPI Rectangle32(HDC32,INT32,INT32,INT32,INT32);
BOOL16 WINAPI RectInRegion16(HRGN16,const RECT16 *);
BOOL32 WINAPI RectInRegion32(HRGN32,const RECT32 *);
#define RectInRegion WINELIB_NAME(RectInRegion)
BOOL16 WINAPI RectVisible16(HDC16,LPRECT16);
BOOL32 WINAPI RectVisible32(HDC32,LPRECT32);
BOOL16 WINAPI RectVisible16(HDC16,const RECT16*);
BOOL32 WINAPI RectVisible32(HDC32,const RECT32*);
#define RectVisible WINELIB_NAME(RectVisible)
BOOL16 WINAPI RedrawWindow16(HWND16,const RECT16*,HRGN16,UINT16);
BOOL32 WINAPI RedrawWindow32(HWND32,const RECT32*,HRGN32,UINT32);
@ -9024,8 +9048,8 @@ COLORREF WINAPI SetBkColor32(HDC32,COLORREF);
INT16 WINAPI SetBkMode16(HDC16,INT16);
INT32 WINAPI SetBkMode32(HDC32,INT32);
#define SetBkMode WINELIB_NAME(SetBkMode)
UINT16 WINAPI SetBoundsRect16(HDC16,LPRECT16,UINT16);
UINT32 WINAPI SetBoundsRect32(HDC32,LPRECT32,UINT32);
UINT16 WINAPI SetBoundsRect16(HDC16,const RECT16*,UINT16);
UINT32 WINAPI SetBoundsRect32(HDC32,const RECT32*,UINT32);
#define SetBoundsRect WINELIB_NAME(SetBoundsRect)
HWND16 WINAPI SetCapture16(HWND16);
HWND32 WINAPI SetCapture32(HWND32);
@ -9133,7 +9157,7 @@ COLORREF WINAPI SetPixel16(HDC16,INT16,INT16,COLORREF);
COLORREF WINAPI SetPixel32(HDC32,INT32,INT32,COLORREF);
#define SetPixel WINELIB_NAME(SetPixel)
BOOL32 WINAPI SetPixelV32(HDC32,INT32,INT32,COLORREF);
BOOL32 WINAPI SetPixelFormat(HDC32,int,PIXELFORMATDESCRIPTOR*);
BOOL32 WINAPI SetPixelFormat(HDC32,int,const PIXELFORMATDESCRIPTOR*);
INT16 WINAPI SetPolyFillMode16(HDC16,INT16);
INT32 WINAPI SetPolyFillMode32(HDC32,INT32);
#define SetPolyFillMode WINELIB_NAME(SetPolyFillMode)

1
include/wintypes.h
View File

@ -62,6 +62,7 @@
#define WINAPIV __cdecl
#define APIENTRY WINAPI
#define CONST const
/* Standard data types. These are the same for emulator and library. */

14
include/x11drv.h
View File

@ -106,13 +106,13 @@ extern COLORREF X11DRV_SetPixel( struct tagDC *dc, INT32 x, INT32 y,
COLORREF color );
extern COLORREF X11DRV_GetPixel( struct tagDC *dc, INT32 x, INT32 y);
extern BOOL32 X11DRV_PaintRgn( struct tagDC *dc, HRGN32 hrgn );
extern BOOL32 X11DRV_Polyline( struct tagDC *dc,const LPPOINT32 pt,INT32 count);
extern BOOL32 X11DRV_PolyBezier( struct tagDC *dc,const POINT32 start, const LPPOINT32 lppt,DWORD cPoints);
extern BOOL32 X11DRV_Polygon( struct tagDC *dc, LPPOINT32 pt, INT32 count );
extern BOOL32 X11DRV_PolyPolygon( struct tagDC *dc, LPPOINT32 pt,
LPINT32 counts, UINT32 polygons);
extern BOOL32 X11DRV_PolyPolyline( struct tagDC *dc, LPPOINT32 pt,
LPDWORD counts, DWORD polylines);
extern BOOL32 X11DRV_Polyline( struct tagDC *dc,const POINT32* pt,INT32 count);
extern BOOL32 X11DRV_PolyBezier( struct tagDC *dc, const POINT32 start, const POINT32* lppt, DWORD cPoints);
extern BOOL32 X11DRV_Polygon( struct tagDC *dc, const POINT32* pt, INT32 count );
extern BOOL32 X11DRV_PolyPolygon( struct tagDC *dc, const POINT32* pt,
const INT32* counts, UINT32 polygons);
extern BOOL32 X11DRV_PolyPolyline( struct tagDC *dc, const POINT32* pt,
const DWORD* counts, DWORD polylines);
extern HGDIOBJ32 X11DRV_SelectObject( struct tagDC *dc, HGDIOBJ32 handle );

4
objects/clipping.c
View File

@ -427,7 +427,7 @@ BOOL32 WINAPI PtVisible32( HDC32 hdc, INT32 x, INT32 y )
/***********************************************************************
* RectVisible16 (GDI.104)
*/
BOOL16 WINAPI RectVisible16( HDC16 hdc, LPRECT16 rect )
BOOL16 WINAPI RectVisible16( HDC16 hdc, const RECT16* rect )
{
RECT16 tmpRect;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
@ -446,7 +446,7 @@ BOOL16 WINAPI RectVisible16( HDC16 hdc, LPRECT16 rect )
/***********************************************************************
* RectVisible32 (GDI32.282)
*/
BOOL32 WINAPI RectVisible32( HDC32 hdc, LPRECT32 rect )
BOOL32 WINAPI RectVisible32( HDC32 hdc, const RECT32* rect )
{
RECT16 rect16;
CONV_RECT32TO16( rect, &rect16 );

2
objects/dc.c
View File

@ -1535,7 +1535,7 @@ UINT16 WINAPI GetBoundsRect16(HDC16 hdc, LPRECT16 rect, UINT16 flags)
/***********************************************************************
* SetBoundsRect16 (GDI.193)
*/
UINT16 WINAPI SetBoundsRect16(HDC16 hdc, LPRECT16 rect, UINT16 flags)
UINT16 WINAPI SetBoundsRect16(HDC16 hdc, const RECT16* rect, UINT16 flags)
{
FIXME(dc, "(): stub\n");
return DCB_DISABLE; /* bounding rectangle always empty */

32
objects/dcvalues.c
View File

@ -33,22 +33,26 @@ func_type WINAPI func_name( HDC16 hdc ) \
return MAKELONG( dc->ret_x, dc->ret_y ); \
}
#define DC_GET_VAL_EX( func_name, ret_x, ret_y ) \
BOOL16 WINAPI func_name##16( HDC16 hdc, LPPOINT16 pt ) \
/* DC_GET_VAL_EX is used to define functions returning a POINT or a SIZE. It is
* important that the function has the right signature, for the implementation
* we can do whatever we want.
*/
#define DC_GET_VAL_EX( func_name, ret_x, ret_y, type ) \
BOOL16 WINAPI func_name##16( HDC16 hdc, LP##type##16 pt ) \
{ \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if (!dc) return FALSE; \
pt->x = dc->ret_x; \
pt->y = dc->ret_y; \
((LPPOINT16)pt)->x = dc->ret_x; \
((LPPOINT16)pt)->y = dc->ret_y; \
return TRUE; \
} \
\
BOOL32 WINAPI func_name##32( HDC32 hdc, LPPOINT32 pt ) \
BOOL32 WINAPI func_name##32( HDC32 hdc, LP##type##32 pt ) \
{ \
DC * dc = (DC *) GDI_GetObjPtr( (HDC16)hdc, DC_MAGIC ); \
if (!dc) return FALSE; \
pt->x = dc->ret_x; \
pt->y = dc->ret_y; \
((LPPOINT32)pt)->x = dc->ret_x; \
((LPPOINT32)pt)->y = dc->ret_y; \
return TRUE; \
}
@ -134,10 +138,10 @@ DC_GET_X_Y( DWORD, GetBrushOrg, w.brushOrgX, w.brushOrgY ) /* GDI.149 */
DC_GET_VAL_16( UINT16, GetTextAlign16, w.textAlign ) /* GDI.345 */
DC_GET_VAL_32( UINT32, GetTextAlign32, w.textAlign ) /* GDI32.224 */
DC_GET_VAL_16( HFONT16, GetCurLogFont, w.hFont ) /* GDI.411 */
DC_GET_VAL_EX( GetBrushOrgEx, w.brushOrgX, w.brushOrgY )/* GDI.469 GDI32.148 */
DC_GET_VAL_EX( GetCurrentPositionEx, w.CursPosX, /* GDI.470 GDI32.167 */
w.CursPosY )
DC_GET_VAL_EX( GetViewportExtEx, vportExtX, vportExtY ) /* GDI.472 GDI32.239 */
DC_GET_VAL_EX( GetViewportOrgEx, vportOrgX, vportOrgY ) /* GDI.473 GDI32.240 */
DC_GET_VAL_EX( GetWindowExtEx, wndExtX, wndExtY ) /* GDI.474 GDI32.242 */
DC_GET_VAL_EX( GetWindowOrgEx, wndOrgX, wndOrgY ) /* GDI.475 GDI32.243 */
DC_GET_VAL_EX( GetBrushOrgEx, w.brushOrgX, w.brushOrgY, POINT ) /* GDI.469 GDI32.148 */
DC_GET_VAL_EX( GetCurrentPositionEx, w.CursPosX, w.CursPosY, /* GDI.470 GDI32.167 */
POINT )
DC_GET_VAL_EX( GetViewportExtEx, vportExtX, vportExtY, SIZE ) /* GDI.472 GDI32.239 */
DC_GET_VAL_EX( GetViewportOrgEx, vportOrgX, vportOrgY, POINT ) /* GDI.473 GDI32.240 */
DC_GET_VAL_EX( GetWindowExtEx, wndExtX, wndExtY, SIZE ) /* GDI.474 GDI32.242 */
DC_GET_VAL_EX( GetWindowOrgEx, wndOrgX, wndOrgY, POINT ) /* GDI.475 GDI32.243 */

4
objects/palette.c
View File

@ -297,7 +297,7 @@ BOOL32 WINAPI ResizePalette32(
* AnimatePalette16 (GDI.367)
*/
void WINAPI AnimatePalette16( HPALETTE16 hPal, UINT16 StartIndex,
UINT16 NumEntries, LPPALETTEENTRY PaletteColors)
UINT16 NumEntries, const PALETTEENTRY* PaletteColors)
{
AnimatePalette32( hPal, StartIndex, NumEntries, PaletteColors );
}
@ -317,7 +317,7 @@ BOOL32 WINAPI AnimatePalette32(
HPALETTE32 hPal, /* [in] Handle to logical palette */
UINT32 StartIndex, /* [in] First entry in palette */
UINT32 NumEntries, /* [in] Count of entries in palette */
LPPALETTEENTRY PaletteColors) /* [in] Pointer to first replacement */
const PALETTEENTRY* PaletteColors) /* [in] Pointer to first replacement */
{
TRACE(palette, "%04x (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);

2
objects/region.c
View File

@ -560,7 +560,7 @@ DWORD WINAPI GetRegionData(HRGN32 hrgn, DWORD count, LPRGNDATA rgndata)
* ExtCreateRegion (GDI32.94)
*
*/
HRGN32 WINAPI ExtCreateRegion( XFORM *lpXform, DWORD dwCount, RGNDATA *rgndata)
HRGN32 WINAPI ExtCreateRegion( const XFORM* lpXform, DWORD dwCount, const RGNDATA* rgndata)
{
HRGN32 hrgn = CreateRectRgn32(0, 0, 0, 0);
RGNOBJ *obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );