StrCase - Revision history

210.209.20.204: /* Syntax */

2011-05-25T07:14:51Z

Syntax

â† Older revision		Revision as of 07:14, 25 May 2011
Line 20:		Line 20:
	Push "String"		Push "String"
	Push "Case"		Push "Case"
	Call ~~StrLoc~~		Call StrCase
	Pop "ResultVar"		Pop "ResultVar"
	</highlight-nsis>		</highlight-nsis>

Deguix at 06:17, 3 December 2005

2005-12-03T06:17:06Z

â† Older revision		Revision as of 06:17, 3 December 2005
Line 3:		Line 3:
	== Description ==		== Description ==

	'''Requires:''' [[LogicLib]] and [[System plug-in]].		'''Requires:''' [[LogicLib header file]] and [[System plug-in]].

	'''Version:''' 2.0.1.		'''Version:''' 2.0.1.

Deguix: Corrected link to System plug-in.

2005-12-03T06:13:12Z

Corrected link to System plug-in.

â† Older revision		Revision as of 06:13, 3 December 2005
Line 3:		Line 3:
	== Description ==		== Description ==

	'''Requires:''' [[LogicLib]] and [[System]] ~~plugin~~.		'''Requires:''' [[LogicLib]] and [[System plug-in]].

	'''Version:''' 2.0.1.		'''Version:''' 2.0.1.

Deguix: "StrStr" -> "StrCase".

2005-08-10T16:21:51Z

"StrStr" -> "StrCase".

â† Older revision		Revision as of 16:21, 10 August 2005
Line 50:		Line 50:

	<highlight-nsis>		<highlight-nsis>
	${~~StrStr~~} $0 "This is just an example" "T"		${StrCase} $0 "This is just an example" "T"
	;$0 = "This Is Just An Example"		;$0 = "This Is Just An Example"
	</highlight-nsis>		</highlight-nsis>

Deguix: Corrected function parameters order.

2005-07-10T11:37:55Z

Corrected function parameters order.

â† Older revision		Revision as of 11:37, 10 July 2005
Line 18:		Line 18:
	or		or
	<highlight-nsis>		<highlight-nsis>
			Push "String"
	Push "Case"		Push "Case"
	~~Push "String"~~
	Call StrLoc		Call StrLoc
	Pop "ResultVar"		Pop "ResultVar"
Line 60:		Line 60:

	!macro StrCase ResultVar String Case		!macro StrCase ResultVar String Case
			Push "${String}"
	Push "${Case}"		Push "${Case}"
	~~Push "${String}"~~
	Call StrCase		Call StrCase
	Pop "${ResultVar}"		Pop "${ResultVar}"

Deguix: Hmm... ":*" is not a good combination when the previous line starts with ";".

2005-07-10T06:05:47Z

Hmm... ":*" is not a good combination when the previous line starts with ";".

â† Older revision		Revision as of 06:05, 10 July 2005
Line 243:		Line 243:

	;2.0.1		;2.0.1
	:*Fixed stack problems.		*Fixed stack problems.

	== Credits ==		== Credits ==

Deguix: "OutVar" -> "ResultVar".

2005-07-10T06:02:31Z

"OutVar" -> "ResultVar".

â† Older revision		Revision as of 06:02, 10 July 2005
Line 222:		Line 222:
	/*After this point:		/*After this point:
	------------------------------------------		------------------------------------------
	$0 = ~~OutVar~~ (output)*/		$0 = ResultVar (output)*/

	; Copy "ResultStr" to "~~OutVar~~"		; Copy "ResultStr" to "ResultVar"
	StrCpy $0 $5		StrCpy $0 $5

Deguix: Version: 2.0.1. Version number "2.0" was wrongly assigned to this version, so nothing was changed except by the addition of "Versions History" header.

2005-07-10T05:39:06Z

Version: 2.0.1. Version number "2.0" was wrongly assigned to this version, so nothing was changed except by the addition of "Versions History" header.

â† Older revision		Revision as of 05:39, 10 July 2005
Line 5:		Line 5:
	'''Requires:''' [[LogicLib]] and [[System]] plugin.		'''Requires:''' [[LogicLib]] and [[System]] plugin.

	'''Version:''' 2.0.		'''Version:''' 2.0.1.

	This function converts a string to a specified case.		This function converts a string to a specified case.
Line 239:		Line 239:
	FunctionEnd		FunctionEnd
	</highlight-nsis>		</highlight-nsis>

			== Versions History ==

			;2.0.1
			:*Fixed stack problems.

	== Credits ==		== Credits ==

Deguix: Version: 2.0.

2005-07-04T00:30:06Z

Version: 2.0.

New page

{{PageAuthor|deguix}}

== Description ==

'''Requires:''' [[LogicLib]] and [[System]] plugin.

'''Version:''' 2.0.

This function converts a string to a specified case.

== How To Use ==

=== Syntax ===

<highlight-nsis>
${StrCase} "ResultVar" "String" "Case"
</highlight-nsis>
or
<highlight-nsis>
Push "Case"
Push "String"
Call StrLoc
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===

