open password protected pdf using c# : Adding text to a pdf in acrobat control Library platform web page .net azure web browser abs-guide50-part1837

Example 34-2. Subshell Pitfalls
#!/bin/bash
# Pitfalls of variables in a subshell.
outer_variable=outer
echo
echo "outer_variable = $outer_variable"
echo
(
# Begin subshell
echo "outer_variable inside subshell = $outer_variable"
inner_variable=inner  # Set
echo "inner_variable inside subshell = $inner_variable"
outer_variable=inner  # Will value change globally?
echo "outer_variable inside subshell = $outer_variable"
# Will 'exporting' make a difference?
   export inner_variable
   export outer_variable
# Try it and see.
# End subshell
)
echo
echo "inner_variable outside subshell = $inner_variable"  # Unset.
echo "outer_variable outside subshell = $outer_variable"  # Unchanged.
echo
exit 0
# What happens if you uncomment lines 19 and 20?
# Does it make a difference?
Piping echo output to a read may produce unexpected results. In this scenario, the read acts as if it
were running in a subshell. Instead, use the set command (as in Example 15-18).
Example 34-3. Piping the output of echo to a read
#!/bin/bash
 badread.sh:
 Attempting to use 'echo and 'read'
#+ to assign variables non-interactively.
  shopt -s lastpipe
a=aaa
b=bbb
c=ccc
echo "one two three" | read a b c
# Try to reassign a, b, and c.
echo
echo "a = $a"  # a = aaa
echo "b = $b"  # b = bbb
• 
Advanced Bash-Scripting Guide
Chapter 34. Gotchas
495
Adding text to a pdf in acrobat - insert text into PDF content in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
XDoc.PDF for .NET, providing C# demo code for inserting text to PDF file
how to enter text in pdf; how to add text box to pdf
Adding text to a pdf in acrobat - VB.NET PDF insert text library: insert text into PDF content in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Providing Demo Code for Adding and Inserting Text to PDF File Page in VB.NET Program
adding text to pdf document; adding text fields to pdf
echo "c = $c"  # c = ccc
# Reassignment failed.
### However . . .
##  Uncommenting line 6:
  shopt -s lastpipe
##+ fixes the problem!
### This is a new feature in Bash, version 4.2.
# ------------------------------
# Try the following alternative.
var=`echo "one two three"`
set -- $var
a=$1; b=$2; c=$3
echo "-------"
echo "a = $a"  # a = one
echo "b = $b"  # b = two
echo "c = $c"  # c = three 
# Reassignment succeeded.
# ------------------------------
 Note also that an echo to a 'read' works within a subshell.
 However, the value of the variable changes *only* within the subshell.
a=aaa          # Starting all over again.
b=bbb
c=ccc
echo; echo
echo "one two three" | ( read a b c;
echo "Inside subshell: "; echo "a = $a"; echo "b = $b"; echo "c = $c" )
# a = one
# b = two
# c = three
echo "-----------------"
echo "Outside subshell: "
echo "a = $a"  # a = aaa
echo "b = $b"  # b = bbb
echo "c = $c"  # c = ccc
echo
exit 0
In fact, as Anthony Richardson points out, piping to any loop can cause a similar problem.
# Loop piping troubles.
 This example by Anthony Richardson,
#+ with addendum by Wilbert Berendsen.
foundone=false
find $HOME -type f -atime +30 -size 100k |
while true
do
read f
echo "$f is over 100KB and has not been accessed in over 30 days"
echo "Consider moving the file to archives."
Advanced Bash-Scripting Guide
Chapter 34. Gotchas
496
VB.NET PDF: How to Create Watermark on PDF Document within
Via our PDF Watermark Creator, users are capable of adding a designed watermark and customizing it on many aspects, for example, typing any text word and
add text pdf acrobat; how to add text to a pdf in acrobat
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
other documents are compatible, including PDF, TIFF, MS in offering full options on adding and creating hand, free hand line, rectangle, text, hotspot, hotspot
adding text to pdf online; adding text box to pdf
foundone=true
# ------------------------------------
echo "Subshell level = $BASH_SUBSHELL"
# Subshell level = 1
# Yes, we're inside a subshell.
# ------------------------------------
done
 foundone will always be false here since it is
