GraphQuil Language Reference Manual COMS W4115

Size: px
Start display at page:

Transcription

1 GraphQuil Language Reference Manual COMS W4115 Steven Weiner (Systems Architect), Jon Paul (Manager), John Heizelman (Language Guru), Gemma Ragozzine (Tester) Chapter 1 - Introduction Chapter 2 - Types 2.1 Explicit Typing 2.2 Primitive Types Ints Doubles Chars Booleans 2.3 Non-Primitive Types Arrays Strings Nodes Edges Graphs Chapter 3 - Lexical Conventions 3.1 Identifiers 3.2 Reserved Keywords 3.3 Literals Integer Literals Double Literals Bool Literals Char Literals String Literals 3.4 Node Types 3.5 Edge Types 3.6 Operators 3.7 Separators 3.8 White Space 3.9 Comments

2 Chapter 4 - Syntax 4.1 Program Structure 4.2 Expressions Unary Operators Binary Operators Assignment Operators Parenthesized Expressions Function Creation Linking Nodes Accessing Data from Non-primitive Types Using Edges to Retrieve Data 4.3 Statements Assignment and Node Linkage Function Calls Selection Statement Iteration Statement 4.4 Scope Scoping within blocks Scoping within functions Chapter 5 - Library Functions 5.1 Print

3 Chapter 1 - Introduction This is a reference manual for the GraphQuil language. GraphQuil is a specialized programming language designed to easily manage and manipulate data stored in graphs. It is simultaneously a data-definition language as well as a data manipulation language. Users operating GraphQuil will have the ability to create vertices that represent objects while also being able to link them together and define their relationships within a graph.

4 Chapter 2 - Types 2.1 Explicit Typing Data in GraphQuil requires explicit typing. In naming any variable type, an explicit specification of type is required. 2.2 Primitive Types GraphQuil provides four primitive types that make up the basis for arranging data in your programs: int, double, char, and bool. These are the building blocks that define what type of data can be included in each Node Ints Integers, denoted by the keyword int are 32 bit numbers with a minimum value of 2,147,483,648 and a maximum value of 2,147,483,647 (inclusive) Doubles Doubles, denoted by the keyword double, are implemented as 64 bit numbers using the IEEE 754 standard Chars Chars, denoted by the keyword char, is an 8 bit data type used specifically for storing ASCII characters Booleans Booleans, denoted by the keyword bool, accept only true or false values and are used in comparisons of equality. 2.3 Non-Primitive Types Arrays An array is a data structure of user defined types that holds variables and other data structures. Here is an example of the initialization of an array called intarray that would store ints: int[] intarray = new int[5]; Arrays are dynamically sized according to number of elements stored within the Array. intarray has been initialized as being able to store five chars, and so its size is at least 160 bits. Arrays are accessed by index, with indexing starting at 0. The syntax for doing though uses the same brackets as the construction, and returns the value at that index. The same works for assigning to an array. An example of each: int x = intarray[0]; #this accesses the array and copies the value at 0 to x intarray[1] = x;#this sets the spot at index 1 in the array to x

5 Finally, arrays store one additional piece of data, their length as an int, which can be accessed using the operator. followed by the identifier length. For example, int len = intarray.length; would set len to Strings Strings are implemented as arrays of chars. Whitespace is not ignored. Here is an example of the initializing of a String called string : String string = string ; The string stores six chars, and so its size is at least 48 bits Nodes A Node is a data structure specifically for use in a Graph. Nodes are required to store one array, edges, that stores all the outward edges from the node. This array is special in that it may not be modified directly; it is modified automatically on the linking of two nodes, as seen in section Additionally, nodes can only be present in one graph at a time, and a duplicate node with the same data must be created before adding it to a different graph. To meet this requirement, the graph must be specified when creating the node. Each node must also be given its own type before creation, and there is no base implementation of Node within GraphQuil that stores certain variables. Before declaring a node, there must be a defined NodeType to denote what that specific kind of node will hold (see section 3.4 for more information on NodeTypes). However, links can be made irrespective of type, and the type of node does not affect the way links are created between them in the graph Edges An edge is a link created between two nodes. There are two different kinds of edge types, weighted and unweighted. Unweighted edges create links that connect two nodes, but provide no information about those links. Weighted edges, however, in a way similar to nodes, can contain all kinds of data about the connections between different nodes. To create a weighted edge between two nodes, there must first be a defined EdgeType (see section 3.5 for more info), then a declaration of the edge that specifies what type of edge to be created and the data to populate said edge (see section for the syntax for doing so) Graphs Graphs are an aggregate of nodes that allow certain operations to be run upon them and are identified by the keyword Graph. A graph contains one piece of data, which is the array of all of the nodes contained within it, named with the identifier nodes. Because graphs are simply aggregations of different nodes, the syntax used to define them only requires creating an identifier, so the following is sufficient to define a graph: Graph g1;

6 Chapter 3 - Lexical Conventions 3.1 Identifiers Identifiers are the names used to identify individual variables within a given function. Each variable must be given a unique identifier within its scope of the function, and each identifier is case sensitive. These identifiers must begin with an ascii letter (a z or A Z), but each following letter can be either a letter, a digit (0 9), or an underscore (_). The only additional restriction on what strings can be used as identifiers is that they must not match one of the GraphQuil s reserved keywords. 3.2 Reserved Keywords The following is a comprehensive list of reserved keywords ingraphquil: add bool char continue dest do double edges else false for Graph has if in int new Node num print return static String true void while 3.3 Literals Integer Literals Integer literals are made up of digits without any decimal points or other characters separating the digits. They are solely to be used for whole numbers, but they can be positive or negative, distinguished by an included or omitted sign. Additionally, integer literals may not begin with a Double Literals Double literals include digits with a single decimal point, followed by at least one number. A 0 can be the first number if and only if it is immediately followed by a decimal point, although in such a case the 0 is not required. Beyond that, any sequence of numbers followed by a decimal point and another sequence of numbers of length >= 1 can be a double Bool Literals The bool type can hold two different values, true or false, and those exact literals are used to declare which value the bool takes.