; ResultVar
: Variable where the transformed ''String'' by the ''Case'' parameter is returned.

; String
: String to transform into ''Case'' case.

; Case
: Case type to transform ''String''. The following are supported:
:;empty value
::Original Case (same as ''String'').
:;L
::Lower Case.
:;U
::Upper Case.
:;T
::Title Case.
:;S
::Sentence Case.
:;<>
::Switch Case.

=== Example ===

<highlight-nsis>
${StrStr} $0 "This is just an example" "T"
;$0 = "This Is Just An Example"
</highlight-nsis>

== Function Code ==

<highlight-nsis>
!define StrCase "!insertmacro StrCase"

!macro StrCase ResultVar String Case
Push "${Case}"
Push "${String}"
Call StrCase
Pop "${ResultVar}"
!macroend

Function StrCase
/*After this point:
------------------------------------------
$0 = String (input)
$1 = Case (input)
$2 = StrLength (temp)
$3 = StartChar (temp)
$4 = EndChar (temp)
$5 = ResultStr (temp)
$6 = CurrentChar (temp)
$7 = LastChar (temp)
$8 = Temp (temp)*/

;Get input from user
Exch $1
Exch
Exch $0
Exch
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7
Push $8

;Initialize variables
StrCpy $2 ""
StrCpy $3 ""
StrCpy $4 ""
StrCpy $5 ""
StrCpy $6 ""
StrCpy $7 ""
StrCpy $8 ""

;Upper and lower cases are simple to use
${If} $1 == "U"

;Upper Case:
;-----------
;Convert all characters to upper case.

System::Call "User32::CharUpper(t r0 r5)i"
Goto StrCase_End
${ElseIf} $1 == "L"

;Lower Case:
;-----------
;Convert all characters to lower case.

System::Call "User32::CharLower(t r0 r5)i"
Goto StrCase_End
${EndIf}

;For the rest of cases:
;Get "String" length
StrLen $2 $0

;Make a loop until the end of "String"
${For} $3 0 $2
;Add 1 to "EndChar" counter also
IntOp $4 $3 + 1

# Step 1: Detect one character at a time

;Remove characters before "StartChar" except when
;"StartChar" is the first character of "String"
${If} $3 <> 0
StrCpy $6 $0 `` $3
${EndIf}

;Remove characters after "EndChar" except when
;"EndChar" is the last character of "String"
${If} $4 <> $2
${If} $3 = 0
StrCpy $6 $0 1
${Else}
StrCpy $6 $6 1
${EndIf}
${EndIf}

# Step 2: Convert to the advanced case user chose:

${If} $1 == "T"

;Title Case:
;------------------
; Convert all characters after a non-alphabetic character to upper case.
; Else convert to lower case.

;Use "IsCharAlpha" for the job
System::Call "*(&t1 r7) i .r8"
System::Call "*$8(&i1 .r7)"
System::Free $8
System::Call "user32::IsCharAlpha(i r7) i .r8"

;Verify "IsCharAlpha" result and convert the character
${If} $8 = 0
System::Call "User32::CharUpper(t r6 r6)i"
${Else}
System::Call "User32::CharLower(t r6 r6)i"
${EndIf}
${ElseIf} $1 == "S"

;Sentence Case:
;------------------
; Convert all characters after a ".", "!" or "?" character to upper case.
; Else convert to lower case. Spaces or tabs after these marks are ignored.

;Detect current characters and ignore if necessary
${If} $6 == " "
${OrIf} $6 == "$\t"
Goto IgnoreLetter
${EndIf}

;Detect last characters and convert
${If} $7 == "."
${OrIf} $7 == "!"
${OrIf} $7 == "?"
${OrIf} $7 == ""
System::Call "User32::CharUpper(t r6 r6)i"
${Else}
System::Call "User32::CharLower(t r6 r6)i"
${EndIf}
${ElseIf} $1 == "<>"

;Switch Case:
;------------------
; Switch all characters cases to their inverse case.

;Use "IsCharUpper" for the job
System::Call "*(&t1 r6) i .r8"
System::Call "*$8(&i1 .r7)"
System::Free $8
System::Call "user32::IsCharUpper(i r7) i .r8"

;Verify "IsCharUpper" result and convert the character
${If} $8 = 0
System::Call "User32::CharUpper(t r6 r6)i"
${Else}
System::Call "User32::CharLower(t r6 r6)i"
${EndIf}
${EndIf}

;Write the character to "LastChar"
StrCpy $7 $6

IgnoreLetter:
;Add this character to "ResultStr"
StrCpy $5 `$5$6`
${Next}

StrCase_End:

/*After this point:
------------------------------------------
$0 = OutVar (output)*/

; Copy "ResultStr" to "OutVar"
StrCpy $0 $5

;Return output to user
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Exch $0
FunctionEnd
</highlight-nsis>

== Credits ==
Author: Diego Pedroso ([[User:deguix|deguix]])<br>
Based on [[StrLower]] and [[StrUpper]] functions.

[[Category:String Functions]]