Most EasyLanguage errors in TradeStation come from small mistakes: a missing semicolon (error 30160), equal sign (30158) or colon (30214), a reserved word used as a variable name, or a division by zero. The Output pane shows the error code and line, whether you code on your own PC or a TradeStation VPS.
Fixing such errors requires understanding their root causes and using TradeStation's debugging tools effectively. For runtime and platform errors outside the code editor, see our guide to fixing other TradeStation EasyLanguage errors. If you also code in MultiCharts, see our MultiCharts PowerLanguage guide.
Key Points:
-
Syntax Errors: Common issues include missing semicolons (
;), incorrect variable assignments, or misuse of reserved keywords. - Verification Errors: These involve runtime logic, such as undeclared variables, data type mismatches, or attempting unsupported operations like dividing by zero.
- Debugging Tools: TradeStation's Output pane highlights errors, and features like line numbering and error codes simplify troubleshooting.
Quick Fixes:
- Always end statements with a semicolon.
-
Use descriptive, valid variable names (e.g., avoid reserved words like
High). - Check for division by zero with conditional statements.
- Verify code frequently to catch errors early.
Keep TradeStation running near CME while you're away.
Common EasyLanguage Syntax and Verification Errors
If you're working with TradeStation, understanding the kinds of errors you might face can save you time and help you write better code. TradeStation's Output pane provides detailed error messages and codes, making it easier to identify and fix issues. These errors generally fall into two categories: syntax errors and verification errors. Below, we'll explore the most common problems in each category, along with their error codes and examples.
Frequent Syntax Errors
Syntax errors occur when the structure of your code doesn't align with EasyLanguage's rules. Here are the most common ones:
- Missing semicolons: This is the most frequent issue. Every statement in EasyLanguage must end with a semicolon. Forgetting one triggers error 30160, "Semicolon (;) expected here." The Output pane shows the line number; add the semicolon at the end of that line or the line before it.
-
Variable assignment mistakes: Error 30158, "An equal sign '=' expected here.", pops up when you forget the equal sign in an assignment. For example, writing
Price Closeinstead ofPrice = Closetriggers it, and the Output pane shows the line. -
Reserved keyword misuse: Using built-in EasyLanguage words as variable names fails verification. For example, declaring
Var: High(0);fails because 'High' is a reserved word. To fix this, choose a different name likeHighValueorPriceHigh. -
Incorrect input declarations: Error 30214, "Colon (:) expected here.", occurs when the colon after
Inputis missing. WriteInput: Length(14);, notInput Length 14, and check the parentheses and semicolon too. -
String handling errors: Mixing strings and numbers in one expression fails verification with a data type error. For instance,
"Price" + 100is not allowed. EasyLanguage doesn't allow mathematical operations involving text.
Typical Verification Errors
Verification errors arise when the code logic doesn't comply with runtime requirements. These issues can prevent your strategy from working properly - including when it is deployed unattended on an algo trading VPS, where a strategy that fails verification simply never starts.
-
Undeclared variable errors: Error 30061, "Word not recognized by EasyLanguage.", occurs when you use a variable that hasn't been declared. For example, referencing
MyValuewithout declaring it first (Var: MyValue(0);) triggers it. Declaring the variable resolves this issue. -
Data type mismatches: Assigning incompatible data types triggers errors such as 30403, "Cannot implicitly convert String to Numerical." For example, assigning a string to a numeric variable (
Length = "Fast") fails. Always ensure variable types match their assignments. -
Function parameter errors: Error 30176, "More inputs expected here.", happens when you call a function without enough inputs. For instance,
Average(Close)is missing the length. The function needs both a data series and a length. -
Historical referencing problems: Referencing more bars back than the chart has loaded causes problems at run time. For example,
Close[1000]needs at least 1,000 earlier bars on the chart. Ensure your strategy accounts for the amount of historical data present. -
Order statement errors: Orders cannot sit inside a
FororWhileloop (error 30204, "Orders cannot be inside a loop."), and market, stop and limit orders must sayNext Bar(error 30331). Place orders after the loop, using values the loop calculated. -
Plot statement errors: Each plot needs its own name. Giving two plots the same name, such as
Plot1(Close, "Price");andPlot2(Open, "Price");, triggers error 30294, "This plot name has been used by more than one plot." Rename one of them.
Step-by-Step Troubleshooting Guides
When EasyLanguage errors pop up, tackling them systematically can save you a lot of time. Building on the common error types mentioned earlier, this guide walks you through practical steps to fix them. These steps directly address the errors discussed previously, and TradeStation's built-in tools can make the process smoother.
Using TradeStation's Built-in Tools
The Output pane is your go-to resource for debugging. It shows error descriptions, document names, line numbers, and error codes. When you verify code with errors, this pane automatically appears at the bottom of your screen.
To make locating errors easier, enable line numbering by going to Tools > Options > Line Numbers. This feature helps you match error messages to specific lines in your code.
For even quicker navigation, double-click an error message in the Output pane. This action takes you directly to the problematic line in the code editor.
If you're dealing with multiple errors, tackle them in the order they appear in the Output pane. Often, fixing the first error clears up others that follow. For example, a single syntax error can trigger multiple downstream issues. Fixing it and re-verifying your code might resolve several problems in one go.
Pay close attention to the error number and description in the Output pane. TradeStation's messages often spell out the problem, like "Colon (:) expected here" or "Invalid variable name." These clues help you figure out when dealing with missing syntax, naming issues, or data type mismatches.
With these tools, you're set to examine the specific fixes outlined below.
Fixing Syntax and Verification Issues
Once you've reviewed the error details, it's time to apply targeted fixes.
-
Missing colon errors: If you see "Colon (:) expected here", check your declaration statements. Keywords like
Input,Variable, orArrayshould always be followed by a colon. For example, fixInput MyValue(10);by changing it toInput: MyValue(10);and then re-verify. -
Signal name errors: To avoid issues with signal names, always format order names with parentheses and double quotes. For instance, correct
Sell From Entry MySignal Next Bar at Market;toSell From Entry("MySignal") Next Bar at Market;. -
Assignment and semicolon errors: These are common issues. For error 30158, check for missing equal signs. For example, change
Value1 10;toValue1 = 10;. Similarly, if you're missing semicolons, make sure each statement ends with one. For example, ifValue1 = Close + Openis followed byBuy Next Bar at Value1 Stop;, add the semicolon afterOpenso the first line readsValue1 = Close + Open;. -
"Statement does not return a value" errors (30205): This happens when you assign the result of a function that doesn’t return anything to a variable. If you wrote
Value1 = AB_SetZone(High, Low, RightSide);, remove the assignment and simply useAB_SetZone(High, Low, RightSide);since the function performs an action instead of returning a value. -
Contract specification errors: If you see error 30208, "CONTRACTS, SHARES expected here", make sure your statement is complete. For example, replace
Buy 100;withBuy 100 Shares;orBuy 100 Contracts;depending on the instrument you're trading. -
ArrayBoundsException errors: Check the error message and call stack to identify the problematic line. Make sure your array indices are within valid bounds. In EasyLanguage, the number in the declaration is the highest index, not the element count:
Array: MyArray[10](0);creates elements 0 through 10, which is 11 elements. Add checks or adjust your logic to prevent out-of-bounds access. -
Division by zero errors: Always check the denominator before performing a division. Instead of writing
Value2 = Value3 / Value1;(whereValue1might be zero), use a conditional statement likeIf Value1 <> 0 then Value2 = Value3 / Value1;.
Keep in mind that error messages don’t always pinpoint the exact problem. If you can’t find the issue in the line flagged by the error, review the preceding lines for missing syntax elements like semicolons, equal signs, or colons.
After fixing each error, re-verify your code to refresh the error list. This step ensures that new issues, which may have been masked by earlier errors, are caught. By iterating through this process, you'll systematically resolve all problems and confirm that your fixes work as intended.
Read next
Corrected Code Examples and Best Practices
Common Code Corrections
Understanding how to fix common coding errors can help you identify and address similar issues in your own EasyLanguage strategies. Below are some frequent mistakes traders encounter and their proper solutions.
Missing Assignment Operators and Semicolons
A missing equal sign or semicolon can cause EasyLanguage to reject your code.
Incorrect:
Value1 10
Corrected:
Value1 = 10;
Both the equal sign (=) and semicolon (;) are necessary for EasyLanguage to process the statement correctly.
Variable Naming Issues
Variable names must begin with a letter, not a number. Starting with a number will result in a syntax error.
Incorrect:
1stValue = Close;
Corrected:
FirstValue = Close;
Always ensure variable names start with a letter to avoid errors.
Division by Zero Prevention
Dividing by zero can cause runtime errors that interrupt live trading. Always check for zero before performing division.
Incorrect:
value2 = value3 / value1
Corrected:
If value1 <> 0 then value2 = value3 / value1;
If-Then Statement Structure
In EasyLanguage, the keyword "Then" is required after every condition, even if it seems optional.
Incorrect:
If Condition1 {any operation}
Corrected:
If Condition1 Then {any operation}
Without "Then", the code will generate a syntax error.
Function Assignment Errors
Some functions in EasyLanguage perform actions but don’t return values. Assigning these functions to variables will result in an error.
Incorrect:
Value1 = AB_SetZone(High, Low, RightSide);
Corrected:
AB_SetZone(High, Low, RightSide);
Since AB_SetZone doesn't produce a return value, it should not be assigned to a variable.
These examples highlight common errors and their solutions, paving the way for better coding habits.
Best Practices for EasyLanguage Development
Adopting consistent practices can greatly improve the reliability and readability of your EasyLanguage strategies. Here are some key tips:
Uptime
99.999% uptime. Built for 24/7 trading reliability.
Your VPS runs in Tier IV datacenters with redundant power and network, monitored 24/7 on site.
See the uptime SLAFrom $29.99/mo · Windows or Linux
Use Descriptive Variable Names
Descriptive variable names make your code easier to understand. Avoid generic names like Value1 or Var1 - instead, use terms that clearly describe the variable's purpose:
Variables: EntryPrice(0), StopLoss(0), ProfitTarget(0);
Keep variable names concise (under 20 characters) to avoid TradeStation's character limit errors.
Implement Consistent Formatting
Well-formatted code is easier to read and debug. Use proper indentation and spacing to organize your logic:
Input: FastLength(12), SlowLength(26);
Variables: AvgFast(0), AvgSlow(0);
AvgFast = Average(Close, FastLength);
AvgSlow = Average(Close, SlowLength);
If AvgFast > AvgSlow Then
Buy Next Bar at Market;
This approach makes it easier to spot missing semicolons, brackets, or other syntax errors.
Add Defensive Programming Checks
Prevent runtime errors by validating your data before using it in calculations. For example:
If Volume > 0 and Close > 0 Then Begin
VolumeRatio = Volume / Average(Volume, 20);
If VolumeRatio > 1.5 Then
Buy Next Bar at Market;
End;
These checks ensure your strategy doesn’t fail during critical market moments.
Comment Your Logic
Adding comments to your code helps explain complex logic and calculations, making it easier to understand later (or for others to review). EasyLanguage supports both single-line (//) and block ({ }) comments:
// Calculate RSI divergence signal
RSIValue = RSI(Close, 14);
{ Possible bullish signal: RSI is oversold while price closes higher }
If RSIValue < 30 and Close > Close[1] Then BuySignal = True;
Comments act as a guide to your reasoning and help clarify your intentions.
Verify Code Regularly
Don’t wait until your strategy is complete to check for errors. Verify your code after every major addition or change. This habit helps catch issues early and prevents small mistakes from snowballing into larger problems.
Avoid Historical References with Server Fields
Server fields like AskSize and BidSize don’t support historical data references. Using bars-ago notation with these fields will cause errors.
Avoid:
Value1 = AskSize[4]; // This will cause an error
Instead, use current bar calculations or store values in arrays for later use.
Test with Multiple Market Conditions
To ensure your strategy performs well under various scenarios, test it against different market conditions - trending, sideways, and volatile periods. This practice helps identify edge cases and allows you to add appropriate error handling before deploying the strategy live.
Quick Reference Table: Common Errors and Solutions
When coding errors pop up, this table can help you quickly identify and resolve the issue. It’s a handy summary that complements the detailed troubleshooting guides mentioned earlier.
| Error Code/Message | Error Example | Why It Happens | Quick Fix |
|---|---|---|---|
| 30214: "Colon (:) expected here." | Input MyValue(10); |
Colon missing after Input or variable declaration |
Add colon: Input: MyValue(10); |
| 30160: "Semicolon (;) expected here." | Value1 = Close + Open |
Missing semicolon at the end of the statement | Add semicolon: Value1 = Close + Open; |
| 30158: "Equal sign '=' expected here." | Value1 Close + Open; |
Assignment operator is missing | Add equals sign: Value1 = Close + Open; |
| 30061: "Word not recognized by EasyLanguage." | Valuel = 100; (letter 'l' instead of '1') |
Typo in variable or function name | Fix spelling: Value1 = 100; |
| 30063: "Number out of range." | Value1 = 99999999999999999999; |
Number is too large for EasyLanguage | Use a valid number: Value1 = 999999; |
| 30208: "CONTRACTS, SHARES expected here." | Buy 100; |
Missing quantity type in the order | Specify type: Buy 100 Shares; |
| 30209: "Signal name expected within quotes." | Sell From Entry ( ) Next Bar at Market; |
Signal name is missing or empty | Add a signal name: Sell From Entry("MySignal") Next Bar at Market; |
| 30247: "References to previous values not allowed in simple functions." | Using Value1[1] in a simple function |
Historical data reference in a simple function | Switch to a "series" function |
| Division by Zero Error | Value2 = Value3 / Value1 when Value1 = 0 |
No check for zero before dividing | Add a condition to verify the denominator isn’t zero |
| 30065: "Invalid variable name." | 2Value = 100; |
Variable name starts with a number | Start variable names with a letter |
| Drawing Object Error -7 | "Unable to add the object. Possibly due to an out of memory condition" | Too many drawing objects or low memory | Reduce objects and check system memory |
| Drawing Object Error -10 | "Too many trendline objects on the chart" | Maximum trendline limit exceeded | Remove unused trendlines or reduce object usage |
Error numbers and messages checked on 10 Oct 2026 against TradeStation's EasyLanguage Verification (Syntax) Error Codes and Drawing Object Error Codes help pages. For more detailed explanations and examples, revisit the earlier sections.
Pro Tips for Troubleshooting
- Quick Navigation: Double-click errors in the Output pane to jump straight to the problematic line.
- Check Preceding Lines: If an error seems misplaced, examine the line before it for syntax issues.
-
Use Debugging Tools: Enable line numbers and insert
Printstatements to track variables and identify issues. - Incremental Testing: Test your code in smaller chunks to catch errors early while the context is still fresh.
Here’s a quick reminder: Variable names must begin with a letter or underscore and cannot include spaces or special characters (except underscores). If you’re working with historical data, ensure your function type is set to "series" to access prior bar values using brackets like [1] or [2].
Conclusion: Streamlining EasyLanguage Development
Getting a handle on EasyLanguage syntax and addressing verification errors is a must for building effective strategies in TradeStation. The errors we’ve discussed - like missing semicolons or division by zero - may seem small, but they can quickly eat up your time and even lead to missed trading opportunities if left unchecked.
By understanding the root causes of these common errors and taking advantage of TradeStation's built-in tools, you can make your development process far smoother. Fixing these issues promptly ensures your strategies work as intended, minimizes the risk of unexpected behavior during live trading, and helps protect you from potential financial setbacks.
Adopting a few key practices - such as using clear variable names, safeguarding against division by zero, and making full use of the Output pane - can significantly improve your coding workflow. Developing in EasyLanguage is an iterative process: compile your code, fix the errors, and repeat. Each challenge you tackle adds to your skill set and boosts your confidence.
Once your code verifies cleanly, the next step is backtesting your EasyLanguage strategy on historical data. When the results hold up, our guide to running automated TradeStation strategies covers moving the strategy into live automated trading.
Mastering error resolution and refining your coding practices will lead to more reliable strategies, fewer disruptions during live trading, and the confidence to build increasingly advanced automated systems. While the journey to error-free development takes patience and persistence, the reward, consistent and reliable trading strategies, is well worth the effort.
FAQs
How can I use TradeStation's debugging tools to fix EasyLanguage syntax and verification errors?
To address EasyLanguage syntax and verification errors in TradeStation, take advantage of the EasyLanguage Debugger. This built-in tool allows you to step through your code, observe its behavior in real-time, and quickly identify issues with logic or syntax.
Pay close attention to error messages - they often point directly to the problematic line of code. Make small, incremental changes to your code, testing frequently to confirm that each adjustment works as expected. For more guidance, look into resources that offer practical troubleshooting tips specifically for EasyLanguage.
By using debugging tools alongside effective coding practices, you can resolve errors more effectively and streamline your strategy development process.
What are the best practices for naming variables in EasyLanguage to prevent syntax errors?
When working with EasyLanguage, it's important to follow a few basic rules to avoid syntax errors. Start your variable names with a letter or an underscore, and steer clear of special characters, spaces, or reserved keywords. Picking clear, descriptive names that reflect the variable's role can make your code much easier to read and maintain.
Adopting consistent naming conventions like camelCase or PascalCase can further enhance clarity and help prevent mistakes. These simple practices go a long way in keeping your code clean, organized, and error-free.









