DOCSLIB.ORG

Rationale for International Standard - Programming Language - C

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Rationale for International Standard - Programming Language - C Rationale for International Standard - Programming Language - C UNIX is a trademark of X/Open Co., Ltd.. DEC and PDP-11 are trademarks of Digital Equipment Corporation. POSIX is a trademark of IEEE. CONTENTS 1. SCOPE...........................................................................................................................................................1 1.2 ORGANIZATION OF THE DOCUMENT............................................................................................................5 2. NORMATIVE REFERENCES.....................................................................................................................7 3. DEFINITIONS AND CONVENTIONS ........................................................................................................9 4. COMPLIANCE ...........................................................................................................................................11 5. ENVIRONMENT......................................................................................................................................13 5.1 CONCEPTUAL MODELS..............................................................................................................................13 5.1.1 Translation environment ................................................................................................................13 5.1.1.1 Program structure......................................................................................................................................13 5.1.1.2 Translation phases .......................................................................................................................................13 5.1.1.3 Diagnostics .................................................................................................................................................14 5.1.2 Execution environments....................................................................................................................14 5.1.2.1 Freestanding environment.............................................................................................................................14 5.1.2.2 Hosted environment.....................................................................................................................................15 5.1.2.3 Program execution .......................................................................................................................................15 5.2 ENVIRONMENTAL CONSIDERATIONS ..........................................................................................................17 5.2.1 Character sets ...................................................................................................................................17 5.2.1.1 Trigraph sequences ......................................................................................................................................17 5.2.1.2 Multibyte characters.....................................................................................................................................18 5.2.2 Character display semantics ..............................................................................................................19 5.2.3 Signals and interrupts .......................................................................................................................20 5.2.4 Environmental limits.........................................................................................................................20 5.2.4.1 Translation limits.........................................................................................................................................20 5.2.4.2 Numerical limits..........................................................................................................................................20 5.2.4.2.1 Sizes of integer types <limits.h> ............................................................................................................21 5.2.4.2.2 Characteristics of floating types <float.h> ...............................................................................................21 6. LANGUAGE.................................................................................................................................................23 6.1 LEXICAL ELEMENTS .................................................................................................................................23 6.1.1 Keywords..........................................................................................................................................23 6.1.2 Identifiers .........................................................................................................................................23 6.1.2.1 Scopes of identifiers.....................................................................................................................................25 6.1.2.2 Linkages of identifiers..................................................................................................................................26 6.1.2.3 Name spaces of identifiers ............................................................................................................................27 6.1.2.4 Storage durations of objects ..........................................................................................................................28 6.1.2.5 Types .........................................................................................................................................................28 6.1.2.6 Compatible type and composite type..............................................................................................................30 6.1.2.7 Predefined identifiers...................................................................................................................................31 6.1.2.8 Representations of types ...............................................................................................................................31 6.1.2.8.1 General...............................................................................................................................................31 6.1.8.2 Integer types...........................................................................................................................................31 6.1.3 Constants..........................................................................................................................................31 6.1.3.1 Floating constants ........................................................................................................................................31 6.1.3.2 Integer constants..........................................................................................................................................31 6.1.3.3 Enumeration constants .................................................................................................................................32 6.1.3.4 Character constants......................................................................................................................................32 6.1.4 String literals ....................................................................................................................................33 6.1.5 Operators..........................................................................................................................................35 6.1.6 Punctuators ......................................................................................................................................35 6.1.7 Header names...................................................................................................................................35 6.1.8 Preprocessing numbers .....................................................................................................................36 6.1.9 Comments ........................................................................................................................................36 6.2 CONVERSIONS ..........................................................................................................................................37 i CONTENTS 6.2.1 Arithmetic operands..........................................................................................................................37 6.2.1.1 Characters and integers ................................................................................................................................37 6.2.1.2 Signed and unsigned integers........................................................................................................................38 6.2.1.3 Real floating and integer...............................................................................................................................38 6.2.1.4 Real floating types .......................................................................................................................................38 6.2.1.5 Complex types.............................................................................................................................................39 6.2.1.6 Real and complex ........................................................................................................................................39 6.2.1.7 Usual arithmetic conversions ........................................................................................................................39
Load more

