This plugin is for loading a Map, a Gradle Project or extension object (and objects nested beneath them), with properties from Java properties file; or for expanding given Strings or text files with the objects just listed or with a supplied Map; plus a general Gradle Copy Filter is provided.
IMPORTANT: Users who are upgrading Gradle or upgrading JavaPropFile should
read the file upgrade.txt in the doc subdirectory.
Most classes are supported, so that you can write JDK objects, custom objects, array, and collections in addition to String values (using a simply casting syntax like "file.txt(File)"). Several mechanisms provided make it easy use a differentiated property name space for propery file loads (when your use case allows for this). The Copy Filter is very similar to the Gradle built-in operator:
filter { String line -> output one line }
but eliminating the performance and limitations due to processing a-line-at-a-time.
What's wrong with Gradle's gradle.properties system? You are restricted to a single properties in your home directory and one for each project directory, all with mandated name. If you want to separate your properties into shared properties and personal properties, as is a very good practice, you can't. If you want to set the value of a property based on anything else (like a previously set property, an extension object property value, a system property, or some nested item in your Project), you can't. If you want to set even a basic JDK object like a Boolean or File value, you will have to change your Gradle Groovy code to convert from the String property value. If you want to load or merge new properties from a properties file into an exiting map, perhaps automatically prefixing these properties with a distinguishing prefix, you have to do that manually. If you want to do all of these things at once... settle down for a week of coding.
What's wrong with Gradle's filter { Sring line -> ... }? Nothing if you really want to work on each input file line independently. Otherwise, your app will suffer from a massive performance penalty from executing the closure once for every input file line stead of just once; and you are subject to regular expression and EOL-transformation limitations.
A sample build setup is provided in subdirectory doc. Even if you don't care to run the demo, you would probably benefit by looking at the .properties files in there, if not the build.gradle file. If you want to run the example and are pulling this project from Git, then cd to the doc subdirectory and run ../gradlew (..\gradlew on Windows). You do not need to have Gradle installed to run the demonstration (if you pull the entire project from Git). WARNING: If you pull from Git trunk, you will be working with pre-production code. The sample may be in the process of being updated. If you experience problems running the sample, work with a Git tag instead of trunk, or open a Github Issue to get help.
xfer.max(Float)=30.0and to dereference object properties, like:
compileJava.options.debug(Boolean) = falseThe behavior is toggled by whether or not the property file definition has a space after the key. Note the space before "=" above.
filter { String line -> output one line }but with good performance and without the limitations. See ContentAsStringFilter below.
Couldn't be easier. This will pull the plugin from jCenter:
buildscript { repositories { jcenter() } // Before plugin v. 1.0.0 use mavenCentral() dependencies { classpath 'com.admc:gradle-javaPropFile-plugin:latest.integration' // For strictly repeatable builds, replace 'latest.integration' // with the latest literal GA version label. } } apply plugin: 'com.admc.javaPropFile' // Following loads 'app.properties' then 'local.properties' files // from project directory if they exist there. propFileLoader.traditionalPropertiesInit() // See // http://admc.com/projectdocs/gradle-javaPropFile-plugin/readme.html // for examples of specifying your own file names and settings, // including usage of typeCasting. // Create a new Map by loading a properties file: someMap = propFileLoader.load(file('mail.properties'), [:]) // The "[:]" parameter causes a map to be returned (as opposed to // adding to the project's properties and returning nothing). // To use the ContentAsStringFilter, you don't need to 'apply' anything. import com.admc.gradle.ContentAsStringFilter task anyCopyTask(type: Copy) { from 'src/main/resources' into 'build/tmp/x' filter(ContentAsStringFilter, closure: { it.toLowerCase() }) } // See // http://admc.com/projectdocs/gradle-javaPropFile-plugin/readme.html // for some other very useful examples using ContentAsStringFilter.
Just use your browser to go to the JavaPropFile directory at jCenter. http://jcenter.bintray.com/com/admc/gradle-javaPropFile-plugin/. Click into the version that you want. Right-click and download the only file in that directory that ends in "-<VERSION_LABEL>.jar" (i.e. the only jar file which is neither for JavaDoc nor source code).
You can save the plugin jar with your project, thereby automatically sharing it with other project developers (assuming you use some SCM system). Or you can store it in a local directory, perhaps with other Gradle plugin jars. The procedure is the same either way:
buildscript { dependencies { classpath fileTree( dir: 'directory/containing/the/plugin/jar/file', include: 'gradle-javaPropFile-plugin-*.jar' ) } } apply plugin: 'com.admc.javaPropFile' // Following loads 'app.properties' then 'local.properties' files // from project directory if they exist there. propFileLoader.traditionalPropertiesInit() // https://github.com/unsaved/gradle-javaPropFile-plugin/tree/master/doc // for examples of specifying your own file names and settings, // including usage of typeCasting. // Create a new Map by loading a properties file: someMap = propFileLoader.load(file('mail.properties'), [:]) // The final "[:]" parameter causes a map to be returned (as opposed to // adding to the project's properties and returning nothing). // To use the ContentAsStringFilter, you don't need to 'apply' anything. import com.admc.gradle.ContentAsStringFilter task anyCopyTask(type: Copy) { from 'src/main/resources' into 'build/tmp/x' filter(ContentAsStringFilter, closure: { it.toLowerCase() }) } // See // https://github.com/unsaved/gradle-javaPropFile-plugin/tree/master/doc // for some other very useful examples using ContentAsStringFilter.
Java properties files allow for the key to be terminated by equal sign, colon character, or a white space character. (Our keys contain a property and may contain other typing and parent-object-identifying information). Since white-space is optional after the property keys, and since property file rules even allow for the '=' to follow white space, we use white space in this position to toggle DotDeref behavior.
Compare:
x.a=eks # No whitespace immediately after key x.a so property name is x.a.
vs.
x.a =eks # Whitespace immediately after key x.a so this means property a of # object x.
(MNEMONIC: Groovy is distinctive for allowing white space to delimit between method name and parameters. We use white space as delimiter to trigger Groovy-style dereferencing.) The presence of absence of white space after the key enables or disables DotDeref both for the key and for ${references} in the value. Another example to show this:
x=Value includes a reference to ${property.with.name.containg.dots}
vs.
x =Value includes a reference to ${subObject1.subObject2.propertyName}
References are not allowed on the left-hand side of property file records. They may be used on the value (right-hand) side of property file records, and in Strings and Files that are expand()ed. These are the variants:
${propName} # Simple property 'propName' of the target # object (which defaults to the Gradle Project). ${sys|propName} # For Java system property 'propName', using # default systemPropPrefix of 'sys|'. ${extObj$propName} # Property 'propName' of extension object 'extObj' ${obj1.obj2.propName} # If DotDeref operator is not active, # then this is just property # 'obj1.obj2.propName' of the target object # like the first case above. # If DotDeref operator is active, # then this is property 'projName' of property # obj2 of property obj1 or the target object. # In the second case, it is an error to # reference a non-defined property. # In all cases above (except nested properties, as noted), references # to properties that are missing are handled according to the default # or specified unsatisfiedRefBehavior. $~{!propName} # For all variants above, if the reference $~{!sys|propName} # property name is immediately preceded by !, etc. # then the unsatisfiedRefBehavior is thereby # overridden so that if the referenced property # is not set, JavaPropFile wil throw. , etc. # Just like previous case, but if the property is # not set, the expression will be replace # with nothing at all (an empty string). ${.propName}, etc. # Just like previous case, but if the property is # not set, the ${....} expression will be left # exactly as it is. # The !, -, . prefixes, which override unsatisfiedRefBehavior, are # known as 'behaviorRefPrefixes'.
In all cases, sequence is consistent and understandable. According to Java's property file rules, it is useless to assign to a single property twice in a single properties file. We therefore prohibit this confusing and misleading scenario. In the great majority of cases, sequence makes no difference. You can assign as many properties as you wish to, and reference as many properties as you wish to, and as long as the following two situations do not apply, the sequence doesn't matter. The ${reference} value of property 'x' will be precisely what 'x' is set to in the same file (or, if it is not set in this file, then what it was before the file was loaded). If 'x' is referenced 100 times like ${x}, it will have the same value every time, regardless of whether it is referenced before or after 'x' is assigned.
You escape with backslash \, whether escaping is required by Java properties file format, java.util.regex.Pattern format, or JavaPropFile. As is very well documented at http://docs.oracle.com/javase/6/docs/api/java/util/Properties.html#load(java.io.Reader) you must \ to escape all white space characters (including line breaks), ':', and '=' inside of property keys. As a consequence of the java.util.Properties \-escaping rules, if you want to totally avoid expansion-processing of a particular variable reference like ${this}, you must double-\-escape it like this: \\${this}.
colon\:and\ space_inside_property_key=hello
But to tell JavaPropFile to escape characters (list of examples follows), you must double escape with \\, because that is how you tell any Java properties file to pass | to the application (and in this context, JavaPropFile is an application). Examples:
# A literal | in a regex must be escaped, and you must use \\ to get # \ to JavaPropFile: mockBean$intList(Integer[\\|]ArrayList)=91|72|101 # The ' ' here does not need to be escaped in a regex, but does need # to be escaped in a properties file key or the key would end at the # space: alpha(Integer[\ ]ArrayList)=94 3 12 expressionVar=Value will contain literal \${dollar sign and curlies} enableX\\(Boolean\\)=With typeCasting on you need this for property \ name "enableX(Boolean)". # With no space after the key, no need to escape dots in keys and refs. owner.id=x5klh.umagumma # But if you want to use DotDeref for only part of # the definition, you will need to escape: owner\\.id=x5klh.${plugBean.user.name}
Property names may begin with the characters ! - . but if you ${reference} them, you must escape that character with \\, like:
nestingVar=${\\!nested!var}} # References property '!nested!var' # Note that you only escape these characters in references and only # when they are the first character. The 2nd ! above should and may # not be escaped.
What characters must be escaped just for JavaPropFile? In .properties name (left) sides:
\\$ Unless $ used to specify an extension object \\( Unless ( used to start a typecast \\) Unless ) used to end a typecast
Inside of ${...} (which are only allowed in .properties value (right) sides and in expand() Strings or text files):
\\$ Unless $ used to specify an extension object \\} Otherwise it would end the ${...}
Precedence works intuitively, not freakishly like Ant properties. The value of a property will be the last value that was assigned to it. You can prohibit attempts to overwrite by throwing or silently ignoring.
Gradle provides no way to unset/remove any Project property, therefore JavaPropFile has no capability to remove a property.
Loads a properties file and writes Gradle Project properties with those values.
Exact same as previous, except that each property written to the Project is prefixed with the supplied String. If you ran "propFileLoader.load(file('a.properties'), 'pref')" and you have a line in a.properties like:
key=val
then JavaPropFile would end up doing
gradleProject.setProperty('prefkey', 'val')
Loads a properties file and writes map properties with those values. You must specify a Map to be populated, so if you want to load a new Map, just specify value [:] as the map. The given aMap reference will be returned.
Exact same as previous, except that each property written to the Map is prefixed with the supplied String. See description for the load(File, String) method above for details about how the prefix value is applied.
The String is an extension object name. This is the default object to apply property values to (or with as-dereference-operator, this is where the dereferencing begins).
Loads app.properties (if it is present), prohibiting use of undefined ${...} references; then loads local.properties (if it is present), allowing use of undefined references. Overwriting is allowed. (It will use whatever settings you have made previously regarding typeCasting, system property assignment, and system property expansion. Only the last of these is enabled by default). File build.properties is actually a more traditional file name than app.properties or local.properties but unfortunately the name build.properties does not distinguish whether it is intended for shared or private/local usage, so I have standardized on the distinctive names app.properties and local.properties
Most users will not use this. It is for checking the state of deferred extension object properties. Returns a map of extension object names to map of deferred property definitions for that extension object.
This probably won't be called in the context of using JavaPropFile, but some developers may want to copy this, as it successfully uses the context class loader and Groovy's default package rules to resolve class names.
Most users will not use this. It is invoked automatically by a Gradle callback to execute deferred extension property settings when the target extension object comes online.
The following methods all expand references in the specified String or File (1st parameter) and return the resulting String. propFileLoader Settings like propFileLoader.unsatisfiedRefBehavior effect how expansions are performed. A peculiarity is that since Behavior.NO_SET makes no sense when only doing expansion, in this method a setting of Behavior.NO_SET causes expansion exactly like Behavior.LITERAL. If a method variant with File parameter and a final String param, the final String parameter is the encoding type that will be used when reading the input text file. If a boolean is specified, that enables DotDeref, which is disabled by default. If a Map is specified, then that mapping will be used by default for expansion mappings instead of the Gradle Project properties. See the Expand methods section below for more details.

