how to view pdf file in asp.net using c# : Extract image from pdf file Library software component .net winforms wpf mvc code_reading38-part1154

[ Team LiB ]
10.1 Regular Expressions
The tools that operate on source code at a lexical level are powerful and often underestimated. They can 
be used on any programming language or platform, operate without a need to preprocess or compile 
files, handle a wide variety of tasks, execute swiftly, and handle arbitrary amounts of program text. Using 
such tools, you can efficiently search for patterns in a large code file or across many files. These tools 
are by their nature imprecise; however, their use can save you time and yield results that might escape 
casual manual browsing.
The power and flexibility of many lexical tools come from the use of regular expressions. You can think of a regular expression as a 
recipe for matching character strings. A regular expression is composed from a sequence of characters. Most characters match only with 
themselves, but some characters, called meta-characters, have special meaning. You create regular expressions by using a 
combination of regular characters and meta-characters to specify a recipe for matching the exact code items you may be looking for. We 
list the most common regular expression building blocks in Table 10.1
.
Most program editors provide a command for searching a text string using a regular expression. Table 10.2
contains the specific 
commands for some popular editors. The regular expression syntax outlined in Table 10.1
is the same across most editors; it is 
supported in its exact form by vi, Emacs, and Epsilon. Most editors extend the regular expression syntax with additional facilities; some 
use a slightly different syntax. As an example, the BRIEF editor uses ? to match any character, % to match the beginning of a line, ~ to 
denote a nonmatching character class, and + to express one or more matches of the preceding regular expression. Consult your editor's 
documentation to learn the complete regular expression syntax it supports.
Table 10.1. Common Regular Expression Building Blocks
Character
Matches
.
Any character
[abc]
Any of the characters a, b, or c (character class)
[^abc]
All characters except for a, b, and c
a*
Zero or more occurrences of a
\m
The (meta-character) m
^
Beginning of a line
$
End of a line
\<
Beginning of a word
\>
End of a word
Extract image from pdf file - Select, copy, paste PDF images in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document
extract pdf images; extract jpeg from pdf
Extract image from pdf file - VB.NET PDF Image Extract Library: Select, copy, paste PDF images in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document
extract image from pdf using; extract images from pdf files without using copy and paste
Table 10.2. Regular Expression Search Commands in Popular Editors
Editor
Forward Search Command
Backward Search Command
BRIEF
[a]
Search Forward
Search Backward
Emacs
C-M-s
[b]
isearch-forward-regexp
C-M-r isearch-backward-regexp
Epsilon
C-A-s
[c]
regex-search
C-A-R reverse-regex-search
vi
/
?
Visual Studio
FindRegExpr
FindRegExprPrev
[a]
After performing a regular expressions toggle.
[b]
Control-Meta-s.
[c]
Control-Alt-s.
Given an editor that supports regular expressions and basic knowledge of their syntax, you can use them 
to efficiently browse large code files. To avoid accidentally changing the file contents, make sure that you 
do not have write permission on the files, or use the editor in a read-only mode (for example, vi -R for the 
vi editor).
In Figure 10.1
[1]
we provide some examples of the types of searches you can perform using regular 
expressions. Often you can locate particular program elements by taking advantage of the programming 
style used by the programmer. A common case concerns looking for a function definition (Figure 10.1:1
). 
Most programming style guides specify that function definitions are to be written with the function name 
starting on a separate line. You can therefore locate a function definition by using a regular expression 
search of the type ^function name. This regular expression will match all lines that start with function 
name. Such an expression will also match functions with a name that starts with the same character 
sequence as the function name you specified. You can always amend the corresponding regular 
expression to have it match the function name as a complete word: ^function name\>
[1]
netbsdsrc/sys/arch/sparc/fpu/fpu_sqrt.c:189–30 0
Figure 10.1 Regular expression matches.
struct fpn *
fpu_sqrt (fe)
struct fpemu *
fe ;
{
register struct fpn 
*x  = &fe->fe_f1;
register u_int bit, q, tt;
register u_int 
x0, 
x1, 
x2, 
x3;
register u_int 
y0, 
y1, 
y2, 
y3 ;
register u_int 
d0, 
d1, 
d2, 
d3;
[...]
C# PDF Text Extract Library: extract text content from PDF file in
Ability to extract highlighted text out of PDF document. text extraction from PDF images and image files. Enable extracting PDF text to another PDF file, TXT and
extract jpg pdf; extract pictures pdf
VB.NET PDF Text Extract Library: extract text content from PDF
Extract and get partial and all text content from PDF file. Extract highlighted text out of PDF document. Image text extraction control provides text extraction
pdf image extractor c#; pdf image extractor online
#define    DOUBLE_X { 
\
FPU_ADDS(x3, x3, x3); FPU_ADDCS(x2, x2, x2); 
\        
<-- a
FPU_ADDCS(x1, x1, x1); FPU_ADDC(x0, x0, x0); 
\
}
[...]
q = bit;
x0 -= bit ;
[...]
t1 =  bit;
^fpu_sqrt
\<fe\>
\*x
[xyd][0-3]
(a) \\$
x0.*bit
t1.*[^=]=[^=]
In practice, you will find that a simple regular expression specification works well enough for locating the
text you are looking for and that you need to give a more specific expression only in cases where the 
original expression generates too many false-positive matches. In some cases you will also find that you 
can get away with specifying only a part of the string you are looking for. In other cases, when you are 
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size effectively.
how to extract images from pdf file; extract jpg from pdf
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Create high resolution PDF file without image quality losing in ASP.NET application. Add multiple images to multipage PDF document in .NET WinForms.
extract text from pdf image; extract image from pdf c#
looking for a variable with a short name that appears in many different contexts, you will find that you 
need to explicitly specify word delimiters (\<, \>) around it (Figure 10.1:2
). Unfortunately, many regular 
expression meta-characters are also used by programming languages. You will therefore have to 
remember to escape them (using a backslash) when you are searching for program elements that 
contain them (Figure 10.1:3
). Regular expression character classes are useful for searching for all 
variables with a name that follows a specific pattern (Figure 10.1:4
), while character classes with 
negation can be used to avoid false-positive matches. As an example, the expression in Figure 10.1:6
locates assignments to t1  (locating where a variable is modified is often crucial for understanding code) 
without matching lines where t1 appears on the left of the equality operator (==). The zero-or-more 
matches (*) meta-character is often used in conjunction with the match-any meta-character (.) symbol to 
specify an arbitrary amount of unknown text (.*). When such an expression is given, the regular 
expression matching code, instead of greedily matching all characters until the end of the line, will try to 
match only enough characters to create a match for the whole regular expression (including the part of 
the pattern after the .*). In Figure 10.1:5
we use this feature to locate all lines that contain the variablex0 
followed by the variable bit.
Exercise 10.1 Learn the regular expression syntax provided by the editor you are using. Experiment with any additional features it
provides. Try to express the additional features using only the meta-characters we have described. Comment on the relative merits of a 
rich regular expression syntax versus the cost of learning it.
Exercise 10.2 Write regular expressions to locate integers, floating-point numbers, and a given word within a character string. Where
would you use such expressions?
Exercise 10.3 Write regular expressions to locate violations from the style guide used in the source code you are reading.
[ Team LiB ]
C# PDF File Split Library: Split, seperate PDF into multiple files
Application. Best and professional adobe PDF file splitting SDK for Visual Studio .NET. outputOps); Divide PDF File into Two Using C#.
extract images from pdf; extract images from pdf c#
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
When you have downloaded the RasterEdge Image SDK for also provided you with detailed PDF processing demo Imaging.Demo directory with the file name RasterEdge
extract pdf images; extract images from pdf online
[ Team LiB ]
10.2 The Editor as a Code Browser
Some editors (for example, Emacs and vi) use regular expression searches in conjunction with an index file to allow you to efficiently locate 
various definitions in source code. You first create an index file using the ctags tool applied on all source files that interest you. The index 
file, named tags, contains a sorted set of the definitions found in the source files. For the C language the definitions recognized include 
functions, #defines, and, optionally, typedefs, structs, unions, and enums. Each line of the tags file contains the name of the entity 
recognized, the file it was found in, and a regular expression pattern for locating that entity within the file. The following lines are part of the 
output of tags run on the source code of sed .
[2]
,[3]
[2]
netbsdsrc/usr.bin/sed
[3]
Unless otherwise noted, all examples in this chapter use the same set of source files.
NEEDSP process.c       /^#define       NEEDSP(reqlen) \\$/
Compile_addr   compile.c       /^compile_addr(p, a)$/
e_args  defs.h /^enum e_args {$/
s_addr  defs.h /^struct s_addr {$/
The use of regular expressions instead of line numbers keeps the tags file current even after lines are inserted or removed in the source 
file. While browsing the source code, a special command (^] in viM-. in Emacs) scans the entity name under the cursor and transfers you 
to the point where that entity is defined. Thus, by using the tags facility you can quickly view the definitions of new entities you encounter. 
By taking advantage of the plain format of the tags file you can easily write simple tools to create custom tag files for other source 
languages or specific applications.
Figure 10.2 Generating tags from Visual Basic source files.
@ARGV = (<*.frm>,<*.bas>,<*.ctl>);        
<-- a
<-- b
while (<>) {
chop;
if (
/Begin\s+[^ ]+\s+(\w+)/
) {        
<-- c
push(@lines, "$1\t$ARGV\t?$_?\n");
<-- d
} elsif (
/(Sub|Function)\s+(\w+)/
) {        
<-- e
push(@lines, 
"$2\t$ARGV\t?$_?\n"
);        
<-- f
}
}
open(T, '>tags') || die "tags: $!\n";        
<-- g
print T sort @lines;
(a) Visual Basic source files
(b) Go through all lines of all files
VB.NET PDF insert image library: insert images into PDF in vb.net
Create high resolution PDF file without image quality losing in .NET WinForms application. Insert single or multiple images or graphics to PDF document.
how to extract a picture from a pdf; pdf image extractor
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size effectively.
pdf extract images; how to extract images from pdf
(c) Is this a control?
(d) Add tag line to the tags array
(e) Is this a subroutine or function?
(f) Tag line containing entity name, filename, pattern
(g) Generate sorted tags file from the tags array
The Perl program in Figure 10.2
will create a tags file from Microsoft Visual Basic source code, allowing you 
to browse Visual Basic source code using any editor that supports tags. The precise formatting of the 
Visual Basic source code files simplifies the program's operation. The program's main loop goes through all 
possible source files in the current directory and matches lines (using the Perl enhanced regular 
expression syntax) for lines that look like definitions of controls, subroutines, or functions. The array lines
contains a list of all search patterns generated, so that when all input has been read it can be written in 
sorted form to the tags file. Although the program can be improved in numerous ways, it is, like most 
operations based on the lexical structure, good enough for most purposes.
A number of tools build upon the original ctags idea.
The idutils indexing tools
[4]
create a database of program identifiers and their occurences within a set of files. Separate 
command-line tools can then be used to query the database for files containing an identifier, edit a set of files that satisfy a 
query, list the tokens within a file, or grep through the subset of files containing an identifier to output the lines where it occurs. 
idutils can be enhanced by user-supplied scanners; they are supported by a number of editors such as Emacs and newer 
variants of vi like vim. Compared to ctags, idutils handle a wider range of "identifiers" including literals and names of include files.
[4]
http://www.gnu.org/directory/idutils.html
The exuberant ctags indexing tools
[5]
enhance ctags by providing support for 23 different languages.
[5]
http://ctags.sourceforge.net/
When browsing large code files you can obtain a bird's-eye view of the source code structure by using an editor's outline view. The GNU
Emacs editor provides the selective display command (C-x $— set-selective-display) to hide lines indented more than a certain number of 
columns. The command takes as a numerical argument the number of indented columns to hide; by using an appropriate number you can 
hide deeply nested source code. You can also use the Emacs outline mode (M-x outline-mode) and appropriate definitions for heading 
lines to quickly switch between a file's tree view and the corresponding node contents. The vim editor also supports the outline concept 
through the folding commands (for example, set foldenable, ZmZr, Zo, Zc.). These allow you to fold parts of the source file, thus obtaining 
an overview of the file's structure.
One other interesting way to look at a whole lot of source code quickly under Windows is to load it into Microsoft Word and then set the 
zoom factor to 10%. Each page of code will appear at about the size of a postage stamp, and you can get a surprising amount of 
information about the code's structure from the shape of the lines. For example, in Figure 10.3
[6]
you can discern the initial import 
statements, method blocks, and heavily indented code.
[6]
cocoon/src/java/org/apache/cocoon/transformation/LDAPTransformer.java
Figure 10.3. Bird's-eye view of source code using Microsoft Word.
You can also use your editor to detect matching parentheses, brackets, and braces. The appropriate commands are again different for 
each editor. Emacs provides a series of list commands: C-M-u (backward-up-list) moves up and backward in list structure, C-M-d (down-list
moves down and forward, C-M-m (forward-list)moves forward, and C-M-p (backward-list) moves backward. The vi editor provides the %
command that will move the cursor to the matching bracketing element. Finally, in the Microsoft Visual Studio IDE you can use the 
LevelUp and LevelDown commands to navigate across different levels and the GoToMatchBrace and GoToMatchBraceExtend commands 
to detect or select text that matches a given brace.
Exercise 10.4 Learn about and experiment with the tags facility of the editor you are using. Can it be extended using external tools?
Exercise 10.5 To localize the output message catalog of the vi editor you need to copy the English base file and replace messages with 
strings in the new local language. Unfortunately, in order to identify the purpose of each message argument you need to search the source 
code for each message.
[7]
Write a custom tag tool to automate this process.
[7]
netbsdsrc/usr.bin/vi/catalog/README:113–12 5
Exercise 10.6 Propose additional uses for the tags facility. Consider large bodies of code such as the Unix kernel.
[8]
[8]
netbsdsrc/sys
Exercise 10.7 Does the editor or programming environment you are using support viewing the outline of a source code file? Experiment
with this feature using examples from the book's CD-ROM.
[ Team LiB ]
[ Team LiB ]
10.3 Code Searching with grep
Large projects are typically split into multiple files, sometimes organized in a directory structure. Searching through each file with an 
editor is not always practical; fortunately, there are tools that can automate this task. The parent of all tools used for searching through 
large bodies of code is grep, which gets its name from the ed/ex editor command that prints all lines matching a pattern (g/RE/p—globall y
through the file find lines that match the given regular expression and print them). grep takes as an argument a regular expression to 
look for and a list of files to search in. The files are typically specified using a wildcard pattern, for example, *.c *.h. Many of the 
characters used in regular expressions also have a special meaning for the command-line shell, so it is better to enclose the regular 
expression in quotes. The following sequence displays the file and the line containing the definition for the function strregerror in the 
source code of sed.
$ grep '^strregerror' *.c
misc.c:strregerror(errcode, preg)
To find both the definition and all uses, we would simply use the name of the function as the regular expression.
$ grep strregerror *.c
compile.c:  err(COMPILE, "RE error: %s", strregerror(eval, *repp));
misc.c:strregerror(errcode, preg)
process.c: err(FATAL, "RE error: %s", strregerror(eval, defpreg));
grep need not be applied to program code. If you are not sure what exactly you are looking for and where to start searching, you can use 
grep to search through the code with a keyword in the hope that the word will be mentioned in a comment or be part of an identifier. To 
ensure that capitalization and the word's ending and derivatives do not overly restrict your search space, search using the word's stem, 
omitting its initial character. In the following example we are looking for code associated with the compilation process.
$ grep ompil *.c
[...]
compile.c:              p = compile–re(p, &a->u.r) ;
main.c: * Linked list pointer to compilation units and pointer to
main.c: compile();
main.c: * Add a compilation unit to the linked list
You can also use grep to search through the output of other tools. For example, in a project with numerous source files you can use 
to search the file list for a file that might interest you.
[9]
[9]
netbsdsrc/usr.bin/vi
$ ls | grep undo
v–undo. c
Sometimes you do not want to read the code that contains a regular expression but are interested only in the files that contain it. The -l
option of grep will display (once) the name of every file that contains the given regular expression.
$ grep -l xmalloc *.c *.h
compile.c
main.c
misc.c
extern.h
You can then use this output to automatically perform a specific task on all those files. Typical tasks might be editing each file to further 
scrutinize it or locking each file under a revision control system. In Unix-type shells you can accomplish this by enclosing the output of 
grep in backticks.
emacs `grep -l xmalloc *.c`
In other environments (for example, Windows), you need to modify the output of grep by adding the invocation of an editor command in 
front of each line and saving the result to a batch file, which you then execute. You can perform this and a number of similar tasks by 
using stream editing. Stream editing refers to the automated modification of text streams by a sequence of commands you specify. Two 
tools commonly used for stream editing are sed and Perl. Although sed is specifically targeted toward stream editing, we will use Perl in 
our examples because of its more regular syntax and in-place editing capability. If you use stream editing in a production environment, it 
might be worthwhile to also learn sed, which can be more efficient for some tasks.
The most useful editing command is the substitution command (s), which is specified as follows.
s/regular expression/replacement/flags
The command will locate text matching the regular expression and replace it with the replacement text. In the replacement text you can 
use the special expression $n to indicate the nth parenthesized part of the regular expression (for example, $1 will match the first 
parenthesized part of the regular expression). The flags are single-character modifiers that change the command behavior. The most 
useful flag is g, which makes the substitution change all nonoverlapping occurences of the regular expression and not just the first one, 
as is the default behavior. When using Perl as a stream editor, you need to execute it with a -p command-line flag to indicate that it 
should execute a printing loop over its input and specify the substitution command as an argument to the -e command-line flag. You can 
provide more than one substitution command by separating them with a semicolon. You can also specify that Perl should edit a file 
in-place rather than work as a filter on its input by using the -ibackup-extension flag. Refer to the Perl documentation for more details.
Returning to our problem of creating a batch file for editing the files that match a pattern, all you need to do is pipe the output of grep to 
Perl in order to substitute the beginning of each line with the edit command.
C:\> grep -l xmalloc *.c | perl -p -e's/^/edit /' >cont.bat
C:\> cont
In a Unix-type shell you can pipe the output of Perl back into a shell for immediate processing.
grep -l OBSOLETE *.c | perl -p -e 's/^/gzip /' |sh
This code compresses all files containing the word OBSOLETE. You can even pipe the output into a shell loop to execute a number of 
commands for every matching file. As an example, the code in Figure 10.4
uses grep to locate all files that contain the word xmalloc and 
pipes the output into the do loop. The code in the loop will do the following.
Read each file name as the $f variable.
Check out each file from the RCS repository, locking it for modification.
Change all occurrences of xmalloc to safe–mallo c using the in-place editing feature of Perl.
Check in the file in the RCS repository with an appropriate log message.
Figure 10.4 Changing an identifier name under 
RCS
control.
grep -l xmalloc *.c *.h |        
<-- a
<-- b
while read f
do
co -l $f
<-- c
perl -p -i.bak -e 's/xmalloc/safe_malloc/g' $f
<-- d
ci -m"Changed xmalloc to safe_malloc" -u $f
<-- e
done
Documents you may be interested
Documents you may be interested