Upload folder using huggingface_hub

APL/APL2_at_a_Glance_-_Brown_Pakin_Polivka.pdf.txt

@@ -0,0 +1 @@
+

APL2_at_a_Glance_-_Brown_Pakin_Polivka.pdf.txt

@@ -0,0 +1 @@
+

ASP.NET/intro%20to%20asp.net%20mvc%204%20with%20visual%20studio%20-%20beta.pdf.txt

@@ -0,0 +1,3442 @@
+Intr
+Visu
+
+ro to
+ual S
+
+o ASP
+Studio
+
+P.NET
+o (Be
+
+T MV
+eta)
+
+VC 4 w
+
+with 
+
+Rick A
+
+Anderso
+
+on and S
+
+Scott Ha
+
+anselma
+
+an 
+
+Summa
+
+ry: This tuto
+
+orial will te
+
+ach you the
+
+e basics of 
+
+building an
+
+n ASP.NET M
+
+MVC Web 
+
+applicat
+
+ion using M
+
+Microsoft Vi
+
+isual Studio
+
+o 11 Express
+
+s Beta for W
+
+Web, which 
+
+is a free 
+
+version o
+
+of Microsof
+
+ft Visual Stu
+
+udio. 
+
+Categor
+
+ry: Step-By
+
+-Step 
+
+Applies 
+
+to: ASP.NE
+
+ET MVC 4 B
+
+eta, Visual 
+
+Studio 11 B
+
+Beta 
+
+Source: 
+
+ASP.NET si
+
+te (link to s
+
+source cont
+
+tent) 
+
+E-book 
+
+publicatio
+
+on date: Ma
+
+ay 2012 
+
+115 pag
+
+es             
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Copyright © 2012 by Microsoft Corporation 
+
+All rights reserved. No part of the contents of this book may be reproduced or transmitted in any form or by any means 
+without the written permission of the publisher. 
+
+Microsoft and the trademarks listed at 
+http://www.microsoft.com/about/legal/en/us/IntellectualProperty/Trademarks/EN-US.aspx are trademarks of the 
+Microsoft group of companies. All other marks are property of their respective owners. 
+
+The example companies, organizations, products, domain names, email addresses, logos, people, places, and events 
+depicted herein are fictitious. No association with any real company, organization, product, domain name, email address, 
+logo, person, place, or event is intended or should be inferred. 
+
+This book expresses the author’s views and opinions. The information contained in this book is provided without any 
+express, statutory, or implied warranties. Neither the authors, Microsoft Corporation, nor its resellers, or distributors will 
+be held liable for any damages caused or alleged to be caused either directly or indirectly by this book. 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Contents 
+Getting Started ........................................................................................................................................ 3 
+
+What You'll Build ........................................................................................................................... 3 
+
+Skills You'll Learn ........................................................................................................................... 5 
+
+Getting Started .............................................................................................................................. 6 
+
+Creating Your First Application .................................................................................................... 7 
+
+Adding a Controller ............................................................................................................................ 13 
+
+Adding a View ..................................................................................................................................... 20 
+
+Changing Views and Layout Pages ............................................................................................ 25 
+
+Passing Data from the Controller to the View ........................................................................... 31 
+
+Adding a Model .................................................................................................................................. 37 
+
+Adding Model Classes................................................................................................................. 37 
+
+Creating a Connection String and Working with SQL Server LocalDB .................................... 41 
+
+Accessing Your Model's Data from a Controller ............................................................................... 43 
+
+Creating a Movie ......................................................................................................................... 46 
+
+Examining the Generated Code.................................................................................................. 48 
+
+Strongly Typed Models and the @model Keyword .................................................................. 49 
+
+Working with SQL Server LocalDB ............................................................................................. 53 
+
+Examining the Edit Methods and Edit View ...................................................................................... 58 
+
+Processing the POST Request ..................................................................................................... 65 
+
+Adding a Search Method and Search View ............................................................................... 67 
+
+Displaying the SearchIndex Form ............................................................................................... 67 
+
+Adding Search by Genre ............................................................................................................. 77 
+
+Adding Markup to the SearchIndex View to Support Search by Genre .................................. 79 
+
+Adding a New Field to the Movie Model and Table ......................................................................... 80 
+
+Adding a Rating Property to the Movie Model ......................................................................... 80 
+
+Managing Model and Database Schema Differences ............................................................... 82 
+
+Automatically Re-Creating the Database on Model Changes .................................................. 85 
+
+Adding Validation to the Model ........................................................................................................ 95 
+
+Keeping Things DRY .................................................................................................................... 95 
+
+Adding Validation Rules to the Movie Model ........................................................................... 95 
+
+Validation Error UI in ASP.NET MVC .......................................................................................... 97 
+
+How Validation Occurs in the Create View and Create Action Method ................................ 100 
+
+Adding Formatting to the Movie Model.................................................................................. 108 
+
+Examining the Details and Delete Methods .................................................................................... 111 
+
+Examining the Details and Delete Methods ............................................................................ 111 
+
+Wrapping Up ............................................................................................................................. 113 
+
+ 
+ 
+ 
+Getting Started 
+By Rick Anderson and Scott Hanselman 
+
+This tutorial will teach you the basics of building an ASP.NET MVC Web application using Microsoft Visual 
+
+Studio 11 Express Beta for Web, which is a free version of Microsoft Visual Studio. Before you start, make sure 
+
+you've installed the prerequisites listed below. You can install all of them by clicking the following link: Web 
+
+Platform Installer.  
+
+If you're using Visual Studio 11 Beta instead of Visual Studio 11 Express Beta for Web , install the prerequisites 
+
+by clicking the following link: Web Platform Installer 
+
+A Visual Web Developer project with C# source code is available to accompany this topic. Download the C# 
+
+version.  
+
+What You'll Build 
+
+You'll implement a simple movie-listing application that supports creating, editing, searching and listing movies 
+
+from a database. Below are two screenshots of the application you’ll build. It includes a page that displays a list 
+
+of movies from a database: 
+
+ 
+ 
+ 
+The application also lets you add, edit, and delete movies, as well as see details about individual ones. All data-
+
+entry scenarios include validation to ensure that the data stored in the database is correct. 
+
+ 
+Skills You'll Learn 
+
+Here's what you'll learn:  
+
+•  How to create a new ASP.NET MVC project.  
+
+ 
+•  How to create ASP.NET MVC controllers and views.  
+
+•  How to create a new database using the Entity Framework Code First paradigm.  
+
+•  How to retrieve and display data.  
+
+•  How to edit data and enable data validation.  
+
+Getting Started 
+
+Start by running Visual Web Developer 11 Express Beta("Visual Web Developer" or VWD for short) and select 
+
+New Project from the Start page. 
+
+Visual Web Developer is an IDE, or integrated development environment. Just like you use Microsoft Word to 
+
+write documents, you'll use an IDE to create applications. In Visual Web Developer there's a toolbar along the 
+
+top showing various options available to you. There's also a menu that provides another way to perform tasks 
+
+in the IDE. (For example, instead of selecting New Project from the Start page, you can use the menu and 
+
+select File>New Project.) 
+
+Creating Your First Application 
+
+You can create applications using either Visual Basic or Visual C# as the programming language. Select Visual 
+
+C# on the left and then select ASP.NET MVC 4 Web Application. Name your project "MvcMovie" and then 
+
+click OK.  
+
+ 
+In the New ASP.NET MVC 4 Project dialog box, select Internet Application. LeaveRazor as the default view 
+
+engine. 
+
+ 
+Click OK. Visual Web Developer used a default template for the ASP.NET MVC project you just created, so you 
+
+have a working application right now without doing anything! This is a simple "Hello World!" project, and it's a 
+
+good place to start your application. 
+
+ 
+From the Debug menu, select Start Debugging. 
+
+ 
+Notice that the keyboard shortcut to start debugging is F5. 
+
+ 
+F5 causes Visual Web Developer to start IIS Express and run your web application. Visual Web Developer then 
+
+launches a browser and opens the application's home page. Notice that the address bar of the browser says 
+
+localhost and not something like example.com. That's becauselocalhost always points to your own local 
+
+computer, which in this case is running the application you just built. When Visual Web Developer runs a web 
+
+project, a random port is used for the web server. In the image below, the port number is 41788. When you run 
+
+the application, you'll probably see a different port number. 
+
+Right out of the box this default template gives you Home, Contact and About pages. It also provides support 
+
+to register and log in, and links to Facebook and Twitter. The next step is to change how this application works 
+
+and learn a little bit about ASP.NET MVC. Close your browser and let's change some code. 
+
+ 
+ 
+ 
+Adding a Controller 
+
+MVC stands formodel-view-controller. MVC is a pattern for developing applications that are well 
+architected, testable and easy to maintain. MVC-based applications contain: 
+•  Models: Classes that represent the data of the application and that use validation logic to enforce 
+
+business rules for that data. 
+
+•  Views: Template files that your application uses to dynamically generate HTML responses. 
+
+•  Controllers: Classes that handle incoming browser requests, retrieve model data, and then specify 
+
+view templates that return a response to the browser. 
+
+We'll be covering all these concepts in this tutorial series and show you how to use them to build an 
+application. 
+
+Let's begin by creating a controller class. InSolution Explorer, right-click theControllersfolder and then 
+selectAdd Controller. 
+
+Name your new controller "HelloWorldController". Leave the default template asEmpty controllerand 
+clickAdd. 
+
+ 
+Notice inSolution Explorerthat a new file has been created namedHelloWorldController.cs. The file is 
+open in the IDE. 
+
+ 
+Replace the contents of the file with the following code.  
+
+usingSystem.Web; 
+usingSystem.Web.Mvc; 
+
+namespaceMvcMovie.Controllers 
+{ 
+publicclassHelloWorldController:Controller 
+{ 
+//  
+// GET: /HelloWorld/  
+
+ 
+ 
+publicstringIndex() 
+{ 
+return"This is my <b>default</b> action..."; 
+} 
+
+//  
+// GET: /HelloWorld/Welcome/  
+
+publicstringWelcome() 
+{ 
+return"This is the Welcome action method..."; 
+} 
+} 
+} 
+
+The controller methods will return a string of HTML as an example. The controller is 
+namedHelloWorldControllerand the first method above is namedIndex. Let’s invoke it from a browser. 
+Run the application (press F5 or Ctrl+F5). In the browser, append "HelloWorld" to the path in the address 
+bar. (For example, in the illustration below, it'shttp://localhost:1234/HelloWorld.) The page in the browser 
+will look like the following screenshot. In the method above, the code returned a string directly. You told 
+the system to just return some HTML, and it did!  
+
+ASP.NET MVC invokes different controller classes (and different action methods within them) depending 
+on the incoming URL. The default URL routing logic used by ASP.NET MVC uses a format like this to 
+determine what code to invoke: 
+
+/[Controller]/[ActionName]/[Parameters] 
+The first part of the URL determines the controller class to execute. So/HelloWorldmaps to the 
+HelloWorldControllerclass. The second part of the URL determines the action method on the class to 
+
+ 
+ 
+ 
+ 
+execute. So/HelloWorld/Indexwould cause theIndexmethod of theHelloWorldControllerclass to 
+execute. Notice that we only had to browse to/HelloWorldand theIndexmethod was used by default. This 
+is because a method named Indexis the default method that will be called on a controller if one is not 
+explicitly specified. 
+Browse tohttp://localhost:xxxx/HelloWorld/Welcome. TheWelcomemethod runs and returns the string "This 
+is the Welcome action method...". The default MVC mapping 
+is/[Controller]/[ActionName]/[Parameters]. For this URL, the controller 
+isHelloWorldandWelcomeis the action method. You haven't used the[Parameters]part of the URL yet. 
+
+Let's modify the example slightly so that you can pass some parameter information from the URL to the 
+controller (for example,/HelloWorld/Welcome?name=Scott&numtimes=4). Change yourWelcomemethod 
+to include two parameters as shown below. Note that the code uses the C# optional-parameter feature to 
+indicate that the numTimesparameter should default to 1 if no value is passed for that parameter. 
+
+publicstringWelcome(string name,int numTimes =1){ 
+returnHttpUtility.HtmlEncode("Hello "+ name +", NumTimes is: "+ numTimes); 
+} 
+
+Run your application and browse to the example URL 
+(http://localhost:xxxx/HelloWorld/Welcome?name=Scott&numtimes=4). You can try different values 
+fornameandnumtimesin the URL. The ASP.NET MVC model binding system automatically maps the named 
+parameters from the query string in the address bar to parameters in your method. 
+
+ 
+In both these examples the controller has been doing the "VC" portion of MVC — that is, the view and 
+controller work. The controller is returning HTML directly. Ordinarily you don't want controllers returning 
+HTML directly, since that becomes very cumbersome to code. Instead we'll typically use a separate view 
+template file to help generate the HTML response. Let's look next at how we can do this. 
+
+ 
+ 
+ 
+Adding a View 
+
+In this section you're going to modify the HelloWorldController class to use view template files to cleanly 
+
+encapsulate the process of generating HTML responses to a client. 
+
+You'll create a view template file using theRazor view engine introduced with ASP.NET MVC 3. Razor-based 
+
+view templates have a .cshtml file extension, and provide an elegant way to create HTML output using C#. Razor 
+
+minimizes the number of characters and keystrokes required when writing a view template, and enables a fast, 
+
+fluid coding workflow. 
+
+Start by creating a view template with the Index method in theHelloWorldController class. Currently the 
+
+Index method returns a string with a message that is hard-coded in the controller class. Change the Index 
+
+method to return a View object, as shown in the following code: 
+
+publicActionResultIndex() 
+
+{ 
+
+returnView(); 
+
+} 
+
+The Index method above uses a view template to generate an HTML response to the browser. Controller 
+
+methods (also known asaction methods), such as the Index method above, generally return anActionResult (or a 
+
+class derrived fromActionResult), not primitive types like string.  
+
+In the project, add a view template that you can use with the Index method. To do this, right-click inside the 
+
+Index method and clickAdd View. 
+
+ 
+The Add View dialog box appears. Leave the defaults the way they are and click the Add button: 
+
+The MvcMovie\Views\HelloWorld folder and the MvcMovie\Views\HelloWorld\Index.cshtml file are created. You 
+
+can see them in Solution Explorer: 
+
+ 
+The following shows the Index.cshtml file that was created: 
+
+ 
+Add the following HTML under the <h2> tag. 
+
+<p>Hello from our View Template!</p> 
+
+The complete MvcMovie\Views\HelloWorld\Index.cshtml file is shown below. 
+
+@{  
+
+    ViewBag.Title = "Index";  
+
+}  
+
+ 
+<h2>Index</h2> 
+
+<p>Hello from our View Template!</p> 
+
+In solution explorer, right click the Index.cshtml file and selectView in Page Inspector. 
+
+ThePage Inspector tutorial has more information about this new tool. 
+
+ 
+ 
+ 
+Alternatively, run the application and browse to the HelloWorld controller (http://localhost:xxxx/HelloWorld). 
+
+The Index method in your controller didn't do much work; it simply ran the statement return View(), which 
+
+specified that the method should use a view template file to render a response to the browser. Because you 
+
+didn't explicitly specify the name of the view template file to use, ASP.NET MVC defaulted to using the 
+
+Index.cshtml view file in the \Views\HelloWorld folder. The image below shows the string hard-coded in the 
+
+view. 
+
+Looks pretty good. However, notice that the browser's title bar shows "Index My ASP.NET A" and the big link on 
+
+the top of the page says "your logo here." Below the "your logo here." link are registration and log in links, and 
+
+below that links to Home, About and Contact pages. Let's change some of these. 
+
+Changing Views and Layout Pages 
+
+First, you want to change the "your logo here." title at the top of the page. That text is common to every page. 
+
+It's actually implemented in only one place in the project, even though it appears on every page in the 
+
+application. Go to the /Views/Shared folder in Solution Explorer and open the _Layout.cshtml file. This file is 
+
+called a layout page and it's the shared "shell" that all other pages use. 
+
+ 
+ 
+Layout templates allow you to specify the HTML container layout of your site in one place and then apply it 
+
+across multiple pages in your site. Find the@RenderBody() line. RenderBody is a placeholder where all the 
+
+view-specific pages you create show up, "wrapped" in the layout page. For example, if you select the About link, 
+
+the Views\Home\About.cshtml view is rendered inside the RenderBody method. 
+
+Change the site-title heading in the layout template from "your logo here" to "MVC Movie". 
+
+<divclass="float-left"> 
+
+<pclass="site-title">@Html.ActionLink("MVC Movie", "Index", "Home")</p> 
+
+</div> 
+
+Replace the contents of the title element with the following markup: 
+
+<title>@ViewBag.Title - Movie App</title> 
+
+The ViewBag is a zzz (dict object) Run the application and notice that it now says "MVC Movie ". Click theAbout 
+
+link, and you see how that page shows "MVC Movie", too. We were able to make the change once in the layout 
+
+template and have all pages on the site reflect the new title. 
+
+The complete _Layout.cshtml file is shown below: 
+
+<!DOCTYPE html> 
+
+<htmllang="en"> 
+
+<head> 
+
+<metacharset="utf-8"/> 
+
+<title>@ViewBag.Title - Movie App</title> 
+
+<linkhref="~/favicon.ico"rel="shortcut icon"type="image/x-icon"/> 
+
+<linkhref="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Content/c
+
+ss")"rel="stylesheet"type="text/css"/> 
+
+<linkhref="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Content/t
+
+hemes/base/css")"rel="stylesheet"type="text/css"/> 
+
+<scriptsrc="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Scripts/
+
+js")"></script> 
+
+<metaname="viewport"content="width=device-width"/> 
+
+</head> 
+
+ 
+<body> 
+
+<header> 
+
+<divclass="content-wrapper"> 
+
+<divclass="float-left"> 
+
+<pclass="site-title">@Html.ActionLink("MVC Movie", "Index", "Home")</p> 
+
+</div> 
+
+<divclass="float-right"> 
+
+<sectionid="login"> 
+
+@Html.Partial("_LoginPartial")  
+
+</section> 
+
+<nav> 
+
+<ulid="menu"> 
+
+<li>@Html.ActionLink("Home", "Index", "Home")</li> 
+
+<li>@Html.ActionLink("About", "About", "Home")</li> 
+
+<li>@Html.ActionLink("Contact", "Contact", "Home")</li> 
+
+</ul> 
+
+</nav> 
+
+</div> 
+
+</div> 
+
+</header> 
+
+<divid="body"> 
+
+@RenderSection("featured", required: false)  
+
+<sectionclass="content-wrapper main-content clear-fix"> 
+
+@RenderBody() 
+
+</section> 
+
+</div> 
+
+<footer> 
+
+<divclass="content-wrapper"> 
+
+<divclass="float-left"> 
+
+<p>&copy; @DateTime.Now.Year - My ASP.NET MVC Application</p> 
+
+</div> 
+
+<divclass="float-right"> 
+
+<ulid="social"> 
+
+<li><ahref="http://facebook.com"class="facebook">Facebook</a></li> 
+
+<li><ahref="http://twitter.com"class="twitter">Twitter</a></li> 
+
+</ul> 
+
+</div> 
+
+</div> 
+
+</footer> 
+
+</body> 
+
+</html> 
+
+Now, let's change the title of the Index view. 
+
+Open MvcMovie\Views\HelloWorld\Index.cshtml. There are two places to make a change: first, the text that 
+
+appears in the title of the browser, and then in the secondary header (the <h2> element). You'll make them 
+
+slightly different so you can see which bit of code changes which part of the app. 
+
+@{  
+
+    ViewBag.Title = "Movie List";  
+
+}  
+
+<h2>My Movie List</h2> 
+
+<p>Hello from our View Template!</p> 
+
+To indicate the HTML title to display, the code above sets a Title property of the ViewBag object (which is in 
+
+the Index.cshtml view template). If you look back at the source code of the layout template, you’ll notice that 
+
+the template uses this value in the <title> element as part of the <head> section of the HTML that we 
+
+modified previously. Using this ViewBag approach, you can easily pass other parameters between your view 
+
+template and your layout file. 
+
+Run the application and browse to http://localhost:xx/HelloWorld. Notice that the browser title, the primary 
+
+heading, and the secondary headings have changed. (If you don't see changes in the browser, you might be 
+
+viewing cached content. Press Ctrl+F5 in your browser to force the response from the server to be loaded.) The 
+
+browser title is created with the ViewBag.Title we set in the Index.cshtml view template and the additional "- 
+
+Movie App" added in the layout file. 
+
+Also notice how the content in the Index.cshtml view template was merged with the _Layout.cshtml view 
+
+template and a single HTML response was sent to the browser. Layout templates make it really easy to make 
+
+changes that apply across all of the pages in your application. 
+
+ 
+ 
+Our little bit of "data" (in this case the "Hello from our View Template!" message) is hard-coded, though. The 
+
+MVC application has a "V" (view) and you've got a "C" (controller), but no "M" (model) yet. Shortly, we'll walk 
+
+through how create a database and retrieve model data from it. 
+
+Passing Data from the Controller to the View 
+
+Before we go to a database and talk about models, though, let's first talk about passing information from the 
+
+controller to a view. Controller classes are invoked in response to an incoming URL request. A controller class is 
+
+where you write the code that handles the incoming browser requests, retrieves data from a database, and 
+
+ultimately decides what type of response to send back to the browser. View templates can then be used from a 
+
+controller to generate and format an HTML response to the browser. 
+
+Controllers are responsible for providing whatever data or objects are required in order for a view template to 
+
+render a response to the browser. A best practice: A view template should never perform business logic or 
+
+interact with a database directly. Instead, a view template should work only with the data that's provided to it 
+
+by the controller. Maintaining this "separation of concerns" helps keep your code clean, testable and more 
+
+maintainable. 
+
+ 
+Currently, the Welcome action method in the HelloWorldController class takes a name and a numTimes 
+
+parameter and then outputs the values directly to the browser. Rather than have the controller render this 
+
+response as a string, let’s change the controller to use a view template instead. The view template will generate 
+
+a dynamic response, which means that you need to pass appropriate bits of data from the controller to the view 
+
+in order to generate the response. You can do this by having the controller put the dynamic data (parameters) 
+
+that the view template needs in a ViewBag object that the view template can then access. 
+
+Return to the HelloWorldController.cs file and change the Welcome method to add a Message and NumTimes 
+
+value to the ViewBag object. ViewBag is a dynamic object, which means you can put whatever you want in to 
+
+it; the ViewBag object has no defined properties until you put something inside it. TheASP.NET MVC model 
+
+binding system automatically maps the named parameters (nameand numTimes) from the query string in the 
+
+address bar to parameters in your method. The completeHelloWorldController.cs file looks like this: 
+
+usingSystem.Web; 
+
+usingSystem.Web.Mvc; 
+
+namespaceMvcMovie.Controllers 
+
+{ 
+
+publicclassHelloWorldController:Controller 
+
+{ 
+
+publicActionResultIndex() 
+
+{ 
+
+returnView(); 
+
+} 
+
+publicActionResultWelcome(string name,int numTimes =1) 
+
+{ 
+
+ViewBag.Message="Hello "+ name; 
+
+ViewBag.NumTimes= numTimes; 
+
+returnView(); 
+
+} 
+
+} 
+
+} 
+
+Now the ViewBag object contains data that will be passed to the view automatically. 
+
+ 
+ 
+ 
+Next, you need a Welcome view template! In the Build menu, select Build MvcMovie to make sure the project 
+
+is compiled. 
+
+Then right-click inside the Welcome method and click Add View. 
+
+ 
+ 
+Here's what the Add View dialog box looks like: 
+
+Click Add, and then add the following code under the < h2> element in the new Welcome.cshtml file. You'll 
+
+create a loop that says "Hello" as many times as the user says it should. The completeWelcome.cshtml file is 
+
+shown below. 
+
+@{  
+
+    ViewBag.Title = "Welcome";  
+
+}  
+
+<h2>Welcome</h2> 
+
+<ul> 
+
+ 
+ 
+ 
+   @for (int i=0; i < ViewBag.NumTimes; i++) {   
+
+<li>@ViewBag.Message</li> 
+
+   }   
+
+</ul> 
+
+Run the application and browse to the following URL: 
+
+http://localhost:xx/HelloWorld/Welcome?name=Scott&numtimes=4 
+
+Now data is taken from the URL and passed to the controller using themodel binder. The controller packages 
+
+the data into a ViewBag object and passes that object to the view. The view then displays the data as HTML to 
+
+the user. 
+
+Well, that was a kind of an "M" for model, but not the database kind. Let's take what we've learned and create a 
+
+database of movies. 
+
+ 
+ 
+ 
+Adding a Model 
+
+In this section you'll add some classes for managing movies in a database. These classes will be the "model" 
+
+part of the ASP.NET MVC application. 
+
+You’ll use a .NET Framework data-access technology known as the Entity Framework to define and work with 
+
+these model classes. The Entity Framework (often referred to as EF) supports a development paradigm called 
+
+Code First. Code First allows you to create model objects by writing simple classes. (These are also known as 
+
+POCO classes, from "plain-old CLR objects.") You can then have the database created on the fly from your 
+
+classes, which enables a very clean and rapid development workflow.  
+
+Adding Model Classes 
+
+In Solution Explorer, right click the Models folder, select Add, and then select New Item. 
+
+ 
+In the Add New Item dialog, select Class then name the class "Movie". 
+
+ 
+Add the following five properties to the Movie class: 
+
+publicclassMovie 
+
+{ 
+
+publicint ID {get;set;} 
+
+publicstringTitle{get;set;} 
+
+publicDateTimeReleaseDate{get;set;} 
+
+publicstringGenre{get;set;} 
+
+publicdecimalPrice{get;set;} 
+
+ 
+} 
+
+We'll use the Movie class to represent movies in a database. Each instance of a Movie object will correspond to 
+
+a row within a database table, and each property of the Movie class will map to a column in the table.  
+
+In the same file, add the following MovieDBContext class: 
+
+publicclassMovieDBContext:DbContext 
+
+{ 
+
+publicDbSet<Movie>Movies{get;set;} 
+
+} 
+
+The MovieDBContext class represents the Entity Framework movie database context, which handles fetching, 
+
+storing, and updating Movie class instances in a database. The MovieDBContext derives from theDbContext 
+
+base class provided by the Entity Framework. For more information about DbContext and DbSet, 
+
+seeProductivity Improvements for the Entity Framework.  
+
+In order to be able to reference DbContext and DbSet, you need to add the following using statement at the 
+
+top of the file: 
+
+usingSystem.Data.Entity; 
+
+The complete Movie.cs file is shown below. (Several using statements that are not needed have been removed.) 
+
+usingSystem; 
+
+usingSystem.Data.Entity; 
+
+namespaceMvcMovie.Models 
+
+{ 
+
+publicclassMovie 
+
+{ 
+
+publicint ID {get;set;} 
+
+publicstringTitle{get;set;} 
+
+publicDateTimeReleaseDate{get;set;} 
+
+publicstringGenre{get;set;} 
+
+publicdecimalPrice{get;set;} 
+
+ 
+} 
+
+publicclassMovieDBContext:DbContext 
+
+{ 
+
+publicDbSet<Movie>Movies{get;set;} 
+
+} 
+
+} 
+
+Creating a Connection String and Working with SQL Server LocalDB 
+
+The MovieDBContext class you created handles the task of connecting to the database and mapping Movie 
+
+objects to database records. One question you might ask, though, is how to specify which database it will 
+
+connect to. You'll do that by adding connection information in the Web.config file of the application. 
+
+Open the application root Web.config file. (Not the Web.configfile in the Views folder.) Open the Web.config file 
+
+outlined in red. 
+
+Add the following connection string to the <connectionStrings> element in the Web.config file. 
+
+<addname="MovieDBContext" 
+
+ 
+ 
+connectionString="Data 
+
+Source=(LocalDB)\v11.0;AttachDbFilename=|DataDirectory|\Movies.mdf;Integrated 
+
+Security=True" 
+
+providerName="System.Data.SqlClient" 
+
+/> 
+
+The following example shows a portion of the Web.config file with the new connection string added:  
+
+<connectionStrings> 
+
+<addname="DefaultConnection" 
+
+connectionString="Data Source=(LocalDb)\v11.0;Initial Catalog=aspnet-MvcMovie-
+
+2012213181139;Integrated Security=true" 
+
+providerName="System.Data.SqlClient" 
+
+/> 
+
+<addname="MovieDBContext" 
+
+connectionString="Data 
+
+Source=(LocalDB)\v11.0;AttachDbFilename=|DataDirectory|\Movies.mdf;Integrated 
+
+Security=True" 
+
+providerName="System.Data.SqlClient" 
+
+/> 
+
+</connectionStrings> 
+
+This small amount of code and XML is everything you need to write in order to represent and store the movie 
+
+data in a database.  
+
+Next, you'll build a new MoviesController class that you can use to display the movie data and allow users 
+
+to create new movie listings. 
+
+ 
+ 
+Accessing Your Model's Data from a Controller 
+
+In this section, you'll create a new MoviesController class and write code that retrieves the movie data and 
+
+displays it in the browser using a view template.  
+
+Build the application before going on to the next step. 
+
+Right-click the Controllers folder and create a new MoviesController controller. The options below will not 
+
+appear until you build your application. Select the following options: 
+
+•  Controller name: MoviesController. (This is the default. ) 
+
+• 
+
+Template: Controller with read/write actions and views, using Entity Framework.  
+
+•  Model class: Movie (MvcMovie.Models).  
+
+•  Data context class: MovieDBContext (MvcMovie.Models).  
+
+•  Views: Razor (CSHTML). (The default.)  
+
+Click Add. Visual Studio Express creates the following files and folders: 
+
+•  A MoviesController.csfile in the project's Controllers folder.  
+
+ 
+•  A Movies folder in the project's Views folder.  
+
+•  Create.cshtml, Delete.cshtml, Details.cshtml, Edit.cshtml, and Index.cshtml in the new Views\Movies folder.  
+
+ 
+ASP.NET MVC 4 automatically created the CRUD (create, read, update, and delete) action methods and views 
+
+for you (the automatic creation of CRUD action methods and views is known as scaffolding). You now have a 
+
+fully functional web application that lets you create, list, edit, and delete movie entries. 
+
+Run the application and browse to the Movies controller by appending /Movies to the URL in the address bar 
+
+of your browser. Because the application is relying on the default routing (defined in the Global.asax file), the 
+
+browser request http://localhost:xxxxx/Movies is routed to the default Index action method of the Movies 
+
+controller. In other words, the browser request http://localhost:xxxxx/Movies is effectively the same as the 
+
+browser request http://localhost:xxxxx/Movies/Index. The result is an empty list of movies, because you haven't 
+
+added any yet. 
+
+Creating a Movie 
+
+Select the Create New link. Enter some details about a movie and then click the Create button. 
+
+ 
+Clicking the Create button causes the form to be posted to the server, where the movie information is saved in 
+
+the database. You're then redirected to the /Movies URL, where you can see the newly created movie in the 
+
+listing. 
+
+ 
+Create a couple more movie entries. Try the Edit, Details, and Delete links, which are all functional. 
+
+Examining the Generated Code 
+
+Open the Controllers\MoviesController.cs file and examine the generated Index method. A portion of the movie 
+
+controller with theIndex method is shown below. 
+
+publicclassMoviesController:Controller 
+
+{ 
+
+privateMovieDBContext db =newMovieDBContext(); 
+
+// 
+
+// GET: /Movies/ 
+
+publicActionResultIndex() 
+
+{ 
+
+returnView(db.Movies.ToList()); 
+
+ 
+ 
+ 
+} 
+
+The following line from the MoviesController class instantiates a movie database context, as described 
+
+previously. You can use the movie database context to query, edit, and delete movies. 
+
+privateMovieDBContext db =newMovieDBContext(); 
+
+A request to the Movies controller returns all the entries in the Movies table of the movie database and then 
+
+passes the results to the Index view. 
+
+Strongly Typed Models and the @model Keyword 
+
+Earlier in this tutorial, you saw how a controller can pass data or objects to a view template using the ViewBag 
+
+object. The ViewBag is a dynamic object that provides a convenient late-bound way to pass information to a 
+
+view. 
+
+ASP.NET MVC also provides the ability to pass strongly typed data or objects to a view template. This strongly 
+
+typed approach enables better compile-time checking of your code and richer IntelliSense in the Visual Studio 
+
+Express editor. The scaffolding mechanism in Visual Studio Express used this approach with the 
+
+MoviesController class and view templates when it created the methods and views. 
+
+In the Controllers\MoviesController.cs file examine the generated Details method. A portion of the movie 
+
+controller with theDetails method is shown below. 
+
+publicActionResultDetails(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+An instance of the Movie model is passed to the Details view. 
+
+By including a @model statement at the top of the view template file, you can specify the type of object that the 
+
+view expects. When you created the movie controller, Visual Studio Express automatically included the 
+
+following@model statement at the top of the Details.cshtml file: 
+
+@model MvcMovie.Models.Movie 
+
+This @model directive allows you to access the movie that the controller passed to the view by using a Model 
+
+object that's strongly typed. For example, in the Details.cshtml template, the code passes each movie field to 
+
+the DisplayNameFor and DisplayFor HTML Helpers with the strongly typed Model object. The Create and Edit 
+
+methods and view templates also pass a movie model object. 
+
+Examine the Index.cshtml view template and the Index method in the MoviesController.cs file. Notice how the 
+
+code creates aList object when it calls the View helper method in the Index action method. The code then 
+
+passes this Movies list from the controller to the view: 
+
+publicActionResultIndex() 
+
+{ 
+
+returnView(db.Movies.ToList()); 
+
+} 
+
+When you created the movie controller, Visual Studio Express automatically included the following@model 
+
+statement at the top of the Index.cshtml file: 
+
+@model IEnumerable<MvcMovie.Models.Movie> 
+
+This @model directive allows you to access the list of movies that the controller passed to the view by using a 
+
+Model object that's strongly typed. For example, in the Index.cshtml template, the code loops through the 
+
+movies by doing a foreach statement over the strongly typed Model object: 
+
+@foreach (var item in Model) {  
+
+<tr> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Title)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.ReleaseDate)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Genre)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Price)  
+
+</td> 
+
+<th> 
+
+@Html.DisplayFor(modelItem => item.Rating)  
+
+</th> 
+
+<td> 
+
+@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |  
+
+@Html.ActionLink("Details", "Details", { id=item.ID })  |  
+
+@Html.ActionLink("Delete", "Delete", { id=item.ID })   
+
+</td> 
+
+</tr> 
+
+} 
+
+Because the Model object is strongly typed (as an IEnumerable<Movie> object), each item object in the loop 
+
+is typed as Movie. Among other benefits, this means that you get compile-time checking of the code and full 
+
+IntelliSense support in the code editor: 
+
+ 
+Working with SQL Server LocalDB 
+
+Entity Framework Code First detected that the database connection string that was provided pointed to a 
+
+Movies database that didn’t exist yet, so Code First created the database automatically. You can verify that it's 
+
+been created by looking in the App_Data folder. If you don't see the Movies.sdf file, click the Show All Files 
+
+button in theSolution Explorer toolbar, click the Refresh button, and then expand the App_Data folder. 
+
+ 
+Double-click Movies.mdf to open DATABASE EXPLORER. Then expand the Tables folder to see the tables that 
+
+have been created in the database. 
+
+ 
+ 
+There are two tables, one for the Movie entity set and theEdmMetadata table. The EdmMetadata table is used 
+
+by the Entity Framework to determine when the model and the database are out of sync.  
+
+Right-click the Movies table and select Show Table Data to see the data you created. 
+
+Right-click the Movies table and select Open Table Definition to see the table structure that Entity Framework 
+
+Code First created for you. 
+
+ 
+ 
+Notice how the schema of the Movies table maps to the Movie class you created earlier. Entity Framework 
+
+Code First automatically created this schema for you based on your Movie class. 
+
+When you're finished, close the connection by right clicking Movies.mdf and selecting Close Connection. (If you 
+
+don't close the connection, you might get an error the next time you run the project).  
+
+ 
+You now have the database and a simple listing page to display content from it. In the next tutorial, we'll 
+
+examine the rest of the scaffolded code and add a SearchIndex method and a SearchIndex view that lets 
+
+you search for movies in this database. 
+
+ 
+ 
+ 
+Examining the Edit Methods and Edit View 
+
+In this section, you'll examine the generated action methods and views for the movie controller. Then you'll add 
+
+a custom search page. 
+
+Run the application and browse to the Movies controller by appending /Movies to the URL in the address bar 
+
+of your browser. Hold the mouse pointer over an Edit link to see the URL that it links to. 
+
+The Edit link was generated by the Html.ActionLink method in the Views\Movies\Index.cshtml view: 
+
+@Html.ActionLink("Edit", "Edit", new { id=item.ID })  
+
+ 
+The Html object is a helper that's exposed using a property on the System.Web.Mvc.WebViewPage base class. 
+
+The ActionLinkmethod of the helper makes it easy to dynamically generate HTML hyperlinks that link to 
+
+action methods on controllers. The first argument to the ActionLink method is the link text to render (for 
+
+example,<a>Edit Me</a>). The second argument is the name of the action method to invoke. The final 
+
+argument is ananonymous object that generates the route data (in this case, the ID of 4). 
+
+The generated link shown in the previous image is http://localhost:xxxxx/Movies/Edit/4. The default route 
+
+(established in Global.asax.cs) takes the URL pattern {controller}/{action}/{id}. Therefore, ASP.NET 
+
+translateshttp://localhost:xxxxx/Movies/Edit/4 into a request to the Edit action method of the Movies 
+
+controller with the parameter ID equal to 4.  
+
+You can also pass action method parameters using a query string. For example, the URL 
+
+http://localhost:xxxxx/Movies/Edit?ID=4 also passes the parameter ID of 4 to the Edit action method of 
+
+theMovies controller. 
+
+ 
+Open the Movies controller. The two Edit action methods are shown below. 
+
+// 
+
+// GET: /Movies/Edit/5 
+
+publicActionResultEdit(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+ 
+ 
+returnView(movie); 
+
+} 
+
+// 
+
+// POST: /Movies/Edit/5 
+
+[HttpPost] 
+
+publicActionResultEdit(Movie movie) 
+
+{ 
+
+if(ModelState.IsValid) 
+
+{ 
+
+db.Entry(movie).State=EntityState.Modified; 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+Notice the second Edit action method is preceded by the HttpPost attribute. This attribute specifies that that 
+
+overload of the Edit method can be invoked only for POST requests. You could apply the HttpGet attribute to 
+
+the first edit method, but that's not necessary because it's the default. (We'll refer to action methods that are 
+
+implicitly assigned the HttpGet attribute as HttpGet methods.) 
+
+The HttpGetEdit method takes the movie ID parameter, looks up the movie using the Entity Framework Find 
+
+method, and returns the selected movie to the Edit view. The ID parameter specifies a default value of zero if 
+
+the Edit method is called without a parameter. If a movie cannot be found, HttpNotFound is returned. When 
+
+the scaffolding system created the Edit view, it examined the Movie class and created code to render <label> 
+
+and <input> elements for each property of the class. The following example shows the Edit view that was 
+
+generated: 
+
+@model MvcMovie.Models.Movie  
+
+@{  
+
+    ViewBag.Title = "Edit";  
+
+}  
+
+<h2>Edit</h2> 
+
+ 
+ 
+ 
+ 
+<scriptsrc="@Url.Content("~/Scripts/jquery.validate.min.js")"type="text/javascript"><
+
+/script> 
+
+<scriptsrc="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")"type="text/j
+
+avascript"></script> 
+
+@using (Html.BeginForm()) {  
+
+@Html.ValidationSummary(true)  
+
+<fieldset> 
+
+<legend>Movie</legend> 
+
+@Html.HiddenFor(model => model.ID)  
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Title)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Title)  
+
+@Html.ValidationMessageFor(model => model.Title)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.ReleaseDate)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.ReleaseDate)  
+
+@Html.ValidationMessageFor(model => model.ReleaseDate)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Genre)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Genre)  
+
+@Html.ValidationMessageFor(model => model.Genre)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+@Html.LabelFor(model => model.Price)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Price)  
+
+@Html.ValidationMessageFor(model => model.Price)  
+
+</div> 
+
+<p> 
+
+<inputtype="submit"value="Save"/> 
+
+</p> 
+
+</fieldset> 
+
+}  
+
+<div> 
+
+@Html.ActionLink("Back to List", "Index")  
+
+</div> 
+
+Notice how the view template has a @model MvcMovie.Models.Movie statement at the top of the file — this 
+
+specifies that the view expects the model for the view template to be of type Movie. 
+
+The scaffolded code uses several helper methods to streamline the HTML markup. TheHtml.LabelFor helper 
+
+displays the name of the field ("Title", "ReleaseDate", "Genre", or "Price"). TheHtml.EditorFor helper renders 
+
+an HTML <input> element. TheHtml.ValidationMessageFor helper displays any validation messages 
+
+associated with that property.  
+
+Run the application and navigate to the /Movies URL. Click anEdit link. In the browser, view the source for the 
+
+page. The HTML for the form element is shown below. 
+
+<formaction="/Movies/Edit/4"method="post"><fieldset> 
+
+<legend>Movie</legend> 
+
+<inputdata-val="true"data-val-number="The field ID must be a number."data-val-
+
+required="The ID field is required."id="ID"name="ID"type="hidden"value="4"/> 
+
+<divclass="editor-label"> 
+
+<labelfor="Title">Title</label> 
+
+</div> 
+
+ 
+ 
+ 
+ 
+<divclass="editor-field"> 
+
+<inputclass="text-box single-line"id="Title"name="Title"type="text"value="Rio 
+
+Bravo"/> 
+
+<spanclass="field-validation-valid"data-valmsg-for="Title"data-valmsg-
+
+replace="true"></span> 
+
+</div> 
+
+<divclass="editor-label"> 
+
+<labelfor="ReleaseDate">ReleaseDate</label> 
+
+</div> 
+
+<divclass="editor-field"> 
+
+<inputclass="text-box single-line"data-val="true"data-val-date="The field ReleaseDate 
+
+must be a date."data-val-required="The ReleaseDate field is 
+
+required."id="ReleaseDate"name="ReleaseDate"type="text"value="4/15/1959 12:00:00 
+
+AM"/> 
+
+<spanclass="field-validation-valid"data-valmsg-for="ReleaseDate"data-valmsg-
+
+replace="true"></span> 
+
+</div> 
+
+<divclass="editor-label"> 
+
+<labelfor="Genre">Genre</label> 
+
+</div> 
+
+<divclass="editor-field"> 
+
+<inputclass="text-box single-line"id="Genre"name="Genre"type="text"value="Western"/> 
+
+<spanclass="field-validation-valid"data-valmsg-for="Genre"data-valmsg-
+
+replace="true"></span> 
+
+</div> 
+
+<divclass="editor-label"> 
+
+<labelfor="Price">Price</label> 
+
+</div> 
+
+<divclass="editor-field"> 
+
+<inputclass="text-box single-line"data-val="true"data-val-number="The field Price 
+
+must be a number."data-val-required="The Price field is 
+
+required."id="Price"name="Price"type="text"value="2.99"/> 
+
+<spanclass="field-validation-valid"data-valmsg-for="Price"data-valmsg-
+
+replace="true"></span> 
+
+</div> 
+
+ 
+ 
+ 
+<p> 
+
+<inputtype="submit"value="Save"/> 
+
+</p> 
+
+</fieldset> 
+
+</form> 
+
+The <input> elements are in an HTML <form> element whose action attribute is set to post to the 
+
+/Movies/Edit URL. The form data will be posted to the server when the Edit button is clicked. 
+
+Processing the POST Request 
+
+The following listing shows the HttpPost version of the Edit action method. 
+
+[HttpPost] 
+
+publicActionResultEdit(Movie movie) 
+
+{ 
+
+if(ModelState.IsValid) 
+
+{ 
+
+db.Entry(movie).State=EntityState.Modified; 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+The ASP.NET MVC model binder takes the posted form values and creates aMovie object that's passed as the 
+
+movie parameter. TheModelState.IsValid method verifies that the data submitted in the form can be used 
+
+to modify (edit or update) a Movie object. If the data is valid, the movie data is saved to the Movies collection 
+
+of the db (MovieDBContext instance). The new movie data is saved to the database by calling the 
+
+SaveChanges method ofMovieDBContext. After saving the data, the code redirects the user to the Index 
+
+action method of the MoviesController class, which displays the of movie collection, including the changes 
+
+just made.. 
+
+If the posted values aren't valid, they are redisplayed in the form. TheHtml.ValidationMessageFor helpers 
+
+in the Edit.cshtml view template take care of displaying appropriate error messages. 
+
+ 
+Note about locales If you normally work with a locale other than English, see Supporting ASP.NET MVC 
+
+Validation with Non-English Locales. The decimal field may require a common, not a decimal point. As a 
+
+temporary fix, you can add the globalization element to the projects root web.config file. The following code 
+
+shows the globalization element with the culture set to United States English. 
+
+ 
+<system.web> 
+
+<globalizationculture="en-US"/> 
+
+<!--elements removed for clarity--> 
+
+</system.web> 
+
+All the HttpGet methods follow a similar pattern. They get a movie object (or list of objects, in the case of 
+
+Index), and pass the model to the view. The Create method passes an empty movie object to the Create view. 
+
+All the methods that create, edit, delete, or otherwise modify data do so in the HttpPost overload of the 
+
+method. Modifying data in an HTTP GET method is a security risk, as described in the blog post entryASP.NET 
+
+MVC Tip #46 – Don’t use Delete Links because they create Security Holes. Modifying data in a GET method also 
+
+violates HTTP best practices and the architectural REST pattern, which specifies that GET requests should not 
+
+change the state of your application. In other words, performing a GET operation should be a safe operation 
+
+that has no side effects and doesn't modify your persisted data. 
+
+Adding a Search Method and Search View 
+
+In this section you'll add a SearchIndex action method that lets you search movies by genre or name. This will 
+
+be available using the /Movies/SearchIndex URL. The request will display an HTML form that contains input 
+
+elements that a user can enter in order to search for a movie. When a user submits the form, the action method 
+
+will get the search values posted by the user and use the values to search the database. 
+
+Displaying the SearchIndex Form 
+
+Start by adding a SearchIndex action method to the existingMoviesController class. The method will 
+
+return a view that contains an HTML form. Here's the code: 
+
+publicActionResultSearchIndex(string searchString) 
+
+{ 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+ 
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+returnView(movies); 
+
+} 
+
+The first line of the SearchIndex method creates the followingLINQ query to select the movies:  
+
+var movies =from m in db.Movies 
+
+select m; 
+
+The query is defined at this point, but hasn't yet been run against the data store. 
+
+If the searchString parameter contains a string, the movies query is modified to filter on the value of the 
+
+search string, using the following code: 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+The s => s.Title code above is aLambda Expression. Lambdas are used in method-basedLINQ queries as 
+
+arguments to standard query operator methods such asWhere method used in the above code. LINQ queries 
+
+are not executed when they are defined or when they are modified by calling a method such as Where or 
+
+OrderBy. Instead, query execution is deferred, which means that the evaluation of an expression is delayed 
+
+until its realized value is actually iterated over or theToList method is called. In the SearchIndex sample, the 
+
+query is executed in the SearchIndex view. For more information about deferred query execution, see Query 
+
+Execution. 
+
+Now you can implement the SearchIndex view that will display the form to the user. Right-click inside the 
+
+SearchIndex method and then click Add View. In the Add View dialog box, specify that you're going to pass 
+
+a Movie object to the view template as its model class. In the Scaffold template list, choose List, then click 
+
+Add. 
+
+ 
+When you click the Add button, the Views\Movies\SearchIndex.cshtml view template is created. Because you 
+
+selected List in the Scaffold template list, Visual Studio Express automatically generated (scaffolded) some 
+
+default markup in the view. The scaffolding created an HTML form. It examined the Movie class and created 
+
+code to render <label> elements for each property of the class. The listing below shows the Create view that 
+
+was generated: 
+
+@model IEnumerable<MvcMovie.Models.Movie> 
+
+@{  
+
+    ViewBag.Title = "SearchIndex";  
+
+}  
+
+<h2>SearchIndex</h2> 
+
+ 
+ 
+ 
+ 
+<p> 
+
+@Html.ActionLink("Create New", "Create")  
+
+</p> 
+
+<table> 
+
+<tr> 
+
+<th> 
+
+            Title  
+
+</th> 
+
+<th> 
+
+            ReleaseDate  
+
+</th> 
+
+<th> 
+
+            Genre  
+
+</th> 
+
+<th> 
+
+            Price  
+
+</th> 
+
+<th></th> 
+
+</tr> 
+
+@foreach (var item in Model) {  
+
+<tr> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Title)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.ReleaseDate)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Genre)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Price)  
+
+</td> 
+
+<td> 
+
+@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |  
+
+@Html.ActionLink("Details", "Details", new { id=item.ID }) |  
+
+@Html.ActionLink("Delete", "Delete", new { id=item.ID })  
+
+ 
+</td> 
+
+</tr> 
+
+}  
+
+</table> 
+
+Run the application and navigate to /Movies/SearchIndex. Append a query string such as 
+
+?searchString=ghost to the URL. The filtered movies are displayed. 
+
+If you change the signature of the SearchIndex method to have a parameter named id, the id parameter will 
+
+match the{id} placeholder for the default routes set in the Global.asax file. 
+
+{controller}/{action}/{id} 
+
+ 
+ 
+The original SearchIndex method looks like this:: 
+
+publicActionResultSearchIndex(string searchString) 
+
+{ 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+returnView(movies); 
+
+} 
+
+The modified SearchIndex method would look as follows: 
+
+publicActionResultSearchIndex(string id) 
+
+{ 
+
+string searchString = id; 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+returnView(movies); 
+
+} 
+
+You can now pass the search title as route data (a URL segment) instead of as a query string value. 
+
+ 
+ 
+ 
+ 
+However, you can't expect users to modify the URL every time they want to search for a movie. So now you 
+
+you'll add UI to help them filter movies. If you changed the signature of the SearchIndex method to test how 
+
+to pass the route-bound ID parameter, change it back so that your SearchIndex method takes a string 
+
+parameter named searchString: 
+
+publicActionResultSearchIndex(string searchString) 
+
+{ 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+ 
+ 
+ 
+returnView(movies); 
+
+} 
+
+Open the Views\Movies\SearchIndex.cshtml file, and just after @Html.ActionLink("Create New", 
+
+"Create"), add the following: 
+
+@using (Html.BeginForm()){     
+
+<p> Title: @Html.TextBox("SearchString")<br/> 
+
+<inputtype="submit"value="Filter"/></p> 
+
+        } 
+
+The following example shows a portion of the Views\Movies\SearchIndex.cshtml file with the added filtering 
+
+markup. 
+
+@model IEnumerable<MvcMovie.Models.Movie> 
+
+@{  
+
+    ViewBag.Title = "SearchIndex";  
+
+}  
+
+<h2>SearchIndex</h2> 
+
+<p> 
+
+@Html.ActionLink("Create New", "Create")  
+
+     @using (Html.BeginForm()){     
+
+<p> Title: @Html.TextBox("SearchString") <br/> 
+
+<inputtype="submit"value="Filter"/></p> 
+
+        }  
+
+</p> 
+
+The Html.BeginForm helper creates an opening <form> tag. The Html.BeginForm helper causes the form to 
+
+post to itself when the user submits the form by clicking the Filter button. 
+
+Run the application and try searching for a movie. 
+
+ 
+ 
+ 
+ 
+There's no HttpPost overload of the SearchIndex method. You don't need it, because the method isn't 
+
+changing the state of the application, just filtering data. 
+
+You could add the following HttpPost SearchIndex method. In that case, the action invoker would match 
+
+the HttpPost SearchIndex method, and the HttpPost SearchIndex method would run as shown in the 
+
+image below. 
+
+[HttpPost] 
+
+publicstringSearchIndex(FormCollection fc,string searchString) 
+
+{ 
+
+return"<h3> From [HttpPost]SearchIndex: "+ searchString +"</h3>"; 
+
+} 
+
+ 
+However, even if you add this HttpPost version of the SearchIndex method, there's a limitation in how this 
+
+has all been implemented. Imagine that you want to bookmark a particular search or you want to send a link to 
+
+friends that they can click in order to see the same filtered list of movies. Notice that the URL for the HTTP 
+
+POST request is the same as the URL for the GET request (localhost:xxxxx/Movies/SearchIndex) -- there's no 
+
+search information in the URL itself. Right now, the search string information is sent to the server as a form field 
+
+value. This means you can't capture that search information to bookmark or send to friends in a URL. 
+
+The solution is to use an overload of BeginForm that specifies that the POST request should add the search 
+
+information to the URL and that is should be routed to the HttpGet version of the SearchIndex method. 
+
+Replace the existing parameterless BeginForm method with the following:  
+
+@using (Html.BeginForm("SearchIndex","Movies",FormMethod.Get)) 
+
+Now when you submit a search, the URL contains a search query string. Searching will also go to the HttpGet 
+
+SearchIndex action method, even if you have a HttpPost SearchIndex method. 
+
+ 
+ 
+Adding Search by Genre 
+
+If you added the HttpPost version of the SearchIndex method, delete it now.  
+
+Next, you'll add a feature to let users search for movies by genre. Replace the SearchIndex method with the 
+
+following code: 
+
+publicActionResultSearchIndex(string movieGenre,string searchString) 
+
+{ 
+
+varGenreLst=newList<string>(); 
+
+varGenreQry=from d in db.Movies 
+
+orderby d.Genre 
+
+ 
+ 
+select d.Genre; 
+
+GenreLst.AddRange(GenreQry.Distinct()); 
+
+ViewBag.movieGenre =newSelectList(GenreLst); 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+if(string.IsNullOrEmpty(movieGenre)) 
+
+returnView(movies); 
+
+else 
+
+{ 
+
+returnView(movies.Where(x => x.Genre== movieGenre)); 
+
+} 
+
+} 
+
+This version of the SearchIndex method takes an additional parameter, namely movieGenre. The first few 
+
+lines of code create aList object to hold movie genres from the database.  
+
+The following code is a LINQ query that retrieves all the genres from the database. 
+
+varGenreQry=from d in db.Movies 
+
+orderby d.Genre 
+
+select d.Genre; 
+
+The code uses the AddRange method of the generic List collection to add all the distinct genres to the list. 
+
+(Without the Distinct modifier, duplicate genres would be added — for example, comedy would be added 
+
+twice in our sample). The code then stores the list of genres in the ViewBag object. 
+
+The following code shows how to check the movieGenre parameter. If it's not empty, the code further 
+
+constrains the movies query to limit the selected movies to the specified genre. 
+
+ 
+ 
+ 
+ 
+if(string.IsNullOrEmpty(movieGenre)) 
+
+returnView(movies); 
+
+else 
+
+{ 
+
+returnView(movies.Where(x => x.Genre== movieGenre)); 
+
+} 
+
+Adding Markup to the SearchIndex View to Support Search by Genre 
+
+Add an Html.DropDownList helper to the Views\Movies\SearchIndex.cshtml file, just before the TextBox 
+
+helper. The completed markup is shown below: 
+
+<p> 
+
+@Html.ActionLink("Create New", "Create")  
+
+    @using (Html.BeginForm("SearchIndex","Movies",FormMethod.Get)){      
+
+<p>Genre: @Html.DropDownList("movieGenre", "All")    
+
+           Title: @Html.TextBox("SearchString")    
+
+<inputtype="submit"value="Filter"/></p> 
+
+        }  
+
+</p> 
+
+Run the application and browse to /Movies/SearchIndex. Try a search by genre, by movie name, and by both 
+
+criteria. 
+
+In this section you examined the CRUD action methods and views generated by the framework. You created a 
+
+search action method and view that let users search by movie title and genre. In the next section, you'll look at 
+
+how to add a property to the Movie model and how to add an initializer that will automatically create a test 
+
+database. 
+
+ 
+ 
+Adding a New Field to the Movie Model and 
+
+Table 
+
+In this section you'll make some changes to the model classes and learn how you can update the database 
+
+schema to match the model changes. 
+
+Adding a Rating Property to the Movie Model 
+
+Start by adding a new Rating property to the existing Movie class. Open the Models\Movie.cs file and add the 
+
+Rating property like this one: 
+
+publicstringRating{get;set;} 
+
+The complete Movie class now looks like the following code: 
+
+publicclassMovie 
+
+{ 
+
+publicint      ID          {get;set;} 
+
+publicstringTitle{get;set;} 
+
+publicDateTimeReleaseDate{get;set;} 
+
+publicstringGenre{get;set;} 
+
+publicdecimalPrice{get;set;} 
+
+publicstringRating{get;set;} 
+
+} 
+
+Recompile the application using the Build > Build Movie menu command. 
+
+Now that you've updated the Model class, you also need to update the \Views\Movies\Index.cshtml and 
+
+\Views\Movies\Create.cshtml view templates in order to display the new Rating property in the browser view. 
+
+Open the \Views\Movies\Index.cshtml file and add a <th>Rating</th> column heading just after the Price 
+
+column. Then add a <td> column near the end of the template to render the @item.Rating value. Below is 
+
+what the updated Index.cshtml view template looks like: 
+
+@model IEnumerable<MvcMovie.Models.Movie> 
+
+@{  
+
+    ViewBag.Title = "Index";  
+
+}  
+
+<h2>Index</h2> 
+
+<p> 
+
+@Html.ActionLink("Create New", "Create")  
+
+</p> 
+
+<table> 
+
+<tr> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.Title)  
+
+</th> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.ReleaseDate)  
+
+</th> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.Genre)  
+
+</th> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.Price)  
+
+</th> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.Rating)  
+
+</th> 
+
+<th></th> 
+
+</tr> 
+
+@foreach (var item in Model) {  
+
+<tr> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Title)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.ReleaseDate)  
+
+</td> 
+
+ 
+ 
+ 
+ 
+<td> 
+
+@Html.DisplayFor(modelItem => item.Genre)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Price)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Rating)  
+
+</td> 
+
+<td> 
+
+@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |  
+
+@Html.ActionLink("Details", "Details", new { id=item.ID }) |  
+
+@Html.ActionLink("Delete", "Delete", new { id=item.ID })  
+
+</td> 
+
+</tr> 
+
+}  
+
+</table> 
+
+Next, open the \Views\Movies\Create.cshtml file and add the following markup near the end of the form. This 
+
+renders a text box so that you can specify a rating when a new movie is created. 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Rating)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Rating)  
+
+@Html.ValidationMessageFor(model => model.Rating)  
+
+</div> 
+
+Managing Model and Database Schema Differences 
+
+You've now updated the application code to support the new Rating property. 
+
+Now run the application and navigate to the /Movies URL. When you do this, though, you'll see one of the 
+
+following errors: 
+
+ 
+ 
+You're seeing this error because the updated Movie model class in the application is now different than the 
+
+schema of the Movie table of the existing database. (There's no Rating column in the database table.) 
+
+By default, when you use Entity Framework Code First to automatically create a database, as you did earlier in 
+
+this tutorial, Code First adds a table to the database to help track whether the schema of the database is in sync 
+
+with the model classes it was generated from. If they aren't in sync, the Entity Framework throws an error. This 
+
+makes it easier to track down issues at development time that you might otherwise only find (by obscure 
+
+ 
+errors) at run time. The sync-checking feature is what causes the error message to be displayed that you just 
+
+saw. 
+
+There are two approaches to resolving the error: 
+
+1.  Have the Entity Framework automatically drop and re-create the database based on the new model class 
+
+schema. This approach is very convenient when doing active development on a test database; it allows 
+
+you to quickly evolve the model and database schema together. The downside, though, is that you lose 
+
+existing data in the database — so you don't want to use this approach on a production database!  
+
+2.  Explicitly modify the schema of the existing database so that it matches the model classes. The advantage 
+
+of this approach is that you keep your data. You can make this change either manually or by creating a 
+
+database change script.  
+
+For this tutorial, we'll use the first approach — you'll have the Entity Framework Code First automatically re-
+
+create the database anytime the model changes. 
+
+Automatically Re-Creating the Database on Model Changes 
+
+Let's update the application so that Code First automatically drops and re-creates the database anytime you 
+
+change the model for the application.  
+
+Warning You should enable this approach of automatically dropping and re-creating the database only when 
+
+you're using a development or test database, and never on a production database that contains real data. Using 
+
+it on a production server can lead to data loss. 
+
+Stop the debugger. In Solution Explorer, right click the Models folder, select Add, and then select New Item. 
+
+In the Add New Item dialog, select Class then name the class "MovieInitializer". Update the 
+
+MovieInitializer class to contain the following code: 
+
+usingSystem; 
+
+usingSystem.Collections.Generic; 
+
+usingSystem.Data.Entity; 
+
+namespaceMvcMovie.Models{ 
+
+publicclassMovieInitializer:DropCreateDatabaseIfModelChanges<MovieDBContext>{ 
+
+protectedoverridevoidSeed(MovieDBContext context){ 
+
+var movies =newList<Movie>{ 
+
+newMovie{Title="When Harry Met Sally", 
+
+ReleaseDate=DateTime.Parse("1989-1-11"), 
+
+Genre="Romantic Comedy", 
+
+ 
+ 
+ 
+Rating="R", 
+
+Price=7.99M}, 
+
+newMovie{Title="Ghostbusters ", 
+
+ReleaseDate=DateTime.Parse("1984-3-13"), 
+
+Genre="Comedy", 
+
+Rating="R", 
+
+Price=8.99M}, 
+
+newMovie{Title="Ghostbusters 2", 
+
+ReleaseDate=DateTime.Parse("1986-2-23"), 
+
+Genre="Comedy", 
+
+Rating="R", 
+
+Price=9.99M}, 
+
+newMovie{Title="Rio Bravo", 
+
+ReleaseDate=DateTime.Parse("1959-4-15"), 
+
+Genre="Western", 
+
+Rating="R", 
+
+Price=3.99M}, 
+
+}; 
+
+movies.ForEach(d => context.Movies.Add(d)); 
+
+} 
+
+} 
+
+} 
+
+The MovieInitializer class specifies that the database used by the model should be dropped and 
+
+automatically re-created if the model classes ever change.DropCreateDatabaseIfModelChanges initializer 
+
+specifies the DB should be re-created only if the schema changes. Alternatively, you could use 
+
+theDropCreateDatabaseAlways initializer to always recreate and re-seed the database with data the first time 
+
+that a context is used in the application domain. TheDropCreateDatabaseAlways approach is useful in some 
+
+integration testing scenarios. The code that you inserted into the MovieInitializer class includes a includes a 
+
+Seed method that specifies some default data to automatically add to the database any time it's created (or re-
+
+created). This provides a useful way to populate the database with some test data, without requiring you to 
+
+manually populate it each time you make a model change. 
+
+ 
+ 
+ 
+ 
+Now that you've defined the MovieInitializer class, you'll want to wire it up so that each time the 
+
+application runs, it checks whether the model classes are different from the schema in the database. If they are, 
+
+you can run the initializer to re-create the database to match the model and then populate the database with 
+
+the sample data. 
+
+Open the Global.asax filet: 
+
+ 
+The Global.asax file contains the class that defines the entire application for the project, and contains an 
+
+Application_Start event handler that runs when the application first starts. 
+
+At the beginning of the Application_Start method, add a call to Database.SetInitializer as shown 
+
+below: 
+
+protectedvoidApplication_Start() 
+
+{ 
+
+Database.SetInitializer<MovieDBContext>(newMovieInitializer()); 
+
+AreaRegistration.RegisterAllAreas(); 
+
+// Use LocalDB for Entity Framework by default 
+
+Database.DefaultConnectionFactory=newSqlConnectionFactory("Data 
+
+Source=(localdb)\v11.0; Integrated Security=True; MultipleActiveResultSets=True"); 
+
+RegisterGlobalFilters(GlobalFilters.Filters); 
+
+RegisterRoutes(RouteTable.Routes); 
+
+BundleTable.Bundles.RegisterTemplateBundles(); 
+
+} 
+
+Put the cursor on the red squiggly line (on MovieDBContext, orMovieInitializer ) right click and select 
+
+Resolve, then using MvcMovie.Models; 
+
+ 
+ 
+ 
+Alternatively, add the using statement to the top of the file. The using statement references the namespace 
+
+where our MovieInitializer class lives: 
+
+usingMvcMovie.Models;// MovieInitializer 
+
+The Database.SetInitializer statement you just added indicates that the database used by the 
+
+MovieDBContext instance should be automatically deleted and re-created if the schema and the database 
+
+don't match. And as you saw, it will also populate the database with the sample data that's specified in the 
+
+MovieInitializer class. 
+
+Close the Global.asax file. 
+
+Re-run the application and navigate to the /Movies URL. When the application starts, it detects that the model 
+
+structure no longer matches the database schema. It automatically re-creates the database to match the new 
+
+model structure and populates the database with the sample movies: 
+
+ 
+<=""> 
+
+Click the Create New link to add a new movie. Note that you can add a rating. 
+
+Click Create. The new movie, including the rating, now shows up in the movies listing: 
+
+ 
+You should also add the Rating field to the Edit view template. 
+
+In this section you saw how you can modify model objects and keep the database in sync with the changes. You 
+
+also learned a way to populate a newly created database with sample data so you can try out scenarios. Next, 
+
+let's look at how you can add richer validation logic to the model classes and enable some business rules to be 
+
+enforced. 
+
+ 
+Adding Validation to the Model 
+
+In this this section you'll add validation logic to the Movie model, and you'll ensure that the validation rules are 
+
+enforced any time a user attempts to create or edit a movie using the application. 
+
+Keeping Things DRY 
+
+One of the core design tenets of ASP.NET MVC is DRY ("Don't Repeat Yourself"). ASP.NET MVC encourages you 
+
+to specify functionality or behavior only once, and then have it be reflected everywhere in an application. This 
+
+reduces the amount of code you need to write and makes the code you do write less error prone and easier to 
+
+maintain. 
+
+The validation support provided by ASP.NET MVC and Entity Framework Code First is a great example of the 
+
+DRY principle in action. You can declaratively specify validation rules in one place (in the model class) and the 
+
+rules are enforced everywhere in the application. 
+
+Let's look at how you can take advantage of this validation support in the movie application. 
+
+Adding Validation Rules to the Movie Model 
+
+You'll begin by adding some validation logic to the Movie class. 
+
+Open the Movie.cs file. Add a using statement at the top of the file that references 
+
+theSystem.ComponentModel.DataAnnotations namespace: 
+
+usingSystem.ComponentModel.DataAnnotations; 
+
+Notice the namespace does not contain System.Web. DataAnnotations provides a built-in set of validation 
+
+attributes that you can apply declaratively to any class or property. 
+
+Now update the Movie class to take advantage of the built-inRequired,StringLength, andRange validation 
+
+attributes. Use the following code as an example of where to apply the attributes. 
+
+publicclassMovie{ 
+
+publicint ID {get;set;} 
+
+[Required] 
+
+ 
+publicstringTitle{get;set;} 
+
+[DataType(DataType.Date)] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+[Required] 
+
+publicstringGenre{get;set;} 
+
+[Range(1,100)] 
+
+[DataType(DataType.Currency)] 
+
+publicdecimalPrice{get;set;} 
+
+[StringLength(5)] 
+
+publicstringRating{get;set;} 
+
+} 
+
+The validation attributes specify behavior that you want to enforce on the model properties they are applied to. 
+
+The Required attribute indicates that a property must have a value; in this sample, a movie has to have values 
+
+for the Title, ReleaseDate, Genre, and Price properties in order to be valid. The Range attribute constrains 
+
+a value to within a specified range. The StringLength attribute lets you set the maximum length of a string 
+
+property, and optionally its minimum length. Intrinsic types (such as decimal, int, float, DateTime) are 
+
+required by default and don't need the Requiredattribute. 
+
+Code First ensures that the validation rules you specify on a model class are enforced before the application 
+
+saves changes in the database. For example, the code below will throw an exception when the SaveChanges 
+
+method is called, because several required Movie property values are missing and the price is zero (which is out 
+
+of the valid range). 
+
+MovieDBContext db =newMovieDBContext(); 
+
+Movie movie =newMovie(); 
+
+movie.Title="Gone with the Wind"; 
+
+movie.Price=0.0M; 
+
+db.Movies.Add(movie); 
+
+db.SaveChanges();// <= Will throw validation exception   
+
+ 
+ 
+ 
+ 
+ 
+ 
+Having validation rules automatically enforced by the .NET Framework helps make your application more 
+
+robust. It also ensures that you can't forget to validate something and inadvertently let bad data into the 
+
+database. 
+
+Here's a complete code listing for the updated Movie.cs file: 
+
+usingSystem; 
+
+usingSystem.Data.Entity; 
+
+usingSystem.ComponentModel.DataAnnotations; 
+
+namespaceMvcMovie.Models{ 
+
+publicclassMovie{ 
+
+publicint ID {get;set;} 
+
+[Required] 
+
+publicstringTitle{get;set;} 
+
+[DataType(DataType.Date)] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+[Required] 
+
+publicstringGenre{get;set;} 
+
+[Range(1,100)] 
+
+[DataType(DataType.Currency)] 
+
+publicdecimalPrice{get;set;} 
+
+[StringLength(5)] 
+
+publicstringRating{get;set;} 
+
+} 
+
+publicclassMovieDBContext:DbContext{ 
+
+publicDbSet<Movie>Movies{get;set;} 
+
+} 
+
+} 
+
+Validation Error UI in ASP.NET MVC 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Re-run the application and navigate to the /Movies URL. 
+
+Click the Create New link to add a new movie. Fill out the form with some invalid values and then click the 
+
+Create button. 
+
+ 
+Notice how the form has automatically used a red border color to highlight the text boxes that contain invalid 
+
+data and has emitted an appropriate validation error message next to each one. The errors are enforced both 
+
+client-side (using JavaScript) and server-side (in case a user has JavaScript disabled). 
+
+A real benefit is that you didn't need to change a single line of code in theMoviesController class or in the 
+
+Create.cshtml view in order to enable this validation UI. The controller and views you created earlier in this 
+
+tutorial automatically picked up the validation rules that you specified by using validation attributes on the 
+
+properties of the Movie model class. 
+
+You might have noticed for the properties Title and Genre, the required attribute is not enforced until you 
+
+submit the form (hit the Create button), or enter text into the input field and removed it. For a field which is 
+
+initially empty (such as the fields on the Create view) and which has only the required attribute and no other 
+
+validation attributes, you can do the following to trigger validation: 
+
+1.  Tab into the field. 
+
+2.  Enter some text. 
+
+3.  Tab out. 
+
+4.  Tab back into the field. 
+
+5.  Remove the text. 
+
+6.  Tab out. 
+
+The above sequence will trigger the required validation without hitting the submit button. Simply hitting the 
+
+submit button without entering any of the fields will trigger client side validation. The form data is not sent to 
+
+the server until there are no client side validation errors. You can test this by putting a break point in the HTTP 
+
+Post method or using thefiddler tool or the IE 9F12 developer tools. 
+
+How Validation Occurs in the Create View and Create Action Method 
+
+ 
+You might wonder how the validation UI was generated without any updates to the code in the controller or 
+
+views. The next listing shows what the Create methods in the MovieController class look like. They're 
+
+unchanged from how you created them earlier in this tutorial.  
+
+// 
+
+// GET: /Movies/Create 
+
+publicActionResultCreate() 
+
+{ 
+
+returnView(); 
+
+} 
+
+// 
+
+// POST: /Movies/Create 
+
+[HttpPost] 
+
+publicActionResultCreate(Movie movie) 
+
+{ 
+
+if(ModelState.IsValid) 
+
+{ 
+
+db.Movies.Add(movie); 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+The first (HTTP GET) Create action method displays the initial Create form. The second ([HttpPost]) version 
+
+handles the form post. The second Create method (The HttpPost version) calls ModelState.IsValid to 
+
+check whether the movie has any validation errors. Calling this method evaluates any validation attributes that 
+
+have been applied to the object. If the object has validation errors, the Create method re-displays the form. If 
+
+there are no errors, the method saves the new movie in the database. In our movie example we are using, the 
+
+form is not posted to the server when their are validation errors detected on the client side; the second Create 
+
+method is never called. If you disable JavaScript in your browser, client validation is disabled and the HTTP 
+
+POST Create method calls ModelState.IsValid to check whether the movie has any validation errors.  
+
+ 
+ 
+ 
+ 
+You can set a break point in the HttpPost Create method and verify the method is never called, client side 
+
+validation will not submit the form data when validation errors are detected. If you disable JavaScript in your 
+
+browser, submit the form with errors, the break point will be hit. You still get full validation without JavaScript. 
+
+ 
+The following image shows how to disable JavaScript in the FireFox browser. 
+
+The following image shows how to disable JavaScript with the Chrome browser. 
+
+ 
+ 
+Below is the Create.cshtml view template that you scaffolded earlier in the tutorial. It's used by the action 
+
+methods shown above both to display the initial form and to redisplay it in the event of an error. 
+
+ 
+@model MvcMovie.Models.Movie  
+
+@{  
+
+    ViewBag.Title = "Create";  
+
+}  
+
+<h2>Create</h2> 
+
+<scriptsrc="@Url.Content("~/Scripts/jquery.validate.min.js")"></script> 
+
+<scriptsrc="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")"></script> 
+
+@using (Html.BeginForm()) {  
+
+@Html.ValidationSummary(true)  
+
+<fieldset> 
+
+<legend>Movie</legend> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Title)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Title)  
+
+@Html.ValidationMessageFor(model => model.Title)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.ReleaseDate)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.ReleaseDate)  
+
+@Html.ValidationMessageFor(model => model.ReleaseDate)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Genre)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Genre)  
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+@Html.ValidationMessageFor(model => model.Genre)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Price)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Price)  
+
+@Html.ValidationMessageFor(model => model.Price)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Rating)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Rating)  
+
+@Html.ValidationMessageFor(model => model.Rating)  
+
+</div> 
+
+<p> 
+
+<inputtype="submit"value="Create"/> 
+
+</p> 
+
+</fieldset> 
+
+}  
+
+<div> 
+
+@Html.ActionLink("Back to List", "Index")  
+
+</div> 
+
+Notice how the code uses an Html.EditorFor helper to output the<input> element for each Movie 
+
+property. Next to this helper is a call to the Html.ValidationMessageFor helper method. These two helper 
+
+methods work with the model object that's passed by the controller to the view (in this case, a Movie object). 
+
+They automatically look for validation attributes specified on the model and display error messages as 
+
+appropriate. 
+
+What's really nice about this approach is that neither the controller nor the Create view template knows 
+
+anything about the actual validation rules being enforced or about the specific error messages displayed. The 
+
+validation rules and the error strings are specified only in the Movie class. 
+
+ 
+ 
+If you want to change the validation logic later, you can do so in exactly one place by adding validation 
+
+attributes to the model (in this example, themovie class). You won't have to worry about different parts of the 
+
+application being inconsistent with how the rules are enforced — all validation logic will be defined in one 
+
+place and used everywhere. This keeps the code very clean, and makes it easy to maintain and evolve. And it 
+
+means that that you'll be fully honoring the DRY principle. 
+
+Adding Formatting to the Movie Model 
+
+Open the Movie.cs file and examine the Movie class. TheSystem.ComponentModel.DataAnnotations 
+
+namespace provides formatting attributes in addition to the built-in set of validation attributes. We've already 
+
+applied aDataType enumeration value to the release date and to the price fields. The following code shows the 
+
+ReleaseDate and Price properties with the appropriateDisplayFormat attribute. 
+
+[DataType(DataType.Date)] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+[DataType(DataType.Currency)] 
+
+publicdecimalPrice{get;set;} 
+
+Alternatively, you could explicitly set aDataFormatString value. The following code shows the release date 
+
+property with a date format string (namely, "d"). You'd use this to specify that you don't want to time as part of 
+
+the release date. 
+
+[DisplayFormat(DataFormatString="{0:d}")] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+The following code formats the Price property as currency. 
+
+[DisplayFormat(DataFormatString="{0:c}")] 
+
+publicdecimalPrice{get;set;} 
+
+The complete Movie class is shown below. 
+
+publicclassMovie{ 
+
+publicint ID {get;set;} 
+
+ 
+ 
+[Required] 
+
+publicstringTitle{get;set;} 
+
+[DataType(DataType.Date)] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+[Required] 
+
+publicstringGenre{get;set;} 
+
+[Range(1,100)] 
+
+[DataType(DataType.Currency)] 
+
+publicdecimalPrice{get;set;} 
+
+[StringLength(5)] 
+
+publicstringRating{get;set;} 
+
+} 
+
+Run the application and browse to the Movies controller. The release date and price are nicely formatted. 
+
+ 
+ 
+ 
+ 
+In the next part of the series, we'll review the application and make some improvements to the automatically 
+
+generated Details and Delete methods. 
+
+ 
+ 
+ 
+Examining the Details and Delete Methods 
+
+In this part of the tutorial, you'll examine the automatically generated Details and Delete methods.  
+
+Examining the Details and Delete Methods 
+
+Open the Movie controller and examine the Details method. 
+
+publicActionResultDetails(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+Code First makes it easy to search for data using the Find method. An important security feature built into the 
+
+method is that the code verifies that the Find method has found a movie before the code tries to do anything 
+
+with it. For example, a hacker could introduce errors into the site by changing the URL created by the links from 
+
+http://localhost:xxxx/Movies/Details/1 to something like http://localhost:xxxx/Movies/Details/12345 (or some 
+
+other value that doesn't represent an actual movie). If you did not check for a null movie, a null movie would 
+
+result in a database error. 
+
+Examine the Delete and DeleteConfirmed methods. 
+
+// GET: /Movies/Delete/5 
+
+publicActionResultDelete(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+returnView(movie); 
+
+ 
+} 
+
+// 
+
+// POST: /Movies/Delete/5 
+
+[HttpPost,ActionName("Delete")] 
+
+publicActionResultDeleteConfirmed(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+db.Movies.Remove(movie); 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+Note that the HTTP Get Delete method doesn't delete the specified movie, it returns a view of the movie 
+
+where you can submit (HttpPost) the deletion.. Performing a delete operation in response to a GET request (or 
+
+for that matter, performing an edit operation, create operation, or any other operation that changes data) 
+
+opens up a security hole. For more information about this, see Stephen Walther's blog entryASP.NET MVC Tip 
+
+#46 — Don't use Delete Links because they create Security Holes. 
+
+The HttpPost method that deletes the data is named DeleteConfirmed to give the HTTP POST method a 
+
+unique signature or name. The two method signatures are shown below: 
+
+// GET: /Movies/Delete/5 
+
+publicActionResultDelete(int id =0) 
+
+// 
+
+// POST: /Movies/Delete/5 
+
+[HttpPost,ActionName("Delete")] 
+
+publicActionResultDeleteConfirmed(int id =0) 
+
+ 
+ 
+ 
+The common language runtime (CLR) requires overloaded methods to have a unique signature (same method 
+
+name but different list of parameters). However, here you need two Delete methods -- one for GET and one for 
+
+POST -- that both have the same signature. (They both need to accept a single integer as a parameter.) 
+
+To sort this out, you can do a couple of things. One is to give the methods different names. That's what the 
+
+scaffolding mechanism did in he preceding example. However, this introduces a small problem: ASP.NET maps 
+
+segments of a URL to action methods by name, and if you rename a method, routing normally wouldn't be able 
+
+to find that method. The solution is what you see in the example, which is to add the ActionName("Delete") 
+
+attribute to theDeleteConfirmed method. This effectively performs mapping for the routing system so that a 
+
+URL that includes /Delete/ for a POST request will find the DeleteConfirmed method. 
+
+Another common way to avoid a problem with methods that have identical names and signatures is to 
+
+artificially change the signature of the POST method to include an unused parameter. For example, some 
+
+developers add a parameter typeFormCollectionthat is passed to the POST method, and then simply don't 
+
+use the parameter: 
+
+publicActionResultDelete(FormCollection fcNotUsed,int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+db.Movies.Remove(movie); 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+Wrapping Up 
+
+You now have a complete ASP.NET MVC application that stores data in a SQL Server Compact database. You 
+
+can create, read, update, delete, and search for movies. 
+
+This basic tutorial got you started making controllers, associating them with views, and passing around hard-
+
+coded data. Then you created and designed a data model. Entity Framework code-first created a database from 
+
+the data model on the fly, and the ASP.NET MVC scaffolding system automatically generated the action 
+
+methods and views for basic CRUD operations. You then added a search form that let users search the 
+
+database. You changed the database to include a new column of data, and then updated two pages to create 
+
+and display this new data. You added validation by marking the data model with attributes from the 
+
+DataAnnotations namespace. The resulting validation runs on the client and on the server.  
+
+If you'd like to deploy your application, it's helpful to first test the application on your local IIS 7 server. You can 
+
+use thisWeb Platform Installer link to enable IIS setting for ASP.NET applications. See the following deployment 
+
+links: 
+
+ 
+•  ASP.NET Deployment Content Map 
+
+• 
+
+Enabling IIS 7.x  
+
+•  Web Application Projects Deployment  
+
+I now encourage you to move on to our intermediate-levelCreating an Entity Framework Data Model for an 
+
+ASP.NET MVC Application andMVC Music Store tutorials, to explore theASP.NET articles on MSDN, and to 
+
+check out the many videos and resources athttp://asp.net/mvc to learn even more about ASP.NET MVC! The 
+
+ASP.NET MVC forums are a great place to ask questions. 
+
+Enjoy! 
+
+— Rick Anderson blogs.msdn.com/rickAndy twitter @RickAndMSFT 
+
+— Scott Hanselmanhttp://www.hanselman.com/blog/ twitter @shanselman 
+
+ 
+ 
+ 
+ 
+ 
+

ASP.NET/intro%2520to%2520asp.net%2520mvc%25204%2520with%2520visual%2520studio%2520-%2520beta.pdf.txt

@@ -0,0 +1,3442 @@
+Intr
+Visu
+
+ro to
+ual S
+
+o ASP
+Studio
+
+P.NET
+o (Be
+
+T MV
+eta)
+
+VC 4 w
+
+with 
+
+Rick A
+
+Anderso
+
+on and S
+
+Scott Ha
+
+anselma
+
+an 
+
+Summa
+
+ry: This tuto
+
+orial will te
+
+ach you the
+
+e basics of 
+
+building an
+
+n ASP.NET M
+
+MVC Web 
+
+applicat
+
+ion using M
+
+Microsoft Vi
+
+isual Studio
+
+o 11 Express
+
+s Beta for W
+
+Web, which 
+
+is a free 
+
+version o
+
+of Microsof
+
+ft Visual Stu
+
+udio. 
+
+Categor
+
+ry: Step-By
+
+-Step 
+
+Applies 
+
+to: ASP.NE
+
+ET MVC 4 B
+
+eta, Visual 
+
+Studio 11 B
+
+Beta 
+
+Source: 
+
+ASP.NET si
+
+te (link to s
+
+source cont
+
+tent) 
+
+E-book 
+
+publicatio
+
+on date: Ma
+
+ay 2012 
+
+115 pag
+
+es             
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Copyright © 2012 by Microsoft Corporation 
+
+All rights reserved. No part of the contents of this book may be reproduced or transmitted in any form or by any means 
+without the written permission of the publisher. 
+
+Microsoft and the trademarks listed at 
+http://www.microsoft.com/about/legal/en/us/IntellectualProperty/Trademarks/EN-US.aspx are trademarks of the 
+Microsoft group of companies. All other marks are property of their respective owners. 
+
+The example companies, organizations, products, domain names, email addresses, logos, people, places, and events 
+depicted herein are fictitious. No association with any real company, organization, product, domain name, email address, 
+logo, person, place, or event is intended or should be inferred. 
+
+This book expresses the author’s views and opinions. The information contained in this book is provided without any 
+express, statutory, or implied warranties. Neither the authors, Microsoft Corporation, nor its resellers, or distributors will 
+be held liable for any damages caused or alleged to be caused either directly or indirectly by this book. 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Contents 
+Getting Started ........................................................................................................................................ 3 
+
+What You'll Build ........................................................................................................................... 3 
+
+Skills You'll Learn ........................................................................................................................... 5 
+
+Getting Started .............................................................................................................................. 6 
+
+Creating Your First Application .................................................................................................... 7 
+
+Adding a Controller ............................................................................................................................ 13 
+
+Adding a View ..................................................................................................................................... 20 
+
+Changing Views and Layout Pages ............................................................................................ 25 
+
+Passing Data from the Controller to the View ........................................................................... 31 
+
+Adding a Model .................................................................................................................................. 37 
+
+Adding Model Classes................................................................................................................. 37 
+
+Creating a Connection String and Working with SQL Server LocalDB .................................... 41 
+
+Accessing Your Model's Data from a Controller ............................................................................... 43 
+
+Creating a Movie ......................................................................................................................... 46 
+
+Examining the Generated Code.................................................................................................. 48 
+
+Strongly Typed Models and the @model Keyword .................................................................. 49 
+
+Working with SQL Server LocalDB ............................................................................................. 53 
+
+Examining the Edit Methods and Edit View ...................................................................................... 58 
+
+Processing the POST Request ..................................................................................................... 65 
+
+Adding a Search Method and Search View ............................................................................... 67 
+
+Displaying the SearchIndex Form ............................................................................................... 67 
+
+Adding Search by Genre ............................................................................................................. 77 
+
+Adding Markup to the SearchIndex View to Support Search by Genre .................................. 79 
+
+Adding a New Field to the Movie Model and Table ......................................................................... 80 
+
+Adding a Rating Property to the Movie Model ......................................................................... 80 
+
+Managing Model and Database Schema Differences ............................................................... 82 
+
+Automatically Re-Creating the Database on Model Changes .................................................. 85 
+
+Adding Validation to the Model ........................................................................................................ 95 
+
+Keeping Things DRY .................................................................................................................... 95 
+
+Adding Validation Rules to the Movie Model ........................................................................... 95 
+
+Validation Error UI in ASP.NET MVC .......................................................................................... 97 
+
+How Validation Occurs in the Create View and Create Action Method ................................ 100 
+
+Adding Formatting to the Movie Model.................................................................................. 108 
+
+Examining the Details and Delete Methods .................................................................................... 111 
+
+Examining the Details and Delete Methods ............................................................................ 111 
+
+Wrapping Up ............................................................................................................................. 113 
+
+ 
+ 
+ 
+Getting Started 
+By Rick Anderson and Scott Hanselman 
+
+This tutorial will teach you the basics of building an ASP.NET MVC Web application using Microsoft Visual 
+
+Studio 11 Express Beta for Web, which is a free version of Microsoft Visual Studio. Before you start, make sure 
+
+you've installed the prerequisites listed below. You can install all of them by clicking the following link: Web 
+
+Platform Installer.  
+
+If you're using Visual Studio 11 Beta instead of Visual Studio 11 Express Beta for Web , install the prerequisites 
+
+by clicking the following link: Web Platform Installer 
+
+A Visual Web Developer project with C# source code is available to accompany this topic. Download the C# 
+
+version.  
+
+What You'll Build 
+
+You'll implement a simple movie-listing application that supports creating, editing, searching and listing movies 
+
+from a database. Below are two screenshots of the application you’ll build. It includes a page that displays a list 
+
+of movies from a database: 
+
+ 
+ 
+ 
+The application also lets you add, edit, and delete movies, as well as see details about individual ones. All data-
+
+entry scenarios include validation to ensure that the data stored in the database is correct. 
+
+ 
+Skills You'll Learn 
+
+Here's what you'll learn:  
+
+•  How to create a new ASP.NET MVC project.  
+
+ 
+•  How to create ASP.NET MVC controllers and views.  
+
+•  How to create a new database using the Entity Framework Code First paradigm.  
+
+•  How to retrieve and display data.  
+
+•  How to edit data and enable data validation.  
+
+Getting Started 
+
+Start by running Visual Web Developer 11 Express Beta("Visual Web Developer" or VWD for short) and select 
+
+New Project from the Start page. 
+
+Visual Web Developer is an IDE, or integrated development environment. Just like you use Microsoft Word to 
+
+write documents, you'll use an IDE to create applications. In Visual Web Developer there's a toolbar along the 
+
+top showing various options available to you. There's also a menu that provides another way to perform tasks 
+
+in the IDE. (For example, instead of selecting New Project from the Start page, you can use the menu and 
+
+select File>New Project.) 
+
+Creating Your First Application 
+
+You can create applications using either Visual Basic or Visual C# as the programming language. Select Visual 
+
+C# on the left and then select ASP.NET MVC 4 Web Application. Name your project "MvcMovie" and then 
+
+click OK.  
+
+ 
+In the New ASP.NET MVC 4 Project dialog box, select Internet Application. LeaveRazor as the default view 
+
+engine. 
+
+ 
+Click OK. Visual Web Developer used a default template for the ASP.NET MVC project you just created, so you 
+
+have a working application right now without doing anything! This is a simple "Hello World!" project, and it's a 
+
+good place to start your application. 
+
+ 
+From the Debug menu, select Start Debugging. 
+
+ 
+Notice that the keyboard shortcut to start debugging is F5. 
+
+ 
+F5 causes Visual Web Developer to start IIS Express and run your web application. Visual Web Developer then 
+
+launches a browser and opens the application's home page. Notice that the address bar of the browser says 
+
+localhost and not something like example.com. That's becauselocalhost always points to your own local 
+
+computer, which in this case is running the application you just built. When Visual Web Developer runs a web 
+
+project, a random port is used for the web server. In the image below, the port number is 41788. When you run 
+
+the application, you'll probably see a different port number. 
+
+Right out of the box this default template gives you Home, Contact and About pages. It also provides support 
+
+to register and log in, and links to Facebook and Twitter. The next step is to change how this application works 
+
+and learn a little bit about ASP.NET MVC. Close your browser and let's change some code. 
+
+ 
+ 
+ 
+Adding a Controller 
+
+MVC stands formodel-view-controller. MVC is a pattern for developing applications that are well 
+architected, testable and easy to maintain. MVC-based applications contain: 
+•  Models: Classes that represent the data of the application and that use validation logic to enforce 
+
+business rules for that data. 
+
+•  Views: Template files that your application uses to dynamically generate HTML responses. 
+
+•  Controllers: Classes that handle incoming browser requests, retrieve model data, and then specify 
+
+view templates that return a response to the browser. 
+
+We'll be covering all these concepts in this tutorial series and show you how to use them to build an 
+application. 
+
+Let's begin by creating a controller class. InSolution Explorer, right-click theControllersfolder and then 
+selectAdd Controller. 
+
+Name your new controller "HelloWorldController". Leave the default template asEmpty controllerand 
+clickAdd. 
+
+ 
+Notice inSolution Explorerthat a new file has been created namedHelloWorldController.cs. The file is 
+open in the IDE. 
+
+ 
+Replace the contents of the file with the following code.  
+
+usingSystem.Web; 
+usingSystem.Web.Mvc; 
+
+namespaceMvcMovie.Controllers 
+{ 
+publicclassHelloWorldController:Controller 
+{ 
+//  
+// GET: /HelloWorld/  
+
+ 
+ 
+publicstringIndex() 
+{ 
+return"This is my <b>default</b> action..."; 
+} 
+
+//  
+// GET: /HelloWorld/Welcome/  
+
+publicstringWelcome() 
+{ 
+return"This is the Welcome action method..."; 
+} 
+} 
+} 
+
+The controller methods will return a string of HTML as an example. The controller is 
+namedHelloWorldControllerand the first method above is namedIndex. Let’s invoke it from a browser. 
+Run the application (press F5 or Ctrl+F5). In the browser, append "HelloWorld" to the path in the address 
+bar. (For example, in the illustration below, it'shttp://localhost:1234/HelloWorld.) The page in the browser 
+will look like the following screenshot. In the method above, the code returned a string directly. You told 
+the system to just return some HTML, and it did!  
+
+ASP.NET MVC invokes different controller classes (and different action methods within them) depending 
+on the incoming URL. The default URL routing logic used by ASP.NET MVC uses a format like this to 
+determine what code to invoke: 
+
+/[Controller]/[ActionName]/[Parameters] 
+The first part of the URL determines the controller class to execute. So/HelloWorldmaps to the 
+HelloWorldControllerclass. The second part of the URL determines the action method on the class to 
+
+ 
+ 
+ 
+ 
+execute. So/HelloWorld/Indexwould cause theIndexmethod of theHelloWorldControllerclass to 
+execute. Notice that we only had to browse to/HelloWorldand theIndexmethod was used by default. This 
+is because a method named Indexis the default method that will be called on a controller if one is not 
+explicitly specified. 
+Browse tohttp://localhost:xxxx/HelloWorld/Welcome. TheWelcomemethod runs and returns the string "This 
+is the Welcome action method...". The default MVC mapping 
+is/[Controller]/[ActionName]/[Parameters]. For this URL, the controller 
+isHelloWorldandWelcomeis the action method. You haven't used the[Parameters]part of the URL yet. 
+
+Let's modify the example slightly so that you can pass some parameter information from the URL to the 
+controller (for example,/HelloWorld/Welcome?name=Scott&numtimes=4). Change yourWelcomemethod 
+to include two parameters as shown below. Note that the code uses the C# optional-parameter feature to 
+indicate that the numTimesparameter should default to 1 if no value is passed for that parameter. 
+
+publicstringWelcome(string name,int numTimes =1){ 
+returnHttpUtility.HtmlEncode("Hello "+ name +", NumTimes is: "+ numTimes); 
+} 
+
+Run your application and browse to the example URL 
+(http://localhost:xxxx/HelloWorld/Welcome?name=Scott&numtimes=4). You can try different values 
+fornameandnumtimesin the URL. The ASP.NET MVC model binding system automatically maps the named 
+parameters from the query string in the address bar to parameters in your method. 
+
+ 
+In both these examples the controller has been doing the "VC" portion of MVC — that is, the view and 
+controller work. The controller is returning HTML directly. Ordinarily you don't want controllers returning 
+HTML directly, since that becomes very cumbersome to code. Instead we'll typically use a separate view 
+template file to help generate the HTML response. Let's look next at how we can do this. 
+
+ 
+ 
+ 
+Adding a View 
+
+In this section you're going to modify the HelloWorldController class to use view template files to cleanly 
+
+encapsulate the process of generating HTML responses to a client. 
+
+You'll create a view template file using theRazor view engine introduced with ASP.NET MVC 3. Razor-based 
+
+view templates have a .cshtml file extension, and provide an elegant way to create HTML output using C#. Razor 
+
+minimizes the number of characters and keystrokes required when writing a view template, and enables a fast, 
+
+fluid coding workflow. 
+
+Start by creating a view template with the Index method in theHelloWorldController class. Currently the 
+
+Index method returns a string with a message that is hard-coded in the controller class. Change the Index 
+
+method to return a View object, as shown in the following code: 
+
+publicActionResultIndex() 
+
+{ 
+
+returnView(); 
+
+} 
+
+The Index method above uses a view template to generate an HTML response to the browser. Controller 
+
+methods (also known asaction methods), such as the Index method above, generally return anActionResult (or a 
+
+class derrived fromActionResult), not primitive types like string.  
+
+In the project, add a view template that you can use with the Index method. To do this, right-click inside the 
+
+Index method and clickAdd View. 
+
+ 
+The Add View dialog box appears. Leave the defaults the way they are and click the Add button: 
+
+The MvcMovie\Views\HelloWorld folder and the MvcMovie\Views\HelloWorld\Index.cshtml file are created. You 
+
+can see them in Solution Explorer: 
+
+ 
+The following shows the Index.cshtml file that was created: 
+
+ 
+Add the following HTML under the <h2> tag. 
+
+<p>Hello from our View Template!</p> 
+
+The complete MvcMovie\Views\HelloWorld\Index.cshtml file is shown below. 
+
+@{  
+
+    ViewBag.Title = "Index";  
+
+}  
+
+ 
+<h2>Index</h2> 
+
+<p>Hello from our View Template!</p> 
+
+In solution explorer, right click the Index.cshtml file and selectView in Page Inspector. 
+
+ThePage Inspector tutorial has more information about this new tool. 
+
+ 
+ 
+ 
+Alternatively, run the application and browse to the HelloWorld controller (http://localhost:xxxx/HelloWorld). 
+
+The Index method in your controller didn't do much work; it simply ran the statement return View(), which 
+
+specified that the method should use a view template file to render a response to the browser. Because you 
+
+didn't explicitly specify the name of the view template file to use, ASP.NET MVC defaulted to using the 
+
+Index.cshtml view file in the \Views\HelloWorld folder. The image below shows the string hard-coded in the 
+
+view. 
+
+Looks pretty good. However, notice that the browser's title bar shows "Index My ASP.NET A" and the big link on 
+
+the top of the page says "your logo here." Below the "your logo here." link are registration and log in links, and 
+
+below that links to Home, About and Contact pages. Let's change some of these. 
+
+Changing Views and Layout Pages 
+
+First, you want to change the "your logo here." title at the top of the page. That text is common to every page. 
+
+It's actually implemented in only one place in the project, even though it appears on every page in the 
+
+application. Go to the /Views/Shared folder in Solution Explorer and open the _Layout.cshtml file. This file is 
+
+called a layout page and it's the shared "shell" that all other pages use. 
+
+ 
+ 
+Layout templates allow you to specify the HTML container layout of your site in one place and then apply it 
+
+across multiple pages in your site. Find the@RenderBody() line. RenderBody is a placeholder where all the 
+
+view-specific pages you create show up, "wrapped" in the layout page. For example, if you select the About link, 
+
+the Views\Home\About.cshtml view is rendered inside the RenderBody method. 
+
+Change the site-title heading in the layout template from "your logo here" to "MVC Movie". 
+
+<divclass="float-left"> 
+
+<pclass="site-title">@Html.ActionLink("MVC Movie", "Index", "Home")</p> 
+
+</div> 
+
+Replace the contents of the title element with the following markup: 
+
+<title>@ViewBag.Title - Movie App</title> 
+
+The ViewBag is a zzz (dict object) Run the application and notice that it now says "MVC Movie ". Click theAbout 
+
+link, and you see how that page shows "MVC Movie", too. We were able to make the change once in the layout 
+
+template and have all pages on the site reflect the new title. 
+
+The complete _Layout.cshtml file is shown below: 
+
+<!DOCTYPE html> 
+
+<htmllang="en"> 
+
+<head> 
+
+<metacharset="utf-8"/> 
+
+<title>@ViewBag.Title - Movie App</title> 
+
+<linkhref="~/favicon.ico"rel="shortcut icon"type="image/x-icon"/> 
+
+<linkhref="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Content/c
+
+ss")"rel="stylesheet"type="text/css"/> 
+
+<linkhref="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Content/t
+
+hemes/base/css")"rel="stylesheet"type="text/css"/> 
+
+<scriptsrc="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Scripts/
+
+js")"></script> 
+
+<metaname="viewport"content="width=device-width"/> 
+
+</head> 
+
+ 
+<body> 
+
+<header> 
+
+<divclass="content-wrapper"> 
+
+<divclass="float-left"> 
+
+<pclass="site-title">@Html.ActionLink("MVC Movie", "Index", "Home")</p> 
+
+</div> 
+
+<divclass="float-right"> 
+
+<sectionid="login"> 
+
+@Html.Partial("_LoginPartial")  
+
+</section> 
+
+<nav> 
+
+<ulid="menu"> 
+
+<li>@Html.ActionLink("Home", "Index", "Home")</li> 
+
+<li>@Html.ActionLink("About", "About", "Home")</li> 
+
+<li>@Html.ActionLink("Contact", "Contact", "Home")</li> 
+
+</ul> 
+
+</nav> 
+
+</div> 
+
+</div> 
+
+</header> 
+
+<divid="body"> 
+
+@RenderSection("featured", required: false)  
+
+<sectionclass="content-wrapper main-content clear-fix"> 
+
+@RenderBody() 
+
+</section> 
+
+</div> 
+
+<footer> 
+
+<divclass="content-wrapper"> 
+
+<divclass="float-left"> 
+
+<p>&copy; @DateTime.Now.Year - My ASP.NET MVC Application</p> 
+
+</div> 
+
+<divclass="float-right"> 
+
+<ulid="social"> 
+
+<li><ahref="http://facebook.com"class="facebook">Facebook</a></li> 
+
+<li><ahref="http://twitter.com"class="twitter">Twitter</a></li> 
+
+</ul> 
+
+</div> 
+
+</div> 
+
+</footer> 
+
+</body> 
+
+</html> 
+
+Now, let's change the title of the Index view. 
+
+Open MvcMovie\Views\HelloWorld\Index.cshtml. There are two places to make a change: first, the text that 
+
+appears in the title of the browser, and then in the secondary header (the <h2> element). You'll make them 
+
+slightly different so you can see which bit of code changes which part of the app. 
+
+@{  
+
+    ViewBag.Title = "Movie List";  
+
+}  
+
+<h2>My Movie List</h2> 
+
+<p>Hello from our View Template!</p> 
+
+To indicate the HTML title to display, the code above sets a Title property of the ViewBag object (which is in 
+
+the Index.cshtml view template). If you look back at the source code of the layout template, you’ll notice that 
+
+the template uses this value in the <title> element as part of the <head> section of the HTML that we 
+
+modified previously. Using this ViewBag approach, you can easily pass other parameters between your view 
+
+template and your layout file. 
+
+Run the application and browse to http://localhost:xx/HelloWorld. Notice that the browser title, the primary 
+
+heading, and the secondary headings have changed. (If you don't see changes in the browser, you might be 
+
+viewing cached content. Press Ctrl+F5 in your browser to force the response from the server to be loaded.) The 
+
+browser title is created with the ViewBag.Title we set in the Index.cshtml view template and the additional "- 
+
+Movie App" added in the layout file. 
+
+Also notice how the content in the Index.cshtml view template was merged with the _Layout.cshtml view 
+
+template and a single HTML response was sent to the browser. Layout templates make it really easy to make 
+
+changes that apply across all of the pages in your application. 
+
+ 
+ 
+Our little bit of "data" (in this case the "Hello from our View Template!" message) is hard-coded, though. The 
+
+MVC application has a "V" (view) and you've got a "C" (controller), but no "M" (model) yet. Shortly, we'll walk 
+
+through how create a database and retrieve model data from it. 
+
+Passing Data from the Controller to the View 
+
+Before we go to a database and talk about models, though, let's first talk about passing information from the 
+
+controller to a view. Controller classes are invoked in response to an incoming URL request. A controller class is 
+
+where you write the code that handles the incoming browser requests, retrieves data from a database, and 
+
+ultimately decides what type of response to send back to the browser. View templates can then be used from a 
+
+controller to generate and format an HTML response to the browser. 
+
+Controllers are responsible for providing whatever data or objects are required in order for a view template to 
+
+render a response to the browser. A best practice: A view template should never perform business logic or 
+
+interact with a database directly. Instead, a view template should work only with the data that's provided to it 
+
+by the controller. Maintaining this "separation of concerns" helps keep your code clean, testable and more 
+
+maintainable. 
+
+ 
+Currently, the Welcome action method in the HelloWorldController class takes a name and a numTimes 
+
+parameter and then outputs the values directly to the browser. Rather than have the controller render this 
+
+response as a string, let’s change the controller to use a view template instead. The view template will generate 
+
+a dynamic response, which means that you need to pass appropriate bits of data from the controller to the view 
+
+in order to generate the response. You can do this by having the controller put the dynamic data (parameters) 
+
+that the view template needs in a ViewBag object that the view template can then access. 
+
+Return to the HelloWorldController.cs file and change the Welcome method to add a Message and NumTimes 
+
+value to the ViewBag object. ViewBag is a dynamic object, which means you can put whatever you want in to 
+
+it; the ViewBag object has no defined properties until you put something inside it. TheASP.NET MVC model 
+
+binding system automatically maps the named parameters (nameand numTimes) from the query string in the 
+
+address bar to parameters in your method. The completeHelloWorldController.cs file looks like this: 
+
+usingSystem.Web; 
+
+usingSystem.Web.Mvc; 
+
+namespaceMvcMovie.Controllers 
+
+{ 
+
+publicclassHelloWorldController:Controller 
+
+{ 
+
+publicActionResultIndex() 
+
+{ 
+
+returnView(); 
+
+} 
+
+publicActionResultWelcome(string name,int numTimes =1) 
+
+{ 
+
+ViewBag.Message="Hello "+ name; 
+
+ViewBag.NumTimes= numTimes; 
+
+returnView(); 
+
+} 
+
+} 
+
+} 
+
+Now the ViewBag object contains data that will be passed to the view automatically. 
+
+ 
+ 
+ 
+Next, you need a Welcome view template! In the Build menu, select Build MvcMovie to make sure the project 
+
+is compiled. 
+
+Then right-click inside the Welcome method and click Add View. 
+
+ 
+ 
+Here's what the Add View dialog box looks like: 
+
+Click Add, and then add the following code under the < h2> element in the new Welcome.cshtml file. You'll 
+
+create a loop that says "Hello" as many times as the user says it should. The completeWelcome.cshtml file is 
+
+shown below. 
+
+@{  
+
+    ViewBag.Title = "Welcome";  
+
+}  
+
+<h2>Welcome</h2> 
+
+<ul> 
+
+ 
+ 
+ 
+   @for (int i=0; i < ViewBag.NumTimes; i++) {   
+
+<li>@ViewBag.Message</li> 
+
+   }   
+
+</ul> 
+
+Run the application and browse to the following URL: 
+
+http://localhost:xx/HelloWorld/Welcome?name=Scott&numtimes=4 
+
+Now data is taken from the URL and passed to the controller using themodel binder. The controller packages 
+
+the data into a ViewBag object and passes that object to the view. The view then displays the data as HTML to 
+
+the user. 
+
+Well, that was a kind of an "M" for model, but not the database kind. Let's take what we've learned and create a 
+
+database of movies. 
+
+ 
+ 
+ 
+Adding a Model 
+
+In this section you'll add some classes for managing movies in a database. These classes will be the "model" 
+
+part of the ASP.NET MVC application. 
+
+You’ll use a .NET Framework data-access technology known as the Entity Framework to define and work with 
+
+these model classes. The Entity Framework (often referred to as EF) supports a development paradigm called 
+
+Code First. Code First allows you to create model objects by writing simple classes. (These are also known as 
+
+POCO classes, from "plain-old CLR objects.") You can then have the database created on the fly from your 
+
+classes, which enables a very clean and rapid development workflow.  
+
+Adding Model Classes 
+
+In Solution Explorer, right click the Models folder, select Add, and then select New Item. 
+
+ 
+In the Add New Item dialog, select Class then name the class "Movie". 
+
+ 
+Add the following five properties to the Movie class: 
+
+publicclassMovie 
+
+{ 
+
+publicint ID {get;set;} 
+
+publicstringTitle{get;set;} 
+
+publicDateTimeReleaseDate{get;set;} 
+
+publicstringGenre{get;set;} 
+
+publicdecimalPrice{get;set;} 
+
+ 
+} 
+
+We'll use the Movie class to represent movies in a database. Each instance of a Movie object will correspond to 
+
+a row within a database table, and each property of the Movie class will map to a column in the table.  
+
+In the same file, add the following MovieDBContext class: 
+
+publicclassMovieDBContext:DbContext 
+
+{ 
+
+publicDbSet<Movie>Movies{get;set;} 
+
+} 
+
+The MovieDBContext class represents the Entity Framework movie database context, which handles fetching, 
+
+storing, and updating Movie class instances in a database. The MovieDBContext derives from theDbContext 
+
+base class provided by the Entity Framework. For more information about DbContext and DbSet, 
+
+seeProductivity Improvements for the Entity Framework.  
+
+In order to be able to reference DbContext and DbSet, you need to add the following using statement at the 
+
+top of the file: 
+
+usingSystem.Data.Entity; 
+
+The complete Movie.cs file is shown below. (Several using statements that are not needed have been removed.) 
+
+usingSystem; 
+
+usingSystem.Data.Entity; 
+
+namespaceMvcMovie.Models 
+
+{ 
+
+publicclassMovie 
+
+{ 
+
+publicint ID {get;set;} 
+
+publicstringTitle{get;set;} 
+
+publicDateTimeReleaseDate{get;set;} 
+
+publicstringGenre{get;set;} 
+
+publicdecimalPrice{get;set;} 
+
+ 
+} 
+
+publicclassMovieDBContext:DbContext 
+
+{ 
+
+publicDbSet<Movie>Movies{get;set;} 
+
+} 
+
+} 
+
+Creating a Connection String and Working with SQL Server LocalDB 
+
+The MovieDBContext class you created handles the task of connecting to the database and mapping Movie 
+
+objects to database records. One question you might ask, though, is how to specify which database it will 
+
+connect to. You'll do that by adding connection information in the Web.config file of the application. 
+
+Open the application root Web.config file. (Not the Web.configfile in the Views folder.) Open the Web.config file 
+
+outlined in red. 
+
+Add the following connection string to the <connectionStrings> element in the Web.config file. 
+
+<addname="MovieDBContext" 
+
+ 
+ 
+connectionString="Data 
+
+Source=(LocalDB)\v11.0;AttachDbFilename=|DataDirectory|\Movies.mdf;Integrated 
+
+Security=True" 
+
+providerName="System.Data.SqlClient" 
+
+/> 
+
+The following example shows a portion of the Web.config file with the new connection string added:  
+
+<connectionStrings> 
+
+<addname="DefaultConnection" 
+
+connectionString="Data Source=(LocalDb)\v11.0;Initial Catalog=aspnet-MvcMovie-
+
+2012213181139;Integrated Security=true" 
+
+providerName="System.Data.SqlClient" 
+
+/> 
+
+<addname="MovieDBContext" 
+
+connectionString="Data 
+
+Source=(LocalDB)\v11.0;AttachDbFilename=|DataDirectory|\Movies.mdf;Integrated 
+
+Security=True" 
+
+providerName="System.Data.SqlClient" 
+
+/> 
+
+</connectionStrings> 
+
+This small amount of code and XML is everything you need to write in order to represent and store the movie 
+
+data in a database.  
+
+Next, you'll build a new MoviesController class that you can use to display the movie data and allow users 
+
+to create new movie listings. 
+
+ 
+ 
+Accessing Your Model's Data from a Controller 
+
+In this section, you'll create a new MoviesController class and write code that retrieves the movie data and 
+
+displays it in the browser using a view template.  
+
+Build the application before going on to the next step. 
+
+Right-click the Controllers folder and create a new MoviesController controller. The options below will not 
+
+appear until you build your application. Select the following options: 
+
+•  Controller name: MoviesController. (This is the default. ) 
+
+• 
+
+Template: Controller with read/write actions and views, using Entity Framework.  
+
+•  Model class: Movie (MvcMovie.Models).  
+
+•  Data context class: MovieDBContext (MvcMovie.Models).  
+
+•  Views: Razor (CSHTML). (The default.)  
+
+Click Add. Visual Studio Express creates the following files and folders: 
+
+•  A MoviesController.csfile in the project's Controllers folder.  
+
+ 
+•  A Movies folder in the project's Views folder.  
+
+•  Create.cshtml, Delete.cshtml, Details.cshtml, Edit.cshtml, and Index.cshtml in the new Views\Movies folder.  
+
+ 
+ASP.NET MVC 4 automatically created the CRUD (create, read, update, and delete) action methods and views 
+
+for you (the automatic creation of CRUD action methods and views is known as scaffolding). You now have a 
+
+fully functional web application that lets you create, list, edit, and delete movie entries. 
+
+Run the application and browse to the Movies controller by appending /Movies to the URL in the address bar 
+
+of your browser. Because the application is relying on the default routing (defined in the Global.asax file), the 
+
+browser request http://localhost:xxxxx/Movies is routed to the default Index action method of the Movies 
+
+controller. In other words, the browser request http://localhost:xxxxx/Movies is effectively the same as the 
+
+browser request http://localhost:xxxxx/Movies/Index. The result is an empty list of movies, because you haven't 
+
+added any yet. 
+
+Creating a Movie 
+
+Select the Create New link. Enter some details about a movie and then click the Create button. 
+
+ 
+Clicking the Create button causes the form to be posted to the server, where the movie information is saved in 
+
+the database. You're then redirected to the /Movies URL, where you can see the newly created movie in the 
+
+listing. 
+
+ 
+Create a couple more movie entries. Try the Edit, Details, and Delete links, which are all functional. 
+
+Examining the Generated Code 
+
+Open the Controllers\MoviesController.cs file and examine the generated Index method. A portion of the movie 
+
+controller with theIndex method is shown below. 
+
+publicclassMoviesController:Controller 
+
+{ 
+
+privateMovieDBContext db =newMovieDBContext(); 
+
+// 
+
+// GET: /Movies/ 
+
+publicActionResultIndex() 
+
+{ 
+
+returnView(db.Movies.ToList()); 
+
+ 
+ 
+ 
+} 
+
+The following line from the MoviesController class instantiates a movie database context, as described 
+
+previously. You can use the movie database context to query, edit, and delete movies. 
+
+privateMovieDBContext db =newMovieDBContext(); 
+
+A request to the Movies controller returns all the entries in the Movies table of the movie database and then 
+
+passes the results to the Index view. 
+
+Strongly Typed Models and the @model Keyword 
+
+Earlier in this tutorial, you saw how a controller can pass data or objects to a view template using the ViewBag 
+
+object. The ViewBag is a dynamic object that provides a convenient late-bound way to pass information to a 
+
+view. 
+
+ASP.NET MVC also provides the ability to pass strongly typed data or objects to a view template. This strongly 
+
+typed approach enables better compile-time checking of your code and richer IntelliSense in the Visual Studio 
+
+Express editor. The scaffolding mechanism in Visual Studio Express used this approach with the 
+
+MoviesController class and view templates when it created the methods and views. 
+
+In the Controllers\MoviesController.cs file examine the generated Details method. A portion of the movie 
+
+controller with theDetails method is shown below. 
+
+publicActionResultDetails(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+An instance of the Movie model is passed to the Details view. 
+
+By including a @model statement at the top of the view template file, you can specify the type of object that the 
+
+view expects. When you created the movie controller, Visual Studio Express automatically included the 
+
+following@model statement at the top of the Details.cshtml file: 
+
+@model MvcMovie.Models.Movie 
+
+This @model directive allows you to access the movie that the controller passed to the view by using a Model 
+
+object that's strongly typed. For example, in the Details.cshtml template, the code passes each movie field to 
+
+the DisplayNameFor and DisplayFor HTML Helpers with the strongly typed Model object. The Create and Edit 
+
+methods and view templates also pass a movie model object. 
+
+Examine the Index.cshtml view template and the Index method in the MoviesController.cs file. Notice how the 
+
+code creates aList object when it calls the View helper method in the Index action method. The code then 
+
+passes this Movies list from the controller to the view: 
+
+publicActionResultIndex() 
+
+{ 
+
+returnView(db.Movies.ToList()); 
+
+} 
+
+When you created the movie controller, Visual Studio Express automatically included the following@model 
+
+statement at the top of the Index.cshtml file: 
+
+@model IEnumerable<MvcMovie.Models.Movie> 
+
+This @model directive allows you to access the list of movies that the controller passed to the view by using a 
+
+Model object that's strongly typed. For example, in the Index.cshtml template, the code loops through the 
+
+movies by doing a foreach statement over the strongly typed Model object: 
+
+@foreach (var item in Model) {  
+
+<tr> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Title)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.ReleaseDate)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Genre)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Price)  
+
+</td> 
+
+<th> 
+
+@Html.DisplayFor(modelItem => item.Rating)  
+
+</th> 
+
+<td> 
+
+@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |  
+
+@Html.ActionLink("Details", "Details", { id=item.ID })  |  
+
+@Html.ActionLink("Delete", "Delete", { id=item.ID })   
+
+</td> 
+
+</tr> 
+
+} 
+
+Because the Model object is strongly typed (as an IEnumerable<Movie> object), each item object in the loop 
+
+is typed as Movie. Among other benefits, this means that you get compile-time checking of the code and full 
+
+IntelliSense support in the code editor: 
+
+ 
+Working with SQL Server LocalDB 
+
+Entity Framework Code First detected that the database connection string that was provided pointed to a 
+
+Movies database that didn’t exist yet, so Code First created the database automatically. You can verify that it's 
+
+been created by looking in the App_Data folder. If you don't see the Movies.sdf file, click the Show All Files 
+
+button in theSolution Explorer toolbar, click the Refresh button, and then expand the App_Data folder. 
+
+ 
+Double-click Movies.mdf to open DATABASE EXPLORER. Then expand the Tables folder to see the tables that 
+
+have been created in the database. 
+
+ 
+ 
+There are two tables, one for the Movie entity set and theEdmMetadata table. The EdmMetadata table is used 
+
+by the Entity Framework to determine when the model and the database are out of sync.  
+
+Right-click the Movies table and select Show Table Data to see the data you created. 
+
+Right-click the Movies table and select Open Table Definition to see the table structure that Entity Framework 
+
+Code First created for you. 
+
+ 
+ 
+Notice how the schema of the Movies table maps to the Movie class you created earlier. Entity Framework 
+
+Code First automatically created this schema for you based on your Movie class. 
+
+When you're finished, close the connection by right clicking Movies.mdf and selecting Close Connection. (If you 
+
+don't close the connection, you might get an error the next time you run the project).  
+
+ 
+You now have the database and a simple listing page to display content from it. In the next tutorial, we'll 
+
+examine the rest of the scaffolded code and add a SearchIndex method and a SearchIndex view that lets 
+
+you search for movies in this database. 
+
+ 
+ 
+ 
+Examining the Edit Methods and Edit View 
+
+In this section, you'll examine the generated action methods and views for the movie controller. Then you'll add 
+
+a custom search page. 
+
+Run the application and browse to the Movies controller by appending /Movies to the URL in the address bar 
+
+of your browser. Hold the mouse pointer over an Edit link to see the URL that it links to. 
+
+The Edit link was generated by the Html.ActionLink method in the Views\Movies\Index.cshtml view: 
+
+@Html.ActionLink("Edit", "Edit", new { id=item.ID })  
+
+ 
+The Html object is a helper that's exposed using a property on the System.Web.Mvc.WebViewPage base class. 
+
+The ActionLinkmethod of the helper makes it easy to dynamically generate HTML hyperlinks that link to 
+
+action methods on controllers. The first argument to the ActionLink method is the link text to render (for 
+
+example,<a>Edit Me</a>). The second argument is the name of the action method to invoke. The final 
+
+argument is ananonymous object that generates the route data (in this case, the ID of 4). 
+
+The generated link shown in the previous image is http://localhost:xxxxx/Movies/Edit/4. The default route 
+
+(established in Global.asax.cs) takes the URL pattern {controller}/{action}/{id}. Therefore, ASP.NET 
+
+translateshttp://localhost:xxxxx/Movies/Edit/4 into a request to the Edit action method of the Movies 
+
+controller with the parameter ID equal to 4.  
+
+You can also pass action method parameters using a query string. For example, the URL 
+
+http://localhost:xxxxx/Movies/Edit?ID=4 also passes the parameter ID of 4 to the Edit action method of 
+
+theMovies controller. 
+
+ 
+Open the Movies controller. The two Edit action methods are shown below. 
+
+// 
+
+// GET: /Movies/Edit/5 
+
+publicActionResultEdit(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+ 
+ 
+returnView(movie); 
+
+} 
+
+// 
+
+// POST: /Movies/Edit/5 
+
+[HttpPost] 
+
+publicActionResultEdit(Movie movie) 
+
+{ 
+
+if(ModelState.IsValid) 
+
+{ 
+
+db.Entry(movie).State=EntityState.Modified; 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+Notice the second Edit action method is preceded by the HttpPost attribute. This attribute specifies that that 
+
+overload of the Edit method can be invoked only for POST requests. You could apply the HttpGet attribute to 
+
+the first edit method, but that's not necessary because it's the default. (We'll refer to action methods that are 
+
+implicitly assigned the HttpGet attribute as HttpGet methods.) 
+
+The HttpGetEdit method takes the movie ID parameter, looks up the movie using the Entity Framework Find 
+
+method, and returns the selected movie to the Edit view. The ID parameter specifies a default value of zero if 
+
+the Edit method is called without a parameter. If a movie cannot be found, HttpNotFound is returned. When 
+
+the scaffolding system created the Edit view, it examined the Movie class and created code to render <label> 
+
+and <input> elements for each property of the class. The following example shows the Edit view that was 
+
+generated: 
+
+@model MvcMovie.Models.Movie  
+
+@{  
+
+    ViewBag.Title = "Edit";  
+
+}  
+
+<h2>Edit</h2> 
+
+ 
+ 
+ 
+ 
+<scriptsrc="@Url.Content("~/Scripts/jquery.validate.min.js")"type="text/javascript"><
+
+/script> 
+
+<scriptsrc="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")"type="text/j
+
+avascript"></script> 
+
+@using (Html.BeginForm()) {  
+
+@Html.ValidationSummary(true)  
+
+<fieldset> 
+
+<legend>Movie</legend> 
+
+@Html.HiddenFor(model => model.ID)  
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Title)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Title)  
+
+@Html.ValidationMessageFor(model => model.Title)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.ReleaseDate)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.ReleaseDate)  
+
+@Html.ValidationMessageFor(model => model.ReleaseDate)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Genre)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Genre)  
+
+@Html.ValidationMessageFor(model => model.Genre)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+@Html.LabelFor(model => model.Price)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Price)  
+
+@Html.ValidationMessageFor(model => model.Price)  
+
+</div> 
+
+<p> 
+
+<inputtype="submit"value="Save"/> 
+
+</p> 
+
+</fieldset> 
+
+}  
+
+<div> 
+
+@Html.ActionLink("Back to List", "Index")  
+
+</div> 
+
+Notice how the view template has a @model MvcMovie.Models.Movie statement at the top of the file — this 
+
+specifies that the view expects the model for the view template to be of type Movie. 
+
+The scaffolded code uses several helper methods to streamline the HTML markup. TheHtml.LabelFor helper 
+
+displays the name of the field ("Title", "ReleaseDate", "Genre", or "Price"). TheHtml.EditorFor helper renders 
+
+an HTML <input> element. TheHtml.ValidationMessageFor helper displays any validation messages 
+
+associated with that property.  
+
+Run the application and navigate to the /Movies URL. Click anEdit link. In the browser, view the source for the 
+
+page. The HTML for the form element is shown below. 
+
+<formaction="/Movies/Edit/4"method="post"><fieldset> 
+
+<legend>Movie</legend> 
+
+<inputdata-val="true"data-val-number="The field ID must be a number."data-val-
+
+required="The ID field is required."id="ID"name="ID"type="hidden"value="4"/> 
+
+<divclass="editor-label"> 
+
+<labelfor="Title">Title</label> 
+
+</div> 
+
+ 
+ 
+ 
+ 
+<divclass="editor-field"> 
+
+<inputclass="text-box single-line"id="Title"name="Title"type="text"value="Rio 
+
+Bravo"/> 
+
+<spanclass="field-validation-valid"data-valmsg-for="Title"data-valmsg-
+
+replace="true"></span> 
+
+</div> 
+
+<divclass="editor-label"> 
+
+<labelfor="ReleaseDate">ReleaseDate</label> 
+
+</div> 
+
+<divclass="editor-field"> 
+
+<inputclass="text-box single-line"data-val="true"data-val-date="The field ReleaseDate 
+
+must be a date."data-val-required="The ReleaseDate field is 
+
+required."id="ReleaseDate"name="ReleaseDate"type="text"value="4/15/1959 12:00:00 
+
+AM"/> 
+
+<spanclass="field-validation-valid"data-valmsg-for="ReleaseDate"data-valmsg-
+
+replace="true"></span> 
+
+</div> 
+
+<divclass="editor-label"> 
+
+<labelfor="Genre">Genre</label> 
+
+</div> 
+
+<divclass="editor-field"> 
+
+<inputclass="text-box single-line"id="Genre"name="Genre"type="text"value="Western"/> 
+
+<spanclass="field-validation-valid"data-valmsg-for="Genre"data-valmsg-
+
+replace="true"></span> 
+
+</div> 
+
+<divclass="editor-label"> 
+
+<labelfor="Price">Price</label> 
+
+</div> 
+
+<divclass="editor-field"> 
+
+<inputclass="text-box single-line"data-val="true"data-val-number="The field Price 
+
+must be a number."data-val-required="The Price field is 
+
+required."id="Price"name="Price"type="text"value="2.99"/> 
+
+<spanclass="field-validation-valid"data-valmsg-for="Price"data-valmsg-
+
+replace="true"></span> 
+
+</div> 
+
+ 
+ 
+ 
+<p> 
+
+<inputtype="submit"value="Save"/> 
+
+</p> 
+
+</fieldset> 
+
+</form> 
+
+The <input> elements are in an HTML <form> element whose action attribute is set to post to the 
+
+/Movies/Edit URL. The form data will be posted to the server when the Edit button is clicked. 
+
+Processing the POST Request 
+
+The following listing shows the HttpPost version of the Edit action method. 
+
+[HttpPost] 
+
+publicActionResultEdit(Movie movie) 
+
+{ 
+
+if(ModelState.IsValid) 
+
+{ 
+
+db.Entry(movie).State=EntityState.Modified; 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+The ASP.NET MVC model binder takes the posted form values and creates aMovie object that's passed as the 
+
+movie parameter. TheModelState.IsValid method verifies that the data submitted in the form can be used 
+
+to modify (edit or update) a Movie object. If the data is valid, the movie data is saved to the Movies collection 
+
+of the db (MovieDBContext instance). The new movie data is saved to the database by calling the 
+
+SaveChanges method ofMovieDBContext. After saving the data, the code redirects the user to the Index 
+
+action method of the MoviesController class, which displays the of movie collection, including the changes 
+
+just made.. 
+
+If the posted values aren't valid, they are redisplayed in the form. TheHtml.ValidationMessageFor helpers 
+
+in the Edit.cshtml view template take care of displaying appropriate error messages. 
+
+ 
+Note about locales If you normally work with a locale other than English, see Supporting ASP.NET MVC 
+
+Validation with Non-English Locales. The decimal field may require a common, not a decimal point. As a 
+
+temporary fix, you can add the globalization element to the projects root web.config file. The following code 
+
+shows the globalization element with the culture set to United States English. 
+
+ 
+<system.web> 
+
+<globalizationculture="en-US"/> 
+
+<!--elements removed for clarity--> 
+
+</system.web> 
+
+All the HttpGet methods follow a similar pattern. They get a movie object (or list of objects, in the case of 
+
+Index), and pass the model to the view. The Create method passes an empty movie object to the Create view. 
+
+All the methods that create, edit, delete, or otherwise modify data do so in the HttpPost overload of the 
+
+method. Modifying data in an HTTP GET method is a security risk, as described in the blog post entryASP.NET 
+
+MVC Tip #46 – Don’t use Delete Links because they create Security Holes. Modifying data in a GET method also 
+
+violates HTTP best practices and the architectural REST pattern, which specifies that GET requests should not 
+
+change the state of your application. In other words, performing a GET operation should be a safe operation 
+
+that has no side effects and doesn't modify your persisted data. 
+
+Adding a Search Method and Search View 
+
+In this section you'll add a SearchIndex action method that lets you search movies by genre or name. This will 
+
+be available using the /Movies/SearchIndex URL. The request will display an HTML form that contains input 
+
+elements that a user can enter in order to search for a movie. When a user submits the form, the action method 
+
+will get the search values posted by the user and use the values to search the database. 
+
+Displaying the SearchIndex Form 
+
+Start by adding a SearchIndex action method to the existingMoviesController class. The method will 
+
+return a view that contains an HTML form. Here's the code: 
+
+publicActionResultSearchIndex(string searchString) 
+
+{ 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+ 
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+returnView(movies); 
+
+} 
+
+The first line of the SearchIndex method creates the followingLINQ query to select the movies:  
+
+var movies =from m in db.Movies 
+
+select m; 
+
+The query is defined at this point, but hasn't yet been run against the data store. 
+
+If the searchString parameter contains a string, the movies query is modified to filter on the value of the 
+
+search string, using the following code: 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+The s => s.Title code above is aLambda Expression. Lambdas are used in method-basedLINQ queries as 
+
+arguments to standard query operator methods such asWhere method used in the above code. LINQ queries 
+
+are not executed when they are defined or when they are modified by calling a method such as Where or 
+
+OrderBy. Instead, query execution is deferred, which means that the evaluation of an expression is delayed 
+
+until its realized value is actually iterated over or theToList method is called. In the SearchIndex sample, the 
+
+query is executed in the SearchIndex view. For more information about deferred query execution, see Query 
+
+Execution. 
+
+Now you can implement the SearchIndex view that will display the form to the user. Right-click inside the 
+
+SearchIndex method and then click Add View. In the Add View dialog box, specify that you're going to pass 
+
+a Movie object to the view template as its model class. In the Scaffold template list, choose List, then click 
+
+Add. 
+
+ 
+When you click the Add button, the Views\Movies\SearchIndex.cshtml view template is created. Because you 
+
+selected List in the Scaffold template list, Visual Studio Express automatically generated (scaffolded) some 
+
+default markup in the view. The scaffolding created an HTML form. It examined the Movie class and created 
+
+code to render <label> elements for each property of the class. The listing below shows the Create view that 
+
+was generated: 
+
+@model IEnumerable<MvcMovie.Models.Movie> 
+
+@{  
+
+    ViewBag.Title = "SearchIndex";  
+
+}  
+
+<h2>SearchIndex</h2> 
+
+ 
+ 
+ 
+ 
+<p> 
+
+@Html.ActionLink("Create New", "Create")  
+
+</p> 
+
+<table> 
+
+<tr> 
+
+<th> 
+
+            Title  
+
+</th> 
+
+<th> 
+
+            ReleaseDate  
+
+</th> 
+
+<th> 
+
+            Genre  
+
+</th> 
+
+<th> 
+
+            Price  
+
+</th> 
+
+<th></th> 
+
+</tr> 
+
+@foreach (var item in Model) {  
+
+<tr> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Title)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.ReleaseDate)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Genre)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Price)  
+
+</td> 
+
+<td> 
+
+@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |  
+
+@Html.ActionLink("Details", "Details", new { id=item.ID }) |  
+
+@Html.ActionLink("Delete", "Delete", new { id=item.ID })  
+
+ 
+</td> 
+
+</tr> 
+
+}  
+
+</table> 
+
+Run the application and navigate to /Movies/SearchIndex. Append a query string such as 
+
+?searchString=ghost to the URL. The filtered movies are displayed. 
+
+If you change the signature of the SearchIndex method to have a parameter named id, the id parameter will 
+
+match the{id} placeholder for the default routes set in the Global.asax file. 
+
+{controller}/{action}/{id} 
+
+ 
+ 
+The original SearchIndex method looks like this:: 
+
+publicActionResultSearchIndex(string searchString) 
+
+{ 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+returnView(movies); 
+
+} 
+
+The modified SearchIndex method would look as follows: 
+
+publicActionResultSearchIndex(string id) 
+
+{ 
+
+string searchString = id; 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+returnView(movies); 
+
+} 
+
+You can now pass the search title as route data (a URL segment) instead of as a query string value. 
+
+ 
+ 
+ 
+ 
+However, you can't expect users to modify the URL every time they want to search for a movie. So now you 
+
+you'll add UI to help them filter movies. If you changed the signature of the SearchIndex method to test how 
+
+to pass the route-bound ID parameter, change it back so that your SearchIndex method takes a string 
+
+parameter named searchString: 
+
+publicActionResultSearchIndex(string searchString) 
+
+{ 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+ 
+ 
+ 
+returnView(movies); 
+
+} 
+
+Open the Views\Movies\SearchIndex.cshtml file, and just after @Html.ActionLink("Create New", 
+
+"Create"), add the following: 
+
+@using (Html.BeginForm()){     
+
+<p> Title: @Html.TextBox("SearchString")<br/> 
+
+<inputtype="submit"value="Filter"/></p> 
+
+        } 
+
+The following example shows a portion of the Views\Movies\SearchIndex.cshtml file with the added filtering 
+
+markup. 
+
+@model IEnumerable<MvcMovie.Models.Movie> 
+
+@{  
+
+    ViewBag.Title = "SearchIndex";  
+
+}  
+
+<h2>SearchIndex</h2> 
+
+<p> 
+
+@Html.ActionLink("Create New", "Create")  
+
+     @using (Html.BeginForm()){     
+
+<p> Title: @Html.TextBox("SearchString") <br/> 
+
+<inputtype="submit"value="Filter"/></p> 
+
+        }  
+
+</p> 
+
+The Html.BeginForm helper creates an opening <form> tag. The Html.BeginForm helper causes the form to 
+
+post to itself when the user submits the form by clicking the Filter button. 
+
+Run the application and try searching for a movie. 
+
+ 
+ 
+ 
+ 
+There's no HttpPost overload of the SearchIndex method. You don't need it, because the method isn't 
+
+changing the state of the application, just filtering data. 
+
+You could add the following HttpPost SearchIndex method. In that case, the action invoker would match 
+
+the HttpPost SearchIndex method, and the HttpPost SearchIndex method would run as shown in the 
+
+image below. 
+
+[HttpPost] 
+
+publicstringSearchIndex(FormCollection fc,string searchString) 
+
+{ 
+
+return"<h3> From [HttpPost]SearchIndex: "+ searchString +"</h3>"; 
+
+} 
+
+ 
+However, even if you add this HttpPost version of the SearchIndex method, there's a limitation in how this 
+
+has all been implemented. Imagine that you want to bookmark a particular search or you want to send a link to 
+
+friends that they can click in order to see the same filtered list of movies. Notice that the URL for the HTTP 
+
+POST request is the same as the URL for the GET request (localhost:xxxxx/Movies/SearchIndex) -- there's no 
+
+search information in the URL itself. Right now, the search string information is sent to the server as a form field 
+
+value. This means you can't capture that search information to bookmark or send to friends in a URL. 
+
+The solution is to use an overload of BeginForm that specifies that the POST request should add the search 
+
+information to the URL and that is should be routed to the HttpGet version of the SearchIndex method. 
+
+Replace the existing parameterless BeginForm method with the following:  
+
+@using (Html.BeginForm("SearchIndex","Movies",FormMethod.Get)) 
+
+Now when you submit a search, the URL contains a search query string. Searching will also go to the HttpGet 
+
+SearchIndex action method, even if you have a HttpPost SearchIndex method. 
+
+ 
+ 
+Adding Search by Genre 
+
+If you added the HttpPost version of the SearchIndex method, delete it now.  
+
+Next, you'll add a feature to let users search for movies by genre. Replace the SearchIndex method with the 
+
+following code: 
+
+publicActionResultSearchIndex(string movieGenre,string searchString) 
+
+{ 
+
+varGenreLst=newList<string>(); 
+
+varGenreQry=from d in db.Movies 
+
+orderby d.Genre 
+
+ 
+ 
+select d.Genre; 
+
+GenreLst.AddRange(GenreQry.Distinct()); 
+
+ViewBag.movieGenre =newSelectList(GenreLst); 
+
+var movies =from m in db.Movies 
+
+select m; 
+
+if(!String.IsNullOrEmpty(searchString)) 
+
+{ 
+
+movies= movies.Where(s => s.Title.Contains(searchString)); 
+
+} 
+
+if(string.IsNullOrEmpty(movieGenre)) 
+
+returnView(movies); 
+
+else 
+
+{ 
+
+returnView(movies.Where(x => x.Genre== movieGenre)); 
+
+} 
+
+} 
+
+This version of the SearchIndex method takes an additional parameter, namely movieGenre. The first few 
+
+lines of code create aList object to hold movie genres from the database.  
+
+The following code is a LINQ query that retrieves all the genres from the database. 
+
+varGenreQry=from d in db.Movies 
+
+orderby d.Genre 
+
+select d.Genre; 
+
+The code uses the AddRange method of the generic List collection to add all the distinct genres to the list. 
+
+(Without the Distinct modifier, duplicate genres would be added — for example, comedy would be added 
+
+twice in our sample). The code then stores the list of genres in the ViewBag object. 
+
+The following code shows how to check the movieGenre parameter. If it's not empty, the code further 
+
+constrains the movies query to limit the selected movies to the specified genre. 
+
+ 
+ 
+ 
+ 
+if(string.IsNullOrEmpty(movieGenre)) 
+
+returnView(movies); 
+
+else 
+
+{ 
+
+returnView(movies.Where(x => x.Genre== movieGenre)); 
+
+} 
+
+Adding Markup to the SearchIndex View to Support Search by Genre 
+
+Add an Html.DropDownList helper to the Views\Movies\SearchIndex.cshtml file, just before the TextBox 
+
+helper. The completed markup is shown below: 
+
+<p> 
+
+@Html.ActionLink("Create New", "Create")  
+
+    @using (Html.BeginForm("SearchIndex","Movies",FormMethod.Get)){      
+
+<p>Genre: @Html.DropDownList("movieGenre", "All")    
+
+           Title: @Html.TextBox("SearchString")    
+
+<inputtype="submit"value="Filter"/></p> 
+
+        }  
+
+</p> 
+
+Run the application and browse to /Movies/SearchIndex. Try a search by genre, by movie name, and by both 
+
+criteria. 
+
+In this section you examined the CRUD action methods and views generated by the framework. You created a 
+
+search action method and view that let users search by movie title and genre. In the next section, you'll look at 
+
+how to add a property to the Movie model and how to add an initializer that will automatically create a test 
+
+database. 
+
+ 
+ 
+Adding a New Field to the Movie Model and 
+
+Table 
+
+In this section you'll make some changes to the model classes and learn how you can update the database 
+
+schema to match the model changes. 
+
+Adding a Rating Property to the Movie Model 
+
+Start by adding a new Rating property to the existing Movie class. Open the Models\Movie.cs file and add the 
+
+Rating property like this one: 
+
+publicstringRating{get;set;} 
+
+The complete Movie class now looks like the following code: 
+
+publicclassMovie 
+
+{ 
+
+publicint      ID          {get;set;} 
+
+publicstringTitle{get;set;} 
+
+publicDateTimeReleaseDate{get;set;} 
+
+publicstringGenre{get;set;} 
+
+publicdecimalPrice{get;set;} 
+
+publicstringRating{get;set;} 
+
+} 
+
+Recompile the application using the Build > Build Movie menu command. 
+
+Now that you've updated the Model class, you also need to update the \Views\Movies\Index.cshtml and 
+
+\Views\Movies\Create.cshtml view templates in order to display the new Rating property in the browser view. 
+
+Open the \Views\Movies\Index.cshtml file and add a <th>Rating</th> column heading just after the Price 
+
+column. Then add a <td> column near the end of the template to render the @item.Rating value. Below is 
+
+what the updated Index.cshtml view template looks like: 
+
+@model IEnumerable<MvcMovie.Models.Movie> 
+
+@{  
+
+    ViewBag.Title = "Index";  
+
+}  
+
+<h2>Index</h2> 
+
+<p> 
+
+@Html.ActionLink("Create New", "Create")  
+
+</p> 
+
+<table> 
+
+<tr> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.Title)  
+
+</th> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.ReleaseDate)  
+
+</th> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.Genre)  
+
+</th> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.Price)  
+
+</th> 
+
+<th> 
+
+@Html.DisplayNameFor(model => model.Rating)  
+
+</th> 
+
+<th></th> 
+
+</tr> 
+
+@foreach (var item in Model) {  
+
+<tr> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Title)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.ReleaseDate)  
+
+</td> 
+
+ 
+ 
+ 
+ 
+<td> 
+
+@Html.DisplayFor(modelItem => item.Genre)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Price)  
+
+</td> 
+
+<td> 
+
+@Html.DisplayFor(modelItem => item.Rating)  
+
+</td> 
+
+<td> 
+
+@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |  
+
+@Html.ActionLink("Details", "Details", new { id=item.ID }) |  
+
+@Html.ActionLink("Delete", "Delete", new { id=item.ID })  
+
+</td> 
+
+</tr> 
+
+}  
+
+</table> 
+
+Next, open the \Views\Movies\Create.cshtml file and add the following markup near the end of the form. This 
+
+renders a text box so that you can specify a rating when a new movie is created. 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Rating)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Rating)  
+
+@Html.ValidationMessageFor(model => model.Rating)  
+
+</div> 
+
+Managing Model and Database Schema Differences 
+
+You've now updated the application code to support the new Rating property. 
+
+Now run the application and navigate to the /Movies URL. When you do this, though, you'll see one of the 
+
+following errors: 
+
+ 
+ 
+You're seeing this error because the updated Movie model class in the application is now different than the 
+
+schema of the Movie table of the existing database. (There's no Rating column in the database table.) 
+
+By default, when you use Entity Framework Code First to automatically create a database, as you did earlier in 
+
+this tutorial, Code First adds a table to the database to help track whether the schema of the database is in sync 
+
+with the model classes it was generated from. If they aren't in sync, the Entity Framework throws an error. This 
+
+makes it easier to track down issues at development time that you might otherwise only find (by obscure 
+
+ 
+errors) at run time. The sync-checking feature is what causes the error message to be displayed that you just 
+
+saw. 
+
+There are two approaches to resolving the error: 
+
+1.  Have the Entity Framework automatically drop and re-create the database based on the new model class 
+
+schema. This approach is very convenient when doing active development on a test database; it allows 
+
+you to quickly evolve the model and database schema together. The downside, though, is that you lose 
+
+existing data in the database — so you don't want to use this approach on a production database!  
+
+2.  Explicitly modify the schema of the existing database so that it matches the model classes. The advantage 
+
+of this approach is that you keep your data. You can make this change either manually or by creating a 
+
+database change script.  
+
+For this tutorial, we'll use the first approach — you'll have the Entity Framework Code First automatically re-
+
+create the database anytime the model changes. 
+
+Automatically Re-Creating the Database on Model Changes 
+
+Let's update the application so that Code First automatically drops and re-creates the database anytime you 
+
+change the model for the application.  
+
+Warning You should enable this approach of automatically dropping and re-creating the database only when 
+
+you're using a development or test database, and never on a production database that contains real data. Using 
+
+it on a production server can lead to data loss. 
+
+Stop the debugger. In Solution Explorer, right click the Models folder, select Add, and then select New Item. 
+
+In the Add New Item dialog, select Class then name the class "MovieInitializer". Update the 
+
+MovieInitializer class to contain the following code: 
+
+usingSystem; 
+
+usingSystem.Collections.Generic; 
+
+usingSystem.Data.Entity; 
+
+namespaceMvcMovie.Models{ 
+
+publicclassMovieInitializer:DropCreateDatabaseIfModelChanges<MovieDBContext>{ 
+
+protectedoverridevoidSeed(MovieDBContext context){ 
+
+var movies =newList<Movie>{ 
+
+newMovie{Title="When Harry Met Sally", 
+
+ReleaseDate=DateTime.Parse("1989-1-11"), 
+
+Genre="Romantic Comedy", 
+
+ 
+ 
+ 
+Rating="R", 
+
+Price=7.99M}, 
+
+newMovie{Title="Ghostbusters ", 
+
+ReleaseDate=DateTime.Parse("1984-3-13"), 
+
+Genre="Comedy", 
+
+Rating="R", 
+
+Price=8.99M}, 
+
+newMovie{Title="Ghostbusters 2", 
+
+ReleaseDate=DateTime.Parse("1986-2-23"), 
+
+Genre="Comedy", 
+
+Rating="R", 
+
+Price=9.99M}, 
+
+newMovie{Title="Rio Bravo", 
+
+ReleaseDate=DateTime.Parse("1959-4-15"), 
+
+Genre="Western", 
+
+Rating="R", 
+
+Price=3.99M}, 
+
+}; 
+
+movies.ForEach(d => context.Movies.Add(d)); 
+
+} 
+
+} 
+
+} 
+
+The MovieInitializer class specifies that the database used by the model should be dropped and 
+
+automatically re-created if the model classes ever change.DropCreateDatabaseIfModelChanges initializer 
+
+specifies the DB should be re-created only if the schema changes. Alternatively, you could use 
+
+theDropCreateDatabaseAlways initializer to always recreate and re-seed the database with data the first time 
+
+that a context is used in the application domain. TheDropCreateDatabaseAlways approach is useful in some 
+
+integration testing scenarios. The code that you inserted into the MovieInitializer class includes a includes a 
+
+Seed method that specifies some default data to automatically add to the database any time it's created (or re-
+
+created). This provides a useful way to populate the database with some test data, without requiring you to 
+
+manually populate it each time you make a model change. 
+
+ 
+ 
+ 
+ 
+Now that you've defined the MovieInitializer class, you'll want to wire it up so that each time the 
+
+application runs, it checks whether the model classes are different from the schema in the database. If they are, 
+
+you can run the initializer to re-create the database to match the model and then populate the database with 
+
+the sample data. 
+
+Open the Global.asax filet: 
+
+ 
+The Global.asax file contains the class that defines the entire application for the project, and contains an 
+
+Application_Start event handler that runs when the application first starts. 
+
+At the beginning of the Application_Start method, add a call to Database.SetInitializer as shown 
+
+below: 
+
+protectedvoidApplication_Start() 
+
+{ 
+
+Database.SetInitializer<MovieDBContext>(newMovieInitializer()); 
+
+AreaRegistration.RegisterAllAreas(); 
+
+// Use LocalDB for Entity Framework by default 
+
+Database.DefaultConnectionFactory=newSqlConnectionFactory("Data 
+
+Source=(localdb)\v11.0; Integrated Security=True; MultipleActiveResultSets=True"); 
+
+RegisterGlobalFilters(GlobalFilters.Filters); 
+
+RegisterRoutes(RouteTable.Routes); 
+
+BundleTable.Bundles.RegisterTemplateBundles(); 
+
+} 
+
+Put the cursor on the red squiggly line (on MovieDBContext, orMovieInitializer ) right click and select 
+
+Resolve, then using MvcMovie.Models; 
+
+ 
+ 
+ 
+Alternatively, add the using statement to the top of the file. The using statement references the namespace 
+
+where our MovieInitializer class lives: 
+
+usingMvcMovie.Models;// MovieInitializer 
+
+The Database.SetInitializer statement you just added indicates that the database used by the 
+
+MovieDBContext instance should be automatically deleted and re-created if the schema and the database 
+
+don't match. And as you saw, it will also populate the database with the sample data that's specified in the 
+
+MovieInitializer class. 
+
+Close the Global.asax file. 
+
+Re-run the application and navigate to the /Movies URL. When the application starts, it detects that the model 
+
+structure no longer matches the database schema. It automatically re-creates the database to match the new 
+
+model structure and populates the database with the sample movies: 
+
+ 
+<=""> 
+
+Click the Create New link to add a new movie. Note that you can add a rating. 
+
+Click Create. The new movie, including the rating, now shows up in the movies listing: 
+
+ 
+You should also add the Rating field to the Edit view template. 
+
+In this section you saw how you can modify model objects and keep the database in sync with the changes. You 
+
+also learned a way to populate a newly created database with sample data so you can try out scenarios. Next, 
+
+let's look at how you can add richer validation logic to the model classes and enable some business rules to be 
+
+enforced. 
+
+ 
+Adding Validation to the Model 
+
+In this this section you'll add validation logic to the Movie model, and you'll ensure that the validation rules are 
+
+enforced any time a user attempts to create or edit a movie using the application. 
+
+Keeping Things DRY 
+
+One of the core design tenets of ASP.NET MVC is DRY ("Don't Repeat Yourself"). ASP.NET MVC encourages you 
+
+to specify functionality or behavior only once, and then have it be reflected everywhere in an application. This 
+
+reduces the amount of code you need to write and makes the code you do write less error prone and easier to 
+
+maintain. 
+
+The validation support provided by ASP.NET MVC and Entity Framework Code First is a great example of the 
+
+DRY principle in action. You can declaratively specify validation rules in one place (in the model class) and the 
+
+rules are enforced everywhere in the application. 
+
+Let's look at how you can take advantage of this validation support in the movie application. 
+
+Adding Validation Rules to the Movie Model 
+
+You'll begin by adding some validation logic to the Movie class. 
+
+Open the Movie.cs file. Add a using statement at the top of the file that references 
+
+theSystem.ComponentModel.DataAnnotations namespace: 
+
+usingSystem.ComponentModel.DataAnnotations; 
+
+Notice the namespace does not contain System.Web. DataAnnotations provides a built-in set of validation 
+
+attributes that you can apply declaratively to any class or property. 
+
+Now update the Movie class to take advantage of the built-inRequired,StringLength, andRange validation 
+
+attributes. Use the following code as an example of where to apply the attributes. 
+
+publicclassMovie{ 
+
+publicint ID {get;set;} 
+
+[Required] 
+
+ 
+publicstringTitle{get;set;} 
+
+[DataType(DataType.Date)] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+[Required] 
+
+publicstringGenre{get;set;} 
+
+[Range(1,100)] 
+
+[DataType(DataType.Currency)] 
+
+publicdecimalPrice{get;set;} 
+
+[StringLength(5)] 
+
+publicstringRating{get;set;} 
+
+} 
+
+The validation attributes specify behavior that you want to enforce on the model properties they are applied to. 
+
+The Required attribute indicates that a property must have a value; in this sample, a movie has to have values 
+
+for the Title, ReleaseDate, Genre, and Price properties in order to be valid. The Range attribute constrains 
+
+a value to within a specified range. The StringLength attribute lets you set the maximum length of a string 
+
+property, and optionally its minimum length. Intrinsic types (such as decimal, int, float, DateTime) are 
+
+required by default and don't need the Requiredattribute. 
+
+Code First ensures that the validation rules you specify on a model class are enforced before the application 
+
+saves changes in the database. For example, the code below will throw an exception when the SaveChanges 
+
+method is called, because several required Movie property values are missing and the price is zero (which is out 
+
+of the valid range). 
+
+MovieDBContext db =newMovieDBContext(); 
+
+Movie movie =newMovie(); 
+
+movie.Title="Gone with the Wind"; 
+
+movie.Price=0.0M; 
+
+db.Movies.Add(movie); 
+
+db.SaveChanges();// <= Will throw validation exception   
+
+ 
+ 
+ 
+ 
+ 
+ 
+Having validation rules automatically enforced by the .NET Framework helps make your application more 
+
+robust. It also ensures that you can't forget to validate something and inadvertently let bad data into the 
+
+database. 
+
+Here's a complete code listing for the updated Movie.cs file: 
+
+usingSystem; 
+
+usingSystem.Data.Entity; 
+
+usingSystem.ComponentModel.DataAnnotations; 
+
+namespaceMvcMovie.Models{ 
+
+publicclassMovie{ 
+
+publicint ID {get;set;} 
+
+[Required] 
+
+publicstringTitle{get;set;} 
+
+[DataType(DataType.Date)] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+[Required] 
+
+publicstringGenre{get;set;} 
+
+[Range(1,100)] 
+
+[DataType(DataType.Currency)] 
+
+publicdecimalPrice{get;set;} 
+
+[StringLength(5)] 
+
+publicstringRating{get;set;} 
+
+} 
+
+publicclassMovieDBContext:DbContext{ 
+
+publicDbSet<Movie>Movies{get;set;} 
+
+} 
+
+} 
+
+Validation Error UI in ASP.NET MVC 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Re-run the application and navigate to the /Movies URL. 
+
+Click the Create New link to add a new movie. Fill out the form with some invalid values and then click the 
+
+Create button. 
+
+ 
+Notice how the form has automatically used a red border color to highlight the text boxes that contain invalid 
+
+data and has emitted an appropriate validation error message next to each one. The errors are enforced both 
+
+client-side (using JavaScript) and server-side (in case a user has JavaScript disabled). 
+
+A real benefit is that you didn't need to change a single line of code in theMoviesController class or in the 
+
+Create.cshtml view in order to enable this validation UI. The controller and views you created earlier in this 
+
+tutorial automatically picked up the validation rules that you specified by using validation attributes on the 
+
+properties of the Movie model class. 
+
+You might have noticed for the properties Title and Genre, the required attribute is not enforced until you 
+
+submit the form (hit the Create button), or enter text into the input field and removed it. For a field which is 
+
+initially empty (such as the fields on the Create view) and which has only the required attribute and no other 
+
+validation attributes, you can do the following to trigger validation: 
+
+1.  Tab into the field. 
+
+2.  Enter some text. 
+
+3.  Tab out. 
+
+4.  Tab back into the field. 
+
+5.  Remove the text. 
+
+6.  Tab out. 
+
+The above sequence will trigger the required validation without hitting the submit button. Simply hitting the 
+
+submit button without entering any of the fields will trigger client side validation. The form data is not sent to 
+
+the server until there are no client side validation errors. You can test this by putting a break point in the HTTP 
+
+Post method or using thefiddler tool or the IE 9F12 developer tools. 
+
+How Validation Occurs in the Create View and Create Action Method 
+
+ 
+You might wonder how the validation UI was generated without any updates to the code in the controller or 
+
+views. The next listing shows what the Create methods in the MovieController class look like. They're 
+
+unchanged from how you created them earlier in this tutorial.  
+
+// 
+
+// GET: /Movies/Create 
+
+publicActionResultCreate() 
+
+{ 
+
+returnView(); 
+
+} 
+
+// 
+
+// POST: /Movies/Create 
+
+[HttpPost] 
+
+publicActionResultCreate(Movie movie) 
+
+{ 
+
+if(ModelState.IsValid) 
+
+{ 
+
+db.Movies.Add(movie); 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+The first (HTTP GET) Create action method displays the initial Create form. The second ([HttpPost]) version 
+
+handles the form post. The second Create method (The HttpPost version) calls ModelState.IsValid to 
+
+check whether the movie has any validation errors. Calling this method evaluates any validation attributes that 
+
+have been applied to the object. If the object has validation errors, the Create method re-displays the form. If 
+
+there are no errors, the method saves the new movie in the database. In our movie example we are using, the 
+
+form is not posted to the server when their are validation errors detected on the client side; the second Create 
+
+method is never called. If you disable JavaScript in your browser, client validation is disabled and the HTTP 
+
+POST Create method calls ModelState.IsValid to check whether the movie has any validation errors.  
+
+ 
+ 
+ 
+ 
+You can set a break point in the HttpPost Create method and verify the method is never called, client side 
+
+validation will not submit the form data when validation errors are detected. If you disable JavaScript in your 
+
+browser, submit the form with errors, the break point will be hit. You still get full validation without JavaScript. 
+
+ 
+The following image shows how to disable JavaScript in the FireFox browser. 
+
+The following image shows how to disable JavaScript with the Chrome browser. 
+
+ 
+ 
+Below is the Create.cshtml view template that you scaffolded earlier in the tutorial. It's used by the action 
+
+methods shown above both to display the initial form and to redisplay it in the event of an error. 
+
+ 
+@model MvcMovie.Models.Movie  
+
+@{  
+
+    ViewBag.Title = "Create";  
+
+}  
+
+<h2>Create</h2> 
+
+<scriptsrc="@Url.Content("~/Scripts/jquery.validate.min.js")"></script> 
+
+<scriptsrc="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")"></script> 
+
+@using (Html.BeginForm()) {  
+
+@Html.ValidationSummary(true)  
+
+<fieldset> 
+
+<legend>Movie</legend> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Title)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Title)  
+
+@Html.ValidationMessageFor(model => model.Title)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.ReleaseDate)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.ReleaseDate)  
+
+@Html.ValidationMessageFor(model => model.ReleaseDate)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Genre)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Genre)  
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+@Html.ValidationMessageFor(model => model.Genre)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Price)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Price)  
+
+@Html.ValidationMessageFor(model => model.Price)  
+
+</div> 
+
+<divclass="editor-label"> 
+
+@Html.LabelFor(model => model.Rating)  
+
+</div> 
+
+<divclass="editor-field"> 
+
+@Html.EditorFor(model => model.Rating)  
+
+@Html.ValidationMessageFor(model => model.Rating)  
+
+</div> 
+
+<p> 
+
+<inputtype="submit"value="Create"/> 
+
+</p> 
+
+</fieldset> 
+
+}  
+
+<div> 
+
+@Html.ActionLink("Back to List", "Index")  
+
+</div> 
+
+Notice how the code uses an Html.EditorFor helper to output the<input> element for each Movie 
+
+property. Next to this helper is a call to the Html.ValidationMessageFor helper method. These two helper 
+
+methods work with the model object that's passed by the controller to the view (in this case, a Movie object). 
+
+They automatically look for validation attributes specified on the model and display error messages as 
+
+appropriate. 
+
+What's really nice about this approach is that neither the controller nor the Create view template knows 
+
+anything about the actual validation rules being enforced or about the specific error messages displayed. The 
+
+validation rules and the error strings are specified only in the Movie class. 
+
+ 
+ 
+If you want to change the validation logic later, you can do so in exactly one place by adding validation 
+
+attributes to the model (in this example, themovie class). You won't have to worry about different parts of the 
+
+application being inconsistent with how the rules are enforced — all validation logic will be defined in one 
+
+place and used everywhere. This keeps the code very clean, and makes it easy to maintain and evolve. And it 
+
+means that that you'll be fully honoring the DRY principle. 
+
+Adding Formatting to the Movie Model 
+
+Open the Movie.cs file and examine the Movie class. TheSystem.ComponentModel.DataAnnotations 
+
+namespace provides formatting attributes in addition to the built-in set of validation attributes. We've already 
+
+applied aDataType enumeration value to the release date and to the price fields. The following code shows the 
+
+ReleaseDate and Price properties with the appropriateDisplayFormat attribute. 
+
+[DataType(DataType.Date)] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+[DataType(DataType.Currency)] 
+
+publicdecimalPrice{get;set;} 
+
+Alternatively, you could explicitly set aDataFormatString value. The following code shows the release date 
+
+property with a date format string (namely, "d"). You'd use this to specify that you don't want to time as part of 
+
+the release date. 
+
+[DisplayFormat(DataFormatString="{0:d}")] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+The following code formats the Price property as currency. 
+
+[DisplayFormat(DataFormatString="{0:c}")] 
+
+publicdecimalPrice{get;set;} 
+
+The complete Movie class is shown below. 
+
+publicclassMovie{ 
+
+publicint ID {get;set;} 
+
+ 
+ 
+[Required] 
+
+publicstringTitle{get;set;} 
+
+[DataType(DataType.Date)] 
+
+publicDateTimeReleaseDate{get;set;} 
+
+[Required] 
+
+publicstringGenre{get;set;} 
+
+[Range(1,100)] 
+
+[DataType(DataType.Currency)] 
+
+publicdecimalPrice{get;set;} 
+
+[StringLength(5)] 
+
+publicstringRating{get;set;} 
+
+} 
+
+Run the application and browse to the Movies controller. The release date and price are nicely formatted. 
+
+ 
+ 
+ 
+ 
+In the next part of the series, we'll review the application and make some improvements to the automatically 
+
+generated Details and Delete methods. 
+
+ 
+ 
+ 
+Examining the Details and Delete Methods 
+
+In this part of the tutorial, you'll examine the automatically generated Details and Delete methods.  
+
+Examining the Details and Delete Methods 
+
+Open the Movie controller and examine the Details method. 
+
+publicActionResultDetails(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+returnView(movie); 
+
+} 
+
+Code First makes it easy to search for data using the Find method. An important security feature built into the 
+
+method is that the code verifies that the Find method has found a movie before the code tries to do anything 
+
+with it. For example, a hacker could introduce errors into the site by changing the URL created by the links from 
+
+http://localhost:xxxx/Movies/Details/1 to something like http://localhost:xxxx/Movies/Details/12345 (or some 
+
+other value that doesn't represent an actual movie). If you did not check for a null movie, a null movie would 
+
+result in a database error. 
+
+Examine the Delete and DeleteConfirmed methods. 
+
+// GET: /Movies/Delete/5 
+
+publicActionResultDelete(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+returnView(movie); 
+
+ 
+} 
+
+// 
+
+// POST: /Movies/Delete/5 
+
+[HttpPost,ActionName("Delete")] 
+
+publicActionResultDeleteConfirmed(int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+db.Movies.Remove(movie); 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+Note that the HTTP Get Delete method doesn't delete the specified movie, it returns a view of the movie 
+
+where you can submit (HttpPost) the deletion.. Performing a delete operation in response to a GET request (or 
+
+for that matter, performing an edit operation, create operation, or any other operation that changes data) 
+
+opens up a security hole. For more information about this, see Stephen Walther's blog entryASP.NET MVC Tip 
+
+#46 — Don't use Delete Links because they create Security Holes. 
+
+The HttpPost method that deletes the data is named DeleteConfirmed to give the HTTP POST method a 
+
+unique signature or name. The two method signatures are shown below: 
+
+// GET: /Movies/Delete/5 
+
+publicActionResultDelete(int id =0) 
+
+// 
+
+// POST: /Movies/Delete/5 
+
+[HttpPost,ActionName("Delete")] 
+
+publicActionResultDeleteConfirmed(int id =0) 
+
+ 
+ 
+ 
+The common language runtime (CLR) requires overloaded methods to have a unique signature (same method 
+
+name but different list of parameters). However, here you need two Delete methods -- one for GET and one for 
+
+POST -- that both have the same signature. (They both need to accept a single integer as a parameter.) 
+
+To sort this out, you can do a couple of things. One is to give the methods different names. That's what the 
+
+scaffolding mechanism did in he preceding example. However, this introduces a small problem: ASP.NET maps 
+
+segments of a URL to action methods by name, and if you rename a method, routing normally wouldn't be able 
+
+to find that method. The solution is what you see in the example, which is to add the ActionName("Delete") 
+
+attribute to theDeleteConfirmed method. This effectively performs mapping for the routing system so that a 
+
+URL that includes /Delete/ for a POST request will find the DeleteConfirmed method. 
+
+Another common way to avoid a problem with methods that have identical names and signatures is to 
+
+artificially change the signature of the POST method to include an unused parameter. For example, some 
+
+developers add a parameter typeFormCollectionthat is passed to the POST method, and then simply don't 
+
+use the parameter: 
+
+publicActionResultDelete(FormCollection fcNotUsed,int id =0) 
+
+{ 
+
+Movie movie =db.Movies.Find(id); 
+
+if(movie ==null) 
+
+{ 
+
+returnHttpNotFound(); 
+
+} 
+
+db.Movies.Remove(movie); 
+
+db.SaveChanges(); 
+
+returnRedirectToAction("Index"); 
+
+} 
+
+Wrapping Up 
+
+You now have a complete ASP.NET MVC application that stores data in a SQL Server Compact database. You 
+
+can create, read, update, delete, and search for movies. 
+
+This basic tutorial got you started making controllers, associating them with views, and passing around hard-
+
+coded data. Then you created and designed a data model. Entity Framework code-first created a database from 
+
+the data model on the fly, and the ASP.NET MVC scaffolding system automatically generated the action 
+
+methods and views for basic CRUD operations. You then added a search form that let users search the 
+
+database. You changed the database to include a new column of data, and then updated two pages to create 
+
+and display this new data. You added validation by marking the data model with attributes from the 
+
+DataAnnotations namespace. The resulting validation runs on the client and on the server.  
+
+If you'd like to deploy your application, it's helpful to first test the application on your local IIS 7 server. You can 
+
+use thisWeb Platform Installer link to enable IIS setting for ASP.NET applications. See the following deployment 
+
+links: 
+
+ 
+•  ASP.NET Deployment Content Map 
+
+• 
+
+Enabling IIS 7.x  
+
+•  Web Application Projects Deployment  
+
+I now encourage you to move on to our intermediate-levelCreating an Entity Framework Data Model for an 
+
+ASP.NET MVC Application andMVC Music Store tutorials, to explore theASP.NET articles on MSDN, and to 
+
+check out the many videos and resources athttp://asp.net/mvc to learn even more about ASP.NET MVC! The 
+
+ASP.NET MVC forums are a great place to ask questions. 
+
+Enjoy! 
+
+— Rick Anderson blogs.msdn.com/rickAndy twitter @RickAndMSFT 
+
+— Scott Hanselmanhttp://www.hanselman.com/blog/ twitter @shanselman 
+
+ 
+ 
+ 
+ 
+ 
+

Arduino/Arduino_-_MakeUseOf.com.pdf.txt

@@ -0,0 +1,1283 @@
+By Brad Kendall
+http://www.bradkendall.ca/
+
+Published August 2013
+
+share:
+
+This manual is the intellectual property of MakeUseOf. It must only be published in its original form. Using 
+parts or republishing altered parts of this guide is prohibited without permission from MakeUseOf.com
+
+Think you’ve got what it takes to write a manual for MakeUseOf.com? We’re always willing to hear a pitch! 
+Send your ideas to justinpot@makeuseof.com.
+
+Table Of Contents                              
+
+1. Intro to the Arduino                                       
+
+2. What Can You Do With an Arduino? 
+
+3. What Is Inside an Arduino?                             
+
+4. What You Will Need For This Guide                    
+
+5. Electrical Component Overview                        
+
+5.1 What is a Breadboard? 
+
+5.2 What is an LED? 
+
+5.3 What is a Photo Resistor? 
+
+5.4 What is a Tactile Switch? 
+
+5.5 What is a Piezo Speaker? 
+
+5.6 What is a Resistor? 
+
+5.7 What are Jumper Wires? 
+
+6. Programming Overview                                   
+
+6.1 Variables 
+
+6.2 Functions 
+
+6.3 Logic Overview 
+
+== - The Equals operator 
+
+&& - The AND operator 
+
+|| - The OR operator 
+
+! - The NOT operator 
+
+Using Multiple Expressions 
+
+7. Setting Up Your Arduino                               
+
+7.1 Installing the Arduino IDE on Windows 
+
+Step 1: Download the Arduino software 
+
+Step 2: Install the software 
+
+7.2 Installing the Arduino IDE on Mac OS X 
+
+Step 1: Download the Arduino software 
+
+Step 2: Install the software 
+
+7.3 Installing the Arduino IDE on Ubuntu/ Linux 
+
+7.4 Running the Arduino Software 
+
+5
+
+6
+
+7
+
+8
+
+9
+
+9
+
+9
+
+10
+
+10
+
+10
+
+11
+
+11
+
+12
+
+12
+
+12
+
+12
+
+13
+
+13
+
+13
+
+13
+
+13
+
+14
+
+14
+
+14
+
+14
+
+15
+
+15
+
+15
+
+15
+
+15
+
+HTTP://MAKEUSEOF.COM
+BRAD KENDALL, HTTP://WWW.BRADKENDALL.CA
+
+3
+
+share:
+
+GETTING STARTED WITH ARDUINO 
+8. Starter Projects                                                     
+
+8.1 Communicating Between Your Arduino and Your PC 
+
+Reading from the Serial Port 
+
+8.2 Building a Calculator 
+
+8.3 Turning on an LED 
+
+8.4 Making Your LED Blink 
+
+8.5 Making Multiple LEDs Blink 
+
+8.6 Pushbuttons with a Pull-up Resistor 
+
+8.7 Turning on an LED with a Pushbutton 
+
+8.8 Control an LED’s Brightness 
+
+8.9 Observing Light with your Arduino 
+
+8.10 Making Music with your Arduino 
+
+9. Where to go From Here                                 
+
+17
+
+17
+
+17
+
+17
+
+20
+
+21
+
+23
+
+25
+
+26
+
+27
+
+28
+
+30
+
+32
+
+HTTP://MAKEUSEOF.COM
+BRAD KENDALL, HTTP://WWW.BRADKENDALL.CA
+
+4
+
+share:
+
+GETTING STARTED WITH ARDUINO1. Intro to the Arduino                                      
+
+Arduino is an open-source electronics prototyping platform based on flexible, easy-to use hardware and software. It’s 
+intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments.
+
+Arduino can sense the environment by receiving input from a variety of sensors and can affect its surroundings by 
+controlling lights, motors, and other actuators. The microcontroller on the board is programmed using the Arduino 
+programming language and the Arduino Development Environment. Arduino projects can be stand-alone, or they can 
+communicate with software running on a computer.
+
+There are plenty of other microcontrollers available. So you may be asking, why choose the Arduino? Arduino really 
+simplifies the process of building projects on a microcontroller making it a great platform for amateurs. You can easily 
+start working on one with no previous electronics experience.
+
+That is what this guide is about.
+
+In addition to Arduino’s simplicity, it is also inexpensive, cross-platform and open source. The Arduino is based on 
+Atmel’s ATMEGA8 and ATMEGA168 microcontrollers. The plans for the modules are published under a Creative Com-
+mons license, so experienced hobbyists and professionals can make their own version of the Arduino, extending it and 
+improving it.
+
+Believe it or not, even relatively inexperienced users can build a version of the Arduino module on a breadboard in 
+order to understand how it works and save a little bit of money.
+
+2. What Can You Do With an Arduino?
+
+There is a lot you can do with an Arduino. An Arduino can basically do anything by interfacing sensors with a com-
+puter. This would allow you to take any sensor and have any action applied with the readings. For example (in one of 
+our projects) we will read the level of light in a room and adjust an LED’s brightness to react based on that input. This 
+of course is a simple example of what you can do with an Arduino. A more complicated example would be to read from 
+multiple sensors and use that data to affect other outputs. Think of the possibility of wiring your house with all sorts 
+of different sensors (photocells, oxygen sensors, thermometers) and having it adjust your blinds, air conditioner and 
+furnace and make your house a more comfortable place.
+
+Hackers have used Arduinos to create some amazing electronics projects. Things like:
+
+•	 Robots
+
+•	 Breathalyzers
+
+•	 Remote	controlled	cars
+
+•	
+
+3d	printers
+
+•	 Video	games
+
+•	 Home	automation	systems
+
+And much more. Read about more great examples of Arduino projects.
+
+3. What Is Inside an Arduino?                            
+
+Although there are many different types of Arduino boards available, this manual focuses on the Arduino Uno. This is 
+the most popular Arduino board around. So what makes this thing tick? Here are the specifications:
+
+•	 Processor:	16	Mhz	ATmega328
+
+•	 Flash	memory:	32	KB
+
+•	 Ram:	2kb
+
+•	 Operating	Voltage:	5V
+
+•	
+
+Input	Voltage:	7-12	V
+
+•	 Number	of	analog	inputs:	6
+
+•	 Number	of	digital	I/O:	14	(6	of	them	pwm)
+
+The specs may seem meager compared to your desktop computer, but remember that the Arduino is an embedded 
+device. We have a lot less to process than your desktop.
+
+Another wonderful feature of the Arduino is the ability to use what are called “Shields”. Although we will not be cov-
+ering shields in this manual, an Arduino shield will give you crazy functionality like you wouldn’t believe. Check out 
+this list of some really cool Arduino shields to take your projects to the next level.
+
+4. What You Will Need For This Guide                   
+
+Below you will find a shopping list of the components we will use for this manual. All these components should come 
+in under $50.00 USD. This should be enough to give you a good understanding of basic electronics and have enough 
+components to build some pretty cool projects.
+
+•	
+
+•	
+
+•	
+
+•	
+
+•	
+
+•	
+
+•	
+
+•	
+
+•	
+
+•	
+
+•	
+
+1x	Arduino	Uno	Microcontroller
+
+1	x	USB	A-B	Cable	(same	as	your	printer	takes)
+
+1x	Breadboard
+
+2	x	LEDs
+
+1	x	Photo	Resistor
+
+1	x	Tactile	Switch
+
+1	x	Piezo	Speaker
+
+1	x	10	k-Ohm	Resistors
+
+1	x	2	k-Ohm	Resistors
+
+2	x	1	K-Ohm	Resistors
+
+1	x	Jumper	Wire	Kit
+
+5. Electrical Component Overview                       
+
+5.1 What is a Breadboard?
+Breadboards are blocks of plastic with holes into which wires can be inserted. The holes are connected electrically, so 
+that wires stuck in the connected holes are also connected electrically.
+
+The connected holes are arranged in rows, in groups of five, so that up to five parts can be quickly connected just by 
+plugging their leads into connected holes in the breadboard. When you want to rearrange a circuit, just pull the wire or 
+part out of the hole, and move it or replace it. The breadboard I recommended also includes power and ground lanes 
+on each side for easy power management.
+
+5.2 What is an LED?
+An LED, short for Light Emitting Diode, is a semiconductor light source. LEDs are typically used as visual indicators. 
+For instance, your new Arduino microcontroller has an LED on pin 13 that we frequently use to indicate an action or 
+event.
+
+5.3 What is a Photo Resistor?
+A photo resistor allows us to measure light by decreasing its resistance when it detects an increase of light intensity.
+
+5.4 What is a Tactile Switch?
+A tactile switch is an electric switch that controls the flow of electricity. When pressed, the switch completes the circuit. 
+Basically, it is a button.
+
+5.5 What is a Piezo Speaker?
+A piezo speaker is a single frequency beeper that converts an electrical signal into a tone. This will allow your Arduino 
+to sing to you.
+
+5.6 What is a Resistor?
+A resistor is an electrical component that limits or regulates the flow of electricity.
+
+5.7 What are Jumper Wires?
+Jumper wires are short wires that are used for prototyping circuits. These are what you will use to connect the various 
+components electrically to your Arduino.
+
+6. Programming Overview                                  
+
+If you’re not too familiar with programming, this guide should get you used to some of the fundamentals. If you’d like to 
+learn more about Arduino-specific functions, http://www.arduino.cc/en/Reference/HomePage is an excellent resource.
+
+6.1 Variables
+A variable is defined as a quantity that can assume any of a set of values. In the Arduino programming language, vari-
+ables have types associated with them, which provide the set of valid values the variable can hold. Some languages 
+are not strict and allow a variable to hold nearly anything, but that is out of the scope of this manual.
+
+For example, a variable with type ‘int’ can only hold integer values like 1 or 12, and not 12.5 or “cats”. Unfortunately, 
+no variable is capable of holding a cat, something the programming world is quite upset about.
+
+Variables are an excellent resource, as they improve code readability and reuse, and are extremely convenient for use 
+as temporary storage.
+
+Before using a variable, you must declare it. This merely lets the Arduino compiler know what data type your variable 
+will hold.
+
+An example of a variable declaration is as follows:
+
+int itemCount;
+In this case, the variable will be of type int, and therefore will only accept integers.
+
+Here are a few example assignments and operations.
+
+itemCount = 4; itemCount = itemCount + 8; // itemCount now holds the value 12. itemCount = 
+“10”; // This will not compile. 
+6.2 Functions
+A function is essentially a group of instructions that perform a specific task. There are many built-in functions, such as 
+digitalWrite() or tone(). In those cases, you don’t necessarily have to see the code, but can still reap the benefits. You 
+can also specify your own functions.
+
+The general form of a function is:
+
+[return type] [function name] ({arguments}) { [ Code to execute ] } 
+Note that functions can return data, as illustrated by the function having a return type.
+
+In many cases, there is no data to return, and in that case, the keyword ‘void’ would be used.
+
+The function name is a user-friendly ‘handle’ to reference later (digitalWrite would be the function name for the digi-
+talWrite function).
+
+A function can accept zero or more arguments. Each argument must be of the form [datatype] [identifier]. For exam-
+ple, if we called a function foo as such:
+
+foo(10);
+The function header for foo would have to look like:
+
+void foo(int number) { } 
+In the function, code can reference ‘number’ to retrieve the passed value. Outside of the function, ‘number’ would be 
+undefined.
+
+Say we want to write a function to multiply two numbers, for whatever reason. This function would look like:
+
+int multiply(int num1, int num2) { int result; result = num1 * num2; return result; } 
+Note that this could simply look like:
+
+int multiply(int num1, int num2) { return num1 * num2; }
+It’s usually a good idea to be liberal with the use of spaces, as it makes for much easier debugging. To each their own, 
+however.
+
+6.3 Logic Overview
+
+You’ll often find yourself wanting to execute certain code under certain conditions. This will give you a quick overview 
+of the logical operators you have to work with.
+
+First up, with the exception of the NOT operator, each logical operation takes two operands.
+
+== - The Equals operator
+This operator ensures that both operands are equal to one another. To test whether or not the operands are not equal 
+to one another, use the != (not-equals) operator.
+
+Example:
+
+4 == 4 (true) 4 == 5 (false) 4 != 5 (true) 
+&& - The AND operator
+The AND operator is quite similar to the equals operator, except it does not evaluate to true when both operands are 
+false.
+
+For example: (true && true) evaluates to true, while (true && false) and (false && false) both evaluate to false.
+
+|| - The OR operator
+The OR operator will evaluate to true so long as at least one of the two operands is true.
+
+The only time OR will evaluate to false is if both the operands are false.
+
+! - The NOT operator
+This simply flips the truthiness of the operand specified. !false == true.
+
+Using Multiple Expressions
+Sometimes you’d like to have more than one test. Fortunately, since (as above), something like (false == true) will 
+evaluate to false, nesting statements in brackets works, and the statements in brackets will be evaluated first.
+
+For example:
+
+if (( a != b) && (b > 12))
+a != b and b > 12 will have to be evaluated first, as their outcome determines whether the entire logical expression is 
+true.
+
+The past two sections should have given you enough basic knowledge to get started with our projects below. If it all 
+seems a little complicated, don’t worry. It will make a lot more sense when we apply it in a practical sense.
+
+7. Setting Up Your Arduino                              
+
+Before we can start on our projects, we first need to get your Arduino talking to your computer. We need to do this so 
+you can compile and send code for your Arduino to execute.
+
+7.1 Installing the Arduino IDE on Windows
+Step 1: Download the Arduino software
+Go to http://arduino.cc/en/Main/Software and download the Arduino Software for your Windows.
+
+Step 2: Install the software
+Install the Drivers:
+
+•	 Plug	in	your	board	and	wait	for	Windows	to	begin	its	driver	installation	process.	After	a	few	mo-
+
+ments,	the	process	will	fail,	despite	its	best	efforts.
+
+•	 Click	on	the	Start	Menu,	and	open	up	the	Control	Panel.
+
+•	 While	in	the	Control	Panel,	navigate	to	System	and	Security.	Next,	click	on	System.	Once	the	
+
+System	window	is	up,	open	the	Device	Manager.
+
+•	
+
+Look	under	Ports	(COM	&	LPT).	You	should	see	an	open	port	named	“Arduino	UNO	(COMxx)”.
+
+•	 Right	click	on	the	“Arduino	UNO	(COMxx)”	port	and	choose	the	“Update	Driver	Software”	option.
+
+•	 Next,	choose	the	“Browse	my	computer	for	Driver	software”	option.
+
+•	 Finally,	navigate	to	and	select	the	Uno’s	driver	file,	named	“ArduinoUNO.inf”,	located	in	the	“Driv-
+
+ers”	folder	of	the	Arduino	Software	download.
+
+•	 Windows	will	finish	up	the	driver	installation	from	there.
+
+7.2 Installing the Arduino IDE on Mac OS X
+Step 1: Download the Arduino software
+Go to http://arduino.cc/en/Main/Software and download the Arduino Software for your Mac OS X.
+
+Step 2: Install the software
+The disk image (.dmg) should mount automatically. If it doesn’t, double-click it. It should look like the following image.
+
+Copy the Arduino application into the Applications folder (or elsewhere on your computer). Since you’re using an Ar-
+duino Uno, you don’t have any drivers to install.
+
+7.3 Installing the Arduino IDE on Ubuntu/ Linux
+Install gcc-avr and avr-libc from the Terminal. 
+
+sudo apt-get install gcc-avr avr-libc
+
+If you don’t have openjdk-6-jre already, install and configure that too:
+
+sudo apt-get install openjdk-6-jre sudo update-alternatives --config java 
+
+Select the correct JRE if you have more than one installed.
+
+Go to http://arduino.cc/en/Main/Software/ and download the Arduino Software for Linux. You can untar and run it with 
+the following command:
+
+tar xzvf arduino-x.x.x-linux64.tgz cd arduino-1.0.1 ./arduino 
+
+7.4 Running the Arduino Software
+Now that our software is installed and our Arduino is setup, let’s verify everything is working. The easiest way to do 
+this is by using the “Blink” sample application.
+
+1.	 Open	the	Arduino	Software	by	Double-clicking	the	Arduino	Application	(./arduino	on	Linux).
+
+2.	 Make	sure	the	board	is	still	connected	to	your	computer.
+
+3.	 Open	the	LED	blink	example	sketch:	File	>	Examples	>	1.Basics	>	Blink.	You	should	see	the	
+
+code	for	the	application	open	and	it	should	look	like	this:
+
+ 
+ 
+ 
+4.	 You’ll	need	to	select	the	entry	in	the	Tools	>	Board	menu	that	corresponds	to	your	Arduino.	Se-
+
+lect	the	Arduino	Uno	Option.
+
+5.	 Select	the	serial	device	of	the	Arduino	board	from	the	Tools	>	Serial	Port	menu.	On	Windows,	
+
+This	is	likely	to	be	COM3	or	higher.	On	the	Mac	or	on	Linux,	this	should	be	something	with	‘/dev/
+tty.usbmodem	‘	in	it.
+
+6.	 Now,	simply	click	the	“Upload”	button	in	the	environment.	Wait	a	few	seconds	-	you	should	see	
+
+the	RX	and	TX	LEDs	on	the	Arduino	flashing.	If	the	upload	is	successful,	the	message	“Done	up-
+loading.”	will	appear	in	the	status	bar.
+
+A few seconds after the upload finishes, you should see the pin 13 (L) LED on the board start to blink. If it does, con-
+gratulations! You’ve got your Arduino up and running.
+
+8. Starter Projects                                                    
+
+Okay, now is when the real fun begins. Let’s get started.
+
+8.1 Communicating Between Your Arduino and Your PC
+Most of the communication you’ll be doing with the Arduino (for now) will be done via the Serial port (The USB cord). 
+This is quite trivial to set up on the Arduino. Merely add the following line to your setup() method:
+
+Serial.begin(9600);
+9600 is the baud rate, something we will not get into here (it essentially means the number of signal changes made 
+per second, and merely ensures that the PC and the Arduino are on the same page in regards to this). Whenever you 
+would like to write something to the serial port, simply use the Serial.print or Serial.println function, as so:
+
+Serial.print(“Hello world!”); 
+
+Reading from the Serial Port
+Note that you will have to read in a single character at a time via the serial port, which is rather unfortunate. If you take 
+a peek at the sample code for our calculator application, specifically the waitForNum() method, you will see an exam-
+ple of how to read in all characters entered, albeit in this case for a number.
+
+8.2 Building a Calculator
+To tie all of your new found programming knowledge together, we submit to you the following program that performs 
+basic mathematical operations. We have clearly commented the code, so you should be able to understand each step. 
+There is a download available for people who don’t like typing at: http://www.bradkendall.ca/arduino
+
+Here we go!
+
+/*
+Example Arduino Calculator
+Communication protocol: Send an ‘A’, ‘S’, ‘M’, or ‘D’ via serial, than two numbers. The arduino 
+will reply with the result of the operation on the two numbers, (first number first). Note that 
+the division will no doubt look strange - it is an integer division and therefore there will 
+not be anything after the decimal point.
+*/
+void setup() {
+Serial.begin(9600);
+Serial.println(“Calculator initiated.”);
+}
+/* loop()
+This code gets executed over, and over, and over, and over, and over, and over, and over, and 
+over, and over, and over, and over, and over, and over, and over, and over, and over again.
+Our loop pretty much starts the ‘waiting for input’ stage, where we wait for the user to input 
+a character (the mathematical operation), then two operands.
+After we output the result, we let the loop get hit again, and joy is had by all!
+*/
+void loop() {
+char operation;
+int number1;
+int number2; // hehe, Number 2. 
+int result; // Hold the result of the operation.
+boolean success;
+// Indicates whether the operation 
+// was successful (we knew what to 
+// do - nothing bad was inputted)
+success = true; 
+// Go ahead and set success to true ; 
+// The only time we will be updating 
+// this variable now is to set it to 
+// false if we’ve encountered a 
+// problem.
+
+Serial.println(“Pick an operation: ‘A’dd, ‘S’ubtract, ‘M’ultiply, or ‘D’ivide (Simply input the 
+first letter in quotes.)”);
+// We have to wait for the user to send something
+// here; the easiest way to do so is to simply loop
+// and waitfor Serial.available() to be true.
+while(Serial.available() == 0) {
+; // ; indicates an empty statement. Or a sea
+// monster in Nethack. God those suck.
+}
+// This loop will continue executing while Serial.
+// available() == 0. Thus, it will be stuck here until 
+// the serial has a character waiting.
+operation = Serial.read();
+// We have to do the same thing to get the two
+// operands (numbers).
+// I have factored this code into a function so that 
+// I do not have to rewrite it twice. See if you can 
+// determine why I would not be able to use it (at 
+// least intuitively) to get the operation.
+Serial.println(“Okay, now please enter the two numbers, one at a time!”);
+number1 = waitForNum();
+Serial.print(“Read: “);
+Serial.println(number1);
+number2 = waitForNum();
+Serial.print(“Read: “);
+Serial.println(number2);
+// Now we have read in all the data we need. It is
+// time to calculate the result. We will have to
+// determine what operation the user specified, and
+// perform the calculation from there.
+Serial.print(“Operation: “);
+if(operation == ‘A’)
+{
+// This checks to see if the user sent along the
+// character ‘A’, specifying an add.
+Serial.println(“ADD (Look, a kitty!)”);
+result = number1 + number2;
+} else if(operation == ‘S’)
+{
+// Note that the above condition will only be
+// tested for if operation is not equal to ‘A’ -
+// hence the else.
+// This code executes if the operation is ‘S’ for
+// subtract.
+Serial.println(“Subtract”);
+result = number1 - number2;
+} else if(operation == ‘M’)
+{
+// In this case, we will be multiplying.
+Serial.println(“Multiply”);
+result = number1 * number2;
+} else if(operation == ‘D’)
+{
+// Here we will be dividing.
+Serial.println(“Divide”);
+result = number1 / number2;
+} else{
+// This code will be used if the character
+// specified doesn’t match anything - in other
+// words, the user did not send A, S, D, or M,
+// and we don’t know what to do.
+// Hence, set ‘success’ to false
+success = false;
+
+}
+// Now we should have our result. Time to send the
+// user back something! (Then start over again! Joy!)
+if(success)
+{
+// Note that print will not start a new
+// line, and the next print statement will
+// continue writing right
+// where the previous one left off.
+// Output the result.
+Serial.print(“Result: “);
+Serial.println(result);
+} else
+{
+Serial.print(“Sorry, I don’t understand what you want me to do! (You inputted ‘”);
+Serial.print(operation);
+Serial.println(“’)”);
+}
+}
+int waitForNum()
+{
+int ret;
+while(Serial.available() == 0) { ;
+}
+// Why minus ‘0’? The value we’ll get from Serial.
+// read() will be a character. What this means is
+// that its numeric value will not necessarily
+// reflect the number it represents. (Look at an
+// ASCII table, the character ‘0’ actually has a
+// decimal value of 48!)
+// The take-away from this is that, since fortunately
+// all the numbers are in sequence, you can simply
+// subtract the decimal value of ‘0’ from
+// whatever you read in, and you’ll be left with the
+// number itself. ‘5’ - ‘0’ = 5 .
+ret = Serial.read() - ‘0’;
+// To handle numbers that span more than one
+// character (like 124, which spans three), we must
+// loop until there is no more input, and multiply
+// each number we read by one (as 124 would come in
+// like: 4 2 1
+// And the number we build would be:
+// (((1 * 10) + 2) * 10) + 4,
+// or 124! The joys of the decimal numbering system!
+// Note that the delays are merely to slow things
+// down a bit - removing them would have the
+// code execute too quickly to ‘notice’ more
+// characters waiting to come in from Serial.
+// A little strange, neh? Welcome to the joys of this
+// type of thing. =]
+delay(10);
+while(Serial.available() != 0)
+{
+ret = ret * 10;
+ret += Serial.read() - ‘0’;
+delay(10);
+}
+return ret;
+}
+
+ 
+8.3 Turning on an LED
+
+What You Need:
+
+•	
+
+•	
+
+•	
+
+1	–	LED
+
+1	–	Resistor	–	1	KOhm	(brown,	black,	red)
+
+4	–	Jumper	Wires
+
+You will build a circuit by plugging the LED and resistor leads into small holes called sockets on the breadboard.
+
+Let’s get started!
+
+Hardware Setup:
+
+•	 Step	1	-	Unplug	the	USB	cord	from	your	Arduino.
+
+•	 Step	2	-	Plug	a	jumper	wire	from	the	5V	port	on	your	Arduino	into	the	positive	section	of	your	
+
+breadboard’s	power	lane.
+
+•	 Step	3	-	Plug	a	jumper	wire	from	the	GND	port	on	your	Arduino	into	the	negative	section	of	your	
+
+breadboard’s	ground	lane.
+
+•	 Step	4	-	Plug	the	LED’s	cathode	(the	short	lead)	into	the	I-2	socket	on	your	breadboard.
+
+•	 Step	5	-	Plug	the	LED��s	anode	(the	long	lead)	into	the	I-4	socket	on	your	breadboard.
+
+•	 Step	6	-	Plug	one	of	the	resistor’s	leads	into	the	H-4	socket	on	your	breadboard.
+
+•	 Step	7	-	Plug	the	resistors	other	lead	into	the	H-9	socket	on	your	breadboard.
+
+•	 Step	8	-	Connect	a	jumper	wire	from	your	breadboard’s	power	lane	to	the	J-9	socket	on	your	
+
+breadboard.
+
+•	 Step	9	-	Connect	a	jumper	wire	from	your	breadboard’s	ground	lane	to	the	J-2	socket	on	your	
+
+breadboard.
+
+•	 Step	10	-	Reconnect	the	USB	cable	to	your	Arduino.
+
+Summary: Once power is applied to the circuit, the LED will turn on. This is about as simple as a circuit gets.
+
+8.4 Making Your LED Blink
+What You Need:
+
+•	
+
+•	
+
+•	
+
+1	–	LED
+
+1	–	Resistor	–	1	K	Ohm	(brown,	black,	red)
+
+4	–	Jumper	Wires
+
+Hardware Setup:
+
+•	 Step	1	-	Unplug	the	USB	cord	from	your	Arduino.
+
+•	 Step	2	-	Plug	a	jumper	wire	from	the	Digital	IO	pin	8	into	the	I-12	socket	on	your	breadboard.
+
+•	 Step	3	-	Plug	one	of	the	resistor’s	leads	into	the	H-12	socket	on	your	breadboard.
+
+•	 Step	4	-	Plug	the	resistor’s	other	lead	into	the	H-4	socket	on	your	breadboard.
+
+•	 Step	5	-	Plug	the	LED’s	cathode	(the	short	lead)	into	the	I-2	socket	on	your	breadboard.
+
+•	 Step	6	-	Plug	the	LED’s	anode	(the	long	lead)	into	the	I-4	socket	on	your	breadboard.
+
+•	 Step	7	-	Connect	a	jumper	wire	from	your	breadboard’s	ground	lane	to	the	J-2	socket	on	your	
+
+breadboard.	Ensure	that	the	ground	lane	is	still	grounded.
+
+•	 Step	8	-	Reconnect	the	USB	cable	to	your	Arduino.
+
+Software Setup:
+
+Open up your Arduino Development Environment and create a new sketch (File	>	New).
+
+Enter the following code into your sketch:
+
+void setup() {
+// initialize the digital pin as an output.
+// Pin 8 is our output pin
+pinMode(8, OUTPUT);
+}
+void loop() {
+digitalWrite(8, HIGH); // set the LED on
+delay(1000); // wait for a second
+digitalWrite(8, LOW); // set the LED off
+delay(1000); // wait for a second
+} 
+
+After you enter the code, press the upload button and your LED should start blinking.
+
+Summary: The digitalWrite(8, HIGH); command sets the output pin 8 on the Arduino to 5V. The digitalWrite(8, LOW); 
+command sets the output pin 8 on the Arduino to 0V. The delay(1000); command pauses execution on the Arduino for 
+1000 ms or 1 second. Since this in the loop() function, the code is called over and over again. Pretty cool, huh?
+
+8.5 Making Multiple LEDs Blink
+
+What You Need:
+
+•	
+
+•	
+
+•	
+
+2	–	LEDs
+
+2	–	Resistor	–	1	K	Ohm	(brown,	black,	red)
+
+4	–	Jumper	Wires
+
+Hardware Setup:
+
+•	 Step	1	-	Unplug	the	USB	cord	from	your	Arduino.
+
+•	 Step	2	-	Setup	the	project	board	the	same	as	in	Project	3.
+
+•	 Step	3	-	Plug	a	jumper	wire	from	the	Digital	IO	pin	9	into	the	I-16	socket	on	your	breadboard.
+
+•	 Step	4	-	Plug	one	of	the	resistor’s	leads	into	the	H-16	socket	on	your	breadboard.
+
+•	 Step	5	-	Plug	the	resistor’s	other	lead	into	the	H-24	socket	on	your	breadboard.
+
+•	 Step	6	-	Plug	the	LED’s	anode	(the	long	lead)	into	the	I-24	socket	on	your	breadboard.
+
+•	 Step	7	-	Plug	the	LED’s	cathode	(the	short	lead)	into	the	I-26	socket	on	your	breadboard.
+
+•	 Step	8	-	Connect	a	jumper	wire	from	your	breadboard’s	ground	lane	to	the	J-26	socket	on	your	
+
+breadboard.	Ensure	that	the	ground	lane	is	still	grounded.
+
+•	 Step	9	-	Reconnect	the	USB	cable	to	your	Arduino.
+
+Software Setup:
+
+Open up your Arduino Development Environment and create a new sketch (File	>	New).
+
+Enter the following code into your sketch:
+
+void setup() {
+// initialize the digital pins as an output.
+pinMode(8, OUTPUT);
+pinMode(9, OUTPUT);
+}
+void loop() {
+digitalWrite(8, HIGH); // set the LED on
+digitalWrite(9, LOW); // set the LED on
+
+delay(1000); // wait for a second
+digitalWrite(8, LOW); // set the LED off
+digitalWrite(9, HIGH); // set the LED on
+delay(1000); // wait for a second
+}
+After you enter the code, press the upload button and both your LEDs should start blinking.
+
+Summary: This project is exactly the same as the last project, except we have added an additional LED on output pin 
+9 that turns off when the other LED is on. Can you think of any other ways to expand on this?
+
+8.6 Pushbuttons with a Pull-up Resistor
+What You Need:
+
+•	
+
+•	
+
+•	
+
+•	
+
+1	–	Resistor	2	K	Ohm	(red-black-red)
+
+1	–	Resistor	–	1	K	Ohm	(brown,	black,	red)
+
+1	–	Tactile	Switch
+
+5	–	Jumper	Wires
+
+Hardware Setup:
+
+•	 Step	1	-	Unplug	the	USB	cord	from	your	Arduino.
+
+•	 Step	2	-	Connect	a	jumper	wire	from	your	breadboard’s	power	lane	to	the	C-3	socket	on	your	
+
+breadboard.	Ensure	that	the	power	lane	is	still	connected.
+
+•	 Step	3	-	Plug	one	of	the	2	K	Ω	resistor’s	leads	into	the	B-3	socket	on	your	breadboard.
+
+•	 Step	4	-	Plug	the	2	K	Ω	resistor’s	other	lead	into	the	B-7	socket	on	your	breadboard.
+
+•	 Step	5	-	Plug	a	tactile	switch	so	the	pins	are	in	the	F-9,	F-7,	E-9	and	E-7	on	your	breadboard.
+
+•	 Step	6	-	Plug	one	of	the	1K	Ω	resistor���s	leads	into	the	H-7	socket	on	your	breadboard.
+
+•	 Step	7	-	Plug	the	1K	Ω	resistors’	other	lead	into	the	H-14	socket	on	your	breadboard.
+
+•	 Step	8	-	Plug	a	jumper	wire	from	the	Digital	IO	pin	9	into	the	I-14	socket	on	your	breadboard.
+
+•	 Step	9	-	Connect	a	jumper	wire	from	your	breadboard’s	ground	lane	to	the	H-9	socket	on	your	
+
+breadboard.	Ensure	that	the	ground	lane	is	still	connected.
+
+•	 Step	10	-	Reconnect	the	USB	cable	to	your	Arduino.
+
+Software Setup:
+
+Open up your Arduino Development Environment and create a new sketch (File	> New).
+
+Enter the following code into your sketch:
+
+void setup() {
+// initialize the digital pin 9 as an input.
+pinMode(9, INPUT);
+// initialize the serial port.
+Serial.begin(9600);
+}
+void loop() {
+int buttonStatus = digitalRead(9);
+if (buttonStatus == LOW) //The button is down
+{
+Serial.println(“The button is down”);
+}
+}
+
+After you enter the code, press the upload button and open the Serial Monitor (Tools	>	Serial	Monitor). When you 
+press the tactile switch, the serial monitor should print “The button is down”.
+
+Summary: This project reads the digital input for 5v (HIGH). When the button is pressed, the voltage is set to 0v 
+(LOW) and the Arduino executes the code in our if statement.
+
+8.7 Turning on an LED with a Pushbutton
+
+What You Need:
+
+•	
+
+•	
+
+•	
+
+•	
+
+1	-	LED
+
+1	–	Resistor	–	1	K	Ohm	(brown,	black,	red)
+
+1	–	Tactile	Switch
+
+4	–	Jumper	Wires
+
+Hardware Setup:
+
+•	 Step	1	-	Unplug	the	USB	cord	from	your	Arduino.
+
+•	 Step	2	-	Plug	a	tactile	switch	so	the	pins	are	in	H-9,	H-11,	J-9	and	J-11	on	your	breadboard.
+
+•	 Step	3	-	Plug	a	jumper	wire	from	the	GND	port	on	your	Arduino	into	the	negative	section	on	your	
+
+breadboard’s	ground	lane.
+
+•	 Step	4	-	Plug	the	LED’s	cathode	(the	short	lead)	into	the	I-2	socket	on	your	breadboard.
+
+•	 Step	5	-	Plug	the	LED’s	anode	(the	long	lead)	into	the	I-4	socket	on	your	breadboard.
+
+•	 Step	6	-	Plug	one	of	the	resistor’s	leads	into	the	H-4	socket	on	your	breadboard.
+
+•	 Step	7	-	Plug	the	resistor’s	other	lead	into	the	H-9	socket	on	your	breadboard.
+
+•	 Step	8	-	Connect	a	jumper	wire	from	your	breadboard’s	power	lane	to	the	G-11	socket	on	your	
+
+breadboard.
+
+•	 Step	9	-	Connect	a	jumper	wire	from	your	breadboard’s	ground	lane	to	the	J-2	socket	on	your	
+
+breadboard.
+
+•	 Step	10	-	Reconnect	the	USB	cable	to	your	Arduino.
+
+8.8 Control an LED’s Brightness
+What You Need:
+
+•	
+
+•	
+
+•	
+
+•	
+
+1	–	Photo	Resistor
+
+1	–	Resistor	–	2	K	Ohm	(red-black-red)
+
+1	–	LED
+
+5	–	Jumper	Wires
+
+Hardware Setup:
+
+•	 Step	1	-	Unplug	the	USB	cord	from	your	Arduino.
+
+•	 Step	2	-	Plug	one	of	the	photo	resistor’s	leads	into	the	I-14	socket	on	your	breadboard.
+
+•	 Step	3	-	Plug	the	photo	resistor’s	other	lead	into	the	I-15	socket	on	your	breadboard.
+
+•	 Step	4	-	Plug	the	LED’s	cathode	(the	short	lead)	into	the	H-17	socket	on	your	breadboard.
+
+•	 Step	5	-	Plug	the	LED’s	anode	(the	long	lead)	into	the	H-15	socket	on	your	breadboard.
+
+•	 Step	6	-	Plug	one	of	the	resistor’s	lead	into	the	I-17	socket	on	your	breadboard.
+
+•	 Step	7	-	Plug	the	resistor’s	other	lead	into	the	I-22	socket	on	your	breadboard.
+
+•	 Step	8	-	Connect	a	jumper	wire	from	your	breadboard’s	power	lane	to	the	J-14	socket	on	your	
+
+breadboard.	Ensure	that	the	power	lane	is	still	connected.
+
+•	 Step	9	-	Connect	a	jumper	wire	from	your	breadboard’s	ground	lane	to	the	J-22	socket	on	your	
+
+breadboard.	Ensure	that	the	ground	lane	is	still	connected.
+
+•	 Step	10	-	Reconnect	the	USB	cable	to	your	Arduino.
+
+Summary: As you see, the resistance of the photo resistor decreases with more light. The lower the resistance, the 
+brighter the LED. Combine this with the pull up resistor project (Chapter 8.6) and watch the opposite effect.
+
+8.9 Observing Light with your Arduino
+What You Need:
+
+•	
+
+1	–	Photo	Resistor
+
+•	
+
+•	
+
+1	–	Resistor	–	10	K	Ohm	(brown-black-orange)
+
+5	–	Jumper	Wires
+
+Hardware Setup:
+
+•	 Step	1	-	Unplug	the	USB	cord	from	your	Arduino.
+
+•	 Step	2	-	Plug	one	of	the	photo	resistor’s	leads	into	the	F-16	socket	on	your	breadboard.
+
+•	 Step	3	-	Plug	the	photo	resistor’s	other	lead	into	the	F-15	socket	on	your	breadboard.
+
+•	 Step	4	-	Plug	one	of	the	resistor’s	leads	into	the	I-15	socket	on	your	breadboard.
+
+•	 Step	5	-	Plug	the	resistor’s	other	lead	into	the	I-10	socket	on	your	breadboard.
+
+•	 Step	6	-	Connect	a	jumper	wire	from	your	breadboard’s	power	lane	to	the	G-16	socket	on	your	
+
+breadboard.	Ensure	that	the	power	lane	is	still	connected.
+
+•	 Step	7	-	Connect	a	jumper	wire	from	your	breadboard’s	ground	lane	to	the	J-10	socket	on	your	
+
+breadboard.	Ensure	that	the	ground	lane	is	still	connected.
+
+•	 Step	8	-	Plug	a	jumper	wire	from	the	Analog	IO	pin	0	into	the	G-15	socket	on	your	breadboard
+
+•	 Step	9	-	Reconnect	the	USB	cable	to	your	Arduino.
+
+Software Setup:
+
+Open up your Arduino Development Environment and create a new sketch (File	>	New).
+
+Enter the following code into your sketch:
+
+int lightPin = 0; //define a pin for Photo resistor
+void setup()
+{
+Serial.begin(9600); //Begin serial communication
+}
+void loop()
+{
+//Write the value of the photo resistor to the serial //monitor.
+int lightValue = analogRead(lightPin);
+Serial.println(lightValue);
+delay(1000); //pause for 1000 ms or 1 second.
+}
+
+After you enter the code, press the upload button and open the Serial Monitor (Tools	>	Serial	Monitor). The console 
+should give a light reading in the form of an integer. When you reduce the amount of light, the number will be lower.
+
+Summary: This project is the same as the previous project, except we are reading the values from your Arduino 
+instead of outputting to an LED. The resistance of the photo resistor decreases with more light. You could use logic to 
+reverse this effect!
+
+8.10 Making Music with your Arduino
+What You Need:
+
+•	
+
+•	
+
+1	–	Piezo	Speaker
+
+3	–	Jumper	Wires
+
+Hardware Setup:
+
+•	 Step	1	-	Unplug	the	USB	cord	from	your	Arduino.
+
+•	 Step	2	-	Plug	the	positive	lead	of	your	piezo	speaker	into	the	E-15	socket	on	your	breadboard.
+
+•	 Step	3	-	Plug	the	negative	lead	of	your	piezo	speaker	into	the	F-15	socket	on	your	breadboard.
+
+•	 Step	4	-	Plug	a	jumper	wire	from	the	Digital	IO	pin	8	into	the	A-15	socket	on	your	breadboard.
+
+•	 Step	5	-	Connect	a	jumper	wire	from	your	breadboard’s	ground	lane	to	the	J-15	socket	on	your	
+
+breadboard.	Ensure	that	the	ground	lane	is	still	connected.
+
+•	 Step	6	-	Reconnect	the	USB	cable	to	your	Arduino.
+
+Easy, right?
+
+Software Setup:
+
+This project is included in the Examples Section. No typing on this one! Open up your Arduino Development Environ-
+ment .Open the toneMelody Example Sketch (File	>	Examples	>	Digital	>	toneMelody).
+
+After you enter the code, press the upload button and your piezo speaker will start making noise. You can modify the 
+sound by modifying the melody[] and noteDurations[] arrays.
+
+Summary: This project produces sound out of the piezo speaker.
+
+9. Where to go From Here                                
+
+As you can see, the Arduino is an easy way to get into electronics and software. Hopefully you have seen that it is 
+easy to build simple electronic projects with it. I hope you have realized that your projects don’t have to stay simple. 
+You can build way more complex projects on top of these simple ones. Here are some of my favorite projects that 
+would be a great next step:
+
+•	 Create	Christmas	light	ornaments
+
+•	 Arduino	Traffic	light	controller
+
+•	 Arduino	Shields	to	superpower	your	project
+
+•	 Make	your	own	Arduino
+
+•	 Build	your	own	pong	game	with	an	Arduino
+
+•	 Connect	your	Arduino	to	the	internet
+
+•	 Create	a	home	automation	system	with	your	Arduino
+
+Did you like this PDF Guide? Then why not visit MakeUseOf.com for daily posts on 
+cool websites, free software and internet tips?
+
+If you want more great guides like this, why not subscribe to MakeUseOf and receive 
+instant access to 50+ PDF Guides like this one covering wide range of topics. More-
+over, you will be able to download free Cheat Sheets, Free Giveaways and other cool 
+things.
+
+Home:  
+
+http://www.makeuseof.com
+
+MakeUseOf Answers: 
+
+http://www.makeuseof.com/answers
+
+PDF Guides:  
+
+Tech Deals:   
+
+http://www.makeuseof.com/pages/
+
+http://www.makeuseof.com/pages/hot-tech-deals 
+
+Follow MakeUseOf:
+
+RSS Feed: 
+
+Newsletter:  
+
+Facebook:   
+
+Twitter: 
+
+http://feedproxy.google.com/Makeuseof
+
+http://www.makeuseof.com/pages/subscribe-to-makeuseof-newsletter
+
+http://www.facebook.com/makeuseof
+
+http://www.twitter.com/Makeuseof
+
+Think you’ve got what it takes to write a manual for MakeUseOf.com? We’re always willing 
+to hear a pitch! Send your ideas to justinpot@makeuseof.com.
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Download Other MakeUseOf PDF Guides!
+
+http://makeuseof.com/pages
+
+

Arduino/arduino-tips-tricks-and-techniques.pdf.txt

@@ -0,0 +1,996 @@
+Error: Can't find stylesheet to import.
+  ╷
+4 │ @import "gist";
+  │         ^^^^^^
+  ╵
+  app/assets/stylesheets/application.pdf.scss 4:9  root stylesheet
+
+Arduino Tips, Tricks, and
+Techniques
+
+Created by lady ada
+
+https://learn.adafruit.com/arduino-tips-tricks-and-techniques
+Last updated on 2024-03-31 03:44:05 PM EDT
+
+Table of Contents
+
+Arduino UNO FAQ
+
+• 
+• 
+• 
+• 
+
+Arduino Timeline
+New USB Chip
+More 3.3v power!
+UNO R2 and R3
+
+Arduino Libraries
+
+• 
+• 
+• 
+• 
+• 
+• 
+
+Need Help Installing a Library?
+What is a library?
+Using Libraries
+What's in a library?
+It's important to remember!
+How to install libraries
+
+Bootloader
+
+• 
+• 
+• 
+• 
+
+Bootloader for the Atmega328
+"No-Wait" Bootloader
+No-Hang Bootloader
+Upload Sketches with AVRDUDE
+
+Upgrade
+
+• 
+• 
+• 
+
+Introduction
+Replace the Chip
+Download an Arduino IDE with ATmega328 compatibility
+
+3.3V Conversion
+
+• 
+• 
+• 
+
+Introduction
+Replace the Regulator
+Replacing the Fuse
+
+Arduino Hacks
+
+• 
+• 
+
+Bumpers
+Free up some RAM
+
+ArduinoISP
+
+• 
+• 
+• 
+• 
+• 
+
+Introduction
+Parts
+Assemble
+Load the Code
+Bonus! Using with AVRdude
+
+Support Forums
+
+Arduino UNO FAQ
+
+There's so many Arduino's out there, it may get a little confusing. We wanted
+to clarify for people some of the changes in the latest version.
+
+NB this is just our opinion and interpretation of some of the decisions made
+by Arduino. We aren't associated with Arduino, and don't speak for them! If
+you have to get an Official Response to your Arduino question please contact
+them directly. Thx!
+
+NB2 Still in progress, we're collecting common questions to answer. If you
+have more questions, please post them in our forums (https://adafru.it/
+forums).
+
+Arduino Timeline
+
+But first…some history! First there was the serial Arduino (what's the name
+of it?) with RS232 which was not used outside of the Arduino team &
+friends. 
+
+The first popularly manufactured Arduino was called the NG (New
+Generation, like Star Trek, yknow?) The NG used the Atmega8 chip running
+at 16 MHz and an FT232 chip for the USB interface. The bootloader takes
+
+up 2KB of space and runs at 19200 baud.
+
+The next version was the Diecimila. The Diecimila updated the chip from the
+Atmega8 to the Atmega168. The great thing here is double the space and
+memory (16K instead of 8K). It still ran at 16MHz. The Diecimila also added
+two extra header pins for 3.3V (from the FTDI chip) and the reset pin which
+can be handy when a shield is covering up the Reset button. The bootloader
+takes up 2KB of space and runs at 19200 baud. Auto-resetting was also
+added which makes life awesomer for everyone. 
+
+In 2009, the Duemilanove was released. This one also upgraded the chip
+again, to the Atmega328. Yet another doubling of space and memory!
+Another upgrade is now the power is automagically switched between USB
+and DC-jack which removed the previous jumper. This makes it easier and
+faster to move from programming to standalone and got rid of some
+confusion. The bootloader takes up 2KB of space and runs at 57600 baud.  
+
+In 2010, we have the Uno! The Uno still uses the 328P chip and the power
+switcher. It has a smaller bootloader called OptiBoot (more space for users'
+projects) that runs at 115K. So even though the chip is the same, you get
+another 1.5K of extra flash space that was previously used by the bootloader.
+The FTDI chip has also been replaced with a atmega8u2 which allows for
+different kinds of USB interfaces. Finally, there's an extra 3.3V regulator
+(LP2985) for a better 3.3V supply. whew! 
+
+New USB Chip
+
+So! All of the older Arduinos (NG, Diecimila and Duemilanove) have used an
+FTDI chip (the FT232RL) to convert the TTL serial from the Arduino chip
+(Atmel ATmega). This allows for printable debugging, connecting to software
+like PureData/Max, Processing, Python, etc. etc. It also allows updating the
+firmware via the serial bootloader.
+
+The good news about the FT232RL has royalty-free drivers and pretty much
+just works. The bad news is that it can -only- act as a USB/Serial port. It
+can't act like a keyboard, mouse, disk drive, MIDI device, etc.
+
+The Uno has changed that by exchanging the FT232RL chip with an
+atmega8u2 chip. There are a few things that are possible with this new chip
+but before we discuss that lets make it clear that by default, this chip acts
+identically to the FTDI chip that it replaces. It's just a USB-serial port!
+
+One improvement in updating the chip is that, previously, Mac users needed
+to install FTDI drivers. The 8u2 imitates a 'generic' CDC serial device. So
+now, Mac users do not have to install a driver. Windows users still need to
+install the .INF file but luckily there are no drivers. This means there will be
+fewer problems with new versions of windows. There is no way to have a
+serial USB device that doesn't require an INF file in windows, sadly :(
+
+The big thing that is nice about the 8u2 is that advanced users can turn it
+into a different kind of USB device. For example it can act like a keyboard or
+mouse. Or a disk driver. Or a MIDI interface, etc. Right now there are no
+examples of how to do this, but we hope to post some shortly.
+
+And, finally, going with the 8u2 reduced the price of the board which made
+up for some of the other extras.
+
+Why not just go with a atmega32u4?
+
+The Arduino team has indicated they thought about this but preferred that
+hackability of a DIP chip. 
+
+Right now there are a few Arduino's with a 32u4 chip such as the Leonardo,
+Micro and Esplora
+
+How can I change the USB firmware?
+
+The 8u2 can be programmed by soldering a 6-pin ISP header (the R3 has the
+6-pin header pre-soldered in) and using a standard AVR programmer. You
+can also use the bootloader (DFU) in the 8u2. On first generation Unos, you
+enable this by soldering the 10K resistor right underneath the board. (R2
+and R3 versions of the Uno use the 16U2 and do not require the resistor!)
+Again, we don't have any examples or tutorials but hope to shortly.
+
+The code for the 8u2 is based on LUFA, Dean Cameran's totally awesome
+USB-AVR library that has great examples and documentation. Its also
+completely open source.
+
+Does the Uno use a resonator or a crystal for
+the processor clock?
+
+The FT232RL had an internal oscillator whereas the 8u2 does not. That
+means there is a 16mhz crystal next to the 8u2 to allow it to keep up with
+precise USB timing.
+
+On the other hand, the Atmega328p chip that is the core processor in the
+Arduino now has a 16mhz ceramic resonator. Ceramic resonators are
+slightly less precise than crystals but we have been assured that this one
+was specified and works quite well.
+
+So the Arduino is not as precise, timing-wise?
+
+The short answer is: yes. The long answer is that most things that people are
+doing with Arduino do not rely on 20ppm precision timing where 100ppm
+would fail. For people who want long term precise timekeeping we suggest
+going with a TCXO (temperature compensation crystal oscillator) - but you
+would know if you needed that.
+
+Why not have one 16Mhz crystal shared
+between both?
+
+Good question, technically you can. However, in practice the board did not
+make it through FCC certification with one crystal (long traces with fast
+squarewaves = lots of noise).
+
+OK well lets say I don't care about that...
+
+You can absolutely connect the CLKO out the crystal from the '8u2 to the
+'328p but you're on your own as we don't think there will be any tutorials
+about that.
+
+Whats with the FCC logo on the back?
+
+Arduino is now FCC certified! That means that the board by itself passes
+FCC certification for electromagnetic emissions. It does not mean that your
+project is FCC certified. The moment you change the Arduino, it's no longer
+FCC certified (although we'd like some back-up documentation on this).
+
+It is also, still, CE certified for Europeans.
+
+A new Bootloader?
+
+There's a new bootloader. It works just like the old one - being an STK500-
+protocol compatible but its a quarter of the size! Down from 2K, the new
+bootloader is a tiny 512b. This gives you more space for your project code!
+Yay! It's also faster - 115K instead of 57.6k so you'll be uploading code in 3
+seconds.
+
+The Bad News is that you must make sure to select Uno in the Boards
+menu!!! If you don't things will be confusing because the bootloader speed
+is wrong, and you won't get that extra 1.5K!
+
+Overall, its a good direction, and the chips can be used in older Arduinos
+just fine (so you can upgrade your Diecimila or Duemilanove to the Uno by
+simply replacing the chip).
+
+For more detailed information about the bootloader, such as source code,
+please visit the Optiboot (https://adafru.it/aUM) project page.
+
+Why not just use the '8u2 as a programmer?
+
+While it is possible that the 8u2 could act as a full ISP programmer there are
+a few reasons why its good that it isn't.
+
+1. 
+
+Giving beginners access to a full ISP programmer will result in bricked
+chips. There's no risk of messing up the Arduino chip beyond
+recognition if it's just being bootloaded
+
+2. 
+
+3. 
+
+Having the chip act only as a USB/serial passthrough simplifies the
+firmware so that the chip has only one function instead of having to
+have it do double duty as programmer -and- serial interface (think
+about it, its not easy)
+Backwards compatibility - the Arduino chips can still be programmed
+with FTDI breakout boards or cables, making it easy for people to
+breadboard or make clones.
+
+How does the new '8u2 affect Arduino-
+derivatives?
+
+Every USB device needs to have a unique product id and vendor id. Vendor
+IDs (VID) are sold to companies and Product IDs (PID) are chosen by that
+company. So for example FTDI owns VID #0403 and they give their chips
+ID's between #0000 and #FFFF (65,536 different PIDs) Older Ardiuno's
+used FTDI's VID/PID as that is part of the deal when you purchase their
+chips. Because the Uno does not use an FTDI chip anymore, the Arduino
+team had to purchase a USB Vendor ID (VID). Every Arduino product will
+now have their own PID starting with the Uno (#0001).
+
+If you want to make your own Arduino-compatible board, you have a few
+choices:
+
+1. 
+2. 
+
+3. 
+
+4. 
+
+Don't use an 8u2, go with an FTDI chip instead that comes with a VID
+If you're planning to make more than one board for your personal use,
+you will have to purchase a VID from USB IF (https://adafru.it/aUN) for
+a one time $2000 fee
+If you're making a single board for your own experimentation, you can
+pick a VID/PID that doesn't interfere with any devices on your
+computer and substitute those in
+You can purchase licenses for single VID/PID pairs from companies that
+develop USB devices (we dont have any specific links at the moment)
+
+However, you can't use the Arduino VID when distributing your own
+Arduino-compatibles! If the cost of a VID is too much for you, simply go with
+an FTDI chip, K?
+
+I tried to find a place to buy some '8u2s and
+couldnt locate any!
+
+Yep, there is a worldwide shortage of Atmel parts right now. Even the chip
+used in the Arduino core (Atmega328P) is really hard to get. This happens
+after recesssions. We hope that these and other Atmel chips will show up
+again in places like digikey soon. Till then, keep searching on findchips.com!
+
+So does this mean there may be an Arduino
+shortage?
+
+Probably not. The Arduino team buys chips in the 10's of thousands, directly
+from Atmel. They probably get priority over distributors because of this.
+We're assuming the team bought enough to last for a while.
+
+Did the Arduino team move from the FTDI
+chip to the '8u2 to screw over derivative-
+makers?
+
+While the appearance of a hard-to-get chip coupled with the VID/PID
+mishegas may seem to be a little annoying, we don't think that means that
+the Arduino team is being malicious or attempting to make life difficult for
+people who make derivatives. The move to an '8u2 makes the Arduino more
+powerful, and easy to use as there are fewer drivers to install. While there is
+a shortage now, there will eventually be plenty of chips on the market.
+
+Some people in the Arduino forum have thought of forming a group that
+would purchase a VID for Arduinites to use in personal projects. This is a
+pretty good idea and its probably the best way to avoid VID/PID conflicts.
+Between 65,536 projects, that comes to under a nickel per PID.
+
+And of course, because they didn't get rid of the bootloader system, you can 
+always just use an FTDI chip.
+
+Are Shields still going to work?
+
+All previous shields should still work perfectly fine as the header spacing is
+the same, the core chip is the same and the location of parts is the same. In
+fact, some should work better because the 3V supply has been upgraded
+(see next point).
+
+Will enclosures, plates, etc still work?
+
+Yup! The Uno is physicially the same size and layout as previous Arduinos.
+The mounting holes are in the same location. There is an additional
+mounting hole as well, now.
+
+More 3.3v power!
+
+One sad thing about older boards is that they had a 3.3v power supply but it
+was really just whatever the FTDI chip's internal 3.3v regulator could give.
+You -could- get 50mA out of it, maybe. But high power stuff like XBees, SD
+cards, some fast ADC or DACs could easily drag down the FTDI chip and
+reset the USB connection. The Uno solves this problem by adding a new
+3.3V regulator the LP2985 which can easily provide 150mA.
+
+The LP2985 is a very high quality regulator, and will work great for
+powering stuff and as a nice solid 1% analog reference.
+
+Why is the Arduino chip running at 16MHz
+when it can run at 20MHz?
+
+This is a common question. The reason is that the first Arduino used the
+Atmega8 which could not run faster than 16Mhz. As the chip has been
+upgraded they wanted to make the boards speed compatible. Arduino is also
+not really intended for fast-processing (its only 8-bit anyways) so the chips
+are running at 16MHz.
+
+Is it still Open source hardware and software?
+
+Yes! The Uno is still available under a Creative commons license. You can
+get the latest schematics and layouts over at the Arduino website. (https://
+adafru.it/aP4)
+
+UNO R2 and R3
+
+During fall of 2011, the Arduino team revealed that there will be a new
+minor revision of the classic Arduino, the "UNO R3" (revision 3). A lot of
+people have asked us about the R3 so here is everything we know so far.
+
+1. 
+
+2. 
+
+The UNO R3 is not available to resellers until December 1st or so.
+Really! Nobody has them until then!
+The UNO R3 is backwards compatible with the UNO - same driver,
+same uploading, same look
+
+There are a few changes in the UNO, here is what they are:
+
+1. 
+
+2. 
+
+3. 
+
+The USB controller chip has moved from an atmega8u2 (8K flash) to an
+atmega16u2 (16K flash). This does not mean that you have more
+flash or RAM for your sketches this upgrade is for the USB interface
+chip only. In theory this will mean that it will be easier to have low
+level USB interfaces such as MIDI/Joystick/Keyboard available. 
+However these are only theoretical at this time, there is no example
+code or firmware which will actually do this.
+There are three more breakout pins on the PCB, next to the AREF pin
+there is are two I2C pins (SDA/SCL) - this is a duplication of the
+Analog 4 and 5 pins. There is not an extra I2C interface or anything, its
+just that they made a copy of those pins there for future shields since
+the I2C pins are in a different place on Mega. There is also an IOREF
+pin which is next to the Reset pin - this is to let shields know what the
+running I/O pin voltage is on the board (for the UNO, its 5V). Again, this
+is a duplication of the power pin, it does not add voltage level shifting
+to the UNO.
+The RESET button has moved to be next to the USB connector, this
+makes it easier to press when a shield is on top.
+
+Here is what didn't change in the UNO:
+
+1. 
+
+2. 
+
+3. 
+4. 
+
+5. 
+6. 
+
+Processor size and speed - its the same ATMega328P running at 16MHz
+that we've had since the Duemilanove. Your code will not run faster or
+better on the R3
+Same number of pins - no extra pins are added EVEN THOUGH
+THERE ARE MORE BREAKOUTS (see above!)
+Board size and shape - same size as before
+Shield compatibility - Every shield that works and plugs into the UNO
+R1/R2 should be able to work fine with the R3
+Driver - the driver is the same
+Upload speed - same upload speed and technique
+
+If you want to get up an Arduino R3 now, visit the adafruit store (http://
+adafru.it/50) and pick up a board or pack! 
+
+Arduino Libraries
+
+Need Help Installing a Library?
+
+Check out our super-detailed tutorial for all operating systems here: 
+http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-
+use (https://adafru.it/aYM)
+
+What is a library?
+
+Libraries are great places, and not yet illegal in the United States! If you
+ever need to learn how to do something, like say fix a motorcycle, you can go
+to your local library and take out a book. Sure you could buy the book but
+the library is nice because as a resource you can get the book whenever you
+need it, keeping your house uncluttered.
+
+Software Libraries are very similar. We already studied what a procedure is,
+in lesson 3 (https://adafru.it/aV0): a procedure is a list of things to do. A
+library is a big collection of procedures, where all the procedures are
+related! If you, say, want to control a motor, you may want to find a Motor
+Control Library: a collection of procedures that have already been written
+for you that you can use without having to do the dirty work of learning the
+nuances of motors.
+
+For example, this is the Serial Library, which allows the Arduino to send
+data back to the computer:
+
+Using Libraries
+
+One of the best features of the Arduino project is the ability to add on pre-
+crafted libraries that add hardware support. There's tons of them, and you
+can pick and choose which to install. They're only loaded in when the sketch
+you're working on needs them, so for the most part you can download and
+
+stash them for future use.
+
+Sketches will often depend on libraries, you can see what they are by
+looking at the top of the sketch. If you see something like:
+
+#include <FatReader.h>
+
+That means that you'll need a library called FatReader or a library that
+contains the file FatReader. If you dont have it installed you'll get an error:
+
+What's in a library?
+
+A library is a folder with some files in it, the files will end in .cpp (C++ code
+file) and .h (C++ header file).
+
+There may also be some .o files. The .o files are C++ compiled Objects. If
+you end up working on the library and modifying it, be sure to delete the .o
+files as that will force the Arduino IDE to recompile the modified .cpp's into
+fresh .o's.
+
+Two optional files you may see are keywords.txt (this is a hints file to tell
+the Arduino IDE how to colorize your sketch and examples folder, which
+may have some handy test-sketches. These will show up under the
+File→Examples→Library dropdown.
+
+It's important to remember!
+
+The structure of the library folder is very important! The .c and .h files must
+be in the 'lowest level' of folders. For example, you cant have Arduino/
+libraries/WaveHC/WaveHC/file.c or Arduino/libraries/MyLibraries/
+WaveHC/file.c - it must be Arduino/libraries/WaveHC/file.c
+
+How to install libraries
+
+In Arduino v16 and earlier, libraries were stored in the 
+ArduinoInstallDirectory/hardware/libraries folder, which also contained
+all the built-in libraries (like Wire and Serial).
+
+In v17 and up, the user libraries are now stored in the 
+ArduinoSketchDirectory/libraries folder. You may need to make the 
+libraries sub-folder the first time. However, the good thing about this is you
+wont have to move & reinstall your libraries every time you upgrade the
+software.
+
+For example, here is how it looks when NewSoftSerial is installed in
+Windows (of course your username will be different).
+
+On a Mac, your arduino sketch folder is likely going to be called 
+Documents/arduino so create a NEW FOLDER inside that called libraries
+and place the uncompressed library folder inside of that. 
+
+Check that the Documents/arduino/libraries/MyNewLibary folder contains
+the .cpp and .h files. 
+
+After you're done, restart the Arduino IDE. 
+
+Bootloader
+
+This is some advanced bootloader tweaks - 99% of Arduino users should not
+mess with their bootloader! Only for the wild at heart!
+
+Bootloader for the Atmega328
+
+Here is the package for a 'fixed up' ATmega328 bootloader (https://adafru.it/
+cnD). To program it you may need to change the Makefile's ISPTOOL, etc
+definitions. The commands are make adaboot328; make
+TARGET=adaboot328 isp328 (I couldn't get the default 'isp' target to
+work so I made a new one).
+
+This version has a few fixes: first it integrates the 'no-wait' and 'no-hang'
+fixes below. It also fixes the annoying "missing signature bytes" bug that
+freaks out avrdude when programming without the IDE. I also repaired the
+EEPROM code so that now you can upload and download the EEPROM
+memory as well as flash. Finally, theres a 'upload feedback' using the LED,
+for arduino clones that don't have TX/RX leds.
+
+Please note that the fuses are different for this chip because of the extended
+memory!
+
+"No-Wait" Bootloader
+
+Here's a bootloader hack that will automatically start the sketch after it has
+been uploaded and will also only start the bootloader when the reset button
+is pressed (so when you plug in power it will go straight to the sketch).
+
+Copy the following lines:
+
+ch = MCUSR;
+    MCUSR = 0;
+
+    WDTCSR |= _BV(WDCE) | _BV(WDE);
+    WDTCSR = 0;
+
+    // Check if the WDT was used to reset, in which case we dont bootload and skip straight to the code. woot.
+    if (! (ch &  _BV(EXTRF))) // if its a not an external reset...
+      app_start();  // skip bootloader
+
+And paste them as shown: 
+
+/* main program starts here */
+int main(void)
+{
+    uint8_t ch,ch2;
+    uint16_t w;
+
+    ch = MCUSR;
+    MCUSR = 0;
+
+    WDTCSR |= _BV(WDCE) | _BV(WDE);
+    WDTCSR = 0;
+
+    // Check if the WDT was used to reset, in which case we dont bootload and skip straight to the code. woot.
+    if (! (ch &  _BV(EXTRF))) // if its a not an external reset...
+      app_start();  // skip bootloader
+
+    /* set pin direction for bootloader pin and enable pullup */
+    /* for ATmega128, two pins need to be initialized */
+
+Now, in the same way, copy the following code: 
+
+// autoreset via watchdog (sneaky!)
+  WDTCSR = _BV(WDE);
+  while (1); // 16 ms
+
+And paste it here: 
+
+/* Leave programming mode  */
+
+else if(ch=='Q') {
+  nothing_response();
+
+  // autoreset via watchdog (sneaky!)
+
+  WDTCSR = _BV(WDE);
+  while (1); // 16 ms
+	}
+/* Erase device, don't care as we will erase one page at a time anyway.  */
+else if(ch=='R') {
+    nothing_response();
+	}
+
+You can also just grab the source code (https://adafru.it/cnE) and compiled
+hex file here (https://adafru.it/cnF).
+
+It will work in NG or Diecimila Arduinos.
+
+No-Hang Bootloader
+
+If you are using a Diecimila with auto-reset you may be frustrated when your
+communications program accidentally triggers the bootloader. Here is a
+quick hack to make the bootloader quit if it doesn't receive a '0' character
+first (which would indicate the Arduino software is trying to talk to it.
+
+Copy the following line: 
+
+uint8_t firstchar = 0;
+
+And paste: 
+
+/* main program starts here */
+int main(void)
+{
+    uint8_t ch,ch2;
+    uint16_t w;
+    uint8_t firstchar = 0;
+
+Copy: 
+
+firstchar = 1; // we got an appropriate bootloader instruction
+
+Paste: 
+
+/* Hello is anyone home ? */ 
+if(ch=='0') {
+  firstchar = 1; // we got an appropriate bootloader instruction
+  nothing_response();
+
+Then paste this below the above code:
+
+	} else if (firstchar == 0) {
+
+  // the first character we got is not '0', lets bail!
+  // autoreset via watchdog (sneaky!)
+  WDTCSR = _BV(WDE);
+  while (1); // 16 ms
+	}
+
+You can also just replace the last two lines with app_start()
+
+Upload Sketches with AVRDUDE
+
+The bootloader is an 'stk500'-compatible, which means you can use good ol'
+AVRDUDE to program the arduino.
+
+Just plug in the USB cable, then press the reset just before you start
+avrdude. If you need an avrdude tutorial, check out this page (https://
+adafru.it/aVy).
+
+• 
+• 
+• 
+• 
+• 
+
+Use -b 19200 to set the baud rate to 19200
+The device signature reads dont seem to work so you'll want to use -F
+The programmer type is avrisp
+The device type is -p m168
+The port is whatever the FTDI chip shows up as
+
+Upgrade
+
+Introduction
+
+The 'brains' of the Arduino is a microcontroller called an ATmega. It is a
+product line from ATMEL (https://adafru.it/aVz) (a Norweigen chip
+company). Just like Intel & AMD release new & better chips each year, so
+does Atmel. The first versions of the Arduino (up to the NG) used an
+ATmega8 - a chip with 8K of flash memory and 1K of RAM. Then Atmel
+released the ATmega168 (https://adafru.it/aIH), a drop-in replacement with
+16K of flash and 1K of RAM - a really big improvement! Now there is the 
+ATmega328 (https://adafru.it/aIH) with 32K of flash and 2K of RAM.
+
+Updating and replacing your Arduino is easy and painless and costs only a
+few dollars. Your sketches will work just as before but with a little more
+breathing room.
+
+In order to perform this upgrade you will have to either purchase a
+preprogrammed chip (https://adafru.it/aIH) or program it yourself with a 
+AVR programmer (https://adafru.it/aIH) or by 'bitbanging' it.
+
+Replace the Chip
+
+First, gently pry the Arduino microcontroller from its socket using a small
+flat screwdriver or similar. Try to make sure the pins dont get bent. Put it in
+a safe place. Preferably in an anti-static bag.
+
+Next, prepare the new chip. The pins of ICs are a little skewed when they
+come from the factory, so they need to be bent in just a tiny bit, to be
+parallel. Grip the chip from the ends and use a table.
+
+Finally, replace the old chip, lining up all the pins and making sure that the
+notch in the chip matches the notch in the socket!
+
+Download an Arduino IDE with ATmega328
+compatibility
+
+Version 13 and up of the Arduino software supports the 328! (https://
+adafru.it/aVB)
+
+If you purchased a chip from Adafruit that shipped before Feb 5, 2009 the
+chip will have the baudrate set at 19200 (same as the older Arduinos). After
+Feb 5 the upgrade chips were changed to 57600 baud rate (3 times faster!)
+in order to be compatible with new Arduinos. If you have a 19200 baud rate
+chip you will have difficulty uploading. Simply quit the Arduino application
+and edit the file in the hardware folder named boards.txt and change the
+line from:
+
+atmega328.upload.speed=57600
+
+to:
+
+atmega328.upload.speed=19200
+
+If you're having problems please try BOTH just in case!
+
+3.3V Conversion
+
+Introduction
+
+Arduino UNO's and many other Arduino boards run on 5 volts, which for a
+long time was the 'standard' voltage for hobbyist electronics and
+microcontrollers. But now the coolest new sensors, displays and chips are
+3.3V and are not 5V compatible. For example, XBee radios, and SD cards
+and acellerometers all run on 3.3V logic and power. If you tried to connect to
+them with 5V you could damage the internals of the accessory.
+
+We use chips like the CD4050 to do level conversion (https://adafru.it/Cc7)
+but if you are using a lot of 3.3V devices, maybe you're just better off
+upgrading the entire Arduino to run from 3.3V!
+
+To do that, we will replace the regulator so that the DC barrel jack goes to a
+3.3v type regulator, not a 5V. And then reconfigure the 5V usb power line so
+it goes through the regulator as well.
+
+Replace the Regulator
+
+The default regulator is a 5.0V type, but we want 3.3V out, so we'll need to
+replace it. We'll use a 1117-3.3V (there are a few manufacturers of 1117
+regulators, just like the 7805 is made by many factories) regulator in a
+TO-252-3 package. It looks like this:
+
+You can get these from any electronics component shop, for example here is
+the digikey link (https://adafru.it/aLu).
+
+To start, we'll need to remove the old regulator. The easiest way to do that is
+to first clip the two legs.
+
+Then you'll need to heat the tab up to get it liquid so you can lift off the old
+part. Although it may seem counter intuitive, its best to add some solder to
+the tab, melt it on with your iron, this will improve the heat conduction since
+the tab is so large. 
+
+Clean up the tabs and remove any clipped parts still stuck on.
+
+Now line up the new 3.3V regulator, and solder the tab first, use plenty of
+solder and be patient, the tab acts like a heat sink.
+
+Then do the two legs.
+
+Replacing the Fuse
+
+The next part is a little tricky, the USB jack gives us exactly 5V already, and
+normally that is tied to the output of the voltage regulator (essentially, its
+got a little circuitry that connects it when the DC jack is not powered).
+
+The easiest way to make the USB 5V also go through the regulator is to
+remove the fuse and solder a diode from the USB output to the regulator
+input.
+
+You can use any power diode, a 1N4001 is perfect (https://adafru.it/cuU) and
+only a few pennies.
+
+The trade off is now there is no 500 mA fuse for the USB jack. The good
+news is that computers will have their own fuses on the USB connector
+(inside the computer) so its not likely you will destroy your PC. But be aware
+
+that you're losing a little safety.
+
+Heat the fuse with your soldering iron, again adding solder may help
+thermal conductivity. Since the fuse is very conductive you can probably just
+heat one side for a while and both ends will melt.
+
+Clip the diode short and bend the leads over. Solder the side without a stripe
+(anode) to the old fuse pad, nearest the board edge. Solder the striped end
+(cathode) to the right hand leg of the regulator.
+
+The Arduino will still automatically select whichever power plug is giving
+you more power.
+
+That's it! You are now 3.3V powered. This is a little lower than the power/
+frequency specification for the AVR chips since they ought to have about
+3.6V to run 16Mhz but its probably not going to be an issue since AVRs can
+be overclocked a little.
+
+Arduino Hacks
+
+Bumpers
+
+Having the conductive traces touch your table is not so great, you can
+protect your Arduino by adding bumpers to the bottom.
+
+You can buy these from McMaster Carr part no. 95495K66 (https://adafru.it/
+aVH) (in large quantities) or Adafruit (http://adafru.it/550)
+
+Free up some RAM
+
+If you're working on a project that needs a lot of memory, you can free up
+100 more bytes (10% of the RAM on an ATmega168!) by lessening the serial
+receive buffer. By default its 128 bytes, which is quite a bit!
+
+Open up hardware/cores/arduino (or cores/arduino) directory, and edit
+the file named wiring_serial.c or HardwareSerial.cpp
+
+Near the top is a #define RX_BUFFER_SIZE 128, which means 128 bytes
+are used for the buffer. You can change this to 32 (or even 16!). If you have
+almost no serial input, make it as low as you'd like as long as its > 0.
+
+You can also save another 2 bytes by changing rx_buffer_head and 
+rx_buffer_tail from int to uint8_t
+
+ArduinoISP
+
+Introduction
+
+A lot of people start learning about microcontrollers with an Arduino but
+then want to build their own projects without having to sacrifice their dev
+board. Or maybe they want to make their own Arduino variant, that is
+compatible with the IDE. Either way, a common problem is how to burn the
+bootloader onto the fresh AVR chip. Since AVRs come blank, they need to be
+set up to be Arduino IDE compatible but to do that you need an AVR
+programmer (like the USBtinyISP).
+
+The good news is that you can burn bootloader using your existing Arduino
+with only a little bit of work. There's even a minitutorial on the arduino.cc
+site (https://adafru.it/aVI).
+
+This tutorial is an extention of that tutorial. First we'll show how you can
+make a permanent bootloader-burner by soldering a 28-pin ZIF
+socket (http://adafru.it/382) to a proto shield  (http://adafru.it/51)and use the
+PWM output line of the Arduino to generate a clock. This will let you 'rescue'
+many chips that have been set to the wrong type of oscillator, or change
+ones that are set from external oscillator (most Arduino bootloaders) to
+internal (such as the lilypad).
+
+Parts
+
+You will need…
+
+• 
+• 
+• 
+
+• 
+• 
+
+An Arduino (http://adafru.it/50)
+A proto shield kit (http://adafru.it/51)
+28-pin ZIF (zero-insertion force) socket (http://adafru.it/382) (you can
+use a plain socket but ZIF is ideal)
+Some wire (http://adafru.it/289)
+Blank ATmega328P (https://adafru.it/Cc8)
+
+If you bought the kit from Adafruit, you'll have an extra few items such as a
+Piezo beeper, LEDs, buttons, etc. that you can use for the Standalone
+version of this project (https://adafru.it/clC), just ignore them for now!
+
+Assemble
+
+First up, place the ZIF socket on the proto shield like so:
+
+Solder all 28 pins for a solid connection!
+
+Solder the following wires to the ZIF socket
+
+• 
+
+• 
+• 
+• 
+• 
+• 
+• 
+• 
+• 
+
+Pin 1 to digital 10 - Blue Don't forget to bend the wire over
+underneath to connect to the ZIF socket pin when soldering!!!
+Pin 7 to 5V - Red
+Pin 8 to Ground - Black
+Pin 9 to digital 9 - Gray
+Pin 17 to digital 11 - Brown
+Pin 18 to digital 12 - Orange
+Pin 19 to digital 13 - Yellow
+Pin 20 to +5V - Red
+Pin 22 to Ground - Black
+
+Follow the protoshield tutorial to solder in the Red LED into LED1 position,
+Green LED into LED2 position. Also solder in the two 1.0K resistors next to
+the LEDs. We'll use the LEDs as indicators. Then solder a wire from the
+LED2 breakout (white) to analog 0 and a wire from LED1 breakout (white)
+to digital 8. 
+
+Finally, you'll need to solder on the header to allow the shield to be placed
+on, break the 0.1" male header and place it into the Arduino sockets. Then
+place the shield above on top to solder it in place.
+
+Load the Code
+
+Time to load the sketch! Grab the code from our Github repository and paste
+it into a new sketch (https://adafru.it/ECM). Then upload it to the Arduino.
+
+We have a report that this procedure does not work with Arduino 1.5.2. Use
+the latest mainstream Arduino release instead!
+Plug the shield on top, lift the latch, pop in the chip and then lower the
+latch. Make sure the chip orientation is like so (so with the lever on the left
+side you can read the text): 
+
+With the USB cable still plugged in (and the same Serial port selected as
+before) Select Tools→Burn Bootloader→w/Arduino as ISP
+
+On newer versions of the Arduino IDE, select Arduino as ISP from the 
+Tools→Programmer menu, then select Burn Bootloader from the Tools
+menu. 
+
+The Green LED will be on during the programming, when its done you'll see
+this message and the LED will turn off.
+
+Thats it! Don't forget, you can burn a few different kinds of bootloaders,
+such as Uno, Duemilanove, Lilypad so depending on your situation you may
+want to use one over the other. 
+
+Bonus! Using with AVRdude
+
+You can use ArduinoISP from the command line very easily, with AVRdude
+which is the standard program used to program AVRs by running:
+
+avrdude -c arduino -p atmega328 -P COMPORT -b 19200 -U flash:w:filetoburn.hex
+
+Instead of atmega328 you can also program atmega8 atmega88
+atmega48 atmega168, etc. 
+
+Support Forums
+
+Support Forums (https://adafru.it/forums)
+
+

C/EssentialC.pdf.txt

@@ -0,0 +1,2747 @@
+Essential C
+
+By Nick Parlante
+
+Copyright 1996-2003, Nick Parlante
+
+This  Stanford CS Education document tries to summarize all the basic features of the C
+language. The coverage is pretty quick, so it is most appropriate as review or for someone
+with some programming background in another language. Topics include variables, int
+types, floating point types, promotion, truncation, operators, control structures (if, while,
+for), functions, value parameters, reference parameters, structs, pointers, arrays, the pre-
+processor, and the standard C library functions.
+
+The most recent version is always maintained at its Stanford CS Education Library URL
+http://cslibrary.stanford.edu/101/. Please send your comments to
+nick.parlante@cs.stanford.edu.
+
+I hope you can share and enjoy this document in the spirit of goodwill in which it is given
+away -- Nick Parlante, 4/2003, Stanford California.
+
+Stanford CS Education Library
+CS Education Library. This and other educational materials are available for free at
+http://cslibrary.stanford.edu/. This article is free to be used, reproduced, excerpted,
+retransmitted, or sold so long as this notice is clearly reproduced at its beginning.
+Table of Contents
+
+This is document #101, Essential C, in the Stanford
+
+Introduction .........................................................................................pg. 2
+
+Where C came from, what is it like, what other resources might you look at.
+
+Section 1
+
+Basic Types and Operators ..........................................pg. 3
+
+Integer types, floating point types, assignment operator, comparison operators,
+arithmetic operators, truncation, promotion.
+
+Section 2
+
+Control Structures ........................................................pg. 11
+
+If statement, conditional operator, switch, while, for, do-while, break, continue.
+
+Section 3
+
+Complex Data Types .....................................................pg. 15
+
+Structs, arrays, pointers, ampersand operator (&), NULL, C strings, typedef.
+
+Section 4
+
+Functions ........................................................................pg. 24
+
+Functions, void, value and reference parameters, const.
+
+Section 5
+
+Odds and Ends ..............................................................pg. 29
+
+Main(), the .h/.c file convention, pre-processor, assert.
+
+Section 6
+
+Advanced Arrays and Pointers ....................................pg. 33
+
+How arrays and pointers interact. The [ ] and + operators with pointers, base
+address/offset arithmetic, heap memory management, heap arrays.
+
+Section 7
+
+Operators and Standard Library Reference ..............pg. 41
+A summary reference of the most common operators and library functions.
+
+The C Language
+C is a professional programmer's language. It was designed to get in one's way as little as
+possible. Kernighan and Ritchie wrote the original language definition in their book, The
+C Programming Language (below), as part of their research at AT&T. Unix and C++
+emerged from the same labs. For several years I used AT&T as my long distance carrier
+in appreciation of all that CS research, but hearing "thank you for using AT&T" for the
+millionth time has used up that good will.
+
+2
+
+Some languages are forgiving. The programmer needs only a basic sense of how things
+work. Errors in the code are flagged by the compile-time or run-time system, and the
+programmer can muddle through and eventually fix things up to work correctly. The C
+language is not like that.
+
+The C programming model is that the programmer knows exactly what they want to do
+and how to use the language constructs to achieve that goal. The language lets the expert
+programmer express what they want in the minimum time by staying out of their way.
+
+C is "simple" in that the number of components in the language is small-- If two language
+features accomplish more-or-less the same thing, C will include only one. C's syntax is
+terse and the language does not restrict what is "allowed" -- the programmer can pretty
+much do whatever they want.
+
+C's type system and error checks exist only at compile-time. The compiled code runs in a
+stripped down run-time model with no safety checks for bad type casts, bad array indices,
+or bad pointers. There is no garbage collector to manage memory. Instead the
+programmer mangages heap memory manually. All this makes C fast but fragile.
+
+Analysis -- Where C Fits
+Because of the above features, C is hard for beginners. A feature can work fine in one
+context, but crash in another. The programmer needs to understand how the features work
+and use them correctly. On the other hand, the number of features is pretty small.
+
+Like most programmers, I have had some moments of real loathing for the C language. It
+can be irritatingly obedient -- you type something incorrectly, and it has a way of
+compiling fine and just doing something you don't expect at run-time. However, as I have
+become a more experienced C programmer, I have grown to appreciate C's straight-to-the
+point style. I have learned not to fall into its little traps, and I appreciate its simplicity.
+
+Perhaps the best advice is just to be careful. Don't type things in you don't understand.
+Debugging takes too much time. Have a mental picture (or a real drawing) of how your C
+code is using memory. That's good advice in any language, but in C it's critical.
+
+Perl and Java are more "portable" than C (you can run them on different computers
+without a recompile). Java and C++ are more structured than C. Structure is useful for
+large projects. C works best for small projects where performance is important and the
+progammers have the time and skill to make it work in C. In any case, C is a very popular
+and influential language. This is mainly because of C's clean (if minimal) style, it's lack
+of annoying or regrettable constructs, and the relative ease of writing a C compiler.
+
+Other Resources
+
+•
+
+•
+
+•
+
+The C Programming Language, 2nd ed., by Kernighan and Ritchie. The thin book
+which for years was the bible for all C programmers. Written by the original
+designers of the language. The explanations are pretty short, so this book is better as a
+reference than for beginners.
+http://cslibrary.stanford.edu/102/
+about local memory, pointers, reference parameters, and heap memory than in this
+article, and memory is really the hardest part of C and C++.
+http://cslibrary.stanford.edu//103/
+basics of pointers and C, these problems are a good way to get more practice.
+
+Linked List Basics --  Once you understand the
+
+Pointers and Memory --  Much more detail
+
+3
+
+Section 1
+Basic Types and Operators
+C provides a standard, minimal set of basic data types. Sometimes these are called
+"primitive" types. More complex data structures can be built up from these basic types.
+
+Integer Types
+The "integral" types in C form a family of integer types. They all behave like integers and
+can be mixed together and used in similar ways. The differences are due to the different
+number of bits ("widths") used to implement each type -- the wider types can store a
+greater ranges of values.
+
+char
+
+ASCII character -- at least 8 bits. Pronounced "car". As a practical matter
+char is basically always a byte which is 8 bits which is enough to store a single
+ASCII character. 8 bits provides a signed range of -128..127 or an unsigned range is
+0..255. char is also required to be the "smallest addressable unit" for the machine --
+each byte in memory has its own address.
+
+short
+
+Small integer -- at least 16 bits which provides a signed range of
+
+-32768..32767. Typical size is 16 bits. Not used so much.
+
+int
+
+Default integer -- at least 16 bits, with 32 bits being typical. Defined to be
+
+the "most comfortable" size for the computer. If you do not really care about the
+range for an integer variable, declare it int since that is likely to be an appropriate
+size (16 or 32 bit) which works well for that machine.
+
+long
+
+Large integer -- at least 32 bits. Typical size is 32 bits which gives a signed
+range of about -2 billion ..+2 billion. Some compilers support "long long" for 64 bit
+ints.
+
+The integer types can be preceded by the qualifier unsigned which disallows
+representing negative numbers, but doubles the largest positive number representable. For
+example, a 16 bit implementation of short can store numbers in the range
+-32768..32767, while unsigned short can store 0..65535. You can think of pointers
+as being a form of unsigned long on a machine with 4 byte pointers. In my opinion,
+it's best to avoid using unsigned unless you really need to. It tends to cause more
+misunderstandings and problems than it is worth.
+
+Extra: Portability Problems
+Instead of defining the exact sizes of the integer types, C defines lower bounds. This
+makes it easier to implement C compilers on a wide range of hardware. Unfortunately it
+occasionally leads to bugs where a program runs differently on a 16-bit-int machine than
+it runs on a 32-bit-int machine. In particular, if you are designing a function that will be
+implemented on several different machines, it is a good idea to use typedefs to set up
+types like Int32 for 32 bit int and Int16 for 16 bit int. That way you can prototype a
+function Foo(Int32) and be confident that the typedefs for each machine will be set so
+that the function really takes exactly a 32 bit int. That way the code will behave the same
+on all the different machines.
+
+char Constants
+A char constant is written with single quotes (') like 'A' or 'z'. The char constant 'A' is
+really just a synonym for the ordinary integer value 65 which is the ASCII value for
+
+4
+
+uppercase 'A'. There are special case char constants, such as '\t' for tab, for characters
+which are not convenient to type on a keyboard.
+
+'A'
+
+uppercase 'A' character
+
+'\n'
+
+newline character
+
+'\t'
+
+tab character
+
+'\0'
+
+the "null" character -- integer value 0 (different from the char digit '0')
+
+'\012' the character with value 12 in octal, which is decimal 10
+
+int Constants
+Numbers in the source code such as 234 default to type int. They may be followed by
+an 'L' (upper or lower case) to designate that the constant should be a long such as 42L.
+An integer constant can be written with a leading 0x to indicate that it is expressed in
+hexadecimal -- 0x10 is way of expressing the number 16. Similarly, a constant may be
+written in octal by preceding it with "0" -- 012 is a way of expressing the number 10.
+
+Type Combination and Promotion
+The integral types may be mixed together in arithmetic expressions since they are all
+basically just integers with variation in their width. For example, char and int can be
+combined in arithmetic expressions such as ('b' + 5). How does the compiler deal
+with the different widths present in such an expression? In such a case, the compiler
+"promotes" the smaller type (char) to be the same size as the larger type (int) before
+combining the values. Promotions are determined at compile time based purely on the
+types of the values in the expressions. Promotions do not lose information -- they always
+convert from a type to compatible, larger type to avoid losing information.
+
+Pitfall -- int Overflow
+I once had a piece of code which tried to compute the number of bytes in a buffer with
+the expression (k * 1024) where k was an int representing the number of kilobytes
+I wanted. Unfortunately this was on a machine where int happened to be 16 bits. Since
+k and 1024 were both int, there was no promotion. For values of k >= 32, the product
+was too big to fit in the 16 bit int resulting in an overflow. The compiler can do
+whatever it wants in overflow situations -- typically the high order bits just vanish. One
+way to fix the code was to rewrite it as (k * 1024L) -- the long constant forced the
+promotion of the int. This was not a fun bug to track down -- the expression sure looked
+reasonable in the source code. Only stepping past the key line in the debugger showed the
+overflow problem. "Professional Programmer's Language." This example also
+demonstrates the way that C only promotes based on the types in an expression. The
+compiler does not consider the values 32 or 1024 to realize that the operation will
+overflow (in general, the values don't exist until run time anyway). The compiler just
+looks at the compile time types, int and int in this case, and thinks everything is fine.
+
+Floating point Types
+
+float
+Single precision floating point number
+double Double precision floating point number
+long double Possibly even bigger floating point number (somewhat obscure)
+Constants in the source code such as 3.14 default to type double unless the are suffixed
+with an 'f' (float) or 'l' (long double). Single precision equates to about 6 digits of
+
+typical size: 32 bits
+typical size: 64 bits
+
+5
+
+precision and double is about 15 digits of precision. Most C programs use double for
+their computations. The main reason to use float is to save memory if many numbers
+need to be stored. The main thing to remember about floating point numbers is that they
+are inexact. For example, what is the value of the following double expression?
+
+(1.0/3.0 + 1.0/3.0 + 1.0/3.0)
+
+// is this equal to 1.0 exactly?
+
+The sum may or may not be 1.0 exactly, and it may vary from one type of machine to
+another. For this reason, you should never compare floating numbers to eachother for
+equality (==) -- use inequality (<) comparisons instead. Realize that a correct C program
+run on different computers may produce slightly different outputs in the rightmost digits
+of its floating point computations.
+
+Comments
+Comments in C are enclosed by  slash/star pairs: /* .. comments .. */ which
+may cross multiple lines. C++ introduced a form of comment started by two slashes and
+extending to the end of the line: // comment until the line end
+The // comment form is so handy that many C compilers now also support it, although it
+is not technically part of the C language.
+
+Along with well-chosen function names, comments are an important part of well written
+code. Comments should not just repeat what the code says. Comments should describe
+what the code accomplishes which is much more interesting than a translation of what
+each statement does. Comments should also narrate what is tricky or non-obvious about a
+section of code.
+
+Variables
+As in most languages, a variable declaration reserves and names an area in memory at run
+time to hold a value of particular type. Syntactically, C puts the type first followed by the
+name of the variable. The following declares an int variable named "num" and the 2nd
+line stores the value 42 into num.
+
+int num;
+num = 42;
+
+num
+
+42
+
+A variable corresponds to an area of memory which can store a value of the given type.
+Making a drawing is an excellent way to think about the variables in a program. Draw
+each variable as box with the current value inside the box. This may seem like a
+"beginner" technique, but when I'm buried in some horribly complex programming
+problem, I invariably resort to making a drawing to help think the problem through.
+
+Variables, such as num, do not have their memory cleared or set in any way when they
+are allocated at run time. Variables start with random values, and it is up to the program
+to set them to something sensible before depending on their values.
+
+Names in C are case sensitive so "x" and "X" refer to different variables. Names can
+contain digits and underscores (_), but may not begin with a digit. Multiple variables can
+be declared after the type by separating them with commas. C is a classical "compile
+time" language -- the names of the variables, their types, and their implementations are all
+flushed out by the compiler at compile time (as opposed to figuring such details out at run
+time like an interpreter).
+
+6
+
+float x, y, z, X;
+
+Assignment Operator =
+The assignment operator is the single equals sign (=).
+
+i = 6;
+i = i + 1;
+
+The assignment operator copies the value from its right hand side to the variable on its
+left hand side. The assignment also acts as an expression which returns the newly
+assigned value. Some programmers will use that feature to write things like the following.
+
+y = (x = 2 * x);
+
+// double x, and also put x's new value in y
+
+Truncation
+The opposite of promotion, truncation moves a value from a type to a smaller type. In
+that case, the compiler just drops the extra bits. It may or may not generate a compile
+time warning of the loss of information. Assigning from an integer to a smaller integer
+(e.g.. long to int, or int to char) drops the most significant bits. Assigning from a
+floating point type to an integer drops the fractional part of the number.
+
+char ch;
+int i;
+
+i = 321;
+ch = i;
+// ch is now 65
+
+// truncation of an int value to fit in a char
+
+The assignment will drop the upper bits of the int 321. The lower 8 bits of the number
+321 represents the number 65 (321 - 256). So the value of ch will be (char)65 which
+happens to be 'A'.
+
+The assignment of a floating point type to an integer type will drop the fractional part of
+the number. The following code will set i to the value 3. This happens when assigning a
+floating point number to an integer or passing a floating point number to a function which
+takes an integer.
+
+double pi;
+int i;
+
+pi = 3.14159;
+i = pi;
+// i is now 3
+
+// truncation of a double to fit in an int
+
+Pitfall -- int vs. float Arithmetic
+Here's an example of the sort of code where int vs. float arithmetic can cause
+problems. Suppose the following code is supposed to scale a homework score in the
+range 0..20 to be in the range 0..100.
+
+{
+
+int score;
+
+...// suppose score gets set in the range 0..20 somehow
+
+7
+
+score = (score / 20) * 100;
+
+// NO -- score/20 truncates to 0
+
+...
+
+Unfortunately, score will almost always be set to 0 for this code because the integer
+division in the expression (score/20) will be 0 for every value of score less than 20.
+The fix is to force the quotient to be computed as a floating point number...
+
+score = ((double)score / 20) * 100;
+
+// OK -- floating point division from cast
+
+score = (score / 20.0) * 100;
+
+// OK -- floating point division from 20.0
+
+score = (int)(score / 20.0) * 100;
+
+// NO -- the (int) truncates the floating
+// quotient back to 0
+
+No Boolean -- Use int
+C does not have a distinct boolean type-- int is used instead. The language treats integer
+0 as false and all non-zero values as true. So the statement...
+
+i = 0;
+while (i - 10) {
+
+...
+
+will execute until the variable i takes on the value 10 at which time the expression (i -
+10) will become false (i.e. 0). (we'll see the while() statement a bit later)
+
+Mathematical Operators
+C includes the usual binary and unary arithmetic operators. See the appendix for the table
+of precedence. Personally, I just use parenthesis liberally to avoid any bugs due to a
+misunderstanding of precedence. The operators are sensitive to the type of the operands.
+So division (/) with two integer arguments will do integer division. If either argument is
+a float, it does floating point division. So (6/4) evaluates to 1 while (6/4.0)
+evaluates to 1.5 -- the 6 is promoted to 6.0 before the division.
+
++ Addition
+
+- Subtraction
+
+/ Division
+
+* Multiplication
+
+% Remainder (mod)
+
+Unary Increment Operators: ++ --
+The unary ++ and -- operators increment or decrement the value in a variable. There are
+"pre" and "post" variants for both operators which do slightly different things (explained
+below)
+
+var++
+
+increment
+
+"post" variant
+
+++var
+
+increment
+
+"pre" variant
+
+var--
+
+decrement
+
+"post" variant
+
+--var
+
+decrement
+
+"pre" variant
+
+8
+
+int i = 42;
+i++;
+// i is now 43
+i--;
+// i is now 42
+
+// increment on i
+
+// decrement on i
+
+Pre and Post Variations
+The Pre/Post variation has to do with nesting a variable with the increment or decrement
+operator inside an expression -- should the entire expression represent the value of the
+variable before or after the change?  I never use the operators in this way (see below), but
+an example looks like...
+
+int i = 42;
+int j;
+
+j = (i++ + 10);
+// i is now 43
+// j is now 52 (NOT 53)
+
+j = (++i + 10)
+// i is now 44
+// j is now 54
+
+C Programming Cleverness and Ego Issues
+Relying on the difference between the pre and post variations of these operators is a
+classic area of C programmer ego showmanship. The syntax is a little tricky. It makes the
+code a little shorter. These qualities drive some C programmers to show off how clever
+they are. C invites this sort of thing since the language has many areas (this is just one
+example) where the programmer can get a complex effect using a code which is short and
+dense.
+
+If I want j to depend on i's value before the increment, I write...
+
+j = (i + 10);
+i++;
+
+Or if I want to j to use the value after the increment, I write...
+
+i++;
+j = (i + 10);
+
+Now then, isn't that nicer? (editorial) Build programs that do something cool rather than
+programs which flex the language's syntax. Syntax -- who cares?
+
+Relational Operators
+These operate on integer or floating point values and return a 0 or 1 boolean value.
+
+==
+
+Equal
+
+9
+
+!=
+
+>
+
+<
+
+>=
+
+<=
+
+Not Equal
+
+Greater Than
+
+Less Than
+
+Greater or Equal
+
+Less or Equal
+
+To see if x equals three, write something like:
+
+if (x == 3) ...
+
+Pitfall  =   ==
+
+An absolutely classic pitfall is to write assignment (=) when you mean comparison (==).
+This would not be such a problem, except the incorrect assignment version compiles fine
+because the compiler assumes you mean to use the value returned by the assignment. This
+is rarely what you want
+
+if (x = 3) ...
+
+This does not test if x is 3. This sets x to the value 3, and then returns the 3 to the if for
+testing. 3 is not 0, so it counts as "true" every time. This is probably the single most
+common error made by beginning C programmers. The problem is that the compiler is no
+help -- it thinks both forms are fine, so the only defense is extreme vigilance when
+coding. Or write "= „
+mistake is an absolute classic and it's a bear to debug. Watch Out! And need I say:
+"Professional Programmer's Language."
+
+ ==" in big letters on the back of your hand before coding. This
+
+Logical Operators
+The value 0 is false, anything else is true. The operators evaluate left to right and stop as
+soon as the truth or falsity of the expression can be deduced. (Such operators are called
+"short circuiting") In ANSI C, these are furthermore guaranteed to use 1 to represent true,
+and not just some random non-zero bit pattern. However, there are many C programs out
+there which use values other than 1 for true (non-zero pointers for example), so when
+programming, do not assume that a true boolean is necessarily 1 exactly.
+
+!
+
+&&
+
+||
+
+Boolean not (unary)
+
+Boolean and
+
+Boolean or
+
+Bitwise Operators
+C includes operators to manipulate memory at the bit level. This is useful for writing low-
+level hardware or operating system code where the ordinary abstractions of numbers,
+characters, pointers, etc... are insufficient -- an increasingly rare need. Bit manipulation
+code tends to be less "portable". Code is "portable" if with no programmer intervention it
+compiles and runs correctly on different types of computers. The bitwise operations are
+
+10
+
+typically used with unsigned types. In particular, the shift operations are guaranteed to
+shift 0 bits into the newly vacated positions when used on unsigned values.
+
+~
+
+&
+
+|
+
+^
+
+>>
+
+<<
+
+Bitwise Negation (unary) – flip 0 to 1 and 1 to 0 throughout
+
+Bitwise And
+
+Bitwise Or
+
+Bitwise Exclusive Or
+
+Right Shift by right hand side (RHS) (divide by power of 2)
+
+Left Shift by RHS (multiply by power of 2)
+
+Do not confuse the Bitwise operators with the logical operators. The bitwise connectives
+are one character wide (&, |) while the boolean connectives are two characters wide (&&,
+||). The bitwise operators have higher precedence than the boolean operators. The
+compiler will never help you out with a type error if you use & when you meant &&. As
+far as the type checker is concerned, they are identical-- they both take and produce
+integers since there is no distinct boolean type.
+
+Other Assignment Operators
+In addition to the plain = operator, C includes many shorthand operators which represents
+variations on the basic =. For example "+=" adds the right hand side to the left hand side.
+x = x + 10;  can be reduced to x += 10;. This is most useful if x is a long
+expression such as the following, and in some cases it may run a little faster.
+
+person->relatives.mom.numChildren += 2;
+
+// increase children by 2
+
+Here's the list of assignment shorthand operators...
+
++=, -= Increment or decrement by RHS
+
+*=, /= Multiply or divide by RHS
+
+%=
+
+>>=
+
+<<=
+
+Mod by RHS
+
+Bitwise right shift by RHS (divide by power of 2)
+
+Bitwise left shift RHS (multiply by power of 2)
+
+&=, |=, ^=
+
+Bitwise and, or, xor by RHS
+
+11
+
+Section 2
+Control Structures
+Curly Braces {}
+C uses curly braces ({}) to group multiple statements together. The statements execute in
+order. Some languages let you declare variables on any line (C++). Other languages insist
+that variables are declared only at the beginning of functions (Pascal). C takes the middle
+road -- variables may be declared within the body of a function, but they must follow a
+'{'. More modern languages like Java and C++ allow you to declare variables on any line,
+which is handy.
+
+If Statement
+Both an if and an if-else are available in C. The <expression> can be any valid
+expression. The parentheses around the expression are required, even if it is just a single
+variable.
+
+if (<expression>) <statement>
+
+// simple form with no {}'s or else clause
+
+if (<expression>) {
+
+// simple form with {}'s to group statements
+
+<statement>
+<statement>
+
+}
+
+if (<expression>) {
+
+// full then/else form
+
+<statement>
+
+}
+else {
+
+<statement>
+
+}
+
+Conditional Expression -or- The Ternary Operator
+The conditional expression can be used as a shorthand for some if-else statements. The
+general syntax of the conditional operator is:
+
+<expression1> ? <expression2> : <expression3>
+
+This is an expression, not a statement, so it represents a value. The operator works by
+evaluating expression1. If it is true (non-zero), it evaluates and returns expression2 .
+Otherwise, it evaluates and returns expression3.
+
+The classic example of the ternary operator is to return the smaller of two variables.
+Every once in a while, the following form is just what you needed. Instead of...
+
+if (x < y) {
+
+min = x;
+
+}
+else {
+
+min = y;
+
+}
+
+12
+
+You just say...
+
+min = (x < y) ? x : y;
+
+Switch Statement
+The switch statement is a sort of specialized form of if used to efficiently separate
+different blocks of code based on the value of an integer. The switch expression is
+evaluated, and then the flow of control jumps to the matching const-expression case. The
+case expressions are typically int or char constants. The switch statement is probably
+the single most syntactically awkward and error-prone features of the C language.
+
+switch (<expression>) {
+
+case <const-expression-1>:
+
+<statement>
+break;
+
+case <const-expression-2>:
+
+<statement>
+break;
+
+case <const-expression-3>:
+case <const-expression-4>:
+
+<statement>
+break;
+
+default:
+
+// optional
+
+<statement>
+
+}
+
+// here we combine case 3 and 4
+
+Each constant needs its own case keyword and a trailing colon (:). Once execution has
+jumped to a particular case, the program will keep running through all the cases from that
+point down -- this so called "fall through" operation is used in the above example so that
+expression-3 and expression-4 run the same statements. The explicit break statements
+are necessary to exit the switch. Omitting the break statements is a common error -- it
+compiles, but leads to inadvertent fall-through behavior.
+
+Why does the switch statement fall-through behavior work the way it does? The best
+explanation I can think of is that originally C was developed for an audience of assembly
+language programmers. The assembly language programmers were used to the idea of a
+jump table with fall-through behavior, so that's the way C does it (it's also relatively easy
+to implement it this way.) Unfortunately, the audience for C is now quite different, and
+the fall-through behavior is widely regarded as a terrible part of the language.
+
+While Loop
+The while loop evaluates the test expression before every loop, so it can execute zero
+times if the condition is initially false. It requires the parenthesis like the if.
+
+while (<expression>) {
+
+<statement>
+
+}
+
+13
+
+Do-While Loop
+Like a while, but with the test condition at the bottom of the loop. The loop body will
+always execute at least once. The do-while is an unpopular area of the language, most
+everyone tries to use the straight while if at all possible.
+
+do {
+
+<statement>
+
+} while (<expression>)
+
+For Loop
+The for loop in C is the most general looping construct.  The loop header contains three
+parts: an initialization, a continuation condition, and an action.
+
+for (<initialization>; <continuation>; <action>) {
+
+<statement>
+
+}
+
+The initialization is executed once before the body of the loop is entered. The loop
+continues to run as long as the continuation condition remains true (like a while). After
+every execution of the loop, the action is executed. The following example executes 10
+times by counting 0..9. Many loops look very much like the following...
+
+for (i = 0; i < 10; i++) {
+
+<statement>
+
+}
+
+C programs often have series of the form  0..(some_number-1). It's idiomatic in C for the
+above type loop to start at 0 and use < in the test so the series runs up to but not equal to
+the upper bound. In other languages you might start at 1 and use <= in the test.
+
+Each of the three parts of the for loop can be made up of multiple expressions separated
+by commas. Expressions separated by commas are executed in order, left to right, and
+represent the value of the last expression. (See the string-reverse example below for a
+demonstration of a complex for loop.)
+
+Break
+The break statement will move control outside a loop or switch statement. Stylistically
+speaking, break has the potential to be a bit vulgar. It's preferable to use a straight
+while with a single test at the top if possible. Sometimes you are forced to use a break
+because the test can occur only somewhere in the midst of the statements in the loop
+body. To keep the code readable, be sure to make the break obvious -- forgetting to
+account for the action of a break is a traditional source of bugs in loop behavior.
+
+while (<expression>) {
+
+<statement>
+<statement>
+
+if (<condition which can only be evaluated here>)
+
+break;
+
+<statement>
+<statement>
+
+}
+// control jumps down here on the break
+
+14
+
+The break does not work with if. It only works in loops and switches. Thinking that a
+break refers to an if when it really refers to the enclosing while has created some high
+quality bugs. When using a break, it's nice to write the enclosing loop to iterate in the
+most straightforward, obvious, normal way, and then use the break to explicitly catch
+the exceptional, weird cases.
+
+Continue
+The continue statement causes control to jump to the bottom of the loop, effectively
+skipping over any code below the continue. As with break, this has a reputation as
+being vulgar, so use it sparingly. You can almost always get the effect more clearly using
+an if inside your loop.
+
+while (<expression>) {
+
+...
+if (<condition>)
+continue;
+
+...
+...
+// control jumps here on the continue
+
+}
+
+15
+
+Section 3
+Complex Data Types
+C has the usual facilities for grouping things together to form composite types-- arrays
+and records (which are called "structures"). The following definition declares a type
+called "struct fraction" that has two integer sub fields named "numerator" and
+"denominator". If you forget the semicolon it tends to produce a syntax error in whatever
+thing follows the struct declaration.
+
+struct fraction {
+int numerator;
+int denominator;
+
+};
+
+// Don't forget the semicolon!
+
+This declaration introduces the type struct fraction (both words are required) as a
+new type. C uses the period (.) to access the fields in a record. You can copy two records
+of the same type using a single assignment statement, however == does not work on
+structs.
+
+struct fraction f1, f2;
+
+// declare two fractions
+
+f1.numerator = 22;
+f1.denominator = 7;
+
+f2 = f1;
+
+// this copies over the whole struct
+
+Arrays
+The simplest type of array in C is one which is declared and used in one place. There are
+more complex uses of arrays which I will address later along with pointers. The following
+declares an array called scores to hold 100 integers and sets the first and last elements.
+C arrays are always indexed from 0. So the first int in scores array is scores[0]
+and the last is scores[99].
+
+int scores[100];
+
+scores[0]  = 13;
+scores[99] = 42;
+
+// set first element
+// set last element
+
+16
+
+scores         
+
+The name of the array refers to the 
+whole array. (implementation) it 
+works by representing a pointer to the 
+start of the array. 
+
+13
+
+-5673
+
+22541
+
+Index
+
+0
+
+1
+
+2
+
+42
+
+99
+
+There is space for 
+each int element in 
+the scores array — 
+this element is 
+referred to as 
+scores[0].
+
+These elements 
+have random 
+values because the 
+code has not yet 
+initialized them to 
+anything.
+
+Someone else’s memory 
+off either end of  the 
+array — do not read or 
+write this memory.
+
+It's a very common error to try to refer to non-existent scores[100] element. C does
+not do any run time or compile time bounds checking in arrays. At run time the code will
+just access or mangle whatever memory it happens to hit and crash or misbehave in some
+unpredictable way thereafter. "Professional programmer's language." The convention of
+numbering things 0..(number of things - 1) pervades the language. To best
+integrate with C and other C programmers, you should use that sort of numbering in your
+own data structures as well.
+
+Multidimensional Arrays
+The following declares a two-dimensional 10 by 10 array of integers and sets the first and
+last elements to be 13.
+
+int board [10][10];
+
+board[0][0] = 13;
+board[9][9] = 13;
+
+The implementation of the array stores all the elements in a single contiguous block of
+memory. The other possible implementation would be a combination of several distinct
+one dimensional arrays -- that's not how C does it. In memory, the array is arranged with
+the elements of the rightmost index next to each other. In other words, board[1][8]
+comes right before board[1][9] in memory.
+
+(highly optional efficiency point) It's typically efficient to access memory which is near
+other recently accessed memory. This means that the most efficient way to read through a
+chunk of the array is to vary the rightmost index the most frequently since that will access
+elements that are near each other in memory.
+
+17
+
+Array of Structs
+The following declares an array named "numbers" which holds 1000 struct
+fraction's.
+
+struct fraction numbers[1000];
+
+numbers[0].numerator = 22;
+numbers[0].denominator = 7;
+
+/* set the 0th struct fraction */
+
+Here's a general trick for unraveling C variable declarations: look at the right hand side
+and imagine that it is an expression. The type of that expression is the left hand side. For
+the above declarations, an expression which looks like the right hand side
+(numbers[1000], or really anything of the form numbers[...]) will be the type
+on the left hand side (struct fraction).
+
+Pointers
+A pointer is a value which represents a reference to another value sometimes known as
+the pointer's "pointee". Hopefully you have learned about pointers somewhere else, since
+the preceding sentence is probably inadequate explanation. This discussion will
+concentrate on the syntax of pointers in C -- for a much more complete discussion of
+pointers and their use see http://cslibrary.stanford.edu/102/, Pointers and Memory.
+
+Syntax
+Syntactically C uses the asterisk or "star" (*) to indicate a pointer. C defines pointer types
+based on the type pointee. A char* is type of pointer which refers to a single char. a
+struct fraction* is type of pointer which refers to a struct fraction.
+
+int* intPtr;
+
+// declare an integer pointer variable intPtr
+
+char* charPtr; // declares a character pointer --
+
+// a very common type of pointer
+
+// Declare two struct fraction pointers
+// (when declaring multiple variables on one line, the *
+//  should go on the right with the variable)
+struct fraction *f1, *f2;
+
+The Floating "*"
+In the syntax, the star is allowed to be anywhere between the base type and the variable
+name. Programmer's have their own conventions-- I generally stick the * on the left with
+the type. So the above declaration of intPtr could be written equivalently...
+
+int  *intPtr;
+int * intPtr;
+int*  intPtr;
+
+// these are all the same
+
+Pointer Dereferencing
+We'll see shortly how a pointer is set to point to something -- for now just assume the
+pointer points to memory of the appropriate type. In an expression, the unary  * to the left
+of a pointer dereferences it to retrieve the value it points to. The following drawing shows
+the types involved with a single pointer pointing to a struct fraction.
+
+18
+
+struct fraction* f1;
+
+f1
+
+struct fraction*
+
+7
+
+22
+
+denominator
+
+numerator
+
+struct fraction
+(the whole 
+block of 
+memory)
+
+int
+(within 
+block of 
+memory)
+
+Expression
+f1
+*f1
+(*f1).numerator
+
+Type
+struct fraction*
+struct fraction
+int
+
+There's an alternate, more readable syntax available for dereferencing a pointer to a
+struct. A "->" at the right of the pointer can access any of the fields in the struct. So the
+reference to the numerator field could be written f1->numerator.
+
+Here are some more complex declarations...
+
+struct fraction** fp;
+
+// a pointer to a pointer to a struct fraction
+
+struct fraction fract_array[20]; 
+
+// an array of 20 struct fractions
+
+struct fraction* fract_ptr_array[20];
+
+// an array of 20 pointers to
+// struct fractions
+
+One nice thing about the C type syntax is that it avoids the circular definition problems
+which come up when a pointer structure needs to refer to itself. The following definition
+defines a node in a linked list. Note that no preparatory declaration of the node pointer
+type is necessary.
+
+struct node {
+
+int data;
+struct node* next;
+
+};
+
+The & Operator
+The & operator is one of the ways that pointers are set to point to things. The & operator
+computes a pointer to the argument to its right. The argument can be any variable which
+takes up space in the stack or heap (known as an "LValue" technically). So &i and
+&(f1->numerator) are ok, but &6 is not. Use & when you have some memory, and
+you want a pointer to that memory.
+
+19
+
+void foo() {
+
+int* p;  // p is a pointer to an integer
+int i;   // i is an integer
+
+p = &i;  // Set p to point to i
+*p = 13; // Change what p points to -- in this case i -- to 13
+
+// At this point i is 13. So is *p. In fact *p is i.
+
+}
+
+p
+
+i
+
+13
+
+When using a pointer to an object created with &, it is important to only use the pointer so
+long as the object exists. A local variable exists only as long as the function where it is
+declared is still executing (we'll see functions shortly). In the above example, i exists
+only as long as foo() is executing. Therefore any pointers which were initialized with
+&i are valid only as long as foo() is executing. This "lifetime" constraint of local
+memory is standard in many languages, and is something you need to take into account
+when using the & operator.
+
+NULL
+A pointer can be assigned the value 0 to explicitly represent that it does not currently
+have a pointee. Having a standard representation for "no current pointee" turns out to be
+very handy when using pointers. The constant NULL is defined to be 0 and is typically
+used when setting a pointer to NULL. Since it is just 0, a NULL pointer will behave like
+a boolean false when used in a boolean context. Dereferencing a NULL pointer is an error
+which, if you are lucky, the computer will detect at runtime -- whether the computer
+detects this depends on the operating system.
+
+Pitfall -- Uninitialized Pointers
+When using pointers, there are two entities to keep track of. The pointer and the memory
+it is pointing to, sometimes called the "pointee". There are three things which must be
+done for a pointer/pointee relationship to work...
+
+(1) The pointer must be declared and allocated
+
+(2) The pointee must be declared and allocated
+
+(3) The pointer (1) must be initialized so that it points to the pointee (2)
+
+The most common pointer related error of all time is the following: Declare and allocate
+the pointer (step 1). Forget step 2 and/or 3. Start using the pointer as if it has been setup
+to point to something. Code with this error frequently compiles fine, but the runtime
+results are disastrous. Unfortunately the pointer does not point anywhere good unless (2)
+and (3) are done, so the run time dereference operations on the pointer with * will misuse
+and trample memory leading to a random crash at some point.
+
+int* p;
+
+*p = 13;
+
+{
+
+}
+
+// NO NO NO p does not point to an int yet
+// this just overwrites a random area in memory
+
+20
+
+p
+
+i
+
+-14346
+
+Of course your code won't be so trivial, but the bug has the same basic form: declare a
+pointer, but forget to set it up to point to a particular pointee.
+
+Using Pointers
+Declaring a pointer allocates space for the pointer itself, but it does not allocate space
+for the pointee. The pointer must be set to point to something before you can dereference
+it.
+
+Here's some code which doesn't do anything useful, but which does demonstrate (1) (2)
+(3) for pointer use correctly...
+
+int* p;
+int i;
+struct fraction f1;
+
+// (1) allocate the pointer
+// (2) allocate pointee
+
+// (2) allocate pointee
+
+p = &i;
+*p = 42;
+
+// (3) setup p to point to i
+// ok to use p since it's setup
+
+p = &(f1.numerator);
+*p = 22;
+
+// (3) setup p to point to a different int
+
+p = &(f1.denominator);
+*p = 7;
+
+// (3)
+
+So far we have just used the & operator to create pointers to simple variables such as i.
+Later, we'll see other ways of getting pointers with arrays and other techniques.
+
+C Strings
+C has minimal support of character strings. For the most part, strings operate as ordinary
+arrays of characters. Their maintenance is up to the programmer using the standard
+facilities available for arrays and pointers. C does include a standard library of functions
+which perform common string operations, but the programmer is responsible for the
+managing the string memory and calling the right functions. Unfortunately computations
+involving strings are very common, so becoming a good C programmer often requires
+becoming adept at writing code which manages strings which means managing pointers
+and arrays.
+
+21
+
+A C string is just an array of char with the one additional convention that a "null"
+character ('\0') is stored after the last real character in the array to mark the end of the
+string. The compiler represents string constants in the source code such as "binky" as
+arrays which follow this convention. The string library functions (see the appendix for a
+partial list) operate on strings stored in this way. The most useful library function is
+strcpy(char dest[], const char source[]); which copies the bytes of
+one string over to another. The order of the arguments to strcpy() mimics the arguments
+in of '=' -- the right is assigned to the left. Another useful string function is
+strlen(const char string[]); which returns the number of characters in C
+string not counting the trailing '\0'.
+
+Note that the regular assignment operator (=) does not do string copying which is why
+strcpy() is necessary. See Section 6, Advanced Pointers and Arrays, for more detail on
+how arrays and pointers work.
+
+The following code allocates a 10 char array and uses strcpy() to copy the bytes of the
+string constant "binky" into that local array.
+
+{
+
+}
+
+char localString[10];
+
+strcpy(localString, "binky");
+
+localString
+
+b
+
+0
+
+i
+
+1
+
+n
+
+k
+
+y
+
+0
+
+x
+
+x
+
+x
+
+x
+
+2 ...
+
+The memory drawing shows the local variable localString with the string "binky"
+copied into it. The letters take up the first 5 characters and the '\0' char marks the end of
+the string after the 'y'. The x's represent characters which have not been set to any
+particular value.
+
+If the code instead tried to store the string "I enjoy languages which have good string
+support" into localString, the code would just crash at run time since the 10 character
+array can contain at most a 9 character string. The large string will be written passed the
+right hand side of localString, overwriting whatever was stored there.
+
+String Code Example
+Here's a moderately complex for loop which reverses a string stored in a local array. It
+demonstrates calling the standard library functions strcpy() and strlen() and demonstrates
+that a string really is just an array of characters with a '\0' to mark the effective end of the
+string. Test your C knowledge of arrays and for loops by making a drawing of the
+memory for this code and tracing through its execution to see how it works.
+
+22
+
+{
+
+char string[1000];
+int len;
+
+// string is a local 1000 char array
+
+strcpy(string, "binky");
+len = strlen(string);
+
+/*
+ Reverse the chars in the string:
+ i starts at the beginning and goes up
+ j starts at the end and goes down
+ i/j exchange their chars as they go until they meet
+*/
+int i, j;
+char temp;
+for (i = 0, j = len - 1; i < j; i++, j--) {
+
+temp = string[i];
+string[i] = string[j];
+string[j] = temp;
+
+}
+
+// at this point the local string should be "yknib"
+
+}
+
+"Large Enough" Strings
+The convention with C strings is that the owner of the string is responsible for allocating
+array space which is "large enough" to store whatever the string will need to store. Most
+routines do not check that size of the string memory they operate on, they just assume its
+big enough and blast away. Many, many programs contain declarations like the
+following...
+
+{
+
+}
+
+char localString[1000];
+...
+
+The program works fine so long as the strings stored are 999 characters or shorter.
+Someday when the program needs to store a string which is 1000 characters or longer,
+then it crashes. Such array-not-quite-big-enough problems are a common source of bugs,
+and are also the source of so called "buffer overflow" security problems. This scheme has
+the additional disadvantage that most of the time when the array is storing short strings,
+95% of the memory reserved is actually being wasted. A better solution allocates the
+string dynamically in the heap, so it has just the right size.
+
+To avoid buffer overflow attacks, production code should check the size of the data first,
+to make sure it fits in the destination string. See the strlcpy() function in Appendix A.
+
+char*
+Because of the way C handles the types of arrays, the type of the variable
+localString above is essentially char*. C programs very often manipulate strings
+using variables of type char* which point to arrays of characters. Manipulating the
+actual chars in a string requires code which manipulates the underlying array, or the use
+
+23
+
+of library functions such as strcpy() which manipulate the array for you. See Section 6 for
+more detail on pointers and arrays.
+
+TypeDef
+A typedef statement introduces a shorthand name for a type. The syntax is...
+
+typedef <type> <name>;
+
+The following defines Fraction type to be the type (struct fraction). C is case
+sensitive, so fraction is different from Fraction. It's convenient to use typedef to
+create types with upper case names and use the lower-case version of the same word as a
+variable.
+
+typedef struct fraction Fraction;
+
+Fraction fraction;
+
+// Declare the variable "fraction" of type "Fraction"
+//  which is really just a synonym for "struct fraction".
+
+The following typedef defines the name Tree as a standard pointer to a binary tree node
+where each node contains some data and "smaller" and "larger" subtree pointers.
+
+typedef struct treenode* Tree;
+struct treenode {
+
+int data;
+Tree smaller, larger;
+
+};
+
+// equivalently, this line could say
+// "struct treenode *smaller, *larger"
+
+24
+
+Section 4
+Functions
+All languages have a construct to separate and package blocks of code. C uses the
+"function" to package blocks of code. This article concentrates on the syntax and
+peculiarities of C functions. The motivation and design for dividing a computation into
+separate blocks is an entire discipline in its own.
+
+A function has a name, a list of arguments which it takes when called, and the block of
+code it executes when called. C functions are defined in a text file and the names of all
+the functions in a C program are lumped together in a single, flat namespace. The special
+function called "main" is where program execution begins. Some programmers like to
+begin their function names with Upper case, using lower case for variables and
+parameters, Here is a simple C function declaration. This declares a function named
+Twice which takes a single int argument named num. The body of the function
+computes the value which is twice the num argument and returns that value to the caller.
+
+/*
+ Computes double of a number.
+ Works by tripling the number, and then subtracting to get back to double.
+*/
+static int Twice(int num) {
+int result = num * 3;
+result = result - num;
+return(result);
+
+}
+
+Syntax
+The keyword "static" defines that the function will only be available to callers in the
+file where it is declared. If a function needs to be called from another file, the function
+cannot be static and will require a prototype -- see prototypes below. The static form
+is convenient for utility functions which will only be used in the file where they are
+declared. Next , the "int" in the function above is the type of its return value. Next
+comes name of the function and its list of parameters. When referring to a function by
+name in documentation or other prose, it's a convention to keep the parenthesis () suffix,
+so in this case I refer to the function as "Twice()". The parameters are listed with their
+types and names, just like variables.
+
+Inside the function, the parameter num and the local variable result are "local" to the
+function -- they get their own memory and exist only so long as the function is executing.
+This independence of "local" memory is a standard feature of most languages (See
+CSLibrary/102 for the detailed discussion of local memory).
+
+The "caller" code which calls Twice() looks like...
+
+int num = 13;
+int a = 1;
+int b = 2;
+a = Twice(a);
+b = Twice(b + num);
+// a == 2
+// b == 30
+// num == 13 (this num is totally independent of the "num" local to Twice()
+
+// call Twice() passing the value of a
+// call Twice() passing the value b+num
+
+25
+
+Things to notice...
+
+(vocabulary) The expression passed to a function by its caller is called the "actual
+
+parameter" -- such as "a" and "b + num" above. The parameter storage local to the
+function is called the "formal parameter" such as the "num" in "static int Twice(int
+num)".
+
+Parameters are passed "by value" that means there is a single copying assignment
+
+operation (=) from each actual parameter to set each formal parameter. The actual
+parameter is evaluated in the caller's context, and then the value is copied into the
+function's formal parameter just before the function begins executing. The alternative
+parameter mechanism is "by reference" which C does not implement directly, but
+which the programmer can implement manually when needed (see below). When a
+parameter is a struct, it is copied.
+
+The variables local to Twice(), num and result, only exist temporarily while
+Twice() is executing. This is the standard definition for "local" storage for
+functions.
+
+The return at the end of Twice() computes the return value and exits the function.
+Execution resumes with the caller. There can be multiple return statements within a
+function, but it's good style to at least have one at the end if a return value needs to be
+specified. Forgetting to account of a return somewhere in the middle of a function
+is a traditional source of bugs.
+
+C-ing and Nothingness -- void
+void is a type formalized in ANSI C which means "nothing". To indicate that a function
+does not return anything, use void as the return type. Also, by convention, a pointer
+which does not point to any particular type is declared as void*. Sometimes void* is
+used to force two bodies of code to not depend on each other where void* translates
+roughly to "this points to something, but I'm not telling you (the client) the type of the
+pointee exactly because you do not really need to know." If a function does not take any
+parameters, its parameter list is empty, or it can contain the keyword void but that style
+is now out of favor.
+
+void TakesAnIntAndReturnsNothing(int anInt);
+
+int TakesNothingAndReturnsAnInt();
+int TakesNothingAndReturnsAnInt(void); // equivalent syntax for above
+
+Call by Value vs. Call by Reference
+C passes parameters "by value" which means that the actual parameter values are copied
+into local storage. The caller and callee functions do not share any memory -- they each
+have their own copy. This scheme is fine for many purposes, but it has two
+disadvantages.
+
+1) Because the callee has its own copy, modifications to that memory are not
+
+communicated back to the caller. Therefore, value parameters do not allow the callee
+to communicate back to the caller. The function's return value can communicate some
+information back to the caller, but not all problems can be solved with the single
+return value.
+
+26
+
+2) Sometimes it is undesirable to copy the value from the caller to the callee because the
+value is large and so copying it is expensive, or because at a conceptual level copying
+the value is undesirable.
+
+The alternative is to pass the arguments "by reference". Instead of passing a copy of a
+value from the caller to the callee, pass a pointer to the value. In this way there is only
+one copy of the value at any time, and the caller and callee both access that one value
+through pointers.
+
+Some languages support reference parameters automatically. C does not do this -- the
+programmer must implement reference parameters manually using the existing pointer
+constructs in the language.
+
+Swap Example
+The classic example of wanting to modify the caller's memory is a swap() function
+which exchanges two values. Because C uses call by value, the following version of
+Swap will not work...
+
+void Swap(int x, int y) {
+
+// NO does not work
+
+int temp;
+
+temp = x;
+x = y;
+y = temp;
+
+}
+
+// these operations just change the local x,y,temp
+// -- nothing connects them back to the caller's a,b
+
+// Some caller code which calls Swap()...
+int a = 1;
+int b = 2;
+Swap(a, b);
+
+Swap() does not affect the arguments a and b in the caller. The function above only
+operates on the copies of a and b local to Swap() itself. This is a good example of how
+"local" memory such as ( x, y, temp) behaves -- it exists independent of everything else
+only while its owning function is running. When the owning function exits, its local
+memory disappears.
+
+Reference Parameter Technique
+To pass an object X as a reference parameter, the programmer must pass a pointer to X
+instead of X itself. The formal parameter will be a pointer to the value of interest. The
+caller will need to use & or other operators to compute the correct pointer actual
+parameter. The callee will need to dereference the pointer with * where appropriate to
+access the value of interest. Here is an example of a correct  Swap() function.
+
+static void Swap(int* x, int* y) {
+
+// params are int* instead of int
+
+int temp;
+
+temp = *x;
+*x = *y;
+*y = temp;
+
+}
+
+// use * to follow the pointer back to the caller's memory
+
+27
+
+// Some caller code which calls Swap()...
+int a = 1;
+int b = 2;
+
+Swap(&a, &b);
+
+Things to notice...
+
+• The formal parameters are int* instead of int.
+
+• The caller uses & to compute pointers to its local memory (a,b).
+
+• The callee uses * to dereference the formal parameter pointers back to get the caller's
+
+memory.
+
+Since the operator & produces the address of a variable --  &a is a pointer to a. In
+Swap() itself, the formal parameters are declared to be pointers, and the values of
+interest (a,b) are accessed through them. There is no special relationship between the
+names used for the actual and formal parameters. The function call matches up the actual
+and formal parameters by their order -- the first actual parameter is assigned to the first
+formal parameter, and so on. I deliberately used different names (a,b vs x,y) to emphasize
+that the names do not matter.
+
+const
+The qualifier const can be added to the left of a variable or parameter type to declare that
+the code using the variable will not change the variable. As a practical matter, use of
+const is very sporadic in the C programming community. It does have one very handy
+use, which is to clarify the role of a parameter in a function prototype...
+
+void foo(const struct fraction* fract);
+
+In the foo() prototype, the const declares that foo() does not intend to change the struct
+fraction pointee which is passed to it. Since the fraction is passed by pointer, we could
+not know otherwise if foo() intended to change our memory or not. Using the const,
+foo() makes its intentions clear. Declaring this extra bit of information helps to clarify the
+role of the function to its implementor and caller.
+
+28
+
+Bigger Pointer Example
+The following code is a large example of using reference parameters. There are several
+common features of C programs in this example...Reference parameters are used to allow
+the functions Swap() and IncrementAndSwap() to affect the memory of their callers.
+There's a tricky case inside of IncrementAndSwap() where it calls Swap() -- no additional
+use of & is necessary in this case since the parameters x, y inside InrementAndSwap() are
+already pointers to the values of interest. The names of the variables through the
+program(a, b, x, y, alice, bob) do not need to match up in any particular way for the
+parameters to work. The parameter mechanism only depends on the types of the
+parameters and their order in the parameter list -- not their names. Finally this is an
+example of what multiple functions look like in a file and how they are called from the
+main() function.
+
+static void Swap(int* a, int* b) {
+
+int temp;
+temp = *a;
+*a = *b;
+*b = temp;
+
+}
+
+static void IncrementAndSwap(int* x, int* y) {
+
+// don't need & here since a and b are already
+// int*'s.
+
+(*x)++;
+(*y)++;
+Swap(x, y);
+
+}
+
+int main()
+{
+
+int alice = 10;
+int bob = 20;
+
+Swap(&alice, &bob);
+// at this point alice==20 and bob==10
+
+IncrementAndSwap(&alice, &bob);
+// at this point alice==11 and bob==21
+
+return 0;
+
+}
+
+29
+
+Section 5
+Odds and Ends
+main()
+The execution of a C program begins with function named main(). All of the files and
+libraries for the C program are compiled together to build a single program file. That file
+must contain exactly one main() function which the operating system uses as the starting
+point for the program. Main() returns an int which, by  convention, is 0 if the program
+completed successfully and non-zero if the program exited due to some error condition.
+This is just a convention which makes sense in shell oriented environments such as Unix
+or DOS.
+
+Multiple Files
+For a program of any size, it's convenient to separate the functions into several separate
+files. To allow the functions in separate files to cooperate, and yet allow the compiler to
+work on the files independently, C programs typically depend on two features...
+
+Prototypes
+A "prototype" for a function gives its name and arguments but not its body. In order for a
+caller, in any file, to use a function, the caller must have seen the prototype for that
+function. For example, here's what the prototypes would look like for Twice() and
+Swap(). The function body is absent and there's a semicolon (;) to terminate the
+prototype...
+
+int Twice(int num);
+void Swap(int* a, int* b);
+
+In pre-ANSI C, the rules for prototypes where very sloppy -- callers were not required to
+see prototypes before calling functions, and as a result it was possible to get in situations
+where the compiler generated code which would crash horribly.
+
+In ANSI C, I'll oversimplify a little to say that...
+
+1) a function may be declared static in which case it can only be used in the same file
+where it is used below the point of its declaration. Static functions do not require a
+separate prototype so long as they are defined before or above where they are called
+which saves some work.
+
+2) A non-static function needs a prototype. When the compiler compiles a function
+
+definition, it must have previously seen a prototype so that it can verify that the two
+are in agreement ("prototype before definition" rule). The prototype must also be seen
+by any client code which wants to call the function ("clients must see prototypes"
+rule).(The require-prototypes behavior is actually somewhat of a compiler option, but
+it's smart to leave it on.)
+
+Preprocessor
+The preprocessing step happens to the C source before it is fed to the compiler. The two
+most common preprocessor directives are #define and #include...
+
+30
+
+#define
+The #define directive can be used to set up symbolic replacements in the source. As with
+all preprocessor operations, #define is extremely unintelligent -- it just does textual
+replacement without understanding. #define statements are used as a crude way of
+establishing symbolic constants.
+
+#define MAX 100
+#define SEVEN_WORDS that_symbol_expands_to_all_these_words
+
+Later code can use the symbols MAX or SEVEN_WORDS which will be replaced by the
+text to the right of each symbol in its #define.
+
+#include
+The "#include" directive brings in text from different files during compilation. #include is
+a very unintelligent and unstructured -- it just pastes in the text from the given file and
+continues compiling. The #include directive is used in the .h/.c file convention below
+which is used to satisfy the various constraints necessary to get prototypes correct.
+
+#include "foo.h"
+
+// refers to a "user" foo.h file --
+//
+
+in the originating directory for the compile
+
+#include <foo.h>
+
+// refers to a "system" foo.h file --
+//
+
+in the compiler's directory somewhere
+
+foo.h vs foo.c
+The universally followed convention for C is that for a file named "foo.c" containing a
+bunch of functions...
+
+• A separate file named foo.h will contain the prototypes for the functions in foo.c
+which clients may want to call. Functions in foo.c which are for "internal use
+only" and should never be called by clients should be declared static.
+
+• Near the top of foo.c will be the following line which ensures that the function
+definitions in foo.c see the prototypes in foo.h which ensures the "prototype
+before definition" rule above.
+#include "foo.h"
+
+// show the contents of "foo.h"
+// to the compiler at this point
+
+• Any xxx.c file which wishes to call a function defined in foo.c must include the
+following line to see the prototypes, ensuring the "clients must see prototypes" rule
+above.
+#include "foo.h"
+
+#if
+At compile time,  there is some space of names defined by the #defines. The #if test can
+be used at compile-time to look at those symbols and turn on and off which lines the
+compiler uses. The following example depends on the value of the FOO #define symbol.
+If it is true, then the "aaa" lines (whatever they are)  are compiled, and the "bbb" lines are
+ignored. If FOO were 0, then the reverse would be true.
+
+31
+
+#define FOO 1
+
+...
+
+#if FOO
+
+aaa
+aaa
+
+#else
+
+bbb
+bbb
+#endif
+
+You can use #if 0 ...#endif to effectively comment out areas of code you don't
+want to compile, but which you want to keeep in the source file.
+
+Multiple #includes -- #pragma once
+There's a problem sometimes where a .h file is #included into a file more than one time
+resulting in compile errors. This can be a serious problem. Because of this, you want to
+avoid #including .h files in other .h files if at all possible. On the other hand, #including
+.h files in .c files is fine. If you are lucky, your compiler will support the #pragma once
+feature which automatically prevents a single file from being #included more than once in
+any one file. This largely solves multiple #include problems.
+
+// foo.h
+// The following line prevents problems in files which #include "foo.h"
+#pragma once
+
+<rest of foo.h ...>
+
+Assert
+Array out of bounds references are an extremely common form of C run-time error. You
+can use the assert() function to sprinkle your code with your own bounds checks. A few
+seconds putting in assert statements can save you hours of debugging.
+
+Getting out all the bugs is the hardest and scariest part of writing a large piece of
+software. Assert statements are one of the easiest and most effective helpers for that
+difficult phase.
+
+#include <assert.h>
+#define MAX_INTS 100
+{
+
+int ints[MAX_INTS];
+i = foo(<something complicated>);
+
+// i should be in bounds,
+// but is it really?
+
+assert(i>=0);
+assert(i<MAX_INTS);
+
+ints[i] = 0;
+
+// safety assertions
+
+32
+
+Depending on the options specified at compile time, the assert() expressions will be left
+in the code for testing, or may be ignored. For that reason, it is important to only put
+expressions in assert() tests which do not need to be evaluated for the proper functioning
+of the program...
+
+int errCode = foo();
+assert(errCode == 0);
+
+// yes
+
+assert(foo() == 0);
+
+// NO, foo() will not be called if
+// the compiler removes the assert()
+
+33
+
+Section 6
+Advanced Arrays and Pointers
+Advanced C Arrays
+In C, an array is formed by laying out all the elements contiguously in memory. The
+square bracket syntax can be used to refer to the elements in the array. The array as a
+whole is referred to by the address of the first element which is also known as the "base
+address" of the whole array.
+
+{
+
+}
+
+int array[6];
+
+int sum = 0;
+sum += array[0] + array[1];
+
+// refer to elements using []
+
+array          
+
+The array name acts like a pointer to the 
+first element- in this case an (int*).
+
+array[0] array[1] array[2] ...
+
+Index
+
+0
+
+1
+
+2
+
+3
+
+4
+
+5
+
+The programmer can refer to elements in the array with the simple [ ] syntax such as
+array[1]. This scheme works by combining the base address of the whole array with
+the index to compute the base address of the desired element in the array. It just requires
+a little arithmetic. Each element takes up a fixed number of bytes which is known at
+compile-time. So the address of element n in the array using 0 based indexing will be at
+an offset of (n * element_size) bytes from the base address of the whole array.
+
+address of nth element = address_of_0th_element + (n * element_size_in_bytes)
+
+The square bracket syntax [ ] deals with this address arithmetic for you, but it's useful to
+know what it's doing. The [ ] takes the integer index, multiplies by the element size, adds
+the resulting offset to the array base address, and finally dereferences the resulting pointer
+to get to the desired element.
+
+{
+
+}
+
+int intArray[6];
+
+intArray[3] = 13;
+
+34
+
+intArray
+
+12 bytes of offset
+
+(intArray+3)
+
+1
+
+4
+
+2
+
+8
+
+13
+
+3
+
+12
+
+4
+
+16
+
+5
+
+20
+
+Index
+
+0
+
+0
+
+Offset
+in bytes =
+ n * elem_size
+
+Assume sizeof(int) = 4i.e. Each array 
+element takes up 4 bytes.
+
+'+' Syntax
+In a closely related piece of syntax, a + between a pointer and an integer does the same
+offset computation, but leaves the result as a pointer. The square bracket syntax gives the
+nth element while the + syntax gives a pointer to the nth element.
+
+So the expression (intArray + 3) is a pointer to the integer intArray[3].
+(intArray + 3) is of type (int*) while intArray[3] is of type int. The two
+expressions only differ by whether the pointer is dereferenced or not. So the expression
+(intArray + 3) is exactly equivalent to the expression (&(intArray[3])). In
+fact those two probably compile to exactly the same code. They both represent a pointer
+to the element at index 3.
+
+Any [] expression can be written with the + syntax instead. We just need to add in the
+pointer dereference. So intArray[3] is exactly equivalent to *(intArray + 3).
+For most purposes, it's easiest and most readable to use the [] syntax. Every once in a
+while the + is convenient if you needed a pointer to the element instead of the element
+itself.
+
+Pointer++ Style -- strcpy()
+If p is a pointer to an element in an array, then (p+1) points to the next element in the
+array. Code can exploit this using the construct p++ to step a pointer over the elements in
+an array. It doesn't help readability any, so I can't recommend the technique, but you may
+see it in code written by others.
+
+(This example was originally inspired by Mike Cleron) There's a library function called
+strcpy(char* destination, char* source) which copies the bytes of a C
+string from one place to another. Below are four different implementations of strcpy()
+written in order: from most verbose to most cryptic. In the first one, the normally
+straightforward while loop is actually sortof tricky to ensure that the terminating null
+character is copied over. The second removes that trickiness by moving assignment into
+the test. The last two are cute (and they demonstrate using ++ on pointers), but not really
+the sort of code you want to maintain. Among the four, I think strcpy2() is the best
+stylistically. With a smart compiler, all four will compile to basically the same code with
+the same efficiency.
+
+35
+
+// Unfortunately, a straight while or for loop won't work.
+// The best we can do is use a while (1) with the test
+// in the middle of the loop.
+void strcpy1(char dest[], const char source[]) {
+
+int i = 0;
+
+while (1) {
+
+dest[i] = source[i];
+if (dest[i] == '\0') break;
+i++;
+
+// we're done
+
+}
+
+}
+
+// Move the assignment into the test
+void strcpy2(char dest[], const char source[]) {
+
+int i = 0;
+
+while ((dest[i] = source[i]) != '\0') {
+
+i++;
+
+}
+
+}
+
+// Get rid of i and just move the pointers.
+// Relies on the precedence of * and ++.
+void strcpy3(char dest[], const char source[])
+{
+
+while ((*dest++ = *source++) != '\0') ;
+
+}
+
+// Rely on the fact that '\0' is equivalent to FALSE
+void strcpy4(char dest[], const char source[])
+{
+
+while (*dest++ = *source++) ;
+
+}
+
+Pointer Type Effects
+Both [ ] and + implicitly use the compile time type of the pointer to compute the
+element_size which affects the offset arithmetic. When looking at code, it's easy to
+assume that everything is in the units of bytes.
+
+int *p;
+
+p = p + 12;
+
+// at run-time, what does this add to p? 12?
+
+The above code does not add the number 12 to the address in p-- that would increment p
+by 12 bytes. The code above increments p by 12 ints. Each int probably takes 4 bytes, so
+at run time the code will effectively increment the address in p by 48. The compiler
+figures all this out based on the type of the pointer.
+
+Using casts, the following code really does just add 12 to the address in the pointer p. It
+works by telling the compiler that the pointer points to char instead of int. The size of
+char is defined to be exactly 1 byte (or whatever the smallest addressable unit is on the
+computer). In other words, sizeof(char) is always 1. We then cast the resulting
+
+36
+
+(char*) back to an (int*). The programmer is allowed to cast any pointer type to
+any other pointer type like this to change the code the compiler generates.
+
+p = (int*) ( ((char*)p) + 12);
+
+Arrays and Pointers
+One effect of the C array scheme is that the compiler does not distinguish meaningfully
+between arrays and pointers-- they both just look like pointers. In the following example,
+the value of intArray is a pointer to the first element in the array so it's an (int*).
+The value of the variable intPtr is also (int*) and it is set to point to a single integer
+i. So what's the difference between intArray and intPtr? Not much as far as the
+compiler is concerned. They are both just (int*) pointers, and the compiler is perfectly
+happy to apply the [] or + syntax to either. It's the programmer's responsibility to ensure
+that the elements referred to by a [] or + operation really are there. Really its' just the
+same old rule that C doesn't do any bounds checking. C thinks of the single integer i as
+just a sort of degenerate array of size 1.
+
+{
+
+}
+
+int intArray[6];
+int *intPtr;
+int i;
+
+intPtr = &i;
+
+intArray[3] = 13;
+intPtr[0] = 12;
+intPtr[3] = 13;
+
+// ok
+// odd, but ok. Changes i.
+// BAD! There is no integer reserved here!
+
+intArray
+
+(intArray+3)
+
+37
+
+Index
+
+0
+
+1
+
+2
+
+intPtr
+
+12
+
+i
+
+4
+
+5
+
+(intPtr+3)
+
+13
+
+3
+
+13
+
+These bytes exist, but they have not been explicitly reserved. 
+They are the bytes which happen to be adjacent to the 
+memory for i. They are probably being used to store 
+something already, such as a smashed looking smiley face. 
+The 13 just gets blindly written over the smiley face. This 
+error will only be apparent later when the program tries to 
+read the smiley face data.
+
+Array Names Are Const
+One subtle distinction between an array and a pointer, is that the pointer which represents
+the base address of an array cannot be changed in the code. The array base address
+behaves like a const pointer. The constraint applies to the name of the array where it is
+declared in the code-- the variable ints in the example below.
+
+{
+
+}
+
+int ints[100]
+int *p;
+int i;
+
+ints = NULL;
+ints = &i;
+ints = ints + 1;
+ints++;
+
+p = ints;
+
+p++;
+p = NULL;
+p = &i;
+
+// NO, cannot change the base addr ptr
+// NO
+// NO
+// NO
+
+// OK, p is a regular pointer which can be changed
+// here it is getting a copy of the ints pointer
+
+// OK, p can still be changed (and ints cannot)
+// OK
+// OK
+
+foo(ints);
+
+// OK (possible foo definitions are below)
+
+38
+
+Array parameters are passed as pointers. The following two definitions of foo look
+different, but to the compiler they mean exactly the same thing. It's preferable to use
+whichever syntax is more accurate for readability. If the pointer coming in really is the
+base address of a whole array, then use [ ].
+
+void foo(int arrayParam[]) {
+
+arrayParam = NULL;
+
+// Silly but valid. Just changes the local pointer
+
+}
+
+void foo(int *arrayParam) {
+
+arrayParam = NULL;
+
+// ditto
+
+}
+
+Heap Memory
+C gives programmers the standard sort of facilities to allocate and deallocate dynamic
+heap memory. A word of warning: writing programs which manage their heap memory is
+notoriously difficult. This partly explains the great popularity of languages such as Java
+and Perl which handle heap management automatically. These languages take over a task
+which has proven to be extremely difficult for the programmer. As a result Perl and Java
+programs run a little more slowly, but they contain far fewer bugs. (For a detailed
+discussion of heap memory see http://cslibrary.stanford.edu/102/, Pointers and Memory.)
+
+C provides access to the heap features through library functions which any C code can
+call. The prototypes for these functions are in the file <stdlib.h>, so any code which
+wants to call these must #include that header file. The three functions of interest are...
+
+void* malloc(size_t size)
+
+Request a contiguous block of memory
+of the given size in the heap. malloc() returns a pointer to the heap block or NULL if
+the request could not be satisfied. The type size_t is essentially an unsigned
+long which indicates how large a block the caller would like measured in bytes.
+Because the block pointer returned by malloc() is a void* (i.e. it makes no claim
+about the type of its pointee), a cast will probably be required when storing the void*
+pointer into a regular typed pointer.
+
+void free(void* block)
+
+The mirror image of malloc() -- free takes a
+
+pointer to a heap block earlier allocated by malloc() and returns that block to the heap
+for re-use. After the free(), the client should not access any part of the block or
+assume that the block is valid memory. The block should not be freed a second time.
+
+void* realloc(void* block, size_t size);
+
+Take an existing heap
+block and try to relocate it to a heap block of the given size which may be larger or
+smaller than the original size of the block. Returns a pointer to the new block, or
+NULL if the relocation was unsuccessful. Remember to catch and examine the return
+value of realloc() -- it is a common error to continue to use the old block pointer.
+Realloc() takes care of moving the bytes from the old block to the new block.
+Realloc() exists because it can be implemented using low-level features which make
+it more efficient than C code the client could write.
+
+Memory Management
+All of a program's memory is deallocated automatically when the it exits, so a program
+only needs to use free() during execution if it is important for the program to recycle its
+memory while it runs -- typically because it uses a lot of memory or because it runs for a
+
+39
+
+long time. The pointer passed to free() must be exactly the pointer which was originally
+returned by malloc() or realloc(), not just a pointer into somewhere within the heap block.
+
+Dynamic Arrays
+Since arrays are just contiguous areas of bytes, you can allocate your own arrays in the
+heap using malloc(). The following code allocates two arrays of 1000 ints-- one in the
+stack the usual "local" way, and one in the heap using malloc(). Other than the different
+allocations, the two are syntactically similar in use.
+
+{
+
+}
+
+int a[1000];
+
+int *b;
+b = (int*) malloc( sizeof(int) * 1000);
+assert(b != NULL);
+
+// check that the allocation succeeded
+
+a[123] = 13;
+b[123] = 13;
+
+// Just use good ol' [] to access elements
+// in both arrays.
+
+free(b);
+
+Although both arrays can be accessed with [ ], the rules for their maintenance are very
+different....
+
+Advantages of being in the heap
+
+• Size (in this case 1000) can be defined at run time. Not so for an array like "a".
+
+• The array will exist until it is explicitly deallocated with a call to free().
+
+• You can change the size of the array at will at run time using realloc(). The following
+changes the size of the array to 2000. Realloc() takes care of copying over the old
+elements.
+
+...
+b = realloc(b, sizeof(int) * 2000);
+assert(b != NULL);
+
+Disadvantages of being in the heap
+
+• You have to remember to allocate the array, and you have to get it right.
+
+• You have to remember to deallocate it exactly once when you are done with it, and you
+
+have to get that right.
+
+• The above two disadvantages have the same basic profile: if you get them wrong, your
+code still looks right. It compiles fine. It even runs for small cases, but for some input
+cases it just crashes unexpectedly because random memory is getting overwritten
+somewhere like the smiley face. This sort of "random memory smasher" bug can be a
+real ordeal to track down.
+
+40
+
+Dynamic Strings
+The dynamic allocation of arrays works very well for allocating strings in the heap. The
+advantage of heap allocating a string is that the heap block can be just big enough to store
+the actual number of characters in the string. The common local variable technique such
+as  char string[1000]; allocates way too much space most of the time, wasting
+the unused bytes, and yet fails if the string ever gets bigger than the variable's fixed size.
+
+#include <string.h>
+
+/*
+ Takes a c string as input, and makes a copy of that string
+ in the heap. The caller takes over ownership of the new string
+ and is responsible for freeing it.
+*/
+char* MakeStringInHeap(const char* source) {
+
+char* newString;
+
+newString = (char*) malloc(strlen(source) + 1); // +1 for the '\0'
+assert(newString != NULL);
+strcpy(newString, source);
+return(newString);
+
+}
+
+41
+
+Section 7
+Details and Library Functions
+Precedence and Associativity
+function-call() [] -> .
+
+L to R
+
+! ~ ++ -- + - *(ptr deref) sizeof &(addr of)
+(all unary ops are the same)
+
+* / %
+(the top tier arithmetic binary ops)
+
++ -
+(second tier arithmetic binary ops)
+
+< <= > >=
+
+== !=
+
+in order: & ^ | && ||
+(note that bitwise comes before boolean)
+
+= and all its variants
+
+, (comma)  . 
+
+R to L
+
+L to R
+
+L to R
+
+L to R
+
+L to R
+
+L to R
+
+R to L
+
+L to R
+
+A combinations which never works right without parens: *structptr.field
+You have to write it as (*structptr).field or structptr->field
+
+Standard Library Functions
+Many basic housekeeping funcions are available to a C program in form of standard
+library functions. To call these, a program must #include the appropriate .h file. Most
+compilers link in the standard library code by default. The functions listed in the next
+section are the most commonly used ones, but there are many more which are not listed
+here.
+
+stdio.h
+
+file input and output
+
+ctype.h
+
+character tests
+
+string.h
+
+string operations
+
+math.h
+
+mathematical functions such as sin() and cos()
+
+stdlib.h
+
+utility functions such as malloc() and rand()
+
+assert.h
+
+the assert() debugging macro
+
+stdarg.h
+
+support for functions with variable numbers of arguments
+
+setjmp.h
+
+support for non-local flow control jumps
+
+signal.h
+
+support for exceptional condition signals
+
+time.h
+
+date and time
+
+42
+
+limits.h, float.h
+
+constants which define type range values such as INT_MAX
+
+stdio.h
+Stdio.h is a very common file to #include -- it includes functions to print and read strings
+from files and to open and close files in the file system.
+
+FILE* fopen(const char* fname, const char* mode);
+
+Open a file named in the filesystem and return a FILE* for it. Mode = "r" read,"w"
+write,"a"append, returns NULL on error. The standard files stdout, stdin,
+stderr are automatically opened and closed for you by the system.
+
+int fclose(FILE* file);
+
+Close a previously opened file. Returns EOF on error. The operating system closes all
+of a program's files when it exits, but it's tidy to do it beforehand. Also, there is
+typically a limit to the number of files which a program may have open
+simultaneously.
+
+int fgetc(FILE* in);
+
+Read and return the next unsigned char out of a file, or EOF if the file has been
+exhausted. (detail) This and other file functions return ints instead of a chars because
+the EOF constant they potentially is not a char, but is an int. getc() is an alternate,
+faster version implemented as a macro which may evaluate the FILE* expression
+more than once.
+
+char* fgets(char* dest, int n, FILE* in)
+
+Reads the next line of text into a string supplied by the caller. Reads at most n-1
+characters from the file, stopping at the first '\n' character. In any case, the string is '\0'
+terminated. The '\n' is included in the string. Returns NULL on EOF or error.
+
+int fputc(int ch, FILE* out);
+
+Write the char to the file as an unsigned char. Returns ch, or EOF on err. putc() is an
+alternate, faster version implemented as a macro which may evaluate the FILE*
+expression more than once.
+
+int ungetc(int ch, FILE* in);
+
+Push the most recent fgetc() char back onto the file. EOF may not be pushed back.
+Returns ch or EOF on error.
+
+int printf(const char* format_string, ...);
+
+Prints a string with values possibly inserted into it to standard output. Takes a variable
+number of arguments -- first a format string followed by a number of matching
+arguments. The format string contains text mixed with % directives which mark
+things to be inserted in the output. %d = int, %Ld=long int, %s=string, %f=double,
+%c=char. Every % directive must have a matching argument of the correct type after
+the format string. Returns the number of characters written, or negative on error. If
+the percent directives do not match the number and type of arguments, printf() tends
+to crash or otherwise do the wrong thing at run time. fprintf() is a variant which takes
+an additional FILE* argument which specifies the file to print to. Examples...
+printf("hello\n");
+printf("hello %d there %d\n", 13, 1+1);
+printf("hello %c there %d %s\n", 'A', 42, "ok");
+
+prints: hello
+prints: hello 13 there 2
+prints: hello A there 42 ok
+
+43
+
+int scanf(const char* format, ...)
+
+Opposite of printf() -- reads characters from standard input trying to match elements
+in the format string. Each percent directive in the format string must have a matching
+pointer in the argument list which scanf() uses to store the values it finds. scanf()
+skips whitespace as it tries to read in each percent directive. Returns the number of
+percent directives processed successfully, or EOF on error. scanf() is famously
+sensitive to programmer errors. If scanf() is called with anything but the correct
+pointers after the format string, it tends to crash or otherwise do the wrong thing at
+run time. sscanf() is a variant which takes an additional initial string from which it
+does its reading. fscanf() is a variant which takes an additional initial FILE* from
+which it does its reading. Example...
+{
+
+int num;
+char s1[1000];
+char s2[1000];
+
+scanf("hello %d %s %s", &num, s1, s2);
+
+}
+Looks for the word "hello" followed by a number and two words (all separated by
+whitespace). scanf() uses the pointers &num, s1, and s2 to store what it finds into the
+local variables.
+
+ctype.h
+ctype.h includes macros for doing simple tests and operations on characters
+
+isalpha(ch)
+
+// ch is an upper or lower case letter
+
+islower(ch), isupper(ch)
+
+// same as above, but upper/lower specific
+
+isspace(ch)
+
+// ch is a whitepace character such as tab, space, newline, etc.
+
+isdigit(ch)
+
+// digit such as '0'..'9'
+
+toupper(ch), tolower(ch)
+
+// Return the lower or upper case version of a
+
+alphabetic character, otherwise pass it through unchanged.
+
+44
+
+string.h
+None of these string routines allocate memory or check that the passed in memory is the
+right size. The caller is responsible for making sure there is "enough" memory for the
+operation. The type size_t is an unsigned integer wide enough for the computer's
+address space -- most likely an unsigned long.
+
+size_t strlen(const char* string);
+
+Return the number of chars in a C string. EG strlen("abc")==3
+
+char* strcpy(char* dest, const char* source);
+
+Copy the characters from the source string to the destination string.
+
+size_t strlcpy(char* dest, const char* source,
+
+size_t dest_size);
+
+Like strcpy(), but knows the size of the dest. Truncates if necessary. Use this to avoid
+memory errors and buffer-overflow security problems. This function is not as
+standard as strcpy(), but most sytems have it. Do not use the old strncpy() function --
+it is difficult to use correctly.
+
+char *strcat(char* dest, const char* source);
+
+Append the characters from the source string to the end of destination string. (There is
+a non-standard strlcat() variant that takes the size of the dest as third argument.)
+
+int strcmp(const char* a, const char* b);
+
+Compare two strings and return an int which encodes their ordering. zero:a==b,
+negative:a<b,  positive:a>b. It is a common error to think of the result of strcmp() as
+being boolean true if the strings are equal which is, unfortunately, exactly backwards.
+
+char* strchr(const char* searchIn, char ch);
+
+Search the given string for the first occurence of the given character. Returns a
+pointer to the character, or NULL if none is found.
+
+char* strstr(const char* searchIn, const char* searchFor);
+Similar to strchr(), but searches for an entire string instead of a single character. The
+search is case sensitive.
+
+void* memcpy(void* dest, const void* source, size_t n);
+
+Copy the given number of bytes from the source to the destination. The source and
+destination must not overlap. This may be implemented in a specialized but highly
+optimized way for a particular computer.
+
+void* memmove(void* dest, const void* source, size_t n);
+Similar to memcpy() but allows the areas to overlap. This probably runs slightly
+slower than memcpy().
+
+45
+
+stdlib.h
+
+int rand();
+
+Returns a pseudo random integer in the range 0..RAND_MAX (limits.h) which is at
+least 32767.
+
+void srand(unsigned int seed);
+
+The sequence of random numbers returned by rand() is initially controlled by a global
+"seed" variable. srand() sets this seed which, by default, starts with the value 1. Pass
+the expression time(NULL) (time.h) to set the seed to a value based on the current
+time to ensure that the random sequence is different from one run to the next.
+
+void* malloc(size_t size);
+
+Allocate a heap block of the given size in bytes. Returns a pointer to the block or
+NULL on failure. A cast may be required to store the void* pointer into a regular
+typed pointer. [ed: see the Heap Allocation section above for the longer discussion of
+malloc(), free(), and realloc()]
+void free(void* block);
+
+Opposite of malloc(). Returns a previous malloc block to the system for reuse
+
+void* realloc(void* block, size_t size);
+
+Resize an existing heap block to the new size. Takes care of copying bytes from the
+old block to the new. Returns the new base address of the heap block. It is a common
+error to forget to catch the return value from realloc(). Returns NULL if the resize
+operation was not possible.
+
+void exit(int status);
+
+Halt and exit the program and pass a condition int back to the operating sytem. Pass 0
+to signal normal program termination, non-zero otherwise.
+
+void* bsearch(const void* key, const void* base, size_t len,
+
+size_t elem_size, <compare_function>);
+Do a binary search in an array of elements. The last argument is a function which
+takes pointers to the two elements to compare. Its prototype should be:
+int compare(const void* a, const void* b);, and it should return 0, -1, or 1 as strcmp()
+does. Returns a pointer to a found element, or NULL otherwise. Note that strcmp()
+itself cannot be used directly as a compare function for bsearch() on an array of char*
+strings because strcmp() takes char* arguments and bsearch() will need a comparator
+that takes pointers to the array elements -- char**.
+
+void qsort(void* base, size_t len, size_t elem_size,
+
+<compare_function>);
+Sort an array of elements. Takes a function pointer just like besearch().
+
+Revision History
+11/1998 -- original major version. Based on my old C handout for CS107. Thanks to Jon
+Becker for proofreading and Mike Cleron for the original inspiration.
+
+Revised 4/2003 with many helpful typo and other suggestions from Negar Shamma and
+A. P. Garcia
+
+

C/pointers.pdf.txt

@@ -0,0 +1,2742 @@
+A TUTORIAL ON POINTERS AND ARRAYS IN C  
+
+by Ted Jensen  
+Version 1.2 (PDF Version) 
+Sept. 2003 
+This material is hereby placed in the public domain  
+Available in various formats via  
+http://pweb.netcom.com/~tjensen/ptr/cpoint.htm 
+
+TABLE OF CONTENTS 
+
+PREFACE 
+
+INTRODUCTION 
+
+CHAPTER 1: What is a pointer? 
+
+CHAPTER 2: Pointer types and Arrays 
+
+CHAPTER 3: Pointers and Strings 
+
+CHAPTER 4: More on Strings 
+
+CHAPTER 5: Pointers and Structures 
+
+CHAPTER 6: Some more on Strings, and Arrays of Strings 
+
+CHAPTER 7: More on Multi-Dimensional Arrays 
+
+CHAPTER 8: Pointers to Arrays 
+
+CHAPTER 9: Pointers and Dynamic Allocation of Memory 
+
+CHAPTER 10: Pointers to Functions 
+
+EPILOG 
+
+2 
+
+4 
+
+5 
+
+9 
+
+14 
+
+19 
+
+22 
+
+26 
+
+30 
+
+32 
+
+34 
+
+42 
+
+53 
+
+1 
+
+ 
+ 
+ 
+PREFACE  
+
+This document is intended to introduce pointers to beginning programmers in the C 
+programming language. Over several years of reading and contributing to various 
+conferences on C including those on the FidoNet and UseNet, I have noted a large 
+number of newcomers to C appear to have a difficult time in grasping the fundamentals 
+of pointers. I therefore undertook the task of trying to explain them in plain language with 
+lots of examples. 
+
+The first version of this document was placed in the public domain, as is this one. It was 
+picked up by Bob Stout who included it as a file called PTR-HELP.TXT in his widely 
+distributed collection of SNIPPETS. Since that original 1995 release, I have added a 
+significant amount of material and made some minor corrections in the original work. 
+
+I subsequently posted an HTML version around 1998 on my website at: 
+
+ http://pweb.netcom.com/~tjensen/ptr/cpoint.htm  
+
+After numerous requests, I’ve finally come out with this PDF version which is identical 
+to that HTML version cited above, and which can be obtained from that same web site.  
+
+Acknowledgements:  
+
+There are so many people who have unknowingly contributed to this work because of the 
+questions they have posed in the FidoNet C Echo, or the UseNet Newsgroup 
+comp.lang.c, or several other conferences in other networks, that it would be impossible 
+to list them all. Special thanks go to Bob Stout who was kind enough to include the first 
+version of this material in his SNIPPETS file.  
+
+About the Author:  
+
+Ted Jensen is a retired Electronics Engineer who worked as a hardware designer or 
+manager of hardware designers in the field of magnetic recording. Programming has been 
+a hobby of his off and on since 1968 when he learned how to keypunch cards for 
+submission to be run on a mainframe. (The mainframe had 64K of magnetic core 
+memory!).  
+
+Use of this Material: 
+
+Everything contained herein is hereby released to the Public Domain. Any person may 
+copy or distribute this material in any manner they wish. The only thing I ask is that if 
+this material is used as a teaching aid in a class, I would appreciate it if it were distributed 
+in its entirety, i.e. including all chapters, the preface and the introduction. I would also 
+appreciate it if, under such circumstances, the instructor of such a class would drop me a 
+
+2 
+
+ 
+note at one of the addresses below informing me of this. I have written this with the hope 
+that it will be useful to others and since I'm not asking any financial remuneration, the 
+only way I know that I have at least partially reached that goal is via feedback from those 
+who find this material useful. 
+
+By the way, you needn't be an instructor or teacher to contact me. I would appreciate a 
+note from anyone who finds the material useful, or who has constructive criticism to 
+offer. I'm also willing to answer questions submitted by email at the addresses shown 
+below. 
+
+Ted Jensen  
+Redwood City, California 
+tjensen@ix.netcom.com  
+July 1998 
+
+3 
+
+ 
+INTRODUCTION 
+
+If you want to be proficient in the writing of code in the C programming language, you 
+must have a thorough working knowledge of how to use pointers. Unfortunately, C 
+pointers appear to represent a stumbling block to newcomers, particularly those coming 
+from other computer languages such as Fortran, Pascal or Basic.  
+
+To aid those newcomers in the understanding of pointers I have written the following 
+material. To get the maximum benefit from this material, I feel it is important that the 
+user be able to run the code in the various listings contained in the article. I have 
+attempted, therefore, to keep all code ANSI compliant so that it will work with any ANSI 
+compliant compiler. I have also tried to carefully block the code within the text. That 
+way, with the help of an ASCII text editor, you can copy a given block of code to a new 
+file and compile it on your system. I recommend that readers do this as it will help in 
+understanding the material.  
+
+4 
+
+ 
+CHAPTER 1: What is a pointer?  
+
+One of those things beginners in C find difficult is the concept of pointers. The purpose 
+of this tutorial is to provide an introduction to pointers and their use to these beginners.  
+
+I have found that often the main reason beginners have a problem with pointers is that 
+they have a weak or minimal feeling for variables, (as they are used in C). Thus we start 
+with a discussion of C variables in general.  
+
+A variable in a program is something with a name, the value of which can vary. The way 
+the compiler and linker handles this is that it assigns a specific block of memory within 
+the computer to hold the value of that variable. The size of that block depends on the 
+range over which the variable is allowed to vary. For example, on PC's the size of an 
+integer variable is 2 bytes, and that of a long integer is 4 bytes. In C the size of a variable 
+type such as an integer need not be the same on all types of machines.  
+
+When we declare a variable we inform the compiler of two things, the name of the 
+variable and the type of the variable. For example, we declare a variable of type integer 
+with the name k by writing:  
+
+    int k;  
+
+On seeing the "int" part of this statement the compiler sets aside 2 bytes of memory (on a 
+PC) to hold the value of the integer. It also sets up a symbol table. In that table it adds the 
+symbol k and the relative address in memory where those 2 bytes were set aside.  
+
+Thus, later if we write:  
+
+    k = 2;  
+
+we expect that, at run time when this statement is executed, the value 2 will be placed in 
+that memory location reserved for the storage of the value of k. In C we refer to a 
+variable such as the integer k as an "object".  
+
+In a sense there are two "values" associated with the object k. One is the value of the 
+integer stored there (2 in the above example) and the other the "value" of the memory 
+location, i.e., the address of k. Some texts refer to these two values with the nomenclature 
+rvalue (right value, pronounced "are value") and lvalue (left value, pronounced "el 
+value") respectively.  
+
+In some languages, the lvalue is the value permitted on the left side of the assignment 
+operator '=' (i.e. the address where the result of evaluation of the right side ends up). The 
+rvalue is that which is on the right side of the assignment statement, the 2 above. Rvalues 
+cannot be used on the left side of the assignment statement. Thus: 2 = k; is illegal.  
+
+5 
+
+ 
+Actually, the above definition of "lvalue" is somewhat modified for C. According to 
+K&R II (page 197): [1]  
+
+"An object is a named region of storage; an lvalue is an expression 
+referring to an object."  
+
+However, at this point, the definition originally cited above is sufficient. As we become 
+more familiar with pointers we will go into more detail on this.  
+
+Okay, now consider:  
+
+   int j, k;  
+
+    k = 2;  
+    j = 7;    <-- line 1  
+    k = j;    <-- line 2  
+
+In the above, the compiler interprets the j in line 1 as the address of the variable j (its 
+lvalue) and creates code to copy the value 7 to that address. In line 2, however, the j is 
+interpreted as its rvalue (since it is on the right hand side of the assignment operator '='). 
+That is, here the j refers to the value stored at the memory location set aside for j, in this 
+case 7. So, the 7 is copied to the address designated by the lvalue of k.  
+
+In all of these examples, we are using 2 byte integers so all copying of rvalues from one 
+storage location to the other is done by copying 2 bytes. Had we been using long integers, 
+we would be copying 4 bytes.  
+
+Now, let's say that we have a reason for wanting a variable designed to hold an lvalue (an 
+address). The size required to hold such a value depends on the system. On older desk top 
+computers with 64K of memory total, the address of any point in memory can be 
+contained in 2 bytes. Computers with more memory would require more bytes to hold an 
+address. Some computers, such as the IBM PC might require special handling to hold a 
+segment and offset under certain circumstances. The actual size required is not too 
+important so long as we have a way of informing the compiler that what we want to store 
+is an address.  
+
+Such a variable is called a pointer variable (for reasons which hopefully will become 
+clearer a little later). In C when we define a pointer variable we do so by preceding its 
+name with an asterisk. In C we also give our pointer a type which, in this case, refers to 
+the type of data stored at the address we will be storing in our pointer. For example, 
+consider the variable declaration:  
+
+   int *ptr; 
+
+ptr is the name of our variable (just as k was the name of our integer variable). The '*' 
+informs the compiler that we want a pointer variable, i.e. to set aside however many bytes 
+is required to store an address in memory. The int says that we intend to use our pointer 
+
+6 
+
+ 
+ 
+variable to store the address of an integer. Such a pointer is said to "point to" an integer. 
+However, note that when we wrote int k; we did not give k a value. If this definition is 
+made outside of any function ANSI compliant compilers will initialize it to zero. 
+Similarly, ptr has no value, that is we haven't stored an address in it in the above 
+declaration. In this case, again if the declaration is outside of any function, it is initialized 
+to a value guaranteed in such a way that it is guaranteed to not point to any C object or 
+function. A pointer initialized in this manner is called a "null" pointer.  
+
+The actual bit pattern used for a null pointer may or may not evaluate to zero since it 
+depends on the specific system on which the code is developed. To make the source code 
+compatible between various compilers on various systems, a macro is used to represent a 
+null pointer. That macro goes under the name NULL. Thus, setting the value of a pointer 
+using the NULL macro, as with an assignment statement such as ptr = NULL, guarantees 
+that the pointer has become a null pointer. Similarly, just as one can test for an integer 
+value of zero, as in if(k == 0), we can test for a null pointer using if (ptr == NULL).  
+
+But, back to using our new variable ptr. Suppose now that we want to store in ptr the 
+address of our integer variable k. To do this we use the unary & operator and write: 
+
+    ptr = &k;  
+
+What the & operator does is retrieve the lvalue (address) of k, even though k is on the 
+right hand side of the assignment operator '=', and copies that to the contents of our 
+pointer ptr. Now, ptr is said to "point to" k. Bear with us now, there is only one more 
+operator we need to discuss.  
+
+The "dereferencing operator" is the asterisk and it is used as follows:  
+
+    *ptr = 7;  
+
+will copy 7 to the address pointed to by ptr. Thus if ptr "points to" (contains the address 
+of) k, the above statement will set the value of k to 7. That is, when we use the '*' this 
+way we are referring to the value of that which ptr is pointing to, not the value of the 
+pointer itself.  
+
+Similarly, we could write:  
+
+ printf("%d\n",*ptr);  
+
+to print to the screen the integer value stored at the address pointed to by ptr;.  
+
+One way to see how all this stuff fits together would be to run the following program and 
+then review the code and the output carefully.  
+
+------------ Program 1.1 ---------------------------------  
+
+/* Program 1.1 from PTRTUT10.TXT   6/10/97 */ 
+
+7 
+
+ 
+ 
+ 
+#include <stdio.h> 
+
+int j, k; 
+int *ptr; 
+
+int main(void) 
+{ 
+    j = 1; 
+    k = 2; 
+    ptr = &k; 
+    printf("\n"); 
+    printf("j has the value %d and is stored at %p\n", j, (void *)&j); 
+    printf("k has the value %d and is stored at %p\n", k, (void *)&k); 
+    printf("ptr has the value %p and is stored at %p\n", ptr, (void 
+*)&ptr); 
+    printf("The value of the integer pointed to by ptr is %d\n", *ptr); 
+
+    return 0; 
+} 
+
+Note: We have yet to discuss those aspects of C which require the use of the (void *) 
+expression used here. For now, include it in your test code. We'll explain the reason 
+behind this expression later.  
+
+To review:  
+
+•  A variable is declared by giving it a type and a name (e.g. int k;)  
+•  A pointer variable is declared by giving it a type and a name (e.g. int *ptr) where 
+the asterisk tells the compiler that the variable named ptr is a pointer variable and 
+the type tells the compiler what type the pointer is to point to (integer in this 
+case).  
+
+•  Once a variable is declared, we can get its address by preceding its name with the 
+
+unary & operator, as in &k.  
+
+•  We can "dereference" a pointer, i.e. refer to the value of that which it points to, by 
+
+using the unary '*' operator as in *ptr.  
+
+•  An "lvalue" of a variable is the value of its address, i.e. where it is stored in 
+
+memory. The "rvalue" of a variable is the value stored in that variable (at that 
+address).  
+
+References for Chapter 1:  
+
+1.  "The C Programming Language" 2nd Edition 
+
+B. Kernighan and D. Ritchie  
+Prentice Hall  
+ISBN 0-13-110362-8  
+
+8 
+
+ 
+ 
+ 
+ 
+CHAPTER 2: Pointer types and Arrays  
+
+Okay, let's move on. Let us consider why we need to identify the type of variable that a 
+pointer points to, as in:  
+
+     int *ptr; 
+
+One reason for doing this is so that later, once ptr "points to" something, if we write:  
+
+    *ptr = 2; 
+
+the compiler will know how many bytes to copy into that memory location pointed to by 
+ptr. If ptr was declared as pointing to an integer, 2 bytes would be copied, if a long, 4 
+bytes would be copied. Similarly for floats and doubles the appropriate number will be 
+copied. But, defining the type that the pointer points to permits a number of other 
+interesting ways a compiler can interpret code. For example, consider a block in memory 
+consisting if ten integers in a row. That is, 20 bytes of memory are set aside to hold 10 
+integers.  
+
+Now, let's say we point our integer pointer ptr at the first of these integers. Furthermore 
+lets say that integer is located at memory location 100 (decimal). What happens when we 
+write:  
+
+    ptr + 1;  
+
+Because the compiler "knows" this is a pointer (i.e. its value is an address) and that it 
+points to an integer (its current address, 100, is the address of an integer), it adds 2 to ptr 
+instead of 1, so the pointer "points to" the next integer, at memory location 102. 
+Similarly, were the ptr declared as a pointer to a long, it would add 4 to it instead of 1. 
+The same goes for other data types such as floats, doubles, or even user defined data 
+types such as structures. This is obviously not the same kind of "addition" that we 
+normally think of. In C it is referred to as addition using "pointer arithmetic", a term 
+which we will come back to later.  
+
+Similarly, since ++ptr and ptr++ are both equivalent to ptr + 1 (though the point in the 
+program when ptr is incremented may be different), incrementing a pointer using the 
+unary ++ operator, either pre- or post-, increments the address it stores by the amount 
+sizeof(type) where "type" is the type of the object pointed to. (i.e. 2 for an integer, 4 for a 
+long, etc.).  
+
+Since a block of 10 integers located contiguously in memory is, by definition, an array of 
+integers, this brings up an interesting relationship between arrays and pointers. 
+
+9 
+
+ 
+Consider the following:  
+
+    int my_array[] = {1,23,17,4,-5,100};  
+
+Here we have an array containing 6 integers. We refer to each of these integers by means 
+of a subscript to my_array, i.e. using my_array[0] through my_array[5]. But, we could 
+alternatively access them via a pointer as follows:  
+
+    int *ptr; 
+    ptr = &my_array[0];       /* point our pointer at the first 
+                                 integer in our array */  
+
+And then we could print out our array either using the array notation or by dereferencing 
+our pointer. The following code illustrates this:  
+
+-----------  Program 2.1  ----------------------------------- 
+
+/* Program 2.1 from PTRTUT10.HTM   6/13/97 */ 
+
+#include <stdio.h> 
+
+int my_array[] = {1,23,17,4,-5,100}; 
+int *ptr; 
+
+int main(void) 
+{ 
+    int i; 
+    ptr = &my_array[0];     /* point our pointer to the first 
+                                      element of the array */ 
+    printf("\n\n"); 
+    for (i = 0; i < 6; i++) 
+    { 
+      printf("my_array[%d] = %d   ",i,my_array[i]);   /*<-- A */ 
+      printf("ptr + %d = %d\n",i, *(ptr + i));        /*<-- B */ 
+    } 
+    return 0; 
+} 
+
+Compile and run the above program and carefully note lines A and B and that the 
+program prints out the same values in either case. Also observe how we dereferenced our 
+pointer in line B, i.e. we first added i to it and then dereferenced the new pointer. Change 
+line B to read:  
+
+    printf("ptr + %d = %d\n",i, *ptr++); 
+
+and run it again... then change it to:  
+
+    printf("ptr + %d = %d\n",i, *(++ptr)); 
+
+10 
+
+ 
+  
+ 
+ 
+ 
+ 
+and try once more. Each time try and predict the outcome and carefully look at the actual 
+outcome.  
+
+In C, the standard states that wherever we might use &var_name[0] we can replace that 
+with var_name, thus in our code where we wrote:  
+
+    ptr = &my_array[0]; 
+
+we can write:  
+
+    ptr = my_array; 
+
+to achieve the same result.  
+
+This leads many texts to state that the name of an array is a pointer. I prefer to mentally 
+think "the name of the array is the address of first element in the array". Many beginners 
+(including myself when I was learning) have a tendency to become confused by thinking 
+of it as a pointer. For example, while we can write  
+
+    ptr = my_array; 
+
+we cannot write  
+
+    my_array = ptr; 
+
+The reason is that while ptr is a variable, my_array is a constant. That is, the location at 
+which the first element of my_array will be stored cannot be changed once my_array[] 
+has been declared.  
+
+Earlier when discussing the term "lvalue" I cited K&R-2 where it stated:  
+
+"An object is a named region of storage; an lvalue is an expression 
+referring to an object".  
+
+This raises an interesting problem. Since my_array is a named region of storage, why is 
+my_array in the above assignment statement not an lvalue? To resolve this problem, 
+some refer to my_array as an "unmodifiable lvalue".  
+
+Modify the example program above by changing  
+
+    ptr = &my_array[0]; 
+
+to  
+
+    ptr = my_array; 
+
+and run it again to verify the results are identical.  
+
+11 
+
+ 
+Now, let's delve a little further into the difference between the names ptr and my_array 
+as used above. Some writers will refer to an array's name as a constant pointer. What do 
+we mean by that? Well, to understand the term "constant" in this sense, let's go back to 
+our definition of the term "variable". When we declare a variable we set aside a spot in 
+memory to hold the value of the appropriate type. Once that is done the name of the 
+variable can be interpreted in one of two ways. When used on the left side of the 
+assignment operator, the compiler interprets it as the memory location to which to move 
+that value resulting from evaluation of the right side of the assignment operator. But, 
+when used on the right side of the assignment operator, the name of a variable is 
+interpreted to mean the contents stored at that memory address set aside to hold the value 
+of that variable.  
+
+With that in mind, let's now consider the simplest of constants, as in:  
+
+    int i, k; 
+    i = 2; 
+
+Here, while i is a variable and then occupies space in the data portion of memory, 2 is a 
+constant and, as such, instead of setting aside memory in the data segment, it is imbedded 
+directly in the code segment of memory. That is, while writing something like k = i; tells 
+the compiler to create code which at run time will look at memory location &i to 
+determine the value to be moved to k, code created by i = 2; simply puts the 2 in the code 
+and there is no referencing of the data segment. That is, both k and i are objects, but 2 is 
+not an object.  
+
+Similarly, in the above, since my_array is a constant, once the compiler establishes 
+where the array itself is to be stored, it "knows" the address of my_array[0] and on 
+seeing:  
+
+    ptr = my_array; 
+
+it simply uses this address as a constant in the code segment and there is no referencing 
+of the data segment beyond that.  
+
+This might be a good place explain further the use of the (void *) expression used in 
+Program 1.1 of Chapter 1. As we have seen we can have pointers of various types. So far 
+we have discussed pointers to integers and pointers to characters. In coming chapters we 
+will be learning about pointers to structures and even pointer to pointers.  
+
+Also we have learned that on different systems the size of a pointer can vary. As it turns 
+out it is also possible that the size of a pointer can vary depending on the data type of the 
+object to which it points. Thus, as with integers where you can run into trouble 
+attempting to assign a long integer to a variable of type short integer, you can run into 
+trouble attempting to assign the values of pointers of various types to pointer variables of 
+other types.  
+
+12 
+
+ 
+To minimize this problem, C provides for a pointer of type void. We can declare such a 
+pointer by writing:  
+
+void *vptr; 
+
+A void pointer is sort of a generic pointer. For example, while C will not permit the 
+comparison of a pointer to type integer with a pointer to type character, for example, 
+either of these can be compared to a void pointer. Of course, as with other variables, casts 
+can be used to convert from one type of pointer to another under the proper 
+circumstances. In Program 1.1. of Chapter 1 I cast the pointers to integers into void 
+pointers to make them compatible with the %p conversion specification. In later chapters 
+other casts will be made for reasons defined therein.  
+
+Well, that's a lot of technical stuff to digest and I don't expect a beginner to understand all 
+of it on first reading. With time and experimentation you will want to come back and re-
+read the first 2 chapters. But for now, let's move on to the relationship between pointers, 
+character arrays, and strings.  
+
+13 
+
+ 
+CHAPTER 3: Pointers and Strings  
+
+The study of strings is useful to further tie in the relationship between pointers and arrays. 
+It also makes it easy to illustrate how some of the standard C string functions can be 
+implemented. Finally it illustrates how and when pointers can and should be passed to 
+functions.  
+
+In C, strings are arrays of characters. This is not necessarily true in other languages. In 
+BASIC, Pascal, Fortran and various other languages, a string has its own data type. But in 
+C it does not. In C a string is an array of characters terminated with a binary zero 
+character (written as '\0'). To start off our discussion we will write some code which, 
+while preferred for illustrative purposes, you would probably never write in an actual 
+program. Consider, for example:  
+
+    char my_string[40]; 
+
+    my_string[0] = 'T'; 
+    my_string[1] = 'e'; 
+    my_string[2] = 'd': 
+    my_string[3] = '\0'; 
+
+While one would never build a string like this, the end result is a string in that it is an 
+array of characters terminated with a nul character. By definition, in C, a string is an 
+array of characters terminated with the nul character. Be aware that "nul" is not the same 
+as "NULL". The nul refers to a zero as defined by the escape sequence '\0'. That is it 
+occupies one byte of memory. NULL, on the other hand, is the name of the macro used to 
+initialize null pointers. NULL is #defined in a header file in your C compiler, nul may not 
+be #defined at all.  
+
+Since writing the above code would be very time consuming, C permits two alternate 
+ways of achieving the same thing. First, one might write:  
+
+    char my_string[40] = {'T', 'e', 'd', '\0',};     
+
+But this also takes more typing than is convenient. So, C permits:  
+
+    char my_string[40] = "Ted"; 
+
+When the double quotes are used, instead of the single quotes as was done in the previous 
+examples, the nul character ( '\0' ) is automatically appended to the end of the string.  
+
+In all of the above cases, the same thing happens. The compiler sets aside an contiguous 
+block of memory 40 bytes long to hold characters and initialized it such that the first 4 
+characters are Ted\0.  
+
+Now, consider the following program:  
+
+14 
+
+ 
+ 
+------------------program 3.1------------------------------------- 
+
+/* Program 3.1 from PTRTUT10.HTM   6/13/97 */ 
+
+#include <stdio.h> 
+
+char strA[80] = "A string to be used for demonstration purposes"; 
+char strB[80]; 
+
+int main(void) 
+{ 
+
+    char *pA;     /* a pointer to type character */ 
+    char *pB;     /* another pointer to type character */ 
+    puts(strA);   /* show string A */ 
+    pA = strA;    /* point pA at string A */ 
+    puts(pA);     /* show what pA is pointing to */ 
+    pB = strB;    /* point pB at string B */ 
+    putchar('\n');       /* move down one line on the screen */ 
+    while(*pA != '\0')   /* line A (see text) */ 
+    { 
+        *pB++ = *pA++;   /* line B (see text) */ 
+    } 
+    *pB = '\0';          /* line C (see text) */ 
+    puts(strB);          /* show strB on screen */ 
+    return 0; 
+} 
+
+--------- end program 3.1 ------------------------------------- 
+
+In the above we start out by defining two character arrays of 80 characters each. Since 
+these are globally defined, they are initialized to all '\0's first. Then, strA has the first 42 
+characters initialized to the string in quotes.  
+
+Now, moving into the code, we declare two character pointers and show the string on the 
+screen. We then "point" the pointer pA at strA. That is, by means of the assignment 
+statement we copy the address of strA[0] into our variable pA. We now use puts() to 
+show that which is pointed to by pA on the screen. Consider here that the function 
+prototype for puts() is:  
+
+    int puts(const char *s);  
+
+For the moment, ignore the const. The parameter passed to puts() is a pointer, that is the 
+value of a pointer (since all parameters in C are passed by value), and the value of a 
+pointer is the address to which it points, or, simply, an address. Thus when we write 
+puts(strA); as we have seen, we are passing the address of strA[0].  
+
+Similarly, when we write puts(pA); we are passing the same address, since we have set 
+pA = strA;  
+
+15 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+     
+Given that, follow the code down to the while() statement on line A. Line A states:  
+
+While the character pointed to by pA (i.e. *pA) is not a nul character (i.e. the terminating 
+'\0'), do the following:  
+
+Line B states: copy the character pointed to by pA to the space pointed to by pB, then 
+increment pA so it points to the next character and pB so it points to the next space.  
+
+When we have copied the last character, pA now points to the terminating nul character 
+and the loop ends. However, we have not copied the nul character. And, by definition a 
+string in C must be nul terminated. So, we add the nul character with line C.  
+
+It is very educational to run this program with your debugger while watching strA, strB, 
+pA and pB and single stepping through the program. It is even more educational if 
+instead of simply defining strB[] as has been done above, initialize it also with something 
+like:  
+
+    strB[80] = "12345678901234567890123456789012345678901234567890" 
+
+where the number of digits used is greater than the length of strA and then repeat the 
+single stepping procedure while watching the above variables. Give these things a try!  
+
+Getting back to the prototype for puts() for a moment, the "const" used as a parameter 
+modifier informs the user that the function will not modify the string pointed to by s, i.e. 
+it will treat that string as a constant.  
+
+Of course, what the above program illustrates is a simple way of copying a string. After 
+playing with the above until you have a good understanding of what is happening, we can 
+proceed to creating our own replacement for the standard strcpy() that comes with C. It 
+might look like:  
+
+   char *my_strcpy(char *destination, char *source) 
+   { 
+       char *p = destination; 
+       while (*source != '\0') 
+       { 
+           *p++ = *source++; 
+       } 
+       *p = '\0'; 
+       return destination; 
+   }    
+
+In this case, I have followed the practice used in the standard routine of returning a 
+pointer to the destination.  
+
+Again, the function is designed to accept the values of two character pointers, i.e. 
+addresses, and thus in the previous program we could write:  
+
+16 
+
+ 
+    int main(void) 
+    { 
+        my_strcpy(strB, strA); 
+        puts(strB); 
+    }     
+
+I have deviated slightly from the form used in standard C which would have the 
+prototype:  
+
+    char *my_strcpy(char *destination, const char *source);   
+
+Here the "const" modifier is used to assure the user that the function will not modify the 
+contents pointed to by the source pointer. You can prove this by modifying the function 
+above, and its prototype, to include the "const" modifier as shown. Then, within the 
+function you can add a statement which attempts to change the contents of that which is 
+pointed to by source, such as:  
+
+    *source = 'X'; 
+
+which would normally change the first character of the string to an X. The const modifier 
+should cause your compiler to catch this as an error. Try it and see.  
+
+Now, let's consider some of the things the above examples have shown us. First off, 
+consider the fact that *ptr++ is to be interpreted as returning the value pointed to by ptr 
+and then incrementing the pointer value. This has to do with the precedence of the 
+operators. Were we to write (*ptr)++ we would increment, not the pointer, but that which 
+the pointer points to! i.e. if used on the first character of the above example string the 'T' 
+would be incremented to a 'U'. You can write some simple example code to illustrate this.  
+
+Recall again that a string is nothing more than an array of characters, with the last 
+character being a '\0'. What we have done above is deal with copying an array. It happens 
+to be an array of characters but the technique could be applied to an array of integers, 
+doubles, etc. In those cases, however, we would not be dealing with strings and hence the 
+end of the array would not be marked with a special value like the nul character. We 
+could implement a version that relied on a special value to identify the end. For example, 
+we could copy an array of positive integers by marking the end with a negative integer. 
+On the other hand, it is more usual that when we write a function to copy an array of 
+items other than strings we pass the function the number of items to be copied as well as 
+the address of the array, e.g. something like the following prototype might indicate:  
+
+    void int_copy(int *ptrA, int *ptrB, int nbr); 
+
+where nbr is the number of integers to be copied. You might want to play with this idea 
+and create an array of integers and see if you can write the function int_copy() and make 
+it work.  
+
+17 
+
+ 
+ 
+This permits using functions to manipulate large arrays. For example, if we have an array 
+of 5000 integers that we want to manipulate with a function, we need only pass to that 
+function the address of the array (and any auxiliary information such as nbr above, 
+depending on what we are doing). The array itself does not get passed, i.e. the whole 
+array is not copied and put on the stack before calling the function, only its address is 
+sent.  
+
+This is different from passing, say an integer, to a function. When we pass an integer we 
+make a copy of the integer, i.e. get its value and put it on the stack. Within the function 
+any manipulation of the value passed can in no way effect the original integer. But, with 
+arrays and pointers we can pass the address of the variable and hence manipulate the 
+values of the original variables.  
+
+18 
+
+ 
+CHAPTER 4: More on Strings 
+
+Well, we have progressed quite a way in a short time! Let's back up a little and look at 
+what was done in Chapter 3 on copying of strings but in a different light. Consider the 
+following function:  
+
+    char *my_strcpy(char dest[], char source[]) 
+    { 
+        int i = 0; 
+        while (source[i] != '\0') 
+        { 
+            dest[i] = source[i]; 
+            i++; 
+        } 
+        dest[i] = '\0'; 
+        return dest; 
+    } 
+Recall that strings are arrays of characters. Here we have chosen to use array notation 
+instead of pointer notation to do the actual copying. The results are the same, i.e. the 
+string gets copied using this notation just as accurately as it did before. This raises some 
+interesting points which we will discuss.  
+
+Since parameters are passed by value, in both the passing of a character pointer or the 
+name of the array as above, what actually gets passed is the address of the first element of 
+each array. Thus, the numerical value of the parameter passed is the same whether we use 
+a character pointer or an array name as a parameter. This would tend to imply that 
+somehow source[i] is the same as *(p+i).  
+
+In fact, this is true, i.e wherever one writes a[i] it can be replaced with *(a + i) without 
+any problems. In fact, the compiler will create the same code in either case. Thus we see 
+that pointer arithmetic is the same thing as array indexing. Either syntax produces the 
+same result.  
+
+This is NOT saying that pointers and arrays are the same thing, they are not. We are only 
+saying that to identify a given element of an array we have the choice of two syntaxes, 
+one using array indexing and the other using pointer arithmetic, which yield identical 
+results.  
+
+Now, looking at this last expression, part of it.. (a + i), is a simple addition using the + 
+operator and the rules of C state that such an expression is commutative. That is (a + i) is 
+identical to (i + a). Thus we could write *(i + a) just as easily as *(a + i).  
+
+19 
+
+ 
+ 
+But *(i + a) could have come from i[a] ! From all of this comes the curious truth that if:  
+
+    char a[20]; 
+    int i; 
+
+writing  
+
+    a[3] = 'x'; 
+
+is the same as writing  
+
+    3[a] = 'x'; 
+
+Try it! Set up an array of characters, integers or longs, etc. and assigned the 3rd or 4th 
+element a value using the conventional approach and then print out that value to be sure 
+you have that working. Then reverse the array notation as I have done above. A good 
+compiler will not balk and the results will be identical. A curiosity... nothing more!  
+
+Now, looking at our function above, when we write:  
+
+    dest[i] = source[i]; 
+
+due to the fact that array indexing and pointer arithmetic yield identical results, we can 
+write this as:  
+
+    *(dest + i) = *(source + i); 
+
+But, this takes 2 additions for each value taken on by i. Additions, generally speaking, 
+take more time than incrementations (such as those done using the ++ operator as in i++). 
+This may not be true in modern optimizing compilers, but one can never be sure. Thus, 
+the pointer version may be a bit faster than the array version.  
+
+Another way to speed up the pointer version would be to change:  
+
+    while (*source != '\0') 
+
+to simply  
+
+    while (*source) 
+
+since the value within the parenthesis will go to zero (FALSE) at the same time in either 
+case.  
+
+20 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+At this point you might want to experiment a bit with writing some of your own programs 
+using pointers. Manipulating strings is a good place to experiment. You might want to 
+write your own versions of such standard functions as:  
+
+    strlen(); 
+    strcat(); 
+    strchr(); 
+and any others you might have on your system.  
+
+We will come back to strings and their manipulation through pointers in a future chapter. 
+For now, let's move on and discuss structures for a bit.  
+
+21 
+
+ 
+ 
+ 
+CHAPTER 5: Pointers and Structures  
+
+As you may know, we can declare the form of a block of data containing different data 
+types by means of a structure declaration. For example, a personnel file might contain 
+structures which look something like:  
+
+    struct tag { 
+        char lname[20];        /* last name */ 
+        char fname[20];        /* first name */ 
+        int age;               /* age */ 
+        float rate;            /* e.g. 12.75 per hour */ 
+    }; 
+
+Let's say we have a bunch of these structures in a disk file and we want to read each one 
+out and print out the first and last name of each one so that we can have a list of the 
+people in our files. The remaining information will not be printed out. We will want to do 
+this printing with a function call and pass to that function a pointer to the structure at 
+hand. For demonstration purposes I will use only one structure for now. But realize the 
+goal is the writing of the function, not the reading of the file which, presumably, we 
+know how to do.  
+
+For review, recall that we can access structure members with the dot operator as in:  
+
+--------------- program 5.1 ------------------ 
+
+/* Program 5.1 from PTRTUT10.HTM     6/13/97 */ 
+
+#include <stdio.h> 
+#include <string.h> 
+
+struct tag { 
+    char lname[20];      /* last name */ 
+    char fname[20];      /* first name */ 
+    int age;             /* age */ 
+    float rate;          /* e.g. 12.75 per hour */ 
+}; 
+
+struct tag my_struct;       /* declare the structure my_struct */ 
+
+int main(void) 
+{ 
+    strcpy(my_struct.lname,"Jensen"); 
+    strcpy(my_struct.fname,"Ted"); 
+    printf("\n%s ",my_struct.fname); 
+    printf("%s\n",my_struct.lname); 
+    return 0; 
+} 
+
+-------------- end of program 5.1 -------------- 
+
+22 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Now, this particular structure is rather small compared to many used in C programs. To 
+the above we might want to add:  
+
+    date_of_hire;                  (data types not shown) 
+    date_of_last_raise; 
+    last_percent_increase; 
+    emergency_phone; 
+    medical_plan; 
+    Social_S_Nbr; 
+    etc..... 
+
+If we have a large number of employees, what we want to do is manipulate the data in 
+these structures by means of functions. For example we might want a function print out 
+the name of the employee listed in any structure passed to it. However, in the original C 
+(Kernighan & Ritchie, 1st Edition) it was not possible to pass a structure, only a pointer 
+to a structure could be passed. In ANSI C, it is now permissible to pass the complete 
+structure. But, since our goal here is to learn more about pointers, we won't pursue that.  
+
+Anyway, if we pass the whole structure it means that we must copy the contents of the 
+structure from the calling function to the called function. In systems using stacks, this is 
+done by pushing the contents of the structure on the stack. With large structures this 
+could prove to be a problem. However, passing a pointer uses a minimum amount of 
+stack space.  
+
+In any case, since this is a discussion of pointers, we will discuss how we go about 
+passing a pointer to a structure and then using it within the function.  
+
+Consider the case described, i.e. we want a function that will accept as a parameter a 
+pointer to a structure and from within that function we want to access members of the 
+structure. For example we want to print out the name of the employee in our example 
+structure.  
+
+Okay, so we know that our pointer is going to point to a structure declared using struct 
+tag. We declare such a pointer with the declaration:  
+
+    struct tag *st_ptr; 
+
+and we point it to our example structure with:  
+
+    st_ptr = &my_struct; 
+
+Now, we can access a given member by de-referencing the pointer. But, how do we de-
+reference the pointer to a structure? Well, consider the fact that we might want to use the 
+pointer to set the age of the employee. We would write:  
+
+    (*st_ptr).age = 63; 
+
+23 
+
+ 
+ 
+Look at this carefully. It says, replace that within the parenthesis with that which st_ptr 
+points to, which is the structure my_struct. Thus, this breaks down to the same as 
+my_struct.age.  
+
+However, this is a fairly often used expression and the designers of C have created an 
+alternate syntax with the same meaning which is:  
+
+    st_ptr->age = 63; 
+
+With that in mind, look at the following program:  
+
+------------ program 5.2 --------------------- 
+
+/* Program 5.2 from PTRTUT10.HTM   6/13/97 */ 
+
+#include <stdio.h> 
+#include <string.h> 
+
+struct tag{                     /* the structure type */ 
+    char lname[20];             /* last name */ 
+    char fname[20];             /* first name */ 
+    int age;                    /* age */ 
+    float rate;                 /* e.g. 12.75 per hour */ 
+}; 
+
+struct tag my_struct;           /* define the structure */ 
+void show_name(struct tag *p);  /* function prototype */ 
+
+int main(void) 
+{ 
+    struct tag *st_ptr;         /* a pointer to a structure */ 
+    st_ptr = &my_struct;        /* point the pointer to my_struct */ 
+    strcpy(my_struct.lname,"Jensen"); 
+    strcpy(my_struct.fname,"Ted"); 
+    printf("\n%s ",my_struct.fname); 
+    printf("%s\n",my_struct.lname); 
+    my_struct.age = 63; 
+    show_name(st_ptr);          /* pass the pointer */ 
+    return 0; 
+} 
+
+void show_name(struct tag *p) 
+{ 
+    printf("\n%s ", p->fname);  /* p points to a structure */ 
+    printf("%s ", p->lname); 
+    printf("%d\n", p->age); 
+} 
+
+-------------------- end of program 5.2 ---------------- 
+
+Again, this is a lot of information to absorb at one time. The reader should compile and 
+run the various code snippets and using a debugger monitor things like my_struct and p 
+
+24 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+while single stepping through the main and following the code down into the function to 
+see what is happening.  
+
+25 
+
+ 
+CHAPTER 6: Some more on Strings, and Arrays of 
+Strings  
+
+Well, let's go back to strings for a bit. In the following all assignments are to be 
+understood as being global, i.e. made outside of any function, including main().  
+
+We pointed out in an earlier chapter that we could write:  
+
+   char my_string[40] = "Ted"; 
+
+which would allocate space for a 40 byte array and put the string in the first 4 bytes (three 
+for the characters in the quotes and a 4th to handle the terminating '\0').  
+
+Actually, if all we wanted to do was store the name "Ted" we could write:  
+
+   char my_name[] = "Ted"; 
+
+and the compiler would count the characters, leave room for the nul character and store 
+the total of the four characters in memory the location of which would be returned by the 
+array name, in this case my_name.  
+
+In some code, instead of the above, you might see:  
+
+   char *my_name = "Ted"; 
+
+which is an alternate approach. Is there a difference between these? The answer is.. yes. 
+Using the array notation 4 bytes of storage in the static memory block are taken up, one 
+for each character and one for the terminating nul character. But, in the pointer notation 
+the same 4 bytes required, plus N bytes to store the pointer variable my_name (where N 
+depends on the system but is usually a minimum of 2 bytes and can be 4 or more).  
+
+In the array notation, my_name is short for &myname[0] which is the address of the 
+first element of the array. Since the location of the array is fixed during run time, this is a 
+constant (not a variable). In the pointer notation my_name is a variable. As to which is 
+the better method, that depends on what you are going to do within the rest of the 
+program.  
+
+Let's now go one step further and consider what happens if each of these declarations are 
+done within a function as opposed to globally outside the bounds of any function.  
+
+void my_function_A(char *ptr) 
+{ 
+    char a[] = "ABCDE" 
+    . 
+    . 
+}  
+
+26 
+
+ 
+ 
+void my_function_B(char *ptr) 
+{ 
+    char *cp = "FGHIJ" 
+    . 
+    . 
+} 
+
+In the case of my_function_A, the content, or value(s), of the array a[] is considered to 
+be the data. The array is said to be initialized to the values ABCDE. In the case of 
+my_function_B, the value of the pointer cp is considered to be the data. The pointer has 
+been initialized to point to the string FGHIJ. In both my_function_A and 
+my_function_B the definitions are local variables and thus the string ABCDE is stored 
+on the stack, as is the value of the pointer cp. The string FGHIJ can be stored anywhere. 
+On my system it gets stored in the data segment.  
+
+By the way, array initialization of automatic variables as I have done in my_function_A 
+was illegal in the older K&R C and only "came of age" in the newer ANSI C. A fact that 
+may be important when one is considering portability and backwards compatibility.  
+
+As long as we are discussing the relationship/differences between pointers and arrays, 
+let's move on to multi-dimensional arrays. Consider, for example the array:  
+
+    char multi[5][10]; 
+
+Just what does this mean? Well, let's consider it in the following light.  
+
+    char multi[5][10]; 
+
+Let's take the underlined part to be the "name" of an array. Then prepending the char and 
+appending the [10] we have an array of 10 characters. But, the name multi[5] is itself an 
+array indicating that there are 5 elements each being an array of 10 characters. Hence we 
+have an array of 5 arrays of 10 characters each..  
+
+Assume we have filled this two dimensional array with data of some kind. In memory, it 
+might look as if it had been formed by initializing 5 separate arrays using something like:  
+
+    multi[0] = {'0','1','2','3','4','5','6','7','8','9'} 
+    multi[1] = {'a','b','c','d','e','f','g','h','i','j'} 
+    multi[2] = {'A','B','C','D','E','F','G','H','I','J'} 
+    multi[3] = {'9','8','7','6','5','4','3','2','1','0'} 
+    multi[4] = {'J','I','H','G','F','E','D','C','B','A'} 
+
+At the same time, individual elements might be addressable using syntax such as: 
+
+    multi[0][3] = '3' 
+    multi[1][7] = 'h' 
+    multi[4][0] = 'J' 
+
+27 
+
+ 
+ 
+Since arrays are contiguous in memory, our actual memory block for the above should 
+look like:  
+
+    0123456789abcdefghijABCDEFGHIJ9876543210JIHGFEDCBA 
+    ^ 
+    |_____ starting at the address &multi[0][0] 
+
+Note that I did not write multi[0] = "0123456789". Had I done so a terminating '\0' 
+would have been implied since whenever double quotes are used a '\0' character is 
+appended to the characters contained within those quotes. Had that been the case I would 
+have had to set aside room for 11 characters per row instead of 10.  
+
+My goal in the above is to illustrate how memory is laid out for 2 dimensional arrays. 
+That is, this is a 2 dimensional array of characters, NOT an array of "strings".  
+
+Now, the compiler knows how many columns are present in the array so it can interpret 
+multi + 1 as the address of the 'a' in the 2nd row above. That is, it adds 10, the number of 
+columns, to get this location. If we were dealing with integers and an array with the same 
+dimension the compiler would add 10*sizeof(int) which, on my machine, would be 20. 
+Thus, the address of the 9 in the 4th row above would be &multi[3][0] or *(multi + 3) in 
+pointer notation. To get to the content of the 2nd element in the 4th row we add 1 to this 
+address and dereference the result as in  
+
+    *(*(multi + 3) + 1) 
+
+With a little thought we can see that:  
+
+    *(*(multi + row) + col)    and 
+    multi[row][col]            yield the same results. 
+
+The following program illustrates this using integer arrays instead of character arrays.  
+
+------------------- program 6.1 ---------------------- 
+
+/* Program 6.1 from PTRTUT10.HTM   6/13/97*/ 
+
+#include <stdio.h> 
+#define ROWS 5 
+#define COLS 10 
+
+int multi[ROWS][COLS]; 
+
+int main(void) 
+{ 
+    int row, col; 
+    for (row = 0; row < ROWS; row++) 
+    { 
+        for (col = 0; col < COLS; col++) 
+        { 
+            multi[row][col] = row*col; 
+        } 
+
+28 
+
+ 
+ 
+ 
+ 
+ 
+    } 
+
+    for (row = 0; row < ROWS; row++) 
+    { 
+        for (col = 0; col < COLS; col++) 
+        { 
+            printf("\n%d  ",multi[row][col]); 
+            printf("%d ",*(*(multi + row) + col)); 
+        } 
+    } 
+
+    return 0; 
+} 
+----------------- end of program 6.1 ---------------------    
+
+Because of the double de-referencing required in the pointer version, the name of a 2 
+dimensional array is often said to be equivalent to a pointer to a pointer. With a three 
+dimensional array we would be dealing with an array of arrays of arrays and some might 
+say its name would be equivalent to a pointer to a pointer to a pointer. However, here we 
+have initially set aside the block of memory for the array by defining it using array 
+notation. Hence, we are dealing with a constant, not a variable. That is we are talking 
+about a fixed address not a variable pointer. The dereferencing function used above 
+permits us to access any element in the array of arrays without the need of changing the 
+value of that address (the address of multi[0][0] as given by the symbol multi).  
+
+29 
+
+ 
+ 
+ 
+CHAPTER 7: More on Multi-Dimensional Arrays 
+
+In the previous chapter we noted that given  
+
+    #define ROWS 5 
+    #define COLS 10 
+
+    int multi[ROWS][COLS]; 
+we can access individual elements of the array multi using either:  
+
+    multi[row][col] 
+or  
+
+    *(*(multi + row) + col) 
+
+To understand more fully what is going on, let us replace  
+
+    *(multi + row) 
+
+with X as in:  
+
+    *(X + col) 
+
+Now, from this we see that X is like a pointer since the expression is de-referenced and 
+we know that col is an integer. Here the arithmetic being used is of a special kind called 
+"pointer arithmetic" is being used. That means that, since we are talking about an integer 
+array, the address pointed to by (i.e. value of) X + col + 1 must be greater than the 
+address X + col by and amount equal to sizeof(int).  
+
+Since we know the memory layout for 2 dimensional arrays, we can determine that in the 
+expression multi + row as used above, multi + row + 1 must increase by value an 
+amount equal to that needed to "point to" the next row, which in this case would be an 
+amount equal to COLS * sizeof(int).  
+
+That says that if the expression *(*(multi + row) + col) is to be evaluated correctly at run 
+time, the compiler must generate code which takes into consideration the value of COLS, 
+i.e. the 2nd dimension. Because of the equivalence of the two forms of expression, this is 
+true whether we are using the pointer expression as here or the array expression 
+multi[row][col].  
+
+Thus, to evaluate either expression, a total of 5 values must be known:  
+
+1.  The address of the first element of the array, which is returned by the expression 
+
+multi, i.e., the name of the array.  
+
+2.  The size of the type of the elements of the array, in this case sizeof(int).  
+3.  The 2nd dimension of the array  
+4.  The specific index value for the first dimension, row in this case.  
+5.  The specific index value for the second dimension, col in this case.  
+
+30 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Given all of that, consider the problem of designing a function to manipulate the element 
+values of a previously declared array. For example, one which would set all the elements 
+of the array multi to the value 1.  
+
+    void set_value(int m_array[][COLS]) 
+    { 
+        int row, col; 
+        for (row = 0; row < ROWS; row++) 
+        { 
+            for (col = 0; col < COLS; col++) 
+            { 
+                m_array[row][col] = 1; 
+            } 
+        } 
+    } 
+
+And to call this function we would then use:  
+
+    set_value(multi); 
+
+Now, within the function we have used the values #defined by ROWS and COLS that set 
+the limits on the for loops. But, these #defines are just constants as far as the compiler is 
+concerned, i.e. there is nothing to connect them to the array size within the function. row 
+and col are local variables, of course. The formal parameter definition permits the 
+compiler to determine the characteristics associated with the pointer value that will be 
+passed at run time. We really don’t need the first dimension and, as will be seen later, 
+there are occasions where we would prefer not to define it within the parameter 
+definition, out of habit or consistency, I have not used it here. But, the second dimension 
+must be used as has been shown in the expression for the parameter. The reason is that 
+we need this in the evaluation of m_array[row][col] as has been described. While the 
+parameter defines the data type (int in this case) and the automatic variables for row and 
+column are defined in the for loops, only one value can be passed using a single 
+parameter. In this case, that is the value of multi as noted in the call statement, i.e. the 
+address of the first element, often referred to as a pointer to the array. Thus, the only way 
+we have of informing the compiler of the 2nd dimension is by explicitly including it in 
+the parameter definition.  
+
+In fact, in general all dimensions of higher order than one are needed when dealing with 
+multi-dimensional arrays. That is if we are talking about 3 dimensional arrays, the 2nd 
+and 3rd dimension must be specified in the parameter definition.  
+
+31 
+
+ 
+ 
+ 
+ 
+ 
+ 
+CHAPTER 8: Pointers to Arrays 
+
+Pointers, of course, can be "pointed at" any type of data object, including arrays. While 
+that was evident when we discussed program 3.1, it is important to expand on how we do 
+this when it comes to multi-dimensional arrays.  
+
+To review, in Chapter 2 we stated that given an array of integers we could point an 
+integer pointer at that array using:  
+
+    int *ptr; 
+    ptr = &my_array[0];       /* point our pointer at the first 
+                                 integer in our array */ 
+As we stated there, the type of the pointer variable must match the type of the first 
+element of the array.  
+
+In addition, we can use a pointer as a formal parameter of a function which is designed to 
+manipulate an array. e.g.  
+
+Given:  
+
+    int array[3] = {'1', '5', '7'}; 
+    void a_func(int *p); 
+
+Some programmers might prefer to write the function prototype as:  
+
+   void a_func(int p[]); 
+
+which would tend to inform others who might use this function that the function is 
+designed to manipulate the elements of an array. Of course, in either case, what actually 
+gets passed is the value of a pointer to the first element of the array, independent of which 
+notation is used in the function prototype or definition. Note that if the array notation is 
+used, there is no need to pass the actual dimension of the array since we are not passing 
+the whole array, only the address to the first element.  
+
+We now turn to the problem of the 2 dimensional array. As stated in the last chapter, C 
+interprets a 2 dimensional array as an array of one dimensional arrays. That being the 
+case, the first element of a 2 dimensional array of integers is a one dimensional array of 
+integers. And a pointer to a two dimensional array of integers must be a pointer to that 
+data type. One way of accomplishing this is through the use of the keyword "typedef". 
+typedef assigns a new name to a specified data type. For example:  
+
+    typedef unsigned char byte; 
+
+causes the name byte to mean type unsigned char. Hence  
+
+    byte b[10];     would be an array of unsigned characters. 
+
+32 
+
+ 
+ 
+ 
+ 
+ 
+ 
+Note that in the typedef declaration, the word byte has replaced that which would 
+normally be the name of our unsigned char. That is, the rule for using typedef is that the 
+new name for the data type is the name used in the definition of the data type. Thus in:  
+
+    typedef int Array[10]; 
+
+Array becomes a data type for an array of 10 integers. i.e. Array my_arr; declares 
+my_arr as an array of 10 integers and Array arr2d[5]; makes arr2d an array of 5 arrays 
+of 10 integers each.  
+
+Also note that Array *p1d; makes p1d a pointer to an array of 10 integers. Because 
+*p1d points to the same type as arr2d, assigning the address of the two dimensional 
+array arr2d to p1d, the pointer to a one dimensional array of 10 integers is acceptable. 
+i.e. p1d = &arr2d[0]; or p1d = arr2d; are both correct.  
+
+Since the data type we use for our pointer is an array of 10 integers we would expect that 
+incrementing p1d by 1 would change its value by 10*sizeof(int), which it does. That is, 
+sizeof(*p1d) is 20. You can prove this to yourself by writing and running a simple short 
+program.  
+
+Now, while using typedef makes things clearer for the reader and easier on the 
+programmer, it is not really necessary. What we need is a way of declaring a pointer like 
+p1d without the need of the typedef keyword. It turns out that this can be done and that  
+
+    int (*p1d)[10]; 
+
+is the proper declaration, i.e. p1d here is a pointer to an array of 10 integers just as it was 
+under the declaration using the Array type. Note that this is different from  
+
+    int *p1d[10]; 
+
+which would make p1d the name of an array of 10 pointers to type int.  
+
+33 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+CHAPTER 9: Pointers and Dynamic Allocation of 
+Memory 
+
+There are times when it is convenient to allocate memory at run time using malloc(), 
+calloc(), or other allocation functions. Using this approach permits postponing the 
+decision on the size of the memory block need to store an array, for example, until run 
+time. Or it permits using a section of memory for the storage of an array of integers at 
+one point in time, and then when that memory is no longer needed it can be freed up for 
+other uses, such as the storage of an array of structures.  
+
+When memory is allocated, the allocating function (such as malloc(), calloc(), etc.) 
+returns a pointer. The type of this pointer depends on whether you are using an older 
+K&R compiler or the newer ANSI type compiler. With the older compiler the type of the 
+returned pointer is char, with the ANSI compiler it is void.  
+
+If you are using an older compiler, and you want to allocate memory for an array of 
+integers you will have to cast the char pointer returned to an integer pointer. For example, 
+to allocate space for 10 integers we might write:  
+
+    int *iptr; 
+    iptr = (int *)malloc(10 * sizeof(int)); 
+    if (iptr == NULL) 
+
+    { .. ERROR ROUTINE GOES HERE .. } 
+
+If you are using an ANSI compliant compiler, malloc() returns a void pointer and since a 
+void pointer can be assigned to a pointer variable of any object type, the (int *) cast 
+shown above is not needed. The array dimension can be determined at run time and is not 
+needed at compile time. That is, the 10 above could be a variable read in from a data file 
+or keyboard, or calculated based on some need, at run time.  
+
+Because of the equivalence between array and pointer notation, once iptr has been 
+assigned as above, one can use the array notation. For example, one could write:  
+
+    int k; 
+    for (k = 0; k < 10; k++) 
+       iptr[k] = 2; 
+
+to set the values of all elements to 2.  
+
+Even with a reasonably good understanding of pointers and arrays, one place the 
+newcomer to C is likely to stumble at first is in the dynamic allocation of multi-
+dimensional arrays. In general, we would like to be able to access elements of such arrays 
+using array notation, not pointer notation, wherever possible. Depending on the 
+application we may or may not know both dimensions at compile time. This leads to a 
+variety of ways to go about our task.  
+
+34 
+
+ 
+ 
+ 
+ 
+As we have seen, when dynamically allocating a one dimensional array its dimension can 
+be determined at run time. Now, when using dynamic allocation of higher order arrays, 
+we never need to know the first dimension at compile time. Whether we need to know the 
+higher dimensions depends on how we go about writing the code. Here I will discuss 
+various methods of dynamically allocating room for 2 dimensional arrays of integers.  
+
+First we will consider cases where the 2nd dimension is known at compile time.  
+
+METHOD 1: 
+
+One way of dealing with the problem is through the use of the typedef keyword. To 
+allocate a 2 dimensional array of integers recall that the following two notations result in 
+the same object code being generated:  
+
+    multi[row][col] = 1;     *(*(multi + row) + col) = 1; 
+
+It is also true that the following two notations generate the same code:  
+
+    multi[row]            *(multi + row) 
+
+Since the one on the right must evaluate to a pointer, the array notation on the left must 
+also evaluate to a pointer. In fact multi[0] will return a pointer to the first integer in the 
+first row, multi[1] a pointer to the first integer of the second row, etc. Actually, multi[n] 
+evaluates to a pointer to that array of integers that make up the n-th row of our 2 
+dimensional array. That is, multi can be thought of as an array of arrays and multi[n] as 
+a pointer to the n-th array of this array of arrays. Here the word pointer is being used to 
+represent an address value. While such usage is common in the literature, when reading 
+such statements one must be careful to distinguish between the constant address of an 
+array and a variable pointer which is a data object in itself.  
+
+Consider now:  
+
+--------------- Program 9.1 -------------------------------- 
+
+/* Program 9.1 from PTRTUT10.HTM  6/13/97 */ 
+
+#include <stdio.h> 
+#include <stdlib.h> 
+
+#define COLS 5 
+
+typedef int RowArray[COLS]; 
+RowArray *rptr; 
+
+int main(void) 
+{ 
+    int nrows = 10; 
+    int row, col; 
+    rptr = malloc(nrows * COLS * sizeof(int)); 
+    for (row = 0; row < nrows; row++) 
+
+35 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+    { 
+        for (col = 0; col < COLS; col++) 
+        { 
+            rptr[row][col] = 17; 
+        } 
+    } 
+
+    return 0; 
+} 
+------------- End of Prog. 9.1 -------------------------------- 
+
+Here I have assumed an ANSI compiler so a cast on the void pointer returned by malloc() 
+is not required. If you are using an older K&R compiler you will have to cast using:  
+
+    rptr = (RowArray *)malloc(.... etc. 
+
+Using this approach, rptr has all the characteristics of an array name name, (except that 
+rptr is modifiable), and array notation may be used throughout the rest of the program. 
+That also means that if you intend to write a function to modify the array contents, you 
+must use COLS as a part of the formal parameter in that function, just as we did when 
+discussing the passing of two dimensional arrays to a function.  
+
+METHOD 2: 
+
+In the METHOD 1 above, rptr turned out to be a pointer to type "one dimensional array 
+of COLS integers". It turns out that there is syntax which can be used for this type 
+without the need of typedef. If we write:  
+
+    int (*xptr)[COLS]; 
+
+the variable xptr will have all the same characteristics as the variable rptr in METHOD 
+1 above, and we need not use the typedef keyword. Here xptr is a pointer to an array of 
+integers and the size of that array is given by the #defined COLS. The parenthesis 
+placement makes the pointer notation predominate, even though the array notation has 
+higher precedence. i.e. had we written  
+
+    int *xptr[COLS]; 
+
+we would have defined xptr as an array of pointers holding the number of pointers equal 
+to that #defined by COLS. That is not the same thing at all. However, arrays of pointers 
+have their use in the dynamic allocation of two dimensional arrays, as will be seen in the 
+next 2 methods.  
+
+METHOD 3: 
+
+Consider the case where we do not know the number of elements in each row at compile 
+time, i.e. both the number of rows and number of columns must be determined at run 
+time. One way of doing this would be to create an array of pointers to type int and then 
+allocate space for each row and point these pointers at each row. Consider:  
+
+36 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+-------------- Program 9.2 ------------------------------------ 
+
+/* Program 9.2 from PTRTUT10.HTM   6/13/97 */ 
+
+#include <stdio.h> 
+#include <stdlib.h> 
+
+int main(void) 
+{ 
+    int nrows = 5;     /* Both nrows and ncols could be evaluated */ 
+    int ncols = 10;    /* or read in at run time */ 
+    int row; 
+    int **rowptr; 
+    rowptr = malloc(nrows * sizeof(int *)); 
+    if (rowptr == NULL) 
+    { 
+        puts("\nFailure to allocate room for row pointers.\n"); 
+        exit(0); 
+    } 
+
+    printf("\n\n\nIndex   Pointer(hex)   Pointer(dec)   Diff.(dec)"); 
+
+    for (row = 0; row < nrows; row++) 
+    { 
+        rowptr[row] = malloc(ncols * sizeof(int)); 
+        if (rowptr[row] == NULL) 
+        { 
+            printf("\nFailure to allocate for row[%d]\n",row); 
+            exit(0); 
+        } 
+        printf("\n%d         %p         %d", row, rowptr[row], 
+rowptr[row]); 
+        if (row > 0) 
+        printf("              %d",(int)(rowptr[row] - rowptr[row-1])); 
+    } 
+
+    return 0; 
+} 
+
+--------------- End 9.2 ------------------------------------ 
+
+In the above code rowptr is a pointer to pointer to type int. In this case it points to the 
+first element of an array of pointers to type int. Consider the number of calls to malloc():  
+
+    To get the array of pointers             1     call 
+    To get space for the rows                5     calls 
+                                          ----- 
+                     Total                   6     calls 
+
+If you choose to use this approach note that while you can use the array notation to access 
+individual elements of the array, e.g. rowptr[row][col] = 17;, it does not mean that the 
+data in the "two dimensional array" is contiguous in memory.  
+
+37 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+You can, however, use the array notation just as if it were a continuous block of memory. 
+For example, you can write:  
+
+    rowptr[row][col] = 176; 
+
+just as if rowptr were the name of a two dimensional array created at compile time. Of 
+course row and col must be within the bounds of the array you have created, just as with 
+an array created at compile time.  
+
+If you want to have a contiguous block of memory dedicated to the storage of the 
+elements in the array you can do it as follows:  
+
+METHOD 4: 
+
+In this method we allocate a block of memory to hold the whole array first. We then 
+create an array of pointers to point to each row. Thus even though the array of pointers is 
+being used, the actual array in memory is contiguous. The code looks like this:  
+
+----------------- Program 9.3 ----------------------------------- 
+
+/* Program 9.3 from PTRTUT10.HTM   6/13/97 */ 
+
+#include <stdio.h> 
+#include <stdlib.h> 
+
+int main(void) 
+{ 
+    int **rptr; 
+    int *aptr; 
+    int *testptr; 
+    int k; 
+    int nrows = 5;     /* Both nrows and ncols could be evaluated */ 
+    int ncols = 8;    /* or read in at run time */ 
+    int row, col; 
+
+    /* we now allocate the memory for the array */ 
+
+    aptr = malloc(nrows * ncols * sizeof(int)); 
+    if (aptr == NULL) 
+    { 
+        puts("\nFailure to allocate room for the array"); 
+        exit(0); 
+    } 
+
+    /* next we allocate room for the pointers to the rows */ 
+
+    rptr = malloc(nrows * sizeof(int *)); 
+    if (rptr == NULL) 
+    { 
+        puts("\nFailure to allocate room for pointers"); 
+        exit(0); 
+    } 
+
+38 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+    /* and now we 'point' the pointers */ 
+
+    for (k = 0; k < nrows; k++) 
+    { 
+        rptr[k] = aptr + (k * ncols); 
+    } 
+
+    /* Now we illustrate how the row pointers are incremented */ 
+    printf("\n\nIllustrating how row pointers are incremented"); 
+    printf("\n\nIndex   Pointer(hex)  Diff.(dec)"); 
+
+    for (row = 0; row < nrows; row++) 
+    { 
+        printf("\n%d         %p", row, rptr[row]); 
+        if (row > 0) 
+        printf("              %d",(rptr[row] - rptr[row-1])); 
+    } 
+    printf("\n\nAnd now we print out the array\n"); 
+    for (row = 0; row < nrows; row++) 
+    { 
+        for (col = 0; col < ncols; col++) 
+        { 
+            rptr[row][col] = row + col; 
+            printf("%d ", rptr[row][col]); 
+        } 
+        putchar('\n'); 
+    } 
+
+    puts("\n"); 
+
+    /* and here we illustrate that we are, in fact, dealing with 
+       a 2 dimensional array in a contiguous block of memory. */ 
+    printf("And now we demonstrate that they are contiguous in 
+memory\n"); 
+
+    testptr = aptr; 
+    for (row = 0; row < nrows; row++) 
+    { 
+        for (col = 0; col < ncols; col++) 
+        { 
+            printf("%d ", *(testptr++)); 
+        } 
+        putchar('\n'); 
+    } 
+
+    return 0; 
+} 
+
+------------- End Program 9.3 ----------------- 
+
+Consider again, the number of calls to malloc()  
+
+    To get room for the array itself      1      call 
+    To get room for the array of ptrs     1      call 
+                                        ---- 
+                         Total            2      calls 
+
+39 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Now, each call to malloc() creates additional space overhead since malloc() is generally 
+implemented by the operating system forming a linked list which contains data 
+concerning the size of the block. But, more importantly, with large arrays (several 
+hundred rows) keeping track of what needs to be freed when the time comes can be more 
+cumbersome. This, combined with the contiguousness of the data block that permits 
+initialization to all zeroes using memset() would seem to make the second alternative the 
+preferred one.  
+
+As a final example on multidimensional arrays we will illustrate the dynamic allocation 
+of a three dimensional array. This example will illustrate one more thing to watch when 
+doing this kind of allocation. For reasons cited above we will use the approach outlined in 
+alternative two. Consider the following code:  
+
+------------------- Program 9.4 ------------------------------------- 
+
+/* Program 9.4 from PTRTUT10.HTM   6/13/97 */ 
+
+#include <stdio.h> 
+#include <stdlib.h> 
+#include <stddef.h> 
+
+int X_DIM=16; 
+int Y_DIM=5; 
+int Z_DIM=3; 
+
+int main(void) 
+{ 
+    char *space; 
+    char ***Arr3D; 
+    int y, z; 
+    ptrdiff_t diff; 
+
+    /* first we set aside space for the array itself */ 
+
+    space = malloc(X_DIM * Y_DIM * Z_DIM * sizeof(char)); 
+
+    /* next we allocate space of an array of pointers, each 
+       to eventually point to the first element of a 
+       2 dimensional array of pointers to pointers */ 
+
+    Arr3D = malloc(Z_DIM * sizeof(char **)); 
+
+    /* and for each of these we assign a pointer to a newly 
+       allocated array of pointers to a row */ 
+
+    for (z = 0; z < Z_DIM; z++) 
+    { 
+        Arr3D[z] = malloc(Y_DIM * sizeof(char *)); 
+
+        /* and for each space in this array we put a pointer to 
+           the first element of each row in the array space 
+           originally allocated */ 
+
+40 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+        for (y = 0; y < Y_DIM; y++) 
+        { 
+            Arr3D[z][y] = space + (z*(X_DIM * Y_DIM) + y*X_DIM); 
+        } 
+    } 
+
+    /* And, now we check each address in our 3D array to see if 
+       the indexing of the Arr3d pointer leads through in a 
+       continuous manner */ 
+
+    for (z = 0; z < Z_DIM; z++) 
+    { 
+        printf("Location of array %d is %p\n", z, *Arr3D[z]); 
+        for ( y = 0; y < Y_DIM; y++) 
+        { 
+            printf("  Array %d and Row %d starts at %p", z, y, 
+Arr3D[z][y]); 
+            diff = Arr3D[z][y] - space; 
+            printf("    diff = %d  ",diff); 
+            printf(" z = %d  y = %d\n", z, y); 
+        } 
+    } 
+    return 0; 
+} 
+
+------------------- End of Prog. 9.4 ---------------------------- 
+
+If you have followed this tutorial up to this point you should have no problem 
+deciphering the above on the basis of the comments alone. There are a couple of points 
+that should be made however. Let's start with the line which reads:  
+
+    Arr3D[z][y] = space + (z*(X_DIM * Y_DIM) + y*X_DIM); 
+Note that here space is a character pointer, which is the same type as Arr3D[z][y]. It is 
+important that when adding an integer, such as that obtained by evaluation of the 
+expression (z*(X_DIM * Y_DIM) + y*X_DIM), to a pointer, the result is a new pointer 
+value. And when assigning pointer values to pointer variables the data types of the value 
+and variable must match.  
+
+41 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+CHAPTER 10: Pointers to Functions 
+
+Up to this point we have been discussing pointers to data objects. C also permits the 
+declaration of pointers to functions. Pointers to functions have a variety of uses and some 
+of them will be discussed here.  
+
+Consider the following real problem. You want to write a function that is capable of 
+sorting virtually any collection of data that can be stored in an array. This might be an 
+array of strings, or integers, or floats, or even structures. The sorting algorithm can be the 
+same for all. For example, it could be a simple bubble sort algorithm, or the more 
+complex shell or quick sort algorithm. We'll use a simple bubble sort for demonstration 
+purposes.  
+
+Sedgewick [1] has described the bubble sort using C code by setting up a function which 
+when passed a pointer to the array would sort it. If we call that function bubble(), a sort 
+program is described by bubble_1.c, which follows:  
+
+/*-------------------- bubble_1.c --------------------*/ 
+
+/* Program bubble_1.c from PTRTUT10.HTM   6/13/97 */ 
+
+#include <stdio.h> 
+
+int arr[10] = { 3,6,1,2,3,8,4,1,7,2}; 
+
+void bubble(int a[], int N); 
+
+int main(void) 
+{ 
+    int i; 
+    putchar('\n'); 
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    bubble(arr,10); 
+    putchar('\n'); 
+
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    return 0; 
+} 
+
+void bubble(int a[], int N) 
+{ 
+    int i, j, t; 
+    for (i = N-1; i >= 0; i--) 
+    { 
+        for (j = 1; j <= i; j++) 
+
+42 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+        { 
+            if (a[j-1] > a[j]) 
+            { 
+                t = a[j-1]; 
+                a[j-1] = a[j]; 
+                a[j] = t; 
+            } 
+        } 
+    } 
+} 
+
+/*---------------------- end bubble_1.c -----------------------*/ 
+
+The bubble sort is one of the simpler sorts. The algorithm scans the array from the second 
+to the last element comparing each element with the one which precedes it. If the one that 
+precedes it is larger than the current element, the two are swapped so the larger one is 
+closer to the end of the array. On the first pass, this results in the largest element ending 
+up at the end of the array. The array is now limited to all elements except the last and the 
+process repeated. This puts the next largest element at a point preceding the largest 
+element. The process is repeated for a number of times equal to the number of elements 
+minus 1. The end result is a sorted array.  
+
+Here our function is designed to sort an array of integers. Thus in line 1 we are 
+comparing integers and in lines 2 through 4 we are using temporary integer storage to 
+store integers. What we want to do now is see if we can convert this code so we can use 
+any data type, i.e. not be restricted to integers.  
+
+At the same time we don't want to have to analyze our algorithm and the code associated 
+with it each time we use it. We start by removing the comparison from within the 
+function bubble() so as to make it relatively easy to modify the comparison function 
+without having to re-write portions related to the actual algorithm. This results in 
+bubble_2.c:  
+
+/*---------------------- bubble_2.c -------------------------*/ 
+
+/* Program bubble_2.c from PTRTUT10.HTM   6/13/97 */ 
+
+   /* Separating the comparison function */ 
+
+#include <stdio.h> 
+
+int arr[10] = { 3,6,1,2,3,8,4,1,7,2}; 
+
+void bubble(int a[], int N); 
+int compare(int m, int n); 
+
+int main(void) 
+{ 
+    int i; 
+    putchar('\n'); 
+
+43 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    bubble(arr,10); 
+    putchar('\n'); 
+
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    return 0; 
+} 
+
+void bubble(int a[], int N) 
+
+{ 
+    int i, j, t; 
+    for (i = N-1; i >= 0; i--) 
+    { 
+        for (j = 1; j <= i; j++) 
+        { 
+            if (compare(a[j-1], a[j])) 
+            { 
+                t = a[j-1]; 
+                a[j-1] = a[j]; 
+                a[j] = t; 
+            } 
+        } 
+    } 
+} 
+
+int compare(int m, int n) 
+{ 
+    return (m > n); 
+} 
+/*--------------------- end of bubble_2.c -----------------------*/ 
+If our goal is to make our sort routine data type independent, one way of doing this is to 
+use pointers to type void to point to the data instead of using the integer data type. As a 
+start in that direction let's modify a few things in the above so that pointers can be used. 
+To begin with, we'll stick with pointers to type integer.  
+
+/*----------------------- bubble_3.c -------------------------*/ 
+
+/* Program bubble_3.c from PTRTUT10.HTM    6/13/97 */ 
+
+#include <stdio.h> 
+
+int arr[10] = { 3,6,1,2,3,8,4,1,7,2}; 
+
+void bubble(int *p, int N); 
+int compare(int *m, int *n); 
+
+int main(void) 
+{ 
+
+44 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+    int i; 
+    putchar('\n'); 
+
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    bubble(arr,10); 
+    putchar('\n'); 
+
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    return 0; 
+} 
+
+void bubble(int *p, int N) 
+{ 
+    int i, j, t; 
+    for (i = N-1; i >= 0; i--) 
+    { 
+        for (j = 1; j <= i; j++) 
+        { 
+            if (compare(&p[j-1], &p[j])) 
+            { 
+                t = p[j-1]; 
+                p[j-1] = p[j]; 
+                p[j] = t; 
+            } 
+        } 
+    } 
+} 
+
+int compare(int *m, int *n) 
+{ 
+    return (*m > *n); 
+} 
+
+/*------------------ end of bubble3.c -------------------------*/ 
+
+Note the changes. We are now passing a pointer to an integer (or array of integers) to 
+bubble(). And from within bubble we are passing pointers to the elements of the array 
+that we want to compare to our comparison function. And, of course we are dereferencing 
+these pointer in our compare() function in order to make the actual comparison. Our next 
+step will be to convert the pointers in bubble() to pointers to type void so that that 
+function will become more type insensitive. This is shown in bubble_4.  
+
+/*------------------ bubble_4.c ----------------------------*/ 
+
+/* Program bubble_4.c from PTRTUT10,HTM   6/13/97 */ 
+
+#include <stdio.h> 
+
+45 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+int arr[10] = { 3,6,1,2,3,8,4,1,7,2}; 
+
+void bubble(int *p, int N); 
+int compare(void *m, void *n); 
+
+int main(void) 
+{ 
+    int i; 
+    putchar('\n'); 
+
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    bubble(arr,10); 
+    putchar('\n'); 
+
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    return 0; 
+} 
+
+void bubble(int *p, int N) 
+{ 
+    int i, j, t; 
+    for (i = N-1; i >= 0; i--) 
+    { 
+        for (j = 1; j <= i; j++) 
+        { 
+            if (compare((void *)&p[j-1], (void *)&p[j])) 
+            { 
+                t = p[j-1]; 
+                p[j-1] = p[j]; 
+                p[j] = t; 
+            } 
+        } 
+    } 
+} 
+
+int compare(void *m, void *n) 
+{ 
+    int *m1, *n1; 
+    m1 = (int *)m; 
+    n1 = (int *)n; 
+    return (*m1 > *n1); 
+} 
+
+/*------------------ end of bubble_4.c ---------------------*/ 
+
+Note that, in doing this, in compare() we had to introduce the casting of the void pointer 
+types passed to the actual type being sorted. But, as we'll see later that's okay. And since 
+what is being passed to bubble() is still a pointer to an array of integers, we had to cast 
+these pointers to void pointers when we passed them as parameters in our call to 
+compare().  
+
+46 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+We now address the problem of what we pass to bubble(). We want to make the first 
+parameter of that function a void pointer also. But, that means that within bubble() we 
+need to do something about the variable t, which is currently an integer. Also, where we 
+use t = p[j-1]; the type of p[j-1] needs to be known in order to know how many bytes to 
+copy to the variable t (or whatever we replace t with).  
+
+Currently, in bubble_4.c, knowledge within bubble() as to the type of the data being 
+sorted (and hence the size of each individual element) is obtained from the fact that the 
+first parameter is a pointer to type integer. If we are going to be able to use bubble() to 
+sort any type of data, we need to make that pointer a pointer to type void. But, in doing so 
+we are going to lose information concerning the size of individual elements within the 
+array. So, in bubble_5.c we will add a separate parameter to handle this size information.  
+
+These changes, from bubble4.c to bubble5.c are, perhaps, a bit more extensive than those 
+we have made in the past. So, compare the two modules carefully for differences.  
+
+/*---------------------- bubble5.c ---------------------------*/ 
+
+/* Program bubble_5.c from PTRTUT10.HTM    6/13/97 */ 
+
+#include <stdio.h> 
+#include <string.h> 
+
+long arr[10] = { 3,6,1,2,3,8,4,1,7,2}; 
+
+void bubble(void *p, size_t width, int N); 
+int compare(void *m, void *n); 
+
+int main(void) 
+{ 
+    int i; 
+    putchar('\n'); 
+
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%d ", arr[i]); 
+    } 
+    bubble(arr, sizeof(long), 10); 
+    putchar('\n'); 
+
+    for (i = 0; i < 10; i++) 
+    { 
+        printf("%ld ", arr[i]); 
+    } 
+
+    return 0; 
+} 
+
+void bubble(void *p, size_t width, int N) 
+{ 
+    int i, j; 
+    unsigned char buf[4]; 
+    unsigned char *bp = p; 
+
+47 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+    for (i = N-1; i >= 0; i--) 
+    { 
+        for (j = 1; j <= i; j++) 
+        { 
+            if (compare((void *)(bp + width*(j-1)), 
+                        (void *)(bp + j*width)))  /* 1 */ 
+            { 
+/*              t = p[j-1];   */ 
+                memcpy(buf, bp + width*(j-1), width); 
+/*              p[j-1] = p[j];   */ 
+                memcpy(bp + width*(j-1), bp + j*width , width); 
+/*              p[j] = t;   */ 
+                memcpy(bp + j*width, buf, width); 
+            } 
+        } 
+    } 
+} 
+
+int compare(void *m, void *n) 
+{ 
+    long *m1, *n1; 
+    m1 = (long *)m; 
+    n1 = (long *)n; 
+    return (*m1 > *n1); 
+} 
+
+/*--------------------- end of bubble5.c ---------------------*/ 
+
+Note that I have changed the data type of the array from int to long to illustrate the 
+changes needed in the compare() function. Within bubble() I've done away with the 
+variable t (which we would have had to change from type int to type long). I have added 
+a buffer of size 4 unsigned characters, which is the size needed to hold a long (this will 
+change again in future modifications to this code). The unsigned character pointer *bp is 
+used to point to the base of the array to be sorted, i.e. to the first element of that array.  
+
+We also had to modify what we passed to compare(), and how we do the swapping of 
+elements that the comparison indicates need swapping. Use of memcpy() and pointer 
+notation instead of array notation work towards this reduction in type sensitivity.  
+
+Again, making a careful comparison of bubble5.c with bubble4.c can result in improved 
+understanding of what is happening and why.  
+
+We move now to bubble6.c where we use the same function bubble() that we used in 
+bubble5.c to sort strings instead of long integers. Of course we have to change the 
+comparison function since the means by which strings are compared is different from that 
+by which long integers are compared. And,in bubble6.c we have deleted the lines within 
+bubble() that were commented out in bubble5.c.  
+
+/*--------------------- bubble6.c ---------------------*/ 
+/* Program bubble_6.c from PTRTUT10.HTM   6/13/97 */ 
+
+48 
+
+ 
+ 
+ 
+ 
+ 
+ 
+#include <stdio.h> 
+#include <string.h> 
+
+#define MAX_BUF 256 
+
+char arr2[5][20] = {  "Mickey Mouse", 
+                      "Donald Duck", 
+                      "Minnie Mouse", 
+                      "Goofy", 
+                      "Ted Jensen" }; 
+
+void bubble(void *p, int width, int N); 
+int compare(void *m, void *n); 
+
+int main(void) 
+{ 
+    int i; 
+    putchar('\n'); 
+
+    for (i = 0; i < 5; i++) 
+    { 
+        printf("%s\n", arr2[i]); 
+    } 
+    bubble(arr2, 20, 5); 
+    putchar('\n\n'); 
+
+    for (i = 0; i < 5; i++) 
+    { 
+        printf("%s\n", arr2[i]); 
+    } 
+    return 0; 
+} 
+
+void bubble(void *p, int width, int N) 
+{ 
+    int i, j, k; 
+    unsigned char buf[MAX_BUF]; 
+    unsigned char *bp = p; 
+
+    for (i = N-1; i >= 0; i--) 
+    { 
+        for (j = 1; j <= i; j++) 
+        { 
+          k = compare((void *)(bp + width*(j-1)), (void *)(bp + 
+j*width)); 
+          if (k > 0) 
+            { 
+             memcpy(buf, bp + width*(j-1), width); 
+             memcpy(bp + width*(j-1), bp + j*width , width); 
+             memcpy(bp + j*width, buf, width); 
+            } 
+        } 
+    } 
+} 
+
+int compare(void *m, void *n) 
+
+49 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+{ 
+    char *m1 = m; 
+    char *n1 = n; 
+    return (strcmp(m1,n1)); 
+} 
+
+/*------------------- end of bubble6.c ---------------------*/ 
+
+But, the fact that bubble() was unchanged from that used in bubble5.c indicates that that 
+function is capable of sorting a wide variety of data types. What is left to do is to pass to 
+bubble() the name of the comparison function we want to use so that it can be truly 
+universal. Just as the name of an array is the address of the first element of the array in 
+the data segment, the name of a function decays into the address of that function in the 
+code segment. Thus we need to use a pointer to a function. In this case the comparison 
+function.  
+
+Pointers to functions must match the functions pointed to in the number and types of the 
+parameters and the type of the return value. In our case, we declare our function pointer 
+as:  
+
+   int (*fptr)(const void *p1, const void *p2); 
+
+Note that were we to write:  
+
+    int *fptr(const void *p1, const void *p2); 
+
+we would have a function prototype for a function which returned a pointer to type int. 
+That is because in C the parenthesis () operator have a higher precedence than the pointer 
+* operator. By putting the parenthesis around the string (*fptr) we indicate that we are 
+declaring a function pointer.  
+
+We now modify our declaration of bubble() by adding, as its 4th parameter, a function 
+pointer of the proper type. It's function prototype becomes:  
+
+    void bubble(void *p, int width, int N, 
+                int(*fptr)(const void *, const void *)); 
+
+When we call the bubble(), we insert the name of the comparison function that we want 
+to use. bubble7.c illustrate how this approach permits the use of the same bubble() 
+function for sorting different types of data.  
+
+/*------------------- bubble7.c ------------------*/ 
+
+/* Program bubble_7.c from PTRTUT10.HTM  6/10/97 */ 
+
+#include <stdio.h> 
+#include <string.h> 
+
+#define MAX_BUF 256 
+
+50 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+long arr[10] = { 3,6,1,2,3,8,4,1,7,2}; 
+char arr2[5][20] = {  "Mickey Mouse", 
+                      "Donald Duck", 
+                      "Minnie Mouse", 
+                      "Goofy", 
+                      "Ted Jensen" }; 
+
+void bubble(void *p, int width, int N, 
+            int(*fptr)(const void *, const void *)); 
+int compare_string(const void *m, const void *n); 
+int compare_long(const void *m, const void *n); 
+
+int main(void) 
+{ 
+    int i; 
+    puts("\nBefore Sorting:\n"); 
+
+    for (i = 0; i < 10; i++)               /* show the long ints */ 
+    { 
+        printf("%ld ",arr[i]); 
+    } 
+    puts("\n"); 
+
+    for (i = 0; i < 5; i++)                  /* show the strings */ 
+    { 
+        printf("%s\n", arr2[i]); 
+    } 
+    bubble(arr, 4, 10, compare_long);          /* sort the longs */ 
+    bubble(arr2, 20, 5, compare_string);     /* sort the strings */ 
+    puts("\n\nAfter Sorting:\n"); 
+
+    for (i = 0; i < 10; i++)             /* show the sorted longs */ 
+    { 
+        printf("%d ",arr[i]); 
+    } 
+    puts("\n"); 
+
+    for (i = 0; i < 5; i++)            /* show the sorted strings */ 
+    { 
+        printf("%s\n", arr2[i]); 
+    } 
+    return 0; 
+} 
+
+void bubble(void *p, int width, int N, 
+            int(*fptr)(const void *, const void *)) 
+{ 
+    int i, j, k; 
+    unsigned char buf[MAX_BUF]; 
+    unsigned char *bp = p; 
+
+    for (i = N-1; i >= 0; i--) 
+    { 
+        for (j = 1; j <= i; j++) 
+        { 
+            k = fptr((void *)(bp + width*(j-1)), (void *)(bp + 
+j*width)); 
+
+51 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+            if (k > 0) 
+            { 
+                memcpy(buf, bp + width*(j-1), width); 
+                memcpy(bp + width*(j-1), bp + j*width , width); 
+                memcpy(bp + j*width, buf, width); 
+            } 
+        } 
+    } 
+} 
+
+int compare_string(const void *m, const void *n) 
+{ 
+    char *m1 = (char *)m; 
+    char *n1 = (char *)n; 
+    return (strcmp(m1,n1)); 
+} 
+
+int compare_long(const void *m, const void *n) 
+{ 
+    long *m1, *n1; 
+    m1 = (long *)m; 
+    n1 = (long *)n; 
+    return (*m1 > *n1); 
+} 
+
+/*----------------- end of bubble7.c -----------------*/ 
+
+References for Chapter 10: 
+
+1.  "Algorithms in C" 
+Robert Sedgewick 
+Addison-Wesley 
+ISBN 0-201-51425-7 
+
+52 
+
+ 
+ 
+ 
+ 
+ 
+EPILOG  
+
+I have written the preceding material to provide an introduction to pointers for 
+newcomers to C. In C, the more one understands about pointers the greater flexibility one 
+has in the writing of code. The above expands on my first effort at this which was entitled 
+ptr_help.txt and found in an early version of Bob Stout's collection of C code SNIPPETS. 
+The content in this version has been updated from that in PTRTUTOT.ZIP included in 
+SNIP9510.ZIP.  
+
+I am always ready to accept constructive criticism on this material, or review requests for 
+the addition of other relevant material. Therefore, if you have questions, comments, 
+criticisms, etc. concerning that which has been presented, I would greatly appreciate your 
+contacting me via email me at tjensen@ix.netcom.com.  
+
+53 
+
+ 
+ 
+

ColdFusion/coldfusion.pdf.txt

@@ -0,0 +1,3002 @@
+coldfusion
+
+#coldfusion
+
+Table of Contents
+
+About
+
+Chapter 1: Getting started with coldfusion
+
+Remarks
+
+Versions
+
+Examples
+
+Installation or Setup
+
+Linux (Ubuntu) Installation
+
+Lucee (Open Source)
+
+ColdFusion / CFML Interpretor
+
+Nginx
+
+Adobe (Closed Source)
+
+ColdFusion / CFML Interpretor
+
+Nginx
+
+Hello World
+
+Chapter 2: CFLOOP How-To
+
+Remarks
+
+Examples
+
+Looping through a collection using CFML tags.
+
+Looping through a collection using CFSCRIPT.
+
+Index
+
+Parameters
+
+Basic index loop
+
+Increase step to 2
+
+Decrement step by 1
+
+CFLoop in a Function
+
+ColdFusion 11 through current
+
+Condition
+
+Tag syntax
+
+Parameters
+
+Generated HTML
+
+1
+
+2
+
+2
+
+2
+
+3
+
+3
+
+3
+
+3
+
+3
+
+3
+
+4
+
+4
+
+4
+
+5
+
+7
+
+7
+
+7
+
+7
+
+7
+
+7
+
+7
+
+8
+
+8
+
+9
+
+9
+
+10
+
+10
+
+10
+
+10
+
+10
+
+CFScript
+
+Previous to ColdFusion 8
+
+ColdFusion 8 through current
+
+ColdFusion 11 through current
+
+Generated HTML
+
+Date or time range
+
+Query
+
+Parameters
+
+Example query
+
+Tag syntax
+
+Generated HTML
+
+Limiting output to specific rows
+
+Grouping Output
+
+CFScript
+
+ColdFusion 6 (MX) though current
+
+ColdFusion 8 though current
+
+ColdFusion 10 though current
+
+ColdFusion 11 though current
+
+List
+
+Tag syntax
+
+Parameters
+
+Generated HTML
+
+CFScript
+
+Previous to ColdFusion 8
+
+ColdFusion 8 through current
+
+ColdFusion 9 through current
+
+ColdFusion 11 through current
+
+Generated HTML
+
+Array
+
+Tag syntax
+
+ColdFusion 8 through current
+
+10
+
+11
+
+11
+
+11
+
+11
+
+11
+
+11
+
+11
+
+12
+
+12
+
+12
+
+13
+
+13
+
+14
+
+15
+
+15
+
+15
+
+15
+
+16
+
+16
+
+16
+
+16
+
+16
+
+16
+
+17
+
+17
+
+17
+
+17
+
+17
+
+17
+
+17
+
+Parameters
+
+Generated HTML
+
+ColdFusion 2016 through current
+
+Parameters
+
+Generated HTML
+
+CFScript
+
+Previous to ColdFusion 8
+
+ColdFusion 8 through current
+
+ColdFusion 9 through current
+
+ColdFusion 11 through current
+
+Generated HTML
+
+File
+
+Structure
+
+Tag syntax
+
+Parameters
+
+Using Structure Functions
+
+Implicit Structure Syntax
+
+Generated HTML
+
+CFScript
+
+Output the structure's keys
+
+Generated HTML
+
+Output the value of the structure's keys
+
+Using Structure Functions
+
+Implicit Structure Syntax
+
+ColdFusion 11 through current
+
+Generated HTML
+
+Index Loop
+
+Conditional Loop
+
+Query Loop
+
+List Loop
+
+File Loop
+
+COM Collection/Structure Loops
+
+18
+
+18
+
+18
+
+18
+
+19
+
+19
+
+19
+
+19
+
+19
+
+19
+
+19
+
+20
+
+20
+
+20
+
+20
+
+20
+
+20
+
+21
+
+21
+
+21
+
+21
+
+21
+
+21
+
+21
+
+22
+
+22
+
+22
+
+22
+
+22
+
+23
+
+23
+
+23
+
+Chapter 3: cfquery
+
+Parameters
+
+Examples
+
+Using cfquery within a Function
+
+Query of Query
+
+Function Calls
+
+User.cfc
+
+Chapter 4: ColdFusion Arrays
+
+Syntax
+
+Parameters
+
+Remarks
+
+Examples
+
+Creating Arrays
+
+Creating arrays explicitly using ArrayNew()
+
+History
+
+Declaration
+
+Using ArrayAppend()
+
+Creating 1-D Array Implicitly
+
+Create 2-D Array Implicitly
+
+Array in CFScript
+
+Similarly, for 2 Dimension Array:
+
+General information
+
+Chapter 5: Creating REST APIs in coldfusion
+
+Introduction
+
+Examples
+
+Creating backend
+
+The interface
+
+Chapter 6: Database Queries
+
+Examples
+
+Working with databases
+
+Basic Example
+
+24
+
+24
+
+24
+
+24
+
+24
+
+24
+
+24
+
+26
+
+26
+
+26
+
+26
+
+26
+
+26
+
+26
+
+26
+
+26
+
+27
+
+28
+
+29
+
+30
+
+31
+
+31
+
+32
+
+32
+
+32
+
+32
+
+32
+
+33
+
+33
+
+33
+
+33
+
+Authentication
+
+Cached Queries
+
+Limiting the Number of Records Returned
+
+Timeouts
+
+Chapter 7: How to invoke a private method dynamically
+
+Remarks
+
+Examples
+
+CFML
+
+CFSCRIPT (CF10+)
+
+Chapter 8: Scopes in Coldfusion
+
+Introduction
+
+Examples
+
+Request Scopes
+
+Global Scopes
+
+Components and functions
+
+Custom tags
+
+Common scopes
+
+Overview
+
+Chapter 9: Variables
+
+Parameters
+
+Examples
+
+Using cfset
+
+Using cfparam
+
+Checking if a Variable Exists
+
+Setting a variable scope
+
+Chapter 10: Working with RegExp Replace callbacks
+
+Introduction
+
+Parameters
+
+Remarks
+
+Examples
+
+User defined REReplaceCallback function
+
+Using REReplaceCallback function
+
+34
+
+34
+
+35
+
+35
+
+36
+
+36
+
+36
+
+36
+
+36
+
+37
+
+37
+
+37
+
+37
+
+37
+
+37
+
+37
+
+38
+
+38
+
+39
+
+39
+
+39
+
+39
+
+39
+
+40
+
+40
+
+42
+
+42
+
+42
+
+42
+
+42
+
+43
+
+43
+
+Credits
+
+44
+
+About
+
+You can share this PDF with anyone you feel could benefit from it, downloaded the latest version 
+from: coldfusion
+
+It is an unofficial and free coldfusion ebook created for educational purposes. All the content is 
+extracted from Stack Overflow Documentation, which is written by many hardworking individuals at 
+Stack Overflow. It is neither affiliated with Stack Overflow nor official coldfusion.
+
+The content is released under Creative Commons BY-SA, and the list of contributors to each 
+chapter are provided in the credits section at the end of this book. Images may be copyright of 
+their respective owners unless otherwise specified. All trademarks and registered trademarks are 
+the property of their respective company owners.
+
+Use the content presented in this book at your own risk; it is not guaranteed to be correct nor 
+accurate, please send your feedback and corrections to info@zzzprojects.com
+
+https://riptutorial.com/
+
+1
+
+Chapter 1: Getting started with coldfusion
+
+Remarks
+
+This section provides an overview of what coldfusion is, and why a developer might want to use it.
+
+It should also mention any large subjects within coldfusion, and link out to the related topics. Since 
+the Documentation for coldfusion is new, you may need to create initial versions of those related 
+topics.
+
+Versions
+
+Version
+
+Release Date
+
+Cold Fusion version 1.0
+
+1995-07-02
+
+Cold Fusion version 1.5
+
+1996-01-01
+
+Cold Fusion version 2.0
+
+1996-10-01
+
+Cold Fusion version 3.0
+
+1997-06-01
+
+Cold Fusion version 3.1
+
+1998-01-01
+
+ColdFusion version 4.0
+
+1998-11-01
+
+ColdFusion version 4.5.1
+
+1999-11-01
+
+ColdFusion version 5.0
+
+2001-06-01
+
+ColdFusion MX version 6.0 2002-05-01
+
+ColdFusion MX version 6.1 2003-07-01
+
+ColdFusion MX 7
+
+2005-02-07
+
+ColdFusion 8
+
+ColdFusion 9
+
+2007-07-30
+
+2009-10-05
+
+ColdFusion 10
+
+2012-05-15
+
+ColdFusion 11
+
+2014-04-29
+
+ColdFusion 2016
+
+2016-02-16
+
+https://riptutorial.com/
+
+2
+
+Examples
+
+Installation or Setup
+
+Linux (Ubuntu) Installation
+
+Lucee (Open Source)
+
+ColdFusion / CFML Interpretor
+
+Download the appropriate file from their site (http://lucee.org/downloads.html) and execute their 
+installer
+
+wget http://cdn.lucee.org/downloader.cfm/id/155/file/lucee-5.0.0.252-pl0-linux-x64-
+installer.run 
+sudo chmod +x lucee-5.0.0.252-pl0-linux-x64-installer.run 
+sudo ./lucee-5.0.0.252-pl0-linux-x64-installer.run
+
+Step through installer.
+
+Nginx
+
+Install Nginx on your server
+
+sudo apt-get install nginx
+
+Edit your /etc/nginx/sites-available/default
+
+server { 
+    listen 80; 
+    server_name _; 
+
+    root /opt/lucee/tomcat/webapps/ROOT; 
+    index index.cfm index.html index.htm; 
+
+    #Lucee Admin should always proxy to Lucee 
+    location /lucee { 
+        include lucee.conf; 
+    } 
+
+    #Pretty URLs 
+    location / { 
+        try_files $uri /index.cfm$uri?$is_args$args; 
+        include lucee.conf; 
+    } 
+
+    location ~ \.cfm { 
+        include lucee.conf; 
+    } 
+
+https://riptutorial.com/
+
+3
+
+ 
+ 
+ 
+ 
+ 
+    location ~ \.cfc { 
+        include lucee.conf; 
+    } 
+}
+
+Edit /etc/nginx/lucee.conf
+
+proxy_pass http://127.0.0.1:8888; 
+proxy_set_header Host $http_host; 
+proxy_set_header X-Real-IP $remote_addr; 
+proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 
+proxy_set_header X-Forwarded-Proto $scheme;
+
+Reload nginx
+
+sudo service nginx reload
+
+Access the Lucee Server admin here:
+
+127.0.0.1/lucee/admin/server.cfm
+
+or
+
+127.0.0.1:8888/lucee/admin/server.cfm
+
+Your root web directory lives here:
+
+/opt/lucee/tomcat/webapps/ROOT
+
+Adobe (Closed Source)
+
+ColdFusion / CFML Interpretor
+
+Download the appropriate file from their site (
+https://www.adobe.com/products/coldfusion/download-trial/try.html) and execute their installer
+
+wget <URL>/ColdFusion_2016_WWEJ_linux64.bin 
+sudo chmod +x ColdFusion_2016_WWEJ_linux64.bin 
+sudo ./ColdFusion_2016_WWEJ_linux64.bin
+
+Step through installer. Make sure you select the internal web server (port 8500)
+
+Nginx
+
+Install Nginx on your server
+
+sudo apt-get install nginx
+
+https://riptutorial.com/
+
+4
+
+Edit your /etc/nginx/sites-available/default
+
+server { 
+    listen 80; 
+    server_name _; 
+
+    root /opt/coldfusion2016/cfusion/wwwroot; 
+    index index.cfm index.html index.htm; 
+
+    location / { 
+        try_files $uri $uri/ =404; 
+    } 
+
+    location ^~ /CFIDE/administrator { 
+        deny all; 
+    } 
+
+    location ~* \.(cfm|cfml|cfc|html)$ { 
+        include /etc/nginx/conf/dc_tomcat_connector.conf; 
+    } 
+
+    location ^~ /rest { 
+        include tomcatconf; 
+    } 
+}
+
+Edit /etc/nginx/tomcat.conf
+
+proxy_pass http://127.0.0.1:8500; 
+proxy_set_header Host $host; 
+proxy_set_header X-Forwarded-Host $host; 
+proxy_set_header X-Forwarded-Server $host; 
+proxy_set_header X-Forwarded-For $http_x_forwarded_for; 
+proxy_set_header X-Real-IP $remote_addr;
+
+Reload nginx
+
+sudo service nginx reload
+
+Access the Adobe ColdFusion Server admin here:
+
+127.0.0.1:8500/CFIDE/administrator/index.cfm
+
+Your root web directory lives here:
+
+/opt/coldfusion2016/cfusion/wwwroot
+
+Hello World
+
+File: test.cfm
+
+Tag Implementation
+
+https://riptutorial.com/
+
+5
+
+ 
+ 
+ 
+ 
+ 
+<cfoutput>Hello World!</cfoutput>
+
+CFScript Implementation
+
+<cfscript> 
+writeOutput("Hello World!"); 
+</cfscript>
+
+Read Getting started with coldfusion online: https://riptutorial.com/coldfusion/topic/913/getting-
+started-with-coldfusion
+
+https://riptutorial.com/
+
+6
+
+Chapter 2: CFLOOP How-To
+
+Remarks
+
+Big thanks to
+
+•
+•
+
+Pete Freitag for his CFScript Cheat Sheet
+Adam Cameron for CF 11: CFLOOP in CFScript is Very Broken (and it still is in CF 2016).
+
+Examples
+
+Looping through a collection using CFML tags.
+
+<!--- Define collection ---> 
+<cfset attributes = { 
+  "name": "Sales", 
+  "type": "text", 
+  "value": "Connection" 
+}> 
+
+<!--- 
+  cfloop tag with attribute collection can be used to 
+  loop through the elements of a structure 
+---> 
+<cfloop collection=#attributes# item="attribute"> 
+  <cfoutput> 
+    Key : #attribute#, Value : #attributes[attribute]# 
+  </cfoutput> 
+</cfloop>
+
+Looping through a collection using CFSCRIPT.
+
+<cfscript> 
+  /*define collection*/ 
+  attributes = { 
+    "name": "Sales", 
+    "type": "text", 
+    "value": "Connection" 
+  }; 
+  for(attribute in attributes){ 
+    /* attribute variable will contain the key name of each key value pair in loop */ 
+    WriteOutput('Key : ' & attribute & ', Value : ' & attributes[attribute] & '<br/>'); 
+  } 
+</cfscript>
+
+Index
+
+Parameters
+
+https://riptutorial.com/
+
+7
+
+ 
+Attribute Required Type
+
+Default Description
+
+index
+
+true
+
+string
+
+Variable name for the loop's index. Defaults to 
+the variables scope.
+
+from
+
+to
+
+true
+
+true
+
+numeric
+
+numeric
+
+Starting value for the index.
+
+Ending value for the index.
+
+step
+
+false
+
+numeric 1
+
+Value by which to increase or decrease the 
+index per iteration.
+
+Basic index loop
+
+Final value of x is 10.
+
+<!--- Tags ---> 
+<cfoutput> 
+    <cfloop index="x" from="1" to="10"> 
+        <li>#x#</li> 
+    </cfloop> 
+</cfoutput> 
+<!--- cfscript ---> 
+<cfscript> 
+    for (x = 1; x <= 10; x++) { 
+        writeOutput('<li>' & x & '</li>'); 
+    } 
+</cfscript> 
+<!--- HTML Output ---> 
+ - 1 
+ - 2 
+ - 3 
+ - 4 
+ - 5 
+ - 6 
+ - 7 
+ - 8 
+ - 9 
+ - 10
+
+Increase step to 2
+
+Final value of x is 11.
+
+<!--- Tags ---> 
+<cfoutput> 
+    <cfloop index="x" from="1" to="10" step="2"> 
+        <li>#x#</li> 
+    </cfloop> 
+</cfoutput> 
+<!--- cfscript ---> 
+<cfscript> 
+    for (x = 1; x <= 10; x += 2) { 
+
+https://riptutorial.com/
+
+8
+
+        writeOutput('<li>' & x & '</li>'); 
+    } 
+</cfscript> 
+<!--- HTML Output ---> 
+ - 1 
+ - 3 
+ - 5 
+ - 7 
+ - 9
+
+Decrement step by 1
+
+Final value of x is 0.
+
+<!--- Tags ---> 
+<cfoutput> 
+    <cfloop index="x" from="10" to="1" step="-1"> 
+        <li>#x#</li> 
+    </cfloop> 
+</cfoutput> 
+<!--- cfscript ---> 
+<cfscript> 
+    for (x = 10; x > 0; x--) { 
+        writeOutput('<li>' & x & '</li>'); 
+    } 
+</cfscript> 
+<!--- HTML Output ---> 
+ - 10 
+ - 9 
+ - 8 
+ - 7 
+ - 6 
+ - 5 
+ - 4 
+ - 3 
+ - 2 
+ - 1
+
+CFLoop in a Function
+
+Make sure to var or local scope the index inside a function. Foo() returns 11.
+
+<!--- var scope ---> 
+<cffunction name="foo" access="public" output="false" returntype="numeric"> 
+    <cfset var x = 0 /> 
+    <cfloop index="x" from="1" to="10" step="1"> 
+        <cfset x++ /> 
+    </cfloop> 
+    <cfreturn x /> 
+</cffunction> 
+
+<!--- Local scope ---> 
+<cffunction name="foo" access="public" output="false" returntype="numeric"> 
+    <cfloop index="local.x" from="1" to="10" step="1"> 
+        <cfset local.x++ /> 
+
+https://riptutorial.com/
+
+9
+
+ 
+    </cfloop> 
+    <cfreturn local.x /> 
+</cffunction>
+
+ColdFusion 11 through current
+
+The cfscript function cfloop has no support for index as a stand alone counter 
+mechanism.
+
+Condition
+
+Tag syntax
+
+Parameters
+
+Attribute Required Type Default Description
+
+Condition that manages the loop. Cannot contain 
+math symbols like <, > or =. Must use ColdFusion 
+text implementations like less than, lt, greater than
+, gt, equals or eq.
+
+condition
+
+true
+
+string
+
+Final value of x is 5.
+
+<cfset x = 0 /> 
+<cfoutput> 
+    <cfloop condition="x LT 5"> 
+        <cfset x++ /> 
+        <li>#x#</li> 
+    </cfloop> 
+</cfoutput>
+
+Generated HTML
+
+This will also have a line break between each line of HTML.
+
+<li>1</li> 
+<li>2</li> 
+<li>3</li> 
+<li>4</li> 
+<li>5</li>
+
+CFScript
+
+https://riptutorial.com/
+
+10
+
+Previous to ColdFusion 8
+
+<cfscript> 
+x = 0; 
+while (x LT 5) { 
+    x = x + 1; 
+    writeOutput('<li>' & x & '</li>'); 
+} 
+</cfscript>
+
+ColdFusion 8 through current
+
+<cfscript> 
+x = 0; 
+while (x LT 5) { 
+    x = x++; 
+    writeOutput('<li>' & x & '</li>'); 
+} 
+</cfscript>
+
+ColdFusion 11 through current
+
+The cfscript function cfloop has no support for condition.
+
+Generated HTML
+
+Notice that the cfscript output is all on one line.
+
+<li>one</li><li>two</li><li>three</li><li>four</li>
+
+Date or time range
+
+Example for date or time range.
+
+Query
+
+Consider the table dbo.state_zip, which contains the columns city, statecode and zipcode and has 
+over 80,000 records.
+
+Parameters
+
+Attribute Required Type
+
+Default Description
+
+query
+
+true
+
+string
+
+The variable name of a query object.
+
+startrow
+
+false
+
+numeric
+
+The starting row index of the query object.
+
+https://riptutorial.com/
+
+11
+
+Attribute Required Type
+
+Default Description
+
+endrow
+
+false
+
+numeric
+
+The ending row index of the query object.
+
+group
+
+false
+
+string
+
+The query column name on which to group 
+records.
+
+Example query
+
+<cfquery name="geo" datasource="reotrans-dev"> 
+    SELECT city, stateCode, zipCode 
+    FROM dbo.state_zip 
+</cfquery>
+
+Tag syntax
+
+Using the query object geo as the source for cfloop. Since the table dbo.state_zip has so many 
+records, the HTML generated will take quite some time. This example shows only the first 20 
+records' worth of HTML.
+
+<cfoutput> 
+    <ul> 
+    <cfloop query="geo"> 
+        <!--- Scope the column names with the query name. ---> 
+        <li>#geo.city# | #geo.stateCode# | #geo.zipCode#</li> 
+    </cfloop> 
+    </ul> 
+</cfoutput>
+
+Generated HTML
+
+<ul> 
+    <li>100 PALMS | CA | 92274</li> 
+    <li>1000 PALMS | CA | 92276</li> 
+    <li>12 MILE | IN | 46988</li> 
+    <li>1ST NATIONAL BANK OF OMAHA | NE | 68197</li> 
+    <li>29 PALMS | CA | 92277</li> 
+    <li>29 PALMS | CA | 92278</li> 
+    <li>3 STATE FARM PLAZA | IL | 61710</li> 
+    <li>3 STATE FARM PLAZA | IL | 61791</li> 
+    <li>30TH STREET | PA | 19104</li> 
+    <li>3M CORP | MN | 55144</li> 
+    <li>65TH INFANTRY | PR | 00923</li> 
+    <li>65TH INFANTRY | PR | 00924</li> 
+    <li>65TH INFANTRY | PR | 00929</li> 
+    <li>65TH INFANTRY | PR | 00936</li> 
+    <li>7 CORNERS | VA | 22044</li> 
+    <li>88 | KY | 42130</li> 
+    <li>9 MILE POINT | LA | 70094</li> 
+    <li>A A R P INS | PA | 19187</li> 
+    <li>A A R P PHARMACY | CT | 06167</li> 
+
+https://riptutorial.com/
+
+12
+
+    <li>A H MCCOY FEDERAL BLDG | MS | 39269</li> 
+</ul>
+
+Limiting output to specific rows
+
+To limit the query's output to a specific range of rows, specify startrow and endrow.
+
+<cfloop query="geo" startrow="100" endrow="150"> 
+    <li>#geo.city# | #geo.stateCode# | #geo.zipCode#</li> 
+</cfloop>
+
+Grouping Output
+
+In the example data, the same state listed multiple times in relation to the multiple cities that are 
+associated to each state. You can also see the same city listed multiple times in relation to the 
+multiple zip codes associated to each city.
+
+Let's group the output by state first. Notice the 2nd instance of cfloop wrapped around the content 
+that will be output under the stateCode grouped content.
+
+<cfoutput> 
+    <ul> 
+    <cfloop query="geo" group="stateCode"> 
+        <!--- Scope the column names with the query name. ---> 
+        <li>#geo.stateCode# 
+            <ul> 
+                <cfloop> 
+                    <li>#geo.city# | #geo.zipCode#</li> 
+                </cfloop> 
+            </ul> 
+        </li> 
+    </cfloop> 
+    </ul> 
+</cfoutput>
+
+Generated HTML (extract) from one grouped cfloop tag.
+
+<ul> 
+    <li>AK 
+        <ul> 
+            <li>KONGIGANAK | 99545</li> 
+            <li>ADAK | 99546</li> 
+            <li>ATKA | 99547</li> 
+            <!-- etc. --> 
+        </ul> 
+    </li> 
+    <li>AL 
+        <ul> 
+            <li>ALEX CITY | 35010</li> 
+            <li>ALEXANDER CITY | 35010</li> 
+            <li>ALEX CITY | 35011</li> 
+            <!-- etc. --> 
+        </ul> 
+
+https://riptutorial.com/
+
+13
+
+    </li> 
+    <!-- etc. --> 
+</ul>
+
+Finally, let's group the output by stateCode, then by city in order to see all the zipCode entries per 
+city. Notice the 2nd cfloop is now grouped by city and a 3rd cfloop exists to output the zipCode 
+data.
+
+<cfoutput> 
+    <ul> 
+    <cfloop query="geo" group="stateCode"> 
+        <li>#geo.stateCode# 
+            <ul> 
+            <cfloop group="city"> 
+                <li>#geo.city# 
+                    <ul> 
+                        <cfloop> 
+                            <li>#geo.zipCode#</li> 
+                        </cfloop> 
+                    </ul> 
+                </li> 
+            </cfloop> 
+            </ul> 
+        </li> 
+    </cfloop> 
+    </ul> 
+</cfoutput>
+
+Generated HTML (extract) from two grouped cfloop tags.
+
+<ul> 
+    <li>AK 
+        <ul> 
+            <li>ADAK 
+                <ul> 
+                    <li>99546</li> 
+                    <li>99571</li> 
+                </ul> 
+            </li> 
+            <li>AKHIOK 
+                <ul> 
+                    <li>99615</li> 
+                </ul> 
+            </li> 
+            <!--- etc. ---> 
+            <li>BARROW 
+                <ul> 
+                    <li>99723</li> 
+                    <li>99759</li> 
+                    <li>99789</li> 
+                    <li>99791</li> 
+                </ul> 
+            </li> 
+            <!--- etc. ---> 
+        </ul> 
+    </li> 
+    <!--- stateCodes etc. ---> 
+</ul>
+
+https://riptutorial.com/
+
+14
+
+CFScript
+
+ColdFusion 6 (MX) though current
+
+<cfscript> 
+    for (x = 1; x LTE geo.recordcount; x = x + 1) { 
+        writeOutput( '<li>' & geo.city[x] & ' | ' & 
+            geo.stateCode[x] & ' | ' & geo.zipCode[x] & '</li>'); 
+    } 
+</cfscript>
+
+ColdFusion 8 though current
+
+<cfscript> 
+    for (x = 1; x <= geo.recordcount; x++) { 
+        writeOutput( '<li>' & geo.city[x] & ' | ' & 
+            geo.stateCode[x] & ' | ' & geo.zipCode[x] & '</li>'); 
+    } 
+</cfscript>
+
+ColdFusion 10 though current
+
+With the FOR IN syntax, x is a query row object, not the row index.
+
+<cfscript> 
+    for (x in geo) { 
+        writeOutput( '<li>' & x.city & ' | ' & 
+            x.stateCode & ' | ' & x.zipCode & '</li>'); 
+    } 
+</cfscript>
+
+ColdFusion 11 though current
+
+ColdFusion 11 allows most tags to be written as cfscript.
+
+<cfscript> 
+    cfloop(query: geo, startrow: 1, endrow: 2) { 
+        writeOutput( '<li>' & geo.city & ' | ' & 
+            geo.stateCode & ' | ' & geo.zipCode & '</li>'); 
+    } 
+</cfscript>
+
+With group.
+
+<cfscript> 
+    cfloop(query: geo, group: 'city') { 
+        writeOutput( '<li>' & geo.city & '<ul>'); 
+        cfloop() { // no arguments, just as in the tag syntax. 
+
+https://riptutorial.com/
+
+15
+
+            writeOutput('<li>'  & geo.zipCode & '</li>'); 
+        } 
+        writeOutput('</ul></li>'); 
+    } 
+</cfscript>
+
+List
+
+Consider this list:
+
+<cfset foo = "one,two,three,four" />
+
+Tag syntax
+
+Parameters
+
+Attribute Required Default Description
+
+list
+
+true
+
+A list object. The variable must be evaluated (wrapped with 
+##)
+
+index
+
+true
+
+The current element of the list.
+
+<cfoutput> 
+    <cfloop list="#foo#" index="x"> 
+        <li>#x#</li> 
+    </cfloop> 
+</cfoutput>
+
+Generated HTML
+
+This will also have a line break between each line of HTML.
+
+<li>one</li> 
+<li>two</li> 
+<li>three</li> 
+<li>four</li>
+
+CFScript
+
+Previous to ColdFusion 8
+
+<cfscript> 
+    for (x = 1; x LTE listLen(foo); x = x + 1) { 
+        writeOutput("<li>" & listGetAt(foo, x) & "</li>"); 
+
+https://riptutorial.com/
+
+16
+
+    } 
+</cfscript>
+
+ColdFusion 8 through current
+
+<cfscript> 
+    for (x = 1; x <= listLen(foo); x++) { 
+        writeOutput("<li>" & listGetAt(foo, x) & "</li>"); 
+    } 
+</cfscript>
+
+ColdFusion 9 through current
+
+<cfscript> 
+    for (x in foo) { 
+        writeOutput("<li>" & x & "</li>"); 
+    } 
+</cfscript>
+
+ColdFusion 11 through current
+
+The cfscript function cfloop has no support for list.
+
+Generated HTML
+
+Notice that the cfscript output is all on one line.
+
+<li>one</li><li>two</li><li>three</li><li>four</li>
+
+Array
+
+The ability to directly use an array object with cfloop was added in ColdFusion 8.
+
+Consider this array;
+
+<cfset aFoo = [ 
+    "one" 
+    , "two" 
+    , "three" 
+    , "four" 
+] />
+
+Tag syntax
+
+ColdFusion 8 through current
+
+https://riptutorial.com/
+
+17
+
+Using the attribute index by itself.
+
+Parameters
+
+Attribute Required Default Description
+
+array
+
+true
+
+An array object. The variable must be evaluated (wrapped 
+with ##)
+
+index
+
+true
+
+The current element of the array.
+
+<cfoutput> 
+    <cfloop array="#aFoo#" index="x"> 
+        <li>#x#</li> 
+    </cfloop> 
+</cfoutput>
+
+Generated HTML
+
+This will also have a line break between each line of HTML.
+
+<li>one</li> 
+<li>two</li> 
+<li>three</li> 
+<li>four</li>
+
+ColdFusion 2016 through current
+
+The attribute item changes the behavior of cfloop as of Coldfusion 2016.
+
+Using the attribute item instead of or in addition to index.
+
+Parameters
+
+Attribute Required Default Description
+
+array
+
+true
+
+An array object. The variable must be evaluated (wrapped 
+with ##)
+
+item
+
+true
+
+The current element of the array.
+
+index
+
+false
+
+The current index of the array.
+
+<cfoutput> 
+    <cfloop array="#aFoo#" item="x" index="y"> 
+        <li>#x# | #y#</li> 
+    </cfloop> 
+</cfoutput>
+
+https://riptutorial.com/
+
+18
+
+Generated HTML
+
+This will also have a line break between each line of HTML.
+
+<li>one | 1</li> 
+<li>two | 2</li> 
+<li>three | 3</li> 
+<li>four | 4</li>
+
+CFScript
+
+Previous to ColdFusion 8
+
+<cfscript> 
+for (i = 1; x LTE arrayLen(aFoo); i = i + 1) { 
+    writeOutput("<li>" & aFoo[i] & "</li>"); 
+} 
+</cfscript>
+
+ColdFusion 8 through current
+
+<cfscript> 
+for (i = 1; i <= arrayLen(aFoo); i = i++) { 
+    writeOutput("<li>" & aFoo[i] & "</li>"); 
+} 
+</cfscript>
+
+ColdFusion 9 through current
+
+With the FOR IN syntax, x is the current array element, not the array index.
+
+<cfscript> 
+for (x in aFoo) { 
+    writeOutput("<li>" & x & "</li>"); 
+} 
+</cfscript>
+
+ColdFusion 11 through current
+
+The cfscript function cfloop has no support for array.
+
+Generated HTML
+
+Notice that the cfscript output is all on one line.
+
+https://riptutorial.com/
+
+19
+
+<li>one</li><li>two</li><li>three</li><li>four</li>
+
+File
+
+<cfloop list="#myFile#" index="FileItem" delimiters="#chr(10)##chr(13)#"> 
+  <cfoutput> 
+   #FileItem#<br /> 
+ </cfoutput> 
+</cfloop>
+
+Structure
+
+Consider this structure:
+
+<cfset stFoo = { 
+    a = "one" 
+    , b = "two" 
+    , c = "three" 
+    , d = "foue" 
+} />
+
+Tag syntax
+
+Parameters
+
+Notice the use of the attribute item instead of index.
+
+Attribute Required Type
+
+Default Description
+
+collection true
+
+structure
+
+A struct object. The variable must be evaluated 
+(wrapped with ##).
+
+item
+
+true
+
+string
+
+The current structure key,
+
+Using Structure Functions
+
+<cfoutput> 
+    <cfloop collection="#stFoo#" item="x"> 
+        <li>#structFind(stFoo, x)#</li> 
+    </cfloop> 
+</cfoutput>
+
+Implicit Structure Syntax
+
+<cfoutput> 
+    <cfloop collection="#stFoo#" item="x"> 
+
+https://riptutorial.com/
+
+20
+
+        <li>#stFoo[x]#</li> 
+    </cfloop> 
+</cfoutput>
+
+Generated HTML
+
+This will also have a line break between each line of HTML.
+
+<li>one</li> 
+<li>two</li> 
+<li>three</li> 
+<li>four</li>
+
+CFScript
+
+With the FOR IN syntax, x is a key of the structure object.
+
+Output the structure's keys
+
+<cfscript> 
+    for (x in stFoo) { 
+        writeOutput("<li>" & x & "</li>"); 
+    } 
+</cfscript>
+
+Generated HTML
+
+<li>A</li><li>B</li><li>C</li><li>D</li>
+
+Output the value of the structure's keys
+
+Using Structure Functions
+
+<cfscript> 
+    for (x in stFoo) { 
+        writeOutput("<li>" & structFind(stFoo, x) & "</li>"); 
+    } 
+</cfscript>
+
+Implicit Structure Syntax
+
+<cfscript> 
+    for (x in stFoo) { 
+        writeOutput("<li>" & stFoo[x] & "</li>"); 
+    } 
+</cfscript>
+
+https://riptutorial.com/
+
+21
+
+ColdFusion 11 through current
+
+The cfscript function cfloop has no support for collection.
+
+Generated HTML
+
+Notice that the cfscript output is all on one line.
+
+<li>one</li><li>two</li><li>three</li><li>four</li>
+
+Index Loop
+
+Use the from and to attributes to specify how many iterations should occur. The (optional) step 
+attribute allows you to determine how big the increments will be.
+
+<cfloop from="1" to="10" index="i" step="2"> 
+    <cfoutput> 
+        #i#<br /> 
+    </cfoutput> 
+</cfloop>
+
+Conditional Loop
+
+You use the condition attribute to specify the condition to use.
+
+<cfset myVar=false> 
+<cfloop condition="myVar eq false"> 
+    <cfoutput> 
+    myVar = <b>#myVar#</b>  (still in loop)<br /> 
+ </cfoutput> 
+    <cfif RandRange(1,10) eq 10> 
+        <cfset myVar="true"> 
+    </cfif> 
+</cfloop> 
+<cfoutput> 
+    myVar = <b>#myVar#</b> (loop has finished) 
+</cfoutput>
+
+Query Loop
+
+You can loop over the results of a ColdFusion query.
+
+<cfquery name="getMovies" datasource="Entertainment"> 
+    select top 4 movieName 
+    from Movies 
+</cfquery> 
+<cfloop query="getMovies"> 
+    #movieName# 
+</cfloop>
+
+https://riptutorial.com/
+
+22
+
+List Loop
+
+You can use the (optional) delimiters attribute to specify which characters are used as separators 
+in the list.
+
+<cfloop list="ColdFusion,HTML;XML" index="ListItem" delimiters=",;"> 
+    <cfoutput> 
+        #ListItem#<br /> 
+    </cfoutput> 
+</cfloop>
+
+File Loop
+
+You can loop over a file.
+
+<cfloop file="#myFile#" index="line"> 
+    <cfoutput> 
+        #line#<br /> 
+    </cfoutput> 
+</cfloop>
+
+COM Collection/Structure Loops
+
+You can loop over a Structure or COM collection.
+
+<cfset myBooks = StructNew()> 
+<cfset myVariable = StructInsert(myBooks,"ColdFusion","ColdFusion MX Bible")> 
+<cfset myVariable = StructInsert(myBooks,"HTML","HTML Visual QuickStart")> 
+<cfset myVariable = StructInsert(myBooks,"XML","Inside XML")> 
+<cfloop collection="#myBooks#" item="subject"> 
+    <cfoutput> 
+        <b>#subject#:</b> #StructFind(myBooks,subject)#<br /> 
+    </cfoutput> 
+</cfloop>
+
+Read CFLOOP How-To online: https://riptutorial.com/coldfusion/topic/3035/cfloop-how-to
+
+https://riptutorial.com/
+
+23
+
+Chapter 3: cfquery
+
+Parameters
+
+Parameter Details
+
+name
+
+Value: string, Default: yes
+
+dbtype
+
+Value: query/hql, Default: no, Remarks: when left blank, it's a normal query
+
+datasource Default: no, Remarks: database
+
+params
+
+Value: structure, Default: no, Remarks: cfscript syntax only! In cfml they are 
+written inside SLQ stament using <cfqueryparam />
+
+Examples
+
+Using cfquery within a Function
+
+<cffunction name="getUserById" access="public" returntype="query"> 
+    <cfargument name="userId" type="numeric" required="yes" hint="The ID of the user"> 
+
+    <cfquery name="local.qryGetUser" datasource="DATABASE_NAME"> 
+         SELECT  id, 
+                 name 
+         FROM    user 
+         WHERE   id = <cfqueryparam value="#arguments.userId#" cfsqltype="cf_sql_integer"> 
+    </cfquery> 
+
+    <cfreturn local.qryGetUser> 
+</cffunction>
+
+Query of Query
+
+Function Calls
+
+<!--- Load the user object based on the component path. ---> 
+<cfset local.user = new com.User() /> 
+<cfset local.allUsers = user.getAllUsers()> 
+<cfset local.specificUser = user.getUserIdFromQry(qry = local.allUsers, userId = 1)> 
+
+User.cfc
+
+<cfcomponent> 
+    <cffunction name="getAllUsers" access="public" returntype="query"> 
+        <cfquery name="local.qryGetAllUsers" datasource="DATABASE_NAME"> 
+
+https://riptutorial.com/
+
+24
+
+ 
+ 
+            SELECT  id, 
+                    name 
+            FROM    user 
+        </cfquery> 
+
+        <cfreturn local.qryGetAllUsers> 
+    </cffunction> 
+
+    <cffunction name="getUserIdFromQry" access="public" returntype="query"> 
+        <cfargument name="qry" type="query" required="Yes" hint="Query to fetch from"> 
+        <cfargument name="userId" type="numeric" required="Yes" hint="The ID of the user"> 
+
+        <cfquery name="local.qryGetUserIdFromQry" dbtype="query"> 
+            SELECT  id, 
+                    name 
+            FROM    arguments.qry 
+            WHERE   id = <cfqueryparam value="#arguments.userId#" cfsqltype="cf_sql_integer"> 
+        </cfquery> 
+
+        <cfreturn local.qryGetUserIdFromQry> 
+    </cffunction> 
+</component>
+
+Read cfquery online: https://riptutorial.com/coldfusion/topic/6452/cfquery
+
+https://riptutorial.com/
+
+25
+
+ 
+ 
+ 
+ 
+Chapter 4: ColdFusion Arrays
+
+Syntax
+
+•
+
+ArrayNew(dimension, isSynchronized)
+
+Parameters
+
+Name
+
+Description
+
+Dimension
+
+Number of dimensions in new array: 1, 2, or 3
+
+isSynchronized
+
+When false, creates an unsynchronized array, When true, the function 
+returns a synchronized array.
+
+Remarks
+
+In a synchronized array, more than two threads cannot access the array simultaneously. Other 
+threads has to wait until the active thread completes its job, resulting in significant performance.
+
+In 2016 ColdFusion release, you can use an unsynchronized array and let multiple threads access 
+the same array object simultaneously.
+
+Examples
+
+Creating Arrays
+
+Creating arrays explicitly using ArrayNew()
+
+Declare an array with the ArrayNew function. Specify the number of dimensions as an argument.
+
+•
+•
+•
+
+ArrayNew(dimension) creates an array of 1–3 dimensions.
+ColdFusion arrays expand dynamically as data is added.
+ArrayNew() returns an array.
+
+History
+
+Introduced in ColdFusion MX 6
+
+Declaration
+
+CFML
+
+https://riptutorial.com/
+
+26
+
+<!--- One Dimension Array---> 
+<cfset oneDimensionArray = ArrayNew(1)>
+
+CFScript Note that inside a function you should use var scoping. Earlier versions of CF required 
+var scoping to be the first thing in a function; later versions allow it anywhere in a function.
+
+<cfscript> 
+    oneDimensionArray = ArrayNew(1); 
+
+    public void function myFunc() { 
+        var oneDimensionArray = ArrayNew(1); 
+    } 
+</cfscript>
+
+After creating the array, add elements by using the element indexes. The Coldfusion Array index 
+starts from 1:
+
+CFML
+
+<cfset oneDimensionArray[1] = 1> 
+<cfset oneDimensionArray[2] = 'one'> 
+<cfset oneDimensionArray[3] = '1'>
+
+CFScript
+
+<cfscript> 
+    oneDimensionArray[1] = 1; 
+    oneDimensionArray[2] = 'one'; 
+    oneDimensionArray[3] = '1'; 
+</cfscript>
+
+Using ArrayAppend()
+
+You can add elements to an array using the function ArrayAppend(array, value).
+
+<cfscript> 
+    ArrayAppend(oneDimensionArray, 1); 
+    ArrayAppend(oneDimensionArray, 'one'); 
+    ArrayAppend(oneDimensionArray, '1'); 
+</cfscript>
+
+Output the array contents using <cfdump>:
+
+<cfdump var="#oneDimensionArray#">
+
+Results:
+
+https://riptutorial.com/
+
+27
+
+ 
+CFML
+
+<!--- Two Dimension Array---> 
+<cfset twoDimensionArray = ArrayNew(2)> 
+<cfset twoDimensionArray[1][1] = 1> 
+<cfset twoDimensionArray[1][2] = 2> 
+<cfset twoDimensionArray[2][1] = 3> 
+<cfset twoDimensionArray[2][2] = 4>
+
+CFScript
+
+<cfscript> 
+    twoDimensionArray = ArrayNew(2); 
+
+    twoDimensionArray[1][1] = 1; 
+    twoDimensionArray[1][2] = 2; 
+    twoDimensionArray[2][1] = 3; 
+    twoDimensionArray[2][2] = 4; 
+</cfscript>
+
+Outputting the contents of array using <cfdump>
+
+<cfdump var="#twoDimensionArray#">
+
+Result:
+
+Each element contains another Array, which will store the values.
+
+Creating 1-D Array Implicitly
+
+When creating an array implicitly, brackets ([]) surround the array contents with comma 
+separators.
+
+<cfset oneDimensionArrayImplicit = [ 1 ,'one','1' ]>
+
+https://riptutorial.com/
+
+28
+
+ 
+This statement is equivalent to the four statements used to create the above oneDimensionArray. 
+The result are the same when using:
+
+<cfdump var="#oneDimensionArrayImplicit#">
+
+Create 2-D Array Implicitly
+
+<cfset twoDimensionArrayImplicit = [[ 1 , 2 ],[ 3 , 4 ],[ 5 , 6 ]]>
+
+Or:
+
+<cfset firstElement = ["1", "2"]> 
+<cfset secondElement= ["3", "4"]> 
+<cfset thirdElement = ["5", "6"]> 
+<cfset twoDimensionArrayImplicit = [firstElement , secondElement, thirdElement]>
+
+Outputting the content using
+
+<cfdump var="#twoDimensionArrayImplicit#">
+
+Alternative Explicit Declaration
+
+Also you can declare 1 Dimension Array as
+
+<cfset oneDimensionArray = []> 
+
+<cfscript> 
+    oneDimensionArray = []; 
+</cfscript>
+
+This declaration is same as that of using ArrayNew(1).
+
+But if you try declaring 2 Dimension Array as
+
+<cfset twoDimensionArray =[][]>    //Invalid CFML construct
+
+https://riptutorial.com/
+
+29
+
+ 
+an error will occur while processing this request.
+
+Following statement will process the request:
+
+<cfset twoDimensionArray =[]>
+
+but variable twoDimensionArray will not actually an Array within Array (or 2-Dimension Array). It 
+actually contains structure within Array.
+
+<cfset twoDimensionArray =[]> 
+<cfset twoDimensionArray[1][1] = 1> 
+<cfset twoDimensionArray[1][2] = 2> 
+<cfset twoDimensionArray[2][1] = 3> 
+<cfset twoDimensionArray[2][2] = 4> 
+
+<cfdump var="#twoDimensionArray#">
+
+Result:
+
+Array in CFScript
+
+<cfscript> 
+    oneDimensionArray = ArrayNew(1); 
+    oneDimensionArray[1] = 1; 
+    oneDimensionArray[2] = 'one'; 
+    oneDimensionArray[3] = '1'; 
+</cfscript> 
+
+<cfif IsDefined("oneDimensionArray")> 
+    <cfdump var="#oneDimensionArray#"> 
+</cfif>
+
+Result:
+
+Also, we can declare an one Dimension Array as:
+
+https://riptutorial.com/
+
+30
+
+ 
+ 
+oneDimensionArray = [];
+
+Alternatively, CF introduced WriteDump() from CF9 as a function equivalent to the <cfdump> tag 
+which can be used in <cfscript>.
+
+<cfscript> 
+    WriteDump(oneDimensionArray); 
+</cfscript>
+
+Similarly, for 2 Dimension Array:
+
+<cfscript> 
+    twoDimensionArray = ArrayNew(2); 
+    twoDimensionArray[1][1] = 1; 
+    twoDimensionArray[1][2] = 2; 
+    twoDimensionArray[2][1] = 3; 
+    twoDimensionArray[2][2] = 4; 
+</cfscript> 
+<cfdump var="#twoDimensionArray#">
+
+Result:
+
+General information
+
+First some general information about how arrays behave in Coldfusion as compared to other 
+programming languages.
+
+•
+
+•
+•
+
+Arrays can have numeric indexes only (if you want to have a string index use structs 
+instead)
+Arrays begin at index [1]
+Arrays can have one ore more dimensions
+
+Read ColdFusion Arrays online: https://riptutorial.com/coldfusion/topic/6896/coldfusion-arrays
+
+https://riptutorial.com/
+
+31
+
+Chapter 5: Creating REST APIs in coldfusion
+
+Introduction
+
+REST APIs are interesting when data should be accessed from everywhere including different 
+languages (server and client side). That requires separation from data and processing.
+
+Examples
+
+Creating backend
+
+<cfcomponent displayname="myAPI" output="false"> 
+    <cffunction name="init" access="public" output="no"> 
+        <!--- do some basic stuff ---> 
+        <cfreturn this> 
+    </cffunction> 
+
+    <cffunction name="welcome"> 
+        <cfreturn "Hello World!"> 
+    </cffunction> 
+</cfcomponent>
+
+The interface
+
+<cfscript> 
+    api_request = GetHttpRequestData(); 
+    api = createObject("component","myAPI").init(); 
+</cfscript> 
+
+<cfif api_request.method is 'GET'> 
+    <cfoutput>#api.welcome()#</cfoutput> 
+<cfelseif api_request.method is 'POST'> 
+    <cfheader statuscode="500" statustext="Internal Server Error" /> 
+</cfif>
+
+Read Creating REST APIs in coldfusion online: 
+https://riptutorial.com/coldfusion/topic/10698/creating-rest-apis-in-coldfusion
+
+https://riptutorial.com/
+
+32
+
+ 
+ 
+Chapter 6: Database Queries
+
+Examples
+
+Working with databases
+
+One of ColdFusion's strengths is how easy it is to work with databases. And of course, query 
+inputs can and should be parameterized.
+
+Tag Implementation
+
+<cfquery name="myQuery" datasource="myDatasource" result="myResult"> 
+    select firstName, lastName 
+    from users 
+    where lastName = <cfqueryparam value="Allaire" cfsqltype="cf_sql_varchar"> 
+</cfquery>
+
+CFScript Implementation
+
+// ColdFusion 9+ 
+var queryService = new query(name="myQuery", datasource="myDatasource"); 
+queryService.addParam(name="lName", value="Allaire", cfsqltype="cf_sql_varchar"); 
+var result = queryService.execute(sql="select firstName, lastName from users where lastName = 
+:lName"); 
+var myQuery = result.getResult(); 
+var myResult = result.getPrefix(); 
+
+// ColdFusion 11+ 
+var queryParams = {lName = {value="Allaire", cfsqltype="cf_sql_varchar"}}; 
+var queryOptions = {datasource="myDatasource", result="myResult"}; 
+var myQuery = queryExecute("select firstName, lastName from users", queryParams, 
+queryOptions);
+
+Inserting values is just as easy:
+
+queryExecute(" 
+    insert into user( firstname, lastname ) 
+    values( :firstname, :lastname ) 
+",{ 
+    firstname: { cfsqltype: "cf_sql_varchar", value: "Dwayne" } 
+    ,lastname: { cfsqltype: "cf_sql_varchar", value: "Camacho" } 
+},{ 
+    result: "local.insertResult" 
+}); 
+
+return local.insertResult.generated_key;
+
+Basic Example
+
+Database connections are set up using the CF Administrator tool. See Database Connections for 
+how to connect a datasource.
+
+https://riptutorial.com/
+
+33
+
+ 
+ 
+To execute queries all you need is the <cfquery> tag. The <cfquery> tag connects to and opens the 
+database for you, all you need to do is supply it with the name of the datasource.
+
+<cfquery name="Movies" datasource="Entertainment"> 
+    SELECT title 
+    FROM   Movies 
+</cfquery>
+
+To display the query results:
+
+<cfoutput query="Movies"> 
+    #title#<BR> 
+</cfoutput>
+
+Authentication
+
+Many database configurations require authentication (in the form of a username and password) 
+before you can query the database. You can supply these using the username and password 
+attributes.
+
+Note: the username and password can also be configured against the datasource in the 
+ColdFusion Administrator. Supplying these details in your query overrides the username and 
+password in the ColdFusion Administrator.
+
+<cfquery datasource="Entertainment" username="webuser" password="letmein"> 
+    select * 
+    from Movies 
+</cfquery>
+
+Cached Queries
+
+A cached query is a query that has its results stored in the server's memory. The results are 
+stored when the query is first run. From then on, whenever that query is requested again, 
+ColdFusion will retrieve the results from memory.
+
+You can cache a query using the cachedAfter attribute. If the query was last run after the supplied 
+date, cached data is used. Otherwise the query is re-run.
+
+<cfquery datasource="Entertainment" cachedAfter="July 20, 2016"> 
+    select * 
+    from Movies 
+</cfquery>
+
+In order for the cache to be used, and multiple calls to the database be avoided the current query 
+must use the same SQL statement, data source, query name, user name, and password as the 
+cached query used. This includes whitespace in the query.
+
+As such the following queries create different caches, even though the trimmed characters are the 
+same and the query results are identical:
+
+https://riptutorial.com/
+
+34
+
+<cfquery datasource="Entertainment" cachedAfter="July 20, 2016"> 
+    select * 
+    from Movies 
+    <cfif false> 
+    where 1 = 1 
+    </cfif> 
+    <cfif true> 
+    where 1 = 1 
+    </cfif> 
+</cfquery> 
+
+<cfquery datasource="Entertainment" cachedAfter="July 20, 2016"> 
+    select * 
+    from Movies 
+    <cfif true> 
+    where 1 = 1 
+    </cfif> 
+    <cfif false> 
+    where 1 = 1 
+    </cfif> 
+</cfquery>
+
+Limiting the Number of Records Returned
+
+You can limit the number of rows to be returned by using the maxrows attribute.
+
+<cfquery datasource="Entertainment" maxrows="50"> 
+    select * 
+    from Movies 
+</cfquery>
+
+Timeouts
+
+You can set a timeout limit using the timeout attribute. This can be useful in preventing requests 
+running far longer than they should and impacting on the whole application as a result.
+
+The timeout attribute sets the maximum number of seconds that each action of a query is allowed 
+to execute before returning an error.
+
+<cfquery datasource="Entertainment" timeout="30"> 
+    select * 
+    from Movies 
+</cfquery>
+
+Read Database Queries online: https://riptutorial.com/coldfusion/topic/4582/database-queries
+
+https://riptutorial.com/
+
+35
+
+ 
+Chapter 7: How to invoke a private method 
+dynamically
+
+Remarks
+
+Use of <cfinvoke> or invoke() should be faster than evaluate()
+
+Examples
+
+CFML
+
+<cfinvoke method="#somePrivateMethodName#"> 
+  <cfinvokeargument name="argument1" value="one"> 
+</cfinvoke>
+
+CFSCRIPT (CF10+)
+
+invoke("", somePrivateMethodName, {argument1='one'});
+
+Read How to invoke a private method dynamically online: 
+https://riptutorial.com/coldfusion/topic/6110/how-to-invoke-a-private-method-dynamically
+
+https://riptutorial.com/
+
+36
+
+Chapter 8: Scopes in Coldfusion
+
+Introduction
+
+A scope is "the range in which a variable can be referenced". ColdFusion knows — as well as 
+most other programming and script languages — several scopes. The following text deals with 
+these types and trys to bring clarity about them, their differences and their characteristics.
+
+Examples
+
+Request Scopes
+
+request
+
+variables
+
+form
+
+url
+
+cgi
+
+Global Scopes
+
+Server
+
+Application
+
+Session
+
+Components and functions
+
+variables
+
+this
+
+local
+
+arguments
+
+Custom tags
+
+attributes
+
+thisTag
+
+caller
+
+https://riptutorial.com/
+
+37
+
+Common scopes
+
+Mostly you're probably working with these scopes:
+
+•
+
+•
+
+•
+•
+•
+
+•
+
+Variables scopeis the scope where all variables are assigned to when nothing else is 
+intentionally declared (like the window scope in JavaScript).
+Form scopeWhen you send a form to your server, all the form fields which can be identified 
+(by setting the name/id property) are accessible in this scope for further server-side 
+processing.
+URL scopeAll url query params are stored in that scope
+this scopeInside a component the this refers to the component itself
+local scopeVariables declared inside a function using the local statement are encapsulated 
+and only accessible inside that specific function (this is made to avoid pollution of other 
+sopes)
+Arguments scopeArguments passed to a function inside a component declared by the 
+cfargument tag are accessible with that scope
+
+Overview
+
+•
+
+Components and functions
+
+○
+
+○
+
+○
+
+○
+
+variables
+this
+local
+arguments
+
+•
+
+Custom tags
+
+○
+
+○
+
+○
+
+attributes
+thisTag
+caller
+
+•
+
+Global Scopes
+
+○
+
+○
+
+○
+
+Server
+Application
+Session
+
+•
+
+Request Scopes
+
+○
+
+○
+
+○
+
+○
+
+○
+
+request
+variables
+form
+url
+cgi
+
+Read Scopes in Coldfusion online: https://riptutorial.com/coldfusion/topic/7864/scopes-in-
+coldfusion
+
+https://riptutorial.com/
+
+38
+
+Chapter 9: Variables
+
+Parameters
+
+Attribute Description
+
+name
+
+(Required) Name of the parameter/variable.
+
+default
+
+(Optional) Value to set parameter to if it does not exist.
+
+max
+
+min
+
+(Optional) The maximum valid value; used only for range validation.
+
+(Optional) The minimum valid value; used only for range validation.
+
+pattern
+
+(Optional) A JavaScript regular expression that the parameter must match; used 
+only for regex or regular_expression validation.
+
+type
+
+(Optional) The valid format for the data.
+
+Examples
+
+Using cfset
+
+You can set a ColdFusion variable using the <cfset> tag. To output the variable, you need to 
+surround the variable name with hash # symbols and enclose it within <cfoutput> tags.
+
+<cfset variablename="World!"> 
+<cfoutput> 
+    Hello #variablename# 
+</cfoutput>
+
+Using cfparam
+
+The <cfparam> tag creates a variable if it does not already exist. You can assign a default value 
+using the default attribute. This can be used if you want to create a variable, but don't want to 
+overwrite it if it has been previously created elsewhere.
+
+Here the variable hasn't been set previously, so it will be assigned with the <cfparam> tag.
+
+<cfparam name="firstName" default="Justin"> 
+<cfoutput> 
+    Hello #firstName# 
+</cfoutput>
+
+Here the variable has already been assigned using the <cfset> tag, so this value will override the 
+default value in the <cfparam> tag.
+
+https://riptutorial.com/
+
+39
+
+<cfset firstname="Justin"> 
+
+<cfparam name="firstName" default="Barney"> 
+<cfoutput> 
+    Hello #firstName# 
+</cfoutput>
+
+Checking if a Variable Exists
+
+You can check if a variable has been defined in a scope by using ColdFusion's built in 
+StructKeyExists() function. This can be used inside a <cfif> tag to prevent error messages in the 
+event you attempt to refer to a variable that does not exist. You can also use this function to 
+determine whether a user has performed a certain action or not. The syntax for the function is
+
+StructKeyExists(structure, "key")
+
+The following example checks if the variable firstName exists in the variables scope.
+
+<cfif StructKeyExists(variables, "firstName")> 
+    Hello #variables.firstname#! 
+<cfelse> 
+    Hello stranger! 
+</cfif>
+
+Alternatively, you may use the function:
+
+isDefined("scopeName.varName")
+
+To avoid ambiguity, it is recommended to declare the scope. For example, If you have a variable 
+in the scope test
+
+<cfset test.name = "Tracy" />
+
+and you test for name in the global scope, you will get a result of true.
+
+isDefined("name") <!--- true ---> 
+isDefined("x.name") <!--- false---> 
+isDefined("test.name") <!--- true --->
+
+Setting a variable scope
+
+It is a common practice to set application variables to an object scope. This keeps them easy to 
+identify and distinguish from variables in other scopes.
+
+The Variables scope in a CFC is private to the CFC. When you set variables in this scope, they 
+cannot be seen by pages that invoke the CFC.
+
+<cfparam name="variables.firstName" default="Timmy"> 
+<cfset variables.firstName="Justin">
+
+https://riptutorial.com/
+
+40
+
+ 
+Scopes shared with the calling page include: Form, URL, Request, CGI, Cookie, Client, Session, 
+Application, Server, and Flash. Variables in these scopes are also available to all pages that are 
+included by a CFC.
+
+CFC:
+
+<cfset url.sessionId="23b5ly17"> 
+
+<cfinclude template="check_session.cfm">
+
+check_session.cfm
+
+<cfif url.sessionId eq "23b5ly17"> 
+    <p>Welcome back!</p> 
+</cfif>
+
+Read Variables online: https://riptutorial.com/coldfusion/topic/4904/variables
+
+https://riptutorial.com/
+
+41
+
+ 
+Chapter 10: Working with RegExp Replace 
+callbacks
+
+Introduction
+
+If you want more than a simple string replacement with common regular expressions you certainly 
+run into trouble and hit the wall when discovering the limits of the regex functions Coldfusion has. 
+There is no build-in function like php's preg_replace_callback.
+
+Parameters
+
+Parameter Details
+
+re
+
+str
+
+The regular expression
+
+The string which should be applyed the the regex
+
+callback
+
+The function where the captured grouped will be passed in if a match was 
+found. There the matches can be processed
+
+Remarks
+
+Because Coldfusion itself does not offer what we want, we make recourse to the variety of Java, 
+which is — as we all know — on top of Coldfusion. Java offers us java.util.regex.Pattern.
+
+So here is what we actually do:
+
+1. 
+
+2. 
+
+3. 
+
+Invoke the Compile method from the Pattern Class object and passing the regex pattern to it 
+(which probably deposits the regex pattern for later use).
+Invoke the Matcher method on what the Compile method returned and passing the string 
+where the pattern should be executed.
+Test if matching was successfull by invoking the find method on what the Matcher method 
+returned.
+
+If matcher.find() returns true, we could say "That's it", but there is one little thing we have to 
+consider: Java's Pattern object stores the groups and gives us access via another function, which 
+is not always the best way for further processing and not that consistent regarding how other 
+programming languages handle this case. Therefore we loop over matcher.group() so that we can 
+pass an array containing the captured groups to the callback function. And now we can say: 
+"That's it!"
+
+Examples
+
+https://riptutorial.com/
+
+42
+
+User defined REReplaceCallback function
+
+function REReplaceCallback(re,str,callback) { 
+    /* 
+        Thanks to Ben Nadel 
+        "Learning ColdFusion 8: REMatch() For Regular Expression Matching" 
+        from 2007-06-13 
+        https://www.bennadel.com/blog/769-learning-coldfusion-8-rematch-for-regular-
+expression-matching.htm 
+    */ 
+    pattern = CreateObject("java","java.util.regex.Pattern").Compile(Arguments.re); 
+    matcher = pattern.Matcher(Arguments.str); 
+    if(matcher.find()) { 
+        groups = []; 
+        for(var i = 1; i lte matcher.groupCount(); i++) { 
+            ArrayAppend(groups,matcher.group(Val(i))); 
+        } 
+        return Arguments.callback(groups); 
+    } 
+    else { 
+        return Arguments.callback(false); 
+    } 
+}
+
+Using REReplaceCallback function
+
+REReplaceCallback('YOUR REGEX GOES HERE','AND YOUR STRING HERE',function(groups) { 
+    //now you can access the 'groups' array containing all the captured groups 
+    return result; //return whatever you've processed inside 
+});
+
+Read Working with RegExp Replace callbacks online: 
+https://riptutorial.com/coldfusion/topic/10655/working-with-regexp-replace-callbacks
+
+https://riptutorial.com/
+
+43
+
+Credits
+
+S. 
+No
+
+1
+
+2
+
+3
+
+4
+
+5
+
+6
+
+7
+
+8
+
+9
+
+Chapters
+
+Contributors
+
+Getting started with 
+coldfusion
+
+Adam Tuttle, Adrian J. Moreno, Community, Justin Duhaime, 
+mhatch, RamenChef, shaedrich, Steven Benjamin, 
+user3071284, William Giles
+
+CFLOOP How-To
+
+Adrian J. Moreno, Bonanza, mhatch, RRK
+
+cfquery
+
+Bubblesphere, shaedrich
+
+ColdFusion Arrays
+
+4444, Justin Duhaime, mhatch, Mishra Shreyanshu, shaedrich
+
+Creating REST APIs 
+in coldfusion
+
+shaedrich
+
+Database Queries
+
+Adam Tuttle, Leigh, mhatch, nosilleg, shaedrich, user3071284
+
+How to invoke a 
+private method 
+dynamically
+
+Henry
+
+Scopes in Coldfusion
+
+James A Mohler, shaedrich
+
+Variables
+
+mhatch
+
+10
+
+Working with 
+RegExp Replace 
+callbacks
+
+shaedrich
+
+https://riptutorial.com/
+
+44
+
+

Cool/cool-manual.pdf.txt

@@ -0,0 +1,1787 @@
+CoolAid: The Cool Reference Manual∗
+
+1
+
+Introduction
+
+This manual describes the programming language Cool: the Classroom Object-Oriented Language. Cool
+is a small language that can be implemented with reasonable effort in a one semester course. Still, Cool
+retains many of the features of modern programming languages including objects, static typing, and
+automatic memory management.
+
+Cool programs are sets of classes. A class encapsulates the variables and procedures of a data type.
+Instances of a class are objects. In Cool, classes and types are identified; i.e., every class defines a type.
+Classes permit programmers to define new types and associated procedures (or methods) specific to those
+types. Inheritance allows new types to extend the behavior of existing types.
+
+Cool is an expression language. Most Cool constructs are expressions, and every expression has a
+value and a type. Cool is type safe: procedures are guaranteed to be applied to data of the correct type.
+While static typing imposes a strong discipline on programming in Cool, it guarantees that no runtime
+type errors can arise in the execution of Cool programs.
+
+This manual is divided into informal and formal components. For a short, informal overview, the first
+
+12 pages (through Section 9) suffices. The formal description begins with Section 10.
+
+2 Getting Started
+
+The reader who wants to get a sense for Cool at the outset should begin by reading, and then write their
+own cool-programs and run them. Cool source files have extension .cl and Cool assembly files have
+extension .s. The Cool compiler is coolc (note that cool is a Linux-binary file). To compile a program:
+
+coolc [ -o fileout ] file1.cl file2.cl ... filen.cl
+
+The compiler compiles the files file1.cl through filen.cl as if they were concatenated together.
+Each file must define a set of complete classes—class definitions may not be split across files. The -o
+option specifies an optional name to use for the output assembly code. If fileout is not supplied, the
+output assembly is named file1.s.
+
+The coolc compiler generates MIPS assembly code. Because not all of the machines the course is
+using are MIPS-based, Cool programs are run on a MIPS simulator called spim. To run a cool program,
+type
+
+% spim
+(spim) load "file.s"
+(spim) run
+
+∗Copyright c(cid:176)1995-2000 by Alex Aiken. All rights reserved.
+
+1
+
+To run a different program during the same spim session, it is necessary to reinitialize the state of the
+simulator before loading the new assembly file:
+
+(spim) reinit
+
+An alternative—and faster—way to invoke spim is with a file:
+
+spim -file file.s
+
+This form loads the file, runs the program, and exits spim when the program terminates. Be sure that
+the spim we provided is actually used. There may be another version of spim installed in on some
+systems, but it will not execute Cool programs. The spim manual is available in the resources folder of
+the repository.
+
+The following is a complete transcript of the compilation and execution of list.cl. This program is
+
+very silly, but it does serve to illustrate many of the features of Cool.
+
+% coolc list.cl
+% spim
+SPIM Version 5.4 of Jan. 17, 1994
+Copyright 1990-1994 by James R. Larus (larus@cs.wisc.edu).
+All Rights Reserved.
+See the file README a full copyright notice.
+Loaded: /usa/pollock/public/cool02/lib/trap.handler
+
+(spim) load "list.s"
+(spim) run
+How many numbers to sort?5
+0
+1
+2
+3
+4
+COOL program successfully executed
+(spim) exit
+%
+
+3 Classes
+
+All code in Cool is organized into classes. Each class definition must be contained in a single source file,
+but multiple classes may be defined in the same file. Class definitions have the form:
+
+class <type> [ inherits <type> ] {
+
+<feature_list>
+
+};
+
+The notation [ ...] denotes an optional construct. All class names are globally visible. Class names
+
+begin with an uppercase letter. Classes may not be redefined.
+
+2
+
+3.1 Features
+
+The body of a class definition consists of a list of feature definitions. A feature is either an attribute or
+a method. An attribute of class A specifies a variable that is part of the state of objects of class A. A
+method of class A is a procedure that may manipulate the variables and objects of class A.
+
+One of the major themes of modern programming languages is information hiding, which is the idea
+that certain aspects of a data type’s implementation should be abstract and hidden from users of the
+data type. Cool supports information hiding through a simple mechanism: all attributes have scope local
+to the class, and all methods have global scope. Thus, the only way to provide access to object state in
+Cool is through methods.
+
+Feature names must begin with a lowercase letter. No method name may be defined multiple times in
+a class, and no attribute name may be defined multiple times in a class, but a method and an attribute
+may have the same name.
+
+A fragment from list.cl illustrates simple cases of both attributes and methods:
+
+class Cons inherits List {
+xcar : Int;
+xcdr : List;
+
+isNil() : Bool { false };
+
+init(hd : Int, tl : List) : Cons {
+
+xcar <- hd;
+xcdr <- tl;
+self;
+
+{
+
+}
+
+}
+...
+};
+
+In this example, the class Cons has two attributes xcar and xcdr and two methods isNil and init.
+Note that the types of attributes, as well as the types of formal parameters and return types of methods,
+are explicitly declared by the programmer.
+
+Given object c of class Cons and object l of class List, we can set the xcar and xcdr fields by using
+
+the method init:
+
+c.init(1,l)
+
+This notation is object-oriented dispatch. There may be many definitions of init methods in many
+different classes. The dispatch looks up the class of the object c to decide which init method to invoke.
+Because the class of c is Cons, the init method in the Cons class is invoked. Within the invocation, the
+variables xcar and xcdr refer to c’s attributes. The special variable self refers to the object on which
+the method was dispatched, which, in the example, is c itself.
+
+There is a special form new C that generates a fresh object of class C. An object can be thought of as
+a record that has a slot for each of the attributes of the class as well as pointers to the methods of the
+class. A typical dispatch for the init method is:
+
+3
+
+(new Cons).init(1,new Nil)
+
+This example creates a new cons cell and initializes the “car” of the cons cell to be 1 and the “cdr” to
+be new Nil.1 There is no mechanism in Cool for programmers to deallocate objects. Cool has automatic
+memory management; objects that cannot be used by the program are deallocated by a runtime garbage
+collector.
+
+Attributes are discussed further in Section 5 and methods are discussed further in Section 6.
+
+3.2 Inheritance
+
+If a class definition has the form
+
+class A inherits B { ... };
+
+then class A inherits the features of B. In this case B is the parent class of A and A is a child class of B.
+
+The semantics of A inherits B is that A has all of the features defined in B in addition to its own
+features. In the case that a parent and child both define the same method name, then the definition
+given in the child class takes precedence. It is illegal to redefine attribute names. Furthermore, for type
+safety, it is necessary to place some restrictions on how methods may be redefined (see Section 6).
+
+There is a distinguished class Object. If a class definition does not specify a parent class, then the
+class inherits from Object by default. A class may inherit only from a single class; this is aptly called
+“single inheritance.”2 The parent-child relation on classes defines a graph. This graph may not contain
+cycles. For example, if A inherits from B, then B must not inherit from A. Furthermore, if A inherits from
+B, then B must have a class definition somewhere in the program. Because Cool has single inheritance, it
+follows that if both of these restrictions are satisfied, then the inheritance graph forms a tree with Object
+as the root.
+
+In addition to Object, Cool has four other basic classes: Int, String, Bool, and IO. The basic classes
+
+are discussed in Section 8.
+
+4 Types
+
+In Cool, every class name is also a type. In addition, there is a type SELF TYPE that can be used in
+special circumstances.
+
+A type declaration has the form x:C, where x is a variable and C is a type. Every variable must have a
+type declaration at the point it is introduced, whether that is in a let, case, or as the formal parameter
+of a method. The types of all attributes must also be declared.
+
+The basic type rule in Cool is that if a method or variable expects a value of type A, then any value
+of type B may be used instead, provided that A is an ancestor of B in the class hierarchy. In other words,
+if B inherits from A, either directly or indirectly, then a B can be used wherever an A would suffice.
+
+When an object of class B may be used in place of an object of class A, we say that B conforms to A
+
+or that B ≤ A. As discussed above, conformance is defined in terms of the inheritance graph.
+
+Definition 4.1 (Conformance) Let A, B, and C be types.
+
+• A ≤ A for all types A
+
+1In this example, Nil is assumed to be a subtype of List.
+2Some object-oriented languages allow a class to inherit from multiple classes, which is equally aptly called “multiple
+
+inheritance.”
+
+4
+
+• if A inherits from B, then A ≤ B
+
+• if A ≤ B and B ≤ C then A ≤ C
+
+Because Object is the root of the class hierarchy, it follows that A ≤ Object for all types A.
+
+4.1 SELF TYPE
+
+The type SELF TYPE is used to refer to the type of the self variable. This is useful in classes that will
+be inherited by other classes, because it allows the programmer to avoid specifying a fixed final type at
+the time the class is written. For example, the program
+
+class Silly {
+
+copy() : SELF_TYPE { self };
+
+};
+
+class Sally inherits Silly { };
+
+class Main {
+
+x : Sally <- (new Sally).copy();
+
+main() : Sally { x };
+
+};
+
+Because SELF TYPE is used in the definition of the copy method, we know that the result of copy is the
+same as the type of the self parameter. Thus, it follows that (new Sally).copy() has type Sally,
+which conforms to the declaration of attribute x.
+
+Note that the meaning of SELF TYPE is not fixed, but depends on the class in which it is used. In
+general, SELF TYPE may refer to the class C in which it appears, or any class that conforms to C. When it
+is useful to make explicit what SELF TYPE may refer to, we use the name of the class C in which SELF TYPE
+appears as an index SELF TYPEC. This subscript notation is not part of Cool syntax—it is used merely
+to make clear in what class a particular occurrence of SELF TYPE appears.
+
+From Definition 4.1, it follows that SELF TYPEX ≤ SELF TYPEX. There is also a special conformance
+
+rule for SELF TYPE:
+
+SELF TYPEC ≤ B if C ≤ B
+
+Finally, SELF TYPE may be used in the following places: new SELF TYPE, as the return type of a
+method, as the declared type of a let variable, or as the declared type of an attribute. No other uses of
+SELF TYPE are permitted.
+
+4.2 Type Checking
+
+The Cool type system guarantees at compile time that execution of a program cannot result in runtime
+type errors. Using the type declarations for identifiers supplied by the programmer, the type checker
+infers a type for every expression in the program.
+
+It is important to distinguish between the type assigned by the type checker to an expression at compile
+time, which we shall call the static type of the expression, and the type(s) to which the expression may
+evaluate during execution, which we shall call the dynamic types.
+
+5
+
+The distinction between static and dynamic types is needed because the type checker cannot, at
+compile time, have perfect information about what values will be computed at runtime. Thus, in general,
+the static and dynamic types may be different. What we require, however, is that the type checker’s
+static types be sound with respect to the dynamic types.
+
+Definition 4.2 For any expression e, let De be a dynamic type of e and let Se be the static type inferred
+by the type checker. Then the type checker is sound if for all expressions e it is the case that De ≤ Se.
+
+Put another way, we require that the type checker err on the side of overestimating the type of an
+expression in those cases where perfect accuracy is not possible. Such a type checker will never accept
+a program that contains type errors. However, the price paid is that the type checker will reject some
+programs that would actually execute without runtime errors.
+
+5 Attributes
+
+An attribute definition has the form
+
+<id> : <type> [ <- <expr> ];
+
+The expression is optional initialization that is executed when a new object is created. The static type
+of the expression must conform to the declared type of the attribute. If no initialization is supplied, then
+the default initialization is used (see below).
+
+When a new object of a class is created, all of the inherited and local attributes must be initialized.
+Inherited attributes are initialized first in inheritance order beginning with the attributes of the greatest
+ancestor class. Within a given class, attributes are initialized in the order they appear in the source text.
+Attributes are local to the class in which they are defined or inherited. Inherited attributes cannot
+
+be redefined.
+
+5.1 Void
+
+All variables in Cool are initialized to contain values of the appropriate type. The special value void
+is a member of all types and is used as the default initialization for variables where no initialization is
+supplied by the user. Note that there is no name for void in Cool; the only way to create a void value
+is to declare a variable of some class other than Int, String, or Bool and allow the default initialization
+to occur.
+
+There is a special form isvoid expr that tests whether a value is void (see Section 7.11). In addition,
+void values may be tested for equality. A void value may be passed as an argument, assigned to a variable,
+or otherwise used in any context where any value is legitimate, except that a dispatch to or case on void
+generates a runtime error.
+
+Variables of the basic classes Int, Bool, and String are initialized specially; see Section 8.
+
+6 Methods
+
+A method definition has the form
+
+<id>(<id> : <type>,...,<id> : <type>): <type> { <expr> };
+
+6
+
+There may be zero or more formal parameters. The identifiers used in the formal parameter list must
+be distinct. The type of the method body must conform to the declared return type. When a method is
+invoked, the formal parameters are bound to the actual arguments and the expression is evaluated; the
+resulting value is the meaning of the method invocation. A formal parameter hides any definition of an
+attribute of the same name.
+
+To ensure type safety, there are restrictions on the redefinition of inherited methods. The rule is
+simple: If a class A inherits a method f from an ancestor class B, then A may override the inherited
+definition of f provided the number of arguments, the types of the formal parameters, and the return
+type are exactly the same in both definitions.
+
+To see why some restriction is necessary on the redefinition of inherited methods, consider the following
+
+example:
+
+class A {
+
+f(): Int { 1 };
+
+};
+
+class B inherits A {
+
+f(): String { "1" };
+
+};
+
+Let a be an object with dynamic type A. Then
+
+a.f() + 1
+
+is a well-formed expression with value 2. However, we cannot substitute a value of type B for a, as it would
+result in adding a string to a number. Thus, if methods can be redefined arbitrarily, then subclasses may
+not simply extend the behavior of their parents, and much of the usefulness of inheritance, as well as
+type safety, is lost.
+
+7 Expressions
+
+Expressions are the largest syntactic category in Cool.
+
+7.1 Constants
+
+The simplest expressions are constants. The boolean constants are true and false. Integer constants are
+unsigned strings of digits such as 0, 123, and 007. String constants are sequences of characters enclosed
+in double quotes, such as "This is a string." String constants may be at most 1024 characters long.
+There are other restrictions on strings; see Section 10.
+
+The constants belong to the basic classes Bool, Int, and String. The value of a constant is an object
+
+of the appropriate basic class.
+
+7.2 Identifiers
+
+The names of local variables, formal parameters of methods, self, and class attributes are all expressions.
+The identifier self may be referenced, but it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+
+7
+
+Local variables and formal parameters have lexical scope. Attributes are visible throughout a class in
+which they are declared or inherited, although they may be hidden by local declarations within expres-
+sions. The binding of an identifier reference is the innermost scope that contains a declaration for that
+identifier, or to the attribute of the same name if there is no other declaration. The exception to this
+rule is the identifier self, which is implicitly bound in every class.
+
+7.3 Assignment
+
+An assignment has the form
+
+<id> <- <expr>
+
+The static type of the expression must conform to the declared type of the identifier. The value is the
+value of the expression. The static type of an assignment is the static type of <expr>.
+
+7.4 Dispatch
+
+There are three forms of dispatch in Cool. The three forms differ only in how the called method is
+selected. The most commonly used form of dispatch is
+
+<expr>.<id>(<expr>,...,<expr>)
+
+Consider the dispatch e0.f(e1, . . . , en). To evaluate this expression, the arguments are evaluated in left-
+to-right order, from e1 to en. Next, e0 is evaluated and its class C noted (if e0 is void a runtime error is
+generated). Finally, the method f in class C is invoked, with the value of e0 bound to self in the body
+of f and the actual arguments bound to the formals as usual. The value of the expression is the value
+returned by the method invocation.
+
+Type checking a dispatch involves several steps. Assume e0 has static type A. (Recall that this type
+is not necessarily the same as the type C above. A is the type inferred by the type checker; C is the class
+of the object computed at runtime, which is potentially any subclass of A.) Class A must have a method
+f, the dispatch and the definition of f must have the same number of arguments, and the static type of
+the ith actual parameter must conform to the declared type of the ith formal parameter.
+
+If f has return type B and B is a class name, then the static type of the dispatch is B. Otherwise, if f
+has return type SELF TYPE, then the static type of the dispatch is A. To see why this is sound, note that
+the self parameter of the method f conforms to type A. Therefore, because f returns SELF TYPE, we can
+infer that the result must also conform to A. Inferring accurate static types for dispatch expressions is
+what justifies including SELF TYPE in the Cool type system.
+
+The other forms of dispatch are:
+
+<id>(<expr>,...,<expr>)
+<expr>@<type>.id(<expr>,...,<expr>)
+
+The first form is shorthand for self.<id>(<expr>,...,<expr>).
+
+The second form provides a way of accessing methods of parent classes that have been hidden by
+redefinitions in child classes.
+Instead of using the class of the leftmost expression to determine the
+method, the method of the class explicitly specified is used. For example, e@B.f() invokes the method
+f in class B on the object that is the value of e. For this form of dispatch, the static type to the left of
+“@”must conform to the type specified to the right of “@”.
+
+8
+
+7.5 Conditionals
+
+A conditional has the form
+
+if <expr> then <expr> else <expr> fi
+
+The semantics of conditionals is standard. The predicate is evaluated first. If the predicate is true,
+then the then branch is evaluated. If the predicate is false, then the else branch is evaluated. The
+value of the conditional is the value of the evaluated branch.
+
+The predicate must have static type Bool. The branches may have any static types. To specify the
+static type of the conditional, we define an operation (cid:116) (pronounced “join”) on types as follows. Let
+A,B,D be any types other than SELF TYPE. The least type of a set of types means the least element with
+respect to the conformance relation ≤.
+
+A (cid:116) B = the least type C such that A ≤ C and B ≤ C
+
+SELF TYPED (cid:116) SELF TYPED = SELF TYPED
+
+SELF TYPED (cid:116) A = D (cid:116) A
+A (cid:116) SELF TYPED = A (cid:116) D
+
+Let T and F be the static types of the branches of the conditional. Then the static type of the
+
+conditional is T (cid:116) F.
+
+7.6 Loops
+
+A loop has the form
+
+while <expr> loop <expr> pool
+
+The predicate is evaluated before each iteration of the loop. If the predicate is false, the loop terminates
+and void is returned. If the predicate is true, the body of the loop is evaluated and the process repeats.
+The predicate must have static type Bool. The body may have any static type. The static type of a
+
+loop expression is Object.
+
+7.7 Blocks
+
+A block has the form
+
+{ <expr>; ... <expr>; }
+
+The expressions are evaluated in left-to-right order. Every block has at least one expression; the value
+of a block is the value of the last expression. The expressions of a block may have any static types. The
+static type of a block is the static type of the last expression.
+
+An occasional source of confusion in Cool is the use of semi-colons. Semi-colons are used as terminators
+in lists of expressions (e.g., the block syntax above) and not as expression separators. Semi-colons also
+terminate other Cool constructs, see Section 11 for details.
+
+9
+
+7.8 Let
+
+A let expression has the form
+
+let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr>
+
+The optional expressions are initialization; the other expression is the body. A let is evaluated as
+follows. First <expr1> is evaluated and the result bound to <id1>. Then <expr2> is evaluated and the
+result bound to <id2>, and so on, until all of the variables in the let are initialized. (If the initialization
+of <idk> is omitted, the default initialization of type <typek> is used.) Next the body of the let is
+evaluated. The value of the let is the value of the body.
+
+The let identifiers <id1>,...,<idn> are visible in the body of the let. Furthermore, identifiers
+
+<id1>,...,<idk> are visible in the initialization of <idm> for any m > k.
+
+If an identifier is defined multiple times in a let, later bindings hide earlier ones. Identifiers introduced
+by let also hide any definitions for the same names in containing scopes. Every let expression must
+introduce at least one identifier.
+
+The type of an initialization expression must conform to the declared type of the identifier. The type
+
+of let is the type of the body.
+
+The scope of a let extends as far (encompasses as many tokens) as possible.
+
+7.9 Case
+
+A case expression has the form
+
+case <expr0> of
+
+<id1> : <type1> => <expr1>;
+. . .
+<idn> : <typen> => <exprn>;
+
+esac
+
+Case expressions provide runtime type tests on objects. First, expr0 is evaluated and its dynamic type
+C noted (if expr0 evaluates to void a run-time error is produced). Next, from among the branches the
+branch with the least type <typek> such that C ≤ <typek> is selected. The identifier <idk> is bound
+to the value of <expr0> and the expression <exprk> is evaluated. The result of the case is the value
+of <exprk>.
+If no branch can be selected for evaluation, a run-time error is generated. Every case
+expression must have at least one branch.
+
+For each branch, let Ti be the static type of <expri>. The static type of a case expression is
+
+1≤i≤n Ti.
+The identifier id introduced by a branch of a case hides any variable or attribute definition for id visible
+in the containing scope.
+
+(cid:70)
+
+The case expression has no special construct for a “default” or “otherwise” branch. The same affect
+
+is achieved by including a branch
+
+x : Object => ...
+
+because every type is ≤ to Object.
+
+The case expression provides programmers a way to insert explicit runtime type checks in situa-
+tions where static types inferred by the type checker are too conservative. A typical situation is that
+a programmer writes an expression e and type checking infers that e has static type A. However, the
+programmer may know that, in fact, the dynamic type of e is always B for some B ≤ A. This information
+can be captured using a case expression:
+
+10
+
+case e of x : B => ...
+
+In the branch the variable x is bound to the value of e but has the more specific static type B.
+
+7.10 New
+
+A new expression has the form
+
+new <type>
+
+The value is a fresh object of the appropriate class. If the type is SELF TYPE, then the value is a fresh
+object of the class of self in the current scope. The static type is <type>.
+
+7.11 Isvoid
+
+The expression
+
+isvoid expr
+
+evaluates to true if expr is void and evaluates to false if expr is not void.
+
+7.12 Arithmetic and Comparison Operations
+
+Cool has four binary arithmetic operations: +, -, *, /. The syntax is
+
+expr1 <op> expr2
+
+To evaluate such an expression first expr1 is evaluated and then expr2. The result of the operation is
+the result of the expression.
+
+The static types of the two sub-expressions must be Int. The static type of the expression is Int.
+
+Cool has only integer division.
+
+Cool has three comparison operations: <, <=, =. For < and <= the rules are exactly the same as
+for the binary arithmetic operations, except that the result is a Bool. The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared. On non-basic objects,
+equality simply checks for pointer equality (i.e., whether the memory addresses of the objects are the
+same). Equality is defined for void.
+
+In principle, there is nothing wrong with permitting equality tests between, for example, Bool and
+Int. However, such a test must always be false and almost certainly indicates some sort of programming
+error. The Cool type checking rules catch such errors at compile-time instead of waiting until runtime.
+
+Finally, there is one arithmetic and one logical unary operator. The expression ~<expr> is the integer
+complement of <expr>. The expression <expr> must have static type Int and the entire expression
+has static type Int. The expression not <expr> is the boolean complement of <expr>. The expression
+<expr> must have static type Bool and the entire expression has static type Bool.
+
+11
+
+8 Basic Classes
+
+8.1 Object
+
+The Object class is the root of the inheritance graph. Methods with the following declarations are
+defined:
+
+abort() : Object
+type_name() : String
+copy() : SELF_TYPE
+
+The method abort halts program execution with an error message. The method type name returns a
+string with the name of the class of the object. The method copy produces a shallow copy of the object.3
+
+8.2 IO
+
+The IO class provides the following methods for performing simple input and output operations:
+
+out_string(x : String) : SELF_TYPE
+out_int(x : Int) : SELF_TYPE
+in_string() : String
+in_int() : Int
+
+The methods out string and out int print their argument and return their self parameter. The
+method in string reads a string from the standard input, up to but not including a newline character.
+The method in int reads a single integer, which may be preceded by whitespace. Any characters following
+the integer, up to and including the next newline, are discarded by in int.
+
+A class can make use of the methods in the IO class by inheriting from IO. It is an error to redefine
+
+the IO class.
+
+8.3 Int
+
+The Int class provides integers. There are no methods special to Int. The default initialization for
+variables of type Int is 0 (not void). It is an error to inherit from or redefine Int.
+
+8.4 String
+
+The String class provides strings. The following methods are defined:
+
+length() : Int
+concat(s : String) : String
+substr(i : Int, l : Int) : String
+
+The method length returns the length of the self parameter. The method concat returns the string
+formed by concatenating s after self. The method substr returns the substring of its self parameter
+beginning at position i with length l; string positions are numbered beginning at 0. A runtime error is
+generated if the specified substring is out of range.
+
+The default initialization for variables of type String is "" (not void). It is an error to inherit from
+
+or redefine String.
+
+3A shallow copy of a copies a itself, but does not recursively copy objects that a points to.
+
+12
+
+8.5 Bool
+
+The Bool class provides true and false. The default initialization for variables of type Bool is false
+(not void). It is an error to inherit from or redefine Bool.
+
+9 Main Class
+
+Every program must have a class Main. Furthermore, the Main class must have a method main that
+takes no formal parameters. The main method must be defined in class Main (not inherited from another
+class). A program is executed by evaluating (new Main).main().
+
+The remaining sections of this manual provide a more formal definition of Cool. There are four sections
+covering lexical structure (Section 10), grammar (Section 11), type rules (Section 12), and operational
+semantics (Section 13).
+
+10 Lexical Structure
+
+The lexical units of Cool are integers, type identifiers, object identifiers, special notation, strings, key-
+words, and white space.
+
+10.1 Integers, Identifiers, and Special Notation
+
+Integers are non-empty strings of digits 0-9. Identifiers are strings (other than keywords) consisting of
+letters, digits, and the underscore character. Type identifiers begin with a capital letter; object identifiers
+begin with a lower case letter. There are two other identifiers, self and SELF TYPE that are treated
+specially by Cool but are not treated as keywords. The special syntactic symbols (e.g., parentheses,
+assignment operator, etc.) are given in Figure 1.
+
+10.2 Strings
+
+Strings are enclosed in double quotes "...". Within a string, a sequence ‘\c’ denotes the character ‘c’,
+with the exception of the following:
+
+\b backspace
+tab
+\t
+\n newline
+\f
+
+formfeed
+
+A non-escaped newline character may not appear in a string:
+
+"This is not
+OK"
+
+A string may not contain EOF. A string may not contain the null (character \0). Any other character
+
+may be included in a string. Strings cannot cross file boundaries.
+
+13
+
+10.3 Comments
+
+There are two forms of comments in Cool. Any characters between two dashes “ – –” and the next
+newline (or EOF, if there is no next newline) are treated as comments. Comments may also be written
+by enclosing text in (∗ . . . ∗). The latter form of comment may be nested. Comments cannot cross file
+boundaries.
+
+10.4 Keywords
+
+The keywords of cool are: class, else, false, fi, if, in, inherits, isvoid, let, loop, pool, then, while,
+case, esac, new, of, not, true. Except for the constants true and false, keywords are case insensitive.
+To conform to the rules for other objects, the first letter of true and false must be lowercase; the trailing
+letters may be upper or lower case.
+
+10.5 White Space
+
+White space consists of any sequence of the characters: blank, newline, \f, \r, \t, \v.
+
+11 Cool Syntax
+
+Figure 1 provides a specification of Cool syntax. The specification is not context-free; for convenience,
+we also use some regular expression notation. Specifically, A∗ means zero or more A’s in succession; A+
+means one or more A’s. The special notation A;∗ means zero or more A’s terminated by semicolons. The
+special notation A,∗ means zero or more A’s separated by commas. Separators differ from terminators
+in that the terminator always appears at the end of the list; a separator is never included at the end of
+a list. In Cool, semicolons are always terminators and commas are always separators. Items in square
+brackets [. . .] are optional. Double braces [[ ]] are not part of Cool; they are used in the grammar as a
+meta-symbol to show association of grammar operations.
+
+11.1 Precedence
+
+The precedence of infix binary and prefix unary operations, from highest to lowest, is given by the
+following table:
+
+.
+@
+~
+isvoid
+* /
++ -
+<=
+not
+<-
+
+< =
+
+All binary operations are left-associative, with the exception of assignment, which is right-associative,
+and the three comparison operations, which do not associate.
+
+14
+
+program ::= class;+
+
+class
+
+::= class TYPE [inherits TYPE] { feature;∗ }
+
+feature ::= ID(formal,∗ ) : TYPE { expr }
+
+|
+
+ID : TYPE [ <- expr ]
+
+formal
+
+::= ID : TYPE
+
+expr
+
+::= ID <- expr
+
+|
+
+|
+
+|
+
+expr[@TYPE].ID(expr,∗ )
+ID(expr,∗ )
+if expr then expr else expr fi
+
+| while expr loop expr pool
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+|
+
+{ expr;+ }
+let [[ID : TYPE [ <- expr ], ]]+ in expr
+case expr of [[ID : TYPE => expr; ]]+esac
+new TYPE
+
+isvoid expr
+
+expr + expr
+
+expr − expr
+
+expr ∗ expr
+
+expr / expr
+
+˜expr
+
+expr < expr
+
+expr <= expr
+
+expr = expr
+
+not expr
+
+(expr)
+
+ID
+
+integer
+
+string
+
+true
+
+false
+
+Figure 1: Cool syntax.
+
+15
+
+12 Type Rules
+
+This section formally defines the type rules of Cool. The type rules define the type of every Cool expression
+in a given context. The context is the type environment, which describes the type of every unbound
+identifier appearing in an expression. The type environment is described in Section 12.1. Section 12.2
+gives the type rules.
+
+12.1 Type Environments
+
+To a first approximation, type checking in Cool can be thought of as a bottom-up algorithm: the type of
+an expression e is computed from the (previously computed) types of e’s subexpressions. For example,
+an integer 1 has type Int; there are no subexpressions in this case. As another example, if en has type
+X, then the expression { e1; . . . ; en; } has type X.
+
+A complication arises in the case of an expression v, where v is an object identifier. It is not possible
+to say what the type of v is in a strictly bottom-up algorithm; we need to know the type declared for v
+in the larger expression. Such a declaration must exist for every object identifier in valid Cool programs.
+To capture information about the types of identifiers, we use a type environment. The environment
+consists of three parts: a method environment M , an object environment O, and the name of the
+current class in which the expression appears. The method environment and object environment are
+both functions (also called mappings). The object environment is a function of the form
+
+O(v) = T
+
+which assigns the type T to object identifier v. The method environment is more complex; it is a function
+of the form
+
+M (C, f ) = (T1, . . . , Tn−1, Tn)
+
+where C is a class name (a type), f is a method name, and t1, . . . , tn are types. The tuple of types is
+the signature of the method. The interpretation of signatures is that in class C the method f has formal
+parameters of types (t1, . . . , tn−1)—in that order—and a return type tn.
+
+Two mappings are required instead of one because object names and method names do not clash—i.e.,
+
+there may be a method and an object identifier of the same name.
+
+The third component of the type environment is the name of the current class, which is needed for
+
+type rules involving SELF TYPE.
+
+Every expression e is type checked in a type environment; the subexpressions of e may be type
+checked in the same environment or, if e introduces a new object identifier, in a modified environment.
+For example, consider the expression
+
+let c : Int <- 33 in
+
+...
+
+The let expression introduces a new variable c with type Int. Let O be the object component of the
+type environment for the let. Then the body of the let is type checked in the object type environment
+
+where the notation O[T /c] is defined as follows:
+
+O[Int/c]
+
+O[T /c](c) = T
+
+O[T /c](d) = O(d) if d (cid:54)= c
+
+16
+
+12.2 Type Checking Rules
+
+The general form a type checking rule is:
+
+...
+O, M, C (cid:96) e : T
+
+The rule should be read: In the type environment for objects O, methods M , and containing class C, the
+expression e has type T . The dots above the horizontal bar stand for other statements about the types
+of sub-expressions of e. These other statements are hypotheses of the rule; if the hypotheses are satisfied,
+then the statement below the bar is true.
+
+The rule for object identifiers is simply that if the environment assigns an identifier Id type T , then
+
+Id has type T .
+
+The rule for assignment to a variable is more complex:
+
+O(Id) = T
+O, M, C (cid:96) Id : T
+
+O(Id) = T
+O, M, C (cid:96) e1 : T (cid:48)
+T (cid:48) ≤ T
+
+O, M, C (cid:96) Id ← e1 : T (cid:48)
+
+[Var]
+
+[ASSIGN]
+
+Note that this type rule—as well as others—use the conformance relation ≤ (see Section 3.2). The rule
+says that the assigned expression e1 must have a type T (cid:48) that conforms to the type T of the identifier Id
+in the type environment. The type of the whole expression is T (cid:48).
+
+The type rules for constants are all easy:
+
+O, M, C (cid:96) true : Bool
+
+O, M, C (cid:96) f alse : Bool
+
+i is an integer constant
+O, M, C (cid:96) i : Int
+
+s is a string constant
+O, M, C (cid:96) s : String
+
+There are two cases for new, one for new SELF TYPE and one for any other form:
+
+(cid:40)
+
+T (cid:48) =
+
+SELF TYPEC if T = SELF TYPE
+T otherwise
+O, M, C (cid:96) new T : T (cid:48)
+
+[True]
+
+[False]
+
+[Int]
+
+[String]
+
+[New]
+
+17
+
+Dispatch expressions are the most complex to type check.
+
+O, M, C (cid:96) e0 : T0
+O, M, C (cid:96) e1 : T1
+...
+O, M, C (cid:96) en : Tn
+
+(cid:40)
+
+T (cid:48)
+0 =
+
+C if T0 = SELF TYPEC
+T0 otherwise
+1, . . . , T (cid:48)
+
+n, T (cid:48)
+
+n+1)
+
+M (T (cid:48)
+Ti ≤ T (cid:48)
+i
+
+0, f ) = (T (cid:48)
+(cid:40)
+
+Tn+1 =
+
+1 ≤ i ≤ n
+if T (cid:48)
+T0
+T (cid:48)
+n+1 otherwise
+O, M, C (cid:96) e0.f (e1, . . . , en) : Tn+1
+
+n+1 = SELF TYPE
+
+O, M, C (cid:96) e0 : T0
+O, M, C (cid:96) e1 : T1
+...
+O, M, C (cid:96) en : Tn
+T0 ≤ T
+M (T, f ) = (T (cid:48)
+Ti ≤ T (cid:48)
+i
+
+1, . . . , T (cid:48)
+
+n, T (cid:48)
+
+n+1)
+
+Tn+1 =
+
+(cid:40)
+
+1 ≤ i ≤ n
+if T (cid:48)
+T0
+T (cid:48)
+n+1 otherwise
+O, M, C (cid:96) e0@T.f (e1, . . . , en) : Tn+1
+
+n+1 = SELF TYPE
+
+[Dispatch]
+
+[StaticDispatch]
+
+To type check a dispatch, each of the subexpressions must first be type checked. The type T0 of e0
+determines the which declaration of the method f is used. The argument types of the dispatch must
+conform to the declared argument types. Note that the type of the result of the dispatch is either the
+declared return type or T0 in the case that the declared return type is SELF TYPE. The only difference in
+type checking a static dispatch is that the class T of the method f is given in the dispatch, and the type
+T0 must conform to T .
+
+The type checking rules for if and {-} expressions are straightforward. See Section 7.5 for the
+
+definition of the (cid:116) operation.
+
+O, M, C (cid:96) e1 : Bool
+O, M, C (cid:96) e2 : T2
+O, M, C (cid:96) e3 : T3
+O, M, C (cid:96) if e1 then e2 else e3 fi : T2 (cid:116) T3
+
+O, M, C (cid:96) e1 : T1
+O, M, C (cid:96) e2 : T2
+...
+O, M, C (cid:96) en : Tn
+O, M, C (cid:96) { e1; e2; . . . en; } : Tn
+
+18
+
+[If]
+
+[Sequence]
+
+The let rule has some interesting aspects.
+
+(cid:40)
+
+T (cid:48)
+0 =
+
+SELF TYPEC if T0 = SELF TYPE
+T0 otherwise
+
+O, M, C (cid:96) e1 : T1
+T1 ≤ T (cid:48)
+0
+O[T (cid:48)
+
+0/x], M, C (cid:96) e2 : T2
+O, M, C (cid:96) let x : T0 ← e1 in e2 : T2
+First, the initialization e1 is type checked in an environment without a definition for x. Thus, the variable
+x cannot be used in e1 unless it already has a definition in an outer scope. Second, the body e2 is type
+checked in the environment O extended with the typing x : T (cid:48)
+0. Third, note that the type of x may be
+SELF TYPE.
+
+[Let-Init]
+
+(cid:40)
+
+T (cid:48)
+0 =
+
+SELF TYPEC if T0 = SELF TYPE
+T0 otherwise
+
+O[T (cid:48)
+
+0/x], M, C (cid:96) e1 : T1
+
+O, M, C (cid:96) let x : T0 in e1 : T1
+The rule for let with no initialization simply omits the conformance requirement. We give type rules
+only for a let with a single variable. Typing a multiple let
+
+[Let-No-Init]
+
+let x1 : T1 [← e1], x2 : T2 [← e2], . . . , xn : Tn [← en] in e
+
+is defined to be the same as typing
+
+let x1 : T1 [← e1] in (let x2 : T2 [← e2], . . . , xn : Tn [← en] in e )
+
+O, M, C (cid:96) e0 : T0
+O[T1/x1], M, C (cid:96) e1 : T (cid:48)
+1
+...
+O[Tn/xn], M, C (cid:96) en : T (cid:48)
+n
+
+O, M, C (cid:96) case e0 of x1 : T1 ⇒ e1; . . . xn : Tn ⇒ en; esac :
+
+(cid:70)
+
+1≤i≤n T (cid:48)
+i
+
+[Case]
+
+Each branch of a case is type checked in an environment where variable xi has type Ti. The type of
+the entire case is the join of the types of its branches. The variables declared on each branch of a case
+must all have distinct types.
+
+O, M, C (cid:96) while e1 loop e2 pool : Object
+The predicate of a loop must have type Bool; the type of the entire loop is always Object. An isvoid
+test has type Bool:
+
+[Loop]
+
+[Isvoid]
+
+O, M, C (cid:96) e1 : Bool
+O, M, C (cid:96) e2 : T2
+
+O, M, C (cid:96) e1 : T1
+O, M, C (cid:96) isvoid e1 : Bool
+
+With the exception of the rule for equality, the type checking rules for the primitive logical, compar-
+
+ison, and arithmetic operations are easy.
+
+O, M, C (cid:96) e1 : Bool
+O, M, C (cid:96) ¬e1 : Bool
+
+19
+
+[Not]
+
+O, M, C (cid:96) e1 : Int
+O, M, C (cid:96) e2 : Int
+op ∈ {<, ≤}
+
+O, M, C (cid:96) e1 op e2 : Bool
+
+O, M, C (cid:96) e1 : Int
+O, M, C (cid:96) ˜e1 : Int
+
+O, M, C (cid:96) e1 : Int
+O, M, C (cid:96) e2 : Int
+op ∈ {∗, +, −, /}
+O, M, C (cid:96) e1 op e2 : Int
+
+[Compare]
+
+[Neg]
+
+[Arith]
+
+The wrinkle in the rule for equality is that any types may be freely compared except Int, String
+
+and Bool, which may only be compared with objects of the same type.
+
+O, M, C (cid:96) e1 : T1
+O, M, C (cid:96) e2 : T2
+T1 ∈ {Int, String, Bool} ∨ T2 ∈ {Int, String, Bool} ⇒ T1 = T2
+O, M, C (cid:96) e1 = e2 : Bool
+
+[Equal]
+
+The final cases are type checking rules for attributes and methods. For a class C, let the object
+environment OC give the types of all attributes of C (including any inherited attributes). More formally,
+if x is an attribute (inherited or not) of C, and the declaration of x is x : T , then
+(cid:40)
+
+OC(x) =
+
+SELF TYPEC if T = SELF TYPE
+T otherwise
+
+The method environment M is global to the entire program and defines for every class C the signatures
+
+of all of the methods of C (including any inherited methods).
+
+The two rules for type checking attribute defininitions are similar the rules for let. The essential
+difference is that attributes are visible within their initialization expressions. Note that self is bound in
+the initialization.
+
+OC(x) = T0
+OC[SELF TYPEC/self], M, C (cid:96) e1 : T1
+T1 ≤ T0
+
+OC, M, C (cid:96) x : T0 ← e1;
+
+OC(x) = T
+OC, M, C (cid:96) x : T ;
+
+[Attr-Init]
+
+[Attr-No-Init]
+
+The rule for typing methods checks the body of the method in an environment where OC is extended
+with bindings for the formal parameters and self. The type of the method body must conform to the
+declared return type.
+
+M (C, f ) = (T1, . . . , Tn, T0)
+OC[SELF TYPEC/self][T1/x1] . . . [Tn/xn], M, C (cid:96) e : T (cid:48)
+0
+
+(cid:40)
+
+T (cid:48)
+0 ≤
+
+SELF TYPEC if T0 = SELF TYPE
+T0 otherwise
+
+OC, M, C (cid:96) f (x1 : T1, . . . , xn : Tn) : T0 { e };
+
+20
+
+[Method]
+
+13 Operational Semantics
+
+This section contains a mostly formal presentation of the operational semantics for the Cool language. The
+operational semantics define for every Cool expression what value it should produce in a given context.
+The context has three components: an environment, a store, and a self object. These components are
+described in the next section. Section 13.2 defines the syntax used to refer to Cool objects, and Section
+13.3 defines the syntax used to refer to class definitions.
+
+Keep in mind that a formal semantics is a specification only—it does not describe an implementation.
+The purpose of presenting the formal semantics is to make clear all the details of the behavior of Cool
+expressions. How this behavior is implemented is another matter.
+
+13.1 Environment and the Store
+
+Before we can present a semantics for Cool we need a number of concepts and a considerable amount of
+notation. An environment is a mapping of variable identifiers to locations. Intuitively, an environment
+tells us for a given identifier the address of the memory location where that identifier’s value is stored.
+For a given expression, the environment must assign a location to all identifiers to which the expression
+may refer. For the expression, e.g., a + b, we need an environment that maps a to some location and b
+to some location. We’ll use the following syntax to describe environments, which is very similar to the
+syntax of type assumptions used in Section 12.
+
+E = [a : l1, b : l2]
+
+This environment maps a to location l1, and b to location l2.
+
+The second component of the context for the evaluation of an expression is the store. The store maps
+locations to values, where values in Cool are just objects. Intuitively, a store tells us what value is stored
+in a given memory location. For the moment, assume all values are integers. A store is similar to an
+environment:
+
+S = [l1 → 55, l2 → 77]
+
+This store maps location l1 to value 55 and location l2 to value 77.
+
+Given an environment and a store, the value of an identifier can be found by first looking up the
+
+location that the identifier maps to in the environment and then looking up the location in the store.
+
+E(a) = l1
+S(l1) = 55
+
+Together, the environment and the store define the execution state at a particular step of the evaluation
+of a Cool expression. The double indirection from identifiers to locations to values allows us to model
+variables. Consider what happens if the value 99 is assigned variable a in the environment and store
+defined above. Assigning to a variable means changing the value to which it refers but not its location.
+To perform the assignment, we look up the location for a in the environment E and then change the
+mapping for the obtained location to the new value, giving a new store S(cid:48).
+
+E(a) = l1
+
+S(cid:48) = S[99/l1]
+
+The syntax S[v/l] denotes a new store that is identical to the store S, except that S(cid:48) maps location l to
+value v. For all locations l(cid:48) where l(cid:48) (cid:54)= l, we still have S(cid:48)(l(cid:48)) = S(l(cid:48)).
+
+21
+
+The store models the contents of memory of the computer during program execution. Assigning to a
+
+variable modifies the store.
+
+There are also situations in which the environment is modified. Consider the following Cool fragment:
+
+let c : Int <- 33 in
+
+c
+
+When evaluating this expression, we must introduce the new identifier c into the environment before
+evaluating the body of the let. If the current environment and state are E and S, then we create a new
+environment E(cid:48) and a new store S(cid:48) defined by:
+
+lc = newloc(S)
+E(cid:48) = E[lc/c]
+S(cid:48) = S[33/lc]
+
+The first step is to allocate a location for the variable c. The location should be fresh, meaning that the
+current store does not have a mapping for it. The function newloc() applied to a store gives us an unused
+location in that store. We then create a new environment E(cid:48), which maps c to lc but also contains all
+of the mappings of E for identifiers other than c. Note that if c already has a mapping in E, the new
+environment E(cid:48) hides this old mapping. We must also update the store to map the new location to a
+value. In this case lc maps to the value 33, which is the initial value for c as defined by the let-expression.
+The example in this subsection oversimplifies Cool environments and stores a bit, because simple
+
+integers are not Cool values. Even integers are full-fledged objects in Cool.
+
+13.2 Syntax for Cool Objects
+
+Every Cool value is an object. Objects contain a list of named attributes, a bit like records in C. In
+addition, each object belongs to a class. We use the following syntax for values in Cool:
+
+v = X(a1 = l1, a2 = l2, . . . , an = ln)
+
+Read the syntax as follows: The value v is a member of class X containing the attributes a1, . . . , an whose
+locations are l1, . . . , ln. Note that the attributes have an associated location. Intuitively this means that
+there is some space in memory reserved for each attribute.
+
+For base objects of Cool (i.e., Ints, Strings, and Bools) we use a special case of the above syntax.
+Base objects have a class name, but their attributes are not like attributes of normal classes, because
+they cannot be modified. Therefore, we describe base objects using the following syntax:
+
+Int(5)
+Bool(true)
+String(4, "Cool")
+
+For Ints and Bools, the meaning is obvious. Strings contain two parts, the length and the actual
+
+sequence of ASCII characters.
+
+13.3 Class definitions
+
+In the rules presented in the next section, we need a way to refer to the definitions of attributes and
+methods for classes. Suppose we have the following Cool class definition:
+
+22
+
+class B {
+
+s : String <- "Hello";
+g (y:String) : Int {
+
+y.concat(s)
+
+};
+f (x:Int) : Int {
+
+x+1
+
+};
+
+};
+
+class A inherits B {
+
+a : Int;
+b : B <- new B;
+f(x:Int) : Int {
+
+x+a
+
+};
+
+};
+
+Two mappings, called class and implementation, are associated with class definitions. The class
+
+mapping is used to get the attributes, as well as their types and initializations, of a particular class:
+
+class(A) = (s : String ← "Hello", a : Int ← 0, b : B ← new B)
+
+Note that the information for class A contains everything that it inherited from class B, as well as its own
+definitions. If B had inherited other attributes, those attributes would also appear in the information for
+A. The attributes are listed in the order they are inherited and then in source order: all the attributes
+from the greatest ancestor are listed first in the order in which they textually appear, then the attributes
+of the next greatest ancestor, and so on, on down to the attributes defined in the particular class. We
+rely on this order in describing how new objects are initialized.
+
+The general form of a class mapping is:
+
+class(X) = (a1 : T1 ← e1, . . . , an : Tn ← en)
+
+Note that every attribute has an initializing expression, even if the Cool program does not specify one for
+each attribute. The default initialization for a variable or attribute is the default of its type. The default
+of Int is 0, the default of String is "", the default of Bool is false, and the default of any other type
+is void.4 The default of type T is written DT .
+
+The implementation mapping gives information about the methods of a class. For the above example,
+
+implementation of A is defined as follows:
+
+implementation(A, f ) = (x, x + a)
+implementation(A, g) = (y, y.concat(s))
+
+In general, for a class X and a method m,
+
+implementation(X, m) = (x1, x2, . . . , xn, ebody)
+
+specifies that method m when invoked from class X, has formal parameters x1, . . . , xn, and the body of
+the method is expression ebody.
+
+4A tiny point: We are allowing void to be used as an expression here. There is no expression for void available to Cool
+
+programmers.
+
+23
+
+13.4 Operational Rules
+
+Equipped with environments, stores, objects, and class definitions, we can now attack the operational
+semantics for Cool. The operational semantics is described by rules similar to the rules used in type
+checking. The general form of the rules is:
+
+...
+so, S, E (cid:96) e1 : v, S(cid:48)
+
+The rule should be read as: In the context where self is the object so, the store is S, and the environment
+is E, the expression e1 evaluates to object v and the new store is S(cid:48). The dots above the horizontal bar
+stand for other statements about the evaluation of sub-expressions of e1.
+
+Besides an environment and a store, the evaluation context contains a self object so. The self object
+is just the object to which the identifier self refers if self appears in the expression. We do not place
+self in the environment and store because self is not a variable—it cannot be assigned to. Note that
+the rules specify a new store after the evaluation of an expression. The new store contains all changes to
+memory resulting as side effects of evaluating expression e1.
+
+The rest of this section presents and briefly discusses each of the operational rules. A few cases are
+
+not covered; these are discussed at the end of the section.
+
+so, S1, E (cid:96) e1 : v1, S2
+E(Id) = l1
+S3 = S2[v1/l1]
+
+so, S1, E (cid:96) Id ← e1 : v1, S3
+
+[Assign]
+
+An assignment first evaluates the expression on the right-hand side, yielding a value v1. This value is
+stored in memory at the address for the identifier.
+
+The rules for identifier references, self, and constants are straightforward:
+
+E(Id) = l
+S(l) = v
+so, S, E (cid:96) Id : v, S
+
+so, S, E (cid:96) self : so, S
+
+so, S, E (cid:96) true : Bool(true), S
+
+so, S, E (cid:96) false : Bool(f alse), S
+
+i is an integer constant
+so, S, E (cid:96) i : Int(i), S
+
+s is a string constant
+l = length(s)
+
+so, S, E (cid:96) s : String(l, s), S
+
+24
+
+[Var]
+
+[Self]
+
+[True]
+
+[False]
+
+[Int]
+
+[String]
+
+A new expression is more complicated than one might expect:
+
+(cid:40)
+
+T0 =
+
+X if T = SELF TYPE and so = X(. . .)
+T otherwise
+
+class(T0) = (a1 : T1 ← e1, . . . , an : Tn ← en)
+li = newloc(S1), for i = 1 . . . n and each li is diistinct
+v1 = T0(a1 = l1, . . . , an = ln)
+S2 = S1[DT1/l1, . . . , DTn/ln]
+v1, S2, [a1 : l1, . . . , an : ln] (cid:96) {a1 ← e1; . . . ; an ← en; } : v2, S3
+so, S1, E (cid:96) new T : v1, S3
+
+[New]
+
+The tricky thing in a new expression is to initialize the attributes in the right order. Note also that,
+during initialization, attributes are bound to the default of the appropriate class.
+
+so, S1, E (cid:96) e1 : v1, S2
+so, S2, E (cid:96) e2 : v2, S3
+...
+so, Sn, E (cid:96) en : vn, Sn+1
+so, Sn+1, E (cid:96) e0 : v0, Sn+2
+v0 = X(a1 = la1, . . . , am = lam)
+implementation(X, f ) = (x1, . . . , xn, en+1)
+lxi = newloc(Sn+2), for i = 1 . . . n and each lxi is distinct
+Sn+3 = Sn+2[v1/lx1, . . . , vn/lxn]
+v0, Sn+3, [a1 : la1, . . . , am : lam, x1 : lx1, . . . , xn : lxn] (cid:96) en+1 : vn+1, Sn+4
+so, S1, E (cid:96) e0.f (e1, . . . , en) : vn+1, Sn+4
+
+so, S1, E (cid:96) e1 : v1, S2
+so, S2, E (cid:96) e2 : v2, S3
+...
+so, Sn, E (cid:96) en : vn, Sn+1
+so, Sn+1, E (cid:96) e0 : v0, Sn+2
+v0 = X(a1 = la1, . . . , am = lam)
+implementation(T, f ) = (x1, . . . , xn, en+1)
+lxi = newloc(Sn+2), for i = 1 . . . n and each lxi is distinct
+Sn+3 = Sn+2[v1/lx1, . . . , vn/lxn]
+v0, Sn+3, [a1 : la1, . . . , am : lam, x1 : lx1, . . . , xn : lxn] (cid:96) en+1 : vn+1, Sn+4
+so, S1, E (cid:96) e0@T.f (e1, . . . , en) : vn+1, Sn+4
+
+[Dispatch]
+
+[StaticDispatch]
+
+The two dispatch rules do what one would expect. The arguments are evaluated and saved. Next, the
+expression on the left-hand side of the “.” is evaluated. In a normal dispatch, the class of this expression
+is used to determine the method to invoke; otherwise the class is specified in the dispatch itself.
+
+so, S1, E (cid:96) e1 : Bool(true), S2
+so, S2, E (cid:96) e2 : v2, S3
+
+so, S1, E (cid:96) if e1 then e2 else e3 fi : v2, S3
+
+[If-True]
+
+25
+
+so, S1, E (cid:96) e1 : Bool(f alse), S2
+so, S2, E (cid:96) e3 : v3, S3
+
+so, S1, E (cid:96) if e1 then e2 else e3 fi : v3, S3
+There are no surprises in the if-then-else rules. Note that value of the predicate is a Bool object, not a
+boolean.
+
+[If-False]
+
+so, S1, E (cid:96) e1 : v1, S2
+so, S2, E (cid:96) e2 : v2, S3
+...
+so, Sn, E (cid:96) en : vn, Sn+1
+so, S1, E (cid:96) { e1; e2; . . . ; en; } : vn, Sn+1
+Blocks are evaluated from the first expression to the last expression, in order. The result is the result of
+the last expression.
+
+[Sequence]
+
+so, S1, E (cid:96) e1 : v1, S2
+l1 = newloc(S2)
+S3 = S2[v1/l1]
+E(cid:48) = E[l1/Id]
+so, S3, E(cid:48) (cid:96) e2 : v2, S4
+so, S1, E (cid:96) let Id : T1 ← e1 in e2 : v2, S4
+A let evaluates any initialization code, assigns the result to the variable at a fresh location, and evaluates
+the body of the let. (If there is no initialization, the variable is initialized to the default value of T1.)
+We give the operational semantics only for the case of let with a single variable. The semantics of a
+multiple let
+
+[Let]
+
+let x1 : T1 ← e1, x2 : T2 ← e2, . . . , xn : Tn ← en in e
+
+is defined to be the same as
+
+let x1 : T1 ← e1 in (let x2 : T2 ← e2, . . . , xn : Tn ← en in e )
+
+so, S1, E (cid:96) e0 : v0, S2
+v0 = X(. . .)
+Ti = closest ancestor of X in {T1, . . . , Tn}
+l0 = newloc(S2)
+S3 = S2[v0/l0]
+E(cid:48) = E[l0/Idi]
+so, S3, E(cid:48) (cid:96) ei : v1, S4
+
+so, S1, E (cid:96) case e0 of Id1 : T1 ⇒ e1; . . . ; Idn : Tn ⇒ en; esac : v1, S4
+Note that the case rule requires that the class hierarchy be available in some form at runtime, so that
+the correct branch of the case can be selected. This rule is otherwise straightforward.
+
+[Case]
+
+so, S1, E (cid:96) e1 : Bool(true), S2
+so, S2, E (cid:96) e2 : v2, S3
+so, S3, E (cid:96) while e1 loop e2 pool : void, S4
+so, S1, E (cid:96) while e1 loop e2 pool : void, S4
+
+26
+
+[Loop-True]
+
+so, S1, E (cid:96) e1 : Bool(f alse), S2
+so, S1, E (cid:96) while e1 loop e2 pool : void, S2
+There are two rules for while: one for the case where the predicate is true and one for the case where the
+predicate is false. Both cases are straightforward. The two rules for isvoid are also straightforward:
+
+[Loop-False]
+
+so, S1, E (cid:96) e1 : void, S2
+so, S1, E (cid:96) isvoid e1 : Bool(true), S2
+
+[IsVoid-True]
+
+so, S1, E (cid:96) e1 : X(. . .), S2
+so, S1, E (cid:96) isvoid e1 : Bool(f alse), S2
+The remainder of the rules are for the primitive arithmetic, logical, and comparison operations except
+equality. These are all easy rules.
+
+[IsVoid-False]
+
+so, S1, E (cid:96) e1 : Bool(b), S2
+v1 = Bool(¬b)
+so, S1, E (cid:96) not e1 : v1, S2
+
+so, S1, E (cid:96) e1 : Int(i1), S2
+so, S2, E (cid:96) e2 : Int(i2), S3
+op ∈ {≤, <}
+(cid:40)
+
+v1 =
+
+Bool(true), if i1 op i2
+Bool(f alse), otherwise
+
+so, S1, E (cid:96) e1 op e2 : v1, S3
+
+so, S1, E (cid:96) e1 : Int(i1), S2
+v1 = Int(−i1)
+
+so, S1, E (cid:96) ˜e1 : v1, S2
+
+[Not]
+
+[Comp]
+
+[Neg]
+
+so, S1, E (cid:96) e1 : Int(i1), S2
+so, S2, E (cid:96) e2 : Int(i2), S3
+op ∈ {∗, +, −, /}
+v1 = Int(i1 op i2)
+so, S1, E (cid:96) e1 op e2 : v1, S3
+Cool Ints are 32-bit two’s complement signed integers; the arithmetic operations are defined accordingly.
+The notation and rules given above are not powerful enough to describe how objects are tested for
+
+[Arith]
+
+equality, or how runtime exceptions are handled. For these cases we resort to an English description.
+
+In e1 = e2, first e1 is evaluated and then e2 is evaluated. The two objects are compared for equality
+by first comparing their pointers (addresses). If they are the same, the objects are equal. The value
+void is not equal to any object except itself. If the two objects are of type String, Bool, or Int, their
+respective contents are compared.
+
+In addition, the operational rules do not specify what happens in the event of a runtime error.
+
+Execution aborts when a runtime error occurs. The following list specifies all possible runtime errors.
+
+1. A dispatch (static or dynamic) on void.
+
+2. A case on void.
+
+27
+
+3. Execution of a case statement without a matching branch.
+
+4. Division by zero.
+
+5. Substring out of range.
+
+6. Heap overflow.
+
+Finally, the rules given above do not explain the execution behaviour for dispatches to primitive
+methods defined in the Object, IO, or String classes. Descriptions of these primitive methods are given
+in Sections 8.3-8.5.
+
+14 Acknowledgements
+
+Cool is based on Sather164, which is itself based on the language Sather. Portions of this document
+were cribbed from the Sather164 manual; in turn, portions of the Sather164 manual are based on Sather
+documentation written by Stephen M. Omohundro.
+
+A number people have contributed to the design and implementation of Cool, including Manuel
+F¨ahndrich, David Gay, Douglas Hauge, Megan Jacoby, Tendo Kayiira, Carleton Miyamoto, and Michael
+Stoddart. Joe Darcy updated Cool to the current version.
+
+28
+
+