midrange.com code scratchpad
Name:
ConvertDToFreeAction
Scriptlanguage:
Java
Tabwidth:
4
Date:
07/03/2014 05:31:34 pm
IP:
Logged
Description:
Convert D-specifications to fully free RPG. Also handles DS (put the cursor on the DS), PI, PR, P...B and P...E specifications. Put the cursor on the line with the definition (ie not on the first line of a continued name, but on the last line, the one that defines the return type and has the keywords)
Code:
  1. package com.kc2hiz.lpexextensions; 
  2.  
  3. import com.ibm.lpex.core.LpexAction;
  4.  
  5. import com.ibm.lpex.core.LpexView;
  6. import com.ibm.lpex.core.LpexLog;
  7. import java.util.ArrayList;
  8. import java.util.regex.Pattern;
  9. import java.util.regex.Matcher;
  10.  
  11. /**
  12.  * Convert D-specification to fully free format
  13.  * <p>Intended to convert one spec at a time to allow for easier review of the conversion.
  14.  * <p>for use as an Lpex User Action.
  15.  * @author buck
  16.  * @version 01.00.00
  17.  *
  18.  */
  19. public class ConvertDToFreeAction implements LpexAction {
  20.     
  21.     /**
  22.      * Check to see if we should be allowed to perform the D to free conversion
  23.      * @param view LpexView to operate on
  24.      * @return true if action is available for this view
  25.      * @see com.ibm.lpex.core.LpexAction#available(com.ibm.lpex.core.LpexView)
  26.      */
  27.     @Override
  28.     public boolean available(LpexView view) {
  29.           return view.currentElement() > 0 &&
  30.                      !view.queryOn("readonly"); /* &&
  31.                      view.queryOn("block.anythingSelected"); */
  32.     }
  33.  
  34.     /**
  35.      * Converts D-specifications to fully free
  36.      * @param view LpexView to operate on
  37.      * @see com.ibm.lpex.core.LpexAction#doAction(com.ibm.lpex.core.LpexView)
  38.      */
  39.     @Override
  40.     public void doAction(LpexView view) {
  41.         
  42.         // work with the line the cursor is on
  43.         int thisLine = view.currentElement();
  44.         String sourceStmt = view.elementText(thisLine);
  45.  
  46.         // leave if no text
  47.         if (sourceStmt.length() == 0) {
  48.             view.doCommand("set messageText Empty text");            
  49.             return;
  50.         }
  51.  
  52.         // need to at least see 6 columns or we don't possibly have a d-spec
  53.         if (sourceStmt.length() <= 5) {
  54.             view.doCommand("set messageText Line too short");
  55.             return;
  56.         } 
  57.         
  58.         // Instantiate a DSpec object.  The constructor will break out the columns.
  59.         DSpec dspec = new DSpec(view, sourceStmt, thisLine);
  60.  
  61.         // leave if we're not looking at a D- or P-specification
  62.         if (!dspec.spec.equals("d") && !dspec.spec.equals("p")) {
  63.             view.doCommand("set messageText Not a D- or P-spec");            
  64.             return;
  65.         }
  66.  
  67.         // Handle the various definition types we know about
  68.         if (dspec.defType.trim().equals("b") ||
  69.             dspec.defType.trim().equals("c") ||
  70.             dspec.defType.trim().equals("e") ||
  71.             dspec.defType.equals("ds") ||
  72.             dspec.defType.equals("pi") ||
  73.             dspec.defType.equals("pr") ||
  74.             dspec.defType.trim().equals("s")) {
  75.                 convertSubfieldsToFree(view, dspec);
  76.                 // position the cursor to the top of the area we converted from
  77.                 view.doDefaultCommand("locate element " + thisLine);
  78.                 view.doDefaultCommand("set position 1");
  79.         } else {
  80.                 view.doCommand("set messageText Unusable D-spec. In the middle of a structure? " + dspec.defType);
  81.         }
  82.         
  83.     }
  84.  
  85.     /**
  86.      * Convert one or more field definitions from fixed to free
  87.      * If a standalone or constant, converts just the one line
  88.      * If a DS, PI or PR, converts the entire structure
  89.      * @param view LpexView - the current view we're working on
  90.      * @param dspec String - the first line of the structure (DS, PR, PI)
  91.      */
  92. private void convertSubfieldsToFree(LpexView view, DSpec dspec) {
  93.         int e = 0;
  94.         int lastSubfieldNumber = view.currentElement();    
  95.         int specLineNumber = view.currentElement();    
  96.         String dsTemp = "";
  97.         ArrayList<String> dsLines = new ArrayList<String>();
  98.         String dsDclTemp = "";
  99.                 
  100.         // the declare uses the definition type
  101.         // unless b, which is a P-spec and s/b 'proc'
  102.         // unless e, which gets nothing for the declaration
  103.         if (!dspec.defType.trim().equals("e")) {
  104.             if (!dspec.defType.trim().equals("b")) {
  105.                 dsDclTemp = "        dcl-" + dspec.defType.trim() + " "    + dspec.name;
  106.             } else {
  107.                 dsDclTemp = "        dcl-proc " + dspec.name;
  108.             }
  109.                 
  110.             // if there is a datatype, append it
  111.             String subfieldKeywords = getSubfieldKeywords(dspec.fromPos, dspec.len, dspec.dataType, dspec.decimals); 
  112.             if (subfieldKeywords.length() != 0) {
  113.                 dsDclTemp = dsDclTemp.concat(" " + subfieldKeywords);
  114.             }
  115.  
  116.             // if there are keywords, append them
  117.             if (dspec.keywords.length() != 0) {
  118.                 dsDclTemp = dsDclTemp.concat(" " + dspec.keywords);
  119.             }
  120.  
  121.             // append the semicolon
  122.             dsDclTemp = dsDclTemp.concat(";");
  123.  
  124.             // right hand comments (if any) come after the semicolon
  125.             if (dspec.rhComment.length() != 0) {
  126.                 dsDclTemp = dsDclTemp.concat(" // " + dspec.rhComment);
  127.             }
  128.         
  129.             // now that we have a fully formed line, add it to the array of lines
  130.             dsLines.add(dsDclTemp);
  131.         }
  132.  
  133.         
  134.         // loop forward through the next set of source lines
  135.         // until the end of the structure is found
  136.         // note that for standalone and constant lines, the very next spec terminates the 'structure'
  137.         for (e = specLineNumber + 1; e <= view.elements(); e++) {
  138.             
  139.             String dsSubfield = view.elementText(e);
  140.             
  141.             // if blank line, assume end of struc
  142.             int textLengthDS = dsSubfield.length();
  143.             if (textLengthDS == 0) {
  144.                 break;
  145.             }
  146.  
  147.             // need to at least see 6 columns or we don't possibly have a d-spec
  148.             if (textLengthDS <= 5) {
  149.                 break;
  150.             } 
  151.  
  152.             // make a new DSpec object which will break out the columns
  153.             DSpec subfield = new DSpec(view, dsSubfield, e);
  154.  
  155.             // comments have no fields to parse, but  
  156.             // carry the comments forward into the converted block
  157.             if (subfield.isComment) {
  158.                 dsTemp = "       // " + subfield.longComment.trim();
  159.             } else {
  160.                 
  161.                 // read the next line if this one is a continuation
  162.                 if (dsSubfield.matches(".*\\.\\.\\.")) {
  163.                     continue;
  164.                 }
  165.  
  166.                 // leave the loop if we've reached the end of the subfields
  167.                 if (subfield.spec.equals("d") && !subfield.defType.equals("  ")) {
  168.                     break;
  169.                 }
  170.  
  171.                 // leave if we're not looking at a D-specification
  172.                 if (!subfield.spec.equals("d")) {
  173.                     break;
  174.                 }
  175.  
  176.                 // now generate the keywords for data type
  177.                 String dataTypeKwdDS = getSubfieldKeywords(subfield.fromPos, subfield.len, subfield.dataType, subfield.decimals);
  178.  
  179.                 dsTemp =  "           " + 
  180.                         subfield.name + " " + dataTypeKwdDS;
  181.                 // keywords are optional; don't leave a trailing space if none needed
  182.                 if (subfield.keywords.length() != 0) {
  183.                     dsTemp = dsTemp.concat(" " + subfield.keywords);
  184.                 }
  185.  
  186.                 // add the terminating semicolon
  187.                 dsTemp = dsTemp.concat(";");
  188.  
  189.                 // if we have a right hand comment, carry it forward
  190.                 if (subfield.rhComment.length() != 0) {
  191.                     dsTemp = dsTemp.concat(" // " + subfield.rhComment.trim());
  192.                 }
  193.                 
  194.                 // save the element number of the last subfield we actually processed
  195.                 lastSubfieldNumber = e;
  196.             }
  197.             dsLines.add(dsTemp);
  198.             
  199.         };
  200.         
  201.         // ...and the end
  202.         // not needed for standalone and constant
  203.         if (!dspec.defType.trim().equals("c") && 
  204.             !dspec.defType.trim().equals("s") &&
  205.             !dspec.defType.trim().equals("b") &&
  206.             !dspec.defType.trim().equals("p")) {
  207.             
  208.             String endDsTemp = "";
  209.             // the declare uses the definition type
  210.             // unless b/e, which are P-specs and s/b 'proc'
  211.             if (!dspec.defType.trim().equals("e")) {
  212.                 endDsTemp = "        end-"  + dspec.defType + ";";
  213.             } else {
  214.                 endDsTemp = "        end-proc;";
  215.             }
  216.             
  217.             dsLines.add(endDsTemp);
  218.         }
  219.  
  220.         // position cursor AFTER the block we just read
  221.         view.doCommand("locate line " + (lastSubfieldNumber));
  222.         
  223.         // loop through the array and write the contents out
  224.         for (String dsLine: dsLines) {
  225.             if (!dsLine.isEmpty()) {
  226.                 view.doDefaultCommand("insert " + dsLine);
  227.             }
  228.         }
  229.     }
  230.  
  231.  
  232. /**
  233.  * build up the character type keyword based on the data type
  234.  * @param fromPos String
  235.  * @param len String
  236.  * @param dataType String
  237.  * @param decimals String
  238.  * @return dataTypeKwd String
  239.  */
  240. private String getSubfieldKeywords(String fromPos, String len, String dataType, String decimals) {
  241.     String dataTypeKwd = "";
  242.     int tempLen = 0;
  243.  
  244.     // no keyword if no 'to positions'
  245.     if (len.length() != 0) {
  246.         // the data type can be blank and the RPG compiler will
  247.         // supply a rational default.  We need to do the same thing.
  248.         if (dataType.length() == 0) {
  249.             if (decimals.length() == 0) {
  250.                 dataType = "a";
  251.             } else {
  252.                 dataType = "p";
  253.             }
  254.         }
  255.  
  256.         // have a length adjustment.  No data type keyword for this.
  257.         // instead, append the adjustment to the LIKE keyword
  258.         // in the getKeywordsFromText method
  259.         if (!len.matches(".*\\+.*")) {
  260.             // old style from/to specs
  261.             // convert length 
  262.             String tempLenChar = len;
  263.             if (fromPos.length() != 0) {
  264.                 tempLen = Integer.parseInt(len) - Integer.parseInt(fromPos) + 1;
  265.                 tempLenChar = String.valueOf(tempLen);
  266.             }
  267.             switch (dataType) {
  268.             case "a":
  269.                 dataTypeKwd = "char(" + tempLenChar + ")";
  270.                 break;
  271.             case "f":
  272.                 dataTypeKwd = "float(" + tempLenChar + ")";
  273.                 break;
  274.             case "i":
  275.                 dataTypeKwd = "int(" + tempLenChar + ")";
  276.                 break;
  277.             case "p":
  278.                 dataTypeKwd = "packed(" + tempLenChar + ": " + decimals + ")";
  279.                 break;
  280.             case "s":
  281.                 dataTypeKwd = "zoned(" + tempLenChar + ": " + decimals + ")";
  282.                 break;
  283.             case "u":
  284.                 dataTypeKwd = "uns(" + tempLenChar + ")";
  285.                 break;
  286.             default:
  287.                 dataTypeKwd = "unk(" + dataType + ") tempLenChar("
  288.                         + tempLenChar + ")";
  289.                 break;
  290.             }
  291.  
  292.             // we may have an old style from-to situation
  293.             // use the POS keyword to tell the compiler where the subfield starts
  294.             if (fromPos.length() != 0) {
  295.                 dataTypeKwd = dataTypeKwd.concat(" pos(" + fromPos + ")");
  296.             }
  297.         }
  298.     }
  299.     return dataTypeKwd;
  300. }
  301.  
  302. }
  303.  
  304. /**
  305.  * This stores the various column based fields for a d-spec
  306.  * This object tokenises the line with the definitions.  It will also move backward 
  307.  * in the view's text lines to accumulate names continued from earlier lines.
  308.  * @param view LpexView 
  309.  * @param dSpec String a single raw d-spec (field / subfield)
  310.  * @author buck
  311.  *
  312.  */
  313. class DSpec {
  314.     public String spec = "";
  315.     public String name = "";
  316.     public String extType = "";
  317.     public String dsType = "";
  318.     public String defType = "";
  319.     public String fromPos = "";
  320.     public String len = "";
  321.     public String dataType = "";
  322.     public String decimals = "";
  323.     public String keywords = "";
  324.     public String rhComment = "";
  325.     public String dataTypeKwd = "";
  326.     public boolean isComment = false;
  327.     public String longComment = "";
  328.     
  329.     // constructor
  330.     public DSpec(LpexView view, String sourceStmt, int thisLine) {
  331.         
  332.         // I prefer lower case, so everything except the name will be monocased
  333.         // RDi trims each line, so they don't all equal 100 bytes...
  334.         // must test for out of bounds before substringing!
  335.         
  336.         /*
  337.          *  1 -  5 sequence number / text
  338.          *  6 -  6 dSpec 
  339.          *  7 - 21 name
  340.          * 22 - 22 external type (' ', 'e')
  341.          * 23 - 23 DS type (' ', 's', 'u')
  342.          * 24 - 25 def type (' ', 'c', 'ds', 'pi', 'pr')
  343.          * 26 - 32 from
  344.          * 33 - 39 len / to
  345.          * 40 - 40 type (a, p, i, z, *, etc)
  346.          * 41 - 42 decimal
  347.          * 44 - 80 keywords
  348.          * 81 -100 comment
  349.          * 
  350.          * Alternatively, there can be a comment of the form:
  351.          *  6 -  6 dSpec 
  352.          *  7 -  7 *
  353.          *  8 -100 comment
  354.          *  
  355.          * Alternatively, there can be a comment of the form:  
  356.          * 6 -  7 blanks
  357.          * 8 -100 // comment.  Note that there can be any number of blanks 
  358.          *                     preceding the //.
  359.          *                     
  360.          * Alternatively, there can be a continuation line of the form:
  361.          * 6 -  6 d
  362.          * 7 - 80 someName...                     
  363.          * 
  364.          */
  365.             
  366.         spec = getSpecFromText(sourceStmt);
  367.         
  368.         isComment = isComment(sourceStmt);
  369.         
  370.         // early exit if a comment
  371.         if (isComment) {
  372.             longComment = getComment(sourceStmt);
  373.             return;
  374.         }
  375.  
  376.         extType = getExtTypeFromText(sourceStmt);
  377.         dsType = getDsTypeFromText(sourceStmt);
  378.         defType = getDefTypeFromText(sourceStmt);
  379.         fromPos = getFromPosFromText(sourceStmt);
  380.         len = getLenFromText(sourceStmt);
  381.         dataType = getDataTypeFromText(sourceStmt);
  382.         decimals = getDecimalsFromText(sourceStmt);
  383.         keywords = getKeywordsFromText(sourceStmt, len);
  384.         rhComment = getRhCommentFromText(sourceStmt);
  385.         // do this last to load the rest of the spec columns before it
  386.         name = getNameFromText(view, sourceStmt, thisLine);
  387.  
  388.     }
  389.  
  390.     // ==========================================================
  391.     // individual methods to extract the columns
  393.     /**
  394.      * Extract RPG specification type (D, P, C, F) from a line of source code
  395.      * @param sourceStmt String raw text
  396.      * @return spec String lower case spec (c, d, f, p, etc.)
  397.      */
  398.     private String getSpecFromText(String sourceStmt) {
  399.         String spec = "";
  400.         
  401.         if (sourceStmt.length() > 5) {
  402.             spec = sourceStmt.substring(5, 6).toLowerCase();
  403.         }
  404.         return spec;
  405.     }
  406.  
  407.     /**
  408.      * Extract name from raw d-spec
  409.      * @param view LpexView
  410.      * @param sourceStmt raw d-spec
  411.      * @param thisLine int line number passed in
  412.      * @return name String
  413.      */
  414.     private String getNameFromText(LpexView view, String sourceStmt, int thisLine ) {
  415.         // name is variable length, ending anywhere from 7 to 21
  416.         // so we could potentially have a name like i which would
  417.         // only be in column 7.
  418.         String name = "";
  419.         StringBuilder sbname = new StringBuilder();
  420.  
  421.         // line too short to hold a name
  422.         if (sourceStmt.length() < 6) {
  423.             return "";
  424.         }
  425.         
  426.         int i = 21;
  427.         if (sourceStmt.length() <= i) {
  428.             i = sourceStmt.length();
  429.         }    
  430.         sbname = sbname.append(sourceStmt.substring(6, i).trim());
  431.         
  432.         
  433.         // names can be continued on another line
  434.         // we started on the specification line;
  435.         // back up until we run out of continuation lines
  436.         // go backward from the line with the specs
  437.         for (int j = thisLine - 1; j != 0; j--) {
  438.             String sourceStmtPrior = view.elementText(j);
  439.             String specPrior = "";
  440.             String namePrior = "";
  441.             String defTypePrior = "";
  442.             String defTypePrior1 = "";
  443.             boolean isCommentPrior = false;
  444.             
  445.             specPrior = getSpecFromText(sourceStmtPrior);
  446.             isCommentPrior = isComment(sourceStmtPrior);
  447.  
  448.             // read another line if this is a comment
  449.             if (isCommentPrior) {
  450.                 continue;
  451.             }
  452.  
  453.             // line too short to hold a name
  454.             if (sourceStmtPrior.length() <= 6) {
  455.                 continue;
  456.             }
  457.             
  458.             i = 21;
  459.             if (sourceStmtPrior.length() <= i) {
  460.                 i = sourceStmtPrior.length();
  461.             }    
  462.             namePrior = sourceStmtPrior.substring(6, i).trim();
  463.                 
  464.             defTypePrior1 = defTypePrior;
  465.             defTypePrior = getDefTypeFromText(sourceStmtPrior);
  466.             
  467.             // is the name continued?
  468.             if (sourceStmtPrior.matches(".*\\.\\.\\.")) {
  469.                 sbname.insert(0, sourceStmtPrior.substring(6, sourceStmtPrior.length() - 3).trim());
  470.                 continue;
  471.             } else {
  472.                 // if d or p spec AND
  473.                 // name is blank AND
  474.                 // defType (s, pi etc) doesn't change THEN
  475.                 // it's legal and read another
  476.                 if ((specPrior.equals("d") || specPrior.equals("p")) &&
  477.                     (namePrior.length() == 0) &&
  478.                     (defTypePrior.equals(defTypePrior1))) {
  479.                     continue;
  480.                 }
  481.                 break;
  482.             }
  483.         }
  484.  
  485.         
  486.         // convert the StringBuilder name to the permanent String
  487.         name = sbname.toString();
  488.         return name;
  489.     }
  490.  
  491.     /**
  492.      * Get external data type from raw d-spec
  493.      * @param sourceStmt String raw d-spec
  494.      * @return extType String
  495.      */
  496.     private String getExtTypeFromText(String sourceStmt) {
  497.         String extType = "";
  498.         
  499.         if (sourceStmt.length() > 21) {
  500.             extType = sourceStmt.substring(21, 22).toLowerCase();
  501.         }
  502.         
  503.         return extType;
  504.     }
  505.  
  506.     /**
  507.      * Extract data structure type from d-spec
  508.      * @param sourceStmt String raw d-spec
  509.      * @return dsType String data structure type
  510.      */
  511.     private String  getDsTypeFromText(String sourceStmt) {
  512.         String dsType = "";
  513.         
  514.         if (sourceStmt.length() > 22) {
  515.             dsType = sourceStmt.substring(22, 23).toLowerCase();
  516.         }
  517.         return dsType;
  518.     }
  519.  
  520.     /**
  521.      * Extract definition type from raw d-spec
  522.      * @param sourceStmt dSpec String raw d-spec
  523.      * @return defType String definition type
  524.      */
  525.     private String getDefTypeFromText(String sourceStmt) {
  526.         String defType = "";
  527.         
  528.         if (sourceStmt.length() > 23) {
  529.             int i = 25;
  530.             if (sourceStmt.length() <= i) {
  531.                 i = sourceStmt.length();
  532.             }
  533.             defType = sourceStmt.substring(23, i).toLowerCase();
  534.         }
  535.         return defType;
  536.     }
  537.  
  538.     /**
  539.      * Extract From position from raw d-spec
  540.      * @param sourceStmt dSpec String raw d-spec
  541.      * @return fromPos String From position
  542.      */
  543.     private String getFromPosFromText(String sourceStmt) {
  544.         String fromPos = "";
  545.         
  546.         if (sourceStmt.length() > 31) {
  547.             fromPos = sourceStmt.substring(25, 32).toLowerCase().trim();
  548.         }
  549.         return fromPos;
  550.     }
  551.  
  552.     /**
  553.      * Extract Length / To position from raw d-spec
  554.      * @param sourceStmt dSpec String raw d-spec
  555.      * @return len String Length / To position 
  556.      */
  557.     private String getLenFromText(String sourceStmt) {
  558.         String len = "";
  559.         
  560.         if (sourceStmt.length() > 38) {
  561.             len = sourceStmt.substring(32, 39).toLowerCase().trim();
  562.         }
  563.         return len;
  564.     }
  565.  
  566.     /**
  567.      * Extract data type from raw d-spec
  568.      * @param sourceStmt dSpec String raw d-spec
  569.      * @return dataType String data type
  570.      */
  571.     private String getDataTypeFromText(String sourceStmt) {
  572.         String dataType = "";
  573.         
  574.         if (sourceStmt.length() > 39) {
  575.             dataType = sourceStmt.substring(39, 40).toLowerCase().trim();
  576.         }
  577.         return dataType;
  578.     }
  579.  
  580.     /**
  581.      * Extract decimals from raw d-spec
  582.      * @param sourceStmt dSpec String raw d-spec
  583.      * @return decimals String decimals
  584.      */
  585.     private String getDecimalsFromText(String sourceStmt) {
  586.         String decimals = "";
  587.         
  588.         if (sourceStmt.length() > 41) {
  589.             decimals = sourceStmt.substring(40, 42).toLowerCase().trim();
  590.         }
  591.         return decimals;
  592.     }
  593.  
  594.     /**
  595.      * Extract keywords from raw d-spec
  596.      * @param sourceStmt dSpec String raw d-spec
  597.      * @param len String to / length
  598.      * @return keywords String keywords
  599.      */
  600.     private String getKeywordsFromText(String sourceStmt, String len) {
  601.         String keywords = "";
  602.         String keywordsAdj = "";
  603.         
  604.         log("start getKeywordsFromTextString " + sourceStmt);
  605.         
  606.         if (sourceStmt.length() > 43) {
  607.             int i = 80;
  608.             if (sourceStmt.length() <= i) {
  609.                 i = sourceStmt.length();
  610.             }
  611.             keywords = sourceStmt.substring(43, i).toLowerCase().trim();
  612.             
  613.             // do we have a length adjustment?
  614.             if (keywords.length() > 0) {                        // have keywords
  615.                 log("keywords.length()=" + keywords.length());    
  616.                 if (len.matches(".*\\+.*")) {                    // have plus
  617.                     log("len.matches +");
  618.                     if (keywords.matches(".*like(.*).*")) {        // have LIKE()
  619.                         log("keywords.matches like(");
  620.                         
  621.                         // yes, length adjustment
  622.                         // delete the spaces
  623.                         String lenAdj = len.replace(" ", "").trim();
  624.                         log("lenAdj=" + lenAdj);
  625.  
  626.                         // split the LIKE() into two strings by use of regex groups
  627.                         // ...LIKE(LIKEVAR
  628.                         // ) INZ(12)...
  629.                         Pattern likeSplit = Pattern.compile("(.*like\\([^\\)]*)(\\).*)");
  630.                         Matcher m = likeSplit.matcher(keywords);
  631.                         if (m.matches()) {
  632.                             log("group 1=" + m.group(1));
  633.                             log("group 1=" + m.group(2));
  634.                         
  635.                             // re-assemble with the length adjustment inserted
  636.                             keywordsAdj = m.group(1) + ": " + lenAdj + m.group(2);
  637.                             log("keywordsAdj=" + keywordsAdj);
  638.                             
  639.                             keywords = keywordsAdj;
  640.                         } else {
  641.                             log("no match");
  642.                         }
  643.                     }
  644.                 }
  645.                 
  646.             }
  647.         }
  648.         return keywords;
  649.     }
  650.  
  651.     /**
  652.      * Extract right hand comment from raw d-spec
  653.      * @param sourceStmt String raw d-spec
  654.      * @return rhComment String right-hand comment
  655.      */
  656.     private String getRhCommentFromText(String sourceStmt) {
  657.         String rhComment = "";
  658.         
  659.         if (sourceStmt.length() > 81) {
  660.             int i = 100;
  661.             if (sourceStmt.length() <= i) {
  662.                 i = sourceStmt.length();
  663.             }
  664.             rhComment = sourceStmt.substring(80, i).trim();
  665.         }
  666.         return rhComment;
  667.     }
  668.  
  669.  
  670.     // ==========================================================
  671.     // utility methods
  673.     /**
  674.      * is this entire spec a comment line?
  675.      * @param sourceStmt String - raw D-specification
  676.      * @param d DSpec - the parsed d-spec object
  677.      * @return true if entire line is a comment
  678.      */
  679.     private boolean isComment(String sourceStmt) {
  680.         boolean isComment = false;
  681.  
  682.         if (sourceStmt.length() >= 8) {
  683.  
  684.             // comments can be either a * in column 7 or
  685.             // a pair of slashes preceded by white space
  686.             // the first is easy:
  687.             if (sourceStmt.substring(6, 7).equals("*")) {
  688.                 isComment = true;
  689.             }
  690.  
  691.             // the second is a bit harder: 
  692.             if (sourceStmt.matches(".{5} *//.*")) {
  693.                 isComment = true;
  694.             }
  695.         }
  696.         return isComment;
  697.     }
  698.  
  699.     /**
  700.      * extract comment from a comment line
  701.      * @param sourceStmt String - raw D-specification
  702.      * @return comment String
  703.      */
  704.     private String getComment(String sourceStmt) {
  705.         String comment = "";
  706.  
  707.         if (isComment(sourceStmt)) {
  708.  
  709.             // comments can be either a * in column 7 or
  710.             // a pair of slashes preceded by white space
  711.             // the first is easy:
  712.             if (sourceStmt.substring(6, 7).equals("*")) {
  713.                 comment = sourceStmt.substring(8, sourceStmt.length());
  714.             }
  715.  
  716.             // the second is a bit harder: 
  717.             if (sourceStmt.matches(".{5} *//.*")) {
  718.                 String[] parts = sourceStmt.split(".{5} *//");
  719.                 comment = parts[1];
  720.             }
  721.         }
  722.         return comment;
  723.     }
  724.  
  725.     /**
  726.      * Log debugging text to the error log
  727.      * @param message String 
  728.      */
  729.     private void log(String message) {
  730.         final boolean DEBUG = false;
  731.         
  732.         if (DEBUG) {
  733.             LpexLog.log(message);
  734.         }
  735.     }    
  736. }
  737.  
  738. ===============================
  739.  
  740. package com.kc2hiz.lpexextensions;
  741.  
  742. import org.eclipse.ui.plugin.AbstractUIPlugin;
  743. import org.osgi.framework.BundleContext;
  744.  
  745. /**
  746.  * The activator class controls the plug-in life cycle
  747.  * Needs to implement com.ibm.lpex.alef.LpexPreload and have a preload() method
  748.  */
  749. public class Activator extends AbstractUIPlugin 
  750.     implements com.ibm.lpex.alef.LpexPreload {
  751.  
  752.     // The plug-in ID
  753.     public static final String PLUGIN_ID = "com.kc2hiz.lpexextensions"; //$NON-NLS-1$
  755.     // The shared instance
  756.     private static Activator plugin;
  757.     
  758.     /**
  759.      * The constructor
  760.      */
  761.     public Activator() {
  762.         plugin = this;
  763.     }
  764.  
  765.     /**
  766.      * Start the plug-in
  767.      * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
  768.      */
  769.     public void start(BundleContext context) throws Exception {
  770.         super.start(context);
  771.         // plugin = this;
  772.     }
  773.  
  774.     /**
  775.      * Stop the plug-in
  776.      * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
  777.      */
  778.     public void stop(BundleContext context) throws Exception {
  779.         plugin = null;
  780.         super.stop(context);
  781.     }
  782.  
  783.     /**
  784.      * Returns the shared instance
  785.      *
  786.      * @return the shared instance
  787.      */
  788.     public static Activator getDefault() {
  789.         return plugin;
  790.     }
  791.     
  792.     /**
  793.      * Activity to perform for LpexPreload
  794.      * @see com.ibm.lpex.alef.LpexPreload#preload()
  795.      */
  796.     public void preload() {
  797.     }
  798. }
  799.  
  800.  
  801. ==========================================
  802.  
  803. MANIFEST.MF
  804.  
  805. Manifest-Version: 1.0
  806. Bundle-ManifestVersion: 2
  807. Bundle-Name: Lpexextensions
  808. Bundle-SymbolicName: com.kc2hiz.lpexextensions;singleton:=true
  809. Bundle-Version: 1.0.0.qualifier
  810. Bundle-Activator: com.kc2hiz.lpexextensions.Activator
  811. Bundle-Vendor: KC2HIZ
  812. Require-Bundle: org.eclipse.ui,
  813.  org.eclipse.core.runtime,
  814.  com.ibm.lpex;bundle-version="4.2.3"
  815. Bundle-RequiredExecutionEnvironment: JavaSE-1.7
  816. Bundle-ActivationPolicy: lazy
  817. Export-Package: com.kc2hiz.lpexextensions
  818.  
  819.  
  820. =============================================
  821.  
  822. plugin.xml
  823.  
  824. <?xml version="1.0" encoding="UTF-8"?>
  825. <?eclipse version="3.4"?>
  826. <plugin>
  827.    <extension
  828.          point="com.ibm.lpex.preload">
  829.       <preload
  830.             class="com.kc2hiz.lpexextensions.Activator">
  831.       </preload>
  832.    </extension>
  833.  
  834. </plugin>
  835.  
© 2004-2019 by midrange.com generated in 0.154s valid xhtml & css