c# pdf viewer itextsharp : How to move pages in a pdf file control Library system web page asp.net html console Windows%20Powershell%20in%20Action%202nd%20Edition8-part1538

50
CHAPTER 2
F
OUNDATIONS
OF
P
OWER
S
HELL
parameter name for production scripts or scripts you want to share. Readability is 
always more important in that scenario.)
Now that we’ve covered the core concepts of how commands are processed, let’s 
step back a bit and look at PowerShell language processing overall. PowerShell has a 
small number of important syntactic rules that you should learn. When you under-
stand  these  rules,  your  ability  to read,  write,  and  debug  PowerShell  scripts  will 
increase tremendously.
2.4
P
ARSING
AND
P
OWER
S
HELL
In this section, we’ll cover the details of how PowerShell scripts are parsed. Before the 
PowerShell interpreter can execute the commands you type, it first has to parse the 
command text and turn it into something the computer can execute, as shown in 
figure 2.3.
More formally, parsing is the process of turning human-readable source code into 
a form the computer understands. This is one area of computer science that deserves 
both of these words—computer and science. Science in this case means formal lan-
guage theory, which is a branch of mathematics. And because it’s mathematics, dis-
cussing it usually requires a collection of Greek letters. We’ll keep things a bit simpler 
here. A piece of script text is broken up into tokens by the tokenizer (or lexical ana-
lyzer, if you want to be more technical). A token is a particular type of symbol in the 
programming language, such as a number, a keyword, or a variable. Once the raw 
text has been broken into a stream of tokens, these tokens are processed into struc-
tures in the language through syntactic analysis. 
In syntactic analysis, the stream of tokens is processed according to the grammati-
cal rules of the language. In normal programming languages, this process is straight-
forward—a token always has the same meaning. A sequence of digits is always a 
number; an expression is always an expression, and so on. For example, the sequence
3+2
would always be an addition expression, and “Hello world” would always be a con-
stant string. Unfortunately, this isn’t the case in shell languages. Sometimes you can’t
3 + 2
Parser converts this
to an internal 
representation
Execution engine
evaluates the
internal
represenation
3
2
+
User types an
expression that is
passed to the
parser
5
Parser
Engine
Figure 2.3 The flow of pro-
cessing in the PowerShell in-
terpreter, where an expression 
is transformed and then exe-
cuted to produce a result
How to move pages in a pdf file - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
reorder pages in pdf file; how to reorder pages in pdf file
How to move pages in a pdf file - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to reorder pages in a pdf document; how to reverse pages in pdf
P
ARSING
AND
P
OWER
S
HELL
51
tell what a token is except through its context. In the next section, we go into more 
detail on why this is and how the PowerShell interpreter parses a script.
2.4.1
How PowerShell parses
For PowerShell to be successful as a shell, it can’t require that everything be quoted. 
PowerShell would fail if it required people to continually type
cd ".."
or
copy "foo.txt" "bar.txt"
On the other hand, people have a strong idea of how expressions should work:
2
This is the number 2, not a string “2”. Consequently, PowerShell has some rather 
complicated parsing rules. The next three sections will cover these rules. We’ll discuss 
how quoting is handled, the two major parsing modes, and the special rules for new-
lines and statement termination.
2.4.2
Quoting
Quoting is the mechanism used to turn a token that has special meaning to the Pow-
erShell interpreter into a simple string value. For example, the 
Write-Output
cmdlet 
has a parameter 
-InputObject
. But what if you  want  to actually use the string 
“-InputObject” as an argument, as mentioned earlier? To do this, you have to quote it; 
that is, you surround it with single or double quotes. The result looks like this:
PS (2) > Write-Output '-InputObject' 
-inputobject
What would happen if you hadn’t put the argument in quotes? Let’s find out:
PS (3) > Write-Output -InputObject
Write-Output : Missing an argument for parameter 'InputObject'.
Specify a parameter of type 'System.Management.Automation.PSObject[]’and 
try again.
At line:1 char:25 
+ Write-Output -inputobject <<<< 
PS (4) >
As you can see, this produces an error message indicating that an argument to the 
parameter 
-InputObject
is required.
PowerShell  supports  several  forms  of  quoting,  each  with  somewhat  different 
meanings (or semantics). Putting single quotes around an entire sequence of charac-
ters causes them to be treated like a single string. This is how you deal with file paths 
that have spaces in them. For example, if you want to change to a directory whose 
path contains spaces, you type this:
PS (4) > cd 'c:\program files'
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
random pages can be deleted from PDF file as well. Sorting Pages. RasterEdge XDoc.PDF allows you to easily move PDF document pages position, including sorting
reorder pages in pdf reader; how to rearrange pages in a pdf document
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Using this C#.NET Tiff image management library, you can easily change and move the position of any two or more Tiff file pages or make a totally new order for
how to move pages around in a pdf document; move pdf pages
52
CHAPTER 2
F
OUNDATIONS
OF
P
OWER
S
HELL
PS (5) > pwd 
Path 
----
C:\Program Files
What happens if you don’t use the quotes? 
PS (6) > cd c:\program files 
Set-Location : A parameter cannot be found that matches paramete 
r name 'files'.
At line:1 char:3 
+ cd  <<<< c:\program files 
When you don’t use the quotes, you receive an error complaining about an unex-
pected parameter in the command because 
"c:\program"
and 
"files"
are treated 
as two separate tokens.
NOTE
Notice that the error message reports the name of the cmdlet, 
not the alias that was used. This way you know what is being executed. 
The position message shows you the text that was entered so you can 
see that an alias was used.
One problem with using matching quotes as we did in the previous examples is that 
you have to remember to start the token with an opening quote. This raises an issue 
when you want to quote a single character. You can use the backquote (`) character to 
do this (the backquote is usually the upper-leftmost key, below Esc):
PS (6) > cd c:\program` files 
PS (7) > pwd 
Path 
----
C:\Program Files
The backquote, or backtick, as it tends to be called, has other uses that we’ll explore 
later in this section. Now let’s look at the other form of matching quote: double 
quotes. Once again, here’s our favorite example:
PS (8) > cd "c:\program files"
PS (9) > pwd
Path 
----
C:\Program Files
It looks pretty much like the example with single quotes, so what’s the difference? In 
double quotes, variables are expanded. In other words, if the string contains a variable 
reference starting with a 
$
, it will be replaced by the string representation of the value 
stored in the variable. Let’s look at an example. First assign the string “files” to the 
variable 
$v
:
PS (10) > $v = "files"
C# Word - Sort Word Pages Order in C#.NET
C# DLLs: Move Word Page Position. Add references: Swap Two Word Pages Position Using C#. You may choose two pages of Word file and exchange their position.
how to move pages in a pdf document; change page order pdf reader
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
splitting. C# DLLs: Move PowerPoint Page Position. C#. You may choose two pages of PowerPoint file and exchange their position. String
reverse pdf page order online; reorder pages in pdf document
P
ARSING
AND
P
OWER
S
HELL
53
Now reference that variable in a string with double quotes:
PS (11) > cd "c:\program $v"
PS (12) > pwd
Path 
----
C:\Program Files
The 
cd
succeeded and the current directory was set as you expected. What happens if 
you try it with single quotes? Here you go:
PS (13) > cd 'c:\program $v' 
set-location : Cannot find path 'C:\program $v' because it does 
not exist.
At line:1 char:3 
+ cd  <<<< 'c:\program $v'
PS (14) >
Because expansion is performed only in double quotes and not in single quotes, you 
get an error because the unexpanded path doesn’t exist.
Take a look at another example:
PS (14) > '$v is $v' 
$v is $v 
PS (15) > "$v is $v" 
files is files
In the single-quoted case, 
$v
is never expanded; and in the double-quoted case, it’s 
always expanded. But what if you really want to show what the value of 
$v
is? To do 
this, you need to have expansion in one place but not in the other. This is one of 
those other uses we had for the backtick. It can be used to quote or escape the dollar 
sign in a double-quoted string to suppress expansion. Let’s try it:
PS (16) > Write-Output "`$v is $v" 
$v is files
Here’s one final tweak to this example—if 
$v
contained spaces, you’d want to make 
clear what part of the output was the value. Because single quotes can contain double 
quotes and double quotes can contain single quotes, this is straightforward:
PS (17) > Write-Output "`$v is '$v'" 
$v is 'files'
PS (18) >
Now, suppose you want  to display the value of 
$v
on another line instead of in 
quotes. Here’s another situation where you can use the backtick as an escape charac-
ter. The sequence `n in a double-quoted string will be replaced by a newline charac-
ter. You can write the example with the value of 
$v
on a separate line as follows:
PS (19) > "The value of `$v is:`n$v" 
The value of $v is: 
Files
C# PDF insert text Library: insert text into PDF content in C#.net
int pageIndex = 0; // Move cursor to (400F, 100F). If you want to add a text string to PDF file, please try this C# demo. // Open a document.
move pages in pdf document; how to reorder pages in pdf online
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Rapidly and multiple PDF document (pages) creation and edit methods append, and split PDF files; insert, delete, move, rotate, copy and paste PDF file page
reorder pages in pdf; reorder pdf pages reader
54
CHAPTER 2
F
OUNDATIONS
OF
P
OWER
S
HELL
Table 2.1 lists the special characters that can be generated using backtick (also called 
escape) sequences.
Note that escape sequence processing, like variable expansion, is only done in double-
quoted strings. In single-quoted strings, what you see is what you get. This is particu-
larly important when writing a string to pass to a subsystem that does additional lev-
els of quote processing.
If you’ve used another language such as 
C
C
#, or Perl, you’ll be accustomed to 
using the backslash instead of the backtick for escaping characters. Because Power-
Shell is a shell and has to deal with Windows’ historical use of the backslash as a 
path separator, it isn’t practical to use the backslash as the escape character. Too 
many applications expect backslash-separated paths, and that would require every 
path to be typed with the slashes doubled. Choosing a different escape character was 
 difficult decision that the PowerShell team had  to  make,  but there wasn’t any 
choice. It’s one of the biggest cognitive bumps that experienced shell and script lan-
guage users run into with PowerShell, but in the end, most people adapt without too 
much difficulty.
2.4.3
Expression-mode and command-mode parsing
As mentioned earlier, because PowerShell is a shell, it has to deal with some parsing 
issues not found in other languages. In practice, most shell languages are collections 
of mini-languages with many different parsing modes. PowerShell simplifies this con-
siderably, trimming the number of modes down to two: expression mode and com-
mand mode.
In expression mode, the parsing is conventional: strings must be quoted, numbers 
are always numbers, and so on. In command mode, numbers are treated as numbers 
but all other arguments are treated as strings unless they start with 
$
@
'
"
, or 
(
When an argument begins with one of these special characters, the rest of the argument 
is parsed as a value expression. (There’s also special treatment for leading variable
Table 2.1 The PowerShell escape sequences 
Escape sequence
Corresponding Special Character
`n 
Newline
`t
Horizontal tab
`a
Alert
`b
Backspace
`'
Single quote
`"
Double quote
`0
The NULL character (in other words, 0)
``
A single backtick
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
Certainly, random pages can be deleted from PDF file as well. PDF Page sorting. RasterEdge XDoc.PDF allows you to easily move PDF document pages position in VB
pdf move pages; how to move pages in pdf files
C# PDF Library SDK to view, edit, convert, process PDF file for C#
Rapidly load, create, convert and edit PDF document (pages) in C# append, and split PDF files; insert, delete, move, rotate, copy and paste PDF file page.
pdf page order reverse; reverse page order pdf
P
ARSING
AND
P
OWER
S
HELL
55
references in a string, which we’ll discuss later.) Table 2.2 shows some examples that 
illustrate how items are parsed in each mode.
Notice that in the 
Write-Output (2+2)
case, the open parenthesis causes the inter-
preter to enter a new level of interpretation where the parsing mode is once again 
established by the first token. This means the sequence 
2+2
is parsed in expression 
mode, not command mode, so the result of the expression (4) is emitted. Also, the 
last example in the table illustrates the exception mentioned previously for a leading 
variable reference in a string. A variable itself is treated as an expression, but a variable 
followed by arbitrary text is treated as though the whole thing were in double quotes. 
This is so you can write
cd $HOME/scripts
instead of
cd "$HOME/scripts"
As mentioned earlier, quoted and unquoted strings are recognized as different tokens 
by the parser. This is why
Invoke-MyCmdlet -Parm arg
treats 
-Parm
as a parameter and
Table 2.2  Parsing mode examples 
Example command line
Parsing mode and explanation
2+2
Expression mode; results in 4.
Write-Output   2+2
Command mode; results in 2+2.
$a=2+2
Expression mode; the variable $a is assigned the value 4.
Write-Output (2+2)
Expression mode; because of the parentheses, 2+2 is evaluated as 
an expression producing 4. This result is then passed as an argu-
ment to the Write-Output cmdlet.
Write-Output $a
Expression mode; produces 4. This is ambiguous—evaluating it in 
either mode produces the same result. The next example shows 
why the default is expression mode if the argument starts with a 
variable.
Write-Output 
$a.Equals(4)
Expression mode; $a.Equals(4) evaluates to true so Write-
Output writes the Boolean value True. This is why a variable is 
evaluated in expression mode by default. You want simple method 
and property expressions to work without parentheses.
Write-Output $a/ 
foo.txt
Command mode; $a/foo.txt expands to 4/foo.txt. This is the 
opposite of the previous example. Here you want it to be evaluated 
as a string in command mode. The interpreter first parses in 
expression mode and sees that it’s not a valid property expression, 
so it backs up and rescans the argument in command mode. As a 
result, it’s treated as an expandable string.
56
CHAPTER 2
F
OUNDATIONS
OF
P
OWER
S
HELL
Invoke-MyCmdlet "-Parm" arg
treats 
"-Parm"
as an argument. There’s an additional wrinkle in the parameter bind-
ing. If an unquoted parameter like 
-NotAparameter
isn’t a parameter on 
Invoke-
MyCmdlet
, it will be treated as an argument. This lets you say
Write-Host  -this -is -a parameter
without requiring quoting.
This finishes our coverage of  the  basics of parsing modes, quoting, and com-
mands. Commands can take arbitrary lists of arguments, so knowing when the state-
ment ends is important. We’ll cover this in the next section.
2.4.4
Statement termination
In PowerShell, there are two statement terminator characters: the semicolon (;) and 
(sometimes) the newline. Why is a newline a statement separator only sometimes? The 
rule is that if the previous text is a syntactically complete statement, a newline is con-
sidered to be  a  statement termination. If it isn’t complete,  the  newline is simply 
treated like any other whitespace. This is how the interpreter can determine when a 
command or expression crosses multiple lines. For example, in the following
PS (1) > 2 + 
>> 2 
>> 
PS (2) >
the sequence 
2
+
is incomplete, so the interpreter prompts you to enter more text. 
(This is indicated by the nest prompt characters, 
>>
.) On the other hand, in the next 
sequence
PS (2) > 2 
PS (3) > + 2 
PS (4) >
the number 
2
by itself is a complete expression, so the interpreter goes ahead and 
evaluates it. Likewise, 
+ 2
is a complete expression and is also evaluated (
+
in this case 
is treated as the unary plus operator). From this, you can see that if the newline comes 
after the 
+
operator, the interpreter will treat the two lines as a single expression. If the 
newline comes before the 
+
operator, it will treat the two lines as two individual 
expressions.
Most of the time, this mechanism works the way you expect, but sometimes you 
can receive some unanticipated results. Take a look at the following example:
PS (22) > $b = ( 2 
>> + 2 ) 
>>
Missing closing ')' in expression.
P
ARSING
AND
P
OWER
S
HELL
57
At line:2 char:1 
+ + <<<<  2 )
PS (23) >
This was a question raised by one of the PowerShell beta testers. They were surprised 
by this result and thought there was something wrong with the interpreter, but in 
fact, this is not a bug. Here’s what’s happening.
Consider the following text:
> $b = (2 + 
> 2)
It’s parsed as 
$b = (2 + 2)
because a trailing 
+
operator is only valid as part of a 
binary operator expression. Because the sequence 
$b = ( 2 +
can’t be a syntactically 
complete statement, the newline is treated as whitespace. On the other hand, con-
sider the text
> $b = (2 
> + 2)
In this case, 
2
is a syntactically complete statement, so the newline is now treated as a 
line terminator. In effect, the sequence is parsed like 
$b = (2 ; + 2 );
that is, two 
complete statements. Because the syntax for a parenthetical expression is
( <expr> )
you get a syntax error—the interpreter is looking for a closing parenthesis as soon as 
it has a complete expression. Contrast this with using a subexpression instead of just 
the parentheses:
>> $b = $( 
>> 2 
>> +2 
>> ) 
>>
PS (24) > $b 
2
Here the expression is valid because the syntax for subexpressions is 
$( <statementList> ) 
But how do you deal with the case when you do need to extend a line that isn’t exten-
sible by itself? This is another place where you can use the backtick escape character. 
If the last character in the line is a backtick, then the newline will be treated as a sim-
ple breaking space instead of as a newline:
PS (1) > Write-Output ` 
>> -inputobject ` 
>> "Hello world" 
>>
Hello world 
PS (2) >
58
CHAPTER 2
F
OUNDATIONS
OF
P
OWER
S
HELL
Finally, one thing that surprises some people is that strings aren’t terminated by a 
newline  character. Strings can  carry over multiple lines until a matching,  closing 
quote is encountered:
PS (1) > Write-Output "Hello 
>> there 
>> how are 
>> you?" 
>>
Hello 
there 
how are 
you?
PS (2) >
In this example, you see a string that extended across multiple lines. When that string 
was displayed, the newlines were preserved in the string.
The handling of end-of-line characters in PowerShell is another of the trade-offs 
that had to be made for PowerShell to be useful as a shell. Although the handling of 
end-of-line characters is a bit strange compared to non-shell languages, the overall 
result is easy for most people to get used to.
2.4.5
Comment syntax in PowerShell
Every computer language has some mechanism for annotating code with expository 
comments. Like many other shells and scripting languages, PowerShell comments 
begin with a number sign (
#
) symbol and continue to the end of the line. The 
#
char-
acter must be at the beginning of a token for it to start a comment. Here’s an example 
that illustrates what this means:
PS (1) > echo hi#there 
hi#there
In this example, the number sign is in the middle of the token 
hi#there
and so isn’t 
treated as the starting of a comment. In the next example, there’s a space before the 
number sign:
PS (2) > echo hi #there 
hi
Now the 
#
is treated as starting a comment and the following text isn’t displayed. It 
can be preceded by characters other than a space and still start a comment. It can be 
preceded by any statement-terminating or expression-terminating character  like a 
bracket, brace, or semicolon, as shown in the next couple of examples:
PS (3) > (echo hi)#there 
hi 
PS (4) > echo hi;#there 
hi
In both of these examples, the 
#
symbol indicates the start of a comment.
P
ARSING
AND
P
OWER
S
HELL
59
Finally, you need to take into account whether you’re in expression mode or com-
mand mode. In command mode, as shown in the next example, the 
+
symbol is 
included in the token 
hi+#there
:
PS (5) > echo hi+#there 
hi+#there
But in expression mode, it’s parsed as its own token. Now the 
#
indicates the start of 
a comment, and the overall expression results in an error:
PS (6) > "hi"+#there
You must provide a value expression on the right-hand side of the '+' 
operator.
At line:1 char:6 
+ "hi"+ <<<< #there
The # symbol is also allowed in function names:
PS (3) > function hi#there { "Hi there" } 
PS (4) > hi#there 
Hi there
The reason for allowing the 
#
in the middle of tokens was to make it easy to accom-
modate path providers that used 
#
as part of their path names. People conventionally 
include a space before the beginning of a comment, so this doesn’t appear to cause 
any difficulties.
Multiline Comments
In PowerShell version 2, a new type of multiline comment was introduced, primarily 
to allow you to embed inline help text in scripts and functions. A multiline comment 
begins with 
<#
and ends with 
#>
. Here’s an example:
<# 
This is a comment
that spans 
multiple lines 
#>
This type of comment can be entered from the command line, which looks like this:
PS {1) > <# 
>> this is a comment 
>> that spans 
>> multiple lines 
>> #> 
>>
PS {2) >
This type of comment need not span multiple lines, so you can use this notation to 
add a comment preceding some code:
PS {2) > <# a comment #> "Some code" 
Some code 
PS {3) >
Documents you may be interested
Documents you may be interested