1 | /* |
2 | ** 2005 May 23 |
3 | ** |
4 | ** The author disclaims copyright to this source code. In place of |
5 | ** a legal notice, here is a blessing: |
6 | ** |
7 | ** May you do good and not evil. |
8 | ** May you find forgiveness for yourself and forgive others. |
9 | ** May you share freely, never taking more than you give. |
10 | ** |
11 | ************************************************************************* |
12 | ** |
13 | ** This file contains functions used to access the internal hash tables |
14 | ** of user defined functions and collation sequences. |
15 | */ |
16 | |
17 | #include "sqliteInt.h" |
18 | |
19 | /* |
20 | ** Invoke the 'collation needed' callback to request a collation sequence |
21 | ** in the encoding enc of name zName, length nName. |
22 | */ |
23 | static void callCollNeeded(sqlite3 *db, int enc, const char *zName){ |
24 | assert( !db->xCollNeeded || !db->xCollNeeded16 ); |
25 | if( db->xCollNeeded ){ |
26 | char *zExternal = sqlite3DbStrDup(db, zName); |
27 | if( !zExternal ) return; |
28 | db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal); |
29 | sqlite3DbFree(db, zExternal); |
30 | } |
31 | #ifndef SQLITE_OMIT_UTF16 |
32 | if( db->xCollNeeded16 ){ |
33 | char const *zExternal; |
34 | sqlite3_value *pTmp = sqlite3ValueNew(db); |
35 | sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC); |
36 | zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE); |
37 | if( zExternal ){ |
38 | db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal); |
39 | } |
40 | sqlite3ValueFree(pTmp); |
41 | } |
42 | #endif |
43 | } |
44 | |
45 | /* |
46 | ** This routine is called if the collation factory fails to deliver a |
47 | ** collation function in the best encoding but there may be other versions |
48 | ** of this collation function (for other text encodings) available. Use one |
49 | ** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if |
50 | ** possible. |
51 | */ |
52 | static int synthCollSeq(sqlite3 *db, CollSeq *pColl){ |
53 | CollSeq *pColl2; |
54 | char *z = pColl->zName; |
55 | int i; |
56 | static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 }; |
57 | for(i=0; i<3; i++){ |
58 | pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0); |
59 | if( pColl2->xCmp!=0 ){ |
60 | memcpy(pColl, pColl2, sizeof(CollSeq)); |
61 | pColl->xDel = 0; /* Do not copy the destructor */ |
62 | return SQLITE_OK; |
63 | } |
64 | } |
65 | return SQLITE_ERROR; |
66 | } |
67 | |
68 | /* |
69 | ** This routine is called on a collation sequence before it is used to |
70 | ** check that it is defined. An undefined collation sequence exists when |
71 | ** a database is loaded that contains references to collation sequences |
72 | ** that have not been defined by sqlite3_create_collation() etc. |
73 | ** |
74 | ** If required, this routine calls the 'collation needed' callback to |
75 | ** request a definition of the collating sequence. If this doesn't work, |
76 | ** an equivalent collating sequence that uses a text encoding different |
77 | ** from the main database is substituted, if one is available. |
78 | */ |
79 | int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){ |
80 | if( pColl && pColl->xCmp==0 ){ |
81 | const char *zName = pColl->zName; |
82 | sqlite3 *db = pParse->db; |
83 | CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName); |
84 | if( !p ){ |
85 | return SQLITE_ERROR; |
86 | } |
87 | assert( p==pColl ); |
88 | } |
89 | return SQLITE_OK; |
90 | } |
91 | |
92 | |
93 | |
94 | /* |
95 | ** Locate and return an entry from the db.aCollSeq hash table. If the entry |
96 | ** specified by zName and nName is not found and parameter 'create' is |
97 | ** true, then create a new entry. Otherwise return NULL. |
98 | ** |
99 | ** Each pointer stored in the sqlite3.aCollSeq hash table contains an |
100 | ** array of three CollSeq structures. The first is the collation sequence |
101 | ** preferred for UTF-8, the second UTF-16le, and the third UTF-16be. |
102 | ** |
103 | ** Stored immediately after the three collation sequences is a copy of |
104 | ** the collation sequence name. A pointer to this string is stored in |
105 | ** each collation sequence structure. |
106 | */ |
107 | static CollSeq *findCollSeqEntry( |
108 | sqlite3 *db, /* Database connection */ |
109 | const char *zName, /* Name of the collating sequence */ |
110 | int create /* Create a new entry if true */ |
111 | ){ |
112 | CollSeq *pColl; |
113 | pColl = sqlite3HashFind(&db->aCollSeq, zName); |
114 | |
115 | if( 0==pColl && create ){ |
116 | int nName = sqlite3Strlen30(zName) + 1; |
117 | pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName); |
118 | if( pColl ){ |
119 | CollSeq *pDel = 0; |
120 | pColl[0].zName = (char*)&pColl[3]; |
121 | pColl[0].enc = SQLITE_UTF8; |
122 | pColl[1].zName = (char*)&pColl[3]; |
123 | pColl[1].enc = SQLITE_UTF16LE; |
124 | pColl[2].zName = (char*)&pColl[3]; |
125 | pColl[2].enc = SQLITE_UTF16BE; |
126 | memcpy(pColl[0].zName, zName, nName); |
127 | pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl); |
128 | |
129 | /* If a malloc() failure occurred in sqlite3HashInsert(), it will |
130 | ** return the pColl pointer to be deleted (because it wasn't added |
131 | ** to the hash table). |
132 | */ |
133 | assert( pDel==0 || pDel==pColl ); |
134 | if( pDel!=0 ){ |
135 | sqlite3OomFault(db); |
136 | sqlite3DbFree(db, pDel); |
137 | pColl = 0; |
138 | } |
139 | } |
140 | } |
141 | return pColl; |
142 | } |
143 | |
144 | /* |
145 | ** Parameter zName points to a UTF-8 encoded string nName bytes long. |
146 | ** Return the CollSeq* pointer for the collation sequence named zName |
147 | ** for the encoding 'enc' from the database 'db'. |
148 | ** |
149 | ** If the entry specified is not found and 'create' is true, then create a |
150 | ** new entry. Otherwise return NULL. |
151 | ** |
152 | ** A separate function sqlite3LocateCollSeq() is a wrapper around |
153 | ** this routine. sqlite3LocateCollSeq() invokes the collation factory |
154 | ** if necessary and generates an error message if the collating sequence |
155 | ** cannot be found. |
156 | ** |
157 | ** See also: sqlite3LocateCollSeq(), sqlite3GetCollSeq() |
158 | */ |
159 | CollSeq *sqlite3FindCollSeq( |
160 | sqlite3 *db, /* Database connection to search */ |
161 | u8 enc, /* Desired text encoding */ |
162 | const char *zName, /* Name of the collating sequence. Might be NULL */ |
163 | int create /* True to create CollSeq if doesn't already exist */ |
164 | ){ |
165 | CollSeq *pColl; |
166 | assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); |
167 | assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE ); |
168 | if( zName ){ |
169 | pColl = findCollSeqEntry(db, zName, create); |
170 | if( pColl ) pColl += enc-1; |
171 | }else{ |
172 | pColl = db->pDfltColl; |
173 | } |
174 | return pColl; |
175 | } |
176 | |
177 | /* |
178 | ** Change the text encoding for a database connection. This means that |
179 | ** the pDfltColl must change as well. |
180 | */ |
181 | void sqlite3SetTextEncoding(sqlite3 *db, u8 enc){ |
182 | assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); |
183 | db->enc = enc; |
184 | /* EVIDENCE-OF: R-08308-17224 The default collating function for all |
185 | ** strings is BINARY. |
186 | */ |
187 | db->pDfltColl = sqlite3FindCollSeq(db, enc, sqlite3StrBINARY, 0); |
188 | } |
189 | |
190 | /* |
191 | ** This function is responsible for invoking the collation factory callback |
192 | ** or substituting a collation sequence of a different encoding when the |
193 | ** requested collation sequence is not available in the desired encoding. |
194 | ** |
195 | ** If it is not NULL, then pColl must point to the database native encoding |
196 | ** collation sequence with name zName, length nName. |
197 | ** |
198 | ** The return value is either the collation sequence to be used in database |
199 | ** db for collation type name zName, length nName, or NULL, if no collation |
200 | ** sequence can be found. If no collation is found, leave an error message. |
201 | ** |
202 | ** See also: sqlite3LocateCollSeq(), sqlite3FindCollSeq() |
203 | */ |
204 | CollSeq *sqlite3GetCollSeq( |
205 | Parse *pParse, /* Parsing context */ |
206 | u8 enc, /* The desired encoding for the collating sequence */ |
207 | CollSeq *pColl, /* Collating sequence with native encoding, or NULL */ |
208 | const char *zName /* Collating sequence name */ |
209 | ){ |
210 | CollSeq *p; |
211 | sqlite3 *db = pParse->db; |
212 | |
213 | p = pColl; |
214 | if( !p ){ |
215 | p = sqlite3FindCollSeq(db, enc, zName, 0); |
216 | } |
217 | if( !p || !p->xCmp ){ |
218 | /* No collation sequence of this type for this encoding is registered. |
219 | ** Call the collation factory to see if it can supply us with one. |
220 | */ |
221 | callCollNeeded(db, enc, zName); |
222 | p = sqlite3FindCollSeq(db, enc, zName, 0); |
223 | } |
224 | if( p && !p->xCmp && synthCollSeq(db, p) ){ |
225 | p = 0; |
226 | } |
227 | assert( !p || p->xCmp ); |
228 | if( p==0 ){ |
229 | sqlite3ErrorMsg(pParse, "no such collation sequence: %s" , zName); |
230 | pParse->rc = SQLITE_ERROR_MISSING_COLLSEQ; |
231 | } |
232 | return p; |
233 | } |
234 | |
235 | /* |
236 | ** This function returns the collation sequence for database native text |
237 | ** encoding identified by the string zName. |
238 | ** |
239 | ** If the requested collation sequence is not available, or not available |
240 | ** in the database native encoding, the collation factory is invoked to |
241 | ** request it. If the collation factory does not supply such a sequence, |
242 | ** and the sequence is available in another text encoding, then that is |
243 | ** returned instead. |
244 | ** |
245 | ** If no versions of the requested collations sequence are available, or |
246 | ** another error occurs, NULL is returned and an error message written into |
247 | ** pParse. |
248 | ** |
249 | ** This routine is a wrapper around sqlite3FindCollSeq(). This routine |
250 | ** invokes the collation factory if the named collation cannot be found |
251 | ** and generates an error message. |
252 | ** |
253 | ** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq() |
254 | */ |
255 | CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){ |
256 | sqlite3 *db = pParse->db; |
257 | u8 enc = ENC(db); |
258 | u8 initbusy = db->init.busy; |
259 | CollSeq *pColl; |
260 | |
261 | pColl = sqlite3FindCollSeq(db, enc, zName, initbusy); |
262 | if( !initbusy && (!pColl || !pColl->xCmp) ){ |
263 | pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName); |
264 | } |
265 | |
266 | return pColl; |
267 | } |
268 | |
269 | /* During the search for the best function definition, this procedure |
270 | ** is called to test how well the function passed as the first argument |
271 | ** matches the request for a function with nArg arguments in a system |
272 | ** that uses encoding enc. The value returned indicates how well the |
273 | ** request is matched. A higher value indicates a better match. |
274 | ** |
275 | ** If nArg is -1 that means to only return a match (non-zero) if p->nArg |
276 | ** is also -1. In other words, we are searching for a function that |
277 | ** takes a variable number of arguments. |
278 | ** |
279 | ** If nArg is -2 that means that we are searching for any function |
280 | ** regardless of the number of arguments it uses, so return a positive |
281 | ** match score for any |
282 | ** |
283 | ** The returned value is always between 0 and 6, as follows: |
284 | ** |
285 | ** 0: Not a match. |
286 | ** 1: UTF8/16 conversion required and function takes any number of arguments. |
287 | ** 2: UTF16 byte order change required and function takes any number of args. |
288 | ** 3: encoding matches and function takes any number of arguments |
289 | ** 4: UTF8/16 conversion required - argument count matches exactly |
290 | ** 5: UTF16 byte order conversion required - argument count matches exactly |
291 | ** 6: Perfect match: encoding and argument count match exactly. |
292 | ** |
293 | ** If nArg==(-2) then any function with a non-null xSFunc is |
294 | ** a perfect match and any function with xSFunc NULL is |
295 | ** a non-match. |
296 | */ |
297 | #define FUNC_PERFECT_MATCH 6 /* The score for a perfect match */ |
298 | static int matchQuality( |
299 | FuncDef *p, /* The function we are evaluating for match quality */ |
300 | int nArg, /* Desired number of arguments. (-1)==any */ |
301 | u8 enc /* Desired text encoding */ |
302 | ){ |
303 | int match; |
304 | assert( p->nArg>=-1 ); |
305 | |
306 | /* Wrong number of arguments means "no match" */ |
307 | if( p->nArg!=nArg ){ |
308 | if( nArg==(-2) ) return (p->xSFunc==0) ? 0 : FUNC_PERFECT_MATCH; |
309 | if( p->nArg>=0 ) return 0; |
310 | } |
311 | |
312 | /* Give a better score to a function with a specific number of arguments |
313 | ** than to function that accepts any number of arguments. */ |
314 | if( p->nArg==nArg ){ |
315 | match = 4; |
316 | }else{ |
317 | match = 1; |
318 | } |
319 | |
320 | /* Bonus points if the text encoding matches */ |
321 | if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){ |
322 | match += 2; /* Exact encoding match */ |
323 | }else if( (enc & p->funcFlags & 2)!=0 ){ |
324 | match += 1; /* Both are UTF16, but with different byte orders */ |
325 | } |
326 | |
327 | return match; |
328 | } |
329 | |
330 | /* |
331 | ** Search a FuncDefHash for a function with the given name. Return |
332 | ** a pointer to the matching FuncDef if found, or 0 if there is no match. |
333 | */ |
334 | FuncDef *sqlite3FunctionSearch( |
335 | int h, /* Hash of the name */ |
336 | const char *zFunc /* Name of function */ |
337 | ){ |
338 | FuncDef *p; |
339 | for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){ |
340 | assert( p->funcFlags & SQLITE_FUNC_BUILTIN ); |
341 | if( sqlite3StrICmp(p->zName, zFunc)==0 ){ |
342 | return p; |
343 | } |
344 | } |
345 | return 0; |
346 | } |
347 | |
348 | /* |
349 | ** Insert a new FuncDef into a FuncDefHash hash table. |
350 | */ |
351 | void sqlite3InsertBuiltinFuncs( |
352 | FuncDef *aDef, /* List of global functions to be inserted */ |
353 | int nDef /* Length of the apDef[] list */ |
354 | ){ |
355 | int i; |
356 | for(i=0; i<nDef; i++){ |
357 | FuncDef *pOther; |
358 | const char *zName = aDef[i].zName; |
359 | int nName = sqlite3Strlen30(zName); |
360 | int h = SQLITE_FUNC_HASH(zName[0], nName); |
361 | assert( aDef[i].funcFlags & SQLITE_FUNC_BUILTIN ); |
362 | pOther = sqlite3FunctionSearch(h, zName); |
363 | if( pOther ){ |
364 | assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] ); |
365 | aDef[i].pNext = pOther->pNext; |
366 | pOther->pNext = &aDef[i]; |
367 | }else{ |
368 | aDef[i].pNext = 0; |
369 | aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h]; |
370 | sqlite3BuiltinFunctions.a[h] = &aDef[i]; |
371 | } |
372 | } |
373 | } |
374 | |
375 | |
376 | |
377 | /* |
378 | ** Locate a user function given a name, a number of arguments and a flag |
379 | ** indicating whether the function prefers UTF-16 over UTF-8. Return a |
380 | ** pointer to the FuncDef structure that defines that function, or return |
381 | ** NULL if the function does not exist. |
382 | ** |
383 | ** If the createFlag argument is true, then a new (blank) FuncDef |
384 | ** structure is created and liked into the "db" structure if a |
385 | ** no matching function previously existed. |
386 | ** |
387 | ** If nArg is -2, then the first valid function found is returned. A |
388 | ** function is valid if xSFunc is non-zero. The nArg==(-2) |
389 | ** case is used to see if zName is a valid function name for some number |
390 | ** of arguments. If nArg is -2, then createFlag must be 0. |
391 | ** |
392 | ** If createFlag is false, then a function with the required name and |
393 | ** number of arguments may be returned even if the eTextRep flag does not |
394 | ** match that requested. |
395 | */ |
396 | FuncDef *sqlite3FindFunction( |
397 | sqlite3 *db, /* An open database */ |
398 | const char *zName, /* Name of the function. zero-terminated */ |
399 | int nArg, /* Number of arguments. -1 means any number */ |
400 | u8 enc, /* Preferred text encoding */ |
401 | u8 createFlag /* Create new entry if true and does not otherwise exist */ |
402 | ){ |
403 | FuncDef *p; /* Iterator variable */ |
404 | FuncDef *pBest = 0; /* Best match found so far */ |
405 | int bestScore = 0; /* Score of best match */ |
406 | int h; /* Hash value */ |
407 | int nName; /* Length of the name */ |
408 | |
409 | assert( nArg>=(-2) ); |
410 | assert( nArg>=(-1) || createFlag==0 ); |
411 | nName = sqlite3Strlen30(zName); |
412 | |
413 | /* First search for a match amongst the application-defined functions. |
414 | */ |
415 | p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName); |
416 | while( p ){ |
417 | int score = matchQuality(p, nArg, enc); |
418 | if( score>bestScore ){ |
419 | pBest = p; |
420 | bestScore = score; |
421 | } |
422 | p = p->pNext; |
423 | } |
424 | |
425 | /* If no match is found, search the built-in functions. |
426 | ** |
427 | ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in |
428 | ** functions even if a prior app-defined function was found. And give |
429 | ** priority to built-in functions. |
430 | ** |
431 | ** Except, if createFlag is true, that means that we are trying to |
432 | ** install a new function. Whatever FuncDef structure is returned it will |
433 | ** have fields overwritten with new information appropriate for the |
434 | ** new function. But the FuncDefs for built-in functions are read-only. |
435 | ** So we must not search for built-ins when creating a new function. |
436 | */ |
437 | if( !createFlag && (pBest==0 || (db->mDbFlags & DBFLAG_PreferBuiltin)!=0) ){ |
438 | bestScore = 0; |
439 | h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName); |
440 | p = sqlite3FunctionSearch(h, zName); |
441 | while( p ){ |
442 | int score = matchQuality(p, nArg, enc); |
443 | if( score>bestScore ){ |
444 | pBest = p; |
445 | bestScore = score; |
446 | } |
447 | p = p->pNext; |
448 | } |
449 | } |
450 | |
451 | /* If the createFlag parameter is true and the search did not reveal an |
452 | ** exact match for the name, number of arguments and encoding, then add a |
453 | ** new entry to the hash table and return it. |
454 | */ |
455 | if( createFlag && bestScore<FUNC_PERFECT_MATCH && |
456 | (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){ |
457 | FuncDef *pOther; |
458 | u8 *z; |
459 | pBest->zName = (const char*)&pBest[1]; |
460 | pBest->nArg = (u16)nArg; |
461 | pBest->funcFlags = enc; |
462 | memcpy((char*)&pBest[1], zName, nName+1); |
463 | for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z]; |
464 | pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest); |
465 | if( pOther==pBest ){ |
466 | sqlite3DbFree(db, pBest); |
467 | sqlite3OomFault(db); |
468 | return 0; |
469 | }else{ |
470 | pBest->pNext = pOther; |
471 | } |
472 | } |
473 | |
474 | if( pBest && (pBest->xSFunc || createFlag) ){ |
475 | return pBest; |
476 | } |
477 | return 0; |
478 | } |
479 | |
480 | /* |
481 | ** Free all resources held by the schema structure. The void* argument points |
482 | ** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the |
483 | ** pointer itself, it just cleans up subsidiary resources (i.e. the contents |
484 | ** of the schema hash tables). |
485 | ** |
486 | ** The Schema.cache_size variable is not cleared. |
487 | */ |
488 | void sqlite3SchemaClear(void *p){ |
489 | Hash temp1; |
490 | Hash temp2; |
491 | HashElem *pElem; |
492 | Schema *pSchema = (Schema *)p; |
493 | sqlite3 xdb; |
494 | |
495 | memset(&xdb, 0, sizeof(xdb)); |
496 | temp1 = pSchema->tblHash; |
497 | temp2 = pSchema->trigHash; |
498 | sqlite3HashInit(&pSchema->trigHash); |
499 | sqlite3HashClear(&pSchema->idxHash); |
500 | for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){ |
501 | sqlite3DeleteTrigger(&xdb, (Trigger*)sqliteHashData(pElem)); |
502 | } |
503 | sqlite3HashClear(&temp2); |
504 | sqlite3HashInit(&pSchema->tblHash); |
505 | for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){ |
506 | Table *pTab = sqliteHashData(pElem); |
507 | sqlite3DeleteTable(&xdb, pTab); |
508 | } |
509 | sqlite3HashClear(&temp1); |
510 | sqlite3HashClear(&pSchema->fkeyHash); |
511 | pSchema->pSeqTab = 0; |
512 | if( pSchema->schemaFlags & DB_SchemaLoaded ){ |
513 | pSchema->iGeneration++; |
514 | } |
515 | pSchema->schemaFlags &= ~(DB_SchemaLoaded|DB_ResetWanted); |
516 | } |
517 | |
518 | /* |
519 | ** Find and return the schema associated with a BTree. Create |
520 | ** a new one if necessary. |
521 | */ |
522 | Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){ |
523 | Schema * p; |
524 | if( pBt ){ |
525 | p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear); |
526 | }else{ |
527 | p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema)); |
528 | } |
529 | if( !p ){ |
530 | sqlite3OomFault(db); |
531 | }else if ( 0==p->file_format ){ |
532 | sqlite3HashInit(&p->tblHash); |
533 | sqlite3HashInit(&p->idxHash); |
534 | sqlite3HashInit(&p->trigHash); |
535 | sqlite3HashInit(&p->fkeyHash); |
536 | p->enc = SQLITE_UTF8; |
537 | } |
538 | return p; |
539 | } |
540 | |