DOCSLIB.ORG

The Pascal Reserved Words and Required Identifiers

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
The Pascal Reserved Words and Required Identifiers APPENDIX I THE PASCAL RESERVED WORDS AND REQUIRED IDENTIFIERS The following are the Pascal reserved words. Each has a special meaning and may not be redefined: AND ARRAY BEGIN CASE CONST DIV DO DOWNTO ELSE END FILE FOR FUNCTION GOTO IF IN LABEL MOD NIL NOT OF OR PACKED PROCEDURE PROGRAM RECORD REPEAT SET THEN TO TYPE UNTIL VAR WHILE WITH The following are the 'required identifiers' of the Pascallanguage. It is possible, but inadvisible, to redefine them du ring a program. INTEGER REAL CHAR BOOLEAN ABS ARCTAN CHR COS DISPOSE EOF EOLN EXP FALSE GET INPUT LN MAXINT NEW ODD ORD OUTPUT PACK PAGE PRED PUT READ READLN RESET REWRITE ROUND SIN SQR SQRT SUCC TEXT TRUE TRUNC UNPACK WRITE WRITELN The following word is a required directive and has also been assigned a special meaning in the language: FORWARD Some implementations have additional predefined functions and procedures. APPENDIX 11 SYNTAX DIAGRAMS Pascal syntax should follow the route indicated in the following diagrams. In these diagrams the following rules hold: (a) 'Letter' means any one of the 26 letters of the English alphabet.1t may be in either upper case or lower case. The Pascallanguage does not differentiate between upper case and lower case letters except within character strings. (b) 'Digit' means any one of the decimal digits 0 .. 9. (c) 'Character' me ans any one letter or digit or other symbol. In theory this means any of the printable characters in a character set such as ASCII (see Appendix IV) but in practice there are often implementation limitations. (d) All other tokens appearing within circles or boxes with semicircular ends should be reproduced in the program exactly as they appear in the diagram, except that letters may be in upper or lower case. (e) All items in solid rectangular boxes are defined in this appendix. program 241 block ~---r--~ unsigned integer ~--__ '- ./ identifier (constant identifier) 242 statement expression 1---------1 function identifier procedure identifier )------..1 unsigned integer 1----------------' 243 parameter I ist ,--------------------------, '----~I conformant array parameter specification !-,___ ....J ~---------------------------~see note 3 expression '--....lo..__ .lo.... __.l!..... __.lo.... __.lo.... __.l..j~simple expression 244 simple expression term factor - .........---------+-1 unsigned constant I-----------,.......,~ function identifier 245 type t }------~ type identifier 1-----1 simple type 246 field list variable -~-+-l variable identifier I------------------...,..-'~ field identifier array identifier record identifier field identifier pointer identifier I--------...,..-'-~ t file identifier 247 constant identifier unsigned number unsigned number u nsigned integer l+-----+l~ unsigned integer unsigned integer Note 1 The semi-colon before the END of a CASE statement was not permitted in so me earlier Pascal implementations. Note 2 The requirement for a parameter list in procedural and func­ tional parameters was introduced in BS 6192 : 1982. It may not be per­ mitted in some earlier implementations. Note 3 Conformant array parameters are a feature of Level 1 of BS 6192: 1982. They are not discussed in this book which claims to comply only with Level 0 of the Standard. APPENDIX 111 INTERACTIVE INPUT In Chapter 8 it was briefly mentioned that there are two main ways of implementing INPUT when a keyboard is used. One is direct and the other is via a line buffer. This appendix considers the two methods in more detail and the implications they have when programming for interactive operation. III.1 mE UNE BUFFER MEmOD The line buffer method requires that the < newline > key must be pressed after the called-for data has been entered. Figure III.1 shows diagram­ matically what is happening immediately before the < newline > key is pressed. The line buffer is acting as though it were in write mode with the keyboard supplying the data. Fig III.1 the fine buffer method of interactive input before the <newline> key is depressed: the fine buffer can be considered as a file in write mode with the arrow representing the key­ board's buffer variable Now is the time for all good men Une buffer Figure III.2 shows the position immediately after pressing the < newline > key. The line buffer is now in read mode and the Pascal pro­ gram's buffer variable is positioned to read the data. 249 Fig I1I.2 the line buffer method of interactive inputs after the <newline> key is pressed; the line buffer is in read mode and the Pascal buffer variable is positioned to read the whole line I Keyboard I EOLN Une buffer Pascal program being executed To see how this works in practice, let us look at a simple program: EBQ§BB~ CharHandling (INPUT, OUTPUT); character : CHAR; I!~§H! B~E~B! WRITE ('Input a character )'; READ (character); WRITELN ('Character is )', character); WRITELN ~~!lb character = 'X' ~~!? The result of running this program using the line buffer method is Input a character >II-f Character is )A Input a character >B-f Character is >8 Input a character >X-f Character is >X Note that each character input has been followed by the pressing of the < newline > key. The line buffer can introduce one feature that may be undesirable. Let us run the program again, but this time we shall supply more data than is needed to satisfy the first read list: 250 Input. a charact.er >RBX~ Charact.er is jA Input. a charact.er >Charact.er is >B Input. a charact.er >Charact.er is >X On the second iteration there were still two characters, Band X, in the buffer. The READ statement accepted the B without waiting for a new character to be keyed in. Similarly, on the next iteration X was accepted. The judicious use of READLN will avert the problem of unwanted data left in the buffer, but see the remarks on the use of READLN for inter­ active working at the end of Chapter 8. An essential feature of any interactive working is that there should be a method of correcting errors made by mis-keying. The usual way to do this is by use of a < backspace > or similar key. The great advantage of the line buffer method is that such errors can usually be corrected before the <newline> key is pressed. The corrections are made in the line buffer by the computer's operating system and no special provision is needed in the Pascal program. A dis advantage of the line buffer method is that < newline > always has to pressed. In many programs (games and computer drafting are examples) it is adefinite disadvantage not to have some form of immediate single keystoke entry. For this reasons so me implementations using a line buffer also provide an additional predefined function which scans the keyboard and, if a key is pressed, returns its value. III.2 THE DIRECT METHOn The direct method of interactive data entry is exemplified diagrammatically in Fig. 111.3. Each character value is passed straight from the keyboard to the buffer variable. If we run the above CharHandling pro gram with this method we would get the following: Input. a charact.er >RCharact.er is >A Input. a charact.er )BCharact.er is >B Input. a charact.er >XCharact.er is >X This layout differs from that obtained with the line buffer method because we have not had to press the < newline > key after entering each character. For games and similar programs the ability of the direct method to 251 Fig 111.3 the direct method of interactive input: each character is passed straight from the keyboard to the Pascal program; the pro­ grammer must write his or her own procedure for dealing with ,backspaced' corrections Pascal program being executed respond to the single entry of any key can be a distinct advantage. Also there is no line buffer to hold unwanted characters. The main disadvantage of this method is that for certain applications the Pascal programmer may need to provide his own procedure for the correction of keying errors. APPENDIX IV ASUBSET OF THE ACSII CODE The American Standard Code for Information Interchange is used to define the ORD values of characters in many Pascal implementations. The table on the next page lists those characters that are likely to be used generally by Pascal programmers, together with their values. 253 Ord Chr Ord Chr Ord Chr 32 < space > 64 (aJ 33 ! 65 A 97 a 34 " 66 B 98 b 35 #or f: 67 C 99 c 36 $ 68 D 100 d 37 % 69 E 101 e 38 & 70 F 102 f 39 ' (quote) 71 G 103 g 40 ( 72 H 104 h 41 ) 73 105 42 * 74 J 106 j 43 + 75 K 107 k 44 , (comma) 76 L 108 45 77 M 109 m 46 . (fuH stop) 78 N 110 n 47 / 79 0 111 0 48 0 80 P 112 P 49 1 81 Q 113 q 50 2 82 R 114 51 3 83 S 115 s 52 4 84 T 116 53 5 85 U 117 u 54 6 86 V 118 v 55 7 87 W 119 w 56 8 88 X 120 x 57 9 89 Y 121 Y 58 90 Z 122 z 59 91 [ 123 { 60 < 61 = 93 ] 125 } 62 > 94 t 63 ? In addition to the above there are several control characters that, when output to some printers, have special significance. Among these are 8 Back-space 9 Horizontal tabulate 10 Line feed 12 Form feed (to the top of next page) 13 Carriage return REFERENCES BS 6192: 1982 (1982). Computer programming language Pascal, British Standards Institution, London Huggins, E. (1979). Microprocessors and Microcomputers: Their Use and Programming, Macmillan, London and Basingstoke Jensen, K.
Load more

Recommended publications
  • Decimal Rounding
    Mathematics Instructional Plan – Grade 5 Decimal Rounding Strand: Number and Number Sense Topic: Rounding decimals, through the thousandths, to the nearest whole number, tenth, or hundredth. Primary SOL: 5.1 The student, given a decimal through thousandths, will round to the nearest whole number, tenth, or hundredth. Materials Base-10 blocks Decimal Rounding activity sheet (attached) “Highest or Lowest” Game (attached) Open Number Lines activity sheet (attached) Ten-sided number generators with digits 0–9, or decks of cards Vocabulary approximate, between, closer to, decimal number, decimal point, hundredth, rounding, tenth, thousandth, whole Student/Teacher Actions: What should students be doing? What should teachers be doing? 1. Begin with a review of decimal place value: Display a decimal in the thousandths place, such as 34.726, using base-10 blocks. In pairs, have students discuss how to read the number using place-value names, and review the decimal place each digit holds. Briefly have students share their thoughts with the class by asking: What digit is in the tenths place? The hundredths place? The thousandths place? Who would like to share how to say this decimal using place value? 2. Ask, “If this were a monetary amount, $34.726, how would we determine the amount to the nearest cent?” Allow partners or small groups to discuss this question. It may be helpful if students underlined the place that indicates cents (the hundredths place) in order to keep track of the rounding place. Distribute the Open Number Lines activity sheet and display this number line on the board. Guide students to recall that the nearest cent is the same as the nearest hundredth of a dollar.
    [Show full text]
  • Cognitive Programming Language (CPL) Programmer's Guide
    Cognitive Programming Language (CPL) Programmer's Guide 105-008-02 Revision C2 – 3/17/2006 *105-008-02* Copyright © 2006, Cognitive. Cognitive™, Cxi™, and Ci™ are trademarks of Cognitive. Microsoft® and Windows™ are trademarks of Microsoft Corporation. Other product and corporate names used in this document may be trademarks or registered trademarks of other companies, and are used only for explanation and to their owner’s benefit, without intent to infringe. All information in this document is subject to change without notice, and does not represent a commitment on the part of Cognitive. No part of this document may be reproduced for any reason or in any form, including electronic storage and retrieval, without the express permission of Cognitive. All program listings in this document are copyrighted and are the property of Cognitive and are provided without warranty. To contact Cognitive: Cognitive Solutions, Inc. 4403 Table Mountain Drive Suite A Golden, CO 80403 E-Mail: [email protected] Telephone: +1.800.525.2785 Fax: +1.303.273.1414 Table of Contents Introduction.............................................................................................. 1 Label Format Organization .................................................................. 2 Command Syntax................................................................................ 2 Important Programming Rules............................................................. 3 Related Publications...........................................................................
    [Show full text]
  • A Compiler for a Simple Language. V0.16
    Project step 1 – a compiler for a simple language. v0.16 Change log: v0.16, changes from 0.15 Make all push types in compiler actions explicit. Simplified and better documentation of call and callr instruction compiler actions. Let the print statement print characters and numbers. Added a printv statement to print variables. Changed compiler actions for retr to push a variable value, not a literal value. Changes are shown in orange. v0.15, changes from 0.14 Change compiler actions for ret, retr, jmp. Change the description and compiler actions for poke. Change the description for swp. Change the compiler actions for call and callr. Changes shown in green. v0.14, changes from 0.13 Add peek, poke and swp instructions. Change popm compiler actions. Change callr compiler actions. Other small changes to wording. Changes are shown in blue. v0.13, changes from 0.12 Add a count field to subr, call and callr to simplify code generation. Changes are shown in red. v0.12 Changes from 0.11. Added a callr statement that takes a return type. Fix the generated code for this and for call to allow arguments to be pushed by the call. Add a retr that returns a value and update the reg. v0.11: changes from 0.10. Put typing into push operators. Put opcodes for compare operators. fix actions for call. Make declarations reserve a stack location. Remove redundant store instruction (popv does the same thing.) v0.10: changes from 0.0. Comparison operators (cmpe, cmplt, cmpgt) added. jump conditional (jmpc) added. bytecode values added.
    [Show full text]
  • Programming Basics - FORTRAN 77
    CWCS Workshop May 2005 Programming Basics - FORTRAN 77 http://www.physics.nau.edu/~bowman/PHY520/F77tutor/tutorial_77.html Program Organization A FORTRAN program is just a sequence of lines of plain text. This is called the source code. The text has to follow certain rules (syntax) to be a valid FORTRAN program. We start by looking at a simple example: program circle real r, area, pi c This program reads a real number r and prints c the area of a circle with radius r. write (*,*) 'Give radius r:' read (*,*) r pi = atan(1.0e0)*4.0e0 area = pi*r*r write (*,*) 'Area = ', area end A FORTRAN program generally consists of a main program and possibly several subprograms (i.e., functions or subroutines). The structure of a main program is: program name declarations statements end Note: Words that are in italics should not be taken as literal text, but rather as a description of what belongs in their place. FORTRAN is not case-sensitive, so "X" and "x" are the same variable. Blank spaces are ignored in Fortran 77. If you remove all blanks in a Fortran 77 program, the program is still acceptable to a compiler but almost unreadable to humans. Column position rules Fortran 77 is not a free-format language, but has a very strict set of rules for how the source code should be formatted. The most important rules are the column position rules: Col. 1: Blank, or a "c" or "*" for comments Col. 1-5: Blank or statement label Col. 6: Blank or a "+" for continuation of previous line Col.
    [Show full text]
  • IEEE Standard 754 for Binary Floating-Point Arithmetic
    Work in Progress: Lecture Notes on the Status of IEEE 754 October 1, 1997 3:36 am Lecture Notes on the Status of IEEE Standard 754 for Binary Floating-Point Arithmetic Prof. W. Kahan Elect. Eng. & Computer Science University of California Berkeley CA 94720-1776 Introduction: Twenty years ago anarchy threatened floating-point arithmetic. Over a dozen commercially significant arithmetics boasted diverse wordsizes, precisions, rounding procedures and over/underflow behaviors, and more were in the works. “Portable” software intended to reconcile that numerical diversity had become unbearably costly to develop. Thirteen years ago, when IEEE 754 became official, major microprocessor manufacturers had already adopted it despite the challenge it posed to implementors. With unprecedented altruism, hardware designers had risen to its challenge in the belief that they would ease and encourage a vast burgeoning of numerical software. They did succeed to a considerable extent. Anyway, rounding anomalies that preoccupied all of us in the 1970s afflict only CRAY X-MPs — J90s now. Now atrophy threatens features of IEEE 754 caught in a vicious circle: Those features lack support in programming languages and compilers, so those features are mishandled and/or practically unusable, so those features are little known and less in demand, and so those features lack support in programming languages and compilers. To help break that circle, those features are discussed in these notes under the following headings: Representable Numbers, Normal and Subnormal, Infinite
    [Show full text]
  • Fortran 90 Programmer's Reference
    Fortran 90 Programmer’s Reference First Edition Product Number: B3909DB Fortran 90 Compiler for HP-UX Document Number: B3908-90002 October 1998 Edition: First Document Number: B3908-90002 Remarks: Released October 1998. Initial release. Notice Copyright Hewlett-Packard Company 1998. All Rights Reserved. Reproduction, adaptation, or translation without prior written permission is prohibited, except as allowed under the copyright laws. The information contained in this document is subject to change without notice. Hewlett-Packard makes no warranty of any kind with regard to this material, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. Hewlett-Packard shall not be liable for errors contained herein or for incidental or consequential damages in connection with the furnishing, performance or use of this material. Contents Preface . xix New in HP Fortran 90 V2.0. .xx Scope. xxi Notational conventions . xxii Command syntax . xxiii Associated documents . xxiv 1 Introduction to HP Fortran 90 . 1 HP Fortran 90 features . .2 Source format . .2 Data types . .2 Pointers . .3 Arrays . .3 Control constructs . .3 Operators . .4 Procedures. .4 Modules . .5 I/O features . .5 Intrinsics . .6 2 Language elements . 7 Character set . .8 Lexical tokens . .9 Names. .9 Program structure . .10 Statement labels . .10 Statements . .11 Source format of program file . .13 Free source form . .13 Source lines . .14 Statement labels . .14 Spaces . .14 Comments . .15 Statement continuation . .15 Fixed source form . .16 Spaces . .16 Source lines . .16 Table of Contents i INCLUDE line . 19 3 Data types and data objects . 21 Intrinsic data types . 22 Type declaration for intrinsic types .
    [Show full text]
  • Control Flow Graphs • Can Be Done at High Level Or Low Level – E.G., Constant Folding
    Optimizations • Code transformations to improve program – Mainly: improve execution time – Also: reduce program size Control Flow Graphs • Can be done at high level or low level – E.g., constant folding • Optimizations must be safe – Execution of transformed code must yield same results as the original code for all possible executions 1 2 Optimization Safety Optimization Safety • Safety of code transformations usually requires certain • Safety of code transformations usually requires certain information that may not be explicit in the code information which may not explicit in the code • Example: dead code elimination • Example: dead code elimination (1) x = y + 1; (1) x = y + 1; (2) y = 2 * z; (2) y = 2 * z; (3) x=y+z;x = y + z; (3) x=y+z;x = y + z; (4) z = 1; (4) z = 1; (5) z = x; (5) z = x; • What statements are dead and can be removed? • Need to know whether values assigned to x at (1) is never used later (i.e., x is dead at statement (1)) – Obvious for this simple example (with no control flow) – Not obvious for complex flow of control 3 4 1 Dead Variable Example Dead Variable Example • Add control flow to example: • Add control flow to example: x = y + 1; x = y + 1; y = 2 * z; y = 2 * z; if (d) x = y+z; if (d) x = y+z; z = 1; z = 1; z = x; z = x; • Statement x = y+1 is not dead code! • Is ‘x = y+1’ dead code? Is ‘z = 1’ dead code? •On some executions, value is used later 5 6 Dead Variable Example Dead Variable Example • Add more control flow: • Add more control flow: while (c) { while (c) { x = y + 1; x = y + 1; y = 2 * z; y = 2
    [Show full text]
  • Variables and Calculations
    ¡ ¢ £ ¤ ¥ ¢ ¤ ¦ § ¨ © © § ¦ © § © ¦ £ £ © § ! 3 VARIABLES AND CALCULATIONS Now you’re ready to learn your first ele- ments of Python and start learning how to solve programming problems. Although programming languages have myriad features, the core parts of any programming language are the instructions that perform numerical calculations. In this chapter, we’ll explore how math is performed in Python programs and learn how to solve some prob- lems using only mathematical operations. ¡ ¢ £ ¤ ¥ ¢ ¤ ¦ § ¨ © © § ¦ © § © ¦ £ £ © § ! Sample Program Let’s start by looking at a very simple problem and its Python solution. PROBLEM: THE TOTAL COST OF TOOTHPASTE A store sells toothpaste at $1.76 per tube. Sales tax is 8 percent. For a user-specified number of tubes, display the cost of the toothpaste, showing the subtotal, sales tax, and total, including tax. First I’ll show you a program that solves this problem: toothpaste.py tube_count = int(input("How many tubes to buy: ")) toothpaste_cost = 1.76 subtotal = toothpaste_cost * tube_count sales_tax_rate = 0.08 sales_tax = subtotal * sales_tax_rate total = subtotal + sales_tax print("Toothpaste subtotal: $", subtotal, sep = "") print("Tax: $", sales_tax, sep = "") print("Total is $", total, " including tax.", sep = ") Parts of this program may make intuitive sense to you already; you know how you would answer the question using a calculator and a scratch pad, so you know that the program must be doing something similar. Over the next few pages, you’ll learn exactly what’s going on in these lines of code. For now, enter this program into your Python editor exactly as shown and save it with the required .py extension. Run the program several times with different responses to the question to verify that the program works.
    [Show full text]
  • Introduction to the Python Language
    Introduction to the Python language CS111 Computer Programming Department of Computer Science Wellesley College Python Intro Overview o Values: 10 (integer), 3.1415 (decimal number or float), 'wellesley' (text or string) o Types: numbers and text: int, float, str type(10) Knowing the type of a type('wellesley') value allows us to choose the right operator when o Operators: + - * / % = creating expressions. o Expressions: (they always produce a value as a result) len('abc') * 'abc' + 'def' o Built-in functions: max, min, len, int, float, str, round, print, input Python Intro 2 Concepts in this slide: Simple Expressions: numerical values, math operators, Python as calculator expressions. Input Output Expressions Values In [...] Out […] 1+2 3 3*4 12 3 * 4 12 # Spaces don't matter 3.4 * 5.67 19.278 # Floating point (decimal) operations 2 + 3 * 4 14 # Precedence: * binds more tightly than + (2 + 3) * 4 20 # Overriding precedence with parentheses 11 / 4 2.75 # Floating point (decimal) division 11 // 4 2 # Integer division 11 % 4 3 # Remainder 5 - 3.4 1.6 3.25 * 4 13.0 11.0 // 2 5.0 # output is float if at least one input is float 5 // 2.25 2.0 5 % 2.25 0.5 Python Intro 3 Concepts in this slide: Strings and concatenation string values, string operators, TypeError A string is just a sequence of characters that we write between a pair of double quotes or a pair of single quotes. Strings are usually displayed with single quotes. The same string value is created regardless of which quotes are used.
    [Show full text]
  • FORTRAN 77 Language Reference
    FORTRAN 77 Language Reference FORTRAN 77 Version 5.0 901 San Antonio Road Palo Alto, , CA 94303-4900 USA 650 960-1300 fax 650 969-9131 Part No: 805-4939 Revision A, February 1999 Copyright Copyright 1999 Sun Microsystems, Inc. 901 San Antonio Road, Palo Alto, California 94303-4900 U.S.A. All rights reserved. All rights reserved. This product or document is protected by copyright and distributed under licenses restricting its use, copying, distribution, and decompilation. No part of this product or document may be reproduced in any form by any means without prior written authorization of Sun and its licensors, if any. Portions of this product may be derived from the UNIX® system, licensed from Novell, Inc., and from the Berkeley 4.3 BSD system, licensed from the University of California. UNIX is a registered trademark in the United States and in other countries and is exclusively licensed by X/Open Company Ltd. Third-party software, including font technology in this product, is protected by copyright and licensed from Sun’s suppliers. RESTRICTED RIGHTS: Use, duplication, or disclosure by the U.S. Government is subject to restrictions of FAR 52.227-14(g)(2)(6/87) and FAR 52.227-19(6/87), or DFAR 252.227-7015(b)(6/95) and DFAR 227.7202-3(a). Sun, Sun Microsystems, the Sun logo, SunDocs, SunExpress, Solaris, Sun Performance Library, Sun Performance WorkShop, Sun Visual WorkShop, Sun WorkShop, and Sun WorkShop Professional are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and in other countries.
    [Show full text]
  • Dynamic Security Labels and Noninterference
    Dynamic Security Labels and Noninterference Lantian Zheng Andrew C. Myers Computer Science Department Cornell University {zlt,andru}@cs.cornell.edu Abstract This paper explores information flow control in systems in which the security classes of data can vary dynamically. Information flow policies provide the means to express strong security requirements for data confidentiality and integrity. Recent work on security-typed programming languages has shown that information flow can be analyzed statically, ensuring that programs will respect the restrictions placed on data. However, real computing systems have security policies that vary dynamically and that cannot be determined at the time of program analysis. For example, a file has associated access permissions that cannot be known with certainty until it is opened. Although one security-typed programming lan- guage has included support for dynamic security labels, there has been no examination of whether such a mechanism can securely control information flow. In this paper, we present an expressive language- based mechanism for securely manipulating dynamic security labels. The mechanism is presented both in the context of a Java-like programming language and, more formally, in a core language based on the typed lambda calculus. This core language is expressive enough to encode previous dynamic label mechanisms; as importantly, any well-typed program is provably secure because it satisfies noninterfer- ence. 1 Introduction Information flow control protects information security by constraining how information is transmitted among objects and users of various security classes. These security classes are expressed as labels associated with the information or its containers. Dynamic labels, labels that can be manipulated and checked at run time, are vital for modeling real systems in which security policies may be changed dynamically.
    [Show full text]
  • X86 Assembly Language Reference Manual
    x86 Assembly Language Reference Manual Part No: 817–5477–11 March 2010 Copyright ©2010 Oracle and/or its affiliates. All rights reserved. This software and related documentation are provided under a license agreement containing restrictions on use and disclosure and are protected by intellectual property laws. Except as expressly permitted in your license agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify, license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means. Reverse engineering, disassembly, or decompilation of this software, unless required by law for interoperability, is prohibited. The information contained herein is subject to change without notice and is not warranted to be error-free. If you find any errors, please report them to us in writing. If this is software or related software documentation that is delivered to the U.S. Government or anyone licensing it on behalf of the U.S. Government, the following notice is applicable: U.S. GOVERNMENT RIGHTS Programs, software, databases, and related documentation and technical data delivered to U.S. Government customers are “commercial computer software” or “commercial technical data” pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, the use, duplication, disclosure, modification, and adaptation shall be subject to the restrictions and license terms setforth in the applicable Government contract, and, to the extent applicable by the terms of the Government contract, the additional rights set forth in FAR 52.227-19, Commercial Computer Software License (December 2007). Oracle USA, Inc., 500 Oracle Parkway, Redwood City, CA 94065.
    [Show full text]