What to do when ${x} is used in a property value, but 'x' is not defined. Defaults to com.admc.gradle.THROW, which will cause the property file load to fast-fail. You can change the behavior to any of the following. (My syntax here assumes that you imported the class com.admc.gradle.JavaPropFile).
JavaPropFile.LITERAL Leave literal ${x} JavaPropFile.EMPTY Replace ${x} with the empty string JavaPropFile.NO_SET Don't set the property at all JavaPropFile.THROW Here only for completeness. See above.
unsatisfiedRef behavior does not apply to references to missing extension object references like ${x$y} (on the value side of assignments or in expand() Strings/files). This situation will always throw. The only reason for this exception is the amount of coding and complexity needed for a capability with unknown user demand. The unsatisfiedRefBehavior setting can be overridden for individual references by using property name prefixes (., -, N/A, ! prefixes corresponding to the listed behaviors).
Property file loading will throw and abort immediately if a property assignment is attempted to a property that already has a value. (Empty string values and nulls are still values). Attempts to assign the same value that a property already has is always allowed. If this value is true, the value of propFileLoader.overwrite doesn't matter. Defaults to false
If set to true, and .overwriteThrow is false (its default), then you can change existing property values. Defaults to true. If false, and .overwriteThrow is false, then attempts to change existing property values are silently ignored.
If this is non-null, then you can both reference system properties in property definition values, and can assign system properties. An example of each with systemPropPrefix set to sys|:
projectOwner=Mr. blaine sys|java.io.tmpdir=/usr/local/tmp
Set to null to prevent referencing and assignment of system properties. Defaults to sys|.
If set to true, then whenever you set a property with name beginning or ending with a (ParenthesizedString), the parentheses and contents will be stripped off and an instance of the specified class name will be instantiated. Use just () to assign a null. Details about this follow.
If false then assignments to missing extension objects will cause the property file load to fail. If true, then assignments for missing extensions will be deferred until the target extension objects become available. Defaults to true.
Type casting is in effect if you set: propFileLoader.typeCasting = true
Property settings with specified name that does not start or end with parentheses will behave without any type casting, exactly as if typeCasting were off.
Put the name of the desired Java class in parentheses immediately before or after the property name, with no intervening spaces. An instance of that class will be instantiated using the specified property value as String parameter to either the static valueOf(String) method of the class, or a String-parameter constructor.
Groovy's rules for package defaults apply.
Some examples:
output(File)=/path/to/file.txt (Long)xferTime.max=31.25 compileJava.options.debug(Boolean) = false monitor(com.admc.net.NetworMonitor)=Custom Network Monitor mavenRepository.dest.url(URL)=file:/tmp/fakeMvn
To assign a null, do the same thing, but give no value at all for class name nor property value:
envTarget()=
Immediately after the element typeCasting class, add [ + splitting-pattern + ] + optional-CollectionImplementationClass. The Splitting pattern is a java.util.regex.Pattern String, and you must, of course, follow Java properties file escaping rules. If no collection implementation class is specifies, an Array will be instantiated. Examples:
mockBean$intList(Integer[\\|]ArrayList)=91|72|101 # Note the extra ugly backslashes needed to satisfy both Java # properties escaping and java.util.regex.Pattern escaping for '|'. alpha(Integer[\ ]ArrayList)=94 3 12 alpha(String[,]HashSet)=one,two,three
If you have JavaPropFile configured to allow property overwriting (by default it is allowed), you are still never allowed to directly change a property value from one non-null type to another non-null type. If you really want to, you can get around htis constraint by assigning null and then assign to the new value.
Set attribute closure to a closure that transforms the entire input file text into output file text. As noted above, the advantages of ContentAsStringFilter are, it invokes the supplied closure only once for each input file, and it has no limitations on regex support or EOL-handling. See doc/build.gradle for useful examples with Copy task configuration, functional copy {...} calls, and filtering a just subset of a predefined file collection.
File doc/build.gradle has an example of expanding property references in application files using a ContentAsStringFilter and an .expand() call.
When using the expand method nested in some closures... definitely when calling expand inside of a ContentAsStringFilter... reference failures (throws) will just indicate failure whatever executes the closure. In the case of a reference failure in a ContentAsStringFilter, you will get a Gradle error message including "Cause: Could not copy file...". Just re-run the Gradle command with the addition of the -s switch and look through the stack traces for the precise failure cause.
JavaPropFile is distinctive from other templating/expansions systems in that it can be used with the other systems without breaking them. I very frequently want to perform build-time substitutions on files that will later be run-time substituted. This is a major pain with other systems out there, requiring extra staging directories, escaping characters, non-standard delimiters, loss of validation, etc. This use case is handled intuitively by JavaPropFile by three easy steps:
propFileLoader.unsatisfiedRefBehavior = JavaPropFile.Behavior.LITERAL
Instead of duplicating an example here, see the configuration of task processResources in this production build file: https://github.com/unsaved/jcreole/raw/master/build.gradle


logger
Home
About
Contact
Search
© This website is designed and created by Sakshi Jain , a sophomore from Sgsits Indore. Back-end is in process . Any suggestions regarding the same are welcome. Also, you can share your articles on<EMAIL_ADDRESS>Thank you for visiting!


🔊 PODCAST | My HIV story - Dr. Watiti and Aloysius Matovu Joy
by AdminIn a three part HIV/AIDS podcast series starting tonight, Dr Love speaks to Aloysius Matovu Joy and Dr. Stephen Watiti on their HIV experince
In a three part HIV/AIDS podcast series starting tonight, Dr Love speaks to Aloysius Matovu Joy and Dr. Stephen Watiti on their HIV experince


Adikavi Nannaya University was established on 22nd April,2006 by the state Government of Andhra Pradesh to promote higher education in the Godavari Region.The University has 486 affliated colleges including Under Education,Post Graduation & Education. The University under the professional/academic gudiance of Hon’ble Vice Chancellor Prof.Murru Mutyalu Naidu’s presently stridling to imprint ‘a mark of excellence’.In addi tion a number of colleges being offered presently in the university colleges of Arts & Commerce, Science & Technology, Engineering & Education the university is visualizing to initiate a few new Post Graduation courses from the academic year 2016-17.
University College Of Engineering was established since the inception of the University. It offers two post graduate programes in M.Tech(CST), MCA, and four under graduate programes B.tech(CSE,EIE,INF,ECE).University College of Engineering also offers Ph.D Program. University College of Engineering Excels with the potential of excellent Faculty with diverse research areas.The Objective of University College of Engineering is to achieve excellence in various fields of the technology and to be with in the vicinity of Industry demands combined with reasearch oriented thoughts. Students are progressively exposed to a gamut of subjects from the core related to advanced technologies which will make them competent enough in the competitive era in the fields of the Computer Science and Information & Communication Technology.


Latvian government decides to divert hospitals’ profits for infrastructure development
by BNNThe government has decided to allow capital associations in which Healthcare Ministry is a shareholder to divert clean profits and dividends for 2018 towards improvement of infrastructure, as confirmed by Healthcare Ministry.
The ministry explains this step will allow certain hospitals to improve their environment’s accessibility, develop services and help resolve infrastructure-related matters.
Aknīste Psychoneurological Hospital will be able to divert profits of EUR 1 377 from 2018 towards repairs of its boiler room to ensure unhindered economic operations of the hospital.
Daugavpils Psychoneurological Hospital’s profits of EUR 2 134 will be diverted towards development and expansion of accessibility of rehabilitation services.
Ģintermuiža Hospital will be able to divert its profits of EUR 352 towards procurement of a gas-powered boiler (total costs planned at EUR 45 000), considering the old boiler is too used up.
Piejūra Hospital will be able to diver its profits of EUR 4 512 towards the project Successful Psychological and Sensory Rehabilitation for Children and Adults Suffering from Mental and Behavioural Disorders to help improve service quality.
Read also: State Audit: Latvia’s Healthcare Ministry is fighting problems that existed ten years ago
National Rehabilitation Centre Vaivari will use its profits of EUR 3 859 to help restore walkways on its territory (total costs estimated at EUR 4 000) to help improve environmental accessibility for patients.
Considering limited state budget availability for healthcare, diverting profits from Healthcare Ministry’s capital associations towards infrastructure and service development, which is a normal practice supported by the government, the ministry reminds.


pa-infinite-scroll
is a wrapper component using intersection observer to setup a performant way for loading more data when reaching
anchors. One anchor is positioned in the middle of the container, and the other is after the content.
By default, the intersection observer is relative to the viewport. It becomes relative to the host when the host
has
overflow: auto;
or
overflow-y: scroll;
style property set.
{{code}}