7 3.3.4 Char Literals Char literals are a single character surrounded by a single quote ( ) on each side. This character can be any character in the 16 bit Unicode character set, with a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive) String Literals String literals are sequences of chars anywhere from length 0 to the maximum integer value (around 2 billion characters). They must begin and end with quotation marks ( ) and can be filled with any character within the same character set as chars. Additionally, strings support a number of special characters to insert codes into the string, as listed below: \' Single quotation mark ( ) \" Double quotation mark ( ) \\ Backslash (/) \t Tab \b Backspace \r Carriage return \n Newline 3.4 Node Types Before declaring a specific node, a node type must be first established, as there is no general type node to be instantiated by the user. To do so, there must be a line defining what type of node the identifier will be associated with. The type includes a listing of all the values to be stored in that node type, as well as the type of values the node stores. These values can be of any valid primitive or non primitive type, with the exception of graphs, edges, and nodes. Using nodes to store other nodes removes the purpose behind a graph structure, so all data contained within a node must be of some other type. Additionally, each value must be associated with an identifier to indicate what the name of that value is, and each identifier must be unique for that node type. For example, the following is a valid declaration of a NodeType: #assume there is a defined Graph g1 NodeType Student has (String name, int age, String[] courses); To create a particular instance of a node, the type must be specified in its construction, along with the graph the node is inserted into: Node john = new Student( John, 21, { PLT, CS Theory, Aristotle }) in g1; 3.5 Edge Types Creating a weighted edge requires an edge type to define what kind of data the edge will hold. This structure is very similar to defining a NodeType, and requires the identifier of the EdgeType, as well as the types and identifiers for each piece of data to be stored. Also, the same requirement applies in that these values can take any type other than nodes, graphs, or other edges. The convention is as follows:

8 EdgeType relationship has (String type, int closeness, bool positive); 3.6 Operators The following denotes the operators of the language and their intended function: Operator Use Associativity + Adds two values Left - Substracts right from left Left * Multiplies two values Left / Divides right into left Left % Modular division Left = Assignment Right == Equal to Left!= Not equal to Left < Less than Left > Greater than Left <= Less than or equal to Left >= Greater than or equal to Left -> Link from left to right Right <-> Bi-directional link Right! Logical negation Right && Logical and Left Logical or Left The order of precedence is as follows, from greatest to least important: * / % + < > <= >=! ==!= &&

9 = > < > 3.7 Separators The following indicates the separators of the language and their usage. ; Signals the end of a line., Separates one argument from another argument in a declaration statement. (...) A parenthesised expression can be used to separate tokens. The type and value are identical to the same expression without the surrounding parentheses. 3.8 Whitespace White space includes the space character, the tab character, and the newline character. Generally used to separate characters, it is entirely optional. No white space is required. 3.9 Comments Multi line comments are enclosed in #* *# characters. The #* characters introduce a multi line comment and the *# signals the termination of the multi line comment. Single line comments are introduced by the character #. The single line comment terminates at the end of the line with no terminating symbol. Data Type Combinations (Arrays, functions, pointers(?), structs)

10 Chapter 4 - Syntax 4.1 Program Structure A valid program in this language can be composed of as little or as many statements that a user desires. 4.2 Expressions Unary Operators! The character! is the logical NOT operator. This operator checks the value of the one boolean operand. If the boolean operand evaluates to true, then the expression returns false. If the boolean operand evaluates to false, the expression returns true Binary Operators The binary operators are divided into give categories: Assignment Operators, Relational Operators, Arithmetic Operators, Logical Operators, and Graphical Operators Assignment Operators All assignment operators group right to left. = The simple assignment operator is the = character. Simple assignment takes the following form: type declaration identifier = expression The value of the expression on the right hand side of the operator replaces the semanti value of the identifier on the right. This value must be equal in type to the declared type of the identifier. += The add AND assignment operator is the two characters +=. This operator adds the semantic value of the operand on the right to the value of the left operand. This operato can only be applied to operands of primitive data types. + The subtract AND assignment operator is the two characters =. The operator subtracts the semantic value of the operand on the right from the value of the left operand. This operator can only be applied to operands of primitive data types.

11 4.2.3 Relational Operators == Two sequential equal signs denotes an equality operator. This operator checks if the values of the two operands are equal in reference. If they are equal, it returns a true boolean, else it returns a false boolean.!= The characters!= denote a not equal operator. Like the equality operator, it checks to see if the two operands are equal or not. If the left and right operands are equal in reference, then the expression evaluates to false. If the operands are not equal in reference, then the expression evaluates to true. > The character > denotes the greater than operator. This can only be used when the left and right operands are primitive types. The greater than operator checks if the value of the left operand is greater than the value of the right operand. If this is true, then the expression returns true. If not, the expression evaluates to false. < The character < denotes the less than operator. This can only be used when the left and right operands are primitive types. The less than operator checks if the valu of the left operand is less than the value of the right operand. If this is true, then the expression returns true. If not, the expression evaluates to false. >= The characters >= denote the greater than or equal to operator. This operator checks if the value of the left operand is greater than or equal to the value of the right operand. If this is true, then the expression returns true. If not, the expression evaluates to false. Like the greater than and less than operators, this operator can only be used when both operands are primitive types. <= The characters <= denote the less than or equal to operator. This operator checks if the value of the left operand is less than or equal to the value of the right operand. I this is true, then the expression returns true. If not, the expression evaluates to false. Like the greater than, less than, and greater than or equal to operators, this operator can only be used when both operands are primitive types Arithmetic Operators These operators only can be performed on primitive data types. + The + character signifies the addition operator. It adds the semantic value of the operands on the left and right side. The character is the subtraction operator. It subtracts the value of the right hand operator from the left hand operator to produce a new result. * The * character is the multiplication operator. It multiplies the values of the operands on the left and right side of the operator.