#+ set to true inside a subshell
if [ $foundone = false ]
then
echo "No files need archiving."
fi
# =====================Now, here is the correct way:=================
foundone=false
for f in $(find $HOME -type f -atime +30 -size 100k)  # No pipe here.
do
echo "$f is over 100KB and has not been accessed in over 30 days"
echo "Consider moving the file to archives."
foundone=true
done
if [ $foundone = false ]
then
echo "No files need archiving."
fi
# ==================And here is another alternative==================
 Places the part of the script that reads the variables
#+ within a code block, so they share the same subshell.
 Thank you, W.B.
find $HOME -type f -atime +30 -size 100k | {
foundone=false
while read f
do
echo "$f is over 100KB and has not been accessed in over 30 days"
echo "Consider moving the file to archives."
foundone=true
done
if ! $foundone
then
echo "No files need archiving."
fi
}
A lookalike problem occurs when trying to write the stdout of a tail -f piped to grep.
tail -f /var/log/messages | grep "$ERROR_MSG" >> error.log
 The "error.log" file will not have anything written to it.
 As Samuli Kaipiainen points out, this results from grep
#+ buffering its output.
 The fix is to add the "--line-buffered" parameter to grep.
Using "suid" commands within scripts is risky, as it may compromise system security. [123]
• 
Advanced Bash-Scripting Guide
Chapter 34. Gotchas
497
Using shell scripts for CGI programming may be problematic. Shell script variables are not
"typesafe," and this can cause undesirable behavior as far as CGI is concerned. Moreover, it is
difficult to "cracker-proof" shell scripts.
• 
Bash does not handle the double slash (//) string correctly.
• 
Bash scripts written for Linux or BSD systems may need fixups to run on a commercial UNIX
machine. Such scripts often employ the GNU set of commands and filters, which have greater
functionality than their generic UNIX counterparts. This is particularly true of such text processing
utilites as tr.
• 
Sadly, updates to Bash itself have broken older scripts that used to work perfectly fine. Let us recall
how risky it is to use undocumented Bash features.
• 
Danger is near thee --
Beware, beware, beware, beware.
Many brave hearts are asleep in the deep.
So beware --
Beware.
--A.J. Lamb and H.W. Petrie
Advanced Bash-Scripting Guide
Chapter 34. Gotchas
498
Chapter 35. Scripting With Style
Get into the habit of writing shell scripts in a structured and systematic manner. Even on-the-fly and "written
on the back of an envelope" scripts will benefit if you take a few minutes to plan and organize your thoughts
before sitting down and coding.
Herewith are a few stylistic guidelines. This is not (necessarily) intended as an Official Shell Scripting
Stylesheet.
35.1. Unofficial Shell Scripting Stylesheet
Comment your code. This makes it easier for others to understand (and appreciate), and easier for you
to maintain.
PASS="$PASS${MATRIX:$(($RANDOM%${#MATRIX})):1}"
 It made perfect sense when you wrote it last year,
#+ but now it's a complete mystery.
 (From Antek Sawicki's "pw.sh" script.)
Add descriptive headers to your scripts and functions.
#!/bin/bash
#************************************************#
                  xyz.sh                       #
          written by Bozo Bozeman              #
               July 05, 2001                   #
                                               #
          Clean up project files.              #
#************************************************#
E_BADDIR=85                       # No such directory.
projectdir=/home/bozo/projects    # Directory to clean up.
# --------------------------------------------------------- #
# cleanup_pfiles ()                                         #
# Removes all files in designated directory.                #
# Parameter: $target_directory                              #
# Returns: 0 on success, $E_BADDIR if something went wrong. #
# --------------------------------------------------------- #
cleanup_pfiles ()
{
if [ ! -d "$1" ]  # Test if target directory exists.
then
echo "$1 is not a directory."
return $E_BADDIR
fi
rm -f "$1"/*
return 0   # Success.
}  
cleanup_pfiles $projectdir
exit $?
• 
Avoid using "magic numbers," [124] that is, "hard-wired" literal constants. Use meaningful variable
names instead. This makes the script easier to understand and permits making changes and updates
without breaking the application.
• 
Chapter 35. Scripting With Style
499
if [ -f /var/log/messages ]
then
...
fi
 A year later, you decide to change the script to check /var/log/syslog.
 It is now necessary to manually change the script, instance by instance,
#+ and hope nothing breaks.
# A better way:
LOGFILE=/var/log/messages  # Only line that needs to be changed.
if [ -f "$LOGFILE" ]
then
...
fi
Choose descriptive names for variables and functions.
fl=`ls -al $dirname`                 # Cryptic.
file_listing=`ls -al $dirname`       # Better.
MAXVAL=10   # All caps used for a script constant.
while [ "$index" -le "$MAXVAL" ]
...
E_NOTFOUND=95                        #  Uppercase for an errorcode,
#+ and name prefixed with E_.
if [ ! -e "$filename" ]
then
echo "File $filename not found."
exit $E_NOTFOUND
fi  
MAIL_DIRECTORY=/var/spool/mail/bozo  #  Uppercase for an environmental
export MAIL_DIRECTORY                #+ variable.
GetAnswer ()                         #  Mixed case works well for a
                                   #+ function name, especially
prompt=$1                          #+ when it improves legibility.
echo -n $prompt
read answer
return $answer
}  
GetAnswer "What is your favorite number? "
favorite_number=$?
echo $favorite_number
_uservariable=23                     # Permissible, but not recommended.
# It's better for user-defined variables not to start with an underscore.
# Leave that for system variables.
• 
Use exit codes in a systematic and meaningful way.
E_WRONG_ARGS=95
...
...
exit $E_WRONG_ARGS
See also Appendix E.
• 
Advanced Bash-Scripting Guide
Chapter 35. Scripting With Style
500
Ender suggests using the exit codes in /usr/include/sysexits.h in shell scripts, though these
are primarily intended for C and C++ programming.
Use standardized parameter flags for script invocation. Ender proposes the following set of flags.
-a      All: Return all information (including hidden file info).
-b      Brief: Short version, usually for other scripts.
-c      Copy, concatenate, etc.
-d      Daily: Use information from the whole day, and not merely
information for a specific instance/user.
-e      Extended/Elaborate: (often does not include hidden file info).
-h      Help: Verbose usage w/descs, aux info, discussion, help.
See also -V.
-l      Log output of script.
-m      Manual: Launch man-page for base command.
-n      Numbers: Numerical data only.
-r      Recursive: All files in a directory (and/or all sub-dirs).
-s      Setup & File Maintenance: Config files for this script.
-u      Usage: List of invocation flags for the script.
-v      Verbose: Human readable output, more or less formatted.
-V      Version / License / Copy(right|left) / Contribs (email too).
See also Section G.1.
• 
Break complex scripts into simpler modules. Use functions where appropriate. See Example 37-4.
• 
Don't use a complex construct where a simpler one will do.
COMMAND
if [ $? -eq 0 ]
...
# Redundant and non-intuitive.
if COMMAND
...
# More concise (if perhaps not quite as legible).
• 
... reading the UNIX source code to the Bourne
shell (/bin/sh). I was shocked at how much simple
algorithms could be made cryptic, and therefore
useless, by a poor choice of code style. I asked
myself, "Could someone be proud of this code?"
--Landon Noll
Advanced Bash-Scripting Guide
Chapter 35. Scripting With Style
501
Chapter 36. Miscellany
Nobody really knows what the Bourne shell's
grammar is. Even examination of the source code
is little help.
--Tom Duff
36.1. Interactive and non-interactive shells and scripts
An interactive shell reads commands from user input on a tty. Among other things, such a shell reads startup
files on activation, displays a prompt, and enables job control by default. The user can interact with the shell.
A shell running a script is always a non-interactive shell. All the same, the script can still access its tty. It is
even possible to emulate an interactive shell in a script.
#!/bin/bash
MY_PROMPT='$ '
while :
do
echo -n "$MY_PROMPT"
read line
eval "$line"
done
exit 0
# This example script, and much of the above explanation supplied by
# Stéphane Chazelas (thanks again).
Let us consider an interactive script to be one that requires input from the user, usually with read statements
(see Example 15-3). "Real life" is actually a bit messier than that. For now, assume an interactive script is
bound to a tty, a script that a user has invoked from the console or an xterm.
Init and startup scripts are necessarily non-interactive, since they must run without human intervention. Many
administrative and system maintenance scripts are likewise non-interactive. Unvarying repetitive tasks cry out
for automation by non-interactive scripts.
Non-interactive scripts can run in the background, but interactive ones hang, waiting for input that never
comes. Handle that difficulty by having an expect script or embedded here document feed input to an
interactive script running as a background job. In the simplest case, redirect a file to supply input to a read
statement (read variable <file). These particular workarounds make possible general purpose scripts that run
in either interactive or non-interactive modes.
If a script needs to test whether it is running in an interactive shell, it is simply a matter of finding whether the
prompt variable, $PS1 is set. (If the user is being prompted for input, then the script needs to display a
prompt.)
if [ -z $PS1 ] # no prompt?
### if [ -v PS1 ]   # On Bash 4.2+ ...
then
# non-interactive
...
Chapter 36. Miscellany
502
else
# interactive
...
fi
Alternatively, the script can test for the presence of option "i" in the $- flag.
case $- in
*i*)    # interactive shell
;;
*)      # non-interactive shell
;;
# (Courtesy of "UNIX F.A.Q.," 1993)
However, John Lange describes an alternative method, using the -t test operator.
# Test for a terminal!
fd=0   # stdin
 As we recall, the -t test option checks whether the stdin, [ -t 0 ],
#+ or stdout, [ -t 1 ], in a given script is running in a terminal.
if [ -t "$fd" ]
then
echo interactive
else
echo non-interactive
fi
 But, as John points out:
   if [ -t 0 ] works ... when you're logged in locally
   but fails when you invoke the command remotely via ssh.
   So for a true test you also have to test for a socket.
if [[ -t "$fd" || -p /dev/stdin ]]
then
echo interactive
else
echo non-interactive
fi
Scripts may be forced to run in interactive mode with the -i option or with a #!/bin/bash -i header.
Be aware that this can cause erratic script behavior or show error messages even when no error is
present.
36.2. Shell Wrappers
A wrapper is a shell script that embeds a system command or utility, that accepts and passes a set of
parameters to that command. [125] Wrapping a script around a complex command-line simplifies invoking it.
This is expecially useful with sed and awk.
A sed or awk script would normally be invoked from the command-line by a sed -e 'commands' or
awk 'commands'. Embedding such a script in a Bash script permits calling it more simply, and makes it
reusable. This also enables combining the functionality of sed and awk, for example piping the output of a set
of sed commands to awk. As a saved executable file, you can then repeatedly invoke it in its original form or
modified, without the inconvenience of retyping it on the command-line.
Advanced Bash-Scripting Guide
Chapter 36. Miscellany
503
Example 36-1. shell wrapper
#!/bin/bash
# This simple script removes blank lines from a file.
# No argument checking.
#
# You might wish to add something like:
#
# E_NOARGS=85
# if [ -z "$1" ]
# then
 echo "Usage: `basename $0` target-file"
 exit $E_NOARGS
# fi
sed -e /^$/d "$1"
# Same as
   sed -e '/^$/d' filename
# invoked from the command-line.
 The '-e' means an "editing" command follows (optional here).
 '^' indicates the beginning of line, '$' the end.
 This matches lines with nothing between the beginning and the end --
#+ blank lines.
 The 'd' is the delete command.
 Quoting the command-line arg permits
#+ whitespace and special characters in the filename.
 Note that this script doesn't actually change the target file.
 If you need to do that, redirect its output.
exit
Example 36-2. A slightly more complex shell wrapper
#!/bin/bash
 subst.sh: a script that substitutes one pattern for
#+ another in a file,
#+ i.e., "sh subst.sh Smith Jones letter.txt".
                    Jones replaces Smith.
ARGS=3         # Script requires 3 arguments.
E_BADARGS=85   # Wrong number of arguments passed to script.
if [ $# -ne "$ARGS" ]
then
echo "Usage: `basename $0` old-pattern new-pattern filename"
exit $E_BADARGS
fi
old_pattern=$1
new_pattern=$2
if [ -f "$3" ]
then
file_name=$3
Advanced Bash-Scripting Guide
Chapter 36. Miscellany
504
Documents you may be interested
Documents you may be interested