Despite what I initially thought, I am really enjoying Search Inside Yourself so far. I have attempted to read a couple of mindfulness books in the past and have always struggled to get past the first couple of pages.
I think the difference with Search Inside Yourself has mainly to do with the author. Coming from an an engineering background, Meng is able to write in a down-to-earth, easy to understand manner. The way in which he provides quotes from different sources to highlight what he is saying, knowing that each member of his audience is likely to resonate more with one of them than the others, is testiment to this. An example of this is on page 66, when he defines the concept of mindfullness. He drawns upon Jon Kabat-Zinn and Thich Nhat Hanh to supply definitions of the concept, before telling us that he is drawn more to Kabat-Zinn's encapsulation as it is likely to resonate more with engineers (perhaps due to it's more sceintific langauage.)
In paticular, I really like the quote from this chapter that comes from Viktor Frankl:
“Between stimulus and response, there is a space. In that space lies our freedom and our power to choose our response. In our response lies our growth and our happiness.”
I find that I am often quick to react to emotions, and I anticipate that by reading this book, and carrying out the exercises within, that I will be able to temper this tendancy. This is probably the thing that I am looking forward to the most
The first exercise from the book, the two minutes of mindfullness, I found quite interesting. I was sitting in a busy cafe (not the architypical setting for medidation), and decided to meditate the "Easy Way" (i.e. concentrating on my breath for two minutes). From yoga sessions that I have done, as well as one of the readings on meditation from last week, I know that one approach to meditation is to embrace the noise and activity that is going on around you. For my two minutes I focused on my breath, but did not worry too much that I could hear the music from the cafe, the conversations of the other customers, etc. I had my eyes closed and was just feeling how it was to sit and breath. Interestingly, after just those two minutes I felt more relaxed and calm.
For next week I am going to incorporate the behavioural concept from BJ Fogg that we learnt last week to make 2 minutes of mindfullness part of my routine. I am going to find an activity that I already do as part of my day (maybe having a shower) and will tack on a 2 minute mindfullness exercise after that activity. Then I will congratulate myself on my acomplishment ;-)


Am Derrick Karitu,but Deko is just fine with me.Born in a Kenya,Africa.Having completed my studies
at Jkuat University
where I took information Technology for my unending love fot Tech.
With an year of experience in graphic design after working at Zuca Solutioin in Nakuru
where I fell in love with coding and decided to attended Moringa schools
and am currently learning how to be a skilled developer.
Hoping to get sharp skills in coding i.e. get help from technical mentors (TMs)
on shortcuts and better programming techniques to save time while working on a program.
Hobbies:
They say love what you do and do what you love,so I follow up on
acting,coding and change and motivate people with my works.
Coding is the most interesting staff right now wish I started earlier.
Though requires time,passion and critical thinking:Here are some programs
created so far.


Read fodors reviews to fins the best travel destinations,hostels and restaurents, plan your trip online with fodors india bristles with a minf-strring mix of landsacpes and cultural tradisions,your journey through this intoxicating country wil blaze in your memory long after you've left its shores.


Pinball Overdrive is a retro-themed pinball game inspired by the arcade era!
Watch out! Various moving, bouncing, and exploding hazards make reaching the next level a challenge! Come back and play again to explore more randomized levels, gain a score multiplier or bonus pinballs to top and share your high score!
Are you up to the challenge? Play Pinball Overdrive and prove you can tackle the levels and come out on top!
Pinball Overdrive can be played offline: don’t let an airplane or bus ride keep you from topping your high score!
Send me an email: mtsmithdesign@gmail.com


---
title: About SBIR FAIR
linkTitle: About
menu:
main:
weight: 10
---
{{< blocks/cover title="About SBI FAIR" image_anchor="bottom" height="min" >}}
What we do ...
The Surrogate Benchmark Initiative (SBI) project will create a community
repository and FAIR data ecosystem for HPC application surrogate benchmarks,
including data, code, and all relevant collateral artifacts the science and
engineering community needs to use and reuse these data sets and surrogates.
{{< /blocks/cover >}}
{{% blocks/lead %}}
Abstract
Computational Science is being revolutionized by the integration of AI
and simulation and in particular, by deep learning surrogates that can
replace all or part or of traditional large-scale HPC computations.
Surrogates can achieve remarkable performance improvements (e.g.,
several orders of magnitude) and so save in both time and energy. The
Surrogate Benchmark Initiative (SBI) project will create a community
repository and FAIR data ecosystem for HPC application surrogate
benchmarks, including data, code, and all relevant collateral
artifacts the science and engineering community needs to use and reuse
these data sets and surrogates. We intend that our repositories will
generate active research from both the participants in our project and
the broad community of AI and domain scientists.
By collaborating with the major industry organization in this area --
MLPerf -- and mirroring their process as much as possible, we will
both increase the value of and obtain industry involvement in the SBI
benchmarks. MLPerf is a major effort with over 1400 members from over
80 institutional members (mainly from industry) and strong existing
involvement of the Department of Energy laboratories through the HPC
and science data MLPerf working groups. We will build tutorials around
each deposited benchmark which will allow users from a broad range of
fields (shown in collaboration letters) to make new surrogates and new
SBI benchmarks based on the initial set of four that we will produce
in house. We will set up a set of working groups and other community
activities that will advance all issues around the surrogate concept.
In particular, we will take the requirements exhibited in benchmarks
and produce general middleware to support the generation (training
from HPC simulations) and the use of surrogates. This also will make
it easier for general users to develop new surrogates and so make the
major performance increases pervasive across DoE computational
science. Here we see SBI benefitting application communities and
computer systems research.
SBI will also support several AI research areas which we will advance
in our project. Our benchmarks will drive research on efficient
generic surrogate architectures and how they fit with different
hardware systems. Another specific activity will be research on the
uncertainty quantification of the surrogate estimates and we expect
future surrogates will always come with this built-in. Thirdly there
will be important studies of the amount of training data needed to get
reliable surrogates for a given accuracy choice. Finally, we have
already derived some simple but effective performance models or
surrogates but these need extension as deeper uses of surrogates
become understood and exhibited in our repository depositions.
{{% /blocks/lead %}}
{{< blocks/section >}}
Funding
The project will explicitly fund staff to make sure that non-project
users are properly supported and that our use of FAIR principles is
effective. We will extend MLPerf’s MLBox project to enable convenient
FAIR use of SBI repositories which will be GitHub based.
{{< /blocks/section >}}