Recommended publications
  • Encapsulation and Data Abstraction
    Data abstraction l Data abstraction is the main organizing principle for building complex software systems l Without data abstraction, computing technology would stop dead in its tracks l We will study what data abstraction is and how it is supported by the programming language l The first step toward data abstraction is called encapsulation l Data abstraction is supported by language concepts such as higher-order programming, static scoping, and explicit state Encapsulation l The first step toward data abstraction, which is the basic organizing principle for large programs, is encapsulation l Assume your television set is not enclosed in a box l All the interior circuitry is exposed to the outside l It’s lighter and takes up less space, so it’s good, right? NO! l It’s dangerous for you: if you touch the circuitry, you can get an electric shock l It’s bad for the television set: if you spill a cup of coffee inside it, you can provoke a short-circuit l If you like electronics, you may be tempted to tweak the insides, to “improve” the television’s performance l So it can be a good idea to put the television in an enclosing box l A box that protects the television against damage and that only authorizes proper interaction (on/off, channel selection, volume) Encapsulation in a program l Assume your program uses a stack with the following implementation: fun {NewStack} nil end fun {Push S X} X|S end fun {Pop S X} X=S.1 S.2 end fun {IsEmpty S} S==nil end l This implementation is not encapsulated! l It has the same problems as a television set
    [Show full text]
  • Modern Programming Languages CS508 Virtual University of Pakistan
    Modern Programming Languages (CS508) VU Modern Programming Languages CS508 Virtual University of Pakistan Leaders in Education Technology 1 © Copyright Virtual University of Pakistan Modern Programming Languages (CS508) VU TABLE of CONTENTS Course Objectives...........................................................................................................................4 Introduction and Historical Background (Lecture 1-8)..............................................................5 Language Evaluation Criterion.....................................................................................................6 Language Evaluation Criterion...................................................................................................15 An Introduction to SNOBOL (Lecture 9-12).............................................................................32 Ada Programming Language: An Introduction (Lecture 13-17).............................................45 LISP Programming Language: An Introduction (Lecture 18-21)...........................................63 PROLOG - Programming in Logic (Lecture 22-26) .................................................................77 Java Programming Language (Lecture 27-30)..........................................................................92 C# Programming Language (Lecture 31-34) ...........................................................................111 PHP – Personal Home Page PHP: Hypertext Preprocessor (Lecture 35-37)........................129 Modern Programming Languages-JavaScript
    [Show full text]
  • About ILE C/C++ Compiler Reference
    IBM i 7.3 Programming IBM Rational Development Studio for i ILE C/C++ Compiler Reference IBM SC09-4816-07 Note Before using this information and the product it supports, read the information in “Notices” on page 121. This edition applies to IBM® Rational® Development Studio for i (product number 5770-WDS) and to all subsequent releases and modifications until otherwise indicated in new editions. This version does not run on all reduced instruction set computer (RISC) models nor does it run on CISC models. This document may contain references to Licensed Internal Code. Licensed Internal Code is Machine Code and is licensed to you under the terms of the IBM License Agreement for Machine Code. © Copyright International Business Machines Corporation 1993, 2015. US Government Users Restricted Rights – Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp. Contents ILE C/C++ Compiler Reference............................................................................... 1 What is new for IBM i 7.3.............................................................................................................................3 PDF file for ILE C/C++ Compiler Reference.................................................................................................5 About ILE C/C++ Compiler Reference......................................................................................................... 7 Prerequisite and Related Information..................................................................................................
    [Show full text]
  • 9. Abstract Data Types
    COMPUTER SCIENCE COMPUTER SCIENCE SEDGEWICK/WAYNE SEDGEWICK/WAYNE 9. Abstract Data Types •Overview 9. Abstract Data Types •Color •Image processing •String processing Section 3.1 http://introcs.cs.princeton.edu http://introcs.cs.princeton.edu Abstract data types Object-oriented programming (OOP) A data type is a set of values and a set of operations on those values. Object-oriented programming (OOP). • Create your own data types (sets of values and ops on them). An object holds a data type value. Primitive types • Use them in your programs (manipulate objects). Variable names refer to objects. • values immediately map to machine representations data type set of values examples of operations • operations immediately map to Color three 8-bit integers get red component, brighten machine instructions. Picture 2D array of colors get/set color of pixel (i, j) String sequence of characters length, substring, compare We want to write programs that process other types of data. • Colors, pictures, strings, An abstract data type is a data type whose representation is hidden from the user. • Complex numbers, vectors, matrices, • ... Impact: We can use ADTs without knowing implementation details. • This lecture: how to write client programs for several useful ADTs • Next lecture: how to implement your own ADTs An abstract data type is a data type whose representation is hidden from the user. 3 4 Sound Strings We have already been using ADTs! We have already been using ADTs! A String is a sequence of Unicode characters. defined in terms of its ADT values (typical) Java's String ADT allows us to write Java programs that manipulate strings.
    [Show full text]
  • Abstract Data Types
    Chapter 2 Abstract Data Types The second idea at the core of computer science, along with algorithms, is data. In a modern computer, data consists fundamentally of binary bits, but meaningful data is organized into primitive data types such as integer, real, and boolean and into more complex data structures such as arrays and binary trees. These data types and data structures always come along with associated operations that can be done on the data. For example, the 32-bit int data type is defined both by the fact that a value of type int consists of 32 binary bits but also by the fact that two int values can be added, subtracted, multiplied, compared, and so on. An array is defined both by the fact that it is a sequence of data items of the same basic type, but also by the fact that it is possible to directly access each of the positions in the list based on its numerical index. So the idea of a data type includes a specification of the possible values of that type together with the operations that can be performed on those values. An algorithm is an abstract idea, and a program is an implementation of an algorithm. Similarly, it is useful to be able to work with the abstract idea behind a data type or data structure, without getting bogged down in the implementation details. The abstraction in this case is called an \abstract data type." An abstract data type specifies the values of the type, but not how those values are represented as collections of bits, and it specifies operations on those values in terms of their inputs, outputs, and effects rather than as particular algorithms or program code.
    [Show full text]
  • Technical Study Desktop Internationalization
    Technical Study Desktop Internationalization NIC CH A E L T S T U D Y [This page intentionally left blank] X/Open Technical Study Desktop Internationalisation X/Open Company Ltd. December 1995, X/Open Company Limited All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, photocopying, recording or otherwise, without the prior permission of the copyright owners. X/Open Technical Study Desktop Internationalisation X/Open Document Number: E501 Published by X/Open Company Ltd., U.K. Any comments relating to the material contained in this document may be submitted to X/Open at: X/Open Company Limited Apex Plaza Forbury Road Reading Berkshire, RG1 1AX United Kingdom or by Electronic Mail to: [email protected] ii X/Open Technical Study (1995) Contents Chapter 1 Internationalisation.............................................................................. 1 1.1 Introduction ................................................................................................. 1 1.2 Character Sets and Encodings.................................................................. 2 1.3 The C Programming Language................................................................ 5 1.4 Internationalisation Support in POSIX .................................................. 6 1.5 Internationalisation Support in the X/Open CAE............................... 7 1.5.1 XPG4 Facilities.........................................................................................
    [Show full text]
  • Unix Standardization and Implementation
    Contents 1. Preface/Introduction 2. Standardization and Implementation 3. File I/O 4. Standard I/O Library 5. Files and Directories 6. System Data Files and Information 7. Environment of a Unix Process 8. Process Control 9. Signals 10.Inter-process Communication * All rights reserved, Tei-Wei Kuo, National Taiwan University, 2003. Standardization and Implementation Why Standardization? Proliferation of UNIX versions What should be done? The specifications of limits that each implementation must define! * All rights reserved, Tei-Wei Kuo, National Taiwan University, 2003. 1 UNIX Standardization ANSI C American National Standards Institute ISO/IEC 9899:1990 International Organization for Standardization (ISO) Syntax/Semantics of C, a standard library Purpose: Provide portability of conforming C programs to a wide variety of OS’s. 15 areas: Fig 2.1 – Page 27 * All rights reserved, Tei-Wei Kuo, National Taiwan University, 2003. UNIX Standardization ANSIC C <assert.h> - verify program assertion <ctype.h> - char types <errno.h> - error codes <float.h> - float point constants <limits.h> - implementation constants <locale.h> - locale catalogs <math.h> - mathematical constants <setjmp.h> - nonlocal goto <signal.h> - signals <stdarg.h> - variable argument lists <stddef.h> - standard definitions <stdio.h> - standard library <stdlib.h> - utilities functions <string.h> - string operations <time.h> - time and date * All rights reserved, Tei-Wei Kuo, National Taiwan University, 2003. 2 UNIX Standardization POSIX.1 (Portable Operating System Interface) developed by IEEE Not restricted for Unix-like systems and no distinction for system calls and library functions Originally IEEE Standard 1003.1-1988 1003.2: shells and utilities, 1003.7: system administrator, > 15 other communities Published as IEEE std 1003.1-1990, ISO/IEC9945-1:1990 New: the inclusion of symbolic links No superuser notion * All rights reserved, Tei-Wei Kuo, National Taiwan University, 2003.
    [Show full text]
  • Abstract Data Types (Adts)
    Data abstraction: Abstract Data Types (ADTs) CSE 331 University of Washington Michael Ernst Outline 1. What is an abstract data type (ADT)? 2. How to specify an ADT – immutable – mutable 3. The ADT design methodology Procedural and data abstraction Recall procedural abstraction Abstracts from the details of procedures A specification mechanism Reasoning connects implementation to specification Data abstraction (Abstract Data Type, or ADT): Abstracts from the details of data representation A specification mechanism + a way of thinking about programs and designs Next lecture: ADT implementations Representation invariants (RI), abstraction functions (AF) Why we need Abstract Data Types Organizing and manipulating data is pervasive Inventing and describing algorithms is rare Start your design by designing data structures Write code to access and manipulate data Potential problems with choosing a data structure: Decisions about data structures are made too early Duplication of effort in creating derived data Very hard to change key data structures An ADT is a set of operations ADT abstracts from the organization to meaning of data ADT abstracts from structure to use Representation does not matter; this choice is irrelevant: class RightTriangle { class RightTriangle { float base, altitude; float base, hypot, angle; } } Instead, think of a type as a set of operations create, getBase, getAltitude, getBottomAngle, ... Force clients (users) to call operations to access data Are these classes the same or different? class Point { class Point { public float x; public float r; public float y; public float theta; }} Different: can't replace one with the other Same: both classes implement the concept "2-d point" Goal of ADT methodology is to express the sameness Clients depend only on the concept "2-d point" Good because: Delay decisions Fix bugs Change algorithms (e.g., performance optimizations) Concept of 2-d point, as an ADT class Point { // A 2-d point exists somewhere in the plane, ..
    [Show full text]
  • Csci 658-01: Software Language Engineering Python 3 Reflexive
    CSci 658-01: Software Language Engineering Python 3 Reflexive Metaprogramming Chapter 3 H. Conrad Cunningham 4 May 2018 Contents 3 Decorators and Metaclasses 2 3.1 Basic Function-Level Debugging . .2 3.1.1 Motivating example . .2 3.1.2 Abstraction Principle, staying DRY . .3 3.1.3 Function decorators . .3 3.1.4 Constructing a debug decorator . .4 3.1.5 Using the debug decorator . .6 3.1.6 Case study review . .7 3.1.7 Variations . .7 3.1.7.1 Logging . .7 3.1.7.2 Optional disable . .8 3.2 Extended Function-Level Debugging . .8 3.2.1 Motivating example . .8 3.2.2 Decorators with arguments . .9 3.2.3 Prefix decorator . .9 3.2.4 Reformulated prefix decorator . 10 3.3 Class-Level Debugging . 12 3.3.1 Motivating example . 12 3.3.2 Class-level debugger . 12 3.3.3 Variation: Attribute access debugging . 14 3.4 Class Hierarchy Debugging . 16 3.4.1 Motivating example . 16 3.4.2 Review of objects and types . 17 3.4.3 Class definition process . 18 3.4.4 Changing the metaclass . 20 3.4.5 Debugging using a metaclass . 21 3.4.6 Why metaclasses? . 22 3.5 Chapter Summary . 23 1 3.6 Exercises . 23 3.7 Acknowledgements . 23 3.8 References . 24 3.9 Terms and Concepts . 24 Copyright (C) 2018, H. Conrad Cunningham Professor of Computer and Information Science University of Mississippi 211 Weir Hall P.O. Box 1848 University, MS 38677 (662) 915-5358 Note: This chapter adapts David Beazley’s debugly example presentation from his Python 3 Metaprogramming tutorial at PyCon’2013 [Beazley 2013a].
    [Show full text]
  • ESC 151 –C Programming (ANSI C) Note on Medical Reasons For
    ESC 151 –C Programming (ANSI C) Class: Section 1: Remote, quizzes Monday at 9:30 Section 2: TTH 10:00 AM-11:15 AM Suggested External Information (in place of a book): http://www.cprogramming.com/tutorial/c- tutorial.html Instructor: Robert Fiske Office: FH 315, Office Hours/Availability: Officially: TTH 6:00-8:00 in general I’m available at any time except TTH: 9:00-12:30. Send me an email and if need be we can meet via zoom, if I don’t reply in a timely fashion send another email and/or post on the class discussion board. Note on medical reasons for extensions/other requirements Educational access is the provision of classroom accommodations, auxiliary aids and services to ensure equal educational opportunities for all students regardless of their disability. Any student who feels he or she may need an accommodation based on the impact of a disability should contact the Office of Disability Services at (216)687-2015. The Office is located in MC 147. Accommodations need to be requested in advance and will not be granted retroactively. Any medical/family issues you have need to be brought to my attention before you take any quiz/exam, once the exam is in your hands no makeup will be oered. Once you begin to take an exam/quiz you may not leave the room until you turn in the quiz/exam. Course Objectives: This course is designed to: 1. Introduce the C programming language. 2. Introduce the concepts of computer programming. 3. Teach students to think about how to approach programming challenges.
    [Show full text]
  • Interfacing Modula-2 to C (Draft)
    Interfacing Modula-2 to C (Draft) http://www.zi.biologie.uni-muenchen.de/~enger/SC22WG13/im2c.html Warning This document is not an ISO International Standard. It is distributed for review and comment. It is subject to change without notice and may not be referred to as an International Standard ISO/IEC JTC1/SC22/WG13 XXXXX DATE: 1998-11-30 Replaces Draft from June 1998 ISO/IEC JTC1 SC22/WG13 (Modula-2) DOC TYPE: Draft (Technical Report) TITLE: Interfacing Modula-2 to C SOURCE: PROJECT: JTC1.22.15436 STATUS: ACTION ID: DUE DATE: DISTRIBUTION: MEDIUM: server NO. OF PAGES: 34 Convenor of ISO/IEC JTC1/SC22/WG13 Dr. Martin Schoenhacker Telephone: +43 1 58801 4079; Facsimile: +43 1 5042583; e-mail: [email protected] Project Editor Eberhard Enger e-mail: [email protected] Contents Foreword Introduction 1 Scope 1 von 34 30.11.98 10:51 Interfacing Modula-2 to C (Draft) http://www.zi.biologie.uni-muenchen.de/~enger/SC22WG13/im2c.html 2 Normative references 3 Definitions 4 General 4.1 Purpose and justification 4.2 Specific aims 4.3 Exclusions 4.4 Cooperation and liaison 4.5 Preparatory work 5 Rationale 6 Requirements 6.1 Compilation system 6.2 Required modules 7 Guidelines for interfacing C 7.1 Introduction to the guidelines 7.2 Lexis 7.2.1 Notation for identifiers 7.2.2 Notation of literals 7.2.3 Collisions of names 7.3 Mapping of datatypes 7.3.1 Introduction 7.3.2 Representation 7.3.3 Basic integer types 7.3.4 Enumerations 7.3.5 Floating-point types 7.3.6 Pointer types 7.3.7 Structure types 7.3.8 Union types 7.3.9
    [Show full text]
  • Reference Guide for X86-64 Cpus
    REFERENCE GUIDE FOR X86-64 CPUS Version 2019 TABLE OF CONTENTS Preface............................................................................................................. xi Audience Description.......................................................................................... xi Compatibility and Conformance to Standards............................................................ xi Organization....................................................................................................xii Hardware and Software Constraints...................................................................... xiii Conventions....................................................................................................xiii Terms............................................................................................................xiv Related Publications.......................................................................................... xv Chapter 1. Fortran, C, and C++ Data Types................................................................ 1 1.1. Fortran Data Types....................................................................................... 1 1.1.1. Fortran Scalars.......................................................................................1 1.1.2. FORTRAN real(2).....................................................................................3 1.1.3. FORTRAN 77 Aggregate Data Type Extensions.................................................. 3 1.1.4. Fortran 90 Aggregate Data Types (Derived
    [Show full text]