12 / The / character denotes the division operator. This divides the value of the left hand operator by the value of the right hand operator. % The % character is the modulus operator. It divides the value of the left hand operator by the value of the right hand operator, and returns the remainder of the division Logical Operators && The characters && signify the logical AND operator. This operator checks the value of two boolean operands. If both boolean operands evaluate to true, then the expression returns true. In any other case, the expression evaluates to false. The characters signify the logical OR operator. Like the logical AND operator, this checks the value of the two boolean operands, but it only returns true if any of the operands (the left operand, the right operand, or both operands) evaluate to true Graphical Operators These operators only work when both operands are Nodes. > The characters > signify the directional link operator. It adds a directional link (edge) from the operand on the left hand side to the operand on the right hand side. The operand on the right hand side is added to the list of destination nodes of the operand on the right hand side. < > The characters < > denote the bidirectional link operator. It adds a bidirectional (and therefore, undirected) link between the left operand and the right operand. In each Nod operand, the other Node operand is added to the list of destination nodes Parenthesized Expressions Parenthesized expressions are a tool to override the built in order of operations in GraphQuil. Parenthesis force the evaluation of the expression inside of them before using that value in whatever other expression the parenthetical is contained in. For example, if a given expression is , the internal order of operations would give the equivalent of (1 2) + 3, which equals 2. If however, parenthesis are added to make 1 (2 + 3), which equals 4. This works for all operators in all expressions Function Creation Functions are declared by giving a return type of the function, a unique identifier for the function, any arguments passed in, then creating and closing a block with the function body. The syntax is as follows: return_type identifier (argtype arg_identifier, ) { return out; }

13 The type of out must match the return type declared at the beginning of the function, and each function must return a type. The only exception to this rule is if the function is declared with the return type void, then the function should not return any type. If at any point the function should return before the end of the block, putting return; will break out of the function and return to wherever the function was called Linking Nodes Given two nodes node1 and node2, there are two main ways of creating edges between the nodes, weighted and unweighted. Edges that have no weight merely create a connection between the two nodes and contain no more information about those connections. They are created using the following statements: node1 > node2; #Creates an unweighted, directed edge from node1 to node2 node1 < > node2; #Creates an unweighted, bidirectional edge between the nodes To create a weighted node, there must first be a specified edge type (see section 3.5 which describes how to do so). Then, the syntax requires an assignment of an EdgeType to the edge created between the two nodes. In the same way a variable is assigned a value, the edge created between two nodes can be assigned a value (which requires a type) by assigning a newly constructed weighted edge to the connection between two nodes, as seen here: EdgeType relationship has (String type, int closeness, bool positive); billy > allie = new relationship( siblings, 10, true); Finally, either kind of edge can only be valid if both nodes are in the same graph. The compiler will give an error if the two nodes are not in the same graph Accessing Data from Non-primitive Types To access the data stored in a non primitive type, the operator. is used, followed by the identifier given to the piece of data you want to access. This access has highest precedence in the order of operations, and the value will be pulled from the object before any other operations are done using the value, unless overridden by parenthesis. It works for accessing the values in nodes, edges, the length of arrays, and the node array of a graph. All of the following are valid: int x = john.age; #where john is a Node containing an int named age x = intarray.length; Node[] nodes = g1.nodes; #note that this returns all nodes in a given graph String str = edge1.relationship; #where edge1 is an Edge containing said String Using Edges to Retrieve Data Accessing all the nodes connection to a node is done through the edges directed outward from a node. To access these, each node type has an implicit array stored inside it with the identifier edges. This array has contains values of type Edge (which includes all EdgeTypes and unweighted edges), and can be accessed in the same way any other data can be accessed from a node by the following: Edge[] edgearray = node_indentifier.edges;

14 Then, that array can be used to iterate through and find any particular edge or node needed. Additionally, each edge, whether weighted or unweighted, contains a reference to the destination of the edge, associated with the identifier dest. This is done using the same syntax for accessing data for any non-primitive type, as follows: Node example = edge1.dest; 4.3 Statements At their core, statements execute specific tasks, control the order and flow of processes being taken, and are performed in the order in which they appear Assignment Statements Assignments of nodes and node values are performed in two separate ways. The first involves setting a variable as equivalent to another variable or expression. This is performed by using an equals sign, seen in the following: Node node1= new CUStudent ( jrh2184, John, Heizelman, 2016) in classroom; Node node2= new CUStudent ( jp3144, Jon, Paul, 2015) in classroom; node2=node1; #node2 now refers to the CUStudent node named with uni jrh2184 #the CUStudent node with uni jp3144 still exists in the classroom, though To assign values into node fields, the. operator is used: node2.uni= jrh2184 ; #updates the uni field of node1 to jrh Function Calls Function call statements are performed simply by using the desired function in any kind of expression. The function call takes highest precedence and will return its data type and use that piece of data in the expression. See the following example: node2.uni = getuni(name); Where getuni is defined as: String getuni(string name) {... } Conditional Statement Usage of the if statement allows a certain set of steps to be taken given an explicit condition. For example, here is the construction for an if statement based on an explicit condition. if (node1.year== 2015) { #insert set of tasks to be performed here }

