source: trunk/pin/include/p2putil.ch@ 62

Last change on this file since 62 was 1, checked in by bart, 18 years ago

Initial checkin of PIN.EXE source code
this contains memory fixes for larger PPD files
File size: 19.2 KB
Line 
1// included into convert.c
2// utility functions
3
4/*
5** D74609
6*/
7/***************************************************************************
8 *
9 * FUNCTION NAME = roundImgAreaVals
10 *
11 * DESCRIPTION = Used for the *ImageableArea key. This function either
12 * rounds the floating point value to the nearest integer, or
13 * truncates the floating point value to the base integer.
14 * The new integer value is stored in the output buffer.
15 *
16 * INPUT = i - Offset to the input buffer where the floating point
17 * string is read.
18 * fIncFrac - Contains one of the following values:
19 * TRUNCATE_FLOAT - Truncate the floating point value to the
20 * base integer (i.e. 25.2 -> 25, 14.8 -> 14).
21 * ROUND_FLOAT - Rounds the floating point value to the next
22 * higher integer value, providing that there is a fractional
23 * value (i.e 25.1 -> 26, 79.8 -> 80, 15.0 -> 15, 4.0 -> 4).
24 * Any other value will yield unpredictable results.
25 * cMovePastChar - Character value that is passed on to
26 * MovePast to indicate what character to move past on the
27 * buffer. For this function's first call, the argument
28 * is usually '"' (quote), and most subsequent calls are ' '
29 * (space).
30 *
31 * OUTPUT = NONE.
32 *
33 * RETURN-NORMAL = Returns the latest offset (passed in from i above).
34 * RETURN-ERROR = NONE.
35 *
36 ************************************************************************* */
37VOID roundImgAreaVals(int *i, float fIncFrac, CHAR cMovePastChar )
38{
39 USHORT j;
40
41 *i += MovePast( pbPrBuffer + *i, cMovePastChar );
42
43 /*
44 ** @V2.187860
45 ** Since spaces are used as terminators in this function, a leading space
46 ** may cause the string offset to stop before skipping to the next value.
47 ** By removing all leading spaces, this ensures that the string offset moves
48 ** to the next value.
49 */
50 /*
51 ** @V3.0100963
52 ** Check for all valid spaces, not just for the whitespace. This is to
53 ** prevent a repeat performance in what was happening with MovePast().
54 */
55 while (isspace( *(pbPrBuffer + *i) ) )
56 {
57 (*i)++;
58 }
59
60 /*
61 ** For the imageable area, only the integer value is to be stored. By
62 ** adding a fraction (fIncFrac) to the whole number taken from the PPD, it
63 ** either increase the integer value by one, or keep the integer unchanged.
64 ** Then the fraction can be discarded (convert it to a USHORT).
65 */
66 j = (USHORT) (atof( pbPrBuffer + *i ) + fIncFrac);
67
68 memcpy((pbItemsBuffer + cbBuffout), (PCHAR) &j, sizeof( USHORT ) );
69 cbBuffout += sizeof( USHORT );
70}
71
72
73
74/***************************************************************************
75 *
76 * FUNCTION NAME = atoRound
77 *
78 * DESCRIPTION = rounds off a fractional number to nearest integer
79 *
80 * INPUT = pchBuffer - pointer to buffer containing number
81 *
82 * OUTPUT = NONE.
83 *
84 * RETURN-NORMAL = NONE.
85 * RETURN-ERROR = NONE.
86 *
87 ************************************************************************* */
88
89int atoRound( char *pchBuffer )
90{
91 int i;
92
93 i = atoi( pchBuffer );
94
95 while (*pchBuffer >= '0' && *pchBuffer <= '9')
96 {
97 pchBuffer++;
98 }
99
100 if (*pchBuffer == '.')
101 {
102 pchBuffer++;
103
104 if (*pchBuffer >= '5')
105 {
106 i++;
107 }
108 }
109 return( i );
110}
111
112/***************************************************************************
113 *
114 * FUNCTION NAME = RepWarning
115 *
116 * DESCRIPTION = prints the given message (pszMsg) with the given
117 * line fragment (pszLine), including the current
118 * input line number. If line fragment is NULL, then
119 * only the message is displayed.
120 *
121 * INPUT = err - error number
122 * pszLine - optional text
123 *
124 * OUTPUT = NONE.
125 *
126 * RETURN-NORMAL = NONE.
127 * RETURN-ERROR = NONE.
128 *
129 ************************************************************************* */
130
131VOID RepWarning( ErrType err, char *pszLine )
132{
133 printf( "%s", szErrmsgs[err] );
134
135 if (pszLine)
136 {
137 printf( " %s", pszLine );
138 }
139}
140
141/***************************************************************************
142 *
143 * FUNCTION NAME = RepError
144 *
145 * DESCRIPTION = Same as RepWarning, but terminates as well.
146 *
147 * INPUT = err - error number
148 * pszLine - optional text
149 *
150 * OUTPUT = NONE.
151 *
152 * RETURN-NORMAL = NONE.
153 * RETURN-ERROR = NONE.
154 *
155 ************************************************************************* */
156
157VOID RepError( ErrType err, char *pszLine )
158{
159 RepWarning( err, pszLine );
160 exit( 1 );
161}
162
163/***************************************************************************
164 *
165 * FUNCTION NAME = SkipNumber
166 *
167 * DESCRIPTION = This routine moves the input buffer pointer forward
168 * to skip the next number. Returns the number of bytes
169 * skipped.
170 *
171 * INPUT = pszLine - line to skip
172 * OUTPUT = NONE.
173 *
174 * RETURN-NORMAL = NONE.
175 * RETURN-ERROR = NONE.
176 *
177 ************************************************************************* */
178
179int SkipNumber( char *pszLine )
180{
181 int i;
182
183 i = SkipBlank( pszLine );
184
185 if (*(pszLine+i) == '+' || *(pszLine+i) == '-' || *(pszLine+i) == '.')
186 {
187 i++;
188 }
189
190 while (*(pszLine+i) >= '0' && *(pszLine+i) <= '9')
191 {
192 i++;
193 }
194
195 if (*(pszLine + i) == '.')
196 {
197 i++;
198
199 while (*(pszLine+i) >= '0' && *(pszLine+i) <= '9')
200 {
201 i++;
202 }
203 }
204 return( i );
205}
206
207/***************************************************************************
208 *
209 * FUNCTION NAME = SkipBlank
210 *
211 * DESCRIPTION = This routine moves the input buffer pointer forward
212 * to the next non-white character. Returns the
213 * number of bytes skipped.
214 *
215 * INPUT = pszLine - line to skip
216 *
217 * OUTPUT = NONE.
218 *
219 * RETURN-NORMAL = NONE.
220 * RETURN-ERROR = NONE.
221 *
222 ************************************************************************* */
223
224int SkipBlank( char *pszLine )
225{
226 int i;
227
228 i = 0;
229
230 while (*(pszLine+i) && (*(pszLine+i) == ' ' || *(pszLine+i) == '\t'))
231 {
232 i++;
233 }
234 return( i );
235}
236
237/***************************************************************************
238 *
239 * FUNCTION NAME = MovePast
240 *
241 * DESCRIPTION = This routine returns the offset to skip past the
242 * first occurrence of character chSkip.
243 *
244 * INPUT = pbBuffer - pointer to buffer containing text
245 * chSkip - character to skip
246 *
247 * OUTPUT = NONE.
248 *
249 * RETURN-NORMAL = NONE.
250 * RETURN-ERROR = NONE.
251 *
252 ************************************************************************* */
253
254int MovePast( char *pbBuffer, char chSkip )
255{
256 int i;
257
258 i = 0;
259
260 /*
261 ** @V2.1100963
262 ** Check for tab characters (0x09) as well as whitespaces. Theoretically, it
263 ** would be easier to replace the ' ' and 0x09 check with isspace(), but
264 ** to make things safer, just add the 0x09 check (with the excpetion of the
265 ** HP 4V, it has been working up to now. We don't want to possibly break
266 ** another PPD by replacing with isspace() ).
267 */
268 /*
269 ** GP@SWHT Defect 225880
270 ** We have 10 ppd's where are used TAB (0x09) instead of space
271 ** So if MovePast is searching for space, search also for TAB char.
272 */
273 while ( ( *(pbBuffer+i) != chSkip ) &&
274 ( *(pbBuffer+i) != 0x09 || chSkip != ' ' ) && // GP@SWHT D225880
275 ( *(pbBuffer+i) >= ' ' || *(pbBuffer+i) == 0x09 )
276 )
277 {
278 i++;
279 }
280 i++;
281
282 // @V3.OEM There may be more than one blank in the PPD file, so get
283 // past all of them
284 while ( ( *(pbBuffer+i) == chSkip) ||
285 ( *(pbBuffer+i) == 0x09 && chSkip == ' ' ) // GP@SWHT D225880
286 )
287 {
288 i++;
289 }
290 return( i );
291}
292
293
294/*
295** @V2.177675
296** This function previously copied the quoted contents to a destination buffer
297** and stored the string length in the first byte. Now, this function does a
298** standard NULL-terminated string copy for the contents within the quotes.
299*/
300/*
301** @V3.0129238
302** Include the forward slash ('/') as a delimeter if bIncludeSlash is TRUE.
303** If bIncludeSlash is FALSE, do not include the forward slash as a
304** delimiter.
305*/
306/***************************************************************************
307 *
308 * FUNCTION NAME = CopyString
309 *
310 * DESCRIPTION = This routine copies a string from source to
311 * destination with delimiters as a double Quote,
312 * blank, colon, or forward slash (optional). The string
313 * is NULL terminated.
314 *
315 * INPUT = szDestn - destination string
316 * szSource - source string
317 * iMaxLen - length of destination string
318 * uiOpt - Options for copying //@V4.HexChar
319 * CSTR_NORMAL
320 * CSTR_INCLUDE_SLASH - Include the forward slash ('/')
321 * as a delimiter.
322 * CSTR_HEX2CHAR - Convert hex <e1> strings to chars.
323 * CSTR_EXCLUDE_DQUOTE- Exclude the double quote (")
324 * as a delimiter. GP@SWHT
325 *
326 * OUTPUT = NONE.
327 *
328 * RETURN-NORMAL = Number of characters in the copied string.
329 * RETURN-ERROR = NONE.
330 *
331 ************************************************************************* */
332
333int CopyString(char *szDestn, char *szSource, int iMaxlen, UINT uiOpt)
334{
335 int i,j;
336
337 int fInHex; // flag, if we currently are processing hex string
338
339 // these variables keep state in case we have to abort hex string conversion
340 // (if it's actually not hex string, just <some string>...
341 int iHexRollbackSrc;
342 int iHexRollbackDest;
343 int iHexDigits;
344
345 char chHex;
346
347 char *str_in;
348 char *str_out;
349
350
351
352 iMaxlen--; /* maxlen is actually 1 based, i is a 0 based index, if you hit the max
353 * then add a NULL you may have a memory violation, so adjust by 1 [wgs] */
354
355 if (!(*szSource)) /* if the string is empty, do nothing */
356 return(0);
357
358
359 i = 0;
360 j = 0;
361 str_in = szSource;
362 str_out = szDestn;
363
364 fInHex = FALSE;
365
366
367 /* @V4.HexChar Begin
368 ** OldCode
369 ** while (*szSource && *szSource != '"' && (*szSource >= ' ' || *szSource < 0) &&
370 ** *szSource != ':' && ((bIncludeSlash == TRUE && *szSource != '/') ||
371 ** bIncludeSlash != TRUE) && i < iMaxlen)
372 ** {
373 ** *(szDestn + i++) = *(szSource++);
374 ** }
375 **
376 ** New Code translates also hex strings <e1> to chars
377 ** if CSTR_HEX2CHAR is set.
378 */
379
380 while ( str_in[i] &&
381 (str_in[i] != '"' || (uiOpt & CSTR_EXCLUDE_DQUOTE) ) &&
382 (str_in[i] >= ' ' || str_in[i] < 0) &&
383 str_in[i] != ':' &&
384 ( ( (uiOpt & CSTR_INCLUDE_SLASH) && str_in[i] != '/') ||
385 !(uiOpt & CSTR_INCLUDE_SLASH) )
386 && j < iMaxlen)
387 {
388 if ( uiOpt & CSTR_HEX2CHAR )
389 {
390
391 //@HEXSTR fix hex string parsing code to support PPD standard.
392 //
393 // note: very similar code is countained in charstr.c::ConvertCharset
394 // if you fix a bug here, don't forget to fix it there too.
395 //
396
397 if( !fInHex && str_in[i]=='<' )
398 {
399 // this might be the beginning of <hex> string
400
401 fInHex = TRUE;
402 iHexRollbackSrc = i;
403 iHexRollbackDest = j;
404 iHexDigits = 0;
405 i++;
406 continue;
407 }
408 else if( fInHex && str_in[i]=='>' )
409 {
410 // hex string is terminated
411
412 if( iHexDigits )
413 {
414 // this string is error, rollback
415 i = iHexRollbackSrc;
416 j = iHexRollbackDest;
417
418 // get over the '<' character
419 str_out[j]=str_in[i];
420 i++;
421 j++;
422
423 // just go on copying
424 }
425 else
426 {
427 i++;
428 }
429
430 fInHex = FALSE;
431 iHexDigits = 0;
432 continue;
433 }
434 else if( fInHex )
435 {
436 // processing the hex string
437
438 char ch = str_in[i];
439
440 // check if it's acceptable hex char
441
442 if( ch >= '0' && ch<='9' )
443 {
444 chHex = (chHex << 4) | (ch - '0');
445 iHexDigits++;
446 }
447 else if( ch >= 'a' && ch<='f' )
448 {
449 chHex = (chHex << 4) | (ch - 'a' + 0xA);
450 iHexDigits++;
451 }
452 else if( ch >= 'A' && ch<='F' )
453 {
454 chHex = (chHex << 4) | (ch - 'A' + 0xA);
455 iHexDigits++;
456 }
457 else if( ch == ' ' || ch == '\t' )
458 {
459 // these are acceptable chars, must be ignored
460 // (note: this is different from charset.c processing
461 // where they would be copied verbatim !)
462
463 ; // do nothing
464 }
465 else
466 {
467 // just bail, return to copying the string as if hex mode never happened
468 i = iHexRollbackSrc;
469 j = iHexRollbackDest;
470
471 // get over the '<' character
472 str_out[j]=str_in[i];
473 i++;
474 j++;
475
476 fInHex = FALSE;
477 iHexDigits = 0;
478
479 // just go on copying
480 continue;
481 }
482
483 // must be 2 or more(even nr) hex characters
484 if( iHexDigits == 2 )
485 {
486 str_out[j] = chHex;
487 j++;
488
489 iHexDigits = 0;
490 }
491
492 i++;
493 continue;
494 }
495
496 }
497
498 str_out[j]=str_in[i];
499 i++;
500 j++;
501 }
502 // @V4.HexChar End
503
504 str_out[j] = 0;
505 j++; // required
506
507//debug print
508// printf(" === %s ===\n", str_out );
509
510 return( j );
511} /* CopyString */
512
513
514/*
515** @V2.177675
516** This function previously copied the quoted contents to a destination buffer
517** and stored the string length in the first byte. Now, this function does a
518** standard NULL-terminated string copy for the contents within the quotes.
519*/
520/***************************************************************************
521 *
522 * FUNCTION NAME = CopyInQuote
523 *
524 * DESCRIPTION = This routine copies a NULL-terminated string from source to
525 * destination with delimiters as a double Quote. This
526 * function returns the string length, in bytes, including
527 * the terminator.
528 *
529 * If fRemoveDots is TRUE the dots in the target
530 * string will be replaced with underscores. This is
531 * to get around a in the IBM spooler which chokes on
532 * more than one dot in a printer model name.
533 *
534 * INPUT = szDestn - destination string
535 * szSource - source string
536 * fRemoveDots - flag
537 *
538 * OUTPUT = NONE.
539 *
540 * RETURN-NORMAL = NONE.
541 * RETURN-ERROR = NONE.
542 *
543 ************************************************************************* */
544
545int CopyInQuote(char *szDestn,char *szSource,BOOL fRemoveDots, BOOL CompressFlag)
546{
547 /*@V3.0CMPS01 start */
548 int j, k;
549//ULONG ulKey; NOTUSED
550 PWORDELEMENT pW;
551 PSZ pszP;
552 /*@V3.0CMPS01 end */
553 register int i = 0;
554 BOOL fInHexString = FALSE;
555
556 /*
557 ** @V2.177675
558 ** Remove MAX_ESC_STR_LEN. Some PPD commands may exceed 256 characters.
559 */
560
561 if (!(*szSource)) /* if the string is empty, do nothing */
562 return(i);
563
564 /* Remove excess leading spaces */
565 while (*szSource && isspace( *szSource ))
566 {
567 szSource++;
568 }
569
570 /*
571 ** Change any dots to underscores if needed
572 */
573 if ( fRemoveDots )
574 {
575 pszP = szSource;
576
577 while ( *pszP != '"' )
578 {
579 if ( *pszP == '.' )
580 {
581 *pszP = '_';
582 }
583
584 pszP++;
585 }
586 }
587
588
589 while (*szSource && *szSource != '"') /* make sure we check the null too. [wgs] */
590 {
591 if ( isalnum( *szSource ) )
592 {
593 /* copy ANs to buffer */
594 j = 0;
595 /*
596 ** A word is alphanumeric. Dots are allowed as long as in
597 ** the middle
598 */
599 while ( isalnum( *szSource ) ||
600 ((*szSource == '.') && isalnum( *(szSource+1) ) ) )
601 {
602 *(szDestn + i + j++ ) = *(szSource++);
603 }
604 if ( j > 1 ) /* a multi char word */
605 {
606 if (CompressFlag == TRUE)
607 {
608 *(szDestn + i + j ) = '\0';
609//
610// if ( fWriteWords ) /* Write out words if needed */
611// {
612// fprintf (ppdOut, "%s\n",szDestn+i);
613// }
614
615 if ( ( pW = SearchHashTable( (PSZ) szDestn+i ) ) != 0 ) //Look in hash table
616 {
617 /*
618 ** For each list we pass write a 0xff out - first list no FFs
619 ** secon write one FF, third write two ...
620 */
621 for ( k = 0; k < pW->sList; k++ )
622 {
623 *(szDestn + i++) = '\xFF';
624 }
625 *(szDestn + i++) = pW->sIndex;
626 }
627 else
628 {
629 i += j; /* move i by word */
630 }
631 }
632 else
633 {
634 i += j; /* move i by word */
635 }
636 }
637 else
638 {
639 i += j; /* move i by word */
640 }
641 }
642
643 else
644 if (isspace( *szSource ))
645 {
646 /*
647 ** If space use one space char and skip rest
648 --
649 ** Keep it a space Not tab CR LF etc...
650 */
651 BOOL fFoundLF = FALSE;
652
653 if ( *szSource != '\n' )
654 {
655 *(szDestn + i++) = ' ';
656 }
657 else
658 {
659 *(szDestn + i++) = '\n';
660 fFoundLF = TRUE;
661 }
662
663 szSource++;
664
665 /* Remove excess any spaces */
666 while ( isspace( *szSource ) &&
667 ( *szSource != '\n' || fFoundLF == TRUE ) )
668 {
669 szSource++;
670 }
671 }
672
673 else
674 {
675 // @V4.1200417
676 // This is either a hex string or dict entry
677 if ( *szSource == '<' )
678 {
679 // It's a Dict entry
680 if ( *(szSource+1) == '<' )
681 {
682 *(szDestn + i++) = *(szSource++);
683 }
684 else
685 {
686 // Do not compress hex strings
687 // If compression is already off then nothing really needs to change
688 fInHexString = CompressFlag;
689 CompressFlag = FALSE;
690 }
691 }
692 else
693 if ( *szSource == '>' &&
694 fInHexString == TRUE )
695 {
696 fInHexString = FALSE;
697 CompressFlag = TRUE;
698 }
699
700 *(szDestn + i++) = *(szSource++);
701 }
702 }
703
704 /*
705 ** NULL-terminate the destination string.
706 */
707
708 *(szDestn + i++) = 0;
709
710 return( i );
711} /* CopyInQuote */
712
713
Note: See TracBrowser for help on using the repository browser.