FlowChart / Software Schematic Programmer Manual
FlowChart
Chapter 1 Introduction FlowChart, Symbol
Chapter 2 Button, Button Who's Got the Button?
Chapter 3 Symbols
Chapter 4 Screens FlowChart, Symbol, Option, Input/Output
Chapter 5 Objects on the Screen
Chapter 6 Importing/Export file formats
Chapter 7 Support Tables
Chapter 8 How to use FlowChart:
For programming languages
For Data Flow Programming
As a Hardware Schematic simulator.
Chapter 9 Support Tables Color Table Data Type Table
Message numbers
Glossary
Chapter 1 Introduction
FlowChart Computer Language is an attempt to be able to program in any computer language via the use of visual FlowCharting. Actually it's more accurate to call it a software schematic. A FlowChart is usuallty thought of as the logical flow of a program. A Data Flow Diagram is a program method where each 'symbol' works when all of the required data arrives to it. A software schematic has both logic and data flow. This FlowChart program works as a software schematic, a Data Flow Diagram, and as a traditional FlowChart.
FlowChart is made to be used by anyone, in any language. It is designed to be used with graphics so that it is not dependent on text based programming. This means that it can be used by anyone whether or not they know the letters used by most European languages. FlowChart is intended to be used without language. As people use this program and come up with ideas to refine it, it will become more language independent.
FlowChart can be used for a number reasons. It allows the source code of a program to be documented in a form that is easy for anyone to understand. It is made to adapt to any new computer language that has logic and data flow. It is not intended for a specific spoken, written, or programming language. People who speak English should be able to use the process as easily as someone who speaks or writes in another language.
FlowChart is a picture oriented representation of what the source code of a computer program is doing. It is therefore easier to understand providing that the symbol designs makes sense to them. There is an assumption that certain symbols have common universal meaning. The stop sign, a circle with an X through it, a stick figure of a man, or a woman, these all have universal meaning. So instead of words, there are picture symbols that represent the operations of the steps that a computer program is doing.
The text of each symbol of FlowChart can be changed to how it uses the logic and data flow. Changing the text of a symbol will change it. So symbols can be changed into another programming language, or the dialect of the compiler. This enables anyone who understands a FlowChart to be able to understand what the program is doing, even if they do not know the computer language that it is using.
The FlowChart program translates from or to almost any programming language. Of course, like anything new and complex, these first versions will have lots of bugs. With the hundreds of dialects of just the BASIC computer language, it would be impossible for me to code and test for every one. So I am relying on others to help test other languages, finding bugs, and add new ideas.
The symbols that make up a flow chart can be customized to any computer language. Conversion between computer languages can be made on a line to line conversion. This should make it easier to translate any computer language into another computer language by changing each of the symbol's text that creates the computer program source code. This requires that the programming language has a flow of logic, uses variable names, and has a keyword syntax. It will not take into consideration the inherent advantages or pitfalls of each computer language.
One of the goals of FlowChart is to have a universal symbol language that can be compiled into any computer language. Another goal is to be able to have programmers who can create code in any computer language without having to know the syntax and detail requirements of a specific computer language.
The FlowChart has two basic units.
The FlowChart screen shows what a program does. It shows the flow of logic and data from one symbol to another. This represents what a computer program is doing, how the data is moved around, tested, and performs computations. The symbols can be as simple as a single machine instruction, or as complicated as a batch file that runs multiple programs.
FlowChart is made up of three basic items:
Paths showing colored and styled lines that connect the symbol points together. They show the flow of logic, and data.
Symbols show each step of a program.
Constants will connect paths with data.
Each symbol is made up of a number of parts:
unique name
colored lines
points where paths connect, each point has:
a name
a data type such as an integer, a real number, a character string, a record structure, an array, and any other data type of a specific compiler
either an input, output, or both
optional or required connected to a path
syntax code that is used to create the actual program source code using the point name
description
file name
version/author
an example of the program code
which can be used to make the syntax of the symbol, according to the rules of FlowChart
notes
a stroke mouse movement (not yet implemented)
machine opcode (not yet implemented)
Chapter 2 Button, Button Who's Got the Button?
The symbol screen has the following buttons on two toolstrips:
The top line has these buttons:
will take you to the FlowChart screen.
will take you to the Option screen.
Will put a new point in the symbol graphics area. Before the add point button is enabled, the 'select datatype dropdown button' must have been used. A point name must be entered into the text area of the point names.
Start a line with mouse button pressed down, and stop the line where the mouse button is release. It will use the defaults which are selected color, selected line style, and selected line width.
will select the closest point to the mouse button when it is pressed down, and moved to where the mouse button is released.
will delete the first closest point when the mouse button is released. Tip: Move the point or end of a line to a remote, separate location before deleting. Make sure the point or line is correct before pushing the delete button.
will clear everything to start a new symbol. Tip: If you just type over a symbol name, that will rename the symbol. Only if you start with a blank symbol name will it make a new one.
will redraw the screen
The second line of menu buttons are:
will select the an existing symbol to work on.
will rotate the symbol when placed on the FlowChart screen.
Data typing is very important in some languages and operating systems, while not in others. This will give a list of all of the data types currently available.
line styles include solid, dot, dash, dash-dot, dash-dot-dot. There is no meaning of the line style at this time. Use only solid at this time only.
select the name of the line colors. Tip: Data type also use the same color names to make points and paths.
sets the default line and point size.
defines if a point is asking for input or giving output or both.
sets the number of bytes for a data type.
selects the start and end of paths. (not yet implemted)
The user can basically do things with and to symbols.
selecting a symbol will display it to be edited
create a complete new symbol from scratch
FlowChart Computer Language Editor buttons:
A FlowChart is drawn by selecting a start symbol and placing it on the screen.
the symbol button gives a dropdown of existing symbol names.
Option screen buttons:
this button will show the FlowChart editor screen.
this button will show the Symbol screen
this button will delete all of the FlowChart errors. Error records are made for a few of the possible errors. This is because later versions will be looking at only these errors when changes are made to see if there is still a problem. Only these errors are put into the FlowChart data. All other errors just show a message box.
1001 Symbol does not have a /point CameFromLine,
1002 Symbol does not have a /point GotoNextLine,
1003 A path goes to two or more places (A logic path can come from many places, but
can only goto one place),
1004 Points of a symbol is not connected to any path,
1005 Paths are not connected to anything - both ends must be connected.,
1006 Not all of the point names are in the syntax,
1007 The syntax does not match the program macro text.,
1008 Make sure that the point names are in the point list,
1009 All paths must have at least one output or constant connected.,
1010 All points have a valid datatype,
1011 All datatype have a valid color,
1012 Colors are valid names, they can only be assigned Microsoft color names,
1013 All point names are in either the micro code text and the syntax,
1014 No duplicate point names,
1015 No syntax code, and there is no macro code to make the syntax code,
1016 Two paths meet here with different path names
deletes the symbols that are defined and not used in this FlowChart.
checks all it can, warning: it takes a very long time.
output into the files dump1.txt, dump2.txt, and dump3.txt information.
File input output screen buttons:
This is the screen for all input and output files.
shows the FlowChart screen
shows the Symbol screen
shows the Option screen
import a FlowChart or symbol file.
export a FlowChart or symbol file.
convert from a FlowChart and export to a text source file.
input a text source code file, and make a FlowChart with symbols.
Chapter 3 Symbols
All programs must have a symbol named, 'Start' which shows where the program begins. Even subroutines and functions must have a start. Device drivers will have multiple entry points coming out of the start.
A FlowChart is expanded by placing more symbols on the FlowChart screen. Each symbol added will define an instruction of what the program is does.
The diagram will be completed by adding symbols and paths between the dots of symbols. Make sure that the points have matching colors. The color and size of the dots on symbols show the datatype being used by each symbol.
After the FlowChart is complete then save the FlowChart.
Next step is to generate and save the source code. If there are no errors, then the program is for whatever compiler will be used. Future versions will compile into machine code. Then print out your FlowChart.
This is done just like making a FlowChart, except that it works on the symbol screen where points, lines, and various texts are added, modified, or deleted.
Entering in the macro code text to create the named points and the syntax string. Then just add the lines.
To add a line, select the color desired in the color drop down.
To add a point, select the data type from the data type drop down.
This lowest level symbol has the graphic picture for the symbol that is seen on the screen and in the printouts. A symbol has syntax to create source code. This syntax is nothing more than programmer code where the point names are replaced with the path names, so that one symbol can be used over and over again to create source code that is unique for each symbol placed. When macro code is entered, the syntax is automatically made.
Each symbol is one or two functions.
One is just another FlowChart because it's a subroutine or function in that computer language.
Two is the bottom level definition of the computer language.
Both of these functions have a symbol text that defines how the graphics are converted into text. A FlowChart for a subroutine or function will have two parts:
One is a FlowChart that defines the routine being called, such as,
Function SubRoutine(X as integer, Y as real) as long
Two is a symbol that you place on flowcharts to call that routine, such as :
Call SubRoutine(x, y)
TIP: Think of each symbol as doing something, whether it is just adding two numbers together or sorting a megabyte data file. Think of the paths that go between the symbols as the data is flowing between symbols.
Some symbols will use data as input on the paths, others will set data as output on the paths, and others will do both by modifying the input at the start, and then putting it as output at the end.
Each symbol point will show as input, output, both or other options in the symbol graphics as arrows showing the direction(s) of the logic or data flow.
Chapter 4 FlowChart Computer Language Screen Views
The option screen is where FlowChart starts at. The first think that must be done is to select the language class and dialect of the computer language. No other buttons will be available until you do. When it is selected it will load the symbols found in the file in the directory Languages/class/dialect Definition.Symbol.
Option numbers 1-13, and 17-18, and 20-21 control what is displayed.
Option 14 controls if all paths must be orthogonal (up/down right/left only) So that when you place a path only the longest leg will be placed if this has a check mark.
Option 15 controls if FlowChart is allowed to move symbols to make room to auto route paths. and to keep symbols from on top of each other.
Option 18 this is used to stop using the clipboard to pass source code back and forth between programs. If it is not disabled then another computer program must watch the clipboard and make changes as needed. See Preprocessor / Postprocessor chapter.
Option 19 controls if the auto route is allowed to work (right now, they only way to turn auto on is with a /route in the tool strip text box)
the remaining options should all be turned off. (but I left them in, incase you needed to find a problem. cause the program still has lots of unsolved problems.)
The progress bars show how much memory is set aside. The green bars show how much memory is being used.
FlowChart is used to visually show a computer program's execution.
Converting an existing computer program to the FlowChart Computer Language is one method of using FlowChart. Another method is to use FlowChart to create a program.
Subroutines and functions will be labeled inside the start symbol. It will be in the micro text and also in the syntax of the start symbol.
A start symbol could be any of the following.
the beginning of a program.
the entry point of a function, or subroutine.
the entry points of a device driver or other system routine.
the start of a batch file, and other computer directives.
A function is something left over from the old programming school where a single value is returned by a subroutine, other than that, it is exactly like a subroutine. Most modern languages can and do return multiply values either by passing an address (sometimes called 'by reference') to the variable to be changed, or changing globally defined variables.
Text Areas
Symbol Names - a drop down button that has all of the symbol names in memory.
Status Text - messages while the program is working
Symbol Name - the currently selected symbol name.
Data Type - all of the data types of variables that can be selected.
Description - describes what this data type does.
Color Name - a list of all of the color names.
Input/Output - a list for the point definitions. When input or output is selected, an arrow will be drawn at the point. The arrow will show that a point is getting data in, or putting data out.
Width - pixel width of paths, and size of points.
Bytes - how many bytes this data type uses.
Syntax text - used to make the source code when exporting from a visual symbol to source code text.
example {[(PointName.PathName)]} or {[(PointName.Variable)]}
Macro Code text - used to make the source code text. The syntax is automatically made from the macro code.
------------------------------------------------------------
Symbol Graphics is what users see when they are writing, checking, or revising symbol details. It is the only thing that programmers need to use to write programs, just like they only need to use the programming language for most of their text based written programs. A compiler is currently still required to compile the source code created by FlowChart.
The graphics is made up of only two items:
simple lines that show on the screen to tell what the symbol is. It can be anything from a simple box to show a general process, a diamond to show IF conditions, a disk to show where files are used, and so on. The lines can have colors to help show what this function does. The same symbol can be used with different colored lines for slight variations in the symbol usage.
points of where paths can be connected to this symbol. The points show, directions arrows , input, output or both. It will also have a data type that is defined by a color.
A point can also have the option of displaying:
symbol macro text
micro text as an example of the text for a symbol.
syntax text where the variable name replaces the name of the point. For example, the simple computer language code could look like: A = A + B
This would be in the symbol syntax text as:
{[(PointA.pathname))]}} = {[(PointA.pathname)]} + {[(PointB.pathname)]}
Where the name of the path connected to PointA is 'A' and the name of the path connected to PointB is 'B'.
The names of the paths connect the symbols together. This is the path on which the data and logic move.
Now that the syntax is encoded, the graphics symbol is used by the programmer in a FlowChart. The syntax text for the variables will be replaced with the name of the path that connects to the point of the symbol that is used.
The original file name of the symbol is kept.
An Opcode is for symbols that will (eventually) create the object files and programs.
The 'stroke' defines the mouse movements which selects a specific symbol.
Chapter 5 Objects on the screen.
This screen has three kinds of objects:
paths which are the lines between symbols.
symbols, which are from the symbols library.
constants, are the starting value of the paths.
This screen has graphic and text objects.
The two kinds of graphic objects are:
Points which are small circles.
Lines which show the symbol shape
The text objects are:
the name of the symbol.
the names of the points.
the names of the colors of the lines.
the file name of where this symbol is stored.
the stroke which is a string of letters to show the direction of mouse movement to select this symbol. (Not yet implemented)
the opcode is the machine binary code to create a program directly, and not have a compiler. (Not yet implemented)
the version/author should contain a version in the form of numbers followed by a period (except the last number) It is assumed that the version is in the form 'Major.Minor.Sub.1.Sub2.Build'. After a space (or comma) should be the information about the creator of this symbol.
the notes are ignored, but are useful to tell what this symbol is suppose to do.
the macro text is a source code example. If you enter it, then FlowChart will create the syntax that understands its use.
the syntax is what is used to create the output source code. It is made up of keywords and fixed replacement strings. (See list below)
the description is ignored.
As of this writing you can replace inside of the syntax text :
{[(SymbolName.index)]}
The index is just the array pointer, not useful
{[(SymbolName.x)]}
This is where the Symbol is located.
{[(SymbolName.y)]}
"
{[(SymbolName.Rotation)]}
This is how the symbol is rotated, flipped, or flopped.
{[(SymbolName.DataType)]}
This is the name of the datatype (meaningless, only paths and points have
datatype)
{[(SymbolName.OpCode)]}
This is machine code the format will be either Hex or the computer address
.
(of a path no intension of using a jump addres at this time.
{[(SymbolName.notes)]}
this prints out notes
{[(SymbolName.FileName)]}
replaces with the filename in the symbol
{[(SymbolName.Author)]}
replaces with the version / author
{[(SymbolName.Version)]}
replaces with the version / author
{[(SymbolName.Stroke)]}
The letter string that defines this symbol.
{[(SymbolName.xa)]}
rotated X
{[(SymbolName.ya)]}
rotated Y
{[(SymbolName.code)]}
macro source code text (no replacements)
{[(PointName.name)]}
name of this point on this symbol
{[(PointName.index)]}
the index of this point in the graphics table
{[(PointName.x)]}
the X of the point
{[(PointName.y)]}
the Y of the point
{[(PointName.IO)]}
Input, output, both etc.
{[(PointName.Rotation)]}
the rotation of the symbol (meaning less, cause the symbol is rotated, which
rotates the point
{[(PointName.Datatype)]}
The datatype of this point
{[(PointName.PathName)]}
the name of the path that is connected to this point
{[(PointName.Variable)]}
same as the path name
{[(PointName.PathX)]}
The X of the path that is connect to the X of this point
{[(PointName.pathY)]}
NOTE: .path? and .xa and .x shoule all match. Other wise the path is not
ending at this point
{[(PointName.Distance)]}
the distance between the point and the path
{[(PointName.DataTypeName)]}
the name of the datatype of this point
{[(PointName.DataTypeDescribtion)]}
describtion of the data type of this datatypename connecter to this point
{[(PointName.Bytes)]}
number of bytes that this data type. (This is for opcode, not yet
implimented.
{[(PointName.DataTypeColor)]}
the color of the datatype.
{[(PointName.Width)]}
the width of the path for this datatype (and size of the circle for points
Chapter 6 Import/Export file formats:
These are the FLowChart keywords to define the information that is being imported and exported.
/Ignore= anything that starts with this will be ignored by FlowChart.
/ComputerLanguageDialect= this is the name of the dialect such as VisualBasic, MicroSoftVisual C++, gnnCC, etc.
/ComputerLanguageGoToNextLine= this is the keyword to goto some address/label
/ComputerLanguageCameFromLastLine= this is the label that the above Goto uses.
/ComputerLanguageProcess= this gives the name of the preprocessor program which passes sourced code back and forth to change it's syntax. (See chapter on Preprocessor / Postprocessor for more details.)
/Language = the name of the language class ie: C, Basic, Cobol, Fortran, Lisp, etc.
/ComputerLanguageCase = {yes, no} (not implemented, everything is considered as one case.)
/ComputerLanguageComment = this is a string of characters that define the start of a comment, ie: rem, ', /*, // , etc.
/ComputerLanguageExtension = this is the extension of the file name of the source code ie:bas, C, Ada, ASM, etc.
/ComputerLanguageMultiLine = will replace the character with a carriage return because FlowChart currently only deals with one line at a time.
/ComputerLanguageVariableNameCharacters = characters that are allowed besides letters and digits. It is assumed that variables names start with a letter, followed by letters and numbers. If the computer language allows special characters in a name then they need to be listed. ie: period, underscore, $, %, and other special characters that define the data type of this variable.
/Options= turns an option or message number on or off by setting it to zero or one.
/Set=
--------------------------------------------------------------------------------
/Path=x1, y1, x2, y2, "Data Type Name", Path Name
code, x1,y1,x2,y2, Rotation name, Option Name, Data type Name {[(actual line of source code ?)]}
code is /path=
a path from x1,y1 to x2,y2
The data type name must be in the support table data type.
The name of this path is also the variable in the source code.
This line segments from the points in one symbol to the points in another symbol inside a FlowChart. The Data Type matches the Data Type from the Point in the symbol to make sure that the user has matches them correctly.
/Use=x1, y1, Rotation, xx, "Name of the symbol called"
code, x1, y1, rotation name, "name of the symbol"
code = /use=
x1,y1 is the location of where the symbol is placed.
xx is a selected option for this usage of the symbol here only. (not implemented yet)
rotation comes from only of the selects from the rotation drop down on the symbol screen. (Yes, the rotation is on the symbol screen, and it has to be selected before placing a symbol on the flowchart, a minor bug that is going to be change one of these days.)
The name of the symbol. This name is looked up in the Named/Symbol table(s)
In a FlowChart this is the symbol that is displayed for the user to connect his lines to.
The rotations with flip or flop gives a mirror image of the symbol.  Which is the same as Rotate180.)
/Constant=x1, y1, "Constant Value"
code, x, y, "constant text at this point"
code = /constant=
The X,Y must be on the end or turn of a path.
The constant value is a string. The compiler will convert that string into a number. If your compile requires quotes around strings, they ou need to add that to the macro text, (and have it in the Syntax text
Syntax:
NAME is the name that is given to the symbol. This also signals the end of the last symbol and the start of the next. The name must be the same as the name in the /use command Right nowe case is turned off
/Language="Computer Language Class", "Dielect"
This is for which computer language that this symbol works on. You can allow the symbol to have output in many different languages (one at a time).
For example:
/Language=BASIC, FreeBasic
/Language=basic, Visual Basic
/Language=C, Visual C
/Language=C++
/Language=FORTRAN, Fortran 66
/Language=COBOL, IBM Micro COBOL
/Language=unknown languages, MyOwnPersonComputerLanguange
/Language=Lisp
/MacroCodeText= Order, TEXT
This is the computer code that is generated for this symbol for the above computer language. The reason that FlowChart works is how the Code is written here. The code is just generalized code with the point names replaced with the name of the path. And the properity replaces with what ever data that point has. {[(PointName.properity)]} is replace and results is PathName, where the point name is PointName and the properity is .Pathname.
Order used in some languages to separate one section from another (Sort Order)
for example:
/Program=main, {{[((SUM{{[((={{[((NUM1{{[((+{{[((NUM2{{[((;
/Point=50,0,-1,integer,"SUM"
/Point=-200,0,1,integer,"NUM1"
/Point=200,100,1,integer,"num2"
When this FlowChart is assembled the result replaces what ever the user has named the paths from one symbol to another with this name (If the user has not named the paths, then the computer assigns a name to each to each set of line/paths that are connected together.) So the results would look something like this in the generated code file.
My Totals=Dept One+Shoes
/Point=X, Y, input/output,Data Type, "Variable-name"
code, x1, y1, input/output, Data Type, "name of this Point"
code = /point
x1,y1 is the offset from the center of the symbol (1 to 500 with the center at 250, 250)
input, output, both and other options are in the input/output drop down. This is to tell if the symbol is getting input to wirk with, or input from logic from another symbol. The output logic goes to another symbol. and the output of data can go to more than one symbol. Altho FlowChart structure can handle multi processor's working on the same program (same memory area) compilers and computers, in general, do not at this time. (There are exceptions, but not many)
The data type support table is then used to get the color, size, style, etc.
The name of this point is what is looked for to replace with the name of the path connected to it.
/Line=x1, y1, x2, y2, "Color Name"
code, x1,y1,x2,y2, "name color"
Code = /line=
x1, y1 is the start of the line, and x2, y2 is the end
The name of a color is looked up in the color support table.
This just draws a line in side the symbol from x1,y1 to x2,y2 of what the symbol displays, it has not other function. You have lines inside a symbol to display only. You have paths inside a FlowChart to connect the /Points inside one displayed symbol to another.
/Color= Color Name, {[(Alpha, Red, Green, Blue)]}, {[(Style)]},{[( Start)]}, {[(End)]}
code,"name of this color"
code = /color=
Color values for Alpha, Red, Green, Blue must be between 0 to 255 and they are optional. Flowchart creates the standared Microsoft
the name of the color is currently restricted to the color names defined from microsoft. (See list in the color support table.
{[( Alpha, Red, Green, Blue)]} These four numbers (from 0 to 255) define what color this is. Currently it is not being used. Future versions will add the ability to name and control your own colors.
{[(Style)]} is currently no implemented. It is how the lines/paths appear, as solid (the current default), Valid styles are: Solid, Dash, Dot, Dashdot, DashDotDot
{[( Start)]}, {[(End)]} these two are for the ends of paths and lines, they really are useless, but are here for other reasons. Ignored. Valid for start and end are: AnchorMask, ArrorAnchor, DiamondAnchor, Flat, NoAnchor, Round, RoundAnchor, Square, SquareAnchor, Triangle
Color names (All 139 of them) and will output them when you export.
Syntax:
/Order= (order1,order2,(,order3,order4)...)
The order is where the source code is written out. For example, Globals should be in order1 from above, and source code should be in order4, with all of the definations of the variables in order3 group for the subroutine order4. If any named order is not in this list then it will be added to the end. Order1... is just an example, andy names can be used (like IncludeSection, GlobalSection, MainSection, DefineSection, DeclareSections)
example:
/Order=(IncludeSection, GlobalSection), MainSection, (VariableSection, CodeSection, FinishSection, ErrorTrappingSection ), OtherSections.
Chapter 7 Support Tables
The program does not currently allow you to make changes to these external tables, they must be edited by hand with
a program like notepad. They are 7 bit ASCII files (UTE-8), DO NOT CHANGE TO DOCUMENT FILE STRUCTURE. unknown results if you use wide character (ie"UTE-16).
Some of the support tables that can be changed.
Color Table: This contains the colors of the lines and paths and text. They all use the same color support table names as defined by Microsoft. This table contains the names of the colors, It also contains optional things as the style of the line (Solid, Dot, Dash, DotDash) and the red/green/blue for non standard colors. All of the colors are available . They are saved each time that you save your FlowChart.
Datatype table: This contains the name of the data type. Such as integer, real, double, byte. It should only contain the data types for the language that you are programming in. Such as C, Basic, FORTRAN, COBOL,. It can also have data types for the operating system that you are using (such as the datatype to interface with Windows APIs). The data type also contains the color, width, and other future items.
Keyword table: They are then made for each computer language. That is how the program tells what to do with a line of code.
Operator table: They are special characters such as + - = , ( ) {[( )]} ^ & * and keywords such as 'mod' It is the grammar of each line of source code. With keywords they tell how the line of code is to be matched to the syntax operator grammer of each symbol.
Function name table, to help the flowchart program decide which symbol to match input lines of code to.
Support tables that can not currently be changed (future)
Direction Table is the 16 directions between two points. 16 is up, 8 is down, 4 is to right, 9 is to left. 2 is at 45 up-right, 6 is down-right, 10 is down left, and up left. All even dumbered directions is on 90 or 45 degrees only, the old numbers is everthing between the 90 and 45 degrees.
14 15 16 1 2
13 | 3
12 -------- |--------- 4
11 | 5
10 9 8 7 6
Rotation Table :
Default = 0, 1 , 0 , 0 , 1, ^. Flips to ^. Stays the same
.
Flip = 1, -1, 0, 0, 1, ^ .Flips To
^. sideways flip.
Flop = 2, 1, 0, 0, -1, ^ .Flips To v. top side flips down.
Rotate90 = 3, 0, 1, -1, 0, ^ .Flips To > rotate 90 degrees period On bottom
Rotate180 = 4, -1, 0, 0, -1, ^ .Flips To .v rotate 180")
Rotate270 = 5, 0, -1, 1, 0, ^ .Flips To <rotate 270 ")
FlipRotate90 = 6, 0, -1, 1, 0, ^ .Flips To > period On top flip Then
rotate 90 ")
FlipRotate180 = 7, 1, 0, 0, -1, ^ .Flips To v. flip Then rotate 180 (mirror
image Of) ")
FlipRotate270 = 8, 0 , -1 , -1 , 0, ^. Flips To <Period On bottom ")
FlopRotate90 = 9, 0 , -1 , -1 , 0, ^. Flips To > period On bottom Same As
")
FlopRotate180 = 10, -1 , 0 , 0 , 1, ^. Flips To .^ same As flip rotate180 ")
FlopRotate270 = 11, 0 , 1 , 1 , 0, ^. Flips To ^. period On top")
FlipFlop = 12, 0 , -1 , -1 , 0, ^. Flips To ^. same As rotate180 ")
This table contains the color/types of data that line paths in FlowChart, and the color of the connection points in symbols that they must connect to. It also contains the color of lines that make up symbols.
The following description of the file layout also shows how the fields are used:
The following are imported via a flowchart, or symbol import file.
Preceeded by :/Color (you must define a color before using it in a /datatype
/Datatype=name, Description, Bytes, Color Name, Width/Radius
Name is unique of this data type (or line color name as used in symbols).
Description is what this data type is for.
It can not have comma's in any field because they areused as as field delimiters.
This is the size of the number of bytes of this data variable (use 0 for Logic, and -1 for strings)
Name of the color in the color support table.
Width/Radius This is the width of paths (lines are always one wide)
Color Support Table:.
Summary of the Import Syntax Statements allowed.
If you must make changes to the import/export file. The latest formats are listed there.
(*1) marks the input statements that allow multiply lines
/ComputerLanguageCase=no
/ComputerLanguageMultiline=_
/ComputerLanguageComment=rem
/ComputerLanguageExtention=.VB
/ComputerLanguageVariableNameCharacters=$%
/ComputerLanguageDialect_=VisualBasic
/ComputerLanguageGoTonextLine={{[((ComputerLanguageGoTonextLine))]}}
/ComputerLanguageCameGromLastLine={{[((ComputerLanguageCameGromLastLine))]}}
/ComputerLanguageProcess=C:\ProgramFiles\FCVisualBasic.exe
/Color= Color Name, Alpha, Red, Green, Blue, Style, start, end
/Datatype= Name, Description, Number of Bytes, Display Width/Radius, Style
/Name= Name
/Language= Computer Language
/Program= Sort, Code of the Computer Language with {[(Replacements)]}.(*1)
/Point= X,Y, {Input, Output, Both,OptionalInput, OptionalOutput, or OptionalBoth}. The Data Type Name, Name of Points in symbol. (*1)
/Line= X1, Y1, X2, Y2, Color Name.(*1)
/Filename= Device:\Path\File Name. Extension of where to save only this symbol (Optional)
/Notes= Notes. (*1)
/Path= X1, Y1, X2, Y2, Datatype, Name of The Path
/Use= X, Y, {'Flip', Rotate90, Rotate180, Rotate270. . . }, Symbol Name
/Constant= X, Y, Constant Value
/Syntax= Language Statement Syntax
/Opcode= Hex Values (&Tables) (Not used yet)
The order of the file must be
/ComputerLanguageDialect...
/Color before it is used, then (If missing the program will use Windows Default colors
/Datatype
/Name
/Point
/Line
/Use, /Path, or /Constant.
This should be the first standard of the language.
Software Schematic should have three parts, a flowchart, a symbol, support tables.
.FlowChart
The flowchart has three parts.
Displaying complete symbols on the screen/page.
. FlowChart symbol properities are the X,Y location, Rotation,
Paths going between points on the symbols.
. Path properities are an (X,Y) to (X,Y), a path name, a logic/data type.
Optionally 'constant' which are what the path value starts with. Optionally but ignored are errors of the program, such as:
points on a symbol not being connected.
logic paths that go to two symbol inputs, assume for now single liner processers, but the language is not restricted by this
paths with no source, output from at least one symbol.
two paths connect with different names.
. Constant properities are (X<Y), The starting value (data type and name comes from the path it is connected to.
optionally 'error' messages. When the program needs to display an error at a location where the error occures. Or to point the user to where something needs to be changed.
Symbol
The symbol has a number of parts. It is defined inside a retangle of from -250 to 250 in the X and Y. This is an artificial limit and might go away, if there are to many people that need/want it larger.)
Symbol properities:
Name: Each symbol is refered to by name. You can use almost any name that could be used as a variable. It begins and ends with 'white space', white can be things like a space, tab, return, and so on. The name of the symbol. This is so that the flowchart displays this symbol by name,
Points: Each symbol has to have the points defined.
Point properities:
(X,Y)
Name of the point (This is used to create the text for each symbol. (See Macro Text)
The Logic/Data Type of this point.
Lines: Each Symbol must have some graphics that show what this symbol is. Usually, a flattened oval is used for the start, and also an end. An end is somtimes just a circle. diamonds are usually used for testing to determin directions of logic branches. That would include things like IF, CASE, Computer Goto, WHILE, and so on.
Optionally Icons/Pictures. There should be Icons and pictures available also.
Support Tables
Color Table: The color table is used to be able to move from one system to another. Currently its format is based on Windows 10 Color Names. But it also has the Red/Green/Blue for other systems to create thier own Color names. (See The details in import/export section)
DataType Table: The data type table has information about a type of data this includes:
They 'should' have color and/or distinction to tell the difference data types they represent.
Second is the symbols, which has a number of items.
The symbol must have a unique name.
A symbol must have the 'program macro code', which is just the computer language code with variables replaced with {{[((names of the point{{[((.
My Exceptions to my own standard:
The File name that the symbol is contained in.
The Computer Language Of this symbol.
Notes.
Version.
Author.
Hex code for the Machine. (Only used in Assemble Language for now.)
An internal text representation of the mouse movement to identify this symbol.
A symbol should have a graphics part represented by points. They should have lines or graphics to show what this symbol does (ie: decision branch (go to, go subroutine), process (subroutine, function calls), loops (do while, for next, do until) and so on).
The points has a number of significant items.
Points must have associated with them the logic or data types (i.e.: Integer, String, Floating Point) Depending on the language.
Points 'should' have a representation of the symbol using (input) or returning (output)
The lines might have colors and/or distinction but nothing else of importance.
Third is support tables.
A support table of color names is helpful.
Showing at least the colors available, or select-able from a pallet of colors
A support table of data types is helpful
Showing the name of the data type (i.e.: byte, integer, Floating Point, or language dependent for C, C++ in Windows and the new C Standards).
{[(My Exceptions)]}
Color Table:
Alpha, Red, Green, Blue of the color for those systems that can use it.
The types of start and end points styles that can be used.
The line styles that can be used. (Solid, Dot, Dash etc.)
Data Type Table:
Has a description of the data type.
Has a name of a color for this data type.
Has the size (in bytes) of this data type.
Has the width of the line, with a minimum of 3 for this data type.
Over-writable Internal Support Tables:
Direction Table: (A flip or a flop will reverse. An symbol can appear 8 ways)
Number Named TopRight ? Top/Bottom Right/Left
Default
Rotate90
Rotate180, FlipFlop
Rotate270
Flip
FlopRotate180
FlipRotate90
FlopRotate270
FlipRotate180
Flop
FlipRotate270
FlopRotate90
FlopRotate90,
Line Styles (Windows Dependant):
SOLID, dash, dot, dashdot, dashdotdot
Line start/finish (Windows Dependant):
AnchorMask, ArrowAnchor, DiamondAnchor, flat, NoAnchor, Round, RoundAnchor, Square, SquareAnchor, Triangle
Computer Languages: (Note that this will change to be an external table also later)
Assembly , Bash , Basic , C , C# , C++ , COBOL , Clojure , Dart , Dos , Elixir , Forth , Fortran , Generic , Go , PowerShell , Java , JavaScript , Kotlin , Lisp , ObjectiveC , Pascal , Perl , PHP , Python , R , Ruby , Rust , Scala , SQL , Swift , TypeScript , VBA , WebAssembly
After selecting the language you also have to either load the keywords, or start up the language dependant program to preprocess the inputs. (See FClanguage)
Default Windows Color Names (Anything will display black)
(Windows 10 dependant colors) AliceBlue, AntiqueWhite, aqua, aquamarine, Azure, beige, bisque, Black, BlanchedAlmond, Blue, BlueViolet, Brown, BurlyWood, CadetBlue, Chartreuse, Chocolate, Coral, CornflowerBlue, Cornsilk, Crimson, Cyan, DarkBlue, DarkCyan, DarkGoldenrod, DarkGray, DarkGreen, DarkKhaki, DarkMagenta, DarkOliveGreen, DarkOrange, DarkOrchid, DarkRed, DarkSalmon, DarkSeaGreen, DarkSlateBlue, DarkSlateGray, DarkTurquoise, DarkViolet, DataTypeError, DeepPink, DeepSkyBlue, DimGray, DodgerBlue, Firebrick, FloralWhite, ForestGreen, Fuchsia, Gainsboro, GhostWhite, Gold, Goldenrod, Gray, Green, GreenYellow, Honeydew, HotPink, IndianRed, Indigo, Ivory, Khaki, Lavender, LavenderBlush, LawnGreen, LemonChiffon, LightBlue, LightCoral, LightCyan, LightGoldenrodYellow, LightGray, LightGreen, LightPink, LightSalmon, LightSeaGreen, LightSkyBlue, LightSlateGray, LightSteelBlue, LightYellow, Lime, LimeGreen, Linen, Logic, Magenta, Maroon, MediumAquamarine, MediumBlue, MediumOrchid, MediumPurple, MediumSeaGreen, MediumSlateBlue, MediumSpringGreen, MediumTurquoise, MediumVioletRed, MidnightBlue, MintCream, MistyRose, Moccasin, NavajoWhite, Navy, OldLace, Olive, OliveDrab, Orange, OrangeRed, Orchid, PaleGoldenrod, PaleGreen, PaleTurquoise, PaleVioletRed, PapayaWhip, PeachPuff, Peru, Pink, Plum, PowderBlue, Purple, Red, RosyBrown, RoyalBlue, SaddleBrown, Salmon, SandyBrown, SeaGreen, SeaShell, Sienna, Silver, SkyBlue, SlateBlue, SlateGray, Snow, SpringGreen, SteelBlue, Tan, Teal, Thistle, Tomato, Transparent, Turquoise, Violet, Wheat, White, WhiteSmoke, Yellow, YellowGreen
Default DataTypes (expanded by external table from flowcharts)
Bit, Byte, errored, erase, Floating, Int16, Int32, Int64, INT8, Integer, logic, Long, Word
Data Type properities:
/Datatype=name, Description, Bytes, Color Name, Width/Radius, Style, Reserved
The name of this symbol (loading another with the same name will just sometimes add, and sometimes replace the existing system properities)
A Description. Do not use comma's in the description because they are required in all imports instead of white space
The number of bytes that this data type requires.
The name of the color that this data type paths and points will be display with
The width of Paths and the size of symbol points.
The style (Solid, dot, dot dash etc Windows 10 dependant)
The line start and end. Arrow, flat, etc. (Windows 10 Dependant)
FlowChart : Is a graphical representation of the logic and data paths of a program connecting symbols together to show the logic steps of a computer process.
FlowChart graphics table : This refers to 'records' that hold the information about each located symbol, path segments, and constants.
Symbol : Is a graphical representation of a basic unit inside a FlowChart made up of lines and points. It contains lines, points, and other information to make the FlowChart into a program.
located symbol : This is a /use record in the FlowChart graphics table
Line : Is a graphical line in a symbol. It has color, but no width.
path segment :
Path : Is a graphical line in a FlowChart that represents the logic, or data going from one symbol to another. It has a color and width representing the type of data that that is moving in the program.
Point : Also called a connection point is in a symbol that is where the Paths from different symbols connect. It show where a path goes into, and comes out of a symbol. It has color and width for this type of data for this connection.
Connection Point: Is another name for Point.
Color : This is a name that Windows has a set of colors for. (Currently new color pens are not allowed, only the existing 139 color names.)
Data Type : This refers to the type of data that they symbol point is looking for. Some computer languages get very picky about this (Like C++), other computer languages could not care less (like BASIC).
DeCompiled : Thiss term refers to the process of converting a source code text file into the graphical FlowChart Computer Language.
Quick Start
For starting quickly, first start the FlowChart ComputerLanguage Program.
This can be done in a number of ways. In Microsoft Windows, press the right mouse button over the windows start icon. This will let you see all programs that are installed. . Then select FlowCHart. You can press the Windows key. If you need more help on how to install or start a computer program refer to your owners manual, or the Internet.
After the FlowChart program is started, there will be a splash screen displayed over the flowchart screen. They will both disappear and the option screen will display, with only one button enabled.
The button will allow you to select the computer language. The list will have generic computer languages, and some specific ones for special useage.
If you have to load the Symbols, Which means keywords, syntax(s), and so on, thendo the folloing steps
1, Select the FlowChart button (Far Left button )
2. Then on the Flowchart Screen, Select the third button (A file folder)
3. Then on the File InputOutput screen select the folder with an arrow pointing up (To open a file)
4. Find and select the symbol file that you require.
a. You might need to repeat opening symbols. depending on your language.
b. You will need a Keyword symbol file,
c, An operator ymbol file.
d. a function keyword file.
f. One or more files for the symbols sintax.
g. OR itmight all becontained in a single file of the computer language name,and the extension of *.Symbol.
5. When you save a FlowChart all of the symbol files will besaved into the flowchart file. The symbol files are the basis on which FlowChart uses to 'translate' to and from a computer language. Different symbol files are required for different languages, and dialects of languages,
6. Next go back to the Symbol Screen. (Second buttonfrom the left)
7. The Symbol screen has two rows of buttons. The top row is to edit symbols. The second row is the defaults that are applied to editing. Each button needs to have a default selected. The buttons shows what the current default is.
8. Last enter a name of the next point to add. Thetext box to enter that is at the right of the buttons. (This will not be used until you add a point to a symbol, but needs to be there anyway (for now)
9. Goto the FlowChart screen again(first button on the left)
10. Select the select a symbol button. A drop down will appear with the defined symbols for this language.
11. You can now place that symbol on the FlowChart.
12 To place paths (lines connecting the logic and data, The button with a line and circles at the ends is the 'make a path connection.
13. Where ever two paths end at the same location, both must have the same path name (The path name is actually the name of the variable in the source code.)
14. Continue placing symbols and connectingthem with paths.
Additional Notes:
1. A symbol can be made by typeing in a line of source code. The program will look for a symbol that matches the syntax and place that one the Flowchart with Paths connecting them. If no syntaxmatches, it will create a symbol, and then placethat one one the Flowchart.
2. A FlowChart can be started from the File Input/Output screen with the text to FlowChart button.
a. writting on the left of the button and symbols on the right makes source into flowchart
b. writing on the right of the button and the symbols on the left makes the source code form the FlowChart.
2. If the auto router is turned on, it will make paths to connect any two paths with the same name. (A background task, so it might take a while to 'catch up' to where new paths and data is entered.
3.
299 Path and symbol names should not start with {[(
436 FindingMyBugsDropDown: The path end selection does not match the drop down.
437 FindingMyBugsDropDown: The path style selection does not match the drop down.
438 FindingMyBugsDropDown: The number of data bytes selection does not match the number in the drop down.
439 FindingMyBugsDropDown: The symbol select drop
down on the symbol screen has a duplicate symbol name.
441 FindingMyBugsDropDown: The FlowChartScreen Screen and Symbol Screen does not have the same number of symbol names.
442 FindingMyBugsDropDown: The symbol select drop down has a duplicate Symbol name.
443 FindingMyBugsNamed: Two symbols with the name name.
444 FindingMyBugsNamed: The symbol name
table is out of order or there is a duplicate symbol name.
445 FindingMyBugsNamed: Duplicate in the symbol name table.
446 FindingMyBugsNamed: Two Symbols with the same syntax. When the syntax is searched for it might fine either one of the two. Each symbol should have a unique syntax to be used when decompileing from a computer language into the FlowChart Computer Language.
447 FindingMyBugsNamed: There are two indexs pointing to the same symbol. This means that there is a symbol in the symbol name table that is not referenced. This needs to be sent to<EMAIL_ADDRESS>448 FindingMyBugsNamed: This is counting
the number of duplicate indexes for each symbol.
449 FindingMyBugsNamed: This is the total number from 448 message above.
451 FindingMyBugsKeyWords: A keyword is found twice in the keyword table.. This should not happen, because duplicate keywords are not added when they are found from the import file.
452 FindingMyBugsKeyWords: The keyword table is not ordered correctly.
453 FindingMyBugsKeyWords: A zero length keyword has been found. This should not happen, because blank keywords are not suppost to be added to the keyword table.
454 FindingMyBugsKeyWords: When this keyword is searched for, it is not defined as a keyword. This is because the keyword is also entered as something else, (such as a function name, a special part of the language grammer.
455 FindingMyBugsKeyWords A keyworld with zero length has found its way into the keyword table.
456 FindingMyBugsPath: The flowchart record is not a path segment record. FlowChart thinks that this should be a path, and is checking that it is.
457 FindingMyBugsPath: The index for the data type of this path segment does not have a valid data type.
458 FindingMyBugsPath: The path name is not in the link list. The link list is a table that has a list of all of the path segments that are connected together. So every path segment should have an entery in the link table by path name.
459 FindingMyBugsPath: the two path segments are in the same link table, but there are no path segments connecting them together.
461 FindingMyBugsPath: A number in the links table might not be pointing to a valid path segment, or the index might be invalid (zero).
462 FindingMyBugsPath: A zero index was in the link table.
463 A condition that never occurs Report to<EMAIL_ADDRESS>464 A condition that never occurs Report to<EMAIL_ADDRESS>465 A condition that never occurs Report to<EMAIL_ADDRESS>466 FindingMyBugsPath: This is the beginning of one of the index tables for X1, Y1, X2, or Y2.
467 FindingMyBugsPath: This is the beggining of one of the index tables for X1, Y1, X2, or Y2.
468 A condition that never occurs Report to<EMAIL_ADDRESS>469 A condition that never occurs Report to<EMAIL_ADDRESS>471 A condition that never occurs Report to<EMAIL_ADDRESS>472 A condition that never occurs Report to<EMAIL_ADDRESS>473 A key was pressed that was not one of the thoundsand's that FlowChart knows about.
474 FindingMyBugsRouter_OnTop: Something other than a path segment, located symbol , /error was found in the FlowChart graphics table.
475 FindingMyBugsRouter_FindDupPath: This path has an end at a point of this symbol.
476 FindingMyBugsRouter_FindDupPath: Something other than a path segment, located symbol , /error was found in the symbol graphics.
477 Report this error number to<EMAIL_ADDRESS>This is a probrm problem, in that the message number was not found in the message table.
478 The name of a data type or color is blank.
479 The resulting color name is blank, This is because of a bad index usually. After trying to get a color for what ever item is being show/displayed a valid color name is not found.
480 A code line was thought to have a variable name, but the variable name is blank. So a random variable name was created in the form vV_######
481 While searching for a connection to a path segment it was not found,
and the four distances are:
last path tested
last non path
the closest path
the closest non path
And the index:
The closest path
the closest non path
484 while searching for a located symbol something else was found in the FLowChart graphics table.
486 While searching for a path segment, something else was found in the FlowChart graphics table.
488 While searching for something other than a path segment or located symbol , one of them was found in the FlowChart graphics table.
491 While trying to find a path segment between two existing path segments, one end turns out not to be at another path segment.
492 Neither end of the path segment is connected.. Bothe ends of the path segment is not connected to another path segment.
493 The name of the paths are not the same as the path segment that is being routed to. The two path have different names but share the same end point.
495 A path segment was made for two paths in the like table that was not connected.
499 This message is show where it is trying to find a between two existing path segments.
500 Invalid index to a path segment. One of the two points that is being routed to is invalid.
501 A path segment is being made bwtween these two points.
502 A path between these two sets of points could not be found.
503 This is when a variable name starts with {[(. This is in the form of {[(variablename.property)]}.
602 A symbol with this name already exist. New symbol graphics will be add (/point,/line), anthing else will be replaced, and anything not changed will be left alone.
604 This was not a located symbol , path segment, /constant, or /error code, so nothing was done to it.
607 Searching in the table the top limit was found to be have a nothing.
611 This symbol is being renamed, and all of the FlowChart grphica is also changed to use the new symbol name.
612 This gives the count of how many times the symbol was used, and renamed.
622 The symbol graphics records table is a list that must be kept in order. When inserting into the list all of the pointers and indexes are then no long valid, so they have to be 'fixed' by reindexing/resorting. Since I use the famous(ly slow) buble sort to keep the list in the order that it needs to be in It takes a (extreamly) long time. This is one of the reasons for the VERY slow speed of this version of FlowChart Computer Lange. (Which is going to be addressed and fixed in a future version when I get around to it.)
623 Pthe index into the drop down box is invalid (an error), to nothing is returnd because it is not in the drop down combo box.
624 The index is bigger than the combobox list is long. So nothing can be returnd.
625 The starting scale is imported with a /scale code (undocumented.) this shows what the code is change to and then the scale is limited to the min and max ranges mentioned above. Note that the scale must be between 32000 and 0 (the axcual scale is an integer that is 1,000 times the acale. Another reason that this is undocumented right now.
626 Than device:\paths\FileName.txt of the three dump files can be changed with a /Dump=File1,file2,file3 This is another undocumented features. Note that these three dump files are only going to be inthese version until the program seems to be working from people testing it for me and are finding fewer problem, bugs, and issues. (not the for see able future right now)
627 The center of these two symbols is closer than the symbol size. Currently it is 500, but I expect that this number will become a import very soon, because what ever number I select does not seem to be enough. 500 Is the absolute minium that it can be (leaving no room to route path segments, so I might have already changed this to be at lease twice the symbol size?OK, I just change it to be 2 1/2 times the symbol size.
628 While finding paths came up on a FlowChart graphics record that was not a path segment, or located symbol , /constant, or /origin
629 While removing duplicates from the links table, it ended up having nothing in this link.
631 Could not find this color name.
637 There was a common XY point in two different link table records. both links had path segment records with different names. See 333 if they were combine after this message.
638 The path segment is connected to a symbol.
639 WARNING path segment is connected to something else, not a located symbol or a path segment.
642 Symbol is connected to a path. otherwise see 643
643 Symbol is NOT connected to a path. otherwise see 642
644 It should be auto routed here if there is another point the the link table See 345, 346 to see if it was able to find a path.
645 Should have programmed for because it is not a /line, /error
646 The FlowChart graphics to be routed to is not another path.
647FindingMyBugsCheckForErrors: The name of every point should appear in the micro code text and in the syntax text in the form {[(pointname.property)]} where the name of the point is in the symbol graphics records, and the property is usually .Pathname or .Variable. But any of the valid properities can be used.
648 FindingMyBugPoints : when there are fewer than four /point or /line records, this message will appear for that symbol.
649 FindingMyBugPoints : You are not working on any data for this symbol. There are only two points. (One for a CameFrom and one for a GoTo which are added to every line of code if DeCompiled.
651 FindingMyBugPoints : When counting up the data points, the count of /point's that are not input, output, both is less than 1. This is a catch all and really should be ignored.
653 FindingMyBugPoints : The point name Is In the syntax text. This is as it should be, See 758.
655 FindingMyBugPoints : The point name Is In the program code. This is as it should be. See 382
657 FindingMyBugPoints : Everything Is OK
658 FindingMyBugPoints : This is giving a list of point name in the drop down for error, See 659
659 FindingMyBugPoints : The symbol point list box, does Not match the order Or point name for point in symbol.
661 FindingMyBugPoints : The poiunt name does not match the point list in the drop down. See 383
662 FindingMyBugPoints : Only the selected symbol that is displayed in the symbol screen can be checked. The selected symbol is not the symbol that is being checked.
663 FindingMyBugPoints : This message just shows what is going on.
664 FindingMyBugPoints : This is not the selected symbol. only the select symbol is check for problems.
665 FindingMyBugPoints : This is not checking for the colors being correct. (It's on the todo list.)
666 FindingMyBugPoints : This record should not be in the symbol graphics table. This usually happens when the record is not used. (ie: a zero code for the record type).
667 FindingMyBugFlowChart: This is the number of the option for the symbol. This is for future expansion in the symbol to do contintionals. (Not implemented yet, but here to make sure that it is test when I do write it.)
668 FindingMyBugFlowChart: Flowchart has /unknow code, which is a zero, meaning that it has not been used, or it is outside the bounds of the table.
669 FindingMyBugFlowChart: empty code (nothing) in the symbol table. Usually means that the index is outside the bounds of the table.
671 FindingMyBugSymbol : This record is not a symbol name , point, line, error, or unknown (zero and unused).
672 A key was pressed and I am not doing anything. It might be unknown (See 473) or on the known list of named keys.
673 There is an error (somewhere ) that is in the FlowChart graphics. See errors that are placed on the flow chart
674 Gives information about what is the closest path here.
675 No match to a path name was found but this is the next closest thing.
676 The ends of these two paths do not meet.
677 Nothing was found close to this end of a path to connect to.
678 FlowChart Found two path connect at the same point, but were not the same path name.
679 If an unknow color is used, then we try to find the closest match to a color in the color list. This is a tempory condition, as the FlowChart Computer Language should allow you to name and use any colors without limits (Well, OK, the limits are that colors have Red/Green/Blue/Alpha components.) It should not be limited to the 150 nameds colors of Microsoft. (Altho, I can not see anyone using more than a twenty or thirty, but then I'm not an artist to design the graphics. :)
709 If no color is somehow to draw lines or paths then it will be drawn in black.
713 While parsing, a variable name was requested at a parsed item, but there is not that many items in the parse list. So a name is made in the form ParsedWord____TheWordParsed____MaxWordsParsed. Some how the number of the word that was parsed is greate the the number of words in the entire line of source code. This is another case of where the universal laws of physics have been violated.
716 Symbol graphic data is limited to -250 to +250. Some XY was changed to be with in this limit.
719 This is just an internal program warning that a Quote mark is being output to the source code text file.
726 an undocumented feature (which is another way of saying that I haven't got it to work yet.) is that on the flow chart editor screen, you can enter code, imports, and a /route. The /route command will cause FlowChart to try and connect all of the named routes together, while avoiding going over other paths or through symbols. This message is shown for each path in the FlowChart graphics table that is works on. It will try both methods that I am working on. One is a backgraound continusly trying to find where paths need to be added. and the other one for every path that is already rounted, to check if any paths are needed to connect two path segments together.
729 A, B The name of the point in the symbol graphics table is not in the macro code text, or the syntax code text (As {[(Pointname.
731 A zero record type code was foun in the FlowChart graphics table.
735 Invalid index program error the array is not the same size as the index isam. This is another place where the universal laws of physics fail to work. Since the two arrays are changed in size at the same time and the same amount.
736 Invalid index is below or above the sizee of the array.
737 The index pointer array points to outside the bounds of the array
738 Number array and ISAM is not the same size. Another case of where the universal laws of physics fail.
739 Index of an array in outside the bounds of the array
741 the index pointer to the array points to beyond the bounds of the array
742 The index array points to an index that is outside the bounds of the table.
753 The select symbol button is on both the FlowChart editor screen, and the symbol screen. They must always match in sixe, and a select symbol of one will trigger a select symbol for that symbol in the other.
754 The select symbol button is on both the FlowChart editor screen, and the symbol screen. They must always match in sixe, and a select symbol of one will trigger a select symbol for that symbol in the other.
755 When trying to find a path, at every turn it is reported here.
680 This is a GotoNextLine line marker
756 Starting to find a path
681 This is a variable name.
757 This is NOT the selected symbol.
682 This is the closest location thto the path
758 Finished found a path for two points in a path link. It does not mean that a complete connecting path is made, only one path segment is possible here, it will most likely NOT save this point because another path will prove dto be better in some way.
683 The point name Is Not In the syntax With a variable attibute. There must be comething for the point name to replace in the symbol syntax. Such as , if the name of the point is ABC then there needs to be {[(ABC. in the syntax. {[(ABC. is incomplete and has to be {[(ABC.PathName)]} or {[( ABC.Index)]} See Replacement String Properities
759 Ignoreing a graphics code of zero. See 666
761 Need path for this line
762 ignoring zero code in symbol graphics
764 The symbol has an /error code. (This should only to the FlowChart)
767 FindingMyBugsCheckNet_TableLinks : The two paths are connected See 459
768 This is not a /path so we should not be routing to it.
772 This message is a severity level ERROR
773 This message is a severity level WARNING
774 The binary search found the items.
776 This path is not in the path links as being connected.
778 This Point connected to this Path A
779 This Point connected to this Path B
781 Ignoreing zero code
782 No Variable Name
783 Path is connected to something
---------------------------------------------------------------------------------------------------------------------------------------------
784 Path is connected to something
785 These two are not connected.
788 Routing path
789 Make a path to
790 Quto router option is turned off:
791 saving a closer distance to something else
792 Closest other path to route to
793 Memory left :
794 Searching for path Found something else
794 Not a point
795 Searching for path to Found something else
795 Searching for path to
797 Searching for path to
803 Net is empty
804 Problem with these two paths.
805 Can not make a path from a blank path name
807 Path name does not match path links name
807 Path not in any path link
820 Path names do not match
821 Path Name Problem
822 Path Name Problem B
823 Path Name Problem C
824 Path Name Problem D
830 trying to route between
831 This is not a Path
832
836 different names error
900 flowchart hint : Enter path name on FlowChart Screen. To add a constant to the FlowChart
901 flowchart hint : Enter the name of the path in the tool strip text box
902 flowchart hint : Adding Paths requires you To enter a path name
903 symbol hint : symbolchanged has not been set/reset
904 symbol hint : No color names have been entered or imported
905 symbol hint : No data types have been entered or imported.
906 symbol hint :No input/output has been made yet.
907 symbol hint :no line widths are available to be selected.
908 symbol hint : FlowChart program issue, return this error message, a number of bytes is not available.
909 symbol hint Either the line style, line start or line end of line drop down does not have a valid list
910 symbol hint Select the input/output Option For the data path To this symbol from the input/output toolsrip dropdown button.
911 symbol hint You need to enter a name of the point to be added,
912 symbol hint Select the data type from the datatype tool strip dropdown button
914 symbol hint Select a line style, start, and end
915 symbol hint There is no symbol graphics in selected symbol Add symbol points and lines.
916 symbol hint Select a symbol name
917 symbol hint Select a rotation for placing the symbol from the rotation drop down button
918 symbol hint select a symbol name from the select a symbol drop down button
919 symbol hint Select the input or output to add symbol point
920 symbol hint Need To Select a symbol named from the symbol selection tool strip drop down button
921 symbol hint There is no rotation options in the list
922 symbol hint Select a color from the color tool strip drop down button
923 symbol hint Need To Select a color from the color tool strip drop down button
951 flowchart No buttons allowed until you have selected a computer language Button Rules")
952 FlowChart hint No FlowChart graphical information to delete", TopOfFile("FlowChart").ToString, "3") ' mst have "3"
956 FlowChart hint There are no symbols defined to select
999 All 999 messages can not be ignored.
999 Can Not have X1
999 Can Not have Y1
999 Not doable
------------------The following messages will be translated into other language (via Google Translate)
1000 the import bit options are "yes", "true", "on", "no", "false", "off" , all lower case please.
1001 The file was not open since it was not flagged to be as a read or write to the file.
1003 An index is in the array twice, which also means that there is an index missing.
1030 Not a /use, /line, /path, or /point.
1031 Not a /use, /path, /constant or /error.
1117 FlowChart graphics code is not a /use, /path, /constant, /error
1163 The rotation is incorrect for the flowchart symbol object.
1164 This does not have a symbol name.
1167 The first two index pointers are the same.
1168 The random generated index pointer is to low.
1169 The first two index pointers are the same.
1211 The import directive is not a know directive. See Syntax Summary for FlowChart and Syntax Summary for Symbols
1215 Item by Item search found what a binary search did not find.
1270 A binary search failed to find what a item by item search found.
1273 The rotation must be 1 to 16
1280 Two index pointers point to the same items in the array, which means that there is an item that is not being 'seen' by the program.
1283 A program button has not been pushed to select what the mouse will do.
1375 This is an unknow FlowChart graphics code.
1385 The index table is pointing to an array entery, but the array is empty.
1402 The /name could not be added, so all following imports are ignored
1403 The /name could not be added, so all following imports are ignored
1404 The /name could not be added, so all following imports are ignored
1406 The /name could not be added, so all following imports are ignored
1407 The /name could not be added, so all following imports are ignored
1408 The /name could not be added, so all following imports are ignored
1409 The /name could not be added, so all following imports are ignored
1410 The /name could not be added, so all following imports are ignored
1411 The /name could not be added, so all following imports are ignored
1433 FlowChart is checking itself if there are invalid indexes, end of table counters and the sizes of the arrays.
1436 The message number must be between 9 and 10,000
1438 An unknown record code
Index
buttons
symbols
flow chart
FlowChart Computer Language
General:
/ComputerLanguageVariableNameCharacters
/Language
/Option
/Delete
/ThisCode
/Set_
Support Tables:
Symbol:
/Name
/Line
/NameOfFile
/Stroke
/Notes
/Version
/Author
/Opcode
FlowChart:
/Path
/Use
/Error


My Amazing Team!
William Lucht
Team Manager
Employee ID: 1
Email Address<EMAIL_ADDRESS>Office Number: 1337
Tyler Abegg
Engineer
Employee ID: 2
Email Address:
<EMAIL_ADDRESS>Github:
TylerA
Random Jack
Intern
Employee ID: 3
Email Address:
<EMAIL_ADDRESS>School: UCSD
Biggie Codes
Engineer
Employee ID: 4
Email Address:
<EMAIL_ADDRESS>Github:
BiggieC


WITNESS LIST State Recreational Resources Committee March 29, 2001-8:00A HB 2244 For: Bezanson, Janice (Texas Committee on Natural Resources) Bristol, Valarie (Trust for Public Land) Dean-Mooney, Laura (MADD, Texas State) Dominguez, Henry (Anheuser-Busch) Farley, Terry (Self) Gochman, David (Self and Texas Outdoor Recreation Alliance) Haire, Jim (Self and Texans Standing Tall) Hess, Myron (National Wildlife Federation) Hill, Mary (Self) Kaestner, John (Anheuser-Busch) Klussmann, Wallace (Self and Texas Wildlife Association & Texas Farm Bureau) Langford, David K. (Self and Texas Wildlife Association) Nau, John (Self) Pressler, Larry (TRAPS - Texas Recreation and Parks Society) On: Jefferson, John (Texas Chapter, The Wildlife Society) Moss, Kirk (Self) Sansom, Andrew (Texas Parks and Wildlife Department) Ward, Ellen (Self) Registering, but not testifying: For: Carr, Snapper (Texas Municipal League) Ellis, Rod (City of Austin) Headrick, Kelly (American Cancer Society) Humphrey, Cynthia (Association of Substance Abuse Programs) Joiner, Gary (Texas Farm Bureau) Jones, Andy (Texans for State Parks) Morrison, Jim (Artificial Reef Advisory Committee) Posey, John (Mothers Against Drunk Driving) Sybert, Brian (Sierra Club, Lone Star Chapter) On: Perez, Noe E. (Self) HB 2719 For: Basco, Pamela S. (Self and Irby Basco) Larson, Dana (Self) Morrison, Jim (Artificial Reef Advisory Committee) On: Hammerschmidt, Paul (Texas Parks and Wildlife Department) Noble, Dianna (Texas Department of Transportation) HB 3482 Against: Aplin, Jr., Daniel R. (Texas Crab Fishermans Association) On: Hammerschmidt, Paul (Texas Parks and Wildlife Department) HCR 205 Registering, but not testifying: For: Patterson, Jerry (Houston Safari Club & Houston Gun Collectors Association) Perez, Noe E. (Self) Rogers, Jr., Johnnie B. (Houston Safari Club) Tripp, Alice Gene (Texas State Rifle Association)


I'm tChatBot, you could text me everything. I resend your message to
the master.
It average takes 1-2 minutes to response.
Hello There!
I'm Ilya, a web developer from Chelyabinsk, Russia Federation.
Please take a look around!
I am passionate about creating web applications. Although web
development is my hobby, in the future I dream of becoming a real
web application developer.
My coder pathway.
Khan Academy
First of all, I started to learn JavaScrip, HTML, CSS at
Khan Academy.
Through a series of simple but interesting interactive
lessons, I learned the basics of programming.
MDN learning center.
Inspired and enthusiastic, I went to the
MDN Learning Center
course. There was a fundamental and detailed course on HTML,
CSS, responsive design technology, etc. After that, I studied
the jQuery library with the
jQuery learning center.
Based on that knowledge, I created this website.
Codecademy
After studying the general features of front-end development,
I decided to try a new direction of programming - data science
engineering. After I studied the Machine Learning course at
Codecademy.
It was positive experience, but I preferred continue web
development way.
freeCodeCamp
Searched the Internet for a while, I found
freeCodeCamp.org. This is a useful training center that gives knowledge for
free. I was crazy about interesting interactive lessons. I
studied JavaScript in depth for about 300 hours. At the end of
the training block, I received a
Certificate. "Front-End Development Libraries" was the next block
of training. It also representing approximately 300 hours of
coursework. It includes six mini-courses:
Bootstrap framework;
jQuery library;
SASS preprocessor;
React, a popular JS framework from Meta.
Redux state management library
A block of React and Redux that looks at their interaction.
At the end of the course it is proposed to create five small
applications based on the knowledge gained. I've complete it
successful. I've got
Certificate.
This is the second application built on the
TypeScript+React+Bottstrap stack.
This project was bootstrapped with the Codesandbox.io online -
IDE.
For my own needs, I created a free app called Arithmetic
Trainer for First Grade.
Twenty five plus five clock project. #freeCodeCamp project.
Technology stack - React, TypeScript + Bootstrap.
This project was bootstrapped with the Codesandbox.io online -
IDE.
That's the final app in the #freeCodeCamp training series.
Simple app, based on functional components, react hooks.
Technology stack - React + Bootstrap.
This project was bootstrapped with the Codesandbox.io online -
IDE.
That's the fourth app in the #freeCodeCamp training series.
Simple app, based on functional components, react hooks.
Technology stack - React + Bootstrap.
This project was bootstrapped with the Codesandbox.io online -
IDE.
That's the third app in the #freeCodeCamp training series.
Simple app, based on functional components, react hooks.
Technology stack - React + Bootstrap.
This project was bootstrapped with the Codesandbox.io online -
IDE.
Second app in the #freeCodeCamp training series. Simple app,
based on functional components, react hooks.
Technology stack - React + Bootstrap.
First app in the #freeCodeCamp training series. Simple app,
used functional components, react hooks and some react
synthetic events. Animation is made with simple CSS.
Technology stack - React + Redux + React-router + Bootstrap +
some npm react Libraries.
Throughout this project, I have been learning how the
framework works. In this project I used the Redux react state
management tool for the first time.
This project was written in pure HTML/CSS, interactivity was implemented with the JQuery
library and some plugins based on JQuery, such as JQuery waypoints. A list of all the plugins
used can be found at the bottom of this page. For responsive design in this project
I used HTML flex, grid structure, CSS media.


{% extends 'template.html' %} {% block content %} {% include 'school/schooltab.html' %}
| # | School Code | School Name | Address | Number of Staff | District | Datecreated | {% if perms.school.add_school %} Add School {% else %}Action{% endif %} | {% for record in records.object_list %}
|---|---|---|---|---|---|---|---|
| {{forloop.counter}} | {{record.school_code}} | {{record.school_name}} | {{record.school_address}} | {{record.staffnumber}} | {{record.district}} | {{record.datecreated}} | {% if perms.school.change_school %} Edit {% endif %} |


|
KlusterKite
0.0.0
A framework to create scalable and redundant services based on awesome Akka.Net project.
|
Classes | |
| class | MigratorConfigurationState |
| The state of migrators resources More... | |
| class | MigratorMigrationState |
| The migrator state according to the migration More... | |
| class | MigratorTemplateConfigurationState |
| The state of resources of the migrator template More... | |
| class | MigratorTemplateMigrationState |
| The migrator template state according to the migration More... | |
| class | ResourceConfigurationState |
| The resource description More... | |
| class | ResourceMigrationState |
| The resource state according to the migration More... | |
Enumerations | |
| enum | EnMigrationSide { EnMigrationSide.Source, EnMigrationSide.Destination } |
| The type of configuration in the migration More... | |
| enum | EnMigratorPosition { EnMigratorPosition.New, EnMigratorPosition.Present, EnMigratorPosition.Obsolete } |
| The IMigrator or MigratorTemplateMigrationState position in the migration More... | |
| enum | EnResourcePosition { EnResourcePosition.NotCreated, EnResourcePosition.Source, EnResourcePosition.InScope, EnResourcePosition.OutOfScope, EnResourcePosition.Destination, EnResourcePosition.SourceAndDestination, EnResourcePosition.Obsolete } |
| The possible resource migration position according to current migration More... | |
The type of configuration in the migration
| Enumerator | |
|---|---|
| Source | The source configuration |
| Destination | The destination configuration |
Definition at line 18 of file EnMigrationSide.cs.
The IMigrator or MigratorTemplateMigrationState position in the migration
Definition at line 19 of file EnMigratorPosition.cs.
The possible resource migration position according to current migration
Definition at line 18 of file EnResourcePosition.cs.


Remote Movement:
1) psexec
The tried and true method for lateral movement on windows. You can use
psexec [1], winexe [2], metasploit's psexec_psh [3], Powershell Empire's
invoke_psexec [4], or the builtin windows command "sc" [5]. For the
metasploit module, powershell empire, and pth-winexe [6], you just need the
hash, not the password. It's the most universal method (it works on any
windows computer with port 445 open), but it's also the least stealthy.
Event type 7045 "Service Control Manager" will appear in the event logs. In
my experience, no one has ever noticed during a hack, but it helps the
investigators piece together what the hacker did afterwards.
2) WMI
The most stealthy method. The WMI service is enabled on all windows
computers, but except for servers, the firewall blocks it by default. You
can use wmiexec.py [7], pth-wmis [6] (here's a demonstration of wmiexec and
pth-wmis [8]), Powershell Empire's invoke_wmi [9], or the windows builtin
wmic [5]. All except wmic just need the hash.
3) PSRemoting [10]
It's disabled by default, and I don't recommend enabling new protocols.
But, if the sysadmin has already enabled it, it's very convenient,
especially if you use powershell for everything (and you should use
powershell for almost everything, it will change [11] with powershell 5 and
windows 10, but for now powershell makes it easy to do everything in RAM,
avoid AV, and leave a small footprint)
4) Scheduled Tasks
You can execute remote programs with at and schtasks [5]. It works in the
same situations where you could use psexec, and it also leaves a well known
footprint [12].
5) GPO
If all those protocols are disabled or blocked by the firewall, once you're
Domain Admin, you can use GPO to give users a login script, install an msi,
execute a scheduled task [13], or, like we'll see with the computer of
Mauro Romeo (one of Hacking Team's sysadmins), use GPO to enable WMI and
open the firewall.


Node Parent:
Info
Charts
Tools
Datasets
Scripts
Reference
Add New Info
First Name of PI
*
Middle Name of PI
Last Name of PI
*
Collections
*
Tags
*
Main Notebook File
Globus Id
*
Save As
*
Extra Fields
Add New Charts
Kind
*
Figure
Table
Caption
*
Number
*
Files
*
Image Files
*
Notebook File
*
Properties
*
Save As
*
Extra Fields
Add New Tools
Kind
*
Software
Experiment
Package Name
*
Program Name
*
Version
*
URLs
Facility Name
*
Measurement
*
URLs
Save As
*
Extra Fields
Add New Datasets
Files
*
Description
*
URLs
Save As
*
Extra Fields
Add New Scripts
Files
*
Description
*
URLs
Save As
*
Extra Fields
Add New Reference
Kind
*
First Name of Author
*
Middle Name of Author
Last Name of Author
*
Title
*
Journal Full
*
Journal Abbr
*
Volume
*
Page
*
Year
*
Published Date
Received Date
DOI
Abstract
URLs
Save As
*
Extra Fields


EBD - Easton Bible DIctionary
Harhaiah
HARHAIAH
"HARHAIAH "zeal of Jehovah, (
Nehemiah 3:8
) “of the goldsmiths,” one whose son helped to repair the wall of Jerusalem.
"HARHAIAH "zeal of Jehovah, (Nehemiah 3:8) “of the goldsmiths,” one whose son helped to repair the wall of Jerusalem.


Date Range Picker
The Date Range Picker is attached to a text input. It will use the current value of the input to initialize, and update the input if new dates are chosen.Date and Time Picker
The Date Range Picker can also be used to select times. Hour, minute and (optional) second dropdowns are added below the calendars. An option exists to set the increment count of the minutes dropdown to e.g. offer only 15-minute or 30-minute increments.Single Date Picker
The Date Range Picker can be turned into a single date picker widget with only one calendar. In this example, dropdowns to select a month and year have also been enabled at the top of the calendar to quickly jump to different months.Predefined Ranges
This example shows the option to predefine date ranges that the user can choose from a list.Documentation
You can find examples and documentation about Bootstrap date picker and range picker here: Datetime range picker


Title should be less than 200 chars long
Release Date should be greater than 2015-10-01
Rating should be between 1 and 5 inclusive


Cold In California
[Verse 1]
My friends, they’re all growing up
Think they realized that nothing’s as good as it seems
While I try to live off of my dream
Sleeping off a headache from the night I had
Just to get away and pretend I’m free
From responsibilities
[Chorus]
Oh, I'll stop making excuses
And start making it better
But I’m too immature for that
[Verse 2]
I’m tired of the little things
Every little thing
I’ll blame it on anxiety
>
Too many possibilities
While I count my days in coffee rings
A sucker for my sympathy
I’m stuck here now but I don’t know why, why I try
[Chorus]
I could stop making excuses
And start making it better
But I'm too immature for that
You know I'll stop making excuses
And start making it better
But I'm too immature for that
[Bridge]
I want love
But I don’t
But I do
But I want just enough to say it
But maybe one day
[Chorus]
I'll stop making excuses
And start making it better
But I'm too immature for that
You know that I'm too immature for that


xmllint
XML parser and linter that supports XPath, a syntax for navigating XML trees.
More information: home page
- Return all nodes (tags) named "foo":
xmllint --xpath "//foo" source_file.xml
- Return the contents of the first node named "foo" as a string:
xmllint --xpath "string(//foo)" source_file.xml
- Return the href attribute of the second anchor element in an HTML file:
xmllint --html --xpath "string(//a[2]/@href)" webpage.xhtml
- Return human-readable (indented) XML from file:
xmllint --format source_file.xml
- Check that an XML file meets the requirements of its DOCTYPE declaration:
xmllint --valid source_file.xml
- Validate XML against DTD schema hosted online:
xmllint --dtdvalid URL source_file.xml


How does life look through the 'pleasure, passion and purpose' lens? From the 'discovering values and higher purpose' exercise, What are your core values? What do you stand for? How did you find the resilience ideas and meditation exercise? Any other musings? In this chapter, Cheng references an outlook on happiness from Tony Hseih, a successful entrepreneur. He identifies three forms of happiness: Pleasure - The least sustainable form of happiness. Things we do to make ourselves feel happy outisde of work; Passion - More sustainable than pleasure. Things we do where the actual work makes us happy; Purpose - Most sustainable form of happiness. Things we do in service of something bigger than ourselves.
Finding my own core values is a task I've been struggling with for a while now. The introspective activity of meditation I found didn't help too much to find clarity because I feel I need more external input and discovery to try and create a moral framework. I need to add more pieces to the puzzle before I can move on to assembly
This chapter was the most interesting for me so far as it's certainly the area that is most pertinent to my needs at the moment. I found the envisioning future self exercise to be an interesting thought experiment and think I took a lot away from it. Looking forward to reading more!


COVID Assistance
It helps people assess their body health condition themselves on their fingertips so that if infected the person will be prompted to immediately consult a COVID-19 specialist based on his/her symptoms mentioned by the user during the conversation with the chatbot. Based on its advantages of taking the assessment from anywhere and at anytime.


Member Details
Qualification Details
Title :
Type :
Master's Degree
Bachelor's Degree
Diploma
12th
10th
Stream :
Year :
College Name:
Percentage :
Date of Birth :
Gender :
Male
Female
Professional Details
Title :
Company Name :
Designation :
Package :
Join Date :
End Date :
City :


Of course, the first thing that your job interview for that cushy new Rust job will task you with is building FizzBuzz. Let’s do it!
If you’re not familiar, FizzBuzz is a simple programming problem:
“Write a program that prints the numbers from 1 to 100. But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. For numbers which are multiples of both three and five print “FizzBuzz”.”
This will give us a good excuse to go over some basics of Rust: Looping, tests, printing to standard output, and a host of other simple things.
First, a test. This will go in fizzbuzz.rs:
#[test]
fn test_div_by_three() {
if div_by_three(1) {
fail!("One is not three");
}
}
And compile it:
$ rustc --test fizzbuzz.rs
fizzbuzz.rs:3:8: 3:20 error: unresolved name `div_by_three`.
fizzbuzz.rs:3 if div_by_three(1) {
^~~~~~~~~~~~
error: aborting due to previous error
This makes sense: We haven’t defined any functions yet. Let’s define one:
fn div_by_three(num: int) -> bool {
true
}
#[test]
fn test_div_by_three() {
if div_by_three(1) {
fail!("One is not three");
}
}
Okay. Here’s some new syntax. The num: int
says that we take one argument, num
, and that it’s of an integer type. The -> bool
says that we return a boolean, and the true
, well, returns true. Just like Ruby, the value of the last expression gets returned.
You’ll also note we have an if
expression. It’s pretty close to what you’d expect, but we have curly braces rather than our friends do/end
.
Now that we’ve got that cleared up, let’s compile and run our tests:
$ rustc --test fizzbuzz.rs
fizzbuzz.rs:1:17: 1:18 warning: unused variable: `num`, #[warn(unused_variable)] on by default
fizzbuzz.rs:1 fn div_by_three(num: int) -> bool {
^
running 1 test
test test_div_by_three ... FAILED
failures:
---- test_div_by_three stdout ----
task 'test_div_by_three' failed at 'One is not three', fizzbuzz.rs:8
failures:
test_div_by_three
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured
task '<main>' failed at 'Some tests failed', /home/steve/src/rust/src/libtest/lib.rs:243
Rust is kind enough to give us a warning: we never used the num
argument. We then get our failure, “One is not three”, because we returned true. Now that we have a failing test, let’s make it pass:
fn div_by_three(num: int) -> bool {
false
}
#[test]
fn test_div_by_three() {
if div_by_three(1) {
fail!("One is not three");
}
}
TDD means do the simplest thing! Compile and run it:
$ rustc --test fizzbuzz.rs
fizzbuzz.rs:1:17: 1:18 warning: unused variable: `num`, #[warn(unused_variable)] on by default
fizzbuzz.rs:1 fn div_by_three(num: int) -> bool {
^
$ ./fizzbuzz
running 1 test
test test_div_by_three ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
Awesome! We pass! We still have that warning, though… let’s write another test, and see what happens:
fn div_by_three(num: int) -> bool {
false
}
#[test]
fn test_div_by_three() {
if div_by_three(1) {
fail!("One is not three");
}
}
#[test]
fn test_div_by_three_with_three() {
if !div_by_three(3) {
fail!("Three should be three");
}
}
$ rustc --test fizzbuzz.rs
fizzbuzz.rs:1:17: 1:18 warning: unused variable: `num`, #[warn(unused_variable)] on by default
fizzbuzz.rs:1 fn div_by_three(num: int) -> bool {
^
$ ./fizzbuzz
running 2 tests
test test_div_by_three ... ok
test test_div_by_three_with_three ... FAILED
failures:
---- test_div_by_three_with_three stdout ----
task 'test_div_by_three_with_three' failed at 'Three should be three', fizzbuzz.rs:15
failures:
test_div_by_three_with_three
test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured
task '<main>' failed at 'Some tests failed', /home/steve/src/rust/src/libtest/lib.rs:243
Great! It showed that our first test passed, and that our second one failed. Let’s make both tests pass:
fn div_by_three(num: int) -> bool {
if num % 3 == 0 {
true
} else {
false
}
}
#[test]
fn test_div_by_three() {
if div_by_three(1) {
fail!("One is not three");
}
}
#[test]
fn test_div_by_three_with_three() {
if !div_by_three(3) {
fail!("Three should be three");
}
}
$ rustc --test fizzbuzz.rs && ./fizzbuzz
running 2 tests
test test_div_by_three_with_three ... ok
test test_div_by_three ... ok
test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured
Awesome! This shows off how elses work, as well. It’s probably what you expected. Go ahead and try to refactor this into a one-liner.
Done? How’d you do? Here’s mine:
fn div_by_three(num: int) -> bool {
num % 3 == 0
}
Wait, whaaaat? Remember,the last thing in a function is a return in Rust, but there’s one wrinkle: note there’s no semicolon here. If you had one, you’d get:
$ rustc --test fizzbuzz.rs
fizzbuzz.rs:2:15: 2:16 note: consider removing this semicolon:
fizzbuzz.rs:2 num % 3 == 0;
^
fizzbuzz.rs:1:1: 3:2 error: not all control paths return a value
fizzbuzz.rs:1 fn div_by_three(num: int) -> bool {
fizzbuzz.rs:2 num % 3 == 0;
fizzbuzz.rs:3 }
error: aborting due to previous error
Basically, ending an expression in Rust with a semicolon ignores the value of that expression. Another way to think about it is that the semicolon turns the expression into a statement, and statements don’t have values. This is kinda weird. It becomes natural after some use, though. And Rust is even smart enough to tell us that it’s probably a problem!
Okay, now try to TDD out the div_by_five
and div_by_fifteen
methods. They should work the same way, but this will let you get practice actually writing it out. Once you see this, you’re ready to advance:
$ rustc --test fizzbuzz.rs && ./fizzbuzz
running 6 tests
test test_div_by_fifteen ... ok
test test_div_by_five_with_five ... ok
test test_div_by_five ... ok
test test_div_by_fifteen_with_fifteen ... ok
test test_div_by_three ... ok
test test_div_by_three_with_three ... ok
test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured
Okay! Let’s talk about the main program now. We’ve got the tools to build FizzBuzz, let’s make it work. First thing we need to do is print out all the numbers from one to 100. It’s easy!
fn main() {
for num in range(1i, 100) {
println!("num");
}
}
Step one: print something 100 times. If you run this via rustc fizzbuzz.rs && ./fizzbuzz
you should see num
printed 100 times. Note that our tests didn’t actually run. Not only are they not run, they’re actually not even in the executable:
Compile with the test flag:
$ rustc --test fizzbuzz.rs
On Linux:
$ nm -C fizzbuzz | grep test
On OS X:
$ nm fizzbuzz | c++filt -p -i | grep test
Expected output:
0000000000403cd0 t test_div_by_five_with_five::_79fbef3fc431adf6::_00
0000000000403ac0 t test_div_by_three_with_three::_79fbef3fc431adf6::_00
0000000000403c10 t test_div_by_five_with_not_five::_79fbef3fc431adf6::_00
0000000000403ee0 t test_div_by_fifteen_with_fifteen::_79fbef3fc431adf6::_00
0000000000403a00 t test_div_by_three_with_not_three::_79fbef3fc431adf6::_00
0000000000403e20 t test_div_by_fifteen_with_not_fifteen::_79fbef3fc431adf6::_00
U test::test_main_static::_e5d562a4bc8c4dd6::_06
000000000040fea0 T __test::main::_79fbef3fc431adf6::_00
0000000000614890 D __test::tests::_7c31a8a9617a6a::_00
Compile without the test flag:
$ rustc fizzbuzz.rs
On Linux:
$ nm -C fizzbuzz | grep test
On OS X:
$ nm fizzbuzz | c++filt -p -i | grep test
Expected output:
$
Neat, huh? Rust is smart.
Anyway, nm
: The nm
program lists all the symbols in a binary executable or library. The -C
option is important on linux, it “de-mangles” the symbol names. On OS X, nm
provides no symbol de-mangling option, so the output must be piped to c++filt
. Rust uses the same mangling scheme as C++, so it’s compatible with all the existing tools. How it works isn’t that important, though. It’s cool low-level stuff if you’re into that sort of thing.
Anywho, where were we? Oh, iteration:
fn main() {
for num in range(1i, 100) {
println!("{:d}", num);
}
}
This uses string interpolation: the double curlies tell Rust where to place num
in the string.
Anyway, now we have 1 to 99. We need 1 to 100.
fn main() {
for num in range(1i, 101) {
println!("{:d}", num);
}
}
Now we can put the two together:
fn main() {
for num in range(1i, 101) {
let mut answer = "";
if div_by_fifteen(num){
answer = "FizzBuzz";
}
else if div_by_three(num) {
answer = "Fizz";
}
else if div_by_five(num) {
answer = "Buzz";
}
else {
answer = "";
};
println!("{:s}", answer);
}
}
Uhhhh let mut
? let
is the way that we make a local variable. mut
means we plan to mutate that variable: yes, variables are immutable by default.
Also, :s
is the format string for a… string.
We can shorten this up a bit with this syntax:
fn main() {
for num in range(1i, 101) {
let mut answer =
if div_by_fifteen(num){
"FizzBuzz"
}
else if div_by_three(num) {
"Fizz"
}
else if div_by_five(num) {
"Buzz"
}
else {
""
};
println!("{:s}", answer);
}
}
We’ve made the if
assign the value to answer. Note that we had to remove the semicolons again; that lets the expression give its value to answer.
Note that this _also_ makes answer immutable, so we can remove the mut
:
fn main() {
for num in range(1i, 101) {
let answer =
if div_by_fifteen(num){
"FizzBuzz"
}
else if div_by_three(num) {
"Fizz"
}
else if div_by_five(num) {
"Buzz"
}
else {
""
};
println!("{:s}", answer);
}
}
Not too shabby! I love eliminating mutable state.
Of course, this version gives us lots of empty lines, so what we actually want is:
fn main() {
for num in range(1i, 101) {
let answer =
if div_by_fifteen(num){
"FizzBuzz".to_str()
}
else if div_by_three(num) {
"Fizz".to_str()
}
else if div_by_five(num) {
"Buzz".to_str()
}
else {
num.to_str()
};
println!("{}", answer);
}
}
Why the “to_str()
”s? There are two types of Strings in Rust: Str
, which is a heap allocated string with dynamic length, and &str
, which is a borrowed, immutable view into a string. The literal is of type &str
, but we want a Str
. to_str()
turns a &str
into a String
.
Before, we could get away with a &str
, because they all had the same type. But since we’ve added an arm with an int
, we need to make them all the same type, and there’s no way to convert an int
into a &str
.
Because the if
returns a value, we could also do something like this:
fn main() {
for num in range(1i, 101) {
println!("{:s}",
if div_by_fifteen(num) { "FizzBuzz".to_str() }
else if div_by_three(num) { "Fizz".to_str() }
else if div_by_five(num) { "Buzz".to_str() }
else { num.to_str() }
);
}
}
It’s more compact, and removes the intermediate variable all together.
We can do one other thing too: this whole if/fail!
thing so common in tests seems too complex. Why do we have to write if over and over and over again? Meet assert!
:
#[test]
fn test_div_by_fifteen_with_fifteen() {
assert!(div_by_fifteen(15))
}
This will fail if it gets false, and pass if it gets true. Simple! You can also give it a message to be printed when the assertion fails, mostly useful when you are using assert!
to test for preconditions and such:
fn main() {
assert!(1 == 0, "1 does not equal 0!");
}
Try running it.
Anyway, awesome! We’ve conquered FizzBuzz.