15 Additionally, if a given condition is not met and the user desires to outline another condition, the else if construction can be used. if (node1.year== 2015) { #insert set of tasks to be performed here } else if (node1.year==2016) { #insert set of tasks to be performed here } Lastly, the else construction allows users to perform a set of tasks if none of the prior mentioned if or else if conditions are met. if (node1.year== 2015) { #insert set of tasks to be performed here } else if (node1.year==2016) { #insert set of tasks to be performed here } else { #insert set of tasks to be performed here } Iteration Statement Iteration statements are performed using for or while, in order to generate loops that execute a set of tasks. For example, running a set of tasks on all pieces of data in an array uses a for loop. The syntax is simple, where each object of the type in the array can be named (in this case tmp), and the loop will apply the set of tasks in the brackets to each object in the array. See the following example for ( Node tmp : classroom) { #where classroom is an array filled with nodes #insert set of tasks to be performed here } Using a while loop is very similar. The set of task outlined within the loop are executed as long as the condition denoted in the while loop is met, where the condition is an expression that results in a bool. The condition is re-evaluated after each pass through the loop (given the case that the condition initially passes). while (node1.year==2015){ #insert set of tasks to be performed here }

16 4.4 Scope Scoping within blocks Variables defined within blocks (separated by { and }) are only accessible within the block they are defined. For example, the following is invalid: if(x = true) { String abc = abc ; } abc.length(); The only exception to this blocking rule is the declaration of non-primitive variables using the new keyword, be they graphs, nodes, or some other type. This declares a new object that is not deleted until all references to it are removed and are taken care of by behind-the-scenes garbage collection Scoping within functions Similar to the block scoping, variables defined within a function are only applicable within that function. This applies both to the variables passed into a function and the ones named and created within it. The same exception is the declaration of non-primitives using the new keyword applies as before. The main difference in the difference between function scoping and scoping within a block is in the return statement. When returning a primitive type, the value of the primitive being returned is copied directly to the expression that called the function. However, when returning a non-primitive type, a reference to the object is returned and used in the expression. The memory used to store the object remains valid until all references to it are gone, then the built-in garbage collection system removes it from the allocated memory.

17 Chapter 5 - Library Functions 5.1 Print GraphQuil includes a built-in print to console feature. To print a String or primitive type toprint, the statement: print(toprint); Multiple Strings or primitives may be printed to console in one statement, separated by the plus sign as follows (for String or primitives toprint1 and toprint2): print(toprint1 + toprint2); Any number of Strings or primitives may be printed in a single print statement as long as they are separated by plus signs as shown above. Attempting to print the literal \n produces a newline in the console. Only Strings and primitives may be printed; printing non-primitives directly is not allowed and elicits a compiler warning.

Language Reference Manual

ALACS Language Reference Manual Manager: Gabriel Lopez (gal2129) Language Guru: Gabriel Kramer-Garcia (glk2110) System Architect: Candace Johnson (crj2121) Tester: Terence Jacobs (tj2316) Table of Contents

Contents. Jairo Pava COMS W4115 June 28, 2013 LEARN: Language Reference Manual

Jairo Pava COMS W4115 June 28, 2013 LEARN: Language Reference Manual Contents 1 Introduction...2 2 Lexical Conventions...2 3 Types...3 4 Syntax...3 5 Expressions...4 6 Declarations...8 7 Statements...9

Lexical Considerations

Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Fall 2005 Handout 6 Decaf Language Wednesday, September 7 The project for the course is to write a

GOLD Language Reference Manual

GOLD Language Reference Manual Language Guru: Timothy E. Chung (tec2123) System Architect: Aidan Rivera (ar3441) Manager: Zeke Reyna (eer2138) Tester: Dennis Guzman (drg2156) October 16th, 2017 1 Introduction

Lexical Considerations

Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2010 Handout Decaf Language Tuesday, Feb 2 The project for the course is to write a compiler

The SPL Programming Language Reference Manual

The SPL Programming Language Reference Manual Leonidas Fegaras University of Texas at Arlington Arlington, TX 76019 fegaras@cse.uta.edu February 27, 2018 1 Introduction The SPL language is a Small Programming

MATVEC: MATRIX-VECTOR COMPUTATION LANGUAGE REFERENCE MANUAL. John C. Murphy jcm2105 Programming Languages and Translators Professor Stephen Edwards

MATVEC: MATRIX-VECTOR COMPUTATION LANGUAGE REFERENCE MANUAL John C. Murphy jcm2105 Programming Languages and Translators Professor Stephen Edwards Language Reference Manual Introduction The purpose of

1 Lexical Considerations

Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2013 Handout Decaf Language Thursday, Feb 7 The project for the course is to write a compiler

CSc 10200! Introduction to Computing. Lecture 2-3 Edgardo Molina Fall 2013 City College of New York

CSc 10200! Introduction to Computing Lecture 2-3 Edgardo Molina Fall 2013 City College of New York 1 C++ for Engineers and Scientists Third Edition Chapter 2 Problem Solving Using C++ 2 Objectives In this

The Warhol Language Reference Manual

The Warhol Language Reference Manual Martina Atabong maa2247 Charvinia Neblett cdn2118 Samuel Nnodim son2105 Catherine Wes ciw2109 Sarina Xie sx2166 Introduction Warhol is a functional and imperative programming

UNIT- 3 Introduction to C++

UNIT- 3 Introduction to C++ C++ Character Sets: Letters A-Z, a-z Digits 0-9 Special Symbols Space + - * / ^ \ ( ) [ ] =!= . \$, ; : %! &? _ # = @ White Spaces Blank spaces, horizontal tab, carriage

BoredGames Language Reference Manual A Language for Board Games. Brandon Kessler (bpk2107) and Kristen Wise (kew2132)

BoredGames Language Reference Manual A Language for Board Games Brandon Kessler (bpk2107) and Kristen Wise (kew2132) 1 Table of Contents 1. Introduction... 4 2. Lexical Conventions... 4 2.A Comments...

egrapher Language Reference Manual

egrapher Language Reference Manual Long Long: ll3078@columbia.edu Xinli Jia: xj2191@columbia.edu Jiefu Ying: jy2799@columbia.edu Linnan Wang: lw2645@columbia.edu Darren Chen: dsc2155@columbia.edu 1. Introduction

ARG! Language Reference Manual

ARG! Language Reference Manual Ryan Eagan, Mike Goldin, River Keefer, Shivangi Saxena 1. Introduction ARG is a language to be used to make programming a less frustrating experience. It is similar to C

The PCAT Programming Language Reference Manual

The PCAT Programming Language Reference Manual Andrew Tolmach and Jingke Li Dept. of Computer Science Portland State University September 27, 1995 (revised October 15, 2002) 1 Introduction The PCAT language

Sprite an animation manipulation language Language Reference Manual

Sprite an animation manipulation language Language Reference Manual Team Leader Dave Smith Team Members Dan Benamy John Morales Monica Ranadive Table of Contents A. Introduction...3 B. Lexical Conventions...3

IPCoreL. Phillip Duane Douglas, Jr. 11/3/2010

IPCoreL Programming Language Reference Manual Phillip Duane Douglas, Jr. 11/3/2010 The IPCoreL Programming Language Reference Manual provides concise information about the grammar, syntax, semantics, and

Language Reference Manual simplicity

Language Reference Manual simplicity Course: COMS S4115 Professor: Dr. Stephen Edwards TA: Graham Gobieski Date: July 20, 2016 Group members Rui Gu rg2970 Adam Hadar anh2130 Zachary Moffitt znm2104 Suzanna

Ordinary Differential Equation Solver Language (ODESL) Reference Manual

Ordinary Differential Equation Solver Language (ODESL) Reference Manual Rui Chen 11/03/2010 1. Introduction ODESL is a computer language specifically designed to solve ordinary differential equations (ODE

Full file at C How to Program, 6/e Multiple Choice Test Bank

2.1 Introduction 2.2 A Simple Program: Printing a Line of Text 2.1 Lines beginning with let the computer know that the rest of the line is a comment. (a) /* (b) ** (c) REM (d)

COMS W4115 Programming Languages & Translators GIRAPHE. Language Reference Manual

COMS W4115 Programming Languages & Translators GIRAPHE Language Reference Manual Name UNI Dianya Jiang dj2459 Vince Pallone vgp2105 Minh Truong mt3077 Tongyun Wu tw2568 Yoki Yuan yy2738 1 Lexical Elements

GBIL: Generic Binary Instrumentation Language. Language Reference Manual. By: Andrew Calvano. COMS W4115 Fall 2015 CVN

GBIL: Generic Binary Instrumentation Language Language Reference Manual By: Andrew Calvano COMS W4115 Fall 2015 CVN Table of Contents 1) Introduction 2) Lexical Conventions 1. Tokens 2. Whitespace 3. Comments

IC Language Specification

CS 301 Spring 2016 IC Language Specification The IC Language For the implementation project, you will build a compiler for an object-oriented language called IC (for Irish Coffee 1 ), which is essentially

Decaf Language Reference Manual

Decaf Language Reference Manual C. R. Ramakrishnan Department of Computer Science SUNY at Stony Brook Stony Brook, NY 11794-4400 cram@cs.stonybrook.edu February 12, 2012 Decaf is a small object oriented

BASIC ELEMENTS OF A COMPUTER PROGRAM

BASIC ELEMENTS OF A COMPUTER PROGRAM CSC128 FUNDAMENTALS OF COMPUTER PROBLEM SOLVING LOGO Contents 1 Identifier 2 3 Rules for naming and declaring data variables Basic data types 4 Arithmetic operators

GridLang: Grid Based Game Development Language Language Reference Manual. Programming Language and Translators - Spring 2017 Prof.

GridLang: Grid Based Game Development Language Language Reference Manual Programming Language and Translators - Spring 2017 Prof. Stephen Edwards Akshay Nagpal Dhruv Shekhawat Parth Panchmatia Sagar Damani

c) Comments do not cause any machine language object code to be generated. d) Lengthy comments can cause poor execution-time performance.

2.1 Introduction (No questions.) 2.2 A Simple Program: Printing a Line of Text 2.1 Which of the following must every C program have? (a) main (b) #include (c) /* (d) 2.2 Every statement in C

ASML Language Reference Manual

ASML Language Reference Manual Tim Favorite (tuf1) & Frank Smith (fas2114) - Team SoundHammer Columbia University COMS W4115 - Programming Languages & Translators 1. Introduction The purpose of Atomic

Java Notes. 10th ICSE. Saravanan Ganesh

Java Notes 10th ICSE Saravanan Ganesh 13 Java Character Set Character set is a set of valid characters that a language can recognise A character represents any letter, digit or any other sign Java uses

Java+- Language Reference Manual

Fall 2016 COMS4115 Programming Languages & Translators Java+- Language Reference Manual Authors Ashley Daguanno (ad3079) - Manager Anna Wen (aw2802) - Tester Tin Nilar Hlaing (th2520) - Systems Architect

Programming Languages & Translators. XML Document Manipulation Language (XDML) Language Reference Manual

Programming Languages & Translators (COMS W4115) Department of Computer Science Columbia University Summer 2007 XML Document Manipulation Language (XDML) Language Reference Manual Luba Leyzerenok ll2310@columbia.edu

\n is used in a string to indicate the newline character. An expression produces data. The simplest expression

Chapter 1 Summary Comments are indicated by a hash sign # (also known as the pound or number sign). Text to the right of the hash sign is ignored. (But, hash loses its special meaning if it is part of

DaMPL. Language Reference Manual. Henrique Grando

DaMPL Language Reference Manual Bernardo Abreu Felipe Rocha Henrique Grando Hugo Sousa bd2440 flt2107 hp2409 ha2398 Contents 1. Getting Started... 4 2. Syntax Notations... 4 3. Lexical Conventions... 4

Learning Language. Reference Manual. George Liao (gkl2104) Joseanibal Colon Ramos (jc2373) Stephen Robinson (sar2120) Huabiao Xu(hx2104)

Learning Language Reference Manual 1 George Liao (gkl2104) Joseanibal Colon Ramos (jc2373) Stephen Robinson (sar2120) Huabiao Xu(hx2104) A. Introduction Learning Language is a programming language designed

3. Except for strings, double quotes, identifiers, and keywords, C++ ignores all white space.

Chapter 2: Problem Solving Using C++ TRUE/FALSE 1. Modular programs are easier to develop, correct, and modify than programs constructed in some other manner. ANS: T PTS: 1 REF: 45 2. One important requirement

Typescript on LLVM Language Reference Manual

Typescript on LLVM Language Reference Manual Ratheet Pandya UNI: rp2707 COMS 4115 H01 (CVN) 1. Introduction 2. Lexical Conventions 2.1 Tokens 2.2 Comments 2.3 Identifiers 2.4 Reserved Keywords 2.5 String

Chapter 2: Using Data

Chapter 2: Using Data TRUE/FALSE 1. A variable can hold more than one value at a time. F PTS: 1 REF: 52 2. The legal integer values are -2 31 through 2 31-1. These are the highest and lowest values that

Review: Exam 1. Your First C++ Program. Declaration Statements. Tells the compiler. Examples of declaration statements

Review: Exam 1 9/20/06 CS150 Introduction to Computer Science 1 1 Your First C++ Program 1 //*********************************************************** 2 // File name: hello.cpp 3 // Author: Shereen Khoja

Introduction to C# Applications

1 2 3 Introduction to C# Applications OBJECTIVES To write simple C# applications To write statements that input and output data to the screen. To declare and use data of various types. To write decision-making

corgi Language Reference Manual COMS W4115

corgi Language Reference Manual COMS W4115 Philippe Guillaume Losembe (pvl2109) Alisha Sindhwani (as4312) Melissa O Sullivan (mko2110) Justin Zhao (jxz2101) October 27, 2014 Chapter 1: Introduction corgi

Objectives. Chapter 2: Basic Elements of C++ Introduction. Objectives (cont d.) A C++ Program (cont d.) A C++ Program

Objectives Chapter 2: Basic Elements of C++ In this chapter, you will: Become familiar with functions, special symbols, and identifiers in C++ Explore simple data types Discover how a program evaluates

Chapter 2: Basic Elements of C++

Chapter 2: Basic Elements of C++ Objectives In this chapter, you will: Become familiar with functions, special symbols, and identifiers in C++ Explore simple data types Discover how a program evaluates

SMURF Language Reference Manual Serial MUsic Represented as Functions

SMURF Language Reference Manual Serial MUsic Represented as Functions Richard Townsend, Lianne Lairmore, Lindsay Neubauer, Van Bui, Kuangya Zhai {rt2515, lel2143, lan2135, vb2363, kz2219}@columbia.edu

Chapter 2: Basic Elements of C++ Objectives. Objectives (cont d.) A C++ Program. Introduction

Chapter 2: Basic Elements of C++ C++ Programming: From Problem Analysis to Program Design, Fifth Edition 1 Objectives In this chapter, you will: Become familiar with functions, special symbols, and identifiers

GeoCode Language Reference Manual

GeoCode Language Reference Manual Contents 1 Introduction... 3 2 Lexical Elements... 3 2.1 Identifiers... 3 2.2 Keywords... 3 2.3 Literals... 3 2.4 Line Structure... 4 2.5 Indentation... 4 2.6 Whitespace...

SSOL Language Reference Manual

SSOL Language Reference Manual Madeleine Tipp Jeevan Farias Daniel Mesko mrt2148 jtf2126 dpm2153 Manager Language Guru System Architect October 15, 2018 Contents 1 Lexical Conventions 2 1.1 Identifiers...............................................

String Computation Program

String Computation Program Reference Manual Scott Pender scp2135@columbia.edu COMS4115 Fall 2012 10/31/2012 1 Lexical Conventions There are four kinds of tokens: identifiers, keywords, expression operators,

Chapter 1 Summary. Chapter 2 Summary. end of a string, in which case the string can span multiple lines.

Chapter 1 Summary Comments are indicated by a hash sign # (also known as the pound or number sign). Text to the right of the hash sign is ignored. (But, hash loses its special meaning if it is part of

The pixelman Language Reference Manual. Anthony Chan, Teresa Choe, Gabriel Kramer-Garcia, Brian Tsau

The pixelman Language Reference Manual Anthony Chan, Teresa Choe, Gabriel Kramer-Garcia, Brian Tsau October 2017 Contents 1 Introduction 2 2 Lexical Conventions 2 2.1 Comments..........................................

Basics of Java Programming

Basics of Java Programming Lecture 2 COP 3252 Summer 2017 May 16, 2017 Components of a Java Program statements - A statement is some action or sequence of actions, given as a command in code. A statement

Lecture 3 Tao Wang 1

Lecture 3 Tao Wang 1 Objectives In this chapter, you will learn about: Arithmetic operations Variables and declaration statements Program input using the cin object Common programming errors C++ for Engineers

Objectives. In this chapter, you will:

Objectives In this chapter, you will: Become familiar with functions, special symbols, and identifiers in C++ Explore simple data types Discover how a program evaluates arithmetic expressions Learn about

Chapter 2 Using Data. Instructor s Manual Table of Contents. At a Glance. Overview. Objectives. Teaching Tips. Quick Quizzes. Class Discussion Topics

Java Programming, Sixth Edition 2-1 Chapter 2 Using Data At a Glance Instructor s Manual Table of Contents Overview Objectives Teaching Tips Quick Quizzes Class Discussion Topics Additional Projects Additional

Cellular Automata Language (CAL) Language Reference Manual

Cellular Automata Language (CAL) Language Reference Manual Calvin Hu, Nathan Keane, Eugene Kim {ch2880, nak2126, esk2152@columbia.edu Columbia University COMS 4115: Programming Languages and Translators

Language Reference Manual

TAPE: A File Handling Language Language Reference Manual Tianhua Fang (tf2377) Alexander Sato (as4628) Priscilla Wang (pyw2102) Edwin Chan (cc3919) Programming Languages and Translators COMSW 4115 Fall

TED Language Reference Manual

1 TED Language Reference Manual Theodore Ahlfeld(twa2108), Konstantin Itskov(koi2104) Matthew Haigh(mlh2196), Gideon Mendels(gm2597) Preface 1. Lexical Elements 1.1 Identifiers 1.2 Keywords 1.3 Constants

FRAC: Language Reference Manual

FRAC: Language Reference Manual Justin Chiang jc4127 Kunal Kamath kak2211 Calvin Li ctl2124 Anne Zhang az2350 1. Introduction FRAC is a domain-specific programming language that enables the programmer

CMPT 125: Lecture 3 Data and Expressions

CMPT 125: Lecture 3 Data and Expressions Tamara Smyth, tamaras@cs.sfu.ca School of Computing Science, Simon Fraser University January 3, 2009 1 Character Strings A character string is an object in Java,

Object oriented programming. Instructor: Masoud Asghari Web page: Ch: 3

Object oriented programming Instructor: Masoud Asghari Web page: http://www.masses.ir/lectures/oops2017sut Ch: 3 1 In this slide We follow: https://docs.oracle.com/javase/tutorial/index.html Trail: Learning

Expressions and Data Types CSC 121 Spring 2015 Howard Rosenthal

Expressions and Data Types CSC 121 Spring 2015 Howard Rosenthal Lesson Goals Understand the basic constructs of a Java Program Understand how to use basic identifiers Understand simple Java data types

Creating a C++ Program

Program A computer program (also software, or just a program) is a sequence of instructions written in a sequence to perform a specified task with a computer. 1 Creating a C++ Program created using an

Features of C. Portable Procedural / Modular Structured Language Statically typed Middle level language

1 History C is a general-purpose, high-level language that was originally developed by Dennis M. Ritchie to develop the UNIX operating system at Bell Labs. C was originally first implemented on the DEC

XQ: An XML Query Language Language Reference Manual

XQ: An XML Query Language Language Reference Manual Kin Ng kn2006@columbia.edu 1. Introduction XQ is a query language for XML documents. This language enables programmers to express queries in a few simple

Petros: A Multi-purpose Text File Manipulation Language

Petros: A Multi-purpose Text File Manipulation Language Language Reference Manual Joseph Sherrick js2778@columbia.edu June 20, 2008 Table of Contents 1 Introduction...................................................

Fundamental of Programming (C)

Borrowed from lecturer notes by Omid Jafarinezhad Fundamental of Programming (C) Lecturer: Vahid Khodabakhshi Lecture 3 Constants, Variables, Data Types, And Operations Department of Computer Engineering

Full file at

Java Programming: From Problem Analysis to Program Design, 3 rd Edition 2-1 Chapter 2 Basic Elements of Java At a Glance Instructor s Manual Table of Contents Overview Objectives s Quick Quizzes Class

2.1. Chapter 2: Parts of a C++ Program. Parts of a C++ Program. Introduction to C++ Parts of a C++ Program

Chapter 2: Introduction to C++ 2.1 Parts of a C++ Program Copyright 2009 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 2-1 Parts of a C++ Program Parts of a C++ Program // sample C++ program

Full file at

Java Programming, Fifth Edition 2-1 Chapter 2 Using Data within a Program At a Glance Instructor s Manual Table of Contents Overview Objectives Teaching Tips Quick Quizzes Class Discussion Topics Additional

C: How to Program. Week /Mar/05

1 C: How to Program Week 2 2007/Mar/05 Chapter 2 - Introduction to C Programming 2 Outline 2.1 Introduction 2.2 A Simple C Program: Printing a Line of Text 2.3 Another Simple C Program: Adding Two Integers

6.096 Introduction to C++ January (IAP) 2009

MIT OpenCourseWare http://ocw.mit.edu 6.096 Introduction to C++ January (IAP) 2009 For information about citing these materials or our Terms of Use, visit: http://ocw.mit.edu/terms. Welcome to 6.096 Lecture

VENTURE. Section 1. Lexical Elements. 1.1 Identifiers. 1.2 Keywords. 1.3 Literals

VENTURE COMS 4115 - Language Reference Manual Zach Adler (zpa2001), Ben Carlin (bc2620), Naina Sahrawat (ns3001), James Sands (js4597) Section 1. Lexical Elements 1.1 Identifiers An identifier in VENTURE

IT 374 C# and Applications/ IT695 C# Data Structures

IT 374 C# and Applications/ IT695 C# Data Structures Module 2.1: Introduction to C# App Programming Xianrong (Shawn) Zheng Spring 2017 1 Outline Introduction Creating a Simple App String Interpolation

Chapter-8 DATA TYPES. Introduction. Variable:

Chapter-8 DATA TYPES Introduction To understand any programming languages we need to first understand the elementary concepts which form the building block of that program. The basic building blocks include

Visual C# 2005 2-1 Chapter 2 Using Data At a Glance Instructor s Manual Table of Contents Overview Objectives s Quick Quizzes Class Discussion Topics Additional Projects Additional Resources Key Terms

EDIABAS BEST/2 LANGUAGE DESCRIPTION. VERSION 6b. Electronic Diagnostic Basic System EDIABAS - BEST/2 LANGUAGE DESCRIPTION

EDIABAS Electronic Diagnostic Basic System BEST/2 LANGUAGE DESCRIPTION VERSION 6b Copyright BMW AG, created by Softing AG BEST2SPC.DOC CONTENTS CONTENTS...2 1. INTRODUCTION TO BEST/2...5 2. TEXT CONVENTIONS...6

Chapter 2 Basic Elements of C++

C++ Programming: From Problem Analysis to Program Design, Fifth Edition 2-1 Chapter 2 Basic Elements of C++ At a Glance Instructor s Manual Table of Contents Overview Objectives s Quick Quizzes Class Discussion

BITG 1233: Introduction to C++

BITG 1233: Introduction to C++ 1 Learning Outcomes At the end of this lecture, you should be able to: Identify basic structure of C++ program (pg 3) Describe the concepts of : Character set. (pg 11) Token

Overview of C. Basic Data Types Constants Variables Identifiers Keywords Basic I/O

Overview of C Basic Data Types Constants Variables Identifiers Keywords Basic I/O NOTE: There are six classes of tokens: identifiers, keywords, constants, string literals, operators, and other separators.

MELODY. Language Reference Manual. Music Programming Language

MELODY Language Reference Manual Music Programming Language Tong GE Jingsi LI Shuo YANG tg2473 jl4165 sy2515 1. Introduction 2. Lexical Conventions 2.1 Comments 2.2 Identifiers 2.3 Keywords 2.4 Constants

SFPL Reference Manual

1 SFPL Reference Manual By: Huang-Hsu Chen (hc2237) Xiao Song Lu(xl2144) Natasha Nezhdanova(nin2001) Ling Zhu(lz2153) 2 1. Lexical Conventions 1.1 Tokens There are six classes of tokes: identifiers, keywords,

RTL Reference 1. JVM. 2. Lexical Conventions

RTL Reference 1. JVM Record Transformation Language (RTL) runs on the JVM. Runtime support for operations on data types are all implemented in Java. This constrains the data types to be compatible to Java's

Chapter 2 - Introduction to C Programming

Chapter 2 - Introduction to C Programming 2 Outline 2.1 Introduction 2.2 A Simple C Program: Printing a Line of Text 2.3 Another Simple C Program: Adding Two Integers 2.4 Memory Concepts 2.5 Arithmetic

Chapter 2: Introduction to C++

Chapter 2: Introduction to C++ Copyright 2010 Pearson Education, Inc. Copyright Publishing as 2010 Pearson Pearson Addison-Wesley Education, Inc. Publishing as Pearson Addison-Wesley 2.1 Parts of a C++

Reserved Words and Identifiers

1 Programming in C Reserved Words and Identifiers Reserved word Word that has a specific meaning in C Ex: int, return Identifier Word used to name and refer to a data element or object manipulated by the

Chapter 2 Using Data. Instructor s Manual Table of Contents. At a Glance. A Guide to this Instructor s Manual:

Java Programming, Eighth Edition 2-1 Chapter 2 Using Data A Guide to this Instructor s Manual: We have designed this Instructor s Manual to supplement and enhance your teaching experience through classroom

Chapter 2: Special Characters. Parts of a C++ Program. Introduction to C++ Displays output on the computer screen

Chapter 2: Introduction to C++ 2.1 Parts of a C++ Program Copyright 2009 Pearson Education, Inc. Copyright 2009 Publishing Pearson as Pearson Education, Addison-Wesley Inc. Publishing as Pearson Addison-Wesley

JME Language Reference Manual

JME Language Reference Manual 1 Introduction JME (pronounced jay+me) is a lightweight language that allows programmers to easily perform statistic computations on tabular data as part of data analysis.

Decaf Language Reference

Decaf Language Reference Mike Lam, James Madison University Fall 2016 1 Introduction Decaf is an imperative language similar to Java or C, but is greatly simplified compared to those languages. It will

Senet. Language Reference Manual. 26 th October Lilia Nikolova Maxim Sigalov Dhruvkumar Motwani Srihari Sridhar Richard Muñoz

Senet Language Reference Manual 26 th October 2015 Lilia Nikolova Maxim Sigalov Dhruvkumar Motwani Srihari Sridhar Richard Muñoz 1. Overview Past projects for Programming Languages and Translators have

easel LANGUAGE REFERENCE MANUAL

easel LANGUAGE REFERENCE MANUAL Manager Danielle Crosswell dac2182 Language Guru Tyrus Cukavac thc2125 System Architect Yuan-Chao Chou yc3211 Tester Xiaofei Chen xc2364 Table of Contents 1. Introduction...

Expressions and Data Types CSC 121 Fall 2015 Howard Rosenthal

Expressions and Data Types CSC 121 Fall 2015 Howard Rosenthal Lesson Goals Understand the basic constructs of a Java Program Understand how to use basic identifiers Understand simple Java data types and

CS4120/4121/5120/5121 Spring 2016 Xi Language Specification Cornell University Version of May 11, 2016

CS4120/4121/5120/5121 Spring 2016 Xi Language Specification Cornell University Version of May 11, 2016 In this course you will start by building a compiler for a language called Xi. This is an imperative,

d-file Language Reference Manual

Erwin Polio Amrita Rajagopal Anton Ushakov Howie Vegter d-file Language Reference Manual COMS 4115.001 Thursday, October 20, 2005 Fall 2005 Columbia University New York, New York Note: Much of the content

Chapter 2: Using Data

Chapter 2: Using Data Declaring Variables Constant Cannot be changed after a program is compiled Variable A named location in computer memory that can hold different values at different points in time

GOBLAN Language Reference Manual

GOBLAN Language Reference Manual UNI Name Role yk2553 Yunsung Kim Project Manager sl3368 Sameer Lal Verification & Validation jw3046 Jee Hyun Wang Language Guru dl2997 Da Liu System Architect sjg2174 Sean

Spoke. Language Reference Manual* CS4118 PROGRAMMING LANGUAGES AND TRANSLATORS. William Yang Wang, Chia-che Tsai, Zhou Yu, Xin Chen 2010/11/03

CS4118 PROGRAMMING LANGUAGES AND TRANSLATORS Spoke Language Reference Manual* William Yang Wang, Chia-che Tsai, Zhou Yu, Xin Chen 2010/11/03 (yw2347, ct2459, zy2147, xc2180)@columbia.edu Columbia University,