public class Memory
extends java.util.Observable
| Modifier and Type | Class | Description |
|---|---|---|
(package private) static class |
Memory.DataTypes |
| Modifier and Type | Field | Description |
|---|---|---|
static boolean |
BIG_ENDIAN |
Constant representing byte order of each memory word.
|
static java.lang.Number |
exceptionHandlerAddress |
starting address for exception handlers
|
static java.lang.Number |
externBaseAddress |
base address for .extern directive
|
static java.lang.Number |
globalPointer |
base address for storing globals
|
static java.lang.Number |
heapAddress |
|
static java.lang.Number |
heapBaseAddress |
base address for heap
|
static java.lang.Number |
kernelHighAddress |
highest address accessible in kernel mode.
|
(package private) java.util.Collection |
observables |
|
static java.lang.Number |
stackPointer |
base address for stack
|
static java.lang.Number |
userHighAddress |
highest address accessible in user (not kernel) mode.
|
static int |
WORD_LENGTH_BYTES |
RISCV word length in bytes.
|
| Modifier and Type | Method | Description |
|---|---|---|
void |
addObserver(java.util.Observer obs) |
Method to accept registration from observer for any memory address.
|
void |
addObserver(java.util.Observer obs,
java.lang.Number addr) |
Method to accept registration from observer for specific address.
|
void |
addObserver(java.util.Observer obs,
java.lang.Number startAddr,
java.lang.Number endAddr) |
Method to accept registration from observer for specific address range.
|
static java.lang.Number |
alignToDoubleWordBoundary(java.lang.Number address) |
Utility method to align given address to next full word boundary, if not already
aligned.
|
java.lang.Number |
allocateBytesFromHeap(int numBytes) |
Returns the next available word-aligned heap address.
|
void |
clear() |
Explicitly clear the contents of memory.
|
int |
countObservers() |
get the number of observers
|
void |
deleteObserver(java.util.Observer obs) |
Remove specified memory observers
|
void |
deleteObservers() |
Remove all memory observers
|
static boolean |
doublewordAligned(java.lang.Number address) |
Utility to determine if given address is doubleword-aligned.
|
java.lang.Number |
get(java.lang.Number address,
int length) |
Starting at the given word/double-word address, read the given number of bytes.
|
java.lang.Number |
getAddressOfFirstNull(java.lang.Number baseAddress,
java.lang.Number limitAddress) |
Look for first "null" memory value in an address range.
|
java.lang.Number |
getByte(java.lang.Number address) |
Reads specified Memory byte into low order 8 bits of int.
|
boolean |
getByteOrder() |
Retrieve memory byte order.
|
BlockTable |
getDataTable() |
Returns the data table in memory
|
java.lang.Number |
getDoubleWord(java.lang.Number address) |
Starting at the given word address, read a 8 byte word as an int.
|
java.lang.Number |
getHalf(java.lang.Number address) |
Starting at the given word address, read a 2 byte word into lower 16 bits of int.
|
static Memory |
getInstance() |
Returns the unique Memory instance, which becomes in essence global.
|
BlockTable |
getKernelDataTable() |
Returns the kernel data table in memory
|
TextBlockTable |
getKernelTextTable() |
Returns the kernel table in memory
|
BlockTable |
getMemoryMapTable() |
Returns the memory map table
|
java.lang.Number |
getRaw(java.lang.Number address,
int shift) |
Starting at the given word address, read a 4/8 byte word/double-word as an int/long.
|
java.lang.Number |
getRawDoubleWord(java.lang.Number address) |
|
java.lang.Number |
getRawDoubleWordOrNull(java.lang.Number address) |
|
java.lang.Number |
getRawOrNull(java.lang.Number address,
int shift) |
Starting at the given address, read a 4/8 byte value as an int/long and return Integer/Long.
|
java.lang.Number |
getRawWord(java.lang.Number address) |
|
java.lang.Number |
getRawWordOrNull(java.lang.Number address) |
|
BlockTable |
getStackTable() |
Returns the stack table in memory
|
ProgramStatement |
getStatement(java.lang.Number address) |
Gets ProgramStatement from Text Segment.
|
ProgramStatement |
getStatementNoNotify(java.lang.Number address) |
Gets ProgramStatement from Text Segment without notifying observers.
|
TextBlockTable |
getTextTable() |
Returns the text table in memory
|
java.lang.Number |
getWord(java.lang.Number address) |
Starting at the given word address, read a 4 byte word as an int.
|
java.lang.Number |
getWordNoNotify(java.lang.Number address) |
Starting at the given word address, read a 4 byte word as an int.
|
void |
notifyObservers() |
Overridden to be unavailable.
|
void |
notifyObservers(java.lang.Object obj) |
Overridden to be unavailable.
|
java.lang.Number |
set(java.lang.Number address,
java.lang.Number value,
int length) |
Starting at the given address, write the given value over the given number of bytes.
|
java.lang.Number |
setByte(java.lang.Number address,
java.lang.Number value) |
Writes low order 8 bits of given value into specified Memory byte.
|
void |
setByteOrder(boolean order) |
Set byte order to either LITTLE_ENDIAN or BIG_ENDIAN.
|
void |
setConfiguration() |
Sets current memory configuration for simulated MIPS.
|
java.lang.Number |
setDoubleWord(java.lang.Number address,
java.lang.Number value) |
|
java.lang.Number |
setHalf(java.lang.Number address,
java.lang.Number value) |
Starting at the given halfword address, write the lower 16 bits of given value
into 2 bytes (a halfword).
|
java.lang.Number |
setRawDoubleWord(java.lang.Number address,
java.lang.Number value) |
|
java.lang.Number |
setRawWord(java.lang.Number address,
java.lang.Number value) |
|
void |
setStatement(java.lang.Number address,
ProgramStatement statement) |
Stores ProgramStatement in Text Segment.
|
java.lang.Number |
setWord(java.lang.Number address,
java.lang.Number value) |
Starting at the given word address, write the given value over 4 bytes (a word).
|
static boolean |
wordAligned(java.lang.Number address) |
Utility to determine if given address is word-aligned.
|
public static java.lang.Number externBaseAddress
public static java.lang.Number globalPointer
public static java.lang.Number heapBaseAddress
public static java.lang.Number stackPointer
public static java.lang.Number userHighAddress
public static java.lang.Number exceptionHandlerAddress
public static java.lang.Number kernelHighAddress
public static final int WORD_LENGTH_BYTES
public static final boolean BIG_ENDIAN
public static java.lang.Number heapAddress
java.util.Collection observables
public static Memory getInstance()
public void clear()
public void setConfiguration()
public java.lang.Number allocateBytesFromHeap(int numBytes) throws java.lang.IllegalArgumentException
numBytes
- Number of bytes requested. Should be multiple of 4, otherwise next higher multiple of 4 allocated.java.lang.IllegalArgumentException
- if number of requested bytes is negative or exceeds available heap storagepublic void setByteOrder(boolean order)
order
- either LITTLE_ENDIAN or BIG_ENDIANpublic boolean getByteOrder()
public java.lang.Number set(java.lang.Number address, java.lang.Number value, int length) throws AddressErrorException
address
- Starting address of Memory address to be set.value
- Value to be stored starting at that address.length
- Number of bytes to be written.AddressErrorException
public java.lang.Number setRawWord(java.lang.Number address, java.lang.Number value) throws AddressErrorException
AddressErrorException
public java.lang.Number setRawDoubleWord(java.lang.Number address, java.lang.Number value) throws AddressErrorException
AddressErrorException
public java.lang.Number setWord(java.lang.Number address, java.lang.Number value) throws AddressErrorException
address
- Starting address of Memory address to be set.value
- Value to be stored starting at that address.AddressErrorException
- If address is not on word boundary.public java.lang.Number setDoubleWord(java.lang.Number address, java.lang.Number value) throws AddressErrorException
AddressErrorException
public java.lang.Number setHalf(java.lang.Number address, java.lang.Number value) throws AddressErrorException
address
- Starting address of Memory address to be set.value
- Value to be stored starting at that address. Only low order 16 bits used.AddressErrorException
- If address is not on halfword boundary.public java.lang.Number setByte(java.lang.Number address, java.lang.Number value) throws AddressErrorException
address
- Address of Memory byte to be set.value
- Value to be stored at that address. Only low order 8 bits used.AddressErrorException
public void setStatement(java.lang.Number address, ProgramStatement statement) throws AddressErrorException
address
- Starting address of Memory address to be set. Must be word boundary.statement
- Machine code to be stored starting at that address -- for simulation
purposes, actually stores reference to ProgramStatement instead of 32-bit machine code.AddressErrorException
- If address is not on word boundary or is outside Text Segment.ProgramStatement
public TextBlockTable getTextTable()
public TextBlockTable getKernelTextTable()
public BlockTable getDataTable()
public BlockTable getKernelDataTable()
public BlockTable getStackTable()
public BlockTable getMemoryMapTable()
public java.lang.Number get(java.lang.Number address, int length) throws AddressErrorException
address
- Starting address of Memory address to be read.length
- Number of bytes to be read.AddressErrorException
public java.lang.Number getRaw(java.lang.Number address, int shift) throws AddressErrorException
address
- Starting address of word to be read.AddressErrorException
- If address is not on word/double-word boundary.public java.lang.Number getRawWord(java.lang.Number address) throws AddressErrorException
AddressErrorException
public java.lang.Number getRawDoubleWord(java.lang.Number address) throws AddressErrorException
AddressErrorException
public java.lang.Number getRawOrNull(java.lang.Number address, int shift) throws AddressErrorException
address
- Starting address of word to be read.shift
- the shift amount (3 or 2)AddressErrorException
- If address is not on word/double-word boundary.public java.lang.Number getRawWordOrNull(java.lang.Number address) throws AddressErrorException
AddressErrorException
public java.lang.Number getRawDoubleWordOrNull(java.lang.Number address) throws AddressErrorException
AddressErrorException
public java.lang.Number getAddressOfFirstNull(java.lang.Number baseAddress, java.lang.Number limitAddress) throws AddressErrorException
baseAddress
- lowest MIPS address to be searched; the starting pointlimitAddress
- highest MIPS address to be searchedAddressErrorException
- if the base address is not on a word boundarypublic java.lang.Number getWord(java.lang.Number address) throws AddressErrorException
address
- Starting address of word to be read.AddressErrorException
- If address is not on word boundary.public java.lang.Number getDoubleWord(java.lang.Number address) throws AddressErrorException
address
- Starting address of word to be read.AddressErrorException
- If address is not on word boundary.public java.lang.Number getWordNoNotify(java.lang.Number address) throws AddressErrorException
address
- Starting address of word to be read.AddressErrorException
- If address is not on word boundary.public java.lang.Number getHalf(java.lang.Number address) throws AddressErrorException
address
- Starting address of word to be read.AddressErrorException
- If address is not on halfword boundary.public java.lang.Number getByte(java.lang.Number address) throws AddressErrorException
address
- Address of Memory byte to be read.AddressErrorException
public ProgramStatement getStatement(java.lang.Number address) throws AddressErrorException
address
- Starting address of Memory address to be read. Must be word boundary.AddressErrorException
- If address is not on word boundary or is outside Text Segment.ProgramStatement
public ProgramStatement getStatementNoNotify(java.lang.Number address) throws AddressErrorException
address
- Starting address of Memory address to be read. Must be word boundary.AddressErrorException
- If address is not on word boundary or is outside Text Segment.ProgramStatement
public static boolean wordAligned(java.lang.Number address)
address
- the address to checkpublic static boolean doublewordAligned(java.lang.Number address)
address
- the address to checkpublic static java.lang.Number alignToDoubleWordBoundary(java.lang.Number address)
address
- a memory address (any long value is potentially valid)public void addObserver(java.util.Observer obs)
addObserver
in class java.util.Observable
obs
- the observerpublic void addObserver(java.util.Observer obs, java.lang.Number addr) throws AddressErrorException
obs
- the observeraddr
- the memory address which must be on word boundaryAddressErrorException
public void addObserver(java.util.Observer obs, java.lang.Number startAddr, java.lang.Number endAddr) throws AddressErrorException
obs
- the observerstartAddr
- the low end of memory address range, must be on word boundaryendAddr
- the high end of memory address range, must be on word boundaryAddressErrorException
public int countObservers()
countObservers
in class java.util.Observable
public void deleteObserver(java.util.Observer obs)
deleteObserver
in class java.util.Observable
obs
- Observer to be removedpublic void deleteObservers()
deleteObservers
in class java.util.Observable
public void notifyObservers()
notifyObservers
in class java.util.Observable
public void notifyObservers(java.lang.Object obj)
notifyObservers
in class java.util.Observable
java.lang.UnsupportedOperationException


