1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #ifndef _REFLCNST_HXX_ 25 #define _REFLCNST_HXX_ 26 27 #include <registry/refltype.hxx> 28 #include <sal/macros.h> 29 30 #include <string.h> 31 32 #define REGTYPE_IEEE_NATIVE 1 33 34 extern const sal_uInt32 magic; 35 extern const sal_uInt16 minorVersion; 36 extern const sal_uInt16 majorVersion; 37 38 #define OFFSET_MAGIC 0 39 #define OFFSET_SIZE (OFFSET_MAGIC + sizeof(magic)) 40 #define OFFSET_MINOR_VERSION (OFFSET_SIZE + sizeof(sal_uInt32)) 41 #define OFFSET_MAJOR_VERSION (OFFSET_MINOR_VERSION + sizeof(minorVersion)) 42 #define OFFSET_N_ENTRIES (OFFSET_MAJOR_VERSION + sizeof(sal_uInt16)) 43 #define OFFSET_TYPE_SOURCE (OFFSET_N_ENTRIES + sizeof(sal_uInt16)) 44 #define OFFSET_TYPE_CLASS (OFFSET_TYPE_SOURCE + sizeof(sal_uInt16)) 45 #define OFFSET_THIS_TYPE (OFFSET_TYPE_CLASS + sizeof(sal_uInt16)) 46 #define OFFSET_UIK (OFFSET_THIS_TYPE + sizeof(sal_uInt16)) 47 #define OFFSET_DOKU (OFFSET_UIK + sizeof(sal_uInt16)) 48 #define OFFSET_FILENAME (OFFSET_DOKU + sizeof(sal_uInt16)) 49 50 #define OFFSET_N_SUPERTYPES (OFFSET_FILENAME + sizeof(sal_uInt16)) 51 #define OFFSET_SUPERTYPES (OFFSET_N_SUPERTYPES + sizeof(sal_uInt16)) 52 53 #define OFFSET_CP_SIZE (OFFSET_SUPERTYPES + sizeof(sal_uInt16)) 54 #define OFFSET_CP (OFFSET_CP_SIZE + sizeof(sal_uInt16)) 55 56 #define CP_OFFSET_ENTRY_SIZE 0 57 #define CP_OFFSET_ENTRY_TAG (CP_OFFSET_ENTRY_SIZE + sizeof(sal_uInt32)) 58 #define CP_OFFSET_ENTRY_DATA (CP_OFFSET_ENTRY_TAG + sizeof(sal_uInt16)) 59 #define CP_OFFSET_ENTRY_UIK1 CP_OFFSET_ENTRY_DATA 60 #define CP_OFFSET_ENTRY_UIK2 (CP_OFFSET_ENTRY_UIK1 + sizeof(sal_uInt32)) 61 #define CP_OFFSET_ENTRY_UIK3 (CP_OFFSET_ENTRY_UIK2 + sizeof(sal_uInt16)) 62 #define CP_OFFSET_ENTRY_UIK4 (CP_OFFSET_ENTRY_UIK3 + sizeof(sal_uInt16)) 63 #define CP_OFFSET_ENTRY_UIK5 (CP_OFFSET_ENTRY_UIK4 + sizeof(sal_uInt32)) 64 65 #define FIELD_OFFSET_ACCESS 0 66 #define FIELD_OFFSET_NAME (FIELD_OFFSET_ACCESS + sizeof(sal_uInt16)) 67 #define FIELD_OFFSET_TYPE (FIELD_OFFSET_NAME + sizeof(sal_uInt16)) 68 #define FIELD_OFFSET_VALUE (FIELD_OFFSET_TYPE + sizeof(sal_uInt16)) 69 #define FIELD_OFFSET_DOKU (FIELD_OFFSET_VALUE + sizeof(sal_uInt16)) 70 #define FIELD_OFFSET_FILENAME (FIELD_OFFSET_DOKU + sizeof(sal_uInt16)) 71 //#define FIELD_ENTRY_SIZE (FIELD_OFFSET_FILENAME + sizeof(sal_uInt16)) 72 73 #define PARAM_OFFSET_TYPE 0 74 #define PARAM_OFFSET_MODE (PARAM_OFFSET_TYPE + sizeof(sal_uInt16)) 75 #define PARAM_OFFSET_NAME (PARAM_OFFSET_MODE + sizeof(sal_uInt16)) 76 //#define PARAM_ENTRY_SIZE (PARAM_OFFSET_NAME + sizeof(sal_uInt16)) 77 78 #define METHOD_OFFSET_SIZE 0 79 #define METHOD_OFFSET_MODE (METHOD_OFFSET_SIZE + sizeof(sal_uInt16)) 80 #define METHOD_OFFSET_NAME (METHOD_OFFSET_MODE + sizeof(sal_uInt16)) 81 #define METHOD_OFFSET_RETURN (METHOD_OFFSET_NAME + sizeof(sal_uInt16)) 82 #define METHOD_OFFSET_DOKU (METHOD_OFFSET_RETURN + sizeof(sal_uInt16)) 83 #define METHOD_OFFSET_PARAM_COUNT (METHOD_OFFSET_DOKU + sizeof(sal_uInt16)) 84 //#define METHOD_OFFSET_PARAM(i) (METHOD_OFFSET_PARAM_COUNT + sizeof(sal_uInt16) + (i * PARAM_ENTRY_SIZE)) 85 86 #define REFERENCE_OFFSET_TYPE 0 87 #define REFERENCE_OFFSET_NAME (REFERENCE_OFFSET_TYPE + sizeof(sal_uInt16)) 88 #define REFERENCE_OFFSET_DOKU (REFERENCE_OFFSET_NAME + sizeof(sal_uInt16)) 89 #define REFERENCE_OFFSET_ACCESS (REFERENCE_OFFSET_DOKU + sizeof(sal_uInt16)) 90 //#define REFERENCE_ENTRY_SIZE (REFERENCE_OFFSET_ACCESS + sizeof(sal_uInt16)) 91 92 enum CPInfoTag 93 { 94 CP_TAG_INVALID = RT_TYPE_NONE, 95 CP_TAG_CONST_BOOL = RT_TYPE_BOOL, 96 CP_TAG_CONST_BYTE = RT_TYPE_BYTE, 97 CP_TAG_CONST_INT16 = RT_TYPE_INT16, 98 CP_TAG_CONST_UINT16 = RT_TYPE_UINT16, 99 CP_TAG_CONST_INT32 = RT_TYPE_INT32, 100 CP_TAG_CONST_UINT32 = RT_TYPE_UINT32, 101 CP_TAG_CONST_INT64 = RT_TYPE_INT64, 102 CP_TAG_CONST_UINT64 = RT_TYPE_UINT64, 103 CP_TAG_CONST_FLOAT = RT_TYPE_FLOAT, 104 CP_TAG_CONST_DOUBLE = RT_TYPE_DOUBLE, 105 CP_TAG_CONST_STRING = RT_TYPE_STRING, 106 CP_TAG_UTF8_NAME, 107 CP_TAG_UIK 108 }; 109 110 inline sal_uInt32 writeBYTE(sal_uInt8* buffer, sal_uInt8 v) 111 { 112 buffer[0] = v; 113 114 return sizeof(sal_uInt8); 115 } 116 117 inline sal_uInt16 readBYTE(const sal_uInt8* buffer, sal_uInt8& v) 118 { 119 v = buffer[0]; 120 121 return sizeof(sal_uInt8); 122 } 123 124 inline sal_uInt32 writeINT16(sal_uInt8* buffer, sal_Int16 v) 125 { 126 buffer[0] = (sal_uInt8)((v >> 8) & 0xFF); 127 buffer[1] = (sal_uInt8)((v >> 0) & 0xFF); 128 129 return sizeof(sal_Int16); 130 } 131 132 inline sal_uInt32 readINT16(const sal_uInt8* buffer, sal_Int16& v) 133 { 134 v = ((buffer[0] << 8) | (buffer[1] << 0)); 135 136 return sizeof(sal_Int16); 137 } 138 139 inline sal_uInt32 writeUINT16(sal_uInt8* buffer, sal_uInt16 v) 140 { 141 buffer[0] = (sal_uInt8)((v >> 8) & 0xFF); 142 buffer[1] = (sal_uInt8)((v >> 0) & 0xFF); 143 144 return sizeof(sal_uInt16); 145 } 146 147 inline sal_uInt32 readUINT16(const sal_uInt8* buffer, sal_uInt16& v) 148 { 149 v = ((buffer[0] << 8) | (buffer[1] << 0)); 150 151 return sizeof(sal_uInt16); 152 } 153 154 inline sal_uInt32 writeINT32(sal_uInt8* buffer, sal_Int32 v) 155 { 156 buffer[0] = (sal_uInt8)((v >> 24) & 0xFF); 157 buffer[1] = (sal_uInt8)((v >> 16) & 0xFF); 158 buffer[2] = (sal_uInt8)((v >> 8) & 0xFF); 159 buffer[3] = (sal_uInt8)((v >> 0) & 0xFF); 160 161 return sizeof(sal_Int32); 162 } 163 164 inline sal_uInt32 readINT32(const sal_uInt8* buffer, sal_Int32& v) 165 { 166 v = ( 167 (buffer[0] << 24) | 168 (buffer[1] << 16) | 169 (buffer[2] << 8) | 170 (buffer[3] << 0) 171 ); 172 173 return sizeof(sal_Int32); 174 } 175 176 inline sal_uInt32 writeUINT32(sal_uInt8* buffer, sal_uInt32 v) 177 { 178 buffer[0] = (sal_uInt8)((v >> 24) & 0xFF); 179 buffer[1] = (sal_uInt8)((v >> 16) & 0xFF); 180 buffer[2] = (sal_uInt8)((v >> 8) & 0xFF); 181 buffer[3] = (sal_uInt8)((v >> 0) & 0xFF); 182 183 return sizeof(sal_uInt32); 184 } 185 186 inline sal_uInt32 readUINT32(const sal_uInt8* buffer, sal_uInt32& v) 187 { 188 v = ( 189 (buffer[0] << 24) | 190 (buffer[1] << 16) | 191 (buffer[2] << 8) | 192 (buffer[3] << 0) 193 ); 194 195 return sizeof(sal_uInt32); 196 } 197 198 inline sal_uInt32 writeINT64(sal_uInt8* buffer, sal_Int64 v) 199 { 200 buffer[0] = (sal_uInt8)((v >> 56) & 0xFF); 201 buffer[1] = (sal_uInt8)((v >> 48) & 0xFF); 202 buffer[2] = (sal_uInt8)((v >> 40) & 0xFF); 203 buffer[3] = (sal_uInt8)((v >> 32) & 0xFF); 204 buffer[4] = (sal_uInt8)((v >> 24) & 0xFF); 205 buffer[5] = (sal_uInt8)((v >> 16) & 0xFF); 206 buffer[6] = (sal_uInt8)((v >> 8) & 0xFF); 207 buffer[7] = (sal_uInt8)((v >> 0) & 0xFF); 208 209 return sizeof(sal_Int64); 210 } 211 212 inline sal_uInt32 readINT64(const sal_uInt8* buffer, sal_Int64& v) 213 { 214 v = ( 215 ((sal_Int64)buffer[0] << 56) | 216 ((sal_Int64)buffer[1] << 48) | 217 ((sal_Int64)buffer[2] << 40) | 218 ((sal_Int64)buffer[3] << 32) | 219 ((sal_Int64)buffer[4] << 24) | 220 ((sal_Int64)buffer[5] << 16) | 221 ((sal_Int64)buffer[6] << 8) | 222 ((sal_Int64)buffer[7] << 0) 223 ); 224 225 return sizeof(sal_Int64); 226 } 227 228 inline sal_uInt32 writeUINT64(sal_uInt8* buffer, sal_uInt64 v) 229 { 230 buffer[0] = (sal_uInt8)((v >> 56) & 0xFF); 231 buffer[1] = (sal_uInt8)((v >> 48) & 0xFF); 232 buffer[2] = (sal_uInt8)((v >> 40) & 0xFF); 233 buffer[3] = (sal_uInt8)((v >> 32) & 0xFF); 234 buffer[4] = (sal_uInt8)((v >> 24) & 0xFF); 235 buffer[5] = (sal_uInt8)((v >> 16) & 0xFF); 236 buffer[6] = (sal_uInt8)((v >> 8) & 0xFF); 237 buffer[7] = (sal_uInt8)((v >> 0) & 0xFF); 238 239 return sizeof(sal_uInt64); 240 } 241 242 inline sal_uInt32 readUINT64(const sal_uInt8* buffer, sal_uInt64& v) 243 { 244 v = ( 245 ((sal_uInt64)buffer[0] << 56) | 246 ((sal_uInt64)buffer[1] << 48) | 247 ((sal_uInt64)buffer[2] << 40) | 248 ((sal_uInt64)buffer[3] << 32) | 249 ((sal_uInt64)buffer[4] << 24) | 250 ((sal_uInt64)buffer[5] << 16) | 251 ((sal_uInt64)buffer[6] << 8) | 252 ((sal_uInt64)buffer[7] << 0) 253 ); 254 255 return sizeof(sal_uInt64); 256 } 257 258 inline sal_uInt32 writeUtf8(sal_uInt8* buffer, const sal_Char* v) 259 { 260 sal_uInt32 size = strlen(v) + 1; 261 262 memcpy(buffer, v, size); 263 264 return (size); 265 } 266 267 inline sal_uInt32 readUtf8(const sal_uInt8* buffer, sal_Char* v, sal_uInt32 maxSize) 268 { 269 sal_uInt32 size = SAL_MIN(strlen((const sal_Char*) buffer) + 1, maxSize); 270 271 memcpy(v, buffer, size); 272 273 if (size == maxSize) v[size - 1] = '\0'; 274 275 return (size); 276 } 277 278 279 sal_uInt32 writeFloat(sal_uInt8* buffer, float v); 280 sal_uInt32 writeDouble(sal_uInt8* buffer, double v); 281 sal_uInt32 writeString(sal_uInt8* buffer, const sal_Unicode* v); 282 sal_uInt32 readString(const sal_uInt8* buffer, sal_Unicode* v, sal_uInt32 maxSize); 283 284 sal_uInt32 UINT16StringLen(const sal_uInt8* wstring); 285 286 #endif 287 288 289 290 291 292