Version 3.1
February, 1998
Thomas N. Anderson
Squak Valley Software
837 Front Street South,
Issaquah, WA 98027
Compuserve: 73770,3612
Internet<EMAIL_ADDRESS>www.halcyon.com/squakvly/
Copyright (C) 1998 by Squak Valley Software. All rights reserved.
The Telemark Assembler (TASM) is a table driven cross assembler for the MS-DOS and LINUX environments. Assembly source code, written in the appropriate dialect (generally very close to the manufacturers assembly language), can be assembled with TASM, and the resulting object code transferred to the target microprocessor system via PROM or other mechanisms.
The microprocessor families supported by TASM are:
The user so inclined may build tables for other microprocessors. The descriptions of the various existing tables and instructions on building new tables are not in this document but can be found in the TASMTABS.HTM file on the TASM distribution disk.
TASM characteristics include:
TASM is distributed as shareware. TASM is not in the public domain. The TASM distribution files may be freely copied (excluding the source code files) and freely used for the purpose of evaluating the suitability of TASM for a given purpose. Use of TASM beyond a reasonable evaluation period requires registration. Prolonged use without registration is unethical.
TASM can be invoked as follows (optional fields shown in brackets, symbolic fields in italics):
tasm -pn [-options ...] src_file [obj_file [lst_file [exp_file [sym_file]]]]
Where options can be one or more of the following:
| -table | Specify version (table = table designation) |
| -ttable | Table (alternate form of above) |
| -aamask | Assembly control (optional error checking) |
| -b | Produce object in binary (.COM) format |
| -c | Object file written as a contiguous block |
| -dmacro | Define a macro (or just a macro label) |
| -e | Show source lines after macro expansion |
| -ffillbyte | Fill entire memory space with fillbyte (hex) |
| -gobjtype | Object file (0=Intel Hex, 1=MOS Tech, 2=Motorola, 3=binary,4=Intel Hex (Word)) |
| -h | Produce hex table of the assembled code (in list file) |
| -i | Ignore case for labels |
| -l[al] | Produce a label table in the listing |
| -m | Produce object in MOS Technology format |
| -oobytes | Bytes per object record (for hex obj formats) |
| -p[lines] | Page the listing file (lines per page. default=60) |
| -q | Quiet, disable the listing file |
| -rkb | Set read buffer size in Kbytes (default 2 Kbytes) |
| -s | Write a symbol table file |
| -x[xmask] | Enable extended instruction set (if any) |
| -y | Time the assembly |
The filename parameters are defined as follows:
| src_file | Source file name |
| obj_file | Object code file name |
| lst_file | Listing file name |
| exp_file | Symbol export file (only if the EXPORT directive is used). |
| sym_file | Symbol table file (only if the -s option or the SYM/AVSYM directives are used). |
The source file must be specified. If not, some usage information is displayed. Default file names for all the other files are generated if they are not explicitly provided. The filename is formed by taking the source filename and changing the extension to one of the following:
| Extension | File type |
| .OBJ | Object file |
| .LST | Listing file |
| .EXP | Symbol export file |
| .SYM | Symbol table file |
TASM has no built-in instruction set tables. Instruction set definition files are read at run time. TASM determines which table to use based on the '-table' field shown above. For example, to assemble the code in a file called source.asm, one would enter
| tasm -48 source.asm | for an 8048 assembly |
| tasm -65 source.asm | for a 6502 assembly |
| tasm -51 source.asm | for an 8051 assembly. |
| tasm -85 source.asm | for an 8085 assembly. |
| tasm -80 source.asm | for a Z80 assembly. |
| tasm -05 source.asm | for a 6805 assembly. |
| tasm -68 source.asm | for a 6800/6801/68HC11 assembly. |
| tasm -70 source.asm | for a TMS7000 assembly. |
| tasm -3210 source.asm | for a TMS32010 assembly. |
| tasm -3225 source.asm | for a TMS320C25 assembly. |
| tasm -96 source.asm | for a 8096/80196 assembly |
Tables are read from a file named by taking the digits specified after the '-' and appending it to 'TASM' then appending the '.TAB' extension. Thus, the -48 flag would cause the tables to be read from the file 'TASM48.TAB'.
It is possible to designate tables by non numeric part numbers if the -t flag is used. For example, if a user built a table called TASMF8.TAB then TASM could be invoked as follows:
tasm -tf8 source.asm
Each option flag must be preceded by a dash. Options need not precede the file names. The various options are described in the sections that follow.
TASM can provide additional error checking by specifying the -a option at the time of execution. If the -a is provided without a digit following, then all the available error checking is done. If a digit follows, then it is used as a mask to determine the error checks to be made. The bits of the mask are defined as follows:
| Bit | Option | Default | Description |
| 0 | -a1 | OFF | Check for apparent illegal use of indirection |
| 1 | -a2 | ON | Check for unused data in the arguments |
| 2 | -a4 | ON | Check for duplicate labels |
| 3 | -a8 | OFF | Check for non-unary operators at start of expression. |
Combinations of the above bits can also be used. For example, -a5 would enable the checking for illegal indirection and duplicate labels.
Illegal indirection applies to micros that use parenthesis around an argument to indicate indirection. Since it is always legal to put an extra pair of parenthesis around any expression (as far as the expression parser is concerned), the user may think that he/she is indicating indirection for an instruction that has no indirection and TASM would not complain. Enabling this checking will result in an error message (warning) whenever an outer pair of parenthesis is used and the instruction set definition table does not explicitly indicate that to be a valid form of addressing.
Unused data in arguments applies to cases where a single byte of data is needed from an argument, but the argument contains more than one byte of data. If a full sixteen bit address is used in a 'Load Immediate' type instruction that needs only a single byte, for example, an error message would be generated. Here is an example (6502 code):
0001 1234 .org $1234 test.asm line 0002: Unused data in MS byte of argument. 0002 1234 A9 34 start lda #start
To make the above checks occur whenever you do an assembly, add a line like this to your AUTOEXEC.BAT file:
SET TASMOPTS=-a
This option causes the object file to be written in binary - one byte for each byte of code/data. Note that no address information is included in the object file in this format. The contiguous block (-c) output mode is forced when this option is invoked. This flag is equivalent to -g3.
If this option is specified, then all bytes in the range from the lowest used byte to the highest will be defined in the object file. Normally, with the default Intel Hex object format enabled, if the Program Counter (PC) jumps forward because of an .ORG directive, the bytes skipped over will not have any value assigned them in the object file. With this option enabled, no output to the object file occurs until the end of the assembly at which time the whole block is written. This is useful when using TASM to generate code that will be put into a PROM so that all locations will have a known value. This option is often used in conjunction with the -f option to ensure all unused bytes will have a known value.
Macros are defined on the command line generally to control the assembly of various IFDEF's that are in the source file. This is a convenient way to generate various versions of object code from a single source file.
Normally TASM shows lines in the listing file just as they are in the source file. If macros are in use (via the DEFINE directive) it is sometimes desirable to see the source lines after expansion. Use the '-e' flag to accomplish this.
This option causes the memory image that TASM maintains to be initialized to the value specified by the two hex characters immediately following the 'f'. TASM maintains a memory image that is a full 64K bytes in size (even if the target processor cannot utilize that memory space). Invocation of this option introduces a delay at start up of up to 2 seconds (time required to initialize all 64K bytes).
TASM can generate object code in four different formats as indicated below:
| Option | Description |
| -g0 | Intel hex (default) |
| -g1 | MOS Technology hex (same as -m) |
| -g2 | Motorola hex |
| -g3 | binary (same as -b) |
| -g4 | Intel hex with word addresses |
The -m and -b flags may also be used, as indicated above. If both are used the right-most option on the command line will be obeyed.
See the section on OBJECT FILE FORMATS for descriptions of each of the above.
This option causes a hex table of the produced object code to appear in the listing file. Each line of the table shows sixteen bytes of code.
TASM is normally case sensitive when dealing with labels. For those that prefer case insensitivity, the '-i' command line option can be employed.
This option causes a label table to appear in the listing file. Each label is shown with its corresponding value. Macro labels (as established via the DEFINE directives) do not appear.
Two optional suffixes may follow the -l option:
| Suffix | Description |
| l | Use long form listing |
| a | Show all labels (including local labels) |
The suffix should immediately follow the '-l'. Here are some examples:
| -l | to show non-local labels in the short form |
| -la | to show all labels in the short form |
| -ll | to show non-local labels in the long form |
| -lal | to show all labels in the long form |
This option causes the object file to be written in MOS Technology hex format rather than the default Intel hex format. See section on OBJECT FILE FORMATS for a description of the format.
When generating object code in either the MOS Technology format or the Intel hex format, a default of 24 (decimal) bytes of object are defined on each record. This can be altered by invoking the '-o' option immediately followed by two hex digits defining the number of bytes per record desired. For example, if 32 bytes per record are desired, one might invoke TASM as:
tasm -48 -o20 source.asm
This option causes the listing file to have top of page headers and form feeds inserted at appropriate intervals (every sixty lines of output). To override the default of sixty lines per page, indicate the desired number of lines per page as a decimal number immediately following the '-p'. Here is an example:
tasm -48 -p56 source.asm
This option causes all output to the listing file to be suppressed, unless a .LIST directive is encountered in the source file (see LIST/NOLIST directives).
This option overrides the default read buffer size of 2 Kbytes. The first hexadecimal digit immediately after the 'r' is taken as the number of K bytes to allocate for the read buffer (.e.g. -r8 indicates an 8K byte buffer, -rf indicates a 15K byte buffer). Note that that read buffers are taken from the same memory pool as labels and macro storage, and that additional read buffers are needed if "includes" are used. Thus, using 8K byte buffers may be suitable for most assemblies, but programs with large numbers of symbols may not allow such a value. Also, reducing the buffer size to 1 Kbyte can increase the memory pool available for label storage, if such is needed.
If this flag is set, a symbol file is generated at the end of the assembly. The format of the file is one line per label, each label starts in the first column and is followed by white space and then four hexadecimal digits representing the value of the label. The following illustrates the format:
label1 FFFE label2 FFFF label3 1000
The symbol file name can be provided as the fifth file name on the command line, or the name will be generated from the source file name with a '.SYM' extension. The symbol table file can also be generated by invoking the SYM directive. The AVSYM directive also generates the symbol file but in a different format (see section on ASSEMBLER DIRECTIVES).
As an alternative to specifying the instruction set table as two decimal digits, the table indication may be proceeded by the '-t' option. This is useful if the desired table name starts with a non-numeric. Thus, a table for an F8 might be selected as:
tasm -tf8 source.asm
TASM would expect to read the instruction set definition tables from a file named TASMF8.TAB.
If a processor family has instructions that are valid for only certain members, this option can be used to enable those beyond the basic standard instruction set. A hex digit may follow the 'x' to indicate a mask value used in selecting the appropriate instruction set. Bit 0 of the mask selects the basic instruction set, thus a '-x1' would have no effect. A '-x3' would enable the basic set plus whatever instructions have bit 1 set in their class mask. A '-x' without a digit following is equivalent to a '-xf' which sets all four of the mask bits. The following table indicates the current extended instruction sets available in the TASM tables:
| Base Table | Base Family | Ext 1 (-x3) | Ext 2 (-x7) | Ext 3 (-x5) | Ext 4 (-x9) |
| 48 | 8048 | 8041A | 8022 | 8021 | |
| 65 | 6502 | R65C02 | R65C00/21 | ||
| 05 | 6805 | M146805 CMOS | HC05C4 | ||
| 80 | Z80 | HD64180 | |||
| 68 | 6800 | 6801/6803 | 68HC11 | ||
| 51 | 8051 | ||||
| 85 | 8080 | ||||
| 3210 | TMS32010 | ||||
| 3225 | TMS320C25 | TMS320C26 | |||
| 70 | TMS7000 |
The above table does not attempt to show the many microprocessor family members that may apply under a given column.
See the TASMTABS.TXT on-line document for details on each specific table.
If this option is enabled TASM will generate a statement of elapsed time and assembled lines per second at the end of the assembly.
The TASM environment can be customized by using the environment variables listed below:
The TASMTABS variable specifies the path to be searched for TASM instruction set definition tables. If it is not defined then the table(s) must exist in the current working directory. The following examples illustrate possible usage:
| For MSDOS | set TASMTABS=C:\TASM |
| For LINUX | TASMTABS=/tasm |
This variable specifies TASM command line options that are to be invoked every time TASM is executed. For example, if TASM is being used for 8048 assemblies with binary object file output desired, the following statement would be appropriate in the AUTOEXEC.BAT file:
set TASMOPTS=-48 -b
When TASM terminates, it will return to the OS the following exit codes:
| Exit Code | Definition |
| 0 | Normal completion, no assembly errors |
| 1 | Normal completion, with assembly errors |
| 2 | Abnormal completion, insufficient memory |
| 3 | Abnormal completion, file access error |
| 4 | Abnormal completion, general error |
Exit codes 2 and above will also be accompanied by messages to the console concerning the error.
Statements in the source file must conform to a format as follows (except for assembler directive statements which are described in a subsequent section):
label operation operand comment
All of the fields are optional, under appropriate circumstances. An arbitrary amount of white space (space and tabs) can separate each field (as long as the maximum line length of 255 characters is not exceeded). Each of the fields are described in the following sections.
If the first character of the line is alphabetic, it is assumed to be the start of a label. Subsequent characters are accepted as part of that label until a space, tab, or ':' is encountered. The assembler assigns a value to the label corresponding to the current location counter. Labels can be a maximum of 32 characters long. Labels can contain upper and lower case letters, digits, underscores, and periods (the first character must be alphabetic). Labels are case sensitive - the label 'START' is a different label from 'start' - unless the '-i' (ignore case) option is enabled.
The operation field contains an instruction mnemonic which specifies the action to be carried out by the target processor when this instruction is executed. The interpretation of each mnemonic is dependent on the target microprocessor (as indicated by the selected TASM table). The operation field may begin in any column except the first. The operation field is case insensitive.
The operand field specifies the data to be operated on by the instruction. It may include expressions and/or special symbols describing the addressing mode to be used. The actual format and interpretation is dependent on the target processor. For a description of the format for currently supported processors, see the TASMTABS.DOC file on the TASM distribution disk.
The comment field always begins with a semicolon. The rest of the line from the semicolon to the end of the line is ignored by TASM, but passed on to the listing file for annotation purposes. The comment field must be the last field on a line, but it may be the only field, starting in column one, if desired.
If the backslash character is encountered on a source line, it is treated as a newline. The remainder of the line following the backslash will be processed as an independent line of source code. This allows one to put multiple statements on a line. This facility is not so useful of itself, but when coupled with the capability of the DEFINE directive, powerful multiple statement macros can be constructed (see section on ASSEMBLER DIRECTIVES). Note that when using the statement separator, the character immediately following it should be considered the first character of a new line, and thus must either be a start of a label or white space (not an instruction). As the examples show, a space is put between the backslash and the start of the next instruction.
Some examples of valid source statements follow (6502 mnemonics shown):
lab1 lda byte1 ;get the first byte dec byte1 jne label1 ; lab2 sta byte2,X ; a multiple statement line follows lda byte1\ sta byte1+4\ lda byte2\ sta byte2+4
Expressions are made up of various syntactic elements combined according to a set of syntactical rules. Expressions can be comprised of the following elements:
Labels are strings of characters that have a numeric value associated with them, generally representing an address. Labels can contain upper and lower case letters, digits, underscores, and periods. The first character must be a letter or the local label prefix (default '_'). The value of a label is limited to 32 bit precision. Labels can contain up to 32 characters, all of which are significant (none are ignored when looking at a label's value, as in some assemblers). Case is significant unless the '-i' command line option is invoked.
Local labels must only be unique within the scope of the current module. Modules are defined with the MODULE directive. Here is an example:
.MODULE xxx lda regx jne _skip dec _skip rts .MODULE yyy lda regy jne _skip dec _skip rts
In the above example, the _skip label is reused without harm. As a default, local labels are not shown in the label table listing (resulting from the '-l' command line option). See also sections on MODULE and LOCALLABELCHAR directives.
Numeric constants must always begin with a decimal digit (thus hexadecimal constants that start with a letter must be prefixed by a '0' unless the '$' prefix is used). The radix is determined by a letter immediately following the digit string according to the following table:
| Radix | Suffix | Prefix |
| 2 | B or b | % |
| 8 | O or o | @ |
| 10 | D or d (or nothing) | |
| 16 | H or h | $ |
Decimal is the default radix, so decimal constants need no suffix or prefix.
The following representations are equivalent:
1234H or $1234 100d or 100 177400o or @177400 01011000b or %01011000
The prefixes are provided for compatibility with some other source code formats but introduce a problem of ambiguity. Both '%' and '$' have alternate uses ('%' for modulo, '$' for location counter symbol). The ambiguity is resolved by examining the context. The '%' character is interpreted as the modulo operator only if it is in a position suitable for a binary operator. Similarly, if the first character following a '$' is a valid hexadecimal digit, it is assumed to be a radix specifier and not the location counter.
Character constants are single characters surrounded by single quotes. The ASCII value of the character in the quotes is returned. No escape provision exists to represent non-printable characters within the quotes, but this is not necessary since these can be just as easily represented as numeric constants (or using the TEXT directive which does allow escapes).
String constants are one or more characters surrounded by double quotes. Note that string constants are not allowed in expressions. They are only allowable following the TITLE, BYTE, DB, and TEXT assembler directives. The quoted strings may also contain escape sequences to put in unprintable values. The following escape sequences are supported:
| Escape Sequence | Description |
| \n | Line Feed |
| \r | Carriage return |
| \b | Backspace |
| \t | Tab |
| \f | Formfeed |
| \\ | Backslash |
| \" | Quote |
| \000 | Octal value of character |
The current value of the location counter (PC) can be used in expressions by placing a '$' in the desired place. The Location Counter Symbol is allowable anywhere a numeric constant is. (Note that if the '$' is followed by a decimal digit then it is taken to be the hexadecimal radix indicator instead of the Location Counter symbol, as mentioned above). The '*' may also be used to represent the location counter, but is less preferred because of its ambiguity with the multiplicative operator.
Expressions can optionally contain operators to perform some alterations or calculations on particular values. The operators are summarized as follows:
| Operator | Type | Description |
| + | Additive | addition |
| - | subtraction | |
| * | Multiplicative | multiplication |
| / | division | |
| % | modulo | |
| << | logical shift left | |
| >> | logical shift right | |
| ~ | Unary | bit inversion (one's complement) |
| - | unary negation | |
| = | Relational | equal |
| == | equal | |
| != | not equal | |
| < | less than | |
| > | greater than | |
| <= | less than or equal | |
| >= | greater than or equal | |
| & | Binary | binary 'and' |
| | | binary 'or' | |
| ^ | binary 'exclusive or' |
The syntax is much the same as in 'C' with the following notes:
The relational operators return a value of 1 if the relation is true and 0 if it is false. Thirty-two bit signed arithmetic is used.
It is always a good idea to explicitly indicate the desired order of evaluation with parenthesis, especially to maintain portability since TASM does not evaluate expressions in the same manner as many other assemblers. To understand how it does arrive at the values for expressions, consider the following example:
1 + 2*3 + 4
TASM would evaluate this as:
(((1 + 2) * 3) + 4) = 13
Typical rules of precedence would cause the (2*3) to be evaluated first, such as:
1 + (2*3) + 4 = 11
To make sure you get the desired order of evaluation, use parenthesis liberally. Here are some examples of valid expressions:
(0f800H + tab) (label_2 >> 8) (label_3 << 8) & $f000 $ + 4<PHONE_NUMBER>00100b + 'a' (base + ((label_4 >> 5) & (mask << 2))
Most of the assembler directives have a format similar to the machine instruction format. However, instead of specifying operations for the processor to carry out, the directives cause the assembler to perform some function related to the assembly process. TASM has two types of assembler directives - those that mimic the 'C' preprocessor functions, and those that resemble the more traditional assembler directive functions. Each of these will be discussed.
The 'C' preprocessor style directives are invoked with a '#' as the first character of the line followed by the appropriate directive (just as in 'C'). Thus, these directives cannot have a label preceding them (on the same line). Note that in the examples directives are shown in upper case, however, either upper or lower case is acceptable.
The ADDINSTR directive can be used to define additional instructions for TASM to use in this assembly. The format is:
[label] .ADDINSTR inst args opcode nbytes rule class shift binor
The fields are separated by white space just as they would appear in an instruction definition file. See the TASMTABS.TXT file on the TASM distribution disk for more detail.
See SYM/AVSYM.
The BLOCK directive causes the Instruction Pointer to advance the specified number of bytes without assigning values to the skipped over locations. The format is:
[label] .BLOCK expr
Some valid examples are:
word1 .BLOCK 2 byte1 .block 1 buffer .block 80
These directives can be invoked to indicate the appropriate address space for symbols and labels defined in the subsequent code. The invocation of these directives in no way affects the code generated, only provides more information in the symbol table file if the AVSYM directive is employed. Segment control directives such as these are generally supported by assemblers that generate relocatable object code. TASM does not generate relocatable object code and does not support a link phase, so these directives have no direct effect on the resulting object code. The segments are defined as follows:
| Directive | Segment Description |
| BSEG | Bit address |
| CSEG | Code address |
| DSEG | Data address (internal RAM) |
| NSEG | Number or constant (EQU) |
| XSEG | External data address (external RAM) |
The BYTE directive allows a value assignment to the byte pointed to by the current Instruction Pointer. The format is:
[label] .BYTE expr [, expr ...]
Only the lower eight bits of expr are used. Multiple bytes may be assigned by separating them with commas or (for printable strings) enclosed in double quotes. Here are some examples:
label1 .BYTE 10010110B .byte 'a' .byte 0 .byte 100010110b,'a',0 .byte "Hello", 10, 13, "World"
The CHK directive causes a checksum to be computed and deposited at the current location. The starting point of the checksum calculation is indicated as an argument. Here is the format:
[label] .CHK starting_addr
Here is an example:
start: NOP LDA #1 .CHK start
The checksum is calculated as the simple arithmetic sum of all bytes starting at the starting_addr up to but not including the address of the CHK directive. The least significant byte is all that is used.
The CODES/NOCODES directives can be used to alternately turn on or off the generation of formatted listing output with line numbers, opcodes, data, etc. With NOCODES in effect, the source lines are sent to the listing file untouched. This is useful around blocks of comments that need a full 80 columns of width for clarity.
This is alternate form of the BYTE directive.
This is alternate form of the WORD directive.
The DEFINE directive is one of the most powerful of the directives and allows string substitution with optional arguments (macros). The format is as follows:
#DEFINE macro_label[(arg_list)] [macro_definition]
Where:
The simplest form of the DEFINE directive might look like this:
#DEFINE MLABEL
Notice that no substitutionary string is specified. The purpose of a statement like this would typically be to define a label for the purpose of controlling some subsequent conditional assembly (IFDEF or IFNDEF).
A more complicated example, performing simple substitution, might look like this:
#DEFINE VAR1_LO (VAR1 & 255)
This statement would cause all occurrences of the string 'VAR1_LO' in the source to be substituted with '(VAR1 & 255)'.
As a more complicated example, using the argument expansion capability, consider this:
#DEFINE ADD(xx,yy) clc\ lda xx\ adc yy\ sta xx
If the source file then contained a line like this:
ADD(VARX,VARY)
It would be expanded to:
clc\ lda VARX\ adc VARY\ sta VARX
The above example shows the use of the backslash ('\') character as a multiple instruction statement delimiter. This approach allows the definition of fairly powerful, multiple statement macros. The example shown generates 6502 instructions to add one memory location to another.
Some rules associated with the argument list:
Note that macros can be defined on the TASM command line, also, with the -d option flag.
The DEFCONT directive can be used to add to the last macro started with a DEFINE directive. This provides a convenient way to define long macros without running off the edge of the page. The ADD macro shown above could be defined as follows:
#DEFINE ADD(xx,yy) clc #DEFCONT \ lda xx #DEFCONT \ adc yy #DEFCONT \ sta xx
The ECHO directive can be used to send output to the console (stderr). It can accept either a quoted text string (with the standard escape sequences allowed) or a valid expression. It can accept only one or the other, however. Multiple instances of the directive may be used to create output that contains both. Consider the following example:
.ECHO "The size of the table is " .ECHO (table_end - table_start) .ECHO " bytes long.\n"
This would result in a single line of output something like this:
The size of the table is 196 bytes long.
The EJECT directive can be used to force a top-of-form and the generation of a page header on the list file. It has no effect if the paging mode is off (see PAGE/NOPAGE). The format is:
[label] .EJECT
The ELSE directive can optionally be used with IFDEF, IFNDEF and IF to delineate an alternate block of code to be assembled if the block immediately following the IFDEF, IFNDEF or IF is not assembled.
Here are some examples of the use of IFDEF, IFNDEF, IF, ELSE, and ENDIF:
#IFDEF label1 lda byte1 sta byte2 #ENDIF #ifdef label1 lda byte1 #else lda byte2 #endif #ifndef label1 lda byte2 #else lda byte1 #endif #if ($ >= 1000h) ; generate an invalid statement to cause an error ; when we go over the 4K boundary. !!! PROM bounds exceeded. #endif
The END directive should follow all code/data generating statements in the source file. It forces the last record to be written to the object file. The format is:
[label] .END [addr]
The optional addr will appear in the last object record (Motorola S9 record type) if the object format is Motorola hex. The addr field is ignored for all other object formats.
The ENDIF directive must always follow an IFDEF, IFNDEF, or IF directive and signifies the end of the conditional block.
The EQU directive can be used to assign values to labels. The labels can then be used in expressions in place of the literal constant. The format is:
label .EQU expr
Here is an example:
MASK .EQU 0F0H ; lda IN_BYTE and MASK sta OUT_BYTE
An alternate form of the EQU directive is '='. The previous example is equivalent to any of the following:
MASK = 0F0H MASK =0F0H MASK =$F0
White space must exist after the label, but none is required after the '='.
The EXPORT directive can be used to define labels (symbols) that are to be written to the export symbol file. The symbols are written as equates (using the .EQU directive) so that the resulting file can be included in a subsequent assembly. This feature can help overcome some of the deficiencies of TASM due to its lack of a relocating linker. The format is:
[label] .EXPORT label [,label...]
The following example illustrates the use of the EXPORT directive and the format of the resulting export file:
Source file:
EXPORT read_byte EXPORT write_byte, open_file
Resulting export file:
read_byte .EQU $1243 write_byte .EQU $12AF open_file .EQU $1301
The FILL directive can be used to fill a selected number of object bytes with a fixed value. Object memory is filled from the current program counter forward. The format is as follows:
[label] .FILL number_of_bytes [,fill_value]
The number_of_bytes value can be provided as any valid expression. The optional fill_value can also be any valid expression. If fill_value is not provided, a default value of 255 ($FF) is used.
The IFDEF directive can be used to optionally assemble a block of code. It has the following form:
#IFDEF macro_label
When invoked, the list of macro labels (established via DEFINE directives) is searched. If the label is found, the following lines of code are assembled. If not found, the input file is skipped until an ENDIF or ELSE directive is found.
Lines that are skipped over still appear in the listing file, but a '~' will appear immediately after the current PC and no object code will be generated (this is applicable to IFDEF, IFNDEF, and IF).
The IFNDEF directive is the opposite of the IFDEF directive. The block of code following is assembled only if the specified macro_label is undefined. It has the following form:
#IFNDEF macro_label
When invoked, the list of macro labels (established via DEFINE directives) is searched. If the label is not found, the following lines of code are assembled. If it is found, the input file is skipped until an ENDIF or ELSE directive is found.
The IF directive can be used to optionally assemble a block of code dependent on the value of a given expression. The format is as follows:
#IF expr
If the expression expr evaluates to non-zero, the following block of code is assembled (until an ENDIF or ELSE is encountered).
The INCLUDE directive reads in and assembles the indicated source file. INCLUDEs can be nested up to six levels. This allows a convenient means to keep common definitions, declarations, or subroutines in files to be included as needed. The format is as follows:
#INCLUDE filename
The filename must be enclosed in double quotes. Here are some examples:
#INCLUDE "macros.h" #include "equates" #include "subs.asm"
The LIST and NOLIST directives can be used to alternately turn the output to the list file on (LIST) or off (NOLIST). The formats are:
.LIST .NOLIST
The LOCALLABELCHAR directive can be used to override the default "_" as the label prefix indicating a local label. For example, to change the prefix to "?" do this:
[label] .LOCALLABELCHAR "?"
Be careful to use only characters that are not operators for expression evaluation. To do so causes ambiguity for the expression evaluator. Some safe characters are "?", "{", and "}".
The LSFIRST and MSFIRST directives determine the byte order rule to be employed for the WORD directive. The default (whether correct or not) for all TASM versions is the least significant byte first (LSFIRST). The following illustrates its effect:
0000 34 12 .word $1234 0002 .msfirst 0002 12 34 .word $1234 0004 .lsfirst 0004 34 12 .word $1234
The MODULE directive defines the scope of local labels. The format is:
[label] .MODULE label
Here is an example:
.MODULE module_x lda regx jne _skip dec _skip rts .MODULE module_y lda regy jne _skip dec _skip rts
In the above example, the local label _skip is reused without harm since the two usages are in separate modules. See also section LOCALLABELCHAR directive.
The ORG directive provides the means to set the Instruction Pointer (a.k.a. Program Counter) to the desired value. The format is:
[label] .ORG expr
The label is optional. The Instruction pointer is assigned the value of the expr. For example, to generate code starting at address 1000H, the following could be done:
start .ORG 1000H
The expression (expr) may contain references to the current Instruction Pointer, thus allowing various manipulations to be done. For example, to align the Instruction Pointer on the next 256 byte boundary, the following could be done:
.ORG (($ + 0FFH) & 0FF00H)
ORG can also be used to reserve space without assigning values:
.ORG $+8
An alternate form of ORG is '*=' or '$='. Thus the following two examples are exactly equivalent to the previous example:
*=*+8 $=$+8
The PAGE/NOPAGE directives can be used to alternately turn the paging mode on (PAGE) or off (NOPAGE). If paging is in effect, then every sixty lines of output will be followed by a Top of Form character and a two line header containing page number, filename, and the title. The format is:
.PAGE .NOPAGE
The number of lines per page can be set with the '-p' command line option.
The SET directive allows the value of an existing label to be changed. The format is:
label .SET expr
The use of the SET directive should be avoided since changing the value of a label can sometimes cause phase errors between pass 1 and pass 2 of the assembly.
These directives can be used to cause a symbol table file to be generated. The format is:
.SYM ["symbol_filename"] .AVSYM ["symbol_filename"]
For example:
.SYM "symbol.map" .SYM .AVSYM "prog.sym" .AVSYM
The two directives are similar, but result in a different format of the symbol table file. The format of the SYM file is one line per symbol, each symbol starts in the first column and is followed by white space and then four hexadecimal digits representing the value of the symbol. The following illustrates the format:
label1 FFFE label2 FFFF label3 1000
The AVSYM directive is provided to generate symbol tables compatible with the Avocet 8051 simulator. The format is similar, but each line is prefixed by an 'AS' and each symbol value is prefixed by a segment indicator:
AS start C:1000 AS read_byte C:1245 AS write_byte C:1280 AS low_nib_mask N:000F AS buffer X:0080
The segment prefixes are determined by the most recent segment directive invoked (see BSEG/CSEG/DSEG/NSEG/XSEG directives).
This directive allows an ASCII string to be used to assign values to a sequence of locations starting at the current Instruction Pointer. The format is:
[label] .TEXT "string"
The ASCII value of each character in string is taken and assigned to the next sequential location. Some escape sequences are supported as follows:
| Escape Sequence | Description |
| \n | Line Feed |
| \r | Carriage return |
| \b | Backspace |
| \t | Tab |
| \f | Formfeed |
| \\ | Backslash |
| \" | Quote |
| \000 | Octal value of character |
Here are some examples:
message1 .TEXT "Disk I/O error" message2 .text "Enter file name " .text "abcdefg\n\r" .text "I said \"NO\""
The TITLE directive allows the user to define a title string that appears at the top of each page of the list file (assuming the PAGE mode is on). The format is:
[label] .TITLE "string"
The string should not exceed 80 characters. Here are some examples:
.TITLE "Controller version 1.1" .title "This is the title of the assembly" .title ""
The WORD directive allows a value assignment to the next two bytes pointed to by the current Instruction Pointer. The format is:
[label] .WORD expr [,expr...]
The least significant byte of expr is put at the current Instruction Pointer with the most significant byte at the next sequential location (unless the MSFIRST directive has been invoked). Here are some examples:
data_table .WORD (data_table + 1) .word $1234 .Word (('x' - 'a') << 2) .Word 12, 55, 32
This is the default object file format. This format is line oriented and uses only printable ASCII characters except for the carriage return/line feed at the end of each line. The format is symbolically represented as:
:NN AAAA RR HH CC CRLF
Where:
|
: |
Record Start Character (colon) |
|
NN |
Byte Count (2 hex digits) |
|
AAAA |
Address of first byte (4 hex digits) |
|
RR |
Record Type (00 except for last record which is 01) |
|
HH |
Data Bytes (a pair of hex digits for each byte of data in the record) |
|
CC |
Check Sum (2 hex digits) |
|
CRLF |
Line Terminator (CR/LF for DOS, LF for LINUX) |
The last line of the file will be a record conforming to the above format with a byte count of zero.
The checksum is defined as:
sum = byte_count+address_hi+address_lo+record_type+(sum of all data
bytes)
checksum = ((-sum) & ffh)
Here is a sample listing file followed by the resulting object file:
0001 0000 0002 1000 .org $1000 0003 1000<PHONE_NUMBER>06 .byte 1, 2, 3, 4, 5, 6, 7, 8 0003 1006 0708 0004 1008 090A0B0C0D0E .byte 9,10,11,12,13,14,15,16 0004 100E 0F10 0005 1010<PHONE_NUMBER>16 .byte 17,18,19,20,21,22,23,24,25,26 0005 1016 1718191A 0006 101A .end
:181000000102030405060708090A0B0C0D0E0F101112131415161718AC :02101800191AA3 :00000001FF
This format is identical to the Intel Hex Object Format except that the address for each line of object code is divided by two thus converting it to a word address (16 bit word). All other fields are identical.
Here is an example:
:180800000102030405060708090A0B0C0D0E0F101112131415161718AC :02080C00191AA3 :00000001FF
This format is line oriented and uses only printable ASCII characters except for the carriage return/line feed at the end of each line. Each line in the file is of the following format:
:NN AAAA HH CC CRLF
Where:
|
; |
Record Start Character (semicolon) |
|
NN |
Byte Count (2 hex digits) |
|
AAAA |
Address of first byte (4 hex digits) |
|
HH |
Data Bytes (a pair of hex digits for each byte of data in the record) |
|
CCCC |
Check Sum (4 hex digits) |
|
CRLF |
Line Terminator (CR/LF for DOS, LF for LINUX) |
The last line of the file will be a record conforming to the above format with a byte count of zero.
The checksum is defined as:
sum =byte_count+address_hi+address_lo+record_type+(sum of all data
bytes)
checksum = (sum & ffffh)
Here is a sample object file:
;1810000102030405060708090A0B0C0D0E0F1011121314151617180154 ;021018191A005D ;00
This format is line oriented and uses only printable ASCII characters except for the carriage return/line feed at the end of each line. The format is symbolically represented as:
S1 NN AAAA HH CCCC CRLF
Where:
|
S1 |
Record Start tag |
|
NN |
Byte Count (2 hex digits) (data byte count + 3) |
|
AAAA |
Address of first byte (4 hex digits) |
|
HH |
Data Bytes (a pair of hex digits for each byte of data in the record) |
|
CC |
Check Sum (2 hex digits) |
|
CRLF |
Line Terminator (CR/LF for DOS, LF for LINUX) |
The checksum is defined as:
sum = byte_count+address_hi+address_lo+(sum of all data bytes)
checksum = ((~sum) & ffh)
Here is a sample file:
S11B10000102030405060708090A0B0C0D0E0F101112131415161718A8 S1051018191A9F S9030000FC
The last line of the file will be a record with a byte count of zero and a tag of S9. The address field will be 0000 unless and address was provided with the END directive in which case it will appear in the address field.
This file format is essentially a memory image of the object code without address, checksum or format description information.
Note that when this object format is selected (-b option), the -c option is forced. This is done so that no ambiguity results from the lack of address information in the file. Without the -c option, discontinuous blocks of object code would appear contiguous.
Each line of source code generates one (or more) lines of output in the listing file. The fields of the output line are as follows:
If paging is enabled (by either the '-p' option flag or the .PAGE directive) some additional fields will be inserted into the listing file every 60 lines. These fields are:
If errors are encountered, then error messages will be interspersed in the listing. TASM outputs error messages proceeding the offending line. The following example illustrates the format:
0001 0000 label1 .equ 40h 0002 0000 label2 .equ 44h 0003 0000 0004 1000 start: .org 1000h 0005 1000 E6 40 inc label1 0006 1002 E6 44 inc label2 tt.asm line 0007: Label not found: (label3) 0007 1004 EE 00 00 inc label3 0008 1007 4C 00 10 jmp start 0009 100A .end 0010 100A tasm: Number of errors = 1
A wide variety of PROM programming equipment is available that can use object code in one or more of the formats supported by TASM. Here are some notes concerning the generation of code to be programmed into PROMs:
It is often desirable to have all bytes in the PROM programmed even if not explicitly assigned a value in the source code (e.g. the bytes are skipped over with a .ORG statement). This can be accomplished by using the -c (contiguous block) and the -f (fill) command line option flags. The -c will ensure that every byte from the lowest byte assigned a value to the highest byte assigned a value will be in the object file with no gaps. The -f flag will assign the specified value to all bytes before the assembly begins so that when the object file is written, all bytes not assigned a value in the source code will have a known value. As an example, the following command line will generate object code in the default Intel Hex format with all bytes not assigned a value in the source set to EA (hex, 6502 NOP instruction):
tasm -65 -c -fEA test.asm
To ensure that TASM generates object code to cover the full address range of the target PROM, put a .ORG statement at the end of the source file set to the last address desired. For example, to generate code to be put in a 2716 EPROM (2 Kbytes) from hex address $1000 to $17ff, do something like this in the source file:
;start of the file .ORG $1000 ;rest of the source code follows source code ;end of the source code .ORG $17ff .BYTE 0 .END
Now, to invoke TASM to generate the code in the binary format with all unassigned bytes set to 00 (6502 BRK instruction), do the following:
tasm -65 -b -f00 test.asm
Note that -b forces the -c option.
TASM error messages take the following general form:
filename line line_number: error_message
For example:
main.asm line 0032: Duplicate label (start)
This format is compatible with the Brief editor (from Borland International). Brief provides the ability to run assemblies from within the editor. Upon completion of the assembly, Brief will parse the error messages and jump to each offending line in the source file allowing the user to make corrective edits.
To use this feature, it is necessary to configure a Brief environment variable to specify the assembly command associated with source files that end in .asm:
SET BCASM = "tasm %s.asm"
TASM also needs to know the proper table to use. It can be added above, or the TASMOPTS environment variable can be used separately:
SET TASMOPTS=-65
| Maximum number of labels | 15000 |
| Maximum length of labels | 32 characters |
| Maximum address space | 64 Kbytes (65536 bytes) |
| Maximum number of nested INCLUDES | 4 |
| Maximum length of TITLE string | 79 characters |
| Maximum source line length | 255 characters |
| Maximum length after macro expansion | 255 characters |
| Maximum length of expressions | 255 characters |
| Maximum length of pathnames | 79 characters |
| Maximum length of command line | 127 characters |
| Maximum number of instructions (per table) | 1200 |
| Maximum number of macros | 1000 |
| Maximum number of macro arguments | 10 |
| Maximum length of macro argument | 16 characters |
| Memory requirements | 512K |


Hey Manvi,
Wish you a very, very Happy Birthday
I hope you have a fantastic day and a wonderful year ahead. I have always wished the best for you and I genuinely hope you fulfil all your aspirations
I might not say it enough, but you are a very special friend of mine and indeed a wonderful person to know. Making unrealistic plans to doing the most childish things together, we have come a long way. And I am counting on you for discussing my retirement plans as well:)
My only piece of advice: Hakuna Matata
Sometimes it is important to let life unfold whatever it has in store for us
Lastly, just know, I'll always be there for you
Always.
Lots of Love- Manika


Résumé
Hi, I’m a motivated email/markup developer with 1+ years’ experience. I like to do web site and email templates and improve my skills every seconds, because it’s amazing. 🤩
Experience
-
08.2016 – 11.2017
Assistant of station master at Kharkiv Metro
- Responsible for the management of other station employees and holds responsibility for safety and the efficient running of the station.
-
05.2018 – present
Email Developer at P2H
- Build fully responsive/hybrid emails that work correctly in all major email clients and devices. Implemant templates in marketing platforms and email service providers (Saleforce, Hubspot, Mailchimp, Campaing Monitor, Cleverich, etc)
Education
-
09.2013 – 06.2017Junior Specialist degree in Railway Operation and Management Department at Kharkiv College of Transport Technologies
-
09.2017 – presentBachelor's degree in Railway Operation and Management Department at Ukrainian State Academy of Railway Transport
-
05.2019 – presentBinary Studio Academy


{% extends "base.html" %} {% block page_title %}{{ year }} - PortFolio{% endblock %} {% block title %}{{ year }} - PortFolio{% endblock %} {% block page_description %}Some projects that have been started and developped in {{ year }} by Nicolas DUBIEN{% endblock %} {% block breadcrumb %}


Senior Frontend Software Engineer and Web Developer
Co-organizer of JavaScriptMN. Occasionally a lighting designer. Cyclist. he/him.
👨🏻💻 at @CHRobinson.
🎙 at @TheNexusTV.
👨🏻🎓 of @UMNMorris.
{%- assign find-me-feature = site.data.find-me.feature | sort: 'icon' -%} {%- for find-me in find-me-feature -%} {% include icons/{{ find-me.icon }}.svg %} {%- endfor -%}
{%- assign find-me-normal = site.data.find-me.normal | sort: 'icon' -%} {%- for find-me in find-me-normal -%} {% include icons/{{ find-me.icon }}.svg %} {%- endfor -%}
I am a co-host on PodKit, a podcast about Apple inclined Web Developers discussing interesting technology and development related topics.
Use these links to save some money or gain extra perks when you sign up for an account.


Colossians 2:22
Which all are to perish with the using;) after the commandments and doctrines of men?


c = None
caches = None
if current_usage_percentage > self._target_usage and len(q) > 0:
current_usage_percentage = memoryUsagePercentage()
self.logger.debug("Memory usage is: {}%".format(100*current_usage_percentage))
info, mem/1024.0/1024.0))
total -= mem
current_usage_percentage = total/float(getAvailableRamBytes())*100
gc.collect()
// don"t keep a reference until next loop iteration
cleanupFun = None
q = None


source ‘rubygems.org’
gem ‘rails’, ‘3.2.14’
# Bundle edge Rails instead: # gem ‘rails’, :git => ‘git://github.com/rails/rails.git’
gem ‘mysql2’ gem ‘devise’, ‘~> 2.2.0’ gem ‘devise_google_authenticator’, ‘0.3.5’ gem ‘haml-rails’ gem ‘will_paginate’ gem ‘paperclip’ gem ‘daemons’ gem ‘babosa’ gem ‘coderay’ gem ‘RedCloth’ gem “renderable”, :git => “git://github.com/jonpearse/renderable.git” gem ‘remotipart’
# Gems used only for assets and not required # in production environments by default. group :assets do
gem 'bourbon' gem 'sass-rails' gem 'coffee-rails' # See https://github.com/sstephenson/execjs#readme for more supported runtimes gem 'therubyracer', :platforms => :ruby gem 'uglifier', '>= 1.0.3'
end
group :development do
gem 'quiet_assets' gem 'thin'
end


Home
Auditors
Managers
Org Info
Grantee
Grant Status
Grants
Employee
Login
Create Employee
Employee Creation
Employee ID:
Username:
Email:
Password:
Time Created:
Org ID: